| blob | 18c8329df9cef919b2190abcadc9ca5698cf4e1e |
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)
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_GETTEXT
11471 #endif
11472 #ifdef FEAT_GUI
11474 #endif
11475 #ifdef FEAT_GUI_ATHENA
11476 # ifdef FEAT_GUI_NEXTAW
11478 # else
11480 # endif
11481 #endif
11482 #ifdef FEAT_GUI_GTK
11484 # ifdef HAVE_GTK2
11486 # endif
11487 #endif
11488 #ifdef FEAT_GUI_GNOME
11490 #endif
11491 #ifdef FEAT_GUI_MAC
11493 #endif
11494 #ifdef FEAT_GUI_MOTIF
11496 #endif
11497 #ifdef FEAT_GUI_PHOTON
11499 #endif
11500 #ifdef FEAT_GUI_W16
11502 #endif
11503 #ifdef FEAT_GUI_W32
11505 #endif
11506 #ifdef FEAT_HANGULIN
11508 #endif
11509 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11511 #endif
11512 #ifdef FEAT_INS_EXPAND
11514 #endif
11515 #ifdef FEAT_JUMPLIST
11517 #endif
11518 #ifdef FEAT_KEYMAP
11520 #endif
11521 #ifdef FEAT_LANGMAP
11523 #endif
11524 #ifdef FEAT_LIBCALL
11526 #endif
11527 #ifdef FEAT_LINEBREAK
11529 #endif
11530 #ifdef FEAT_LISP
11532 #endif
11533 #ifdef FEAT_LISTCMDS
11535 #endif
11536 #ifdef FEAT_LOCALMAP
11538 #endif
11539 #ifdef FEAT_MENU
11541 #endif
11542 #ifdef FEAT_SESSION
11544 #endif
11545 #ifdef FEAT_MODIFY_FNAME
11547 #endif
11548 #ifdef FEAT_MOUSE
11550 #endif
11551 #ifdef FEAT_MOUSESHAPE
11553 #endif
11554 #if defined(UNIX) || defined(VMS)
11555 # ifdef FEAT_MOUSE_DEC
11557 # endif
11558 # ifdef FEAT_MOUSE_GPM
11560 # endif
11561 # ifdef FEAT_MOUSE_JSB
11563 # endif
11564 # ifdef FEAT_MOUSE_NET
11566 # endif
11567 # ifdef FEAT_MOUSE_PTERM
11569 # endif
11570 # ifdef FEAT_SYSMOUSE
11572 # endif
11573 # ifdef FEAT_MOUSE_XTERM
11575 # endif
11576 #endif
11577 #ifdef FEAT_MBYTE
11579 #endif
11580 #ifdef FEAT_MBYTE_IME
11582 #endif
11583 #ifdef FEAT_MULTI_LANG
11585 #endif
11586 #ifdef FEAT_MZSCHEME
11587 #ifndef DYNAMIC_MZSCHEME
11589 #endif
11590 #endif
11591 #ifdef FEAT_OLE
11593 #endif
11594 #ifdef FEAT_OSFILETYPE
11596 #endif
11597 #ifdef FEAT_PATH_EXTRA
11599 #endif
11600 #ifdef FEAT_PERL
11601 #ifndef DYNAMIC_PERL
11603 #endif
11604 #endif
11605 #ifdef FEAT_PYTHON
11606 #ifndef DYNAMIC_PYTHON
11608 #endif
11609 #endif
11610 #ifdef FEAT_POSTSCRIPT
11612 #endif
11613 #ifdef FEAT_PRINTER
11615 #endif
11616 #ifdef FEAT_PROFILE
11618 #endif
11619 #ifdef FEAT_RELTIME
11621 #endif
11622 #ifdef FEAT_QUICKFIX
11624 #endif
11625 #ifdef FEAT_RIGHTLEFT
11627 #endif
11628 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11630 #endif
11631 #ifdef FEAT_SCROLLBIND
11633 #endif
11634 #ifdef FEAT_CMDL_INFO
11637 #endif
11638 #ifdef FEAT_SIGNS
11640 #endif
11641 #ifdef FEAT_SMARTINDENT
11643 #endif
11644 #ifdef FEAT_SNIFF
11646 #endif
11647 #ifdef FEAT_STL_OPT
11649 #endif
11650 #ifdef FEAT_SUN_WORKSHOP
11652 #endif
11653 #ifdef FEAT_NETBEANS_INTG
11655 #endif
11656 #ifdef FEAT_SPELL
11658 #endif
11659 #ifdef FEAT_SYN_HL
11661 #endif
11662 #if defined(USE_SYSTEM) || !defined(UNIX)
11664 #endif
11665 #ifdef FEAT_TAG_BINS
11667 #endif
11668 #ifdef FEAT_TAG_OLDSTATIC
11670 #endif
11671 #ifdef FEAT_TAG_ANYWHITE
11673 #endif
11674 #ifdef FEAT_TCL
11675 # ifndef DYNAMIC_TCL
11677 # endif
11678 #endif
11679 #ifdef TERMINFO
11681 #endif
11682 #ifdef FEAT_TERMRESPONSE
11684 #endif
11685 #ifdef FEAT_TEXTOBJ
11687 #endif
11688 #ifdef HAVE_TGETENT
11690 #endif
11691 #ifdef FEAT_TITLE
11693 #endif
11694 #ifdef FEAT_TOOLBAR
11696 #endif
11697 #ifdef FEAT_USR_CMDS
11700 #endif
11701 #ifdef FEAT_VIMINFO
11703 #endif
11704 #ifdef FEAT_VERTSPLIT
11706 #endif
11707 #ifdef FEAT_VIRTUALEDIT
11709 #endif
11710 #ifdef FEAT_VISUAL
11712 #endif
11713 #ifdef FEAT_VISUALEXTRA
11715 #endif
11716 #ifdef FEAT_VREPLACE
11718 #endif
11719 #ifdef FEAT_WILDIGN
11721 #endif
11722 #ifdef FEAT_WILDMENU
11724 #endif
11725 #ifdef FEAT_WINDOWS
11727 #endif
11728 #ifdef FEAT_WAK
11730 #endif
11731 #ifdef FEAT_WRITEBACKUP
11733 #endif
11734 #ifdef FEAT_XIM
11736 #endif
11737 #ifdef FEAT_XFONTSET
11739 #endif
11740 #ifdef USE_XSMP
11742 #endif
11743 #ifdef USE_XSMP_INTERACT
11745 #endif
11746 #ifdef FEAT_XCLIPBOARD
11748 #endif
11749 #ifdef FEAT_XTERM_SAVE
11751 #endif
11752 #if defined(UNIX) && defined(FEAT_X11)
11754 #endif
11755 NULL
11756 };
11761 {
11764 }
11767 {
11772 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11775 #endif
11776 #ifdef DYNAMIC_TCL
11779 #endif
11780 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11783 #endif
11784 #ifdef DYNAMIC_MZSCHEME
11787 #endif
11788 #ifdef DYNAMIC_RUBY
11791 #endif
11792 #ifdef DYNAMIC_PYTHON
11795 #endif
11796 #ifdef DYNAMIC_PERL
11799 #endif
11800 #ifdef FEAT_GUI
11803 # ifdef FEAT_GUI_W32
11806 # endif
11807 # ifdef FEAT_BROWSE
11810 # endif
11811 #endif
11812 #ifdef FEAT_SYN_HL
11815 #endif
11816 #if defined(WIN3264)
11819 #endif
11820 #ifdef FEAT_NETBEANS_INTG
11823 #endif
11824 }
11827 }
11829 /*
11830 * "has_key()" function
11831 */
11832 static void
11836 {
11839 {
11842 }
11848 }
11850 /*
11851 * "haslocaldir()" function
11852 */
11853 /*ARGSUSED*/
11854 static void
11858 {
11860 }
11862 /*
11863 * "hasmapto()" function
11864 */
11865 static void
11869 {
11878 else
11879 {
11883 }
11887 else
11889 }
11891 /*
11892 * "histadd()" function
11893 */
11894 /*ARGSUSED*/
11895 static void
11899 {
11900 #ifdef FEAT_CMDHIST
11904 #endif
11909 #ifdef FEAT_CMDHIST
11913 {
11916 {
11920 }
11921 }
11922 #endif
11923 }
11925 /*
11926 * "histdel()" function
11927 */
11928 /*ARGSUSED*/
11929 static void
11933 {
11934 #ifdef FEAT_CMDHIST
11943 /* only one argument: clear entire history */
11946 /* index given: remove that entry */
11949 else
11950 /* string given: remove all matching entries */
11954 #else
11956 #endif
11957 }
11959 /*
11960 * "histget()" function
11961 */
11962 /*ARGSUSED*/
11963 static void
11967 {
11968 #ifdef FEAT_CMDHIST
11976 else
11977 {
11981 else
11983 /* -1 on type error */
11985 }
11986 #else
11988 #endif
11990 }
11992 /*
11993 * "histnr()" function
11994 */
11995 /*ARGSUSED*/
11996 static void
12000 {
12003 #ifdef FEAT_CMDHIST
12009 else
12010 #endif
12013 }
12015 /*
12016 * "highlightID(name)" function
12017 */
12018 static void
12022 {
12024 }
12026 /*
12027 * "highlight_exists()" function
12028 */
12029 static void
12033 {
12035 }
12037 /*
12038 * "hostname()" function
12039 */
12040 /*ARGSUSED*/
12041 static void
12045 {
12051 }
12053 /*
12054 * iconv() function
12055 */
12056 /*ARGSUSED*/
12057 static void
12061 {
12062 #ifdef FEAT_MBYTE
12066 vimconv_T vimconv;
12067 #endif
12072 #ifdef FEAT_MBYTE
12079 /* If the encodings are equal, no conversion needed. */
12082 else
12088 #endif
12089 }
12091 /*
12092 * "indent()" function
12093 */
12094 static void
12098 {
12099 linenr_T lnum;
12104 else
12106 }
12108 /*
12109 * "index()" function
12110 */
12111 static void
12115 {
12123 {
12126 }
12129 {
12132 {
12135 /* Start at specified item. Use the cached index that list_find()
12136 * sets, so that a negative number also works. */
12143 }
12147 {
12150 }
12151 }
12152 }
12158 /*
12159 * This function is used by f_input() and f_inputdialog() functions. The third
12160 * argument to f_input() specifies the type of completion to use at the
12161 * prompt. The third argument to f_inputdialog() specifies the value to return
12162 * when the user cancels the prompt.
12163 */
12164 static void
12169 {
12182 #ifdef NO_CONSOLE_INPUT
12183 /* While starting up, there is no place to enter text. */
12186 #endif
12190 {
12191 /* Only the part of the message after the last NL is considered as
12192 * prompt for the command line */
12196 else
12197 {
12207 }
12211 {
12217 {
12233 }
12234 }
12243 /* since the user typed this, no need to wait for return */
12246 }
12248 }
12250 /*
12251 * "input()" function
12252 * Also handles inputsecret() when inputsecret is set.
12253 */
12254 static void
12258 {
12260 }
12262 /*
12263 * "inputdialog()" function
12264 */
12265 static void
12269 {
12270 #if defined(FEAT_GUI_TEXTDIALOG)
12271 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12273 {
12282 else
12288 else
12289 {
12295 else
12297 }
12299 }
12300 else
12301 #endif
12303 }
12305 /*
12306 * "inputlist()" function
12307 */
12308 static void
12312 {
12318 #ifdef NO_CONSOLE_INPUT
12319 /* While starting up, there is no place to enter text. */
12322 #endif
12324 {
12327 }
12336 {
12339 }
12341 /* Ask for choice. */
12347 }
12352 /*
12353 * "inputrestore()" function
12354 */
12355 /*ARGSUSED*/
12356 static void
12360 {
12362 {
12367 }
12369 {
12372 }
12373 }
12375 /*
12376 * "inputsave()" function
12377 */
12378 /*ARGSUSED*/
12379 static void
12383 {
12384 /* Add an entry to the stack of typeahead storage. */
12386 {
12391 }
12392 else
12394 }
12396 /*
12397 * "inputsecret()" function
12398 */
12399 static void
12403 {
12409 }
12411 /*
12412 * "insert()" function
12413 */
12414 static void
12418 {
12429 {
12437 else
12438 {
12441 {
12444 }
12445 }
12447 {
12450 }
12451 }
12452 }
12454 /*
12455 * "isdirectory()" function
12456 */
12457 static void
12461 {
12463 }
12465 /*
12466 * "islocked()" function
12467 */
12468 static void
12472 {
12473 lval_T lv;
12479 FNE_CHECK_START);
12481 {
12484 else
12485 {
12487 {
12490 else
12491 {
12494 {
12495 /* Consider a variable locked when:
12496 * 1. the variable itself is locked
12497 * 2. the value of the variable is locked.
12498 * 3. the List or Dict value is locked.
12499 */
12502 }
12503 }
12504 }
12510 /* List item. */
12512 else
12513 /* Dictionary item. */
12515 }
12516 }
12519 }
12523 /*
12524 * Turn a dict into a list:
12525 * "what" == 0: list of keys
12526 * "what" == 1: list of values
12527 * "what" == 2: list of items
12528 */
12529 static void
12534 {
12545 {
12548 }
12557 {
12559 {
12569 {
12570 /* keys() */
12574 }
12576 {
12577 /* values() */
12579 }
12580 else
12581 {
12582 /* items() */
12604 }
12605 }
12606 }
12607 }
12609 /*
12610 * "items(dict)" function
12611 */
12612 static void
12616 {
12618 }
12620 /*
12621 * "join()" function
12622 */
12623 static void
12627 {
12628 garray_T ga;
12633 {
12636 }
12641 else
12647 {
12652 }
12653 else
12655 }
12657 /*
12658 * "keys()" function
12659 */
12660 static void
12664 {
12666 }
12668 /*
12669 * "last_buffer_nr()" function.
12670 */
12671 /*ARGSUSED*/
12672 static void
12676 {
12685 }
12687 /*
12688 * "len()" function
12689 */
12690 static void
12694 {
12696 {
12711 }
12712 }
12716 static void
12721 {
12722 #ifdef FEAT_LIBCALL
12726 #endif
12731 else
12737 #ifdef FEAT_LIBCALL
12738 /* The first two args must be strings, otherwise its meaningless */
12740 {
12746 else
12750 string_in,
12752 string_result,
12756 }
12757 #endif
12758 }
12760 /*
12761 * "libcall()" function
12762 */
12763 static void
12767 {
12769 }
12771 /*
12772 * "libcallnr()" function
12773 */
12774 static void
12778 {
12780 }
12782 /*
12783 * "line(string)" function
12784 */
12785 static void
12789 {
12798 }
12800 /*
12801 * "line2byte(lnum)" function
12802 */
12803 /*ARGSUSED*/
12804 static void
12808 {
12809 #ifndef FEAT_BYTEOFF
12811 #else
12812 linenr_T lnum;
12817 else
12821 #endif
12822 }
12824 /*
12825 * "lispindent(lnum)" function
12826 */
12827 static void
12831 {
12832 #ifdef FEAT_LISP
12833 pos_T pos;
12834 linenr_T lnum;
12839 {
12843 }
12844 else
12845 #endif
12847 }
12849 /*
12850 * "localtime()" function
12851 */
12852 /*ARGSUSED*/
12853 static void
12857 {
12859 }
12863 static void
12868 {
12875 garray_T ga;
12878 /* return empty string for failure */
12887 {
12891 }
12892 else
12903 {
12913 }
12914 }
12916 #ifdef FEAT_FLOAT
12917 /*
12918 * "log10()" function
12919 */
12920 static void
12924 {
12925 float_T f;
12930 else
12932 }
12933 #endif
12935 /*
12936 * "map()" function
12937 */
12938 static void
12942 {
12944 }
12946 /*
12947 * "maparg()" function
12948 */
12949 static void
12953 {
12955 }
12957 /*
12958 * "mapcheck()" function
12959 */
12960 static void
12964 {
12966 }
12970 static void
12975 {
12979 regmatch_T regmatch;
12992 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12998 {
12999 /* return empty list when there are no matches */
13002 }
13004 {
13007 }
13010 {
13014 }
13015 else
13023 {
13030 {
13035 }
13036 else
13037 {
13042 /* When "count" argument is there ignore matches before "start",
13043 * otherwise skip part of the string. Differs when pattern is "^"
13044 * or "\<". */
13047 else
13049 }
13055 }
13059 {
13063 {
13065 {
13067 {
13070 }
13075 }
13084 /* Advance to just after the match. */
13086 {
13089 }
13090 else
13091 {
13092 #ifdef FEAT_MBYTE
13095 #else
13097 #endif
13098 }
13099 }
13102 {
13104 {
13107 /* return list with matched string and submatches */
13109 {
13111 {
13115 }
13121 }
13122 }
13124 {
13125 /* return matched string */
13128 else
13131 }
13134 else
13135 {
13139 else
13143 }
13144 }
13146 }
13148 theend:
13151 }
13153 /*
13154 * "match()" function
13155 */
13156 static void
13160 {
13162 }
13164 /*
13165 * "matchadd()" function
13166 */
13167 static void
13171 {
13172 #ifdef FEAT_SEARCH_EXTRA
13185 {
13189 }
13193 {
13196 }
13199 #endif
13200 }
13202 /*
13203 * "matcharg()" function
13204 */
13205 static void
13209 {
13211 {
13212 #ifdef FEAT_SEARCH_EXTRA
13217 {
13219 {
13223 }
13224 else
13225 {
13228 }
13229 }
13230 #endif
13231 }
13232 }
13234 /*
13235 * "matchdelete()" function
13236 */
13237 static void
13241 {
13242 #ifdef FEAT_SEARCH_EXTRA
13245 #endif
13246 }
13248 /*
13249 * "matchend()" function
13250 */
13251 static void
13255 {
13257 }
13259 /*
13260 * "matchlist()" function
13261 */
13262 static void
13266 {
13268 }
13270 /*
13271 * "matchstr()" function
13272 */
13273 static void
13277 {
13279 }
13283 static void
13288 {
13294 {
13300 {
13303 {
13306 {
13313 }
13314 }
13315 }
13316 }
13318 {
13326 {
13329 {
13331 {
13335 {
13338 }
13341 }
13342 }
13343 }
13344 }
13345 else
13348 }
13350 /*
13351 * "max()" function
13352 */
13353 static void
13357 {
13359 }
13361 /*
13362 * "min()" function
13363 */
13364 static void
13368 {
13370 }
13374 /*
13375 * Create the directory in which "dir" is located, and higher levels when
13376 * needed.
13377 */
13378 static int
13382 {
13387 /* Get end of directory name in "dir".
13388 * We're done when it's "/" or "c:/". */
13393 /* If the directory exists we're done. Otherwise: create it.*/
13403 }
13405 #ifdef vim_mkdir
13406 /*
13407 * "mkdir()" function
13408 */
13409 static void
13413 {
13424 {
13429 }
13431 }
13432 #endif
13434 /*
13435 * "mode()" function
13436 */
13437 /*ARGSUSED*/
13438 static void
13442 {
13448 #ifdef FEAT_VISUAL
13450 {
13453 else
13455 }
13456 else
13457 #endif
13460 {
13466 }
13470 {
13471 #ifdef FEAT_VREPLACE
13473 {
13476 }
13477 else
13478 #endif
13481 else
13483 }
13485 {
13489 }
13491 {
13494 }
13495 else
13496 {
13500 }
13502 /* Clear out the minor mode when the argument is not a non-zero number or
13503 * non-empty string. */
13509 }
13511 /*
13512 * "nextnonblank()" function
13513 */
13514 static void
13518 {
13519 linenr_T lnum;
13522 {
13524 {
13527 }
13530 }
13532 }
13534 /*
13535 * "nr2char()" function
13536 */
13537 static void
13541 {
13544 #ifdef FEAT_MBYTE
13547 else
13548 #endif
13549 {
13552 }
13555 }
13557 /*
13558 * "pathshorten()" function
13559 */
13560 static void
13564 {
13571 else
13572 {
13577 }
13578 }
13580 #ifdef FEAT_FLOAT
13581 /*
13582 * "pow()" function
13583 */
13584 static void
13588 {
13595 else
13597 }
13598 #endif
13600 /*
13601 * "prevnonblank()" function
13602 */
13603 static void
13607 {
13608 linenr_T lnum;
13613 else
13617 }
13619 #ifdef HAVE_STDARG_H
13620 /* This dummy va_list is here because:
13621 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13622 * - locally in the function results in a "used before set" warning
13623 * - using va_start() to initialize it gives "function with fixed args" error */
13625 #endif
13627 /*
13628 * "printf()" function
13629 */
13630 static void
13634 {
13638 {
13645 /* Get the required length, allocate the buffer and do it for real. */
13650 {
13653 {
13656 }
13657 }
13659 }
13660 #endif
13661 }
13663 /*
13664 * "pumvisible()" function
13665 */
13666 /*ARGSUSED*/
13667 static void
13671 {
13673 #ifdef FEAT_INS_EXPAND
13676 #endif
13677 }
13679 /*
13680 * "range()" function
13681 */
13682 static void
13686 {
13695 {
13698 }
13699 else
13700 {
13704 }
13713 else
13714 {
13720 }
13721 }
13723 /*
13724 * "readfile()" function
13725 */
13726 static void
13730 {
13750 {
13755 }
13760 /* Always open the file in binary mode, library functions have a mind of
13761 * their own about CR-LF conversion. */
13764 {
13767 }
13771 {
13776 {
13778 {
13779 /* Only when in binary mode add an empty list item when the
13780 * last line ends in a '\n'. */
13784 /* Found end-of-line or end-of-file: add a text line to the
13785 * list. */
13794 else
13795 {
13798 {
13804 }
13805 }
13810 {
13813 }
13823 }
13826 }
13831 {
13832 /* "buf" is full, need to move text to an allocated buffer */
13834 {
13837 }
13838 else
13839 {
13842 {
13848 }
13849 }
13851 }
13852 else
13853 {
13856 }
13857 }
13859 /*
13860 * For a negative line count use only the lines at the end of the file,
13861 * free the rest.
13862 */
13865 {
13868 }
13872 }
13874 #if defined(FEAT_RELTIME)
13877 /*
13878 * Convert a List to proftime_T.
13879 * Return FAIL when there is something wrong.
13880 */
13881 static int
13885 {
13894 # ifdef WIN3264
13897 # else
13900 # endif
13902 }
13905 /*
13906 * "reltime()" function
13907 */
13908 static void
13912 {
13913 #ifdef FEAT_RELTIME
13914 proftime_T res;
13915 proftime_T start;
13918 {
13919 /* No arguments: get current time. */
13921 }
13923 {
13927 }
13928 else
13929 {
13930 /* Two arguments: compute the difference. */
13935 }
13938 {
13941 # ifdef WIN3264
13944 # else
13947 # endif
13950 }
13951 #endif
13952 }
13954 /*
13955 * "reltimestr()" function
13956 */
13957 static void
13961 {
13962 #ifdef FEAT_RELTIME
13963 proftime_T tm;
13964 #endif
13968 #ifdef FEAT_RELTIME
13971 #endif
13972 }
13974 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13978 static void
13980 {
13982 # ifdef FEAT_GUI
13984 # endif
13985 )
13986 {
13990 }
13991 }
13993 static int
13995 {
13998 {
14001 }
14003 }
14004 #endif
14006 #ifdef FEAT_CLIENTSERVER
14009 static void
14014 {
14019 # ifdef WIN32
14020 HWND w;
14021 # else
14022 Window w;
14023 # endif
14028 # ifdef FEAT_X11
14031 # endif
14037 # ifdef WIN32
14039 # else
14042 # endif
14043 {
14046 else
14049 }
14054 {
14055 dictitem_T v;
14066 }
14067 }
14068 #endif
14070 /*
14071 * "remote_expr()" function
14072 */
14073 /*ARGSUSED*/
14074 static void
14078 {
14081 #ifdef FEAT_CLIENTSERVER
14083 #endif
14084 }
14086 /*
14087 * "remote_foreground()" function
14088 */
14089 /*ARGSUSED*/
14090 static void
14094 {
14096 #ifdef FEAT_CLIENTSERVER
14097 # ifdef WIN32
14098 /* On Win32 it's done in this application. */
14099 {
14104 }
14105 # else
14106 /* Send a foreground() expression to the server. */
14112 # endif
14113 #endif
14114 }
14116 /*ARGSUSED*/
14117 static void
14121 {
14122 #ifdef FEAT_CLIENTSERVER
14123 dictitem_T v;
14125 # ifdef WIN32
14127 # endif
14131 {
14134 }
14137 {
14140 }
14141 # ifdef WIN32
14145 else
14146 {
14149 }
14150 # else
14157 # endif
14160 {
14169 }
14170 #else
14172 #endif
14173 }
14175 /*ARGSUSED*/
14176 static void
14180 {
14183 #ifdef FEAT_CLIENTSERVER
14187 {
14188 # ifdef WIN32
14189 /* The server's HWND is encoded in the 'id' parameter */
14196 # else
14199 # endif
14201 }
14202 #endif
14205 }
14207 /*
14208 * "remote_send()" function
14209 */
14210 /*ARGSUSED*/
14211 static void
14215 {
14218 #ifdef FEAT_CLIENTSERVER
14220 #endif
14221 }
14223 /*
14224 * "remove()" function
14225 */
14226 static void
14230 {
14242 {
14247 {
14250 {
14254 else
14255 {
14259 }
14260 }
14261 }
14262 }
14267 {
14275 else
14276 {
14278 {
14279 /* Remove one item, return its value. */
14283 }
14284 else
14285 {
14286 /* Remove range of items, return list with values. */
14292 else
14293 {
14297 {
14301 }
14304 else
14305 {
14308 {
14315 }
14316 }
14317 }
14318 }
14319 }
14320 }
14321 }
14323 /*
14324 * "rename({from}, {to})" function
14325 */
14326 static void
14330 {
14335 else
14338 }
14340 /*
14341 * "repeat()" function
14342 */
14343 /*ARGSUSED*/
14344 static void
14348 {
14358 {
14364 }
14365 else
14366 {
14378 {
14382 }
14385 }
14386 }
14388 /*
14389 * "resolve()" function
14390 */
14391 static void
14395 {
14399 #ifdef FEAT_SHORTCUT
14400 {
14406 else
14408 }
14409 #else
14410 # ifdef HAVE_READLINK
14411 {
14433 {
14434 /* Separate the first path component in "p", and keep the
14435 * remainder (beginning with the path separator). */
14438 }
14441 {
14443 {
14450 {
14456 }
14458 /* Ensure that the result will have a trailing path separator
14459 * if the argument has one. */
14463 /* Separate the first path component in the link value and
14464 * concatenate the remainders. */
14467 {
14470 else
14471 {
14474 {
14477 }
14478 }
14480 }
14484 {
14485 /* Ignore trailing path separator. */
14488 }
14490 {
14491 /* symlink is relative to directory of argument */
14494 {
14499 }
14500 }
14501 else
14502 {
14505 }
14506 }
14511 /* Append the first path component of "remain" to "p". */
14516 {
14520 }
14521 /* Shorten "remain". */
14524 else
14525 {
14528 }
14529 }
14531 /* If the result is a relative path name, make it explicitly relative to
14532 * the current directory if and only if the argument had this form. */
14534 {
14543 {
14544 /* Prepend "./". */
14547 {
14550 }
14551 }
14553 {
14554 /* Strip leading "./". */
14560 }
14561 }
14563 /* Ensure that the result will have no trailing path separator
14564 * if the argument had none. But keep "/" or "//". */
14566 {
14570 }
14573 }
14574 # else
14576 # endif
14577 #endif
14581 #ifdef HAVE_READLINK
14582 fail:
14583 #endif
14585 }
14587 /*
14588 * "reverse({list})" function
14589 */
14590 static void
14594 {
14603 {
14608 {
14612 }
14617 }
14618 }
14630 /*
14631 * Get flags for a search function.
14632 * Possibly sets "p_ws".
14633 * Returns BACKWARD, FORWARD or zero (for an error).
14634 */
14635 static int
14639 {
14646 {
14651 {
14653 {
14660 {
14668 }
14670 {
14673 }
14674 else
14676 }
14680 }
14681 }
14683 }
14685 /*
14686 * Shared by search() and searchpos() functions
14687 */
14688 static int
14693 {
14696 pos_T pos;
14697 pos_T save_cursor;
14702 proftime_T tm;
14703 #ifdef FEAT_RELTIME
14705 #endif
14719 /* Optional arguments: line number to stop searching and timeout. */
14721 {
14725 #ifdef FEAT_RELTIME
14727 {
14731 }
14732 #endif
14733 }
14735 #ifdef FEAT_RELTIME
14736 /* Set the time limit, if there is one. */
14738 #endif
14740 /*
14741 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14742 * Check to make sure only those flags are set.
14743 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14744 * flags cannot be set. Check for that condition also.
14745 */
14748 {
14751 }
14757 {
14760 else
14766 {
14767 /* Store the match cursor position */
14770 }
14771 /* "/$" will put the cursor after the end of the line, may need to
14772 * correct that here */
14774 }
14776 /* If 'n' flag is used: restore cursor position. */
14779 else
14781 theend:
14785 }
14787 #ifdef FEAT_FLOAT
14788 /*
14789 * "round({float})" function
14790 */
14791 static void
14795 {
14796 float_T f;
14800 /* round() is not in C90, use ceil() or floor() instead. */
14802 else
14804 }
14805 #endif
14807 /*
14808 * "search()" function
14809 */
14810 static void
14814 {
14818 }
14820 /*
14821 * "searchdecl()" function
14822 */
14823 static void
14827 {
14837 {
14841 }
14845 }
14847 /*
14848 * Used by searchpair() and searchpairpos()
14849 */
14850 static int
14854 {
14867 /* Get the three pattern arguments: start, middle, end. */
14874 /* Handle the optional fourth argument: flags */
14879 /* Don't accept SP_END or SP_SUBPAT.
14880 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14881 */
14884 {
14887 }
14889 /* Using 'r' implies 'W', otherwise it doesn't work. */
14893 /* Optional fifth argument: skip expression */
14897 else
14898 {
14901 {
14905 #ifdef FEAT_RELTIME
14907 {
14911 }
14912 #endif
14913 }
14914 }
14921 theend:
14925 }
14927 /*
14928 * "searchpair()" function
14929 */
14930 static void
14934 {
14936 }
14938 /*
14939 * "searchpairpos()" function
14940 */
14941 static void
14945 {
14946 pos_T match_pos;
14956 {
14959 }
14963 }
14965 /*
14966 * Search for a start/middle/end thing.
14967 * Used by searchpair(), see its documentation for the details.
14968 * Returns 0 or -1 for no match,
14969 */
14970 long
14982 {
14986 pos_T pos;
14987 pos_T firstpos;
14988 pos_T foundpos;
14989 pos_T save_cursor;
14990 pos_T save_pos;
14996 proftime_T tm;
14998 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15002 #ifdef FEAT_RELTIME
15003 /* Set the time limit, if there is one. */
15005 #endif
15007 /* Make two search patterns: start/end (pat2, for in nested pairs) and
15008 * start/middle/end (pat3, for the top pair). */
15016 else
15028 {
15032 /* didn't find it or found the first match again: FAIL */
15038 {
15039 /* Found the same position again. Can happen with a pattern that
15040 * has "\zs" at the end and searching backwards. Advance one
15041 * character and try again. */
15044 else
15046 }
15049 /* clear the start flag to avoid getting stuck here */
15052 /* If the skip pattern matches, ignore this match. */
15054 {
15060 {
15061 /* Evaluating {skip} caused an error, break here. */
15065 }
15068 }
15071 {
15072 /* Found end when searching backwards or start when searching
15073 * forward: nested pair. */
15076 }
15077 else
15078 {
15079 /* Found end when searching forward or start when searching
15080 * backward: end of (nested) pair; or found middle in outer pair. */
15083 }
15086 {
15087 /* Found the match: return matchcount or line number. */
15090 else
15098 }
15099 }
15102 {
15103 /* Store the match cursor position */
15106 }
15108 /* If 'n' flag is used or search failed: restore cursor position. */
15112 theend:
15118 }
15120 /*
15121 * "searchpos()" function
15122 */
15123 static void
15127 {
15128 pos_T match_pos;
15141 {
15144 }
15150 }
15153 /*ARGSUSED*/
15154 static void
15158 {
15159 #ifdef FEAT_CLIENTSERVER
15169 # ifdef FEAT_X11
15172 # endif
15175 {
15178 }
15180 #else
15182 #endif
15183 }
15185 /*ARGSUSED*/
15186 static void
15190 {
15193 #ifdef FEAT_CLIENTSERVER
15194 # ifdef WIN32
15196 # else
15200 # endif
15201 #endif
15204 }
15206 /*
15207 * "setbufvar()" function
15208 */
15209 /*ARGSUSED*/
15210 static void
15214 {
15216 aco_save_T aco;
15231 {
15232 /* set curbuf to be our buf, temporarily */
15236 {
15246 }
15247 else
15248 {
15251 {
15256 }
15257 }
15259 /* reset notion of buffer */
15261 }
15262 }
15264 /*
15265 * "setcmdpos()" function
15266 */
15267 static void
15271 {
15276 }
15278 /*
15279 * "setline()" function
15280 */
15281 static void
15285 {
15286 linenr_T lnum;
15295 {
15298 }
15299 else
15304 {
15306 {
15307 /* list argument, get next string */
15312 }
15318 {
15319 /* existing line, replace it */
15321 {
15326 }
15327 }
15329 {
15330 /* lnum is one past the last line, append the line */
15334 }
15339 }
15343 }
15345 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15347 /*
15348 * Used by "setqflist()" and "setloclist()" functions
15349 */
15350 /*ARGSUSED*/
15351 static void
15357 {
15358 #ifdef FEAT_QUICKFIX
15361 #endif
15365 #ifdef FEAT_QUICKFIX
15368 else
15369 {
15373 {
15379 }
15383 }
15384 #endif
15385 }
15387 /*
15388 * "setloclist()" function
15389 */
15390 /*ARGSUSED*/
15391 static void
15395 {
15403 }
15405 /*
15406 * "setmatches()" function
15407 */
15408 static void
15412 {
15413 #ifdef FEAT_SEARCH_EXTRA
15420 {
15423 }
15425 {
15427 /* To some extent make sure that we are dealing with a list from
15428 * "getmatches()". */
15431 {
15434 {
15437 }
15442 {
15445 }
15447 }
15452 {
15459 }
15461 }
15462 #endif
15463 }
15465 /*
15466 * "setpos()" function
15467 */
15468 /*ARGSUSED*/
15469 static void
15473 {
15474 pos_T pos;
15481 {
15483 {
15486 {
15487 /* set cursor */
15489 {
15493 }
15494 else
15496 }
15498 {
15499 /* set mark */
15502 }
15503 else
15505 }
15506 }
15507 }
15509 /*
15510 * "setqflist()" function
15511 */
15512 /*ARGSUSED*/
15513 static void
15517 {
15519 }
15521 /*
15522 * "setreg()" function
15523 */
15524 static void
15528 {
15534 char_u yank_type;
15553 {
15559 {
15569 #ifdef FEAT_VISUAL
15573 {
15577 }
15579 #endif
15580 }
15581 }
15588 }
15590 /*
15591 * "settabwinvar()" function
15592 */
15593 static void
15597 {
15599 }
15601 /*
15602 * "setwinvar()" function
15603 */
15604 static void
15608 {
15610 }
15612 /*
15613 * "setwinvar()" and "settabwinvar()" functions
15614 */
15615 static void
15620 {
15622 #ifdef FEAT_WINDOWS
15625 #endif
15636 #ifdef FEAT_WINDOWS
15639 else
15641 #endif
15647 {
15648 #ifdef FEAT_WINDOWS
15649 /* set curwin to be our win, temporarily */
15657 #endif
15660 {
15670 }
15671 else
15672 {
15675 {
15680 }
15681 }
15683 #ifdef FEAT_WINDOWS
15684 /* Restore current tabpage and window, if still valid (autocomands can
15685 * make them invalid). */
15689 {
15692 }
15693 #endif
15694 }
15695 }
15697 /*
15698 * "shellescape({string})" function
15699 */
15700 static void
15704 {
15708 }
15710 /*
15711 * "simplify()" function
15712 */
15713 static void
15717 {
15724 }
15726 #ifdef FEAT_FLOAT
15727 /*
15728 * "sin()" function
15729 */
15730 static void
15734 {
15735 float_T f;
15740 else
15742 }
15743 #endif
15745 static int
15746 #ifdef __BORLANDC__
15747 _RTLENTRYF
15748 #endif
15750 static int
15751 #ifdef __BORLANDC__
15752 _RTLENTRYF
15753 #endif
15759 #define ITEM_COMPARE_FAIL 999
15761 /*
15762 * Compare functions for f_sort() below.
15763 */
15764 static int
15765 #ifdef __BORLANDC__
15766 _RTLENTRYF
15767 #endif
15771 {
15786 else
15791 }
15793 static int
15794 #ifdef __BORLANDC__
15795 _RTLENTRYF
15796 #endif
15800 {
15802 typval_T rettv;
15806 /* shortcut after failure in previous call; compare all items equal */
15810 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15811 * in the copy without changing the original list items. */
15823 else
15824 /* return value has wrong type */
15830 }
15832 /*
15833 * "sort({list})" function
15834 */
15835 static void
15839 {
15849 else
15850 {
15865 {
15868 else
15869 {
15877 else
15879 }
15880 }
15882 /* Make an array with each entry pointing to an item in the List. */
15891 /* test the compare function */
15896 else
15897 {
15898 /* Sort the array with item pointers. */
15903 {
15904 /* Clear the List and append the items in the sorted order. */
15909 }
15910 }
15913 }
15914 }
15916 /*
15917 * "soundfold({word})" function
15918 */
15919 static void
15923 {
15928 #ifdef FEAT_SPELL
15930 #else
15932 #endif
15933 }
15935 /*
15936 * "spellbadword()" function
15937 */
15938 /* ARGSUSED */
15939 static void
15943 {
15951 #ifdef FEAT_SPELL
15953 {
15954 /* Find the start and length of the badly spelled word. */
15958 }
15960 {
15965 {
15966 /* Check the argument for spelling. */
15968 {
15971 {
15974 }
15976 }
15977 }
15978 }
15979 #endif
15988 }
15990 /*
15991 * "spellsuggest()" function
15992 */
15993 /*ARGSUSED*/
15994 static void
15998 {
15999 #ifdef FEAT_SPELL
16003 garray_T ga;
16007 #endif
16012 #ifdef FEAT_SPELL
16014 {
16017 {
16022 {
16026 }
16027 }
16028 else
16034 {
16040 else
16041 {
16046 }
16047 }
16049 }
16050 #endif
16051 }
16053 static void
16057 {
16061 regmatch_T regmatch;
16069 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16075 {
16081 }
16092 {
16095 {
16098 else
16102 else
16106 {
16110 }
16113 /* Advance to just after the match. */
16116 else
16117 {
16118 /* Don't get stuck at the same match. */
16119 #ifdef FEAT_MBYTE
16121 #else
16123 #endif
16124 }
16126 }
16129 }
16132 }
16134 #ifdef FEAT_FLOAT
16135 /*
16136 * "sqrt()" function
16137 */
16138 static void
16142 {
16143 float_T f;
16148 else
16150 }
16152 /*
16153 * "str2float()" function
16154 */
16155 static void
16159 {
16166 }
16167 #endif
16169 /*
16170 * "str2nr()" function
16171 */
16172 static void
16176 {
16182 {
16185 {
16188 }
16189 }
16196 }
16198 #ifdef HAVE_STRFTIME
16199 /*
16200 * "strftime({format}[, {time}])" function
16201 */
16202 static void
16206 {
16217 else
16220 /* MSVC returns NULL for an invalid value of seconds. */
16223 else
16224 {
16225 # ifdef FEAT_MBYTE
16226 vimconv_T conv;
16234 # endif
16238 else
16241 # ifdef FEAT_MBYTE
16247 else
16248 # endif
16251 # ifdef FEAT_MBYTE
16252 /* Release conversion descriptors */
16255 # endif
16256 }
16257 }
16258 #endif
16260 /*
16261 * "stridx()" function
16262 */
16263 static void
16267 {
16282 {
16290 }
16295 }
16297 /*
16298 * "string()" function
16299 */
16300 static void
16304 {
16310 /* Make a copy if we have a value but it's not in allocated memory. */
16313 }
16315 /*
16316 * "strlen()" function
16317 */
16318 static void
16322 {
16325 }
16327 /*
16328 * "strpart()" function
16329 */
16330 static void
16334 {
16349 else
16352 /*
16353 * Only return the overlap between the specified part and the actual
16354 * string.
16355 */
16357 {
16360 }
16370 }
16372 /*
16373 * "strridx()" function
16374 */
16375 static void
16379 {
16396 {
16397 /* Third argument: upper limit for index */
16401 }
16402 else
16406 {
16407 /* Empty string matches past the end. */
16409 }
16410 else
16411 {
16413 {
16418 }
16419 }
16423 else
16425 }
16427 /*
16428 * "strtrans()" function
16429 */
16430 static void
16434 {
16437 }
16439 /*
16440 * "submatch()" function
16441 */
16442 static void
16446 {
16450 }
16452 /*
16453 * "substitute()" function
16454 */
16455 static void
16459 {
16472 else
16474 }
16476 /*
16477 * "synID(lnum, col, trans)" function
16478 */
16479 /*ARGSUSED*/
16480 static void
16484 {
16486 #ifdef FEAT_SYN_HL
16499 #endif
16502 }
16504 /*
16505 * "synIDattr(id, what [, mode])" function
16506 */
16507 /*ARGSUSED*/
16508 static void
16512 {
16514 #ifdef FEAT_SYN_HL
16524 {
16528 #ifdef FEAT_GUI
16530 #endif
16531 )
16533 }
16534 else
16535 {
16536 #ifdef FEAT_GUI
16539 else
16540 #endif
16543 else
16545 }
16549 {
16582 /* underline */
16584 else
16585 /* undercurl */
16588 }
16592 #endif
16595 }
16597 /*
16598 * "synIDtrans(id)" function
16599 */
16600 /*ARGSUSED*/
16601 static void
16605 {
16608 #ifdef FEAT_SYN_HL
16613 else
16614 #endif
16618 }
16620 /*
16621 * "synstack(lnum, col)" function
16622 */
16623 /*ARGSUSED*/
16624 static void
16628 {
16629 #ifdef FEAT_SYN_HL
16634 #endif
16639 #ifdef FEAT_SYN_HL
16646 {
16649 {
16655 }
16656 }
16657 #endif
16658 }
16660 /*
16661 * "system()" function
16662 */
16663 static void
16667 {
16679 {
16680 /*
16681 * Write the string to a temp file, to be used for input of the shell
16682 * command.
16683 */
16685 {
16688 }
16692 {
16695 }
16698 {
16701 }
16707 {
16710 }
16711 }
16716 #ifdef USE_CR
16717 /* translate <CR> into <NL> */
16719 {
16723 {
16726 }
16727 }
16728 #else
16729 # ifdef USE_CRNL
16730 /* translate <CR><NL> into <NL> */
16732 {
16737 {
16741 }
16743 }
16744 # endif
16745 #endif
16747 done:
16749 {
16752 }
16755 }
16757 /*
16758 * "tabpagebuflist()" function
16759 */
16760 /* ARGSUSED */
16761 static void
16765 {
16766 #ifndef FEAT_WINDOWS
16768 #else
16774 else
16775 {
16779 }
16782 else
16783 {
16786 else
16787 {
16792 }
16793 }
16794 #endif
16795 }
16798 /*
16799 * "tabpagenr()" function
16800 */
16801 /* ARGSUSED */
16802 static void
16806 {
16808 #ifdef FEAT_WINDOWS
16812 {
16816 {
16819 else
16821 }
16822 }
16823 else
16825 #endif
16827 }
16830 #ifdef FEAT_WINDOWS
16833 /*
16834 * Common code for tabpagewinnr() and winnr().
16835 */
16836 static int
16840 {
16848 {
16855 {
16859 }
16860 else
16861 {
16864 }
16865 }
16870 {
16872 {
16873 /* didn't find it in this tabpage */
16876 }
16878 }
16880 }
16881 #endif
16883 /*
16884 * "tabpagewinnr()" function
16885 */
16886 /* ARGSUSED */
16887 static void
16891 {
16893 #ifdef FEAT_WINDOWS
16899 else
16901 #endif
16903 }
16906 /*
16907 * "tagfiles()" function
16908 */
16909 /*ARGSUSED*/
16910 static void
16914 {
16916 tagname_T tn;
16920 {
16923 }
16930 }
16932 /*
16933 * "taglist()" function
16934 */
16935 static void
16939 {
16950 }
16952 /*
16953 * "tempname()" function
16954 */
16955 /*ARGSUSED*/
16956 static void
16960 {
16966 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16967 * names. Skip 'I' and 'O', they are used for shell redirection. */
16968 do
16969 {
16974 else
16975 {
16976 #ifdef EBCDIC
16981 else
16982 #endif
16984 }
16986 }
16988 /*
16989 * "test(list)" function: Just checking the walls...
16990 */
16991 /*ARGSUSED*/
16992 static void
16996 {
16997 /* Used for unit testing. Change the code below to your liking. */
16998 #if 0
17017 #endif
17018 }
17020 /*
17021 * "tolower(string)" function
17022 */
17023 static void
17027 {
17036 {
17037 #ifdef FEAT_MBYTE
17041 {
17047 /* TODO: reallocate string when byte count changes. */
17051 }
17054 else
17055 #endif
17056 {
17059 }
17060 }
17061 }
17063 /*
17064 * "toupper(string)" function
17065 */
17066 static void
17070 {
17073 }
17075 /*
17076 * "tr(string, fromstr, tostr)" function
17077 */
17078 static void
17082 {
17087 #ifdef FEAT_MBYTE
17095 #endif
17098 garray_T ga;
17104 /* Default return value: empty string. */
17111 #ifdef FEAT_MBYTE
17113 #endif
17114 /* not multi-byte: fromstr and tostr must be the same length */
17116 {
17117 #ifdef FEAT_MBYTE
17118 error:
17119 #endif
17123 }
17125 /* fromstr and tostr have to contain the same number of chars */
17127 {
17128 #ifdef FEAT_MBYTE
17130 {
17136 {
17139 {
17141 {
17144 {
17148 }
17149 }
17153 }
17155 }
17158 {
17159 /* Check that fromstr and tostr have the same number of
17160 * (multi-byte) characters. Done only once when a character
17161 * of instr doesn't appear in fromstr. */
17164 {
17167 }
17170 }
17177 }
17178 else
17179 #endif
17180 {
17181 /* When not using multi-byte chars we can do it faster. */
17185 else
17188 }
17189 }
17191 /* add a terminating NUL */
17196 }
17198 #ifdef FEAT_FLOAT
17199 /*
17200 * "trunc({float})" function
17201 */
17202 static void
17206 {
17207 float_T f;
17211 /* trunc() is not in C90, use floor() or ceil() instead. */
17213 else
17215 }
17216 #endif
17218 /*
17219 * "type(expr)" function
17220 */
17221 static void
17225 {
17229 {
17235 #ifdef FEAT_FLOAT
17237 #endif
17239 }
17241 }
17243 /*
17244 * "values(dict)" function
17245 */
17246 static void
17250 {
17252 }
17254 /*
17255 * "virtcol(string)" function
17256 */
17257 static void
17261 {
17269 {
17272 }
17275 }
17277 /*
17278 * "visualmode()" function
17279 */
17280 /*ARGSUSED*/
17281 static void
17285 {
17286 #ifdef FEAT_VISUAL
17294 /* A non-zero number or non-empty string argument: reset mode. */
17297 #else
17299 #endif
17300 }
17302 /*
17303 * "winbufnr(nr)" function
17304 */
17305 static void
17309 {
17315 else
17317 }
17319 /*
17320 * "wincol()" function
17321 */
17322 /*ARGSUSED*/
17323 static void
17327 {
17330 }
17332 /*
17333 * "winheight(nr)" function
17334 */
17335 static void
17339 {
17345 else
17347 }
17349 /*
17350 * "winline()" function
17351 */
17352 /*ARGSUSED*/
17353 static void
17357 {
17360 }
17362 /*
17363 * "winnr()" function
17364 */
17365 /* ARGSUSED */
17366 static void
17370 {
17373 #ifdef FEAT_WINDOWS
17375 #endif
17377 }
17379 /*
17380 * "winrestcmd()" function
17381 */
17382 /* ARGSUSED */
17383 static void
17387 {
17388 #ifdef FEAT_WINDOWS
17391 garray_T ga;
17396 {
17399 # ifdef FEAT_VERTSPLIT
17402 # endif
17404 }
17408 #else
17410 #endif
17412 }
17414 /*
17415 * "winrestview()" function
17416 */
17417 /* ARGSUSED */
17418 static void
17422 {
17428 else
17429 {
17432 #ifdef FEAT_VIRTUALEDIT
17434 #endif
17439 #ifdef FEAT_DIFF
17441 #endif
17454 #ifdef FEAT_DIFF
17456 #endif
17457 }
17458 }
17460 /*
17461 * "winsaveview()" function
17462 */
17463 /* ARGSUSED */
17464 static void
17468 {
17480 #ifdef FEAT_VIRTUALEDIT
17482 #endif
17487 #ifdef FEAT_DIFF
17489 #endif
17492 }
17494 /*
17495 * "winwidth(nr)" function
17496 */
17497 static void
17501 {
17507 else
17508 #ifdef FEAT_VERTSPLIT
17510 #else
17512 #endif
17513 }
17515 /*
17516 * "writefile()" function
17517 */
17518 static void
17522 {
17535 {
17538 }
17546 /* Always open the file in binary mode, library functions have a mind of
17547 * their own about CR-LF conversion. */
17550 {
17553 }
17554 else
17555 {
17558 {
17560 {
17563 else
17566 {
17569 }
17570 }
17573 {
17576 }
17578 {
17581 }
17582 }
17584 }
17587 }
17589 /*
17590 * Translate a String variable into a position.
17591 * Returns NULL when there is an error.
17592 */
17598 {
17603 /* Argument can be [lnum, col, coladd]. */
17605 {
17615 /* Get the line number */
17620 /* Get the column number */
17626 /* We accept "$" for the column number: last column. */
17633 /* Accept a position up to the NUL after the line. */
17638 #ifdef FEAT_VIRTUALEDIT
17639 /* Get the virtual offset. Defaults to zero. */
17643 #endif
17646 }
17653 #ifdef FEAT_VISUAL
17655 {
17659 }
17660 #endif
17662 {
17667 }
17669 #ifdef FEAT_VIRTUALEDIT
17671 #endif
17674 {
17677 {
17681 }
17683 {
17687 }
17688 }
17690 {
17692 {
17695 }
17696 else
17697 {
17700 }
17702 }
17704 }
17706 /*
17707 * Convert list in "arg" into a position and optional file number.
17708 * When "fnump" is NULL there is no file number, only 3 items.
17709 * Note that the column is passed on as-is, the caller may want to decrement
17710 * it to use 1 for the first column.
17711 * Return FAIL when conversion is not possible, doesn't check the position for
17712 * validity.
17713 */
17714 static int
17719 {
17724 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17725 * when "fnump" isn't NULL and "coladd" is optional. */
17733 {
17740 }
17752 #ifdef FEAT_VIRTUALEDIT
17756 else
17758 #endif
17761 }
17763 /*
17764 * Get the length of an environment variable name.
17765 * Advance "arg" to the first character after the name.
17766 * Return 0 for error.
17767 */
17768 static int
17771 {
17776 ;
17783 }
17785 /*
17786 * Get the length of the name of a function or internal variable.
17787 * "arg" is advanced to the first non-white character after the name.
17788 * Return 0 if something is wrong.
17789 */
17790 static int
17793 {
17797 /* Find the end of the name. */
17799 ;
17807 }
17809 /*
17810 * Get the length of the name of a variable or function.
17811 * Only the name is recognized, does not handle ".key" or "[idx]".
17812 * "arg" is advanced to the first non-white character after the name.
17813 * Return -1 if curly braces expansion failed.
17814 * Return 0 if something else is wrong.
17815 * If the name contains 'magic' {}'s, expand them and return the
17816 * expanded name in an allocated string via 'alias' - caller must free.
17817 */
17818 static int
17824 {
17834 {
17835 /* hard coded <SNR>, already translated */
17838 }
17841 {
17842 /* literal "<SID>", "s:" or "<SNR>" */
17844 }
17846 /*
17847 * Find the end of the name; check for {} construction.
17848 */
17852 {
17856 {
17860 }
17862 /*
17863 * Include any <SID> etc in the expanded string:
17864 * Thus the -len here.
17865 */
17872 }
17879 }
17881 /*
17882 * Find the end of a variable or function name, taking care of magic braces.
17883 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17884 * start and end of the first magic braces item.
17885 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17886 * Return a pointer to just after the name. Equal to "arg" if there is no
17887 * valid name.
17888 */
17895 {
17901 {
17904 }
17906 /* Quick check for valid starting character. */
17916 {
17918 {
17919 /* skip over 'string' to avoid counting [ and ] inside it. */
17921 ;
17924 }
17926 {
17927 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17933 }
17936 {
17941 }
17944 {
17946 {
17947 mb_nest++;
17950 }
17952 {
17953 mb_nest--;
17956 }
17957 }
17958 }
17961 }
17963 /*
17964 * Expands out the 'magic' {}'s in a variable/function name.
17965 * Note that this can call itself recursively, to deal with
17966 * constructs like foo{bar}{baz}{bam}
17967 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17968 * "in_start" ^
17969 * "expr_start" ^
17970 * "expr_end" ^
17971 * "in_end" ^
17972 *
17973 * Returns a new allocated string, which the caller must free.
17974 * Returns NULL for failure.
17975 */
17982 {
17983 char_u c1;
17997 {
18001 {
18005 }
18006 }
18014 {
18017 {
18018 /* Further expansion! */
18023 }
18024 }
18027 }
18029 /*
18030 * Return TRUE if character "c" can be used in a variable or function name.
18031 * Does not include '{' or '}' for magic braces.
18032 */
18033 static int
18036 {
18038 }
18040 /*
18041 * Return TRUE if character "c" can be used as the first character in a
18042 * variable or function name (excluding '{' and '}').
18043 */
18044 static int
18047 {
18049 }
18051 /*
18052 * Set number v: variable to "val".
18053 */
18054 void
18058 {
18060 }
18062 /*
18063 * Get number v: variable value.
18064 */
18065 long
18068 {
18070 }
18072 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18073 /*
18074 * Get string v: variable value. Uses a static buffer, can only be used once.
18075 */
18076 char_u *
18079 {
18081 }
18082 #endif
18084 /*
18085 * Set v:count, v:count1 and v:prevcount.
18086 */
18087 void
18091 {
18095 }
18097 /*
18098 * Set string v: variable to a copy of "val".
18099 */
18100 void
18105 {
18106 /* Need to do this (at least) once, since we can't initialize a union.
18107 * Will always be invoked when "v:progname" is set. */
18115 else
18117 }
18119 /*
18120 * Set v:register if needed.
18121 */
18122 void
18125 {
18126 char_u regname;
18130 else
18132 /* Avoid free/alloc when the value is already right. */
18135 }
18137 /*
18138 * Get or set v:exception. If "oldval" == NULL, return the current value.
18139 * Otherwise, restore the value to "oldval" and return NULL.
18140 * Must always be called in pairs to save and restore v:exception! Does not
18141 * take care of memory allocations.
18142 */
18143 char_u *
18146 {
18152 }
18154 /*
18155 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18156 * Otherwise, restore the value to "oldval" and return NULL.
18157 * Must always be called in pairs to save and restore v:throwpoint! Does not
18158 * take care of memory allocations.
18159 */
18160 char_u *
18163 {
18169 }
18171 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18172 /*
18173 * Set v:cmdarg.
18174 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18175 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18176 * Must always be called in pairs!
18177 */
18178 char_u *
18182 {
18189 {
18193 }
18199 else
18207 # ifdef FEAT_MBYTE
18212 # endif
18222 else
18231 # ifdef FEAT_MBYTE
18238 # endif
18241 }
18242 #endif
18244 /*
18245 * Get the value of internal variable "name".
18246 * Return OK or FAIL.
18247 */
18248 static int
18254 {
18257 typval_T atv;
18261 /* truncate the name, so that we can use strcmp() */
18265 /*
18266 * Check for "b:changedtick".
18267 */
18269 {
18273 }
18275 /*
18276 * Check for user-defined variables.
18277 */
18278 else
18279 {
18283 }
18286 {
18290 }
18297 }
18299 /*
18300 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18301 * Also handle function call with Funcref variable: func(expr)
18302 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18303 */
18304 static int
18310 {
18315 typval_T functv;
18322 {
18324 {
18325 /* need to copy the funcref so that we can clear rettv */
18329 /* Invoke the function. Recursive! */
18335 /* Clear the funcref afterwards, so that deleting it while
18336 * evaluating the arguments is possible (see test55). */
18339 /* Stop the expression evaluation when immediately aborting on
18340 * error, or when an interrupt occurred or an exception was thrown
18341 * but not caught. */
18343 {
18347 }
18350 }
18352 {
18355 {
18359 }
18360 else
18363 {
18366 }
18367 }
18368 }
18371 }
18373 /*
18374 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18375 * value).
18376 */
18379 {
18381 }
18383 /*
18384 * Allocate memory for a variable type-value, and assign a string to it.
18385 * The string "s" must have been allocated, it is consumed.
18386 * Return NULL for out of memory, the variable otherwise.
18387 */
18391 {
18396 {
18399 }
18400 else
18403 }
18405 /*
18406 * Free the memory for a variable type-value.
18407 */
18408 void
18411 {
18413 {
18415 {
18418 /*FALLTHROUGH*/
18429 #ifdef FEAT_FLOAT
18431 #endif
18437 }
18439 }
18440 }
18442 /*
18443 * Free the memory for a variable value and set the value to NULL or 0.
18444 */
18445 void
18448 {
18450 {
18452 {
18455 /*FALLTHROUGH*/
18471 #ifdef FEAT_FLOAT
18475 #endif
18480 }
18482 }
18483 }
18485 /*
18486 * Set the value of a variable to NULL without freeing items.
18487 */
18488 static void
18491 {
18494 }
18496 /*
18497 * Get the number value of a variable.
18498 * If it is a String variable, uses vim_str2nr().
18499 * For incompatible types, return 0.
18500 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18501 * caller of incompatible types: it sets *denote to TRUE if "denote"
18502 * is not NULL or returns -1 otherwise.
18503 */
18504 static long
18507 {
18511 }
18513 long
18517 {
18521 {
18524 #ifdef FEAT_FLOAT
18528 #endif
18546 }
18549 else
18552 }
18554 /*
18555 * Get the lnum from the first argument.
18556 * Also accepts ".", "$", etc., but that only works for the current buffer.
18557 * Returns -1 on error.
18558 */
18559 static linenr_T
18562 {
18563 typval_T rettv;
18564 linenr_T lnum;
18568 {
18573 }
18575 }
18577 /*
18578 * Get the lnum from the first argument.
18579 * Also accepts "$", then "buf" is used.
18580 * Returns 0 on error.
18581 */
18582 static linenr_T
18586 {
18593 }
18595 /*
18596 * Get the string value of a variable.
18597 * If it is a Number variable, the number is converted into a string.
18598 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18599 * get_tv_string_buf() uses a given buffer.
18600 * If the String variable has never been set, return an empty string.
18601 * Never returns NULL;
18602 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18603 * NULL on error.
18604 */
18608 {
18612 }
18618 {
18622 }
18624 char_u *
18627 {
18631 }
18637 {
18639 {
18652 #ifdef FEAT_FLOAT
18656 #endif
18664 }
18666 }
18668 /*
18669 * Find variable "name" in the list of variables.
18670 * Return a pointer to it if found, NULL if not found.
18671 * Careful: "a:0" variables don't have a name.
18672 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18673 * hashtab_T used.
18674 */
18679 {
18689 }
18691 /*
18692 * Find variable "varname" in hashtab "ht".
18693 * Returns NULL if not found.
18694 */
18700 {
18704 {
18705 /* Must be something like "s:", otherwise "ht" would be NULL. */
18707 {
18713 #ifdef FEAT_WINDOWS
18715 #endif
18720 }
18722 }
18726 {
18727 /* For global variables we may try auto-loading the script. If it
18728 * worked find the variable again. Don't auto-load a script if it was
18729 * loaded already, otherwise it would be loaded every time when
18730 * checking if a function name is a Funcref variable. */
18736 }
18738 }
18740 /*
18741 * Find the hashtab used for a variable name.
18742 * Set "varname" to the start of name without ':'.
18743 */
18748 {
18752 {
18753 /* The name must not start with a colon or #. */
18758 /* "version" is "v:version" in all scopes */
18766 }
18770 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18771 */
18779 #ifdef FEAT_WINDOWS
18782 #endif
18793 }
18795 /*
18796 * Get the string value of a (global/local) variable.
18797 * Returns NULL when it doesn't exist.
18798 */
18799 char_u *
18802 {
18809 }
18811 /*
18812 * Allocate a new hashtab for a sourced script. It will be used while
18813 * sourcing this script and when executing functions defined in the script.
18814 */
18815 void
18817 scid_T id;
18818 {
18824 {
18825 /* Re-allocating ga_data means that an ht_array pointing to
18826 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18827 * at its init value. Also reset "v_dict", it's always the same. */
18829 {
18835 }
18838 {
18842 }
18843 }
18844 }
18846 /*
18847 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18848 * point to it.
18849 */
18850 void
18854 {
18862 }
18864 /*
18865 * Clean up a list of internal variables.
18866 * Frees all allocated variables and the value they contain.
18867 * Clears hashtab "ht", does not free it.
18868 */
18869 void
18872 {
18874 }
18876 /*
18877 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18878 */
18879 static void
18883 {
18891 {
18893 {
18896 /* Free the variable. Don't remove it from the hashtab,
18897 * ht_array might change then. hash_clear() takes care of it
18898 * later. */
18904 }
18905 }
18908 }
18910 /*
18911 * Delete a variable from hashtab "ht" at item "hi".
18912 * Clear the variable value and free the dictitem.
18913 */
18914 static void
18918 {
18924 }
18926 /*
18927 * List the value of one internal variable.
18928 */
18929 static void
18934 {
18943 }
18945 static void
18952 {
18953 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18965 {
18969 }
18971 {
18975 }
18976 else
18984 {
18987 }
18988 }
18990 /*
18991 * Set variable "name" to value in "tv".
18992 * If the variable already exists, the value is updated.
18993 * Otherwise the variable is created.
18994 */
18995 static void
19000 {
19007 {
19011 {
19014 }
19016 {
19018 name);
19020 }
19021 }
19025 {
19028 }
19032 {
19033 /* existing variable, need to clear the value */
19042 #ifdef FEAT_FLOAT
19047 #endif
19048 )
19049 {
19052 }
19054 /*
19055 * Handle setting internal v: variables separately: we don't change
19056 * the type.
19057 */
19059 {
19061 {
19065 else
19066 {
19067 /* Take over the string to avoid an extra alloc/free. */
19070 }
19071 }
19074 else
19075 {
19079 }
19081 }
19084 }
19086 {
19087 /* Can't add "v:" variable. */
19089 {
19092 }
19094 /* Make sure the variable name is valid. */
19098 {
19101 }
19109 {
19112 }
19114 }
19118 else
19119 {
19123 }
19124 }
19126 /*
19127 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19128 * Also give an error message.
19129 */
19130 static int
19134 {
19136 {
19139 }
19141 {
19144 }
19146 }
19148 /*
19149 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19150 * Also give an error message.
19151 */
19152 static int
19156 {
19158 {
19161 }
19163 }
19165 /*
19166 * Return TRUE if typeval "tv" is set to be locked (immutable).
19167 * Also give an error message, using "name".
19168 */
19169 static int
19173 {
19175 {
19179 }
19181 {
19185 }
19187 }
19189 /*
19190 * Copy the values from typval_T "from" to typval_T "to".
19191 * When needed allocates string or increases reference count.
19192 * Does not make a copy of a list or dict but copies the reference!
19193 */
19194 static void
19198 {
19202 {
19206 #ifdef FEAT_FLOAT
19210 #endif
19215 else
19216 {
19220 }
19225 else
19226 {
19229 }
19234 else
19235 {
19238 }
19243 }
19244 }
19246 /*
19247 * Make a copy of an item.
19248 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19249 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19250 * reference to an already copied list/dict can be used.
19251 * Returns FAIL or OK.
19252 */
19253 static int
19259 {
19264 {
19267 }
19271 {
19273 #ifdef FEAT_FLOAT
19275 #endif
19286 {
19287 /* use the copy made earlier */
19290 }
19291 else
19302 {
19303 /* use the copy made earlier */
19306 }
19307 else
19315 }
19318 }
19320 /*
19321 * ":echo expr1 ..." print each argument separated with a space, add a
19322 * newline at the end.
19323 * ":echon expr1 ..." print each argument plain.
19324 */
19325 void
19328 {
19330 typval_T rettv;
19340 {
19341 /* If eval1() causes an error message the text from the command may
19342 * still need to be cleared. E.g., "echo 22,44". */
19347 {
19348 /*
19349 * Report the invalid expression unless the expression evaluation
19350 * has been cancelled due to an aborting error, an interrupt, or an
19351 * exception.
19352 */
19357 }
19361 {
19363 {
19365 /* Call msg_start() after eval1(), evaluating the expression
19366 * may cause a message to appear. */
19369 }
19375 {
19377 {
19379 {
19380 /* remove any text still there from the command */
19383 }
19385 }
19386 else
19387 {
19388 #ifdef FEAT_MBYTE
19390 {
19395 }
19396 else
19397 #endif
19399 }
19400 }
19402 }
19405 }
19410 else
19411 {
19412 /* remove text that may still be there from the command */
19417 }
19418 }
19420 /*
19421 * ":echohl {name}".
19422 */
19423 void
19426 {
19432 else
19434 }
19436 /*
19437 * ":execute expr1 ..." execute the result of an expression.
19438 * ":echomsg expr1 ..." Print a message
19439 * ":echoerr expr1 ..." Print an error
19440 * Each gets spaces around each argument and a newline at the end for
19441 * echo commands
19442 */
19443 void
19446 {
19448 typval_T rettv;
19451 garray_T ga;
19460 {
19463 {
19464 /*
19465 * Report the invalid expression unless the expression evaluation
19466 * has been cancelled due to an aborting error, an interrupt, or an
19467 * exception.
19468 */
19473 }
19476 {
19480 {
19484 }
19489 }
19493 }
19496 {
19498 {
19501 }
19503 {
19504 /* We don't want to abort following commands, restore did_emsg. */
19509 }
19513 }
19521 }
19523 /*
19524 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19525 * "arg" points to the "&" or '+' when called, to "option" when returning.
19526 * Returns NULL when no option name found. Otherwise pointer to the char
19527 * after the option name.
19528 */
19533 {
19538 {
19541 }
19543 {
19546 }
19547 else
19556 else
19560 }
19562 /*
19563 * ":function"
19564 */
19565 void
19568 {
19577 garray_T newargs;
19578 garray_T newlines;
19587 funcdict_T fudi;
19595 /*
19596 * ":function" without argument: list functions.
19597 */
19599 {
19601 {
19604 {
19606 {
19611 }
19612 }
19613 }
19616 }
19618 /*
19619 * ":function /pat": list functions matching pattern.
19620 */
19622 {
19625 {
19626 regmatch_T regmatch;
19633 {
19638 {
19640 {
19646 }
19647 }
19648 }
19649 }
19654 }
19656 /*
19657 * Get the function name. There are these situations:
19658 * func normal function name
19659 * "name" == func, "fudi.fd_dict" == NULL
19660 * dict.func new dictionary entry
19661 * "name" == NULL, "fudi.fd_dict" set,
19662 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19663 * dict.func existing dict entry with a Funcref
19664 * "name" == func, "fudi.fd_dict" set,
19665 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19666 * dict.func existing dict entry that's not a Funcref
19667 * "name" == NULL, "fudi.fd_dict" set,
19668 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19669 */
19674 {
19675 /*
19676 * Return on an invalid expression in braces, unless the expression
19677 * evaluation has been cancelled due to an aborting error, an
19678 * interrupt, or an exception.
19679 */
19681 {
19686 }
19687 else
19689 }
19691 /* An error in a function call during evaluation of an expression in magic
19692 * braces should not cause the function not to be defined. */
19696 /*
19697 * ":function func" with only function name: list function.
19698 */
19700 {
19702 {
19705 }
19710 {
19713 {
19716 {
19728 }
19730 {
19733 }
19734 }
19735 else
19737 }
19739 }
19741 /*
19742 * ":function name(arg1, arg2)" Define function.
19743 */
19746 {
19748 {
19751 }
19752 /* attempt to continue by skipping some text */
19755 }
19762 {
19763 /* Check the name of the function. Unless it's a dictionary function
19764 * (that we are overwriting). */
19767 else
19771 {
19774 else
19781 }
19782 }
19784 /*
19785 * Isolate the arguments: "arg1, arg2, ...)"
19786 */
19788 {
19790 {
19794 }
19795 else
19796 {
19803 {
19807 }
19820 else
19822 }
19825 {
19829 }
19830 }
19833 /* find extra arguments "range", "dict" and "abort" */
19835 {
19838 {
19841 }
19843 {
19846 }
19848 {
19851 }
19852 else
19854 }
19856 /* When there is a line break use what follows for the function body.
19857 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19863 /*
19864 * Read the body of the function, until ":endfunction" is found.
19865 */
19867 {
19868 /* Check if the function already exists, don't let the user type the
19869 * whole function before telling him it doesn't work! For a script we
19870 * need to skip the body to be able to find what follows. */
19872 {
19877 }
19884 }
19889 {
19895 {
19896 /* Use eap->arg, split up in parts by line breaks. */
19901 else
19902 {
19905 }
19906 }
19909 else
19914 {
19917 }
19919 /* Detect line continuation: sourcing_lnum increased more than one. */
19922 else
19926 {
19927 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19928 * don't check for ":endfunc". */
19930 {
19933 }
19934 }
19935 else
19936 {
19937 /* skip ':' and blanks*/
19939 ;
19941 /* Check for "endfunction". */
19943 {
19947 }
19949 /* Increase indent inside "if", "while", "for" and "try", decrease
19950 * at "end". */
19959 /* Check for defining a function inside this function. */
19961 {
19966 {
19969 {
19972 }
19973 }
19974 }
19976 /* Check for ":append" or ":insert". */
19984 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19997 ))
19998 {
19999 /* ":python <<" continues until a dot, like ":append" */
20003 else
20005 }
20006 }
20008 /* Add the line to the function. */
20010 {
20014 }
20016 /* Copy the line to newly allocated memory. get_one_sourceline()
20017 * allocates 250 bytes per line, this saves 80% on average. The cost
20018 * is an extra alloc/free. */
20021 {
20025 }
20029 /* Add NULL lines for continuation lines, so that the line count is
20030 * equal to the index in the growarray. */
20034 /* Check for end of eap->arg. */
20037 }
20039 /* Don't define the function when skipping commands or when an error was
20040 * detected. */
20044 /*
20045 * If there are no errors, add the function
20046 */
20048 {
20051 {
20053 name);
20055 }
20059 {
20061 {
20064 }
20066 {
20068 name);
20070 }
20071 /* redefine existing function */
20076 }
20077 }
20078 else
20079 {
20084 {
20087 }
20089 {
20090 /* Can't add a function to a locked dictionary */
20093 }
20094 /* Can't change an existing function if it is locked */
20098 /* Give the function a sequential number. Can only be used with a
20099 * Funcref! */
20105 }
20108 {
20110 {
20114 /* Check that the autoload name matches the script name. */
20117 {
20120 {
20128 }
20129 }
20131 {
20134 }
20135 }
20142 {
20144 {
20145 /* add new dict entry */
20148 {
20151 }
20153 {
20157 }
20158 }
20159 else
20160 /* overwrite existing dict entry */
20167 /* behave like "dict" was used */
20169 }
20171 /* insert the new function in the function list */
20174 }
20177 #ifdef FEAT_PROFILE
20184 #endif
20191 erret:
20194 ret_free:
20199 }
20201 /*
20202 * Get a function name, translating "<SID>" and "<SNR>".
20203 * Also handles a Funcref in a List or Dictionary.
20204 * Returns the function name in allocated memory, or NULL for failure.
20205 * flags:
20206 * TFN_INT: internal function name OK
20207 * TFN_QUIET: be quiet
20208 * Advances "pp" to just after the function name (if no error).
20209 */
20216 {
20223 lval_T lv;
20229 /* Check for hard coded <SNR>: already translated function ID (from a user
20230 * command). */
20233 {
20237 }
20239 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20240 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20248 {
20252 }
20254 {
20255 /*
20256 * Report an invalid expression in braces, unless the expression
20257 * evaluation has been cancelled due to an aborting error, an
20258 * interrupt, or an exception.
20259 */
20261 {
20264 }
20265 else
20268 }
20271 {
20273 {
20278 }
20280 {
20283 }
20284 else
20285 {
20289 else
20292 }
20294 }
20297 {
20298 /* Error found, but continue after the function name. */
20301 }
20303 /* Check if the name is a Funcref. If so, use the value. */
20305 {
20310 }
20311 else
20312 {
20317 }
20319 {
20323 }
20326 {
20330 {
20331 /* When there was "s:" already or the name expanded to get a
20332 * leading "s:" then remove it. */
20336 }
20337 }
20338 else
20339 {
20343 }
20345 /*
20346 * Copy the function name to allocated memory.
20347 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20348 * Accept <SNR>123_name() outside a script.
20349 */
20353 {
20357 {
20358 /* It's "s:" or "<SID>" */
20360 {
20363 }
20366 }
20367 }
20369 {
20372 }
20375 {
20377 {
20383 }
20386 }
20389 theend:
20392 }
20394 /*
20395 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20396 * Return 2 if "p" starts with "s:".
20397 * Return 0 otherwise.
20398 */
20399 static int
20402 {
20409 }
20411 /*
20412 * Return TRUE if "p" starts with "<SID>" or "s:".
20413 * Only works if eval_fname_script() returned non-zero for "p"!
20414 */
20415 static int
20418 {
20420 }
20422 /*
20423 * List the head of the function: "name(arg1, arg2)".
20424 */
20425 static void
20429 {
20437 {
20440 }
20441 else
20445 {
20449 }
20451 {
20455 }
20460 }
20462 /*
20463 * Find a function by name, return pointer to it in ufuncs.
20464 * Return NULL for unknown function.
20465 */
20469 {
20476 }
20478 #if defined(EXITFREE) || defined(PROTO)
20479 void
20481 {
20484 /* Need to start all over every time, because func_free() may change the
20485 * hash table. */
20489 {
20492 }
20493 }
20494 #endif
20496 /*
20497 * Return TRUE if a function "name" exists.
20498 */
20499 static int
20502 {
20510 /* Only accept "funcname", "funcname ", "funcname (..." and
20511 * "funcname(...", not "funcname!...". */
20513 {
20516 else
20518 }
20521 }
20523 /*
20524 * Return TRUE if "name" looks like a builtin function name: starts with a
20525 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20526 */
20527 static int
20530 {
20533 }
20535 #if defined(FEAT_PROFILE) || defined(PROTO)
20536 /*
20537 * Start profiling function "fp".
20538 */
20539 static void
20542 {
20561 }
20563 /*
20564 * Dump the profiling results for all functions in file "fd".
20565 */
20566 void
20569 {
20581 {
20583 {
20587 {
20593 else
20597 else
20605 {
20611 }
20613 }
20614 }
20615 }
20618 {
20620 prof_total_cmp);
20623 prof_self_cmp);
20625 }
20626 }
20628 static void
20635 {
20642 {
20645 prefer_self);
20648 else
20650 }
20652 }
20654 /*
20655 * Print the count and times for one function or function line.
20656 */
20657 static void
20664 {
20666 {
20670 else
20674 else
20676 }
20677 else
20679 }
20681 /*
20682 * Compare function for total time sorting.
20683 */
20684 static int
20685 #ifdef __BORLANDC__
20686 _RTLENTRYF
20687 #endif
20691 {
20697 }
20699 /*
20700 * Compare function for self time sorting.
20701 */
20702 static int
20703 #ifdef __BORLANDC__
20704 _RTLENTRYF
20705 #endif
20709 {
20715 }
20717 #endif
20719 /*
20720 * If "name" has a package name try autoloading the script for it.
20721 * Return TRUE if a package was loaded.
20722 */
20723 static int
20727 {
20733 /* If there is no '#' after name[0] there is no package name. */
20740 /* Find the name in the list of previously loaded package names. Skip
20741 * "autoload/", it's always the same. */
20747 else
20748 {
20749 /* Remember the name if it wasn't loaded already. */
20751 {
20754 }
20756 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20759 }
20763 }
20765 /*
20766 * Return the autoload script name for a function or variable name.
20767 * Returns NULL when out of memory.
20768 */
20772 {
20776 /* Get the script file name: replace '#' with '/', append ".vim". */
20787 }
20789 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20791 /*
20792 * Function given to ExpandGeneric() to obtain the list of user defined
20793 * function names.
20794 */
20795 char_u *
20799 {
20805 {
20808 }
20810 {
20822 {
20826 }
20828 }
20830 }
20834 /*
20835 * Copy the function name of "fp" to buffer "buf".
20836 * "buf" must be able to hold the function name plus three bytes.
20837 * Takes care of script-local function names.
20838 */
20839 static void
20843 {
20845 {
20848 }
20849 else
20851 }
20853 /*
20854 * ":delfunction {name}"
20855 */
20856 void
20859 {
20863 funcdict_T fudi;
20869 {
20873 }
20875 {
20879 }
20889 {
20891 {
20894 }
20896 {
20899 }
20902 {
20903 /* Delete the dict item that refers to the function, it will
20904 * invoke func_unref() and possibly delete the function. */
20906 }
20907 else
20909 }
20910 }
20912 /*
20913 * Free a function and remove it from the list of functions.
20914 */
20915 static void
20918 {
20921 /* clear this function */
20924 #ifdef FEAT_PROFILE
20928 #endif
20930 /* remove the function from the function hashtable */
20934 else
20938 }
20940 /*
20941 * Unreference a Function: decrement the reference count and free it when it
20942 * becomes zero. Only for numbered functions.
20943 */
20944 static void
20947 {
20951 {
20956 {
20957 /* Only delete it when it's not being used. Otherwise it's done
20958 * when "uf_calls" becomes zero. */
20961 }
20962 }
20963 }
20965 /*
20966 * Count a reference to a Function.
20967 */
20968 static void
20971 {
20975 {
20979 else
20981 }
20982 }
20984 /*
20985 * Call a user function.
20986 */
20987 static void
20996 {
20998 linenr_T save_sourcing_lnum;
20999 scid_T save_current_SID;
21000 funccall_T fc;
21009 #ifdef FEAT_PROFILE
21010 proftime_T wait_start;
21011 proftime_T call_start;
21012 #endif
21014 /* If depth of calling is getting too high, don't execute the function */
21016 {
21021 }
21034 /* Check if this function has a breakpoint. */
21038 /*
21039 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21040 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21041 * each argument variable and saves a lot of time.
21042 */
21043 /*
21044 * Init l: variables.
21045 */
21048 {
21049 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21050 * some compiler that checks the destination size. */
21060 }
21062 /*
21063 * Init a: variables.
21064 * Set a:0 to "argcount".
21065 * Set a:000 to a list with room for the "..." arguments.
21066 */
21081 /*
21082 * Set a:firstline to "firstline" and a:lastline to "lastline".
21083 * Set a:name to named arguments.
21084 * Set a:N to the "..." arguments.
21085 */
21091 {
21094 /* named argument a:name */
21096 else
21097 {
21098 /* "..." argument a:1, a:2, etc. */
21101 }
21103 {
21106 }
21107 else
21108 {
21114 }
21118 /* Note: the values are copied directly to avoid alloc/free.
21119 * "argvars" must have VAR_FIXED for v_lock. */
21124 {
21128 }
21129 }
21131 /* Don't redraw while executing the function. */
21139 {
21143 else
21148 {
21154 {
21162 {
21167 else
21168 {
21171 {
21175 }
21176 }
21177 }
21179 }
21184 }
21185 }
21186 #ifdef FEAT_PROFILE
21188 {
21193 {
21197 }
21199 }
21200 #endif
21207 /* call do_cmdline() to execute the lines */
21213 /* when the function was aborted because of an error, return -1 */
21215 {
21219 }
21221 #ifdef FEAT_PROFILE
21224 {
21230 {
21233 }
21234 }
21235 #endif
21237 /* when being verbose, mention the return value */
21239 {
21248 else
21249 {
21255 /* The value may be very long. Skip the middle part, so that we
21256 * have some idea how it starts and ends. smsg() would always
21257 * truncate it at the end. */
21260 {
21264 }
21265 }
21270 }
21276 #ifdef FEAT_PROFILE
21279 #endif
21282 {
21291 }
21296 /* The a: variables typevals were not allocated, only free the allocated
21297 * variables. */
21302 }
21304 /*
21305 * Add a number variable "name" to dict "dp" with value "nr".
21306 */
21307 static void
21312 varnumber_T nr;
21313 {
21320 }
21322 /*
21323 * ":return [expr]"
21324 */
21325 void
21328 {
21330 typval_T rettv;
21334 {
21337 }
21345 {
21348 else
21350 }
21351 /* It's safer to return also on error. */
21353 {
21354 /*
21355 * Return unless the expression evaluation has been cancelled due to an
21356 * aborting error, an interrupt, or an exception.
21357 */
21360 }
21362 /* When skipping or the return gets pending, advance to the next command
21363 * in this line (!returning). Otherwise, ignore the rest of the line.
21364 * Following lines will be ignored by get_func_line(). */
21372 }
21374 /*
21375 * Return from a function. Possibly makes the return pending. Also called
21376 * for a pending return at the ":endtry" or after returning from an extra
21377 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21378 * when called due to a ":return" command. "rettv" may point to a typval_T
21379 * with the return rettv. Returns TRUE when the return can be carried out,
21380 * FALSE when the return gets pending.
21381 */
21382 int
21388 {
21393 /* Undo the return. */
21396 /*
21397 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21398 * not in its finally clause (which then is to be executed next) is found.
21399 * In this case, make the ":return" pending for execution at the ":endtry".
21400 * Otherwise, return normally.
21401 */
21404 {
21408 /* A pending return again gets pending. "rettv" points to an
21409 * allocated variable with the rettv of the original ":return"'s
21410 * argument if present or is NULL else. */
21412 else
21413 {
21414 /* When undoing a return in order to make it pending, get the stored
21415 * return rettv. */
21420 {
21421 /* Store the value of the pending return. */
21424 else
21426 }
21427 else
21431 {
21432 /* The pending return value could be overwritten by a ":return"
21433 * without argument in a finally clause; reset the default
21434 * return value. */
21437 }
21438 }
21440 }
21441 else
21442 {
21445 /* If the return is carried out now, store the return value. For
21446 * a return immediately after reanimation, the value is already
21447 * there. */
21449 {
21454 }
21455 }
21458 }
21460 /*
21461 * Free the variable with a pending return value.
21462 */
21463 void
21466 {
21468 }
21470 /*
21471 * Generate a return command for producing the value of "rettv". The result
21472 * is an allocated string. Used by report_pending() for verbose messages.
21473 */
21474 char_u *
21477 {
21493 }
21495 /*
21496 * Get next function line.
21497 * Called by do_cmdline() to get the next line.
21498 * Returns allocated string, or NULL for end of function.
21499 */
21500 /* ARGSUSED */
21501 char_u *
21506 {
21512 /* If breakpoints have been added/deleted need to check for it. */
21514 {
21516 sourcing_lnum);
21518 }
21519 #ifdef FEAT_PROFILE
21522 #endif
21528 else
21529 {
21530 /* Skip NULL lines (continuation lines). */
21536 else
21537 {
21540 #ifdef FEAT_PROFILE
21543 #endif
21544 }
21545 }
21547 /* Did we encounter a breakpoint? */
21549 {
21551 /* Find next breakpoint. */
21553 sourcing_lnum);
21555 }
21558 }
21560 #if defined(FEAT_PROFILE) || defined(PROTO)
21561 /*
21562 * Called when starting to read a function line.
21563 * "sourcing_lnum" must be correct!
21564 * When skipping lines it may not actually be executed, but we won't find out
21565 * until later and we need to store the time now.
21566 */
21567 void
21570 {
21576 {
21578 /* Skip continuation lines. */
21585 }
21586 }
21588 /*
21589 * Called when actually executing a function line.
21590 */
21591 void
21594 {
21600 }
21602 /*
21603 * Called when done with a function line.
21604 */
21605 void
21608 {
21613 {
21615 {
21622 }
21624 }
21625 }
21626 #endif
21628 /*
21629 * Return TRUE if the currently active function should be ended, because a
21630 * return was encountered or an error occurred. Used inside a ":while".
21631 */
21632 int
21635 {
21638 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21639 * an error inside a try conditional. */
21642 }
21644 /*
21645 * return TRUE if cookie indicates a function which "abort"s on errors.
21646 */
21647 int
21650 {
21652 }
21654 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21656 {
21659 VAR_FLAVOUR_VIMINFO /* all uppercase */
21664 static var_flavour_T
21667 {
21671 {
21676 }
21677 else
21679 }
21680 #endif
21682 #if defined(FEAT_VIMINFO) || defined(PROTO)
21683 /*
21684 * Restore global vars that start with a capital from the viminfo file
21685 */
21686 int
21690 {
21693 typval_T tv;
21696 {
21699 {
21703 #ifdef FEAT_FLOAT
21706 #endif
21710 {
21715 #ifdef FEAT_FLOAT
21718 #endif
21719 else
21724 }
21725 }
21726 }
21729 }
21731 /*
21732 * Write global vars that start with a capital to the viminfo file
21733 */
21734 void
21737 {
21753 {
21755 {
21759 {
21761 {
21764 #ifdef FEAT_FLOAT
21766 #endif
21768 }
21774 }
21775 }
21776 }
21777 }
21778 #endif
21780 #if defined(FEAT_SESSION) || defined(PROTO)
21781 int
21784 {
21792 {
21794 {
21800 {
21801 /* Escape special characters with a backslash. Turn a LF and
21802 * CR into \n and \r. */
21816 p,
21820 {
21823 }
21825 }
21826 #ifdef FEAT_FLOAT
21829 {
21834 {
21837 }
21842 }
21843 #endif
21844 }
21845 }
21847 }
21848 #endif
21850 /*
21851 * Display script name where an item was last set.
21852 * Should only be invoked when 'verbose' is non-zero.
21853 */
21854 void
21856 scid_T scriptID;
21857 {
21861 {
21864 {
21870 }
21871 }
21872 }
21877 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21879 #ifdef WIN3264
21880 /*
21881 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21882 */
21884 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21887 /*
21888 * Get the short path (8.3) for the filename in "fnamep".
21889 * Only works for a valid file name.
21890 * When the path gets longer "fnamep" is changed and the allocated buffer
21891 * is put in "bufp".
21892 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21893 * Returns OK on success, FAIL on failure.
21894 */
21895 static int
21900 {
21907 {
21908 /* If that doesn't work (not enough space), then save the string
21909 * and try again with a new buffer big enough. */
21917 /* Really should always succeed, as the buffer is big enough. */
21919 }
21923 }
21925 /*
21926 * Get the short path (8.3) for the filename in "fname". The converted
21927 * path is returned in "bufp".
21928 *
21929 * Some of the directories specified in "fname" may not exist. This function
21930 * will shorten the existing directories at the beginning of the path and then
21931 * append the remaining non-existing path.
21932 *
21933 * fname - Pointer to the filename to shorten. On return, contains the
21934 * pointer to the shortened pathname
21935 * bufp - Pointer to an allocated buffer for the filename.
21936 * fnamelen - Length of the filename pointed to by fname
21937 *
21938 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21939 */
21940 static int
21945 {
21948 char_u ch;
21953 /* Make a copy */
21962 /*
21963 * Try shortening the supplied path till it succeeds by removing one
21964 * directory at a time from the tail of the path.
21965 */
21968 {
21969 /* go back one path-separator */
21975 /*
21976 * Replace the path separator with a NUL and try to shorten the
21977 * resulting path.
21978 */
21984 {
21987 }
21993 /* failed to shorten the path. Skip the path separator */
21995 }
21998 {
21999 /*
22000 * Succeeded in shortening the path. Now concatenate the shortened
22001 * path with the remaining path at the tail.
22002 */
22004 /* Compute the length of the new path. */
22011 {
22012 /* There is not enough space in the currently allocated string,
22013 * copy it to a buffer big enough. */
22016 {
22019 }
22020 }
22021 else
22022 {
22023 /* Transfer short_fname to the main buffer (it's big enough),
22024 * unless get_short_pathname() did its work in-place. */
22029 }
22031 /* concat the not-shortened part of the path */
22034 }
22036 theend:
22041 }
22043 /*
22044 * Get a pathname for a partial path.
22045 * Returns OK for success, FAIL for failure.
22046 */
22047 static int
22052 {
22058 /* Count up the path separators from the RHS.. so we know which part
22059 * of the path to return. */
22065 /* Need full path first (use expand_env() to remove a "~/") */
22069 else
22078 {
22079 /* Don't have a valid filename, so shorten the rest of the
22080 * path if we can. This CAN give us invalid 8.3 filenames, but
22081 * there's not a lot of point in guessing what it might be.
22082 */
22086 }
22088 /* Count the paths backward to find the beginning of the desired string. */
22090 {
22091 #ifdef FEAT_MBYTE
22094 #endif
22096 {
22099 else
22100 sepcount --;
22101 }
22102 }
22104 {
22108 else
22110 }
22111 else
22114 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22121 }
22124 /*
22125 * Adjust a filename, according to a string of modifiers.
22126 * *fnamep must be NUL terminated when called. When returning, the length is
22127 * determined by *fnamelen.
22128 * Returns VALID_ flags or -1 for failure.
22129 * When there is an error, *fnamep is set to NULL.
22130 */
22131 int
22138 {
22145 #ifdef WIN3264
22147 #endif
22149 repeat:
22150 /* ":p" - full path/file_name */
22152 {
22158 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22160 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22162 # ifdef BACKSLASH_IN_FILENAME
22164 # endif
22167 #endif
22168 )
22169 {
22175 }
22177 /* When "/." or "/.." is used: force expansion to get rid of it. */
22179 {
22187 }
22189 /* FullName_save() is slow, don't use it when not needed. */
22191 {
22197 }
22199 /* Append a path separator to a directory. */
22201 {
22202 /* Make room for one or two extra characters. */
22209 }
22210 }
22212 /* ":." - path relative to the current directory */
22213 /* ":~" - path relative to the home directory */
22214 /* ":8" - shortname path - postponed till after */
22217 {
22220 {
22221 #ifdef WIN3264
22223 #endif
22225 }
22227 /* Need full path first (use expand_env() to remove a "~/") */
22229 {
22232 else
22234 }
22235 else
22241 {
22243 {
22247 {
22250 {
22254 }
22255 }
22256 }
22257 else
22258 {
22260 /* Only replace it when it starts with '~' */
22262 {
22265 {
22269 }
22270 }
22271 }
22273 }
22274 }
22279 /* ":h" - head, remove "/file_name", can be repeated */
22280 /* Don't remove the first "/" or "c:\" */
22282 {
22289 #ifdef VMS
22292 #endif
22294 {
22295 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22302 }
22303 else
22304 {
22307 }
22308 }
22310 /* ":8" - shortname */
22312 {
22314 #ifdef WIN3264
22316 #endif
22317 }
22319 #ifdef WIN3264
22320 /* Check shortname after we have done 'heads' and before we do 'tails'
22321 */
22323 {
22325 /* Copy the string if it is shortened by :h */
22327 {
22333 }
22335 /* Split into two implementations - makes it easier. First is where
22336 * there isn't a full name already, second is where there is.
22337 */
22339 {
22342 }
22343 else
22344 {
22347 /* Simple case, already have the full-name
22348 * Nearly always shorter, so try first time. */
22354 {
22355 /* Couldn't find the filename.. search the paths.
22356 */
22360 }
22362 }
22363 }
22366 /* ":t" - tail, just the basename */
22368 {
22372 }
22374 /* ":e" - extension, can be repeated */
22375 /* ":r" - root, without extension, can be repeated */
22378 {
22379 /* find a '.' in the tail:
22380 * - for second :e: before the current fname
22381 * - otherwise: The last '.'
22382 */
22385 else
22391 {
22393 {
22396 #ifdef VMS
22397 /* cut version from the extension */
22404 #endif
22405 }
22408 }
22410 {
22413 }
22415 }
22417 /* ":s?pat?foo?" - substitute */
22418 /* ":gs?pat?foo?" - global substitute */
22422 {
22433 {
22436 }
22440 {
22441 /* find end of pattern */
22444 {
22447 {
22449 /* find end of substitution */
22452 {
22456 {
22460 {
22466 }
22467 }
22470 }
22472 }
22473 }
22474 /* after using ":s", repeat all the modifiers */
22477 }
22478 }
22481 }
22483 /*
22484 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22485 * "flags" can be "g" to do a global substitute.
22486 * Returns an allocated string, NULL for error.
22487 */
22488 char_u *
22494 {
22496 regmatch_T regmatch;
22500 garray_T ga;
22504 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22515 {
22518 {
22519 /*
22520 * Get some space for a temporary buffer to do the substitution
22521 * into. It will contain:
22522 * - The text up to where the match is.
22523 * - The substituted text.
22524 * - The text after the match.
22525 */
22529 {
22532 }
22534 /* copy the text up to where the match is */
22537 /* add the substituted text */
22541 /* avoid getting stuck on a match with an empty string */
22543 {
22548 }
22549 else
22550 {
22554 }
22557 }
22563 }
22570 }