| blob | bcf9b79d9ca0dedc1e309788e8088069c4dbf8f8 |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(MSWIN)
15 #endif
19 #ifdef AMIGA
21 #endif
23 #ifdef MACOS
25 #endif
27 #ifdef HAVE_FCNTL_H
28 # include <fcntl.h>
29 #endif
31 #if defined(FEAT_EVAL) || defined(PROTO)
35 /*
36 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
37 * This avoids adding a pointer to the hashtab item.
38 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
39 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
40 * HI2DI() converts a hashitem pointer to a dictitem pointer.
41 */
43 #define DI2HIKEY(di) ((di)->di_key)
44 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
45 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
47 /*
48 * Structure returned by get_lval() and used by set_var_lval().
49 * For a plain name:
50 * "name" points to the variable name.
51 * "exp_name" is NULL.
52 * "tv" is NULL
53 * For a magic braces name:
54 * "name" points to the expanded variable name.
55 * "exp_name" is non-NULL, to be freed later.
56 * "tv" is NULL
57 * For an index in a list:
58 * "name" points to the (expanded) variable name.
59 * "exp_name" NULL or non-NULL, to be freed later.
60 * "tv" points to the (first) list item value
61 * "li" points to the (first) list item
62 * "range", "n1", "n2" and "empty2" indicate what items are used.
63 * For an existing Dict item:
64 * "name" points to the (expanded) variable name.
65 * "exp_name" NULL or non-NULL, to be freed later.
66 * "tv" points to the dict item value
67 * "newkey" is NULL
68 * For a non-existing Dict item:
69 * "name" points to the (expanded) variable name.
70 * "exp_name" NULL or non-NULL, to be freed later.
71 * "tv" points to the Dictionary typval_T
72 * "newkey" is the key for the new item.
73 */
75 {
79 isn't NULL it's the Dict to which to add
80 the item. */
111 /*
112 * All user-defined global variables are stored in dictionary "globvardict".
113 * "globvars_var" is the variable that is used for "g:".
114 */
117 #define globvarht globvardict.dv_hashtab
119 /*
120 * Old Vim variables such as "v:version" are also available without the "v:".
121 * Also in functions. We need a special hashtable for them.
122 */
125 /*
126 * When recursively copying lists and dicts we need to remember which ones we
127 * have done to avoid endless recursiveness. This unique ID is used for that.
128 */
131 /*
132 * Array to hold the hashtab with variables local to each sourced script.
133 * Each item holds a variable (nameless) that points to the dict_T.
134 */
136 {
137 dictitem_T sv_var;
138 dict_T sv_dict;
142 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
143 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
147 /* Values for trans_function_name() argument: */
151 /*
152 * Structure to hold info for a user function.
153 */
156 struct ufunc
157 {
163 #ifdef FEAT_PROFILE
165 /* profiling the function as a whole */
170 /* profiling the function per line */
179 #endif
181 used for s: variables */
184 start with <SNR>123_ (<SNR> is K_SPECIAL
185 KS_EXTRA KE_SNR) */
186 };
188 /* function flags */
193 /*
194 * All user-defined functions are found in this hashtable.
195 */
198 /* The names of packages that once were loaded are remembered. */
201 /* list heads for garbage collection */
205 /* From user function to hashitem and back. */
207 #define UF2HIKEY(fp) ((fp)->uf_name)
208 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
209 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
211 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
212 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
218 /* structure to hold info for a function that is currently being executed. */
221 struct funccall_S
222 {
227 {
241 #ifdef FEAT_PROFILE
243 #endif
245 };
247 /*
248 * Info used by a ":for" loop.
249 */
251 {
258 /*
259 * Struct used by trans_function_name()
260 */
262 {
269 /*
270 * Array to hold the value of v: variables.
271 * The value is in a dictitem, so that it can also be used in the v: scope.
272 * The reason to use this table anyway is for very quick access to the
273 * variables with the VV_ defines.
274 */
277 /* values for vv_flags: */
282 #define VV_NAME(s, t) s, {{t}}, {0}
284 static struct vimvar
285 {
291 {
292 /*
293 * The order here must match the VV_ defines in vim.h!
294 * Initializing a union does not work, leave tv.vval empty to get zero's.
295 */
349 };
351 /* shorthand */
352 #define vv_type vv_di.di_tv.v_type
353 #define vv_nr vv_di.di_tv.vval.v_number
354 #define vv_str vv_di.di_tv.vval.v_string
355 #define vv_tv vv_di.di_tv
357 /*
358 * The v: variables are stored in dictionary "vimvardict".
359 * "vimvars_var" is the variable that is used for the "l:" scope.
360 */
363 #define vimvarht vimvardict.dv_hashtab
367 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
368 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
369 #endif
370 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
377 #ifdef FEAT_WINDOWS
379 #endif
384 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
386 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
388 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
456 static int get_func_tv __ARGS((char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
457 static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
481 #if defined(FEAT_INS_EXPAND)
485 #endif
592 #ifdef vim_mkdir
594 #endif
641 #ifdef HAVE_STRFTIME
643 #endif
687 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
690 valid character */
691 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
711 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
726 #ifdef FEAT_PROFILE
728 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
729 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
730 static int
731 # ifdef __BORLANDC__
732 _RTLENTRYF
733 # endif
735 static int
736 # ifdef __BORLANDC__
737 _RTLENTRYF
738 # endif
740 #endif
747 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));
755 /* Character used as separated in autoload function/variable names. */
758 /*
759 * Initialize the global and v: variables.
760 */
761 void
763 {
773 {
780 else
783 /* add to v: scope dict, unless the value is not always available */
787 /* add to compat scope dict */
789 }
790 }
792 #if defined(EXITFREE) || defined(PROTO)
793 void
795 {
800 {
803 {
806 }
807 }
811 /* script-local variables */
817 /* global variables */
820 /* functions */
824 /* autoloaded script names */
827 /* unreferenced lists and dicts */
829 }
830 #endif
832 /*
833 * Return the name of the executed function.
834 */
835 char_u *
838 {
840 }
842 /*
843 * Return the address holding the next breakpoint line for a funccall cookie.
844 */
845 linenr_T *
848 {
850 }
852 /*
853 * Return the address holding the debug tick for a funccall cookie.
854 */
858 {
860 }
862 /*
863 * Return the nesting level for a funccall cookie.
864 */
865 int
868 {
870 }
872 /* pointer to funccal for currently active function */
875 /*
876 * Return TRUE when a function was ended by a ":return" command.
877 */
878 int
880 {
882 }
885 /*
886 * Set an internal variable to a string value. Creates the variable if it does
887 * not already exist.
888 */
889 void
893 {
899 {
902 {
905 }
906 }
907 }
914 /*
915 * Start recording command output to a variable
916 * Returns OK if successfully completed the setup. FAIL otherwise.
917 */
918 int
922 {
925 typval_T tv;
927 /* Make sure a valid variable name is specified */
929 {
932 }
940 {
943 }
945 /* The output is stored in growarray "redir_ga" until redirection ends. */
948 /* Parse the variable name (can be a dict or list entry). */
950 FNE_CHECK_START);
952 {
954 /* Trailing characters are present after the variable name */
956 else
960 }
962 /* check if we can write to the variable: set it to or append an empty
963 * string */
970 else
975 {
978 }
980 {
981 /* Dictionary item was created, don't do it again. */
984 }
987 }
989 /*
990 * Append "value[value_len]" to the variable set by var_redir_start().
991 * The actual appending is postponed until redirection ends, because the value
992 * appended may in fact be the string we write to, changing it may cause freed
993 * memory to be used:
994 * :redir => foo
995 * :let foo
996 * :redir END
997 */
998 void
1002 {
1010 else
1014 {
1017 }
1018 else
1020 }
1022 /*
1023 * Stop redirecting command output to a variable.
1024 */
1025 void
1027 {
1028 typval_T tv;
1031 {
1032 /* Append the trailing NUL. */
1035 /* Assign the text to the variable. */
1044 }
1047 }
1049 # if defined(FEAT_MBYTE) || defined(PROTO)
1050 int
1056 {
1073 }
1074 # endif
1076 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1077 int
1081 {
1092 {
1095 }
1097 }
1098 # endif
1100 # if defined(FEAT_DIFF) || defined(PROTO)
1101 void
1106 {
1116 }
1118 void
1123 {
1133 }
1134 # endif
1136 /*
1137 * Top level evaluation function, returning a boolean.
1138 * Sets "error" to TRUE if there was an error.
1139 * Return TRUE or FALSE.
1140 */
1141 int
1147 {
1148 typval_T tv;
1155 else
1156 {
1159 {
1162 }
1163 }
1168 }
1170 /*
1171 * Top level evaluation function, returning a string. If "skip" is TRUE,
1172 * only parsing to "nextcmd" is done, without reporting errors. Return
1173 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1174 */
1175 char_u *
1180 {
1181 typval_T tv;
1188 else
1189 {
1192 }
1197 }
1199 /*
1200 * Skip over an expression at "*pp".
1201 * Return FAIL for an error, OK otherwise.
1202 */
1203 int
1206 {
1207 typval_T rettv;
1211 }
1213 /*
1214 * Top level evaluation function, returning a string.
1215 * Return pointer to allocated memory, or NULL for failure.
1216 */
1217 char_u *
1222 {
1223 typval_T tv;
1225 garray_T ga;
1229 else
1230 {
1232 {
1237 }
1238 else
1241 }
1244 }
1246 /*
1247 * Call eval_to_string() without using current local variables and using
1248 * textlock. When "use_sandbox" is TRUE use the sandbox.
1249 */
1250 char_u *
1255 {
1269 }
1271 /*
1272 * Top level evaluation function, returning a number.
1273 * Evaluates "expr" silently.
1274 * Returns -1 for an error.
1275 */
1276 int
1279 {
1280 typval_T rettv;
1288 else
1289 {
1292 }
1296 }
1298 /*
1299 * Prepare v: variable "idx" to be used.
1300 * Save the current typeval in "save_tv".
1301 * When not used yet add the variable to the v: hashtable.
1302 */
1303 static void
1307 {
1311 }
1313 /*
1314 * Restore v: variable "idx" to typeval "save_tv".
1315 * When no longer defined, remove the variable from the v: hashtable.
1316 */
1317 static void
1321 {
1326 {
1330 else
1332 }
1333 }
1335 #if defined(FEAT_SPELL) || defined(PROTO)
1336 /*
1337 * Evaluate an expression to a list with suggestions.
1338 * For the "expr:" part of 'spellsuggest'.
1339 */
1340 list_T *
1344 {
1345 typval_T save_val;
1346 typval_T rettv;
1350 /* Set "v:val" to the bad word. */
1358 {
1361 else
1363 }
1370 }
1372 /*
1373 * "list" is supposed to contain two items: a word and a number. Return the
1374 * word in "pp" and the number as the return value.
1375 * Return -1 if anything isn't right.
1376 * Used to get the good word and score from the eval_spell_expr() result.
1377 */
1378 int
1382 {
1394 }
1395 #endif
1397 /*
1398 * Top level evaluation function.
1399 * Returns an allocated typval_T with the result.
1400 * Returns NULL when there is an error.
1401 */
1402 typval_T *
1406 {
1411 {
1414 }
1417 }
1420 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1421 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1422 /*
1423 * Call some vimL function and return the result in "*rettv".
1424 * Uses argv[argc] for the function arguments.
1425 * Returns OK or FAIL.
1426 */
1427 static int
1434 {
1448 {
1449 /* Pass a NULL or empty argument as an empty string */
1451 {
1455 }
1457 /* Recognize a number argument, the others must be strings. */
1460 {
1463 }
1464 else
1465 {
1468 }
1469 }
1472 {
1475 }
1482 {
1485 }
1492 }
1494 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1495 /*
1496 * Call vimL function "func" and return the result as a string.
1497 * Returns NULL when calling the function fails.
1498 * Uses argv[argc] for the function arguments.
1499 */
1506 {
1507 typval_T rettv;
1516 }
1517 # endif
1519 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1520 /*
1521 * Call vimL function "func" and return the result as a number.
1522 * Returns -1 when calling the function fails.
1523 * Uses argv[argc] for the function arguments.
1524 */
1525 long
1531 {
1532 typval_T rettv;
1541 }
1542 # endif
1544 /*
1545 * Call vimL function "func" and return the result as a list
1546 * Uses argv[argc] for the function arguments.
1547 */
1554 {
1555 typval_T rettv;
1561 {
1564 }
1567 }
1568 #endif
1571 /*
1572 * Save the current function call pointer, and set it to NULL.
1573 * Used when executing autocommands and for ":source".
1574 */
1577 {
1582 }
1584 void
1587 {
1591 }
1593 #if defined(FEAT_PROFILE) || defined(PROTO)
1594 /*
1595 * Prepare profiling for entering a child or something else that is not
1596 * counted for the script/function itself.
1597 * Should always be called in pair with prof_child_exit().
1598 */
1599 void
1602 {
1608 }
1610 /*
1611 * Take care of time spent in a child.
1612 * Should always be called after prof_child_enter().
1613 */
1614 void
1617 {
1621 {
1626 }
1628 }
1629 #endif
1632 #ifdef FEAT_FOLDING
1633 /*
1634 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1635 * it in "*cp". Doesn't give error messages.
1636 */
1637 int
1641 {
1642 typval_T tv;
1646 OPT_LOCAL);
1655 else
1656 {
1657 /* If the result is a number, just return the number. */
1662 else
1663 {
1664 /* If the result is a string, check if there is a non-digit before
1665 * the number. */
1670 }
1672 }
1679 }
1680 #endif
1682 /*
1683 * ":let" list all variable values
1684 * ":let var1 var2" list variable values
1685 * ":let var = expr" assignment command.
1686 * ":let var += expr" assignment command.
1687 * ":let var -= expr" assignment command.
1688 * ":let var .= expr" assignment command.
1689 * ":let [var1, var2] = expr" unpack list.
1690 */
1691 void
1694 {
1697 typval_T rettv;
1712 {
1713 /*
1714 * ":let" without "=": list variables
1715 */
1719 /* ":let var1 var2" */
1722 {
1723 /* ":let" */
1727 #ifdef FEAT_WINDOWS
1729 #endif
1733 }
1735 }
1736 else
1737 {
1741 {
1744 }
1751 {
1755 }
1757 {
1759 op);
1761 }
1762 }
1763 }
1765 /*
1766 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1767 * Handles both "var" with any type and "[var, var; var]" with a list type.
1768 * When "nextchars" is not NULL it points to a string with characters that
1769 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1770 * or concatenate.
1771 * Returns OK or FAIL;
1772 */
1773 static int
1781 {
1786 typval_T ltv;
1789 {
1790 /*
1791 * ":let var = expr" or ":for var in list"
1792 */
1796 }
1798 /*
1799 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1800 */
1802 {
1805 }
1809 {
1812 }
1814 {
1817 }
1821 {
1830 {
1831 /* Put the rest of the list (may be empty) in the var after ';'.
1832 * Create a new list for this. */
1837 {
1840 }
1853 }
1855 {
1858 }
1859 }
1862 }
1864 /*
1865 * Skip over assignable variable "var" or list of variables "[var, var]".
1866 * Used for ":let varvar = expr" and ":for varvar in expr".
1867 * For "[var, var]" increment "*var_count" for each variable.
1868 * for "[var, var; var]" set "semicolon".
1869 * Return NULL for an error.
1870 */
1876 {
1880 {
1881 /* "[var, var]": find the matching ']'. */
1884 {
1888 {
1891 }
1898 {
1900 {
1903 }
1905 }
1907 {
1910 }
1911 }
1913 }
1914 else
1916 }
1918 /*
1919 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1920 * l[idx].
1921 */
1925 {
1930 }
1932 /*
1933 * List variables for hashtab "ht" with prefix "prefix".
1934 * If "empty" is TRUE also list NULL strings as empty strings.
1935 */
1936 static void
1942 {
1949 {
1951 {
1957 }
1958 }
1959 }
1961 /*
1962 * List global variables.
1963 */
1964 static void
1967 {
1969 }
1971 /*
1972 * List buffer variables.
1973 */
1974 static void
1977 {
1986 }
1988 /*
1989 * List window variables.
1990 */
1991 static void
1994 {
1997 }
1999 #ifdef FEAT_WINDOWS
2000 /*
2001 * List tab page variables.
2002 */
2003 static void
2006 {
2009 }
2010 #endif
2012 /*
2013 * List Vim variables.
2014 */
2015 static void
2018 {
2020 }
2022 /*
2023 * List script-local variables, if there is a script.
2024 */
2025 static void
2028 {
2032 }
2034 /*
2035 * List function variables, if there is a function.
2036 */
2037 static void
2040 {
2044 }
2046 /*
2047 * List variables in "arg".
2048 */
2054 {
2061 typval_T tv;
2064 {
2066 {
2069 {
2073 }
2074 }
2075 else
2076 {
2077 /* get_name_len() takes care of expanding curly braces */
2081 {
2082 /* This is mainly to keep test 49 working: when expanding
2083 * curly braces fails overrule the exception error message. */
2085 {
2089 }
2091 }
2092 else
2093 {
2098 else
2099 {
2100 /* handle d.key, l[idx], f(expr) */
2104 else
2105 {
2107 {
2109 {
2113 #ifdef FEAT_WINDOWS
2115 #endif
2121 }
2122 }
2123 else
2124 {
2137 first);
2140 }
2142 }
2143 }
2144 }
2147 }
2150 }
2153 }
2155 /*
2156 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2157 * Returns a pointer to the char just after the var name.
2158 * Returns NULL if there is an error.
2159 */
2167 {
2176 /*
2177 * ":let $VAR = expr": Set environment variable.
2178 */
2180 {
2181 /* Find the end of the name. */
2187 else
2188 {
2194 else
2195 {
2200 {
2205 {
2209 }
2210 }
2212 {
2222 }
2225 }
2226 }
2227 }
2229 /*
2230 * ":let &option = expr": Set option value.
2231 * ":let &l:option = expr": Set local option value.
2232 * ":let &g:option = expr": Set global option value.
2233 */
2235 {
2236 /* Find the end of the name. */
2241 else
2242 {
2255 {
2261 else
2262 {
2264 {
2267 else
2269 }
2271 {
2275 }
2276 }
2277 }
2279 {
2282 }
2285 }
2286 }
2288 /*
2289 * ":let @r = expr": Set register contents.
2290 */
2292 {
2299 else
2300 {
2306 {
2309 {
2312 }
2313 }
2315 {
2318 }
2320 }
2321 }
2323 /*
2324 * ":let var = expr": Set internal variable.
2325 * ":let {expr} = expr": Idem, name made with curly braces
2326 */
2328 {
2329 lval_T lv;
2333 {
2336 else
2337 {
2340 }
2341 }
2343 }
2345 else
2349 }
2351 /*
2352 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2353 */
2354 static int
2357 {
2359 {
2362 }
2364 }
2366 /*
2367 * Get an lval: variable, Dict item or List item that can be assigned a value
2368 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2369 * "name.key", "name.key[expr]" etc.
2370 * Indexing only works if "name" is an existing List or Dictionary.
2371 * "name" points to the start of the name.
2372 * If "rettv" is not NULL it points to the value to be assigned.
2373 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2374 * wrong; must end in space or cmd separator.
2375 *
2376 * Returns a pointer to just after the name, including indexes.
2377 * When an evaluation error occurs "lp->ll_name" is NULL;
2378 * Returns NULL for a parsing error. Still need to free items in "lp"!
2379 */
2389 {
2394 typval_T var1;
2395 typval_T var2;
2402 /* Clear everything in "lp". */
2406 {
2407 /* When skipping just find the end of the name. */
2410 }
2412 /* Find the end of the name. */
2415 {
2416 /* Don't expand the name when we already know there is an error. */
2419 {
2422 }
2426 {
2427 /* Report an invalid expression in braces, unless the
2428 * expression evaluation has been cancelled due to an
2429 * aborting error, an interrupt, or an exception. */
2431 {
2435 }
2436 }
2438 }
2439 else
2442 /* Without [idx] or .key we are done. */
2455 /*
2456 * Loop until no more [idx] or .key is following.
2457 */
2460 {
2464 {
2468 }
2470 {
2474 }
2478 {
2481 ;
2483 {
2487 }
2489 }
2490 else
2491 {
2492 /* Get the index [expr] or the first index [expr: ]. */
2496 else
2497 {
2502 {
2503 /* not a number or string */
2506 }
2507 }
2509 /* Optionally get the second index [ :expr]. */
2511 {
2513 {
2519 }
2522 {
2528 }
2532 else
2533 {
2536 {
2540 }
2542 {
2543 /* not a number or string */
2548 }
2549 }
2551 }
2552 else
2556 {
2564 }
2566 /* Skip to past ']'. */
2568 }
2571 {
2573 {
2574 /* "[key]": get key from "var1" */
2577 {
2582 }
2583 }
2588 {
2589 /* Key does not exist in dict: may need to add it. */
2591 {
2597 }
2600 else
2607 }
2611 }
2612 else
2613 {
2614 /*
2615 * Get the number and item for the only or first index of the List.
2616 */
2619 else
2620 {
2623 }
2628 {
2630 {
2633 }
2634 }
2636 {
2640 }
2642 /*
2643 * May need to find the item or absolute index for the second
2644 * index of a range.
2645 * When no index given: "lp->ll_empty2" is TRUE.
2646 * Otherwise "lp->ll_n2" is set to the second index.
2647 */
2649 {
2653 {
2658 }
2660 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2665 }
2668 }
2669 }
2672 }
2674 /*
2675 * Clear lval "lp" that was filled by get_lval().
2676 */
2677 static void
2680 {
2683 }
2685 /*
2686 * Set a variable that was parsed by get_lval() to "rettv".
2687 * "endp" points to just after the parsed name.
2688 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2689 */
2690 static void
2697 {
2703 {
2705 {
2709 {
2710 typval_T tv;
2712 /* handle +=, -= and .= */
2715 {
2719 }
2720 }
2721 else
2724 }
2725 }
2729 ;
2731 {
2732 /*
2733 * Assign the List values to the list items.
2734 */
2736 {
2739 else
2740 {
2743 }
2748 {
2749 /* Need to add an empty item. */
2751 {
2754 }
2755 }
2758 }
2765 }
2766 else
2767 {
2768 /*
2769 * Assign to a List or Dictionary item.
2770 */
2772 {
2774 {
2777 }
2779 /* Need to add an item to the Dictionary. */
2784 {
2787 }
2789 }
2791 {
2794 }
2795 else
2798 /*
2799 * Assign the value to the variable or list item.
2800 */
2803 else
2804 {
2808 }
2809 }
2810 }
2812 /*
2813 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2814 * Returns OK or FAIL.
2815 */
2816 static int
2821 {
2826 /* Can't do anything with a Funcref or a Dict on the right. */
2828 {
2830 {
2838 /* List += List */
2848 {
2849 /* nr += nr or nr -= nr*/
2853 else
2858 }
2859 else
2860 {
2861 /* str .= str */
2867 }
2869 }
2870 }
2874 }
2876 /*
2877 * Add a watcher to a list.
2878 */
2879 static void
2883 {
2886 }
2888 /*
2889 * Remove a watcher from a list.
2890 * No warning when it isn't found...
2891 */
2892 static void
2896 {
2901 {
2903 {
2906 }
2908 }
2909 }
2911 /*
2912 * Just before removing an item from a list: advance watchers to the next
2913 * item.
2914 */
2915 static void
2919 {
2925 }
2927 /*
2928 * Evaluate the expression used in a ":for var in expr" command.
2929 * "arg" points to "var".
2930 * Set "*errp" to TRUE for an error, FALSE otherwise;
2931 * Return a pointer that holds the info. Null when there is an error.
2932 */
2939 {
2942 typval_T tv;
2957 {
2960 }
2965 {
2968 {
2971 {
2974 }
2975 else
2976 {
2977 /* No need to increment the refcount, it's already set for the
2978 * list being used in "tv". */
2982 }
2983 }
2984 }
2989 }
2991 /*
2992 * Use the first item in a ":for" list. Advance to the next.
2993 * Assign the values to the variable (list). "arg" points to the first one.
2994 * Return TRUE when a valid item was found, FALSE when at end of list or
2995 * something wrong.
2996 */
2997 int
3001 {
3009 else
3010 {
3014 }
3016 }
3018 /*
3019 * Free the structure used to store info used by ":for".
3020 */
3021 void
3024 {
3028 {
3031 }
3033 }
3035 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3037 void
3041 cmdidx_T cmdidx;
3042 {
3048 {
3051 {
3052 /* ":let var1 var2 ...": find last space. */
3054 {
3059 }
3061 }
3062 }
3063 else
3068 {
3071 {
3074 {
3078 }
3080 {
3085 }
3086 }
3088 {
3089 /* environment variable */
3091 }
3093 {
3096 }
3100 {
3101 /* Function name can start with "<SNR>" */
3103 }
3105 {
3107 {
3112 }
3114 {
3115 /* Trick: '' is like stopping and starting a literal string. */
3119 }
3121 {
3123 {
3126 }
3127 else
3129 }
3130 else
3132 }
3133 else
3134 /* Doesn't look like something valid, expand as an expression
3135 * anyway. */
3141 }
3143 }
3147 /*
3148 * ":1,25call func(arg1, arg2)" function call.
3149 */
3150 void
3153 {
3159 typval_T rettv;
3160 linenr_T lnum;
3163 funcdict_T fudi;
3167 {
3168 /* Still need to give an error message for missing key. */
3171 }
3175 /* Increase refcount on dictionary, it could get deleted when evaluating
3176 * the arguments. */
3180 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3184 /* Skip white space to allow ":call func ()". Not good, but required for
3185 * backward compatibility. */
3190 {
3193 }
3195 /*
3196 * When skipping, evaluate the function once, to find the end of the
3197 * arguments.
3198 * When the function takes a range, this is discovered after the first
3199 * call, and the loop is broken.
3200 */
3202 {
3205 }
3206 else
3209 {
3211 {
3214 }
3219 {
3222 }
3224 /* Handle a function returning a Funcref, Dictionary or List. */
3226 {
3229 }
3235 /* Stop when immediately aborting on error, or when an interrupt
3236 * occurred or an exception was thrown but not caught.
3237 * get_func_tv() returned OK, so that the check for trailing
3238 * characters below is executed. */
3241 }
3246 {
3247 /* Check for trailing illegal characters and a following command. */
3249 {
3252 }
3253 else
3255 }
3257 end:
3260 }
3262 /*
3263 * ":unlet[!] var1 ... " command.
3264 */
3265 void
3268 {
3270 }
3272 /*
3273 * ":lockvar" and ":unlockvar" commands
3274 */
3275 void
3278 {
3285 {
3288 }
3291 }
3293 /*
3294 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3295 */
3296 static void
3301 {
3305 lval_T lv;
3307 do
3308 {
3309 /* Parse the name and find the end. */
3311 FNE_CHECK_START);
3316 {
3318 {
3321 }
3325 }
3328 {
3330 {
3333 }
3334 else
3335 {
3339 }
3340 }
3349 }
3351 static int
3356 {
3361 {
3365 /* Normal name or expanded name. */
3371 }
3375 {
3378 /* Delete a range of List items. */
3380 {
3385 }
3386 }
3387 else
3388 {
3390 /* unlet a List item. */
3392 else
3393 /* unlet a Dictionary item. */
3395 }
3398 }
3400 /*
3401 * "unlet" a variable. Return OK if it existed, FAIL if not.
3402 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3403 */
3404 int
3408 {
3416 {
3419 {
3426 }
3427 }
3432 }
3434 /*
3435 * Lock or unlock variable indicated by "lp".
3436 * "deep" is the levels to go (-1 for unlimited);
3437 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3438 */
3439 static int
3445 {
3454 {
3458 /* Normal name or expanded name. */
3461 else
3462 {
3466 else
3467 {
3470 else
3473 }
3474 }
3476 }
3478 {
3481 /* (un)lock a range of List items. */
3483 {
3487 }
3488 }
3490 /* (un)lock a List item. */
3492 else
3493 /* un(lock) a Dictionary item. */
3497 }
3499 /*
3500 * Lock or unlock an item. "deep" is nr of levels to go.
3501 */
3502 static void
3507 {
3516 {
3519 }
3524 /* lock/unlock the item itself */
3527 else
3531 {
3534 {
3537 else
3540 /* recursive: lock/unlock the items the List contains */
3543 }
3547 {
3550 else
3553 {
3554 /* recursive: lock/unlock the items the List contains */
3557 {
3559 {
3562 }
3563 }
3564 }
3565 }
3566 }
3568 }
3570 /*
3571 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3572 * it refers to a List or Dictionary that is locked.
3573 */
3574 static int
3577 {
3585 }
3587 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3588 /*
3589 * Delete all "menutrans_" variables.
3590 */
3591 void
3593 {
3600 {
3602 {
3606 }
3607 }
3609 }
3610 #endif
3612 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3614 /*
3615 * Local string buffer for the next two functions to store a variable name
3616 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3617 * get_user_var_name().
3618 */
3625 /*
3626 * Function to concatenate a prefix and a variable name.
3627 */
3632 {
3637 {
3642 {
3645 }
3647 }
3652 }
3654 /*
3655 * Function given to ExpandGeneric() to obtain the list of user defined
3656 * (global/buffer/window/built-in) variable names.
3657 */
3658 /*ARGSUSED*/
3659 char_u *
3663 {
3667 #ifdef FEAT_WINDOWS
3669 #endif
3675 {
3677 #ifdef FEAT_WINDOWS
3679 #endif
3680 }
3682 /* Global variables */
3684 {
3687 else
3694 }
3696 /* b: variables */
3699 {
3702 else
3707 }
3709 {
3712 }
3714 /* w: variables */
3717 {
3720 else
3725 }
3727 #ifdef FEAT_WINDOWS
3728 /* t: variables */
3731 {
3734 else
3739 }
3740 #endif
3742 /* v: variables */
3750 }
3754 /*
3755 * types for expressions.
3756 */
3758 {
3770 /*
3771 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3772 * executed. The function may return OK, but the rettv will be of type
3773 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3774 */
3776 /*
3777 * Handle zero level expression.
3778 * This calls eval1() and handles error message and nextcmd.
3779 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3780 * Note: "rettv.v_lock" is not set.
3781 * Return OK or FAIL.
3782 */
3783 static int
3789 {
3796 {
3799 /*
3800 * Report the invalid expression unless the expression evaluation has
3801 * been cancelled due to an aborting error, an interrupt, or an
3802 * exception.
3803 */
3807 }
3812 }
3814 /*
3815 * Handle top level expression:
3816 * expr1 ? expr0 : expr0
3817 *
3818 * "arg" must point to the first non-white of the expression.
3819 * "arg" is advanced to the next non-white after the recognized expression.
3820 *
3821 * Note: "rettv.v_lock" is not set.
3822 *
3823 * Return OK or FAIL.
3824 */
3825 static int
3830 {
3832 typval_T var2;
3834 /*
3835 * Get the first variable.
3836 */
3841 {
3844 {
3852 }
3854 /*
3855 * Get the second variable.
3856 */
3861 /*
3862 * Check for the ":".
3863 */
3865 {
3870 }
3872 /*
3873 * Get the third variable.
3874 */
3877 {
3881 }
3884 }
3887 }
3889 /*
3890 * Handle first level expression:
3891 * expr2 || expr2 || expr2 logical OR
3892 *
3893 * "arg" must point to the first non-white of the expression.
3894 * "arg" is advanced to the next non-white after the recognized expression.
3895 *
3896 * Return OK or FAIL.
3897 */
3898 static int
3903 {
3904 typval_T var2;
3909 /*
3910 * Get the first variable.
3911 */
3915 /*
3916 * Repeat until there is no following "||".
3917 */
3921 {
3923 {
3930 }
3932 /*
3933 * Get the second variable.
3934 */
3939 /*
3940 * Compute the result.
3941 */
3943 {
3949 }
3951 {
3954 }
3955 }
3958 }
3960 /*
3961 * Handle second level expression:
3962 * expr3 && expr3 && expr3 logical AND
3963 *
3964 * "arg" must point to the first non-white of the expression.
3965 * "arg" is advanced to the next non-white after the recognized expression.
3966 *
3967 * Return OK or FAIL.
3968 */
3969 static int
3974 {
3975 typval_T var2;
3980 /*
3981 * Get the first variable.
3982 */
3986 /*
3987 * Repeat until there is no following "&&".
3988 */
3992 {
3994 {
4001 }
4003 /*
4004 * Get the second variable.
4005 */
4010 /*
4011 * Compute the result.
4012 */
4014 {
4020 }
4022 {
4025 }
4026 }
4029 }
4031 /*
4032 * Handle third level expression:
4033 * var1 == var2
4034 * var1 =~ var2
4035 * var1 != var2
4036 * var1 !~ var2
4037 * var1 > var2
4038 * var1 >= var2
4039 * var1 < var2
4040 * var1 <= var2
4041 * var1 is var2
4042 * var1 isnot var2
4043 *
4044 * "arg" must point to the first non-white of the expression.
4045 * "arg" is advanced to the next non-white after the recognized expression.
4046 *
4047 * Return OK or FAIL.
4048 */
4049 static int
4054 {
4055 typval_T var2;
4064 regmatch_T regmatch;
4068 /*
4069 * Get the first variable.
4070 */
4076 {
4088 {
4091 }
4092 else
4096 {
4099 }
4100 else
4104 {
4108 {
4111 }
4112 }
4114 }
4116 /*
4117 * If there is a comparitive operator, use it.
4118 */
4120 {
4121 /* extra question mark appended: ignore case */
4123 {
4126 }
4127 /* extra '#' appended: match case */
4129 {
4132 }
4133 /* nothing appened: use 'ignorecase' */
4134 else
4137 /*
4138 * Get the second variable.
4139 */
4142 {
4145 }
4148 {
4150 {
4151 /* For "is" a different type always means FALSE, for "notis"
4152 * it means TRUE. */
4154 }
4156 {
4158 {
4163 }
4166 {
4169 else
4174 }
4175 else
4176 {
4177 /* Compare two Lists for being equal or unequal. */
4181 }
4182 }
4185 {
4187 {
4192 }
4195 {
4198 else
4203 }
4204 else
4205 {
4206 /* Compare two Dictionaries for being equal or unequal. */
4210 }
4211 }
4214 {
4217 {
4220 else
4225 }
4226 else
4227 {
4228 /* Compare two Funcrefs for being equal or unequal. */
4232 else
4237 }
4238 }
4240 /*
4241 * If one of the two variables is a number, compare as a number.
4242 * When using "=~" or "!~", always compare as string.
4243 */
4246 {
4250 {
4260 }
4261 }
4262 else
4263 {
4268 else
4272 {
4282 /* avoid 'l' flag in 'cpoptions' */
4289 {
4294 }
4299 }
4300 }
4305 }
4306 }
4309 }
4311 /*
4312 * Handle fourth level expression:
4313 * + number addition
4314 * - number subtraction
4315 * . string concatenation
4316 *
4317 * "arg" must point to the first non-white of the expression.
4318 * "arg" is advanced to the next non-white after the recognized expression.
4319 *
4320 * Return OK or FAIL.
4321 */
4322 static int
4327 {
4328 typval_T var2;
4329 typval_T var3;
4336 /*
4337 * Get the first variable.
4338 */
4342 /*
4343 * Repeat computing, until no '+', '-' or '.' is following.
4344 */
4346 {
4352 {
4353 /* For "list + ...", an illegal use of the first operand as
4354 * a number cannot be determined before evaluating the 2nd
4355 * operand: if this is also a list, all is ok.
4356 * For "something . ...", "something - ..." or "non-list + ...",
4357 * we know that the first operand needs to be a string or number
4358 * without evaluating the 2nd operand. So check before to avoid
4359 * side effects after an error. */
4361 {
4364 }
4365 }
4367 /*
4368 * Get the second variable.
4369 */
4372 {
4375 }
4378 {
4379 /*
4380 * Compute the result.
4381 */
4383 {
4387 {
4391 }
4396 }
4399 {
4400 /* concatenate Lists */
4403 {
4407 }
4410 }
4411 else
4412 {
4417 {
4418 /* This can only happen for "list + non-list".
4419 * For "non-list + ..." or "something - ...", we returned
4420 * before evaluating the 2nd operand. */
4423 }
4426 {
4430 }
4434 else
4438 }
4440 }
4441 }
4443 }
4445 /*
4446 * Handle fifth level expression:
4447 * * number multiplication
4448 * / number division
4449 * % number modulo
4450 *
4451 * "arg" must point to the first non-white of the expression.
4452 * "arg" is advanced to the next non-white after the recognized expression.
4453 *
4454 * Return OK or FAIL.
4455 */
4456 static int
4461 {
4462 typval_T var2;
4467 /*
4468 * Get the first variable.
4469 */
4473 /*
4474 * Repeat computing, until no '*', '/' or '%' is following.
4475 */
4477 {
4483 {
4488 }
4489 else
4492 /*
4493 * Get the second variable.
4494 */
4500 {
4506 /*
4507 * Compute the result.
4508 */
4512 {
4515 else
4517 }
4518 else
4519 {
4522 else
4524 }
4527 }
4528 }
4531 }
4533 /*
4534 * Handle sixth level expression:
4535 * number number constant
4536 * "string" string constant
4537 * 'string' literal string constant
4538 * &option-name option value
4539 * @r register contents
4540 * identifier variable value
4541 * function() function call
4542 * $VAR environment variable
4543 * (expression) nested expression
4544 * [expr, expr] List
4545 * {key: val, key: val} Dictionary
4546 *
4547 * Also handle:
4548 * ! in front logical NOT
4549 * - in front unary minus
4550 * + in front unary plus (ignored)
4551 * trailing [] subscript in String or List
4552 * trailing .name entry in Dictionary
4553 *
4554 * "arg" must point to the first non-white of the expression.
4555 * "arg" is advanced to the next non-white after the recognized expression.
4556 *
4557 * Return OK or FAIL.
4558 */
4559 static int
4564 {
4573 /*
4574 * Initialise variable so that clear_tv() can't mistake this for a
4575 * string and free a string that isn't there.
4576 */
4579 /*
4580 * Skip '!' and '-' characters. They are handled later.
4581 */
4588 {
4589 /*
4590 * Number constant.
4591 */
4605 {
4608 }
4611 /*
4612 * String constant: "string".
4613 */
4617 /*
4618 * Literal string constant: 'str''ing'.
4619 */
4623 /*
4624 * List: [expr, expr]
4625 */
4629 /*
4630 * Dictionary: {key: val, key: val}
4631 */
4635 /*
4636 * Option value: &name
4637 */
4641 /*
4642 * Environment variable: $VAR.
4643 */
4647 /*
4648 * Register contents: @r.
4649 */
4652 {
4655 }
4660 /*
4661 * nested expression: (expression).
4662 */
4668 {
4672 }
4677 }
4680 {
4681 /*
4682 * Must be a variable or function name.
4683 * Can also be a curly-braces kind of name: {expr}.
4684 */
4692 else
4693 {
4695 {
4696 /* If "s" is the name of a variable of type VAR_FUNC
4697 * use its contents. */
4700 /* Invoke the function. */
4704 /* Stop the expression evaluation when immediately
4705 * aborting on error, or when an interrupt occurred or
4706 * an exception was thrown but not caught. */
4708 {
4712 }
4713 }
4716 else
4718 }
4722 }
4726 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
4727 * expr(expr). */
4731 /*
4732 * Apply logical NOT and unary '-', from right to left, ignore '+'.
4733 */
4735 {
4740 {
4743 }
4744 else
4745 {
4747 {
4753 }
4757 }
4758 }
4761 }
4763 /*
4764 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
4765 * "*arg" points to the '[' or '.'.
4766 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
4767 */
4768 static int
4774 {
4784 {
4788 }
4791 {
4792 /*
4793 * dict.name
4794 */
4797 ;
4801 }
4802 else
4803 {
4804 /*
4805 * something[idx]
4806 *
4807 * Get the (first) variable from inside the [].
4808 */
4815 {
4816 /* not a number or string */
4819 }
4821 /*
4822 * Get the second variable from inside the [:].
4823 */
4825 {
4831 {
4835 }
4837 {
4838 /* not a number or string */
4843 }
4844 }
4846 /* Check for the ']'. */
4848 {
4855 }
4857 }
4860 {
4863 {
4866 }
4868 {
4871 else
4872 {
4875 }
4876 }
4879 {
4885 {
4886 /* The resulting variable is a substring. If the indexes
4887 * are out of range the result is empty. */
4889 {
4893 }
4900 else
4902 }
4903 else
4904 {
4905 /* The resulting variable is a string of a single
4906 * character. If the index is too big or negative the
4907 * result is empty. */
4910 else
4912 }
4923 {
4924 /* For a range we allow invalid values and return an empty
4925 * list. A list index out of range is an error. */
4927 {
4931 }
4933 }
4935 {
4950 {
4952 {
4955 }
4957 }
4962 }
4963 else
4964 {
4968 }
4973 {
4979 }
4980 {
4984 {
4987 {
4992 }
4993 }
5007 }
5009 }
5010 }
5013 }
5015 /*
5016 * Get an option value.
5017 * "arg" points to the '&' or '+' before the option name.
5018 * "arg" is advanced to character after the option name.
5019 * Return OK or FAIL.
5020 */
5021 static int
5026 {
5036 /*
5037 * Isolate the option name and find its value.
5038 */
5041 {
5045 }
5048 {
5051 }
5059 {
5063 }
5065 {
5067 {
5070 }
5072 {
5075 }
5077 {
5080 }
5082 {
5085 }
5086 }
5094 }
5096 /*
5097 * Allocate a variable for a string constant.
5098 * Return OK or FAIL.
5099 */
5100 static int
5105 {
5110 /*
5111 * Find the end of the string, skipping backslashed characters.
5112 */
5114 {
5116 {
5118 /* A "\<x>" form occupies at least 4 characters, and produces up
5119 * to 6 characters: reserve space for 2 extra */
5122 }
5123 }
5126 {
5129 }
5131 /* If only parsing, set *arg and return here */
5133 {
5136 }
5138 /*
5139 * Copy the string into allocated memory, handling backslashed
5140 * characters.
5141 */
5149 {
5151 {
5153 {
5166 {
5172 else
5176 {
5179 }
5181 #ifdef FEAT_MBYTE
5182 /* For "\u" store the number according to
5183 * 'encoding'. */
5186 else
5187 #endif
5189 }
5192 /* octal: "\1", "\12", "\123" */
5202 {
5206 }
5210 /* Special key, e.g.: "\<C-W>" */
5213 {
5216 }
5217 /* FALLTHROUGH */
5221 }
5222 }
5223 else
5226 }
5231 }
5233 /*
5234 * Allocate a variable for a 'str''ing' constant.
5235 * Return OK or FAIL.
5236 */
5237 static int
5242 {
5247 /*
5248 * Find the end of the string, skipping ''.
5249 */
5251 {
5253 {
5258 }
5259 }
5262 {
5265 }
5267 /* If only parsing return after setting "*arg" */
5269 {
5272 }
5274 /*
5275 * Copy the string into allocated memory, handling '' to ' reduction.
5276 */
5284 {
5286 {
5290 }
5292 }
5297 }
5299 /*
5300 * Allocate a variable for a List and fill it from "*arg".
5301 * Return OK or FAIL.
5302 */
5303 static int
5308 {
5310 typval_T tv;
5314 {
5318 }
5322 {
5326 {
5329 {
5333 }
5334 else
5336 }
5341 {
5344 }
5346 }
5349 {
5351 failret:
5355 }
5359 {
5363 }
5366 }
5368 /*
5369 * Allocate an empty header for a list.
5370 * Caller should take care of the reference count.
5371 */
5372 list_T *
5374 {
5379 {
5380 /* Prepend the list to the list of lists for garbage collection. */
5386 }
5388 }
5390 /*
5391 * Allocate an empty list for a return value.
5392 * Returns OK or FAIL.
5393 */
5394 static int
5397 {
5407 }
5409 /*
5410 * Unreference a list: decrement the reference count and free it when it
5411 * becomes zero.
5412 */
5413 void
5416 {
5419 }
5421 /*
5422 * Free a list, including all items it points to.
5423 * Ignores the reference count.
5424 */
5425 void
5429 {
5432 /* Remove the list from the list of lists for garbage collection. */
5435 else
5441 {
5442 /* Remove the item before deleting it. */
5448 }
5450 }
5452 /*
5453 * Allocate a list item.
5454 */
5457 {
5459 }
5461 /*
5462 * Free a list item. Also clears the value. Does not notify watchers.
5463 */
5464 static void
5467 {
5470 }
5472 /*
5473 * Remove a list item from a List and free it. Also clears the value.
5474 */
5475 static void
5479 {
5482 }
5484 /*
5485 * Get the number of items in a list.
5486 */
5487 static long
5490 {
5494 }
5496 /*
5497 * Return TRUE when two lists have exactly the same values.
5498 */
5499 static int
5504 {
5518 }
5520 #if defined(FEAT_PYTHON) || defined(PROTO)
5521 /*
5522 * Return the dictitem that an entry in a hashtable points to.
5523 */
5524 dictitem_T *
5527 {
5529 }
5530 #endif
5532 /*
5533 * Return TRUE when two dictionaries have exactly the same key/values.
5534 */
5535 static int
5540 {
5552 {
5554 {
5561 }
5562 }
5564 }
5566 /*
5567 * Return TRUE if "tv1" and "tv2" have the same value.
5568 * Compares the items just like "==" would compare them, but strings and
5569 * numbers are different.
5570 */
5571 static int
5576 {
5584 /* Catch lists and dicts that have an endless loop by limiting
5585 * recursiveness to 1000. We guess they are equal then. */
5590 {
5615 }
5619 }
5621 /*
5622 * Locate item with index "n" in list "l" and return it.
5623 * A negative index is counted from the end; -1 is the last item.
5624 * Returns NULL when "n" is out of range.
5625 */
5630 {
5637 /* Negative index is relative to the end. */
5641 /* Check for index out of range. */
5645 /* When there is a cached index may start search from there. */
5647 {
5649 {
5650 /* closest to the start of the list */
5653 }
5655 {
5656 /* closest to the end of the list */
5659 }
5660 else
5661 {
5662 /* closest to the cached index */
5665 }
5666 }
5667 else
5668 {
5670 {
5671 /* closest to the start of the list */
5674 }
5675 else
5676 {
5677 /* closest to the end of the list */
5680 }
5681 }
5684 {
5685 /* search forward */
5688 }
5690 {
5691 /* search backward */
5694 }
5696 /* cache the used index */
5701 }
5703 /*
5704 * Get list item "l[idx]" as a number.
5705 */
5706 static long
5711 {
5716 {
5720 }
5722 }
5724 /*
5725 * Locate "item" list "l" and return its index.
5726 * Returns -1 when "item" is not in the list.
5727 */
5728 static long
5732 {
5744 }
5746 /*
5747 * Append item "item" to the end of list "l".
5748 */
5749 static void
5753 {
5755 {
5756 /* empty list */
5760 }
5761 else
5762 {
5766 }
5769 }
5771 /*
5772 * Append typval_T "tv" to the end of list "l".
5773 * Return FAIL when out of memory.
5774 */
5775 static int
5779 {
5787 }
5789 /*
5790 * Add a dictionary to a list. Used by getqflist().
5791 * Return FAIL when out of memory.
5792 */
5793 int
5797 {
5808 }
5810 /*
5811 * Make a copy of "str" and append it as an item to list "l".
5812 * When "len" >= 0 use "str[len]".
5813 * Returns FAIL when out of memory.
5814 */
5815 static int
5820 {
5834 }
5836 /*
5837 * Append "n" to list "l".
5838 * Returns FAIL when out of memory.
5839 */
5840 static int
5843 varnumber_T n;
5844 {
5855 }
5857 /*
5858 * Insert typval_T "tv" in list "l" before "item".
5859 * If "item" is NULL append at the end.
5860 * Return FAIL when out of memory.
5861 */
5862 static int
5867 {
5874 /* Append new item at end of list. */
5876 else
5877 {
5878 /* Insert new item before existing item. */
5882 {
5885 }
5886 else
5887 {
5890 }
5893 }
5895 }
5897 /*
5898 * Extend "l1" with "l2".
5899 * If "bef" is NULL append at the end, otherwise insert before this item.
5900 * Returns FAIL when out of memory.
5901 */
5902 static int
5907 {
5914 }
5916 /*
5917 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
5918 * Return FAIL when out of memory.
5919 */
5920 static int
5925 {
5928 /* make a copy of the first list. */
5935 /* append all items from the second list */
5937 }
5939 /*
5940 * Make a copy of list "orig". Shallow if "deep" is FALSE.
5941 * The refcount of the new list is set to 1.
5942 * See item_copy() for "copyID".
5943 * Returns NULL when out of memory.
5944 */
5950 {
5960 {
5962 {
5963 /* Do this before adding the items, because one of the items may
5964 * refer back to this list. */
5967 }
5970 {
5975 {
5977 {
5980 }
5981 }
5982 else
5985 }
5988 {
5991 }
5992 }
5995 }
5997 /*
5998 * Remove items "item" to "item2" from list "l".
5999 * Does not free the listitem or the value!
6000 */
6001 static void
6006 {
6009 /* notify watchers */
6011 {
6016 }
6020 else
6024 else
6027 }
6029 /*
6030 * Return an allocated string with the string representation of a list.
6031 * May return NULL.
6032 */
6037 {
6038 garray_T ga;
6045 {
6048 }
6052 }
6054 /*
6055 * Join list "l" into a string in "*gap", using separator "sep".
6056 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6057 * Return FAIL or OK.
6058 */
6059 static int
6066 {
6074 {
6077 else
6082 else
6089 }
6091 }
6093 /*
6094 * Garbage collection for lists and dictionaries.
6095 *
6096 * We use reference counts to be able to free most items right away when they
6097 * are no longer used. But for composite items it's possible that it becomes
6098 * unused while the reference count is > 0: When there is a recursive
6099 * reference. Example:
6100 * :let l = [1, 2, 3]
6101 * :let d = {9: l}
6102 * :let l[1] = d
6103 *
6104 * Since this is quite unusual we handle this with garbage collection: every
6105 * once in a while find out which lists and dicts are not referenced from any
6106 * variable.
6107 *
6108 * Here is a good reference text about garbage collection (refers to Python
6109 * but it applies to all reference-counting mechanisms):
6110 * http://python.ca/nas/python/gc/
6111 */
6113 /*
6114 * Do garbage collection for lists and dicts.
6115 * Return TRUE if some memory was freed.
6116 */
6117 int
6119 {
6128 #ifdef FEAT_WINDOWS
6130 #endif
6132 /* Only do this once. */
6137 /*
6138 * 1. Go through all accessible variables and mark all lists and dicts
6139 * with copyID.
6140 */
6141 /* script-local variables */
6145 /* buffer-local variables */
6149 /* window-local variables */
6153 #ifdef FEAT_WINDOWS
6154 /* tabpage-local variables */
6157 #endif
6159 /* global variables */
6162 /* function-local variables */
6164 {
6167 }
6169 /*
6170 * 2. Go through the list of dicts and free items without the copyID.
6171 */
6174 {
6175 /* Free the Dictionary and ordinary items it contains, but don't
6176 * recurse into Lists and Dictionaries, they will be in the list
6177 * of dicts or list of lists. */
6181 /* restart, next dict may also have been freed */
6183 }
6184 else
6187 /*
6188 * 3. Go through the list of lists and free items without the copyID.
6189 * But don't free a list that has a watcher (used in a for loop), these
6190 * are not referenced anywhere.
6191 */
6194 {
6195 /* Free the List and ordinary items it contains, but don't recurse
6196 * into Lists and Dictionaries, they will be in the list of dicts
6197 * or list of lists. */
6201 /* restart, next list may also have been freed */
6203 }
6204 else
6208 }
6210 /*
6211 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6212 */
6213 static void
6217 {
6224 {
6227 }
6228 }
6230 /*
6231 * Mark all lists and dicts referenced through list "l" with "copyID".
6232 */
6233 static void
6237 {
6242 }
6244 /*
6245 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6246 */
6247 static void
6251 {
6256 {
6260 {
6261 /* Didn't see this dict yet. */
6264 }
6270 {
6271 /* Didn't see this list yet. */
6274 }
6276 }
6278 }
6280 /*
6281 * Allocate an empty header for a dictionary.
6282 */
6283 dict_T *
6285 {
6290 {
6291 /* Add the list to the list of dicts for garbage collection. */
6302 }
6304 }
6306 /*
6307 * Unreference a Dictionary: decrement the reference count and free it when it
6308 * becomes zero.
6309 */
6310 static void
6313 {
6316 }
6318 /*
6319 * Free a Dictionary, including all items it contains.
6320 * Ignores the reference count.
6321 */
6322 static void
6326 {
6331 /* Remove the dict from the list of dicts for garbage collection. */
6334 else
6339 /* Lock the hashtab, we don't want it to resize while freeing items. */
6343 {
6345 {
6346 /* Remove the item before deleting it, just in case there is
6347 * something recursive causing trouble. */
6355 }
6356 }
6359 }
6361 /*
6362 * Allocate a Dictionary item.
6363 * The "key" is copied to the new item.
6364 * Note that the value of the item "di_tv" still needs to be initialized!
6365 * Returns NULL when out of memory.
6366 */
6370 {
6375 {
6378 }
6380 }
6382 /*
6383 * Make a copy of a Dictionary item.
6384 */
6388 {
6394 {
6398 }
6400 }
6402 /*
6403 * Remove item "item" from Dictionary "dict" and free it.
6404 */
6405 static void
6409 {
6415 else
6418 }
6420 /*
6421 * Free a dict item. Also clears the value.
6422 */
6423 static void
6426 {
6429 }
6431 /*
6432 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6433 * The refcount of the new dict is set to 1.
6434 * See item_copy() for "copyID".
6435 * Returns NULL when out of memory.
6436 */
6442 {
6453 {
6455 {
6458 }
6461 {
6463 {
6470 {
6473 {
6476 }
6477 }
6478 else
6481 {
6484 }
6485 }
6486 }
6490 {
6493 }
6494 }
6497 }
6499 /*
6500 * Add item "item" to Dictionary "d".
6501 * Returns FAIL when out of memory and when key already existed.
6502 */
6503 static int
6507 {
6509 }
6511 /*
6512 * Add a number or string entry to dictionary "d".
6513 * When "str" is NULL use number "nr", otherwise use "str".
6514 * Returns FAIL when out of memory and when key already exists.
6515 */
6516 int
6522 {
6530 {
6533 }
6534 else
6535 {
6538 }
6540 {
6543 }
6545 }
6547 /*
6548 * Get the number of items in a Dictionary.
6549 */
6550 static long
6553 {
6557 }
6559 /*
6560 * Find item "key[len]" in Dictionary "d".
6561 * If "len" is negative use strlen(key).
6562 * Returns NULL when not found.
6563 */
6569 {
6570 #define AKEYLEN 200
6579 {
6583 }
6584 else
6585 {
6586 /* Avoid a malloc/free by using buf[]. */
6589 }
6596 }
6598 /*
6599 * Get a string item from a dictionary.
6600 * When "save" is TRUE allocate memory for it.
6601 * Returns NULL if the entry doesn't exist or out of memory.
6602 */
6603 char_u *
6608 {
6619 }
6621 /*
6622 * Get a number item from a dictionary.
6623 * Returns 0 if the entry doesn't exist or out of memory.
6624 */
6625 long
6629 {
6636 }
6638 /*
6639 * Return an allocated string with the string representation of a Dictionary.
6640 * May return NULL.
6641 */
6646 {
6647 garray_T ga;
6663 {
6665 {
6670 else
6675 {
6678 }
6686 }
6687 }
6689 {
6692 }
6697 }
6699 /*
6700 * Allocate a variable for a Dictionary and fill it from "*arg".
6701 * Return OK or FAIL. Returns NOTDONE for {expr}.
6702 */
6703 static int
6708 {
6710 typval_T tvkey;
6711 typval_T tv;
6717 /*
6718 * First check if it's not a curly-braces thing: {expr}.
6719 * Must do this without evaluating, otherwise a function may be called
6720 * twice. Unfortunately this means we need to call eval1() twice for the
6721 * first item.
6722 * But {} is an empty Dictionary.
6723 */
6725 {
6730 }
6733 {
6737 }
6743 {
6747 {
6751 }
6753 {
6756 {
6757 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
6762 }
6763 }
6767 {
6771 }
6773 {
6776 {
6781 }
6785 {
6790 }
6791 }
6796 {
6799 }
6801 }
6804 {
6806 failret:
6810 }
6814 {
6818 }
6821 }
6823 /*
6824 * Return a string with the string representation of a variable.
6825 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6826 * "numbuf" is used for a number.
6827 * Does not put quotes around strings, as ":echo" displays values.
6828 * When "copyID" is not NULL replace recursive lists and dicts with "...".
6829 * May return NULL.
6830 */
6837 {
6842 {
6846 }
6850 {
6858 {
6861 }
6863 {
6866 }
6867 else
6868 {
6872 }
6877 {
6880 }
6882 {
6885 }
6886 else
6887 {
6891 }
6903 }
6907 }
6909 /*
6910 * Return a string with the string representation of a variable.
6911 * If the memory is allocated "tofree" is set to it, otherwise NULL.
6912 * "numbuf" is used for a number.
6913 * Puts quotes around strings, so that they can be parsed back by eval().
6914 * May return NULL.
6915 */
6922 {
6924 {
6937 }
6939 }
6941 /*
6942 * Return string "str" in ' quotes, doubling ' characters.
6943 * If "str" is NULL an empty string is assumed.
6944 * If "function" is TRUE make it function('string').
6945 */
6950 {
6956 {
6961 }
6964 {
6966 {
6969 }
6970 else
6974 {
6978 }
6983 }
6985 }
6987 /*
6988 * Get the value of an environment variable.
6989 * "arg" is pointing to the '$'. It is advanced to after the name.
6990 * If the environment variable was not set, silently assume it is empty.
6991 * Always return OK.
6992 */
6993 static int
6998 {
7009 {
7011 {
7014 /* first try vim_getenv(), fast for normal environment vars */
7017 {
7020 }
7021 else
7022 {
7026 /* next try expanding things like $VIM and ${HOME} */
7029 {
7032 }
7033 }
7035 }
7038 }
7041 }
7043 /*
7044 * Array with names and number of arguments of all internal functions
7045 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7046 */
7047 static struct fst
7048 {
7053 /* implementation of function */
7055 {
7080 #if defined(FEAT_INS_EXPAND)
7084 #endif
7195 #ifdef vim_mkdir
7197 #endif
7244 #ifdef HAVE_STRFTIME
7246 #endif
7284 };
7286 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7288 /*
7289 * Function given to ExpandGeneric() to obtain the list of internal
7290 * or user defined function names.
7291 */
7292 char_u *
7296 {
7303 {
7307 }
7309 {
7315 }
7318 }
7320 /*
7321 * Function given to ExpandGeneric() to obtain the list of internal or
7322 * user defined variable or function names.
7323 */
7324 /*ARGSUSED*/
7325 char_u *
7329 {
7336 {
7340 }
7342 }
7346 /*
7347 * Find internal function in table above.
7348 * Return index, or -1 if not found
7349 */
7350 static int
7353 {
7359 /*
7360 * Find the function name in the table. Binary search.
7361 */
7363 {
7370 else
7372 }
7374 }
7376 /*
7377 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7378 * name it contains, otherwise return "name".
7379 */
7384 {
7393 {
7395 {
7398 }
7401 }
7404 }
7406 /*
7407 * Allocate a variable for the result of a function.
7408 * Return OK or FAIL.
7409 */
7410 static int
7422 {
7428 /*
7429 * Get the arguments.
7430 */
7433 {
7438 {
7441 }
7445 }
7448 else
7455 {
7458 else
7460 }
7467 }
7470 /*
7471 * Call a function with its resolved parameters
7472 * Return OK when the function can't be called, FAIL otherwise.
7473 * Also returns OK when an error was encountered while executing the function.
7474 */
7475 static int
7483 PLUS ONE elements! */
7489 {
7491 #define ERROR_UNKNOWN 0
7492 #define ERROR_TOOMANY 1
7493 #define ERROR_TOOFEW 2
7494 #define ERROR_SCRIPT 3
7495 #define ERROR_DICT 4
7496 #define ERROR_NONE 5
7497 #define ERROR_OTHER 6
7503 #define FLEN_FIXED 40
7507 /*
7508 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7509 * Change <SNR>123_name() to K_SNR 123_name().
7510 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7511 */
7516 {
7522 {
7525 else
7526 {
7529 }
7530 }
7532 {
7535 }
7536 else
7537 {
7541 else
7542 {
7545 }
7546 }
7547 }
7548 else
7554 /* execute the function if no errors detected and executing */
7556 {
7561 {
7562 /*
7563 * User defined function.
7564 */
7567 #ifdef FEAT_AUTOCMD
7568 /* Trigger FuncUndefined event, may load the function. */
7573 {
7574 /* executed an autocommand, search for the function again */
7576 }
7577 #endif
7578 /* Try loading a package. */
7580 {
7581 /* loaded a package, search for the function again */
7583 }
7586 {
7595 else
7596 {
7597 /*
7598 * Call the user function.
7599 * Save and restore search patterns, script variables and
7600 * redo buffer.
7601 */
7610 /* Function was unreferenced while being used, free it
7611 * now. */
7616 }
7617 }
7618 }
7619 else
7620 {
7621 /*
7622 * Find the function name in the table, call its implementation.
7623 */
7626 {
7631 else
7632 {
7636 }
7637 }
7638 }
7639 /*
7640 * The function call (or "FuncUndefined" autocommand sequence) might
7641 * have been aborted by an error, an interrupt, or an explicitly thrown
7642 * exception that has not been caught so far. This situation can be
7643 * tested for by calling aborting(). For an error in an internal
7644 * function or for the "E132" error in call_user_func(), however, the
7645 * throw point at which the "force_abort" flag (temporarily reset by
7646 * emsg()) is normally updated has not been reached yet. We need to
7647 * update that flag first to make aborting() reliable.
7648 */
7650 }
7654 /*
7655 * Report an error unless the argument evaluation or function call has been
7656 * cancelled due to an aborting error, an interrupt, or an exception.
7657 */
7659 {
7661 {
7670 name);
7674 name);
7678 name);
7680 }
7681 }
7688 }
7690 /*
7691 * Give an error message with a function name. Handle <SNR> things.
7692 */
7693 static void
7697 {
7702 else
7707 }
7709 /*********************************************
7710 * Implementation of the built-in functions
7711 */
7713 /*
7714 * "add(list, item)" function
7715 */
7716 static void
7720 {
7725 {
7730 }
7731 else
7733 }
7735 /*
7736 * "append(lnum, string/list)" function
7737 */
7738 static void
7742 {
7754 {
7756 {
7761 }
7764 {
7769 else
7773 {
7776 }
7782 }
7787 }
7788 else
7790 }
7792 /*
7793 * "argc()" function
7794 */
7795 /* ARGSUSED */
7796 static void
7800 {
7802 }
7804 /*
7805 * "argidx()" function
7806 */
7807 /* ARGSUSED */
7808 static void
7812 {
7814 }
7816 /*
7817 * "argv(nr)" function
7818 */
7819 static void
7823 {
7827 {
7831 else
7834 }
7839 }
7841 /*
7842 * "browse(save, title, initdir, default)" function
7843 */
7844 /* ARGSUSED */
7845 static void
7849 {
7850 #ifdef FEAT_BROWSE
7866 else
7870 #else
7872 #endif
7874 }
7876 /*
7877 * "browsedir(title, initdir)" function
7878 */
7879 /* ARGSUSED */
7880 static void
7884 {
7885 #ifdef FEAT_BROWSE
7895 else
7898 #else
7900 #endif
7902 }
7906 /*
7907 * Find a buffer by number or exact name.
7908 */
7912 {
7918 {
7921 {
7922 /* No full path name match, try a match with a URL or a "nofile"
7923 * buffer, these don't use the full path. */
7927 #ifdef FEAT_QUICKFIX
7929 #endif
7930 )
7933 }
7934 }
7936 }
7938 /*
7939 * "bufexists(expr)" function
7940 */
7941 static void
7945 {
7947 }
7949 /*
7950 * "buflisted(expr)" function
7951 */
7952 static void
7956 {
7961 }
7963 /*
7964 * "bufloaded(expr)" function
7965 */
7966 static void
7970 {
7975 }
7979 /*
7980 * Get buffer by number or pattern.
7981 */
7985 {
8000 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8012 /* If not found, try expanding the name, like done for bufexists(). */
8017 }
8019 /*
8020 * "bufname(expr)" function
8021 */
8022 static void
8026 {
8035 else
8038 }
8040 /*
8041 * "bufnr(expr)" function
8042 */
8043 static void
8047 {
8057 /* If the buffer isn't found and the second argument is not zero create a
8058 * new buffer. */
8062 && !error
8069 else
8071 }
8073 /*
8074 * "bufwinnr(nr)" function
8075 */
8076 static void
8080 {
8081 #ifdef FEAT_WINDOWS
8084 #endif
8090 #ifdef FEAT_WINDOWS
8092 {
8096 }
8098 #else
8100 #endif
8102 }
8104 /*
8105 * "byte2line(byte)" function
8106 */
8107 /*ARGSUSED*/
8108 static void
8112 {
8113 #ifndef FEAT_BYTEOFF
8115 #else
8121 else
8124 #endif
8125 }
8127 /*
8128 * "byteidx()" function
8129 */
8130 /*ARGSUSED*/
8131 static void
8135 {
8136 #ifdef FEAT_MBYTE
8138 #endif
8148 #ifdef FEAT_MBYTE
8151 {
8155 }
8157 #else
8160 #endif
8161 }
8163 /*
8164 * "call(func, arglist)" function
8165 */
8166 static void
8170 {
8180 {
8183 }
8189 else
8195 {
8197 {
8200 }
8202 }
8206 {
8208 {
8211 }
8212 /* Make a copy of each argument. This is needed to be able to set
8213 * v_lock to VAR_FIXED in the copy without changing the original list.
8214 */
8216 }
8223 /* Free the arguments. */
8226 }
8228 /*
8229 * "changenr()" function
8230 */
8231 /*ARGSUSED*/
8232 static void
8236 {
8238 }
8240 /*
8241 * "char2nr(string)" function
8242 */
8243 static void
8247 {
8248 #ifdef FEAT_MBYTE
8251 else
8252 #endif
8254 }
8256 /*
8257 * "cindent(lnum)" function
8258 */
8259 static void
8263 {
8264 #ifdef FEAT_CINDENT
8265 pos_T pos;
8266 linenr_T lnum;
8271 {
8275 }
8276 else
8277 #endif
8279 }
8281 /*
8282 * "clearmatches()" function
8283 */
8284 /*ARGSUSED*/
8285 static void
8289 {
8290 #ifdef FEAT_SEARCH_EXTRA
8292 #endif
8293 }
8295 /*
8296 * "col(string)" function
8297 */
8298 static void
8302 {
8309 {
8311 {
8312 /* '> can be MAXCOL, get the length of the line then */
8315 else
8317 }
8318 else
8319 {
8321 #ifdef FEAT_VIRTUALEDIT
8322 /* col(".") when the cursor is on the NUL at the end of the line
8323 * because of "coladd" can be seen as an extra column. */
8325 {
8330 {
8331 # ifdef FEAT_MBYTE
8336 # else
8339 # endif
8340 }
8341 }
8342 #endif
8343 }
8344 }
8346 }
8348 #if defined(FEAT_INS_EXPAND)
8349 /*
8350 * "complete()" function
8351 */
8352 /*ARGSUSED*/
8353 static void
8357 {
8361 {
8364 }
8366 /* Check for undo allowed here, because if something was already inserted
8367 * the line was already saved for undo and this check isn't done. */
8372 {
8375 }
8382 }
8384 /*
8385 * "complete_add()" function
8386 */
8387 /*ARGSUSED*/
8388 static void
8392 {
8394 }
8396 /*
8397 * "complete_check()" function
8398 */
8399 /*ARGSUSED*/
8400 static void
8404 {
8411 }
8412 #endif
8414 /*
8415 * "confirm(message, buttons[, default [, type]])" function
8416 */
8417 /*ARGSUSED*/
8418 static void
8422 {
8423 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8437 {
8442 {
8445 {
8449 else
8450 {
8452 {
8458 }
8459 }
8460 }
8461 }
8462 }
8469 else
8472 #else
8474 #endif
8475 }
8477 /*
8478 * "copy()" function
8479 */
8480 static void
8484 {
8486 }
8488 /*
8489 * "count()" function
8490 */
8491 static void
8495 {
8500 {
8506 {
8509 {
8514 {
8517 {
8521 }
8522 }
8525 }
8530 }
8531 }
8533 {
8539 {
8543 {
8547 }
8551 {
8553 {
8557 }
8558 }
8559 }
8560 }
8561 else
8564 }
8566 /*
8567 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
8568 *
8569 * Checks the existence of a cscope connection.
8570 */
8571 /*ARGSUSED*/
8572 static void
8576 {
8577 #ifdef FEAT_CSCOPE
8585 {
8590 }
8593 #else
8595 #endif
8596 }
8598 /*
8599 * "cursor(lnum, col)" function
8600 *
8601 * Moves the cursor to the specified line and column
8602 */
8603 /*ARGSUSED*/
8604 static void
8608 {
8610 #ifdef FEAT_VIRTUALEDIT
8612 #endif
8615 {
8616 pos_T pos;
8622 #ifdef FEAT_VIRTUALEDIT
8624 #endif
8625 }
8626 else
8627 {
8630 #ifdef FEAT_VIRTUALEDIT
8633 #endif
8634 }
8636 #ifdef FEAT_VIRTUALEDIT
8638 #endif
8639 )
8645 #ifdef FEAT_VIRTUALEDIT
8647 #endif
8649 /* Make sure the cursor is in a valid position. */
8651 #ifdef FEAT_MBYTE
8652 /* Correct cursor for multi-byte character. */
8655 #endif
8658 }
8660 /*
8661 * "deepcopy()" function
8662 */
8663 static void
8667 {
8674 else
8676 }
8678 /*
8679 * "delete()" function
8680 */
8681 static void
8685 {
8688 else
8690 }
8692 /*
8693 * "did_filetype()" function
8694 */
8695 /*ARGSUSED*/
8696 static void
8700 {
8701 #ifdef FEAT_AUTOCMD
8703 #else
8705 #endif
8706 }
8708 /*
8709 * "diff_filler()" function
8710 */
8711 /*ARGSUSED*/
8712 static void
8716 {
8717 #ifdef FEAT_DIFF
8719 #endif
8720 }
8722 /*
8723 * "diff_hlID()" function
8724 */
8725 /*ARGSUSED*/
8726 static void
8730 {
8731 #ifdef FEAT_DIFF
8747 {
8748 /* New line, buffer, change: need to get the values. */
8751 {
8753 {
8758 else
8760 }
8761 else
8763 }
8764 else
8769 }
8772 {
8776 else
8778 }
8780 #endif
8781 }
8783 /*
8784 * "empty({expr})" function
8785 */
8786 static void
8790 {
8794 {
8814 }
8817 }
8819 /*
8820 * "escape({string}, {chars})" function
8821 */
8822 static void
8826 {
8832 }
8834 /*
8835 * "eval()" function
8836 */
8837 /*ARGSUSED*/
8838 static void
8842 {
8850 {
8853 }
8856 }
8858 /*
8859 * "eventhandler()" function
8860 */
8861 /*ARGSUSED*/
8862 static void
8866 {
8868 }
8870 /*
8871 * "executable()" function
8872 */
8873 static void
8877 {
8879 }
8881 /*
8882 * "exists()" function
8883 */
8884 static void
8888 {
8896 {
8897 /* first try "normal" environment variables (fast) */
8900 else
8901 {
8902 /* try expanding things like $VIM and ${HOME} */
8907 }
8908 }
8910 {
8914 }
8916 {
8918 }
8920 {
8922 }
8924 {
8925 #ifdef FEAT_AUTOCMD
8928 else
8930 #endif
8931 }
8933 {
8935 typval_T tv;
8937 /* get_name_len() takes care of expanding curly braces */
8941 {
8946 {
8947 /* handle d.key, l[idx], f(expr) */
8951 }
8952 }
8957 }
8960 }
8962 /*
8963 * "expand()" function
8964 */
8965 static void
8969 {
8974 expand_T xpc;
8980 {
8984 }
8985 else
8986 {
8987 /* When the optional second argument is non-zero, don't remove matches
8988 * for 'suffixes' and 'wildignore' */
8993 {
8997 }
8998 else
9000 }
9001 }
9003 /*
9004 * "extend(list, list [, idx])" function
9005 * "extend(dict, dict [, action])" function
9006 */
9007 static void
9011 {
9014 {
9024 {
9026 {
9033 else
9034 {
9037 {
9040 }
9041 }
9042 }
9043 else
9048 }
9049 }
9051 {
9063 {
9064 /* Check the third argument. */
9066 {
9076 {
9079 }
9080 }
9081 else
9084 /* Go over all entries in the second dict and add them to the
9085 * first dict. */
9088 {
9090 {
9094 {
9098 }
9100 {
9103 }
9105 {
9108 }
9109 }
9110 }
9113 }
9114 }
9115 else
9117 }
9119 /*
9120 * "feedkeys()" function
9121 */
9122 /*ARGSUSED*/
9123 static void
9127 {
9134 /* This is not allowed in the sandbox. If the commands would still be
9135 * executed in the sandbox it would be OK, but it probably happens later,
9136 * when "sandbox" is no longer set. */
9143 {
9145 {
9148 {
9150 {
9154 }
9155 }
9156 }
9158 /* Need to escape K_SPECIAL and CSI before putting the string in the
9159 * typeahead buffer. */
9162 {
9168 }
9169 }
9170 }
9172 /*
9173 * "filereadable()" function
9174 */
9175 static void
9179 {
9186 {
9189 }
9190 else
9194 }
9196 /*
9197 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9198 * rights to write into.
9199 */
9200 static void
9204 {
9206 }
9210 static void
9215 {
9216 #ifdef FEAT_SEARCHPATH
9225 #endif
9230 #ifdef FEAT_SEARCHPATH
9234 {
9238 else
9239 {
9245 }
9246 }
9252 {
9253 do
9254 {
9260 find_what,
9262 find_what == FINDFILE_DIR
9270 }
9274 #endif
9275 }
9280 /*
9281 * Implementation of map() and filter().
9282 */
9283 static void
9288 {
9297 typval_T save_val;
9298 typval_T save_key;
9306 {
9310 }
9312 {
9316 }
9317 else
9318 {
9321 }
9324 /* On type errors, the preceding call has already displayed an error
9325 * message. Avoid a misleading error message for an empty string that
9326 * was not passed as argument. */
9328 {
9332 /* We reset "did_emsg" to be able to detect whether an error
9333 * occurred during evaluation of the expression. */
9338 {
9346 {
9348 {
9360 }
9361 }
9365 }
9366 else
9367 {
9369 {
9378 }
9379 }
9384 }
9387 }
9389 static int
9395 {
9396 typval_T rettv;
9405 {
9408 }
9410 {
9411 /* map(): replace the list item value */
9415 }
9416 else
9417 {
9420 /* filter(): when expr is zero remove the item */
9423 /* On type error, nothing has been removed; return FAIL to stop the
9424 * loop. The error message was given by get_tv_number_chk(). */
9427 }
9429 theend:
9432 }
9434 /*
9435 * "filter()" function
9436 */
9437 static void
9441 {
9443 }
9445 /*
9446 * "finddir({fname}[, {path}[, {count}]])" function
9447 */
9448 static void
9452 {
9454 }
9456 /*
9457 * "findfile({fname}[, {path}[, {count}]])" function
9458 */
9459 static void
9463 {
9465 }
9467 /*
9468 * "fnamemodify({fname}, {mods})" function
9469 */
9470 static void
9474 {
9486 else
9487 {
9490 }
9495 else
9498 }
9502 /*
9503 * "foldclosed()" function
9504 */
9505 static void
9510 {
9511 #ifdef FEAT_FOLDING
9512 linenr_T lnum;
9517 {
9519 {
9522 else
9525 }
9526 }
9527 #endif
9529 }
9531 /*
9532 * "foldclosed()" function
9533 */
9534 static void
9538 {
9540 }
9542 /*
9543 * "foldclosedend()" function
9544 */
9545 static void
9549 {
9551 }
9553 /*
9554 * "foldlevel()" function
9555 */
9556 static void
9560 {
9561 #ifdef FEAT_FOLDING
9562 linenr_T lnum;
9567 else
9568 #endif
9570 }
9572 /*
9573 * "foldtext()" function
9574 */
9575 /*ARGSUSED*/
9576 static void
9580 {
9581 #ifdef FEAT_FOLDING
9582 linenr_T lnum;
9587 #endif
9591 #ifdef FEAT_FOLDING
9596 {
9597 /* Find first non-empty line in the fold. */
9600 {
9604 }
9606 /* Find interesting text in this line. */
9608 /* skip C comment-start */
9610 {
9614 {
9618 }
9619 }
9626 {
9632 /* remove 'foldmarker' and 'commentstring' */
9635 }
9636 }
9637 #endif
9638 }
9640 /*
9641 * "foldtextresult(lnum)" function
9642 */
9643 /*ARGSUSED*/
9644 static void
9648 {
9649 #ifdef FEAT_FOLDING
9650 linenr_T lnum;
9653 foldinfo_T foldinfo;
9655 #endif
9659 #ifdef FEAT_FOLDING
9661 /* treat illegal types and illegal string values for {lnum} the same */
9666 {
9672 }
9673 #endif
9674 }
9676 /*
9677 * "foreground()" function
9678 */
9679 /*ARGSUSED*/
9680 static void
9684 {
9686 #ifdef FEAT_GUI
9689 #else
9690 # ifdef WIN32
9692 # endif
9693 #endif
9694 }
9696 /*
9697 * "function()" function
9698 */
9699 /*ARGSUSED*/
9700 static void
9704 {
9713 else
9714 {
9717 }
9718 }
9720 /*
9721 * "garbagecollect()" function
9722 */
9723 /*ARGSUSED*/
9724 static void
9728 {
9729 /* This is postponed until we are back at the toplevel, because we may be
9730 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
9735 }
9737 /*
9738 * "get()" function
9739 */
9740 static void
9744 {
9752 {
9754 {
9760 }
9761 }
9763 {
9765 {
9769 }
9770 }
9771 else
9775 {
9778 else
9780 }
9781 else
9783 }
9785 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
9787 /*
9788 * Get line or list of lines from buffer "buf" into "rettv".
9789 * Return a range (from start to end) of lines in rettv from the specified
9790 * buffer.
9791 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
9792 */
9793 static void
9796 linenr_T start;
9797 linenr_T end;
9800 {
9804 {
9807 }
9808 else
9815 {
9818 else
9823 }
9824 else
9825 {
9837 }
9838 }
9840 /*
9841 * "getbufline()" function
9842 */
9843 static void
9847 {
9848 linenr_T lnum;
9849 linenr_T end;
9860 else
9864 }
9866 /*
9867 * "getbufvar()" function
9868 */
9869 static void
9873 {
9888 {
9890 {
9891 /* set curbuf to be our buf, temporarily */
9897 /* restore previous notion of curbuf */
9899 }
9900 else
9901 {
9903 /* let getbufvar({nr}, "") return the "b:" dictionary. The
9904 * scope prefix before the NUL byte is required by
9905 * find_var_in_ht(). */
9907 /* look up the variable */
9911 }
9912 }
9915 }
9917 /*
9918 * "getchar()" function
9919 */
9920 static void
9924 {
9925 varnumber_T n;
9928 /* Position the cursor. Needed after a message that ends in a space. */
9934 {
9936 /* getchar(): blocking wait. */
9939 /* getchar(1): only check if char avail */
9942 /* illegal argument or getchar(0) and no char avail: return zero */
9944 else
9945 /* getchar(0) and char avail: return char */
9950 }
9960 {
9964 /* Turn a special key into three bytes, plus modifier. */
9966 {
9970 }
9972 {
9976 }
9977 #ifdef FEAT_MBYTE
9980 #endif
9981 else
9987 #ifdef FEAT_MOUSE
10007 {
10011 linenr_T lnum;
10012 # ifdef FEAT_WINDOWS
10014 # endif
10018 {
10019 /* Find the window at the mouse coordinates and compute the
10020 * text position. */
10023 # ifdef FEAT_WINDOWS
10026 # endif
10030 }
10031 }
10032 #endif
10033 }
10034 }
10036 /*
10037 * "getcharmod()" function
10038 */
10039 /*ARGSUSED*/
10040 static void
10044 {
10046 }
10048 /*
10049 * "getcmdline()" function
10050 */
10051 /*ARGSUSED*/
10052 static void
10056 {
10059 }
10061 /*
10062 * "getcmdpos()" function
10063 */
10064 /*ARGSUSED*/
10065 static void
10069 {
10071 }
10073 /*
10074 * "getcmdtype()" function
10075 */
10076 /*ARGSUSED*/
10077 static void
10081 {
10085 {
10088 }
10089 }
10091 /*
10092 * "getcwd()" function
10093 */
10094 /*ARGSUSED*/
10095 static void
10099 {
10105 else
10106 {
10108 #ifdef BACKSLASH_IN_FILENAME
10111 #endif
10112 }
10113 }
10115 /*
10116 * "getfontname()" function
10117 */
10118 /*ARGSUSED*/
10119 static void
10123 {
10126 #ifdef FEAT_GUI
10128 {
10129 GuiFont font;
10133 {
10134 /* Get the "Normal" font. Either the name saved by
10135 * hl_set_font_name() or from the font ID. */
10138 }
10139 else
10140 {
10147 }
10151 }
10152 #endif
10153 }
10155 /*
10156 * "getfperm({fname})" function
10157 */
10158 static void
10162 {
10173 {
10176 {
10178 {
10181 }
10182 }
10183 }
10185 }
10187 /*
10188 * "getfsize({fname})" function
10189 */
10190 static void
10194 {
10203 {
10206 else
10207 {
10210 /* non-perfect check for overflow */
10213 }
10214 }
10215 else
10217 }
10219 /*
10220 * "getftime({fname})" function
10221 */
10222 static void
10226 {
10234 else
10236 }
10238 /*
10239 * "getftype({fname})" function
10240 */
10241 static void
10245 {
10255 {
10256 #ifdef S_ISREG
10261 # ifdef S_ISLNK
10264 # endif
10265 # ifdef S_ISBLK
10268 # endif
10269 # ifdef S_ISCHR
10272 # endif
10273 # ifdef S_ISFIFO
10276 # endif
10277 # ifdef S_ISSOCK
10280 # endif
10281 else
10283 #else
10284 # ifdef S_IFMT
10286 {
10289 # ifdef S_IFLNK
10291 # endif
10292 # ifdef S_IFBLK
10294 # endif
10295 # ifdef S_IFCHR
10297 # endif
10298 # ifdef S_IFIFO
10300 # endif
10301 # ifdef S_IFSOCK
10303 # endif
10305 }
10306 # else
10309 else
10311 # endif
10312 #endif
10314 }
10316 }
10318 /*
10319 * "getline(lnum, [end])" function
10320 */
10321 static void
10325 {
10326 linenr_T lnum;
10327 linenr_T end;
10332 {
10335 }
10336 else
10337 {
10340 }
10343 }
10345 /*
10346 * "getmatches()" function
10347 */
10348 /*ARGSUSED*/
10349 static void
10353 {
10354 #ifdef FEAT_SEARCH_EXTRA
10361 {
10363 {
10373 }
10374 }
10375 #endif
10376 }
10378 /*
10379 * "getpid()" function
10380 */
10381 /*ARGSUSED*/
10382 static void
10386 {
10388 }
10390 /*
10391 * "getpos(string)" function
10392 */
10393 static void
10397 {
10403 {
10408 else
10416 #ifdef FEAT_VIRTUALEDIT
10418 #endif
10420 }
10421 else
10423 }
10425 /*
10426 * "getqflist()" and "getloclist()" functions
10427 */
10428 /*ARGSUSED*/
10429 static void
10433 {
10434 #ifdef FEAT_QUICKFIX
10436 #endif
10439 #ifdef FEAT_QUICKFIX
10441 {
10444 {
10448 }
10451 }
10452 #endif
10453 }
10455 /*
10456 * "getreg()" function
10457 */
10458 static void
10462 {
10469 {
10474 }
10475 else
10484 }
10486 /*
10487 * "getregtype()" function
10488 */
10489 static void
10493 {
10500 {
10503 {
10507 }
10508 }
10509 else
10510 /* Default to v:register */
10520 {
10523 #ifdef FEAT_VISUAL
10528 #endif
10529 }
10532 }
10534 /*
10535 * "gettabwinvar()" function
10536 */
10537 static void
10541 {
10543 }
10545 /*
10546 * "getwinposx()" function
10547 */
10548 /*ARGSUSED*/
10549 static void
10553 {
10555 #ifdef FEAT_GUI
10557 {
10562 }
10563 #endif
10564 }
10566 /*
10567 * "getwinposy()" function
10568 */
10569 /*ARGSUSED*/
10570 static void
10574 {
10576 #ifdef FEAT_GUI
10578 {
10583 }
10584 #endif
10585 }
10587 /*
10588 * Find window specifed by "vp" in tabpage "tp".
10589 */
10594 {
10595 #ifdef FEAT_WINDOWS
10597 #endif
10602 #ifdef FEAT_WINDOWS
10613 #else
10617 #endif
10618 }
10620 /*
10621 * "getwinvar()" function
10622 */
10623 static void
10627 {
10629 }
10631 /*
10632 * getwinvar() and gettabwinvar()
10633 */
10634 static void
10639 {
10645 #ifdef FEAT_WINDOWS
10648 else
10650 #endif
10659 {
10660 /* Set curwin to be our win, temporarily. Also set curbuf, so
10661 * that we can get buffer-local options. */
10668 else
10669 {
10671 /* let getwinvar({nr}, "") return the "w:" dictionary. The
10672 * scope prefix before the NUL byte is required by
10673 * find_var_in_ht(). */
10675 /* look up the variable */
10679 }
10681 /* restore previous notion of curwin */
10684 }
10687 }
10689 /*
10690 * "glob()" function
10691 */
10692 static void
10696 {
10697 expand_T xpc;
10704 }
10706 /*
10707 * "globpath()" function
10708 */
10709 static void
10713 {
10720 else
10722 }
10724 /*
10725 * "has()" function
10726 */
10727 static void
10731 {
10736 {
10737 #ifdef AMIGA
10739 # ifdef FEAT_ARP
10741 # endif
10742 #endif
10743 #ifdef __BEOS__
10745 #endif
10746 #ifdef MSDOS
10747 # ifdef DJGPP
10749 # else
10751 # endif
10752 #endif
10753 #ifdef MACOS
10755 #endif
10756 #if defined(MACOS_X_UNIX)
10758 #endif
10759 #ifdef OS2
10761 #endif
10762 #ifdef __QNX__
10764 #endif
10765 #ifdef RISCOS
10767 #endif
10768 #ifdef UNIX
10770 #endif
10771 #ifdef VMS
10773 #endif
10774 #ifdef WIN16
10776 #endif
10777 #ifdef WIN32
10779 #endif
10780 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
10782 #endif
10783 #ifdef WIN64
10785 #endif
10786 #ifdef EBCDIC
10788 #endif
10789 #ifndef CASE_INSENSITIVE_FILENAME
10791 #endif
10792 #ifdef FEAT_ARABIC
10794 #endif
10795 #ifdef FEAT_AUTOCMD
10797 #endif
10798 #ifdef FEAT_BEVAL
10802 # endif
10803 #endif
10804 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
10806 # ifdef ALL_BUILTIN_TCAPS
10808 # endif
10809 #endif
10810 #ifdef FEAT_BYTEOFF
10812 #endif
10813 #ifdef FEAT_CINDENT
10815 #endif
10816 #ifdef FEAT_CLIENTSERVER
10818 #endif
10819 #ifdef FEAT_CLIPBOARD
10821 #endif
10822 #ifdef FEAT_CMDL_COMPL
10824 #endif
10825 #ifdef FEAT_CMDHIST
10827 #endif
10828 #ifdef FEAT_COMMENTS
10830 #endif
10831 #ifdef FEAT_CRYPT
10833 #endif
10834 #ifdef FEAT_CSCOPE
10836 #endif
10837 #ifdef CURSOR_SHAPE
10839 #endif
10840 #ifdef DEBUG
10842 #endif
10843 #ifdef FEAT_CON_DIALOG
10845 #endif
10846 #ifdef FEAT_GUI_DIALOG
10848 #endif
10849 #ifdef FEAT_DIFF
10851 #endif
10852 #ifdef FEAT_DIGRAPHS
10854 #endif
10855 #ifdef FEAT_DND
10857 #endif
10858 #ifdef FEAT_EMACS_TAGS
10860 #endif
10862 #ifdef FEAT_EX_EXTRA
10864 #endif
10865 #ifdef FEAT_SEARCH_EXTRA
10867 #endif
10868 #ifdef FEAT_FKMAP
10870 #endif
10871 #ifdef FEAT_SEARCHPATH
10873 #endif
10874 #if defined(UNIX) && !defined(USE_SYSTEM)
10876 #endif
10877 #ifdef FEAT_FIND_ID
10879 #endif
10880 #ifdef FEAT_FOLDING
10882 #endif
10883 #ifdef FEAT_FOOTER
10885 #endif
10886 #if !defined(USE_SYSTEM) && defined(UNIX)
10888 #endif
10889 #ifdef FEAT_GETTEXT
10891 #endif
10892 #ifdef FEAT_GUI
10894 #endif
10895 #ifdef FEAT_GUI_ATHENA
10896 # ifdef FEAT_GUI_NEXTAW
10898 # else
10900 # endif
10901 #endif
10902 #ifdef FEAT_GUI_GTK
10904 # ifdef HAVE_GTK2
10906 # endif
10907 #endif
10908 #ifdef FEAT_GUI_GNOME
10910 #endif
10911 #ifdef FEAT_GUI_MAC
10913 #endif
10914 #ifdef FEAT_GUI_MOTIF
10916 #endif
10917 #ifdef FEAT_GUI_PHOTON
10919 #endif
10920 #ifdef FEAT_GUI_W16
10922 #endif
10923 #ifdef FEAT_GUI_W32
10925 #endif
10926 #ifdef FEAT_HANGULIN
10928 #endif
10929 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
10931 #endif
10932 #ifdef FEAT_INS_EXPAND
10934 #endif
10935 #ifdef FEAT_JUMPLIST
10937 #endif
10938 #ifdef FEAT_KEYMAP
10940 #endif
10941 #ifdef FEAT_LANGMAP
10943 #endif
10944 #ifdef FEAT_LIBCALL
10946 #endif
10947 #ifdef FEAT_LINEBREAK
10949 #endif
10950 #ifdef FEAT_LISP
10952 #endif
10953 #ifdef FEAT_LISTCMDS
10955 #endif
10956 #ifdef FEAT_LOCALMAP
10958 #endif
10959 #ifdef FEAT_MENU
10961 #endif
10962 #ifdef FEAT_SESSION
10964 #endif
10965 #ifdef FEAT_MODIFY_FNAME
10967 #endif
10968 #ifdef FEAT_MOUSE
10970 #endif
10971 #ifdef FEAT_MOUSESHAPE
10973 #endif
10974 #if defined(UNIX) || defined(VMS)
10975 # ifdef FEAT_MOUSE_DEC
10977 # endif
10978 # ifdef FEAT_MOUSE_GPM
10980 # endif
10981 # ifdef FEAT_MOUSE_JSB
10983 # endif
10984 # ifdef FEAT_MOUSE_NET
10986 # endif
10987 # ifdef FEAT_MOUSE_PTERM
10989 # endif
10990 # ifdef FEAT_MOUSE_XTERM
10992 # endif
10993 #endif
10994 #ifdef FEAT_MBYTE
10996 #endif
10997 #ifdef FEAT_MBYTE_IME
10999 #endif
11000 #ifdef FEAT_MULTI_LANG
11002 #endif
11003 #ifdef FEAT_MZSCHEME
11004 #ifndef DYNAMIC_MZSCHEME
11006 #endif
11007 #endif
11008 #ifdef FEAT_OLE
11010 #endif
11011 #ifdef FEAT_OSFILETYPE
11013 #endif
11014 #ifdef FEAT_PATH_EXTRA
11016 #endif
11017 #ifdef FEAT_PERL
11018 #ifndef DYNAMIC_PERL
11020 #endif
11021 #endif
11022 #ifdef FEAT_PYTHON
11023 #ifndef DYNAMIC_PYTHON
11025 #endif
11026 #endif
11027 #ifdef FEAT_POSTSCRIPT
11029 #endif
11030 #ifdef FEAT_PRINTER
11032 #endif
11033 #ifdef FEAT_PROFILE
11035 #endif
11036 #ifdef FEAT_RELTIME
11038 #endif
11039 #ifdef FEAT_QUICKFIX
11041 #endif
11042 #ifdef FEAT_RIGHTLEFT
11044 #endif
11045 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11047 #endif
11048 #ifdef FEAT_SCROLLBIND
11050 #endif
11051 #ifdef FEAT_CMDL_INFO
11054 #endif
11055 #ifdef FEAT_SIGNS
11057 #endif
11058 #ifdef FEAT_SMARTINDENT
11060 #endif
11061 #ifdef FEAT_SNIFF
11063 #endif
11064 #ifdef FEAT_STL_OPT
11066 #endif
11067 #ifdef FEAT_SUN_WORKSHOP
11069 #endif
11070 #ifdef FEAT_NETBEANS_INTG
11072 #endif
11073 #ifdef FEAT_SPELL
11075 #endif
11076 #ifdef FEAT_SYN_HL
11078 #endif
11079 #if defined(USE_SYSTEM) || !defined(UNIX)
11081 #endif
11082 #ifdef FEAT_TAG_BINS
11084 #endif
11085 #ifdef FEAT_TAG_OLDSTATIC
11087 #endif
11088 #ifdef FEAT_TAG_ANYWHITE
11090 #endif
11091 #ifdef FEAT_TCL
11092 # ifndef DYNAMIC_TCL
11094 # endif
11095 #endif
11096 #ifdef TERMINFO
11098 #endif
11099 #ifdef FEAT_TERMRESPONSE
11101 #endif
11102 #ifdef FEAT_TEXTOBJ
11104 #endif
11105 #ifdef HAVE_TGETENT
11107 #endif
11108 #ifdef FEAT_TITLE
11110 #endif
11111 #ifdef FEAT_TOOLBAR
11113 #endif
11114 #ifdef FEAT_USR_CMDS
11117 #endif
11118 #ifdef FEAT_VIMINFO
11120 #endif
11121 #ifdef FEAT_VERTSPLIT
11123 #endif
11124 #ifdef FEAT_VIRTUALEDIT
11126 #endif
11127 #ifdef FEAT_VISUAL
11129 #endif
11130 #ifdef FEAT_VISUALEXTRA
11132 #endif
11133 #ifdef FEAT_VREPLACE
11135 #endif
11136 #ifdef FEAT_WILDIGN
11138 #endif
11139 #ifdef FEAT_WILDMENU
11141 #endif
11142 #ifdef FEAT_WINDOWS
11144 #endif
11145 #ifdef FEAT_WAK
11147 #endif
11148 #ifdef FEAT_WRITEBACKUP
11150 #endif
11151 #ifdef FEAT_XIM
11153 #endif
11154 #ifdef FEAT_XFONTSET
11156 #endif
11157 #ifdef USE_XSMP
11159 #endif
11160 #ifdef USE_XSMP_INTERACT
11162 #endif
11163 #ifdef FEAT_XCLIPBOARD
11165 #endif
11166 #ifdef FEAT_XTERM_SAVE
11168 #endif
11169 #if defined(UNIX) && defined(FEAT_X11)
11171 #endif
11172 NULL
11173 };
11178 {
11181 }
11184 {
11189 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11192 #endif
11193 #ifdef DYNAMIC_TCL
11196 #endif
11197 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11200 #endif
11201 #ifdef DYNAMIC_MZSCHEME
11204 #endif
11205 #ifdef DYNAMIC_RUBY
11208 #endif
11209 #ifdef DYNAMIC_PYTHON
11212 #endif
11213 #ifdef DYNAMIC_PERL
11216 #endif
11217 #ifdef FEAT_GUI
11220 # ifdef FEAT_GUI_W32
11223 # endif
11224 # ifdef FEAT_BROWSE
11227 # endif
11228 #endif
11229 #ifdef FEAT_SYN_HL
11232 #endif
11233 #if defined(WIN3264)
11236 #endif
11237 #ifdef FEAT_NETBEANS_INTG
11240 #endif
11241 }
11244 }
11246 /*
11247 * "has_key()" function
11248 */
11249 static void
11253 {
11256 {
11259 }
11265 }
11267 /*
11268 * "haslocaldir()" function
11269 */
11270 /*ARGSUSED*/
11271 static void
11275 {
11277 }
11279 /*
11280 * "hasmapto()" function
11281 */
11282 static void
11286 {
11295 else
11296 {
11300 }
11304 else
11306 }
11308 /*
11309 * "histadd()" function
11310 */
11311 /*ARGSUSED*/
11312 static void
11316 {
11317 #ifdef FEAT_CMDHIST
11321 #endif
11326 #ifdef FEAT_CMDHIST
11330 {
11333 {
11337 }
11338 }
11339 #endif
11340 }
11342 /*
11343 * "histdel()" function
11344 */
11345 /*ARGSUSED*/
11346 static void
11350 {
11351 #ifdef FEAT_CMDHIST
11360 /* only one argument: clear entire history */
11363 /* index given: remove that entry */
11366 else
11367 /* string given: remove all matching entries */
11371 #else
11373 #endif
11374 }
11376 /*
11377 * "histget()" function
11378 */
11379 /*ARGSUSED*/
11380 static void
11384 {
11385 #ifdef FEAT_CMDHIST
11393 else
11394 {
11398 else
11400 /* -1 on type error */
11402 }
11403 #else
11405 #endif
11407 }
11409 /*
11410 * "histnr()" function
11411 */
11412 /*ARGSUSED*/
11413 static void
11417 {
11420 #ifdef FEAT_CMDHIST
11426 else
11427 #endif
11430 }
11432 /*
11433 * "highlightID(name)" function
11434 */
11435 static void
11439 {
11441 }
11443 /*
11444 * "highlight_exists()" function
11445 */
11446 static void
11450 {
11452 }
11454 /*
11455 * "hostname()" function
11456 */
11457 /*ARGSUSED*/
11458 static void
11462 {
11468 }
11470 /*
11471 * iconv() function
11472 */
11473 /*ARGSUSED*/
11474 static void
11478 {
11479 #ifdef FEAT_MBYTE
11483 vimconv_T vimconv;
11484 #endif
11489 #ifdef FEAT_MBYTE
11496 /* If the encodings are equal, no conversion needed. */
11499 else
11505 #endif
11506 }
11508 /*
11509 * "indent()" function
11510 */
11511 static void
11515 {
11516 linenr_T lnum;
11521 else
11523 }
11525 /*
11526 * "index()" function
11527 */
11528 static void
11532 {
11540 {
11543 }
11546 {
11549 {
11552 /* Start at specified item. Use the cached index that list_find()
11553 * sets, so that a negative number also works. */
11560 }
11564 {
11567 }
11568 }
11569 }
11575 /*
11576 * This function is used by f_input() and f_inputdialog() functions. The third
11577 * argument to f_input() specifies the type of completion to use at the
11578 * prompt. The third argument to f_inputdialog() specifies the value to return
11579 * when the user cancels the prompt.
11580 */
11581 static void
11586 {
11599 #ifdef NO_CONSOLE_INPUT
11600 /* While starting up, there is no place to enter text. */
11603 #endif
11607 {
11608 /* Only the part of the message after the last NL is considered as
11609 * prompt for the command line */
11613 else
11614 {
11624 }
11628 {
11634 {
11650 }
11651 }
11660 /* since the user typed this, no need to wait for return */
11663 }
11665 }
11667 /*
11668 * "input()" function
11669 * Also handles inputsecret() when inputsecret is set.
11670 */
11671 static void
11675 {
11677 }
11679 /*
11680 * "inputdialog()" function
11681 */
11682 static void
11686 {
11687 #if defined(FEAT_GUI_TEXTDIALOG)
11688 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
11690 {
11699 else
11705 else
11706 {
11712 else
11714 }
11716 }
11717 else
11718 #endif
11720 }
11722 /*
11723 * "inputlist()" function
11724 */
11725 static void
11729 {
11735 #ifdef NO_CONSOLE_INPUT
11736 /* While starting up, there is no place to enter text. */
11739 #endif
11741 {
11744 }
11753 {
11756 }
11758 /* Ask for choice. */
11764 }
11769 /*
11770 * "inputrestore()" function
11771 */
11772 /*ARGSUSED*/
11773 static void
11777 {
11779 {
11784 }
11786 {
11789 }
11790 }
11792 /*
11793 * "inputsave()" function
11794 */
11795 /*ARGSUSED*/
11796 static void
11800 {
11801 /* Add an entry to the stack of typehead storage. */
11803 {
11808 }
11809 else
11811 }
11813 /*
11814 * "inputsecret()" function
11815 */
11816 static void
11820 {
11826 }
11828 /*
11829 * "insert()" function
11830 */
11831 static void
11835 {
11846 {
11854 else
11855 {
11858 {
11861 }
11862 }
11864 {
11867 }
11868 }
11869 }
11871 /*
11872 * "isdirectory()" function
11873 */
11874 static void
11878 {
11880 }
11882 /*
11883 * "islocked()" function
11884 */
11885 static void
11889 {
11890 lval_T lv;
11896 FNE_CHECK_START);
11898 {
11901 else
11902 {
11904 {
11907 else
11908 {
11911 {
11912 /* Consider a variable locked when:
11913 * 1. the variable itself is locked
11914 * 2. the value of the variable is locked.
11915 * 3. the List or Dict value is locked.
11916 */
11919 }
11920 }
11921 }
11927 /* List item. */
11929 else
11930 /* Dictionary item. */
11932 }
11933 }
11936 }
11940 /*
11941 * Turn a dict into a list:
11942 * "what" == 0: list of keys
11943 * "what" == 1: list of values
11944 * "what" == 2: list of items
11945 */
11946 static void
11951 {
11962 {
11965 }
11974 {
11976 {
11986 {
11987 /* keys() */
11991 }
11993 {
11994 /* values() */
11996 }
11997 else
11998 {
11999 /* items() */
12021 }
12022 }
12023 }
12024 }
12026 /*
12027 * "items(dict)" function
12028 */
12029 static void
12033 {
12035 }
12037 /*
12038 * "join()" function
12039 */
12040 static void
12044 {
12045 garray_T ga;
12050 {
12053 }
12058 else
12064 {
12069 }
12070 else
12072 }
12074 /*
12075 * "keys()" function
12076 */
12077 static void
12081 {
12083 }
12085 /*
12086 * "last_buffer_nr()" function.
12087 */
12088 /*ARGSUSED*/
12089 static void
12093 {
12102 }
12104 /*
12105 * "len()" function
12106 */
12107 static void
12111 {
12113 {
12128 }
12129 }
12133 static void
12138 {
12139 #ifdef FEAT_LIBCALL
12143 #endif
12148 else
12154 #ifdef FEAT_LIBCALL
12155 /* The first two args must be strings, otherwise its meaningless */
12157 {
12163 else
12167 string_in,
12169 string_result,
12173 }
12174 #endif
12175 }
12177 /*
12178 * "libcall()" function
12179 */
12180 static void
12184 {
12186 }
12188 /*
12189 * "libcallnr()" function
12190 */
12191 static void
12195 {
12197 }
12199 /*
12200 * "line(string)" function
12201 */
12202 static void
12206 {
12215 }
12217 /*
12218 * "line2byte(lnum)" function
12219 */
12220 /*ARGSUSED*/
12221 static void
12225 {
12226 #ifndef FEAT_BYTEOFF
12228 #else
12229 linenr_T lnum;
12234 else
12238 #endif
12239 }
12241 /*
12242 * "lispindent(lnum)" function
12243 */
12244 static void
12248 {
12249 #ifdef FEAT_LISP
12250 pos_T pos;
12251 linenr_T lnum;
12256 {
12260 }
12261 else
12262 #endif
12264 }
12266 /*
12267 * "localtime()" function
12268 */
12269 /*ARGSUSED*/
12270 static void
12274 {
12276 }
12280 static void
12285 {
12292 garray_T ga;
12295 /* return empty string for failure */
12304 {
12308 }
12309 else
12320 {
12330 }
12331 }
12333 /*
12334 * "map()" function
12335 */
12336 static void
12340 {
12342 }
12344 /*
12345 * "maparg()" function
12346 */
12347 static void
12351 {
12353 }
12355 /*
12356 * "mapcheck()" function
12357 */
12358 static void
12362 {
12364 }
12368 static void
12373 {
12377 regmatch_T regmatch;
12390 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12396 {
12397 /* return empty list when there are no matches */
12400 }
12402 {
12405 }
12408 {
12412 }
12413 else
12421 {
12428 {
12433 }
12434 else
12435 {
12440 /* When "count" argument is there ignore matches before "start",
12441 * otherwise skip part of the string. Differs when pattern is "^"
12442 * or "\<". */
12445 else
12447 }
12453 }
12457 {
12461 {
12463 {
12465 {
12468 }
12473 }
12482 /* Advance to just after the match. */
12484 {
12487 }
12488 else
12489 {
12490 #ifdef FEAT_MBYTE
12493 #else
12495 #endif
12496 }
12497 }
12500 {
12502 {
12505 /* return list with matched string and submatches */
12507 {
12509 {
12513 }
12519 }
12520 }
12522 {
12523 /* return matched string */
12526 else
12529 }
12532 else
12533 {
12537 else
12541 }
12542 }
12544 }
12546 theend:
12549 }
12551 /*
12552 * "match()" function
12553 */
12554 static void
12558 {
12560 }
12562 /*
12563 * "matchadd()" function
12564 */
12565 static void
12569 {
12570 #ifdef FEAT_SEARCH_EXTRA
12583 {
12587 }
12591 {
12594 }
12597 #endif
12598 }
12600 /*
12601 * "matcharg()" function
12602 */
12603 static void
12607 {
12609 {
12610 #ifdef FEAT_SEARCH_EXTRA
12615 {
12617 {
12621 }
12622 else
12623 {
12626 }
12627 }
12628 #endif
12629 }
12630 }
12632 /*
12633 * "matchdelete()" function
12634 */
12635 static void
12639 {
12640 #ifdef FEAT_SEARCH_EXTRA
12643 #endif
12644 }
12646 /*
12647 * "matchend()" function
12648 */
12649 static void
12653 {
12655 }
12657 /*
12658 * "matchlist()" function
12659 */
12660 static void
12664 {
12666 }
12668 /*
12669 * "matchstr()" function
12670 */
12671 static void
12675 {
12677 }
12681 static void
12686 {
12692 {
12698 {
12701 {
12704 {
12711 }
12712 }
12713 }
12714 }
12716 {
12724 {
12727 {
12729 {
12733 {
12736 }
12739 }
12740 }
12741 }
12742 }
12743 else
12746 }
12748 /*
12749 * "max()" function
12750 */
12751 static void
12755 {
12757 }
12759 /*
12760 * "min()" function
12761 */
12762 static void
12766 {
12768 }
12772 /*
12773 * Create the directory in which "dir" is located, and higher levels when
12774 * needed.
12775 */
12776 static int
12780 {
12785 /* Get end of directory name in "dir".
12786 * We're done when it's "/" or "c:/". */
12791 /* If the directory exists we're done. Otherwise: create it.*/
12801 }
12803 #ifdef vim_mkdir
12804 /*
12805 * "mkdir()" function
12806 */
12807 static void
12811 {
12822 {
12827 }
12829 }
12830 #endif
12832 /*
12833 * "mode()" function
12834 */
12835 /*ARGSUSED*/
12836 static void
12840 {
12843 #ifdef FEAT_VISUAL
12845 {
12848 else
12850 }
12851 else
12852 #endif
12856 {
12859 else
12861 }
12864 else
12870 }
12872 /*
12873 * "nextnonblank()" function
12874 */
12875 static void
12879 {
12880 linenr_T lnum;
12883 {
12885 {
12888 }
12891 }
12893 }
12895 /*
12896 * "nr2char()" function
12897 */
12898 static void
12902 {
12905 #ifdef FEAT_MBYTE
12908 else
12909 #endif
12910 {
12913 }
12916 }
12918 /*
12919 * "pathshorten()" function
12920 */
12921 static void
12925 {
12932 else
12933 {
12938 }
12939 }
12941 /*
12942 * "prevnonblank()" function
12943 */
12944 static void
12948 {
12949 linenr_T lnum;
12954 else
12958 }
12960 #ifdef HAVE_STDARG_H
12961 /* This dummy va_list is here because:
12962 * - passing a NULL pointer doesn't work when va_list isn't a pointer
12963 * - locally in the function results in a "used before set" warning
12964 * - using va_start() to initialize it gives "function with fixed args" error */
12966 #endif
12968 /*
12969 * "printf()" function
12970 */
12971 static void
12975 {
12979 {
12986 /* Get the required length, allocate the buffer and do it for real. */
12991 {
12994 {
12997 }
12998 }
13000 }
13001 #endif
13002 }
13004 /*
13005 * "pumvisible()" function
13006 */
13007 /*ARGSUSED*/
13008 static void
13012 {
13014 #ifdef FEAT_INS_EXPAND
13017 #endif
13018 }
13020 /*
13021 * "range()" function
13022 */
13023 static void
13027 {
13036 {
13039 }
13040 else
13041 {
13045 }
13054 else
13055 {
13061 }
13062 }
13064 /*
13065 * "readfile()" function
13066 */
13067 static void
13071 {
13091 {
13096 }
13101 /* Always open the file in binary mode, library functions have a mind of
13102 * their own about CR-LF conversion. */
13105 {
13108 }
13112 {
13117 {
13119 {
13120 /* Only when in binary mode add an empty list item when the
13121 * last line ends in a '\n'. */
13125 /* Found end-of-line or end-of-file: add a text line to the
13126 * list. */
13135 else
13136 {
13139 {
13145 }
13146 }
13151 {
13154 }
13164 }
13167 }
13172 {
13173 /* "buf" is full, need to move text to an allocated buffer */
13175 {
13178 }
13179 else
13180 {
13183 {
13189 }
13190 }
13192 }
13193 else
13194 {
13197 }
13198 }
13200 /*
13201 * For a negative line count use only the lines at the end of the file,
13202 * free the rest.
13203 */
13206 {
13209 }
13213 }
13215 #if defined(FEAT_RELTIME)
13218 /*
13219 * Convert a List to proftime_T.
13220 * Return FAIL when there is something wrong.
13221 */
13222 static int
13226 {
13235 # ifdef WIN3264
13238 # else
13241 # endif
13243 }
13246 /*
13247 * "reltime()" function
13248 */
13249 static void
13253 {
13254 #ifdef FEAT_RELTIME
13255 proftime_T res;
13256 proftime_T start;
13259 {
13260 /* No arguments: get current time. */
13262 }
13264 {
13268 }
13269 else
13270 {
13271 /* Two arguments: compute the difference. */
13276 }
13279 {
13282 # ifdef WIN3264
13285 # else
13288 # endif
13291 }
13292 #endif
13293 }
13295 /*
13296 * "reltimestr()" function
13297 */
13298 static void
13302 {
13303 #ifdef FEAT_RELTIME
13304 proftime_T tm;
13305 #endif
13309 #ifdef FEAT_RELTIME
13312 #endif
13313 }
13315 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13319 static void
13321 {
13323 # ifdef FEAT_GUI
13325 # endif
13326 )
13327 {
13331 }
13332 }
13334 static int
13336 {
13339 {
13342 }
13344 }
13345 #endif
13347 #ifdef FEAT_CLIENTSERVER
13350 static void
13355 {
13360 # ifdef WIN32
13361 HWND w;
13362 # else
13363 Window w;
13364 # endif
13369 # ifdef FEAT_X11
13372 # endif
13378 # ifdef WIN32
13380 # else
13383 # endif
13384 {
13387 else
13390 }
13395 {
13396 dictitem_T v;
13407 }
13408 }
13409 #endif
13411 /*
13412 * "remote_expr()" function
13413 */
13414 /*ARGSUSED*/
13415 static void
13419 {
13422 #ifdef FEAT_CLIENTSERVER
13424 #endif
13425 }
13427 /*
13428 * "remote_foreground()" function
13429 */
13430 /*ARGSUSED*/
13431 static void
13435 {
13437 #ifdef FEAT_CLIENTSERVER
13438 # ifdef WIN32
13439 /* On Win32 it's done in this application. */
13440 {
13445 }
13446 # else
13447 /* Send a foreground() expression to the server. */
13453 # endif
13454 #endif
13455 }
13457 /*ARGSUSED*/
13458 static void
13462 {
13463 #ifdef FEAT_CLIENTSERVER
13464 dictitem_T v;
13466 # ifdef WIN32
13468 # endif
13472 {
13475 }
13478 {
13481 }
13482 # ifdef WIN32
13486 else
13487 {
13490 }
13491 # else
13498 # endif
13501 {
13510 }
13511 #else
13513 #endif
13514 }
13516 /*ARGSUSED*/
13517 static void
13521 {
13524 #ifdef FEAT_CLIENTSERVER
13528 {
13529 # ifdef WIN32
13530 /* The server's HWND is encoded in the 'id' parameter */
13537 # else
13540 # endif
13542 }
13543 #endif
13546 }
13548 /*
13549 * "remote_send()" function
13550 */
13551 /*ARGSUSED*/
13552 static void
13556 {
13559 #ifdef FEAT_CLIENTSERVER
13561 #endif
13562 }
13564 /*
13565 * "remove()" function
13566 */
13567 static void
13571 {
13583 {
13588 {
13591 {
13595 else
13596 {
13600 }
13601 }
13602 }
13603 }
13608 {
13616 else
13617 {
13619 {
13620 /* Remove one item, return its value. */
13624 }
13625 else
13626 {
13627 /* Remove range of items, return list with values. */
13633 else
13634 {
13638 {
13642 }
13645 else
13646 {
13649 {
13656 }
13657 }
13658 }
13659 }
13660 }
13661 }
13662 }
13664 /*
13665 * "rename({from}, {to})" function
13666 */
13667 static void
13671 {
13676 else
13679 }
13681 /*
13682 * "repeat()" function
13683 */
13684 /*ARGSUSED*/
13685 static void
13689 {
13699 {
13705 }
13706 else
13707 {
13719 {
13723 }
13726 }
13727 }
13729 /*
13730 * "resolve()" function
13731 */
13732 static void
13736 {
13740 #ifdef FEAT_SHORTCUT
13741 {
13747 else
13749 }
13750 #else
13751 # ifdef HAVE_READLINK
13752 {
13774 {
13775 /* Separate the first path component in "p", and keep the
13776 * remainder (beginning with the path separator). */
13779 }
13782 {
13784 {
13791 {
13797 }
13799 /* Ensure that the result will have a trailing path separator
13800 * if the argument has one. */
13804 /* Separate the first path component in the link value and
13805 * concatenate the remainders. */
13808 {
13811 else
13812 {
13815 {
13818 }
13819 }
13821 }
13825 {
13826 /* Ignore trailing path separator. */
13829 }
13831 {
13832 /* symlink is relative to directory of argument */
13835 {
13840 }
13841 }
13842 else
13843 {
13846 }
13847 }
13852 /* Append the first path component of "remain" to "p". */
13857 {
13861 }
13862 /* Shorten "remain". */
13865 else
13866 {
13869 }
13870 }
13872 /* If the result is a relative path name, make it explicitly relative to
13873 * the current directory if and only if the argument had this form. */
13875 {
13884 {
13885 /* Prepend "./". */
13888 {
13891 }
13892 }
13894 {
13895 /* Strip leading "./". */
13901 }
13902 }
13904 /* Ensure that the result will have no trailing path separator
13905 * if the argument had none. But keep "/" or "//". */
13907 {
13911 }
13914 }
13915 # else
13917 # endif
13918 #endif
13922 #ifdef HAVE_READLINK
13923 fail:
13924 #endif
13926 }
13928 /*
13929 * "reverse({list})" function
13930 */
13931 static void
13935 {
13944 {
13949 {
13953 }
13957 }
13958 }
13970 /*
13971 * Get flags for a search function.
13972 * Possibly sets "p_ws".
13973 * Returns BACKWARD, FORWARD or zero (for an error).
13974 */
13975 static int
13979 {
13986 {
13991 {
13993 {
14000 {
14008 }
14010 {
14013 }
14014 else
14016 }
14020 }
14021 }
14023 }
14025 /*
14026 * Shared by search() and searchpos() functions
14027 */
14028 static int
14033 {
14036 pos_T pos;
14037 pos_T save_cursor;
14042 proftime_T tm;
14043 #ifdef FEAT_RELTIME
14045 #endif
14059 /* Optional arguments: line number to stop searching and timeout. */
14061 {
14065 #ifdef FEAT_RELTIME
14067 {
14071 }
14072 #endif
14073 }
14075 #ifdef FEAT_RELTIME
14076 /* Set the time limit, if there is one. */
14078 #endif
14080 /*
14081 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14082 * Check to make sure only those flags are set.
14083 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14084 * flags cannot be set. Check for that condition also.
14085 */
14088 {
14091 }
14097 {
14100 else
14106 {
14107 /* Store the match cursor position */
14110 }
14111 /* "/$" will put the cursor after the end of the line, may need to
14112 * correct that here */
14114 }
14116 /* If 'n' flag is used: restore cursor position. */
14119 else
14121 theend:
14125 }
14127 /*
14128 * "search()" function
14129 */
14130 static void
14134 {
14138 }
14140 /*
14141 * "searchdecl()" function
14142 */
14143 static void
14147 {
14157 {
14161 }
14165 }
14167 /*
14168 * Used by searchpair() and searchpairpos()
14169 */
14170 static int
14174 {
14187 /* Get the three pattern arguments: start, middle, end. */
14194 /* Handle the optional fourth argument: flags */
14199 /* Don't accept SP_END or SP_SUBPAT.
14200 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14201 */
14204 {
14207 }
14209 /* Using 'r' implies 'W', otherwise it doesn't work. */
14213 /* Optional fifth argument: skip expression */
14217 else
14218 {
14221 {
14225 #ifdef FEAT_RELTIME
14227 {
14231 }
14232 #endif
14233 }
14234 }
14241 theend:
14245 }
14247 /*
14248 * "searchpair()" function
14249 */
14250 static void
14254 {
14256 }
14258 /*
14259 * "searchpairpos()" function
14260 */
14261 static void
14265 {
14266 pos_T match_pos;
14276 {
14279 }
14283 }
14285 /*
14286 * Search for a start/middle/end thing.
14287 * Used by searchpair(), see its documentation for the details.
14288 * Returns 0 or -1 for no match,
14289 */
14290 long
14302 {
14306 pos_T pos;
14307 pos_T firstpos;
14308 pos_T foundpos;
14309 pos_T save_cursor;
14310 pos_T save_pos;
14316 proftime_T tm;
14318 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14322 #ifdef FEAT_RELTIME
14323 /* Set the time limit, if there is one. */
14325 #endif
14327 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14328 * start/middle/end (pat3, for the top pair). */
14336 else
14348 {
14352 /* didn't find it or found the first match again: FAIL */
14358 {
14359 /* Found the same position again. Can happen with a pattern that
14360 * has "\zs" at the end and searching backwards. Advance one
14361 * character and try again. */
14364 else
14366 }
14369 /* clear the start flag to avoid getting stuck here */
14372 /* If the skip pattern matches, ignore this match. */
14374 {
14380 {
14381 /* Evaluating {skip} caused an error, break here. */
14385 }
14388 }
14391 {
14392 /* Found end when searching backwards or start when searching
14393 * forward: nested pair. */
14396 }
14397 else
14398 {
14399 /* Found end when searching forward or start when searching
14400 * backward: end of (nested) pair; or found middle in outer pair. */
14403 }
14406 {
14407 /* Found the match: return matchcount or line number. */
14410 else
14418 }
14419 }
14422 {
14423 /* Store the match cursor position */
14426 }
14428 /* If 'n' flag is used or search failed: restore cursor position. */
14432 theend:
14438 }
14440 /*
14441 * "searchpos()" function
14442 */
14443 static void
14447 {
14448 pos_T match_pos;
14461 {
14464 }
14470 }
14473 /*ARGSUSED*/
14474 static void
14478 {
14479 #ifdef FEAT_CLIENTSERVER
14489 # ifdef FEAT_X11
14492 # endif
14495 {
14498 }
14500 #else
14502 #endif
14503 }
14505 /*ARGSUSED*/
14506 static void
14510 {
14513 #ifdef FEAT_CLIENTSERVER
14514 # ifdef WIN32
14516 # else
14520 # endif
14521 #endif
14524 }
14526 /*
14527 * "setbufvar()" function
14528 */
14529 /*ARGSUSED*/
14530 static void
14534 {
14536 aco_save_T aco;
14551 {
14552 /* set curbuf to be our buf, temporarily */
14556 {
14566 }
14567 else
14568 {
14571 {
14576 }
14577 }
14579 /* reset notion of buffer */
14581 }
14582 }
14584 /*
14585 * "setcmdpos()" function
14586 */
14587 static void
14591 {
14596 }
14598 /*
14599 * "setline()" function
14600 */
14601 static void
14605 {
14606 linenr_T lnum;
14615 {
14618 }
14619 else
14624 {
14626 {
14627 /* list argument, get next string */
14632 }
14638 {
14639 /* existing line, replace it */
14641 {
14646 }
14647 }
14649 {
14650 /* lnum is one past the last line, append the line */
14654 }
14659 }
14663 }
14665 /*
14666 * Used by "setqflist()" and "setloclist()" functions
14667 */
14668 /*ARGSUSED*/
14669 static void
14675 {
14676 #ifdef FEAT_QUICKFIX
14679 #endif
14683 #ifdef FEAT_QUICKFIX
14686 else
14687 {
14691 {
14697 }
14701 }
14702 #endif
14703 }
14705 /*
14706 * "setloclist()" function
14707 */
14708 /*ARGSUSED*/
14709 static void
14713 {
14721 }
14723 /*
14724 * "setmatches()" function
14725 */
14726 static void
14730 {
14731 #ifdef FEAT_SEARCH_EXTRA
14738 {
14741 }
14743 {
14745 /* To some extent make sure that we are dealing with a list from
14746 * "getmatches()". */
14749 {
14752 {
14755 }
14760 {
14763 }
14765 }
14770 {
14777 }
14779 }
14780 #endif
14781 }
14783 /*
14784 * "setpos()" function
14785 */
14786 /*ARGSUSED*/
14787 static void
14791 {
14792 pos_T pos;
14799 {
14801 {
14804 {
14805 /* set cursor */
14807 {
14811 }
14812 else
14814 }
14816 {
14817 /* set mark */
14820 }
14821 else
14823 }
14824 }
14825 }
14827 /*
14828 * "setqflist()" function
14829 */
14830 /*ARGSUSED*/
14831 static void
14835 {
14837 }
14839 /*
14840 * "setreg()" function
14841 */
14842 static void
14846 {
14852 char_u yank_type;
14871 {
14877 {
14887 #ifdef FEAT_VISUAL
14891 {
14895 }
14897 #endif
14898 }
14899 }
14906 }
14908 /*
14909 * "settabwinvar()" function
14910 */
14911 static void
14915 {
14917 }
14919 /*
14920 * "setwinvar()" function
14921 */
14922 static void
14926 {
14928 }
14930 /*
14931 * "setwinvar()" and "settabwinvar()" functions
14932 */
14933 static void
14938 {
14940 #ifdef FEAT_WINDOWS
14943 #endif
14954 #ifdef FEAT_WINDOWS
14957 else
14959 #endif
14965 {
14966 #ifdef FEAT_WINDOWS
14967 /* set curwin to be our win, temporarily */
14975 #endif
14978 {
14988 }
14989 else
14990 {
14993 {
14998 }
14999 }
15001 #ifdef FEAT_WINDOWS
15002 /* Restore current tabpage and window, if still valid (autocomands can
15003 * make them invalid). */
15007 {
15010 }
15011 #endif
15012 }
15013 }
15015 /*
15016 * "shellescape({string})" function
15017 */
15018 static void
15022 {
15025 }
15027 /*
15028 * "simplify()" function
15029 */
15030 static void
15034 {
15041 }
15043 static int
15044 #ifdef __BORLANDC__
15045 _RTLENTRYF
15046 #endif
15048 static int
15049 #ifdef __BORLANDC__
15050 _RTLENTRYF
15051 #endif
15057 #define ITEM_COMPARE_FAIL 999
15059 /*
15060 * Compare functions for f_sort() below.
15061 */
15062 static int
15063 #ifdef __BORLANDC__
15064 _RTLENTRYF
15065 #endif
15069 {
15084 else
15089 }
15091 static int
15092 #ifdef __BORLANDC__
15093 _RTLENTRYF
15094 #endif
15098 {
15100 typval_T rettv;
15104 /* shortcut after failure in previous call; compare all items equal */
15108 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15109 * in the copy without changing the original list items. */
15121 else
15122 /* return value has wrong type */
15128 }
15130 /*
15131 * "sort({list})" function
15132 */
15133 static void
15137 {
15147 else
15148 {
15163 {
15166 else
15167 {
15175 else
15177 }
15178 }
15180 /* Make an array with each entry pointing to an item in the List. */
15189 /* test the compare function */
15194 else
15195 {
15196 /* Sort the array with item pointers. */
15201 {
15202 /* Clear the List and append the items in the sorted order. */
15207 }
15208 }
15211 }
15212 }
15214 /*
15215 * "soundfold({word})" function
15216 */
15217 static void
15221 {
15226 #ifdef FEAT_SPELL
15228 #else
15230 #endif
15231 }
15233 /*
15234 * "spellbadword()" function
15235 */
15236 /* ARGSUSED */
15237 static void
15241 {
15249 #ifdef FEAT_SPELL
15251 {
15252 /* Find the start and length of the badly spelled word. */
15256 }
15258 {
15263 {
15264 /* Check the argument for spelling. */
15266 {
15269 {
15272 }
15274 }
15275 }
15276 }
15277 #endif
15286 }
15288 /*
15289 * "spellsuggest()" function
15290 */
15291 /*ARGSUSED*/
15292 static void
15296 {
15297 #ifdef FEAT_SPELL
15301 garray_T ga;
15305 #endif
15310 #ifdef FEAT_SPELL
15312 {
15315 {
15320 {
15324 }
15325 }
15326 else
15332 {
15338 else
15339 {
15344 }
15345 }
15347 }
15348 #endif
15349 }
15351 static void
15355 {
15359 regmatch_T regmatch;
15367 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15373 {
15379 }
15390 {
15393 {
15396 else
15400 else
15404 {
15408 }
15411 /* Advance to just after the match. */
15414 else
15415 {
15416 /* Don't get stuck at the same match. */
15417 #ifdef FEAT_MBYTE
15419 #else
15421 #endif
15422 }
15424 }
15427 }
15430 }
15432 /*
15433 * "str2nr()" function
15434 */
15435 static void
15439 {
15445 {
15448 {
15451 }
15452 }
15457 }
15459 #ifdef HAVE_STRFTIME
15460 /*
15461 * "strftime({format}[, {time}])" function
15462 */
15463 static void
15467 {
15478 else
15481 /* MSVC returns NULL for an invalid value of seconds. */
15484 else
15485 {
15486 # ifdef FEAT_MBYTE
15487 vimconv_T conv;
15495 # endif
15499 else
15502 # ifdef FEAT_MBYTE
15508 else
15509 # endif
15512 # ifdef FEAT_MBYTE
15513 /* Release conversion descriptors */
15516 # endif
15517 }
15518 }
15519 #endif
15521 /*
15522 * "stridx()" function
15523 */
15524 static void
15528 {
15543 {
15551 }
15556 }
15558 /*
15559 * "string()" function
15560 */
15561 static void
15565 {
15571 /* Make a copy if we have a value but it's not in allocate memory. */
15574 }
15576 /*
15577 * "strlen()" function
15578 */
15579 static void
15583 {
15586 }
15588 /*
15589 * "strpart()" function
15590 */
15591 static void
15595 {
15610 else
15613 /*
15614 * Only return the overlap between the specified part and the actual
15615 * string.
15616 */
15618 {
15621 }
15631 }
15633 /*
15634 * "strridx()" function
15635 */
15636 static void
15640 {
15657 {
15658 /* Third argument: upper limit for index */
15662 }
15663 else
15667 {
15668 /* Empty string matches past the end. */
15670 }
15671 else
15672 {
15674 {
15679 }
15680 }
15684 else
15686 }
15688 /*
15689 * "strtrans()" function
15690 */
15691 static void
15695 {
15698 }
15700 /*
15701 * "submatch()" function
15702 */
15703 static void
15707 {
15711 }
15713 /*
15714 * "substitute()" function
15715 */
15716 static void
15720 {
15733 else
15735 }
15737 /*
15738 * "synID(lnum, col, trans)" function
15739 */
15740 /*ARGSUSED*/
15741 static void
15745 {
15747 #ifdef FEAT_SYN_HL
15760 #endif
15763 }
15765 /*
15766 * "synIDattr(id, what [, mode])" function
15767 */
15768 /*ARGSUSED*/
15769 static void
15773 {
15775 #ifdef FEAT_SYN_HL
15785 {
15789 #ifdef FEAT_GUI
15791 #endif
15792 )
15794 }
15795 else
15796 {
15797 #ifdef FEAT_GUI
15800 else
15801 #endif
15804 else
15806 }
15810 {
15843 /* underline */
15845 else
15846 /* undercurl */
15849 }
15853 #endif
15856 }
15858 /*
15859 * "synIDtrans(id)" function
15860 */
15861 /*ARGSUSED*/
15862 static void
15866 {
15869 #ifdef FEAT_SYN_HL
15874 else
15875 #endif
15879 }
15881 /*
15882 * "synstack(lnum, col)" function
15883 */
15884 /*ARGSUSED*/
15885 static void
15889 {
15890 #ifdef FEAT_SYN_HL
15895 #endif
15900 #ifdef FEAT_SYN_HL
15907 {
15910 {
15916 }
15917 }
15918 #endif
15919 }
15921 /*
15922 * "system()" function
15923 */
15924 static void
15928 {
15940 {
15941 /*
15942 * Write the string to a temp file, to be used for input of the shell
15943 * command.
15944 */
15946 {
15949 }
15953 {
15956 }
15959 {
15962 }
15968 {
15971 }
15972 }
15977 #ifdef USE_CR
15978 /* translate <CR> into <NL> */
15980 {
15984 {
15987 }
15988 }
15989 #else
15990 # ifdef USE_CRNL
15991 /* translate <CR><NL> into <NL> */
15993 {
15998 {
16002 }
16004 }
16005 # endif
16006 #endif
16008 done:
16010 {
16013 }
16016 }
16018 /*
16019 * "tabpagebuflist()" function
16020 */
16021 /* ARGSUSED */
16022 static void
16026 {
16027 #ifndef FEAT_WINDOWS
16029 #else
16035 else
16036 {
16040 }
16043 else
16044 {
16047 else
16048 {
16053 }
16054 }
16055 #endif
16056 }
16059 /*
16060 * "tabpagenr()" function
16061 */
16062 /* ARGSUSED */
16063 static void
16067 {
16069 #ifdef FEAT_WINDOWS
16073 {
16077 {
16080 else
16082 }
16083 }
16084 else
16086 #endif
16088 }
16091 #ifdef FEAT_WINDOWS
16094 /*
16095 * Common code for tabpagewinnr() and winnr().
16096 */
16097 static int
16101 {
16109 {
16116 {
16120 }
16121 else
16122 {
16125 }
16126 }
16131 {
16133 {
16134 /* didn't find it in this tabpage */
16137 }
16139 }
16141 }
16142 #endif
16144 /*
16145 * "tabpagewinnr()" function
16146 */
16147 /* ARGSUSED */
16148 static void
16152 {
16154 #ifdef FEAT_WINDOWS
16160 else
16162 #endif
16164 }
16167 /*
16168 * "tagfiles()" function
16169 */
16170 /*ARGSUSED*/
16171 static void
16175 {
16177 tagname_T tn;
16181 {
16184 }
16191 }
16193 /*
16194 * "taglist()" function
16195 */
16196 static void
16200 {
16211 }
16213 /*
16214 * "tempname()" function
16215 */
16216 /*ARGSUSED*/
16217 static void
16221 {
16227 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16228 * names. Skip 'I' and 'O', they are used for shell redirection. */
16229 do
16230 {
16235 else
16236 {
16237 #ifdef EBCDIC
16242 else
16243 #endif
16245 }
16247 }
16249 /*
16250 * "test(list)" function: Just checking the walls...
16251 */
16252 /*ARGSUSED*/
16253 static void
16257 {
16258 /* Used for unit testing. Change the code below to your liking. */
16259 #if 0
16278 #endif
16279 }
16281 /*
16282 * "tolower(string)" function
16283 */
16284 static void
16288 {
16297 {
16298 #ifdef FEAT_MBYTE
16302 {
16308 /* TODO: reallocate string when byte count changes. */
16312 }
16315 else
16316 #endif
16317 {
16320 }
16321 }
16322 }
16324 /*
16325 * "toupper(string)" function
16326 */
16327 static void
16331 {
16334 }
16336 /*
16337 * "tr(string, fromstr, tostr)" function
16338 */
16339 static void
16343 {
16348 #ifdef FEAT_MBYTE
16356 #endif
16359 garray_T ga;
16365 /* Default return value: empty string. */
16372 #ifdef FEAT_MBYTE
16374 #endif
16375 /* not multi-byte: fromstr and tostr must be the same length */
16377 {
16378 #ifdef FEAT_MBYTE
16379 error:
16380 #endif
16384 }
16386 /* fromstr and tostr have to contain the same number of chars */
16388 {
16389 #ifdef FEAT_MBYTE
16391 {
16397 {
16400 {
16402 {
16405 {
16409 }
16410 }
16414 }
16416 }
16419 {
16420 /* Check that fromstr and tostr have the same number of
16421 * (multi-byte) characters. Done only once when a character
16422 * of instr doesn't appear in fromstr. */
16425 {
16428 }
16431 }
16438 }
16439 else
16440 #endif
16441 {
16442 /* When not using multi-byte chars we can do it faster. */
16446 else
16449 }
16450 }
16452 /* add a terminating NUL */
16457 }
16459 /*
16460 * "type(expr)" function
16461 */
16462 static void
16466 {
16470 {
16477 }
16479 }
16481 /*
16482 * "values(dict)" function
16483 */
16484 static void
16488 {
16490 }
16492 /*
16493 * "virtcol(string)" function
16494 */
16495 static void
16499 {
16507 {
16510 }
16513 }
16515 /*
16516 * "visualmode()" function
16517 */
16518 /*ARGSUSED*/
16519 static void
16523 {
16524 #ifdef FEAT_VISUAL
16532 /* A non-zero number or non-empty string argument: reset mode. */
16538 #else
16540 #endif
16541 }
16543 /*
16544 * "winbufnr(nr)" function
16545 */
16546 static void
16550 {
16556 else
16558 }
16560 /*
16561 * "wincol()" function
16562 */
16563 /*ARGSUSED*/
16564 static void
16568 {
16571 }
16573 /*
16574 * "winheight(nr)" function
16575 */
16576 static void
16580 {
16586 else
16588 }
16590 /*
16591 * "winline()" function
16592 */
16593 /*ARGSUSED*/
16594 static void
16598 {
16601 }
16603 /*
16604 * "winnr()" function
16605 */
16606 /* ARGSUSED */
16607 static void
16611 {
16614 #ifdef FEAT_WINDOWS
16616 #endif
16618 }
16620 /*
16621 * "winrestcmd()" function
16622 */
16623 /* ARGSUSED */
16624 static void
16628 {
16629 #ifdef FEAT_WINDOWS
16632 garray_T ga;
16637 {
16640 # ifdef FEAT_VERTSPLIT
16643 # endif
16645 }
16649 #else
16651 #endif
16653 }
16655 /*
16656 * "winrestview()" function
16657 */
16658 /* ARGSUSED */
16659 static void
16663 {
16669 else
16670 {
16673 #ifdef FEAT_VIRTUALEDIT
16675 #endif
16680 #ifdef FEAT_DIFF
16682 #endif
16695 #ifdef FEAT_DIFF
16697 #endif
16698 }
16699 }
16701 /*
16702 * "winsaveview()" function
16703 */
16704 /* ARGSUSED */
16705 static void
16709 {
16721 #ifdef FEAT_VIRTUALEDIT
16723 #endif
16728 #ifdef FEAT_DIFF
16730 #endif
16733 }
16735 /*
16736 * "winwidth(nr)" function
16737 */
16738 static void
16742 {
16748 else
16749 #ifdef FEAT_VERTSPLIT
16751 #else
16753 #endif
16754 }
16756 /*
16757 * "writefile()" function
16758 */
16759 static void
16763 {
16776 {
16779 }
16787 /* Always open the file in binary mode, library functions have a mind of
16788 * their own about CR-LF conversion. */
16791 {
16794 }
16795 else
16796 {
16799 {
16801 {
16804 else
16807 {
16810 }
16811 }
16814 {
16817 }
16819 {
16822 }
16823 }
16825 }
16828 }
16830 /*
16831 * Translate a String variable into a position.
16832 * Returns NULL when there is an error.
16833 */
16839 {
16844 /* Argument can be [lnum, col, coladd]. */
16846 {
16856 /* Get the line number */
16861 /* Get the column number */
16867 /* We accept "$" for the column number: last column. */
16874 /* Accept a position up to the NUL after the line. */
16879 #ifdef FEAT_VIRTUALEDIT
16880 /* Get the virtual offset. Defaults to zero. */
16884 #endif
16887 }
16895 {
16900 }
16902 #ifdef FEAT_VIRTUALEDIT
16904 #endif
16907 {
16910 {
16914 }
16916 {
16920 }
16921 }
16923 {
16925 {
16928 }
16929 else
16930 {
16933 }
16935 }
16937 }
16939 /*
16940 * Convert list in "arg" into a position and optional file number.
16941 * When "fnump" is NULL there is no file number, only 3 items.
16942 * Note that the column is passed on as-is, the caller may want to decrement
16943 * it to use 1 for the first column.
16944 * Return FAIL when conversion is not possible, doesn't check the position for
16945 * validity.
16946 */
16947 static int
16952 {
16957 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
16958 * when "fnump" isn't NULL and "coladd" is optional. */
16966 {
16973 }
16985 #ifdef FEAT_VIRTUALEDIT
16989 else
16991 #endif
16994 }
16996 /*
16997 * Get the length of an environment variable name.
16998 * Advance "arg" to the first character after the name.
16999 * Return 0 for error.
17000 */
17001 static int
17004 {
17009 ;
17016 }
17018 /*
17019 * Get the length of the name of a function or internal variable.
17020 * "arg" is advanced to the first non-white character after the name.
17021 * Return 0 if something is wrong.
17022 */
17023 static int
17026 {
17030 /* Find the end of the name. */
17032 ;
17040 }
17042 /*
17043 * Get the length of the name of a variable or function.
17044 * Only the name is recognized, does not handle ".key" or "[idx]".
17045 * "arg" is advanced to the first non-white character after the name.
17046 * Return -1 if curly braces expansion failed.
17047 * Return 0 if something else is wrong.
17048 * If the name contains 'magic' {}'s, expand them and return the
17049 * expanded name in an allocated string via 'alias' - caller must free.
17050 */
17051 static int
17057 {
17067 {
17068 /* hard coded <SNR>, already translated */
17071 }
17074 {
17075 /* literal "<SID>", "s:" or "<SNR>" */
17077 }
17079 /*
17080 * Find the end of the name; check for {} construction.
17081 */
17085 {
17089 {
17093 }
17095 /*
17096 * Include any <SID> etc in the expanded string:
17097 * Thus the -len here.
17098 */
17105 }
17112 }
17114 /*
17115 * Find the end of a variable or function name, taking care of magic braces.
17116 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17117 * start and end of the first magic braces item.
17118 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17119 * Return a pointer to just after the name. Equal to "arg" if there is no
17120 * valid name.
17121 */
17128 {
17134 {
17137 }
17139 /* Quick check for valid starting character. */
17149 {
17151 {
17152 /* skip over 'string' to avoid counting [ and ] inside it. */
17154 ;
17157 }
17159 {
17160 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17166 }
17169 {
17174 }
17177 {
17179 {
17180 mb_nest++;
17183 }
17185 {
17186 mb_nest--;
17189 }
17190 }
17191 }
17194 }
17196 /*
17197 * Expands out the 'magic' {}'s in a variable/function name.
17198 * Note that this can call itself recursively, to deal with
17199 * constructs like foo{bar}{baz}{bam}
17200 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17201 * "in_start" ^
17202 * "expr_start" ^
17203 * "expr_end" ^
17204 * "in_end" ^
17205 *
17206 * Returns a new allocated string, which the caller must free.
17207 * Returns NULL for failure.
17208 */
17215 {
17216 char_u c1;
17230 {
17234 {
17238 }
17239 }
17247 {
17250 {
17251 /* Further expansion! */
17256 }
17257 }
17260 }
17262 /*
17263 * Return TRUE if character "c" can be used in a variable or function name.
17264 * Does not include '{' or '}' for magic braces.
17265 */
17266 static int
17269 {
17271 }
17273 /*
17274 * Return TRUE if character "c" can be used as the first character in a
17275 * variable or function name (excluding '{' and '}').
17276 */
17277 static int
17280 {
17282 }
17284 /*
17285 * Set number v: variable to "val".
17286 */
17287 void
17291 {
17293 }
17295 /*
17296 * Get number v: variable value.
17297 */
17298 long
17301 {
17303 }
17305 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17306 /*
17307 * Get string v: variable value. Uses a static buffer, can only be used once.
17308 */
17309 char_u *
17312 {
17314 }
17315 #endif
17317 /*
17318 * Set v:count, v:count1 and v:prevcount.
17319 */
17320 void
17324 {
17328 }
17330 /*
17331 * Set string v: variable to a copy of "val".
17332 */
17333 void
17338 {
17339 /* Need to do this (at least) once, since we can't initialize a union.
17340 * Will always be invoked when "v:progname" is set. */
17348 else
17350 }
17352 /*
17353 * Set v:register if needed.
17354 */
17355 void
17358 {
17359 char_u regname;
17363 else
17365 /* Avoid free/alloc when the value is already right. */
17368 }
17370 /*
17371 * Get or set v:exception. If "oldval" == NULL, return the current value.
17372 * Otherwise, restore the value to "oldval" and return NULL.
17373 * Must always be called in pairs to save and restore v:exception! Does not
17374 * take care of memory allocations.
17375 */
17376 char_u *
17379 {
17385 }
17387 /*
17388 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
17389 * Otherwise, restore the value to "oldval" and return NULL.
17390 * Must always be called in pairs to save and restore v:throwpoint! Does not
17391 * take care of memory allocations.
17392 */
17393 char_u *
17396 {
17402 }
17404 #if defined(FEAT_AUTOCMD) || defined(PROTO)
17405 /*
17406 * Set v:cmdarg.
17407 * If "eap" != NULL, use "eap" to generate the value and return the old value.
17408 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
17409 * Must always be called in pairs!
17410 */
17411 char_u *
17415 {
17422 {
17426 }
17432 else
17440 # ifdef FEAT_MBYTE
17445 # endif
17455 else
17464 # ifdef FEAT_MBYTE
17471 # endif
17474 }
17475 #endif
17477 /*
17478 * Get the value of internal variable "name".
17479 * Return OK or FAIL.
17480 */
17481 static int
17487 {
17490 typval_T atv;
17494 /* truncate the name, so that we can use strcmp() */
17498 /*
17499 * Check for "b:changedtick".
17500 */
17502 {
17506 }
17508 /*
17509 * Check for user-defined variables.
17510 */
17511 else
17512 {
17516 }
17519 {
17523 }
17530 }
17532 /*
17533 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
17534 * Also handle function call with Funcref variable: func(expr)
17535 * Can all be combined: dict.func(expr)[idx]['func'](expr)
17536 */
17537 static int
17543 {
17548 typval_T functv;
17555 {
17557 {
17558 /* need to copy the funcref so that we can clear rettv */
17562 /* Invoke the function. Recursive! */
17568 /* Clear the funcref afterwards, so that deleting it while
17569 * evaluating the arguments is possible (see test55). */
17572 /* Stop the expression evaluation when immediately aborting on
17573 * error, or when an interrupt occurred or an exception was thrown
17574 * but not caught. */
17576 {
17580 }
17583 }
17585 {
17588 {
17592 }
17593 else
17596 {
17599 }
17600 }
17601 }
17604 }
17606 /*
17607 * Allocate memory for a variable type-value, and make it emtpy (0 or NULL
17608 * value).
17609 */
17612 {
17614 }
17616 /*
17617 * Allocate memory for a variable type-value, and assign a string to it.
17618 * The string "s" must have been allocated, it is consumed.
17619 * Return NULL for out of memory, the variable otherwise.
17620 */
17624 {
17629 {
17632 }
17633 else
17636 }
17638 /*
17639 * Free the memory for a variable type-value.
17640 */
17641 void
17644 {
17646 {
17648 {
17651 /*FALLTHROUGH*/
17667 }
17669 }
17670 }
17672 /*
17673 * Free the memory for a variable value and set the value to NULL or 0.
17674 */
17675 void
17678 {
17680 {
17682 {
17685 /*FALLTHROUGH*/
17705 }
17707 }
17708 }
17710 /*
17711 * Set the value of a variable to NULL without freeing items.
17712 */
17713 static void
17716 {
17719 }
17721 /*
17722 * Get the number value of a variable.
17723 * If it is a String variable, uses vim_str2nr().
17724 * For incompatible types, return 0.
17725 * get_tv_number_chk() is similar to get_tv_number(), but informs the
17726 * caller of incompatible types: it sets *denote to TRUE if "denote"
17727 * is not NULL or returns -1 otherwise.
17728 */
17729 static long
17732 {
17736 }
17738 long
17742 {
17746 {
17766 }
17769 else
17772 }
17774 /*
17775 * Get the lnum from the first argument.
17776 * Also accepts ".", "$", etc., but that only works for the current buffer.
17777 * Returns -1 on error.
17778 */
17779 static linenr_T
17782 {
17783 typval_T rettv;
17784 linenr_T lnum;
17788 {
17793 }
17795 }
17797 /*
17798 * Get the lnum from the first argument.
17799 * Also accepts "$", then "buf" is used.
17800 * Returns 0 on error.
17801 */
17802 static linenr_T
17806 {
17813 }
17815 /*
17816 * Get the string value of a variable.
17817 * If it is a Number variable, the number is converted into a string.
17818 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
17819 * get_tv_string_buf() uses a given buffer.
17820 * If the String variable has never been set, return an empty string.
17821 * Never returns NULL;
17822 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
17823 * NULL on error.
17824 */
17828 {
17832 }
17838 {
17842 }
17844 char_u *
17847 {
17851 }
17857 {
17859 {
17879 }
17881 }
17883 /*
17884 * Find variable "name" in the list of variables.
17885 * Return a pointer to it if found, NULL if not found.
17886 * Careful: "a:0" variables don't have a name.
17887 * When "htp" is not NULL we are writing to the variable, set "htp" to the
17888 * hashtab_T used.
17889 */
17894 {
17904 }
17906 /*
17907 * Find variable "varname" in hashtab "ht".
17908 * Returns NULL if not found.
17909 */
17915 {
17919 {
17920 /* Must be something like "s:", otherwise "ht" would be NULL. */
17922 {
17928 #ifdef FEAT_WINDOWS
17930 #endif
17935 }
17937 }
17941 {
17942 /* For global variables we may try auto-loading the script. If it
17943 * worked find the variable again. Don't auto-load a script if it was
17944 * loaded already, otherwise it would be loaded every time when
17945 * checking if a function name is a Funcref variable. */
17951 }
17953 }
17955 /*
17956 * Find the hashtab used for a variable name.
17957 * Set "varname" to the start of name without ':'.
17958 */
17963 {
17967 {
17968 /* The name must not start with a colon or #. */
17973 /* "version" is "v:version" in all scopes */
17981 }
17985 /* There must be no ':' or '#' in the rest of the name, unless g: is used
17986 */
17994 #ifdef FEAT_WINDOWS
17997 #endif
18008 }
18010 /*
18011 * Get the string value of a (global/local) variable.
18012 * Returns NULL when it doesn't exist.
18013 */
18014 char_u *
18017 {
18024 }
18026 /*
18027 * Allocate a new hashtab for a sourced script. It will be used while
18028 * sourcing this script and when executing functions defined in the script.
18029 */
18030 void
18032 scid_T id;
18033 {
18039 {
18040 /* Re-allocating ga_data means that an ht_array pointing to
18041 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18042 * at its init value. Also reset "v_dict", it's always the same. */
18044 {
18050 }
18053 {
18057 }
18058 }
18059 }
18061 /*
18062 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18063 * point to it.
18064 */
18065 void
18069 {
18077 }
18079 /*
18080 * Clean up a list of internal variables.
18081 * Frees all allocated variables and the value they contain.
18082 * Clears hashtab "ht", does not free it.
18083 */
18084 void
18087 {
18089 }
18091 /*
18092 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18093 */
18094 static void
18098 {
18106 {
18108 {
18111 /* Free the variable. Don't remove it from the hashtab,
18112 * ht_array might change then. hash_clear() takes care of it
18113 * later. */
18119 }
18120 }
18123 }
18125 /*
18126 * Delete a variable from hashtab "ht" at item "hi".
18127 * Clear the variable value and free the dictitem.
18128 */
18129 static void
18133 {
18139 }
18141 /*
18142 * List the value of one internal variable.
18143 */
18144 static void
18149 {
18158 }
18160 static void
18167 {
18168 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18180 {
18184 }
18186 {
18190 }
18191 else
18199 {
18202 }
18203 }
18205 /*
18206 * Set variable "name" to value in "tv".
18207 * If the variable already exists, the value is updated.
18208 * Otherwise the variable is created.
18209 */
18210 static void
18215 {
18222 {
18226 {
18229 }
18231 {
18233 name);
18235 }
18236 }
18240 {
18243 }
18247 {
18248 /* existing variable, need to clear the value */
18257 {
18260 }
18262 /*
18263 * Handle setting internal v: variables separately: we don't change
18264 * the type.
18265 */
18267 {
18269 {
18273 else
18274 {
18275 /* Take over the string to avoid an extra alloc/free. */
18278 }
18279 }
18282 else
18285 }
18288 }
18290 {
18291 /* Can't add "v:" variable. */
18293 {
18296 }
18298 /* Make sure the variable name is valid. */
18302 {
18305 }
18313 {
18316 }
18318 }
18322 else
18323 {
18327 }
18328 }
18330 /*
18331 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
18332 * Also give an error message.
18333 */
18334 static int
18338 {
18340 {
18343 }
18345 {
18348 }
18350 }
18352 /*
18353 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
18354 * Also give an error message.
18355 */
18356 static int
18360 {
18362 {
18365 }
18367 }
18369 /*
18370 * Return TRUE if typeval "tv" is set to be locked (immutable).
18371 * Also give an error message, using "name".
18372 */
18373 static int
18377 {
18379 {
18383 }
18385 {
18389 }
18391 }
18393 /*
18394 * Copy the values from typval_T "from" to typval_T "to".
18395 * When needed allocates string or increases reference count.
18396 * Does not make a copy of a list or dict but copies the reference!
18397 */
18398 static void
18402 {
18406 {
18414 else
18415 {
18419 }
18424 else
18425 {
18428 }
18433 else
18434 {
18437 }
18442 }
18443 }
18445 /*
18446 * Make a copy of an item.
18447 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
18448 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
18449 * reference to an already copied list/dict can be used.
18450 * Returns FAIL or OK.
18451 */
18452 static int
18458 {
18463 {
18466 }
18470 {
18482 {
18483 /* use the copy made earlier */
18486 }
18487 else
18498 {
18499 /* use the copy made earlier */
18502 }
18503 else
18511 }
18514 }
18516 /*
18517 * ":echo expr1 ..." print each argument separated with a space, add a
18518 * newline at the end.
18519 * ":echon expr1 ..." print each argument plain.
18520 */
18521 void
18524 {
18526 typval_T rettv;
18536 {
18539 {
18540 /*
18541 * Report the invalid expression unless the expression evaluation
18542 * has been cancelled due to an aborting error, an interrupt, or an
18543 * exception.
18544 */
18548 }
18550 {
18552 {
18554 /* Call msg_start() after eval1(), evaluating the expression
18555 * may cause a message to appear. */
18558 }
18564 {
18566 {
18568 {
18569 /* remove any text still there from the command */
18572 }
18574 }
18575 else
18576 {
18577 #ifdef FEAT_MBYTE
18579 {
18584 }
18585 else
18586 #endif
18588 }
18589 }
18591 }
18594 }
18599 else
18600 {
18601 /* remove text that may still be there from the command */
18606 }
18607 }
18609 /*
18610 * ":echohl {name}".
18611 */
18612 void
18615 {
18621 else
18623 }
18625 /*
18626 * ":execute expr1 ..." execute the result of an expression.
18627 * ":echomsg expr1 ..." Print a message
18628 * ":echoerr expr1 ..." Print an error
18629 * Each gets spaces around each argument and a newline at the end for
18630 * echo commands
18631 */
18632 void
18635 {
18637 typval_T rettv;
18640 garray_T ga;
18649 {
18652 {
18653 /*
18654 * Report the invalid expression unless the expression evaluation
18655 * has been cancelled due to an aborting error, an interrupt, or an
18656 * exception.
18657 */
18662 }
18665 {
18669 {
18673 }
18678 }
18682 }
18685 {
18687 {
18690 }
18692 {
18693 /* We don't want to abort following commands, restore did_emsg. */
18698 }
18702 }
18710 }
18712 /*
18713 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
18714 * "arg" points to the "&" or '+' when called, to "option" when returning.
18715 * Returns NULL when no option name found. Otherwise pointer to the char
18716 * after the option name.
18717 */
18722 {
18727 {
18730 }
18732 {
18735 }
18736 else
18745 else
18749 }
18751 /*
18752 * ":function"
18753 */
18754 void
18757 {
18766 garray_T newargs;
18767 garray_T newlines;
18776 funcdict_T fudi;
18784 /*
18785 * ":function" without argument: list functions.
18786 */
18788 {
18790 {
18793 {
18795 {
18800 }
18801 }
18802 }
18805 }
18807 /*
18808 * ":function /pat": list functions matching pattern.
18809 */
18811 {
18814 {
18815 regmatch_T regmatch;
18822 {
18827 {
18829 {
18835 }
18836 }
18837 }
18838 }
18843 }
18845 /*
18846 * Get the function name. There are these situations:
18847 * func normal function name
18848 * "name" == func, "fudi.fd_dict" == NULL
18849 * dict.func new dictionary entry
18850 * "name" == NULL, "fudi.fd_dict" set,
18851 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
18852 * dict.func existing dict entry with a Funcref
18853 * "name" == func, "fudi.fd_dict" set,
18854 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18855 * dict.func existing dict entry that's not a Funcref
18856 * "name" == NULL, "fudi.fd_dict" set,
18857 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
18858 */
18863 {
18864 /*
18865 * Return on an invalid expression in braces, unless the expression
18866 * evaluation has been cancelled due to an aborting error, an
18867 * interrupt, or an exception.
18868 */
18870 {
18875 }
18876 else
18878 }
18880 /* An error in a function call during evaluation of an expression in magic
18881 * braces should not cause the function not to be defined. */
18885 /*
18886 * ":function func" with only function name: list function.
18887 */
18889 {
18891 {
18894 }
18899 {
18902 {
18905 {
18917 }
18919 {
18922 }
18923 }
18924 else
18926 }
18928 }
18930 /*
18931 * ":function name(arg1, arg2)" Define function.
18932 */
18935 {
18937 {
18940 }
18941 /* attempt to continue by skipping some text */
18944 }
18951 {
18952 /* Check the name of the function. Unless it's a dictionary function
18953 * (that we are overwriting). */
18956 else
18960 {
18963 else
18970 }
18971 }
18973 /*
18974 * Isolate the arguments: "arg1, arg2, ...)"
18975 */
18977 {
18979 {
18983 }
18984 else
18985 {
18992 {
18996 }
19009 else
19011 }
19014 {
19018 }
19019 }
19022 /* find extra arguments "range", "dict" and "abort" */
19024 {
19027 {
19030 }
19032 {
19035 }
19037 {
19040 }
19041 else
19043 }
19045 /* When there is a line break use what follows for the function body.
19046 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19052 /*
19053 * Read the body of the function, until ":endfunction" is found.
19054 */
19056 {
19057 /* Check if the function already exists, don't let the user type the
19058 * whole function before telling him it doesn't work! For a script we
19059 * need to skip the body to be able to find what follows. */
19061 {
19066 }
19073 }
19078 {
19084 {
19085 /* Use eap->arg, split up in parts by line breaks. */
19090 else
19091 {
19094 }
19095 }
19098 else
19103 {
19106 }
19108 /* Detect line continuation: sourcing_lnum increased more than one. */
19111 else
19115 {
19116 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19117 * don't check for ":endfunc". */
19119 {
19122 }
19123 }
19124 else
19125 {
19126 /* skip ':' and blanks*/
19128 ;
19130 /* Check for "endfunction". */
19132 {
19136 }
19138 /* Increase indent inside "if", "while", "for" and "try", decrease
19139 * at "end". */
19148 /* Check for defining a function inside this function. */
19150 {
19155 {
19158 {
19161 }
19162 }
19163 }
19165 /* Check for ":append" or ":insert". */
19173 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19186 ))
19187 {
19188 /* ":python <<" continues until a dot, like ":append" */
19192 else
19194 }
19195 }
19197 /* Add the line to the function. */
19199 {
19203 }
19205 /* Copy the line to newly allocated memory. get_one_sourceline()
19206 * allocates 250 bytes per line, this saves 80% on average. The cost
19207 * is an extra alloc/free. */
19210 {
19214 }
19218 /* Add NULL lines for continuation lines, so that the line count is
19219 * equal to the index in the growarray. */
19223 /* Check for end of eap->arg. */
19226 }
19228 /* Don't define the function when skipping commands or when an error was
19229 * detected. */
19233 /*
19234 * If there are no errors, add the function
19235 */
19237 {
19240 {
19242 name);
19244 }
19248 {
19250 {
19253 }
19255 {
19257 name);
19259 }
19260 /* redefine existing function */
19265 }
19266 }
19267 else
19268 {
19273 {
19276 }
19278 {
19279 /* Can't add a function to a locked dictionary */
19282 }
19283 /* Can't change an existing function if it is locked */
19287 /* Give the function a sequential number. Can only be used with a
19288 * Funcref! */
19294 }
19297 {
19299 {
19303 /* Check that the autoload name matches the script name. */
19306 {
19309 {
19317 }
19318 }
19320 {
19323 }
19324 }
19331 {
19333 {
19334 /* add new dict entry */
19337 {
19340 }
19342 {
19346 }
19347 }
19348 else
19349 /* overwrite existing dict entry */
19356 /* behave like "dict" was used */
19358 }
19360 /* insert the new function in the function list */
19363 }
19366 #ifdef FEAT_PROFILE
19373 #endif
19380 erret:
19383 ret_free:
19388 }
19390 /*
19391 * Get a function name, translating "<SID>" and "<SNR>".
19392 * Also handles a Funcref in a List or Dictionary.
19393 * Returns the function name in allocated memory, or NULL for failure.
19394 * flags:
19395 * TFN_INT: internal function name OK
19396 * TFN_QUIET: be quiet
19397 * Advances "pp" to just after the function name (if no error).
19398 */
19405 {
19412 lval_T lv;
19418 /* Check for hard coded <SNR>: already translated function ID (from a user
19419 * command). */
19422 {
19426 }
19428 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
19429 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
19437 {
19441 }
19443 {
19444 /*
19445 * Report an invalid expression in braces, unless the expression
19446 * evaluation has been cancelled due to an aborting error, an
19447 * interrupt, or an exception.
19448 */
19450 {
19453 }
19454 else
19457 }
19460 {
19462 {
19467 }
19469 {
19472 }
19473 else
19474 {
19478 else
19481 }
19483 }
19486 {
19487 /* Error found, but continue after the function name. */
19490 }
19492 /* Check if the name is a Funcref. If so, use the value. */
19494 {
19499 }
19500 else
19501 {
19506 }
19508 {
19512 }
19515 {
19519 {
19520 /* When there was "s:" already or the name expanded to get a
19521 * leading "s:" then remove it. */
19525 }
19526 }
19527 else
19528 {
19532 }
19534 /*
19535 * Copy the function name to allocated memory.
19536 * Accept <SID>name() inside a script, translate into <SNR>123_name().
19537 * Accept <SNR>123_name() outside a script.
19538 */
19542 {
19546 {
19547 /* It's "s:" or "<SID>" */
19549 {
19552 }
19555 }
19556 }
19558 {
19561 }
19564 {
19566 {
19572 }
19575 }
19578 theend:
19581 }
19583 /*
19584 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
19585 * Return 2 if "p" starts with "s:".
19586 * Return 0 otherwise.
19587 */
19588 static int
19591 {
19598 }
19600 /*
19601 * Return TRUE if "p" starts with "<SID>" or "s:".
19602 * Only works if eval_fname_script() returned non-zero for "p"!
19603 */
19604 static int
19607 {
19609 }
19611 /*
19612 * List the head of the function: "name(arg1, arg2)".
19613 */
19614 static void
19618 {
19626 {
19629 }
19630 else
19634 {
19638 }
19640 {
19644 }
19649 }
19651 /*
19652 * Find a function by name, return pointer to it in ufuncs.
19653 * Return NULL for unknown function.
19654 */
19658 {
19665 }
19667 #if defined(EXITFREE) || defined(PROTO)
19668 void
19670 {
19673 /* Need to start all over every time, because func_free() may change the
19674 * hash table. */
19678 {
19681 }
19682 }
19683 #endif
19685 /*
19686 * Return TRUE if a function "name" exists.
19687 */
19688 static int
19691 {
19699 /* Only accept "funcname", "funcname ", "funcname (..." and
19700 * "funcname(...", not "funcname!...". */
19702 {
19705 else
19707 }
19710 }
19712 /*
19713 * Return TRUE if "name" looks like a builtin function name: starts with a
19714 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
19715 */
19716 static int
19719 {
19722 }
19724 #if defined(FEAT_PROFILE) || defined(PROTO)
19725 /*
19726 * Start profiling function "fp".
19727 */
19728 static void
19731 {
19750 }
19752 /*
19753 * Dump the profiling results for all functions in file "fd".
19754 */
19755 void
19758 {
19770 {
19772 {
19776 {
19782 else
19786 else
19794 {
19800 }
19802 }
19803 }
19804 }
19807 {
19809 prof_total_cmp);
19812 prof_self_cmp);
19814 }
19815 }
19817 static void
19824 {
19831 {
19834 prefer_self);
19837 else
19839 }
19841 }
19843 /*
19844 * Print the count and times for one function or function line.
19845 */
19846 static void
19853 {
19855 {
19859 else
19863 else
19865 }
19866 else
19868 }
19870 /*
19871 * Compare function for total time sorting.
19872 */
19873 static int
19874 #ifdef __BORLANDC__
19875 _RTLENTRYF
19876 #endif
19880 {
19886 }
19888 /*
19889 * Compare function for self time sorting.
19890 */
19891 static int
19892 #ifdef __BORLANDC__
19893 _RTLENTRYF
19894 #endif
19898 {
19904 }
19906 #endif
19908 /*
19909 * If "name" has a package name try autoloading the script for it.
19910 * Return TRUE if a package was loaded.
19911 */
19912 static int
19916 {
19922 /* If there is no '#' after name[0] there is no package name. */
19929 /* Find the name in the list of previously loaded package names. Skip
19930 * "autoload/", it's always the same. */
19936 else
19937 {
19938 /* Remember the name if it wasn't loaded already. */
19940 {
19943 }
19945 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
19948 }
19952 }
19954 /*
19955 * Return the autoload script name for a function or variable name.
19956 * Returns NULL when out of memory.
19957 */
19961 {
19965 /* Get the script file name: replace '#' with '/', append ".vim". */
19976 }
19978 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
19980 /*
19981 * Function given to ExpandGeneric() to obtain the list of user defined
19982 * function names.
19983 */
19984 char_u *
19988 {
19994 {
19997 }
19999 {
20011 {
20015 }
20017 }
20019 }
20023 /*
20024 * Copy the function name of "fp" to buffer "buf".
20025 * "buf" must be able to hold the function name plus three bytes.
20026 * Takes care of script-local function names.
20027 */
20028 static void
20032 {
20034 {
20037 }
20038 else
20040 }
20042 /*
20043 * ":delfunction {name}"
20044 */
20045 void
20048 {
20052 funcdict_T fudi;
20058 {
20062 }
20064 {
20068 }
20078 {
20080 {
20083 }
20085 {
20088 }
20091 {
20092 /* Delete the dict item that refers to the function, it will
20093 * invoke func_unref() and possibly delete the function. */
20095 }
20096 else
20098 }
20099 }
20101 /*
20102 * Free a function and remove it from the list of functions.
20103 */
20104 static void
20107 {
20110 /* clear this function */
20113 #ifdef FEAT_PROFILE
20117 #endif
20119 /* remove the function from the function hashtable */
20123 else
20127 }
20129 /*
20130 * Unreference a Function: decrement the reference count and free it when it
20131 * becomes zero. Only for numbered functions.
20132 */
20133 static void
20136 {
20140 {
20145 {
20146 /* Only delete it when it's not being used. Otherwise it's done
20147 * when "uf_calls" becomes zero. */
20150 }
20151 }
20152 }
20154 /*
20155 * Count a reference to a Function.
20156 */
20157 static void
20160 {
20164 {
20168 else
20170 }
20171 }
20173 /*
20174 * Call a user function.
20175 */
20176 static void
20185 {
20187 linenr_T save_sourcing_lnum;
20188 scid_T save_current_SID;
20189 funccall_T fc;
20198 #ifdef FEAT_PROFILE
20199 proftime_T wait_start;
20200 proftime_T call_start;
20201 #endif
20203 /* If depth of calling is getting too high, don't execute the function */
20205 {
20210 }
20223 /* Check if this function has a breakpoint. */
20227 /*
20228 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
20229 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
20230 * each argument variable and saves a lot of time.
20231 */
20232 /*
20233 * Init l: variables.
20234 */
20237 {
20238 /* Set l:self to "selfdict". Use "name" to avoid a warning from
20239 * some compiler that checks the destination size. */
20249 }
20251 /*
20252 * Init a: variables.
20253 * Set a:0 to "argcount".
20254 * Set a:000 to a list with room for the "..." arguments.
20255 */
20270 /*
20271 * Set a:firstline to "firstline" and a:lastline to "lastline".
20272 * Set a:name to named arguments.
20273 * Set a:N to the "..." arguments.
20274 */
20280 {
20283 /* named argument a:name */
20285 else
20286 {
20287 /* "..." argument a:1, a:2, etc. */
20290 }
20292 {
20295 }
20296 else
20297 {
20303 }
20307 /* Note: the values are copied directly to avoid alloc/free.
20308 * "argvars" must have VAR_FIXED for v_lock. */
20313 {
20317 }
20318 }
20320 /* Don't redraw while executing the function. */
20328 {
20332 else
20337 {
20343 {
20351 {
20356 else
20357 {
20360 {
20364 }
20365 }
20366 }
20368 }
20373 }
20374 }
20375 #ifdef FEAT_PROFILE
20377 {
20382 {
20386 }
20388 }
20389 #endif
20396 /* call do_cmdline() to execute the lines */
20402 /* when the function was aborted because of an error, return -1 */
20404 {
20408 }
20410 #ifdef FEAT_PROFILE
20413 {
20419 {
20422 }
20423 }
20424 #endif
20426 /* when being verbose, mention the return value */
20428 {
20437 else
20438 {
20444 /* The value may be very long. Skip the middle part, so that we
20445 * have some idea how it starts and ends. smsg() would always
20446 * truncate it at the end. */
20449 {
20453 }
20454 }
20459 }
20465 #ifdef FEAT_PROFILE
20468 #endif
20471 {
20480 }
20485 /* The a: variables typevals were not alloced, only free the allocated
20486 * variables. */
20491 }
20493 /*
20494 * Add a number variable "name" to dict "dp" with value "nr".
20495 */
20496 static void
20501 varnumber_T nr;
20502 {
20509 }
20511 /*
20512 * ":return [expr]"
20513 */
20514 void
20517 {
20519 typval_T rettv;
20523 {
20526 }
20534 {
20537 else
20539 }
20540 /* It's safer to return also on error. */
20542 {
20543 /*
20544 * Return unless the expression evaluation has been cancelled due to an
20545 * aborting error, an interrupt, or an exception.
20546 */
20549 }
20551 /* When skipping or the return gets pending, advance to the next command
20552 * in this line (!returning). Otherwise, ignore the rest of the line.
20553 * Following lines will be ignored by get_func_line(). */
20561 }
20563 /*
20564 * Return from a function. Possibly makes the return pending. Also called
20565 * for a pending return at the ":endtry" or after returning from an extra
20566 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
20567 * when called due to a ":return" command. "rettv" may point to a typval_T
20568 * with the return rettv. Returns TRUE when the return can be carried out,
20569 * FALSE when the return gets pending.
20570 */
20571 int
20577 {
20582 /* Undo the return. */
20585 /*
20586 * Cleanup (and inactivate) conditionals, but stop when a try conditional
20587 * not in its finally clause (which then is to be executed next) is found.
20588 * In this case, make the ":return" pending for execution at the ":endtry".
20589 * Otherwise, return normally.
20590 */
20593 {
20597 /* A pending return again gets pending. "rettv" points to an
20598 * allocated variable with the rettv of the original ":return"'s
20599 * argument if present or is NULL else. */
20601 else
20602 {
20603 /* When undoing a return in order to make it pending, get the stored
20604 * return rettv. */
20609 {
20610 /* Store the value of the pending return. */
20613 else
20615 }
20616 else
20620 {
20621 /* The pending return value could be overwritten by a ":return"
20622 * without argument in a finally clause; reset the default
20623 * return value. */
20626 }
20627 }
20629 }
20630 else
20631 {
20634 /* If the return is carried out now, store the return value. For
20635 * a return immediately after reanimation, the value is already
20636 * there. */
20638 {
20643 }
20644 }
20647 }
20649 /*
20650 * Free the variable with a pending return value.
20651 */
20652 void
20655 {
20657 }
20659 /*
20660 * Generate a return command for producing the value of "rettv". The result
20661 * is an allocated string. Used by report_pending() for verbose messages.
20662 */
20663 char_u *
20666 {
20682 }
20684 /*
20685 * Get next function line.
20686 * Called by do_cmdline() to get the next line.
20687 * Returns allocated string, or NULL for end of function.
20688 */
20689 /* ARGSUSED */
20690 char_u *
20695 {
20701 /* If breakpoints have been added/deleted need to check for it. */
20703 {
20705 sourcing_lnum);
20707 }
20708 #ifdef FEAT_PROFILE
20711 #endif
20717 else
20718 {
20719 /* Skip NULL lines (continuation lines). */
20725 else
20726 {
20729 #ifdef FEAT_PROFILE
20732 #endif
20733 }
20734 }
20736 /* Did we encounter a breakpoint? */
20738 {
20740 /* Find next breakpoint. */
20742 sourcing_lnum);
20744 }
20747 }
20749 #if defined(FEAT_PROFILE) || defined(PROTO)
20750 /*
20751 * Called when starting to read a function line.
20752 * "sourcing_lnum" must be correct!
20753 * When skipping lines it may not actually be executed, but we won't find out
20754 * until later and we need to store the time now.
20755 */
20756 void
20759 {
20765 {
20767 /* Skip continuation lines. */
20774 }
20775 }
20777 /*
20778 * Called when actually executing a function line.
20779 */
20780 void
20783 {
20789 }
20791 /*
20792 * Called when done with a function line.
20793 */
20794 void
20797 {
20802 {
20804 {
20811 }
20813 }
20814 }
20815 #endif
20817 /*
20818 * Return TRUE if the currently active function should be ended, because a
20819 * return was encountered or an error occured. Used inside a ":while".
20820 */
20821 int
20824 {
20827 /* Ignore the "abort" flag if the abortion behavior has been changed due to
20828 * an error inside a try conditional. */
20831 }
20833 /*
20834 * return TRUE if cookie indicates a function which "abort"s on errors.
20835 */
20836 int
20839 {
20841 }
20843 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
20845 {
20846 VAR_FLAVOUR_DEFAULT,
20847 VAR_FLAVOUR_SESSION,
20848 VAR_FLAVOUR_VIMINFO
20853 static var_flavour_T
20856 {
20860 {
20865 }
20866 else
20868 }
20869 #endif
20871 #if defined(FEAT_VIMINFO) || defined(PROTO)
20872 /*
20873 * Restore global vars that start with a capital from the viminfo file
20874 */
20875 int
20879 {
20882 typval_T tv;
20885 {
20888 {
20895 {
20897 {
20901 }
20902 else
20903 {
20906 }
20910 }
20911 }
20912 }
20915 }
20917 /*
20918 * Write global vars that start with a capital to the viminfo file
20919 */
20920 void
20923 {
20939 {
20941 {
20945 {
20947 {
20951 }
20957 }
20958 }
20959 }
20960 }
20961 #endif
20963 #if defined(FEAT_SESSION) || defined(PROTO)
20964 int
20967 {
20975 {
20977 {
20983 {
20984 /* Escape special characters with a backslash. Turn a LF and
20985 * CR into \n and \r. */
20999 p,
21003 {
21006 }
21008 }
21009 }
21010 }
21012 }
21013 #endif
21015 /*
21016 * Display script name where an item was last set.
21017 * Should only be invoked when 'verbose' is non-zero.
21018 */
21019 void
21021 scid_T scriptID;
21022 {
21026 {
21029 {
21035 }
21036 }
21037 }
21041 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21044 #ifdef WIN3264
21045 /*
21046 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21047 */
21049 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21052 /*
21053 * Get the short pathname of a file.
21054 * Returns 1 on success. *fnamelen is 0 for nonexistent path.
21055 */
21056 static int
21061 {
21069 {
21070 /* If that doesn't work (not enough space), then save the string
21071 * and try again with a new buffer big enough
21072 */
21082 /* Really should always succeed, as the buffer is big enough */
21083 }
21087 }
21089 /*
21090 * Create a short path name. Returns the length of the buffer it needs.
21091 * Doesn't copy over the end of the buffer passed in.
21092 */
21093 static int
21098 {
21100 char_u ch;
21103 /* Make a copy */
21113 {
21117 }
21119 do
21120 {
21121 /* Go back one path-separator */
21123 {
21127 }
21131 /* Remember the character that is about to be splatted */
21135 /* Try it in situ */
21138 {
21141 }
21146 {
21147 /* Remember the length of the new string. */
21151 {
21152 /* If there's not enough space in the currently allocated string,
21153 * then copy it to a buffer big enough.
21154 */
21158 }
21159 else
21160 {
21161 /* Transfer pbuf2 to being the main buffer (it's big enough) */
21166 }
21167 /* Concat the next bit */
21170 }
21174 }
21176 /*
21177 * Get a pathname for a partial path.
21178 */
21179 static int
21184 {
21190 /* Count up the path seperators from the RHS.. so we know which part
21191 * of the path to return.
21192 */
21198 /* Need full path first (use expand_env() to remove a "~/") */
21202 else
21211 {
21212 /* Don't have a valid filename, so shorten the rest of the
21213 * path if we can. This CAN give us invalid 8.3 filenames, but
21214 * there's not a lot of point in guessing what it might be.
21215 */
21219 }
21221 /* Count the paths backward to find the beginning of the desired string. */
21223 {
21224 #ifdef FEAT_MBYTE
21227 #endif
21229 {
21232 else
21233 sepcount --;
21234 }
21235 }
21237 {
21241 else
21243 }
21244 else
21247 /* Copy in the string - p indexes into tfname - allocated at pbuf */
21254 }
21257 /*
21258 * Adjust a filename, according to a string of modifiers.
21259 * *fnamep must be NUL terminated when called. When returning, the length is
21260 * determined by *fnamelen.
21261 * Returns valid flags.
21262 * When there is an error, *fnamep is set to NULL.
21263 */
21264 int
21271 {
21278 #ifdef WIN3264
21280 #endif
21282 repeat:
21283 /* ":p" - full path/file_name */
21285 {
21291 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
21293 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
21295 # ifdef BACKSLASH_IN_FILENAME
21297 # endif
21300 #endif
21301 )
21302 {
21308 }
21310 /* When "/." or "/.." is used: force expansion to get rid of it. */
21312 {
21320 }
21322 /* FullName_save() is slow, don't use it when not needed. */
21324 {
21330 }
21332 /* Append a path separator to a directory. */
21334 {
21335 /* Make room for one or two extra characters. */
21342 }
21343 }
21345 /* ":." - path relative to the current directory */
21346 /* ":~" - path relative to the home directory */
21347 /* ":8" - shortname path - postponed till after */
21350 {
21353 {
21354 #ifdef WIN3264
21356 #endif
21358 }
21360 /* Need full path first (use expand_env() to remove a "~/") */
21362 {
21365 else
21367 }
21368 else
21374 {
21376 {
21380 {
21383 {
21387 }
21388 }
21389 }
21390 else
21391 {
21393 /* Only replace it when it starts with '~' */
21395 {
21398 {
21402 }
21403 }
21404 }
21406 }
21407 }
21412 /* ":h" - head, remove "/file_name", can be repeated */
21413 /* Don't remove the first "/" or "c:\" */
21415 {
21422 #ifdef VMS
21425 #endif
21427 {
21428 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
21435 }
21436 else
21437 {
21440 }
21441 }
21443 /* ":8" - shortname */
21445 {
21447 #ifdef WIN3264
21449 #endif
21450 }
21452 #ifdef WIN3264
21453 /* Check shortname after we have done 'heads' and before we do 'tails'
21454 */
21456 {
21458 /* Copy the string if it is shortened by :h */
21460 {
21466 }
21468 /* Split into two implementations - makes it easier. First is where
21469 * there isn't a full name already, second is where there is.
21470 */
21472 {
21475 }
21476 else
21477 {
21480 /* Simple case, already have the full-name
21481 * Nearly always shorter, so try first time. */
21487 {
21488 /* Couldn't find the filename.. search the paths.
21489 */
21493 }
21495 }
21496 }
21499 /* ":t" - tail, just the basename */
21501 {
21505 }
21507 /* ":e" - extension, can be repeated */
21508 /* ":r" - root, without extension, can be repeated */
21511 {
21512 /* find a '.' in the tail:
21513 * - for second :e: before the current fname
21514 * - otherwise: The last '.'
21515 */
21518 else
21524 {
21526 {
21529 #ifdef VMS
21530 /* cut version from the extension */
21537 #endif
21538 }
21541 }
21543 {
21546 }
21548 }
21550 /* ":s?pat?foo?" - substitute */
21551 /* ":gs?pat?foo?" - global substitute */
21555 {
21566 {
21569 }
21573 {
21574 /* find end of pattern */
21577 {
21580 {
21582 /* find end of substitution */
21585 {
21589 {
21593 {
21599 }
21600 }
21603 }
21605 }
21606 }
21607 /* after using ":s", repeat all the modifiers */
21610 }
21611 }
21614 }
21616 /*
21617 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
21618 * "flags" can be "g" to do a global substitute.
21619 * Returns an allocated string, NULL for error.
21620 */
21621 char_u *
21627 {
21629 regmatch_T regmatch;
21633 garray_T ga;
21637 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
21648 {
21651 {
21652 /*
21653 * Get some space for a temporary buffer to do the substitution
21654 * into. It will contain:
21655 * - The text up to where the match is.
21656 * - The substituted text.
21657 * - The text after the match.
21658 */
21662 {
21665 }
21667 /* copy the text up to where the match is */
21670 /* add the substituted text */
21674 /* avoid getting stuck on a match with an empty string */
21676 {
21681 }
21682 else
21683 {
21687 }
21690 }
21696 }
21703 }