| blob | 0f2461e1126d99f3e48c3351c384732658a22f71 |
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_GETTEXT
10874 #endif
10875 #ifdef FEAT_GUI
10877 #endif
10878 #ifdef FEAT_GUI_ATHENA
10879 # ifdef FEAT_GUI_NEXTAW
10881 # else
10883 # endif
10884 #endif
10885 #ifdef FEAT_GUI_GTK
10887 # ifdef HAVE_GTK2
10889 # endif
10890 #endif
10891 #ifdef FEAT_GUI_GNOME
10893 #endif
10894 #ifdef FEAT_GUI_MAC
10896 #endif
10897 #ifdef FEAT_GUI_MOTIF
10899 #endif
10900 #ifdef FEAT_GUI_PHOTON
10902 #endif
10903 #ifdef FEAT_GUI_W16
10905 #endif
10906 #ifdef FEAT_GUI_W32
10908 #endif
10909 #ifdef FEAT_HANGULIN
10911 #endif
10912 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10914 #endif
10915 #ifdef FEAT_INS_EXPAND
10917 #endif
10918 #ifdef FEAT_JUMPLIST
10920 #endif
10921 #ifdef FEAT_KEYMAP
10923 #endif
10924 #ifdef FEAT_LANGMAP
10926 #endif
10927 #ifdef FEAT_LIBCALL
10929 #endif
10930 #ifdef FEAT_LINEBREAK
10932 #endif
10933 #ifdef FEAT_LISP
10935 #endif
10936 #ifdef FEAT_LISTCMDS
10938 #endif
10939 #ifdef FEAT_LOCALMAP
10941 #endif
10942 #ifdef FEAT_MENU
10944 #endif
10945 #ifdef FEAT_SESSION
10947 #endif
10948 #ifdef FEAT_MODIFY_FNAME
10950 #endif
10951 #ifdef FEAT_MOUSE
10953 #endif
10954 #ifdef FEAT_MOUSESHAPE
10956 #endif
10957 #if defined(UNIX) || defined(VMS)
10958 # ifdef FEAT_MOUSE_DEC
10960 # endif
10961 # ifdef FEAT_MOUSE_GPM
10963 # endif
10964 # ifdef FEAT_MOUSE_JSB
10966 # endif
10967 # ifdef FEAT_MOUSE_NET
10969 # endif
10970 # ifdef FEAT_MOUSE_PTERM
10972 # endif
10973 # ifdef FEAT_MOUSE_XTERM
10975 # endif
10976 #endif
10977 #ifdef FEAT_MBYTE
10979 #endif
10980 #ifdef FEAT_MBYTE_IME
10982 #endif
10983 #ifdef FEAT_MULTI_LANG
10985 #endif
10986 #ifdef FEAT_MZSCHEME
10987 #ifndef DYNAMIC_MZSCHEME
10989 #endif
10990 #endif
10991 #ifdef FEAT_OLE
10993 #endif
10994 #ifdef FEAT_OSFILETYPE
10996 #endif
10997 #ifdef FEAT_PATH_EXTRA
10999 #endif
11000 #ifdef FEAT_PERL
11001 #ifndef DYNAMIC_PERL
11003 #endif
11004 #endif
11005 #ifdef FEAT_PYTHON
11006 #ifndef DYNAMIC_PYTHON
11008 #endif
11009 #endif
11010 #ifdef FEAT_POSTSCRIPT
11012 #endif
11013 #ifdef FEAT_PRINTER
11015 #endif
11016 #ifdef FEAT_PROFILE
11018 #endif
11019 #ifdef FEAT_RELTIME
11021 #endif
11022 #ifdef FEAT_QUICKFIX
11024 #endif
11025 #ifdef FEAT_RIGHTLEFT
11027 #endif
11028 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11030 #endif
11031 #ifdef FEAT_SCROLLBIND
11033 #endif
11034 #ifdef FEAT_CMDL_INFO
11037 #endif
11038 #ifdef FEAT_SIGNS
11040 #endif
11041 #ifdef FEAT_SMARTINDENT
11043 #endif
11044 #ifdef FEAT_SNIFF
11046 #endif
11047 #ifdef FEAT_STL_OPT
11049 #endif
11050 #ifdef FEAT_SUN_WORKSHOP
11052 #endif
11053 #ifdef FEAT_NETBEANS_INTG
11055 #endif
11056 #ifdef FEAT_SPELL
11058 #endif
11059 #ifdef FEAT_SYN_HL
11061 #endif
11062 #if defined(USE_SYSTEM) || !defined(UNIX)
11064 #endif
11065 #ifdef FEAT_TAG_BINS
11067 #endif
11068 #ifdef FEAT_TAG_OLDSTATIC
11070 #endif
11071 #ifdef FEAT_TAG_ANYWHITE
11073 #endif
11074 #ifdef FEAT_TCL
11075 # ifndef DYNAMIC_TCL
11077 # endif
11078 #endif
11079 #ifdef TERMINFO
11081 #endif
11082 #ifdef FEAT_TERMRESPONSE
11084 #endif
11085 #ifdef FEAT_TEXTOBJ
11087 #endif
11088 #ifdef HAVE_TGETENT
11090 #endif
11091 #ifdef FEAT_TITLE
11093 #endif
11094 #ifdef FEAT_TOOLBAR
11096 #endif
11097 #ifdef FEAT_USR_CMDS
11100 #endif
11101 #ifdef FEAT_VIMINFO
11103 #endif
11104 #ifdef FEAT_VERTSPLIT
11106 #endif
11107 #ifdef FEAT_VIRTUALEDIT
11109 #endif
11110 #ifdef FEAT_VISUAL
11112 #endif
11113 #ifdef FEAT_VISUALEXTRA
11115 #endif
11116 #ifdef FEAT_VREPLACE
11118 #endif
11119 #ifdef FEAT_WILDIGN
11121 #endif
11122 #ifdef FEAT_WILDMENU
11124 #endif
11125 #ifdef FEAT_WINDOWS
11127 #endif
11128 #ifdef FEAT_WAK
11130 #endif
11131 #ifdef FEAT_WRITEBACKUP
11133 #endif
11134 #ifdef FEAT_XIM
11136 #endif
11137 #ifdef FEAT_XFONTSET
11139 #endif
11140 #ifdef USE_XSMP
11142 #endif
11143 #ifdef USE_XSMP_INTERACT
11145 #endif
11146 #ifdef FEAT_XCLIPBOARD
11148 #endif
11149 #ifdef FEAT_XTERM_SAVE
11151 #endif
11152 #if defined(UNIX) && defined(FEAT_X11)
11154 #endif
11155 NULL
11156 };
11161 {
11164 }
11167 {
11172 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11175 #endif
11176 #ifdef DYNAMIC_TCL
11179 #endif
11180 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11183 #endif
11184 #ifdef DYNAMIC_MZSCHEME
11187 #endif
11188 #ifdef DYNAMIC_RUBY
11191 #endif
11192 #ifdef DYNAMIC_PYTHON
11195 #endif
11196 #ifdef DYNAMIC_PERL
11199 #endif
11200 #ifdef FEAT_GUI
11203 # ifdef FEAT_GUI_W32
11206 # endif
11207 # ifdef FEAT_BROWSE
11210 # endif
11211 #endif
11212 #ifdef FEAT_SYN_HL
11215 #endif
11216 #if defined(WIN3264)
11219 #endif
11220 #ifdef FEAT_NETBEANS_INTG
11223 #endif
11224 }
11227 }
11229 /*
11230 * "has_key()" function
11231 */
11232 static void
11236 {
11239 {
11242 }
11248 }
11250 /*
11251 * "haslocaldir()" function
11252 */
11253 /*ARGSUSED*/
11254 static void
11258 {
11260 }
11262 /*
11263 * "hasmapto()" function
11264 */
11265 static void
11269 {
11278 else
11279 {
11283 }
11287 else
11289 }
11291 /*
11292 * "histadd()" function
11293 */
11294 /*ARGSUSED*/
11295 static void
11299 {
11300 #ifdef FEAT_CMDHIST
11304 #endif
11309 #ifdef FEAT_CMDHIST
11313 {
11316 {
11320 }
11321 }
11322 #endif
11323 }
11325 /*
11326 * "histdel()" function
11327 */
11328 /*ARGSUSED*/
11329 static void
11333 {
11334 #ifdef FEAT_CMDHIST
11343 /* only one argument: clear entire history */
11346 /* index given: remove that entry */
11349 else
11350 /* string given: remove all matching entries */
11354 #else
11356 #endif
11357 }
11359 /*
11360 * "histget()" function
11361 */
11362 /*ARGSUSED*/
11363 static void
11367 {
11368 #ifdef FEAT_CMDHIST
11376 else
11377 {
11381 else
11383 /* -1 on type error */
11385 }
11386 #else
11388 #endif
11390 }
11392 /*
11393 * "histnr()" function
11394 */
11395 /*ARGSUSED*/
11396 static void
11400 {
11403 #ifdef FEAT_CMDHIST
11409 else
11410 #endif
11413 }
11415 /*
11416 * "highlightID(name)" function
11417 */
11418 static void
11422 {
11424 }
11426 /*
11427 * "highlight_exists()" function
11428 */
11429 static void
11433 {
11435 }
11437 /*
11438 * "hostname()" function
11439 */
11440 /*ARGSUSED*/
11441 static void
11445 {
11451 }
11453 /*
11454 * iconv() function
11455 */
11456 /*ARGSUSED*/
11457 static void
11461 {
11462 #ifdef FEAT_MBYTE
11466 vimconv_T vimconv;
11467 #endif
11472 #ifdef FEAT_MBYTE
11479 /* If the encodings are equal, no conversion needed. */
11482 else
11488 #endif
11489 }
11491 /*
11492 * "indent()" function
11493 */
11494 static void
11498 {
11499 linenr_T lnum;
11504 else
11506 }
11508 /*
11509 * "index()" function
11510 */
11511 static void
11515 {
11523 {
11526 }
11529 {
11532 {
11535 /* Start at specified item. Use the cached index that list_find()
11536 * sets, so that a negative number also works. */
11543 }
11547 {
11550 }
11551 }
11552 }
11558 /*
11559 * This function is used by f_input() and f_inputdialog() functions. The third
11560 * argument to f_input() specifies the type of completion to use at the
11561 * prompt. The third argument to f_inputdialog() specifies the value to return
11562 * when the user cancels the prompt.
11563 */
11564 static void
11569 {
11582 #ifdef NO_CONSOLE_INPUT
11583 /* While starting up, there is no place to enter text. */
11586 #endif
11590 {
11591 /* Only the part of the message after the last NL is considered as
11592 * prompt for the command line */
11596 else
11597 {
11607 }
11611 {
11617 {
11633 }
11634 }
11643 /* since the user typed this, no need to wait for return */
11646 }
11648 }
11650 /*
11651 * "input()" function
11652 * Also handles inputsecret() when inputsecret is set.
11653 */
11654 static void
11658 {
11660 }
11662 /*
11663 * "inputdialog()" function
11664 */
11665 static void
11669 {
11670 #if defined(FEAT_GUI_TEXTDIALOG)
11671 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11673 {
11682 else
11688 else
11689 {
11695 else
11697 }
11699 }
11700 else
11701 #endif
11703 }
11705 /*
11706 * "inputlist()" function
11707 */
11708 static void
11712 {
11718 #ifdef NO_CONSOLE_INPUT
11719 /* While starting up, there is no place to enter text. */
11722 #endif
11724 {
11727 }
11736 {
11739 }
11741 /* Ask for choice. */
11747 }
11752 /*
11753 * "inputrestore()" function
11754 */
11755 /*ARGSUSED*/
11756 static void
11760 {
11762 {
11767 }
11769 {
11772 }
11773 }
11775 /*
11776 * "inputsave()" function
11777 */
11778 /*ARGSUSED*/
11779 static void
11783 {
11784 /* Add an entry to the stack of typehead storage. */
11786 {
11791 }
11792 else
11794 }
11796 /*
11797 * "inputsecret()" function
11798 */
11799 static void
11803 {
11809 }
11811 /*
11812 * "insert()" function
11813 */
11814 static void
11818 {
11829 {
11837 else
11838 {
11841 {
11844 }
11845 }
11847 {
11850 }
11851 }
11852 }
11854 /*
11855 * "isdirectory()" function
11856 */
11857 static void
11861 {
11863 }
11865 /*
11866 * "islocked()" function
11867 */
11868 static void
11872 {
11873 lval_T lv;
11879 FNE_CHECK_START);
11881 {
11884 else
11885 {
11887 {
11890 else
11891 {
11894 {
11895 /* Consider a variable locked when:
11896 * 1. the variable itself is locked
11897 * 2. the value of the variable is locked.
11898 * 3. the List or Dict value is locked.
11899 */
11902 }
11903 }
11904 }
11910 /* List item. */
11912 else
11913 /* Dictionary item. */
11915 }
11916 }
11919 }
11923 /*
11924 * Turn a dict into a list:
11925 * "what" == 0: list of keys
11926 * "what" == 1: list of values
11927 * "what" == 2: list of items
11928 */
11929 static void
11934 {
11945 {
11948 }
11957 {
11959 {
11969 {
11970 /* keys() */
11974 }
11976 {
11977 /* values() */
11979 }
11980 else
11981 {
11982 /* items() */
12004 }
12005 }
12006 }
12007 }
12009 /*
12010 * "items(dict)" function
12011 */
12012 static void
12016 {
12018 }
12020 /*
12021 * "join()" function
12022 */
12023 static void
12027 {
12028 garray_T ga;
12033 {
12036 }
12041 else
12047 {
12052 }
12053 else
12055 }
12057 /*
12058 * "keys()" function
12059 */
12060 static void
12064 {
12066 }
12068 /*
12069 * "last_buffer_nr()" function.
12070 */
12071 /*ARGSUSED*/
12072 static void
12076 {
12085 }
12087 /*
12088 * "len()" function
12089 */
12090 static void
12094 {
12096 {
12111 }
12112 }
12116 static void
12121 {
12122 #ifdef FEAT_LIBCALL
12126 #endif
12131 else
12137 #ifdef FEAT_LIBCALL
12138 /* The first two args must be strings, otherwise its meaningless */
12140 {
12146 else
12150 string_in,
12152 string_result,
12156 }
12157 #endif
12158 }
12160 /*
12161 * "libcall()" function
12162 */
12163 static void
12167 {
12169 }
12171 /*
12172 * "libcallnr()" function
12173 */
12174 static void
12178 {
12180 }
12182 /*
12183 * "line(string)" function
12184 */
12185 static void
12189 {
12198 }
12200 /*
12201 * "line2byte(lnum)" function
12202 */
12203 /*ARGSUSED*/
12204 static void
12208 {
12209 #ifndef FEAT_BYTEOFF
12211 #else
12212 linenr_T lnum;
12217 else
12221 #endif
12222 }
12224 /*
12225 * "lispindent(lnum)" function
12226 */
12227 static void
12231 {
12232 #ifdef FEAT_LISP
12233 pos_T pos;
12234 linenr_T lnum;
12239 {
12243 }
12244 else
12245 #endif
12247 }
12249 /*
12250 * "localtime()" function
12251 */
12252 /*ARGSUSED*/
12253 static void
12257 {
12259 }
12263 static void
12268 {
12275 garray_T ga;
12278 /* return empty string for failure */
12287 {
12291 }
12292 else
12303 {
12313 }
12314 }
12316 /*
12317 * "map()" function
12318 */
12319 static void
12323 {
12325 }
12327 /*
12328 * "maparg()" function
12329 */
12330 static void
12334 {
12336 }
12338 /*
12339 * "mapcheck()" function
12340 */
12341 static void
12345 {
12347 }
12351 static void
12356 {
12360 regmatch_T regmatch;
12373 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12379 {
12380 /* return empty list when there are no matches */
12383 }
12385 {
12388 }
12391 {
12395 }
12396 else
12404 {
12411 {
12416 }
12417 else
12418 {
12423 /* When "count" argument is there ignore matches before "start",
12424 * otherwise skip part of the string. Differs when pattern is "^"
12425 * or "\<". */
12428 else
12430 }
12436 }
12440 {
12444 {
12446 {
12448 {
12451 }
12456 }
12465 /* Advance to just after the match. */
12467 {
12470 }
12471 else
12472 {
12473 #ifdef FEAT_MBYTE
12476 #else
12478 #endif
12479 }
12480 }
12483 {
12485 {
12488 /* return list with matched string and submatches */
12490 {
12492 {
12496 }
12502 }
12503 }
12505 {
12506 /* return matched string */
12509 else
12512 }
12515 else
12516 {
12520 else
12524 }
12525 }
12527 }
12529 theend:
12532 }
12534 /*
12535 * "match()" function
12536 */
12537 static void
12541 {
12543 }
12545 /*
12546 * "matchadd()" function
12547 */
12548 static void
12552 {
12553 #ifdef FEAT_SEARCH_EXTRA
12566 {
12570 }
12574 {
12577 }
12580 #endif
12581 }
12583 /*
12584 * "matcharg()" function
12585 */
12586 static void
12590 {
12592 {
12593 #ifdef FEAT_SEARCH_EXTRA
12598 {
12600 {
12604 }
12605 else
12606 {
12609 }
12610 }
12611 #endif
12612 }
12613 }
12615 /*
12616 * "matchdelete()" function
12617 */
12618 static void
12622 {
12623 #ifdef FEAT_SEARCH_EXTRA
12626 #endif
12627 }
12629 /*
12630 * "matchend()" function
12631 */
12632 static void
12636 {
12638 }
12640 /*
12641 * "matchlist()" function
12642 */
12643 static void
12647 {
12649 }
12651 /*
12652 * "matchstr()" function
12653 */
12654 static void
12658 {
12660 }
12664 static void
12669 {
12675 {
12681 {
12684 {
12687 {
12694 }
12695 }
12696 }
12697 }
12699 {
12707 {
12710 {
12712 {
12716 {
12719 }
12722 }
12723 }
12724 }
12725 }
12726 else
12729 }
12731 /*
12732 * "max()" function
12733 */
12734 static void
12738 {
12740 }
12742 /*
12743 * "min()" function
12744 */
12745 static void
12749 {
12751 }
12755 /*
12756 * Create the directory in which "dir" is located, and higher levels when
12757 * needed.
12758 */
12759 static int
12763 {
12768 /* Get end of directory name in "dir".
12769 * We're done when it's "/" or "c:/". */
12774 /* If the directory exists we're done. Otherwise: create it.*/
12784 }
12786 #ifdef vim_mkdir
12787 /*
12788 * "mkdir()" function
12789 */
12790 static void
12794 {
12805 {
12810 }
12812 }
12813 #endif
12815 /*
12816 * "mode()" function
12817 */
12818 /*ARGSUSED*/
12819 static void
12823 {
12826 #ifdef FEAT_VISUAL
12828 {
12831 else
12833 }
12834 else
12835 #endif
12839 {
12842 else
12844 }
12847 else
12853 }
12855 /*
12856 * "nextnonblank()" function
12857 */
12858 static void
12862 {
12863 linenr_T lnum;
12866 {
12868 {
12871 }
12874 }
12876 }
12878 /*
12879 * "nr2char()" function
12880 */
12881 static void
12885 {
12888 #ifdef FEAT_MBYTE
12891 else
12892 #endif
12893 {
12896 }
12899 }
12901 /*
12902 * "pathshorten()" function
12903 */
12904 static void
12908 {
12915 else
12916 {
12921 }
12922 }
12924 /*
12925 * "prevnonblank()" function
12926 */
12927 static void
12931 {
12932 linenr_T lnum;
12937 else
12941 }
12943 #ifdef HAVE_STDARG_H
12944 /* This dummy va_list is here because:
12945 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12946 * - locally in the function results in a "used before set" warning
12947 * - using va_start() to initialize it gives "function with fixed args" error */
12949 #endif
12951 /*
12952 * "printf()" function
12953 */
12954 static void
12958 {
12962 {
12969 /* Get the required length, allocate the buffer and do it for real. */
12974 {
12977 {
12980 }
12981 }
12983 }
12984 #endif
12985 }
12987 /*
12988 * "pumvisible()" function
12989 */
12990 /*ARGSUSED*/
12991 static void
12995 {
12997 #ifdef FEAT_INS_EXPAND
13000 #endif
13001 }
13003 /*
13004 * "range()" function
13005 */
13006 static void
13010 {
13019 {
13022 }
13023 else
13024 {
13028 }
13037 else
13038 {
13044 }
13045 }
13047 /*
13048 * "readfile()" function
13049 */
13050 static void
13054 {
13074 {
13079 }
13084 /* Always open the file in binary mode, library functions have a mind of
13085 * their own about CR-LF conversion. */
13088 {
13091 }
13095 {
13100 {
13102 {
13103 /* Only when in binary mode add an empty list item when the
13104 * last line ends in a '\n'. */
13108 /* Found end-of-line or end-of-file: add a text line to the
13109 * list. */
13118 else
13119 {
13122 {
13128 }
13129 }
13134 {
13137 }
13147 }
13150 }
13155 {
13156 /* "buf" is full, need to move text to an allocated buffer */
13158 {
13161 }
13162 else
13163 {
13166 {
13172 }
13173 }
13175 }
13176 else
13177 {
13180 }
13181 }
13183 /*
13184 * For a negative line count use only the lines at the end of the file,
13185 * free the rest.
13186 */
13189 {
13192 }
13196 }
13198 #if defined(FEAT_RELTIME)
13201 /*
13202 * Convert a List to proftime_T.
13203 * Return FAIL when there is something wrong.
13204 */
13205 static int
13209 {
13218 # ifdef WIN3264
13221 # else
13224 # endif
13226 }
13229 /*
13230 * "reltime()" function
13231 */
13232 static void
13236 {
13237 #ifdef FEAT_RELTIME
13238 proftime_T res;
13239 proftime_T start;
13242 {
13243 /* No arguments: get current time. */
13245 }
13247 {
13251 }
13252 else
13253 {
13254 /* Two arguments: compute the difference. */
13259 }
13262 {
13265 # ifdef WIN3264
13268 # else
13271 # endif
13274 }
13275 #endif
13276 }
13278 /*
13279 * "reltimestr()" function
13280 */
13281 static void
13285 {
13286 #ifdef FEAT_RELTIME
13287 proftime_T tm;
13288 #endif
13292 #ifdef FEAT_RELTIME
13295 #endif
13296 }
13298 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13302 static void
13304 {
13306 # ifdef FEAT_GUI
13308 # endif
13309 )
13310 {
13314 }
13315 }
13317 static int
13319 {
13322 {
13325 }
13327 }
13328 #endif
13330 #ifdef FEAT_CLIENTSERVER
13333 static void
13338 {
13343 # ifdef WIN32
13344 HWND w;
13345 # else
13346 Window w;
13347 # endif
13352 # ifdef FEAT_X11
13355 # endif
13361 # ifdef WIN32
13363 # else
13366 # endif
13367 {
13370 else
13373 }
13378 {
13379 dictitem_T v;
13390 }
13391 }
13392 #endif
13394 /*
13395 * "remote_expr()" function
13396 */
13397 /*ARGSUSED*/
13398 static void
13402 {
13405 #ifdef FEAT_CLIENTSERVER
13407 #endif
13408 }
13410 /*
13411 * "remote_foreground()" function
13412 */
13413 /*ARGSUSED*/
13414 static void
13418 {
13420 #ifdef FEAT_CLIENTSERVER
13421 # ifdef WIN32
13422 /* On Win32 it's done in this application. */
13423 {
13428 }
13429 # else
13430 /* Send a foreground() expression to the server. */
13436 # endif
13437 #endif
13438 }
13440 /*ARGSUSED*/
13441 static void
13445 {
13446 #ifdef FEAT_CLIENTSERVER
13447 dictitem_T v;
13449 # ifdef WIN32
13451 # endif
13455 {
13458 }
13461 {
13464 }
13465 # ifdef WIN32
13469 else
13470 {
13473 }
13474 # else
13481 # endif
13484 {
13493 }
13494 #else
13496 #endif
13497 }
13499 /*ARGSUSED*/
13500 static void
13504 {
13507 #ifdef FEAT_CLIENTSERVER
13511 {
13512 # ifdef WIN32
13513 /* The server's HWND is encoded in the 'id' parameter */
13520 # else
13523 # endif
13525 }
13526 #endif
13529 }
13531 /*
13532 * "remote_send()" function
13533 */
13534 /*ARGSUSED*/
13535 static void
13539 {
13542 #ifdef FEAT_CLIENTSERVER
13544 #endif
13545 }
13547 /*
13548 * "remove()" function
13549 */
13550 static void
13554 {
13566 {
13571 {
13574 {
13578 else
13579 {
13583 }
13584 }
13585 }
13586 }
13591 {
13599 else
13600 {
13602 {
13603 /* Remove one item, return its value. */
13607 }
13608 else
13609 {
13610 /* Remove range of items, return list with values. */
13616 else
13617 {
13621 {
13625 }
13628 else
13629 {
13632 {
13639 }
13640 }
13641 }
13642 }
13643 }
13644 }
13645 }
13647 /*
13648 * "rename({from}, {to})" function
13649 */
13650 static void
13654 {
13659 else
13662 }
13664 /*
13665 * "repeat()" function
13666 */
13667 /*ARGSUSED*/
13668 static void
13672 {
13682 {
13688 }
13689 else
13690 {
13702 {
13706 }
13709 }
13710 }
13712 /*
13713 * "resolve()" function
13714 */
13715 static void
13719 {
13723 #ifdef FEAT_SHORTCUT
13724 {
13730 else
13732 }
13733 #else
13734 # ifdef HAVE_READLINK
13735 {
13757 {
13758 /* Separate the first path component in "p", and keep the
13759 * remainder (beginning with the path separator). */
13762 }
13765 {
13767 {
13774 {
13780 }
13782 /* Ensure that the result will have a trailing path separator
13783 * if the argument has one. */
13787 /* Separate the first path component in the link value and
13788 * concatenate the remainders. */
13791 {
13794 else
13795 {
13798 {
13801 }
13802 }
13804 }
13808 {
13809 /* Ignore trailing path separator. */
13812 }
13814 {
13815 /* symlink is relative to directory of argument */
13818 {
13823 }
13824 }
13825 else
13826 {
13829 }
13830 }
13835 /* Append the first path component of "remain" to "p". */
13840 {
13844 }
13845 /* Shorten "remain". */
13848 else
13849 {
13852 }
13853 }
13855 /* If the result is a relative path name, make it explicitly relative to
13856 * the current directory if and only if the argument had this form. */
13858 {
13867 {
13868 /* Prepend "./". */
13871 {
13874 }
13875 }
13877 {
13878 /* Strip leading "./". */
13884 }
13885 }
13887 /* Ensure that the result will have no trailing path separator
13888 * if the argument had none. But keep "/" or "//". */
13890 {
13894 }
13897 }
13898 # else
13900 # endif
13901 #endif
13905 #ifdef HAVE_READLINK
13906 fail:
13907 #endif
13909 }
13911 /*
13912 * "reverse({list})" function
13913 */
13914 static void
13918 {
13927 {
13932 {
13936 }
13940 }
13941 }
13953 /*
13954 * Get flags for a search function.
13955 * Possibly sets "p_ws".
13956 * Returns BACKWARD, FORWARD or zero (for an error).
13957 */
13958 static int
13962 {
13969 {
13974 {
13976 {
13983 {
13991 }
13993 {
13996 }
13997 else
13999 }
14003 }
14004 }
14006 }
14008 /*
14009 * Shared by search() and searchpos() functions
14010 */
14011 static int
14016 {
14019 pos_T pos;
14020 pos_T save_cursor;
14025 proftime_T tm;
14026 #ifdef FEAT_RELTIME
14028 #endif
14042 /* Optional arguments: line number to stop searching and timeout. */
14044 {
14048 #ifdef FEAT_RELTIME
14050 {
14054 }
14055 #endif
14056 }
14058 #ifdef FEAT_RELTIME
14059 /* Set the time limit, if there is one. */
14061 #endif
14063 /*
14064 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14065 * Check to make sure only those flags are set.
14066 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14067 * flags cannot be set. Check for that condition also.
14068 */
14071 {
14074 }
14080 {
14083 else
14089 {
14090 /* Store the match cursor position */
14093 }
14094 /* "/$" will put the cursor after the end of the line, may need to
14095 * correct that here */
14097 }
14099 /* If 'n' flag is used: restore cursor position. */
14102 else
14104 theend:
14108 }
14110 /*
14111 * "search()" function
14112 */
14113 static void
14117 {
14121 }
14123 /*
14124 * "searchdecl()" function
14125 */
14126 static void
14130 {
14140 {
14144 }
14148 }
14150 /*
14151 * Used by searchpair() and searchpairpos()
14152 */
14153 static int
14157 {
14170 /* Get the three pattern arguments: start, middle, end. */
14177 /* Handle the optional fourth argument: flags */
14182 /* Don't accept SP_END or SP_SUBPAT.
14183 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14184 */
14187 {
14190 }
14192 /* Using 'r' implies 'W', otherwise it doesn't work. */
14196 /* Optional fifth argument: skip expression */
14200 else
14201 {
14204 {
14208 #ifdef FEAT_RELTIME
14210 {
14214 }
14215 #endif
14216 }
14217 }
14224 theend:
14228 }
14230 /*
14231 * "searchpair()" function
14232 */
14233 static void
14237 {
14239 }
14241 /*
14242 * "searchpairpos()" function
14243 */
14244 static void
14248 {
14249 pos_T match_pos;
14259 {
14262 }
14266 }
14268 /*
14269 * Search for a start/middle/end thing.
14270 * Used by searchpair(), see its documentation for the details.
14271 * Returns 0 or -1 for no match,
14272 */
14273 long
14285 {
14289 pos_T pos;
14290 pos_T firstpos;
14291 pos_T foundpos;
14292 pos_T save_cursor;
14293 pos_T save_pos;
14299 proftime_T tm;
14301 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14305 #ifdef FEAT_RELTIME
14306 /* Set the time limit, if there is one. */
14308 #endif
14310 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14311 * start/middle/end (pat3, for the top pair). */
14319 else
14331 {
14335 /* didn't find it or found the first match again: FAIL */
14341 {
14342 /* Found the same position again. Can happen with a pattern that
14343 * has "\zs" at the end and searching backwards. Advance one
14344 * character and try again. */
14347 else
14349 }
14352 /* clear the start flag to avoid getting stuck here */
14355 /* If the skip pattern matches, ignore this match. */
14357 {
14363 {
14364 /* Evaluating {skip} caused an error, break here. */
14368 }
14371 }
14374 {
14375 /* Found end when searching backwards or start when searching
14376 * forward: nested pair. */
14379 }
14380 else
14381 {
14382 /* Found end when searching forward or start when searching
14383 * backward: end of (nested) pair; or found middle in outer pair. */
14386 }
14389 {
14390 /* Found the match: return matchcount or line number. */
14393 else
14401 }
14402 }
14405 {
14406 /* Store the match cursor position */
14409 }
14411 /* If 'n' flag is used or search failed: restore cursor position. */
14415 theend:
14421 }
14423 /*
14424 * "searchpos()" function
14425 */
14426 static void
14430 {
14431 pos_T match_pos;
14444 {
14447 }
14453 }
14456 /*ARGSUSED*/
14457 static void
14461 {
14462 #ifdef FEAT_CLIENTSERVER
14472 # ifdef FEAT_X11
14475 # endif
14478 {
14481 }
14483 #else
14485 #endif
14486 }
14488 /*ARGSUSED*/
14489 static void
14493 {
14496 #ifdef FEAT_CLIENTSERVER
14497 # ifdef WIN32
14499 # else
14503 # endif
14504 #endif
14507 }
14509 /*
14510 * "setbufvar()" function
14511 */
14512 /*ARGSUSED*/
14513 static void
14517 {
14519 aco_save_T aco;
14534 {
14535 /* set curbuf to be our buf, temporarily */
14539 {
14549 }
14550 else
14551 {
14554 {
14559 }
14560 }
14562 /* reset notion of buffer */
14564 }
14565 }
14567 /*
14568 * "setcmdpos()" function
14569 */
14570 static void
14574 {
14579 }
14581 /*
14582 * "setline()" function
14583 */
14584 static void
14588 {
14589 linenr_T lnum;
14598 {
14601 }
14602 else
14607 {
14609 {
14610 /* list argument, get next string */
14615 }
14621 {
14622 /* existing line, replace it */
14624 {
14629 }
14630 }
14632 {
14633 /* lnum is one past the last line, append the line */
14637 }
14642 }
14646 }
14648 /*
14649 * Used by "setqflist()" and "setloclist()" functions
14650 */
14651 /*ARGSUSED*/
14652 static void
14658 {
14659 #ifdef FEAT_QUICKFIX
14662 #endif
14666 #ifdef FEAT_QUICKFIX
14669 else
14670 {
14674 {
14680 }
14684 }
14685 #endif
14686 }
14688 /*
14689 * "setloclist()" function
14690 */
14691 /*ARGSUSED*/
14692 static void
14696 {
14704 }
14706 /*
14707 * "setmatches()" function
14708 */
14709 static void
14713 {
14714 #ifdef FEAT_SEARCH_EXTRA
14721 {
14724 }
14726 {
14728 /* To some extent make sure that we are dealing with a list from
14729 * "getmatches()". */
14732 {
14735 {
14738 }
14743 {
14746 }
14748 }
14753 {
14760 }
14762 }
14763 #endif
14764 }
14766 /*
14767 * "setpos()" function
14768 */
14769 /*ARGSUSED*/
14770 static void
14774 {
14775 pos_T pos;
14782 {
14784 {
14787 {
14788 /* set cursor */
14790 {
14794 }
14795 else
14797 }
14799 {
14800 /* set mark */
14803 }
14804 else
14806 }
14807 }
14808 }
14810 /*
14811 * "setqflist()" function
14812 */
14813 /*ARGSUSED*/
14814 static void
14818 {
14820 }
14822 /*
14823 * "setreg()" function
14824 */
14825 static void
14829 {
14835 char_u yank_type;
14854 {
14860 {
14870 #ifdef FEAT_VISUAL
14874 {
14878 }
14880 #endif
14881 }
14882 }
14889 }
14891 /*
14892 * "settabwinvar()" function
14893 */
14894 static void
14898 {
14900 }
14902 /*
14903 * "setwinvar()" function
14904 */
14905 static void
14909 {
14911 }
14913 /*
14914 * "setwinvar()" and "settabwinvar()" functions
14915 */
14916 static void
14921 {
14923 #ifdef FEAT_WINDOWS
14926 #endif
14937 #ifdef FEAT_WINDOWS
14940 else
14942 #endif
14948 {
14949 #ifdef FEAT_WINDOWS
14950 /* set curwin to be our win, temporarily */
14958 #endif
14961 {
14971 }
14972 else
14973 {
14976 {
14981 }
14982 }
14984 #ifdef FEAT_WINDOWS
14985 /* Restore current tabpage and window, if still valid (autocomands can
14986 * make them invalid). */
14990 {
14993 }
14994 #endif
14995 }
14996 }
14998 /*
14999 * "shellescape({string})" function
15000 */
15001 static void
15005 {
15008 }
15010 /*
15011 * "simplify()" function
15012 */
15013 static void
15017 {
15024 }
15026 static int
15027 #ifdef __BORLANDC__
15028 _RTLENTRYF
15029 #endif
15031 static int
15032 #ifdef __BORLANDC__
15033 _RTLENTRYF
15034 #endif
15040 #define ITEM_COMPARE_FAIL 999
15042 /*
15043 * Compare functions for f_sort() below.
15044 */
15045 static int
15046 #ifdef __BORLANDC__
15047 _RTLENTRYF
15048 #endif
15052 {
15067 else
15072 }
15074 static int
15075 #ifdef __BORLANDC__
15076 _RTLENTRYF
15077 #endif
15081 {
15083 typval_T rettv;
15087 /* shortcut after failure in previous call; compare all items equal */
15091 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15092 * in the copy without changing the original list items. */
15104 else
15105 /* return value has wrong type */
15111 }
15113 /*
15114 * "sort({list})" function
15115 */
15116 static void
15120 {
15130 else
15131 {
15146 {
15149 else
15150 {
15158 else
15160 }
15161 }
15163 /* Make an array with each entry pointing to an item in the List. */
15172 /* test the compare function */
15177 else
15178 {
15179 /* Sort the array with item pointers. */
15184 {
15185 /* Clear the List and append the items in the sorted order. */
15190 }
15191 }
15194 }
15195 }
15197 /*
15198 * "soundfold({word})" function
15199 */
15200 static void
15204 {
15209 #ifdef FEAT_SPELL
15211 #else
15213 #endif
15214 }
15216 /*
15217 * "spellbadword()" function
15218 */
15219 /* ARGSUSED */
15220 static void
15224 {
15232 #ifdef FEAT_SPELL
15234 {
15235 /* Find the start and length of the badly spelled word. */
15239 }
15241 {
15246 {
15247 /* Check the argument for spelling. */
15249 {
15252 {
15255 }
15257 }
15258 }
15259 }
15260 #endif
15269 }
15271 /*
15272 * "spellsuggest()" function
15273 */
15274 /*ARGSUSED*/
15275 static void
15279 {
15280 #ifdef FEAT_SPELL
15284 garray_T ga;
15288 #endif
15293 #ifdef FEAT_SPELL
15295 {
15298 {
15303 {
15307 }
15308 }
15309 else
15315 {
15321 else
15322 {
15327 }
15328 }
15330 }
15331 #endif
15332 }
15334 static void
15338 {
15342 regmatch_T regmatch;
15350 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15356 {
15362 }
15373 {
15376 {
15379 else
15383 else
15387 {
15391 }
15394 /* Advance to just after the match. */
15397 else
15398 {
15399 /* Don't get stuck at the same match. */
15400 #ifdef FEAT_MBYTE
15402 #else
15404 #endif
15405 }
15407 }
15410 }
15413 }
15415 /*
15416 * "str2nr()" function
15417 */
15418 static void
15422 {
15428 {
15431 {
15434 }
15435 }
15440 }
15442 #ifdef HAVE_STRFTIME
15443 /*
15444 * "strftime({format}[, {time}])" function
15445 */
15446 static void
15450 {
15461 else
15464 /* MSVC returns NULL for an invalid value of seconds. */
15467 else
15468 {
15469 # ifdef FEAT_MBYTE
15470 vimconv_T conv;
15478 # endif
15482 else
15485 # ifdef FEAT_MBYTE
15491 else
15492 # endif
15495 # ifdef FEAT_MBYTE
15496 /* Release conversion descriptors */
15499 # endif
15500 }
15501 }
15502 #endif
15504 /*
15505 * "stridx()" function
15506 */
15507 static void
15511 {
15526 {
15534 }
15539 }
15541 /*
15542 * "string()" function
15543 */
15544 static void
15548 {
15554 /* Make a copy if we have a value but it's not in allocate memory. */
15557 }
15559 /*
15560 * "strlen()" function
15561 */
15562 static void
15566 {
15569 }
15571 /*
15572 * "strpart()" function
15573 */
15574 static void
15578 {
15593 else
15596 /*
15597 * Only return the overlap between the specified part and the actual
15598 * string.
15599 */
15601 {
15604 }
15614 }
15616 /*
15617 * "strridx()" function
15618 */
15619 static void
15623 {
15640 {
15641 /* Third argument: upper limit for index */
15645 }
15646 else
15650 {
15651 /* Empty string matches past the end. */
15653 }
15654 else
15655 {
15657 {
15662 }
15663 }
15667 else
15669 }
15671 /*
15672 * "strtrans()" function
15673 */
15674 static void
15678 {
15681 }
15683 /*
15684 * "submatch()" function
15685 */
15686 static void
15690 {
15694 }
15696 /*
15697 * "substitute()" function
15698 */
15699 static void
15703 {
15716 else
15718 }
15720 /*
15721 * "synID(lnum, col, trans)" function
15722 */
15723 /*ARGSUSED*/
15724 static void
15728 {
15730 #ifdef FEAT_SYN_HL
15743 #endif
15746 }
15748 /*
15749 * "synIDattr(id, what [, mode])" function
15750 */
15751 /*ARGSUSED*/
15752 static void
15756 {
15758 #ifdef FEAT_SYN_HL
15768 {
15772 #ifdef FEAT_GUI
15774 #endif
15775 )
15777 }
15778 else
15779 {
15780 #ifdef FEAT_GUI
15783 else
15784 #endif
15787 else
15789 }
15793 {
15826 /* underline */
15828 else
15829 /* undercurl */
15832 }
15836 #endif
15839 }
15841 /*
15842 * "synIDtrans(id)" function
15843 */
15844 /*ARGSUSED*/
15845 static void
15849 {
15852 #ifdef FEAT_SYN_HL
15857 else
15858 #endif
15862 }
15864 /*
15865 * "synstack(lnum, col)" function
15866 */
15867 /*ARGSUSED*/
15868 static void
15872 {
15873 #ifdef FEAT_SYN_HL
15878 #endif
15883 #ifdef FEAT_SYN_HL
15890 {
15893 {
15899 }
15900 }
15901 #endif
15902 }
15904 /*
15905 * "system()" function
15906 */
15907 static void
15911 {
15923 {
15924 /*
15925 * Write the string to a temp file, to be used for input of the shell
15926 * command.
15927 */
15929 {
15932 }
15936 {
15939 }
15942 {
15945 }
15951 {
15954 }
15955 }
15960 #ifdef USE_CR
15961 /* translate <CR> into <NL> */
15963 {
15967 {
15970 }
15971 }
15972 #else
15973 # ifdef USE_CRNL
15974 /* translate <CR><NL> into <NL> */
15976 {
15981 {
15985 }
15987 }
15988 # endif
15989 #endif
15991 done:
15993 {
15996 }
15999 }
16001 /*
16002 * "tabpagebuflist()" function
16003 */
16004 /* ARGSUSED */
16005 static void
16009 {
16010 #ifndef FEAT_WINDOWS
16012 #else
16018 else
16019 {
16023 }
16026 else
16027 {
16030 else
16031 {
16036 }
16037 }
16038 #endif
16039 }
16042 /*
16043 * "tabpagenr()" function
16044 */
16045 /* ARGSUSED */
16046 static void
16050 {
16052 #ifdef FEAT_WINDOWS
16056 {
16060 {
16063 else
16065 }
16066 }
16067 else
16069 #endif
16071 }
16074 #ifdef FEAT_WINDOWS
16077 /*
16078 * Common code for tabpagewinnr() and winnr().
16079 */
16080 static int
16084 {
16092 {
16099 {
16103 }
16104 else
16105 {
16108 }
16109 }
16114 {
16116 {
16117 /* didn't find it in this tabpage */
16120 }
16122 }
16124 }
16125 #endif
16127 /*
16128 * "tabpagewinnr()" function
16129 */
16130 /* ARGSUSED */
16131 static void
16135 {
16137 #ifdef FEAT_WINDOWS
16143 else
16145 #endif
16147 }
16150 /*
16151 * "tagfiles()" function
16152 */
16153 /*ARGSUSED*/
16154 static void
16158 {
16160 tagname_T tn;
16164 {
16167 }
16174 }
16176 /*
16177 * "taglist()" function
16178 */
16179 static void
16183 {
16194 }
16196 /*
16197 * "tempname()" function
16198 */
16199 /*ARGSUSED*/
16200 static void
16204 {
16210 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16211 * names. Skip 'I' and 'O', they are used for shell redirection. */
16212 do
16213 {
16218 else
16219 {
16220 #ifdef EBCDIC
16225 else
16226 #endif
16228 }
16230 }
16232 /*
16233 * "test(list)" function: Just checking the walls...
16234 */
16235 /*ARGSUSED*/
16236 static void
16240 {
16241 /* Used for unit testing. Change the code below to your liking. */
16242 #if 0
16261 #endif
16262 }
16264 /*
16265 * "tolower(string)" function
16266 */
16267 static void
16271 {
16280 {
16281 #ifdef FEAT_MBYTE
16285 {
16291 /* TODO: reallocate string when byte count changes. */
16295 }
16298 else
16299 #endif
16300 {
16303 }
16304 }
16305 }
16307 /*
16308 * "toupper(string)" function
16309 */
16310 static void
16314 {
16317 }
16319 /*
16320 * "tr(string, fromstr, tostr)" function
16321 */
16322 static void
16326 {
16331 #ifdef FEAT_MBYTE
16339 #endif
16342 garray_T ga;
16348 /* Default return value: empty string. */
16355 #ifdef FEAT_MBYTE
16357 #endif
16358 /* not multi-byte: fromstr and tostr must be the same length */
16360 {
16361 #ifdef FEAT_MBYTE
16362 error:
16363 #endif
16367 }
16369 /* fromstr and tostr have to contain the same number of chars */
16371 {
16372 #ifdef FEAT_MBYTE
16374 {
16380 {
16383 {
16385 {
16388 {
16392 }
16393 }
16397 }
16399 }
16402 {
16403 /* Check that fromstr and tostr have the same number of
16404 * (multi-byte) characters. Done only once when a character
16405 * of instr doesn't appear in fromstr. */
16408 {
16411 }
16414 }
16421 }
16422 else
16423 #endif
16424 {
16425 /* When not using multi-byte chars we can do it faster. */
16429 else
16432 }
16433 }
16435 /* add a terminating NUL */
16440 }
16442 /*
16443 * "type(expr)" function
16444 */
16445 static void
16449 {
16453 {
16460 }
16462 }
16464 /*
16465 * "values(dict)" function
16466 */
16467 static void
16471 {
16473 }
16475 /*
16476 * "virtcol(string)" function
16477 */
16478 static void
16482 {
16490 {
16493 }
16496 }
16498 /*
16499 * "visualmode()" function
16500 */
16501 /*ARGSUSED*/
16502 static void
16506 {
16507 #ifdef FEAT_VISUAL
16515 /* A non-zero number or non-empty string argument: reset mode. */
16521 #else
16523 #endif
16524 }
16526 /*
16527 * "winbufnr(nr)" function
16528 */
16529 static void
16533 {
16539 else
16541 }
16543 /*
16544 * "wincol()" function
16545 */
16546 /*ARGSUSED*/
16547 static void
16551 {
16554 }
16556 /*
16557 * "winheight(nr)" function
16558 */
16559 static void
16563 {
16569 else
16571 }
16573 /*
16574 * "winline()" function
16575 */
16576 /*ARGSUSED*/
16577 static void
16581 {
16584 }
16586 /*
16587 * "winnr()" function
16588 */
16589 /* ARGSUSED */
16590 static void
16594 {
16597 #ifdef FEAT_WINDOWS
16599 #endif
16601 }
16603 /*
16604 * "winrestcmd()" function
16605 */
16606 /* ARGSUSED */
16607 static void
16611 {
16612 #ifdef FEAT_WINDOWS
16615 garray_T ga;
16620 {
16623 # ifdef FEAT_VERTSPLIT
16626 # endif
16628 }
16632 #else
16634 #endif
16636 }
16638 /*
16639 * "winrestview()" function
16640 */
16641 /* ARGSUSED */
16642 static void
16646 {
16652 else
16653 {
16656 #ifdef FEAT_VIRTUALEDIT
16658 #endif
16663 #ifdef FEAT_DIFF
16665 #endif
16678 #ifdef FEAT_DIFF
16680 #endif
16681 }
16682 }
16684 /*
16685 * "winsaveview()" function
16686 */
16687 /* ARGSUSED */
16688 static void
16692 {
16704 #ifdef FEAT_VIRTUALEDIT
16706 #endif
16711 #ifdef FEAT_DIFF
16713 #endif
16716 }
16718 /*
16719 * "winwidth(nr)" function
16720 */
16721 static void
16725 {
16731 else
16732 #ifdef FEAT_VERTSPLIT
16734 #else
16736 #endif
16737 }
16739 /*
16740 * "writefile()" function
16741 */
16742 static void
16746 {
16759 {
16762 }
16770 /* Always open the file in binary mode, library functions have a mind of
16771 * their own about CR-LF conversion. */
16774 {
16777 }
16778 else
16779 {
16782 {
16784 {
16787 else
16790 {
16793 }
16794 }
16797 {
16800 }
16802 {
16805 }
16806 }
16808 }
16811 }
16813 /*
16814 * Translate a String variable into a position.
16815 * Returns NULL when there is an error.
16816 */
16822 {
16827 /* Argument can be [lnum, col, coladd]. */
16829 {
16839 /* Get the line number */
16844 /* Get the column number */
16850 /* We accept "$" for the column number: last column. */
16857 /* Accept a position up to the NUL after the line. */
16862 #ifdef FEAT_VIRTUALEDIT
16863 /* Get the virtual offset. Defaults to zero. */
16867 #endif
16870 }
16878 {
16883 }
16885 #ifdef FEAT_VIRTUALEDIT
16887 #endif
16890 {
16893 {
16897 }
16899 {
16903 }
16904 }
16906 {
16908 {
16911 }
16912 else
16913 {
16916 }
16918 }
16920 }
16922 /*
16923 * Convert list in "arg" into a position and optional file number.
16924 * When "fnump" is NULL there is no file number, only 3 items.
16925 * Note that the column is passed on as-is, the caller may want to decrement
16926 * it to use 1 for the first column.
16927 * Return FAIL when conversion is not possible, doesn't check the position for
16928 * validity.
16929 */
16930 static int
16935 {
16940 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16941 * when "fnump" isn't NULL and "coladd" is optional. */
16949 {
16956 }
16968 #ifdef FEAT_VIRTUALEDIT
16972 else
16974 #endif
16977 }
16979 /*
16980 * Get the length of an environment variable name.
16981 * Advance "arg" to the first character after the name.
16982 * Return 0 for error.
16983 */
16984 static int
16987 {
16992 ;
16999 }
17001 /*
17002 * Get the length of the name of a function or internal variable.
17003 * "arg" is advanced to the first non-white character after the name.
17004 * Return 0 if something is wrong.
17005 */
17006 static int
17009 {
17013 /* Find the end of the name. */
17015 ;
17023 }
17025 /*
17026 * Get the length of the name of a variable or function.
17027 * Only the name is recognized, does not handle ".key" or "[idx]".
17028 * "arg" is advanced to the first non-white character after the name.
17029 * Return -1 if curly braces expansion failed.
17030 * Return 0 if something else is wrong.
17031 * If the name contains 'magic' {}'s, expand them and return the
17032 * expanded name in an allocated string via 'alias' - caller must free.
17033 */
17034 static int
17040 {
17050 {
17051 /* hard coded <SNR>, already translated */
17054 }
17057 {
17058 /* literal "<SID>", "s:" or "<SNR>" */
17060 }
17062 /*
17063 * Find the end of the name; check for {} construction.
17064 */
17068 {
17072 {
17076 }
17078 /*
17079 * Include any <SID> etc in the expanded string:
17080 * Thus the -len here.
17081 */
17088 }
17095 }
17097 /*
17098 * Find the end of a variable or function name, taking care of magic braces.
17099 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17100 * start and end of the first magic braces item.
17101 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17102 * Return a pointer to just after the name. Equal to "arg" if there is no
17103 * valid name.
17104 */
17111 {
17117 {
17120 }
17122 /* Quick check for valid starting character. */
17132 {
17134 {
17135 /* skip over 'string' to avoid counting [ and ] inside it. */
17137 ;
17140 }
17142 {
17143 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17149 }
17152 {
17157 }
17160 {
17162 {
17163 mb_nest++;
17166 }
17168 {
17169 mb_nest--;
17172 }
17173 }
17174 }
17177 }
17179 /*
17180 * Expands out the 'magic' {}'s in a variable/function name.
17181 * Note that this can call itself recursively, to deal with
17182 * constructs like foo{bar}{baz}{bam}
17183 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17184 * "in_start" ^
17185 * "expr_start" ^
17186 * "expr_end" ^
17187 * "in_end" ^
17188 *
17189 * Returns a new allocated string, which the caller must free.
17190 * Returns NULL for failure.
17191 */
17198 {
17199 char_u c1;
17213 {
17217 {
17221 }
17222 }
17230 {
17233 {
17234 /* Further expansion! */
17239 }
17240 }
17243 }
17245 /*
17246 * Return TRUE if character "c" can be used in a variable or function name.
17247 * Does not include '{' or '}' for magic braces.
17248 */
17249 static int
17252 {
17254 }
17256 /*
17257 * Return TRUE if character "c" can be used as the first character in a
17258 * variable or function name (excluding '{' and '}').
17259 */
17260 static int
17263 {
17265 }
17267 /*
17268 * Set number v: variable to "val".
17269 */
17270 void
17274 {
17276 }
17278 /*
17279 * Get number v: variable value.
17280 */
17281 long
17284 {
17286 }
17288 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17289 /*
17290 * Get string v: variable value. Uses a static buffer, can only be used once.
17291 */
17292 char_u *
17295 {
17297 }
17298 #endif
17300 /*
17301 * Set v:count, v:count1 and v:prevcount.
17302 */
17303 void
17307 {
17311 }
17313 /*
17314 * Set string v: variable to a copy of "val".
17315 */
17316 void
17321 {
17322 /* Need to do this (at least) once, since we can't initialize a union.
17323 * Will always be invoked when "v:progname" is set. */
17331 else
17333 }
17335 /*
17336 * Set v:register if needed.
17337 */
17338 void
17341 {
17342 char_u regname;
17346 else
17348 /* Avoid free/alloc when the value is already right. */
17351 }
17353 /*
17354 * Get or set v:exception. If "oldval" == NULL, return the current value.
17355 * Otherwise, restore the value to "oldval" and return NULL.
17356 * Must always be called in pairs to save and restore v:exception! Does not
17357 * take care of memory allocations.
17358 */
17359 char_u *
17362 {
17368 }
17370 /*
17371 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17372 * Otherwise, restore the value to "oldval" and return NULL.
17373 * Must always be called in pairs to save and restore v:throwpoint! Does not
17374 * take care of memory allocations.
17375 */
17376 char_u *
17379 {
17385 }
17387 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17388 /*
17389 * Set v:cmdarg.
17390 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17391 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17392 * Must always be called in pairs!
17393 */
17394 char_u *
17398 {
17405 {
17409 }
17415 else
17423 # ifdef FEAT_MBYTE
17428 # endif
17438 else
17447 # ifdef FEAT_MBYTE
17454 # endif
17457 }
17458 #endif
17460 /*
17461 * Get the value of internal variable "name".
17462 * Return OK or FAIL.
17463 */
17464 static int
17470 {
17473 typval_T atv;
17477 /* truncate the name, so that we can use strcmp() */
17481 /*
17482 * Check for "b:changedtick".
17483 */
17485 {
17489 }
17491 /*
17492 * Check for user-defined variables.
17493 */
17494 else
17495 {
17499 }
17502 {
17506 }
17513 }
17515 /*
17516 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17517 * Also handle function call with Funcref variable: func(expr)
17518 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17519 */
17520 static int
17526 {
17531 typval_T functv;
17538 {
17540 {
17541 /* need to copy the funcref so that we can clear rettv */
17545 /* Invoke the function. Recursive! */
17551 /* Clear the funcref afterwards, so that deleting it while
17552 * evaluating the arguments is possible (see test55). */
17555 /* Stop the expression evaluation when immediately aborting on
17556 * error, or when an interrupt occurred or an exception was thrown
17557 * but not caught. */
17559 {
17563 }
17566 }
17568 {
17571 {
17575 }
17576 else
17579 {
17582 }
17583 }
17584 }
17587 }
17589 /*
17590 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17591 * value).
17592 */
17595 {
17597 }
17599 /*
17600 * Allocate memory for a variable type-value, and assign a string to it.
17601 * The string "s" must have been allocated, it is consumed.
17602 * Return NULL for out of memory, the variable otherwise.
17603 */
17607 {
17612 {
17615 }
17616 else
17619 }
17621 /*
17622 * Free the memory for a variable type-value.
17623 */
17624 void
17627 {
17629 {
17631 {
17634 /*FALLTHROUGH*/
17650 }
17652 }
17653 }
17655 /*
17656 * Free the memory for a variable value and set the value to NULL or 0.
17657 */
17658 void
17661 {
17663 {
17665 {
17668 /*FALLTHROUGH*/
17688 }
17690 }
17691 }
17693 /*
17694 * Set the value of a variable to NULL without freeing items.
17695 */
17696 static void
17699 {
17702 }
17704 /*
17705 * Get the number value of a variable.
17706 * If it is a String variable, uses vim_str2nr().
17707 * For incompatible types, return 0.
17708 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17709 * caller of incompatible types: it sets *denote to TRUE if "denote"
17710 * is not NULL or returns -1 otherwise.
17711 */
17712 static long
17715 {
17719 }
17721 long
17725 {
17729 {
17749 }
17752 else
17755 }
17757 /*
17758 * Get the lnum from the first argument.
17759 * Also accepts ".", "$", etc., but that only works for the current buffer.
17760 * Returns -1 on error.
17761 */
17762 static linenr_T
17765 {
17766 typval_T rettv;
17767 linenr_T lnum;
17771 {
17776 }
17778 }
17780 /*
17781 * Get the lnum from the first argument.
17782 * Also accepts "$", then "buf" is used.
17783 * Returns 0 on error.
17784 */
17785 static linenr_T
17789 {
17796 }
17798 /*
17799 * Get the string value of a variable.
17800 * If it is a Number variable, the number is converted into a string.
17801 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17802 * get_tv_string_buf() uses a given buffer.
17803 * If the String variable has never been set, return an empty string.
17804 * Never returns NULL;
17805 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17806 * NULL on error.
17807 */
17811 {
17815 }
17821 {
17825 }
17827 char_u *
17830 {
17834 }
17840 {
17842 {
17862 }
17864 }
17866 /*
17867 * Find variable "name" in the list of variables.
17868 * Return a pointer to it if found, NULL if not found.
17869 * Careful: "a:0" variables don't have a name.
17870 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17871 * hashtab_T used.
17872 */
17877 {
17887 }
17889 /*
17890 * Find variable "varname" in hashtab "ht".
17891 * Returns NULL if not found.
17892 */
17898 {
17902 {
17903 /* Must be something like "s:", otherwise "ht" would be NULL. */
17905 {
17911 #ifdef FEAT_WINDOWS
17913 #endif
17918 }
17920 }
17924 {
17925 /* For global variables we may try auto-loading the script. If it
17926 * worked find the variable again. Don't auto-load a script if it was
17927 * loaded already, otherwise it would be loaded every time when
17928 * checking if a function name is a Funcref variable. */
17934 }
17936 }
17938 /*
17939 * Find the hashtab used for a variable name.
17940 * Set "varname" to the start of name without ':'.
17941 */
17946 {
17950 {
17951 /* The name must not start with a colon or #. */
17956 /* "version" is "v:version" in all scopes */
17964 }
17968 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17969 */
17977 #ifdef FEAT_WINDOWS
17980 #endif
17991 }
17993 /*
17994 * Get the string value of a (global/local) variable.
17995 * Returns NULL when it doesn't exist.
17996 */
17997 char_u *
18000 {
18007 }
18009 /*
18010 * Allocate a new hashtab for a sourced script. It will be used while
18011 * sourcing this script and when executing functions defined in the script.
18012 */
18013 void
18015 scid_T id;
18016 {
18022 {
18023 /* Re-allocating ga_data means that an ht_array pointing to
18024 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18025 * at its init value. Also reset "v_dict", it's always the same. */
18027 {
18033 }
18036 {
18040 }
18041 }
18042 }
18044 /*
18045 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18046 * point to it.
18047 */
18048 void
18052 {
18060 }
18062 /*
18063 * Clean up a list of internal variables.
18064 * Frees all allocated variables and the value they contain.
18065 * Clears hashtab "ht", does not free it.
18066 */
18067 void
18070 {
18072 }
18074 /*
18075 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18076 */
18077 static void
18081 {
18089 {
18091 {
18094 /* Free the variable. Don't remove it from the hashtab,
18095 * ht_array might change then. hash_clear() takes care of it
18096 * later. */
18102 }
18103 }
18106 }
18108 /*
18109 * Delete a variable from hashtab "ht" at item "hi".
18110 * Clear the variable value and free the dictitem.
18111 */
18112 static void
18116 {
18122 }
18124 /*
18125 * List the value of one internal variable.
18126 */
18127 static void
18132 {
18141 }
18143 static void
18150 {
18151 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18163 {
18167 }
18169 {
18173 }
18174 else
18182 {
18185 }
18186 }
18188 /*
18189 * Set variable "name" to value in "tv".
18190 * If the variable already exists, the value is updated.
18191 * Otherwise the variable is created.
18192 */
18193 static void
18198 {
18205 {
18209 {
18212 }
18214 {
18216 name);
18218 }
18219 }
18223 {
18226 }
18230 {
18231 /* existing variable, need to clear the value */
18240 {
18243 }
18245 /*
18246 * Handle setting internal v: variables separately: we don't change
18247 * the type.
18248 */
18250 {
18252 {
18256 else
18257 {
18258 /* Take over the string to avoid an extra alloc/free. */
18261 }
18262 }
18265 else
18268 }
18271 }
18273 {
18274 /* Can't add "v:" variable. */
18276 {
18279 }
18281 /* Make sure the variable name is valid. */
18285 {
18288 }
18296 {
18299 }
18301 }
18305 else
18306 {
18310 }
18311 }
18313 /*
18314 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18315 * Also give an error message.
18316 */
18317 static int
18321 {
18323 {
18326 }
18328 {
18331 }
18333 }
18335 /*
18336 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18337 * Also give an error message.
18338 */
18339 static int
18343 {
18345 {
18348 }
18350 }
18352 /*
18353 * Return TRUE if typeval "tv" is set to be locked (immutable).
18354 * Also give an error message, using "name".
18355 */
18356 static int
18360 {
18362 {
18366 }
18368 {
18372 }
18374 }
18376 /*
18377 * Copy the values from typval_T "from" to typval_T "to".
18378 * When needed allocates string or increases reference count.
18379 * Does not make a copy of a list or dict but copies the reference!
18380 */
18381 static void
18385 {
18389 {
18397 else
18398 {
18402 }
18407 else
18408 {
18411 }
18416 else
18417 {
18420 }
18425 }
18426 }
18428 /*
18429 * Make a copy of an item.
18430 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18431 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18432 * reference to an already copied list/dict can be used.
18433 * Returns FAIL or OK.
18434 */
18435 static int
18441 {
18446 {
18449 }
18453 {
18465 {
18466 /* use the copy made earlier */
18469 }
18470 else
18481 {
18482 /* use the copy made earlier */
18485 }
18486 else
18494 }
18497 }
18499 /*
18500 * ":echo expr1 ..." print each argument separated with a space, add a
18501 * newline at the end.
18502 * ":echon expr1 ..." print each argument plain.
18503 */
18504 void
18507 {
18509 typval_T rettv;
18519 {
18522 {
18523 /*
18524 * Report the invalid expression unless the expression evaluation
18525 * has been cancelled due to an aborting error, an interrupt, or an
18526 * exception.
18527 */
18531 }
18533 {
18535 {
18537 /* Call msg_start() after eval1(), evaluating the expression
18538 * may cause a message to appear. */
18541 }
18547 {
18549 {
18551 {
18552 /* remove any text still there from the command */
18555 }
18557 }
18558 else
18559 {
18560 #ifdef FEAT_MBYTE
18562 {
18567 }
18568 else
18569 #endif
18571 }
18572 }
18574 }
18577 }
18582 else
18583 {
18584 /* remove text that may still be there from the command */
18589 }
18590 }
18592 /*
18593 * ":echohl {name}".
18594 */
18595 void
18598 {
18604 else
18606 }
18608 /*
18609 * ":execute expr1 ..." execute the result of an expression.
18610 * ":echomsg expr1 ..." Print a message
18611 * ":echoerr expr1 ..." Print an error
18612 * Each gets spaces around each argument and a newline at the end for
18613 * echo commands
18614 */
18615 void
18618 {
18620 typval_T rettv;
18623 garray_T ga;
18632 {
18635 {
18636 /*
18637 * Report the invalid expression unless the expression evaluation
18638 * has been cancelled due to an aborting error, an interrupt, or an
18639 * exception.
18640 */
18645 }
18648 {
18652 {
18656 }
18661 }
18665 }
18668 {
18670 {
18673 }
18675 {
18676 /* We don't want to abort following commands, restore did_emsg. */
18681 }
18685 }
18693 }
18695 /*
18696 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18697 * "arg" points to the "&" or '+' when called, to "option" when returning.
18698 * Returns NULL when no option name found. Otherwise pointer to the char
18699 * after the option name.
18700 */
18705 {
18710 {
18713 }
18715 {
18718 }
18719 else
18728 else
18732 }
18734 /*
18735 * ":function"
18736 */
18737 void
18740 {
18749 garray_T newargs;
18750 garray_T newlines;
18759 funcdict_T fudi;
18767 /*
18768 * ":function" without argument: list functions.
18769 */
18771 {
18773 {
18776 {
18778 {
18783 }
18784 }
18785 }
18788 }
18790 /*
18791 * ":function /pat": list functions matching pattern.
18792 */
18794 {
18797 {
18798 regmatch_T regmatch;
18805 {
18810 {
18812 {
18818 }
18819 }
18820 }
18821 }
18826 }
18828 /*
18829 * Get the function name. There are these situations:
18830 * func normal function name
18831 * "name" == func, "fudi.fd_dict" == NULL
18832 * dict.func new dictionary entry
18833 * "name" == NULL, "fudi.fd_dict" set,
18834 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18835 * dict.func existing dict entry with a Funcref
18836 * "name" == func, "fudi.fd_dict" set,
18837 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18838 * dict.func existing dict entry that's not a Funcref
18839 * "name" == NULL, "fudi.fd_dict" set,
18840 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18841 */
18846 {
18847 /*
18848 * Return on an invalid expression in braces, unless the expression
18849 * evaluation has been cancelled due to an aborting error, an
18850 * interrupt, or an exception.
18851 */
18853 {
18858 }
18859 else
18861 }
18863 /* An error in a function call during evaluation of an expression in magic
18864 * braces should not cause the function not to be defined. */
18868 /*
18869 * ":function func" with only function name: list function.
18870 */
18872 {
18874 {
18877 }
18882 {
18885 {
18888 {
18900 }
18902 {
18905 }
18906 }
18907 else
18909 }
18911 }
18913 /*
18914 * ":function name(arg1, arg2)" Define function.
18915 */
18918 {
18920 {
18923 }
18924 /* attempt to continue by skipping some text */
18927 }
18934 {
18935 /* Check the name of the function. Unless it's a dictionary function
18936 * (that we are overwriting). */
18939 else
18943 {
18946 else
18953 }
18954 }
18956 /*
18957 * Isolate the arguments: "arg1, arg2, ...)"
18958 */
18960 {
18962 {
18966 }
18967 else
18968 {
18975 {
18979 }
18992 else
18994 }
18997 {
19001 }
19002 }
19005 /* find extra arguments "range", "dict" and "abort" */
19007 {
19010 {
19013 }
19015 {
19018 }
19020 {
19023 }
19024 else
19026 }
19028 /* When there is a line break use what follows for the function body.
19029 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19035 /*
19036 * Read the body of the function, until ":endfunction" is found.
19037 */
19039 {
19040 /* Check if the function already exists, don't let the user type the
19041 * whole function before telling him it doesn't work! For a script we
19042 * need to skip the body to be able to find what follows. */
19044 {
19049 }
19056 }
19061 {
19067 {
19068 /* Use eap->arg, split up in parts by line breaks. */
19073 else
19074 {
19077 }
19078 }
19081 else
19086 {
19089 }
19091 /* Detect line continuation: sourcing_lnum increased more than one. */
19094 else
19098 {
19099 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19100 * don't check for ":endfunc". */
19102 {
19105 }
19106 }
19107 else
19108 {
19109 /* skip ':' and blanks*/
19111 ;
19113 /* Check for "endfunction". */
19115 {
19119 }
19121 /* Increase indent inside "if", "while", "for" and "try", decrease
19122 * at "end". */
19131 /* Check for defining a function inside this function. */
19133 {
19138 {
19141 {
19144 }
19145 }
19146 }
19148 /* Check for ":append" or ":insert". */
19156 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19169 ))
19170 {
19171 /* ":python <<" continues until a dot, like ":append" */
19175 else
19177 }
19178 }
19180 /* Add the line to the function. */
19182 {
19186 }
19188 /* Copy the line to newly allocated memory. get_one_sourceline()
19189 * allocates 250 bytes per line, this saves 80% on average. The cost
19190 * is an extra alloc/free. */
19193 {
19197 }
19201 /* Add NULL lines for continuation lines, so that the line count is
19202 * equal to the index in the growarray. */
19206 /* Check for end of eap->arg. */
19209 }
19211 /* Don't define the function when skipping commands or when an error was
19212 * detected. */
19216 /*
19217 * If there are no errors, add the function
19218 */
19220 {
19223 {
19225 name);
19227 }
19231 {
19233 {
19236 }
19238 {
19240 name);
19242 }
19243 /* redefine existing function */
19248 }
19249 }
19250 else
19251 {
19256 {
19259 }
19261 {
19262 /* Can't add a function to a locked dictionary */
19265 }
19266 /* Can't change an existing function if it is locked */
19270 /* Give the function a sequential number. Can only be used with a
19271 * Funcref! */
19277 }
19280 {
19282 {
19286 /* Check that the autoload name matches the script name. */
19289 {
19292 {
19300 }
19301 }
19303 {
19306 }
19307 }
19314 {
19316 {
19317 /* add new dict entry */
19320 {
19323 }
19325 {
19329 }
19330 }
19331 else
19332 /* overwrite existing dict entry */
19339 /* behave like "dict" was used */
19341 }
19343 /* insert the new function in the function list */
19346 }
19349 #ifdef FEAT_PROFILE
19356 #endif
19363 erret:
19366 ret_free:
19371 }
19373 /*
19374 * Get a function name, translating "<SID>" and "<SNR>".
19375 * Also handles a Funcref in a List or Dictionary.
19376 * Returns the function name in allocated memory, or NULL for failure.
19377 * flags:
19378 * TFN_INT: internal function name OK
19379 * TFN_QUIET: be quiet
19380 * Advances "pp" to just after the function name (if no error).
19381 */
19388 {
19395 lval_T lv;
19401 /* Check for hard coded <SNR>: already translated function ID (from a user
19402 * command). */
19405 {
19409 }
19411 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19412 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19420 {
19424 }
19426 {
19427 /*
19428 * Report an invalid expression in braces, unless the expression
19429 * evaluation has been cancelled due to an aborting error, an
19430 * interrupt, or an exception.
19431 */
19433 {
19436 }
19437 else
19440 }
19443 {
19445 {
19450 }
19452 {
19455 }
19456 else
19457 {
19461 else
19464 }
19466 }
19469 {
19470 /* Error found, but continue after the function name. */
19473 }
19475 /* Check if the name is a Funcref. If so, use the value. */
19477 {
19482 }
19483 else
19484 {
19489 }
19491 {
19495 }
19498 {
19502 {
19503 /* When there was "s:" already or the name expanded to get a
19504 * leading "s:" then remove it. */
19508 }
19509 }
19510 else
19511 {
19515 }
19517 /*
19518 * Copy the function name to allocated memory.
19519 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19520 * Accept <SNR>123_name() outside a script.
19521 */
19525 {
19529 {
19530 /* It's "s:" or "<SID>" */
19532 {
19535 }
19538 }
19539 }
19541 {
19544 }
19547 {
19549 {
19555 }
19558 }
19561 theend:
19564 }
19566 /*
19567 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19568 * Return 2 if "p" starts with "s:".
19569 * Return 0 otherwise.
19570 */
19571 static int
19574 {
19581 }
19583 /*
19584 * Return TRUE if "p" starts with "<SID>" or "s:".
19585 * Only works if eval_fname_script() returned non-zero for "p"!
19586 */
19587 static int
19590 {
19592 }
19594 /*
19595 * List the head of the function: "name(arg1, arg2)".
19596 */
19597 static void
19601 {
19609 {
19612 }
19613 else
19617 {
19621 }
19623 {
19627 }
19632 }
19634 /*
19635 * Find a function by name, return pointer to it in ufuncs.
19636 * Return NULL for unknown function.
19637 */
19641 {
19648 }
19650 #if defined(EXITFREE) || defined(PROTO)
19651 void
19653 {
19656 /* Need to start all over every time, because func_free() may change the
19657 * hash table. */
19661 {
19664 }
19665 }
19666 #endif
19668 /*
19669 * Return TRUE if a function "name" exists.
19670 */
19671 static int
19674 {
19682 /* Only accept "funcname", "funcname ", "funcname (..." and
19683 * "funcname(...", not "funcname!...". */
19685 {
19688 else
19690 }
19693 }
19695 /*
19696 * Return TRUE if "name" looks like a builtin function name: starts with a
19697 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19698 */
19699 static int
19702 {
19705 }
19707 #if defined(FEAT_PROFILE) || defined(PROTO)
19708 /*
19709 * Start profiling function "fp".
19710 */
19711 static void
19714 {
19733 }
19735 /*
19736 * Dump the profiling results for all functions in file "fd".
19737 */
19738 void
19741 {
19753 {
19755 {
19759 {
19765 else
19769 else
19777 {
19783 }
19785 }
19786 }
19787 }
19790 {
19792 prof_total_cmp);
19795 prof_self_cmp);
19797 }
19798 }
19800 static void
19807 {
19814 {
19817 prefer_self);
19820 else
19822 }
19824 }
19826 /*
19827 * Print the count and times for one function or function line.
19828 */
19829 static void
19836 {
19838 {
19842 else
19846 else
19848 }
19849 else
19851 }
19853 /*
19854 * Compare function for total time sorting.
19855 */
19856 static int
19857 #ifdef __BORLANDC__
19858 _RTLENTRYF
19859 #endif
19863 {
19869 }
19871 /*
19872 * Compare function for self time sorting.
19873 */
19874 static int
19875 #ifdef __BORLANDC__
19876 _RTLENTRYF
19877 #endif
19881 {
19887 }
19889 #endif
19891 /*
19892 * If "name" has a package name try autoloading the script for it.
19893 * Return TRUE if a package was loaded.
19894 */
19895 static int
19899 {
19905 /* If there is no '#' after name[0] there is no package name. */
19912 /* Find the name in the list of previously loaded package names. Skip
19913 * "autoload/", it's always the same. */
19919 else
19920 {
19921 /* Remember the name if it wasn't loaded already. */
19923 {
19926 }
19928 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19931 }
19935 }
19937 /*
19938 * Return the autoload script name for a function or variable name.
19939 * Returns NULL when out of memory.
19940 */
19944 {
19948 /* Get the script file name: replace '#' with '/', append ".vim". */
19959 }
19961 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19963 /*
19964 * Function given to ExpandGeneric() to obtain the list of user defined
19965 * function names.
19966 */
19967 char_u *
19971 {
19977 {
19980 }
19982 {
19994 {
19998 }
20000 }
20002 }
20006 /*
20007 * Copy the function name of "fp" to buffer "buf".
20008 * "buf" must be able to hold the function name plus three bytes.
20009 * Takes care of script-local function names.
20010 */
20011 static void
20015 {
20017 {
20020 }
20021 else
20023 }
20025 /*
20026 * ":delfunction {name}"
20027 */
20028 void
20031 {
20035 funcdict_T fudi;
20041 {
20045 }
20047 {
20051 }
20061 {
20063 {
20066 }
20068 {
20071 }
20074 {
20075 /* Delete the dict item that refers to the function, it will
20076 * invoke func_unref() and possibly delete the function. */
20078 }
20079 else
20081 }
20082 }
20084 /*
20085 * Free a function and remove it from the list of functions.
20086 */
20087 static void
20090 {
20093 /* clear this function */
20096 #ifdef FEAT_PROFILE
20100 #endif
20102 /* remove the function from the function hashtable */
20106 else
20110 }
20112 /*
20113 * Unreference a Function: decrement the reference count and free it when it
20114 * becomes zero. Only for numbered functions.
20115 */
20116 static void
20119 {
20123 {
20128 {
20129 /* Only delete it when it's not being used. Otherwise it's done
20130 * when "uf_calls" becomes zero. */
20133 }
20134 }
20135 }
20137 /*
20138 * Count a reference to a Function.
20139 */
20140 static void
20143 {
20147 {
20151 else
20153 }
20154 }
20156 /*
20157 * Call a user function.
20158 */
20159 static void
20168 {
20170 linenr_T save_sourcing_lnum;
20171 scid_T save_current_SID;
20172 funccall_T fc;
20181 #ifdef FEAT_PROFILE
20182 proftime_T wait_start;
20183 proftime_T call_start;
20184 #endif
20186 /* If depth of calling is getting too high, don't execute the function */
20188 {
20193 }
20206 /* Check if this function has a breakpoint. */
20210 /*
20211 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20212 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20213 * each argument variable and saves a lot of time.
20214 */
20215 /*
20216 * Init l: variables.
20217 */
20220 {
20221 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20222 * some compiler that checks the destination size. */
20232 }
20234 /*
20235 * Init a: variables.
20236 * Set a:0 to "argcount".
20237 * Set a:000 to a list with room for the "..." arguments.
20238 */
20253 /*
20254 * Set a:firstline to "firstline" and a:lastline to "lastline".
20255 * Set a:name to named arguments.
20256 * Set a:N to the "..." arguments.
20257 */
20263 {
20266 /* named argument a:name */
20268 else
20269 {
20270 /* "..." argument a:1, a:2, etc. */
20273 }
20275 {
20278 }
20279 else
20280 {
20286 }
20290 /* Note: the values are copied directly to avoid alloc/free.
20291 * "argvars" must have VAR_FIXED for v_lock. */
20296 {
20300 }
20301 }
20303 /* Don't redraw while executing the function. */
20311 {
20315 else
20320 {
20326 {
20334 {
20339 else
20340 {
20343 {
20347 }
20348 }
20349 }
20351 }
20356 }
20357 }
20358 #ifdef FEAT_PROFILE
20360 {
20365 {
20369 }
20371 }
20372 #endif
20379 /* call do_cmdline() to execute the lines */
20385 /* when the function was aborted because of an error, return -1 */
20387 {
20391 }
20393 #ifdef FEAT_PROFILE
20396 {
20402 {
20405 }
20406 }
20407 #endif
20409 /* when being verbose, mention the return value */
20411 {
20420 else
20421 {
20427 /* The value may be very long. Skip the middle part, so that we
20428 * have some idea how it starts and ends. smsg() would always
20429 * truncate it at the end. */
20432 {
20436 }
20437 }
20442 }
20448 #ifdef FEAT_PROFILE
20451 #endif
20454 {
20463 }
20468 /* The a: variables typevals were not alloced, only free the allocated
20469 * variables. */
20474 }
20476 /*
20477 * Add a number variable "name" to dict "dp" with value "nr".
20478 */
20479 static void
20484 varnumber_T nr;
20485 {
20492 }
20494 /*
20495 * ":return [expr]"
20496 */
20497 void
20500 {
20502 typval_T rettv;
20506 {
20509 }
20517 {
20520 else
20522 }
20523 /* It's safer to return also on error. */
20525 {
20526 /*
20527 * Return unless the expression evaluation has been cancelled due to an
20528 * aborting error, an interrupt, or an exception.
20529 */
20532 }
20534 /* When skipping or the return gets pending, advance to the next command
20535 * in this line (!returning). Otherwise, ignore the rest of the line.
20536 * Following lines will be ignored by get_func_line(). */
20544 }
20546 /*
20547 * Return from a function. Possibly makes the return pending. Also called
20548 * for a pending return at the ":endtry" or after returning from an extra
20549 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20550 * when called due to a ":return" command. "rettv" may point to a typval_T
20551 * with the return rettv. Returns TRUE when the return can be carried out,
20552 * FALSE when the return gets pending.
20553 */
20554 int
20560 {
20565 /* Undo the return. */
20568 /*
20569 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20570 * not in its finally clause (which then is to be executed next) is found.
20571 * In this case, make the ":return" pending for execution at the ":endtry".
20572 * Otherwise, return normally.
20573 */
20576 {
20580 /* A pending return again gets pending. "rettv" points to an
20581 * allocated variable with the rettv of the original ":return"'s
20582 * argument if present or is NULL else. */
20584 else
20585 {
20586 /* When undoing a return in order to make it pending, get the stored
20587 * return rettv. */
20592 {
20593 /* Store the value of the pending return. */
20596 else
20598 }
20599 else
20603 {
20604 /* The pending return value could be overwritten by a ":return"
20605 * without argument in a finally clause; reset the default
20606 * return value. */
20609 }
20610 }
20612 }
20613 else
20614 {
20617 /* If the return is carried out now, store the return value. For
20618 * a return immediately after reanimation, the value is already
20619 * there. */
20621 {
20626 }
20627 }
20630 }
20632 /*
20633 * Free the variable with a pending return value.
20634 */
20635 void
20638 {
20640 }
20642 /*
20643 * Generate a return command for producing the value of "rettv". The result
20644 * is an allocated string. Used by report_pending() for verbose messages.
20645 */
20646 char_u *
20649 {
20665 }
20667 /*
20668 * Get next function line.
20669 * Called by do_cmdline() to get the next line.
20670 * Returns allocated string, or NULL for end of function.
20671 */
20672 /* ARGSUSED */
20673 char_u *
20678 {
20684 /* If breakpoints have been added/deleted need to check for it. */
20686 {
20688 sourcing_lnum);
20690 }
20691 #ifdef FEAT_PROFILE
20694 #endif
20700 else
20701 {
20702 /* Skip NULL lines (continuation lines). */
20708 else
20709 {
20712 #ifdef FEAT_PROFILE
20715 #endif
20716 }
20717 }
20719 /* Did we encounter a breakpoint? */
20721 {
20723 /* Find next breakpoint. */
20725 sourcing_lnum);
20727 }
20730 }
20732 #if defined(FEAT_PROFILE) || defined(PROTO)
20733 /*
20734 * Called when starting to read a function line.
20735 * "sourcing_lnum" must be correct!
20736 * When skipping lines it may not actually be executed, but we won't find out
20737 * until later and we need to store the time now.
20738 */
20739 void
20742 {
20748 {
20750 /* Skip continuation lines. */
20757 }
20758 }
20760 /*
20761 * Called when actually executing a function line.
20762 */
20763 void
20766 {
20772 }
20774 /*
20775 * Called when done with a function line.
20776 */
20777 void
20780 {
20785 {
20787 {
20794 }
20796 }
20797 }
20798 #endif
20800 /*
20801 * Return TRUE if the currently active function should be ended, because a
20802 * return was encountered or an error occured. Used inside a ":while".
20803 */
20804 int
20807 {
20810 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20811 * an error inside a try conditional. */
20814 }
20816 /*
20817 * return TRUE if cookie indicates a function which "abort"s on errors.
20818 */
20819 int
20822 {
20824 }
20826 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20828 {
20829 VAR_FLAVOUR_DEFAULT,
20830 VAR_FLAVOUR_SESSION,
20831 VAR_FLAVOUR_VIMINFO
20836 static var_flavour_T
20839 {
20843 {
20848 }
20849 else
20851 }
20852 #endif
20854 #if defined(FEAT_VIMINFO) || defined(PROTO)
20855 /*
20856 * Restore global vars that start with a capital from the viminfo file
20857 */
20858 int
20862 {
20865 typval_T tv;
20868 {
20871 {
20878 {
20880 {
20884 }
20885 else
20886 {
20889 }
20893 }
20894 }
20895 }
20898 }
20900 /*
20901 * Write global vars that start with a capital to the viminfo file
20902 */
20903 void
20906 {
20922 {
20924 {
20928 {
20930 {
20934 }
20940 }
20941 }
20942 }
20943 }
20944 #endif
20946 #if defined(FEAT_SESSION) || defined(PROTO)
20947 int
20950 {
20958 {
20960 {
20966 {
20967 /* Escape special characters with a backslash. Turn a LF and
20968 * CR into \n and \r. */
20982 p,
20986 {
20989 }
20991 }
20992 }
20993 }
20995 }
20996 #endif
20998 /*
20999 * Display script name where an item was last set.
21000 * Should only be invoked when 'verbose' is non-zero.
21001 */
21002 void
21004 scid_T scriptID;
21005 {
21009 {
21012 {
21018 }
21019 }
21020 }
21024 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21027 #ifdef WIN3264
21028 /*
21029 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21030 */
21032 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21035 /*
21036 * Get the short pathname of a file.
21037 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
21038 */
21039 static int
21044 {
21052 {
21053 /* If that doesn't work (not enough space), then save the string
21054 * and try again with a new buffer big enough
21055 */
21065 /* Really should always succeed, as the buffer is big enough */
21066 }
21070 }
21072 /*
21073 * Create a short path name. Returns the length of the buffer it needs.
21074 * Doesn't copy over the end of the buffer passed in.
21075 */
21076 static int
21081 {
21083 char_u ch;
21086 /* Make a copy */
21096 {
21100 }
21102 do
21103 {
21104 /* Go back one path-separator */
21106 {
21110 }
21114 /* Remember the character that is about to be splatted */
21118 /* Try it in situ */
21121 {
21124 }
21129 {
21130 /* Remember the length of the new string. */
21134 {
21135 /* If there's not enough space in the currently allocated string,
21136 * then copy it to a buffer big enough.
21137 */
21141 }
21142 else
21143 {
21144 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21149 }
21150 /* Concat the next bit */
21153 }
21157 }
21159 /*
21160 * Get a pathname for a partial path.
21161 */
21162 static int
21167 {
21173 /* Count up the path seperators from the RHS.. so we know which part
21174 * of the path to return.
21175 */
21181 /* Need full path first (use expand_env() to remove a "~/") */
21185 else
21194 {
21195 /* Don't have a valid filename, so shorten the rest of the
21196 * path if we can. This CAN give us invalid 8.3 filenames, but
21197 * there's not a lot of point in guessing what it might be.
21198 */
21202 }
21204 /* Count the paths backward to find the beginning of the desired string. */
21206 {
21207 #ifdef FEAT_MBYTE
21210 #endif
21212 {
21215 else
21216 sepcount --;
21217 }
21218 }
21220 {
21224 else
21226 }
21227 else
21230 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21237 }
21240 /*
21241 * Adjust a filename, according to a string of modifiers.
21242 * *fnamep must be NUL terminated when called. When returning, the length is
21243 * determined by *fnamelen.
21244 * Returns valid flags.
21245 * When there is an error, *fnamep is set to NULL.
21246 */
21247 int
21254 {
21261 #ifdef WIN3264
21263 #endif
21265 repeat:
21266 /* ":p" - full path/file_name */
21268 {
21274 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21276 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21278 # ifdef BACKSLASH_IN_FILENAME
21280 # endif
21283 #endif
21284 )
21285 {
21291 }
21293 /* When "/." or "/.." is used: force expansion to get rid of it. */
21295 {
21303 }
21305 /* FullName_save() is slow, don't use it when not needed. */
21307 {
21313 }
21315 /* Append a path separator to a directory. */
21317 {
21318 /* Make room for one or two extra characters. */
21325 }
21326 }
21328 /* ":." - path relative to the current directory */
21329 /* ":~" - path relative to the home directory */
21330 /* ":8" - shortname path - postponed till after */
21333 {
21336 {
21337 #ifdef WIN3264
21339 #endif
21341 }
21343 /* Need full path first (use expand_env() to remove a "~/") */
21345 {
21348 else
21350 }
21351 else
21357 {
21359 {
21363 {
21366 {
21370 }
21371 }
21372 }
21373 else
21374 {
21376 /* Only replace it when it starts with '~' */
21378 {
21381 {
21385 }
21386 }
21387 }
21389 }
21390 }
21395 /* ":h" - head, remove "/file_name", can be repeated */
21396 /* Don't remove the first "/" or "c:\" */
21398 {
21405 #ifdef VMS
21408 #endif
21410 {
21411 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21418 }
21419 else
21420 {
21423 }
21424 }
21426 /* ":8" - shortname */
21428 {
21430 #ifdef WIN3264
21432 #endif
21433 }
21435 #ifdef WIN3264
21436 /* Check shortname after we have done 'heads' and before we do 'tails'
21437 */
21439 {
21441 /* Copy the string if it is shortened by :h */
21443 {
21449 }
21451 /* Split into two implementations - makes it easier. First is where
21452 * there isn't a full name already, second is where there is.
21453 */
21455 {
21458 }
21459 else
21460 {
21463 /* Simple case, already have the full-name
21464 * Nearly always shorter, so try first time. */
21470 {
21471 /* Couldn't find the filename.. search the paths.
21472 */
21476 }
21478 }
21479 }
21482 /* ":t" - tail, just the basename */
21484 {
21488 }
21490 /* ":e" - extension, can be repeated */
21491 /* ":r" - root, without extension, can be repeated */
21494 {
21495 /* find a '.' in the tail:
21496 * - for second :e: before the current fname
21497 * - otherwise: The last '.'
21498 */
21501 else
21507 {
21509 {
21512 #ifdef VMS
21513 /* cut version from the extension */
21520 #endif
21521 }
21524 }
21526 {
21529 }
21531 }
21533 /* ":s?pat?foo?" - substitute */
21534 /* ":gs?pat?foo?" - global substitute */
21538 {
21549 {
21552 }
21556 {
21557 /* find end of pattern */
21560 {
21563 {
21565 /* find end of substitution */
21568 {
21572 {
21576 {
21582 }
21583 }
21586 }
21588 }
21589 }
21590 /* after using ":s", repeat all the modifiers */
21593 }
21594 }
21597 }
21599 /*
21600 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21601 * "flags" can be "g" to do a global substitute.
21602 * Returns an allocated string, NULL for error.
21603 */
21604 char_u *
21610 {
21612 regmatch_T regmatch;
21616 garray_T ga;
21620 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21631 {
21634 {
21635 /*
21636 * Get some space for a temporary buffer to do the substitution
21637 * into. It will contain:
21638 * - The text up to where the match is.
21639 * - The substituted text.
21640 * - The text after the match.
21641 */
21645 {
21648 }
21650 /* copy the text up to where the match is */
21653 /* add the substituted text */
21657 /* avoid getting stuck on a match with an empty string */
21659 {
21664 }
21665 else
21666 {
21670 }
21673 }
21679 }
21686 }