| blob | cfb347616cd5b6ef09c194ebf38e797108994887 |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(MSWIN)
15 #endif
19 #ifdef AMIGA
21 #endif
23 #ifdef MACOS
25 #endif
27 #ifdef HAVE_FCNTL_H
28 # include <fcntl.h>
29 #endif
31 #if defined(FEAT_EVAL) || defined(PROTO)
35 /*
36 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
37 * This avoids adding a pointer to the hashtab item.
38 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
39 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
40 * HI2DI() converts a hashitem pointer to a dictitem pointer.
41 */
43 #define DI2HIKEY(di) ((di)->di_key)
44 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
45 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
47 /*
48 * Structure returned by get_lval() and used by set_var_lval().
49 * For a plain name:
50 * "name" points to the variable name.
51 * "exp_name" is NULL.
52 * "tv" is NULL
53 * For a magic braces name:
54 * "name" points to the expanded variable name.
55 * "exp_name" is non-NULL, to be freed later.
56 * "tv" is NULL
57 * For an index in a list:
58 * "name" points to the (expanded) variable name.
59 * "exp_name" NULL or non-NULL, to be freed later.
60 * "tv" points to the (first) list item value
61 * "li" points to the (first) list item
62 * "range", "n1", "n2" and "empty2" indicate what items are used.
63 * For an existing Dict item:
64 * "name" points to the (expanded) variable name.
65 * "exp_name" NULL or non-NULL, to be freed later.
66 * "tv" points to the dict item value
67 * "newkey" is NULL
68 * For a non-existing Dict item:
69 * "name" points to the (expanded) variable name.
70 * "exp_name" NULL or non-NULL, to be freed later.
71 * "tv" points to the Dictionary typval_T
72 * "newkey" is the key for the new item.
73 */
75 {
79 isn't NULL it's the Dict to which to add
80 the item. */
111 /*
112 * All user-defined global variables are stored in dictionary "globvardict".
113 * "globvars_var" is the variable that is used for "g:".
114 */
117 #define globvarht globvardict.dv_hashtab
119 /*
120 * Old Vim variables such as "v:version" are also available without the "v:".
121 * Also in functions. We need a special hashtable for them.
122 */
125 /*
126 * When recursively copying lists and dicts we need to remember which ones we
127 * have done to avoid endless recursiveness. This unique ID is used for that.
128 */
131 /*
132 * Array to hold the hashtab with variables local to each sourced script.
133 * Each item holds a variable (nameless) that points to the dict_T.
134 */
136 {
137 dictitem_T sv_var;
138 dict_T sv_dict;
142 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
143 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
147 /* Values for trans_function_name() argument: */
151 /*
152 * Structure to hold info for a user function.
153 */
156 struct ufunc
157 {
163 #ifdef FEAT_PROFILE
165 /* profiling the function as a whole */
170 /* profiling the function per line */
179 #endif
181 used for s: variables */
184 start with <SNR>123_ (<SNR> is K_SPECIAL
185 KS_EXTRA KE_SNR) */
186 };
188 /* function flags */
193 /*
194 * All user-defined functions are found in this hashtable.
195 */
198 /* The names of packages that once were loaded are remembered. */
201 /* list heads for garbage collection */
205 /* From user function to hashitem and back. */
207 #define UF2HIKEY(fp) ((fp)->uf_name)
208 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
209 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
211 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
212 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
218 /* structure to hold info for a function that is currently being executed. */
221 struct funccall_S
222 {
227 {
241 #ifdef FEAT_PROFILE
243 #endif
245 };
247 /*
248 * Info used by a ":for" loop.
249 */
251 {
258 /*
259 * Struct used by trans_function_name()
260 */
262 {
269 /*
270 * Array to hold the value of v: variables.
271 * The value is in a dictitem, so that it can also be used in the v: scope.
272 * The reason to use this table anyway is for very quick access to the
273 * variables with the VV_ defines.
274 */
277 /* values for vv_flags: */
282 #define VV_NAME(s, t) s, {{t}}, {0}
284 static struct vimvar
285 {
291 {
292 /*
293 * The order here must match the VV_ defines in vim.h!
294 * Initializing a union does not work, leave tv.vval empty to get zero's.
295 */
348 };
350 /* shorthand */
351 #define vv_type vv_di.di_tv.v_type
352 #define vv_nr vv_di.di_tv.vval.v_number
353 #define vv_str vv_di.di_tv.vval.v_string
354 #define vv_tv vv_di.di_tv
356 /*
357 * The v: variables are stored in dictionary "vimvardict".
358 * "vimvars_var" is the variable that is used for the "l:" scope.
359 */
362 #define vimvarht vimvardict.dv_hashtab
366 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
367 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
368 #endif
369 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
376 #ifdef FEAT_WINDOWS
378 #endif
383 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
385 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
387 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
455 static int get_func_tv __ARGS((char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
456 static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
479 #if defined(FEAT_INS_EXPAND)
483 #endif
586 #ifdef vim_mkdir
588 #endif
634 #ifdef HAVE_STRFTIME
636 #endif
679 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
682 valid character */
683 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
718 #ifdef FEAT_PROFILE
720 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
721 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
722 static int
723 # ifdef __BORLANDC__
724 _RTLENTRYF
725 # endif
727 static int
728 # ifdef __BORLANDC__
729 _RTLENTRYF
730 # endif
732 #endif
739 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));
747 /* Character used as separated in autoload function/variable names. */
750 /*
751 * Initialize the global and v: variables.
752 */
753 void
755 {
765 {
772 else
775 /* add to v: scope dict, unless the value is not always available */
779 /* add to compat scope dict */
781 }
782 }
784 #if defined(EXITFREE) || defined(PROTO)
785 void
787 {
792 {
795 {
798 }
799 }
803 /* script-local variables */
809 /* global variables */
812 /* functions */
816 /* autoloaded script names */
819 /* unreferenced lists and dicts */
821 }
822 #endif
824 /*
825 * Return the name of the executed function.
826 */
827 char_u *
830 {
832 }
834 /*
835 * Return the address holding the next breakpoint line for a funccall cookie.
836 */
837 linenr_T *
840 {
842 }
844 /*
845 * Return the address holding the debug tick for a funccall cookie.
846 */
850 {
852 }
854 /*
855 * Return the nesting level for a funccall cookie.
856 */
857 int
860 {
862 }
864 /* pointer to funccal for currently active function */
867 /*
868 * Return TRUE when a function was ended by a ":return" command.
869 */
870 int
872 {
874 }
877 /*
878 * Set an internal variable to a string value. Creates the variable if it does
879 * not already exist.
880 */
881 void
885 {
891 {
894 {
897 }
898 }
899 }
906 /*
907 * Start recording command output to a variable
908 * Returns OK if successfully completed the setup. FAIL otherwise.
909 */
910 int
914 {
917 typval_T tv;
919 /* Make sure a valid variable name is specified */
921 {
924 }
932 {
935 }
937 /* The output is stored in growarray "redir_ga" until redirection ends. */
940 /* Parse the variable name (can be a dict or list entry). */
942 FNE_CHECK_START);
944 {
946 /* Trailing characters are present after the variable name */
948 else
952 }
954 /* check if we can write to the variable: set it to or append an empty
955 * string */
962 else
967 {
970 }
972 {
973 /* Dictionary item was created, don't do it again. */
976 }
979 }
981 /*
982 * Append "value[value_len]" to the variable set by var_redir_start().
983 * The actual appending is postponed until redirection ends, because the value
984 * appended may in fact be the string we write to, changing it may cause freed
985 * memory to be used:
986 * :redir => foo
987 * :let foo
988 * :redir END
989 */
990 void
994 {
1002 else
1006 {
1009 }
1010 else
1012 }
1014 /*
1015 * Stop redirecting command output to a variable.
1016 */
1017 void
1019 {
1020 typval_T tv;
1023 {
1024 /* Append the trailing NUL. */
1027 /* Assign the text to the variable. */
1036 }
1039 }
1041 # if defined(FEAT_MBYTE) || defined(PROTO)
1042 int
1048 {
1065 }
1066 # endif
1068 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1069 int
1073 {
1084 {
1087 }
1089 }
1090 # endif
1092 # if defined(FEAT_DIFF) || defined(PROTO)
1093 void
1098 {
1108 }
1110 void
1115 {
1125 }
1126 # endif
1128 /*
1129 * Top level evaluation function, returning a boolean.
1130 * Sets "error" to TRUE if there was an error.
1131 * Return TRUE or FALSE.
1132 */
1133 int
1139 {
1140 typval_T tv;
1147 else
1148 {
1151 {
1154 }
1155 }
1160 }
1162 /*
1163 * Top level evaluation function, returning a string. If "skip" is TRUE,
1164 * only parsing to "nextcmd" is done, without reporting errors. Return
1165 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1166 */
1167 char_u *
1172 {
1173 typval_T tv;
1180 else
1181 {
1184 }
1189 }
1191 /*
1192 * Skip over an expression at "*pp".
1193 * Return FAIL for an error, OK otherwise.
1194 */
1195 int
1198 {
1199 typval_T rettv;
1203 }
1205 /*
1206 * Top level evaluation function, returning a string.
1207 * Return pointer to allocated memory, or NULL for failure.
1208 */
1209 char_u *
1214 {
1215 typval_T tv;
1217 garray_T ga;
1221 else
1222 {
1224 {
1229 }
1230 else
1233 }
1236 }
1238 /*
1239 * Call eval_to_string() without using current local variables and using
1240 * textlock. When "use_sandbox" is TRUE use the sandbox.
1241 */
1242 char_u *
1247 {
1261 }
1263 /*
1264 * Top level evaluation function, returning a number.
1265 * Evaluates "expr" silently.
1266 * Returns -1 for an error.
1267 */
1268 int
1271 {
1272 typval_T rettv;
1280 else
1281 {
1284 }
1288 }
1290 /*
1291 * Prepare v: variable "idx" to be used.
1292 * Save the current typeval in "save_tv".
1293 * When not used yet add the variable to the v: hashtable.
1294 */
1295 static void
1299 {
1303 }
1305 /*
1306 * Restore v: variable "idx" to typeval "save_tv".
1307 * When no longer defined, remove the variable from the v: hashtable.
1308 */
1309 static void
1313 {
1319 {
1323 else
1325 }
1326 }
1328 #if defined(FEAT_SPELL) || defined(PROTO)
1329 /*
1330 * Evaluate an expression to a list with suggestions.
1331 * For the "expr:" part of 'spellsuggest'.
1332 */
1333 list_T *
1337 {
1338 typval_T save_val;
1339 typval_T rettv;
1343 /* Set "v:val" to the bad word. */
1351 {
1354 else
1356 }
1364 }
1366 /*
1367 * "list" is supposed to contain two items: a word and a number. Return the
1368 * word in "pp" and the number as the return value.
1369 * Return -1 if anything isn't right.
1370 * Used to get the good word and score from the eval_spell_expr() result.
1371 */
1372 int
1376 {
1388 }
1389 #endif
1391 /*
1392 * Top level evaluation function.
1393 * Returns an allocated typval_T with the result.
1394 * Returns NULL when there is an error.
1395 */
1396 typval_T *
1400 {
1405 {
1408 }
1411 }
1414 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1415 /*
1416 * Call some vimL function and return the result in "*rettv".
1417 * Uses argv[argc] for the function arguments.
1418 * Returns OK or FAIL.
1419 */
1420 static int
1427 {
1441 {
1442 /* Pass a NULL or empty argument as an empty string */
1444 {
1448 }
1450 /* Recognize a number argument, the others must be strings. */
1453 {
1456 }
1457 else
1458 {
1461 }
1462 }
1465 {
1468 }
1475 {
1478 }
1485 }
1487 /*
1488 * Call vimL function "func" and return the result as a string.
1489 * Returns NULL when calling the function fails.
1490 * Uses argv[argc] for the function arguments.
1491 */
1498 {
1499 typval_T rettv;
1508 }
1510 #if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1511 /*
1512 * Call vimL function "func" and return the result as a number.
1513 * Returns -1 when calling the function fails.
1514 * Uses argv[argc] for the function arguments.
1515 */
1516 long
1522 {
1523 typval_T rettv;
1532 }
1533 #endif
1535 /*
1536 * Call vimL function "func" and return the result as a list
1537 * Uses argv[argc] for the function arguments.
1538 */
1545 {
1546 typval_T rettv;
1552 {
1555 }
1558 }
1560 #endif
1562 /*
1563 * Save the current function call pointer, and set it to NULL.
1564 * Used when executing autocommands and for ":source".
1565 */
1568 {
1573 }
1575 void
1578 {
1582 }
1584 #if defined(FEAT_PROFILE) || defined(PROTO)
1585 /*
1586 * Prepare profiling for entering a child or something else that is not
1587 * counted for the script/function itself.
1588 * Should always be called in pair with prof_child_exit().
1589 */
1590 void
1593 {
1599 }
1601 /*
1602 * Take care of time spent in a child.
1603 * Should always be called after prof_child_enter().
1604 */
1605 void
1608 {
1612 {
1617 }
1619 }
1620 #endif
1623 #ifdef FEAT_FOLDING
1624 /*
1625 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1626 * it in "*cp". Doesn't give error messages.
1627 */
1628 int
1632 {
1633 typval_T tv;
1637 OPT_LOCAL);
1646 else
1647 {
1648 /* If the result is a number, just return the number. */
1653 else
1654 {
1655 /* If the result is a string, check if there is a non-digit before
1656 * the number. */
1661 }
1663 }
1670 }
1671 #endif
1673 /*
1674 * ":let" list all variable values
1675 * ":let var1 var2" list variable values
1676 * ":let var = expr" assignment command.
1677 * ":let var += expr" assignment command.
1678 * ":let var -= expr" assignment command.
1679 * ":let var .= expr" assignment command.
1680 * ":let [var1, var2] = expr" unpack list.
1681 */
1682 void
1685 {
1688 typval_T rettv;
1702 {
1703 /*
1704 * ":let" without "=": list variables
1705 */
1709 /* ":let var1 var2" */
1712 {
1713 /* ":let" */
1717 #ifdef FEAT_WINDOWS
1719 #endif
1723 }
1725 }
1726 else
1727 {
1731 {
1734 }
1741 {
1745 }
1747 {
1749 op);
1751 }
1752 }
1753 }
1755 /*
1756 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1757 * Handles both "var" with any type and "[var, var; var]" with a list type.
1758 * When "nextchars" is not NULL it points to a string with characters that
1759 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1760 * or concatenate.
1761 * Returns OK or FAIL;
1762 */
1763 static int
1771 {
1776 typval_T ltv;
1779 {
1780 /*
1781 * ":let var = expr" or ":for var in list"
1782 */
1786 }
1788 /*
1789 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1790 */
1792 {
1795 }
1799 {
1802 }
1804 {
1807 }
1811 {
1820 {
1821 /* Put the rest of the list (may be empty) in the var after ';'.
1822 * Create a new list for this. */
1827 {
1830 }
1843 }
1845 {
1848 }
1849 }
1852 }
1854 /*
1855 * Skip over assignable variable "var" or list of variables "[var, var]".
1856 * Used for ":let varvar = expr" and ":for varvar in expr".
1857 * For "[var, var]" increment "*var_count" for each variable.
1858 * for "[var, var; var]" set "semicolon".
1859 * Return NULL for an error.
1860 */
1866 {
1870 {
1871 /* "[var, var]": find the matching ']'. */
1874 {
1878 {
1881 }
1888 {
1890 {
1893 }
1895 }
1897 {
1900 }
1901 }
1903 }
1904 else
1906 }
1908 /*
1909 * Skip one (assignable) variable name, includig @r, $VAR, &option, d.key,
1910 * l[idx].
1911 */
1915 {
1920 }
1922 /*
1923 * List variables for hashtab "ht" with prefix "prefix".
1924 * If "empty" is TRUE also list NULL strings as empty strings.
1925 */
1926 static void
1931 {
1938 {
1940 {
1946 }
1947 }
1948 }
1950 /*
1951 * List global variables.
1952 */
1953 static void
1955 {
1957 }
1959 /*
1960 * List buffer variables.
1961 */
1962 static void
1964 {
1971 }
1973 /*
1974 * List window variables.
1975 */
1976 static void
1978 {
1980 }
1982 #ifdef FEAT_WINDOWS
1983 /*
1984 * List tab page variables.
1985 */
1986 static void
1988 {
1990 }
1991 #endif
1993 /*
1994 * List Vim variables.
1995 */
1996 static void
1998 {
2000 }
2002 /*
2003 * List script-local variables, if there is a script.
2004 */
2005 static void
2007 {
2010 }
2012 /*
2013 * List function variables, if there is a function.
2014 */
2015 static void
2017 {
2021 }
2023 /*
2024 * List variables in "arg".
2025 */
2030 {
2037 typval_T tv;
2040 {
2042 {
2045 {
2049 }
2050 }
2051 else
2052 {
2053 /* get_name_len() takes care of expanding curly braces */
2057 {
2058 /* This is mainly to keep test 49 working: when expanding
2059 * curly braces fails overrule the exception error message. */
2061 {
2065 }
2067 }
2068 else
2069 {
2074 else
2075 {
2076 /* handle d.key, l[idx], f(expr) */
2080 else
2081 {
2083 {
2085 {
2089 #ifdef FEAT_WINDOWS
2091 #endif
2097 }
2098 }
2099 else
2100 {
2114 }
2116 }
2117 }
2118 }
2121 }
2124 }
2127 }
2129 /*
2130 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2131 * Returns a pointer to the char just after the var name.
2132 * Returns NULL if there is an error.
2133 */
2141 {
2150 /*
2151 * ":let $VAR = expr": Set environment variable.
2152 */
2154 {
2155 /* Find the end of the name. */
2161 else
2162 {
2168 else
2169 {
2174 {
2179 {
2183 }
2184 }
2186 {
2196 }
2199 }
2200 }
2201 }
2203 /*
2204 * ":let &option = expr": Set option value.
2205 * ":let &l:option = expr": Set local option value.
2206 * ":let &g:option = expr": Set global option value.
2207 */
2209 {
2210 /* Find the end of the name. */
2215 else
2216 {
2229 {
2235 else
2236 {
2238 {
2241 else
2243 }
2245 {
2249 }
2250 }
2251 }
2253 {
2256 }
2259 }
2260 }
2262 /*
2263 * ":let @r = expr": Set register contents.
2264 */
2266 {
2273 else
2274 {
2280 {
2283 {
2286 }
2287 }
2289 {
2292 }
2294 }
2295 }
2297 /*
2298 * ":let var = expr": Set internal variable.
2299 * ":let {expr} = expr": Idem, name made with curly braces
2300 */
2302 {
2303 lval_T lv;
2307 {
2310 else
2311 {
2314 }
2315 }
2317 }
2319 else
2323 }
2325 /*
2326 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2327 */
2328 static int
2331 {
2333 {
2336 }
2338 }
2340 /*
2341 * Get an lval: variable, Dict item or List item that can be assigned a value
2342 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2343 * "name.key", "name.key[expr]" etc.
2344 * Indexing only works if "name" is an existing List or Dictionary.
2345 * "name" points to the start of the name.
2346 * If "rettv" is not NULL it points to the value to be assigned.
2347 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2348 * wrong; must end in space or cmd separator.
2349 *
2350 * Returns a pointer to just after the name, including indexes.
2351 * When an evaluation error occurs "lp->ll_name" is NULL;
2352 * Returns NULL for a parsing error. Still need to free items in "lp"!
2353 */
2363 {
2368 typval_T var1;
2369 typval_T var2;
2376 /* Clear everything in "lp". */
2380 {
2381 /* When skipping just find the end of the name. */
2384 }
2386 /* Find the end of the name. */
2389 {
2390 /* Don't expand the name when we already know there is an error. */
2393 {
2396 }
2400 {
2401 /* Report an invalid expression in braces, unless the
2402 * expression evaluation has been cancelled due to an
2403 * aborting error, an interrupt, or an exception. */
2405 {
2409 }
2410 }
2412 }
2413 else
2416 /* Without [idx] or .key we are done. */
2429 /*
2430 * Loop until no more [idx] or .key is following.
2431 */
2434 {
2438 {
2442 }
2444 {
2448 }
2452 {
2455 ;
2457 {
2461 }
2463 }
2464 else
2465 {
2466 /* Get the index [expr] or the first index [expr: ]. */
2470 else
2471 {
2476 {
2477 /* not a number or string */
2480 }
2481 }
2483 /* Optionally get the second index [ :expr]. */
2485 {
2487 {
2493 }
2496 {
2502 }
2506 else
2507 {
2510 {
2514 }
2516 {
2517 /* not a number or string */
2522 }
2523 }
2525 }
2526 else
2530 {
2538 }
2540 /* Skip to past ']'. */
2542 }
2545 {
2547 {
2548 /* "[key]": get key from "var1" */
2551 {
2556 }
2557 }
2562 {
2563 /* Key does not exist in dict: may need to add it. */
2565 {
2571 }
2574 else
2581 }
2585 }
2586 else
2587 {
2588 /*
2589 * Get the number and item for the only or first index of the List.
2590 */
2593 else
2594 {
2597 }
2602 {
2604 {
2607 }
2608 }
2610 {
2614 }
2616 /*
2617 * May need to find the item or absolute index for the second
2618 * index of a range.
2619 * When no index given: "lp->ll_empty2" is TRUE.
2620 * Otherwise "lp->ll_n2" is set to the second index.
2621 */
2623 {
2627 {
2632 }
2634 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2639 }
2642 }
2643 }
2646 }
2648 /*
2649 * Clear lval "lp" that was filled by get_lval().
2650 */
2651 static void
2654 {
2657 }
2659 /*
2660 * Set a variable that was parsed by get_lval() to "rettv".
2661 * "endp" points to just after the parsed name.
2662 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2663 */
2664 static void
2671 {
2677 {
2679 {
2683 {
2684 typval_T tv;
2686 /* handle +=, -= and .= */
2689 {
2693 }
2694 }
2695 else
2698 }
2699 }
2703 ;
2705 {
2706 /*
2707 * Assign the List values to the list items.
2708 */
2710 {
2713 else
2714 {
2717 }
2722 {
2723 /* Need to add an empty item. */
2725 {
2728 }
2729 }
2732 }
2739 }
2740 else
2741 {
2742 /*
2743 * Assign to a List or Dictionary item.
2744 */
2746 {
2748 {
2751 }
2753 /* Need to add an item to the Dictionary. */
2758 {
2761 }
2763 }
2765 {
2768 }
2769 else
2772 /*
2773 * Assign the value to the variable or list item.
2774 */
2777 else
2778 {
2782 }
2783 }
2784 }
2786 /*
2787 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2788 * Returns OK or FAIL.
2789 */
2790 static int
2795 {
2800 /* Can't do anything with a Funcref or a Dict on the right. */
2802 {
2804 {
2812 /* List += List */
2822 {
2823 /* nr += nr or nr -= nr*/
2827 else
2832 }
2833 else
2834 {
2835 /* str .= str */
2841 }
2843 }
2844 }
2848 }
2850 /*
2851 * Add a watcher to a list.
2852 */
2853 static void
2857 {
2860 }
2862 /*
2863 * Remove a watcher from a list.
2864 * No warning when it isn't found...
2865 */
2866 static void
2870 {
2875 {
2877 {
2880 }
2882 }
2883 }
2885 /*
2886 * Just before removing an item from a list: advance watchers to the next
2887 * item.
2888 */
2889 static void
2893 {
2899 }
2901 /*
2902 * Evaluate the expression used in a ":for var in expr" command.
2903 * "arg" points to "var".
2904 * Set "*errp" to TRUE for an error, FALSE otherwise;
2905 * Return a pointer that holds the info. Null when there is an error.
2906 */
2913 {
2916 typval_T tv;
2931 {
2934 }
2939 {
2942 {
2945 {
2948 }
2949 else
2950 {
2951 /* No need to increment the refcount, it's already set for the
2952 * list being used in "tv". */
2956 }
2957 }
2958 }
2963 }
2965 /*
2966 * Use the first item in a ":for" list. Advance to the next.
2967 * Assign the values to the variable (list). "arg" points to the first one.
2968 * Return TRUE when a valid item was found, FALSE when at end of list or
2969 * something wrong.
2970 */
2971 int
2975 {
2983 else
2984 {
2988 }
2990 }
2992 /*
2993 * Free the structure used to store info used by ":for".
2994 */
2995 void
2998 {
3002 {
3005 }
3007 }
3009 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3011 void
3015 cmdidx_T cmdidx;
3016 {
3022 {
3025 {
3026 /* ":let var1 var2 ...": find last space. */
3028 {
3033 }
3035 }
3036 }
3037 else
3042 {
3045 {
3048 {
3052 }
3054 {
3059 }
3060 }
3062 {
3063 /* environment variable */
3065 }
3067 {
3070 }
3074 {
3075 /* Function name can start with "<SNR>" */
3077 }
3079 {
3081 {
3086 }
3088 {
3089 /* Trick: '' is like stopping and starting a literal string. */
3093 }
3095 {
3097 {
3100 }
3101 else
3103 }
3104 else
3106 }
3107 else
3108 /* Doesn't look like something valid, expand as an expression
3109 * anyway. */
3115 }
3117 }
3121 /*
3122 * ":1,25call func(arg1, arg2)" function call.
3123 */
3124 void
3127 {
3133 typval_T rettv;
3134 linenr_T lnum;
3137 funcdict_T fudi;
3141 {
3142 /* Still need to give an error message for missing key. */
3145 }
3149 /* Increase refcount on dictionary, it could get deleted when evaluating
3150 * the arguments. */
3154 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3158 /* Skip white space to allow ":call func ()". Not good, but required for
3159 * backward compatibility. */
3164 {
3167 }
3169 /*
3170 * When skipping, evaluate the function once, to find the end of the
3171 * arguments.
3172 * When the function takes a range, this is discovered after the first
3173 * call, and the loop is broken.
3174 */
3176 {
3179 }
3180 else
3183 {
3185 {
3188 }
3193 {
3196 }
3198 /* Handle a function returning a Funcref, Dictionary or List. */
3200 {
3203 }
3209 /* Stop when immediately aborting on error, or when an interrupt
3210 * occurred or an exception was thrown but not caught.
3211 * get_func_tv() returned OK, so that the check for trailing
3212 * characters below is executed. */
3215 }
3220 {
3221 /* Check for trailing illegal characters and a following command. */
3223 {
3226 }
3227 else
3229 }
3231 end:
3234 }
3236 /*
3237 * ":unlet[!] var1 ... " command.
3238 */
3239 void
3242 {
3244 }
3246 /*
3247 * ":lockvar" and ":unlockvar" commands
3248 */
3249 void
3252 {
3259 {
3262 }
3265 }
3267 /*
3268 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3269 */
3270 static void
3275 {
3279 lval_T lv;
3281 do
3282 {
3283 /* Parse the name and find the end. */
3285 FNE_CHECK_START);
3290 {
3292 {
3295 }
3299 }
3302 {
3304 {
3307 }
3308 else
3309 {
3313 }
3314 }
3323 }
3325 static int
3330 {
3335 {
3339 /* Normal name or expanded name. */
3345 }
3349 {
3352 /* Delete a range of List items. */
3354 {
3359 }
3360 }
3361 else
3362 {
3364 /* unlet a List item. */
3366 else
3367 /* unlet a Dictionary item. */
3369 }
3372 }
3374 /*
3375 * "unlet" a variable. Return OK if it existed, FAIL if not.
3376 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3377 */
3378 int
3382 {
3389 {
3392 {
3399 }
3400 }
3405 }
3407 /*
3408 * Lock or unlock variable indicated by "lp".
3409 * "deep" is the levels to go (-1 for unlimited);
3410 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3411 */
3412 static int
3418 {
3427 {
3431 /* Normal name or expanded name. */
3434 else
3435 {
3439 else
3440 {
3443 else
3446 }
3447 }
3449 }
3451 {
3454 /* (un)lock a range of List items. */
3456 {
3460 }
3461 }
3463 /* (un)lock a List item. */
3465 else
3466 /* un(lock) a Dictionary item. */
3470 }
3472 /*
3473 * Lock or unlock an item. "deep" is nr of levels to go.
3474 */
3475 static void
3480 {
3489 {
3492 }
3497 /* lock/unlock the item itself */
3500 else
3504 {
3507 {
3510 else
3513 /* recursive: lock/unlock the items the List contains */
3516 }
3520 {
3523 else
3526 {
3527 /* recursive: lock/unlock the items the List contains */
3530 {
3532 {
3535 }
3536 }
3537 }
3538 }
3539 }
3541 }
3543 /*
3544 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3545 * it refers to a List or Dictionary that is locked.
3546 */
3547 static int
3550 {
3558 }
3560 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3561 /*
3562 * Delete all "menutrans_" variables.
3563 */
3564 void
3566 {
3573 {
3575 {
3579 }
3580 }
3582 }
3583 #endif
3585 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3587 /*
3588 * Local string buffer for the next two functions to store a variable name
3589 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3590 * get_user_var_name().
3591 */
3598 /*
3599 * Function to concatenate a prefix and a variable name.
3600 */
3605 {
3610 {
3615 {
3618 }
3620 }
3625 }
3627 /*
3628 * Function given to ExpandGeneric() to obtain the list of user defined
3629 * (global/buffer/window/built-in) variable names.
3630 */
3631 /*ARGSUSED*/
3632 char_u *
3636 {
3640 #ifdef FEAT_WINDOWS
3642 #endif
3648 {
3650 #ifdef FEAT_WINDOWS
3652 #endif
3653 }
3655 /* Global variables */
3657 {
3660 else
3667 }
3669 /* b: variables */
3672 {
3675 else
3680 }
3682 {
3685 }
3687 /* w: variables */
3690 {
3693 else
3698 }
3700 #ifdef FEAT_WINDOWS
3701 /* t: variables */
3704 {
3707 else
3712 }
3713 #endif
3715 /* v: variables */
3723 }
3727 /*
3728 * types for expressions.
3729 */
3731 {
3743 /*
3744 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3745 * executed. The function may return OK, but the rettv will be of type
3746 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3747 */
3749 /*
3750 * Handle zero level expression.
3751 * This calls eval1() and handles error message and nextcmd.
3752 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3753 * Note: "rettv.v_lock" is not set.
3754 * Return OK or FAIL.
3755 */
3756 static int
3762 {
3769 {
3772 /*
3773 * Report the invalid expression unless the expression evaluation has
3774 * been cancelled due to an aborting error, an interrupt, or an
3775 * exception.
3776 */
3780 }
3785 }
3787 /*
3788 * Handle top level expression:
3789 * expr1 ? expr0 : expr0
3790 *
3791 * "arg" must point to the first non-white of the expression.
3792 * "arg" is advanced to the next non-white after the recognized expression.
3793 *
3794 * Note: "rettv.v_lock" is not set.
3795 *
3796 * Return OK or FAIL.
3797 */
3798 static int
3803 {
3805 typval_T var2;
3807 /*
3808 * Get the first variable.
3809 */
3814 {
3817 {
3825 }
3827 /*
3828 * Get the second variable.
3829 */
3834 /*
3835 * Check for the ":".
3836 */
3838 {
3843 }
3845 /*
3846 * Get the third variable.
3847 */
3850 {
3854 }
3857 }
3860 }
3862 /*
3863 * Handle first level expression:
3864 * expr2 || expr2 || expr2 logical OR
3865 *
3866 * "arg" must point to the first non-white of the expression.
3867 * "arg" is advanced to the next non-white after the recognized expression.
3868 *
3869 * Return OK or FAIL.
3870 */
3871 static int
3876 {
3877 typval_T var2;
3882 /*
3883 * Get the first variable.
3884 */
3888 /*
3889 * Repeat until there is no following "||".
3890 */
3894 {
3896 {
3903 }
3905 /*
3906 * Get the second variable.
3907 */
3912 /*
3913 * Compute the result.
3914 */
3916 {
3922 }
3924 {
3927 }
3928 }
3931 }
3933 /*
3934 * Handle second level expression:
3935 * expr3 && expr3 && expr3 logical AND
3936 *
3937 * "arg" must point to the first non-white of the expression.
3938 * "arg" is advanced to the next non-white after the recognized expression.
3939 *
3940 * Return OK or FAIL.
3941 */
3942 static int
3947 {
3948 typval_T var2;
3953 /*
3954 * Get the first variable.
3955 */
3959 /*
3960 * Repeat until there is no following "&&".
3961 */
3965 {
3967 {
3974 }
3976 /*
3977 * Get the second variable.
3978 */
3983 /*
3984 * Compute the result.
3985 */
3987 {
3993 }
3995 {
3998 }
3999 }
4002 }
4004 /*
4005 * Handle third level expression:
4006 * var1 == var2
4007 * var1 =~ var2
4008 * var1 != var2
4009 * var1 !~ var2
4010 * var1 > var2
4011 * var1 >= var2
4012 * var1 < var2
4013 * var1 <= var2
4014 * var1 is var2
4015 * var1 isnot var2
4016 *
4017 * "arg" must point to the first non-white of the expression.
4018 * "arg" is advanced to the next non-white after the recognized expression.
4019 *
4020 * Return OK or FAIL.
4021 */
4022 static int
4027 {
4028 typval_T var2;
4037 regmatch_T regmatch;
4041 /*
4042 * Get the first variable.
4043 */
4049 {
4061 {
4064 }
4065 else
4069 {
4072 }
4073 else
4077 {
4081 {
4084 }
4085 }
4087 }
4089 /*
4090 * If there is a comparitive operator, use it.
4091 */
4093 {
4094 /* extra question mark appended: ignore case */
4096 {
4099 }
4100 /* extra '#' appended: match case */
4102 {
4105 }
4106 /* nothing appened: use 'ignorecase' */
4107 else
4110 /*
4111 * Get the second variable.
4112 */
4115 {
4118 }
4121 {
4123 {
4124 /* For "is" a different type always means FALSE, for "notis"
4125 * it means TRUE. */
4127 }
4129 {
4131 {
4136 }
4139 {
4142 else
4147 }
4148 else
4149 {
4150 /* Compare two Lists for being equal or unequal. */
4154 }
4155 }
4158 {
4160 {
4165 }
4168 {
4171 else
4176 }
4177 else
4178 {
4179 /* Compare two Dictionaries for being equal or unequal. */
4183 }
4184 }
4187 {
4190 {
4193 else
4198 }
4199 else
4200 {
4201 /* Compare two Funcrefs for being equal or unequal. */
4205 else
4210 }
4211 }
4213 /*
4214 * If one of the two variables is a number, compare as a number.
4215 * When using "=~" or "!~", always compare as string.
4216 */
4219 {
4223 {
4233 }
4234 }
4235 else
4236 {
4241 else
4245 {
4255 /* avoid 'l' flag in 'cpoptions' */
4262 {
4267 }
4272 }
4273 }
4278 }
4279 }
4282 }
4284 /*
4285 * Handle fourth level expression:
4286 * + number addition
4287 * - number subtraction
4288 * . string concatenation
4289 *
4290 * "arg" must point to the first non-white of the expression.
4291 * "arg" is advanced to the next non-white after the recognized expression.
4292 *
4293 * Return OK or FAIL.
4294 */
4295 static int
4300 {
4301 typval_T var2;
4302 typval_T var3;
4309 /*
4310 * Get the first variable.
4311 */
4315 /*
4316 * Repeat computing, until no '+', '-' or '.' is following.
4317 */
4319 {
4325 {
4326 /* For "list + ...", an illegal use of the first operand as
4327 * a number cannot be determined before evaluating the 2nd
4328 * operand: if this is also a list, all is ok.
4329 * For "something . ...", "something - ..." or "non-list + ...",
4330 * we know that the first operand needs to be a string or number
4331 * without evaluating the 2nd operand. So check before to avoid
4332 * side effects after an error. */
4334 {
4337 }
4338 }
4340 /*
4341 * Get the second variable.
4342 */
4345 {
4348 }
4351 {
4352 /*
4353 * Compute the result.
4354 */
4356 {
4360 {
4364 }
4369 }
4372 {
4373 /* concatenate Lists */
4376 {
4380 }
4383 }
4384 else
4385 {
4390 {
4391 /* This can only happen for "list + non-list".
4392 * For "non-list + ..." or "something - ...", we returned
4393 * before evaluating the 2nd operand. */
4396 }
4399 {
4403 }
4407 else
4411 }
4413 }
4414 }
4416 }
4418 /*
4419 * Handle fifth level expression:
4420 * * number multiplication
4421 * / number division
4422 * % number modulo
4423 *
4424 * "arg" must point to the first non-white of the expression.
4425 * "arg" is advanced to the next non-white after the recognized expression.
4426 *
4427 * Return OK or FAIL.
4428 */
4429 static int
4434 {
4435 typval_T var2;
4440 /*
4441 * Get the first variable.
4442 */
4446 /*
4447 * Repeat computing, until no '*', '/' or '%' is following.
4448 */
4450 {
4456 {
4461 }
4462 else
4465 /*
4466 * Get the second variable.
4467 */
4473 {
4479 /*
4480 * Compute the result.
4481 */
4485 {
4488 else
4490 }
4491 else
4492 {
4495 else
4497 }
4500 }
4501 }
4504 }
4506 /*
4507 * Handle sixth level expression:
4508 * number number constant
4509 * "string" string contstant
4510 * 'string' literal string contstant
4511 * &option-name option value
4512 * @r register contents
4513 * identifier variable value
4514 * function() function call
4515 * $VAR environment variable
4516 * (expression) nested expression
4517 * [expr, expr] List
4518 * {key: val, key: val} Dictionary
4519 *
4520 * Also handle:
4521 * ! in front logical NOT
4522 * - in front unary minus
4523 * + in front unary plus (ignored)
4524 * trailing [] subscript in String or List
4525 * trailing .name entry in Dictionary
4526 *
4527 * "arg" must point to the first non-white of the expression.
4528 * "arg" is advanced to the next non-white after the recognized expression.
4529 *
4530 * Return OK or FAIL.
4531 */
4532 static int
4537 {
4546 /*
4547 * Initialise variable so that clear_tv() can't mistake this for a
4548 * string and free a string that isn't there.
4549 */
4552 /*
4553 * Skip '!' and '-' characters. They are handled later.
4554 */
4561 {
4562 /*
4563 * Number constant.
4564 */
4578 {
4581 }
4584 /*
4585 * String constant: "string".
4586 */
4590 /*
4591 * Literal string constant: 'str''ing'.
4592 */
4596 /*
4597 * List: [expr, expr]
4598 */
4602 /*
4603 * Dictionary: {key: val, key: val}
4604 */
4608 /*
4609 * Option value: &name
4610 */
4614 /*
4615 * Environment variable: $VAR.
4616 */
4620 /*
4621 * Register contents: @r.
4622 */
4625 {
4628 }
4633 /*
4634 * nested expression: (expression).
4635 */
4641 {
4645 }
4650 }
4653 {
4654 /*
4655 * Must be a variable or function name.
4656 * Can also be a curly-braces kind of name: {expr}.
4657 */
4665 else
4666 {
4668 {
4669 /* If "s" is the name of a variable of type VAR_FUNC
4670 * use its contents. */
4673 /* Invoke the function. */
4677 /* Stop the expression evaluation when immediately
4678 * aborting on error, or when an interrupt occurred or
4679 * an exception was thrown but not caught. */
4681 {
4685 }
4686 }
4689 else
4691 }
4695 }
4699 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4700 * expr(expr). */
4704 /*
4705 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4706 */
4708 {
4713 {
4716 }
4717 else
4718 {
4720 {
4726 }
4730 }
4731 }
4734 }
4736 /*
4737 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4738 * "*arg" points to the '[' or '.'.
4739 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4740 */
4741 static int
4747 {
4757 {
4761 }
4764 {
4765 /*
4766 * dict.name
4767 */
4770 ;
4774 }
4775 else
4776 {
4777 /*
4778 * something[idx]
4779 *
4780 * Get the (first) variable from inside the [].
4781 */
4788 {
4789 /* not a number or string */
4792 }
4794 /*
4795 * Get the second variable from inside the [:].
4796 */
4798 {
4804 {
4808 }
4810 {
4811 /* not a number or string */
4816 }
4817 }
4819 /* Check for the ']'. */
4821 {
4828 }
4830 }
4833 {
4836 {
4839 }
4841 {
4844 else
4845 {
4848 }
4849 }
4852 {
4858 {
4859 /* The resulting variable is a substring. If the indexes
4860 * are out of range the result is empty. */
4862 {
4866 }
4873 else
4875 }
4876 else
4877 {
4878 /* The resulting variable is a string of a single
4879 * character. If the index is too big or negative the
4880 * result is empty. */
4883 else
4885 }
4896 {
4897 /* For a range we allow invalid values and return an empty
4898 * list. A list index out of range is an error. */
4900 {
4904 }
4906 }
4908 {
4923 {
4925 {
4928 }
4930 }
4935 }
4936 else
4937 {
4941 }
4946 {
4952 }
4953 {
4957 {
4960 {
4965 }
4966 }
4980 }
4982 }
4983 }
4986 }
4988 /*
4989 * Get an option value.
4990 * "arg" points to the '&' or '+' before the option name.
4991 * "arg" is advanced to character after the option name.
4992 * Return OK or FAIL.
4993 */
4994 static int
4999 {
5009 /*
5010 * Isolate the option name and find its value.
5011 */
5014 {
5018 }
5021 {
5024 }
5032 {
5036 }
5038 {
5040 {
5043 }
5045 {
5048 }
5050 {
5053 }
5055 {
5058 }
5059 }
5067 }
5069 /*
5070 * Allocate a variable for a string constant.
5071 * Return OK or FAIL.
5072 */
5073 static int
5078 {
5083 /*
5084 * Find the end of the string, skipping backslashed characters.
5085 */
5087 {
5089 {
5091 /* A "\<x>" form occupies at least 4 characters, and produces up
5092 * to 6 characters: reserve space for 2 extra */
5095 }
5096 }
5099 {
5102 }
5104 /* If only parsing, set *arg and return here */
5106 {
5109 }
5111 /*
5112 * Copy the string into allocated memory, handling backslashed
5113 * characters.
5114 */
5122 {
5124 {
5126 {
5139 {
5145 else
5149 {
5152 }
5154 #ifdef FEAT_MBYTE
5155 /* For "\u" store the number according to
5156 * 'encoding'. */
5159 else
5160 #endif
5162 }
5165 /* octal: "\1", "\12", "\123" */
5175 {
5179 }
5183 /* Special key, e.g.: "\<C-W>" */
5186 {
5189 }
5190 /* FALLTHROUGH */
5194 }
5195 }
5196 else
5199 }
5204 }
5206 /*
5207 * Allocate a variable for a 'str''ing' constant.
5208 * Return OK or FAIL.
5209 */
5210 static int
5215 {
5220 /*
5221 * Find the end of the string, skipping ''.
5222 */
5224 {
5226 {
5231 }
5232 }
5235 {
5238 }
5240 /* If only parsing return after setting "*arg" */
5242 {
5245 }
5247 /*
5248 * Copy the string into allocated memory, handling '' to ' reduction.
5249 */
5257 {
5259 {
5263 }
5265 }
5270 }
5272 /*
5273 * Allocate a variable for a List and fill it from "*arg".
5274 * Return OK or FAIL.
5275 */
5276 static int
5281 {
5283 typval_T tv;
5287 {
5291 }
5295 {
5299 {
5302 {
5306 }
5307 else
5309 }
5314 {
5317 }
5319 }
5322 {
5324 failret:
5328 }
5332 {
5336 }
5339 }
5341 /*
5342 * Allocate an empty header for a list.
5343 * Caller should take care of the reference count.
5344 */
5345 list_T *
5347 {
5352 {
5353 /* Prepend the list to the list of lists for garbage collection. */
5359 }
5361 }
5363 /*
5364 * Allocate an empty list for a return value.
5365 * Returns OK or FAIL.
5366 */
5367 static int
5370 {
5380 }
5382 /*
5383 * Unreference a list: decrement the reference count and free it when it
5384 * becomes zero.
5385 */
5386 void
5389 {
5392 }
5394 /*
5395 * Free a list, including all items it points to.
5396 * Ignores the reference count.
5397 */
5398 void
5402 {
5405 /* Remove the list from the list of lists for garbage collection. */
5408 else
5414 {
5415 /* Remove the item before deleting it. */
5421 }
5423 }
5425 /*
5426 * Allocate a list item.
5427 */
5430 {
5432 }
5434 /*
5435 * Free a list item. Also clears the value. Does not notify watchers.
5436 */
5437 static void
5440 {
5443 }
5445 /*
5446 * Remove a list item from a List and free it. Also clears the value.
5447 */
5448 static void
5452 {
5455 }
5457 /*
5458 * Get the number of items in a list.
5459 */
5460 static long
5463 {
5467 }
5469 /*
5470 * Return TRUE when two lists have exactly the same values.
5471 */
5472 static int
5477 {
5491 }
5493 #if defined(FEAT_PYTHON) || defined(PROTO)
5494 /*
5495 * Return the dictitem that an entry in a hashtable points to.
5496 */
5497 dictitem_T *
5500 {
5502 }
5503 #endif
5505 /*
5506 * Return TRUE when two dictionaries have exactly the same key/values.
5507 */
5508 static int
5513 {
5525 {
5527 {
5534 }
5535 }
5537 }
5539 /*
5540 * Return TRUE if "tv1" and "tv2" have the same value.
5541 * Compares the items just like "==" would compare them, but strings and
5542 * numbers are different.
5543 */
5544 static int
5549 {
5557 /* Catch lists and dicts that have an endless loop by limiting
5558 * recursiveness to 1000. We guess they are equal then. */
5563 {
5588 }
5592 }
5594 /*
5595 * Locate item with index "n" in list "l" and return it.
5596 * A negative index is counted from the end; -1 is the last item.
5597 * Returns NULL when "n" is out of range.
5598 */
5603 {
5610 /* Negative index is relative to the end. */
5614 /* Check for index out of range. */
5618 /* When there is a cached index may start search from there. */
5620 {
5622 {
5623 /* closest to the start of the list */
5626 }
5628 {
5629 /* closest to the end of the list */
5632 }
5633 else
5634 {
5635 /* closest to the cached index */
5638 }
5639 }
5640 else
5641 {
5643 {
5644 /* closest to the start of the list */
5647 }
5648 else
5649 {
5650 /* closest to the end of the list */
5653 }
5654 }
5657 {
5658 /* search forward */
5661 }
5663 {
5664 /* search backward */
5667 }
5669 /* cache the used index */
5674 }
5676 /*
5677 * Get list item "l[idx]" as a number.
5678 */
5679 static long
5684 {
5689 {
5693 }
5695 }
5697 /*
5698 * Locate "item" list "l" and return its index.
5699 * Returns -1 when "item" is not in the list.
5700 */
5701 static long
5705 {
5717 }
5719 /*
5720 * Append item "item" to the end of list "l".
5721 */
5722 static void
5726 {
5728 {
5729 /* empty list */
5733 }
5734 else
5735 {
5739 }
5742 }
5744 /*
5745 * Append typval_T "tv" to the end of list "l".
5746 * Return FAIL when out of memory.
5747 */
5748 static int
5752 {
5760 }
5762 /*
5763 * Add a dictionary to a list. Used by getqflist().
5764 * Return FAIL when out of memory.
5765 */
5766 int
5770 {
5781 }
5783 /*
5784 * Make a copy of "str" and append it as an item to list "l".
5785 * When "len" >= 0 use "str[len]".
5786 * Returns FAIL when out of memory.
5787 */
5788 static int
5793 {
5807 }
5809 /*
5810 * Append "n" to list "l".
5811 * Returns FAIL when out of memory.
5812 */
5813 static int
5816 varnumber_T n;
5817 {
5828 }
5830 /*
5831 * Insert typval_T "tv" in list "l" before "item".
5832 * If "item" is NULL append at the end.
5833 * Return FAIL when out of memory.
5834 */
5835 static int
5840 {
5847 /* Append new item at end of list. */
5849 else
5850 {
5851 /* Insert new item before existing item. */
5855 {
5858 }
5859 else
5860 {
5863 }
5866 }
5868 }
5870 /*
5871 * Extend "l1" with "l2".
5872 * If "bef" is NULL append at the end, otherwise insert before this item.
5873 * Returns FAIL when out of memory.
5874 */
5875 static int
5880 {
5887 }
5889 /*
5890 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5891 * Return FAIL when out of memory.
5892 */
5893 static int
5898 {
5901 /* make a copy of the first list. */
5908 /* append all items from the second list */
5910 }
5912 /*
5913 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5914 * The refcount of the new list is set to 1.
5915 * See item_copy() for "copyID".
5916 * Returns NULL when out of memory.
5917 */
5923 {
5933 {
5935 {
5936 /* Do this before adding the items, because one of the items may
5937 * refer back to this list. */
5940 }
5943 {
5948 {
5950 {
5953 }
5954 }
5955 else
5958 }
5961 {
5964 }
5965 }
5968 }
5970 /*
5971 * Remove items "item" to "item2" from list "l".
5972 * Does not free the listitem or the value!
5973 */
5974 static void
5979 {
5982 /* notify watchers */
5984 {
5989 }
5993 else
5997 else
6000 }
6002 /*
6003 * Return an allocated string with the string representation of a list.
6004 * May return NULL.
6005 */
6010 {
6011 garray_T ga;
6018 {
6021 }
6025 }
6027 /*
6028 * Join list "l" into a string in "*gap", using separator "sep".
6029 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6030 * Return FAIL or OK.
6031 */
6032 static int
6039 {
6047 {
6050 else
6055 else
6062 }
6064 }
6066 /*
6067 * Garbage collection for lists and dictionaries.
6068 *
6069 * We use reference counts to be able to free most items right away when they
6070 * are no longer used. But for composite items it's possible that it becomes
6071 * unused while the reference count is > 0: When there is a recursive
6072 * reference. Example:
6073 * :let l = [1, 2, 3]
6074 * :let d = {9: l}
6075 * :let l[1] = d
6076 *
6077 * Since this is quite unusual we handle this with garbage collection: every
6078 * once in a while find out which lists and dicts are not referenced from any
6079 * variable.
6080 *
6081 * Here is a good reference text about garbage collection (refers to Python
6082 * but it applies to all reference-counting mechanisms):
6083 * http://python.ca/nas/python/gc/
6084 */
6086 /*
6087 * Do garbage collection for lists and dicts.
6088 * Return TRUE if some memory was freed.
6089 */
6090 int
6092 {
6101 #ifdef FEAT_WINDOWS
6103 #endif
6105 /* Only do this once. */
6109 /*
6110 * 1. Go through all accessible variables and mark all lists and dicts
6111 * with copyID.
6112 */
6113 /* script-local variables */
6117 /* buffer-local variables */
6121 /* window-local variables */
6125 #ifdef FEAT_WINDOWS
6126 /* tabpage-local variables */
6129 #endif
6131 /* global variables */
6134 /* function-local variables */
6136 {
6139 }
6141 /*
6142 * 2. Go through the list of dicts and free items without the copyID.
6143 */
6146 {
6147 /* Free the Dictionary and ordinary items it contains, but don't
6148 * recurse into Lists and Dictionaries, they will be in the list
6149 * of dicts or list of lists. */
6153 /* restart, next dict may also have been freed */
6155 }
6156 else
6159 /*
6160 * 3. Go through the list of lists and free items without the copyID.
6161 * But don't free a list that has a watcher (used in a for loop), these
6162 * are not referenced anywhere.
6163 */
6166 {
6167 /* Free the List and ordinary items it contains, but don't recurse
6168 * into Lists and Dictionaries, they will be in the list of dicts
6169 * or list of lists. */
6173 /* restart, next list may also have been freed */
6175 }
6176 else
6180 }
6182 /*
6183 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6184 */
6185 static void
6189 {
6196 {
6199 }
6200 }
6202 /*
6203 * Mark all lists and dicts referenced through list "l" with "copyID".
6204 */
6205 static void
6209 {
6214 }
6216 /*
6217 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6218 */
6219 static void
6223 {
6228 {
6232 {
6233 /* Didn't see this dict yet. */
6236 }
6242 {
6243 /* Didn't see this list yet. */
6246 }
6248 }
6250 }
6252 /*
6253 * Allocate an empty header for a dictionary.
6254 */
6255 dict_T *
6257 {
6262 {
6263 /* Add the list to the list of dicts for garbage collection. */
6274 }
6276 }
6278 /*
6279 * Unreference a Dictionary: decrement the reference count and free it when it
6280 * becomes zero.
6281 */
6282 static void
6285 {
6288 }
6290 /*
6291 * Free a Dictionary, including all items it contains.
6292 * Ignores the reference count.
6293 */
6294 static void
6298 {
6303 /* Remove the dict from the list of dicts for garbage collection. */
6306 else
6311 /* Lock the hashtab, we don't want it to resize while freeing items. */
6315 {
6317 {
6318 /* Remove the item before deleting it, just in case there is
6319 * something recursive causing trouble. */
6327 }
6328 }
6331 }
6333 /*
6334 * Allocate a Dictionary item.
6335 * The "key" is copied to the new item.
6336 * Note that the value of the item "di_tv" still needs to be initialized!
6337 * Returns NULL when out of memory.
6338 */
6342 {
6347 {
6350 }
6352 }
6354 /*
6355 * Make a copy of a Dictionary item.
6356 */
6360 {
6366 {
6370 }
6372 }
6374 /*
6375 * Remove item "item" from Dictionary "dict" and free it.
6376 */
6377 static void
6381 {
6387 else
6390 }
6392 /*
6393 * Free a dict item. Also clears the value.
6394 */
6395 static void
6398 {
6401 }
6403 /*
6404 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6405 * The refcount of the new dict is set to 1.
6406 * See item_copy() for "copyID".
6407 * Returns NULL when out of memory.
6408 */
6414 {
6425 {
6427 {
6430 }
6433 {
6435 {
6442 {
6445 {
6448 }
6449 }
6450 else
6453 {
6456 }
6457 }
6458 }
6462 {
6465 }
6466 }
6469 }
6471 /*
6472 * Add item "item" to Dictionary "d".
6473 * Returns FAIL when out of memory and when key already existed.
6474 */
6475 static int
6479 {
6481 }
6483 /*
6484 * Add a number or string entry to dictionary "d".
6485 * When "str" is NULL use number "nr", otherwise use "str".
6486 * Returns FAIL when out of memory and when key already exists.
6487 */
6488 int
6494 {
6502 {
6505 }
6506 else
6507 {
6510 }
6512 {
6515 }
6517 }
6519 /*
6520 * Get the number of items in a Dictionary.
6521 */
6522 static long
6525 {
6529 }
6531 /*
6532 * Find item "key[len]" in Dictionary "d".
6533 * If "len" is negative use strlen(key).
6534 * Returns NULL when not found.
6535 */
6541 {
6542 #define AKEYLEN 200
6551 {
6555 }
6556 else
6557 {
6558 /* Avoid a malloc/free by using buf[]. */
6561 }
6568 }
6570 /*
6571 * Get a string item from a dictionary.
6572 * When "save" is TRUE allocate memory for it.
6573 * Returns NULL if the entry doesn't exist or out of memory.
6574 */
6575 char_u *
6580 {
6591 }
6593 /*
6594 * Get a number item from a dictionary.
6595 * Returns 0 if the entry doesn't exist or out of memory.
6596 */
6597 long
6601 {
6608 }
6610 /*
6611 * Return an allocated string with the string representation of a Dictionary.
6612 * May return NULL.
6613 */
6618 {
6619 garray_T ga;
6635 {
6637 {
6642 else
6647 {
6650 }
6658 }
6659 }
6661 {
6664 }
6669 }
6671 /*
6672 * Allocate a variable for a Dictionary and fill it from "*arg".
6673 * Return OK or FAIL. Returns NOTDONE for {expr}.
6674 */
6675 static int
6680 {
6682 typval_T tvkey;
6683 typval_T tv;
6689 /*
6690 * First check if it's not a curly-braces thing: {expr}.
6691 * Must do this without evaluating, otherwise a function may be called
6692 * twice. Unfortunately this means we need to call eval1() twice for the
6693 * first item.
6694 * But {} is an empty Dictionary.
6695 */
6697 {
6702 }
6705 {
6709 }
6715 {
6719 {
6723 }
6726 {
6727 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6732 }
6736 {
6739 }
6741 {
6744 {
6749 }
6753 {
6758 }
6759 }
6764 {
6767 }
6769 }
6772 {
6774 failret:
6778 }
6782 {
6786 }
6789 }
6791 /*
6792 * Return a string with the string representation of a variable.
6793 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6794 * "numbuf" is used for a number.
6795 * Does not put quotes around strings, as ":echo" displays values.
6796 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6797 * May return NULL;
6798 */
6805 {
6810 {
6814 }
6818 {
6826 {
6829 }
6831 {
6834 }
6835 else
6836 {
6840 }
6845 {
6848 }
6850 {
6853 }
6854 else
6855 {
6859 }
6871 }
6875 }
6877 /*
6878 * Return a string with the string representation of a variable.
6879 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6880 * "numbuf" is used for a number.
6881 * Puts quotes around strings, so that they can be parsed back by eval().
6882 * May return NULL;
6883 */
6890 {
6892 {
6905 }
6907 }
6909 /*
6910 * Return string "str" in ' quotes, doubling ' characters.
6911 * If "str" is NULL an empty string is assumed.
6912 * If "function" is TRUE make it function('string').
6913 */
6918 {
6924 {
6929 }
6932 {
6934 {
6937 }
6938 else
6942 {
6946 }
6951 }
6953 }
6955 /*
6956 * Get the value of an environment variable.
6957 * "arg" is pointing to the '$'. It is advanced to after the name.
6958 * If the environment variable was not set, silently assume it is empty.
6959 * Always return OK.
6960 */
6961 static int
6966 {
6977 {
6979 {
6982 /* first try vim_getenv(), fast for normal environment vars */
6985 {
6988 }
6989 else
6990 {
6994 /* next try expanding things like $VIM and ${HOME} */
6997 {
7000 }
7001 }
7003 }
7006 }
7009 }
7011 /*
7012 * Array with names and number of arguments of all internal functions
7013 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7014 */
7015 static struct fst
7016 {
7021 /* implemenation of function */
7023 {
7047 #if defined(FEAT_INS_EXPAND)
7051 #endif
7158 #ifdef vim_mkdir
7160 #endif
7206 #ifdef HAVE_STRFTIME
7208 #endif
7245 };
7247 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7249 /*
7250 * Function given to ExpandGeneric() to obtain the list of internal
7251 * or user defined function names.
7252 */
7253 char_u *
7257 {
7264 {
7268 }
7270 {
7276 }
7279 }
7281 /*
7282 * Function given to ExpandGeneric() to obtain the list of internal or
7283 * user defined variable or function names.
7284 */
7285 /*ARGSUSED*/
7286 char_u *
7290 {
7297 {
7301 }
7303 }
7307 /*
7308 * Find internal function in table above.
7309 * Return index, or -1 if not found
7310 */
7311 static int
7314 {
7320 /*
7321 * Find the function name in the table. Binary search.
7322 */
7324 {
7331 else
7333 }
7335 }
7337 /*
7338 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7339 * name it contains, otherwise return "name".
7340 */
7345 {
7354 {
7356 {
7359 }
7362 }
7365 }
7367 /*
7368 * Allocate a variable for the result of a function.
7369 * Return OK or FAIL.
7370 */
7371 static int
7383 {
7389 /*
7390 * Get the arguments.
7391 */
7394 {
7399 {
7402 }
7406 }
7409 else
7416 {
7419 else
7421 }
7428 }
7431 /*
7432 * Call a function with its resolved parameters
7433 * Return OK when the function can't be called, FAIL otherwise.
7434 * Also returns OK when an error was encountered while executing the function.
7435 */
7436 static int
7444 PLUS ONE elements! */
7450 {
7452 #define ERROR_UNKNOWN 0
7453 #define ERROR_TOOMANY 1
7454 #define ERROR_TOOFEW 2
7455 #define ERROR_SCRIPT 3
7456 #define ERROR_DICT 4
7457 #define ERROR_NONE 5
7458 #define ERROR_OTHER 6
7464 #define FLEN_FIXED 40
7468 /*
7469 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7470 * Change <SNR>123_name() to K_SNR 123_name().
7471 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7472 */
7477 {
7483 {
7486 else
7487 {
7490 }
7491 }
7493 {
7496 }
7497 else
7498 {
7502 else
7503 {
7506 }
7507 }
7508 }
7509 else
7515 /* execute the function if no errors detected and executing */
7517 {
7522 {
7523 /*
7524 * User defined function.
7525 */
7528 #ifdef FEAT_AUTOCMD
7529 /* Trigger FuncUndefined event, may load the function. */
7534 {
7535 /* executed an autocommand, search for the function again */
7537 }
7538 #endif
7539 /* Try loading a package. */
7541 {
7542 /* loaded a package, search for the function again */
7544 }
7547 {
7556 else
7557 {
7558 /*
7559 * Call the user function.
7560 * Save and restore search patterns, script variables and
7561 * redo buffer.
7562 */
7571 /* Function was unreferenced while being used, free it
7572 * now. */
7577 }
7578 }
7579 }
7580 else
7581 {
7582 /*
7583 * Find the function name in the table, call its implementation.
7584 */
7587 {
7592 else
7593 {
7597 }
7598 }
7599 }
7600 /*
7601 * The function call (or "FuncUndefined" autocommand sequence) might
7602 * have been aborted by an error, an interrupt, or an explicitly thrown
7603 * exception that has not been caught so far. This situation can be
7604 * tested for by calling aborting(). For an error in an internal
7605 * function or for the "E132" error in call_user_func(), however, the
7606 * throw point at which the "force_abort" flag (temporarily reset by
7607 * emsg()) is normally updated has not been reached yet. We need to
7608 * update that flag first to make aborting() reliable.
7609 */
7611 }
7615 /*
7616 * Report an error unless the argument evaluation or function call has been
7617 * cancelled due to an aborting error, an interrupt, or an exception.
7618 */
7620 {
7622 {
7631 name);
7635 name);
7639 name);
7641 }
7642 }
7649 }
7651 /*
7652 * Give an error message with a function name. Handle <SNR> things.
7653 */
7654 static void
7658 {
7663 else
7668 }
7670 /*********************************************
7671 * Implementation of the built-in functions
7672 */
7674 /*
7675 * "add(list, item)" function
7676 */
7677 static void
7681 {
7686 {
7691 }
7692 else
7694 }
7696 /*
7697 * "append(lnum, string/list)" function
7698 */
7699 static void
7703 {
7715 {
7717 {
7722 }
7725 {
7730 else
7734 {
7737 }
7743 }
7748 }
7749 else
7751 }
7753 /*
7754 * "argc()" function
7755 */
7756 /* ARGSUSED */
7757 static void
7761 {
7763 }
7765 /*
7766 * "argidx()" function
7767 */
7768 /* ARGSUSED */
7769 static void
7773 {
7775 }
7777 /*
7778 * "argv(nr)" function
7779 */
7780 static void
7784 {
7788 {
7792 else
7795 }
7800 }
7802 /*
7803 * "browse(save, title, initdir, default)" function
7804 */
7805 /* ARGSUSED */
7806 static void
7810 {
7811 #ifdef FEAT_BROWSE
7827 else
7831 #else
7833 #endif
7835 }
7837 /*
7838 * "browsedir(title, initdir)" function
7839 */
7840 /* ARGSUSED */
7841 static void
7845 {
7846 #ifdef FEAT_BROWSE
7856 else
7859 #else
7861 #endif
7863 }
7867 /*
7868 * Find a buffer by number or exact name.
7869 */
7873 {
7879 {
7882 {
7883 /* No full path name match, try a match with a URL or a "nofile"
7884 * buffer, these don't use the full path. */
7888 #ifdef FEAT_QUICKFIX
7890 #endif
7891 )
7894 }
7895 }
7897 }
7899 /*
7900 * "bufexists(expr)" function
7901 */
7902 static void
7906 {
7908 }
7910 /*
7911 * "buflisted(expr)" function
7912 */
7913 static void
7917 {
7922 }
7924 /*
7925 * "bufloaded(expr)" function
7926 */
7927 static void
7931 {
7936 }
7940 /*
7941 * Get buffer by number or pattern.
7942 */
7946 {
7961 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
7973 /* If not found, try expanding the name, like done for bufexists(). */
7978 }
7980 /*
7981 * "bufname(expr)" function
7982 */
7983 static void
7987 {
7996 else
7999 }
8001 /*
8002 * "bufnr(expr)" function
8003 */
8004 static void
8008 {
8018 /* If the buffer isn't found and the second argument is not zero create a
8019 * new buffer. */
8023 && !error
8030 else
8032 }
8034 /*
8035 * "bufwinnr(nr)" function
8036 */
8037 static void
8041 {
8042 #ifdef FEAT_WINDOWS
8045 #endif
8051 #ifdef FEAT_WINDOWS
8053 {
8057 }
8059 #else
8061 #endif
8063 }
8065 /*
8066 * "byte2line(byte)" function
8067 */
8068 /*ARGSUSED*/
8069 static void
8073 {
8074 #ifndef FEAT_BYTEOFF
8076 #else
8082 else
8085 #endif
8086 }
8088 /*
8089 * "byteidx()" function
8090 */
8091 /*ARGSUSED*/
8092 static void
8096 {
8097 #ifdef FEAT_MBYTE
8099 #endif
8109 #ifdef FEAT_MBYTE
8112 {
8116 }
8118 #else
8121 #endif
8122 }
8124 /*
8125 * "call(func, arglist)" function
8126 */
8127 static void
8131 {
8141 {
8144 }
8150 else
8156 {
8158 {
8161 }
8163 }
8167 {
8169 {
8172 }
8173 /* Make a copy of each argument. This is needed to be able to set
8174 * v_lock to VAR_FIXED in the copy without changing the original list.
8175 */
8177 }
8184 /* Free the arguments. */
8187 }
8189 /*
8190 * "changenr()" function
8191 */
8192 /*ARGSUSED*/
8193 static void
8197 {
8199 }
8201 /*
8202 * "char2nr(string)" function
8203 */
8204 static void
8208 {
8209 #ifdef FEAT_MBYTE
8212 else
8213 #endif
8215 }
8217 /*
8218 * "cindent(lnum)" function
8219 */
8220 static void
8224 {
8225 #ifdef FEAT_CINDENT
8226 pos_T pos;
8227 linenr_T lnum;
8232 {
8236 }
8237 else
8238 #endif
8240 }
8242 /*
8243 * "col(string)" function
8244 */
8245 static void
8249 {
8256 {
8258 {
8259 /* '> can be MAXCOL, get the length of the line then */
8262 else
8264 }
8265 else
8266 {
8268 #ifdef FEAT_VIRTUALEDIT
8269 /* col(".") when the cursor is on the NUL at the end of the line
8270 * because of "coladd" can be seen as an extra column. */
8272 {
8277 {
8278 # ifdef FEAT_MBYTE
8283 # else
8286 # endif
8287 }
8288 }
8289 #endif
8290 }
8291 }
8293 }
8295 #if defined(FEAT_INS_EXPAND)
8296 /*
8297 * "complete()" function
8298 */
8299 /*ARGSUSED*/
8300 static void
8304 {
8308 {
8311 }
8313 /* Check for undo allowed here, because if something was already inserted
8314 * the line was already saved for undo and this check isn't done. */
8319 {
8322 }
8329 }
8331 /*
8332 * "complete_add()" function
8333 */
8334 /*ARGSUSED*/
8335 static void
8339 {
8341 }
8343 /*
8344 * "complete_check()" function
8345 */
8346 /*ARGSUSED*/
8347 static void
8351 {
8358 }
8359 #endif
8361 /*
8362 * "confirm(message, buttons[, default [, type]])" function
8363 */
8364 /*ARGSUSED*/
8365 static void
8369 {
8370 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8384 {
8389 {
8392 {
8396 else
8397 {
8399 {
8405 }
8406 }
8407 }
8408 }
8409 }
8416 else
8419 #else
8421 #endif
8422 }
8424 /*
8425 * "copy()" function
8426 */
8427 static void
8431 {
8433 }
8435 /*
8436 * "count()" function
8437 */
8438 static void
8442 {
8447 {
8453 {
8456 {
8461 {
8464 {
8468 }
8469 }
8472 }
8477 }
8478 }
8480 {
8486 {
8490 {
8494 }
8498 {
8500 {
8504 }
8505 }
8506 }
8507 }
8508 else
8511 }
8513 /*
8514 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8515 *
8516 * Checks the existence of a cscope connection.
8517 */
8518 /*ARGSUSED*/
8519 static void
8523 {
8524 #ifdef FEAT_CSCOPE
8532 {
8537 }
8540 #else
8542 #endif
8543 }
8545 /*
8546 * "cursor(lnum, col)" function
8547 *
8548 * Moves the cursor to the specified line and column
8549 */
8550 /*ARGSUSED*/
8551 static void
8555 {
8557 #ifdef FEAT_VIRTUALEDIT
8559 #endif
8562 {
8563 pos_T pos;
8569 #ifdef FEAT_VIRTUALEDIT
8571 #endif
8572 }
8573 else
8574 {
8577 #ifdef FEAT_VIRTUALEDIT
8580 #endif
8581 }
8583 #ifdef FEAT_VIRTUALEDIT
8585 #endif
8586 )
8592 #ifdef FEAT_VIRTUALEDIT
8594 #endif
8596 /* Make sure the cursor is in a valid position. */
8598 #ifdef FEAT_MBYTE
8599 /* Correct cursor for multi-byte character. */
8602 #endif
8605 }
8607 /*
8608 * "deepcopy()" function
8609 */
8610 static void
8614 {
8621 else
8623 }
8625 /*
8626 * "delete()" function
8627 */
8628 static void
8632 {
8635 else
8637 }
8639 /*
8640 * "did_filetype()" function
8641 */
8642 /*ARGSUSED*/
8643 static void
8647 {
8648 #ifdef FEAT_AUTOCMD
8650 #else
8652 #endif
8653 }
8655 /*
8656 * "diff_filler()" function
8657 */
8658 /*ARGSUSED*/
8659 static void
8663 {
8664 #ifdef FEAT_DIFF
8666 #endif
8667 }
8669 /*
8670 * "diff_hlID()" function
8671 */
8672 /*ARGSUSED*/
8673 static void
8677 {
8678 #ifdef FEAT_DIFF
8694 {
8695 /* New line, buffer, change: need to get the values. */
8698 {
8700 {
8705 else
8707 }
8708 else
8710 }
8711 else
8716 }
8719 {
8723 else
8725 }
8727 #endif
8728 }
8730 /*
8731 * "empty({expr})" function
8732 */
8733 static void
8737 {
8741 {
8761 }
8764 }
8766 /*
8767 * "escape({string}, {chars})" function
8768 */
8769 static void
8773 {
8779 }
8781 /*
8782 * "eval()" function
8783 */
8784 /*ARGSUSED*/
8785 static void
8789 {
8797 {
8800 }
8803 }
8805 /*
8806 * "eventhandler()" function
8807 */
8808 /*ARGSUSED*/
8809 static void
8813 {
8815 }
8817 /*
8818 * "executable()" function
8819 */
8820 static void
8824 {
8826 }
8828 /*
8829 * "exists()" function
8830 */
8831 static void
8835 {
8843 {
8844 /* first try "normal" environment variables (fast) */
8847 else
8848 {
8849 /* try expanding things like $VIM and ${HOME} */
8854 }
8855 }
8857 {
8861 }
8863 {
8865 }
8867 {
8869 }
8871 {
8872 #ifdef FEAT_AUTOCMD
8875 else
8877 #endif
8878 }
8880 {
8882 typval_T tv;
8884 /* get_name_len() takes care of expanding curly braces */
8888 {
8893 {
8894 /* handle d.key, l[idx], f(expr) */
8898 }
8899 }
8904 }
8907 }
8909 /*
8910 * "expand()" function
8911 */
8912 static void
8916 {
8921 expand_T xpc;
8927 {
8931 }
8932 else
8933 {
8934 /* When the optional second argument is non-zero, don't remove matches
8935 * for 'suffixes' and 'wildignore' */
8940 {
8944 }
8945 else
8947 }
8948 }
8950 /*
8951 * "extend(list, list [, idx])" function
8952 * "extend(dict, dict [, action])" function
8953 */
8954 static void
8958 {
8961 {
8971 {
8973 {
8980 else
8981 {
8984 {
8987 }
8988 }
8989 }
8990 else
8995 }
8996 }
8998 {
9010 {
9011 /* Check the third argument. */
9013 {
9023 {
9026 }
9027 }
9028 else
9031 /* Go over all entries in the second dict and add them to the
9032 * first dict. */
9035 {
9037 {
9041 {
9045 }
9047 {
9050 }
9052 {
9055 }
9056 }
9057 }
9060 }
9061 }
9062 else
9064 }
9066 /*
9067 * "feedkeys()" function
9068 */
9069 /*ARGSUSED*/
9070 static void
9074 {
9081 /* This is not allowed in the sandbox. If the commands would still be
9082 * executed in the sandbox it would be OK, but it probably happens later,
9083 * when "sandbox" is no longer set. */
9090 {
9092 {
9095 {
9097 {
9101 }
9102 }
9103 }
9105 /* Need to escape K_SPECIAL and CSI before putting the string in the
9106 * typeahead buffer. */
9109 {
9115 }
9116 }
9117 }
9119 /*
9120 * "filereadable()" function
9121 */
9122 static void
9126 {
9133 {
9136 }
9137 else
9141 }
9143 /*
9144 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9145 * rights to write into.
9146 */
9147 static void
9151 {
9153 }
9157 static void
9162 {
9163 #ifdef FEAT_SEARCHPATH
9172 #endif
9177 #ifdef FEAT_SEARCHPATH
9181 {
9185 else
9186 {
9192 }
9193 }
9199 {
9200 do
9201 {
9214 }
9218 #endif
9219 }
9224 /*
9225 * Implementation of map() and filter().
9226 */
9227 static void
9232 {
9241 typval_T save_val;
9242 typval_T save_key;
9250 {
9254 }
9256 {
9260 }
9261 else
9262 {
9265 }
9268 /* On type errors, the preceding call has already displayed an error
9269 * message. Avoid a misleading error message for an empty string that
9270 * was not passed as argument. */
9272 {
9276 /* We reset "did_emsg" to be able to detect whether an error
9277 * occurred during evaluation of the expression. */
9282 {
9290 {
9292 {
9304 }
9305 }
9309 }
9310 else
9311 {
9313 {
9322 }
9323 }
9328 }
9331 }
9333 static int
9339 {
9340 typval_T rettv;
9348 {
9351 }
9353 {
9354 /* map(): replace the list item value */
9358 }
9359 else
9360 {
9363 /* filter(): when expr is zero remove the item */
9366 /* On type error, nothing has been removed; return FAIL to stop the
9367 * loop. The error message was given by get_tv_number_chk(). */
9370 }
9373 }
9375 /*
9376 * "filter()" function
9377 */
9378 static void
9382 {
9384 }
9386 /*
9387 * "finddir({fname}[, {path}[, {count}]])" function
9388 */
9389 static void
9393 {
9395 }
9397 /*
9398 * "findfile({fname}[, {path}[, {count}]])" function
9399 */
9400 static void
9404 {
9406 }
9408 /*
9409 * "fnamemodify({fname}, {mods})" function
9410 */
9411 static void
9415 {
9427 else
9428 {
9431 }
9436 else
9439 }
9443 /*
9444 * "foldclosed()" function
9445 */
9446 static void
9451 {
9452 #ifdef FEAT_FOLDING
9453 linenr_T lnum;
9458 {
9460 {
9463 else
9466 }
9467 }
9468 #endif
9470 }
9472 /*
9473 * "foldclosed()" function
9474 */
9475 static void
9479 {
9481 }
9483 /*
9484 * "foldclosedend()" function
9485 */
9486 static void
9490 {
9492 }
9494 /*
9495 * "foldlevel()" function
9496 */
9497 static void
9501 {
9502 #ifdef FEAT_FOLDING
9503 linenr_T lnum;
9508 else
9509 #endif
9511 }
9513 /*
9514 * "foldtext()" function
9515 */
9516 /*ARGSUSED*/
9517 static void
9521 {
9522 #ifdef FEAT_FOLDING
9523 linenr_T lnum;
9528 #endif
9532 #ifdef FEAT_FOLDING
9537 {
9538 /* Find first non-empty line in the fold. */
9541 {
9545 }
9547 /* Find interesting text in this line. */
9549 /* skip C comment-start */
9551 {
9555 {
9559 }
9560 }
9567 {
9573 /* remove 'foldmarker' and 'commentstring' */
9576 }
9577 }
9578 #endif
9579 }
9581 /*
9582 * "foldtextresult(lnum)" function
9583 */
9584 /*ARGSUSED*/
9585 static void
9589 {
9590 #ifdef FEAT_FOLDING
9591 linenr_T lnum;
9594 foldinfo_T foldinfo;
9596 #endif
9600 #ifdef FEAT_FOLDING
9602 /* treat illegal types and illegal string values for {lnum} the same */
9607 {
9613 }
9614 #endif
9615 }
9617 /*
9618 * "foreground()" function
9619 */
9620 /*ARGSUSED*/
9621 static void
9625 {
9627 #ifdef FEAT_GUI
9630 #else
9631 # ifdef WIN32
9633 # endif
9634 #endif
9635 }
9637 /*
9638 * "function()" function
9639 */
9640 /*ARGSUSED*/
9641 static void
9645 {
9654 else
9655 {
9658 }
9659 }
9661 /*
9662 * "garbagecollect()" function
9663 */
9664 /*ARGSUSED*/
9665 static void
9669 {
9670 /* This is postponed until we are back at the toplevel, because we may be
9671 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9673 }
9675 /*
9676 * "get()" function
9677 */
9678 static void
9682 {
9690 {
9692 {
9698 }
9699 }
9701 {
9703 {
9707 }
9708 }
9709 else
9713 {
9716 else
9718 }
9719 else
9721 }
9723 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9725 /*
9726 * Get line or list of lines from buffer "buf" into "rettv".
9727 * Return a range (from start to end) of lines in rettv from the specified
9728 * buffer.
9729 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9730 */
9731 static void
9734 linenr_T start;
9735 linenr_T end;
9738 {
9742 {
9745 }
9746 else
9753 {
9756 else
9761 }
9762 else
9763 {
9775 }
9776 }
9778 /*
9779 * "getbufline()" function
9780 */
9781 static void
9785 {
9786 linenr_T lnum;
9787 linenr_T end;
9798 else
9802 }
9804 /*
9805 * "getbufvar()" function
9806 */
9807 static void
9811 {
9826 {
9828 {
9829 /* set curbuf to be our buf, temporarily */
9835 /* restore previous notion of curbuf */
9837 }
9838 else
9839 {
9841 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9842 * scope prefix before the NUL byte is required by
9843 * find_var_in_ht(). */
9845 /* look up the variable */
9849 }
9850 }
9853 }
9855 /*
9856 * "getchar()" function
9857 */
9858 static void
9862 {
9863 varnumber_T n;
9866 /* Position the cursor. Needed after a message that ends in a space. */
9872 /* getchar(): blocking wait. */
9875 /* getchar(1): only check if char avail */
9878 /* illegal argument or getchar(0) and no char avail: return zero */
9880 else
9881 /* getchar(0) and char avail: return char */
9892 {
9896 /* Turn a special key into three bytes, plus modifier. */
9898 {
9902 }
9904 {
9908 }
9909 #ifdef FEAT_MBYTE
9912 #endif
9913 else
9919 #ifdef FEAT_MOUSE
9939 {
9943 linenr_T lnum;
9944 # ifdef FEAT_WINDOWS
9946 # endif
9950 {
9951 /* Find the window at the mouse coordinates and compute the
9952 * text position. */
9955 # ifdef FEAT_WINDOWS
9958 # endif
9962 }
9963 }
9964 #endif
9965 }
9966 }
9968 /*
9969 * "getcharmod()" function
9970 */
9971 /*ARGSUSED*/
9972 static void
9976 {
9978 }
9980 /*
9981 * "getcmdline()" function
9982 */
9983 /*ARGSUSED*/
9984 static void
9988 {
9991 }
9993 /*
9994 * "getcmdpos()" function
9995 */
9996 /*ARGSUSED*/
9997 static void
10001 {
10003 }
10005 /*
10006 * "getcmdtype()" function
10007 */
10008 /*ARGSUSED*/
10009 static void
10013 {
10017 {
10020 }
10021 }
10023 /*
10024 * "getcwd()" function
10025 */
10026 /*ARGSUSED*/
10027 static void
10031 {
10037 else
10038 {
10040 #ifdef BACKSLASH_IN_FILENAME
10043 #endif
10044 }
10045 }
10047 /*
10048 * "getfontname()" function
10049 */
10050 /*ARGSUSED*/
10051 static void
10055 {
10058 #ifdef FEAT_GUI
10060 {
10061 GuiFont font;
10065 {
10066 /* Get the "Normal" font. Either the name saved by
10067 * hl_set_font_name() or from the font ID. */
10070 }
10071 else
10072 {
10079 }
10083 }
10084 #endif
10085 }
10087 /*
10088 * "getfperm({fname})" function
10089 */
10090 static void
10094 {
10105 {
10108 {
10110 {
10113 }
10114 }
10115 }
10117 }
10119 /*
10120 * "getfsize({fname})" function
10121 */
10122 static void
10126 {
10135 {
10138 else
10140 }
10141 else
10143 }
10145 /*
10146 * "getftime({fname})" function
10147 */
10148 static void
10152 {
10160 else
10162 }
10164 /*
10165 * "getftype({fname})" function
10166 */
10167 static void
10171 {
10181 {
10182 #ifdef S_ISREG
10187 # ifdef S_ISLNK
10190 # endif
10191 # ifdef S_ISBLK
10194 # endif
10195 # ifdef S_ISCHR
10198 # endif
10199 # ifdef S_ISFIFO
10202 # endif
10203 # ifdef S_ISSOCK
10206 # endif
10207 else
10209 #else
10210 # ifdef S_IFMT
10212 {
10215 # ifdef S_IFLNK
10217 # endif
10218 # ifdef S_IFBLK
10220 # endif
10221 # ifdef S_IFCHR
10223 # endif
10224 # ifdef S_IFIFO
10226 # endif
10227 # ifdef S_IFSOCK
10229 # endif
10231 }
10232 # else
10235 else
10237 # endif
10238 #endif
10240 }
10242 }
10244 /*
10245 * "getline(lnum, [end])" function
10246 */
10247 static void
10251 {
10252 linenr_T lnum;
10253 linenr_T end;
10258 {
10261 }
10262 else
10263 {
10266 }
10269 }
10271 /*
10272 * "getpos(string)" function
10273 */
10274 static void
10278 {
10284 {
10289 else
10296 #ifdef FEAT_VIRTUALEDIT
10298 #endif
10300 }
10301 else
10303 }
10305 /*
10306 * "getqflist()" and "getloclist()" functions
10307 */
10308 /*ARGSUSED*/
10309 static void
10313 {
10314 #ifdef FEAT_QUICKFIX
10316 #endif
10319 #ifdef FEAT_QUICKFIX
10321 {
10324 {
10328 }
10331 }
10332 #endif
10333 }
10335 /*
10336 * "getreg()" function
10337 */
10338 static void
10342 {
10349 {
10354 }
10355 else
10364 }
10366 /*
10367 * "getregtype()" function
10368 */
10369 static void
10373 {
10380 {
10383 {
10387 }
10388 }
10389 else
10390 /* Default to v:register */
10400 {
10403 #ifdef FEAT_VISUAL
10408 #endif
10409 }
10412 }
10414 /*
10415 * "gettabwinvar()" function
10416 */
10417 static void
10421 {
10423 }
10425 /*
10426 * "getwinposx()" function
10427 */
10428 /*ARGSUSED*/
10429 static void
10433 {
10435 #ifdef FEAT_GUI
10437 {
10442 }
10443 #endif
10444 }
10446 /*
10447 * "getwinposy()" function
10448 */
10449 /*ARGSUSED*/
10450 static void
10454 {
10456 #ifdef FEAT_GUI
10458 {
10463 }
10464 #endif
10465 }
10467 /*
10468 * Find window specifed by "vp" in tabpage "tp".
10469 */
10474 {
10475 #ifdef FEAT_WINDOWS
10477 #endif
10482 #ifdef FEAT_WINDOWS
10493 #else
10497 #endif
10498 }
10500 /*
10501 * "getwinvar()" function
10502 */
10503 static void
10507 {
10509 }
10511 /*
10512 * getwinvar() and gettabwinvar()
10513 */
10514 static void
10519 {
10525 #ifdef FEAT_WINDOWS
10528 else
10530 #endif
10539 {
10540 /* Set curwin to be our win, temporarily. Also set curbuf, so
10541 * that we can get buffer-local options. */
10548 else
10549 {
10551 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10552 * scope prefix before the NUL byte is required by
10553 * find_var_in_ht(). */
10555 /* look up the variable */
10559 }
10561 /* restore previous notion of curwin */
10564 }
10567 }
10569 /*
10570 * "glob()" function
10571 */
10572 static void
10576 {
10577 expand_T xpc;
10584 }
10586 /*
10587 * "globpath()" function
10588 */
10589 static void
10593 {
10600 else
10602 }
10604 /*
10605 * "has()" function
10606 */
10607 static void
10611 {
10616 {
10617 #ifdef AMIGA
10619 # ifdef FEAT_ARP
10621 # endif
10622 #endif
10623 #ifdef __BEOS__
10625 #endif
10626 #ifdef MSDOS
10627 # ifdef DJGPP
10629 # else
10631 # endif
10632 #endif
10633 #ifdef MACOS
10635 #endif
10636 #if defined(MACOS_X_UNIX)
10638 #endif
10639 #ifdef OS2
10641 #endif
10642 #ifdef __QNX__
10644 #endif
10645 #ifdef RISCOS
10647 #endif
10648 #ifdef UNIX
10650 #endif
10651 #ifdef VMS
10653 #endif
10654 #ifdef WIN16
10656 #endif
10657 #ifdef WIN32
10659 #endif
10660 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10662 #endif
10663 #ifdef WIN64
10665 #endif
10666 #ifdef EBCDIC
10668 #endif
10669 #ifndef CASE_INSENSITIVE_FILENAME
10671 #endif
10672 #ifdef FEAT_ARABIC
10674 #endif
10675 #ifdef FEAT_AUTOCMD
10677 #endif
10678 #ifdef FEAT_BEVAL
10682 # endif
10683 #endif
10684 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10686 # ifdef ALL_BUILTIN_TCAPS
10688 # endif
10689 #endif
10690 #ifdef FEAT_BYTEOFF
10692 #endif
10693 #ifdef FEAT_CINDENT
10695 #endif
10696 #ifdef FEAT_CLIENTSERVER
10698 #endif
10699 #ifdef FEAT_CLIPBOARD
10701 #endif
10702 #ifdef FEAT_CMDL_COMPL
10704 #endif
10705 #ifdef FEAT_CMDHIST
10707 #endif
10708 #ifdef FEAT_COMMENTS
10710 #endif
10711 #ifdef FEAT_CRYPT
10713 #endif
10714 #ifdef FEAT_CSCOPE
10716 #endif
10717 #ifdef CURSOR_SHAPE
10719 #endif
10720 #ifdef DEBUG
10722 #endif
10723 #ifdef FEAT_CON_DIALOG
10725 #endif
10726 #ifdef FEAT_GUI_DIALOG
10728 #endif
10729 #ifdef FEAT_DIFF
10731 #endif
10732 #ifdef FEAT_DIGRAPHS
10734 #endif
10735 #ifdef FEAT_DND
10737 #endif
10738 #ifdef FEAT_EMACS_TAGS
10740 #endif
10742 #ifdef FEAT_EX_EXTRA
10744 #endif
10745 #ifdef FEAT_SEARCH_EXTRA
10747 #endif
10748 #ifdef FEAT_FKMAP
10750 #endif
10751 #ifdef FEAT_SEARCHPATH
10753 #endif
10754 #if defined(UNIX) && !defined(USE_SYSTEM)
10756 #endif
10757 #ifdef FEAT_FIND_ID
10759 #endif
10760 #ifdef FEAT_FOLDING
10762 #endif
10763 #ifdef FEAT_FOOTER
10765 #endif
10766 #if !defined(USE_SYSTEM) && defined(UNIX)
10768 #endif
10769 #ifdef FEAT_GETTEXT
10771 #endif
10772 #ifdef FEAT_GUI
10774 #endif
10775 #ifdef FEAT_GUI_ATHENA
10776 # ifdef FEAT_GUI_NEXTAW
10778 # else
10780 # endif
10781 #endif
10782 #ifdef FEAT_GUI_GTK
10784 # ifdef HAVE_GTK2
10786 # endif
10787 #endif
10788 #ifdef FEAT_GUI_MAC
10790 #endif
10791 #ifdef FEAT_GUI_MOTIF
10793 #endif
10794 #ifdef FEAT_GUI_PHOTON
10796 #endif
10797 #ifdef FEAT_GUI_W16
10799 #endif
10800 #ifdef FEAT_GUI_W32
10802 #endif
10803 #ifdef FEAT_HANGULIN
10805 #endif
10806 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10808 #endif
10809 #ifdef FEAT_INS_EXPAND
10811 #endif
10812 #ifdef FEAT_JUMPLIST
10814 #endif
10815 #ifdef FEAT_KEYMAP
10817 #endif
10818 #ifdef FEAT_LANGMAP
10820 #endif
10821 #ifdef FEAT_LIBCALL
10823 #endif
10824 #ifdef FEAT_LINEBREAK
10826 #endif
10827 #ifdef FEAT_LISP
10829 #endif
10830 #ifdef FEAT_LISTCMDS
10832 #endif
10833 #ifdef FEAT_LOCALMAP
10835 #endif
10836 #ifdef FEAT_MENU
10838 #endif
10839 #ifdef FEAT_SESSION
10841 #endif
10842 #ifdef FEAT_MODIFY_FNAME
10844 #endif
10845 #ifdef FEAT_MOUSE
10847 #endif
10848 #ifdef FEAT_MOUSESHAPE
10850 #endif
10851 #if defined(UNIX) || defined(VMS)
10852 # ifdef FEAT_MOUSE_DEC
10854 # endif
10855 # ifdef FEAT_MOUSE_GPM
10857 # endif
10858 # ifdef FEAT_MOUSE_JSB
10860 # endif
10861 # ifdef FEAT_MOUSE_NET
10863 # endif
10864 # ifdef FEAT_MOUSE_PTERM
10866 # endif
10867 # ifdef FEAT_MOUSE_XTERM
10869 # endif
10870 #endif
10871 #ifdef FEAT_MBYTE
10873 #endif
10874 #ifdef FEAT_MBYTE_IME
10876 #endif
10877 #ifdef FEAT_MULTI_LANG
10879 #endif
10880 #ifdef FEAT_MZSCHEME
10881 #ifndef DYNAMIC_MZSCHEME
10883 #endif
10884 #endif
10885 #ifdef FEAT_OLE
10887 #endif
10888 #ifdef FEAT_OSFILETYPE
10890 #endif
10891 #ifdef FEAT_PATH_EXTRA
10893 #endif
10894 #ifdef FEAT_PERL
10895 #ifndef DYNAMIC_PERL
10897 #endif
10898 #endif
10899 #ifdef FEAT_PYTHON
10900 #ifndef DYNAMIC_PYTHON
10902 #endif
10903 #endif
10904 #ifdef FEAT_POSTSCRIPT
10906 #endif
10907 #ifdef FEAT_PRINTER
10909 #endif
10910 #ifdef FEAT_PROFILE
10912 #endif
10913 #ifdef FEAT_RELTIME
10915 #endif
10916 #ifdef FEAT_QUICKFIX
10918 #endif
10919 #ifdef FEAT_RIGHTLEFT
10921 #endif
10922 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
10924 #endif
10925 #ifdef FEAT_SCROLLBIND
10927 #endif
10928 #ifdef FEAT_CMDL_INFO
10931 #endif
10932 #ifdef FEAT_SIGNS
10934 #endif
10935 #ifdef FEAT_SMARTINDENT
10937 #endif
10938 #ifdef FEAT_SNIFF
10940 #endif
10941 #ifdef FEAT_STL_OPT
10943 #endif
10944 #ifdef FEAT_SUN_WORKSHOP
10946 #endif
10947 #ifdef FEAT_NETBEANS_INTG
10949 #endif
10950 #ifdef FEAT_SPELL
10952 #endif
10953 #ifdef FEAT_SYN_HL
10955 #endif
10956 #if defined(USE_SYSTEM) || !defined(UNIX)
10958 #endif
10959 #ifdef FEAT_TAG_BINS
10961 #endif
10962 #ifdef FEAT_TAG_OLDSTATIC
10964 #endif
10965 #ifdef FEAT_TAG_ANYWHITE
10967 #endif
10968 #ifdef FEAT_TCL
10969 # ifndef DYNAMIC_TCL
10971 # endif
10972 #endif
10973 #ifdef TERMINFO
10975 #endif
10976 #ifdef FEAT_TERMRESPONSE
10978 #endif
10979 #ifdef FEAT_TEXTOBJ
10981 #endif
10982 #ifdef HAVE_TGETENT
10984 #endif
10985 #ifdef FEAT_TITLE
10987 #endif
10988 #ifdef FEAT_TOOLBAR
10990 #endif
10991 #ifdef FEAT_USR_CMDS
10994 #endif
10995 #ifdef FEAT_VIMINFO
10997 #endif
10998 #ifdef FEAT_VERTSPLIT
11000 #endif
11001 #ifdef FEAT_VIRTUALEDIT
11003 #endif
11004 #ifdef FEAT_VISUAL
11006 #endif
11007 #ifdef FEAT_VISUALEXTRA
11009 #endif
11010 #ifdef FEAT_VREPLACE
11012 #endif
11013 #ifdef FEAT_WILDIGN
11015 #endif
11016 #ifdef FEAT_WILDMENU
11018 #endif
11019 #ifdef FEAT_WINDOWS
11021 #endif
11022 #ifdef FEAT_WAK
11024 #endif
11025 #ifdef FEAT_WRITEBACKUP
11027 #endif
11028 #ifdef FEAT_XIM
11030 #endif
11031 #ifdef FEAT_XFONTSET
11033 #endif
11034 #ifdef USE_XSMP
11036 #endif
11037 #ifdef USE_XSMP_INTERACT
11039 #endif
11040 #ifdef FEAT_XCLIPBOARD
11042 #endif
11043 #ifdef FEAT_XTERM_SAVE
11045 #endif
11046 #if defined(UNIX) && defined(FEAT_X11)
11048 #endif
11049 NULL
11050 };
11055 {
11058 }
11061 {
11066 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11069 #endif
11070 #ifdef DYNAMIC_TCL
11073 #endif
11074 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11077 #endif
11078 #ifdef DYNAMIC_MZSCHEME
11081 #endif
11082 #ifdef DYNAMIC_RUBY
11085 #endif
11086 #ifdef DYNAMIC_PYTHON
11089 #endif
11090 #ifdef DYNAMIC_PERL
11093 #endif
11094 #ifdef FEAT_GUI
11097 # ifdef FEAT_GUI_W32
11100 # endif
11101 # ifdef FEAT_BROWSE
11104 # endif
11105 #endif
11106 #ifdef FEAT_SYN_HL
11109 #endif
11110 #if defined(WIN3264)
11113 #endif
11114 #ifdef FEAT_NETBEANS_INTG
11117 #endif
11118 }
11121 }
11123 /*
11124 * "has_key()" function
11125 */
11126 static void
11130 {
11133 {
11136 }
11142 }
11144 /*
11145 * "haslocaldir()" function
11146 */
11147 /*ARGSUSED*/
11148 static void
11152 {
11154 }
11156 /*
11157 * "hasmapto()" function
11158 */
11159 static void
11163 {
11172 else
11173 {
11177 }
11181 else
11183 }
11185 /*
11186 * "histadd()" function
11187 */
11188 /*ARGSUSED*/
11189 static void
11193 {
11194 #ifdef FEAT_CMDHIST
11198 #endif
11203 #ifdef FEAT_CMDHIST
11207 {
11210 {
11214 }
11215 }
11216 #endif
11217 }
11219 /*
11220 * "histdel()" function
11221 */
11222 /*ARGSUSED*/
11223 static void
11227 {
11228 #ifdef FEAT_CMDHIST
11237 /* only one argument: clear entire history */
11240 /* index given: remove that entry */
11243 else
11244 /* string given: remove all matching entries */
11248 #else
11250 #endif
11251 }
11253 /*
11254 * "histget()" function
11255 */
11256 /*ARGSUSED*/
11257 static void
11261 {
11262 #ifdef FEAT_CMDHIST
11270 else
11271 {
11275 else
11277 /* -1 on type error */
11279 }
11280 #else
11282 #endif
11284 }
11286 /*
11287 * "histnr()" function
11288 */
11289 /*ARGSUSED*/
11290 static void
11294 {
11297 #ifdef FEAT_CMDHIST
11303 else
11304 #endif
11307 }
11309 /*
11310 * "highlightID(name)" function
11311 */
11312 static void
11316 {
11318 }
11320 /*
11321 * "highlight_exists()" function
11322 */
11323 static void
11327 {
11329 }
11331 /*
11332 * "hostname()" function
11333 */
11334 /*ARGSUSED*/
11335 static void
11339 {
11345 }
11347 /*
11348 * iconv() function
11349 */
11350 /*ARGSUSED*/
11351 static void
11355 {
11356 #ifdef FEAT_MBYTE
11360 vimconv_T vimconv;
11361 #endif
11366 #ifdef FEAT_MBYTE
11373 /* If the encodings are equal, no conversion needed. */
11376 else
11382 #endif
11383 }
11385 /*
11386 * "indent()" function
11387 */
11388 static void
11392 {
11393 linenr_T lnum;
11398 else
11400 }
11402 /*
11403 * "index()" function
11404 */
11405 static void
11409 {
11417 {
11420 }
11423 {
11426 {
11429 /* Start at specified item. Use the cached index that list_find()
11430 * sets, so that a negative number also works. */
11437 }
11441 {
11444 }
11445 }
11446 }
11452 /*
11453 * This function is used by f_input() and f_inputdialog() functions. The third
11454 * argument to f_input() specifies the type of completion to use at the
11455 * prompt. The third argument to f_inputdialog() specifies the value to return
11456 * when the user cancels the prompt.
11457 */
11458 static void
11463 {
11475 #ifdef NO_CONSOLE_INPUT
11476 /* While starting up, there is no place to enter text. */
11478 {
11481 }
11482 #endif
11486 {
11487 /* Only the part of the message after the last NL is considered as
11488 * prompt for the command line */
11492 else
11493 {
11503 }
11507 {
11513 {
11529 }
11530 }
11539 /* since the user typed this, no need to wait for return */
11542 }
11544 }
11546 /*
11547 * "input()" function
11548 * Also handles inputsecret() when inputsecret is set.
11549 */
11550 static void
11554 {
11556 }
11558 /*
11559 * "inputdialog()" function
11560 */
11561 static void
11565 {
11566 #if defined(FEAT_GUI_TEXTDIALOG)
11567 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11569 {
11578 else
11584 else
11585 {
11591 else
11593 }
11595 }
11596 else
11597 #endif
11599 }
11601 /*
11602 * "inputlist()" function
11603 */
11604 static void
11608 {
11614 #ifdef NO_CONSOLE_INPUT
11615 /* While starting up, there is no place to enter text. */
11618 #endif
11620 {
11623 }
11632 {
11635 }
11637 /* Ask for choice. */
11643 }
11648 /*
11649 * "inputrestore()" function
11650 */
11651 /*ARGSUSED*/
11652 static void
11656 {
11658 {
11663 }
11665 {
11668 }
11669 }
11671 /*
11672 * "inputsave()" function
11673 */
11674 /*ARGSUSED*/
11675 static void
11679 {
11680 /* Add an entry to the stack of typehead storage. */
11682 {
11687 }
11688 else
11690 }
11692 /*
11693 * "inputsecret()" function
11694 */
11695 static void
11699 {
11705 }
11707 /*
11708 * "insert()" function
11709 */
11710 static void
11714 {
11725 {
11733 else
11734 {
11737 {
11740 }
11741 }
11743 {
11746 }
11747 }
11748 }
11750 /*
11751 * "isdirectory()" function
11752 */
11753 static void
11757 {
11759 }
11761 /*
11762 * "islocked()" function
11763 */
11764 static void
11768 {
11769 lval_T lv;
11775 FNE_CHECK_START);
11777 {
11780 else
11781 {
11783 {
11786 else
11787 {
11790 {
11791 /* Consider a variable locked when:
11792 * 1. the variable itself is locked
11793 * 2. the value of the variable is locked.
11794 * 3. the List or Dict value is locked.
11795 */
11798 }
11799 }
11800 }
11806 /* List item. */
11808 else
11809 /* Dictionary item. */
11811 }
11812 }
11815 }
11819 /*
11820 * Turn a dict into a list:
11821 * "what" == 0: list of keys
11822 * "what" == 1: list of values
11823 * "what" == 2: list of items
11824 */
11825 static void
11830 {
11841 {
11844 }
11853 {
11855 {
11865 {
11866 /* keys() */
11870 }
11872 {
11873 /* values() */
11875 }
11876 else
11877 {
11878 /* items() */
11900 }
11901 }
11902 }
11903 }
11905 /*
11906 * "items(dict)" function
11907 */
11908 static void
11912 {
11914 }
11916 /*
11917 * "join()" function
11918 */
11919 static void
11923 {
11924 garray_T ga;
11929 {
11932 }
11937 else
11943 {
11948 }
11949 else
11951 }
11953 /*
11954 * "keys()" function
11955 */
11956 static void
11960 {
11962 }
11964 /*
11965 * "last_buffer_nr()" function.
11966 */
11967 /*ARGSUSED*/
11968 static void
11972 {
11981 }
11983 /*
11984 * "len()" function
11985 */
11986 static void
11990 {
11992 {
12007 }
12008 }
12012 static void
12017 {
12018 #ifdef FEAT_LIBCALL
12022 #endif
12027 else
12033 #ifdef FEAT_LIBCALL
12034 /* The first two args must be strings, otherwise its meaningless */
12036 {
12042 else
12046 string_in,
12048 string_result,
12052 }
12053 #endif
12054 }
12056 /*
12057 * "libcall()" function
12058 */
12059 static void
12063 {
12065 }
12067 /*
12068 * "libcallnr()" function
12069 */
12070 static void
12074 {
12076 }
12078 /*
12079 * "line(string)" function
12080 */
12081 static void
12085 {
12094 }
12096 /*
12097 * "line2byte(lnum)" function
12098 */
12099 /*ARGSUSED*/
12100 static void
12104 {
12105 #ifndef FEAT_BYTEOFF
12107 #else
12108 linenr_T lnum;
12113 else
12117 #endif
12118 }
12120 /*
12121 * "lispindent(lnum)" function
12122 */
12123 static void
12127 {
12128 #ifdef FEAT_LISP
12129 pos_T pos;
12130 linenr_T lnum;
12135 {
12139 }
12140 else
12141 #endif
12143 }
12145 /*
12146 * "localtime()" function
12147 */
12148 /*ARGSUSED*/
12149 static void
12153 {
12155 }
12159 static void
12164 {
12171 garray_T ga;
12174 /* return empty string for failure */
12183 {
12187 }
12188 else
12199 {
12209 }
12210 }
12212 /*
12213 * "map()" function
12214 */
12215 static void
12219 {
12221 }
12223 /*
12224 * "maparg()" function
12225 */
12226 static void
12230 {
12232 }
12234 /*
12235 * "mapcheck()" function
12236 */
12237 static void
12241 {
12243 }
12247 static void
12252 {
12256 regmatch_T regmatch;
12269 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12275 {
12276 /* return empty list when there are no matches */
12279 }
12281 {
12284 }
12287 {
12291 }
12292 else
12300 {
12307 {
12312 }
12313 else
12314 {
12319 /* When "count" argument is there ignore matches before "start",
12320 * otherwise skip part of the string. Differs when pattern is "^"
12321 * or "\<". */
12324 else
12326 }
12332 }
12336 {
12340 {
12342 {
12344 {
12347 }
12352 }
12361 /* Advance to just after the match. */
12363 {
12366 }
12367 else
12368 {
12369 #ifdef FEAT_MBYTE
12372 #else
12374 #endif
12375 }
12376 }
12379 {
12381 {
12384 /* return list with matched string and submatches */
12386 {
12388 {
12392 }
12398 }
12399 }
12401 {
12402 /* return matched string */
12405 else
12408 }
12411 else
12412 {
12416 else
12420 }
12421 }
12423 }
12425 theend:
12428 }
12430 /*
12431 * "match()" function
12432 */
12433 static void
12437 {
12439 }
12441 /*
12442 * "matcharg()" function
12443 */
12444 static void
12448 {
12450 {
12451 #ifdef FEAT_SEARCH_EXTRA
12455 {
12460 }
12461 #endif
12462 }
12463 }
12465 /*
12466 * "matchend()" function
12467 */
12468 static void
12472 {
12474 }
12476 /*
12477 * "matchlist()" function
12478 */
12479 static void
12483 {
12485 }
12487 /*
12488 * "matchstr()" function
12489 */
12490 static void
12494 {
12496 }
12500 static void
12505 {
12511 {
12517 {
12520 {
12523 {
12530 }
12531 }
12532 }
12533 }
12535 {
12543 {
12546 {
12548 {
12552 {
12555 }
12558 }
12559 }
12560 }
12561 }
12562 else
12565 }
12567 /*
12568 * "max()" function
12569 */
12570 static void
12574 {
12576 }
12578 /*
12579 * "min()" function
12580 */
12581 static void
12585 {
12587 }
12591 /*
12592 * Create the directory in which "dir" is located, and higher levels when
12593 * needed.
12594 */
12595 static int
12599 {
12604 /* Get end of directory name in "dir".
12605 * We're done when it's "/" or "c:/". */
12610 /* If the directory exists we're done. Otherwise: create it.*/
12620 }
12622 #ifdef vim_mkdir
12623 /*
12624 * "mkdir()" function
12625 */
12626 static void
12630 {
12641 {
12646 }
12648 }
12649 #endif
12651 /*
12652 * "mode()" function
12653 */
12654 /*ARGSUSED*/
12655 static void
12659 {
12662 #ifdef FEAT_VISUAL
12664 {
12667 else
12669 }
12670 else
12671 #endif
12675 {
12678 else
12680 }
12683 else
12689 }
12691 /*
12692 * "nextnonblank()" function
12693 */
12694 static void
12698 {
12699 linenr_T lnum;
12702 {
12704 {
12707 }
12710 }
12712 }
12714 /*
12715 * "nr2char()" function
12716 */
12717 static void
12721 {
12724 #ifdef FEAT_MBYTE
12727 else
12728 #endif
12729 {
12732 }
12735 }
12737 /*
12738 * "pathshorten()" function
12739 */
12740 static void
12744 {
12751 else
12752 {
12757 }
12758 }
12760 /*
12761 * "prevnonblank()" function
12762 */
12763 static void
12767 {
12768 linenr_T lnum;
12773 else
12777 }
12779 #ifdef HAVE_STDARG_H
12780 /* This dummy va_list is here because:
12781 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12782 * - locally in the function results in a "used before set" warning
12783 * - using va_start() to initialize it gives "function with fixed args" error */
12785 #endif
12787 /*
12788 * "printf()" function
12789 */
12790 static void
12794 {
12798 {
12805 /* Get the required length, allocate the buffer and do it for real. */
12810 {
12813 {
12816 }
12817 }
12819 }
12820 #endif
12821 }
12823 /*
12824 * "pumvisible()" function
12825 */
12826 /*ARGSUSED*/
12827 static void
12831 {
12833 #ifdef FEAT_INS_EXPAND
12836 #endif
12837 }
12839 /*
12840 * "range()" function
12841 */
12842 static void
12846 {
12855 {
12858 }
12859 else
12860 {
12864 }
12873 else
12874 {
12880 }
12881 }
12883 /*
12884 * "readfile()" function
12885 */
12886 static void
12890 {
12910 {
12915 }
12920 /* Always open the file in binary mode, library functions have a mind of
12921 * their own about CR-LF conversion. */
12924 {
12927 }
12931 {
12936 {
12938 {
12939 /* Only when in binary mode add an empty list item when the
12940 * last line ends in a '\n'. */
12944 /* Found end-of-line or end-of-file: add a text line to the
12945 * list. */
12954 else
12955 {
12958 {
12964 }
12965 }
12970 {
12973 }
12983 }
12986 }
12991 {
12992 /* "buf" is full, need to move text to an allocated buffer */
12994 {
12997 }
12998 else
12999 {
13002 {
13008 }
13009 }
13011 }
13012 else
13013 {
13016 }
13017 }
13019 /*
13020 * For a negative line count use only the lines at the end of the file,
13021 * free the rest.
13022 */
13025 {
13028 }
13032 }
13034 #if defined(FEAT_RELTIME)
13037 /*
13038 * Convert a List to proftime_T.
13039 * Return FAIL when there is something wrong.
13040 */
13041 static int
13045 {
13054 # ifdef WIN3264
13057 # else
13060 # endif
13062 }
13065 /*
13066 * "reltime()" function
13067 */
13068 static void
13072 {
13073 #ifdef FEAT_RELTIME
13074 proftime_T res;
13075 proftime_T start;
13078 {
13079 /* No arguments: get current time. */
13081 }
13083 {
13087 }
13088 else
13089 {
13090 /* Two arguments: compute the difference. */
13095 }
13098 {
13101 # ifdef WIN3264
13104 # else
13107 # endif
13110 }
13111 #endif
13112 }
13114 /*
13115 * "reltimestr()" function
13116 */
13117 static void
13121 {
13122 #ifdef FEAT_RELTIME
13123 proftime_T tm;
13124 #endif
13128 #ifdef FEAT_RELTIME
13131 #endif
13132 }
13134 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13138 static void
13140 {
13142 # ifdef FEAT_GUI
13144 # endif
13145 )
13146 {
13150 }
13151 }
13153 static int
13155 {
13158 {
13161 }
13163 }
13164 #endif
13166 #ifdef FEAT_CLIENTSERVER
13169 static void
13174 {
13179 # ifdef WIN32
13180 HWND w;
13181 # else
13182 Window w;
13183 # endif
13188 # ifdef FEAT_X11
13191 # endif
13197 # ifdef WIN32
13199 # else
13202 # endif
13203 {
13206 else
13209 }
13214 {
13215 dictitem_T v;
13226 }
13227 }
13228 #endif
13230 /*
13231 * "remote_expr()" function
13232 */
13233 /*ARGSUSED*/
13234 static void
13238 {
13241 #ifdef FEAT_CLIENTSERVER
13243 #endif
13244 }
13246 /*
13247 * "remote_foreground()" function
13248 */
13249 /*ARGSUSED*/
13250 static void
13254 {
13256 #ifdef FEAT_CLIENTSERVER
13257 # ifdef WIN32
13258 /* On Win32 it's done in this application. */
13259 {
13264 }
13265 # else
13266 /* Send a foreground() expression to the server. */
13272 # endif
13273 #endif
13274 }
13276 /*ARGSUSED*/
13277 static void
13281 {
13282 #ifdef FEAT_CLIENTSERVER
13283 dictitem_T v;
13285 # ifdef WIN32
13287 # endif
13291 {
13294 }
13297 {
13300 }
13301 # ifdef WIN32
13305 else
13306 {
13309 }
13310 # else
13317 # endif
13320 {
13329 }
13330 #else
13332 #endif
13333 }
13335 /*ARGSUSED*/
13336 static void
13340 {
13343 #ifdef FEAT_CLIENTSERVER
13347 {
13348 # ifdef WIN32
13349 /* The server's HWND is encoded in the 'id' parameter */
13356 # else
13359 # endif
13361 }
13362 #endif
13365 }
13367 /*
13368 * "remote_send()" function
13369 */
13370 /*ARGSUSED*/
13371 static void
13375 {
13378 #ifdef FEAT_CLIENTSERVER
13380 #endif
13381 }
13383 /*
13384 * "remove()" function
13385 */
13386 static void
13390 {
13402 {
13407 {
13410 {
13414 else
13415 {
13419 }
13420 }
13421 }
13422 }
13427 {
13435 else
13436 {
13438 {
13439 /* Remove one item, return its value. */
13443 }
13444 else
13445 {
13446 /* Remove range of items, return list with values. */
13452 else
13453 {
13457 {
13461 }
13464 else
13465 {
13468 {
13475 }
13476 }
13477 }
13478 }
13479 }
13480 }
13481 }
13483 /*
13484 * "rename({from}, {to})" function
13485 */
13486 static void
13490 {
13495 else
13498 }
13500 /*
13501 * "repeat()" function
13502 */
13503 /*ARGSUSED*/
13504 static void
13508 {
13518 {
13524 }
13525 else
13526 {
13538 {
13542 }
13545 }
13546 }
13548 /*
13549 * "resolve()" function
13550 */
13551 static void
13555 {
13559 #ifdef FEAT_SHORTCUT
13560 {
13566 else
13568 }
13569 #else
13570 # ifdef HAVE_READLINK
13571 {
13593 {
13594 /* Separate the first path component in "p", and keep the
13595 * remainder (beginning with the path separator). */
13598 }
13601 {
13603 {
13610 {
13616 }
13618 /* Ensure that the result will have a trailing path separator
13619 * if the argument has one. */
13623 /* Separate the first path component in the link value and
13624 * concatenate the remainders. */
13627 {
13630 else
13631 {
13634 {
13637 }
13638 }
13640 }
13644 {
13645 /* Ignore trailing path separator. */
13648 }
13650 {
13651 /* symlink is relative to directory of argument */
13654 {
13659 }
13660 }
13661 else
13662 {
13665 }
13666 }
13671 /* Append the first path component of "remain" to "p". */
13676 {
13680 }
13681 /* Shorten "remain". */
13684 else
13685 {
13688 }
13689 }
13691 /* If the result is a relative path name, make it explicitly relative to
13692 * the current directory if and only if the argument had this form. */
13694 {
13703 {
13704 /* Prepend "./". */
13707 {
13710 }
13711 }
13713 {
13714 /* Strip leading "./". */
13720 }
13721 }
13723 /* Ensure that the result will have no trailing path separator
13724 * if the argument had none. But keep "/" or "//". */
13726 {
13730 }
13733 }
13734 # else
13736 # endif
13737 #endif
13741 #ifdef HAVE_READLINK
13742 fail:
13743 #endif
13745 }
13747 /*
13748 * "reverse({list})" function
13749 */
13750 static void
13754 {
13763 {
13768 {
13772 }
13776 }
13777 }
13789 /*
13790 * Get flags for a search function.
13791 * Possibly sets "p_ws".
13792 * Returns BACKWARD, FORWARD or zero (for an error).
13793 */
13794 static int
13798 {
13805 {
13810 {
13812 {
13819 {
13827 }
13829 {
13832 }
13833 else
13835 }
13839 }
13840 }
13842 }
13844 /*
13845 * Shared by search() and searchpos() functions
13846 */
13847 static int
13852 {
13855 pos_T pos;
13856 pos_T save_cursor;
13874 /* Optional extra argument: line number to stop searching. */
13877 {
13881 }
13883 /*
13884 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
13885 * Check to make sure only those flags are set.
13886 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
13887 * flags cannot be set. Check for that condition also.
13888 */
13891 {
13894 }
13900 {
13903 else
13909 {
13910 /* Store the match cursor position */
13913 }
13914 /* "/$" will put the cursor after the end of the line, may need to
13915 * correct that here */
13917 }
13919 /* If 'n' flag is used: restore cursor position. */
13922 theend:
13926 }
13928 /*
13929 * "search()" function
13930 */
13931 static void
13935 {
13939 }
13941 /*
13942 * "searchdecl()" function
13943 */
13944 static void
13948 {
13958 {
13962 }
13966 }
13968 /*
13969 * Used by searchpair() and searchpairpos()
13970 */
13971 static int
13975 {
13987 /* Get the three pattern arguments: start, middle, end. */
13994 /* Handle the optional fourth argument: flags */
13999 /* Don't accept SP_END or SP_SUBPAT.
14000 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14001 */
14004 {
14007 }
14009 /* Optional fifth argument: skip expression */
14013 else
14014 {
14017 {
14021 }
14022 }
14029 theend:
14033 }
14035 /*
14036 * "searchpair()" function
14037 */
14038 static void
14042 {
14044 }
14046 /*
14047 * "searchpairpos()" function
14048 */
14049 static void
14053 {
14054 pos_T match_pos;
14064 {
14067 }
14071 }
14073 /*
14074 * Search for a start/middle/end thing.
14075 * Used by searchpair(), see its documentation for the details.
14076 * Returns 0 or -1 for no match,
14077 */
14078 long
14088 {
14092 pos_T pos;
14093 pos_T firstpos;
14094 pos_T foundpos;
14095 pos_T save_cursor;
14096 pos_T save_pos;
14103 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14107 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14108 * start/middle/end (pat3, for the top pair). */
14116 else
14128 {
14132 /* didn't find it or found the first match again: FAIL */
14138 {
14139 /* Found the same position again. Can happen with a pattern that
14140 * has "\zs" at the end and searching backwards. Advance one
14141 * character and try again. */
14144 else
14146 }
14149 /* If the skip pattern matches, ignore this match. */
14151 {
14157 {
14158 /* Evaluating {skip} caused an error, break here. */
14162 }
14165 }
14168 {
14169 /* Found end when searching backwards or start when searching
14170 * forward: nested pair. */
14173 }
14174 else
14175 {
14176 /* Found end when searching forward or start when searching
14177 * backward: end of (nested) pair; or found middle in outer pair. */
14180 }
14183 {
14184 /* Found the match: return matchcount or line number. */
14187 else
14195 }
14196 }
14199 {
14200 /* Store the match cursor position */
14203 }
14205 /* If 'n' flag is used or search failed: restore cursor position. */
14209 theend:
14215 }
14217 /*
14218 * "searchpos()" function
14219 */
14220 static void
14224 {
14225 pos_T match_pos;
14238 {
14241 }
14247 }
14250 /*ARGSUSED*/
14251 static void
14255 {
14256 #ifdef FEAT_CLIENTSERVER
14266 # ifdef FEAT_X11
14269 # endif
14272 {
14275 }
14277 #else
14279 #endif
14280 }
14282 /*ARGSUSED*/
14283 static void
14287 {
14290 #ifdef FEAT_CLIENTSERVER
14291 # ifdef WIN32
14293 # else
14297 # endif
14298 #endif
14301 }
14303 /*
14304 * "setbufvar()" function
14305 */
14306 /*ARGSUSED*/
14307 static void
14311 {
14313 aco_save_T aco;
14328 {
14329 /* set curbuf to be our buf, temporarily */
14333 {
14343 }
14344 else
14345 {
14348 {
14353 }
14354 }
14356 /* reset notion of buffer */
14358 }
14359 }
14361 /*
14362 * "setcmdpos()" function
14363 */
14364 static void
14368 {
14373 }
14375 /*
14376 * "setline()" function
14377 */
14378 static void
14382 {
14383 linenr_T lnum;
14392 {
14395 }
14396 else
14401 {
14403 {
14404 /* list argument, get next string */
14409 }
14415 {
14416 /* existing line, replace it */
14418 {
14423 }
14424 }
14426 {
14427 /* lnum is one past the last line, append the line */
14431 }
14436 }
14440 }
14442 /*
14443 * Used by "setqflist()" and "setloclist()" functions
14444 */
14445 /*ARGSUSED*/
14446 static void
14452 {
14453 #ifdef FEAT_QUICKFIX
14456 #endif
14460 #ifdef FEAT_QUICKFIX
14463 else
14464 {
14468 {
14474 }
14478 }
14479 #endif
14480 }
14482 /*
14483 * "setloclist()" function
14484 */
14485 /*ARGSUSED*/
14486 static void
14490 {
14498 }
14500 /*
14501 * "setpos()" function
14502 */
14503 /*ARGSUSED*/
14504 static void
14508 {
14509 pos_T pos;
14515 {
14517 {
14520 {
14522 {
14525 }
14526 else
14528 }
14531 else
14533 }
14534 }
14535 }
14537 /*
14538 * "setqflist()" function
14539 */
14540 /*ARGSUSED*/
14541 static void
14545 {
14547 }
14549 /*
14550 * "setreg()" function
14551 */
14552 static void
14556 {
14562 char_u yank_type;
14581 {
14587 {
14597 #ifdef FEAT_VISUAL
14601 {
14605 }
14607 #endif
14608 }
14609 }
14616 }
14618 /*
14619 * "settabwinvar()" function
14620 */
14621 static void
14625 {
14627 }
14629 /*
14630 * "setwinvar()" function
14631 */
14632 static void
14636 {
14638 }
14640 /*
14641 * "setwinvar()" and "settabwinvar()" functions
14642 */
14643 static void
14648 {
14650 #ifdef FEAT_WINDOWS
14653 #endif
14664 #ifdef FEAT_WINDOWS
14667 else
14669 #endif
14675 {
14676 #ifdef FEAT_WINDOWS
14677 /* set curwin to be our win, temporarily */
14685 #endif
14688 {
14698 }
14699 else
14700 {
14703 {
14708 }
14709 }
14711 #ifdef FEAT_WINDOWS
14712 /* Restore current tabpage and window, if still valid (autocomands can
14713 * make them invalid). */
14717 {
14720 }
14721 #endif
14722 }
14723 }
14725 /*
14726 * "shellescape({string})" function
14727 */
14728 static void
14732 {
14735 }
14737 /*
14738 * "simplify()" function
14739 */
14740 static void
14744 {
14751 }
14753 static int
14754 #ifdef __BORLANDC__
14755 _RTLENTRYF
14756 #endif
14758 static int
14759 #ifdef __BORLANDC__
14760 _RTLENTRYF
14761 #endif
14767 #define ITEM_COMPARE_FAIL 999
14769 /*
14770 * Compare functions for f_sort() below.
14771 */
14772 static int
14773 #ifdef __BORLANDC__
14774 _RTLENTRYF
14775 #endif
14779 {
14790 else
14795 }
14797 static int
14798 #ifdef __BORLANDC__
14799 _RTLENTRYF
14800 #endif
14804 {
14806 typval_T rettv;
14810 /* shortcut after failure in previous call; compare all items equal */
14814 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
14815 * in the copy without changing the original list items. */
14827 else
14828 /* return value has wrong type */
14834 }
14836 /*
14837 * "sort({list})" function
14838 */
14839 static void
14843 {
14853 else
14854 {
14869 {
14872 else
14873 {
14881 else
14883 }
14884 }
14886 /* Make an array with each entry pointing to an item in the List. */
14895 /* test the compare function */
14900 else
14901 {
14902 /* Sort the array with item pointers. */
14907 {
14908 /* Clear the List and append the items in the sorted order. */
14913 }
14914 }
14917 }
14918 }
14920 /*
14921 * "soundfold({word})" function
14922 */
14923 static void
14927 {
14932 #ifdef FEAT_SPELL
14934 #else
14936 #endif
14937 }
14939 /*
14940 * "spellbadword()" function
14941 */
14942 /* ARGSUSED */
14943 static void
14947 {
14955 #ifdef FEAT_SPELL
14957 {
14958 /* Find the start and length of the badly spelled word. */
14962 }
14964 {
14969 {
14970 /* Check the argument for spelling. */
14972 {
14975 {
14978 }
14980 }
14981 }
14982 }
14983 #endif
14992 }
14994 /*
14995 * "spellsuggest()" function
14996 */
14997 /*ARGSUSED*/
14998 static void
15002 {
15003 #ifdef FEAT_SPELL
15007 garray_T ga;
15011 #endif
15016 #ifdef FEAT_SPELL
15018 {
15021 {
15026 {
15030 }
15031 }
15032 else
15038 {
15044 else
15045 {
15050 }
15051 }
15053 }
15054 #endif
15055 }
15057 static void
15061 {
15065 regmatch_T regmatch;
15073 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15079 {
15085 }
15096 {
15099 {
15102 else
15106 else
15110 {
15114 }
15117 /* Advance to just after the match. */
15120 else
15121 {
15122 /* Don't get stuck at the same match. */
15123 #ifdef FEAT_MBYTE
15125 #else
15127 #endif
15128 }
15130 }
15133 }
15136 }
15138 /*
15139 * "str2nr()" function
15140 */
15141 static void
15145 {
15151 {
15154 {
15157 }
15158 }
15163 }
15165 #ifdef HAVE_STRFTIME
15166 /*
15167 * "strftime({format}[, {time}])" function
15168 */
15169 static void
15173 {
15184 else
15187 /* MSVC returns NULL for an invalid value of seconds. */
15190 else
15191 {
15192 # ifdef FEAT_MBYTE
15193 vimconv_T conv;
15201 # endif
15205 else
15208 # ifdef FEAT_MBYTE
15214 else
15215 # endif
15218 # ifdef FEAT_MBYTE
15219 /* Release conversion descriptors */
15222 # endif
15223 }
15224 }
15225 #endif
15227 /*
15228 * "stridx()" function
15229 */
15230 static void
15234 {
15249 {
15257 }
15262 }
15264 /*
15265 * "string()" function
15266 */
15267 static void
15271 {
15279 }
15281 /*
15282 * "strlen()" function
15283 */
15284 static void
15288 {
15291 }
15293 /*
15294 * "strpart()" function
15295 */
15296 static void
15300 {
15315 else
15318 /*
15319 * Only return the overlap between the specified part and the actual
15320 * string.
15321 */
15323 {
15326 }
15336 }
15338 /*
15339 * "strridx()" function
15340 */
15341 static void
15345 {
15362 {
15363 /* Third argument: upper limit for index */
15367 }
15368 else
15372 {
15373 /* Empty string matches past the end. */
15375 }
15376 else
15377 {
15379 {
15384 }
15385 }
15389 else
15391 }
15393 /*
15394 * "strtrans()" function
15395 */
15396 static void
15400 {
15403 }
15405 /*
15406 * "submatch()" function
15407 */
15408 static void
15412 {
15416 }
15418 /*
15419 * "substitute()" function
15420 */
15421 static void
15425 {
15438 else
15440 }
15442 /*
15443 * "synID(lnum, col, trans)" function
15444 */
15445 /*ARGSUSED*/
15446 static void
15450 {
15452 #ifdef FEAT_SYN_HL
15465 #endif
15468 }
15470 /*
15471 * "synIDattr(id, what [, mode])" function
15472 */
15473 /*ARGSUSED*/
15474 static void
15478 {
15480 #ifdef FEAT_SYN_HL
15490 {
15494 #ifdef FEAT_GUI
15496 #endif
15497 )
15499 }
15500 else
15501 {
15502 #ifdef FEAT_GUI
15505 else
15506 #endif
15509 else
15511 }
15515 {
15548 /* underline */
15550 else
15551 /* undercurl */
15554 }
15558 #endif
15561 }
15563 /*
15564 * "synIDtrans(id)" function
15565 */
15566 /*ARGSUSED*/
15567 static void
15571 {
15574 #ifdef FEAT_SYN_HL
15579 else
15580 #endif
15584 }
15586 /*
15587 * "system()" function
15588 */
15589 static void
15593 {
15602 {
15603 /*
15604 * Write the string to a temp file, to be used for input of the shell
15605 * command.
15606 */
15608 {
15611 }
15615 {
15618 }
15621 {
15624 }
15630 {
15633 }
15634 }
15639 #ifdef USE_CR
15640 /* translate <CR> into <NL> */
15642 {
15646 {
15649 }
15650 }
15651 #else
15652 # ifdef USE_CRNL
15653 /* translate <CR><NL> into <NL> */
15655 {
15660 {
15664 }
15666 }
15667 # endif
15668 #endif
15670 done:
15672 {
15675 }
15678 }
15680 /*
15681 * "tabpagebuflist()" function
15682 */
15683 /* ARGSUSED */
15684 static void
15688 {
15689 #ifndef FEAT_WINDOWS
15691 #else
15697 else
15698 {
15702 }
15705 else
15706 {
15709 else
15710 {
15715 }
15716 }
15717 #endif
15718 }
15721 /*
15722 * "tabpagenr()" function
15723 */
15724 /* ARGSUSED */
15725 static void
15729 {
15731 #ifdef FEAT_WINDOWS
15735 {
15739 {
15742 else
15744 }
15745 }
15746 else
15748 #endif
15750 }
15753 #ifdef FEAT_WINDOWS
15756 /*
15757 * Common code for tabpagewinnr() and winnr().
15758 */
15759 static int
15763 {
15771 {
15778 {
15782 }
15783 else
15784 {
15787 }
15788 }
15793 {
15795 {
15796 /* didn't find it in this tabpage */
15799 }
15801 }
15803 }
15804 #endif
15806 /*
15807 * "tabpagewinnr()" function
15808 */
15809 /* ARGSUSED */
15810 static void
15814 {
15816 #ifdef FEAT_WINDOWS
15822 else
15824 #endif
15826 }
15829 /*
15830 * "tagfiles()" function
15831 */
15832 /*ARGSUSED*/
15833 static void
15837 {
15839 tagname_T tn;
15843 {
15846 }
15853 }
15855 /*
15856 * "taglist()" function
15857 */
15858 static void
15862 {
15873 }
15875 /*
15876 * "tempname()" function
15877 */
15878 /*ARGSUSED*/
15879 static void
15883 {
15889 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
15890 * names. Skip 'I' and 'O', they are used for shell redirection. */
15891 do
15892 {
15897 else
15898 {
15899 #ifdef EBCDIC
15904 else
15905 #endif
15907 }
15909 }
15911 /*
15912 * "test(list)" function: Just checking the walls...
15913 */
15914 /*ARGSUSED*/
15915 static void
15919 {
15920 /* Used for unit testing. Change the code below to your liking. */
15921 #if 0
15940 #endif
15941 }
15943 /*
15944 * "tolower(string)" function
15945 */
15946 static void
15950 {
15959 {
15960 #ifdef FEAT_MBYTE
15964 {
15970 /* TODO: reallocate string when byte count changes. */
15974 }
15977 else
15978 #endif
15979 {
15982 }
15983 }
15984 }
15986 /*
15987 * "toupper(string)" function
15988 */
15989 static void
15993 {
15996 }
15998 /*
15999 * "tr(string, fromstr, tostr)" function
16000 */
16001 static void
16005 {
16010 #ifdef FEAT_MBYTE
16018 #endif
16021 garray_T ga;
16027 /* Default return value: empty string. */
16034 #ifdef FEAT_MBYTE
16036 #endif
16037 /* not multi-byte: fromstr and tostr must be the same length */
16039 {
16040 #ifdef FEAT_MBYTE
16041 error:
16042 #endif
16046 }
16048 /* fromstr and tostr have to contain the same number of chars */
16050 {
16051 #ifdef FEAT_MBYTE
16053 {
16059 {
16062 {
16064 {
16067 {
16071 }
16072 }
16076 }
16078 }
16081 {
16082 /* Check that fromstr and tostr have the same number of
16083 * (multi-byte) characters. Done only once when a character
16084 * of instr doesn't appear in fromstr. */
16087 {
16090 }
16093 }
16100 }
16101 else
16102 #endif
16103 {
16104 /* When not using multi-byte chars we can do it faster. */
16108 else
16111 }
16112 }
16114 /* add a terminating NUL */
16119 }
16121 /*
16122 * "type(expr)" function
16123 */
16124 static void
16128 {
16132 {
16139 }
16141 }
16143 /*
16144 * "values(dict)" function
16145 */
16146 static void
16150 {
16152 }
16154 /*
16155 * "virtcol(string)" function
16156 */
16157 static void
16161 {
16169 {
16172 }
16175 }
16177 /*
16178 * "visualmode()" function
16179 */
16180 /*ARGSUSED*/
16181 static void
16185 {
16186 #ifdef FEAT_VISUAL
16194 /* A non-zero number or non-empty string argument: reset mode. */
16200 #else
16202 #endif
16203 }
16205 /*
16206 * "winbufnr(nr)" function
16207 */
16208 static void
16212 {
16218 else
16220 }
16222 /*
16223 * "wincol()" function
16224 */
16225 /*ARGSUSED*/
16226 static void
16230 {
16233 }
16235 /*
16236 * "winheight(nr)" function
16237 */
16238 static void
16242 {
16248 else
16250 }
16252 /*
16253 * "winline()" function
16254 */
16255 /*ARGSUSED*/
16256 static void
16260 {
16263 }
16265 /*
16266 * "winnr()" function
16267 */
16268 /* ARGSUSED */
16269 static void
16273 {
16276 #ifdef FEAT_WINDOWS
16278 #endif
16280 }
16282 /*
16283 * "winrestcmd()" function
16284 */
16285 /* ARGSUSED */
16286 static void
16290 {
16291 #ifdef FEAT_WINDOWS
16294 garray_T ga;
16299 {
16302 # ifdef FEAT_VERTSPLIT
16305 # endif
16307 }
16311 #else
16313 #endif
16315 }
16317 /*
16318 * "winrestview()" function
16319 */
16320 /* ARGSUSED */
16321 static void
16325 {
16331 else
16332 {
16335 #ifdef FEAT_VIRTUALEDIT
16337 #endif
16342 #ifdef FEAT_DIFF
16344 #endif
16357 #ifdef FEAT_DIFF
16359 #endif
16360 }
16361 }
16363 /*
16364 * "winsaveview()" function
16365 */
16366 /* ARGSUSED */
16367 static void
16371 {
16383 #ifdef FEAT_VIRTUALEDIT
16385 #endif
16390 #ifdef FEAT_DIFF
16392 #endif
16395 }
16397 /*
16398 * "winwidth(nr)" function
16399 */
16400 static void
16404 {
16410 else
16411 #ifdef FEAT_VERTSPLIT
16413 #else
16415 #endif
16416 }
16418 /*
16419 * "writefile()" function
16420 */
16421 static void
16425 {
16435 {
16438 }
16446 /* Always open the file in binary mode, library functions have a mind of
16447 * their own about CR-LF conversion. */
16450 {
16453 }
16454 else
16455 {
16458 {
16460 {
16463 else
16466 {
16469 }
16470 }
16473 {
16476 }
16478 {
16481 }
16482 }
16484 }
16487 }
16489 /*
16490 * Translate a String variable into a position.
16491 * Returns NULL when there is an error.
16492 */
16498 {
16503 /* Argument can be [lnum, col, coladd]. */
16505 {
16514 /* Get the line number */
16519 /* Get the column number */
16524 /* Accept a position up to the NUL after the line. */
16529 #ifdef FEAT_VIRTUALEDIT
16530 /* Get the virtual offset. Defaults to zero. */
16534 #endif
16537 }
16545 {
16550 }
16552 #ifdef FEAT_VIRTUALEDIT
16554 #endif
16557 {
16560 {
16564 }
16566 {
16570 }
16571 }
16573 {
16575 {
16578 }
16579 else
16580 {
16583 }
16585 }
16587 }
16589 /*
16590 * Convert list in "arg" into a position and optional file number.
16591 * When "fnump" is NULL there is no file number, only 3 items.
16592 * Note that the column is passed on as-is, the caller may want to decrement
16593 * it to use 1 for the first column.
16594 * Return FAIL when conversion is not possible, doesn't check the position for
16595 * validity.
16596 */
16597 static int
16602 {
16607 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16608 * when "fnump" isn't NULL and "coladd" is optional. */
16616 {
16623 }
16635 #ifdef FEAT_VIRTUALEDIT
16639 else
16641 #endif
16644 }
16646 /*
16647 * Get the length of an environment variable name.
16648 * Advance "arg" to the first character after the name.
16649 * Return 0 for error.
16650 */
16651 static int
16654 {
16659 ;
16666 }
16668 /*
16669 * Get the length of the name of a function or internal variable.
16670 * "arg" is advanced to the first non-white character after the name.
16671 * Return 0 if something is wrong.
16672 */
16673 static int
16676 {
16680 /* Find the end of the name. */
16682 ;
16690 }
16692 /*
16693 * Get the length of the name of a variable or function.
16694 * Only the name is recognized, does not handle ".key" or "[idx]".
16695 * "arg" is advanced to the first non-white character after the name.
16696 * Return -1 if curly braces expansion failed.
16697 * Return 0 if something else is wrong.
16698 * If the name contains 'magic' {}'s, expand them and return the
16699 * expanded name in an allocated string via 'alias' - caller must free.
16700 */
16701 static int
16707 {
16717 {
16718 /* hard coded <SNR>, already translated */
16721 }
16724 {
16725 /* literal "<SID>", "s:" or "<SNR>" */
16727 }
16729 /*
16730 * Find the end of the name; check for {} construction.
16731 */
16735 {
16739 {
16743 }
16745 /*
16746 * Include any <SID> etc in the expanded string:
16747 * Thus the -len here.
16748 */
16755 }
16762 }
16764 /*
16765 * Find the end of a variable or function name, taking care of magic braces.
16766 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
16767 * start and end of the first magic braces item.
16768 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
16769 * Return a pointer to just after the name. Equal to "arg" if there is no
16770 * valid name.
16771 */
16778 {
16784 {
16787 }
16789 /* Quick check for valid starting character. */
16799 {
16801 {
16802 /* skip over 'string' to avoid counting [ and ] inside it. */
16804 ;
16807 }
16809 {
16810 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
16816 }
16819 {
16824 }
16827 {
16829 {
16830 mb_nest++;
16833 }
16835 {
16836 mb_nest--;
16839 }
16840 }
16841 }
16844 }
16846 /*
16847 * Expands out the 'magic' {}'s in a variable/function name.
16848 * Note that this can call itself recursively, to deal with
16849 * constructs like foo{bar}{baz}{bam}
16850 * The four pointer arguments point to "foo{expre}ss{ion}bar"
16851 * "in_start" ^
16852 * "expr_start" ^
16853 * "expr_end" ^
16854 * "in_end" ^
16855 *
16856 * Returns a new allocated string, which the caller must free.
16857 * Returns NULL for failure.
16858 */
16865 {
16866 char_u c1;
16880 {
16884 {
16888 }
16889 }
16897 {
16900 {
16901 /* Further expansion! */
16906 }
16907 }
16910 }
16912 /*
16913 * Return TRUE if character "c" can be used in a variable or function name.
16914 * Does not include '{' or '}' for magic braces.
16915 */
16916 static int
16919 {
16921 }
16923 /*
16924 * Return TRUE if character "c" can be used as the first character in a
16925 * variable or function name (excluding '{' and '}').
16926 */
16927 static int
16930 {
16932 }
16934 /*
16935 * Set number v: variable to "val".
16936 */
16937 void
16941 {
16943 }
16945 /*
16946 * Get number v: variable value.
16947 */
16948 long
16951 {
16953 }
16955 #if defined(FEAT_AUTOCMD) || defined(PROTO)
16956 /*
16957 * Get string v: variable value. Uses a static buffer, can only be used once.
16958 */
16959 char_u *
16962 {
16964 }
16965 #endif
16967 /*
16968 * Set v:count, v:count1 and v:prevcount.
16969 */
16970 void
16974 {
16978 }
16980 /*
16981 * Set string v: variable to a copy of "val".
16982 */
16983 void
16988 {
16989 /* Need to do this (at least) once, since we can't initialize a union.
16990 * Will always be invoked when "v:progname" is set. */
16998 else
17000 }
17002 /*
17003 * Set v:register if needed.
17004 */
17005 void
17008 {
17009 char_u regname;
17013 else
17015 /* Avoid free/alloc when the value is already right. */
17018 }
17020 /*
17021 * Get or set v:exception. If "oldval" == NULL, return the current value.
17022 * Otherwise, restore the value to "oldval" and return NULL.
17023 * Must always be called in pairs to save and restore v:exception! Does not
17024 * take care of memory allocations.
17025 */
17026 char_u *
17029 {
17035 }
17037 /*
17038 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17039 * Otherwise, restore the value to "oldval" and return NULL.
17040 * Must always be called in pairs to save and restore v:throwpoint! Does not
17041 * take care of memory allocations.
17042 */
17043 char_u *
17046 {
17052 }
17054 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17055 /*
17056 * Set v:cmdarg.
17057 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17058 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17059 * Must always be called in pairs!
17060 */
17061 char_u *
17065 {
17072 {
17076 }
17082 else
17090 # ifdef FEAT_MBYTE
17095 # endif
17105 else
17114 # ifdef FEAT_MBYTE
17121 # endif
17124 }
17125 #endif
17127 /*
17128 * Get the value of internal variable "name".
17129 * Return OK or FAIL.
17130 */
17131 static int
17137 {
17140 typval_T atv;
17144 /* truncate the name, so that we can use strcmp() */
17148 /*
17149 * Check for "b:changedtick".
17150 */
17152 {
17156 }
17158 /*
17159 * Check for user-defined variables.
17160 */
17161 else
17162 {
17166 }
17169 {
17173 }
17180 }
17182 /*
17183 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17184 * Also handle function call with Funcref variable: func(expr)
17185 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17186 */
17187 static int
17193 {
17198 typval_T functv;
17205 {
17207 {
17208 /* need to copy the funcref so that we can clear rettv */
17212 /* Invoke the function. Recursive! */
17218 /* Clear the funcref afterwards, so that deleting it while
17219 * evaluating the arguments is possible (see test55). */
17222 /* Stop the expression evaluation when immediately aborting on
17223 * error, or when an interrupt occurred or an exception was thrown
17224 * but not caught. */
17226 {
17230 }
17233 }
17235 {
17238 {
17242 }
17243 else
17246 {
17249 }
17250 }
17251 }
17254 }
17256 /*
17257 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17258 * value).
17259 */
17262 {
17264 }
17266 /*
17267 * Allocate memory for a variable type-value, and assign a string to it.
17268 * The string "s" must have been allocated, it is consumed.
17269 * Return NULL for out of memory, the variable otherwise.
17270 */
17274 {
17279 {
17282 }
17283 else
17286 }
17288 /*
17289 * Free the memory for a variable type-value.
17290 */
17291 void
17294 {
17296 {
17298 {
17301 /*FALLTHROUGH*/
17317 }
17319 }
17320 }
17322 /*
17323 * Free the memory for a variable value and set the value to NULL or 0.
17324 */
17325 void
17328 {
17330 {
17332 {
17335 /*FALLTHROUGH*/
17355 }
17357 }
17358 }
17360 /*
17361 * Set the value of a variable to NULL without freeing items.
17362 */
17363 static void
17366 {
17369 }
17371 /*
17372 * Get the number value of a variable.
17373 * If it is a String variable, uses vim_str2nr().
17374 * For incompatible types, return 0.
17375 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17376 * caller of incompatible types: it sets *denote to TRUE if "denote"
17377 * is not NULL or returns -1 otherwise.
17378 */
17379 static long
17382 {
17386 }
17388 long
17392 {
17396 {
17416 }
17419 else
17422 }
17424 /*
17425 * Get the lnum from the first argument.
17426 * Also accepts ".", "$", etc., but that only works for the current buffer.
17427 * Returns -1 on error.
17428 */
17429 static linenr_T
17432 {
17433 typval_T rettv;
17434 linenr_T lnum;
17438 {
17443 }
17445 }
17447 /*
17448 * Get the lnum from the first argument.
17449 * Also accepts "$", then "buf" is used.
17450 * Returns 0 on error.
17451 */
17452 static linenr_T
17456 {
17463 }
17465 /*
17466 * Get the string value of a variable.
17467 * If it is a Number variable, the number is converted into a string.
17468 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17469 * get_tv_string_buf() uses a given buffer.
17470 * If the String variable has never been set, return an empty string.
17471 * Never returns NULL;
17472 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17473 * NULL on error.
17474 */
17478 {
17482 }
17488 {
17492 }
17494 char_u *
17497 {
17501 }
17507 {
17509 {
17529 }
17531 }
17533 /*
17534 * Find variable "name" in the list of variables.
17535 * Return a pointer to it if found, NULL if not found.
17536 * Careful: "a:0" variables don't have a name.
17537 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17538 * hashtab_T used.
17539 */
17544 {
17554 }
17556 /*
17557 * Find variable "varname" in hashtab "ht".
17558 * Returns NULL if not found.
17559 */
17565 {
17569 {
17570 /* Must be something like "s:", otherwise "ht" would be NULL. */
17572 {
17578 #ifdef FEAT_WINDOWS
17580 #endif
17585 }
17587 }
17591 {
17592 /* For global variables we may try auto-loading the script. If it
17593 * worked find the variable again. Don't auto-load a script if it was
17594 * loaded already, otherwise it would be loaded every time when
17595 * checking if a function name is a Funcref variable. */
17601 }
17603 }
17605 /*
17606 * Find the hashtab used for a variable name.
17607 * Set "varname" to the start of name without ':'.
17608 */
17613 {
17617 {
17618 /* The name must not start with a colon or #. */
17623 /* "version" is "v:version" in all scopes */
17631 }
17635 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17636 */
17644 #ifdef FEAT_WINDOWS
17647 #endif
17658 }
17660 /*
17661 * Get the string value of a (global/local) variable.
17662 * Returns NULL when it doesn't exist.
17663 */
17664 char_u *
17667 {
17674 }
17676 /*
17677 * Allocate a new hashtab for a sourced script. It will be used while
17678 * sourcing this script and when executing functions defined in the script.
17679 */
17680 void
17682 scid_T id;
17683 {
17689 {
17690 /* Re-allocating ga_data means that an ht_array pointing to
17691 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
17692 * at its init value. Also reset "v_dict", it's always the same. */
17694 {
17700 }
17703 {
17707 }
17708 }
17709 }
17711 /*
17712 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
17713 * point to it.
17714 */
17715 void
17719 {
17727 }
17729 /*
17730 * Clean up a list of internal variables.
17731 * Frees all allocated variables and the value they contain.
17732 * Clears hashtab "ht", does not free it.
17733 */
17734 void
17737 {
17739 }
17741 /*
17742 * Like vars_clear(), but only free the value if "free_val" is TRUE.
17743 */
17744 static void
17748 {
17756 {
17758 {
17761 /* Free the variable. Don't remove it from the hashtab,
17762 * ht_array might change then. hash_clear() takes care of it
17763 * later. */
17769 }
17770 }
17773 }
17775 /*
17776 * Delete a variable from hashtab "ht" at item "hi".
17777 * Clear the variable value and free the dictitem.
17778 */
17779 static void
17783 {
17789 }
17791 /*
17792 * List the value of one internal variable.
17793 */
17794 static void
17798 {
17807 }
17809 static void
17815 {
17826 {
17830 }
17832 {
17836 }
17837 else
17844 }
17846 /*
17847 * Set variable "name" to value in "tv".
17848 * If the variable already exists, the value is updated.
17849 * Otherwise the variable is created.
17850 */
17851 static void
17856 {
17863 {
17867 {
17870 }
17872 {
17874 name);
17876 }
17877 }
17881 {
17884 }
17888 {
17889 /* existing variable, need to clear the value */
17898 {
17901 }
17903 /*
17904 * Handle setting internal v: variables separately: we don't change
17905 * the type.
17906 */
17908 {
17910 {
17914 else
17915 {
17916 /* Take over the string to avoid an extra alloc/free. */
17919 }
17920 }
17923 else
17926 }
17929 }
17931 {
17932 /* Can't add "v:" variable. */
17934 {
17937 }
17939 /* Make sure the variable name is valid. */
17943 {
17946 }
17954 {
17957 }
17959 }
17963 else
17964 {
17968 }
17969 }
17971 /*
17972 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
17973 * Also give an error message.
17974 */
17975 static int
17979 {
17981 {
17984 }
17986 {
17989 }
17991 }
17993 /*
17994 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
17995 * Also give an error message.
17996 */
17997 static int
18001 {
18003 {
18006 }
18008 }
18010 /*
18011 * Return TRUE if typeval "tv" is set to be locked (immutable).
18012 * Also give an error message, using "name".
18013 */
18014 static int
18018 {
18020 {
18024 }
18026 {
18030 }
18032 }
18034 /*
18035 * Copy the values from typval_T "from" to typval_T "to".
18036 * When needed allocates string or increases reference count.
18037 * Does not make a copy of a list or dict but copies the reference!
18038 */
18039 static void
18043 {
18047 {
18055 else
18056 {
18060 }
18065 else
18066 {
18069 }
18074 else
18075 {
18078 }
18083 }
18084 }
18086 /*
18087 * Make a copy of an item.
18088 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18089 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18090 * reference to an already copied list/dict can be used.
18091 * Returns FAIL or OK.
18092 */
18093 static int
18099 {
18104 {
18107 }
18111 {
18123 {
18124 /* use the copy made earlier */
18127 }
18128 else
18139 {
18140 /* use the copy made earlier */
18143 }
18144 else
18152 }
18155 }
18157 /*
18158 * ":echo expr1 ..." print each argument separated with a space, add a
18159 * newline at the end.
18160 * ":echon expr1 ..." print each argument plain.
18161 */
18162 void
18165 {
18167 typval_T rettv;
18177 {
18180 {
18181 /*
18182 * Report the invalid expression unless the expression evaluation
18183 * has been cancelled due to an aborting error, an interrupt, or an
18184 * exception.
18185 */
18189 }
18191 {
18193 {
18195 /* Call msg_start() after eval1(), evaluating the expression
18196 * may cause a message to appear. */
18199 }
18205 {
18207 {
18209 {
18210 /* remove any text still there from the command */
18213 }
18215 }
18216 else
18217 {
18218 #ifdef FEAT_MBYTE
18220 {
18225 }
18226 else
18227 #endif
18229 }
18230 }
18232 }
18235 }
18240 else
18241 {
18242 /* remove text that may still be there from the command */
18247 }
18248 }
18250 /*
18251 * ":echohl {name}".
18252 */
18253 void
18256 {
18262 else
18264 }
18266 /*
18267 * ":execute expr1 ..." execute the result of an expression.
18268 * ":echomsg expr1 ..." Print a message
18269 * ":echoerr expr1 ..." Print an error
18270 * Each gets spaces around each argument and a newline at the end for
18271 * echo commands
18272 */
18273 void
18276 {
18278 typval_T rettv;
18281 garray_T ga;
18290 {
18293 {
18294 /*
18295 * Report the invalid expression unless the expression evaluation
18296 * has been cancelled due to an aborting error, an interrupt, or an
18297 * exception.
18298 */
18303 }
18306 {
18310 {
18314 }
18319 }
18323 }
18326 {
18328 {
18331 }
18333 {
18334 /* We don't want to abort following commands, restore did_emsg. */
18339 }
18343 }
18351 }
18353 /*
18354 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18355 * "arg" points to the "&" or '+' when called, to "option" when returning.
18356 * Returns NULL when no option name found. Otherwise pointer to the char
18357 * after the option name.
18358 */
18363 {
18368 {
18371 }
18373 {
18376 }
18377 else
18386 else
18390 }
18392 /*
18393 * ":function"
18394 */
18395 void
18398 {
18407 garray_T newargs;
18408 garray_T newlines;
18417 funcdict_T fudi;
18425 /*
18426 * ":function" without argument: list functions.
18427 */
18429 {
18431 {
18434 {
18436 {
18441 }
18442 }
18443 }
18446 }
18448 /*
18449 * ":function /pat": list functions matching pattern.
18450 */
18452 {
18455 {
18456 regmatch_T regmatch;
18463 {
18468 {
18470 {
18476 }
18477 }
18478 }
18479 }
18484 }
18486 /*
18487 * Get the function name. There are these situations:
18488 * func normal function name
18489 * "name" == func, "fudi.fd_dict" == NULL
18490 * dict.func new dictionary entry
18491 * "name" == NULL, "fudi.fd_dict" set,
18492 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18493 * dict.func existing dict entry with a Funcref
18494 * "name" == func, "fudi.fd_dict" set,
18495 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18496 * dict.func existing dict entry that's not a Funcref
18497 * "name" == NULL, "fudi.fd_dict" set,
18498 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18499 */
18504 {
18505 /*
18506 * Return on an invalid expression in braces, unless the expression
18507 * evaluation has been cancelled due to an aborting error, an
18508 * interrupt, or an exception.
18509 */
18511 {
18516 }
18517 else
18519 }
18521 /* An error in a function call during evaluation of an expression in magic
18522 * braces should not cause the function not to be defined. */
18526 /*
18527 * ":function func" with only function name: list function.
18528 */
18530 {
18532 {
18535 }
18540 {
18543 {
18546 {
18558 }
18560 {
18563 }
18564 }
18565 else
18567 }
18569 }
18571 /*
18572 * ":function name(arg1, arg2)" Define function.
18573 */
18576 {
18578 {
18581 }
18582 /* attempt to continue by skipping some text */
18585 }
18592 {
18593 /* Check the name of the function. Unless it's a dictionary function
18594 * (that we are overwriting). */
18597 else
18601 {
18604 else
18611 }
18612 }
18614 /*
18615 * Isolate the arguments: "arg1, arg2, ...)"
18616 */
18618 {
18620 {
18624 }
18625 else
18626 {
18633 {
18637 }
18650 else
18652 }
18655 {
18659 }
18660 }
18663 /* find extra arguments "range", "dict" and "abort" */
18665 {
18668 {
18671 }
18673 {
18676 }
18678 {
18681 }
18682 else
18684 }
18686 /* When there is a line break use what follows for the function body.
18687 * Makes 'exe "func Test()\n...\nendfunc"' work. */
18693 /*
18694 * Read the body of the function, until ":endfunction" is found.
18695 */
18697 {
18698 /* Check if the function already exists, don't let the user type the
18699 * whole function before telling him it doesn't work! For a script we
18700 * need to skip the body to be able to find what follows. */
18702 {
18707 }
18714 }
18719 {
18725 {
18726 /* Use eap->arg, split up in parts by line breaks. */
18731 else
18732 {
18735 }
18736 }
18739 else
18744 {
18747 }
18749 /* Detect line continuation: sourcing_lnum increased more than one. */
18752 else
18756 {
18757 /* between ":append" and "." and between ":python <<EOF" and "EOF"
18758 * don't check for ":endfunc". */
18760 {
18763 }
18764 }
18765 else
18766 {
18767 /* skip ':' and blanks*/
18769 ;
18771 /* Check for "endfunction". */
18773 {
18777 }
18779 /* Increase indent inside "if", "while", "for" and "try", decrease
18780 * at "end". */
18789 /* Check for defining a function inside this function. */
18791 {
18796 {
18799 {
18802 }
18803 }
18804 }
18806 /* Check for ":append" or ":insert". */
18814 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
18827 ))
18828 {
18829 /* ":python <<" continues until a dot, like ":append" */
18833 else
18835 }
18836 }
18838 /* Add the line to the function. */
18840 {
18844 }
18846 /* Copy the line to newly allocated memory. get_one_sourceline()
18847 * allocates 250 bytes per line, this saves 80% on average. The cost
18848 * is an extra alloc/free. */
18851 {
18855 }
18859 /* Add NULL lines for continuation lines, so that the line count is
18860 * equal to the index in the growarray. */
18864 /* Check for end of eap->arg. */
18867 }
18869 /* Don't define the function when skipping commands or when an error was
18870 * detected. */
18874 /*
18875 * If there are no errors, add the function
18876 */
18878 {
18881 {
18883 name);
18885 }
18889 {
18891 {
18894 }
18896 {
18898 name);
18900 }
18901 /* redefine existing function */
18906 }
18907 }
18908 else
18909 {
18914 {
18917 }
18919 {
18920 /* Can't add a function to a locked dictionary */
18923 }
18924 /* Can't change an existing function if it is locked */
18928 /* Give the function a sequential number. Can only be used with a
18929 * Funcref! */
18935 }
18938 {
18940 {
18944 /* Check that the autoload name matches the script name. */
18947 {
18950 {
18958 }
18959 }
18961 {
18964 }
18965 }
18972 {
18974 {
18975 /* add new dict entry */
18978 {
18981 }
18983 {
18987 }
18988 }
18989 else
18990 /* overwrite existing dict entry */
18997 /* behave like "dict" was used */
18999 }
19001 /* insert the new function in the function list */
19004 }
19007 #ifdef FEAT_PROFILE
19014 #endif
19021 erret:
19024 ret_free:
19029 }
19031 /*
19032 * Get a function name, translating "<SID>" and "<SNR>".
19033 * Also handles a Funcref in a List or Dictionary.
19034 * Returns the function name in allocated memory, or NULL for failure.
19035 * flags:
19036 * TFN_INT: internal function name OK
19037 * TFN_QUIET: be quiet
19038 * Advances "pp" to just after the function name (if no error).
19039 */
19046 {
19053 lval_T lv;
19059 /* Check for hard coded <SNR>: already translated function ID (from a user
19060 * command). */
19063 {
19067 }
19069 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19070 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19078 {
19082 }
19084 {
19085 /*
19086 * Report an invalid expression in braces, unless the expression
19087 * evaluation has been cancelled due to an aborting error, an
19088 * interrupt, or an exception.
19089 */
19091 {
19094 }
19095 else
19098 }
19101 {
19103 {
19108 }
19110 {
19113 }
19114 else
19115 {
19119 else
19122 }
19124 }
19127 {
19128 /* Error found, but continue after the function name. */
19131 }
19134 {
19138 {
19139 /* When there was "s:" already or the name expanded to get a
19140 * leading "s:" then remove it. */
19144 }
19145 }
19146 else
19147 {
19151 }
19153 /*
19154 * Copy the function name to allocated memory.
19155 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19156 * Accept <SNR>123_name() outside a script.
19157 */
19161 {
19165 {
19166 /* It's "s:" or "<SID>" */
19168 {
19171 }
19174 }
19175 }
19177 {
19180 }
19183 {
19185 {
19191 }
19194 }
19197 theend:
19200 }
19202 /*
19203 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19204 * Return 2 if "p" starts with "s:".
19205 * Return 0 otherwise.
19206 */
19207 static int
19210 {
19217 }
19219 /*
19220 * Return TRUE if "p" starts with "<SID>" or "s:".
19221 * Only works if eval_fname_script() returned non-zero for "p"!
19222 */
19223 static int
19226 {
19228 }
19230 /*
19231 * List the head of the function: "name(arg1, arg2)".
19232 */
19233 static void
19237 {
19245 {
19248 }
19249 else
19253 {
19257 }
19259 {
19263 }
19268 }
19270 /*
19271 * Find a function by name, return pointer to it in ufuncs.
19272 * Return NULL for unknown function.
19273 */
19277 {
19284 }
19286 #if defined(EXITFREE) || defined(PROTO)
19287 void
19289 {
19292 /* Need to start all over every time, because func_free() may change the
19293 * hash table. */
19297 {
19300 }
19301 }
19302 #endif
19304 /*
19305 * Return TRUE if a function "name" exists.
19306 */
19307 static int
19310 {
19318 /* Only accept "funcname", "funcname ", "funcname (..." and
19319 * "funcname(...", not "funcname!...". */
19321 {
19324 else
19326 }
19329 }
19331 /*
19332 * Return TRUE if "name" looks like a builtin function name: starts with a
19333 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19334 */
19335 static int
19338 {
19341 }
19343 #if defined(FEAT_PROFILE) || defined(PROTO)
19344 /*
19345 * Start profiling function "fp".
19346 */
19347 static void
19350 {
19369 }
19371 /*
19372 * Dump the profiling results for all functions in file "fd".
19373 */
19374 void
19377 {
19389 {
19391 {
19395 {
19401 else
19405 else
19413 {
19419 }
19421 }
19422 }
19423 }
19426 {
19428 prof_total_cmp);
19431 prof_self_cmp);
19433 }
19434 }
19436 static void
19443 {
19450 {
19453 prefer_self);
19456 else
19458 }
19460 }
19462 /*
19463 * Print the count and times for one function or function line.
19464 */
19465 static void
19472 {
19474 {
19478 else
19482 else
19484 }
19485 else
19487 }
19489 /*
19490 * Compare function for total time sorting.
19491 */
19492 static int
19493 #ifdef __BORLANDC__
19494 _RTLENTRYF
19495 #endif
19499 {
19505 }
19507 /*
19508 * Compare function for self time sorting.
19509 */
19510 static int
19511 #ifdef __BORLANDC__
19512 _RTLENTRYF
19513 #endif
19517 {
19523 }
19525 #endif
19527 /*
19528 * If "name" has a package name try autoloading the script for it.
19529 * Return TRUE if a package was loaded.
19530 */
19531 static int
19535 {
19541 /* If there is no '#' after name[0] there is no package name. */
19548 /* Find the name in the list of previously loaded package names. Skip
19549 * "autoload/", it's always the same. */
19555 else
19556 {
19557 /* Remember the name if it wasn't loaded already. */
19559 {
19562 }
19564 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19567 }
19571 }
19573 /*
19574 * Return the autoload script name for a function or variable name.
19575 * Returns NULL when out of memory.
19576 */
19580 {
19584 /* Get the script file name: replace '#' with '/', append ".vim". */
19595 }
19597 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19599 /*
19600 * Function given to ExpandGeneric() to obtain the list of user defined
19601 * function names.
19602 */
19603 char_u *
19607 {
19613 {
19616 }
19618 {
19630 {
19634 }
19636 }
19638 }
19642 /*
19643 * Copy the function name of "fp" to buffer "buf".
19644 * "buf" must be able to hold the function name plus three bytes.
19645 * Takes care of script-local function names.
19646 */
19647 static void
19651 {
19653 {
19656 }
19657 else
19659 }
19661 /*
19662 * ":delfunction {name}"
19663 */
19664 void
19667 {
19671 funcdict_T fudi;
19677 {
19681 }
19683 {
19687 }
19697 {
19699 {
19702 }
19704 {
19707 }
19710 {
19711 /* Delete the dict item that refers to the function, it will
19712 * invoke func_unref() and possibly delete the function. */
19714 }
19715 else
19717 }
19718 }
19720 /*
19721 * Free a function and remove it from the list of functions.
19722 */
19723 static void
19726 {
19729 /* clear this function */
19732 #ifdef FEAT_PROFILE
19736 #endif
19738 /* remove the function from the function hashtable */
19742 else
19746 }
19748 /*
19749 * Unreference a Function: decrement the reference count and free it when it
19750 * becomes zero. Only for numbered functions.
19751 */
19752 static void
19755 {
19759 {
19764 {
19765 /* Only delete it when it's not being used. Otherwise it's done
19766 * when "uf_calls" becomes zero. */
19769 }
19770 }
19771 }
19773 /*
19774 * Count a reference to a Function.
19775 */
19776 static void
19779 {
19783 {
19787 else
19789 }
19790 }
19792 /*
19793 * Call a user function.
19794 */
19795 static void
19804 {
19806 linenr_T save_sourcing_lnum;
19807 scid_T save_current_SID;
19808 funccall_T fc;
19817 #ifdef FEAT_PROFILE
19818 proftime_T wait_start;
19819 proftime_T call_start;
19820 #endif
19822 /* If depth of calling is getting too high, don't execute the function */
19824 {
19829 }
19842 /* Check if this function has a breakpoint. */
19846 /*
19847 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
19848 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
19849 * each argument variable and saves a lot of time.
19850 */
19851 /*
19852 * Init l: variables.
19853 */
19856 {
19857 /* Set l:self to "selfdict". Use "name" to avoid a warning from
19858 * some compiler that checks the destination size. */
19868 }
19870 /*
19871 * Init a: variables.
19872 * Set a:0 to "argcount".
19873 * Set a:000 to a list with room for the "..." arguments.
19874 */
19889 /*
19890 * Set a:firstline to "firstline" and a:lastline to "lastline".
19891 * Set a:name to named arguments.
19892 * Set a:N to the "..." arguments.
19893 */
19899 {
19902 /* named argument a:name */
19904 else
19905 {
19906 /* "..." argument a:1, a:2, etc. */
19909 }
19911 {
19914 }
19915 else
19916 {
19922 }
19926 /* Note: the values are copied directly to avoid alloc/free.
19927 * "argvars" must have VAR_FIXED for v_lock. */
19932 {
19936 }
19937 }
19939 /* Don't redraw while executing the function. */
19947 {
19951 else
19956 {
19962 {
19969 {
19974 else
19975 {
19980 }
19981 }
19983 }
19988 }
19989 }
19990 #ifdef FEAT_PROFILE
19992 {
19997 {
20001 }
20003 }
20004 #endif
20011 /* call do_cmdline() to execute the lines */
20017 /* when the function was aborted because of an error, return -1 */
20019 {
20023 }
20025 #ifdef FEAT_PROFILE
20028 {
20034 {
20037 }
20038 }
20039 #endif
20041 /* when being verbose, mention the return value */
20043 {
20052 else
20053 {
20058 /* The value may be very long. Skip the middle part, so that we
20059 * have some idea how it starts and ends. smsg() would always
20060 * truncate it at the end. */
20065 }
20070 }
20076 #ifdef FEAT_PROFILE
20079 #endif
20082 {
20091 }
20096 /* The a: variables typevals were not alloced, only free the allocated
20097 * variables. */
20102 }
20104 /*
20105 * Add a number variable "name" to dict "dp" with value "nr".
20106 */
20107 static void
20112 varnumber_T nr;
20113 {
20120 }
20122 /*
20123 * ":return [expr]"
20124 */
20125 void
20128 {
20130 typval_T rettv;
20134 {
20137 }
20145 {
20148 else
20150 }
20151 /* It's safer to return also on error. */
20153 {
20154 /*
20155 * Return unless the expression evaluation has been cancelled due to an
20156 * aborting error, an interrupt, or an exception.
20157 */
20160 }
20162 /* When skipping or the return gets pending, advance to the next command
20163 * in this line (!returning). Otherwise, ignore the rest of the line.
20164 * Following lines will be ignored by get_func_line(). */
20172 }
20174 /*
20175 * Return from a function. Possibly makes the return pending. Also called
20176 * for a pending return at the ":endtry" or after returning from an extra
20177 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20178 * when called due to a ":return" command. "rettv" may point to a typval_T
20179 * with the return rettv. Returns TRUE when the return can be carried out,
20180 * FALSE when the return gets pending.
20181 */
20182 int
20188 {
20193 /* Undo the return. */
20196 /*
20197 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20198 * not in its finally clause (which then is to be executed next) is found.
20199 * In this case, make the ":return" pending for execution at the ":endtry".
20200 * Otherwise, return normally.
20201 */
20204 {
20208 /* A pending return again gets pending. "rettv" points to an
20209 * allocated variable with the rettv of the original ":return"'s
20210 * argument if present or is NULL else. */
20212 else
20213 {
20214 /* When undoing a return in order to make it pending, get the stored
20215 * return rettv. */
20220 {
20221 /* Store the value of the pending return. */
20224 else
20226 }
20227 else
20231 {
20232 /* The pending return value could be overwritten by a ":return"
20233 * without argument in a finally clause; reset the default
20234 * return value. */
20237 }
20238 }
20240 }
20241 else
20242 {
20245 /* If the return is carried out now, store the return value. For
20246 * a return immediately after reanimation, the value is already
20247 * there. */
20249 {
20254 }
20255 }
20258 }
20260 /*
20261 * Free the variable with a pending return value.
20262 */
20263 void
20266 {
20268 }
20270 /*
20271 * Generate a return command for producing the value of "rettv". The result
20272 * is an allocated string. Used by report_pending() for verbose messages.
20273 */
20274 char_u *
20277 {
20293 }
20295 /*
20296 * Get next function line.
20297 * Called by do_cmdline() to get the next line.
20298 * Returns allocated string, or NULL for end of function.
20299 */
20300 /* ARGSUSED */
20301 char_u *
20306 {
20312 /* If breakpoints have been added/deleted need to check for it. */
20314 {
20316 sourcing_lnum);
20318 }
20319 #ifdef FEAT_PROFILE
20322 #endif
20328 else
20329 {
20330 /* Skip NULL lines (continuation lines). */
20336 else
20337 {
20340 #ifdef FEAT_PROFILE
20343 #endif
20344 }
20345 }
20347 /* Did we encounter a breakpoint? */
20349 {
20351 /* Find next breakpoint. */
20353 sourcing_lnum);
20355 }
20358 }
20360 #if defined(FEAT_PROFILE) || defined(PROTO)
20361 /*
20362 * Called when starting to read a function line.
20363 * "sourcing_lnum" must be correct!
20364 * When skipping lines it may not actually be executed, but we won't find out
20365 * until later and we need to store the time now.
20366 */
20367 void
20370 {
20376 {
20378 /* Skip continuation lines. */
20385 }
20386 }
20388 /*
20389 * Called when actually executing a function line.
20390 */
20391 void
20394 {
20400 }
20402 /*
20403 * Called when done with a function line.
20404 */
20405 void
20408 {
20413 {
20415 {
20422 }
20424 }
20425 }
20426 #endif
20428 /*
20429 * Return TRUE if the currently active function should be ended, because a
20430 * return was encountered or an error occured. Used inside a ":while".
20431 */
20432 int
20435 {
20438 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20439 * an error inside a try conditional. */
20442 }
20444 /*
20445 * return TRUE if cookie indicates a function which "abort"s on errors.
20446 */
20447 int
20450 {
20452 }
20454 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20456 {
20457 VAR_FLAVOUR_DEFAULT,
20458 VAR_FLAVOUR_SESSION,
20459 VAR_FLAVOUR_VIMINFO
20464 static var_flavour_T
20467 {
20471 {
20476 }
20477 else
20479 }
20480 #endif
20482 #if defined(FEAT_VIMINFO) || defined(PROTO)
20483 /*
20484 * Restore global vars that start with a capital from the viminfo file
20485 */
20486 int
20490 {
20493 typval_T tv;
20496 {
20499 {
20506 {
20508 {
20512 }
20513 else
20514 {
20517 }
20521 }
20522 }
20523 }
20526 }
20528 /*
20529 * Write global vars that start with a capital to the viminfo file
20530 */
20531 void
20534 {
20550 {
20552 {
20556 {
20558 {
20562 }
20568 }
20569 }
20570 }
20571 }
20572 #endif
20574 #if defined(FEAT_SESSION) || defined(PROTO)
20575 int
20578 {
20586 {
20588 {
20594 {
20595 /* Escape special characters with a backslash. Turn a LF and
20596 * CR into \n and \r. */
20610 p,
20614 {
20617 }
20619 }
20620 }
20621 }
20623 }
20624 #endif
20626 /*
20627 * Display script name where an item was last set.
20628 * Should only be invoked when 'verbose' is non-zero.
20629 */
20630 void
20632 scid_T scriptID;
20633 {
20637 {
20640 {
20646 }
20647 }
20648 }
20652 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
20655 #ifdef WIN3264
20656 /*
20657 * Functions for ":8" filename modifier: get 8.3 version of a filename.
20658 */
20660 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
20663 /*
20664 * Get the short pathname of a file.
20665 * Returns 1 on success. *fnamelen is 0 for nonexistant path.
20666 */
20667 static int
20672 {
20680 {
20681 /* If that doesn't work (not enough space), then save the string
20682 * and try again with a new buffer big enough
20683 */
20693 /* Really should always succeed, as the buffer is big enough */
20694 }
20698 }
20700 /*
20701 * Create a short path name. Returns the length of the buffer it needs.
20702 * Doesn't copy over the end of the buffer passed in.
20703 */
20704 static int
20709 {
20711 char_u ch;
20714 /* Make a copy */
20724 {
20728 }
20730 do
20731 {
20732 /* Go back one path-seperator */
20734 {
20738 }
20742 /* Remeber the character that is about to be blatted */
20746 /* Try it in situ */
20749 {
20752 }
20757 {
20758 /* Remeber the length of the new string. */
20762 {
20763 /* If there's not enough space in the currently allocated string,
20764 * then copy it to a buffer big enough.
20765 */
20769 }
20770 else
20771 {
20772 /* Transfer pbuf2 to being the main buffer (it's big enough) */
20777 }
20778 /* Concat the next bit */
20781 }
20785 }
20787 /*
20788 * Get a pathname for a partial path.
20789 */
20790 static int
20795 {
20801 /* Count up the path seperators from the RHS.. so we know which part
20802 * of the path to return.
20803 */
20809 /* Need full path first (use expand_env() to remove a "~/") */
20813 else
20822 {
20823 /* Don't have a valid filename, so shorten the rest of the
20824 * path if we can. This CAN give us invalid 8.3 filenames, but
20825 * there's not a lot of point in guessing what it might be.
20826 */
20830 }
20832 /* Count the paths backward to find the beginning of the desired string. */
20834 {
20835 #ifdef FEAT_MBYTE
20838 #endif
20840 {
20843 else
20844 sepcount --;
20845 }
20846 }
20848 {
20852 else
20854 }
20855 else
20858 /* Copy in the string - p indexes into tfname - allocated at pbuf */
20865 }
20868 /*
20869 * Adjust a filename, according to a string of modifiers.
20870 * *fnamep must be NUL terminated when called. When returning, the length is
20871 * determined by *fnamelen.
20872 * Returns valid flags.
20873 * When there is an error, *fnamep is set to NULL.
20874 */
20875 int
20882 {
20889 #ifdef WIN3264
20891 #endif
20893 repeat:
20894 /* ":p" - full path/file_name */
20896 {
20902 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
20904 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
20906 # ifdef BACKSLASH_IN_FILENAME
20908 # endif
20911 #endif
20912 )
20913 {
20919 }
20921 /* When "/." or "/.." is used: force expansion to get rid of it. */
20923 {
20931 }
20933 /* FullName_save() is slow, don't use it when not needed. */
20935 {
20941 }
20943 /* Append a path separator to a directory. */
20945 {
20946 /* Make room for one or two extra characters. */
20953 }
20954 }
20956 /* ":." - path relative to the current directory */
20957 /* ":~" - path relative to the home directory */
20958 /* ":8" - shortname path - postponed till after */
20961 {
20964 {
20965 #ifdef WIN3264
20967 #endif
20969 }
20971 /* Need full path first (use expand_env() to remove a "~/") */
20973 {
20976 else
20978 }
20979 else
20985 {
20987 {
20991 {
20994 {
20998 }
20999 }
21000 }
21001 else
21002 {
21004 /* Only replace it when it starts with '~' */
21006 {
21009 {
21013 }
21014 }
21015 }
21017 }
21018 }
21023 /* ":h" - head, remove "/file_name", can be repeated */
21024 /* Don't remove the first "/" or "c:\" */
21026 {
21033 #ifdef VMS
21036 #endif
21039 }
21041 /* ":8" - shortname */
21043 {
21045 #ifdef WIN3264
21047 #endif
21048 }
21050 #ifdef WIN3264
21051 /* Check shortname after we have done 'heads' and before we do 'tails'
21052 */
21054 {
21056 /* Copy the string if it is shortened by :h */
21058 {
21064 }
21066 /* Split into two implementations - makes it easier. First is where
21067 * there isn't a full name already, second is where there is.
21068 */
21070 {
21073 }
21074 else
21075 {
21078 /* Simple case, already have the full-name
21079 * Nearly always shorter, so try first time. */
21085 {
21086 /* Couldn't find the filename.. search the paths.
21087 */
21091 }
21093 }
21094 }
21097 /* ":t" - tail, just the basename */
21099 {
21103 }
21105 /* ":e" - extension, can be repeated */
21106 /* ":r" - root, without extension, can be repeated */
21109 {
21110 /* find a '.' in the tail:
21111 * - for second :e: before the current fname
21112 * - otherwise: The last '.'
21113 */
21116 else
21122 {
21124 {
21127 #ifdef VMS
21128 /* cut version from the extension */
21135 #endif
21136 }
21139 }
21141 {
21144 }
21146 }
21148 /* ":s?pat?foo?" - substitute */
21149 /* ":gs?pat?foo?" - global substitute */
21153 {
21164 {
21167 }
21171 {
21172 /* find end of pattern */
21175 {
21178 {
21180 /* find end of substitution */
21183 {
21187 {
21191 {
21197 }
21198 }
21201 }
21203 }
21204 }
21205 /* after using ":s", repeat all the modifiers */
21208 }
21209 }
21212 }
21214 /*
21215 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21216 * "flags" can be "g" to do a global substitute.
21217 * Returns an allocated string, NULL for error.
21218 */
21219 char_u *
21225 {
21227 regmatch_T regmatch;
21231 garray_T ga;
21235 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21246 {
21249 {
21250 /*
21251 * Get some space for a temporary buffer to do the substitution
21252 * into. It will contain:
21253 * - The text up to where the match is.
21254 * - The substituted text.
21255 * - The text after the match.
21256 */
21260 {
21263 }
21265 /* copy the text up to where the match is */
21268 /* add the substituted text */
21272 /* avoid getting stuck on a match with an empty string */
21274 {
21279 }
21280 else
21281 {
21285 }
21288 }
21294 }
21301 }