| blob | c06b363d2464eb93138bce82f6a0420201b37f92 |
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(WIN16) || defined(WIN32) || defined(_WIN64)
15 #endif
19 #if defined(FEAT_EVAL) || defined(PROTO)
21 #ifdef AMIGA
23 #endif
25 #ifdef MACOS
27 #endif
29 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
30 # include <math.h>
31 #endif
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. */
112 /*
113 * All user-defined global variables are stored in dictionary "globvardict".
114 * "globvars_var" is the variable that is used for "g:".
115 */
118 #define globvarht globvardict.dv_hashtab
120 /*
121 * Old Vim variables such as "v:version" are also available without the "v:".
122 * Also in functions. We need a special hashtable for them.
123 */
126 /*
127 * When recursively copying lists and dicts we need to remember which ones we
128 * have done to avoid endless recursiveness. This unique ID is used for that.
129 */
132 /*
133 * Array to hold the hashtab with variables local to each sourced script.
134 * Each item holds a variable (nameless) that points to the dict_T.
135 */
137 {
138 dictitem_T sv_var;
139 dict_T sv_dict;
143 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
144 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
148 /* Values for trans_function_name() argument: */
152 /*
153 * Structure to hold info for a user function.
154 */
157 struct ufunc
158 {
164 #ifdef FEAT_PROFILE
166 /* profiling the function as a whole */
171 /* profiling the function per line */
180 #endif
182 used for s: variables */
185 start with <SNR>123_ (<SNR> is K_SPECIAL
186 KS_EXTRA KE_SNR) */
187 };
189 /* function flags */
194 /*
195 * All user-defined functions are found in this hashtable.
196 */
199 /* The names of packages that once were loaded are remembered. */
202 /* list heads for garbage collection */
206 /* From user function to hashitem and back. */
208 #define UF2HIKEY(fp) ((fp)->uf_name)
209 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
210 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
212 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
213 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
219 /* structure to hold info for a function that is currently being executed. */
222 struct funccall_S
223 {
228 {
242 #ifdef FEAT_PROFILE
244 #endif
246 };
248 /*
249 * Info used by a ":for" loop.
250 */
252 {
259 /*
260 * Struct used by trans_function_name()
261 */
263 {
270 /*
271 * Array to hold the value of v: variables.
272 * The value is in a dictitem, so that it can also be used in the v: scope.
273 * The reason to use this table anyway is for very quick access to the
274 * variables with the VV_ defines.
275 */
278 /* values for vv_flags: */
283 #define VV_NAME(s, t) s, {{t}}, {0}
285 static struct vimvar
286 {
292 {
293 /*
294 * The order here must match the VV_ defines in vim.h!
295 * Initializing a union does not work, leave tv.vval empty to get zero's.
296 */
351 };
353 /* shorthand */
354 #define vv_type vv_di.di_tv.v_type
355 #define vv_nr vv_di.di_tv.vval.v_number
356 #define vv_float vv_di.di_tv.vval.v_float
357 #define vv_str vv_di.di_tv.vval.v_string
358 #define vv_tv vv_di.di_tv
360 /*
361 * The v: variables are stored in dictionary "vimvardict".
362 * "vimvars_var" is the variable that is used for the "l:" scope.
363 */
366 #define vimvarht vimvardict.dv_hashtab
370 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
371 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
372 #endif
373 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
380 #ifdef FEAT_WINDOWS
382 #endif
387 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
389 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
391 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
456 #ifdef FEAT_FLOAT
458 #endif
462 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));
463 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));
467 #ifdef FEAT_FLOAT
469 #endif
475 #ifdef FEAT_FLOAT
477 #endif
489 #ifdef FEAT_FLOAT
491 #endif
497 #if defined(FEAT_INS_EXPAND)
501 #endif
504 #ifdef FEAT_FLOAT
506 #endif
529 #ifdef FEAT_FLOAT
532 #endif
604 #ifdef FEAT_FLOAT
606 #endif
619 #ifdef vim_mkdir
621 #endif
626 #ifdef FEAT_FLOAT
628 #endif
646 #ifdef FEAT_FLOAT
648 #endif
668 #ifdef FEAT_FLOAT
670 #endif
676 #ifdef FEAT_FLOAT
679 #endif
681 #ifdef HAVE_STRFTIME
683 #endif
707 #ifdef FEAT_FLOAT
709 #endif
730 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
733 valid character */
734 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
754 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
769 #ifdef FEAT_PROFILE
771 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
772 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
773 static int
774 # ifdef __BORLANDC__
775 _RTLENTRYF
776 # endif
778 static int
779 # ifdef __BORLANDC__
780 _RTLENTRYF
781 # endif
783 #endif
790 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));
798 /* Character used as separated in autoload function/variable names. */
801 /*
802 * Initialize the global and v: variables.
803 */
804 void
806 {
816 {
823 else
826 /* add to v: scope dict, unless the value is not always available */
830 /* add to compat scope dict */
832 }
834 }
836 #if defined(EXITFREE) || defined(PROTO)
837 void
839 {
844 {
847 {
850 }
851 }
855 /* script-local variables */
861 /* global variables */
864 /* autoloaded script names */
867 /* unreferenced lists and dicts */
870 /* functions */
873 }
874 #endif
876 /*
877 * Return the name of the executed function.
878 */
879 char_u *
882 {
884 }
886 /*
887 * Return the address holding the next breakpoint line for a funccall cookie.
888 */
889 linenr_T *
892 {
894 }
896 /*
897 * Return the address holding the debug tick for a funccall cookie.
898 */
902 {
904 }
906 /*
907 * Return the nesting level for a funccall cookie.
908 */
909 int
912 {
914 }
916 /* pointer to funccal for currently active function */
919 /*
920 * Return TRUE when a function was ended by a ":return" command.
921 */
922 int
924 {
926 }
929 /*
930 * Set an internal variable to a string value. Creates the variable if it does
931 * not already exist.
932 */
933 void
937 {
943 {
946 {
949 }
950 }
951 }
958 /*
959 * Start recording command output to a variable
960 * Returns OK if successfully completed the setup. FAIL otherwise.
961 */
962 int
966 {
969 typval_T tv;
971 /* Make sure a valid variable name is specified */
973 {
976 }
984 {
987 }
989 /* The output is stored in growarray "redir_ga" until redirection ends. */
992 /* Parse the variable name (can be a dict or list entry). */
994 FNE_CHECK_START);
996 {
998 /* Trailing characters are present after the variable name */
1000 else
1004 }
1006 /* check if we can write to the variable: set it to or append an empty
1007 * string */
1014 else
1019 {
1022 }
1024 {
1025 /* Dictionary item was created, don't do it again. */
1028 }
1031 }
1033 /*
1034 * Append "value[value_len]" to the variable set by var_redir_start().
1035 * The actual appending is postponed until redirection ends, because the value
1036 * appended may in fact be the string we write to, changing it may cause freed
1037 * memory to be used:
1038 * :redir => foo
1039 * :let foo
1040 * :redir END
1041 */
1042 void
1046 {
1054 else
1058 {
1061 }
1062 else
1064 }
1066 /*
1067 * Stop redirecting command output to a variable.
1068 */
1069 void
1071 {
1072 typval_T tv;
1075 {
1076 /* Append the trailing NUL. */
1079 /* Assign the text to the variable. */
1088 }
1091 }
1093 # if defined(FEAT_MBYTE) || defined(PROTO)
1094 int
1100 {
1117 }
1118 # endif
1120 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1121 int
1125 {
1136 {
1139 }
1141 }
1142 # endif
1144 # if defined(FEAT_DIFF) || defined(PROTO)
1145 void
1150 {
1160 }
1162 void
1167 {
1177 }
1178 # endif
1180 /*
1181 * Top level evaluation function, returning a boolean.
1182 * Sets "error" to TRUE if there was an error.
1183 * Return TRUE or FALSE.
1184 */
1185 int
1191 {
1192 typval_T tv;
1199 else
1200 {
1203 {
1206 }
1207 }
1212 }
1214 /*
1215 * Top level evaluation function, returning a string. If "skip" is TRUE,
1216 * only parsing to "nextcmd" is done, without reporting errors. Return
1217 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1218 */
1219 char_u *
1224 {
1225 typval_T tv;
1232 else
1233 {
1236 }
1241 }
1243 /*
1244 * Skip over an expression at "*pp".
1245 * Return FAIL for an error, OK otherwise.
1246 */
1247 int
1250 {
1251 typval_T rettv;
1255 }
1257 /*
1258 * Top level evaluation function, returning a string.
1259 * Return pointer to allocated memory, or NULL for failure.
1260 */
1261 char_u *
1266 {
1267 typval_T tv;
1269 garray_T ga;
1273 else
1274 {
1276 {
1281 }
1282 else
1285 }
1288 }
1290 /*
1291 * Call eval_to_string() without using current local variables and using
1292 * textlock. When "use_sandbox" is TRUE use the sandbox.
1293 */
1294 char_u *
1299 {
1313 }
1315 /*
1316 * Top level evaluation function, returning a number.
1317 * Evaluates "expr" silently.
1318 * Returns -1 for an error.
1319 */
1320 int
1323 {
1324 typval_T rettv;
1332 else
1333 {
1336 }
1340 }
1342 /*
1343 * Prepare v: variable "idx" to be used.
1344 * Save the current typeval in "save_tv".
1345 * When not used yet add the variable to the v: hashtable.
1346 */
1347 static void
1351 {
1355 }
1357 /*
1358 * Restore v: variable "idx" to typeval "save_tv".
1359 * When no longer defined, remove the variable from the v: hashtable.
1360 */
1361 static void
1365 {
1370 {
1374 else
1376 }
1377 }
1379 #if defined(FEAT_SPELL) || defined(PROTO)
1380 /*
1381 * Evaluate an expression to a list with suggestions.
1382 * For the "expr:" part of 'spellsuggest'.
1383 */
1384 list_T *
1388 {
1389 typval_T save_val;
1390 typval_T rettv;
1394 /* Set "v:val" to the bad word. */
1402 {
1405 else
1407 }
1414 }
1416 /*
1417 * "list" is supposed to contain two items: a word and a number. Return the
1418 * word in "pp" and the number as the return value.
1419 * Return -1 if anything isn't right.
1420 * Used to get the good word and score from the eval_spell_expr() result.
1421 */
1422 int
1426 {
1438 }
1439 #endif
1441 /*
1442 * Top level evaluation function.
1443 * Returns an allocated typval_T with the result.
1444 * Returns NULL when there is an error.
1445 */
1446 typval_T *
1450 {
1455 {
1458 }
1461 }
1464 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1465 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1466 /*
1467 * Call some vimL function and return the result in "*rettv".
1468 * Uses argv[argc] for the function arguments. Only Number and String
1469 * arguments are currently supported.
1470 * Returns OK or FAIL.
1471 */
1472 static int
1479 {
1493 {
1494 /* Pass a NULL or empty argument as an empty string */
1496 {
1500 }
1502 /* Recognize a number argument, the others must be strings. */
1505 {
1508 }
1509 else
1510 {
1513 }
1514 }
1517 {
1520 }
1527 {
1530 }
1537 }
1539 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1540 /*
1541 * Call vimL function "func" and return the result as a string.
1542 * Returns NULL when calling the function fails.
1543 * Uses argv[argc] for the function arguments.
1544 */
1551 {
1552 typval_T rettv;
1561 }
1562 # endif
1564 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1565 /*
1566 * Call vimL function "func" and return the result as a number.
1567 * Returns -1 when calling the function fails.
1568 * Uses argv[argc] for the function arguments.
1569 */
1570 long
1576 {
1577 typval_T rettv;
1586 }
1587 # endif
1589 /*
1590 * Call vimL function "func" and return the result as a list
1591 * Uses argv[argc] for the function arguments.
1592 */
1599 {
1600 typval_T rettv;
1606 {
1609 }
1612 }
1613 #endif
1616 /*
1617 * Save the current function call pointer, and set it to NULL.
1618 * Used when executing autocommands and for ":source".
1619 */
1622 {
1627 }
1629 void
1632 {
1636 }
1638 #if defined(FEAT_PROFILE) || defined(PROTO)
1639 /*
1640 * Prepare profiling for entering a child or something else that is not
1641 * counted for the script/function itself.
1642 * Should always be called in pair with prof_child_exit().
1643 */
1644 void
1647 {
1653 }
1655 /*
1656 * Take care of time spent in a child.
1657 * Should always be called after prof_child_enter().
1658 */
1659 void
1662 {
1666 {
1671 }
1673 }
1674 #endif
1677 #ifdef FEAT_FOLDING
1678 /*
1679 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1680 * it in "*cp". Doesn't give error messages.
1681 */
1682 int
1686 {
1687 typval_T tv;
1691 OPT_LOCAL);
1700 else
1701 {
1702 /* If the result is a number, just return the number. */
1707 else
1708 {
1709 /* If the result is a string, check if there is a non-digit before
1710 * the number. */
1715 }
1717 }
1724 }
1725 #endif
1727 /*
1728 * ":let" list all variable values
1729 * ":let var1 var2" list variable values
1730 * ":let var = expr" assignment command.
1731 * ":let var += expr" assignment command.
1732 * ":let var -= expr" assignment command.
1733 * ":let var .= expr" assignment command.
1734 * ":let [var1, var2] = expr" unpack list.
1735 */
1736 void
1739 {
1742 typval_T rettv;
1757 {
1758 /*
1759 * ":let" without "=": list variables
1760 */
1764 /* ":let var1 var2" */
1767 {
1768 /* ":let" */
1772 #ifdef FEAT_WINDOWS
1774 #endif
1778 }
1780 }
1781 else
1782 {
1786 {
1789 }
1796 {
1800 }
1802 {
1804 op);
1806 }
1807 }
1808 }
1810 /*
1811 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1812 * Handles both "var" with any type and "[var, var; var]" with a list type.
1813 * When "nextchars" is not NULL it points to a string with characters that
1814 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1815 * or concatenate.
1816 * Returns OK or FAIL;
1817 */
1818 static int
1826 {
1831 typval_T ltv;
1834 {
1835 /*
1836 * ":let var = expr" or ":for var in list"
1837 */
1841 }
1843 /*
1844 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1845 */
1847 {
1850 }
1854 {
1857 }
1859 {
1862 }
1866 {
1875 {
1876 /* Put the rest of the list (may be empty) in the var after ';'.
1877 * Create a new list for this. */
1882 {
1885 }
1898 }
1900 {
1903 }
1904 }
1907 }
1909 /*
1910 * Skip over assignable variable "var" or list of variables "[var, var]".
1911 * Used for ":let varvar = expr" and ":for varvar in expr".
1912 * For "[var, var]" increment "*var_count" for each variable.
1913 * for "[var, var; var]" set "semicolon".
1914 * Return NULL for an error.
1915 */
1921 {
1925 {
1926 /* "[var, var]": find the matching ']'. */
1929 {
1933 {
1936 }
1943 {
1945 {
1948 }
1950 }
1952 {
1955 }
1956 }
1958 }
1959 else
1961 }
1963 /*
1964 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1965 * l[idx].
1966 */
1970 {
1975 }
1977 /*
1978 * List variables for hashtab "ht" with prefix "prefix".
1979 * If "empty" is TRUE also list NULL strings as empty strings.
1980 */
1981 static void
1987 {
1994 {
1996 {
2002 }
2003 }
2004 }
2006 /*
2007 * List global variables.
2008 */
2009 static void
2012 {
2014 }
2016 /*
2017 * List buffer variables.
2018 */
2019 static void
2022 {
2031 }
2033 /*
2034 * List window variables.
2035 */
2036 static void
2039 {
2042 }
2044 #ifdef FEAT_WINDOWS
2045 /*
2046 * List tab page variables.
2047 */
2048 static void
2051 {
2054 }
2055 #endif
2057 /*
2058 * List Vim variables.
2059 */
2060 static void
2063 {
2065 }
2067 /*
2068 * List script-local variables, if there is a script.
2069 */
2070 static void
2073 {
2077 }
2079 /*
2080 * List function variables, if there is a function.
2081 */
2082 static void
2085 {
2089 }
2091 /*
2092 * List variables in "arg".
2093 */
2099 {
2106 typval_T tv;
2109 {
2111 {
2114 {
2118 }
2119 }
2120 else
2121 {
2122 /* get_name_len() takes care of expanding curly braces */
2126 {
2127 /* This is mainly to keep test 49 working: when expanding
2128 * curly braces fails overrule the exception error message. */
2130 {
2134 }
2136 }
2137 else
2138 {
2143 else
2144 {
2145 /* handle d.key, l[idx], f(expr) */
2149 else
2150 {
2152 {
2154 {
2158 #ifdef FEAT_WINDOWS
2160 #endif
2166 }
2167 }
2168 else
2169 {
2182 first);
2185 }
2187 }
2188 }
2189 }
2192 }
2195 }
2198 }
2200 /*
2201 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2202 * Returns a pointer to the char just after the var name.
2203 * Returns NULL if there is an error.
2204 */
2212 {
2221 /*
2222 * ":let $VAR = expr": Set environment variable.
2223 */
2225 {
2226 /* Find the end of the name. */
2232 else
2233 {
2239 else
2240 {
2245 {
2250 {
2254 }
2255 }
2257 {
2267 }
2270 }
2271 }
2272 }
2274 /*
2275 * ":let &option = expr": Set option value.
2276 * ":let &l:option = expr": Set local option value.
2277 * ":let &g:option = expr": Set global option value.
2278 */
2280 {
2281 /* Find the end of the name. */
2286 else
2287 {
2300 {
2306 else
2307 {
2309 {
2312 else
2314 }
2316 {
2320 }
2321 }
2322 }
2324 {
2327 }
2330 }
2331 }
2333 /*
2334 * ":let @r = expr": Set register contents.
2335 */
2337 {
2344 else
2345 {
2351 {
2354 {
2357 }
2358 }
2360 {
2363 }
2365 }
2366 }
2368 /*
2369 * ":let var = expr": Set internal variable.
2370 * ":let {expr} = expr": Idem, name made with curly braces
2371 */
2373 {
2374 lval_T lv;
2378 {
2381 else
2382 {
2385 }
2386 }
2388 }
2390 else
2394 }
2396 /*
2397 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2398 */
2399 static int
2402 {
2404 {
2407 }
2409 }
2411 /*
2412 * Get an lval: variable, Dict item or List item that can be assigned a value
2413 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2414 * "name.key", "name.key[expr]" etc.
2415 * Indexing only works if "name" is an existing List or Dictionary.
2416 * "name" points to the start of the name.
2417 * If "rettv" is not NULL it points to the value to be assigned.
2418 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2419 * wrong; must end in space or cmd separator.
2420 *
2421 * Returns a pointer to just after the name, including indexes.
2422 * When an evaluation error occurs "lp->ll_name" is NULL;
2423 * Returns NULL for a parsing error. Still need to free items in "lp"!
2424 */
2434 {
2439 typval_T var1;
2440 typval_T var2;
2447 /* Clear everything in "lp". */
2451 {
2452 /* When skipping just find the end of the name. */
2455 }
2457 /* Find the end of the name. */
2460 {
2461 /* Don't expand the name when we already know there is an error. */
2464 {
2467 }
2471 {
2472 /* Report an invalid expression in braces, unless the
2473 * expression evaluation has been cancelled due to an
2474 * aborting error, an interrupt, or an exception. */
2476 {
2480 }
2481 }
2483 }
2484 else
2487 /* Without [idx] or .key we are done. */
2500 /*
2501 * Loop until no more [idx] or .key is following.
2502 */
2505 {
2509 {
2513 }
2515 {
2519 }
2523 {
2526 ;
2528 {
2532 }
2534 }
2535 else
2536 {
2537 /* Get the index [expr] or the first index [expr: ]. */
2541 else
2542 {
2547 {
2548 /* not a number or string */
2551 }
2552 }
2554 /* Optionally get the second index [ :expr]. */
2556 {
2558 {
2564 }
2567 {
2573 }
2577 else
2578 {
2581 {
2585 }
2587 {
2588 /* not a number or string */
2593 }
2594 }
2596 }
2597 else
2601 {
2609 }
2611 /* Skip to past ']'. */
2613 }
2616 {
2618 {
2619 /* "[key]": get key from "var1" */
2622 {
2627 }
2628 }
2633 {
2634 /* Key does not exist in dict: may need to add it. */
2636 {
2642 }
2645 else
2652 }
2656 }
2657 else
2658 {
2659 /*
2660 * Get the number and item for the only or first index of the List.
2661 */
2664 else
2665 {
2668 }
2673 {
2675 {
2678 }
2679 }
2681 {
2685 }
2687 /*
2688 * May need to find the item or absolute index for the second
2689 * index of a range.
2690 * When no index given: "lp->ll_empty2" is TRUE.
2691 * Otherwise "lp->ll_n2" is set to the second index.
2692 */
2694 {
2698 {
2703 }
2705 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2710 }
2713 }
2714 }
2717 }
2719 /*
2720 * Clear lval "lp" that was filled by get_lval().
2721 */
2722 static void
2725 {
2728 }
2730 /*
2731 * Set a variable that was parsed by get_lval() to "rettv".
2732 * "endp" points to just after the parsed name.
2733 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2734 */
2735 static void
2742 {
2748 {
2750 {
2754 {
2755 typval_T tv;
2757 /* handle +=, -= and .= */
2760 {
2764 }
2765 }
2766 else
2769 }
2770 }
2774 ;
2776 {
2777 /*
2778 * Assign the List values to the list items.
2779 */
2781 {
2784 else
2785 {
2788 }
2793 {
2794 /* Need to add an empty item. */
2796 {
2799 }
2800 }
2803 }
2810 }
2811 else
2812 {
2813 /*
2814 * Assign to a List or Dictionary item.
2815 */
2817 {
2819 {
2822 }
2824 /* Need to add an item to the Dictionary. */
2829 {
2832 }
2834 }
2836 {
2839 }
2840 else
2843 /*
2844 * Assign the value to the variable or list item.
2845 */
2848 else
2849 {
2853 }
2854 }
2855 }
2857 /*
2858 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2859 * Returns OK or FAIL.
2860 */
2861 static int
2866 {
2871 /* Can't do anything with a Funcref or a Dict on the right. */
2873 {
2875 {
2883 /* List += List */
2893 {
2894 /* nr += nr or nr -= nr*/
2896 #ifdef FEAT_FLOAT
2898 {
2903 else
2908 }
2909 else
2910 #endif
2911 {
2914 else
2919 }
2920 }
2921 else
2922 {
2926 /* str .= str */
2932 }
2935 #ifdef FEAT_FLOAT
2937 {
2938 float_T f;
2946 else
2950 else
2952 }
2954 #endif
2955 }
2956 }
2960 }
2962 /*
2963 * Add a watcher to a list.
2964 */
2965 static void
2969 {
2972 }
2974 /*
2975 * Remove a watcher from a list.
2976 * No warning when it isn't found...
2977 */
2978 static void
2982 {
2987 {
2989 {
2992 }
2994 }
2995 }
2997 /*
2998 * Just before removing an item from a list: advance watchers to the next
2999 * item.
3000 */
3001 static void
3005 {
3011 }
3013 /*
3014 * Evaluate the expression used in a ":for var in expr" command.
3015 * "arg" points to "var".
3016 * Set "*errp" to TRUE for an error, FALSE otherwise;
3017 * Return a pointer that holds the info. Null when there is an error.
3018 */
3025 {
3028 typval_T tv;
3043 {
3046 }
3051 {
3054 {
3057 {
3060 }
3061 else
3062 {
3063 /* No need to increment the refcount, it's already set for the
3064 * list being used in "tv". */
3068 }
3069 }
3070 }
3075 }
3077 /*
3078 * Use the first item in a ":for" list. Advance to the next.
3079 * Assign the values to the variable (list). "arg" points to the first one.
3080 * Return TRUE when a valid item was found, FALSE when at end of list or
3081 * something wrong.
3082 */
3083 int
3087 {
3095 else
3096 {
3100 }
3102 }
3104 /*
3105 * Free the structure used to store info used by ":for".
3106 */
3107 void
3110 {
3114 {
3117 }
3119 }
3121 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3123 void
3127 cmdidx_T cmdidx;
3128 {
3134 {
3137 {
3138 /* ":let var1 var2 ...": find last space. */
3140 {
3145 }
3147 }
3148 }
3149 else
3154 {
3157 {
3160 {
3164 }
3166 {
3171 }
3172 }
3174 {
3175 /* environment variable */
3177 }
3179 {
3182 }
3186 {
3187 /* Function name can start with "<SNR>" */
3189 }
3191 {
3193 {
3198 }
3200 {
3201 /* Trick: '' is like stopping and starting a literal string. */
3205 }
3207 {
3209 {
3212 }
3213 else
3215 }
3216 else
3218 }
3219 else
3220 /* Doesn't look like something valid, expand as an expression
3221 * anyway. */
3227 }
3229 }
3233 /*
3234 * ":1,25call func(arg1, arg2)" function call.
3235 */
3236 void
3239 {
3245 typval_T rettv;
3246 linenr_T lnum;
3249 funcdict_T fudi;
3253 {
3254 /* Still need to give an error message for missing key. */
3257 }
3261 /* Increase refcount on dictionary, it could get deleted when evaluating
3262 * the arguments. */
3266 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3270 /* Skip white space to allow ":call func ()". Not good, but required for
3271 * backward compatibility. */
3276 {
3279 }
3281 /*
3282 * When skipping, evaluate the function once, to find the end of the
3283 * arguments.
3284 * When the function takes a range, this is discovered after the first
3285 * call, and the loop is broken.
3286 */
3288 {
3291 }
3292 else
3295 {
3297 {
3300 }
3305 {
3308 }
3310 /* Handle a function returning a Funcref, Dictionary or List. */
3312 {
3315 }
3321 /* Stop when immediately aborting on error, or when an interrupt
3322 * occurred or an exception was thrown but not caught.
3323 * get_func_tv() returned OK, so that the check for trailing
3324 * characters below is executed. */
3327 }
3332 {
3333 /* Check for trailing illegal characters and a following command. */
3335 {
3338 }
3339 else
3341 }
3343 end:
3346 }
3348 /*
3349 * ":unlet[!] var1 ... " command.
3350 */
3351 void
3354 {
3356 }
3358 /*
3359 * ":lockvar" and ":unlockvar" commands
3360 */
3361 void
3364 {
3371 {
3374 }
3377 }
3379 /*
3380 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3381 */
3382 static void
3387 {
3391 lval_T lv;
3393 do
3394 {
3395 /* Parse the name and find the end. */
3397 FNE_CHECK_START);
3402 {
3404 {
3407 }
3411 }
3414 {
3416 {
3419 }
3420 else
3421 {
3425 }
3426 }
3435 }
3437 static int
3442 {
3447 {
3451 /* Normal name or expanded name. */
3457 }
3461 {
3464 /* Delete a range of List items. */
3466 {
3471 }
3472 }
3473 else
3474 {
3476 /* unlet a List item. */
3478 else
3479 /* unlet a Dictionary item. */
3481 }
3484 }
3486 /*
3487 * "unlet" a variable. Return OK if it existed, FAIL if not.
3488 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3489 */
3490 int
3494 {
3502 {
3505 {
3512 }
3513 }
3518 }
3520 /*
3521 * Lock or unlock variable indicated by "lp".
3522 * "deep" is the levels to go (-1 for unlimited);
3523 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3524 */
3525 static int
3531 {
3540 {
3544 /* Normal name or expanded name. */
3547 else
3548 {
3552 else
3553 {
3556 else
3559 }
3560 }
3562 }
3564 {
3567 /* (un)lock a range of List items. */
3569 {
3573 }
3574 }
3576 /* (un)lock a List item. */
3578 else
3579 /* un(lock) a Dictionary item. */
3583 }
3585 /*
3586 * Lock or unlock an item. "deep" is nr of levels to go.
3587 */
3588 static void
3593 {
3602 {
3605 }
3610 /* lock/unlock the item itself */
3613 else
3617 {
3620 {
3623 else
3626 /* recursive: lock/unlock the items the List contains */
3629 }
3633 {
3636 else
3639 {
3640 /* recursive: lock/unlock the items the List contains */
3643 {
3645 {
3648 }
3649 }
3650 }
3651 }
3652 }
3654 }
3656 /*
3657 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3658 * it refers to a List or Dictionary that is locked.
3659 */
3660 static int
3663 {
3671 }
3673 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3674 /*
3675 * Delete all "menutrans_" variables.
3676 */
3677 void
3679 {
3686 {
3688 {
3692 }
3693 }
3695 }
3696 #endif
3698 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3700 /*
3701 * Local string buffer for the next two functions to store a variable name
3702 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3703 * get_user_var_name().
3704 */
3711 /*
3712 * Function to concatenate a prefix and a variable name.
3713 */
3718 {
3723 {
3728 {
3731 }
3733 }
3738 }
3740 /*
3741 * Function given to ExpandGeneric() to obtain the list of user defined
3742 * (global/buffer/window/built-in) variable names.
3743 */
3744 /*ARGSUSED*/
3745 char_u *
3749 {
3753 #ifdef FEAT_WINDOWS
3755 #endif
3761 {
3763 #ifdef FEAT_WINDOWS
3765 #endif
3766 }
3768 /* Global variables */
3770 {
3773 else
3780 }
3782 /* b: variables */
3785 {
3788 else
3793 }
3795 {
3798 }
3800 /* w: variables */
3803 {
3806 else
3811 }
3813 #ifdef FEAT_WINDOWS
3814 /* t: variables */
3817 {
3820 else
3825 }
3826 #endif
3828 /* v: variables */
3836 }
3840 /*
3841 * types for expressions.
3842 */
3844 {
3856 /*
3857 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3858 * executed. The function may return OK, but the rettv will be of type
3859 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3860 */
3862 /*
3863 * Handle zero level expression.
3864 * This calls eval1() and handles error message and nextcmd.
3865 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3866 * Note: "rettv.v_lock" is not set.
3867 * Return OK or FAIL.
3868 */
3869 static int
3875 {
3882 {
3885 /*
3886 * Report the invalid expression unless the expression evaluation has
3887 * been cancelled due to an aborting error, an interrupt, or an
3888 * exception.
3889 */
3893 }
3898 }
3900 /*
3901 * Handle top level expression:
3902 * expr1 ? expr0 : expr0
3903 *
3904 * "arg" must point to the first non-white of the expression.
3905 * "arg" is advanced to the next non-white after the recognized expression.
3906 *
3907 * Note: "rettv.v_lock" is not set.
3908 *
3909 * Return OK or FAIL.
3910 */
3911 static int
3916 {
3918 typval_T var2;
3920 /*
3921 * Get the first variable.
3922 */
3927 {
3930 {
3938 }
3940 /*
3941 * Get the second variable.
3942 */
3947 /*
3948 * Check for the ":".
3949 */
3951 {
3956 }
3958 /*
3959 * Get the third variable.
3960 */
3963 {
3967 }
3970 }
3973 }
3975 /*
3976 * Handle first level expression:
3977 * expr2 || expr2 || expr2 logical OR
3978 *
3979 * "arg" must point to the first non-white of the expression.
3980 * "arg" is advanced to the next non-white after the recognized expression.
3981 *
3982 * Return OK or FAIL.
3983 */
3984 static int
3989 {
3990 typval_T var2;
3995 /*
3996 * Get the first variable.
3997 */
4001 /*
4002 * Repeat until there is no following "||".
4003 */
4007 {
4009 {
4016 }
4018 /*
4019 * Get the second variable.
4020 */
4025 /*
4026 * Compute the result.
4027 */
4029 {
4035 }
4037 {
4040 }
4041 }
4044 }
4046 /*
4047 * Handle second level expression:
4048 * expr3 && expr3 && expr3 logical AND
4049 *
4050 * "arg" must point to the first non-white of the expression.
4051 * "arg" is advanced to the next non-white after the recognized expression.
4052 *
4053 * Return OK or FAIL.
4054 */
4055 static int
4060 {
4061 typval_T var2;
4066 /*
4067 * Get the first variable.
4068 */
4072 /*
4073 * Repeat until there is no following "&&".
4074 */
4078 {
4080 {
4087 }
4089 /*
4090 * Get the second variable.
4091 */
4096 /*
4097 * Compute the result.
4098 */
4100 {
4106 }
4108 {
4111 }
4112 }
4115 }
4117 /*
4118 * Handle third level expression:
4119 * var1 == var2
4120 * var1 =~ var2
4121 * var1 != var2
4122 * var1 !~ var2
4123 * var1 > var2
4124 * var1 >= var2
4125 * var1 < var2
4126 * var1 <= var2
4127 * var1 is var2
4128 * var1 isnot var2
4129 *
4130 * "arg" must point to the first non-white of the expression.
4131 * "arg" is advanced to the next non-white after the recognized expression.
4132 *
4133 * Return OK or FAIL.
4134 */
4135 static int
4140 {
4141 typval_T var2;
4150 regmatch_T regmatch;
4154 /*
4155 * Get the first variable.
4156 */
4162 {
4174 {
4177 }
4178 else
4182 {
4185 }
4186 else
4190 {
4194 {
4197 }
4198 }
4200 }
4202 /*
4203 * If there is a comparative operator, use it.
4204 */
4206 {
4207 /* extra question mark appended: ignore case */
4209 {
4212 }
4213 /* extra '#' appended: match case */
4215 {
4218 }
4219 /* nothing appended: use 'ignorecase' */
4220 else
4223 /*
4224 * Get the second variable.
4225 */
4228 {
4231 }
4234 {
4236 {
4237 /* For "is" a different type always means FALSE, for "notis"
4238 * it means TRUE. */
4240 }
4242 {
4244 {
4249 }
4252 {
4255 else
4260 }
4261 else
4262 {
4263 /* Compare two Lists for being equal or unequal. */
4267 }
4268 }
4271 {
4273 {
4278 }
4281 {
4284 else
4289 }
4290 else
4291 {
4292 /* Compare two Dictionaries for being equal or unequal. */
4296 }
4297 }
4300 {
4303 {
4306 else
4311 }
4312 else
4313 {
4314 /* Compare two Funcrefs for being equal or unequal. */
4318 else
4323 }
4324 }
4326 #ifdef FEAT_FLOAT
4327 /*
4328 * If one of the two variables is a float, compare as a float.
4329 * When using "=~" or "!~", always compare as string.
4330 */
4333 {
4338 else
4342 else
4346 {
4356 }
4357 }
4358 #endif
4360 /*
4361 * If one of the two variables is a number, compare as a number.
4362 * When using "=~" or "!~", always compare as string.
4363 */
4366 {
4370 {
4380 }
4381 }
4382 else
4383 {
4388 else
4392 {
4402 /* avoid 'l' flag in 'cpoptions' */
4409 {
4414 }
4419 }
4420 }
4425 }
4426 }
4429 }
4431 /*
4432 * Handle fourth level expression:
4433 * + number addition
4434 * - number subtraction
4435 * . string concatenation
4436 *
4437 * "arg" must point to the first non-white of the expression.
4438 * "arg" is advanced to the next non-white after the recognized expression.
4439 *
4440 * Return OK or FAIL.
4441 */
4442 static int
4447 {
4448 typval_T var2;
4449 typval_T var3;
4452 #ifdef FEAT_FLOAT
4454 #endif
4459 /*
4460 * Get the first variable.
4461 */
4465 /*
4466 * Repeat computing, until no '+', '-' or '.' is following.
4467 */
4469 {
4475 #ifdef FEAT_FLOAT
4477 #endif
4478 )
4479 {
4480 /* For "list + ...", an illegal use of the first operand as
4481 * a number cannot be determined before evaluating the 2nd
4482 * operand: if this is also a list, all is ok.
4483 * For "something . ...", "something - ..." or "non-list + ...",
4484 * we know that the first operand needs to be a string or number
4485 * without evaluating the 2nd operand. So check before to avoid
4486 * side effects after an error. */
4488 {
4491 }
4492 }
4494 /*
4495 * Get the second variable.
4496 */
4499 {
4502 }
4505 {
4506 /*
4507 * Compute the result.
4508 */
4510 {
4514 {
4518 }
4523 }
4526 {
4527 /* concatenate Lists */
4530 {
4534 }
4537 }
4538 else
4539 {
4542 #ifdef FEAT_FLOAT
4544 {
4547 }
4548 else
4549 #endif
4550 {
4553 {
4554 /* This can only happen for "list + non-list". For
4555 * "non-list + ..." or "something - ...", we returned
4556 * before evaluating the 2nd operand. */
4559 }
4560 #ifdef FEAT_FLOAT
4563 #endif
4564 }
4565 #ifdef FEAT_FLOAT
4567 {
4570 }
4571 else
4572 #endif
4573 {
4576 {
4580 }
4581 #ifdef FEAT_FLOAT
4584 #endif
4585 }
4588 #ifdef FEAT_FLOAT
4589 /* If there is a float on either side the result is a float. */
4591 {
4594 else
4598 }
4599 else
4600 #endif
4601 {
4604 else
4608 }
4609 }
4611 }
4612 }
4614 }
4616 /*
4617 * Handle fifth level expression:
4618 * * number multiplication
4619 * / number division
4620 * % number modulo
4621 *
4622 * "arg" must point to the first non-white of the expression.
4623 * "arg" is advanced to the next non-white after the recognized expression.
4624 *
4625 * Return OK or FAIL.
4626 */
4627 static int
4633 {
4634 typval_T var2;
4637 #ifdef FEAT_FLOAT
4640 #endif
4643 /*
4644 * Get the first variable.
4645 */
4649 /*
4650 * Repeat computing, until no '*', '/' or '%' is following.
4651 */
4653 {
4659 {
4660 #ifdef FEAT_FLOAT
4662 {
4666 }
4667 else
4668 #endif
4673 }
4674 else
4677 /*
4678 * Get the second variable.
4679 */
4685 {
4686 #ifdef FEAT_FLOAT
4688 {
4690 {
4693 }
4696 }
4697 else
4698 #endif
4699 {
4704 #ifdef FEAT_FLOAT
4707 #endif
4708 }
4710 /*
4711 * Compute the result.
4712 * When either side is a float the result is a float.
4713 */
4714 #ifdef FEAT_FLOAT
4716 {
4720 {
4721 /* We rely on the floating point library to handle divide
4722 * by zero to result in "inf" and not a crash. */
4724 }
4725 else
4726 {
4729 }
4732 }
4733 else
4734 #endif
4735 {
4739 {
4741 {
4746 else
4748 }
4749 else
4751 }
4752 else
4753 {
4756 else
4758 }
4761 }
4762 }
4763 }
4766 }
4768 /*
4769 * Handle sixth level expression:
4770 * number number constant
4771 * "string" string constant
4772 * 'string' literal string constant
4773 * &option-name option value
4774 * @r register contents
4775 * identifier variable value
4776 * function() function call
4777 * $VAR environment variable
4778 * (expression) nested expression
4779 * [expr, expr] List
4780 * {key: val, key: val} Dictionary
4781 *
4782 * Also handle:
4783 * ! in front logical NOT
4784 * - in front unary minus
4785 * + in front unary plus (ignored)
4786 * trailing [] subscript in String or List
4787 * trailing .name entry in Dictionary
4788 *
4789 * "arg" must point to the first non-white of the expression.
4790 * "arg" is advanced to the next non-white after the recognized expression.
4791 *
4792 * Return OK or FAIL.
4793 */
4794 static int
4800 {
4808 /*
4809 * Initialise variable so that clear_tv() can't mistake this for a
4810 * string and free a string that isn't there.
4811 */
4814 /*
4815 * Skip '!' and '-' characters. They are handled later.
4816 */
4823 {
4824 /*
4825 * Number constant.
4826 */
4837 {
4838 #ifdef FEAT_FLOAT
4842 /* We accept a float when the format matches
4843 * "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very
4844 * strict to avoid backwards compatibility problems.
4845 * Don't look for a float after the "." operator, so that
4846 * ":let vers = 1.2.3" doesn't fail. */
4848 {
4852 {
4858 else
4860 }
4863 }
4865 {
4866 float_T f;
4870 {
4873 }
4874 }
4875 else
4876 #endif
4877 {
4881 {
4884 }
4885 }
4887 }
4889 /*
4890 * String constant: "string".
4891 */
4895 /*
4896 * Literal string constant: 'str''ing'.
4897 */
4901 /*
4902 * List: [expr, expr]
4903 */
4907 /*
4908 * Dictionary: {key: val, key: val}
4909 */
4913 /*
4914 * Option value: &name
4915 */
4919 /*
4920 * Environment variable: $VAR.
4921 */
4925 /*
4926 * Register contents: @r.
4927 */
4930 {
4933 }
4938 /*
4939 * nested expression: (expression).
4940 */
4946 {
4950 }
4955 }
4958 {
4959 /*
4960 * Must be a variable or function name.
4961 * Can also be a curly-braces kind of name: {expr}.
4962 */
4970 else
4971 {
4973 {
4974 /* If "s" is the name of a variable of type VAR_FUNC
4975 * use its contents. */
4978 /* Invoke the function. */
4982 /* Stop the expression evaluation when immediately
4983 * aborting on error, or when an interrupt occurred or
4984 * an exception was thrown but not caught. */
4986 {
4990 }
4991 }
4994 else
4996 }
5000 }
5004 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
5005 * expr(expr). */
5009 /*
5010 * Apply logical NOT and unary '-', from right to left, ignore '+'.
5011 */
5013 {
5016 #ifdef FEAT_FLOAT
5021 else
5022 #endif
5025 {
5028 }
5029 else
5030 {
5032 {
5035 {
5036 #ifdef FEAT_FLOAT
5039 else
5040 #endif
5042 }
5044 {
5045 #ifdef FEAT_FLOAT
5048 else
5049 #endif
5051 }
5052 }
5053 #ifdef FEAT_FLOAT
5055 {
5058 }
5059 else
5060 #endif
5061 {
5065 }
5066 }
5067 }
5070 }
5072 /*
5073 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
5074 * "*arg" points to the '[' or '.'.
5075 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
5076 */
5077 static int
5083 {
5093 #ifdef FEAT_FLOAT
5095 #endif
5096 )
5097 {
5101 }
5104 {
5105 /*
5106 * dict.name
5107 */
5110 ;
5114 }
5115 else
5116 {
5117 /*
5118 * something[idx]
5119 *
5120 * Get the (first) variable from inside the [].
5121 */
5128 {
5129 /* not a number or string */
5132 }
5134 /*
5135 * Get the second variable from inside the [:].
5136 */
5138 {
5144 {
5148 }
5150 {
5151 /* not a number or string */
5156 }
5157 }
5159 /* Check for the ']'. */
5161 {
5168 }
5170 }
5173 {
5176 {
5179 }
5181 {
5184 else
5185 {
5188 }
5189 }
5192 {
5198 {
5199 /* The resulting variable is a substring. If the indexes
5200 * are out of range the result is empty. */
5202 {
5206 }
5213 else
5215 }
5216 else
5217 {
5218 /* The resulting variable is a string of a single
5219 * character. If the index is too big or negative the
5220 * result is empty. */
5223 else
5225 }
5236 {
5237 /* For a range we allow invalid values and return an empty
5238 * list. A list index out of range is an error. */
5240 {
5244 }
5246 }
5248 {
5263 {
5265 {
5268 }
5270 }
5275 }
5276 else
5277 {
5281 }
5286 {
5292 }
5293 {
5297 {
5300 {
5305 }
5306 }
5320 }
5322 }
5323 }
5326 }
5328 /*
5329 * Get an option value.
5330 * "arg" points to the '&' or '+' before the option name.
5331 * "arg" is advanced to character after the option name.
5332 * Return OK or FAIL.
5333 */
5334 static int
5339 {
5349 /*
5350 * Isolate the option name and find its value.
5351 */
5354 {
5358 }
5361 {
5364 }
5372 {
5376 }
5378 {
5380 {
5383 }
5385 {
5388 }
5390 {
5393 }
5395 {
5398 }
5399 }
5407 }
5409 /*
5410 * Allocate a variable for a string constant.
5411 * Return OK or FAIL.
5412 */
5413 static int
5418 {
5423 /*
5424 * Find the end of the string, skipping backslashed characters.
5425 */
5427 {
5429 {
5431 /* A "\<x>" form occupies at least 4 characters, and produces up
5432 * to 6 characters: reserve space for 2 extra */
5435 }
5436 }
5439 {
5442 }
5444 /* If only parsing, set *arg and return here */
5446 {
5449 }
5451 /*
5452 * Copy the string into allocated memory, handling backslashed
5453 * characters.
5454 */
5462 {
5464 {
5466 {
5479 {
5485 else
5489 {
5492 }
5494 #ifdef FEAT_MBYTE
5495 /* For "\u" store the number according to
5496 * 'encoding'. */
5499 else
5500 #endif
5502 }
5505 /* octal: "\1", "\12", "\123" */
5515 {
5519 }
5523 /* Special key, e.g.: "\<C-W>" */
5526 {
5529 }
5530 /* FALLTHROUGH */
5534 }
5535 }
5536 else
5539 }
5544 }
5546 /*
5547 * Allocate a variable for a 'str''ing' constant.
5548 * Return OK or FAIL.
5549 */
5550 static int
5555 {
5560 /*
5561 * Find the end of the string, skipping ''.
5562 */
5564 {
5566 {
5571 }
5572 }
5575 {
5578 }
5580 /* If only parsing return after setting "*arg" */
5582 {
5585 }
5587 /*
5588 * Copy the string into allocated memory, handling '' to ' reduction.
5589 */
5597 {
5599 {
5603 }
5605 }
5610 }
5612 /*
5613 * Allocate a variable for a List and fill it from "*arg".
5614 * Return OK or FAIL.
5615 */
5616 static int
5621 {
5623 typval_T tv;
5627 {
5631 }
5635 {
5639 {
5642 {
5646 }
5647 else
5649 }
5654 {
5657 }
5659 }
5662 {
5664 failret:
5668 }
5672 {
5676 }
5679 }
5681 /*
5682 * Allocate an empty header for a list.
5683 * Caller should take care of the reference count.
5684 */
5685 list_T *
5687 {
5692 {
5693 /* Prepend the list to the list of lists for garbage collection. */
5699 }
5701 }
5703 /*
5704 * Allocate an empty list for a return value.
5705 * Returns OK or FAIL.
5706 */
5707 static int
5710 {
5720 }
5722 /*
5723 * Unreference a list: decrement the reference count and free it when it
5724 * becomes zero.
5725 */
5726 void
5729 {
5732 }
5734 /*
5735 * Free a list, including all items it points to.
5736 * Ignores the reference count.
5737 */
5738 void
5742 {
5745 /* Remove the list from the list of lists for garbage collection. */
5748 else
5754 {
5755 /* Remove the item before deleting it. */
5761 }
5763 }
5765 /*
5766 * Allocate a list item.
5767 */
5770 {
5772 }
5774 /*
5775 * Free a list item. Also clears the value. Does not notify watchers.
5776 */
5777 static void
5780 {
5783 }
5785 /*
5786 * Remove a list item from a List and free it. Also clears the value.
5787 */
5788 static void
5792 {
5795 }
5797 /*
5798 * Get the number of items in a list.
5799 */
5800 static long
5803 {
5807 }
5809 /*
5810 * Return TRUE when two lists have exactly the same values.
5811 */
5812 static int
5817 {
5831 }
5833 #if defined(FEAT_PYTHON) || defined(PROTO) || defined(FEAT_GUI_MACVIM)
5834 /*
5835 * Return the dictitem that an entry in a hashtable points to.
5836 */
5837 dictitem_T *
5840 {
5842 }
5843 #endif
5845 /*
5846 * Return TRUE when two dictionaries have exactly the same key/values.
5847 */
5848 static int
5853 {
5865 {
5867 {
5874 }
5875 }
5877 }
5879 /*
5880 * Return TRUE if "tv1" and "tv2" have the same value.
5881 * Compares the items just like "==" would compare them, but strings and
5882 * numbers are different. Floats and numbers are also different.
5883 */
5884 static int
5889 {
5897 /* Catch lists and dicts that have an endless loop by limiting
5898 * recursiveness to 1000. We guess they are equal then. */
5903 {
5924 #ifdef FEAT_FLOAT
5927 #endif
5933 }
5937 }
5939 /*
5940 * Locate item with index "n" in list "l" and return it.
5941 * A negative index is counted from the end; -1 is the last item.
5942 * Returns NULL when "n" is out of range.
5943 */
5948 {
5955 /* Negative index is relative to the end. */
5959 /* Check for index out of range. */
5963 /* When there is a cached index may start search from there. */
5965 {
5967 {
5968 /* closest to the start of the list */
5971 }
5973 {
5974 /* closest to the end of the list */
5977 }
5978 else
5979 {
5980 /* closest to the cached index */
5983 }
5984 }
5985 else
5986 {
5988 {
5989 /* closest to the start of the list */
5992 }
5993 else
5994 {
5995 /* closest to the end of the list */
5998 }
5999 }
6002 {
6003 /* search forward */
6006 }
6008 {
6009 /* search backward */
6012 }
6014 /* cache the used index */
6019 }
6021 /*
6022 * Get list item "l[idx]" as a number.
6023 */
6024 static long
6029 {
6034 {
6038 }
6040 }
6042 /*
6043 * Locate "item" list "l" and return its index.
6044 * Returns -1 when "item" is not in the list.
6045 */
6046 static long
6050 {
6062 }
6064 /*
6065 * Append item "item" to the end of list "l".
6066 */
6067 static void
6071 {
6073 {
6074 /* empty list */
6078 }
6079 else
6080 {
6084 }
6087 }
6089 /*
6090 * Append typval_T "tv" to the end of list "l".
6091 * Return FAIL when out of memory.
6092 */
6093 static int
6097 {
6105 }
6107 /*
6108 * Add a dictionary to a list. Used by getqflist().
6109 * Return FAIL when out of memory.
6110 */
6111 int
6115 {
6126 }
6128 /*
6129 * Make a copy of "str" and append it as an item to list "l".
6130 * When "len" >= 0 use "str[len]".
6131 * Returns FAIL when out of memory.
6132 */
6133 static int
6138 {
6152 }
6154 /*
6155 * Append "n" to list "l".
6156 * Returns FAIL when out of memory.
6157 */
6158 static int
6161 varnumber_T n;
6162 {
6173 }
6175 /*
6176 * Insert typval_T "tv" in list "l" before "item".
6177 * If "item" is NULL append at the end.
6178 * Return FAIL when out of memory.
6179 */
6180 static int
6185 {
6192 /* Append new item at end of list. */
6194 else
6195 {
6196 /* Insert new item before existing item. */
6200 {
6203 }
6204 else
6205 {
6208 }
6211 }
6213 }
6215 /*
6216 * Extend "l1" with "l2".
6217 * If "bef" is NULL append at the end, otherwise insert before this item.
6218 * Returns FAIL when out of memory.
6219 */
6220 static int
6225 {
6232 }
6234 /*
6235 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
6236 * Return FAIL when out of memory.
6237 */
6238 static int
6243 {
6246 /* make a copy of the first list. */
6253 /* append all items from the second list */
6255 }
6257 /*
6258 * Make a copy of list "orig". Shallow if "deep" is FALSE.
6259 * The refcount of the new list is set to 1.
6260 * See item_copy() for "copyID".
6261 * Returns NULL when out of memory.
6262 */
6268 {
6278 {
6280 {
6281 /* Do this before adding the items, because one of the items may
6282 * refer back to this list. */
6285 }
6288 {
6293 {
6295 {
6298 }
6299 }
6300 else
6303 }
6306 {
6309 }
6310 }
6313 }
6315 /*
6316 * Remove items "item" to "item2" from list "l".
6317 * Does not free the listitem or the value!
6318 */
6319 static void
6324 {
6327 /* notify watchers */
6329 {
6334 }
6338 else
6342 else
6345 }
6347 /*
6348 * Return an allocated string with the string representation of a list.
6349 * May return NULL.
6350 */
6355 {
6356 garray_T ga;
6363 {
6366 }
6370 }
6372 /*
6373 * Join list "l" into a string in "*gap", using separator "sep".
6374 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6375 * Return FAIL or OK.
6376 */
6377 static int
6384 {
6392 {
6395 else
6400 else
6407 }
6409 }
6411 /*
6412 * Garbage collection for lists and dictionaries.
6413 *
6414 * We use reference counts to be able to free most items right away when they
6415 * are no longer used. But for composite items it's possible that it becomes
6416 * unused while the reference count is > 0: When there is a recursive
6417 * reference. Example:
6418 * :let l = [1, 2, 3]
6419 * :let d = {9: l}
6420 * :let l[1] = d
6421 *
6422 * Since this is quite unusual we handle this with garbage collection: every
6423 * once in a while find out which lists and dicts are not referenced from any
6424 * variable.
6425 *
6426 * Here is a good reference text about garbage collection (refers to Python
6427 * but it applies to all reference-counting mechanisms):
6428 * http://python.ca/nas/python/gc/
6429 */
6431 /*
6432 * Do garbage collection for lists and dicts.
6433 * Return TRUE if some memory was freed.
6434 */
6435 int
6437 {
6446 #ifdef FEAT_WINDOWS
6448 #endif
6450 /* Only do this once. */
6455 /*
6456 * 1. Go through all accessible variables and mark all lists and dicts
6457 * with copyID.
6458 */
6459 /* script-local variables */
6463 /* buffer-local variables */
6467 /* window-local variables */
6471 #ifdef FEAT_WINDOWS
6472 /* tabpage-local variables */
6475 #endif
6477 /* global variables */
6480 /* function-local variables */
6482 {
6485 }
6487 /*
6488 * 2. Go through the list of dicts and free items without the copyID.
6489 */
6492 {
6493 /* Free the Dictionary and ordinary items it contains, but don't
6494 * recurse into Lists and Dictionaries, they will be in the list
6495 * of dicts or list of lists. */
6499 /* restart, next dict may also have been freed */
6501 }
6502 else
6505 /*
6506 * 3. Go through the list of lists and free items without the copyID.
6507 * But don't free a list that has a watcher (used in a for loop), these
6508 * are not referenced anywhere.
6509 */
6512 {
6513 /* Free the List and ordinary items it contains, but don't recurse
6514 * into Lists and Dictionaries, they will be in the list of dicts
6515 * or list of lists. */
6519 /* restart, next list may also have been freed */
6521 }
6522 else
6526 }
6528 /*
6529 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6530 */
6531 static void
6535 {
6542 {
6545 }
6546 }
6548 /*
6549 * Mark all lists and dicts referenced through list "l" with "copyID".
6550 */
6551 static void
6555 {
6560 }
6562 /*
6563 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6564 */
6565 static void
6569 {
6574 {
6578 {
6579 /* Didn't see this dict yet. */
6582 }
6588 {
6589 /* Didn't see this list yet. */
6592 }
6594 }
6596 }
6598 /*
6599 * Allocate an empty header for a dictionary.
6600 */
6601 dict_T *
6603 {
6608 {
6609 /* Add the list to the list of dicts for garbage collection. */
6620 }
6622 }
6624 /*
6625 * Unreference a Dictionary: decrement the reference count and free it when it
6626 * becomes zero.
6627 */
6628 static void
6631 {
6634 }
6636 /*
6637 * Free a Dictionary, including all items it contains.
6638 * Ignores the reference count.
6639 */
6640 static void
6644 {
6649 /* Remove the dict from the list of dicts for garbage collection. */
6652 else
6657 /* Lock the hashtab, we don't want it to resize while freeing items. */
6661 {
6663 {
6664 /* Remove the item before deleting it, just in case there is
6665 * something recursive causing trouble. */
6673 }
6674 }
6677 }
6679 /*
6680 * Allocate a Dictionary item.
6681 * The "key" is copied to the new item.
6682 * Note that the value of the item "di_tv" still needs to be initialized!
6683 * Returns NULL when out of memory.
6684 */
6688 {
6693 {
6696 }
6698 }
6700 /*
6701 * Make a copy of a Dictionary item.
6702 */
6706 {
6712 {
6716 }
6718 }
6720 /*
6721 * Remove item "item" from Dictionary "dict" and free it.
6722 */
6723 static void
6727 {
6733 else
6736 }
6738 /*
6739 * Free a dict item. Also clears the value.
6740 */
6741 static void
6744 {
6747 }
6749 /*
6750 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6751 * The refcount of the new dict is set to 1.
6752 * See item_copy() for "copyID".
6753 * Returns NULL when out of memory.
6754 */
6760 {
6771 {
6773 {
6776 }
6779 {
6781 {
6788 {
6791 {
6794 }
6795 }
6796 else
6799 {
6802 }
6803 }
6804 }
6808 {
6811 }
6812 }
6815 }
6817 /*
6818 * Add item "item" to Dictionary "d".
6819 * Returns FAIL when out of memory and when key already existed.
6820 */
6821 static int
6825 {
6827 }
6829 /*
6830 * Add a number or string entry to dictionary "d".
6831 * When "str" is NULL use number "nr", otherwise use "str".
6832 * Returns FAIL when out of memory and when key already exists.
6833 */
6834 int
6840 {
6848 {
6851 }
6852 else
6853 {
6856 }
6858 {
6861 }
6863 }
6865 /*
6866 * Get the number of items in a Dictionary.
6867 */
6868 static long
6871 {
6875 }
6877 /*
6878 * Find item "key[len]" in Dictionary "d".
6879 * If "len" is negative use strlen(key).
6880 * Returns NULL when not found.
6881 */
6887 {
6888 #define AKEYLEN 200
6897 {
6901 }
6902 else
6903 {
6904 /* Avoid a malloc/free by using buf[]. */
6907 }
6914 }
6916 /*
6917 * Get a string item from a dictionary.
6918 * When "save" is TRUE allocate memory for it.
6919 * Returns NULL if the entry doesn't exist or out of memory.
6920 */
6921 char_u *
6926 {
6937 }
6939 /*
6940 * Get a number item from a dictionary.
6941 * Returns 0 if the entry doesn't exist or out of memory.
6942 */
6943 long
6947 {
6954 }
6956 /*
6957 * Return an allocated string with the string representation of a Dictionary.
6958 * May return NULL.
6959 */
6964 {
6965 garray_T ga;
6981 {
6983 {
6988 else
6993 {
6996 }
7004 }
7005 }
7007 {
7010 }
7015 }
7017 /*
7018 * Allocate a variable for a Dictionary and fill it from "*arg".
7019 * Return OK or FAIL. Returns NOTDONE for {expr}.
7020 */
7021 static int
7026 {
7028 typval_T tvkey;
7029 typval_T tv;
7035 /*
7036 * First check if it's not a curly-braces thing: {expr}.
7037 * Must do this without evaluating, otherwise a function may be called
7038 * twice. Unfortunately this means we need to call eval1() twice for the
7039 * first item.
7040 * But {} is an empty Dictionary.
7041 */
7043 {
7048 }
7051 {
7055 }
7061 {
7065 {
7069 }
7071 {
7074 {
7075 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
7080 }
7081 }
7085 {
7089 }
7091 {
7094 {
7099 }
7103 {
7108 }
7109 }
7114 {
7117 }
7119 }
7122 {
7124 failret:
7128 }
7132 {
7136 }
7139 }
7141 /*
7142 * Return a string with the string representation of a variable.
7143 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7144 * "numbuf" is used for a number.
7145 * Does not put quotes around strings, as ":echo" displays values.
7146 * When "copyID" is not NULL replace recursive lists and dicts with "...".
7147 * May return NULL.
7148 */
7155 {
7160 {
7164 }
7168 {
7176 {
7179 }
7181 {
7184 }
7185 else
7186 {
7190 }
7195 {
7198 }
7200 {
7203 }
7204 else
7205 {
7209 }
7218 #ifdef FEAT_FLOAT
7224 #endif
7229 }
7233 }
7235 /*
7236 * Return a string with the string representation of a variable.
7237 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7238 * "numbuf" is used for a number.
7239 * Puts quotes around strings, so that they can be parsed back by eval().
7240 * May return NULL.
7241 */
7248 {
7250 {
7257 #ifdef FEAT_FLOAT
7262 #endif
7269 }
7271 }
7273 /*
7274 * Return string "str" in ' quotes, doubling ' characters.
7275 * If "str" is NULL an empty string is assumed.
7276 * If "function" is TRUE make it function('string').
7277 */
7282 {
7288 {
7293 }
7296 {
7298 {
7301 }
7302 else
7306 {
7310 }
7315 }
7317 }
7319 #ifdef FEAT_FLOAT
7320 /*
7321 * Convert the string "text" to a floating point number.
7322 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
7323 * this always uses a decimal point.
7324 * Returns the length of the text that was consumed.
7325 */
7326 static int
7330 {
7332 float_T f;
7337 }
7338 #endif
7340 /*
7341 * Get the value of an environment variable.
7342 * "arg" is pointing to the '$'. It is advanced to after the name.
7343 * If the environment variable was not set, silently assume it is empty.
7344 * Always return OK.
7345 */
7346 static int
7351 {
7362 {
7364 {
7367 /* first try vim_getenv(), fast for normal environment vars */
7370 {
7373 }
7374 else
7375 {
7379 /* next try expanding things like $VIM and ${HOME} */
7382 {
7385 }
7386 }
7388 }
7391 }
7394 }
7396 /*
7397 * Array with names and number of arguments of all internal functions
7398 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7399 */
7400 static struct fst
7401 {
7406 /* implementation of function */
7408 {
7409 #ifdef FEAT_FLOAT
7411 #endif
7417 #ifdef FEAT_FLOAT
7419 #endif
7434 #ifdef FEAT_FLOAT
7436 #endif
7442 #if defined(FEAT_INS_EXPAND)
7446 #endif
7449 #ifdef FEAT_FLOAT
7451 #endif
7475 #ifdef FEAT_FLOAT
7478 #endif
7553 #ifdef FEAT_FLOAT
7555 #endif
7568 #ifdef vim_mkdir
7570 #endif
7575 #ifdef FEAT_FLOAT
7577 #endif
7595 #ifdef FEAT_FLOAT
7597 #endif
7617 #ifdef FEAT_FLOAT
7619 #endif
7625 #ifdef FEAT_FLOAT
7628 #endif
7630 #ifdef HAVE_STRFTIME
7632 #endif
7656 #ifdef FEAT_FLOAT
7658 #endif
7673 };
7675 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7677 /*
7678 * Function given to ExpandGeneric() to obtain the list of internal
7679 * or user defined function names.
7680 */
7681 char_u *
7685 {
7692 {
7696 }
7698 {
7704 }
7707 }
7709 /*
7710 * Function given to ExpandGeneric() to obtain the list of internal or
7711 * user defined variable or function names.
7712 */
7713 /*ARGSUSED*/
7714 char_u *
7718 {
7725 {
7729 }
7731 }
7735 /*
7736 * Find internal function in table above.
7737 * Return index, or -1 if not found
7738 */
7739 static int
7742 {
7748 /*
7749 * Find the function name in the table. Binary search.
7750 */
7752 {
7759 else
7761 }
7763 }
7765 /*
7766 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7767 * name it contains, otherwise return "name".
7768 */
7773 {
7782 {
7784 {
7787 }
7790 }
7793 }
7795 /*
7796 * Allocate a variable for the result of a function.
7797 * Return OK or FAIL.
7798 */
7799 static int
7811 {
7817 /*
7818 * Get the arguments.
7819 */
7822 {
7827 {
7830 }
7834 }
7837 else
7844 {
7847 else
7849 }
7856 }
7859 /*
7860 * Call a function with its resolved parameters
7861 * Return OK when the function can't be called, FAIL otherwise.
7862 * Also returns OK when an error was encountered while executing the function.
7863 */
7864 static int
7872 PLUS ONE elements! */
7878 {
7880 #define ERROR_UNKNOWN 0
7881 #define ERROR_TOOMANY 1
7882 #define ERROR_TOOFEW 2
7883 #define ERROR_SCRIPT 3
7884 #define ERROR_DICT 4
7885 #define ERROR_NONE 5
7886 #define ERROR_OTHER 6
7892 #define FLEN_FIXED 40
7896 /*
7897 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7898 * Change <SNR>123_name() to K_SNR 123_name().
7899 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7900 */
7905 {
7911 {
7914 else
7915 {
7918 }
7919 }
7921 {
7924 }
7925 else
7926 {
7930 else
7931 {
7934 }
7935 }
7936 }
7937 else
7943 /* execute the function if no errors detected and executing */
7945 {
7950 {
7951 /*
7952 * User defined function.
7953 */
7956 #ifdef FEAT_AUTOCMD
7957 /* Trigger FuncUndefined event, may load the function. */
7962 {
7963 /* executed an autocommand, search for the function again */
7965 }
7966 #endif
7967 /* Try loading a package. */
7969 {
7970 /* loaded a package, search for the function again */
7972 }
7975 {
7984 else
7985 {
7986 /*
7987 * Call the user function.
7988 * Save and restore search patterns, script variables and
7989 * redo buffer.
7990 */
7999 /* Function was unreferenced while being used, free it
8000 * now. */
8005 }
8006 }
8007 }
8008 else
8009 {
8010 /*
8011 * Find the function name in the table, call its implementation.
8012 */
8015 {
8020 else
8021 {
8025 }
8026 }
8027 }
8028 /*
8029 * The function call (or "FuncUndefined" autocommand sequence) might
8030 * have been aborted by an error, an interrupt, or an explicitly thrown
8031 * exception that has not been caught so far. This situation can be
8032 * tested for by calling aborting(). For an error in an internal
8033 * function or for the "E132" error in call_user_func(), however, the
8034 * throw point at which the "force_abort" flag (temporarily reset by
8035 * emsg()) is normally updated has not been reached yet. We need to
8036 * update that flag first to make aborting() reliable.
8037 */
8039 }
8043 /*
8044 * Report an error unless the argument evaluation or function call has been
8045 * cancelled due to an aborting error, an interrupt, or an exception.
8046 */
8048 {
8050 {
8059 name);
8063 name);
8067 name);
8069 }
8070 }
8077 }
8079 /*
8080 * Give an error message with a function name. Handle <SNR> things.
8081 */
8082 static void
8086 {
8091 else
8096 }
8098 /*
8099 * Return TRUE for a non-zero Number and a non-empty String.
8100 */
8101 static int
8104 {
8110 }
8112 /*********************************************
8113 * Implementation of the built-in functions
8114 */
8116 #ifdef FEAT_FLOAT
8117 /*
8118 * "abs(expr)" function
8119 */
8120 static void
8124 {
8126 {
8129 }
8130 else
8131 {
8132 varnumber_T n;
8140 else
8142 }
8143 }
8144 #endif
8146 /*
8147 * "add(list, item)" function
8148 */
8149 static void
8153 {
8158 {
8163 }
8164 else
8166 }
8168 /*
8169 * "append(lnum, string/list)" function
8170 */
8171 static void
8175 {
8187 {
8189 {
8194 }
8197 {
8202 else
8206 {
8209 }
8215 }
8220 }
8221 else
8223 }
8225 /*
8226 * "argc()" function
8227 */
8228 /* ARGSUSED */
8229 static void
8233 {
8235 }
8237 /*
8238 * "argidx()" function
8239 */
8240 /* ARGSUSED */
8241 static void
8245 {
8247 }
8249 /*
8250 * "argv(nr)" function
8251 */
8252 static void
8256 {
8260 {
8264 else
8267 }
8272 }
8274 #ifdef FEAT_FLOAT
8277 /*
8278 * Get the float value of "argvars[0]" into "f".
8279 * Returns FAIL when the argument is not a Number or Float.
8280 */
8281 static int
8285 {
8287 {
8290 }
8292 {
8295 }
8298 }
8300 /*
8301 * "atan()" function
8302 */
8303 static void
8307 {
8308 float_T f;
8313 else
8315 }
8316 #endif
8318 /*
8319 * "browse(save, title, initdir, default)" function
8320 */
8321 /* ARGSUSED */
8322 static void
8326 {
8327 #ifdef FEAT_BROWSE
8343 else
8347 #else
8349 #endif
8351 }
8353 /*
8354 * "browsedir(title, initdir)" function
8355 */
8356 /* ARGSUSED */
8357 static void
8361 {
8362 #ifdef FEAT_BROWSE
8372 else
8375 #else
8377 #endif
8379 }
8383 /*
8384 * Find a buffer by number or exact name.
8385 */
8389 {
8395 {
8398 {
8399 /* No full path name match, try a match with a URL or a "nofile"
8400 * buffer, these don't use the full path. */
8404 #ifdef FEAT_QUICKFIX
8406 #endif
8407 )
8410 }
8411 }
8413 }
8415 /*
8416 * "bufexists(expr)" function
8417 */
8418 static void
8422 {
8424 }
8426 /*
8427 * "buflisted(expr)" function
8428 */
8429 static void
8433 {
8438 }
8440 /*
8441 * "bufloaded(expr)" function
8442 */
8443 static void
8447 {
8452 }
8456 /*
8457 * Get buffer by number or pattern.
8458 */
8462 {
8477 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8489 /* If not found, try expanding the name, like done for bufexists(). */
8494 }
8496 /*
8497 * "bufname(expr)" function
8498 */
8499 static void
8503 {
8512 else
8515 }
8517 /*
8518 * "bufnr(expr)" function
8519 */
8520 static void
8524 {
8534 /* If the buffer isn't found and the second argument is not zero create a
8535 * new buffer. */
8539 && !error
8546 else
8548 }
8550 /*
8551 * "bufwinnr(nr)" function
8552 */
8553 static void
8557 {
8558 #ifdef FEAT_WINDOWS
8561 #endif
8567 #ifdef FEAT_WINDOWS
8569 {
8573 }
8575 #else
8577 #endif
8579 }
8581 /*
8582 * "byte2line(byte)" function
8583 */
8584 /*ARGSUSED*/
8585 static void
8589 {
8590 #ifndef FEAT_BYTEOFF
8592 #else
8598 else
8601 #endif
8602 }
8604 /*
8605 * "byteidx()" function
8606 */
8607 /*ARGSUSED*/
8608 static void
8612 {
8613 #ifdef FEAT_MBYTE
8615 #endif
8625 #ifdef FEAT_MBYTE
8628 {
8632 }
8634 #else
8637 #endif
8638 }
8640 /*
8641 * "call(func, arglist)" function
8642 */
8643 static void
8647 {
8657 {
8660 }
8666 else
8672 {
8674 {
8677 }
8679 }
8683 {
8685 {
8688 }
8689 /* Make a copy of each argument. This is needed to be able to set
8690 * v_lock to VAR_FIXED in the copy without changing the original list.
8691 */
8693 }
8700 /* Free the arguments. */
8703 }
8705 #ifdef FEAT_FLOAT
8706 /*
8707 * "ceil({float})" function
8708 */
8709 static void
8713 {
8714 float_T f;
8719 else
8721 }
8722 #endif
8724 /*
8725 * "changenr()" function
8726 */
8727 /*ARGSUSED*/
8728 static void
8732 {
8734 }
8736 /*
8737 * "char2nr(string)" function
8738 */
8739 static void
8743 {
8744 #ifdef FEAT_MBYTE
8747 else
8748 #endif
8750 }
8752 /*
8753 * "cindent(lnum)" function
8754 */
8755 static void
8759 {
8760 #ifdef FEAT_CINDENT
8761 pos_T pos;
8762 linenr_T lnum;
8767 {
8771 }
8772 else
8773 #endif
8775 }
8777 /*
8778 * "clearmatches()" function
8779 */
8780 /*ARGSUSED*/
8781 static void
8785 {
8786 #ifdef FEAT_SEARCH_EXTRA
8788 #endif
8789 }
8791 /*
8792 * "col(string)" function
8793 */
8794 static void
8798 {
8805 {
8807 {
8808 /* '> can be MAXCOL, get the length of the line then */
8811 else
8813 }
8814 else
8815 {
8817 #ifdef FEAT_VIRTUALEDIT
8818 /* col(".") when the cursor is on the NUL at the end of the line
8819 * because of "coladd" can be seen as an extra column. */
8821 {
8826 {
8827 # ifdef FEAT_MBYTE
8832 # else
8835 # endif
8836 }
8837 }
8838 #endif
8839 }
8840 }
8842 }
8844 #if defined(FEAT_INS_EXPAND)
8845 /*
8846 * "complete()" function
8847 */
8848 /*ARGSUSED*/
8849 static void
8853 {
8857 {
8860 }
8862 /* Check for undo allowed here, because if something was already inserted
8863 * the line was already saved for undo and this check isn't done. */
8868 {
8871 }
8878 }
8880 /*
8881 * "complete_add()" function
8882 */
8883 /*ARGSUSED*/
8884 static void
8888 {
8890 }
8892 /*
8893 * "complete_check()" function
8894 */
8895 /*ARGSUSED*/
8896 static void
8900 {
8907 }
8908 #endif
8910 /*
8911 * "confirm(message, buttons[, default [, type]])" function
8912 */
8913 /*ARGSUSED*/
8914 static void
8918 {
8919 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8933 {
8938 {
8941 {
8945 else
8946 {
8948 {
8954 }
8955 }
8956 }
8957 }
8958 }
8965 else
8968 #else
8970 #endif
8971 }
8973 /*
8974 * "copy()" function
8975 */
8976 static void
8980 {
8982 }
8984 #ifdef FEAT_FLOAT
8985 /*
8986 * "cos()" function
8987 */
8988 static void
8992 {
8993 float_T f;
8998 else
9000 }
9001 #endif
9003 /*
9004 * "count()" function
9005 */
9006 static void
9010 {
9015 {
9021 {
9024 {
9029 {
9032 {
9036 }
9037 }
9040 }
9045 }
9046 }
9048 {
9054 {
9058 {
9062 }
9066 {
9068 {
9072 }
9073 }
9074 }
9075 }
9076 else
9079 }
9081 /*
9082 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
9083 *
9084 * Checks the existence of a cscope connection.
9085 */
9086 /*ARGSUSED*/
9087 static void
9091 {
9092 #ifdef FEAT_CSCOPE
9100 {
9105 }
9108 #else
9110 #endif
9111 }
9113 /*
9114 * "cursor(lnum, col)" function
9115 *
9116 * Moves the cursor to the specified line and column
9117 */
9118 /*ARGSUSED*/
9119 static void
9123 {
9125 #ifdef FEAT_VIRTUALEDIT
9127 #endif
9130 {
9131 pos_T pos;
9137 #ifdef FEAT_VIRTUALEDIT
9139 #endif
9140 }
9141 else
9142 {
9145 #ifdef FEAT_VIRTUALEDIT
9148 #endif
9149 }
9151 #ifdef FEAT_VIRTUALEDIT
9153 #endif
9154 )
9160 #ifdef FEAT_VIRTUALEDIT
9162 #endif
9164 /* Make sure the cursor is in a valid position. */
9166 #ifdef FEAT_MBYTE
9167 /* Correct cursor for multi-byte character. */
9170 #endif
9173 }
9175 /*
9176 * "deepcopy()" function
9177 */
9178 static void
9182 {
9189 else
9191 }
9193 /*
9194 * "delete()" function
9195 */
9196 static void
9200 {
9203 else
9205 }
9207 /*
9208 * "did_filetype()" function
9209 */
9210 /*ARGSUSED*/
9211 static void
9215 {
9216 #ifdef FEAT_AUTOCMD
9218 #else
9220 #endif
9221 }
9223 /*
9224 * "diff_filler()" function
9225 */
9226 /*ARGSUSED*/
9227 static void
9231 {
9232 #ifdef FEAT_DIFF
9234 #endif
9235 }
9237 /*
9238 * "diff_hlID()" function
9239 */
9240 /*ARGSUSED*/
9241 static void
9245 {
9246 #ifdef FEAT_DIFF
9262 {
9263 /* New line, buffer, change: need to get the values. */
9266 {
9268 {
9273 else
9275 }
9276 else
9278 }
9279 else
9284 }
9287 {
9291 else
9293 }
9295 #endif
9296 }
9298 /*
9299 * "empty({expr})" function
9300 */
9301 static void
9305 {
9309 {
9318 #ifdef FEAT_FLOAT
9322 #endif
9334 }
9337 }
9339 /*
9340 * "escape({string}, {chars})" function
9341 */
9342 static void
9346 {
9352 }
9354 /*
9355 * "eval()" function
9356 */
9357 /*ARGSUSED*/
9358 static void
9362 {
9370 {
9373 }
9376 }
9378 /*
9379 * "eventhandler()" function
9380 */
9381 /*ARGSUSED*/
9382 static void
9386 {
9388 }
9390 /*
9391 * "executable()" function
9392 */
9393 static void
9397 {
9399 }
9401 /*
9402 * "exists()" function
9403 */
9404 static void
9408 {
9416 {
9417 /* first try "normal" environment variables (fast) */
9420 else
9421 {
9422 /* try expanding things like $VIM and ${HOME} */
9427 }
9428 }
9430 {
9434 }
9436 {
9438 }
9440 {
9442 }
9444 {
9445 #ifdef FEAT_AUTOCMD
9448 else
9450 #endif
9451 }
9453 {
9455 typval_T tv;
9457 /* get_name_len() takes care of expanding curly braces */
9461 {
9466 {
9467 /* handle d.key, l[idx], f(expr) */
9471 }
9472 }
9477 }
9480 }
9482 /*
9483 * "expand()" function
9484 */
9485 static void
9489 {
9494 expand_T xpc;
9500 {
9504 }
9505 else
9506 {
9507 /* When the optional second argument is non-zero, don't remove matches
9508 * for 'suffixes' and 'wildignore' */
9513 {
9517 }
9518 else
9520 }
9521 }
9523 /*
9524 * "extend(list, list [, idx])" function
9525 * "extend(dict, dict [, action])" function
9526 */
9527 static void
9531 {
9534 {
9544 {
9546 {
9553 else
9554 {
9557 {
9560 }
9561 }
9562 }
9563 else
9568 }
9569 }
9571 {
9583 {
9584 /* Check the third argument. */
9586 {
9596 {
9599 }
9600 }
9601 else
9604 /* Go over all entries in the second dict and add them to the
9605 * first dict. */
9608 {
9610 {
9614 {
9618 }
9620 {
9623 }
9625 {
9628 }
9629 }
9630 }
9633 }
9634 }
9635 else
9637 }
9639 /*
9640 * "feedkeys()" function
9641 */
9642 /*ARGSUSED*/
9643 static void
9647 {
9654 /* This is not allowed in the sandbox. If the commands would still be
9655 * executed in the sandbox it would be OK, but it probably happens later,
9656 * when "sandbox" is no longer set. */
9663 {
9665 {
9668 {
9670 {
9674 }
9675 }
9676 }
9678 /* Need to escape K_SPECIAL and CSI before putting the string in the
9679 * typeahead buffer. */
9682 {
9688 }
9689 }
9690 }
9692 /*
9693 * "filereadable()" function
9694 */
9695 static void
9699 {
9704 #ifndef O_NONBLOCK
9705 # define O_NONBLOCK 0
9706 #endif
9710 {
9713 }
9714 else
9718 }
9720 /*
9721 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9722 * rights to write into.
9723 */
9724 static void
9728 {
9730 }
9734 static void
9739 {
9740 #ifdef FEAT_SEARCHPATH
9749 #endif
9754 #ifdef FEAT_SEARCHPATH
9758 {
9762 else
9763 {
9769 }
9770 }
9776 {
9777 do
9778 {
9784 find_what,
9786 find_what == FINDFILE_DIR
9794 }
9798 #endif
9799 }
9804 /*
9805 * Implementation of map() and filter().
9806 */
9807 static void
9812 {
9821 typval_T save_val;
9822 typval_T save_key;
9830 {
9834 }
9836 {
9840 }
9841 else
9842 {
9845 }
9848 /* On type errors, the preceding call has already displayed an error
9849 * message. Avoid a misleading error message for an empty string that
9850 * was not passed as argument. */
9852 {
9856 /* We reset "did_emsg" to be able to detect whether an error
9857 * occurred during evaluation of the expression. */
9862 {
9870 {
9872 {
9884 }
9885 }
9889 }
9890 else
9891 {
9893 {
9902 }
9903 }
9908 }
9911 }
9913 static int
9919 {
9920 typval_T rettv;
9929 {
9932 }
9934 {
9935 /* map(): replace the list item value */
9939 }
9940 else
9941 {
9944 /* filter(): when expr is zero remove the item */
9947 /* On type error, nothing has been removed; return FAIL to stop the
9948 * loop. The error message was given by get_tv_number_chk(). */
9951 }
9953 theend:
9956 }
9958 /*
9959 * "filter()" function
9960 */
9961 static void
9965 {
9967 }
9969 /*
9970 * "finddir({fname}[, {path}[, {count}]])" function
9971 */
9972 static void
9976 {
9978 }
9980 /*
9981 * "findfile({fname}[, {path}[, {count}]])" function
9982 */
9983 static void
9987 {
9989 }
9991 #ifdef FEAT_FLOAT
9992 /*
9993 * "float2nr({float})" function
9994 */
9995 static void
9999 {
10000 float_T f;
10003 {
10008 else
10010 }
10011 else
10013 }
10015 /*
10016 * "floor({float})" function
10017 */
10018 static void
10022 {
10023 float_T f;
10028 else
10030 }
10031 #endif
10033 /*
10034 * "fnameescape({string})" function
10035 */
10036 static void
10040 {
10044 }
10046 /*
10047 * "fnamemodify({fname}, {mods})" function
10048 */
10049 static void
10053 {
10065 else
10066 {
10069 }
10074 else
10077 }
10081 /*
10082 * "foldclosed()" function
10083 */
10084 static void
10089 {
10090 #ifdef FEAT_FOLDING
10091 linenr_T lnum;
10096 {
10098 {
10101 else
10104 }
10105 }
10106 #endif
10108 }
10110 /*
10111 * "foldclosed()" function
10112 */
10113 static void
10117 {
10119 }
10121 /*
10122 * "foldclosedend()" function
10123 */
10124 static void
10128 {
10130 }
10132 /*
10133 * "foldlevel()" function
10134 */
10135 static void
10139 {
10140 #ifdef FEAT_FOLDING
10141 linenr_T lnum;
10146 else
10147 #endif
10149 }
10151 /*
10152 * "foldtext()" function
10153 */
10154 /*ARGSUSED*/
10155 static void
10159 {
10160 #ifdef FEAT_FOLDING
10161 linenr_T lnum;
10166 #endif
10170 #ifdef FEAT_FOLDING
10175 {
10176 /* Find first non-empty line in the fold. */
10179 {
10183 }
10185 /* Find interesting text in this line. */
10187 /* skip C comment-start */
10189 {
10193 {
10197 }
10198 }
10205 {
10211 /* remove 'foldmarker' and 'commentstring' */
10214 }
10215 }
10216 #endif
10217 }
10219 /*
10220 * "foldtextresult(lnum)" function
10221 */
10222 /*ARGSUSED*/
10223 static void
10227 {
10228 #ifdef FEAT_FOLDING
10229 linenr_T lnum;
10232 foldinfo_T foldinfo;
10234 #endif
10238 #ifdef FEAT_FOLDING
10240 /* treat illegal types and illegal string values for {lnum} the same */
10245 {
10251 }
10252 #endif
10253 }
10255 /*
10256 * "foreground()" function
10257 */
10258 /*ARGSUSED*/
10259 static void
10263 {
10265 #ifdef FEAT_GUI
10268 #else
10269 # ifdef WIN32
10271 # endif
10272 #endif
10273 }
10275 /*
10276 * "function()" function
10277 */
10278 /*ARGSUSED*/
10279 static void
10283 {
10292 else
10293 {
10296 }
10297 }
10299 /*
10300 * "garbagecollect()" function
10301 */
10302 /*ARGSUSED*/
10303 static void
10307 {
10308 /* This is postponed until we are back at the toplevel, because we may be
10309 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
10314 }
10316 /*
10317 * "get()" function
10318 */
10319 static void
10323 {
10331 {
10333 {
10339 }
10340 }
10342 {
10344 {
10348 }
10349 }
10350 else
10354 {
10357 else
10359 }
10360 else
10362 }
10364 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
10366 /*
10367 * Get line or list of lines from buffer "buf" into "rettv".
10368 * Return a range (from start to end) of lines in rettv from the specified
10369 * buffer.
10370 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
10371 */
10372 static void
10375 linenr_T start;
10376 linenr_T end;
10379 {
10383 {
10386 }
10387 else
10394 {
10397 else
10402 }
10403 else
10404 {
10416 }
10417 }
10419 /*
10420 * "getbufline()" function
10421 */
10422 static void
10426 {
10427 linenr_T lnum;
10428 linenr_T end;
10439 else
10443 }
10445 /*
10446 * "getbufvar()" function
10447 */
10448 static void
10452 {
10467 {
10468 /* set curbuf to be our buf, temporarily */
10474 else
10475 {
10477 /* let getbufvar({nr}, "") return the "b:" dictionary. The
10478 * scope prefix before the NUL byte is required by
10479 * find_var_in_ht(). */
10481 /* look up the variable */
10485 }
10487 /* restore previous notion of curbuf */
10489 }
10492 }
10494 /*
10495 * "getchar()" function
10496 */
10497 static void
10501 {
10502 varnumber_T n;
10505 /* Position the cursor. Needed after a message that ends in a space. */
10511 {
10513 /* getchar(): blocking wait. */
10516 /* getchar(1): only check if char avail */
10519 /* illegal argument or getchar(0) and no char avail: return zero */
10521 else
10522 /* getchar(0) and char avail: return char */
10527 }
10537 {
10541 /* Turn a special key into three bytes, plus modifier. */
10543 {
10547 }
10549 {
10553 }
10554 #ifdef FEAT_MBYTE
10557 #endif
10558 else
10564 #ifdef FEAT_MOUSE
10584 {
10588 linenr_T lnum;
10589 # ifdef FEAT_WINDOWS
10591 # endif
10595 {
10596 /* Find the window at the mouse coordinates and compute the
10597 * text position. */
10600 # ifdef FEAT_WINDOWS
10603 # endif
10607 }
10608 }
10609 #endif
10610 }
10611 }
10613 /*
10614 * "getcharmod()" function
10615 */
10616 /*ARGSUSED*/
10617 static void
10621 {
10623 }
10625 /*
10626 * "getcmdline()" function
10627 */
10628 /*ARGSUSED*/
10629 static void
10633 {
10636 }
10638 /*
10639 * "getcmdpos()" function
10640 */
10641 /*ARGSUSED*/
10642 static void
10646 {
10648 }
10650 /*
10651 * "getcmdtype()" function
10652 */
10653 /*ARGSUSED*/
10654 static void
10658 {
10662 {
10665 }
10666 }
10668 /*
10669 * "getcwd()" function
10670 */
10671 /*ARGSUSED*/
10672 static void
10676 {
10682 else
10683 {
10685 #ifdef BACKSLASH_IN_FILENAME
10688 #endif
10689 }
10690 }
10692 /*
10693 * "getfontname()" function
10694 */
10695 /*ARGSUSED*/
10696 static void
10700 {
10703 #ifdef FEAT_GUI
10705 {
10706 GuiFont font;
10710 {
10711 /* Get the "Normal" font. Either the name saved by
10712 * hl_set_font_name() or from the font ID. */
10715 }
10716 else
10717 {
10724 }
10728 }
10729 #endif
10730 }
10732 /*
10733 * "getfperm({fname})" function
10734 */
10735 static void
10739 {
10750 {
10753 {
10755 {
10758 }
10759 }
10760 }
10762 }
10764 /*
10765 * "getfsize({fname})" function
10766 */
10767 static void
10771 {
10780 {
10783 else
10784 {
10787 /* non-perfect check for overflow */
10790 }
10791 }
10792 else
10794 }
10796 /*
10797 * "getftime({fname})" function
10798 */
10799 static void
10803 {
10811 else
10813 }
10815 /*
10816 * "getftype({fname})" function
10817 */
10818 static void
10822 {
10832 {
10833 #ifdef S_ISREG
10838 # ifdef S_ISLNK
10841 # endif
10842 # ifdef S_ISBLK
10845 # endif
10846 # ifdef S_ISCHR
10849 # endif
10850 # ifdef S_ISFIFO
10853 # endif
10854 # ifdef S_ISSOCK
10857 # endif
10858 else
10860 #else
10861 # ifdef S_IFMT
10863 {
10866 # ifdef S_IFLNK
10868 # endif
10869 # ifdef S_IFBLK
10871 # endif
10872 # ifdef S_IFCHR
10874 # endif
10875 # ifdef S_IFIFO
10877 # endif
10878 # ifdef S_IFSOCK
10880 # endif
10882 }
10883 # else
10886 else
10888 # endif
10889 #endif
10891 }
10893 }
10895 /*
10896 * "getline(lnum, [end])" function
10897 */
10898 static void
10902 {
10903 linenr_T lnum;
10904 linenr_T end;
10909 {
10912 }
10913 else
10914 {
10917 }
10920 }
10922 /*
10923 * "getmatches()" function
10924 */
10925 /*ARGSUSED*/
10926 static void
10930 {
10931 #ifdef FEAT_SEARCH_EXTRA
10938 {
10940 {
10950 }
10951 }
10952 #endif
10953 }
10955 /*
10956 * "getpid()" function
10957 */
10958 /*ARGSUSED*/
10959 static void
10963 {
10965 }
10967 /*
10968 * "getpos(string)" function
10969 */
10970 static void
10974 {
10980 {
10985 else
10993 #ifdef FEAT_VIRTUALEDIT
10995 #endif
10997 }
10998 else
11000 }
11002 /*
11003 * "getqflist()" and "getloclist()" functions
11004 */
11005 /*ARGSUSED*/
11006 static void
11010 {
11011 #ifdef FEAT_QUICKFIX
11013 #endif
11016 #ifdef FEAT_QUICKFIX
11018 {
11021 {
11025 }
11028 }
11029 #endif
11030 }
11032 /*
11033 * "getreg()" function
11034 */
11035 static void
11039 {
11046 {
11051 }
11052 else
11061 }
11063 /*
11064 * "getregtype()" function
11065 */
11066 static void
11070 {
11077 {
11080 {
11084 }
11085 }
11086 else
11087 /* Default to v:register */
11097 {
11100 #ifdef FEAT_VISUAL
11105 #endif
11106 }
11109 }
11111 /*
11112 * "gettabwinvar()" function
11113 */
11114 static void
11118 {
11120 }
11122 /*
11123 * "getwinposx()" function
11124 */
11125 /*ARGSUSED*/
11126 static void
11130 {
11132 #ifdef FEAT_GUI
11134 {
11139 }
11140 #endif
11141 }
11143 /*
11144 * "getwinposy()" function
11145 */
11146 /*ARGSUSED*/
11147 static void
11151 {
11153 #ifdef FEAT_GUI
11155 {
11160 }
11161 #endif
11162 }
11164 /*
11165 * Find window specified by "vp" in tabpage "tp".
11166 */
11171 {
11172 #ifdef FEAT_WINDOWS
11174 #endif
11179 #ifdef FEAT_WINDOWS
11190 #else
11194 #endif
11195 }
11197 /*
11198 * "getwinvar()" function
11199 */
11200 static void
11204 {
11206 }
11208 /*
11209 * getwinvar() and gettabwinvar()
11210 */
11211 static void
11216 {
11222 #ifdef FEAT_WINDOWS
11225 else
11227 #endif
11236 {
11237 /* Set curwin to be our win, temporarily. Also set curbuf, so
11238 * that we can get buffer-local options. */
11245 else
11246 {
11248 /* let getwinvar({nr}, "") return the "w:" dictionary. The
11249 * scope prefix before the NUL byte is required by
11250 * find_var_in_ht(). */
11252 /* look up the variable */
11256 }
11258 /* restore previous notion of curwin */
11261 }
11264 }
11266 /*
11267 * "glob()" function
11268 */
11269 static void
11273 {
11274 expand_T xpc;
11281 }
11283 /*
11284 * "globpath()" function
11285 */
11286 static void
11290 {
11297 else
11299 }
11301 /*
11302 * "has()" function
11303 */
11304 static void
11308 {
11313 {
11314 #ifdef AMIGA
11316 # ifdef FEAT_ARP
11318 # endif
11319 #endif
11320 #ifdef __BEOS__
11322 #endif
11323 #ifdef MSDOS
11324 # ifdef DJGPP
11326 # else
11328 # endif
11329 #endif
11330 #ifdef MACOS
11332 #endif
11333 #if defined(MACOS_X_UNIX)
11335 #endif
11336 #ifdef OS2
11338 #endif
11339 #ifdef __QNX__
11341 #endif
11342 #ifdef RISCOS
11344 #endif
11345 #ifdef UNIX
11347 #endif
11348 #ifdef VMS
11350 #endif
11351 #ifdef WIN16
11353 #endif
11354 #ifdef WIN32
11356 #endif
11357 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
11359 #endif
11360 #ifdef WIN64
11362 #endif
11363 #ifdef EBCDIC
11365 #endif
11366 #ifndef CASE_INSENSITIVE_FILENAME
11368 #endif
11369 #ifdef FEAT_ARABIC
11371 #endif
11372 #ifdef FEAT_AUTOCMD
11374 #endif
11375 #ifdef FEAT_BEVAL
11379 # endif
11380 #endif
11381 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
11383 # ifdef ALL_BUILTIN_TCAPS
11385 # endif
11386 #endif
11387 #ifdef FEAT_BYTEOFF
11389 #endif
11390 #ifdef FEAT_CINDENT
11392 #endif
11393 #ifdef FEAT_CLIENTSERVER
11395 #endif
11396 #ifdef FEAT_CLIPBOARD
11398 #endif
11399 #ifdef FEAT_CMDL_COMPL
11401 #endif
11402 #ifdef FEAT_CMDHIST
11404 #endif
11405 #ifdef FEAT_COMMENTS
11407 #endif
11408 #ifdef FEAT_CRYPT
11410 #endif
11411 #ifdef FEAT_CSCOPE
11413 #endif
11414 #ifdef CURSOR_SHAPE
11416 #endif
11417 #ifdef DEBUG
11419 #endif
11420 #ifdef FEAT_CON_DIALOG
11422 #endif
11423 #ifdef FEAT_GUI_DIALOG
11425 #endif
11426 #ifdef FEAT_DIFF
11428 #endif
11429 #ifdef FEAT_DIGRAPHS
11431 #endif
11432 #ifdef FEAT_DND
11434 #endif
11435 #ifdef FEAT_EMACS_TAGS
11437 #endif
11439 #ifdef FEAT_EX_EXTRA
11441 #endif
11442 #ifdef FEAT_SEARCH_EXTRA
11444 #endif
11445 #ifdef FEAT_FKMAP
11447 #endif
11448 #ifdef FEAT_SEARCHPATH
11450 #endif
11451 #if defined(UNIX) && !defined(USE_SYSTEM)
11453 #endif
11454 #ifdef FEAT_FIND_ID
11456 #endif
11457 #ifdef FEAT_FLOAT
11459 #endif
11460 #ifdef FEAT_FOLDING
11462 #endif
11463 #ifdef FEAT_FOOTER
11465 #endif
11466 #if !defined(USE_SYSTEM) && defined(UNIX)
11468 #endif
11469 #ifdef FEAT_FULLSCREEN
11471 #endif
11472 #ifdef FEAT_GETTEXT
11474 #endif
11475 #ifdef FEAT_GUI
11477 #endif
11478 #ifdef FEAT_GUI_ATHENA
11479 # ifdef FEAT_GUI_NEXTAW
11481 # else
11483 # endif
11484 #endif
11485 #ifdef FEAT_GUI_GTK
11487 # ifdef HAVE_GTK2
11489 # endif
11490 #endif
11491 #ifdef FEAT_GUI_GNOME
11493 #endif
11494 #ifdef FEAT_GUI_MAC
11496 #endif
11497 #ifdef FEAT_GUI_MACVIM
11499 #endif
11500 #ifdef FEAT_GUI_MOTIF
11502 #endif
11503 #ifdef FEAT_GUI_PHOTON
11505 #endif
11506 #ifdef FEAT_GUI_W16
11508 #endif
11509 #ifdef FEAT_GUI_W32
11511 #endif
11512 #ifdef FEAT_HANGULIN
11514 #endif
11515 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11517 #endif
11518 #ifdef FEAT_INS_EXPAND
11520 #endif
11521 #ifdef FEAT_JUMPLIST
11523 #endif
11524 #ifdef FEAT_KEYMAP
11526 #endif
11527 #ifdef FEAT_LANGMAP
11529 #endif
11530 #ifdef FEAT_LIBCALL
11532 #endif
11533 #ifdef FEAT_LINEBREAK
11535 #endif
11536 #ifdef FEAT_LISP
11538 #endif
11539 #ifdef FEAT_LISTCMDS
11541 #endif
11542 #ifdef FEAT_LOCALMAP
11544 #endif
11545 #ifdef FEAT_MENU
11547 #endif
11548 #ifdef FEAT_SESSION
11550 #endif
11551 #ifdef FEAT_MODIFY_FNAME
11553 #endif
11554 #ifdef FEAT_MOUSE
11556 #endif
11557 #ifdef FEAT_MOUSESHAPE
11559 #endif
11560 #if defined(UNIX) || defined(VMS)
11561 # ifdef FEAT_MOUSE_DEC
11563 # endif
11564 # ifdef FEAT_MOUSE_GPM
11566 # endif
11567 # ifdef FEAT_MOUSE_JSB
11569 # endif
11570 # ifdef FEAT_MOUSE_NET
11572 # endif
11573 # ifdef FEAT_MOUSE_PTERM
11575 # endif
11576 # ifdef FEAT_SYSMOUSE
11578 # endif
11579 # ifdef FEAT_MOUSE_XTERM
11581 # endif
11582 #endif
11583 #ifdef FEAT_MBYTE
11585 #endif
11586 #ifdef FEAT_MBYTE_IME
11588 #endif
11589 #ifdef FEAT_MULTI_LANG
11591 #endif
11592 #ifdef FEAT_MZSCHEME
11593 #ifndef DYNAMIC_MZSCHEME
11595 #endif
11596 #endif
11597 #ifdef FEAT_OLE
11599 #endif
11600 #ifdef FEAT_OSFILETYPE
11602 #endif
11603 #ifdef FEAT_PATH_EXTRA
11605 #endif
11606 #ifdef FEAT_PERL
11607 #ifndef DYNAMIC_PERL
11609 #endif
11610 #endif
11611 #ifdef FEAT_PYTHON
11612 #ifndef DYNAMIC_PYTHON
11614 #endif
11615 #endif
11616 #ifdef FEAT_POSTSCRIPT
11618 #endif
11619 #ifdef FEAT_PRINTER
11621 #endif
11622 #ifdef FEAT_PROFILE
11624 #endif
11625 #ifdef FEAT_RELTIME
11627 #endif
11628 #ifdef FEAT_QUICKFIX
11630 #endif
11631 #ifdef FEAT_RIGHTLEFT
11633 #endif
11634 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11636 #endif
11637 #ifdef FEAT_SCROLLBIND
11639 #endif
11640 #ifdef FEAT_CMDL_INFO
11643 #endif
11644 #ifdef FEAT_SIGNS
11646 #endif
11647 #ifdef FEAT_SMARTINDENT
11649 #endif
11650 #ifdef FEAT_SNIFF
11652 #endif
11653 #ifdef FEAT_STL_OPT
11655 #endif
11656 #ifdef FEAT_SUN_WORKSHOP
11658 #endif
11659 #ifdef FEAT_NETBEANS_INTG
11661 #endif
11662 #ifdef FEAT_ODB_EDITOR
11664 #endif
11665 #ifdef FEAT_SPELL
11667 #endif
11668 #ifdef FEAT_SYN_HL
11670 #endif
11671 #if defined(USE_SYSTEM) || !defined(UNIX)
11673 #endif
11674 #ifdef FEAT_TAG_BINS
11676 #endif
11677 #ifdef FEAT_TAG_OLDSTATIC
11679 #endif
11680 #ifdef FEAT_TAG_ANYWHITE
11682 #endif
11683 #ifdef FEAT_TCL
11684 # ifndef DYNAMIC_TCL
11686 # endif
11687 #endif
11688 #ifdef TERMINFO
11690 #endif
11691 #ifdef FEAT_TERMRESPONSE
11693 #endif
11694 #ifdef FEAT_TEXTOBJ
11696 #endif
11697 #ifdef HAVE_TGETENT
11699 #endif
11700 #ifdef FEAT_TITLE
11702 #endif
11703 #ifdef FEAT_TOOLBAR
11705 #endif
11706 #ifdef FEAT_TRANSPARENCY
11708 #endif
11709 #ifdef FEAT_USR_CMDS
11712 #endif
11713 #ifdef FEAT_VIMINFO
11715 #endif
11716 #ifdef FEAT_VERTSPLIT
11718 #endif
11719 #ifdef FEAT_VIRTUALEDIT
11721 #endif
11722 #ifdef FEAT_VISUAL
11724 #endif
11725 #ifdef FEAT_VISUALEXTRA
11727 #endif
11728 #ifdef FEAT_VREPLACE
11730 #endif
11731 #ifdef FEAT_WILDIGN
11733 #endif
11734 #ifdef FEAT_WILDMENU
11736 #endif
11737 #ifdef FEAT_WINDOWS
11739 #endif
11740 #ifdef FEAT_WAK
11742 #endif
11743 #ifdef FEAT_WRITEBACKUP
11745 #endif
11746 #ifdef FEAT_XIM
11748 #endif
11749 #ifdef FEAT_XFONTSET
11751 #endif
11752 #ifdef USE_XSMP
11754 #endif
11755 #ifdef USE_XSMP_INTERACT
11757 #endif
11758 #ifdef FEAT_XCLIPBOARD
11760 #endif
11761 #ifdef FEAT_XTERM_SAVE
11763 #endif
11764 #if defined(UNIX) && defined(FEAT_X11)
11766 #endif
11767 NULL
11768 };
11773 {
11776 }
11779 {
11784 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11787 #endif
11788 #ifdef DYNAMIC_TCL
11791 #endif
11792 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11795 #endif
11796 #ifdef DYNAMIC_MZSCHEME
11799 #endif
11800 #ifdef DYNAMIC_RUBY
11803 #endif
11804 #ifdef DYNAMIC_PYTHON
11807 #endif
11808 #ifdef DYNAMIC_PERL
11811 #endif
11812 #ifdef FEAT_GUI
11815 # ifdef FEAT_GUI_W32
11818 # endif
11819 # ifdef FEAT_BROWSE
11822 # endif
11823 #endif
11824 #ifdef FEAT_SYN_HL
11827 #endif
11828 #if defined(WIN3264)
11831 #endif
11832 #ifdef FEAT_NETBEANS_INTG
11835 #endif
11836 }
11839 }
11841 /*
11842 * "has_key()" function
11843 */
11844 static void
11848 {
11851 {
11854 }
11860 }
11862 /*
11863 * "haslocaldir()" function
11864 */
11865 /*ARGSUSED*/
11866 static void
11870 {
11872 }
11874 /*
11875 * "hasmapto()" function
11876 */
11877 static void
11881 {
11890 else
11891 {
11895 }
11899 else
11901 }
11903 /*
11904 * "histadd()" function
11905 */
11906 /*ARGSUSED*/
11907 static void
11911 {
11912 #ifdef FEAT_CMDHIST
11916 #endif
11921 #ifdef FEAT_CMDHIST
11925 {
11928 {
11932 }
11933 }
11934 #endif
11935 }
11937 /*
11938 * "histdel()" function
11939 */
11940 /*ARGSUSED*/
11941 static void
11945 {
11946 #ifdef FEAT_CMDHIST
11955 /* only one argument: clear entire history */
11958 /* index given: remove that entry */
11961 else
11962 /* string given: remove all matching entries */
11966 #else
11968 #endif
11969 }
11971 /*
11972 * "histget()" function
11973 */
11974 /*ARGSUSED*/
11975 static void
11979 {
11980 #ifdef FEAT_CMDHIST
11988 else
11989 {
11993 else
11995 /* -1 on type error */
11997 }
11998 #else
12000 #endif
12002 }
12004 /*
12005 * "histnr()" function
12006 */
12007 /*ARGSUSED*/
12008 static void
12012 {
12015 #ifdef FEAT_CMDHIST
12021 else
12022 #endif
12025 }
12027 /*
12028 * "highlightID(name)" function
12029 */
12030 static void
12034 {
12036 }
12038 /*
12039 * "highlight_exists()" function
12040 */
12041 static void
12045 {
12047 }
12049 /*
12050 * "hostname()" function
12051 */
12052 /*ARGSUSED*/
12053 static void
12057 {
12063 }
12065 /*
12066 * iconv() function
12067 */
12068 /*ARGSUSED*/
12069 static void
12073 {
12074 #ifdef FEAT_MBYTE
12078 vimconv_T vimconv;
12079 #endif
12084 #ifdef FEAT_MBYTE
12091 /* If the encodings are equal, no conversion needed. */
12094 else
12100 #endif
12101 }
12103 /*
12104 * "indent()" function
12105 */
12106 static void
12110 {
12111 linenr_T lnum;
12116 else
12118 }
12120 /*
12121 * "index()" function
12122 */
12123 static void
12127 {
12135 {
12138 }
12141 {
12144 {
12147 /* Start at specified item. Use the cached index that list_find()
12148 * sets, so that a negative number also works. */
12155 }
12159 {
12162 }
12163 }
12164 }
12170 /*
12171 * This function is used by f_input() and f_inputdialog() functions. The third
12172 * argument to f_input() specifies the type of completion to use at the
12173 * prompt. The third argument to f_inputdialog() specifies the value to return
12174 * when the user cancels the prompt.
12175 */
12176 static void
12181 {
12194 #ifdef NO_CONSOLE_INPUT
12195 /* While starting up, there is no place to enter text. */
12198 #endif
12202 {
12203 /* Only the part of the message after the last NL is considered as
12204 * prompt for the command line */
12208 else
12209 {
12219 }
12223 {
12229 {
12245 }
12246 }
12255 /* since the user typed this, no need to wait for return */
12258 }
12260 }
12262 /*
12263 * "input()" function
12264 * Also handles inputsecret() when inputsecret is set.
12265 */
12266 static void
12270 {
12272 }
12274 /*
12275 * "inputdialog()" function
12276 */
12277 static void
12281 {
12282 #if defined(FEAT_GUI_TEXTDIALOG)
12283 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12285 {
12294 else
12300 else
12301 {
12307 else
12309 }
12311 }
12312 else
12313 #endif
12315 }
12317 /*
12318 * "inputlist()" function
12319 */
12320 static void
12324 {
12330 #ifdef NO_CONSOLE_INPUT
12331 /* While starting up, there is no place to enter text. */
12334 #endif
12336 {
12339 }
12348 {
12351 }
12353 /* Ask for choice. */
12359 }
12364 /*
12365 * "inputrestore()" function
12366 */
12367 /*ARGSUSED*/
12368 static void
12372 {
12374 {
12379 }
12381 {
12384 }
12385 }
12387 /*
12388 * "inputsave()" function
12389 */
12390 /*ARGSUSED*/
12391 static void
12395 {
12396 /* Add an entry to the stack of typeahead storage. */
12398 {
12403 }
12404 else
12406 }
12408 /*
12409 * "inputsecret()" function
12410 */
12411 static void
12415 {
12421 }
12423 /*
12424 * "insert()" function
12425 */
12426 static void
12430 {
12441 {
12449 else
12450 {
12453 {
12456 }
12457 }
12459 {
12462 }
12463 }
12464 }
12466 /*
12467 * "isdirectory()" function
12468 */
12469 static void
12473 {
12475 }
12477 /*
12478 * "islocked()" function
12479 */
12480 static void
12484 {
12485 lval_T lv;
12491 FNE_CHECK_START);
12493 {
12496 else
12497 {
12499 {
12502 else
12503 {
12506 {
12507 /* Consider a variable locked when:
12508 * 1. the variable itself is locked
12509 * 2. the value of the variable is locked.
12510 * 3. the List or Dict value is locked.
12511 */
12514 }
12515 }
12516 }
12522 /* List item. */
12524 else
12525 /* Dictionary item. */
12527 }
12528 }
12531 }
12535 /*
12536 * Turn a dict into a list:
12537 * "what" == 0: list of keys
12538 * "what" == 1: list of values
12539 * "what" == 2: list of items
12540 */
12541 static void
12546 {
12557 {
12560 }
12569 {
12571 {
12581 {
12582 /* keys() */
12586 }
12588 {
12589 /* values() */
12591 }
12592 else
12593 {
12594 /* items() */
12616 }
12617 }
12618 }
12619 }
12621 /*
12622 * "items(dict)" function
12623 */
12624 static void
12628 {
12630 }
12632 /*
12633 * "join()" function
12634 */
12635 static void
12639 {
12640 garray_T ga;
12645 {
12648 }
12653 else
12659 {
12664 }
12665 else
12667 }
12669 /*
12670 * "keys()" function
12671 */
12672 static void
12676 {
12678 }
12680 /*
12681 * "last_buffer_nr()" function.
12682 */
12683 /*ARGSUSED*/
12684 static void
12688 {
12697 }
12699 /*
12700 * "len()" function
12701 */
12702 static void
12706 {
12708 {
12723 }
12724 }
12728 static void
12733 {
12734 #ifdef FEAT_LIBCALL
12738 #endif
12743 else
12749 #ifdef FEAT_LIBCALL
12750 /* The first two args must be strings, otherwise its meaningless */
12752 {
12758 else
12762 string_in,
12764 string_result,
12768 }
12769 #endif
12770 }
12772 /*
12773 * "libcall()" function
12774 */
12775 static void
12779 {
12781 }
12783 /*
12784 * "libcallnr()" function
12785 */
12786 static void
12790 {
12792 }
12794 /*
12795 * "line(string)" function
12796 */
12797 static void
12801 {
12810 }
12812 /*
12813 * "line2byte(lnum)" function
12814 */
12815 /*ARGSUSED*/
12816 static void
12820 {
12821 #ifndef FEAT_BYTEOFF
12823 #else
12824 linenr_T lnum;
12829 else
12833 #endif
12834 }
12836 /*
12837 * "lispindent(lnum)" function
12838 */
12839 static void
12843 {
12844 #ifdef FEAT_LISP
12845 pos_T pos;
12846 linenr_T lnum;
12851 {
12855 }
12856 else
12857 #endif
12859 }
12861 /*
12862 * "localtime()" function
12863 */
12864 /*ARGSUSED*/
12865 static void
12869 {
12871 }
12875 static void
12880 {
12887 garray_T ga;
12890 /* return empty string for failure */
12899 {
12903 }
12904 else
12915 {
12925 }
12926 }
12928 #ifdef FEAT_FLOAT
12929 /*
12930 * "log10()" function
12931 */
12932 static void
12936 {
12937 float_T f;
12942 else
12944 }
12945 #endif
12947 /*
12948 * "map()" function
12949 */
12950 static void
12954 {
12956 }
12958 /*
12959 * "maparg()" function
12960 */
12961 static void
12965 {
12967 }
12969 /*
12970 * "mapcheck()" function
12971 */
12972 static void
12976 {
12978 }
12982 static void
12987 {
12991 regmatch_T regmatch;
13004 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
13010 {
13011 /* return empty list when there are no matches */
13014 }
13016 {
13019 }
13022 {
13026 }
13027 else
13035 {
13042 {
13047 }
13048 else
13049 {
13054 /* When "count" argument is there ignore matches before "start",
13055 * otherwise skip part of the string. Differs when pattern is "^"
13056 * or "\<". */
13059 else
13061 }
13067 }
13071 {
13075 {
13077 {
13079 {
13082 }
13087 }
13096 /* Advance to just after the match. */
13098 {
13101 }
13102 else
13103 {
13104 #ifdef FEAT_MBYTE
13107 #else
13109 #endif
13110 }
13111 }
13114 {
13116 {
13119 /* return list with matched string and submatches */
13121 {
13123 {
13127 }
13133 }
13134 }
13136 {
13137 /* return matched string */
13140 else
13143 }
13146 else
13147 {
13151 else
13155 }
13156 }
13158 }
13160 theend:
13163 }
13165 /*
13166 * "match()" function
13167 */
13168 static void
13172 {
13174 }
13176 /*
13177 * "matchadd()" function
13178 */
13179 static void
13183 {
13184 #ifdef FEAT_SEARCH_EXTRA
13197 {
13201 }
13205 {
13208 }
13211 #endif
13212 }
13214 /*
13215 * "matcharg()" function
13216 */
13217 static void
13221 {
13223 {
13224 #ifdef FEAT_SEARCH_EXTRA
13229 {
13231 {
13235 }
13236 else
13237 {
13240 }
13241 }
13242 #endif
13243 }
13244 }
13246 /*
13247 * "matchdelete()" function
13248 */
13249 static void
13253 {
13254 #ifdef FEAT_SEARCH_EXTRA
13257 #endif
13258 }
13260 /*
13261 * "matchend()" function
13262 */
13263 static void
13267 {
13269 }
13271 /*
13272 * "matchlist()" function
13273 */
13274 static void
13278 {
13280 }
13282 /*
13283 * "matchstr()" function
13284 */
13285 static void
13289 {
13291 }
13295 static void
13300 {
13306 {
13312 {
13315 {
13318 {
13325 }
13326 }
13327 }
13328 }
13330 {
13338 {
13341 {
13343 {
13347 {
13350 }
13353 }
13354 }
13355 }
13356 }
13357 else
13360 }
13362 /*
13363 * "max()" function
13364 */
13365 static void
13369 {
13371 }
13373 /*
13374 * "min()" function
13375 */
13376 static void
13380 {
13382 }
13386 /*
13387 * Create the directory in which "dir" is located, and higher levels when
13388 * needed.
13389 */
13390 static int
13394 {
13399 /* Get end of directory name in "dir".
13400 * We're done when it's "/" or "c:/". */
13405 /* If the directory exists we're done. Otherwise: create it.*/
13415 }
13417 #ifdef vim_mkdir
13418 /*
13419 * "mkdir()" function
13420 */
13421 static void
13425 {
13436 {
13441 }
13443 }
13444 #endif
13446 /*
13447 * "mode()" function
13448 */
13449 /*ARGSUSED*/
13450 static void
13454 {
13460 #ifdef FEAT_VISUAL
13462 {
13465 else
13467 }
13468 else
13469 #endif
13472 {
13478 }
13482 {
13483 #ifdef FEAT_VREPLACE
13485 {
13488 }
13489 else
13490 #endif
13493 else
13495 }
13497 {
13501 }
13503 {
13506 }
13507 else
13508 {
13512 }
13514 /* Clear out the minor mode when the argument is not a non-zero number or
13515 * non-empty string. */
13521 }
13523 /*
13524 * "nextnonblank()" function
13525 */
13526 static void
13530 {
13531 linenr_T lnum;
13534 {
13536 {
13539 }
13542 }
13544 }
13546 /*
13547 * "nr2char()" function
13548 */
13549 static void
13553 {
13556 #ifdef FEAT_MBYTE
13559 else
13560 #endif
13561 {
13564 }
13567 }
13569 /*
13570 * "pathshorten()" function
13571 */
13572 static void
13576 {
13583 else
13584 {
13589 }
13590 }
13592 #ifdef FEAT_FLOAT
13593 /*
13594 * "pow()" function
13595 */
13596 static void
13600 {
13607 else
13609 }
13610 #endif
13612 /*
13613 * "prevnonblank()" function
13614 */
13615 static void
13619 {
13620 linenr_T lnum;
13625 else
13629 }
13631 #ifdef HAVE_STDARG_H
13632 /* This dummy va_list is here because:
13633 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13634 * - locally in the function results in a "used before set" warning
13635 * - using va_start() to initialize it gives "function with fixed args" error */
13637 #endif
13639 /*
13640 * "printf()" function
13641 */
13642 static void
13646 {
13650 {
13657 /* Get the required length, allocate the buffer and do it for real. */
13662 {
13665 {
13668 }
13669 }
13671 }
13672 #endif
13673 }
13675 /*
13676 * "pumvisible()" function
13677 */
13678 /*ARGSUSED*/
13679 static void
13683 {
13685 #ifdef FEAT_INS_EXPAND
13688 #endif
13689 }
13691 /*
13692 * "range()" function
13693 */
13694 static void
13698 {
13707 {
13710 }
13711 else
13712 {
13716 }
13725 else
13726 {
13732 }
13733 }
13735 /*
13736 * "readfile()" function
13737 */
13738 static void
13742 {
13762 {
13767 }
13772 /* Always open the file in binary mode, library functions have a mind of
13773 * their own about CR-LF conversion. */
13776 {
13779 }
13783 {
13788 {
13790 {
13791 /* Only when in binary mode add an empty list item when the
13792 * last line ends in a '\n'. */
13796 /* Found end-of-line or end-of-file: add a text line to the
13797 * list. */
13806 else
13807 {
13810 {
13816 }
13817 }
13822 {
13825 }
13835 }
13838 }
13843 {
13844 /* "buf" is full, need to move text to an allocated buffer */
13846 {
13849 }
13850 else
13851 {
13854 {
13860 }
13861 }
13863 }
13864 else
13865 {
13868 }
13869 }
13871 /*
13872 * For a negative line count use only the lines at the end of the file,
13873 * free the rest.
13874 */
13877 {
13880 }
13884 }
13886 #if defined(FEAT_RELTIME)
13889 /*
13890 * Convert a List to proftime_T.
13891 * Return FAIL when there is something wrong.
13892 */
13893 static int
13897 {
13906 # ifdef WIN3264
13909 # else
13912 # endif
13914 }
13917 /*
13918 * "reltime()" function
13919 */
13920 static void
13924 {
13925 #ifdef FEAT_RELTIME
13926 proftime_T res;
13927 proftime_T start;
13930 {
13931 /* No arguments: get current time. */
13933 }
13935 {
13939 }
13940 else
13941 {
13942 /* Two arguments: compute the difference. */
13947 }
13950 {
13953 # ifdef WIN3264
13956 # else
13959 # endif
13962 }
13963 #endif
13964 }
13966 /*
13967 * "reltimestr()" function
13968 */
13969 static void
13973 {
13974 #ifdef FEAT_RELTIME
13975 proftime_T tm;
13976 #endif
13980 #ifdef FEAT_RELTIME
13983 #endif
13984 }
13986 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13990 static void
13992 {
13994 # ifdef FEAT_GUI
13996 # endif
13997 )
13998 {
14002 }
14003 }
14005 static int
14007 {
14010 {
14013 }
14015 }
14016 #endif
14018 #ifdef FEAT_CLIENTSERVER
14021 static void
14026 {
14031 # ifdef WIN32
14032 HWND w;
14033 # elif defined(FEAT_X11)
14034 Window w;
14035 # elif defined(MAC_CLIENTSERVER)
14037 # endif
14042 # ifdef FEAT_X11
14045 # endif
14051 # ifdef WIN32
14053 # elif defined(FEAT_X11)
14056 # elif defined(MAC_CLIENTSERVER)
14058 # endif
14059 {
14062 else
14065 }
14070 {
14071 dictitem_T v;
14082 }
14083 }
14084 #endif
14086 /*
14087 * "remote_expr()" function
14088 */
14089 /*ARGSUSED*/
14090 static void
14094 {
14097 #ifdef FEAT_CLIENTSERVER
14099 #endif
14100 }
14102 /*
14103 * "remote_foreground()" function
14104 */
14105 /*ARGSUSED*/
14106 static void
14110 {
14112 #ifdef FEAT_CLIENTSERVER
14113 # ifdef WIN32
14114 /* On Win32 it's done in this application. */
14115 {
14120 }
14121 # elif defined(FEAT_X11) || defined(MAC_CLIENTSERVER)
14122 /* Send a foreground() expression to the server. */
14128 # endif
14129 #endif
14130 }
14132 /*ARGSUSED*/
14133 static void
14137 {
14138 #ifdef FEAT_CLIENTSERVER
14139 dictitem_T v;
14141 # ifdef WIN32
14143 # endif
14147 {
14150 }
14153 {
14156 }
14157 # ifdef WIN32
14161 else
14162 {
14165 }
14166 # elif defined(FEAT_X11)
14173 # elif defined(MAC_CLIENTSERVER)
14175 # endif
14178 {
14187 }
14188 #else
14190 #endif
14191 }
14193 /*ARGSUSED*/
14194 static void
14198 {
14201 #ifdef FEAT_CLIENTSERVER
14205 {
14206 # ifdef WIN32
14207 /* The server's HWND is encoded in the 'id' parameter */
14214 # elif defined(FEAT_X11)
14217 # elif defined(MAC_CLIENTSERVER)
14219 # endif
14221 }
14222 #endif
14225 }
14227 /*
14228 * "remote_send()" function
14229 */
14230 /*ARGSUSED*/
14231 static void
14235 {
14238 #ifdef FEAT_CLIENTSERVER
14240 #endif
14241 }
14243 /*
14244 * "remove()" function
14245 */
14246 static void
14250 {
14262 {
14267 {
14270 {
14274 else
14275 {
14279 }
14280 }
14281 }
14282 }
14287 {
14295 else
14296 {
14298 {
14299 /* Remove one item, return its value. */
14303 }
14304 else
14305 {
14306 /* Remove range of items, return list with values. */
14312 else
14313 {
14317 {
14321 }
14324 else
14325 {
14328 {
14335 }
14336 }
14337 }
14338 }
14339 }
14340 }
14341 }
14343 /*
14344 * "rename({from}, {to})" function
14345 */
14346 static void
14350 {
14355 else
14358 }
14360 /*
14361 * "repeat()" function
14362 */
14363 /*ARGSUSED*/
14364 static void
14368 {
14378 {
14384 }
14385 else
14386 {
14398 {
14402 }
14405 }
14406 }
14408 /*
14409 * "resolve()" function
14410 */
14411 static void
14415 {
14419 #ifdef FEAT_SHORTCUT
14420 {
14426 else
14428 }
14429 #else
14430 # ifdef HAVE_READLINK
14431 {
14453 {
14454 /* Separate the first path component in "p", and keep the
14455 * remainder (beginning with the path separator). */
14458 }
14461 {
14463 {
14470 {
14476 }
14478 /* Ensure that the result will have a trailing path separator
14479 * if the argument has one. */
14483 /* Separate the first path component in the link value and
14484 * concatenate the remainders. */
14487 {
14490 else
14491 {
14494 {
14497 }
14498 }
14500 }
14504 {
14505 /* Ignore trailing path separator. */
14508 }
14510 {
14511 /* symlink is relative to directory of argument */
14514 {
14519 }
14520 }
14521 else
14522 {
14525 }
14526 }
14531 /* Append the first path component of "remain" to "p". */
14536 {
14540 }
14541 /* Shorten "remain". */
14544 else
14545 {
14548 }
14549 }
14551 /* If the result is a relative path name, make it explicitly relative to
14552 * the current directory if and only if the argument had this form. */
14554 {
14563 {
14564 /* Prepend "./". */
14567 {
14570 }
14571 }
14573 {
14574 /* Strip leading "./". */
14580 }
14581 }
14583 /* Ensure that the result will have no trailing path separator
14584 * if the argument had none. But keep "/" or "//". */
14586 {
14590 }
14593 }
14594 # else
14596 # endif
14597 #endif
14601 #ifdef HAVE_READLINK
14602 fail:
14603 #endif
14605 }
14607 /*
14608 * "reverse({list})" function
14609 */
14610 static void
14614 {
14623 {
14628 {
14632 }
14637 }
14638 }
14650 /*
14651 * Get flags for a search function.
14652 * Possibly sets "p_ws".
14653 * Returns BACKWARD, FORWARD or zero (for an error).
14654 */
14655 static int
14659 {
14666 {
14671 {
14673 {
14680 {
14688 }
14690 {
14693 }
14694 else
14696 }
14700 }
14701 }
14703 }
14705 /*
14706 * Shared by search() and searchpos() functions
14707 */
14708 static int
14713 {
14716 pos_T pos;
14717 pos_T save_cursor;
14722 proftime_T tm;
14723 #ifdef FEAT_RELTIME
14725 #endif
14739 /* Optional arguments: line number to stop searching and timeout. */
14741 {
14745 #ifdef FEAT_RELTIME
14747 {
14751 }
14752 #endif
14753 }
14755 #ifdef FEAT_RELTIME
14756 /* Set the time limit, if there is one. */
14758 #endif
14760 /*
14761 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14762 * Check to make sure only those flags are set.
14763 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14764 * flags cannot be set. Check for that condition also.
14765 */
14768 {
14771 }
14777 {
14780 else
14786 {
14787 /* Store the match cursor position */
14790 }
14791 /* "/$" will put the cursor after the end of the line, may need to
14792 * correct that here */
14794 }
14796 /* If 'n' flag is used: restore cursor position. */
14799 else
14801 theend:
14805 }
14807 #ifdef FEAT_FLOAT
14808 /*
14809 * "round({float})" function
14810 */
14811 static void
14815 {
14816 float_T f;
14820 /* round() is not in C90, use ceil() or floor() instead. */
14822 else
14824 }
14825 #endif
14827 /*
14828 * "search()" function
14829 */
14830 static void
14834 {
14838 }
14840 /*
14841 * "searchdecl()" function
14842 */
14843 static void
14847 {
14857 {
14861 }
14865 }
14867 /*
14868 * Used by searchpair() and searchpairpos()
14869 */
14870 static int
14874 {
14887 /* Get the three pattern arguments: start, middle, end. */
14894 /* Handle the optional fourth argument: flags */
14899 /* Don't accept SP_END or SP_SUBPAT.
14900 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14901 */
14904 {
14907 }
14909 /* Using 'r' implies 'W', otherwise it doesn't work. */
14913 /* Optional fifth argument: skip expression */
14917 else
14918 {
14921 {
14925 #ifdef FEAT_RELTIME
14927 {
14931 }
14932 #endif
14933 }
14934 }
14941 theend:
14945 }
14947 /*
14948 * "searchpair()" function
14949 */
14950 static void
14954 {
14956 }
14958 /*
14959 * "searchpairpos()" function
14960 */
14961 static void
14965 {
14966 pos_T match_pos;
14976 {
14979 }
14983 }
14985 /*
14986 * Search for a start/middle/end thing.
14987 * Used by searchpair(), see its documentation for the details.
14988 * Returns 0 or -1 for no match,
14989 */
14990 long
15002 {
15006 pos_T pos;
15007 pos_T firstpos;
15008 pos_T foundpos;
15009 pos_T save_cursor;
15010 pos_T save_pos;
15016 proftime_T tm;
15018 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15022 #ifdef FEAT_RELTIME
15023 /* Set the time limit, if there is one. */
15025 #endif
15027 /* Make two search patterns: start/end (pat2, for in nested pairs) and
15028 * start/middle/end (pat3, for the top pair). */
15036 else
15048 {
15052 /* didn't find it or found the first match again: FAIL */
15058 {
15059 /* Found the same position again. Can happen with a pattern that
15060 * has "\zs" at the end and searching backwards. Advance one
15061 * character and try again. */
15064 else
15066 }
15069 /* clear the start flag to avoid getting stuck here */
15072 /* If the skip pattern matches, ignore this match. */
15074 {
15080 {
15081 /* Evaluating {skip} caused an error, break here. */
15085 }
15088 }
15091 {
15092 /* Found end when searching backwards or start when searching
15093 * forward: nested pair. */
15096 }
15097 else
15098 {
15099 /* Found end when searching forward or start when searching
15100 * backward: end of (nested) pair; or found middle in outer pair. */
15103 }
15106 {
15107 /* Found the match: return matchcount or line number. */
15110 else
15118 }
15119 }
15122 {
15123 /* Store the match cursor position */
15126 }
15128 /* If 'n' flag is used or search failed: restore cursor position. */
15132 theend:
15137 else
15138 /* Darn, evaluating the {skip} expression changed the value. */
15142 }
15144 /*
15145 * "searchpos()" function
15146 */
15147 static void
15151 {
15152 pos_T match_pos;
15165 {
15168 }
15174 }
15177 /*ARGSUSED*/
15178 static void
15182 {
15183 #ifdef FEAT_CLIENTSERVER
15193 # ifdef FEAT_X11
15196 # endif
15199 {
15202 }
15204 #else
15206 #endif
15207 }
15209 /*ARGSUSED*/
15210 static void
15214 {
15217 #ifdef FEAT_CLIENTSERVER
15218 # if defined(WIN32) || defined(MAC_CLIENTSERVER)
15220 # elif defined(FEAT_X11)
15224 # endif
15225 #endif
15228 }
15230 /*
15231 * "setbufvar()" function
15232 */
15233 /*ARGSUSED*/
15234 static void
15238 {
15240 aco_save_T aco;
15255 {
15256 /* set curbuf to be our buf, temporarily */
15260 {
15270 }
15271 else
15272 {
15275 {
15280 }
15281 }
15283 /* reset notion of buffer */
15285 }
15286 }
15288 /*
15289 * "setcmdpos()" function
15290 */
15291 static void
15295 {
15300 }
15302 /*
15303 * "setline()" function
15304 */
15305 static void
15309 {
15310 linenr_T lnum;
15319 {
15322 }
15323 else
15328 {
15330 {
15331 /* list argument, get next string */
15336 }
15342 {
15343 /* existing line, replace it */
15345 {
15350 }
15351 }
15353 {
15354 /* lnum is one past the last line, append the line */
15358 }
15363 }
15367 }
15369 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15371 /*
15372 * Used by "setqflist()" and "setloclist()" functions
15373 */
15374 /*ARGSUSED*/
15375 static void
15381 {
15382 #ifdef FEAT_QUICKFIX
15385 #endif
15389 #ifdef FEAT_QUICKFIX
15392 else
15393 {
15397 {
15403 }
15407 }
15408 #endif
15409 }
15411 /*
15412 * "setloclist()" function
15413 */
15414 /*ARGSUSED*/
15415 static void
15419 {
15427 }
15429 /*
15430 * "setmatches()" function
15431 */
15432 static void
15436 {
15437 #ifdef FEAT_SEARCH_EXTRA
15444 {
15447 }
15449 {
15451 /* To some extent make sure that we are dealing with a list from
15452 * "getmatches()". */
15455 {
15458 {
15461 }
15466 {
15469 }
15471 }
15476 {
15483 }
15485 }
15486 #endif
15487 }
15489 /*
15490 * "setpos()" function
15491 */
15492 /*ARGSUSED*/
15493 static void
15497 {
15498 pos_T pos;
15505 {
15507 {
15510 {
15511 /* set cursor */
15513 {
15517 }
15518 else
15520 }
15522 {
15523 /* set mark */
15526 }
15527 else
15529 }
15530 }
15531 }
15533 /*
15534 * "setqflist()" function
15535 */
15536 /*ARGSUSED*/
15537 static void
15541 {
15543 }
15545 /*
15546 * "setreg()" function
15547 */
15548 static void
15552 {
15558 char_u yank_type;
15577 {
15583 {
15593 #ifdef FEAT_VISUAL
15597 {
15601 }
15603 #endif
15604 }
15605 }
15612 }
15614 /*
15615 * "settabwinvar()" function
15616 */
15617 static void
15621 {
15623 }
15625 /*
15626 * "setwinvar()" function
15627 */
15628 static void
15632 {
15634 }
15636 /*
15637 * "setwinvar()" and "settabwinvar()" functions
15638 */
15639 static void
15644 {
15646 #ifdef FEAT_WINDOWS
15649 #endif
15660 #ifdef FEAT_WINDOWS
15663 else
15665 #endif
15671 {
15672 #ifdef FEAT_WINDOWS
15673 /* set curwin to be our win, temporarily */
15681 #endif
15684 {
15694 }
15695 else
15696 {
15699 {
15704 }
15705 }
15707 #ifdef FEAT_WINDOWS
15708 /* Restore current tabpage and window, if still valid (autocomands can
15709 * make them invalid). */
15713 {
15716 }
15717 #endif
15718 }
15719 }
15721 /*
15722 * "shellescape({string})" function
15723 */
15724 static void
15728 {
15732 }
15734 /*
15735 * "simplify()" function
15736 */
15737 static void
15741 {
15748 }
15750 #ifdef FEAT_FLOAT
15751 /*
15752 * "sin()" function
15753 */
15754 static void
15758 {
15759 float_T f;
15764 else
15766 }
15767 #endif
15769 static int
15770 #ifdef __BORLANDC__
15771 _RTLENTRYF
15772 #endif
15774 static int
15775 #ifdef __BORLANDC__
15776 _RTLENTRYF
15777 #endif
15783 #define ITEM_COMPARE_FAIL 999
15785 /*
15786 * Compare functions for f_sort() below.
15787 */
15788 static int
15789 #ifdef __BORLANDC__
15790 _RTLENTRYF
15791 #endif
15795 {
15810 else
15815 }
15817 static int
15818 #ifdef __BORLANDC__
15819 _RTLENTRYF
15820 #endif
15824 {
15826 typval_T rettv;
15830 /* shortcut after failure in previous call; compare all items equal */
15834 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15835 * in the copy without changing the original list items. */
15847 else
15848 /* return value has wrong type */
15854 }
15856 /*
15857 * "sort({list})" function
15858 */
15859 static void
15863 {
15873 else
15874 {
15889 {
15892 else
15893 {
15901 else
15903 }
15904 }
15906 /* Make an array with each entry pointing to an item in the List. */
15915 /* test the compare function */
15920 else
15921 {
15922 /* Sort the array with item pointers. */
15927 {
15928 /* Clear the List and append the items in the sorted order. */
15933 }
15934 }
15937 }
15938 }
15940 /*
15941 * "soundfold({word})" function
15942 */
15943 static void
15947 {
15952 #ifdef FEAT_SPELL
15954 #else
15956 #endif
15957 }
15959 /*
15960 * "spellbadword()" function
15961 */
15962 /* ARGSUSED */
15963 static void
15967 {
15975 #ifdef FEAT_SPELL
15977 {
15978 /* Find the start and length of the badly spelled word. */
15982 }
15984 {
15989 {
15990 /* Check the argument for spelling. */
15992 {
15995 {
15998 }
16000 }
16001 }
16002 }
16003 #endif
16012 }
16014 /*
16015 * "spellsuggest()" function
16016 */
16017 /*ARGSUSED*/
16018 static void
16022 {
16023 #ifdef FEAT_SPELL
16027 garray_T ga;
16031 #endif
16036 #ifdef FEAT_SPELL
16038 {
16041 {
16046 {
16050 }
16051 }
16052 else
16058 {
16064 else
16065 {
16070 }
16071 }
16073 }
16074 #endif
16075 }
16077 static void
16081 {
16085 regmatch_T regmatch;
16093 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16099 {
16105 }
16116 {
16119 {
16122 else
16126 else
16130 {
16134 }
16137 /* Advance to just after the match. */
16140 else
16141 {
16142 /* Don't get stuck at the same match. */
16143 #ifdef FEAT_MBYTE
16145 #else
16147 #endif
16148 }
16150 }
16153 }
16156 }
16158 #ifdef FEAT_FLOAT
16159 /*
16160 * "sqrt()" function
16161 */
16162 static void
16166 {
16167 float_T f;
16172 else
16174 }
16176 /*
16177 * "str2float()" function
16178 */
16179 static void
16183 {
16190 }
16191 #endif
16193 /*
16194 * "str2nr()" function
16195 */
16196 static void
16200 {
16206 {
16209 {
16212 }
16213 }
16220 }
16222 #ifdef HAVE_STRFTIME
16223 /*
16224 * "strftime({format}[, {time}])" function
16225 */
16226 static void
16230 {
16241 else
16244 /* MSVC returns NULL for an invalid value of seconds. */
16247 else
16248 {
16249 # ifdef FEAT_MBYTE
16250 vimconv_T conv;
16258 # endif
16262 else
16265 # ifdef FEAT_MBYTE
16271 else
16272 # endif
16275 # ifdef FEAT_MBYTE
16276 /* Release conversion descriptors */
16279 # endif
16280 }
16281 }
16282 #endif
16284 /*
16285 * "stridx()" function
16286 */
16287 static void
16291 {
16306 {
16314 }
16319 }
16321 /*
16322 * "string()" function
16323 */
16324 static void
16328 {
16334 /* Make a copy if we have a value but it's not in allocated memory. */
16337 }
16339 /*
16340 * "strlen()" function
16341 */
16342 static void
16346 {
16349 }
16351 /*
16352 * "strpart()" function
16353 */
16354 static void
16358 {
16373 else
16376 /*
16377 * Only return the overlap between the specified part and the actual
16378 * string.
16379 */
16381 {
16384 }
16394 }
16396 /*
16397 * "strridx()" function
16398 */
16399 static void
16403 {
16420 {
16421 /* Third argument: upper limit for index */
16425 }
16426 else
16430 {
16431 /* Empty string matches past the end. */
16433 }
16434 else
16435 {
16437 {
16442 }
16443 }
16447 else
16449 }
16451 /*
16452 * "strtrans()" function
16453 */
16454 static void
16458 {
16461 }
16463 /*
16464 * "submatch()" function
16465 */
16466 static void
16470 {
16474 }
16476 /*
16477 * "substitute()" function
16478 */
16479 static void
16483 {
16496 else
16498 }
16500 /*
16501 * "synID(lnum, col, trans)" function
16502 */
16503 /*ARGSUSED*/
16504 static void
16508 {
16510 #ifdef FEAT_SYN_HL
16523 #endif
16526 }
16528 /*
16529 * "synIDattr(id, what [, mode])" function
16530 */
16531 /*ARGSUSED*/
16532 static void
16536 {
16538 #ifdef FEAT_SYN_HL
16548 {
16552 #ifdef FEAT_GUI
16554 #endif
16555 )
16557 }
16558 else
16559 {
16560 #ifdef FEAT_GUI
16563 else
16564 #endif
16567 else
16569 }
16573 {
16606 /* underline */
16608 else
16609 /* undercurl */
16612 }
16616 #endif
16619 }
16621 /*
16622 * "synIDtrans(id)" function
16623 */
16624 /*ARGSUSED*/
16625 static void
16629 {
16632 #ifdef FEAT_SYN_HL
16637 else
16638 #endif
16642 }
16644 /*
16645 * "synstack(lnum, col)" function
16646 */
16647 /*ARGSUSED*/
16648 static void
16652 {
16653 #ifdef FEAT_SYN_HL
16658 #endif
16663 #ifdef FEAT_SYN_HL
16670 {
16673 {
16679 }
16680 }
16681 #endif
16682 }
16684 /*
16685 * "system()" function
16686 */
16687 static void
16691 {
16703 {
16704 /*
16705 * Write the string to a temp file, to be used for input of the shell
16706 * command.
16707 */
16709 {
16712 }
16716 {
16719 }
16722 {
16725 }
16731 {
16734 }
16735 }
16740 #ifdef USE_CR
16741 /* translate <CR> into <NL> */
16743 {
16747 {
16750 }
16751 }
16752 #else
16753 # ifdef USE_CRNL
16754 /* translate <CR><NL> into <NL> */
16756 {
16761 {
16765 }
16767 }
16768 # endif
16769 #endif
16771 done:
16773 {
16776 }
16779 }
16781 /*
16782 * "tabpagebuflist()" function
16783 */
16784 /* ARGSUSED */
16785 static void
16789 {
16790 #ifndef FEAT_WINDOWS
16792 #else
16798 else
16799 {
16803 }
16806 else
16807 {
16810 else
16811 {
16816 }
16817 }
16818 #endif
16819 }
16822 /*
16823 * "tabpagenr()" function
16824 */
16825 /* ARGSUSED */
16826 static void
16830 {
16832 #ifdef FEAT_WINDOWS
16836 {
16840 {
16843 else
16845 }
16846 }
16847 else
16849 #endif
16851 }
16854 #ifdef FEAT_WINDOWS
16857 /*
16858 * Common code for tabpagewinnr() and winnr().
16859 */
16860 static int
16864 {
16872 {
16879 {
16883 }
16884 else
16885 {
16888 }
16889 }
16894 {
16896 {
16897 /* didn't find it in this tabpage */
16900 }
16902 }
16904 }
16905 #endif
16907 /*
16908 * "tabpagewinnr()" function
16909 */
16910 /* ARGSUSED */
16911 static void
16915 {
16917 #ifdef FEAT_WINDOWS
16923 else
16925 #endif
16927 }
16930 /*
16931 * "tagfiles()" function
16932 */
16933 /*ARGSUSED*/
16934 static void
16938 {
16940 tagname_T tn;
16944 {
16947 }
16954 }
16956 /*
16957 * "taglist()" function
16958 */
16959 static void
16963 {
16974 }
16976 /*
16977 * "tempname()" function
16978 */
16979 /*ARGSUSED*/
16980 static void
16984 {
16990 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16991 * names. Skip 'I' and 'O', they are used for shell redirection. */
16992 do
16993 {
16998 else
16999 {
17000 #ifdef EBCDIC
17005 else
17006 #endif
17008 }
17010 }
17012 /*
17013 * "test(list)" function: Just checking the walls...
17014 */
17015 /*ARGSUSED*/
17016 static void
17020 {
17021 /* Used for unit testing. Change the code below to your liking. */
17022 #if 0
17041 #endif
17042 }
17044 /*
17045 * "tolower(string)" function
17046 */
17047 static void
17051 {
17060 {
17061 #ifdef FEAT_MBYTE
17065 {
17071 /* TODO: reallocate string when byte count changes. */
17075 }
17078 else
17079 #endif
17080 {
17083 }
17084 }
17085 }
17087 /*
17088 * "toupper(string)" function
17089 */
17090 static void
17094 {
17097 }
17099 /*
17100 * "tr(string, fromstr, tostr)" function
17101 */
17102 static void
17106 {
17111 #ifdef FEAT_MBYTE
17119 #endif
17122 garray_T ga;
17128 /* Default return value: empty string. */
17135 #ifdef FEAT_MBYTE
17137 #endif
17138 /* not multi-byte: fromstr and tostr must be the same length */
17140 {
17141 #ifdef FEAT_MBYTE
17142 error:
17143 #endif
17147 }
17149 /* fromstr and tostr have to contain the same number of chars */
17151 {
17152 #ifdef FEAT_MBYTE
17154 {
17160 {
17163 {
17165 {
17168 {
17172 }
17173 }
17177 }
17179 }
17182 {
17183 /* Check that fromstr and tostr have the same number of
17184 * (multi-byte) characters. Done only once when a character
17185 * of instr doesn't appear in fromstr. */
17188 {
17191 }
17194 }
17201 }
17202 else
17203 #endif
17204 {
17205 /* When not using multi-byte chars we can do it faster. */
17209 else
17212 }
17213 }
17215 /* add a terminating NUL */
17220 }
17222 #ifdef FEAT_FLOAT
17223 /*
17224 * "trunc({float})" function
17225 */
17226 static void
17230 {
17231 float_T f;
17235 /* trunc() is not in C90, use floor() or ceil() instead. */
17237 else
17239 }
17240 #endif
17242 /*
17243 * "type(expr)" function
17244 */
17245 static void
17249 {
17253 {
17259 #ifdef FEAT_FLOAT
17261 #endif
17263 }
17265 }
17267 /*
17268 * "values(dict)" function
17269 */
17270 static void
17274 {
17276 }
17278 /*
17279 * "virtcol(string)" function
17280 */
17281 static void
17285 {
17293 {
17296 }
17299 }
17301 /*
17302 * "visualmode()" function
17303 */
17304 /*ARGSUSED*/
17305 static void
17309 {
17310 #ifdef FEAT_VISUAL
17318 /* A non-zero number or non-empty string argument: reset mode. */
17321 #else
17323 #endif
17324 }
17326 /*
17327 * "winbufnr(nr)" function
17328 */
17329 static void
17333 {
17339 else
17341 }
17343 /*
17344 * "wincol()" function
17345 */
17346 /*ARGSUSED*/
17347 static void
17351 {
17354 }
17356 /*
17357 * "winheight(nr)" function
17358 */
17359 static void
17363 {
17369 else
17371 }
17373 /*
17374 * "winline()" function
17375 */
17376 /*ARGSUSED*/
17377 static void
17381 {
17384 }
17386 /*
17387 * "winnr()" function
17388 */
17389 /* ARGSUSED */
17390 static void
17394 {
17397 #ifdef FEAT_WINDOWS
17399 #endif
17401 }
17403 /*
17404 * "winrestcmd()" function
17405 */
17406 /* ARGSUSED */
17407 static void
17411 {
17412 #ifdef FEAT_WINDOWS
17415 garray_T ga;
17420 {
17423 # ifdef FEAT_VERTSPLIT
17426 # endif
17428 }
17432 #else
17434 #endif
17436 }
17438 /*
17439 * "winrestview()" function
17440 */
17441 /* ARGSUSED */
17442 static void
17446 {
17452 else
17453 {
17456 #ifdef FEAT_VIRTUALEDIT
17458 #endif
17463 #ifdef FEAT_DIFF
17465 #endif
17478 #ifdef FEAT_DIFF
17480 #endif
17481 }
17482 }
17484 /*
17485 * "winsaveview()" function
17486 */
17487 /* ARGSUSED */
17488 static void
17492 {
17504 #ifdef FEAT_VIRTUALEDIT
17506 #endif
17511 #ifdef FEAT_DIFF
17513 #endif
17516 }
17518 /*
17519 * "winwidth(nr)" function
17520 */
17521 static void
17525 {
17531 else
17532 #ifdef FEAT_VERTSPLIT
17534 #else
17536 #endif
17537 }
17539 /*
17540 * "writefile()" function
17541 */
17542 static void
17546 {
17559 {
17562 }
17570 /* Always open the file in binary mode, library functions have a mind of
17571 * their own about CR-LF conversion. */
17574 {
17577 }
17578 else
17579 {
17582 {
17584 {
17587 else
17590 {
17593 }
17594 }
17597 {
17600 }
17602 {
17605 }
17606 }
17608 }
17611 }
17613 /*
17614 * Translate a String variable into a position.
17615 * Returns NULL when there is an error.
17616 */
17622 {
17627 /* Argument can be [lnum, col, coladd]. */
17629 {
17639 /* Get the line number */
17644 /* Get the column number */
17650 /* We accept "$" for the column number: last column. */
17657 /* Accept a position up to the NUL after the line. */
17662 #ifdef FEAT_VIRTUALEDIT
17663 /* Get the virtual offset. Defaults to zero. */
17667 #endif
17670 }
17677 #ifdef FEAT_VISUAL
17679 {
17683 }
17684 #endif
17686 {
17691 }
17693 #ifdef FEAT_VIRTUALEDIT
17695 #endif
17698 {
17701 {
17705 }
17707 {
17711 }
17712 }
17714 {
17716 {
17719 }
17720 else
17721 {
17724 }
17726 }
17728 }
17730 /*
17731 * Convert list in "arg" into a position and optional file number.
17732 * When "fnump" is NULL there is no file number, only 3 items.
17733 * Note that the column is passed on as-is, the caller may want to decrement
17734 * it to use 1 for the first column.
17735 * Return FAIL when conversion is not possible, doesn't check the position for
17736 * validity.
17737 */
17738 static int
17743 {
17748 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17749 * when "fnump" isn't NULL and "coladd" is optional. */
17757 {
17764 }
17776 #ifdef FEAT_VIRTUALEDIT
17780 else
17782 #endif
17785 }
17787 /*
17788 * Get the length of an environment variable name.
17789 * Advance "arg" to the first character after the name.
17790 * Return 0 for error.
17791 */
17792 static int
17795 {
17800 ;
17807 }
17809 /*
17810 * Get the length of the name of a function or internal variable.
17811 * "arg" is advanced to the first non-white character after the name.
17812 * Return 0 if something is wrong.
17813 */
17814 static int
17817 {
17821 /* Find the end of the name. */
17823 ;
17831 }
17833 /*
17834 * Get the length of the name of a variable or function.
17835 * Only the name is recognized, does not handle ".key" or "[idx]".
17836 * "arg" is advanced to the first non-white character after the name.
17837 * Return -1 if curly braces expansion failed.
17838 * Return 0 if something else is wrong.
17839 * If the name contains 'magic' {}'s, expand them and return the
17840 * expanded name in an allocated string via 'alias' - caller must free.
17841 */
17842 static int
17848 {
17858 {
17859 /* hard coded <SNR>, already translated */
17862 }
17865 {
17866 /* literal "<SID>", "s:" or "<SNR>" */
17868 }
17870 /*
17871 * Find the end of the name; check for {} construction.
17872 */
17876 {
17880 {
17884 }
17886 /*
17887 * Include any <SID> etc in the expanded string:
17888 * Thus the -len here.
17889 */
17896 }
17903 }
17905 /*
17906 * Find the end of a variable or function name, taking care of magic braces.
17907 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17908 * start and end of the first magic braces item.
17909 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17910 * Return a pointer to just after the name. Equal to "arg" if there is no
17911 * valid name.
17912 */
17919 {
17925 {
17928 }
17930 /* Quick check for valid starting character. */
17940 {
17942 {
17943 /* skip over 'string' to avoid counting [ and ] inside it. */
17945 ;
17948 }
17950 {
17951 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17957 }
17960 {
17965 }
17968 {
17970 {
17971 mb_nest++;
17974 }
17976 {
17977 mb_nest--;
17980 }
17981 }
17982 }
17985 }
17987 /*
17988 * Expands out the 'magic' {}'s in a variable/function name.
17989 * Note that this can call itself recursively, to deal with
17990 * constructs like foo{bar}{baz}{bam}
17991 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17992 * "in_start" ^
17993 * "expr_start" ^
17994 * "expr_end" ^
17995 * "in_end" ^
17996 *
17997 * Returns a new allocated string, which the caller must free.
17998 * Returns NULL for failure.
17999 */
18006 {
18007 char_u c1;
18021 {
18025 {
18029 }
18030 }
18038 {
18041 {
18042 /* Further expansion! */
18047 }
18048 }
18051 }
18053 /*
18054 * Return TRUE if character "c" can be used in a variable or function name.
18055 * Does not include '{' or '}' for magic braces.
18056 */
18057 static int
18060 {
18062 }
18064 /*
18065 * Return TRUE if character "c" can be used as the first character in a
18066 * variable or function name (excluding '{' and '}').
18067 */
18068 static int
18071 {
18073 }
18075 /*
18076 * Set number v: variable to "val".
18077 */
18078 void
18082 {
18084 }
18086 /*
18087 * Get number v: variable value.
18088 */
18089 long
18092 {
18094 }
18096 /*
18097 * Get string v: variable value. Uses a static buffer, can only be used once.
18098 */
18099 char_u *
18102 {
18104 }
18106 /*
18107 * Set v:count, v:count1 and v:prevcount.
18108 */
18109 void
18113 {
18117 }
18119 /*
18120 * Set string v: variable to a copy of "val".
18121 */
18122 void
18127 {
18128 /* Need to do this (at least) once, since we can't initialize a union.
18129 * Will always be invoked when "v:progname" is set. */
18137 else
18139 }
18141 /*
18142 * Set v:register if needed.
18143 */
18144 void
18147 {
18148 char_u regname;
18152 else
18154 /* Avoid free/alloc when the value is already right. */
18157 }
18159 /*
18160 * Get or set v:exception. If "oldval" == NULL, return the current value.
18161 * Otherwise, restore the value to "oldval" and return NULL.
18162 * Must always be called in pairs to save and restore v:exception! Does not
18163 * take care of memory allocations.
18164 */
18165 char_u *
18168 {
18174 }
18176 /*
18177 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18178 * Otherwise, restore the value to "oldval" and return NULL.
18179 * Must always be called in pairs to save and restore v:throwpoint! Does not
18180 * take care of memory allocations.
18181 */
18182 char_u *
18185 {
18191 }
18193 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18194 /*
18195 * Set v:cmdarg.
18196 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18197 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18198 * Must always be called in pairs!
18199 */
18200 char_u *
18204 {
18211 {
18215 }
18221 else
18229 # ifdef FEAT_MBYTE
18234 # endif
18244 else
18253 # ifdef FEAT_MBYTE
18260 # endif
18263 }
18264 #endif
18266 /*
18267 * Get the value of internal variable "name".
18268 * Return OK or FAIL.
18269 */
18270 static int
18276 {
18279 typval_T atv;
18283 /* truncate the name, so that we can use strcmp() */
18287 /*
18288 * Check for "b:changedtick".
18289 */
18291 {
18295 }
18297 /*
18298 * Check for user-defined variables.
18299 */
18300 else
18301 {
18305 }
18308 {
18312 }
18319 }
18321 /*
18322 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18323 * Also handle function call with Funcref variable: func(expr)
18324 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18325 */
18326 static int
18332 {
18337 typval_T functv;
18344 {
18346 {
18347 /* need to copy the funcref so that we can clear rettv */
18351 /* Invoke the function. Recursive! */
18357 /* Clear the funcref afterwards, so that deleting it while
18358 * evaluating the arguments is possible (see test55). */
18361 /* Stop the expression evaluation when immediately aborting on
18362 * error, or when an interrupt occurred or an exception was thrown
18363 * but not caught. */
18365 {
18369 }
18372 }
18374 {
18377 {
18381 }
18382 else
18385 {
18388 }
18389 }
18390 }
18393 }
18395 /*
18396 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18397 * value).
18398 */
18401 {
18403 }
18405 /*
18406 * Allocate memory for a variable type-value, and assign a string to it.
18407 * The string "s" must have been allocated, it is consumed.
18408 * Return NULL for out of memory, the variable otherwise.
18409 */
18413 {
18418 {
18421 }
18422 else
18425 }
18427 /*
18428 * Free the memory for a variable type-value.
18429 */
18430 void
18433 {
18435 {
18437 {
18440 /*FALLTHROUGH*/
18451 #ifdef FEAT_FLOAT
18453 #endif
18459 }
18461 }
18462 }
18464 /*
18465 * Free the memory for a variable value and set the value to NULL or 0.
18466 */
18467 void
18470 {
18472 {
18474 {
18477 /*FALLTHROUGH*/
18493 #ifdef FEAT_FLOAT
18497 #endif
18502 }
18504 }
18505 }
18507 /*
18508 * Set the value of a variable to NULL without freeing items.
18509 */
18510 static void
18513 {
18516 }
18518 /*
18519 * Get the number value of a variable.
18520 * If it is a String variable, uses vim_str2nr().
18521 * For incompatible types, return 0.
18522 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18523 * caller of incompatible types: it sets *denote to TRUE if "denote"
18524 * is not NULL or returns -1 otherwise.
18525 */
18526 static long
18529 {
18533 }
18535 long
18539 {
18543 {
18546 #ifdef FEAT_FLOAT
18550 #endif
18568 }
18571 else
18574 }
18576 /*
18577 * Get the lnum from the first argument.
18578 * Also accepts ".", "$", etc., but that only works for the current buffer.
18579 * Returns -1 on error.
18580 */
18581 static linenr_T
18584 {
18585 typval_T rettv;
18586 linenr_T lnum;
18590 {
18595 }
18597 }
18599 /*
18600 * Get the lnum from the first argument.
18601 * Also accepts "$", then "buf" is used.
18602 * Returns 0 on error.
18603 */
18604 static linenr_T
18608 {
18615 }
18617 /*
18618 * Get the string value of a variable.
18619 * If it is a Number variable, the number is converted into a string.
18620 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18621 * get_tv_string_buf() uses a given buffer.
18622 * If the String variable has never been set, return an empty string.
18623 * Never returns NULL;
18624 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18625 * NULL on error.
18626 */
18630 {
18634 }
18640 {
18644 }
18646 char_u *
18649 {
18653 }
18659 {
18661 {
18674 #ifdef FEAT_FLOAT
18678 #endif
18686 }
18688 }
18690 /*
18691 * Find variable "name" in the list of variables.
18692 * Return a pointer to it if found, NULL if not found.
18693 * Careful: "a:0" variables don't have a name.
18694 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18695 * hashtab_T used.
18696 */
18701 {
18711 }
18713 /*
18714 * Find variable "varname" in hashtab "ht".
18715 * Returns NULL if not found.
18716 */
18722 {
18726 {
18727 /* Must be something like "s:", otherwise "ht" would be NULL. */
18729 {
18735 #ifdef FEAT_WINDOWS
18737 #endif
18742 }
18744 }
18748 {
18749 /* For global variables we may try auto-loading the script. If it
18750 * worked find the variable again. Don't auto-load a script if it was
18751 * loaded already, otherwise it would be loaded every time when
18752 * checking if a function name is a Funcref variable. */
18758 }
18760 }
18762 /*
18763 * Find the hashtab used for a variable name.
18764 * Set "varname" to the start of name without ':'.
18765 */
18770 {
18774 {
18775 /* The name must not start with a colon or #. */
18780 /* "version" is "v:version" in all scopes */
18788 }
18792 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18793 */
18801 #ifdef FEAT_WINDOWS
18804 #endif
18815 }
18817 /*
18818 * Get the string value of a (global/local) variable.
18819 * Returns NULL when it doesn't exist.
18820 */
18821 char_u *
18824 {
18831 }
18833 /*
18834 * Allocate a new hashtab for a sourced script. It will be used while
18835 * sourcing this script and when executing functions defined in the script.
18836 */
18837 void
18839 scid_T id;
18840 {
18846 {
18847 /* Re-allocating ga_data means that an ht_array pointing to
18848 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18849 * at its init value. Also reset "v_dict", it's always the same. */
18851 {
18857 }
18860 {
18864 }
18865 }
18866 }
18868 /*
18869 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18870 * point to it.
18871 */
18872 void
18876 {
18884 }
18886 /*
18887 * Clean up a list of internal variables.
18888 * Frees all allocated variables and the value they contain.
18889 * Clears hashtab "ht", does not free it.
18890 */
18891 void
18894 {
18896 }
18898 /*
18899 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18900 */
18901 static void
18905 {
18913 {
18915 {
18918 /* Free the variable. Don't remove it from the hashtab,
18919 * ht_array might change then. hash_clear() takes care of it
18920 * later. */
18926 }
18927 }
18930 }
18932 /*
18933 * Delete a variable from hashtab "ht" at item "hi".
18934 * Clear the variable value and free the dictitem.
18935 */
18936 static void
18940 {
18946 }
18948 /*
18949 * List the value of one internal variable.
18950 */
18951 static void
18956 {
18965 }
18967 static void
18974 {
18975 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18987 {
18991 }
18993 {
18997 }
18998 else
19006 {
19009 }
19010 }
19012 /*
19013 * Set variable "name" to value in "tv".
19014 * If the variable already exists, the value is updated.
19015 * Otherwise the variable is created.
19016 */
19017 static void
19022 {
19029 {
19033 {
19036 }
19038 {
19040 name);
19042 }
19043 }
19047 {
19050 }
19054 {
19055 /* existing variable, need to clear the value */
19064 #ifdef FEAT_FLOAT
19069 #endif
19070 )
19071 {
19074 }
19076 /*
19077 * Handle setting internal v: variables separately: we don't change
19078 * the type.
19079 */
19081 {
19083 {
19087 else
19088 {
19089 /* Take over the string to avoid an extra alloc/free. */
19092 }
19093 }
19096 else
19097 {
19101 }
19103 }
19106 }
19108 {
19109 /* Can't add "v:" variable. */
19111 {
19114 }
19116 /* Make sure the variable name is valid. */
19120 {
19123 }
19131 {
19134 }
19136 }
19140 else
19141 {
19145 }
19146 }
19148 /*
19149 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19150 * Also give an error message.
19151 */
19152 static int
19156 {
19158 {
19161 }
19163 {
19166 }
19168 }
19170 /*
19171 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19172 * Also give an error message.
19173 */
19174 static int
19178 {
19180 {
19183 }
19185 }
19187 /*
19188 * Return TRUE if typeval "tv" is set to be locked (immutable).
19189 * Also give an error message, using "name".
19190 */
19191 static int
19195 {
19197 {
19201 }
19203 {
19207 }
19209 }
19211 /*
19212 * Copy the values from typval_T "from" to typval_T "to".
19213 * When needed allocates string or increases reference count.
19214 * Does not make a copy of a list or dict but copies the reference!
19215 */
19216 static void
19220 {
19224 {
19228 #ifdef FEAT_FLOAT
19232 #endif
19237 else
19238 {
19242 }
19247 else
19248 {
19251 }
19256 else
19257 {
19260 }
19265 }
19266 }
19268 /*
19269 * Make a copy of an item.
19270 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19271 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19272 * reference to an already copied list/dict can be used.
19273 * Returns FAIL or OK.
19274 */
19275 static int
19281 {
19286 {
19289 }
19293 {
19295 #ifdef FEAT_FLOAT
19297 #endif
19308 {
19309 /* use the copy made earlier */
19312 }
19313 else
19324 {
19325 /* use the copy made earlier */
19328 }
19329 else
19337 }
19340 }
19342 /*
19343 * ":echo expr1 ..." print each argument separated with a space, add a
19344 * newline at the end.
19345 * ":echon expr1 ..." print each argument plain.
19346 */
19347 void
19350 {
19352 typval_T rettv;
19362 {
19363 /* If eval1() causes an error message the text from the command may
19364 * still need to be cleared. E.g., "echo 22,44". */
19369 {
19370 /*
19371 * Report the invalid expression unless the expression evaluation
19372 * has been cancelled due to an aborting error, an interrupt, or an
19373 * exception.
19374 */
19379 }
19383 {
19385 {
19387 /* Call msg_start() after eval1(), evaluating the expression
19388 * may cause a message to appear. */
19391 }
19397 {
19399 {
19401 {
19402 /* remove any text still there from the command */
19405 }
19407 }
19408 else
19409 {
19410 #ifdef FEAT_MBYTE
19412 {
19417 }
19418 else
19419 #endif
19421 }
19422 }
19424 }
19427 }
19432 else
19433 {
19434 /* remove text that may still be there from the command */
19439 }
19440 }
19442 /*
19443 * ":echohl {name}".
19444 */
19445 void
19448 {
19454 else
19456 }
19458 /*
19459 * ":execute expr1 ..." execute the result of an expression.
19460 * ":echomsg expr1 ..." Print a message
19461 * ":echoerr expr1 ..." Print an error
19462 * Each gets spaces around each argument and a newline at the end for
19463 * echo commands
19464 */
19465 void
19468 {
19470 typval_T rettv;
19473 garray_T ga;
19482 {
19485 {
19486 /*
19487 * Report the invalid expression unless the expression evaluation
19488 * has been cancelled due to an aborting error, an interrupt, or an
19489 * exception.
19490 */
19495 }
19498 {
19502 {
19506 }
19511 }
19515 }
19518 {
19520 {
19523 }
19525 {
19526 /* We don't want to abort following commands, restore did_emsg. */
19531 }
19535 }
19543 }
19545 /*
19546 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19547 * "arg" points to the "&" or '+' when called, to "option" when returning.
19548 * Returns NULL when no option name found. Otherwise pointer to the char
19549 * after the option name.
19550 */
19555 {
19560 {
19563 }
19565 {
19568 }
19569 else
19578 else
19582 }
19584 /*
19585 * ":function"
19586 */
19587 void
19590 {
19599 garray_T newargs;
19600 garray_T newlines;
19609 funcdict_T fudi;
19617 /*
19618 * ":function" without argument: list functions.
19619 */
19621 {
19623 {
19626 {
19628 {
19633 }
19634 }
19635 }
19638 }
19640 /*
19641 * ":function /pat": list functions matching pattern.
19642 */
19644 {
19647 {
19648 regmatch_T regmatch;
19655 {
19660 {
19662 {
19668 }
19669 }
19670 }
19671 }
19676 }
19678 /*
19679 * Get the function name. There are these situations:
19680 * func normal function name
19681 * "name" == func, "fudi.fd_dict" == NULL
19682 * dict.func new dictionary entry
19683 * "name" == NULL, "fudi.fd_dict" set,
19684 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19685 * dict.func existing dict entry with a Funcref
19686 * "name" == func, "fudi.fd_dict" set,
19687 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19688 * dict.func existing dict entry that's not a Funcref
19689 * "name" == NULL, "fudi.fd_dict" set,
19690 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19691 */
19696 {
19697 /*
19698 * Return on an invalid expression in braces, unless the expression
19699 * evaluation has been cancelled due to an aborting error, an
19700 * interrupt, or an exception.
19701 */
19703 {
19708 }
19709 else
19711 }
19713 /* An error in a function call during evaluation of an expression in magic
19714 * braces should not cause the function not to be defined. */
19718 /*
19719 * ":function func" with only function name: list function.
19720 */
19722 {
19724 {
19727 }
19732 {
19735 {
19738 {
19750 }
19752 {
19755 }
19756 }
19757 else
19759 }
19761 }
19763 /*
19764 * ":function name(arg1, arg2)" Define function.
19765 */
19768 {
19770 {
19773 }
19774 /* attempt to continue by skipping some text */
19777 }
19784 {
19785 /* Check the name of the function. Unless it's a dictionary function
19786 * (that we are overwriting). */
19789 else
19793 {
19796 else
19803 }
19804 }
19806 /*
19807 * Isolate the arguments: "arg1, arg2, ...)"
19808 */
19810 {
19812 {
19816 }
19817 else
19818 {
19825 {
19829 }
19842 else
19844 }
19847 {
19851 }
19852 }
19855 /* find extra arguments "range", "dict" and "abort" */
19857 {
19860 {
19863 }
19865 {
19868 }
19870 {
19873 }
19874 else
19876 }
19878 /* When there is a line break use what follows for the function body.
19879 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19885 /*
19886 * Read the body of the function, until ":endfunction" is found.
19887 */
19889 {
19890 /* Check if the function already exists, don't let the user type the
19891 * whole function before telling him it doesn't work! For a script we
19892 * need to skip the body to be able to find what follows. */
19894 {
19899 }
19906 }
19911 {
19917 {
19918 /* Use eap->arg, split up in parts by line breaks. */
19923 else
19924 {
19927 }
19928 }
19931 else
19936 {
19939 }
19941 /* Detect line continuation: sourcing_lnum increased more than one. */
19944 else
19948 {
19949 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19950 * don't check for ":endfunc". */
19952 {
19955 }
19956 }
19957 else
19958 {
19959 /* skip ':' and blanks*/
19961 ;
19963 /* Check for "endfunction". */
19965 {
19969 }
19971 /* Increase indent inside "if", "while", "for" and "try", decrease
19972 * at "end". */
19981 /* Check for defining a function inside this function. */
19983 {
19988 {
19991 {
19994 }
19995 }
19996 }
19998 /* Check for ":append" or ":insert". */
20006 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
20019 ))
20020 {
20021 /* ":python <<" continues until a dot, like ":append" */
20025 else
20027 }
20028 }
20030 /* Add the line to the function. */
20032 {
20036 }
20038 /* Copy the line to newly allocated memory. get_one_sourceline()
20039 * allocates 250 bytes per line, this saves 80% on average. The cost
20040 * is an extra alloc/free. */
20043 {
20047 }
20051 /* Add NULL lines for continuation lines, so that the line count is
20052 * equal to the index in the growarray. */
20056 /* Check for end of eap->arg. */
20059 }
20061 /* Don't define the function when skipping commands or when an error was
20062 * detected. */
20066 /*
20067 * If there are no errors, add the function
20068 */
20070 {
20073 {
20075 name);
20077 }
20081 {
20083 {
20086 }
20088 {
20090 name);
20092 }
20093 /* redefine existing function */
20098 }
20099 }
20100 else
20101 {
20106 {
20109 }
20111 {
20112 /* Can't add a function to a locked dictionary */
20115 }
20116 /* Can't change an existing function if it is locked */
20120 /* Give the function a sequential number. Can only be used with a
20121 * Funcref! */
20127 }
20130 {
20132 {
20136 /* Check that the autoload name matches the script name. */
20139 {
20142 {
20150 }
20151 }
20153 {
20156 }
20157 }
20164 {
20166 {
20167 /* add new dict entry */
20170 {
20173 }
20175 {
20179 }
20180 }
20181 else
20182 /* overwrite existing dict entry */
20189 /* behave like "dict" was used */
20191 }
20193 /* insert the new function in the function list */
20196 }
20199 #ifdef FEAT_PROFILE
20206 #endif
20213 erret:
20216 ret_free:
20221 }
20223 /*
20224 * Get a function name, translating "<SID>" and "<SNR>".
20225 * Also handles a Funcref in a List or Dictionary.
20226 * Returns the function name in allocated memory, or NULL for failure.
20227 * flags:
20228 * TFN_INT: internal function name OK
20229 * TFN_QUIET: be quiet
20230 * Advances "pp" to just after the function name (if no error).
20231 */
20238 {
20245 lval_T lv;
20251 /* Check for hard coded <SNR>: already translated function ID (from a user
20252 * command). */
20255 {
20259 }
20261 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20262 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20270 {
20274 }
20276 {
20277 /*
20278 * Report an invalid expression in braces, unless the expression
20279 * evaluation has been cancelled due to an aborting error, an
20280 * interrupt, or an exception.
20281 */
20283 {
20286 }
20287 else
20290 }
20293 {
20295 {
20300 }
20302 {
20305 }
20306 else
20307 {
20311 else
20314 }
20316 }
20319 {
20320 /* Error found, but continue after the function name. */
20323 }
20325 /* Check if the name is a Funcref. If so, use the value. */
20327 {
20332 }
20333 else
20334 {
20339 }
20341 {
20345 }
20348 {
20352 {
20353 /* When there was "s:" already or the name expanded to get a
20354 * leading "s:" then remove it. */
20358 }
20359 }
20360 else
20361 {
20365 }
20367 /*
20368 * Copy the function name to allocated memory.
20369 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20370 * Accept <SNR>123_name() outside a script.
20371 */
20375 {
20379 {
20380 /* It's "s:" or "<SID>" */
20382 {
20385 }
20388 }
20389 }
20391 {
20394 }
20397 {
20399 {
20405 }
20408 }
20411 theend:
20414 }
20416 /*
20417 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20418 * Return 2 if "p" starts with "s:".
20419 * Return 0 otherwise.
20420 */
20421 static int
20424 {
20431 }
20433 /*
20434 * Return TRUE if "p" starts with "<SID>" or "s:".
20435 * Only works if eval_fname_script() returned non-zero for "p"!
20436 */
20437 static int
20440 {
20442 }
20444 /*
20445 * List the head of the function: "name(arg1, arg2)".
20446 */
20447 static void
20451 {
20459 {
20462 }
20463 else
20467 {
20471 }
20473 {
20477 }
20482 }
20484 /*
20485 * Find a function by name, return pointer to it in ufuncs.
20486 * Return NULL for unknown function.
20487 */
20491 {
20498 }
20500 #if defined(EXITFREE) || defined(PROTO)
20501 void
20503 {
20506 /* Need to start all over every time, because func_free() may change the
20507 * hash table. */
20511 {
20514 }
20515 }
20516 #endif
20518 /*
20519 * Return TRUE if a function "name" exists.
20520 */
20521 static int
20524 {
20532 /* Only accept "funcname", "funcname ", "funcname (..." and
20533 * "funcname(...", not "funcname!...". */
20535 {
20538 else
20540 }
20543 }
20545 /*
20546 * Return TRUE if "name" looks like a builtin function name: starts with a
20547 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20548 */
20549 static int
20552 {
20555 }
20557 #if defined(FEAT_PROFILE) || defined(PROTO)
20558 /*
20559 * Start profiling function "fp".
20560 */
20561 static void
20564 {
20583 }
20585 /*
20586 * Dump the profiling results for all functions in file "fd".
20587 */
20588 void
20591 {
20603 {
20605 {
20609 {
20615 else
20619 else
20627 {
20633 }
20635 }
20636 }
20637 }
20640 {
20642 prof_total_cmp);
20645 prof_self_cmp);
20647 }
20648 }
20650 static void
20657 {
20664 {
20667 prefer_self);
20670 else
20672 }
20674 }
20676 /*
20677 * Print the count and times for one function or function line.
20678 */
20679 static void
20686 {
20688 {
20692 else
20696 else
20698 }
20699 else
20701 }
20703 /*
20704 * Compare function for total time sorting.
20705 */
20706 static int
20707 #ifdef __BORLANDC__
20708 _RTLENTRYF
20709 #endif
20713 {
20719 }
20721 /*
20722 * Compare function for self time sorting.
20723 */
20724 static int
20725 #ifdef __BORLANDC__
20726 _RTLENTRYF
20727 #endif
20731 {
20737 }
20739 #endif
20741 /*
20742 * If "name" has a package name try autoloading the script for it.
20743 * Return TRUE if a package was loaded.
20744 */
20745 static int
20749 {
20755 /* If there is no '#' after name[0] there is no package name. */
20762 /* Find the name in the list of previously loaded package names. Skip
20763 * "autoload/", it's always the same. */
20769 else
20770 {
20771 /* Remember the name if it wasn't loaded already. */
20773 {
20776 }
20778 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20781 }
20785 }
20787 /*
20788 * Return the autoload script name for a function or variable name.
20789 * Returns NULL when out of memory.
20790 */
20794 {
20798 /* Get the script file name: replace '#' with '/', append ".vim". */
20809 }
20811 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20813 /*
20814 * Function given to ExpandGeneric() to obtain the list of user defined
20815 * function names.
20816 */
20817 char_u *
20821 {
20827 {
20830 }
20832 {
20844 {
20848 }
20850 }
20852 }
20856 /*
20857 * Copy the function name of "fp" to buffer "buf".
20858 * "buf" must be able to hold the function name plus three bytes.
20859 * Takes care of script-local function names.
20860 */
20861 static void
20865 {
20867 {
20870 }
20871 else
20873 }
20875 /*
20876 * ":delfunction {name}"
20877 */
20878 void
20881 {
20885 funcdict_T fudi;
20891 {
20895 }
20897 {
20901 }
20911 {
20913 {
20916 }
20918 {
20921 }
20924 {
20925 /* Delete the dict item that refers to the function, it will
20926 * invoke func_unref() and possibly delete the function. */
20928 }
20929 else
20931 }
20932 }
20934 /*
20935 * Free a function and remove it from the list of functions.
20936 */
20937 static void
20940 {
20943 /* clear this function */
20946 #ifdef FEAT_PROFILE
20950 #endif
20952 /* remove the function from the function hashtable */
20956 else
20960 }
20962 /*
20963 * Unreference a Function: decrement the reference count and free it when it
20964 * becomes zero. Only for numbered functions.
20965 */
20966 static void
20969 {
20973 {
20978 {
20979 /* Only delete it when it's not being used. Otherwise it's done
20980 * when "uf_calls" becomes zero. */
20983 }
20984 }
20985 }
20987 /*
20988 * Count a reference to a Function.
20989 */
20990 static void
20993 {
20997 {
21001 else
21003 }
21004 }
21006 /*
21007 * Call a user function.
21008 */
21009 static void
21018 {
21020 linenr_T save_sourcing_lnum;
21021 scid_T save_current_SID;
21022 funccall_T fc;
21031 #ifdef FEAT_PROFILE
21032 proftime_T wait_start;
21033 proftime_T call_start;
21034 #endif
21036 /* If depth of calling is getting too high, don't execute the function */
21038 {
21043 }
21056 /* Check if this function has a breakpoint. */
21060 /*
21061 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21062 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21063 * each argument variable and saves a lot of time.
21064 */
21065 /*
21066 * Init l: variables.
21067 */
21070 {
21071 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21072 * some compiler that checks the destination size. */
21082 }
21084 /*
21085 * Init a: variables.
21086 * Set a:0 to "argcount".
21087 * Set a:000 to a list with room for the "..." arguments.
21088 */
21103 /*
21104 * Set a:firstline to "firstline" and a:lastline to "lastline".
21105 * Set a:name to named arguments.
21106 * Set a:N to the "..." arguments.
21107 */
21113 {
21116 /* named argument a:name */
21118 else
21119 {
21120 /* "..." argument a:1, a:2, etc. */
21123 }
21125 {
21128 }
21129 else
21130 {
21136 }
21140 /* Note: the values are copied directly to avoid alloc/free.
21141 * "argvars" must have VAR_FIXED for v_lock. */
21146 {
21150 }
21151 }
21153 /* Don't redraw while executing the function. */
21161 {
21165 else
21170 {
21176 {
21184 {
21189 else
21190 {
21193 {
21197 }
21198 }
21199 }
21201 }
21206 }
21207 }
21208 #ifdef FEAT_PROFILE
21210 {
21215 {
21219 }
21221 }
21222 #endif
21229 /* call do_cmdline() to execute the lines */
21235 /* when the function was aborted because of an error, return -1 */
21237 {
21241 }
21243 #ifdef FEAT_PROFILE
21246 {
21252 {
21255 }
21256 }
21257 #endif
21259 /* when being verbose, mention the return value */
21261 {
21270 else
21271 {
21277 /* The value may be very long. Skip the middle part, so that we
21278 * have some idea how it starts and ends. smsg() would always
21279 * truncate it at the end. */
21282 {
21286 }
21287 }
21292 }
21298 #ifdef FEAT_PROFILE
21301 #endif
21304 {
21313 }
21318 /* The a: variables typevals were not allocated, only free the allocated
21319 * variables. */
21324 }
21326 /*
21327 * Add a number variable "name" to dict "dp" with value "nr".
21328 */
21329 static void
21334 varnumber_T nr;
21335 {
21342 }
21344 /*
21345 * ":return [expr]"
21346 */
21347 void
21350 {
21352 typval_T rettv;
21356 {
21359 }
21367 {
21370 else
21372 }
21373 /* It's safer to return also on error. */
21375 {
21376 /*
21377 * Return unless the expression evaluation has been cancelled due to an
21378 * aborting error, an interrupt, or an exception.
21379 */
21382 }
21384 /* When skipping or the return gets pending, advance to the next command
21385 * in this line (!returning). Otherwise, ignore the rest of the line.
21386 * Following lines will be ignored by get_func_line(). */
21394 }
21396 /*
21397 * Return from a function. Possibly makes the return pending. Also called
21398 * for a pending return at the ":endtry" or after returning from an extra
21399 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21400 * when called due to a ":return" command. "rettv" may point to a typval_T
21401 * with the return rettv. Returns TRUE when the return can be carried out,
21402 * FALSE when the return gets pending.
21403 */
21404 int
21410 {
21415 /* Undo the return. */
21418 /*
21419 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21420 * not in its finally clause (which then is to be executed next) is found.
21421 * In this case, make the ":return" pending for execution at the ":endtry".
21422 * Otherwise, return normally.
21423 */
21426 {
21430 /* A pending return again gets pending. "rettv" points to an
21431 * allocated variable with the rettv of the original ":return"'s
21432 * argument if present or is NULL else. */
21434 else
21435 {
21436 /* When undoing a return in order to make it pending, get the stored
21437 * return rettv. */
21442 {
21443 /* Store the value of the pending return. */
21446 else
21448 }
21449 else
21453 {
21454 /* The pending return value could be overwritten by a ":return"
21455 * without argument in a finally clause; reset the default
21456 * return value. */
21459 }
21460 }
21462 }
21463 else
21464 {
21467 /* If the return is carried out now, store the return value. For
21468 * a return immediately after reanimation, the value is already
21469 * there. */
21471 {
21476 }
21477 }
21480 }
21482 /*
21483 * Free the variable with a pending return value.
21484 */
21485 void
21488 {
21490 }
21492 /*
21493 * Generate a return command for producing the value of "rettv". The result
21494 * is an allocated string. Used by report_pending() for verbose messages.
21495 */
21496 char_u *
21499 {
21515 }
21517 /*
21518 * Get next function line.
21519 * Called by do_cmdline() to get the next line.
21520 * Returns allocated string, or NULL for end of function.
21521 */
21522 /* ARGSUSED */
21523 char_u *
21528 {
21534 /* If breakpoints have been added/deleted need to check for it. */
21536 {
21538 sourcing_lnum);
21540 }
21541 #ifdef FEAT_PROFILE
21544 #endif
21550 else
21551 {
21552 /* Skip NULL lines (continuation lines). */
21558 else
21559 {
21562 #ifdef FEAT_PROFILE
21565 #endif
21566 }
21567 }
21569 /* Did we encounter a breakpoint? */
21571 {
21573 /* Find next breakpoint. */
21575 sourcing_lnum);
21577 }
21580 }
21582 #if defined(FEAT_PROFILE) || defined(PROTO)
21583 /*
21584 * Called when starting to read a function line.
21585 * "sourcing_lnum" must be correct!
21586 * When skipping lines it may not actually be executed, but we won't find out
21587 * until later and we need to store the time now.
21588 */
21589 void
21592 {
21598 {
21600 /* Skip continuation lines. */
21607 }
21608 }
21610 /*
21611 * Called when actually executing a function line.
21612 */
21613 void
21616 {
21622 }
21624 /*
21625 * Called when done with a function line.
21626 */
21627 void
21630 {
21635 {
21637 {
21644 }
21646 }
21647 }
21648 #endif
21650 /*
21651 * Return TRUE if the currently active function should be ended, because a
21652 * return was encountered or an error occurred. Used inside a ":while".
21653 */
21654 int
21657 {
21660 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21661 * an error inside a try conditional. */
21664 }
21666 /*
21667 * return TRUE if cookie indicates a function which "abort"s on errors.
21668 */
21669 int
21672 {
21674 }
21676 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21678 {
21681 VAR_FLAVOUR_VIMINFO /* all uppercase */
21686 static var_flavour_T
21689 {
21693 {
21698 }
21699 else
21701 }
21702 #endif
21704 #if defined(FEAT_VIMINFO) || defined(PROTO)
21705 /*
21706 * Restore global vars that start with a capital from the viminfo file
21707 */
21708 int
21712 {
21715 typval_T tv;
21718 {
21721 {
21725 #ifdef FEAT_FLOAT
21728 #endif
21732 {
21737 #ifdef FEAT_FLOAT
21740 #endif
21741 else
21746 }
21747 }
21748 }
21751 }
21753 /*
21754 * Write global vars that start with a capital to the viminfo file
21755 */
21756 void
21759 {
21775 {
21777 {
21781 {
21783 {
21786 #ifdef FEAT_FLOAT
21788 #endif
21790 }
21796 }
21797 }
21798 }
21799 }
21800 #endif
21802 #if defined(FEAT_SESSION) || defined(PROTO)
21803 int
21806 {
21814 {
21816 {
21822 {
21823 /* Escape special characters with a backslash. Turn a LF and
21824 * CR into \n and \r. */
21838 p,
21842 {
21845 }
21847 }
21848 #ifdef FEAT_FLOAT
21851 {
21856 {
21859 }
21864 }
21865 #endif
21866 }
21867 }
21869 }
21870 #endif
21872 /*
21873 * Display script name where an item was last set.
21874 * Should only be invoked when 'verbose' is non-zero.
21875 */
21876 void
21878 scid_T scriptID;
21879 {
21883 {
21886 {
21892 }
21893 }
21894 }
21899 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21901 #ifdef WIN3264
21902 /*
21903 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21904 */
21906 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21909 /*
21910 * Get the short path (8.3) for the filename in "fnamep".
21911 * Only works for a valid file name.
21912 * When the path gets longer "fnamep" is changed and the allocated buffer
21913 * is put in "bufp".
21914 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21915 * Returns OK on success, FAIL on failure.
21916 */
21917 static int
21922 {
21929 {
21930 /* If that doesn't work (not enough space), then save the string
21931 * and try again with a new buffer big enough. */
21939 /* Really should always succeed, as the buffer is big enough. */
21941 }
21945 }
21947 /*
21948 * Get the short path (8.3) for the filename in "fname". The converted
21949 * path is returned in "bufp".
21950 *
21951 * Some of the directories specified in "fname" may not exist. This function
21952 * will shorten the existing directories at the beginning of the path and then
21953 * append the remaining non-existing path.
21954 *
21955 * fname - Pointer to the filename to shorten. On return, contains the
21956 * pointer to the shortened pathname
21957 * bufp - Pointer to an allocated buffer for the filename.
21958 * fnamelen - Length of the filename pointed to by fname
21959 *
21960 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21961 */
21962 static int
21967 {
21970 char_u ch;
21975 /* Make a copy */
21984 /*
21985 * Try shortening the supplied path till it succeeds by removing one
21986 * directory at a time from the tail of the path.
21987 */
21990 {
21991 /* go back one path-separator */
21997 /*
21998 * Replace the path separator with a NUL and try to shorten the
21999 * resulting path.
22000 */
22006 {
22009 }
22015 /* failed to shorten the path. Skip the path separator */
22017 }
22020 {
22021 /*
22022 * Succeeded in shortening the path. Now concatenate the shortened
22023 * path with the remaining path at the tail.
22024 */
22026 /* Compute the length of the new path. */
22033 {
22034 /* There is not enough space in the currently allocated string,
22035 * copy it to a buffer big enough. */
22038 {
22041 }
22042 }
22043 else
22044 {
22045 /* Transfer short_fname to the main buffer (it's big enough),
22046 * unless get_short_pathname() did its work in-place. */
22051 }
22053 /* concat the not-shortened part of the path */
22056 }
22058 theend:
22063 }
22065 /*
22066 * Get a pathname for a partial path.
22067 * Returns OK for success, FAIL for failure.
22068 */
22069 static int
22074 {
22080 /* Count up the path separators from the RHS.. so we know which part
22081 * of the path to return. */
22087 /* Need full path first (use expand_env() to remove a "~/") */
22091 else
22100 {
22101 /* Don't have a valid filename, so shorten the rest of the
22102 * path if we can. This CAN give us invalid 8.3 filenames, but
22103 * there's not a lot of point in guessing what it might be.
22104 */
22108 }
22110 /* Count the paths backward to find the beginning of the desired string. */
22112 {
22113 #ifdef FEAT_MBYTE
22116 #endif
22118 {
22121 else
22122 sepcount --;
22123 }
22124 }
22126 {
22130 else
22132 }
22133 else
22136 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22143 }
22146 /*
22147 * Adjust a filename, according to a string of modifiers.
22148 * *fnamep must be NUL terminated when called. When returning, the length is
22149 * determined by *fnamelen.
22150 * Returns VALID_ flags or -1 for failure.
22151 * When there is an error, *fnamep is set to NULL.
22152 */
22153 int
22160 {
22167 #ifdef WIN3264
22169 #endif
22171 repeat:
22172 /* ":p" - full path/file_name */
22174 {
22180 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22182 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22184 # ifdef BACKSLASH_IN_FILENAME
22186 # endif
22189 #endif
22190 )
22191 {
22197 }
22199 /* When "/." or "/.." is used: force expansion to get rid of it. */
22201 {
22209 }
22211 /* FullName_save() is slow, don't use it when not needed. */
22213 {
22219 }
22221 /* Append a path separator to a directory. */
22223 {
22224 /* Make room for one or two extra characters. */
22231 }
22232 }
22234 /* ":." - path relative to the current directory */
22235 /* ":~" - path relative to the home directory */
22236 /* ":8" - shortname path - postponed till after */
22239 {
22242 {
22243 #ifdef WIN3264
22245 #endif
22247 }
22249 /* Need full path first (use expand_env() to remove a "~/") */
22251 {
22254 else
22256 }
22257 else
22263 {
22265 {
22269 {
22272 {
22276 }
22277 }
22278 }
22279 else
22280 {
22282 /* Only replace it when it starts with '~' */
22284 {
22287 {
22291 }
22292 }
22293 }
22295 }
22296 }
22301 /* ":h" - head, remove "/file_name", can be repeated */
22302 /* Don't remove the first "/" or "c:\" */
22304 {
22311 #ifdef VMS
22314 #endif
22316 {
22317 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22324 }
22325 else
22326 {
22329 }
22330 }
22332 /* ":8" - shortname */
22334 {
22336 #ifdef WIN3264
22338 #endif
22339 }
22341 #ifdef WIN3264
22342 /* Check shortname after we have done 'heads' and before we do 'tails'
22343 */
22345 {
22347 /* Copy the string if it is shortened by :h */
22349 {
22355 }
22357 /* Split into two implementations - makes it easier. First is where
22358 * there isn't a full name already, second is where there is.
22359 */
22361 {
22364 }
22365 else
22366 {
22369 /* Simple case, already have the full-name
22370 * Nearly always shorter, so try first time. */
22376 {
22377 /* Couldn't find the filename.. search the paths.
22378 */
22382 }
22384 }
22385 }
22388 /* ":t" - tail, just the basename */
22390 {
22394 }
22396 /* ":e" - extension, can be repeated */
22397 /* ":r" - root, without extension, can be repeated */
22400 {
22401 /* find a '.' in the tail:
22402 * - for second :e: before the current fname
22403 * - otherwise: The last '.'
22404 */
22407 else
22413 {
22415 {
22418 #ifdef VMS
22419 /* cut version from the extension */
22426 #endif
22427 }
22430 }
22432 {
22435 }
22437 }
22439 /* ":s?pat?foo?" - substitute */
22440 /* ":gs?pat?foo?" - global substitute */
22444 {
22455 {
22458 }
22462 {
22463 /* find end of pattern */
22466 {
22469 {
22471 /* find end of substitution */
22474 {
22478 {
22482 {
22488 }
22489 }
22492 }
22494 }
22495 }
22496 /* after using ":s", repeat all the modifiers */
22499 }
22500 }
22503 }
22505 /*
22506 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22507 * "flags" can be "g" to do a global substitute.
22508 * Returns an allocated string, NULL for error.
22509 */
22510 char_u *
22516 {
22518 regmatch_T regmatch;
22522 garray_T ga;
22526 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22537 {
22540 {
22541 /*
22542 * Get some space for a temporary buffer to do the substitution
22543 * into. It will contain:
22544 * - The text up to where the match is.
22545 * - The substituted text.
22546 * - The text after the match.
22547 */
22551 {
22554 }
22556 /* copy the text up to where the match is */
22559 /* add the substituted text */
22563 /* avoid getting stuck on a match with an empty string */
22565 {
22570 }
22571 else
22572 {
22576 }
22579 }
22585 }
22591 else
22592 /* Darn, evaluating {sub} expression changed the value. */
22596 }