| blob | 194157494c74abb0605218f26f1b04a70bb424eb |
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
591 #ifdef vim_mkdir
593 #endif
640 #ifdef HAVE_STRFTIME
642 #endif
686 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
689 valid character */
690 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
710 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
725 #ifdef FEAT_PROFILE
727 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
728 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
729 static int
730 # ifdef __BORLANDC__
731 _RTLENTRYF
732 # endif
734 static int
735 # ifdef __BORLANDC__
736 _RTLENTRYF
737 # endif
739 #endif
746 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));
754 /* Character used as separated in autoload function/variable names. */
757 /*
758 * Initialize the global and v: variables.
759 */
760 void
762 {
772 {
779 else
782 /* add to v: scope dict, unless the value is not always available */
786 /* add to compat scope dict */
788 }
789 }
791 #if defined(EXITFREE) || defined(PROTO)
792 void
794 {
799 {
802 {
805 }
806 }
810 /* script-local variables */
816 /* global variables */
819 /* functions */
823 /* autoloaded script names */
826 /* unreferenced lists and dicts */
828 }
829 #endif
831 /*
832 * Return the name of the executed function.
833 */
834 char_u *
837 {
839 }
841 /*
842 * Return the address holding the next breakpoint line for a funccall cookie.
843 */
844 linenr_T *
847 {
849 }
851 /*
852 * Return the address holding the debug tick for a funccall cookie.
853 */
857 {
859 }
861 /*
862 * Return the nesting level for a funccall cookie.
863 */
864 int
867 {
869 }
871 /* pointer to funccal for currently active function */
874 /*
875 * Return TRUE when a function was ended by a ":return" command.
876 */
877 int
879 {
881 }
884 /*
885 * Set an internal variable to a string value. Creates the variable if it does
886 * not already exist.
887 */
888 void
892 {
898 {
901 {
904 }
905 }
906 }
913 /*
914 * Start recording command output to a variable
915 * Returns OK if successfully completed the setup. FAIL otherwise.
916 */
917 int
921 {
924 typval_T tv;
926 /* Make sure a valid variable name is specified */
928 {
931 }
939 {
942 }
944 /* The output is stored in growarray "redir_ga" until redirection ends. */
947 /* Parse the variable name (can be a dict or list entry). */
949 FNE_CHECK_START);
951 {
953 /* Trailing characters are present after the variable name */
955 else
959 }
961 /* check if we can write to the variable: set it to or append an empty
962 * string */
969 else
974 {
977 }
979 {
980 /* Dictionary item was created, don't do it again. */
983 }
986 }
988 /*
989 * Append "value[value_len]" to the variable set by var_redir_start().
990 * The actual appending is postponed until redirection ends, because the value
991 * appended may in fact be the string we write to, changing it may cause freed
992 * memory to be used:
993 * :redir => foo
994 * :let foo
995 * :redir END
996 */
997 void
1001 {
1009 else
1013 {
1016 }
1017 else
1019 }
1021 /*
1022 * Stop redirecting command output to a variable.
1023 */
1024 void
1026 {
1027 typval_T tv;
1030 {
1031 /* Append the trailing NUL. */
1034 /* Assign the text to the variable. */
1043 }
1046 }
1048 # if defined(FEAT_MBYTE) || defined(PROTO)
1049 int
1055 {
1072 }
1073 # endif
1075 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1076 int
1080 {
1091 {
1094 }
1096 }
1097 # endif
1099 # if defined(FEAT_DIFF) || defined(PROTO)
1100 void
1105 {
1115 }
1117 void
1122 {
1132 }
1133 # endif
1135 /*
1136 * Top level evaluation function, returning a boolean.
1137 * Sets "error" to TRUE if there was an error.
1138 * Return TRUE or FALSE.
1139 */
1140 int
1146 {
1147 typval_T tv;
1154 else
1155 {
1158 {
1161 }
1162 }
1167 }
1169 /*
1170 * Top level evaluation function, returning a string. If "skip" is TRUE,
1171 * only parsing to "nextcmd" is done, without reporting errors. Return
1172 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1173 */
1174 char_u *
1179 {
1180 typval_T tv;
1187 else
1188 {
1191 }
1196 }
1198 /*
1199 * Skip over an expression at "*pp".
1200 * Return FAIL for an error, OK otherwise.
1201 */
1202 int
1205 {
1206 typval_T rettv;
1210 }
1212 /*
1213 * Top level evaluation function, returning a string.
1214 * Return pointer to allocated memory, or NULL for failure.
1215 */
1216 char_u *
1221 {
1222 typval_T tv;
1224 garray_T ga;
1228 else
1229 {
1231 {
1236 }
1237 else
1240 }
1243 }
1245 /*
1246 * Call eval_to_string() without using current local variables and using
1247 * textlock. When "use_sandbox" is TRUE use the sandbox.
1248 */
1249 char_u *
1254 {
1268 }
1270 /*
1271 * Top level evaluation function, returning a number.
1272 * Evaluates "expr" silently.
1273 * Returns -1 for an error.
1274 */
1275 int
1278 {
1279 typval_T rettv;
1287 else
1288 {
1291 }
1295 }
1297 /*
1298 * Prepare v: variable "idx" to be used.
1299 * Save the current typeval in "save_tv".
1300 * When not used yet add the variable to the v: hashtable.
1301 */
1302 static void
1306 {
1310 }
1312 /*
1313 * Restore v: variable "idx" to typeval "save_tv".
1314 * When no longer defined, remove the variable from the v: hashtable.
1315 */
1316 static void
1320 {
1325 {
1329 else
1331 }
1332 }
1334 #if defined(FEAT_SPELL) || defined(PROTO)
1335 /*
1336 * Evaluate an expression to a list with suggestions.
1337 * For the "expr:" part of 'spellsuggest'.
1338 */
1339 list_T *
1343 {
1344 typval_T save_val;
1345 typval_T rettv;
1349 /* Set "v:val" to the bad word. */
1357 {
1360 else
1362 }
1369 }
1371 /*
1372 * "list" is supposed to contain two items: a word and a number. Return the
1373 * word in "pp" and the number as the return value.
1374 * Return -1 if anything isn't right.
1375 * Used to get the good word and score from the eval_spell_expr() result.
1376 */
1377 int
1381 {
1393 }
1394 #endif
1396 /*
1397 * Top level evaluation function.
1398 * Returns an allocated typval_T with the result.
1399 * Returns NULL when there is an error.
1400 */
1401 typval_T *
1405 {
1410 {
1413 }
1416 }
1419 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1420 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1421 /*
1422 * Call some vimL function and return the result in "*rettv".
1423 * Uses argv[argc] for the function arguments.
1424 * Returns OK or FAIL.
1425 */
1426 static int
1433 {
1447 {
1448 /* Pass a NULL or empty argument as an empty string */
1450 {
1454 }
1456 /* Recognize a number argument, the others must be strings. */
1459 {
1462 }
1463 else
1464 {
1467 }
1468 }
1471 {
1474 }
1481 {
1484 }
1491 }
1493 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1494 /*
1495 * Call vimL function "func" and return the result as a string.
1496 * Returns NULL when calling the function fails.
1497 * Uses argv[argc] for the function arguments.
1498 */
1505 {
1506 typval_T rettv;
1515 }
1516 # endif
1518 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1519 /*
1520 * Call vimL function "func" and return the result as a number.
1521 * Returns -1 when calling the function fails.
1522 * Uses argv[argc] for the function arguments.
1523 */
1524 long
1530 {
1531 typval_T rettv;
1540 }
1541 # endif
1543 /*
1544 * Call vimL function "func" and return the result as a list
1545 * Uses argv[argc] for the function arguments.
1546 */
1553 {
1554 typval_T rettv;
1560 {
1563 }
1566 }
1567 #endif
1570 /*
1571 * Save the current function call pointer, and set it to NULL.
1572 * Used when executing autocommands and for ":source".
1573 */
1576 {
1581 }
1583 void
1586 {
1590 }
1592 #if defined(FEAT_PROFILE) || defined(PROTO)
1593 /*
1594 * Prepare profiling for entering a child or something else that is not
1595 * counted for the script/function itself.
1596 * Should always be called in pair with prof_child_exit().
1597 */
1598 void
1601 {
1607 }
1609 /*
1610 * Take care of time spent in a child.
1611 * Should always be called after prof_child_enter().
1612 */
1613 void
1616 {
1620 {
1625 }
1627 }
1628 #endif
1631 #ifdef FEAT_FOLDING
1632 /*
1633 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1634 * it in "*cp". Doesn't give error messages.
1635 */
1636 int
1640 {
1641 typval_T tv;
1645 OPT_LOCAL);
1654 else
1655 {
1656 /* If the result is a number, just return the number. */
1661 else
1662 {
1663 /* If the result is a string, check if there is a non-digit before
1664 * the number. */
1669 }
1671 }
1678 }
1679 #endif
1681 /*
1682 * ":let" list all variable values
1683 * ":let var1 var2" list variable values
1684 * ":let var = expr" assignment command.
1685 * ":let var += expr" assignment command.
1686 * ":let var -= expr" assignment command.
1687 * ":let var .= expr" assignment command.
1688 * ":let [var1, var2] = expr" unpack list.
1689 */
1690 void
1693 {
1696 typval_T rettv;
1711 {
1712 /*
1713 * ":let" without "=": list variables
1714 */
1718 /* ":let var1 var2" */
1721 {
1722 /* ":let" */
1726 #ifdef FEAT_WINDOWS
1728 #endif
1732 }
1734 }
1735 else
1736 {
1740 {
1743 }
1750 {
1754 }
1756 {
1758 op);
1760 }
1761 }
1762 }
1764 /*
1765 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1766 * Handles both "var" with any type and "[var, var; var]" with a list type.
1767 * When "nextchars" is not NULL it points to a string with characters that
1768 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1769 * or concatenate.
1770 * Returns OK or FAIL;
1771 */
1772 static int
1780 {
1785 typval_T ltv;
1788 {
1789 /*
1790 * ":let var = expr" or ":for var in list"
1791 */
1795 }
1797 /*
1798 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1799 */
1801 {
1804 }
1808 {
1811 }
1813 {
1816 }
1820 {
1829 {
1830 /* Put the rest of the list (may be empty) in the var after ';'.
1831 * Create a new list for this. */
1836 {
1839 }
1852 }
1854 {
1857 }
1858 }
1861 }
1863 /*
1864 * Skip over assignable variable "var" or list of variables "[var, var]".
1865 * Used for ":let varvar = expr" and ":for varvar in expr".
1866 * For "[var, var]" increment "*var_count" for each variable.
1867 * for "[var, var; var]" set "semicolon".
1868 * Return NULL for an error.
1869 */
1875 {
1879 {
1880 /* "[var, var]": find the matching ']'. */
1883 {
1887 {
1890 }
1897 {
1899 {
1902 }
1904 }
1906 {
1909 }
1910 }
1912 }
1913 else
1915 }
1917 /*
1918 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1919 * l[idx].
1920 */
1924 {
1929 }
1931 /*
1932 * List variables for hashtab "ht" with prefix "prefix".
1933 * If "empty" is TRUE also list NULL strings as empty strings.
1934 */
1935 static void
1941 {
1948 {
1950 {
1956 }
1957 }
1958 }
1960 /*
1961 * List global variables.
1962 */
1963 static void
1966 {
1968 }
1970 /*
1971 * List buffer variables.
1972 */
1973 static void
1976 {
1985 }
1987 /*
1988 * List window variables.
1989 */
1990 static void
1993 {
1996 }
1998 #ifdef FEAT_WINDOWS
1999 /*
2000 * List tab page variables.
2001 */
2002 static void
2005 {
2008 }
2009 #endif
2011 /*
2012 * List Vim variables.
2013 */
2014 static void
2017 {
2019 }
2021 /*
2022 * List script-local variables, if there is a script.
2023 */
2024 static void
2027 {
2031 }
2033 /*
2034 * List function variables, if there is a function.
2035 */
2036 static void
2039 {
2043 }
2045 /*
2046 * List variables in "arg".
2047 */
2053 {
2060 typval_T tv;
2063 {
2065 {
2068 {
2072 }
2073 }
2074 else
2075 {
2076 /* get_name_len() takes care of expanding curly braces */
2080 {
2081 /* This is mainly to keep test 49 working: when expanding
2082 * curly braces fails overrule the exception error message. */
2084 {
2088 }
2090 }
2091 else
2092 {
2097 else
2098 {
2099 /* handle d.key, l[idx], f(expr) */
2103 else
2104 {
2106 {
2108 {
2112 #ifdef FEAT_WINDOWS
2114 #endif
2120 }
2121 }
2122 else
2123 {
2136 first);
2139 }
2141 }
2142 }
2143 }
2146 }
2149 }
2152 }
2154 /*
2155 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2156 * Returns a pointer to the char just after the var name.
2157 * Returns NULL if there is an error.
2158 */
2166 {
2175 /*
2176 * ":let $VAR = expr": Set environment variable.
2177 */
2179 {
2180 /* Find the end of the name. */
2186 else
2187 {
2193 else
2194 {
2199 {
2204 {
2208 }
2209 }
2211 {
2221 }
2224 }
2225 }
2226 }
2228 /*
2229 * ":let &option = expr": Set option value.
2230 * ":let &l:option = expr": Set local option value.
2231 * ":let &g:option = expr": Set global option value.
2232 */
2234 {
2235 /* Find the end of the name. */
2240 else
2241 {
2254 {
2260 else
2261 {
2263 {
2266 else
2268 }
2270 {
2274 }
2275 }
2276 }
2278 {
2281 }
2284 }
2285 }
2287 /*
2288 * ":let @r = expr": Set register contents.
2289 */
2291 {
2298 else
2299 {
2305 {
2308 {
2311 }
2312 }
2314 {
2317 }
2319 }
2320 }
2322 /*
2323 * ":let var = expr": Set internal variable.
2324 * ":let {expr} = expr": Idem, name made with curly braces
2325 */
2327 {
2328 lval_T lv;
2332 {
2335 else
2336 {
2339 }
2340 }
2342 }
2344 else
2348 }
2350 /*
2351 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2352 */
2353 static int
2356 {
2358 {
2361 }
2363 }
2365 /*
2366 * Get an lval: variable, Dict item or List item that can be assigned a value
2367 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2368 * "name.key", "name.key[expr]" etc.
2369 * Indexing only works if "name" is an existing List or Dictionary.
2370 * "name" points to the start of the name.
2371 * If "rettv" is not NULL it points to the value to be assigned.
2372 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2373 * wrong; must end in space or cmd separator.
2374 *
2375 * Returns a pointer to just after the name, including indexes.
2376 * When an evaluation error occurs "lp->ll_name" is NULL;
2377 * Returns NULL for a parsing error. Still need to free items in "lp"!
2378 */
2388 {
2393 typval_T var1;
2394 typval_T var2;
2401 /* Clear everything in "lp". */
2405 {
2406 /* When skipping just find the end of the name. */
2409 }
2411 /* Find the end of the name. */
2414 {
2415 /* Don't expand the name when we already know there is an error. */
2418 {
2421 }
2425 {
2426 /* Report an invalid expression in braces, unless the
2427 * expression evaluation has been cancelled due to an
2428 * aborting error, an interrupt, or an exception. */
2430 {
2434 }
2435 }
2437 }
2438 else
2441 /* Without [idx] or .key we are done. */
2454 /*
2455 * Loop until no more [idx] or .key is following.
2456 */
2459 {
2463 {
2467 }
2469 {
2473 }
2477 {
2480 ;
2482 {
2486 }
2488 }
2489 else
2490 {
2491 /* Get the index [expr] or the first index [expr: ]. */
2495 else
2496 {
2501 {
2502 /* not a number or string */
2505 }
2506 }
2508 /* Optionally get the second index [ :expr]. */
2510 {
2512 {
2518 }
2521 {
2527 }
2531 else
2532 {
2535 {
2539 }
2541 {
2542 /* not a number or string */
2547 }
2548 }
2550 }
2551 else
2555 {
2563 }
2565 /* Skip to past ']'. */
2567 }
2570 {
2572 {
2573 /* "[key]": get key from "var1" */
2576 {
2581 }
2582 }
2587 {
2588 /* Key does not exist in dict: may need to add it. */
2590 {
2596 }
2599 else
2606 }
2610 }
2611 else
2612 {
2613 /*
2614 * Get the number and item for the only or first index of the List.
2615 */
2618 else
2619 {
2622 }
2627 {
2629 {
2632 }
2633 }
2635 {
2639 }
2641 /*
2642 * May need to find the item or absolute index for the second
2643 * index of a range.
2644 * When no index given: "lp->ll_empty2" is TRUE.
2645 * Otherwise "lp->ll_n2" is set to the second index.
2646 */
2648 {
2652 {
2657 }
2659 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2664 }
2667 }
2668 }
2671 }
2673 /*
2674 * Clear lval "lp" that was filled by get_lval().
2675 */
2676 static void
2679 {
2682 }
2684 /*
2685 * Set a variable that was parsed by get_lval() to "rettv".
2686 * "endp" points to just after the parsed name.
2687 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2688 */
2689 static void
2696 {
2702 {
2704 {
2708 {
2709 typval_T tv;
2711 /* handle +=, -= and .= */
2714 {
2718 }
2719 }
2720 else
2723 }
2724 }
2728 ;
2730 {
2731 /*
2732 * Assign the List values to the list items.
2733 */
2735 {
2738 else
2739 {
2742 }
2747 {
2748 /* Need to add an empty item. */
2750 {
2753 }
2754 }
2757 }
2764 }
2765 else
2766 {
2767 /*
2768 * Assign to a List or Dictionary item.
2769 */
2771 {
2773 {
2776 }
2778 /* Need to add an item to the Dictionary. */
2783 {
2786 }
2788 }
2790 {
2793 }
2794 else
2797 /*
2798 * Assign the value to the variable or list item.
2799 */
2802 else
2803 {
2807 }
2808 }
2809 }
2811 /*
2812 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2813 * Returns OK or FAIL.
2814 */
2815 static int
2820 {
2825 /* Can't do anything with a Funcref or a Dict on the right. */
2827 {
2829 {
2837 /* List += List */
2847 {
2848 /* nr += nr or nr -= nr*/
2852 else
2857 }
2858 else
2859 {
2860 /* str .= str */
2866 }
2868 }
2869 }
2873 }
2875 /*
2876 * Add a watcher to a list.
2877 */
2878 static void
2882 {
2885 }
2887 /*
2888 * Remove a watcher from a list.
2889 * No warning when it isn't found...
2890 */
2891 static void
2895 {
2900 {
2902 {
2905 }
2907 }
2908 }
2910 /*
2911 * Just before removing an item from a list: advance watchers to the next
2912 * item.
2913 */
2914 static void
2918 {
2924 }
2926 /*
2927 * Evaluate the expression used in a ":for var in expr" command.
2928 * "arg" points to "var".
2929 * Set "*errp" to TRUE for an error, FALSE otherwise;
2930 * Return a pointer that holds the info. Null when there is an error.
2931 */
2938 {
2941 typval_T tv;
2956 {
2959 }
2964 {
2967 {
2970 {
2973 }
2974 else
2975 {
2976 /* No need to increment the refcount, it's already set for the
2977 * list being used in "tv". */
2981 }
2982 }
2983 }
2988 }
2990 /*
2991 * Use the first item in a ":for" list. Advance to the next.
2992 * Assign the values to the variable (list). "arg" points to the first one.
2993 * Return TRUE when a valid item was found, FALSE when at end of list or
2994 * something wrong.
2995 */
2996 int
3000 {
3008 else
3009 {
3013 }
3015 }
3017 /*
3018 * Free the structure used to store info used by ":for".
3019 */
3020 void
3023 {
3027 {
3030 }
3032 }
3034 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3036 void
3040 cmdidx_T cmdidx;
3041 {
3047 {
3050 {
3051 /* ":let var1 var2 ...": find last space. */
3053 {
3058 }
3060 }
3061 }
3062 else
3067 {
3070 {
3073 {
3077 }
3079 {
3084 }
3085 }
3087 {
3088 /* environment variable */
3090 }
3092 {
3095 }
3099 {
3100 /* Function name can start with "<SNR>" */
3102 }
3104 {
3106 {
3111 }
3113 {
3114 /* Trick: '' is like stopping and starting a literal string. */
3118 }
3120 {
3122 {
3125 }
3126 else
3128 }
3129 else
3131 }
3132 else
3133 /* Doesn't look like something valid, expand as an expression
3134 * anyway. */
3140 }
3142 }
3146 /*
3147 * ":1,25call func(arg1, arg2)" function call.
3148 */
3149 void
3152 {
3158 typval_T rettv;
3159 linenr_T lnum;
3162 funcdict_T fudi;
3166 {
3167 /* Still need to give an error message for missing key. */
3170 }
3174 /* Increase refcount on dictionary, it could get deleted when evaluating
3175 * the arguments. */
3179 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3183 /* Skip white space to allow ":call func ()". Not good, but required for
3184 * backward compatibility. */
3189 {
3192 }
3194 /*
3195 * When skipping, evaluate the function once, to find the end of the
3196 * arguments.
3197 * When the function takes a range, this is discovered after the first
3198 * call, and the loop is broken.
3199 */
3201 {
3204 }
3205 else
3208 {
3210 {
3213 }
3218 {
3221 }
3223 /* Handle a function returning a Funcref, Dictionary or List. */
3225 {
3228 }
3234 /* Stop when immediately aborting on error, or when an interrupt
3235 * occurred or an exception was thrown but not caught.
3236 * get_func_tv() returned OK, so that the check for trailing
3237 * characters below is executed. */
3240 }
3245 {
3246 /* Check for trailing illegal characters and a following command. */
3248 {
3251 }
3252 else
3254 }
3256 end:
3259 }
3261 /*
3262 * ":unlet[!] var1 ... " command.
3263 */
3264 void
3267 {
3269 }
3271 /*
3272 * ":lockvar" and ":unlockvar" commands
3273 */
3274 void
3277 {
3284 {
3287 }
3290 }
3292 /*
3293 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3294 */
3295 static void
3300 {
3304 lval_T lv;
3306 do
3307 {
3308 /* Parse the name and find the end. */
3310 FNE_CHECK_START);
3315 {
3317 {
3320 }
3324 }
3327 {
3329 {
3332 }
3333 else
3334 {
3338 }
3339 }
3348 }
3350 static int
3355 {
3360 {
3364 /* Normal name or expanded name. */
3370 }
3374 {
3377 /* Delete a range of List items. */
3379 {
3384 }
3385 }
3386 else
3387 {
3389 /* unlet a List item. */
3391 else
3392 /* unlet a Dictionary item. */
3394 }
3397 }
3399 /*
3400 * "unlet" a variable. Return OK if it existed, FAIL if not.
3401 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3402 */
3403 int
3407 {
3415 {
3418 {
3425 }
3426 }
3431 }
3433 /*
3434 * Lock or unlock variable indicated by "lp".
3435 * "deep" is the levels to go (-1 for unlimited);
3436 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3437 */
3438 static int
3444 {
3453 {
3457 /* Normal name or expanded name. */
3460 else
3461 {
3465 else
3466 {
3469 else
3472 }
3473 }
3475 }
3477 {
3480 /* (un)lock a range of List items. */
3482 {
3486 }
3487 }
3489 /* (un)lock a List item. */
3491 else
3492 /* un(lock) a Dictionary item. */
3496 }
3498 /*
3499 * Lock or unlock an item. "deep" is nr of levels to go.
3500 */
3501 static void
3506 {
3515 {
3518 }
3523 /* lock/unlock the item itself */
3526 else
3530 {
3533 {
3536 else
3539 /* recursive: lock/unlock the items the List contains */
3542 }
3546 {
3549 else
3552 {
3553 /* recursive: lock/unlock the items the List contains */
3556 {
3558 {
3561 }
3562 }
3563 }
3564 }
3565 }
3567 }
3569 /*
3570 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3571 * it refers to a List or Dictionary that is locked.
3572 */
3573 static int
3576 {
3584 }
3586 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3587 /*
3588 * Delete all "menutrans_" variables.
3589 */
3590 void
3592 {
3599 {
3601 {
3605 }
3606 }
3608 }
3609 #endif
3611 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3613 /*
3614 * Local string buffer for the next two functions to store a variable name
3615 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3616 * get_user_var_name().
3617 */
3624 /*
3625 * Function to concatenate a prefix and a variable name.
3626 */
3631 {
3636 {
3641 {
3644 }
3646 }
3651 }
3653 /*
3654 * Function given to ExpandGeneric() to obtain the list of user defined
3655 * (global/buffer/window/built-in) variable names.
3656 */
3657 /*ARGSUSED*/
3658 char_u *
3662 {
3666 #ifdef FEAT_WINDOWS
3668 #endif
3674 {
3676 #ifdef FEAT_WINDOWS
3678 #endif
3679 }
3681 /* Global variables */
3683 {
3686 else
3693 }
3695 /* b: variables */
3698 {
3701 else
3706 }
3708 {
3711 }
3713 /* w: variables */
3716 {
3719 else
3724 }
3726 #ifdef FEAT_WINDOWS
3727 /* t: variables */
3730 {
3733 else
3738 }
3739 #endif
3741 /* v: variables */
3749 }
3753 /*
3754 * types for expressions.
3755 */
3757 {
3769 /*
3770 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3771 * executed. The function may return OK, but the rettv will be of type
3772 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3773 */
3775 /*
3776 * Handle zero level expression.
3777 * This calls eval1() and handles error message and nextcmd.
3778 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3779 * Note: "rettv.v_lock" is not set.
3780 * Return OK or FAIL.
3781 */
3782 static int
3788 {
3795 {
3798 /*
3799 * Report the invalid expression unless the expression evaluation has
3800 * been cancelled due to an aborting error, an interrupt, or an
3801 * exception.
3802 */
3806 }
3811 }
3813 /*
3814 * Handle top level expression:
3815 * expr1 ? expr0 : expr0
3816 *
3817 * "arg" must point to the first non-white of the expression.
3818 * "arg" is advanced to the next non-white after the recognized expression.
3819 *
3820 * Note: "rettv.v_lock" is not set.
3821 *
3822 * Return OK or FAIL.
3823 */
3824 static int
3829 {
3831 typval_T var2;
3833 /*
3834 * Get the first variable.
3835 */
3840 {
3843 {
3851 }
3853 /*
3854 * Get the second variable.
3855 */
3860 /*
3861 * Check for the ":".
3862 */
3864 {
3869 }
3871 /*
3872 * Get the third variable.
3873 */
3876 {
3880 }
3883 }
3886 }
3888 /*
3889 * Handle first level expression:
3890 * expr2 || expr2 || expr2 logical OR
3891 *
3892 * "arg" must point to the first non-white of the expression.
3893 * "arg" is advanced to the next non-white after the recognized expression.
3894 *
3895 * Return OK or FAIL.
3896 */
3897 static int
3902 {
3903 typval_T var2;
3908 /*
3909 * Get the first variable.
3910 */
3914 /*
3915 * Repeat until there is no following "||".
3916 */
3920 {
3922 {
3929 }
3931 /*
3932 * Get the second variable.
3933 */
3938 /*
3939 * Compute the result.
3940 */
3942 {
3948 }
3950 {
3953 }
3954 }
3957 }
3959 /*
3960 * Handle second level expression:
3961 * expr3 && expr3 && expr3 logical AND
3962 *
3963 * "arg" must point to the first non-white of the expression.
3964 * "arg" is advanced to the next non-white after the recognized expression.
3965 *
3966 * Return OK or FAIL.
3967 */
3968 static int
3973 {
3974 typval_T var2;
3979 /*
3980 * Get the first variable.
3981 */
3985 /*
3986 * Repeat until there is no following "&&".
3987 */
3991 {
3993 {
4000 }
4002 /*
4003 * Get the second variable.
4004 */
4009 /*
4010 * Compute the result.
4011 */
4013 {
4019 }
4021 {
4024 }
4025 }
4028 }
4030 /*
4031 * Handle third level expression:
4032 * var1 == var2
4033 * var1 =~ var2
4034 * var1 != var2
4035 * var1 !~ var2
4036 * var1 > var2
4037 * var1 >= var2
4038 * var1 < var2
4039 * var1 <= var2
4040 * var1 is var2
4041 * var1 isnot var2
4042 *
4043 * "arg" must point to the first non-white of the expression.
4044 * "arg" is advanced to the next non-white after the recognized expression.
4045 *
4046 * Return OK or FAIL.
4047 */
4048 static int
4053 {
4054 typval_T var2;
4063 regmatch_T regmatch;
4067 /*
4068 * Get the first variable.
4069 */
4075 {
4087 {
4090 }
4091 else
4095 {
4098 }
4099 else
4103 {
4107 {
4110 }
4111 }
4113 }
4115 /*
4116 * If there is a comparitive operator, use it.
4117 */
4119 {
4120 /* extra question mark appended: ignore case */
4122 {
4125 }
4126 /* extra '#' appended: match case */
4128 {
4131 }
4132 /* nothing appened: use 'ignorecase' */
4133 else
4136 /*
4137 * Get the second variable.
4138 */
4141 {
4144 }
4147 {
4149 {
4150 /* For "is" a different type always means FALSE, for "notis"
4151 * it means TRUE. */
4153 }
4155 {
4157 {
4162 }
4165 {
4168 else
4173 }
4174 else
4175 {
4176 /* Compare two Lists for being equal or unequal. */
4180 }
4181 }
4184 {
4186 {
4191 }
4194 {
4197 else
4202 }
4203 else
4204 {
4205 /* Compare two Dictionaries for being equal or unequal. */
4209 }
4210 }
4213 {
4216 {
4219 else
4224 }
4225 else
4226 {
4227 /* Compare two Funcrefs for being equal or unequal. */
4231 else
4236 }
4237 }
4239 /*
4240 * If one of the two variables is a number, compare as a number.
4241 * When using "=~" or "!~", always compare as string.
4242 */
4245 {
4249 {
4259 }
4260 }
4261 else
4262 {
4267 else
4271 {
4281 /* avoid 'l' flag in 'cpoptions' */
4288 {
4293 }
4298 }
4299 }
4304 }
4305 }
4308 }
4310 /*
4311 * Handle fourth level expression:
4312 * + number addition
4313 * - number subtraction
4314 * . string concatenation
4315 *
4316 * "arg" must point to the first non-white of the expression.
4317 * "arg" is advanced to the next non-white after the recognized expression.
4318 *
4319 * Return OK or FAIL.
4320 */
4321 static int
4326 {
4327 typval_T var2;
4328 typval_T var3;
4335 /*
4336 * Get the first variable.
4337 */
4341 /*
4342 * Repeat computing, until no '+', '-' or '.' is following.
4343 */
4345 {
4351 {
4352 /* For "list + ...", an illegal use of the first operand as
4353 * a number cannot be determined before evaluating the 2nd
4354 * operand: if this is also a list, all is ok.
4355 * For "something . ...", "something - ..." or "non-list + ...",
4356 * we know that the first operand needs to be a string or number
4357 * without evaluating the 2nd operand. So check before to avoid
4358 * side effects after an error. */
4360 {
4363 }
4364 }
4366 /*
4367 * Get the second variable.
4368 */
4371 {
4374 }
4377 {
4378 /*
4379 * Compute the result.
4380 */
4382 {
4386 {
4390 }
4395 }
4398 {
4399 /* concatenate Lists */
4402 {
4406 }
4409 }
4410 else
4411 {
4416 {
4417 /* This can only happen for "list + non-list".
4418 * For "non-list + ..." or "something - ...", we returned
4419 * before evaluating the 2nd operand. */
4422 }
4425 {
4429 }
4433 else
4437 }
4439 }
4440 }
4442 }
4444 /*
4445 * Handle fifth level expression:
4446 * * number multiplication
4447 * / number division
4448 * % number modulo
4449 *
4450 * "arg" must point to the first non-white of the expression.
4451 * "arg" is advanced to the next non-white after the recognized expression.
4452 *
4453 * Return OK or FAIL.
4454 */
4455 static int
4460 {
4461 typval_T var2;
4466 /*
4467 * Get the first variable.
4468 */
4472 /*
4473 * Repeat computing, until no '*', '/' or '%' is following.
4474 */
4476 {
4482 {
4487 }
4488 else
4491 /*
4492 * Get the second variable.
4493 */
4499 {
4505 /*
4506 * Compute the result.
4507 */
4511 {
4514 else
4516 }
4517 else
4518 {
4521 else
4523 }
4526 }
4527 }
4530 }
4532 /*
4533 * Handle sixth level expression:
4534 * number number constant
4535 * "string" string constant
4536 * 'string' literal string constant
4537 * &option-name option value
4538 * @r register contents
4539 * identifier variable value
4540 * function() function call
4541 * $VAR environment variable
4542 * (expression) nested expression
4543 * [expr, expr] List
4544 * {key: val, key: val} Dictionary
4545 *
4546 * Also handle:
4547 * ! in front logical NOT
4548 * - in front unary minus
4549 * + in front unary plus (ignored)
4550 * trailing [] subscript in String or List
4551 * trailing .name entry in Dictionary
4552 *
4553 * "arg" must point to the first non-white of the expression.
4554 * "arg" is advanced to the next non-white after the recognized expression.
4555 *
4556 * Return OK or FAIL.
4557 */
4558 static int
4563 {
4572 /*
4573 * Initialise variable so that clear_tv() can't mistake this for a
4574 * string and free a string that isn't there.
4575 */
4578 /*
4579 * Skip '!' and '-' characters. They are handled later.
4580 */
4587 {
4588 /*
4589 * Number constant.
4590 */
4604 {
4607 }
4610 /*
4611 * String constant: "string".
4612 */
4616 /*
4617 * Literal string constant: 'str''ing'.
4618 */
4622 /*
4623 * List: [expr, expr]
4624 */
4628 /*
4629 * Dictionary: {key: val, key: val}
4630 */
4634 /*
4635 * Option value: &name
4636 */
4640 /*
4641 * Environment variable: $VAR.
4642 */
4646 /*
4647 * Register contents: @r.
4648 */
4651 {
4654 }
4659 /*
4660 * nested expression: (expression).
4661 */
4667 {
4671 }
4676 }
4679 {
4680 /*
4681 * Must be a variable or function name.
4682 * Can also be a curly-braces kind of name: {expr}.
4683 */
4691 else
4692 {
4694 {
4695 /* If "s" is the name of a variable of type VAR_FUNC
4696 * use its contents. */
4699 /* Invoke the function. */
4703 /* Stop the expression evaluation when immediately
4704 * aborting on error, or when an interrupt occurred or
4705 * an exception was thrown but not caught. */
4707 {
4711 }
4712 }
4715 else
4717 }
4721 }
4725 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4726 * expr(expr). */
4730 /*
4731 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4732 */
4734 {
4739 {
4742 }
4743 else
4744 {
4746 {
4752 }
4756 }
4757 }
4760 }
4762 /*
4763 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4764 * "*arg" points to the '[' or '.'.
4765 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4766 */
4767 static int
4773 {
4783 {
4787 }
4790 {
4791 /*
4792 * dict.name
4793 */
4796 ;
4800 }
4801 else
4802 {
4803 /*
4804 * something[idx]
4805 *
4806 * Get the (first) variable from inside the [].
4807 */
4814 {
4815 /* not a number or string */
4818 }
4820 /*
4821 * Get the second variable from inside the [:].
4822 */
4824 {
4830 {
4834 }
4836 {
4837 /* not a number or string */
4842 }
4843 }
4845 /* Check for the ']'. */
4847 {
4854 }
4856 }
4859 {
4862 {
4865 }
4867 {
4870 else
4871 {
4874 }
4875 }
4878 {
4884 {
4885 /* The resulting variable is a substring. If the indexes
4886 * are out of range the result is empty. */
4888 {
4892 }
4899 else
4901 }
4902 else
4903 {
4904 /* The resulting variable is a string of a single
4905 * character. If the index is too big or negative the
4906 * result is empty. */
4909 else
4911 }
4922 {
4923 /* For a range we allow invalid values and return an empty
4924 * list. A list index out of range is an error. */
4926 {
4930 }
4932 }
4934 {
4949 {
4951 {
4954 }
4956 }
4961 }
4962 else
4963 {
4967 }
4972 {
4978 }
4979 {
4983 {
4986 {
4991 }
4992 }
5006 }
5008 }
5009 }
5012 }
5014 /*
5015 * Get an option value.
5016 * "arg" points to the '&' or '+' before the option name.
5017 * "arg" is advanced to character after the option name.
5018 * Return OK or FAIL.
5019 */
5020 static int
5025 {
5035 /*
5036 * Isolate the option name and find its value.
5037 */
5040 {
5044 }
5047 {
5050 }
5058 {
5062 }
5064 {
5066 {
5069 }
5071 {
5074 }
5076 {
5079 }
5081 {
5084 }
5085 }
5093 }
5095 /*
5096 * Allocate a variable for a string constant.
5097 * Return OK or FAIL.
5098 */
5099 static int
5104 {
5109 /*
5110 * Find the end of the string, skipping backslashed characters.
5111 */
5113 {
5115 {
5117 /* A "\<x>" form occupies at least 4 characters, and produces up
5118 * to 6 characters: reserve space for 2 extra */
5121 }
5122 }
5125 {
5128 }
5130 /* If only parsing, set *arg and return here */
5132 {
5135 }
5137 /*
5138 * Copy the string into allocated memory, handling backslashed
5139 * characters.
5140 */
5148 {
5150 {
5152 {
5165 {
5171 else
5175 {
5178 }
5180 #ifdef FEAT_MBYTE
5181 /* For "\u" store the number according to
5182 * 'encoding'. */
5185 else
5186 #endif
5188 }
5191 /* octal: "\1", "\12", "\123" */
5201 {
5205 }
5209 /* Special key, e.g.: "\<C-W>" */
5212 {
5215 }
5216 /* FALLTHROUGH */
5220 }
5221 }
5222 else
5225 }
5230 }
5232 /*
5233 * Allocate a variable for a 'str''ing' constant.
5234 * Return OK or FAIL.
5235 */
5236 static int
5241 {
5246 /*
5247 * Find the end of the string, skipping ''.
5248 */
5250 {
5252 {
5257 }
5258 }
5261 {
5264 }
5266 /* If only parsing return after setting "*arg" */
5268 {
5271 }
5273 /*
5274 * Copy the string into allocated memory, handling '' to ' reduction.
5275 */
5283 {
5285 {
5289 }
5291 }
5296 }
5298 /*
5299 * Allocate a variable for a List and fill it from "*arg".
5300 * Return OK or FAIL.
5301 */
5302 static int
5307 {
5309 typval_T tv;
5313 {
5317 }
5321 {
5325 {
5328 {
5332 }
5333 else
5335 }
5340 {
5343 }
5345 }
5348 {
5350 failret:
5354 }
5358 {
5362 }
5365 }
5367 /*
5368 * Allocate an empty header for a list.
5369 * Caller should take care of the reference count.
5370 */
5371 list_T *
5373 {
5378 {
5379 /* Prepend the list to the list of lists for garbage collection. */
5385 }
5387 }
5389 /*
5390 * Allocate an empty list for a return value.
5391 * Returns OK or FAIL.
5392 */
5393 static int
5396 {
5406 }
5408 /*
5409 * Unreference a list: decrement the reference count and free it when it
5410 * becomes zero.
5411 */
5412 void
5415 {
5418 }
5420 /*
5421 * Free a list, including all items it points to.
5422 * Ignores the reference count.
5423 */
5424 void
5428 {
5431 /* Remove the list from the list of lists for garbage collection. */
5434 else
5440 {
5441 /* Remove the item before deleting it. */
5447 }
5449 }
5451 /*
5452 * Allocate a list item.
5453 */
5456 {
5458 }
5460 /*
5461 * Free a list item. Also clears the value. Does not notify watchers.
5462 */
5463 static void
5466 {
5469 }
5471 /*
5472 * Remove a list item from a List and free it. Also clears the value.
5473 */
5474 static void
5478 {
5481 }
5483 /*
5484 * Get the number of items in a list.
5485 */
5486 static long
5489 {
5493 }
5495 /*
5496 * Return TRUE when two lists have exactly the same values.
5497 */
5498 static int
5503 {
5517 }
5519 #if defined(FEAT_PYTHON) || defined(PROTO)
5520 /*
5521 * Return the dictitem that an entry in a hashtable points to.
5522 */
5523 dictitem_T *
5526 {
5528 }
5529 #endif
5531 /*
5532 * Return TRUE when two dictionaries have exactly the same key/values.
5533 */
5534 static int
5539 {
5551 {
5553 {
5560 }
5561 }
5563 }
5565 /*
5566 * Return TRUE if "tv1" and "tv2" have the same value.
5567 * Compares the items just like "==" would compare them, but strings and
5568 * numbers are different.
5569 */
5570 static int
5575 {
5583 /* Catch lists and dicts that have an endless loop by limiting
5584 * recursiveness to 1000. We guess they are equal then. */
5589 {
5614 }
5618 }
5620 /*
5621 * Locate item with index "n" in list "l" and return it.
5622 * A negative index is counted from the end; -1 is the last item.
5623 * Returns NULL when "n" is out of range.
5624 */
5629 {
5636 /* Negative index is relative to the end. */
5640 /* Check for index out of range. */
5644 /* When there is a cached index may start search from there. */
5646 {
5648 {
5649 /* closest to the start of the list */
5652 }
5654 {
5655 /* closest to the end of the list */
5658 }
5659 else
5660 {
5661 /* closest to the cached index */
5664 }
5665 }
5666 else
5667 {
5669 {
5670 /* closest to the start of the list */
5673 }
5674 else
5675 {
5676 /* closest to the end of the list */
5679 }
5680 }
5683 {
5684 /* search forward */
5687 }
5689 {
5690 /* search backward */
5693 }
5695 /* cache the used index */
5700 }
5702 /*
5703 * Get list item "l[idx]" as a number.
5704 */
5705 static long
5710 {
5715 {
5719 }
5721 }
5723 /*
5724 * Locate "item" list "l" and return its index.
5725 * Returns -1 when "item" is not in the list.
5726 */
5727 static long
5731 {
5743 }
5745 /*
5746 * Append item "item" to the end of list "l".
5747 */
5748 static void
5752 {
5754 {
5755 /* empty list */
5759 }
5760 else
5761 {
5765 }
5768 }
5770 /*
5771 * Append typval_T "tv" to the end of list "l".
5772 * Return FAIL when out of memory.
5773 */
5774 static int
5778 {
5786 }
5788 /*
5789 * Add a dictionary to a list. Used by getqflist().
5790 * Return FAIL when out of memory.
5791 */
5792 int
5796 {
5807 }
5809 /*
5810 * Make a copy of "str" and append it as an item to list "l".
5811 * When "len" >= 0 use "str[len]".
5812 * Returns FAIL when out of memory.
5813 */
5814 static int
5819 {
5833 }
5835 /*
5836 * Append "n" to list "l".
5837 * Returns FAIL when out of memory.
5838 */
5839 static int
5842 varnumber_T n;
5843 {
5854 }
5856 /*
5857 * Insert typval_T "tv" in list "l" before "item".
5858 * If "item" is NULL append at the end.
5859 * Return FAIL when out of memory.
5860 */
5861 static int
5866 {
5873 /* Append new item at end of list. */
5875 else
5876 {
5877 /* Insert new item before existing item. */
5881 {
5884 }
5885 else
5886 {
5889 }
5892 }
5894 }
5896 /*
5897 * Extend "l1" with "l2".
5898 * If "bef" is NULL append at the end, otherwise insert before this item.
5899 * Returns FAIL when out of memory.
5900 */
5901 static int
5906 {
5913 }
5915 /*
5916 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5917 * Return FAIL when out of memory.
5918 */
5919 static int
5924 {
5927 /* make a copy of the first list. */
5934 /* append all items from the second list */
5936 }
5938 /*
5939 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5940 * The refcount of the new list is set to 1.
5941 * See item_copy() for "copyID".
5942 * Returns NULL when out of memory.
5943 */
5949 {
5959 {
5961 {
5962 /* Do this before adding the items, because one of the items may
5963 * refer back to this list. */
5966 }
5969 {
5974 {
5976 {
5979 }
5980 }
5981 else
5984 }
5987 {
5990 }
5991 }
5994 }
5996 /*
5997 * Remove items "item" to "item2" from list "l".
5998 * Does not free the listitem or the value!
5999 */
6000 static void
6005 {
6008 /* notify watchers */
6010 {
6015 }
6019 else
6023 else
6026 }
6028 /*
6029 * Return an allocated string with the string representation of a list.
6030 * May return NULL.
6031 */
6036 {
6037 garray_T ga;
6044 {
6047 }
6051 }
6053 /*
6054 * Join list "l" into a string in "*gap", using separator "sep".
6055 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6056 * Return FAIL or OK.
6057 */
6058 static int
6065 {
6073 {
6076 else
6081 else
6088 }
6090 }
6092 /*
6093 * Garbage collection for lists and dictionaries.
6094 *
6095 * We use reference counts to be able to free most items right away when they
6096 * are no longer used. But for composite items it's possible that it becomes
6097 * unused while the reference count is > 0: When there is a recursive
6098 * reference. Example:
6099 * :let l = [1, 2, 3]
6100 * :let d = {9: l}
6101 * :let l[1] = d
6102 *
6103 * Since this is quite unusual we handle this with garbage collection: every
6104 * once in a while find out which lists and dicts are not referenced from any
6105 * variable.
6106 *
6107 * Here is a good reference text about garbage collection (refers to Python
6108 * but it applies to all reference-counting mechanisms):
6109 * http://python.ca/nas/python/gc/
6110 */
6112 /*
6113 * Do garbage collection for lists and dicts.
6114 * Return TRUE if some memory was freed.
6115 */
6116 int
6118 {
6127 #ifdef FEAT_WINDOWS
6129 #endif
6131 /* Only do this once. */
6136 /*
6137 * 1. Go through all accessible variables and mark all lists and dicts
6138 * with copyID.
6139 */
6140 /* script-local variables */
6144 /* buffer-local variables */
6148 /* window-local variables */
6152 #ifdef FEAT_WINDOWS
6153 /* tabpage-local variables */
6156 #endif
6158 /* global variables */
6161 /* function-local variables */
6163 {
6166 }
6168 /*
6169 * 2. Go through the list of dicts and free items without the copyID.
6170 */
6173 {
6174 /* Free the Dictionary and ordinary items it contains, but don't
6175 * recurse into Lists and Dictionaries, they will be in the list
6176 * of dicts or list of lists. */
6180 /* restart, next dict may also have been freed */
6182 }
6183 else
6186 /*
6187 * 3. Go through the list of lists and free items without the copyID.
6188 * But don't free a list that has a watcher (used in a for loop), these
6189 * are not referenced anywhere.
6190 */
6193 {
6194 /* Free the List and ordinary items it contains, but don't recurse
6195 * into Lists and Dictionaries, they will be in the list of dicts
6196 * or list of lists. */
6200 /* restart, next list may also have been freed */
6202 }
6203 else
6207 }
6209 /*
6210 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6211 */
6212 static void
6216 {
6223 {
6226 }
6227 }
6229 /*
6230 * Mark all lists and dicts referenced through list "l" with "copyID".
6231 */
6232 static void
6236 {
6241 }
6243 /*
6244 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6245 */
6246 static void
6250 {
6255 {
6259 {
6260 /* Didn't see this dict yet. */
6263 }
6269 {
6270 /* Didn't see this list yet. */
6273 }
6275 }
6277 }
6279 /*
6280 * Allocate an empty header for a dictionary.
6281 */
6282 dict_T *
6284 {
6289 {
6290 /* Add the list to the list of dicts for garbage collection. */
6301 }
6303 }
6305 /*
6306 * Unreference a Dictionary: decrement the reference count and free it when it
6307 * becomes zero.
6308 */
6309 static void
6312 {
6315 }
6317 /*
6318 * Free a Dictionary, including all items it contains.
6319 * Ignores the reference count.
6320 */
6321 static void
6325 {
6330 /* Remove the dict from the list of dicts for garbage collection. */
6333 else
6338 /* Lock the hashtab, we don't want it to resize while freeing items. */
6342 {
6344 {
6345 /* Remove the item before deleting it, just in case there is
6346 * something recursive causing trouble. */
6354 }
6355 }
6358 }
6360 /*
6361 * Allocate a Dictionary item.
6362 * The "key" is copied to the new item.
6363 * Note that the value of the item "di_tv" still needs to be initialized!
6364 * Returns NULL when out of memory.
6365 */
6369 {
6374 {
6377 }
6379 }
6381 /*
6382 * Make a copy of a Dictionary item.
6383 */
6387 {
6393 {
6397 }
6399 }
6401 /*
6402 * Remove item "item" from Dictionary "dict" and free it.
6403 */
6404 static void
6408 {
6414 else
6417 }
6419 /*
6420 * Free a dict item. Also clears the value.
6421 */
6422 static void
6425 {
6428 }
6430 /*
6431 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6432 * The refcount of the new dict is set to 1.
6433 * See item_copy() for "copyID".
6434 * Returns NULL when out of memory.
6435 */
6441 {
6452 {
6454 {
6457 }
6460 {
6462 {
6469 {
6472 {
6475 }
6476 }
6477 else
6480 {
6483 }
6484 }
6485 }
6489 {
6492 }
6493 }
6496 }
6498 /*
6499 * Add item "item" to Dictionary "d".
6500 * Returns FAIL when out of memory and when key already existed.
6501 */
6502 static int
6506 {
6508 }
6510 /*
6511 * Add a number or string entry to dictionary "d".
6512 * When "str" is NULL use number "nr", otherwise use "str".
6513 * Returns FAIL when out of memory and when key already exists.
6514 */
6515 int
6521 {
6529 {
6532 }
6533 else
6534 {
6537 }
6539 {
6542 }
6544 }
6546 /*
6547 * Get the number of items in a Dictionary.
6548 */
6549 static long
6552 {
6556 }
6558 /*
6559 * Find item "key[len]" in Dictionary "d".
6560 * If "len" is negative use strlen(key).
6561 * Returns NULL when not found.
6562 */
6568 {
6569 #define AKEYLEN 200
6578 {
6582 }
6583 else
6584 {
6585 /* Avoid a malloc/free by using buf[]. */
6588 }
6595 }
6597 /*
6598 * Get a string item from a dictionary.
6599 * When "save" is TRUE allocate memory for it.
6600 * Returns NULL if the entry doesn't exist or out of memory.
6601 */
6602 char_u *
6607 {
6618 }
6620 /*
6621 * Get a number item from a dictionary.
6622 * Returns 0 if the entry doesn't exist or out of memory.
6623 */
6624 long
6628 {
6635 }
6637 /*
6638 * Return an allocated string with the string representation of a Dictionary.
6639 * May return NULL.
6640 */
6645 {
6646 garray_T ga;
6662 {
6664 {
6669 else
6674 {
6677 }
6685 }
6686 }
6688 {
6691 }
6696 }
6698 /*
6699 * Allocate a variable for a Dictionary and fill it from "*arg".
6700 * Return OK or FAIL. Returns NOTDONE for {expr}.
6701 */
6702 static int
6707 {
6709 typval_T tvkey;
6710 typval_T tv;
6716 /*
6717 * First check if it's not a curly-braces thing: {expr}.
6718 * Must do this without evaluating, otherwise a function may be called
6719 * twice. Unfortunately this means we need to call eval1() twice for the
6720 * first item.
6721 * But {} is an empty Dictionary.
6722 */
6724 {
6729 }
6732 {
6736 }
6742 {
6746 {
6750 }
6752 {
6755 {
6756 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6761 }
6762 }
6766 {
6770 }
6772 {
6775 {
6780 }
6784 {
6789 }
6790 }
6795 {
6798 }
6800 }
6803 {
6805 failret:
6809 }
6813 {
6817 }
6820 }
6822 /*
6823 * Return a string with the string representation of a variable.
6824 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6825 * "numbuf" is used for a number.
6826 * Does not put quotes around strings, as ":echo" displays values.
6827 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6828 * May return NULL.
6829 */
6836 {
6841 {
6845 }
6849 {
6857 {
6860 }
6862 {
6865 }
6866 else
6867 {
6871 }
6876 {
6879 }
6881 {
6884 }
6885 else
6886 {
6890 }
6902 }
6906 }
6908 /*
6909 * Return a string with the string representation of a variable.
6910 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6911 * "numbuf" is used for a number.
6912 * Puts quotes around strings, so that they can be parsed back by eval().
6913 * May return NULL.
6914 */
6921 {
6923 {
6936 }
6938 }
6940 /*
6941 * Return string "str" in ' quotes, doubling ' characters.
6942 * If "str" is NULL an empty string is assumed.
6943 * If "function" is TRUE make it function('string').
6944 */
6949 {
6955 {
6960 }
6963 {
6965 {
6968 }
6969 else
6973 {
6977 }
6982 }
6984 }
6986 /*
6987 * Get the value of an environment variable.
6988 * "arg" is pointing to the '$'. It is advanced to after the name.
6989 * If the environment variable was not set, silently assume it is empty.
6990 * Always return OK.
6991 */
6992 static int
6997 {
7008 {
7010 {
7013 /* first try vim_getenv(), fast for normal environment vars */
7016 {
7019 }
7020 else
7021 {
7025 /* next try expanding things like $VIM and ${HOME} */
7028 {
7031 }
7032 }
7034 }
7037 }
7040 }
7042 /*
7043 * Array with names and number of arguments of all internal functions
7044 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7045 */
7046 static struct fst
7047 {
7052 /* implementation of function */
7054 {
7079 #if defined(FEAT_INS_EXPAND)
7083 #endif
7193 #ifdef vim_mkdir
7195 #endif
7242 #ifdef HAVE_STRFTIME
7244 #endif
7282 };
7284 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7286 /*
7287 * Function given to ExpandGeneric() to obtain the list of internal
7288 * or user defined function names.
7289 */
7290 char_u *
7294 {
7301 {
7305 }
7307 {
7313 }
7316 }
7318 /*
7319 * Function given to ExpandGeneric() to obtain the list of internal or
7320 * user defined variable or function names.
7321 */
7322 /*ARGSUSED*/
7323 char_u *
7327 {
7334 {
7338 }
7340 }
7344 /*
7345 * Find internal function in table above.
7346 * Return index, or -1 if not found
7347 */
7348 static int
7351 {
7357 /*
7358 * Find the function name in the table. Binary search.
7359 */
7361 {
7368 else
7370 }
7372 }
7374 /*
7375 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7376 * name it contains, otherwise return "name".
7377 */
7382 {
7391 {
7393 {
7396 }
7399 }
7402 }
7404 /*
7405 * Allocate a variable for the result of a function.
7406 * Return OK or FAIL.
7407 */
7408 static int
7420 {
7426 /*
7427 * Get the arguments.
7428 */
7431 {
7436 {
7439 }
7443 }
7446 else
7453 {
7456 else
7458 }
7465 }
7468 /*
7469 * Call a function with its resolved parameters
7470 * Return OK when the function can't be called, FAIL otherwise.
7471 * Also returns OK when an error was encountered while executing the function.
7472 */
7473 static int
7481 PLUS ONE elements! */
7487 {
7489 #define ERROR_UNKNOWN 0
7490 #define ERROR_TOOMANY 1
7491 #define ERROR_TOOFEW 2
7492 #define ERROR_SCRIPT 3
7493 #define ERROR_DICT 4
7494 #define ERROR_NONE 5
7495 #define ERROR_OTHER 6
7501 #define FLEN_FIXED 40
7505 /*
7506 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7507 * Change <SNR>123_name() to K_SNR 123_name().
7508 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7509 */
7514 {
7520 {
7523 else
7524 {
7527 }
7528 }
7530 {
7533 }
7534 else
7535 {
7539 else
7540 {
7543 }
7544 }
7545 }
7546 else
7552 /* execute the function if no errors detected and executing */
7554 {
7559 {
7560 /*
7561 * User defined function.
7562 */
7565 #ifdef FEAT_AUTOCMD
7566 /* Trigger FuncUndefined event, may load the function. */
7571 {
7572 /* executed an autocommand, search for the function again */
7574 }
7575 #endif
7576 /* Try loading a package. */
7578 {
7579 /* loaded a package, search for the function again */
7581 }
7584 {
7593 else
7594 {
7595 /*
7596 * Call the user function.
7597 * Save and restore search patterns, script variables and
7598 * redo buffer.
7599 */
7608 /* Function was unreferenced while being used, free it
7609 * now. */
7614 }
7615 }
7616 }
7617 else
7618 {
7619 /*
7620 * Find the function name in the table, call its implementation.
7621 */
7624 {
7629 else
7630 {
7634 }
7635 }
7636 }
7637 /*
7638 * The function call (or "FuncUndefined" autocommand sequence) might
7639 * have been aborted by an error, an interrupt, or an explicitly thrown
7640 * exception that has not been caught so far. This situation can be
7641 * tested for by calling aborting(). For an error in an internal
7642 * function or for the "E132" error in call_user_func(), however, the
7643 * throw point at which the "force_abort" flag (temporarily reset by
7644 * emsg()) is normally updated has not been reached yet. We need to
7645 * update that flag first to make aborting() reliable.
7646 */
7648 }
7652 /*
7653 * Report an error unless the argument evaluation or function call has been
7654 * cancelled due to an aborting error, an interrupt, or an exception.
7655 */
7657 {
7659 {
7668 name);
7672 name);
7676 name);
7678 }
7679 }
7686 }
7688 /*
7689 * Give an error message with a function name. Handle <SNR> things.
7690 */
7691 static void
7695 {
7700 else
7705 }
7707 /*********************************************
7708 * Implementation of the built-in functions
7709 */
7711 /*
7712 * "add(list, item)" function
7713 */
7714 static void
7718 {
7723 {
7728 }
7729 else
7731 }
7733 /*
7734 * "append(lnum, string/list)" function
7735 */
7736 static void
7740 {
7752 {
7754 {
7759 }
7762 {
7767 else
7771 {
7774 }
7780 }
7785 }
7786 else
7788 }
7790 /*
7791 * "argc()" function
7792 */
7793 /* ARGSUSED */
7794 static void
7798 {
7800 }
7802 /*
7803 * "argidx()" function
7804 */
7805 /* ARGSUSED */
7806 static void
7810 {
7812 }
7814 /*
7815 * "argv(nr)" function
7816 */
7817 static void
7821 {
7825 {
7829 else
7832 }
7837 }
7839 /*
7840 * "browse(save, title, initdir, default)" function
7841 */
7842 /* ARGSUSED */
7843 static void
7847 {
7848 #ifdef FEAT_BROWSE
7864 else
7868 #else
7870 #endif
7872 }
7874 /*
7875 * "browsedir(title, initdir)" function
7876 */
7877 /* ARGSUSED */
7878 static void
7882 {
7883 #ifdef FEAT_BROWSE
7893 else
7896 #else
7898 #endif
7900 }
7904 /*
7905 * Find a buffer by number or exact name.
7906 */
7910 {
7916 {
7919 {
7920 /* No full path name match, try a match with a URL or a "nofile"
7921 * buffer, these don't use the full path. */
7925 #ifdef FEAT_QUICKFIX
7927 #endif
7928 )
7931 }
7932 }
7934 }
7936 /*
7937 * "bufexists(expr)" function
7938 */
7939 static void
7943 {
7945 }
7947 /*
7948 * "buflisted(expr)" function
7949 */
7950 static void
7954 {
7959 }
7961 /*
7962 * "bufloaded(expr)" function
7963 */
7964 static void
7968 {
7973 }
7977 /*
7978 * Get buffer by number or pattern.
7979 */
7983 {
7998 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8010 /* If not found, try expanding the name, like done for bufexists(). */
8015 }
8017 /*
8018 * "bufname(expr)" function
8019 */
8020 static void
8024 {
8033 else
8036 }
8038 /*
8039 * "bufnr(expr)" function
8040 */
8041 static void
8045 {
8055 /* If the buffer isn't found and the second argument is not zero create a
8056 * new buffer. */
8060 && !error
8067 else
8069 }
8071 /*
8072 * "bufwinnr(nr)" function
8073 */
8074 static void
8078 {
8079 #ifdef FEAT_WINDOWS
8082 #endif
8088 #ifdef FEAT_WINDOWS
8090 {
8094 }
8096 #else
8098 #endif
8100 }
8102 /*
8103 * "byte2line(byte)" function
8104 */
8105 /*ARGSUSED*/
8106 static void
8110 {
8111 #ifndef FEAT_BYTEOFF
8113 #else
8119 else
8122 #endif
8123 }
8125 /*
8126 * "byteidx()" function
8127 */
8128 /*ARGSUSED*/
8129 static void
8133 {
8134 #ifdef FEAT_MBYTE
8136 #endif
8146 #ifdef FEAT_MBYTE
8149 {
8153 }
8155 #else
8158 #endif
8159 }
8161 /*
8162 * "call(func, arglist)" function
8163 */
8164 static void
8168 {
8178 {
8181 }
8187 else
8193 {
8195 {
8198 }
8200 }
8204 {
8206 {
8209 }
8210 /* Make a copy of each argument. This is needed to be able to set
8211 * v_lock to VAR_FIXED in the copy without changing the original list.
8212 */
8214 }
8221 /* Free the arguments. */
8224 }
8226 /*
8227 * "changenr()" function
8228 */
8229 /*ARGSUSED*/
8230 static void
8234 {
8236 }
8238 /*
8239 * "char2nr(string)" function
8240 */
8241 static void
8245 {
8246 #ifdef FEAT_MBYTE
8249 else
8250 #endif
8252 }
8254 /*
8255 * "cindent(lnum)" function
8256 */
8257 static void
8261 {
8262 #ifdef FEAT_CINDENT
8263 pos_T pos;
8264 linenr_T lnum;
8269 {
8273 }
8274 else
8275 #endif
8277 }
8279 /*
8280 * "clearmatches()" function
8281 */
8282 /*ARGSUSED*/
8283 static void
8287 {
8288 #ifdef FEAT_SEARCH_EXTRA
8290 #endif
8291 }
8293 /*
8294 * "col(string)" function
8295 */
8296 static void
8300 {
8307 {
8309 {
8310 /* '> can be MAXCOL, get the length of the line then */
8313 else
8315 }
8316 else
8317 {
8319 #ifdef FEAT_VIRTUALEDIT
8320 /* col(".") when the cursor is on the NUL at the end of the line
8321 * because of "coladd" can be seen as an extra column. */
8323 {
8328 {
8329 # ifdef FEAT_MBYTE
8334 # else
8337 # endif
8338 }
8339 }
8340 #endif
8341 }
8342 }
8344 }
8346 #if defined(FEAT_INS_EXPAND)
8347 /*
8348 * "complete()" function
8349 */
8350 /*ARGSUSED*/
8351 static void
8355 {
8359 {
8362 }
8364 /* Check for undo allowed here, because if something was already inserted
8365 * the line was already saved for undo and this check isn't done. */
8370 {
8373 }
8380 }
8382 /*
8383 * "complete_add()" function
8384 */
8385 /*ARGSUSED*/
8386 static void
8390 {
8392 }
8394 /*
8395 * "complete_check()" function
8396 */
8397 /*ARGSUSED*/
8398 static void
8402 {
8409 }
8410 #endif
8412 /*
8413 * "confirm(message, buttons[, default [, type]])" function
8414 */
8415 /*ARGSUSED*/
8416 static void
8420 {
8421 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8435 {
8440 {
8443 {
8447 else
8448 {
8450 {
8456 }
8457 }
8458 }
8459 }
8460 }
8467 else
8470 #else
8472 #endif
8473 }
8475 /*
8476 * "copy()" function
8477 */
8478 static void
8482 {
8484 }
8486 /*
8487 * "count()" function
8488 */
8489 static void
8493 {
8498 {
8504 {
8507 {
8512 {
8515 {
8519 }
8520 }
8523 }
8528 }
8529 }
8531 {
8537 {
8541 {
8545 }
8549 {
8551 {
8555 }
8556 }
8557 }
8558 }
8559 else
8562 }
8564 /*
8565 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8566 *
8567 * Checks the existence of a cscope connection.
8568 */
8569 /*ARGSUSED*/
8570 static void
8574 {
8575 #ifdef FEAT_CSCOPE
8583 {
8588 }
8591 #else
8593 #endif
8594 }
8596 /*
8597 * "cursor(lnum, col)" function
8598 *
8599 * Moves the cursor to the specified line and column
8600 */
8601 /*ARGSUSED*/
8602 static void
8606 {
8608 #ifdef FEAT_VIRTUALEDIT
8610 #endif
8613 {
8614 pos_T pos;
8620 #ifdef FEAT_VIRTUALEDIT
8622 #endif
8623 }
8624 else
8625 {
8628 #ifdef FEAT_VIRTUALEDIT
8631 #endif
8632 }
8634 #ifdef FEAT_VIRTUALEDIT
8636 #endif
8637 )
8643 #ifdef FEAT_VIRTUALEDIT
8645 #endif
8647 /* Make sure the cursor is in a valid position. */
8649 #ifdef FEAT_MBYTE
8650 /* Correct cursor for multi-byte character. */
8653 #endif
8656 }
8658 /*
8659 * "deepcopy()" function
8660 */
8661 static void
8665 {
8672 else
8674 }
8676 /*
8677 * "delete()" function
8678 */
8679 static void
8683 {
8686 else
8688 }
8690 /*
8691 * "did_filetype()" function
8692 */
8693 /*ARGSUSED*/
8694 static void
8698 {
8699 #ifdef FEAT_AUTOCMD
8701 #else
8703 #endif
8704 }
8706 /*
8707 * "diff_filler()" function
8708 */
8709 /*ARGSUSED*/
8710 static void
8714 {
8715 #ifdef FEAT_DIFF
8717 #endif
8718 }
8720 /*
8721 * "diff_hlID()" function
8722 */
8723 /*ARGSUSED*/
8724 static void
8728 {
8729 #ifdef FEAT_DIFF
8745 {
8746 /* New line, buffer, change: need to get the values. */
8749 {
8751 {
8756 else
8758 }
8759 else
8761 }
8762 else
8767 }
8770 {
8774 else
8776 }
8778 #endif
8779 }
8781 /*
8782 * "empty({expr})" function
8783 */
8784 static void
8788 {
8792 {
8812 }
8815 }
8817 /*
8818 * "escape({string}, {chars})" function
8819 */
8820 static void
8824 {
8830 }
8832 /*
8833 * "eval()" function
8834 */
8835 /*ARGSUSED*/
8836 static void
8840 {
8848 {
8851 }
8854 }
8856 /*
8857 * "eventhandler()" function
8858 */
8859 /*ARGSUSED*/
8860 static void
8864 {
8866 }
8868 /*
8869 * "executable()" function
8870 */
8871 static void
8875 {
8877 }
8879 /*
8880 * "exists()" function
8881 */
8882 static void
8886 {
8894 {
8895 /* first try "normal" environment variables (fast) */
8898 else
8899 {
8900 /* try expanding things like $VIM and ${HOME} */
8905 }
8906 }
8908 {
8912 }
8914 {
8916 }
8918 {
8920 }
8922 {
8923 #ifdef FEAT_AUTOCMD
8926 else
8928 #endif
8929 }
8931 {
8933 typval_T tv;
8935 /* get_name_len() takes care of expanding curly braces */
8939 {
8944 {
8945 /* handle d.key, l[idx], f(expr) */
8949 }
8950 }
8955 }
8958 }
8960 /*
8961 * "expand()" function
8962 */
8963 static void
8967 {
8972 expand_T xpc;
8978 {
8982 }
8983 else
8984 {
8985 /* When the optional second argument is non-zero, don't remove matches
8986 * for 'suffixes' and 'wildignore' */
8991 {
8995 }
8996 else
8998 }
8999 }
9001 /*
9002 * "extend(list, list [, idx])" function
9003 * "extend(dict, dict [, action])" function
9004 */
9005 static void
9009 {
9012 {
9022 {
9024 {
9031 else
9032 {
9035 {
9038 }
9039 }
9040 }
9041 else
9046 }
9047 }
9049 {
9061 {
9062 /* Check the third argument. */
9064 {
9074 {
9077 }
9078 }
9079 else
9082 /* Go over all entries in the second dict and add them to the
9083 * first dict. */
9086 {
9088 {
9092 {
9096 }
9098 {
9101 }
9103 {
9106 }
9107 }
9108 }
9111 }
9112 }
9113 else
9115 }
9117 /*
9118 * "feedkeys()" function
9119 */
9120 /*ARGSUSED*/
9121 static void
9125 {
9132 /* This is not allowed in the sandbox. If the commands would still be
9133 * executed in the sandbox it would be OK, but it probably happens later,
9134 * when "sandbox" is no longer set. */
9141 {
9143 {
9146 {
9148 {
9152 }
9153 }
9154 }
9156 /* Need to escape K_SPECIAL and CSI before putting the string in the
9157 * typeahead buffer. */
9160 {
9166 }
9167 }
9168 }
9170 /*
9171 * "filereadable()" function
9172 */
9173 static void
9177 {
9184 {
9187 }
9188 else
9192 }
9194 /*
9195 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9196 * rights to write into.
9197 */
9198 static void
9202 {
9204 }
9208 static void
9213 {
9214 #ifdef FEAT_SEARCHPATH
9223 #endif
9228 #ifdef FEAT_SEARCHPATH
9232 {
9236 else
9237 {
9243 }
9244 }
9250 {
9251 do
9252 {
9265 }
9269 #endif
9270 }
9275 /*
9276 * Implementation of map() and filter().
9277 */
9278 static void
9283 {
9292 typval_T save_val;
9293 typval_T save_key;
9301 {
9305 }
9307 {
9311 }
9312 else
9313 {
9316 }
9319 /* On type errors, the preceding call has already displayed an error
9320 * message. Avoid a misleading error message for an empty string that
9321 * was not passed as argument. */
9323 {
9327 /* We reset "did_emsg" to be able to detect whether an error
9328 * occurred during evaluation of the expression. */
9333 {
9341 {
9343 {
9355 }
9356 }
9360 }
9361 else
9362 {
9364 {
9373 }
9374 }
9379 }
9382 }
9384 static int
9390 {
9391 typval_T rettv;
9400 {
9403 }
9405 {
9406 /* map(): replace the list item value */
9410 }
9411 else
9412 {
9415 /* filter(): when expr is zero remove the item */
9418 /* On type error, nothing has been removed; return FAIL to stop the
9419 * loop. The error message was given by get_tv_number_chk(). */
9422 }
9424 theend:
9427 }
9429 /*
9430 * "filter()" function
9431 */
9432 static void
9436 {
9438 }
9440 /*
9441 * "finddir({fname}[, {path}[, {count}]])" function
9442 */
9443 static void
9447 {
9449 }
9451 /*
9452 * "findfile({fname}[, {path}[, {count}]])" function
9453 */
9454 static void
9458 {
9460 }
9462 /*
9463 * "fnamemodify({fname}, {mods})" function
9464 */
9465 static void
9469 {
9481 else
9482 {
9485 }
9490 else
9493 }
9497 /*
9498 * "foldclosed()" function
9499 */
9500 static void
9505 {
9506 #ifdef FEAT_FOLDING
9507 linenr_T lnum;
9512 {
9514 {
9517 else
9520 }
9521 }
9522 #endif
9524 }
9526 /*
9527 * "foldclosed()" function
9528 */
9529 static void
9533 {
9535 }
9537 /*
9538 * "foldclosedend()" function
9539 */
9540 static void
9544 {
9546 }
9548 /*
9549 * "foldlevel()" function
9550 */
9551 static void
9555 {
9556 #ifdef FEAT_FOLDING
9557 linenr_T lnum;
9562 else
9563 #endif
9565 }
9567 /*
9568 * "foldtext()" function
9569 */
9570 /*ARGSUSED*/
9571 static void
9575 {
9576 #ifdef FEAT_FOLDING
9577 linenr_T lnum;
9582 #endif
9586 #ifdef FEAT_FOLDING
9591 {
9592 /* Find first non-empty line in the fold. */
9595 {
9599 }
9601 /* Find interesting text in this line. */
9603 /* skip C comment-start */
9605 {
9609 {
9613 }
9614 }
9621 {
9627 /* remove 'foldmarker' and 'commentstring' */
9630 }
9631 }
9632 #endif
9633 }
9635 /*
9636 * "foldtextresult(lnum)" function
9637 */
9638 /*ARGSUSED*/
9639 static void
9643 {
9644 #ifdef FEAT_FOLDING
9645 linenr_T lnum;
9648 foldinfo_T foldinfo;
9650 #endif
9654 #ifdef FEAT_FOLDING
9656 /* treat illegal types and illegal string values for {lnum} the same */
9661 {
9667 }
9668 #endif
9669 }
9671 /*
9672 * "foreground()" function
9673 */
9674 /*ARGSUSED*/
9675 static void
9679 {
9681 #ifdef FEAT_GUI
9684 #else
9685 # ifdef WIN32
9687 # endif
9688 #endif
9689 }
9691 /*
9692 * "function()" function
9693 */
9694 /*ARGSUSED*/
9695 static void
9699 {
9708 else
9709 {
9712 }
9713 }
9715 /*
9716 * "garbagecollect()" function
9717 */
9718 /*ARGSUSED*/
9719 static void
9723 {
9724 /* This is postponed until we are back at the toplevel, because we may be
9725 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9730 }
9732 /*
9733 * "get()" function
9734 */
9735 static void
9739 {
9747 {
9749 {
9755 }
9756 }
9758 {
9760 {
9764 }
9765 }
9766 else
9770 {
9773 else
9775 }
9776 else
9778 }
9780 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9782 /*
9783 * Get line or list of lines from buffer "buf" into "rettv".
9784 * Return a range (from start to end) of lines in rettv from the specified
9785 * buffer.
9786 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9787 */
9788 static void
9791 linenr_T start;
9792 linenr_T end;
9795 {
9799 {
9802 }
9803 else
9810 {
9813 else
9818 }
9819 else
9820 {
9832 }
9833 }
9835 /*
9836 * "getbufline()" function
9837 */
9838 static void
9842 {
9843 linenr_T lnum;
9844 linenr_T end;
9855 else
9859 }
9861 /*
9862 * "getbufvar()" function
9863 */
9864 static void
9868 {
9883 {
9885 {
9886 /* set curbuf to be our buf, temporarily */
9892 /* restore previous notion of curbuf */
9894 }
9895 else
9896 {
9898 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9899 * scope prefix before the NUL byte is required by
9900 * find_var_in_ht(). */
9902 /* look up the variable */
9906 }
9907 }
9910 }
9912 /*
9913 * "getchar()" function
9914 */
9915 static void
9919 {
9920 varnumber_T n;
9923 /* Position the cursor. Needed after a message that ends in a space. */
9929 {
9931 /* getchar(): blocking wait. */
9934 /* getchar(1): only check if char avail */
9937 /* illegal argument or getchar(0) and no char avail: return zero */
9939 else
9940 /* getchar(0) and char avail: return char */
9945 }
9955 {
9959 /* Turn a special key into three bytes, plus modifier. */
9961 {
9965 }
9967 {
9971 }
9972 #ifdef FEAT_MBYTE
9975 #endif
9976 else
9982 #ifdef FEAT_MOUSE
10002 {
10006 linenr_T lnum;
10007 # ifdef FEAT_WINDOWS
10009 # endif
10013 {
10014 /* Find the window at the mouse coordinates and compute the
10015 * text position. */
10018 # ifdef FEAT_WINDOWS
10021 # endif
10025 }
10026 }
10027 #endif
10028 }
10029 }
10031 /*
10032 * "getcharmod()" function
10033 */
10034 /*ARGSUSED*/
10035 static void
10039 {
10041 }
10043 /*
10044 * "getcmdline()" function
10045 */
10046 /*ARGSUSED*/
10047 static void
10051 {
10054 }
10056 /*
10057 * "getcmdpos()" function
10058 */
10059 /*ARGSUSED*/
10060 static void
10064 {
10066 }
10068 /*
10069 * "getcmdtype()" function
10070 */
10071 /*ARGSUSED*/
10072 static void
10076 {
10080 {
10083 }
10084 }
10086 /*
10087 * "getcwd()" function
10088 */
10089 /*ARGSUSED*/
10090 static void
10094 {
10100 else
10101 {
10103 #ifdef BACKSLASH_IN_FILENAME
10106 #endif
10107 }
10108 }
10110 /*
10111 * "getfontname()" function
10112 */
10113 /*ARGSUSED*/
10114 static void
10118 {
10121 #ifdef FEAT_GUI
10123 {
10124 GuiFont font;
10128 {
10129 /* Get the "Normal" font. Either the name saved by
10130 * hl_set_font_name() or from the font ID. */
10133 }
10134 else
10135 {
10142 }
10146 }
10147 #endif
10148 }
10150 /*
10151 * "getfperm({fname})" function
10152 */
10153 static void
10157 {
10168 {
10171 {
10173 {
10176 }
10177 }
10178 }
10180 }
10182 /*
10183 * "getfsize({fname})" function
10184 */
10185 static void
10189 {
10198 {
10201 else
10202 {
10205 /* non-perfect check for overflow */
10208 }
10209 }
10210 else
10212 }
10214 /*
10215 * "getftime({fname})" function
10216 */
10217 static void
10221 {
10229 else
10231 }
10233 /*
10234 * "getftype({fname})" function
10235 */
10236 static void
10240 {
10250 {
10251 #ifdef S_ISREG
10256 # ifdef S_ISLNK
10259 # endif
10260 # ifdef S_ISBLK
10263 # endif
10264 # ifdef S_ISCHR
10267 # endif
10268 # ifdef S_ISFIFO
10271 # endif
10272 # ifdef S_ISSOCK
10275 # endif
10276 else
10278 #else
10279 # ifdef S_IFMT
10281 {
10284 # ifdef S_IFLNK
10286 # endif
10287 # ifdef S_IFBLK
10289 # endif
10290 # ifdef S_IFCHR
10292 # endif
10293 # ifdef S_IFIFO
10295 # endif
10296 # ifdef S_IFSOCK
10298 # endif
10300 }
10301 # else
10304 else
10306 # endif
10307 #endif
10309 }
10311 }
10313 /*
10314 * "getline(lnum, [end])" function
10315 */
10316 static void
10320 {
10321 linenr_T lnum;
10322 linenr_T end;
10327 {
10330 }
10331 else
10332 {
10335 }
10338 }
10340 /*
10341 * "getmatches()" function
10342 */
10343 /*ARGSUSED*/
10344 static void
10348 {
10349 #ifdef FEAT_SEARCH_EXTRA
10356 {
10358 {
10368 }
10369 }
10370 #endif
10371 }
10373 /*
10374 * "getpos(string)" function
10375 */
10376 static void
10380 {
10386 {
10391 else
10399 #ifdef FEAT_VIRTUALEDIT
10401 #endif
10403 }
10404 else
10406 }
10408 /*
10409 * "getqflist()" and "getloclist()" functions
10410 */
10411 /*ARGSUSED*/
10412 static void
10416 {
10417 #ifdef FEAT_QUICKFIX
10419 #endif
10422 #ifdef FEAT_QUICKFIX
10424 {
10427 {
10431 }
10434 }
10435 #endif
10436 }
10438 /*
10439 * "getreg()" function
10440 */
10441 static void
10445 {
10452 {
10457 }
10458 else
10467 }
10469 /*
10470 * "getregtype()" function
10471 */
10472 static void
10476 {
10483 {
10486 {
10490 }
10491 }
10492 else
10493 /* Default to v:register */
10503 {
10506 #ifdef FEAT_VISUAL
10511 #endif
10512 }
10515 }
10517 /*
10518 * "gettabwinvar()" function
10519 */
10520 static void
10524 {
10526 }
10528 /*
10529 * "getwinposx()" function
10530 */
10531 /*ARGSUSED*/
10532 static void
10536 {
10538 #ifdef FEAT_GUI
10540 {
10545 }
10546 #endif
10547 }
10549 /*
10550 * "getwinposy()" function
10551 */
10552 /*ARGSUSED*/
10553 static void
10557 {
10559 #ifdef FEAT_GUI
10561 {
10566 }
10567 #endif
10568 }
10570 /*
10571 * Find window specifed by "vp" in tabpage "tp".
10572 */
10577 {
10578 #ifdef FEAT_WINDOWS
10580 #endif
10585 #ifdef FEAT_WINDOWS
10596 #else
10600 #endif
10601 }
10603 /*
10604 * "getwinvar()" function
10605 */
10606 static void
10610 {
10612 }
10614 /*
10615 * getwinvar() and gettabwinvar()
10616 */
10617 static void
10622 {
10628 #ifdef FEAT_WINDOWS
10631 else
10633 #endif
10642 {
10643 /* Set curwin to be our win, temporarily. Also set curbuf, so
10644 * that we can get buffer-local options. */
10651 else
10652 {
10654 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10655 * scope prefix before the NUL byte is required by
10656 * find_var_in_ht(). */
10658 /* look up the variable */
10662 }
10664 /* restore previous notion of curwin */
10667 }
10670 }
10672 /*
10673 * "glob()" function
10674 */
10675 static void
10679 {
10680 expand_T xpc;
10687 }
10689 /*
10690 * "globpath()" function
10691 */
10692 static void
10696 {
10703 else
10705 }
10707 /*
10708 * "has()" function
10709 */
10710 static void
10714 {
10719 {
10720 #ifdef AMIGA
10722 # ifdef FEAT_ARP
10724 # endif
10725 #endif
10726 #ifdef __BEOS__
10728 #endif
10729 #ifdef MSDOS
10730 # ifdef DJGPP
10732 # else
10734 # endif
10735 #endif
10736 #ifdef MACOS
10738 #endif
10739 #if defined(MACOS_X_UNIX)
10741 #endif
10742 #ifdef OS2
10744 #endif
10745 #ifdef __QNX__
10747 #endif
10748 #ifdef RISCOS
10750 #endif
10751 #ifdef UNIX
10753 #endif
10754 #ifdef VMS
10756 #endif
10757 #ifdef WIN16
10759 #endif
10760 #ifdef WIN32
10762 #endif
10763 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10765 #endif
10766 #ifdef WIN64
10768 #endif
10769 #ifdef EBCDIC
10771 #endif
10772 #ifndef CASE_INSENSITIVE_FILENAME
10774 #endif
10775 #ifdef FEAT_ARABIC
10777 #endif
10778 #ifdef FEAT_AUTOCMD
10780 #endif
10781 #ifdef FEAT_BEVAL
10785 # endif
10786 #endif
10787 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10789 # ifdef ALL_BUILTIN_TCAPS
10791 # endif
10792 #endif
10793 #ifdef FEAT_BYTEOFF
10795 #endif
10796 #ifdef FEAT_CINDENT
10798 #endif
10799 #ifdef FEAT_CLIENTSERVER
10801 #endif
10802 #ifdef FEAT_CLIPBOARD
10804 #endif
10805 #ifdef FEAT_CMDL_COMPL
10807 #endif
10808 #ifdef FEAT_CMDHIST
10810 #endif
10811 #ifdef FEAT_COMMENTS
10813 #endif
10814 #ifdef FEAT_CRYPT
10816 #endif
10817 #ifdef FEAT_CSCOPE
10819 #endif
10820 #ifdef CURSOR_SHAPE
10822 #endif
10823 #ifdef DEBUG
10825 #endif
10826 #ifdef FEAT_CON_DIALOG
10828 #endif
10829 #ifdef FEAT_GUI_DIALOG
10831 #endif
10832 #ifdef FEAT_DIFF
10834 #endif
10835 #ifdef FEAT_DIGRAPHS
10837 #endif
10838 #ifdef FEAT_DND
10840 #endif
10841 #ifdef FEAT_EMACS_TAGS
10843 #endif
10845 #ifdef FEAT_EX_EXTRA
10847 #endif
10848 #ifdef FEAT_SEARCH_EXTRA
10850 #endif
10851 #ifdef FEAT_FKMAP
10853 #endif
10854 #ifdef FEAT_SEARCHPATH
10856 #endif
10857 #if defined(UNIX) && !defined(USE_SYSTEM)
10859 #endif
10860 #ifdef FEAT_FIND_ID
10862 #endif
10863 #ifdef FEAT_FOLDING
10865 #endif
10866 #ifdef FEAT_FOOTER
10868 #endif
10869 #if !defined(USE_SYSTEM) && defined(UNIX)
10871 #endif
10872 #ifdef FEAT_FULLSCREEN
10874 #endif
10875 #ifdef FEAT_GETTEXT
10877 #endif
10878 #ifdef FEAT_GUI
10880 #endif
10881 #ifdef FEAT_GUI_ATHENA
10882 # ifdef FEAT_GUI_NEXTAW
10884 # else
10886 # endif
10887 #endif
10888 #ifdef FEAT_GUI_GTK
10890 # ifdef HAVE_GTK2
10892 # endif
10893 #endif
10894 #ifdef FEAT_GUI_GNOME
10896 #endif
10897 #ifdef FEAT_GUI_MAC
10899 #endif
10900 #ifdef FEAT_GUI_MACVIM
10902 #endif
10903 #ifdef FEAT_GUI_MOTIF
10905 #endif
10906 #ifdef FEAT_GUI_PHOTON
10908 #endif
10909 #ifdef FEAT_GUI_W16
10911 #endif
10912 #ifdef FEAT_GUI_W32
10914 #endif
10915 #ifdef FEAT_HANGULIN
10917 #endif
10918 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10920 #endif
10921 #ifdef FEAT_INS_EXPAND
10923 #endif
10924 #ifdef FEAT_JUMPLIST
10926 #endif
10927 #ifdef FEAT_KEYMAP
10929 #endif
10930 #ifdef FEAT_LANGMAP
10932 #endif
10933 #ifdef FEAT_LIBCALL
10935 #endif
10936 #ifdef FEAT_LINEBREAK
10938 #endif
10939 #ifdef FEAT_LISP
10941 #endif
10942 #ifdef FEAT_LISTCMDS
10944 #endif
10945 #ifdef FEAT_LOCALMAP
10947 #endif
10948 #ifdef FEAT_MENU
10950 #endif
10951 #ifdef FEAT_SESSION
10953 #endif
10954 #ifdef FEAT_MODIFY_FNAME
10956 #endif
10957 #ifdef FEAT_MOUSE
10959 #endif
10960 #ifdef FEAT_MOUSESHAPE
10962 #endif
10963 #if defined(UNIX) || defined(VMS)
10964 # ifdef FEAT_MOUSE_DEC
10966 # endif
10967 # ifdef FEAT_MOUSE_GPM
10969 # endif
10970 # ifdef FEAT_MOUSE_JSB
10972 # endif
10973 # ifdef FEAT_MOUSE_NET
10975 # endif
10976 # ifdef FEAT_MOUSE_PTERM
10978 # endif
10979 # ifdef FEAT_MOUSE_XTERM
10981 # endif
10982 #endif
10983 #ifdef FEAT_MBYTE
10985 #endif
10986 #ifdef FEAT_MBYTE_IME
10988 #endif
10989 #ifdef FEAT_MULTI_LANG
10991 #endif
10992 #ifdef FEAT_MZSCHEME
10993 #ifndef DYNAMIC_MZSCHEME
10995 #endif
10996 #endif
10997 #ifdef FEAT_OLE
10999 #endif
11000 #ifdef FEAT_OSFILETYPE
11002 #endif
11003 #ifdef FEAT_PATH_EXTRA
11005 #endif
11006 #ifdef FEAT_PERL
11007 #ifndef DYNAMIC_PERL
11009 #endif
11010 #endif
11011 #ifdef FEAT_PYTHON
11012 #ifndef DYNAMIC_PYTHON
11014 #endif
11015 #endif
11016 #ifdef FEAT_POSTSCRIPT
11018 #endif
11019 #ifdef FEAT_PRINTER
11021 #endif
11022 #ifdef FEAT_PROFILE
11024 #endif
11025 #ifdef FEAT_RELTIME
11027 #endif
11028 #ifdef FEAT_QUICKFIX
11030 #endif
11031 #ifdef FEAT_RIGHTLEFT
11033 #endif
11034 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11036 #endif
11037 #ifdef FEAT_SCROLLBIND
11039 #endif
11040 #ifdef FEAT_CMDL_INFO
11043 #endif
11044 #ifdef FEAT_SIGNS
11046 #endif
11047 #ifdef FEAT_SMARTINDENT
11049 #endif
11050 #ifdef FEAT_SNIFF
11052 #endif
11053 #ifdef FEAT_STL_OPT
11055 #endif
11056 #ifdef FEAT_SUN_WORKSHOP
11058 #endif
11059 #ifdef FEAT_NETBEANS_INTG
11061 #endif
11062 #ifdef FEAT_ODB_EDITOR
11064 #endif
11065 #ifdef FEAT_SPELL
11067 #endif
11068 #ifdef FEAT_SYN_HL
11070 #endif
11071 #if defined(USE_SYSTEM) || !defined(UNIX)
11073 #endif
11074 #ifdef FEAT_TAG_BINS
11076 #endif
11077 #ifdef FEAT_TAG_OLDSTATIC
11079 #endif
11080 #ifdef FEAT_TAG_ANYWHITE
11082 #endif
11083 #ifdef FEAT_TCL
11084 # ifndef DYNAMIC_TCL
11086 # endif
11087 #endif
11088 #ifdef TERMINFO
11090 #endif
11091 #ifdef FEAT_TERMRESPONSE
11093 #endif
11094 #ifdef FEAT_TEXTOBJ
11096 #endif
11097 #ifdef HAVE_TGETENT
11099 #endif
11100 #ifdef FEAT_TITLE
11102 #endif
11103 #ifdef FEAT_TOOLBAR
11105 #endif
11106 #ifdef FEAT_TRANSPARENCY
11108 #endif
11109 #ifdef FEAT_USR_CMDS
11112 #endif
11113 #ifdef FEAT_VIMINFO
11115 #endif
11116 #ifdef FEAT_VERTSPLIT
11118 #endif
11119 #ifdef FEAT_VIRTUALEDIT
11121 #endif
11122 #ifdef FEAT_VISUAL
11124 #endif
11125 #ifdef FEAT_VISUALEXTRA
11127 #endif
11128 #ifdef FEAT_VREPLACE
11130 #endif
11131 #ifdef FEAT_WILDIGN
11133 #endif
11134 #ifdef FEAT_WILDMENU
11136 #endif
11137 #ifdef FEAT_WINDOWS
11139 #endif
11140 #ifdef FEAT_WAK
11142 #endif
11143 #ifdef FEAT_WRITEBACKUP
11145 #endif
11146 #ifdef FEAT_XIM
11148 #endif
11149 #ifdef FEAT_XFONTSET
11151 #endif
11152 #ifdef USE_XSMP
11154 #endif
11155 #ifdef USE_XSMP_INTERACT
11157 #endif
11158 #ifdef FEAT_XCLIPBOARD
11160 #endif
11161 #ifdef FEAT_XTERM_SAVE
11163 #endif
11164 #if defined(UNIX) && defined(FEAT_X11)
11166 #endif
11167 NULL
11168 };
11173 {
11176 }
11179 {
11184 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11187 #endif
11188 #ifdef DYNAMIC_TCL
11191 #endif
11192 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11195 #endif
11196 #ifdef DYNAMIC_MZSCHEME
11199 #endif
11200 #ifdef DYNAMIC_RUBY
11203 #endif
11204 #ifdef DYNAMIC_PYTHON
11207 #endif
11208 #ifdef DYNAMIC_PERL
11211 #endif
11212 #ifdef FEAT_GUI
11215 # ifdef FEAT_GUI_W32
11218 # endif
11219 # ifdef FEAT_BROWSE
11222 # endif
11223 #endif
11224 #ifdef FEAT_SYN_HL
11227 #endif
11228 #if defined(WIN3264)
11231 #endif
11232 #ifdef FEAT_NETBEANS_INTG
11235 #endif
11236 }
11239 }
11241 /*
11242 * "has_key()" function
11243 */
11244 static void
11248 {
11251 {
11254 }
11260 }
11262 /*
11263 * "haslocaldir()" function
11264 */
11265 /*ARGSUSED*/
11266 static void
11270 {
11272 }
11274 /*
11275 * "hasmapto()" function
11276 */
11277 static void
11281 {
11290 else
11291 {
11295 }
11299 else
11301 }
11303 /*
11304 * "histadd()" function
11305 */
11306 /*ARGSUSED*/
11307 static void
11311 {
11312 #ifdef FEAT_CMDHIST
11316 #endif
11321 #ifdef FEAT_CMDHIST
11325 {
11328 {
11332 }
11333 }
11334 #endif
11335 }
11337 /*
11338 * "histdel()" function
11339 */
11340 /*ARGSUSED*/
11341 static void
11345 {
11346 #ifdef FEAT_CMDHIST
11355 /* only one argument: clear entire history */
11358 /* index given: remove that entry */
11361 else
11362 /* string given: remove all matching entries */
11366 #else
11368 #endif
11369 }
11371 /*
11372 * "histget()" function
11373 */
11374 /*ARGSUSED*/
11375 static void
11379 {
11380 #ifdef FEAT_CMDHIST
11388 else
11389 {
11393 else
11395 /* -1 on type error */
11397 }
11398 #else
11400 #endif
11402 }
11404 /*
11405 * "histnr()" function
11406 */
11407 /*ARGSUSED*/
11408 static void
11412 {
11415 #ifdef FEAT_CMDHIST
11421 else
11422 #endif
11425 }
11427 /*
11428 * "highlightID(name)" function
11429 */
11430 static void
11434 {
11436 }
11438 /*
11439 * "highlight_exists()" function
11440 */
11441 static void
11445 {
11447 }
11449 /*
11450 * "hostname()" function
11451 */
11452 /*ARGSUSED*/
11453 static void
11457 {
11463 }
11465 /*
11466 * iconv() function
11467 */
11468 /*ARGSUSED*/
11469 static void
11473 {
11474 #ifdef FEAT_MBYTE
11478 vimconv_T vimconv;
11479 #endif
11484 #ifdef FEAT_MBYTE
11491 /* If the encodings are equal, no conversion needed. */
11494 else
11500 #endif
11501 }
11503 /*
11504 * "indent()" function
11505 */
11506 static void
11510 {
11511 linenr_T lnum;
11516 else
11518 }
11520 /*
11521 * "index()" function
11522 */
11523 static void
11527 {
11535 {
11538 }
11541 {
11544 {
11547 /* Start at specified item. Use the cached index that list_find()
11548 * sets, so that a negative number also works. */
11555 }
11559 {
11562 }
11563 }
11564 }
11570 /*
11571 * This function is used by f_input() and f_inputdialog() functions. The third
11572 * argument to f_input() specifies the type of completion to use at the
11573 * prompt. The third argument to f_inputdialog() specifies the value to return
11574 * when the user cancels the prompt.
11575 */
11576 static void
11581 {
11594 #ifdef NO_CONSOLE_INPUT
11595 /* While starting up, there is no place to enter text. */
11598 #endif
11602 {
11603 /* Only the part of the message after the last NL is considered as
11604 * prompt for the command line */
11608 else
11609 {
11619 }
11623 {
11629 {
11645 }
11646 }
11655 /* since the user typed this, no need to wait for return */
11658 }
11660 }
11662 /*
11663 * "input()" function
11664 * Also handles inputsecret() when inputsecret is set.
11665 */
11666 static void
11670 {
11672 }
11674 /*
11675 * "inputdialog()" function
11676 */
11677 static void
11681 {
11682 #if defined(FEAT_GUI_TEXTDIALOG)
11683 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11685 {
11694 else
11700 else
11701 {
11707 else
11709 }
11711 }
11712 else
11713 #endif
11715 }
11717 /*
11718 * "inputlist()" function
11719 */
11720 static void
11724 {
11730 #ifdef NO_CONSOLE_INPUT
11731 /* While starting up, there is no place to enter text. */
11734 #endif
11736 {
11739 }
11748 {
11751 }
11753 /* Ask for choice. */
11759 }
11764 /*
11765 * "inputrestore()" function
11766 */
11767 /*ARGSUSED*/
11768 static void
11772 {
11774 {
11779 }
11781 {
11784 }
11785 }
11787 /*
11788 * "inputsave()" function
11789 */
11790 /*ARGSUSED*/
11791 static void
11795 {
11796 /* Add an entry to the stack of typehead storage. */
11798 {
11803 }
11804 else
11806 }
11808 /*
11809 * "inputsecret()" function
11810 */
11811 static void
11815 {
11821 }
11823 /*
11824 * "insert()" function
11825 */
11826 static void
11830 {
11841 {
11849 else
11850 {
11853 {
11856 }
11857 }
11859 {
11862 }
11863 }
11864 }
11866 /*
11867 * "isdirectory()" function
11868 */
11869 static void
11873 {
11875 }
11877 /*
11878 * "islocked()" function
11879 */
11880 static void
11884 {
11885 lval_T lv;
11891 FNE_CHECK_START);
11893 {
11896 else
11897 {
11899 {
11902 else
11903 {
11906 {
11907 /* Consider a variable locked when:
11908 * 1. the variable itself is locked
11909 * 2. the value of the variable is locked.
11910 * 3. the List or Dict value is locked.
11911 */
11914 }
11915 }
11916 }
11922 /* List item. */
11924 else
11925 /* Dictionary item. */
11927 }
11928 }
11931 }
11935 /*
11936 * Turn a dict into a list:
11937 * "what" == 0: list of keys
11938 * "what" == 1: list of values
11939 * "what" == 2: list of items
11940 */
11941 static void
11946 {
11957 {
11960 }
11969 {
11971 {
11981 {
11982 /* keys() */
11986 }
11988 {
11989 /* values() */
11991 }
11992 else
11993 {
11994 /* items() */
12016 }
12017 }
12018 }
12019 }
12021 /*
12022 * "items(dict)" function
12023 */
12024 static void
12028 {
12030 }
12032 /*
12033 * "join()" function
12034 */
12035 static void
12039 {
12040 garray_T ga;
12045 {
12048 }
12053 else
12059 {
12064 }
12065 else
12067 }
12069 /*
12070 * "keys()" function
12071 */
12072 static void
12076 {
12078 }
12080 /*
12081 * "last_buffer_nr()" function.
12082 */
12083 /*ARGSUSED*/
12084 static void
12088 {
12097 }
12099 /*
12100 * "len()" function
12101 */
12102 static void
12106 {
12108 {
12123 }
12124 }
12128 static void
12133 {
12134 #ifdef FEAT_LIBCALL
12138 #endif
12143 else
12149 #ifdef FEAT_LIBCALL
12150 /* The first two args must be strings, otherwise its meaningless */
12152 {
12158 else
12162 string_in,
12164 string_result,
12168 }
12169 #endif
12170 }
12172 /*
12173 * "libcall()" function
12174 */
12175 static void
12179 {
12181 }
12183 /*
12184 * "libcallnr()" function
12185 */
12186 static void
12190 {
12192 }
12194 /*
12195 * "line(string)" function
12196 */
12197 static void
12201 {
12210 }
12212 /*
12213 * "line2byte(lnum)" function
12214 */
12215 /*ARGSUSED*/
12216 static void
12220 {
12221 #ifndef FEAT_BYTEOFF
12223 #else
12224 linenr_T lnum;
12229 else
12233 #endif
12234 }
12236 /*
12237 * "lispindent(lnum)" function
12238 */
12239 static void
12243 {
12244 #ifdef FEAT_LISP
12245 pos_T pos;
12246 linenr_T lnum;
12251 {
12255 }
12256 else
12257 #endif
12259 }
12261 /*
12262 * "localtime()" function
12263 */
12264 /*ARGSUSED*/
12265 static void
12269 {
12271 }
12275 static void
12280 {
12287 garray_T ga;
12290 /* return empty string for failure */
12299 {
12303 }
12304 else
12315 {
12325 }
12326 }
12328 /*
12329 * "map()" function
12330 */
12331 static void
12335 {
12337 }
12339 /*
12340 * "maparg()" function
12341 */
12342 static void
12346 {
12348 }
12350 /*
12351 * "mapcheck()" function
12352 */
12353 static void
12357 {
12359 }
12363 static void
12368 {
12372 regmatch_T regmatch;
12385 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12391 {
12392 /* return empty list when there are no matches */
12395 }
12397 {
12400 }
12403 {
12407 }
12408 else
12416 {
12423 {
12428 }
12429 else
12430 {
12435 /* When "count" argument is there ignore matches before "start",
12436 * otherwise skip part of the string. Differs when pattern is "^"
12437 * or "\<". */
12440 else
12442 }
12448 }
12452 {
12456 {
12458 {
12460 {
12463 }
12468 }
12477 /* Advance to just after the match. */
12479 {
12482 }
12483 else
12484 {
12485 #ifdef FEAT_MBYTE
12488 #else
12490 #endif
12491 }
12492 }
12495 {
12497 {
12500 /* return list with matched string and submatches */
12502 {
12504 {
12508 }
12514 }
12515 }
12517 {
12518 /* return matched string */
12521 else
12524 }
12527 else
12528 {
12532 else
12536 }
12537 }
12539 }
12541 theend:
12544 }
12546 /*
12547 * "match()" function
12548 */
12549 static void
12553 {
12555 }
12557 /*
12558 * "matchadd()" function
12559 */
12560 static void
12564 {
12565 #ifdef FEAT_SEARCH_EXTRA
12578 {
12582 }
12586 {
12589 }
12592 #endif
12593 }
12595 /*
12596 * "matcharg()" function
12597 */
12598 static void
12602 {
12604 {
12605 #ifdef FEAT_SEARCH_EXTRA
12610 {
12612 {
12616 }
12617 else
12618 {
12621 }
12622 }
12623 #endif
12624 }
12625 }
12627 /*
12628 * "matchdelete()" function
12629 */
12630 static void
12634 {
12635 #ifdef FEAT_SEARCH_EXTRA
12638 #endif
12639 }
12641 /*
12642 * "matchend()" function
12643 */
12644 static void
12648 {
12650 }
12652 /*
12653 * "matchlist()" function
12654 */
12655 static void
12659 {
12661 }
12663 /*
12664 * "matchstr()" function
12665 */
12666 static void
12670 {
12672 }
12676 static void
12681 {
12687 {
12693 {
12696 {
12699 {
12706 }
12707 }
12708 }
12709 }
12711 {
12719 {
12722 {
12724 {
12728 {
12731 }
12734 }
12735 }
12736 }
12737 }
12738 else
12741 }
12743 /*
12744 * "max()" function
12745 */
12746 static void
12750 {
12752 }
12754 /*
12755 * "min()" function
12756 */
12757 static void
12761 {
12763 }
12767 /*
12768 * Create the directory in which "dir" is located, and higher levels when
12769 * needed.
12770 */
12771 static int
12775 {
12780 /* Get end of directory name in "dir".
12781 * We're done when it's "/" or "c:/". */
12786 /* If the directory exists we're done. Otherwise: create it.*/
12796 }
12798 #ifdef vim_mkdir
12799 /*
12800 * "mkdir()" function
12801 */
12802 static void
12806 {
12817 {
12822 }
12824 }
12825 #endif
12827 /*
12828 * "mode()" function
12829 */
12830 /*ARGSUSED*/
12831 static void
12835 {
12838 #ifdef FEAT_VISUAL
12840 {
12843 else
12845 }
12846 else
12847 #endif
12851 {
12854 else
12856 }
12859 else
12865 }
12867 /*
12868 * "nextnonblank()" function
12869 */
12870 static void
12874 {
12875 linenr_T lnum;
12878 {
12880 {
12883 }
12886 }
12888 }
12890 /*
12891 * "nr2char()" function
12892 */
12893 static void
12897 {
12900 #ifdef FEAT_MBYTE
12903 else
12904 #endif
12905 {
12908 }
12911 }
12913 /*
12914 * "pathshorten()" function
12915 */
12916 static void
12920 {
12927 else
12928 {
12933 }
12934 }
12936 /*
12937 * "prevnonblank()" function
12938 */
12939 static void
12943 {
12944 linenr_T lnum;
12949 else
12953 }
12955 #ifdef HAVE_STDARG_H
12956 /* This dummy va_list is here because:
12957 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12958 * - locally in the function results in a "used before set" warning
12959 * - using va_start() to initialize it gives "function with fixed args" error */
12961 #endif
12963 /*
12964 * "printf()" function
12965 */
12966 static void
12970 {
12974 {
12981 /* Get the required length, allocate the buffer and do it for real. */
12986 {
12989 {
12992 }
12993 }
12995 }
12996 #endif
12997 }
12999 /*
13000 * "pumvisible()" function
13001 */
13002 /*ARGSUSED*/
13003 static void
13007 {
13009 #ifdef FEAT_INS_EXPAND
13012 #endif
13013 }
13015 /*
13016 * "range()" function
13017 */
13018 static void
13022 {
13031 {
13034 }
13035 else
13036 {
13040 }
13049 else
13050 {
13056 }
13057 }
13059 /*
13060 * "readfile()" function
13061 */
13062 static void
13066 {
13086 {
13091 }
13096 /* Always open the file in binary mode, library functions have a mind of
13097 * their own about CR-LF conversion. */
13100 {
13103 }
13107 {
13112 {
13114 {
13115 /* Only when in binary mode add an empty list item when the
13116 * last line ends in a '\n'. */
13120 /* Found end-of-line or end-of-file: add a text line to the
13121 * list. */
13130 else
13131 {
13134 {
13140 }
13141 }
13146 {
13149 }
13159 }
13162 }
13167 {
13168 /* "buf" is full, need to move text to an allocated buffer */
13170 {
13173 }
13174 else
13175 {
13178 {
13184 }
13185 }
13187 }
13188 else
13189 {
13192 }
13193 }
13195 /*
13196 * For a negative line count use only the lines at the end of the file,
13197 * free the rest.
13198 */
13201 {
13204 }
13208 }
13210 #if defined(FEAT_RELTIME)
13213 /*
13214 * Convert a List to proftime_T.
13215 * Return FAIL when there is something wrong.
13216 */
13217 static int
13221 {
13230 # ifdef WIN3264
13233 # else
13236 # endif
13238 }
13241 /*
13242 * "reltime()" function
13243 */
13244 static void
13248 {
13249 #ifdef FEAT_RELTIME
13250 proftime_T res;
13251 proftime_T start;
13254 {
13255 /* No arguments: get current time. */
13257 }
13259 {
13263 }
13264 else
13265 {
13266 /* Two arguments: compute the difference. */
13271 }
13274 {
13277 # ifdef WIN3264
13280 # else
13283 # endif
13286 }
13287 #endif
13288 }
13290 /*
13291 * "reltimestr()" function
13292 */
13293 static void
13297 {
13298 #ifdef FEAT_RELTIME
13299 proftime_T tm;
13300 #endif
13304 #ifdef FEAT_RELTIME
13307 #endif
13308 }
13310 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13314 static void
13316 {
13318 # ifdef FEAT_GUI
13320 # endif
13321 )
13322 {
13326 }
13327 }
13329 static int
13331 {
13334 {
13337 }
13339 }
13340 #endif
13342 #ifdef FEAT_CLIENTSERVER
13345 static void
13350 {
13355 # ifdef WIN32
13356 HWND w;
13357 # elif defined(FEAT_X11)
13358 Window w;
13359 # elif defined(MAC_CLIENTSERVER)
13361 # endif
13366 # ifdef FEAT_X11
13369 # endif
13375 # ifdef WIN32
13377 # elif defined(FEAT_X11)
13380 # elif defined(MAC_CLIENTSERVER)
13382 # endif
13383 {
13386 else
13389 }
13394 {
13395 dictitem_T v;
13406 }
13407 }
13408 #endif
13410 /*
13411 * "remote_expr()" function
13412 */
13413 /*ARGSUSED*/
13414 static void
13418 {
13421 #ifdef FEAT_CLIENTSERVER
13423 #endif
13424 }
13426 /*
13427 * "remote_foreground()" function
13428 */
13429 /*ARGSUSED*/
13430 static void
13434 {
13436 #ifdef FEAT_CLIENTSERVER
13437 # ifdef WIN32
13438 /* On Win32 it's done in this application. */
13439 {
13444 }
13445 # elif defined(FEAT_X11) || defined(MAC_CLIENTSERVER)
13446 /* Send a foreground() expression to the server. */
13452 # endif
13453 #endif
13454 }
13456 /*ARGSUSED*/
13457 static void
13461 {
13462 #ifdef FEAT_CLIENTSERVER
13463 dictitem_T v;
13465 # ifdef WIN32
13467 # endif
13471 {
13474 }
13477 {
13480 }
13481 # ifdef WIN32
13485 else
13486 {
13489 }
13490 # elif defined(FEAT_X11)
13497 # elif defined(MAC_CLIENTSERVER)
13499 # endif
13502 {
13511 }
13512 #else
13514 #endif
13515 }
13517 /*ARGSUSED*/
13518 static void
13522 {
13525 #ifdef FEAT_CLIENTSERVER
13529 {
13530 # ifdef WIN32
13531 /* The server's HWND is encoded in the 'id' parameter */
13538 # elif defined(FEAT_X11)
13541 # elif defined(MAC_CLIENTSERVER)
13543 # endif
13545 }
13546 #endif
13549 }
13551 /*
13552 * "remote_send()" function
13553 */
13554 /*ARGSUSED*/
13555 static void
13559 {
13562 #ifdef FEAT_CLIENTSERVER
13564 #endif
13565 }
13567 /*
13568 * "remove()" function
13569 */
13570 static void
13574 {
13586 {
13591 {
13594 {
13598 else
13599 {
13603 }
13604 }
13605 }
13606 }
13611 {
13619 else
13620 {
13622 {
13623 /* Remove one item, return its value. */
13627 }
13628 else
13629 {
13630 /* Remove range of items, return list with values. */
13636 else
13637 {
13641 {
13645 }
13648 else
13649 {
13652 {
13659 }
13660 }
13661 }
13662 }
13663 }
13664 }
13665 }
13667 /*
13668 * "rename({from}, {to})" function
13669 */
13670 static void
13674 {
13679 else
13682 }
13684 /*
13685 * "repeat()" function
13686 */
13687 /*ARGSUSED*/
13688 static void
13692 {
13702 {
13708 }
13709 else
13710 {
13722 {
13726 }
13729 }
13730 }
13732 /*
13733 * "resolve()" function
13734 */
13735 static void
13739 {
13743 #ifdef FEAT_SHORTCUT
13744 {
13750 else
13752 }
13753 #else
13754 # ifdef HAVE_READLINK
13755 {
13777 {
13778 /* Separate the first path component in "p", and keep the
13779 * remainder (beginning with the path separator). */
13782 }
13785 {
13787 {
13794 {
13800 }
13802 /* Ensure that the result will have a trailing path separator
13803 * if the argument has one. */
13807 /* Separate the first path component in the link value and
13808 * concatenate the remainders. */
13811 {
13814 else
13815 {
13818 {
13821 }
13822 }
13824 }
13828 {
13829 /* Ignore trailing path separator. */
13832 }
13834 {
13835 /* symlink is relative to directory of argument */
13838 {
13843 }
13844 }
13845 else
13846 {
13849 }
13850 }
13855 /* Append the first path component of "remain" to "p". */
13860 {
13864 }
13865 /* Shorten "remain". */
13868 else
13869 {
13872 }
13873 }
13875 /* If the result is a relative path name, make it explicitly relative to
13876 * the current directory if and only if the argument had this form. */
13878 {
13887 {
13888 /* Prepend "./". */
13891 {
13894 }
13895 }
13897 {
13898 /* Strip leading "./". */
13904 }
13905 }
13907 /* Ensure that the result will have no trailing path separator
13908 * if the argument had none. But keep "/" or "//". */
13910 {
13914 }
13917 }
13918 # else
13920 # endif
13921 #endif
13925 #ifdef HAVE_READLINK
13926 fail:
13927 #endif
13929 }
13931 /*
13932 * "reverse({list})" function
13933 */
13934 static void
13938 {
13947 {
13952 {
13956 }
13960 }
13961 }
13973 /*
13974 * Get flags for a search function.
13975 * Possibly sets "p_ws".
13976 * Returns BACKWARD, FORWARD or zero (for an error).
13977 */
13978 static int
13982 {
13989 {
13994 {
13996 {
14003 {
14011 }
14013 {
14016 }
14017 else
14019 }
14023 }
14024 }
14026 }
14028 /*
14029 * Shared by search() and searchpos() functions
14030 */
14031 static int
14036 {
14039 pos_T pos;
14040 pos_T save_cursor;
14045 proftime_T tm;
14046 #ifdef FEAT_RELTIME
14048 #endif
14062 /* Optional arguments: line number to stop searching and timeout. */
14064 {
14068 #ifdef FEAT_RELTIME
14070 {
14074 }
14075 #endif
14076 }
14078 #ifdef FEAT_RELTIME
14079 /* Set the time limit, if there is one. */
14081 #endif
14083 /*
14084 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14085 * Check to make sure only those flags are set.
14086 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14087 * flags cannot be set. Check for that condition also.
14088 */
14091 {
14094 }
14100 {
14103 else
14109 {
14110 /* Store the match cursor position */
14113 }
14114 /* "/$" will put the cursor after the end of the line, may need to
14115 * correct that here */
14117 }
14119 /* If 'n' flag is used: restore cursor position. */
14122 else
14124 theend:
14128 }
14130 /*
14131 * "search()" function
14132 */
14133 static void
14137 {
14141 }
14143 /*
14144 * "searchdecl()" function
14145 */
14146 static void
14150 {
14160 {
14164 }
14168 }
14170 /*
14171 * Used by searchpair() and searchpairpos()
14172 */
14173 static int
14177 {
14190 /* Get the three pattern arguments: start, middle, end. */
14197 /* Handle the optional fourth argument: flags */
14202 /* Don't accept SP_END or SP_SUBPAT.
14203 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14204 */
14207 {
14210 }
14212 /* Using 'r' implies 'W', otherwise it doesn't work. */
14216 /* Optional fifth argument: skip expression */
14220 else
14221 {
14224 {
14228 #ifdef FEAT_RELTIME
14230 {
14234 }
14235 #endif
14236 }
14237 }
14244 theend:
14248 }
14250 /*
14251 * "searchpair()" function
14252 */
14253 static void
14257 {
14259 }
14261 /*
14262 * "searchpairpos()" function
14263 */
14264 static void
14268 {
14269 pos_T match_pos;
14279 {
14282 }
14286 }
14288 /*
14289 * Search for a start/middle/end thing.
14290 * Used by searchpair(), see its documentation for the details.
14291 * Returns 0 or -1 for no match,
14292 */
14293 long
14305 {
14309 pos_T pos;
14310 pos_T firstpos;
14311 pos_T foundpos;
14312 pos_T save_cursor;
14313 pos_T save_pos;
14319 proftime_T tm;
14321 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14325 #ifdef FEAT_RELTIME
14326 /* Set the time limit, if there is one. */
14328 #endif
14330 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14331 * start/middle/end (pat3, for the top pair). */
14339 else
14351 {
14355 /* didn't find it or found the first match again: FAIL */
14361 {
14362 /* Found the same position again. Can happen with a pattern that
14363 * has "\zs" at the end and searching backwards. Advance one
14364 * character and try again. */
14367 else
14369 }
14372 /* clear the start flag to avoid getting stuck here */
14375 /* If the skip pattern matches, ignore this match. */
14377 {
14383 {
14384 /* Evaluating {skip} caused an error, break here. */
14388 }
14391 }
14394 {
14395 /* Found end when searching backwards or start when searching
14396 * forward: nested pair. */
14399 }
14400 else
14401 {
14402 /* Found end when searching forward or start when searching
14403 * backward: end of (nested) pair; or found middle in outer pair. */
14406 }
14409 {
14410 /* Found the match: return matchcount or line number. */
14413 else
14421 }
14422 }
14425 {
14426 /* Store the match cursor position */
14429 }
14431 /* If 'n' flag is used or search failed: restore cursor position. */
14435 theend:
14441 }
14443 /*
14444 * "searchpos()" function
14445 */
14446 static void
14450 {
14451 pos_T match_pos;
14464 {
14467 }
14473 }
14476 /*ARGSUSED*/
14477 static void
14481 {
14482 #ifdef FEAT_CLIENTSERVER
14492 # ifdef FEAT_X11
14495 # endif
14498 {
14501 }
14503 #else
14505 #endif
14506 }
14508 /*ARGSUSED*/
14509 static void
14513 {
14516 #ifdef FEAT_CLIENTSERVER
14517 # if defined(WIN32) || defined(MAC_CLIENTSERVER)
14519 # elif defined(FEAT_X11)
14523 # endif
14524 #endif
14527 }
14529 /*
14530 * "setbufvar()" function
14531 */
14532 /*ARGSUSED*/
14533 static void
14537 {
14539 aco_save_T aco;
14554 {
14555 /* set curbuf to be our buf, temporarily */
14559 {
14569 }
14570 else
14571 {
14574 {
14579 }
14580 }
14582 /* reset notion of buffer */
14584 }
14585 }
14587 /*
14588 * "setcmdpos()" function
14589 */
14590 static void
14594 {
14599 }
14601 /*
14602 * "setline()" function
14603 */
14604 static void
14608 {
14609 linenr_T lnum;
14618 {
14621 }
14622 else
14627 {
14629 {
14630 /* list argument, get next string */
14635 }
14641 {
14642 /* existing line, replace it */
14644 {
14649 }
14650 }
14652 {
14653 /* lnum is one past the last line, append the line */
14657 }
14662 }
14666 }
14668 /*
14669 * Used by "setqflist()" and "setloclist()" functions
14670 */
14671 /*ARGSUSED*/
14672 static void
14678 {
14679 #ifdef FEAT_QUICKFIX
14682 #endif
14686 #ifdef FEAT_QUICKFIX
14689 else
14690 {
14694 {
14700 }
14704 }
14705 #endif
14706 }
14708 /*
14709 * "setloclist()" function
14710 */
14711 /*ARGSUSED*/
14712 static void
14716 {
14724 }
14726 /*
14727 * "setmatches()" function
14728 */
14729 static void
14733 {
14734 #ifdef FEAT_SEARCH_EXTRA
14741 {
14744 }
14746 {
14748 /* To some extent make sure that we are dealing with a list from
14749 * "getmatches()". */
14752 {
14755 {
14758 }
14763 {
14766 }
14768 }
14773 {
14780 }
14782 }
14783 #endif
14784 }
14786 /*
14787 * "setpos()" function
14788 */
14789 /*ARGSUSED*/
14790 static void
14794 {
14795 pos_T pos;
14801 {
14803 {
14806 {
14808 {
14811 }
14812 else
14814 }
14817 else
14819 }
14820 }
14821 }
14823 /*
14824 * "setqflist()" function
14825 */
14826 /*ARGSUSED*/
14827 static void
14831 {
14833 }
14835 /*
14836 * "setreg()" function
14837 */
14838 static void
14842 {
14848 char_u yank_type;
14867 {
14873 {
14883 #ifdef FEAT_VISUAL
14887 {
14891 }
14893 #endif
14894 }
14895 }
14902 }
14904 /*
14905 * "settabwinvar()" function
14906 */
14907 static void
14911 {
14913 }
14915 /*
14916 * "setwinvar()" function
14917 */
14918 static void
14922 {
14924 }
14926 /*
14927 * "setwinvar()" and "settabwinvar()" functions
14928 */
14929 static void
14934 {
14936 #ifdef FEAT_WINDOWS
14939 #endif
14950 #ifdef FEAT_WINDOWS
14953 else
14955 #endif
14961 {
14962 #ifdef FEAT_WINDOWS
14963 /* set curwin to be our win, temporarily */
14971 #endif
14974 {
14984 }
14985 else
14986 {
14989 {
14994 }
14995 }
14997 #ifdef FEAT_WINDOWS
14998 /* Restore current tabpage and window, if still valid (autocomands can
14999 * make them invalid). */
15003 {
15006 }
15007 #endif
15008 }
15009 }
15011 /*
15012 * "shellescape({string})" function
15013 */
15014 static void
15018 {
15021 }
15023 /*
15024 * "simplify()" function
15025 */
15026 static void
15030 {
15037 }
15039 static int
15040 #ifdef __BORLANDC__
15041 _RTLENTRYF
15042 #endif
15044 static int
15045 #ifdef __BORLANDC__
15046 _RTLENTRYF
15047 #endif
15053 #define ITEM_COMPARE_FAIL 999
15055 /*
15056 * Compare functions for f_sort() below.
15057 */
15058 static int
15059 #ifdef __BORLANDC__
15060 _RTLENTRYF
15061 #endif
15065 {
15080 else
15085 }
15087 static int
15088 #ifdef __BORLANDC__
15089 _RTLENTRYF
15090 #endif
15094 {
15096 typval_T rettv;
15100 /* shortcut after failure in previous call; compare all items equal */
15104 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15105 * in the copy without changing the original list items. */
15117 else
15118 /* return value has wrong type */
15124 }
15126 /*
15127 * "sort({list})" function
15128 */
15129 static void
15133 {
15143 else
15144 {
15159 {
15162 else
15163 {
15171 else
15173 }
15174 }
15176 /* Make an array with each entry pointing to an item in the List. */
15185 /* test the compare function */
15190 else
15191 {
15192 /* Sort the array with item pointers. */
15197 {
15198 /* Clear the List and append the items in the sorted order. */
15203 }
15204 }
15207 }
15208 }
15210 /*
15211 * "soundfold({word})" function
15212 */
15213 static void
15217 {
15222 #ifdef FEAT_SPELL
15224 #else
15226 #endif
15227 }
15229 /*
15230 * "spellbadword()" function
15231 */
15232 /* ARGSUSED */
15233 static void
15237 {
15245 #ifdef FEAT_SPELL
15247 {
15248 /* Find the start and length of the badly spelled word. */
15252 }
15254 {
15259 {
15260 /* Check the argument for spelling. */
15262 {
15265 {
15268 }
15270 }
15271 }
15272 }
15273 #endif
15282 }
15284 /*
15285 * "spellsuggest()" function
15286 */
15287 /*ARGSUSED*/
15288 static void
15292 {
15293 #ifdef FEAT_SPELL
15297 garray_T ga;
15301 #endif
15306 #ifdef FEAT_SPELL
15308 {
15311 {
15316 {
15320 }
15321 }
15322 else
15328 {
15334 else
15335 {
15340 }
15341 }
15343 }
15344 #endif
15345 }
15347 static void
15351 {
15355 regmatch_T regmatch;
15363 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15369 {
15375 }
15386 {
15389 {
15392 else
15396 else
15400 {
15404 }
15407 /* Advance to just after the match. */
15410 else
15411 {
15412 /* Don't get stuck at the same match. */
15413 #ifdef FEAT_MBYTE
15415 #else
15417 #endif
15418 }
15420 }
15423 }
15426 }
15428 /*
15429 * "str2nr()" function
15430 */
15431 static void
15435 {
15441 {
15444 {
15447 }
15448 }
15453 }
15455 #ifdef HAVE_STRFTIME
15456 /*
15457 * "strftime({format}[, {time}])" function
15458 */
15459 static void
15463 {
15474 else
15477 /* MSVC returns NULL for an invalid value of seconds. */
15480 else
15481 {
15482 # ifdef FEAT_MBYTE
15483 vimconv_T conv;
15491 # endif
15495 else
15498 # ifdef FEAT_MBYTE
15504 else
15505 # endif
15508 # ifdef FEAT_MBYTE
15509 /* Release conversion descriptors */
15512 # endif
15513 }
15514 }
15515 #endif
15517 /*
15518 * "stridx()" function
15519 */
15520 static void
15524 {
15539 {
15547 }
15552 }
15554 /*
15555 * "string()" function
15556 */
15557 static void
15561 {
15567 /* Make a copy if we have a value but it's not in allocate memory. */
15570 }
15572 /*
15573 * "strlen()" function
15574 */
15575 static void
15579 {
15582 }
15584 /*
15585 * "strpart()" function
15586 */
15587 static void
15591 {
15606 else
15609 /*
15610 * Only return the overlap between the specified part and the actual
15611 * string.
15612 */
15614 {
15617 }
15627 }
15629 /*
15630 * "strridx()" function
15631 */
15632 static void
15636 {
15653 {
15654 /* Third argument: upper limit for index */
15658 }
15659 else
15663 {
15664 /* Empty string matches past the end. */
15666 }
15667 else
15668 {
15670 {
15675 }
15676 }
15680 else
15682 }
15684 /*
15685 * "strtrans()" function
15686 */
15687 static void
15691 {
15694 }
15696 /*
15697 * "submatch()" function
15698 */
15699 static void
15703 {
15707 }
15709 /*
15710 * "substitute()" function
15711 */
15712 static void
15716 {
15729 else
15731 }
15733 /*
15734 * "synID(lnum, col, trans)" function
15735 */
15736 /*ARGSUSED*/
15737 static void
15741 {
15743 #ifdef FEAT_SYN_HL
15756 #endif
15759 }
15761 /*
15762 * "synIDattr(id, what [, mode])" function
15763 */
15764 /*ARGSUSED*/
15765 static void
15769 {
15771 #ifdef FEAT_SYN_HL
15781 {
15785 #ifdef FEAT_GUI
15787 #endif
15788 )
15790 }
15791 else
15792 {
15793 #ifdef FEAT_GUI
15796 else
15797 #endif
15800 else
15802 }
15806 {
15839 /* underline */
15841 else
15842 /* undercurl */
15845 }
15849 #endif
15852 }
15854 /*
15855 * "synIDtrans(id)" function
15856 */
15857 /*ARGSUSED*/
15858 static void
15862 {
15865 #ifdef FEAT_SYN_HL
15870 else
15871 #endif
15875 }
15877 /*
15878 * "synstack(lnum, col)" function
15879 */
15880 /*ARGSUSED*/
15881 static void
15885 {
15886 #ifdef FEAT_SYN_HL
15891 #endif
15896 #ifdef FEAT_SYN_HL
15903 {
15906 {
15912 }
15913 }
15914 #endif
15915 }
15917 /*
15918 * "system()" function
15919 */
15920 static void
15924 {
15936 {
15937 /*
15938 * Write the string to a temp file, to be used for input of the shell
15939 * command.
15940 */
15942 {
15945 }
15949 {
15952 }
15955 {
15958 }
15964 {
15967 }
15968 }
15973 #ifdef USE_CR
15974 /* translate <CR> into <NL> */
15976 {
15980 {
15983 }
15984 }
15985 #else
15986 # ifdef USE_CRNL
15987 /* translate <CR><NL> into <NL> */
15989 {
15994 {
15998 }
16000 }
16001 # endif
16002 #endif
16004 done:
16006 {
16009 }
16012 }
16014 /*
16015 * "tabpagebuflist()" function
16016 */
16017 /* ARGSUSED */
16018 static void
16022 {
16023 #ifndef FEAT_WINDOWS
16025 #else
16031 else
16032 {
16036 }
16039 else
16040 {
16043 else
16044 {
16049 }
16050 }
16051 #endif
16052 }
16055 /*
16056 * "tabpagenr()" function
16057 */
16058 /* ARGSUSED */
16059 static void
16063 {
16065 #ifdef FEAT_WINDOWS
16069 {
16073 {
16076 else
16078 }
16079 }
16080 else
16082 #endif
16084 }
16087 #ifdef FEAT_WINDOWS
16090 /*
16091 * Common code for tabpagewinnr() and winnr().
16092 */
16093 static int
16097 {
16105 {
16112 {
16116 }
16117 else
16118 {
16121 }
16122 }
16127 {
16129 {
16130 /* didn't find it in this tabpage */
16133 }
16135 }
16137 }
16138 #endif
16140 /*
16141 * "tabpagewinnr()" function
16142 */
16143 /* ARGSUSED */
16144 static void
16148 {
16150 #ifdef FEAT_WINDOWS
16156 else
16158 #endif
16160 }
16163 /*
16164 * "tagfiles()" function
16165 */
16166 /*ARGSUSED*/
16167 static void
16171 {
16173 tagname_T tn;
16177 {
16180 }
16187 }
16189 /*
16190 * "taglist()" function
16191 */
16192 static void
16196 {
16207 }
16209 /*
16210 * "tempname()" function
16211 */
16212 /*ARGSUSED*/
16213 static void
16217 {
16223 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16224 * names. Skip 'I' and 'O', they are used for shell redirection. */
16225 do
16226 {
16231 else
16232 {
16233 #ifdef EBCDIC
16238 else
16239 #endif
16241 }
16243 }
16245 /*
16246 * "test(list)" function: Just checking the walls...
16247 */
16248 /*ARGSUSED*/
16249 static void
16253 {
16254 /* Used for unit testing. Change the code below to your liking. */
16255 #if 0
16274 #endif
16275 }
16277 /*
16278 * "tolower(string)" function
16279 */
16280 static void
16284 {
16293 {
16294 #ifdef FEAT_MBYTE
16298 {
16304 /* TODO: reallocate string when byte count changes. */
16308 }
16311 else
16312 #endif
16313 {
16316 }
16317 }
16318 }
16320 /*
16321 * "toupper(string)" function
16322 */
16323 static void
16327 {
16330 }
16332 /*
16333 * "tr(string, fromstr, tostr)" function
16334 */
16335 static void
16339 {
16344 #ifdef FEAT_MBYTE
16352 #endif
16355 garray_T ga;
16361 /* Default return value: empty string. */
16368 #ifdef FEAT_MBYTE
16370 #endif
16371 /* not multi-byte: fromstr and tostr must be the same length */
16373 {
16374 #ifdef FEAT_MBYTE
16375 error:
16376 #endif
16380 }
16382 /* fromstr and tostr have to contain the same number of chars */
16384 {
16385 #ifdef FEAT_MBYTE
16387 {
16393 {
16396 {
16398 {
16401 {
16405 }
16406 }
16410 }
16412 }
16415 {
16416 /* Check that fromstr and tostr have the same number of
16417 * (multi-byte) characters. Done only once when a character
16418 * of instr doesn't appear in fromstr. */
16421 {
16424 }
16427 }
16434 }
16435 else
16436 #endif
16437 {
16438 /* When not using multi-byte chars we can do it faster. */
16442 else
16445 }
16446 }
16448 /* add a terminating NUL */
16453 }
16455 /*
16456 * "type(expr)" function
16457 */
16458 static void
16462 {
16466 {
16473 }
16475 }
16477 /*
16478 * "values(dict)" function
16479 */
16480 static void
16484 {
16486 }
16488 /*
16489 * "virtcol(string)" function
16490 */
16491 static void
16495 {
16503 {
16506 }
16509 }
16511 /*
16512 * "visualmode()" function
16513 */
16514 /*ARGSUSED*/
16515 static void
16519 {
16520 #ifdef FEAT_VISUAL
16528 /* A non-zero number or non-empty string argument: reset mode. */
16534 #else
16536 #endif
16537 }
16539 /*
16540 * "winbufnr(nr)" function
16541 */
16542 static void
16546 {
16552 else
16554 }
16556 /*
16557 * "wincol()" function
16558 */
16559 /*ARGSUSED*/
16560 static void
16564 {
16567 }
16569 /*
16570 * "winheight(nr)" function
16571 */
16572 static void
16576 {
16582 else
16584 }
16586 /*
16587 * "winline()" function
16588 */
16589 /*ARGSUSED*/
16590 static void
16594 {
16597 }
16599 /*
16600 * "winnr()" function
16601 */
16602 /* ARGSUSED */
16603 static void
16607 {
16610 #ifdef FEAT_WINDOWS
16612 #endif
16614 }
16616 /*
16617 * "winrestcmd()" function
16618 */
16619 /* ARGSUSED */
16620 static void
16624 {
16625 #ifdef FEAT_WINDOWS
16628 garray_T ga;
16633 {
16636 # ifdef FEAT_VERTSPLIT
16639 # endif
16641 }
16645 #else
16647 #endif
16649 }
16651 /*
16652 * "winrestview()" function
16653 */
16654 /* ARGSUSED */
16655 static void
16659 {
16665 else
16666 {
16669 #ifdef FEAT_VIRTUALEDIT
16671 #endif
16676 #ifdef FEAT_DIFF
16678 #endif
16691 #ifdef FEAT_DIFF
16693 #endif
16694 }
16695 }
16697 /*
16698 * "winsaveview()" function
16699 */
16700 /* ARGSUSED */
16701 static void
16705 {
16717 #ifdef FEAT_VIRTUALEDIT
16719 #endif
16724 #ifdef FEAT_DIFF
16726 #endif
16729 }
16731 /*
16732 * "winwidth(nr)" function
16733 */
16734 static void
16738 {
16744 else
16745 #ifdef FEAT_VERTSPLIT
16747 #else
16749 #endif
16750 }
16752 /*
16753 * "writefile()" function
16754 */
16755 static void
16759 {
16772 {
16775 }
16783 /* Always open the file in binary mode, library functions have a mind of
16784 * their own about CR-LF conversion. */
16787 {
16790 }
16791 else
16792 {
16795 {
16797 {
16800 else
16803 {
16806 }
16807 }
16810 {
16813 }
16815 {
16818 }
16819 }
16821 }
16824 }
16826 /*
16827 * Translate a String variable into a position.
16828 * Returns NULL when there is an error.
16829 */
16835 {
16840 /* Argument can be [lnum, col, coladd]. */
16842 {
16852 /* Get the line number */
16857 /* Get the column number */
16863 /* We accept "$" for the column number: last column. */
16870 /* Accept a position up to the NUL after the line. */
16875 #ifdef FEAT_VIRTUALEDIT
16876 /* Get the virtual offset. Defaults to zero. */
16880 #endif
16883 }
16891 {
16896 }
16898 #ifdef FEAT_VIRTUALEDIT
16900 #endif
16903 {
16906 {
16910 }
16912 {
16916 }
16917 }
16919 {
16921 {
16924 }
16925 else
16926 {
16929 }
16931 }
16933 }
16935 /*
16936 * Convert list in "arg" into a position and optional file number.
16937 * When "fnump" is NULL there is no file number, only 3 items.
16938 * Note that the column is passed on as-is, the caller may want to decrement
16939 * it to use 1 for the first column.
16940 * Return FAIL when conversion is not possible, doesn't check the position for
16941 * validity.
16942 */
16943 static int
16948 {
16953 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16954 * when "fnump" isn't NULL and "coladd" is optional. */
16962 {
16969 }
16981 #ifdef FEAT_VIRTUALEDIT
16985 else
16987 #endif
16990 }
16992 /*
16993 * Get the length of an environment variable name.
16994 * Advance "arg" to the first character after the name.
16995 * Return 0 for error.
16996 */
16997 static int
17000 {
17005 ;
17012 }
17014 /*
17015 * Get the length of the name of a function or internal variable.
17016 * "arg" is advanced to the first non-white character after the name.
17017 * Return 0 if something is wrong.
17018 */
17019 static int
17022 {
17026 /* Find the end of the name. */
17028 ;
17036 }
17038 /*
17039 * Get the length of the name of a variable or function.
17040 * Only the name is recognized, does not handle ".key" or "[idx]".
17041 * "arg" is advanced to the first non-white character after the name.
17042 * Return -1 if curly braces expansion failed.
17043 * Return 0 if something else is wrong.
17044 * If the name contains 'magic' {}'s, expand them and return the
17045 * expanded name in an allocated string via 'alias' - caller must free.
17046 */
17047 static int
17053 {
17063 {
17064 /* hard coded <SNR>, already translated */
17067 }
17070 {
17071 /* literal "<SID>", "s:" or "<SNR>" */
17073 }
17075 /*
17076 * Find the end of the name; check for {} construction.
17077 */
17081 {
17085 {
17089 }
17091 /*
17092 * Include any <SID> etc in the expanded string:
17093 * Thus the -len here.
17094 */
17101 }
17108 }
17110 /*
17111 * Find the end of a variable or function name, taking care of magic braces.
17112 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17113 * start and end of the first magic braces item.
17114 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17115 * Return a pointer to just after the name. Equal to "arg" if there is no
17116 * valid name.
17117 */
17124 {
17130 {
17133 }
17135 /* Quick check for valid starting character. */
17145 {
17147 {
17148 /* skip over 'string' to avoid counting [ and ] inside it. */
17150 ;
17153 }
17155 {
17156 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17162 }
17165 {
17170 }
17173 {
17175 {
17176 mb_nest++;
17179 }
17181 {
17182 mb_nest--;
17185 }
17186 }
17187 }
17190 }
17192 /*
17193 * Expands out the 'magic' {}'s in a variable/function name.
17194 * Note that this can call itself recursively, to deal with
17195 * constructs like foo{bar}{baz}{bam}
17196 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17197 * "in_start" ^
17198 * "expr_start" ^
17199 * "expr_end" ^
17200 * "in_end" ^
17201 *
17202 * Returns a new allocated string, which the caller must free.
17203 * Returns NULL for failure.
17204 */
17211 {
17212 char_u c1;
17226 {
17230 {
17234 }
17235 }
17243 {
17246 {
17247 /* Further expansion! */
17252 }
17253 }
17256 }
17258 /*
17259 * Return TRUE if character "c" can be used in a variable or function name.
17260 * Does not include '{' or '}' for magic braces.
17261 */
17262 static int
17265 {
17267 }
17269 /*
17270 * Return TRUE if character "c" can be used as the first character in a
17271 * variable or function name (excluding '{' and '}').
17272 */
17273 static int
17276 {
17278 }
17280 /*
17281 * Set number v: variable to "val".
17282 */
17283 void
17287 {
17289 }
17291 /*
17292 * Get number v: variable value.
17293 */
17294 long
17297 {
17299 }
17301 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17302 /*
17303 * Get string v: variable value. Uses a static buffer, can only be used once.
17304 */
17305 char_u *
17308 {
17310 }
17311 #endif
17313 /*
17314 * Set v:count, v:count1 and v:prevcount.
17315 */
17316 void
17320 {
17324 }
17326 /*
17327 * Set string v: variable to a copy of "val".
17328 */
17329 void
17334 {
17335 /* Need to do this (at least) once, since we can't initialize a union.
17336 * Will always be invoked when "v:progname" is set. */
17344 else
17346 }
17348 /*
17349 * Set v:register if needed.
17350 */
17351 void
17354 {
17355 char_u regname;
17359 else
17361 /* Avoid free/alloc when the value is already right. */
17364 }
17366 /*
17367 * Get or set v:exception. If "oldval" == NULL, return the current value.
17368 * Otherwise, restore the value to "oldval" and return NULL.
17369 * Must always be called in pairs to save and restore v:exception! Does not
17370 * take care of memory allocations.
17371 */
17372 char_u *
17375 {
17381 }
17383 /*
17384 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17385 * Otherwise, restore the value to "oldval" and return NULL.
17386 * Must always be called in pairs to save and restore v:throwpoint! Does not
17387 * take care of memory allocations.
17388 */
17389 char_u *
17392 {
17398 }
17400 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17401 /*
17402 * Set v:cmdarg.
17403 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17404 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17405 * Must always be called in pairs!
17406 */
17407 char_u *
17411 {
17418 {
17422 }
17428 else
17436 # ifdef FEAT_MBYTE
17441 # endif
17451 else
17460 # ifdef FEAT_MBYTE
17467 # endif
17470 }
17471 #endif
17473 /*
17474 * Get the value of internal variable "name".
17475 * Return OK or FAIL.
17476 */
17477 static int
17483 {
17486 typval_T atv;
17490 /* truncate the name, so that we can use strcmp() */
17494 /*
17495 * Check for "b:changedtick".
17496 */
17498 {
17502 }
17504 /*
17505 * Check for user-defined variables.
17506 */
17507 else
17508 {
17512 }
17515 {
17519 }
17526 }
17528 /*
17529 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17530 * Also handle function call with Funcref variable: func(expr)
17531 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17532 */
17533 static int
17539 {
17544 typval_T functv;
17551 {
17553 {
17554 /* need to copy the funcref so that we can clear rettv */
17558 /* Invoke the function. Recursive! */
17564 /* Clear the funcref afterwards, so that deleting it while
17565 * evaluating the arguments is possible (see test55). */
17568 /* Stop the expression evaluation when immediately aborting on
17569 * error, or when an interrupt occurred or an exception was thrown
17570 * but not caught. */
17572 {
17576 }
17579 }
17581 {
17584 {
17588 }
17589 else
17592 {
17595 }
17596 }
17597 }
17600 }
17602 /*
17603 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17604 * value).
17605 */
17608 {
17610 }
17612 /*
17613 * Allocate memory for a variable type-value, and assign a string to it.
17614 * The string "s" must have been allocated, it is consumed.
17615 * Return NULL for out of memory, the variable otherwise.
17616 */
17620 {
17625 {
17628 }
17629 else
17632 }
17634 /*
17635 * Free the memory for a variable type-value.
17636 */
17637 void
17640 {
17642 {
17644 {
17647 /*FALLTHROUGH*/
17663 }
17665 }
17666 }
17668 /*
17669 * Free the memory for a variable value and set the value to NULL or 0.
17670 */
17671 void
17674 {
17676 {
17678 {
17681 /*FALLTHROUGH*/
17701 }
17703 }
17704 }
17706 /*
17707 * Set the value of a variable to NULL without freeing items.
17708 */
17709 static void
17712 {
17715 }
17717 /*
17718 * Get the number value of a variable.
17719 * If it is a String variable, uses vim_str2nr().
17720 * For incompatible types, return 0.
17721 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17722 * caller of incompatible types: it sets *denote to TRUE if "denote"
17723 * is not NULL or returns -1 otherwise.
17724 */
17725 static long
17728 {
17732 }
17734 long
17738 {
17742 {
17762 }
17765 else
17768 }
17770 /*
17771 * Get the lnum from the first argument.
17772 * Also accepts ".", "$", etc., but that only works for the current buffer.
17773 * Returns -1 on error.
17774 */
17775 static linenr_T
17778 {
17779 typval_T rettv;
17780 linenr_T lnum;
17784 {
17789 }
17791 }
17793 /*
17794 * Get the lnum from the first argument.
17795 * Also accepts "$", then "buf" is used.
17796 * Returns 0 on error.
17797 */
17798 static linenr_T
17802 {
17809 }
17811 /*
17812 * Get the string value of a variable.
17813 * If it is a Number variable, the number is converted into a string.
17814 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17815 * get_tv_string_buf() uses a given buffer.
17816 * If the String variable has never been set, return an empty string.
17817 * Never returns NULL;
17818 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17819 * NULL on error.
17820 */
17824 {
17828 }
17834 {
17838 }
17840 char_u *
17843 {
17847 }
17853 {
17855 {
17875 }
17877 }
17879 /*
17880 * Find variable "name" in the list of variables.
17881 * Return a pointer to it if found, NULL if not found.
17882 * Careful: "a:0" variables don't have a name.
17883 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17884 * hashtab_T used.
17885 */
17890 {
17900 }
17902 /*
17903 * Find variable "varname" in hashtab "ht".
17904 * Returns NULL if not found.
17905 */
17911 {
17915 {
17916 /* Must be something like "s:", otherwise "ht" would be NULL. */
17918 {
17924 #ifdef FEAT_WINDOWS
17926 #endif
17931 }
17933 }
17937 {
17938 /* For global variables we may try auto-loading the script. If it
17939 * worked find the variable again. Don't auto-load a script if it was
17940 * loaded already, otherwise it would be loaded every time when
17941 * checking if a function name is a Funcref variable. */
17947 }
17949 }
17951 /*
17952 * Find the hashtab used for a variable name.
17953 * Set "varname" to the start of name without ':'.
17954 */
17959 {
17963 {
17964 /* The name must not start with a colon or #. */
17969 /* "version" is "v:version" in all scopes */
17977 }
17981 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17982 */
17990 #ifdef FEAT_WINDOWS
17993 #endif
18004 }
18006 /*
18007 * Get the string value of a (global/local) variable.
18008 * Returns NULL when it doesn't exist.
18009 */
18010 char_u *
18013 {
18020 }
18022 /*
18023 * Allocate a new hashtab for a sourced script. It will be used while
18024 * sourcing this script and when executing functions defined in the script.
18025 */
18026 void
18028 scid_T id;
18029 {
18035 {
18036 /* Re-allocating ga_data means that an ht_array pointing to
18037 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18038 * at its init value. Also reset "v_dict", it's always the same. */
18040 {
18046 }
18049 {
18053 }
18054 }
18055 }
18057 /*
18058 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18059 * point to it.
18060 */
18061 void
18065 {
18073 }
18075 /*
18076 * Clean up a list of internal variables.
18077 * Frees all allocated variables and the value they contain.
18078 * Clears hashtab "ht", does not free it.
18079 */
18080 void
18083 {
18085 }
18087 /*
18088 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18089 */
18090 static void
18094 {
18102 {
18104 {
18107 /* Free the variable. Don't remove it from the hashtab,
18108 * ht_array might change then. hash_clear() takes care of it
18109 * later. */
18115 }
18116 }
18119 }
18121 /*
18122 * Delete a variable from hashtab "ht" at item "hi".
18123 * Clear the variable value and free the dictitem.
18124 */
18125 static void
18129 {
18135 }
18137 /*
18138 * List the value of one internal variable.
18139 */
18140 static void
18145 {
18154 }
18156 static void
18163 {
18164 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18176 {
18180 }
18182 {
18186 }
18187 else
18195 {
18198 }
18199 }
18201 /*
18202 * Set variable "name" to value in "tv".
18203 * If the variable already exists, the value is updated.
18204 * Otherwise the variable is created.
18205 */
18206 static void
18211 {
18218 {
18222 {
18225 }
18227 {
18229 name);
18231 }
18232 }
18236 {
18239 }
18243 {
18244 /* existing variable, need to clear the value */
18253 {
18256 }
18258 /*
18259 * Handle setting internal v: variables separately: we don't change
18260 * the type.
18261 */
18263 {
18265 {
18269 else
18270 {
18271 /* Take over the string to avoid an extra alloc/free. */
18274 }
18275 }
18278 else
18281 }
18284 }
18286 {
18287 /* Can't add "v:" variable. */
18289 {
18292 }
18294 /* Make sure the variable name is valid. */
18298 {
18301 }
18309 {
18312 }
18314 }
18318 else
18319 {
18323 }
18324 }
18326 /*
18327 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18328 * Also give an error message.
18329 */
18330 static int
18334 {
18336 {
18339 }
18341 {
18344 }
18346 }
18348 /*
18349 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18350 * Also give an error message.
18351 */
18352 static int
18356 {
18358 {
18361 }
18363 }
18365 /*
18366 * Return TRUE if typeval "tv" is set to be locked (immutable).
18367 * Also give an error message, using "name".
18368 */
18369 static int
18373 {
18375 {
18379 }
18381 {
18385 }
18387 }
18389 /*
18390 * Copy the values from typval_T "from" to typval_T "to".
18391 * When needed allocates string or increases reference count.
18392 * Does not make a copy of a list or dict but copies the reference!
18393 */
18394 static void
18398 {
18402 {
18410 else
18411 {
18415 }
18420 else
18421 {
18424 }
18429 else
18430 {
18433 }
18438 }
18439 }
18441 /*
18442 * Make a copy of an item.
18443 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18444 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18445 * reference to an already copied list/dict can be used.
18446 * Returns FAIL or OK.
18447 */
18448 static int
18454 {
18459 {
18462 }
18466 {
18478 {
18479 /* use the copy made earlier */
18482 }
18483 else
18494 {
18495 /* use the copy made earlier */
18498 }
18499 else
18507 }
18510 }
18512 /*
18513 * ":echo expr1 ..." print each argument separated with a space, add a
18514 * newline at the end.
18515 * ":echon expr1 ..." print each argument plain.
18516 */
18517 void
18520 {
18522 typval_T rettv;
18532 {
18535 {
18536 /*
18537 * Report the invalid expression unless the expression evaluation
18538 * has been cancelled due to an aborting error, an interrupt, or an
18539 * exception.
18540 */
18544 }
18546 {
18548 {
18550 /* Call msg_start() after eval1(), evaluating the expression
18551 * may cause a message to appear. */
18554 }
18560 {
18562 {
18564 {
18565 /* remove any text still there from the command */
18568 }
18570 }
18571 else
18572 {
18573 #ifdef FEAT_MBYTE
18575 {
18580 }
18581 else
18582 #endif
18584 }
18585 }
18587 }
18590 }
18595 else
18596 {
18597 /* remove text that may still be there from the command */
18602 }
18603 }
18605 /*
18606 * ":echohl {name}".
18607 */
18608 void
18611 {
18617 else
18619 }
18621 /*
18622 * ":execute expr1 ..." execute the result of an expression.
18623 * ":echomsg expr1 ..." Print a message
18624 * ":echoerr expr1 ..." Print an error
18625 * Each gets spaces around each argument and a newline at the end for
18626 * echo commands
18627 */
18628 void
18631 {
18633 typval_T rettv;
18636 garray_T ga;
18645 {
18648 {
18649 /*
18650 * Report the invalid expression unless the expression evaluation
18651 * has been cancelled due to an aborting error, an interrupt, or an
18652 * exception.
18653 */
18658 }
18661 {
18665 {
18669 }
18674 }
18678 }
18681 {
18683 {
18686 }
18688 {
18689 /* We don't want to abort following commands, restore did_emsg. */
18694 }
18698 }
18706 }
18708 /*
18709 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18710 * "arg" points to the "&" or '+' when called, to "option" when returning.
18711 * Returns NULL when no option name found. Otherwise pointer to the char
18712 * after the option name.
18713 */
18718 {
18723 {
18726 }
18728 {
18731 }
18732 else
18741 else
18745 }
18747 /*
18748 * ":function"
18749 */
18750 void
18753 {
18762 garray_T newargs;
18763 garray_T newlines;
18772 funcdict_T fudi;
18780 /*
18781 * ":function" without argument: list functions.
18782 */
18784 {
18786 {
18789 {
18791 {
18796 }
18797 }
18798 }
18801 }
18803 /*
18804 * ":function /pat": list functions matching pattern.
18805 */
18807 {
18810 {
18811 regmatch_T regmatch;
18818 {
18823 {
18825 {
18831 }
18832 }
18833 }
18834 }
18839 }
18841 /*
18842 * Get the function name. There are these situations:
18843 * func normal function name
18844 * "name" == func, "fudi.fd_dict" == NULL
18845 * dict.func new dictionary entry
18846 * "name" == NULL, "fudi.fd_dict" set,
18847 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18848 * dict.func existing dict entry with a Funcref
18849 * "name" == func, "fudi.fd_dict" set,
18850 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18851 * dict.func existing dict entry that's not a Funcref
18852 * "name" == NULL, "fudi.fd_dict" set,
18853 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18854 */
18859 {
18860 /*
18861 * Return on an invalid expression in braces, unless the expression
18862 * evaluation has been cancelled due to an aborting error, an
18863 * interrupt, or an exception.
18864 */
18866 {
18871 }
18872 else
18874 }
18876 /* An error in a function call during evaluation of an expression in magic
18877 * braces should not cause the function not to be defined. */
18881 /*
18882 * ":function func" with only function name: list function.
18883 */
18885 {
18887 {
18890 }
18895 {
18898 {
18901 {
18913 }
18915 {
18918 }
18919 }
18920 else
18922 }
18924 }
18926 /*
18927 * ":function name(arg1, arg2)" Define function.
18928 */
18931 {
18933 {
18936 }
18937 /* attempt to continue by skipping some text */
18940 }
18947 {
18948 /* Check the name of the function. Unless it's a dictionary function
18949 * (that we are overwriting). */
18952 else
18956 {
18959 else
18966 }
18967 }
18969 /*
18970 * Isolate the arguments: "arg1, arg2, ...)"
18971 */
18973 {
18975 {
18979 }
18980 else
18981 {
18988 {
18992 }
19005 else
19007 }
19010 {
19014 }
19015 }
19018 /* find extra arguments "range", "dict" and "abort" */
19020 {
19023 {
19026 }
19028 {
19031 }
19033 {
19036 }
19037 else
19039 }
19041 /* When there is a line break use what follows for the function body.
19042 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19048 /*
19049 * Read the body of the function, until ":endfunction" is found.
19050 */
19052 {
19053 /* Check if the function already exists, don't let the user type the
19054 * whole function before telling him it doesn't work! For a script we
19055 * need to skip the body to be able to find what follows. */
19057 {
19062 }
19069 }
19074 {
19080 {
19081 /* Use eap->arg, split up in parts by line breaks. */
19086 else
19087 {
19090 }
19091 }
19094 else
19099 {
19102 }
19104 /* Detect line continuation: sourcing_lnum increased more than one. */
19107 else
19111 {
19112 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19113 * don't check for ":endfunc". */
19115 {
19118 }
19119 }
19120 else
19121 {
19122 /* skip ':' and blanks*/
19124 ;
19126 /* Check for "endfunction". */
19128 {
19132 }
19134 /* Increase indent inside "if", "while", "for" and "try", decrease
19135 * at "end". */
19144 /* Check for defining a function inside this function. */
19146 {
19151 {
19154 {
19157 }
19158 }
19159 }
19161 /* Check for ":append" or ":insert". */
19169 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19182 ))
19183 {
19184 /* ":python <<" continues until a dot, like ":append" */
19188 else
19190 }
19191 }
19193 /* Add the line to the function. */
19195 {
19199 }
19201 /* Copy the line to newly allocated memory. get_one_sourceline()
19202 * allocates 250 bytes per line, this saves 80% on average. The cost
19203 * is an extra alloc/free. */
19206 {
19210 }
19214 /* Add NULL lines for continuation lines, so that the line count is
19215 * equal to the index in the growarray. */
19219 /* Check for end of eap->arg. */
19222 }
19224 /* Don't define the function when skipping commands or when an error was
19225 * detected. */
19229 /*
19230 * If there are no errors, add the function
19231 */
19233 {
19236 {
19238 name);
19240 }
19244 {
19246 {
19249 }
19251 {
19253 name);
19255 }
19256 /* redefine existing function */
19261 }
19262 }
19263 else
19264 {
19269 {
19272 }
19274 {
19275 /* Can't add a function to a locked dictionary */
19278 }
19279 /* Can't change an existing function if it is locked */
19283 /* Give the function a sequential number. Can only be used with a
19284 * Funcref! */
19290 }
19293 {
19295 {
19299 /* Check that the autoload name matches the script name. */
19302 {
19305 {
19313 }
19314 }
19316 {
19319 }
19320 }
19327 {
19329 {
19330 /* add new dict entry */
19333 {
19336 }
19338 {
19342 }
19343 }
19344 else
19345 /* overwrite existing dict entry */
19352 /* behave like "dict" was used */
19354 }
19356 /* insert the new function in the function list */
19359 }
19362 #ifdef FEAT_PROFILE
19369 #endif
19376 erret:
19379 ret_free:
19384 }
19386 /*
19387 * Get a function name, translating "<SID>" and "<SNR>".
19388 * Also handles a Funcref in a List or Dictionary.
19389 * Returns the function name in allocated memory, or NULL for failure.
19390 * flags:
19391 * TFN_INT: internal function name OK
19392 * TFN_QUIET: be quiet
19393 * Advances "pp" to just after the function name (if no error).
19394 */
19401 {
19408 lval_T lv;
19414 /* Check for hard coded <SNR>: already translated function ID (from a user
19415 * command). */
19418 {
19422 }
19424 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19425 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19433 {
19437 }
19439 {
19440 /*
19441 * Report an invalid expression in braces, unless the expression
19442 * evaluation has been cancelled due to an aborting error, an
19443 * interrupt, or an exception.
19444 */
19446 {
19449 }
19450 else
19453 }
19456 {
19458 {
19463 }
19465 {
19468 }
19469 else
19470 {
19474 else
19477 }
19479 }
19482 {
19483 /* Error found, but continue after the function name. */
19486 }
19488 /* Check if the name is a Funcref. If so, use the value. */
19490 {
19495 }
19496 else
19497 {
19502 }
19504 {
19508 }
19511 {
19515 {
19516 /* When there was "s:" already or the name expanded to get a
19517 * leading "s:" then remove it. */
19521 }
19522 }
19523 else
19524 {
19528 }
19530 /*
19531 * Copy the function name to allocated memory.
19532 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19533 * Accept <SNR>123_name() outside a script.
19534 */
19538 {
19542 {
19543 /* It's "s:" or "<SID>" */
19545 {
19548 }
19551 }
19552 }
19554 {
19557 }
19560 {
19562 {
19568 }
19571 }
19574 theend:
19577 }
19579 /*
19580 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19581 * Return 2 if "p" starts with "s:".
19582 * Return 0 otherwise.
19583 */
19584 static int
19587 {
19594 }
19596 /*
19597 * Return TRUE if "p" starts with "<SID>" or "s:".
19598 * Only works if eval_fname_script() returned non-zero for "p"!
19599 */
19600 static int
19603 {
19605 }
19607 /*
19608 * List the head of the function: "name(arg1, arg2)".
19609 */
19610 static void
19614 {
19622 {
19625 }
19626 else
19630 {
19634 }
19636 {
19640 }
19645 }
19647 /*
19648 * Find a function by name, return pointer to it in ufuncs.
19649 * Return NULL for unknown function.
19650 */
19654 {
19661 }
19663 #if defined(EXITFREE) || defined(PROTO)
19664 void
19666 {
19669 /* Need to start all over every time, because func_free() may change the
19670 * hash table. */
19674 {
19677 }
19678 }
19679 #endif
19681 /*
19682 * Return TRUE if a function "name" exists.
19683 */
19684 static int
19687 {
19695 /* Only accept "funcname", "funcname ", "funcname (..." and
19696 * "funcname(...", not "funcname!...". */
19698 {
19701 else
19703 }
19706 }
19708 /*
19709 * Return TRUE if "name" looks like a builtin function name: starts with a
19710 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19711 */
19712 static int
19715 {
19718 }
19720 #if defined(FEAT_PROFILE) || defined(PROTO)
19721 /*
19722 * Start profiling function "fp".
19723 */
19724 static void
19727 {
19746 }
19748 /*
19749 * Dump the profiling results for all functions in file "fd".
19750 */
19751 void
19754 {
19766 {
19768 {
19772 {
19778 else
19782 else
19790 {
19796 }
19798 }
19799 }
19800 }
19803 {
19805 prof_total_cmp);
19808 prof_self_cmp);
19810 }
19811 }
19813 static void
19820 {
19827 {
19830 prefer_self);
19833 else
19835 }
19837 }
19839 /*
19840 * Print the count and times for one function or function line.
19841 */
19842 static void
19849 {
19851 {
19855 else
19859 else
19861 }
19862 else
19864 }
19866 /*
19867 * Compare function for total time sorting.
19868 */
19869 static int
19870 #ifdef __BORLANDC__
19871 _RTLENTRYF
19872 #endif
19876 {
19882 }
19884 /*
19885 * Compare function for self time sorting.
19886 */
19887 static int
19888 #ifdef __BORLANDC__
19889 _RTLENTRYF
19890 #endif
19894 {
19900 }
19902 #endif
19904 /*
19905 * If "name" has a package name try autoloading the script for it.
19906 * Return TRUE if a package was loaded.
19907 */
19908 static int
19912 {
19918 /* If there is no '#' after name[0] there is no package name. */
19925 /* Find the name in the list of previously loaded package names. Skip
19926 * "autoload/", it's always the same. */
19932 else
19933 {
19934 /* Remember the name if it wasn't loaded already. */
19936 {
19939 }
19941 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19944 }
19948 }
19950 /*
19951 * Return the autoload script name for a function or variable name.
19952 * Returns NULL when out of memory.
19953 */
19957 {
19961 /* Get the script file name: replace '#' with '/', append ".vim". */
19972 }
19974 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19976 /*
19977 * Function given to ExpandGeneric() to obtain the list of user defined
19978 * function names.
19979 */
19980 char_u *
19984 {
19990 {
19993 }
19995 {
20007 {
20011 }
20013 }
20015 }
20019 /*
20020 * Copy the function name of "fp" to buffer "buf".
20021 * "buf" must be able to hold the function name plus three bytes.
20022 * Takes care of script-local function names.
20023 */
20024 static void
20028 {
20030 {
20033 }
20034 else
20036 }
20038 /*
20039 * ":delfunction {name}"
20040 */
20041 void
20044 {
20048 funcdict_T fudi;
20054 {
20058 }
20060 {
20064 }
20074 {
20076 {
20079 }
20081 {
20084 }
20087 {
20088 /* Delete the dict item that refers to the function, it will
20089 * invoke func_unref() and possibly delete the function. */
20091 }
20092 else
20094 }
20095 }
20097 /*
20098 * Free a function and remove it from the list of functions.
20099 */
20100 static void
20103 {
20106 /* clear this function */
20109 #ifdef FEAT_PROFILE
20113 #endif
20115 /* remove the function from the function hashtable */
20119 else
20123 }
20125 /*
20126 * Unreference a Function: decrement the reference count and free it when it
20127 * becomes zero. Only for numbered functions.
20128 */
20129 static void
20132 {
20136 {
20141 {
20142 /* Only delete it when it's not being used. Otherwise it's done
20143 * when "uf_calls" becomes zero. */
20146 }
20147 }
20148 }
20150 /*
20151 * Count a reference to a Function.
20152 */
20153 static void
20156 {
20160 {
20164 else
20166 }
20167 }
20169 /*
20170 * Call a user function.
20171 */
20172 static void
20181 {
20183 linenr_T save_sourcing_lnum;
20184 scid_T save_current_SID;
20185 funccall_T fc;
20194 #ifdef FEAT_PROFILE
20195 proftime_T wait_start;
20196 proftime_T call_start;
20197 #endif
20199 /* If depth of calling is getting too high, don't execute the function */
20201 {
20206 }
20219 /* Check if this function has a breakpoint. */
20223 /*
20224 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20225 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20226 * each argument variable and saves a lot of time.
20227 */
20228 /*
20229 * Init l: variables.
20230 */
20233 {
20234 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20235 * some compiler that checks the destination size. */
20245 }
20247 /*
20248 * Init a: variables.
20249 * Set a:0 to "argcount".
20250 * Set a:000 to a list with room for the "..." arguments.
20251 */
20266 /*
20267 * Set a:firstline to "firstline" and a:lastline to "lastline".
20268 * Set a:name to named arguments.
20269 * Set a:N to the "..." arguments.
20270 */
20276 {
20279 /* named argument a:name */
20281 else
20282 {
20283 /* "..." argument a:1, a:2, etc. */
20286 }
20288 {
20291 }
20292 else
20293 {
20299 }
20303 /* Note: the values are copied directly to avoid alloc/free.
20304 * "argvars" must have VAR_FIXED for v_lock. */
20309 {
20313 }
20314 }
20316 /* Don't redraw while executing the function. */
20324 {
20328 else
20333 {
20339 {
20347 {
20352 else
20353 {
20356 {
20360 }
20361 }
20362 }
20364 }
20369 }
20370 }
20371 #ifdef FEAT_PROFILE
20373 {
20378 {
20382 }
20384 }
20385 #endif
20392 /* call do_cmdline() to execute the lines */
20398 /* when the function was aborted because of an error, return -1 */
20400 {
20404 }
20406 #ifdef FEAT_PROFILE
20409 {
20415 {
20418 }
20419 }
20420 #endif
20422 /* when being verbose, mention the return value */
20424 {
20433 else
20434 {
20440 /* The value may be very long. Skip the middle part, so that we
20441 * have some idea how it starts and ends. smsg() would always
20442 * truncate it at the end. */
20445 {
20449 }
20450 }
20455 }
20461 #ifdef FEAT_PROFILE
20464 #endif
20467 {
20476 }
20481 /* The a: variables typevals were not alloced, only free the allocated
20482 * variables. */
20487 }
20489 /*
20490 * Add a number variable "name" to dict "dp" with value "nr".
20491 */
20492 static void
20497 varnumber_T nr;
20498 {
20505 }
20507 /*
20508 * ":return [expr]"
20509 */
20510 void
20513 {
20515 typval_T rettv;
20519 {
20522 }
20530 {
20533 else
20535 }
20536 /* It's safer to return also on error. */
20538 {
20539 /*
20540 * Return unless the expression evaluation has been cancelled due to an
20541 * aborting error, an interrupt, or an exception.
20542 */
20545 }
20547 /* When skipping or the return gets pending, advance to the next command
20548 * in this line (!returning). Otherwise, ignore the rest of the line.
20549 * Following lines will be ignored by get_func_line(). */
20557 }
20559 /*
20560 * Return from a function. Possibly makes the return pending. Also called
20561 * for a pending return at the ":endtry" or after returning from an extra
20562 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20563 * when called due to a ":return" command. "rettv" may point to a typval_T
20564 * with the return rettv. Returns TRUE when the return can be carried out,
20565 * FALSE when the return gets pending.
20566 */
20567 int
20573 {
20578 /* Undo the return. */
20581 /*
20582 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20583 * not in its finally clause (which then is to be executed next) is found.
20584 * In this case, make the ":return" pending for execution at the ":endtry".
20585 * Otherwise, return normally.
20586 */
20589 {
20593 /* A pending return again gets pending. "rettv" points to an
20594 * allocated variable with the rettv of the original ":return"'s
20595 * argument if present or is NULL else. */
20597 else
20598 {
20599 /* When undoing a return in order to make it pending, get the stored
20600 * return rettv. */
20605 {
20606 /* Store the value of the pending return. */
20609 else
20611 }
20612 else
20616 {
20617 /* The pending return value could be overwritten by a ":return"
20618 * without argument in a finally clause; reset the default
20619 * return value. */
20622 }
20623 }
20625 }
20626 else
20627 {
20630 /* If the return is carried out now, store the return value. For
20631 * a return immediately after reanimation, the value is already
20632 * there. */
20634 {
20639 }
20640 }
20643 }
20645 /*
20646 * Free the variable with a pending return value.
20647 */
20648 void
20651 {
20653 }
20655 /*
20656 * Generate a return command for producing the value of "rettv". The result
20657 * is an allocated string. Used by report_pending() for verbose messages.
20658 */
20659 char_u *
20662 {
20678 }
20680 /*
20681 * Get next function line.
20682 * Called by do_cmdline() to get the next line.
20683 * Returns allocated string, or NULL for end of function.
20684 */
20685 /* ARGSUSED */
20686 char_u *
20691 {
20697 /* If breakpoints have been added/deleted need to check for it. */
20699 {
20701 sourcing_lnum);
20703 }
20704 #ifdef FEAT_PROFILE
20707 #endif
20713 else
20714 {
20715 /* Skip NULL lines (continuation lines). */
20721 else
20722 {
20725 #ifdef FEAT_PROFILE
20728 #endif
20729 }
20730 }
20732 /* Did we encounter a breakpoint? */
20734 {
20736 /* Find next breakpoint. */
20738 sourcing_lnum);
20740 }
20743 }
20745 #if defined(FEAT_PROFILE) || defined(PROTO)
20746 /*
20747 * Called when starting to read a function line.
20748 * "sourcing_lnum" must be correct!
20749 * When skipping lines it may not actually be executed, but we won't find out
20750 * until later and we need to store the time now.
20751 */
20752 void
20755 {
20761 {
20763 /* Skip continuation lines. */
20770 }
20771 }
20773 /*
20774 * Called when actually executing a function line.
20775 */
20776 void
20779 {
20785 }
20787 /*
20788 * Called when done with a function line.
20789 */
20790 void
20793 {
20798 {
20800 {
20807 }
20809 }
20810 }
20811 #endif
20813 /*
20814 * Return TRUE if the currently active function should be ended, because a
20815 * return was encountered or an error occured. Used inside a ":while".
20816 */
20817 int
20820 {
20823 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20824 * an error inside a try conditional. */
20827 }
20829 /*
20830 * return TRUE if cookie indicates a function which "abort"s on errors.
20831 */
20832 int
20835 {
20837 }
20839 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20841 {
20842 VAR_FLAVOUR_DEFAULT,
20843 VAR_FLAVOUR_SESSION,
20844 VAR_FLAVOUR_VIMINFO
20849 static var_flavour_T
20852 {
20856 {
20861 }
20862 else
20864 }
20865 #endif
20867 #if defined(FEAT_VIMINFO) || defined(PROTO)
20868 /*
20869 * Restore global vars that start with a capital from the viminfo file
20870 */
20871 int
20875 {
20878 typval_T tv;
20881 {
20884 {
20891 {
20893 {
20897 }
20898 else
20899 {
20902 }
20906 }
20907 }
20908 }
20911 }
20913 /*
20914 * Write global vars that start with a capital to the viminfo file
20915 */
20916 void
20919 {
20935 {
20937 {
20941 {
20943 {
20947 }
20953 }
20954 }
20955 }
20956 }
20957 #endif
20959 #if defined(FEAT_SESSION) || defined(PROTO)
20960 int
20963 {
20971 {
20973 {
20979 {
20980 /* Escape special characters with a backslash. Turn a LF and
20981 * CR into \n and \r. */
20995 p,
20999 {
21002 }
21004 }
21005 }
21006 }
21008 }
21009 #endif
21011 /*
21012 * Display script name where an item was last set.
21013 * Should only be invoked when 'verbose' is non-zero.
21014 */
21015 void
21017 scid_T scriptID;
21018 {
21022 {
21025 {
21031 }
21032 }
21033 }
21037 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21040 #ifdef WIN3264
21041 /*
21042 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21043 */
21045 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21048 /*
21049 * Get the short pathname of a file.
21050 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
21051 */
21052 static int
21057 {
21065 {
21066 /* If that doesn't work (not enough space), then save the string
21067 * and try again with a new buffer big enough
21068 */
21078 /* Really should always succeed, as the buffer is big enough */
21079 }
21083 }
21085 /*
21086 * Create a short path name. Returns the length of the buffer it needs.
21087 * Doesn't copy over the end of the buffer passed in.
21088 */
21089 static int
21094 {
21096 char_u ch;
21099 /* Make a copy */
21109 {
21113 }
21115 do
21116 {
21117 /* Go back one path-separator */
21119 {
21123 }
21127 /* Remember the character that is about to be splatted */
21131 /* Try it in situ */
21134 {
21137 }
21142 {
21143 /* Remember the length of the new string. */
21147 {
21148 /* If there's not enough space in the currently allocated string,
21149 * then copy it to a buffer big enough.
21150 */
21154 }
21155 else
21156 {
21157 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21162 }
21163 /* Concat the next bit */
21166 }
21170 }
21172 /*
21173 * Get a pathname for a partial path.
21174 */
21175 static int
21180 {
21186 /* Count up the path seperators from the RHS.. so we know which part
21187 * of the path to return.
21188 */
21194 /* Need full path first (use expand_env() to remove a "~/") */
21198 else
21207 {
21208 /* Don't have a valid filename, so shorten the rest of the
21209 * path if we can. This CAN give us invalid 8.3 filenames, but
21210 * there's not a lot of point in guessing what it might be.
21211 */
21215 }
21217 /* Count the paths backward to find the beginning of the desired string. */
21219 {
21220 #ifdef FEAT_MBYTE
21223 #endif
21225 {
21228 else
21229 sepcount --;
21230 }
21231 }
21233 {
21237 else
21239 }
21240 else
21243 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21250 }
21253 /*
21254 * Adjust a filename, according to a string of modifiers.
21255 * *fnamep must be NUL terminated when called. When returning, the length is
21256 * determined by *fnamelen.
21257 * Returns valid flags.
21258 * When there is an error, *fnamep is set to NULL.
21259 */
21260 int
21267 {
21274 #ifdef WIN3264
21276 #endif
21278 repeat:
21279 /* ":p" - full path/file_name */
21281 {
21287 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21289 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21291 # ifdef BACKSLASH_IN_FILENAME
21293 # endif
21296 #endif
21297 )
21298 {
21304 }
21306 /* When "/." or "/.." is used: force expansion to get rid of it. */
21308 {
21316 }
21318 /* FullName_save() is slow, don't use it when not needed. */
21320 {
21326 }
21328 /* Append a path separator to a directory. */
21330 {
21331 /* Make room for one or two extra characters. */
21338 }
21339 }
21341 /* ":." - path relative to the current directory */
21342 /* ":~" - path relative to the home directory */
21343 /* ":8" - shortname path - postponed till after */
21346 {
21349 {
21350 #ifdef WIN3264
21352 #endif
21354 }
21356 /* Need full path first (use expand_env() to remove a "~/") */
21358 {
21361 else
21363 }
21364 else
21370 {
21372 {
21376 {
21379 {
21383 }
21384 }
21385 }
21386 else
21387 {
21389 /* Only replace it when it starts with '~' */
21391 {
21394 {
21398 }
21399 }
21400 }
21402 }
21403 }
21408 /* ":h" - head, remove "/file_name", can be repeated */
21409 /* Don't remove the first "/" or "c:\" */
21411 {
21418 #ifdef VMS
21421 #endif
21423 {
21424 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21431 }
21432 else
21433 {
21436 }
21437 }
21439 /* ":8" - shortname */
21441 {
21443 #ifdef WIN3264
21445 #endif
21446 }
21448 #ifdef WIN3264
21449 /* Check shortname after we have done 'heads' and before we do 'tails'
21450 */
21452 {
21454 /* Copy the string if it is shortened by :h */
21456 {
21462 }
21464 /* Split into two implementations - makes it easier. First is where
21465 * there isn't a full name already, second is where there is.
21466 */
21468 {
21471 }
21472 else
21473 {
21476 /* Simple case, already have the full-name
21477 * Nearly always shorter, so try first time. */
21483 {
21484 /* Couldn't find the filename.. search the paths.
21485 */
21489 }
21491 }
21492 }
21495 /* ":t" - tail, just the basename */
21497 {
21501 }
21503 /* ":e" - extension, can be repeated */
21504 /* ":r" - root, without extension, can be repeated */
21507 {
21508 /* find a '.' in the tail:
21509 * - for second :e: before the current fname
21510 * - otherwise: The last '.'
21511 */
21514 else
21520 {
21522 {
21525 #ifdef VMS
21526 /* cut version from the extension */
21533 #endif
21534 }
21537 }
21539 {
21542 }
21544 }
21546 /* ":s?pat?foo?" - substitute */
21547 /* ":gs?pat?foo?" - global substitute */
21551 {
21562 {
21565 }
21569 {
21570 /* find end of pattern */
21573 {
21576 {
21578 /* find end of substitution */
21581 {
21585 {
21589 {
21595 }
21596 }
21599 }
21601 }
21602 }
21603 /* after using ":s", repeat all the modifiers */
21606 }
21607 }
21610 }
21612 /*
21613 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21614 * "flags" can be "g" to do a global substitute.
21615 * Returns an allocated string, NULL for error.
21616 */
21617 char_u *
21623 {
21625 regmatch_T regmatch;
21629 garray_T ga;
21633 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21644 {
21647 {
21648 /*
21649 * Get some space for a temporary buffer to do the substitution
21650 * into. It will contain:
21651 * - The text up to where the match is.
21652 * - The substituted text.
21653 * - The text after the match.
21654 */
21658 {
21661 }
21663 /* copy the text up to where the match is */
21666 /* add the substituted text */
21670 /* avoid getting stuck on a match with an empty string */
21672 {
21677 }
21678 else
21679 {
21683 }
21686 }
21692 }
21699 }