| blob | 7ebaa08f12a349555ed67c07d7a191f2727da654 |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(MSWIN)
15 #endif
19 #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 {
9706 {
9709 }
9710 else
9714 }
9716 /*
9717 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9718 * rights to write into.
9719 */
9720 static void
9724 {
9726 }
9730 static void
9735 {
9736 #ifdef FEAT_SEARCHPATH
9745 #endif
9750 #ifdef FEAT_SEARCHPATH
9754 {
9758 else
9759 {
9765 }
9766 }
9772 {
9773 do
9774 {
9780 find_what,
9782 find_what == FINDFILE_DIR
9790 }
9794 #endif
9795 }
9800 /*
9801 * Implementation of map() and filter().
9802 */
9803 static void
9808 {
9817 typval_T save_val;
9818 typval_T save_key;
9826 {
9830 }
9832 {
9836 }
9837 else
9838 {
9841 }
9844 /* On type errors, the preceding call has already displayed an error
9845 * message. Avoid a misleading error message for an empty string that
9846 * was not passed as argument. */
9848 {
9852 /* We reset "did_emsg" to be able to detect whether an error
9853 * occurred during evaluation of the expression. */
9858 {
9866 {
9868 {
9880 }
9881 }
9885 }
9886 else
9887 {
9889 {
9898 }
9899 }
9904 }
9907 }
9909 static int
9915 {
9916 typval_T rettv;
9925 {
9928 }
9930 {
9931 /* map(): replace the list item value */
9935 }
9936 else
9937 {
9940 /* filter(): when expr is zero remove the item */
9943 /* On type error, nothing has been removed; return FAIL to stop the
9944 * loop. The error message was given by get_tv_number_chk(). */
9947 }
9949 theend:
9952 }
9954 /*
9955 * "filter()" function
9956 */
9957 static void
9961 {
9963 }
9965 /*
9966 * "finddir({fname}[, {path}[, {count}]])" function
9967 */
9968 static void
9972 {
9974 }
9976 /*
9977 * "findfile({fname}[, {path}[, {count}]])" function
9978 */
9979 static void
9983 {
9985 }
9987 #ifdef FEAT_FLOAT
9988 /*
9989 * "float2nr({float})" function
9990 */
9991 static void
9995 {
9996 float_T f;
9999 {
10004 else
10006 }
10007 else
10009 }
10011 /*
10012 * "floor({float})" function
10013 */
10014 static void
10018 {
10019 float_T f;
10024 else
10026 }
10027 #endif
10029 /*
10030 * "fnameescape({string})" function
10031 */
10032 static void
10036 {
10040 }
10042 /*
10043 * "fnamemodify({fname}, {mods})" function
10044 */
10045 static void
10049 {
10061 else
10062 {
10065 }
10070 else
10073 }
10077 /*
10078 * "foldclosed()" function
10079 */
10080 static void
10085 {
10086 #ifdef FEAT_FOLDING
10087 linenr_T lnum;
10092 {
10094 {
10097 else
10100 }
10101 }
10102 #endif
10104 }
10106 /*
10107 * "foldclosed()" function
10108 */
10109 static void
10113 {
10115 }
10117 /*
10118 * "foldclosedend()" function
10119 */
10120 static void
10124 {
10126 }
10128 /*
10129 * "foldlevel()" function
10130 */
10131 static void
10135 {
10136 #ifdef FEAT_FOLDING
10137 linenr_T lnum;
10142 else
10143 #endif
10145 }
10147 /*
10148 * "foldtext()" function
10149 */
10150 /*ARGSUSED*/
10151 static void
10155 {
10156 #ifdef FEAT_FOLDING
10157 linenr_T lnum;
10162 #endif
10166 #ifdef FEAT_FOLDING
10171 {
10172 /* Find first non-empty line in the fold. */
10175 {
10179 }
10181 /* Find interesting text in this line. */
10183 /* skip C comment-start */
10185 {
10189 {
10193 }
10194 }
10201 {
10207 /* remove 'foldmarker' and 'commentstring' */
10210 }
10211 }
10212 #endif
10213 }
10215 /*
10216 * "foldtextresult(lnum)" function
10217 */
10218 /*ARGSUSED*/
10219 static void
10223 {
10224 #ifdef FEAT_FOLDING
10225 linenr_T lnum;
10228 foldinfo_T foldinfo;
10230 #endif
10234 #ifdef FEAT_FOLDING
10236 /* treat illegal types and illegal string values for {lnum} the same */
10241 {
10247 }
10248 #endif
10249 }
10251 /*
10252 * "foreground()" function
10253 */
10254 /*ARGSUSED*/
10255 static void
10259 {
10261 #ifdef FEAT_GUI
10264 #else
10265 # ifdef WIN32
10267 # endif
10268 #endif
10269 }
10271 /*
10272 * "function()" function
10273 */
10274 /*ARGSUSED*/
10275 static void
10279 {
10288 else
10289 {
10292 }
10293 }
10295 /*
10296 * "garbagecollect()" function
10297 */
10298 /*ARGSUSED*/
10299 static void
10303 {
10304 /* This is postponed until we are back at the toplevel, because we may be
10305 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
10310 }
10312 /*
10313 * "get()" function
10314 */
10315 static void
10319 {
10327 {
10329 {
10335 }
10336 }
10338 {
10340 {
10344 }
10345 }
10346 else
10350 {
10353 else
10355 }
10356 else
10358 }
10360 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
10362 /*
10363 * Get line or list of lines from buffer "buf" into "rettv".
10364 * Return a range (from start to end) of lines in rettv from the specified
10365 * buffer.
10366 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
10367 */
10368 static void
10371 linenr_T start;
10372 linenr_T end;
10375 {
10379 {
10382 }
10383 else
10390 {
10393 else
10398 }
10399 else
10400 {
10412 }
10413 }
10415 /*
10416 * "getbufline()" function
10417 */
10418 static void
10422 {
10423 linenr_T lnum;
10424 linenr_T end;
10435 else
10439 }
10441 /*
10442 * "getbufvar()" function
10443 */
10444 static void
10448 {
10463 {
10464 /* set curbuf to be our buf, temporarily */
10470 else
10471 {
10473 /* let getbufvar({nr}, "") return the "b:" dictionary. The
10474 * scope prefix before the NUL byte is required by
10475 * find_var_in_ht(). */
10477 /* look up the variable */
10481 }
10483 /* restore previous notion of curbuf */
10485 }
10488 }
10490 /*
10491 * "getchar()" function
10492 */
10493 static void
10497 {
10498 varnumber_T n;
10501 /* Position the cursor. Needed after a message that ends in a space. */
10507 {
10509 /* getchar(): blocking wait. */
10512 /* getchar(1): only check if char avail */
10515 /* illegal argument or getchar(0) and no char avail: return zero */
10517 else
10518 /* getchar(0) and char avail: return char */
10523 }
10533 {
10537 /* Turn a special key into three bytes, plus modifier. */
10539 {
10543 }
10545 {
10549 }
10550 #ifdef FEAT_MBYTE
10553 #endif
10554 else
10560 #ifdef FEAT_MOUSE
10580 {
10584 linenr_T lnum;
10585 # ifdef FEAT_WINDOWS
10587 # endif
10591 {
10592 /* Find the window at the mouse coordinates and compute the
10593 * text position. */
10596 # ifdef FEAT_WINDOWS
10599 # endif
10603 }
10604 }
10605 #endif
10606 }
10607 }
10609 /*
10610 * "getcharmod()" function
10611 */
10612 /*ARGSUSED*/
10613 static void
10617 {
10619 }
10621 /*
10622 * "getcmdline()" function
10623 */
10624 /*ARGSUSED*/
10625 static void
10629 {
10632 }
10634 /*
10635 * "getcmdpos()" function
10636 */
10637 /*ARGSUSED*/
10638 static void
10642 {
10644 }
10646 /*
10647 * "getcmdtype()" function
10648 */
10649 /*ARGSUSED*/
10650 static void
10654 {
10658 {
10661 }
10662 }
10664 /*
10665 * "getcwd()" function
10666 */
10667 /*ARGSUSED*/
10668 static void
10672 {
10678 else
10679 {
10681 #ifdef BACKSLASH_IN_FILENAME
10684 #endif
10685 }
10686 }
10688 /*
10689 * "getfontname()" function
10690 */
10691 /*ARGSUSED*/
10692 static void
10696 {
10699 #ifdef FEAT_GUI
10701 {
10702 GuiFont font;
10706 {
10707 /* Get the "Normal" font. Either the name saved by
10708 * hl_set_font_name() or from the font ID. */
10711 }
10712 else
10713 {
10720 }
10724 }
10725 #endif
10726 }
10728 /*
10729 * "getfperm({fname})" function
10730 */
10731 static void
10735 {
10746 {
10749 {
10751 {
10754 }
10755 }
10756 }
10758 }
10760 /*
10761 * "getfsize({fname})" function
10762 */
10763 static void
10767 {
10776 {
10779 else
10780 {
10783 /* non-perfect check for overflow */
10786 }
10787 }
10788 else
10790 }
10792 /*
10793 * "getftime({fname})" function
10794 */
10795 static void
10799 {
10807 else
10809 }
10811 /*
10812 * "getftype({fname})" function
10813 */
10814 static void
10818 {
10828 {
10829 #ifdef S_ISREG
10834 # ifdef S_ISLNK
10837 # endif
10838 # ifdef S_ISBLK
10841 # endif
10842 # ifdef S_ISCHR
10845 # endif
10846 # ifdef S_ISFIFO
10849 # endif
10850 # ifdef S_ISSOCK
10853 # endif
10854 else
10856 #else
10857 # ifdef S_IFMT
10859 {
10862 # ifdef S_IFLNK
10864 # endif
10865 # ifdef S_IFBLK
10867 # endif
10868 # ifdef S_IFCHR
10870 # endif
10871 # ifdef S_IFIFO
10873 # endif
10874 # ifdef S_IFSOCK
10876 # endif
10878 }
10879 # else
10882 else
10884 # endif
10885 #endif
10887 }
10889 }
10891 /*
10892 * "getline(lnum, [end])" function
10893 */
10894 static void
10898 {
10899 linenr_T lnum;
10900 linenr_T end;
10905 {
10908 }
10909 else
10910 {
10913 }
10916 }
10918 /*
10919 * "getmatches()" function
10920 */
10921 /*ARGSUSED*/
10922 static void
10926 {
10927 #ifdef FEAT_SEARCH_EXTRA
10934 {
10936 {
10946 }
10947 }
10948 #endif
10949 }
10951 /*
10952 * "getpid()" function
10953 */
10954 /*ARGSUSED*/
10955 static void
10959 {
10961 }
10963 /*
10964 * "getpos(string)" function
10965 */
10966 static void
10970 {
10976 {
10981 else
10989 #ifdef FEAT_VIRTUALEDIT
10991 #endif
10993 }
10994 else
10996 }
10998 /*
10999 * "getqflist()" and "getloclist()" functions
11000 */
11001 /*ARGSUSED*/
11002 static void
11006 {
11007 #ifdef FEAT_QUICKFIX
11009 #endif
11012 #ifdef FEAT_QUICKFIX
11014 {
11017 {
11021 }
11024 }
11025 #endif
11026 }
11028 /*
11029 * "getreg()" function
11030 */
11031 static void
11035 {
11042 {
11047 }
11048 else
11057 }
11059 /*
11060 * "getregtype()" function
11061 */
11062 static void
11066 {
11073 {
11076 {
11080 }
11081 }
11082 else
11083 /* Default to v:register */
11093 {
11096 #ifdef FEAT_VISUAL
11101 #endif
11102 }
11105 }
11107 /*
11108 * "gettabwinvar()" function
11109 */
11110 static void
11114 {
11116 }
11118 /*
11119 * "getwinposx()" function
11120 */
11121 /*ARGSUSED*/
11122 static void
11126 {
11128 #ifdef FEAT_GUI
11130 {
11135 }
11136 #endif
11137 }
11139 /*
11140 * "getwinposy()" function
11141 */
11142 /*ARGSUSED*/
11143 static void
11147 {
11149 #ifdef FEAT_GUI
11151 {
11156 }
11157 #endif
11158 }
11160 /*
11161 * Find window specified by "vp" in tabpage "tp".
11162 */
11167 {
11168 #ifdef FEAT_WINDOWS
11170 #endif
11175 #ifdef FEAT_WINDOWS
11186 #else
11190 #endif
11191 }
11193 /*
11194 * "getwinvar()" function
11195 */
11196 static void
11200 {
11202 }
11204 /*
11205 * getwinvar() and gettabwinvar()
11206 */
11207 static void
11212 {
11218 #ifdef FEAT_WINDOWS
11221 else
11223 #endif
11232 {
11233 /* Set curwin to be our win, temporarily. Also set curbuf, so
11234 * that we can get buffer-local options. */
11241 else
11242 {
11244 /* let getwinvar({nr}, "") return the "w:" dictionary. The
11245 * scope prefix before the NUL byte is required by
11246 * find_var_in_ht(). */
11248 /* look up the variable */
11252 }
11254 /* restore previous notion of curwin */
11257 }
11260 }
11262 /*
11263 * "glob()" function
11264 */
11265 static void
11269 {
11270 expand_T xpc;
11277 }
11279 /*
11280 * "globpath()" function
11281 */
11282 static void
11286 {
11293 else
11295 }
11297 /*
11298 * "has()" function
11299 */
11300 static void
11304 {
11309 {
11310 #ifdef AMIGA
11312 # ifdef FEAT_ARP
11314 # endif
11315 #endif
11316 #ifdef __BEOS__
11318 #endif
11319 #ifdef MSDOS
11320 # ifdef DJGPP
11322 # else
11324 # endif
11325 #endif
11326 #ifdef MACOS
11328 #endif
11329 #if defined(MACOS_X_UNIX)
11331 #endif
11332 #ifdef OS2
11334 #endif
11335 #ifdef __QNX__
11337 #endif
11338 #ifdef RISCOS
11340 #endif
11341 #ifdef UNIX
11343 #endif
11344 #ifdef VMS
11346 #endif
11347 #ifdef WIN16
11349 #endif
11350 #ifdef WIN32
11352 #endif
11353 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
11355 #endif
11356 #ifdef WIN64
11358 #endif
11359 #ifdef EBCDIC
11361 #endif
11362 #ifndef CASE_INSENSITIVE_FILENAME
11364 #endif
11365 #ifdef FEAT_ARABIC
11367 #endif
11368 #ifdef FEAT_AUTOCMD
11370 #endif
11371 #ifdef FEAT_BEVAL
11375 # endif
11376 #endif
11377 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
11379 # ifdef ALL_BUILTIN_TCAPS
11381 # endif
11382 #endif
11383 #ifdef FEAT_BYTEOFF
11385 #endif
11386 #ifdef FEAT_CINDENT
11388 #endif
11389 #ifdef FEAT_CLIENTSERVER
11391 #endif
11392 #ifdef FEAT_CLIPBOARD
11394 #endif
11395 #ifdef FEAT_CMDL_COMPL
11397 #endif
11398 #ifdef FEAT_CMDHIST
11400 #endif
11401 #ifdef FEAT_COMMENTS
11403 #endif
11404 #ifdef FEAT_CRYPT
11406 #endif
11407 #ifdef FEAT_CSCOPE
11409 #endif
11410 #ifdef CURSOR_SHAPE
11412 #endif
11413 #ifdef DEBUG
11415 #endif
11416 #ifdef FEAT_CON_DIALOG
11418 #endif
11419 #ifdef FEAT_GUI_DIALOG
11421 #endif
11422 #ifdef FEAT_DIFF
11424 #endif
11425 #ifdef FEAT_DIGRAPHS
11427 #endif
11428 #ifdef FEAT_DND
11430 #endif
11431 #ifdef FEAT_EMACS_TAGS
11433 #endif
11435 #ifdef FEAT_EX_EXTRA
11437 #endif
11438 #ifdef FEAT_SEARCH_EXTRA
11440 #endif
11441 #ifdef FEAT_FKMAP
11443 #endif
11444 #ifdef FEAT_SEARCHPATH
11446 #endif
11447 #if defined(UNIX) && !defined(USE_SYSTEM)
11449 #endif
11450 #ifdef FEAT_FIND_ID
11452 #endif
11453 #ifdef FEAT_FLOAT
11455 #endif
11456 #ifdef FEAT_FOLDING
11458 #endif
11459 #ifdef FEAT_FOOTER
11461 #endif
11462 #if !defined(USE_SYSTEM) && defined(UNIX)
11464 #endif
11465 #ifdef FEAT_GETTEXT
11467 #endif
11468 #ifdef FEAT_GUI
11470 #endif
11471 #ifdef FEAT_GUI_ATHENA
11472 # ifdef FEAT_GUI_NEXTAW
11474 # else
11476 # endif
11477 #endif
11478 #ifdef FEAT_GUI_GTK
11480 # ifdef HAVE_GTK2
11482 # endif
11483 #endif
11484 #ifdef FEAT_GUI_GNOME
11486 #endif
11487 #ifdef FEAT_GUI_MAC
11489 #endif
11490 #ifdef FEAT_GUI_MOTIF
11492 #endif
11493 #ifdef FEAT_GUI_PHOTON
11495 #endif
11496 #ifdef FEAT_GUI_W16
11498 #endif
11499 #ifdef FEAT_GUI_W32
11501 #endif
11502 #ifdef FEAT_HANGULIN
11504 #endif
11505 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11507 #endif
11508 #ifdef FEAT_INS_EXPAND
11510 #endif
11511 #ifdef FEAT_JUMPLIST
11513 #endif
11514 #ifdef FEAT_KEYMAP
11516 #endif
11517 #ifdef FEAT_LANGMAP
11519 #endif
11520 #ifdef FEAT_LIBCALL
11522 #endif
11523 #ifdef FEAT_LINEBREAK
11525 #endif
11526 #ifdef FEAT_LISP
11528 #endif
11529 #ifdef FEAT_LISTCMDS
11531 #endif
11532 #ifdef FEAT_LOCALMAP
11534 #endif
11535 #ifdef FEAT_MENU
11537 #endif
11538 #ifdef FEAT_SESSION
11540 #endif
11541 #ifdef FEAT_MODIFY_FNAME
11543 #endif
11544 #ifdef FEAT_MOUSE
11546 #endif
11547 #ifdef FEAT_MOUSESHAPE
11549 #endif
11550 #if defined(UNIX) || defined(VMS)
11551 # ifdef FEAT_MOUSE_DEC
11553 # endif
11554 # ifdef FEAT_MOUSE_GPM
11556 # endif
11557 # ifdef FEAT_MOUSE_JSB
11559 # endif
11560 # ifdef FEAT_MOUSE_NET
11562 # endif
11563 # ifdef FEAT_MOUSE_PTERM
11565 # endif
11566 # ifdef FEAT_SYSMOUSE
11568 # endif
11569 # ifdef FEAT_MOUSE_XTERM
11571 # endif
11572 #endif
11573 #ifdef FEAT_MBYTE
11575 #endif
11576 #ifdef FEAT_MBYTE_IME
11578 #endif
11579 #ifdef FEAT_MULTI_LANG
11581 #endif
11582 #ifdef FEAT_MZSCHEME
11583 #ifndef DYNAMIC_MZSCHEME
11585 #endif
11586 #endif
11587 #ifdef FEAT_OLE
11589 #endif
11590 #ifdef FEAT_OSFILETYPE
11592 #endif
11593 #ifdef FEAT_PATH_EXTRA
11595 #endif
11596 #ifdef FEAT_PERL
11597 #ifndef DYNAMIC_PERL
11599 #endif
11600 #endif
11601 #ifdef FEAT_PYTHON
11602 #ifndef DYNAMIC_PYTHON
11604 #endif
11605 #endif
11606 #ifdef FEAT_POSTSCRIPT
11608 #endif
11609 #ifdef FEAT_PRINTER
11611 #endif
11612 #ifdef FEAT_PROFILE
11614 #endif
11615 #ifdef FEAT_RELTIME
11617 #endif
11618 #ifdef FEAT_QUICKFIX
11620 #endif
11621 #ifdef FEAT_RIGHTLEFT
11623 #endif
11624 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11626 #endif
11627 #ifdef FEAT_SCROLLBIND
11629 #endif
11630 #ifdef FEAT_CMDL_INFO
11633 #endif
11634 #ifdef FEAT_SIGNS
11636 #endif
11637 #ifdef FEAT_SMARTINDENT
11639 #endif
11640 #ifdef FEAT_SNIFF
11642 #endif
11643 #ifdef FEAT_STL_OPT
11645 #endif
11646 #ifdef FEAT_SUN_WORKSHOP
11648 #endif
11649 #ifdef FEAT_NETBEANS_INTG
11651 #endif
11652 #ifdef FEAT_SPELL
11654 #endif
11655 #ifdef FEAT_SYN_HL
11657 #endif
11658 #if defined(USE_SYSTEM) || !defined(UNIX)
11660 #endif
11661 #ifdef FEAT_TAG_BINS
11663 #endif
11664 #ifdef FEAT_TAG_OLDSTATIC
11666 #endif
11667 #ifdef FEAT_TAG_ANYWHITE
11669 #endif
11670 #ifdef FEAT_TCL
11671 # ifndef DYNAMIC_TCL
11673 # endif
11674 #endif
11675 #ifdef TERMINFO
11677 #endif
11678 #ifdef FEAT_TERMRESPONSE
11680 #endif
11681 #ifdef FEAT_TEXTOBJ
11683 #endif
11684 #ifdef HAVE_TGETENT
11686 #endif
11687 #ifdef FEAT_TITLE
11689 #endif
11690 #ifdef FEAT_TOOLBAR
11692 #endif
11693 #ifdef FEAT_USR_CMDS
11696 #endif
11697 #ifdef FEAT_VIMINFO
11699 #endif
11700 #ifdef FEAT_VERTSPLIT
11702 #endif
11703 #ifdef FEAT_VIRTUALEDIT
11705 #endif
11706 #ifdef FEAT_VISUAL
11708 #endif
11709 #ifdef FEAT_VISUALEXTRA
11711 #endif
11712 #ifdef FEAT_VREPLACE
11714 #endif
11715 #ifdef FEAT_WILDIGN
11717 #endif
11718 #ifdef FEAT_WILDMENU
11720 #endif
11721 #ifdef FEAT_WINDOWS
11723 #endif
11724 #ifdef FEAT_WAK
11726 #endif
11727 #ifdef FEAT_WRITEBACKUP
11729 #endif
11730 #ifdef FEAT_XIM
11732 #endif
11733 #ifdef FEAT_XFONTSET
11735 #endif
11736 #ifdef USE_XSMP
11738 #endif
11739 #ifdef USE_XSMP_INTERACT
11741 #endif
11742 #ifdef FEAT_XCLIPBOARD
11744 #endif
11745 #ifdef FEAT_XTERM_SAVE
11747 #endif
11748 #if defined(UNIX) && defined(FEAT_X11)
11750 #endif
11751 NULL
11752 };
11757 {
11760 }
11763 {
11768 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11771 #endif
11772 #ifdef DYNAMIC_TCL
11775 #endif
11776 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11779 #endif
11780 #ifdef DYNAMIC_MZSCHEME
11783 #endif
11784 #ifdef DYNAMIC_RUBY
11787 #endif
11788 #ifdef DYNAMIC_PYTHON
11791 #endif
11792 #ifdef DYNAMIC_PERL
11795 #endif
11796 #ifdef FEAT_GUI
11799 # ifdef FEAT_GUI_W32
11802 # endif
11803 # ifdef FEAT_BROWSE
11806 # endif
11807 #endif
11808 #ifdef FEAT_SYN_HL
11811 #endif
11812 #if defined(WIN3264)
11815 #endif
11816 #ifdef FEAT_NETBEANS_INTG
11819 #endif
11820 }
11823 }
11825 /*
11826 * "has_key()" function
11827 */
11828 static void
11832 {
11835 {
11838 }
11844 }
11846 /*
11847 * "haslocaldir()" function
11848 */
11849 /*ARGSUSED*/
11850 static void
11854 {
11856 }
11858 /*
11859 * "hasmapto()" function
11860 */
11861 static void
11865 {
11874 else
11875 {
11879 }
11883 else
11885 }
11887 /*
11888 * "histadd()" function
11889 */
11890 /*ARGSUSED*/
11891 static void
11895 {
11896 #ifdef FEAT_CMDHIST
11900 #endif
11905 #ifdef FEAT_CMDHIST
11909 {
11912 {
11916 }
11917 }
11918 #endif
11919 }
11921 /*
11922 * "histdel()" function
11923 */
11924 /*ARGSUSED*/
11925 static void
11929 {
11930 #ifdef FEAT_CMDHIST
11939 /* only one argument: clear entire history */
11942 /* index given: remove that entry */
11945 else
11946 /* string given: remove all matching entries */
11950 #else
11952 #endif
11953 }
11955 /*
11956 * "histget()" function
11957 */
11958 /*ARGSUSED*/
11959 static void
11963 {
11964 #ifdef FEAT_CMDHIST
11972 else
11973 {
11977 else
11979 /* -1 on type error */
11981 }
11982 #else
11984 #endif
11986 }
11988 /*
11989 * "histnr()" function
11990 */
11991 /*ARGSUSED*/
11992 static void
11996 {
11999 #ifdef FEAT_CMDHIST
12005 else
12006 #endif
12009 }
12011 /*
12012 * "highlightID(name)" function
12013 */
12014 static void
12018 {
12020 }
12022 /*
12023 * "highlight_exists()" function
12024 */
12025 static void
12029 {
12031 }
12033 /*
12034 * "hostname()" function
12035 */
12036 /*ARGSUSED*/
12037 static void
12041 {
12047 }
12049 /*
12050 * iconv() function
12051 */
12052 /*ARGSUSED*/
12053 static void
12057 {
12058 #ifdef FEAT_MBYTE
12062 vimconv_T vimconv;
12063 #endif
12068 #ifdef FEAT_MBYTE
12075 /* If the encodings are equal, no conversion needed. */
12078 else
12084 #endif
12085 }
12087 /*
12088 * "indent()" function
12089 */
12090 static void
12094 {
12095 linenr_T lnum;
12100 else
12102 }
12104 /*
12105 * "index()" function
12106 */
12107 static void
12111 {
12119 {
12122 }
12125 {
12128 {
12131 /* Start at specified item. Use the cached index that list_find()
12132 * sets, so that a negative number also works. */
12139 }
12143 {
12146 }
12147 }
12148 }
12154 /*
12155 * This function is used by f_input() and f_inputdialog() functions. The third
12156 * argument to f_input() specifies the type of completion to use at the
12157 * prompt. The third argument to f_inputdialog() specifies the value to return
12158 * when the user cancels the prompt.
12159 */
12160 static void
12165 {
12178 #ifdef NO_CONSOLE_INPUT
12179 /* While starting up, there is no place to enter text. */
12182 #endif
12186 {
12187 /* Only the part of the message after the last NL is considered as
12188 * prompt for the command line */
12192 else
12193 {
12203 }
12207 {
12213 {
12229 }
12230 }
12239 /* since the user typed this, no need to wait for return */
12242 }
12244 }
12246 /*
12247 * "input()" function
12248 * Also handles inputsecret() when inputsecret is set.
12249 */
12250 static void
12254 {
12256 }
12258 /*
12259 * "inputdialog()" function
12260 */
12261 static void
12265 {
12266 #if defined(FEAT_GUI_TEXTDIALOG)
12267 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12269 {
12278 else
12284 else
12285 {
12291 else
12293 }
12295 }
12296 else
12297 #endif
12299 }
12301 /*
12302 * "inputlist()" function
12303 */
12304 static void
12308 {
12314 #ifdef NO_CONSOLE_INPUT
12315 /* While starting up, there is no place to enter text. */
12318 #endif
12320 {
12323 }
12332 {
12335 }
12337 /* Ask for choice. */
12343 }
12348 /*
12349 * "inputrestore()" function
12350 */
12351 /*ARGSUSED*/
12352 static void
12356 {
12358 {
12363 }
12365 {
12368 }
12369 }
12371 /*
12372 * "inputsave()" function
12373 */
12374 /*ARGSUSED*/
12375 static void
12379 {
12380 /* Add an entry to the stack of typeahead storage. */
12382 {
12387 }
12388 else
12390 }
12392 /*
12393 * "inputsecret()" function
12394 */
12395 static void
12399 {
12405 }
12407 /*
12408 * "insert()" function
12409 */
12410 static void
12414 {
12425 {
12433 else
12434 {
12437 {
12440 }
12441 }
12443 {
12446 }
12447 }
12448 }
12450 /*
12451 * "isdirectory()" function
12452 */
12453 static void
12457 {
12459 }
12461 /*
12462 * "islocked()" function
12463 */
12464 static void
12468 {
12469 lval_T lv;
12475 FNE_CHECK_START);
12477 {
12480 else
12481 {
12483 {
12486 else
12487 {
12490 {
12491 /* Consider a variable locked when:
12492 * 1. the variable itself is locked
12493 * 2. the value of the variable is locked.
12494 * 3. the List or Dict value is locked.
12495 */
12498 }
12499 }
12500 }
12506 /* List item. */
12508 else
12509 /* Dictionary item. */
12511 }
12512 }
12515 }
12519 /*
12520 * Turn a dict into a list:
12521 * "what" == 0: list of keys
12522 * "what" == 1: list of values
12523 * "what" == 2: list of items
12524 */
12525 static void
12530 {
12541 {
12544 }
12553 {
12555 {
12565 {
12566 /* keys() */
12570 }
12572 {
12573 /* values() */
12575 }
12576 else
12577 {
12578 /* items() */
12600 }
12601 }
12602 }
12603 }
12605 /*
12606 * "items(dict)" function
12607 */
12608 static void
12612 {
12614 }
12616 /*
12617 * "join()" function
12618 */
12619 static void
12623 {
12624 garray_T ga;
12629 {
12632 }
12637 else
12643 {
12648 }
12649 else
12651 }
12653 /*
12654 * "keys()" function
12655 */
12656 static void
12660 {
12662 }
12664 /*
12665 * "last_buffer_nr()" function.
12666 */
12667 /*ARGSUSED*/
12668 static void
12672 {
12681 }
12683 /*
12684 * "len()" function
12685 */
12686 static void
12690 {
12692 {
12707 }
12708 }
12712 static void
12717 {
12718 #ifdef FEAT_LIBCALL
12722 #endif
12727 else
12733 #ifdef FEAT_LIBCALL
12734 /* The first two args must be strings, otherwise its meaningless */
12736 {
12742 else
12746 string_in,
12748 string_result,
12752 }
12753 #endif
12754 }
12756 /*
12757 * "libcall()" function
12758 */
12759 static void
12763 {
12765 }
12767 /*
12768 * "libcallnr()" function
12769 */
12770 static void
12774 {
12776 }
12778 /*
12779 * "line(string)" function
12780 */
12781 static void
12785 {
12794 }
12796 /*
12797 * "line2byte(lnum)" function
12798 */
12799 /*ARGSUSED*/
12800 static void
12804 {
12805 #ifndef FEAT_BYTEOFF
12807 #else
12808 linenr_T lnum;
12813 else
12817 #endif
12818 }
12820 /*
12821 * "lispindent(lnum)" function
12822 */
12823 static void
12827 {
12828 #ifdef FEAT_LISP
12829 pos_T pos;
12830 linenr_T lnum;
12835 {
12839 }
12840 else
12841 #endif
12843 }
12845 /*
12846 * "localtime()" function
12847 */
12848 /*ARGSUSED*/
12849 static void
12853 {
12855 }
12859 static void
12864 {
12871 garray_T ga;
12874 /* return empty string for failure */
12883 {
12887 }
12888 else
12899 {
12909 }
12910 }
12912 #ifdef FEAT_FLOAT
12913 /*
12914 * "log10()" function
12915 */
12916 static void
12920 {
12921 float_T f;
12926 else
12928 }
12929 #endif
12931 /*
12932 * "map()" function
12933 */
12934 static void
12938 {
12940 }
12942 /*
12943 * "maparg()" function
12944 */
12945 static void
12949 {
12951 }
12953 /*
12954 * "mapcheck()" function
12955 */
12956 static void
12960 {
12962 }
12966 static void
12971 {
12975 regmatch_T regmatch;
12988 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12994 {
12995 /* return empty list when there are no matches */
12998 }
13000 {
13003 }
13006 {
13010 }
13011 else
13019 {
13026 {
13031 }
13032 else
13033 {
13038 /* When "count" argument is there ignore matches before "start",
13039 * otherwise skip part of the string. Differs when pattern is "^"
13040 * or "\<". */
13043 else
13045 }
13051 }
13055 {
13059 {
13061 {
13063 {
13066 }
13071 }
13080 /* Advance to just after the match. */
13082 {
13085 }
13086 else
13087 {
13088 #ifdef FEAT_MBYTE
13091 #else
13093 #endif
13094 }
13095 }
13098 {
13100 {
13103 /* return list with matched string and submatches */
13105 {
13107 {
13111 }
13117 }
13118 }
13120 {
13121 /* return matched string */
13124 else
13127 }
13130 else
13131 {
13135 else
13139 }
13140 }
13142 }
13144 theend:
13147 }
13149 /*
13150 * "match()" function
13151 */
13152 static void
13156 {
13158 }
13160 /*
13161 * "matchadd()" function
13162 */
13163 static void
13167 {
13168 #ifdef FEAT_SEARCH_EXTRA
13181 {
13185 }
13189 {
13192 }
13195 #endif
13196 }
13198 /*
13199 * "matcharg()" function
13200 */
13201 static void
13205 {
13207 {
13208 #ifdef FEAT_SEARCH_EXTRA
13213 {
13215 {
13219 }
13220 else
13221 {
13224 }
13225 }
13226 #endif
13227 }
13228 }
13230 /*
13231 * "matchdelete()" function
13232 */
13233 static void
13237 {
13238 #ifdef FEAT_SEARCH_EXTRA
13241 #endif
13242 }
13244 /*
13245 * "matchend()" function
13246 */
13247 static void
13251 {
13253 }
13255 /*
13256 * "matchlist()" function
13257 */
13258 static void
13262 {
13264 }
13266 /*
13267 * "matchstr()" function
13268 */
13269 static void
13273 {
13275 }
13279 static void
13284 {
13290 {
13296 {
13299 {
13302 {
13309 }
13310 }
13311 }
13312 }
13314 {
13322 {
13325 {
13327 {
13331 {
13334 }
13337 }
13338 }
13339 }
13340 }
13341 else
13344 }
13346 /*
13347 * "max()" function
13348 */
13349 static void
13353 {
13355 }
13357 /*
13358 * "min()" function
13359 */
13360 static void
13364 {
13366 }
13370 /*
13371 * Create the directory in which "dir" is located, and higher levels when
13372 * needed.
13373 */
13374 static int
13378 {
13383 /* Get end of directory name in "dir".
13384 * We're done when it's "/" or "c:/". */
13389 /* If the directory exists we're done. Otherwise: create it.*/
13399 }
13401 #ifdef vim_mkdir
13402 /*
13403 * "mkdir()" function
13404 */
13405 static void
13409 {
13420 {
13425 }
13427 }
13428 #endif
13430 /*
13431 * "mode()" function
13432 */
13433 /*ARGSUSED*/
13434 static void
13438 {
13444 #ifdef FEAT_VISUAL
13446 {
13449 else
13451 }
13452 else
13453 #endif
13456 {
13462 }
13466 {
13467 #ifdef FEAT_VREPLACE
13469 {
13472 }
13473 else
13474 #endif
13477 else
13479 }
13481 {
13485 }
13487 {
13490 }
13491 else
13492 {
13496 }
13498 /* Clear out the minor mode when the argument is not a non-zero number or
13499 * non-empty string. */
13505 }
13507 /*
13508 * "nextnonblank()" function
13509 */
13510 static void
13514 {
13515 linenr_T lnum;
13518 {
13520 {
13523 }
13526 }
13528 }
13530 /*
13531 * "nr2char()" function
13532 */
13533 static void
13537 {
13540 #ifdef FEAT_MBYTE
13543 else
13544 #endif
13545 {
13548 }
13551 }
13553 /*
13554 * "pathshorten()" function
13555 */
13556 static void
13560 {
13567 else
13568 {
13573 }
13574 }
13576 #ifdef FEAT_FLOAT
13577 /*
13578 * "pow()" function
13579 */
13580 static void
13584 {
13591 else
13593 }
13594 #endif
13596 /*
13597 * "prevnonblank()" function
13598 */
13599 static void
13603 {
13604 linenr_T lnum;
13609 else
13613 }
13615 #ifdef HAVE_STDARG_H
13616 /* This dummy va_list is here because:
13617 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13618 * - locally in the function results in a "used before set" warning
13619 * - using va_start() to initialize it gives "function with fixed args" error */
13621 #endif
13623 /*
13624 * "printf()" function
13625 */
13626 static void
13630 {
13634 {
13641 /* Get the required length, allocate the buffer and do it for real. */
13646 {
13649 {
13652 }
13653 }
13655 }
13656 #endif
13657 }
13659 /*
13660 * "pumvisible()" function
13661 */
13662 /*ARGSUSED*/
13663 static void
13667 {
13669 #ifdef FEAT_INS_EXPAND
13672 #endif
13673 }
13675 /*
13676 * "range()" function
13677 */
13678 static void
13682 {
13691 {
13694 }
13695 else
13696 {
13700 }
13709 else
13710 {
13716 }
13717 }
13719 /*
13720 * "readfile()" function
13721 */
13722 static void
13726 {
13746 {
13751 }
13756 /* Always open the file in binary mode, library functions have a mind of
13757 * their own about CR-LF conversion. */
13760 {
13763 }
13767 {
13772 {
13774 {
13775 /* Only when in binary mode add an empty list item when the
13776 * last line ends in a '\n'. */
13780 /* Found end-of-line or end-of-file: add a text line to the
13781 * list. */
13790 else
13791 {
13794 {
13800 }
13801 }
13806 {
13809 }
13819 }
13822 }
13827 {
13828 /* "buf" is full, need to move text to an allocated buffer */
13830 {
13833 }
13834 else
13835 {
13838 {
13844 }
13845 }
13847 }
13848 else
13849 {
13852 }
13853 }
13855 /*
13856 * For a negative line count use only the lines at the end of the file,
13857 * free the rest.
13858 */
13861 {
13864 }
13868 }
13870 #if defined(FEAT_RELTIME)
13873 /*
13874 * Convert a List to proftime_T.
13875 * Return FAIL when there is something wrong.
13876 */
13877 static int
13881 {
13890 # ifdef WIN3264
13893 # else
13896 # endif
13898 }
13901 /*
13902 * "reltime()" function
13903 */
13904 static void
13908 {
13909 #ifdef FEAT_RELTIME
13910 proftime_T res;
13911 proftime_T start;
13914 {
13915 /* No arguments: get current time. */
13917 }
13919 {
13923 }
13924 else
13925 {
13926 /* Two arguments: compute the difference. */
13931 }
13934 {
13937 # ifdef WIN3264
13940 # else
13943 # endif
13946 }
13947 #endif
13948 }
13950 /*
13951 * "reltimestr()" function
13952 */
13953 static void
13957 {
13958 #ifdef FEAT_RELTIME
13959 proftime_T tm;
13960 #endif
13964 #ifdef FEAT_RELTIME
13967 #endif
13968 }
13970 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13974 static void
13976 {
13978 # ifdef FEAT_GUI
13980 # endif
13981 )
13982 {
13986 }
13987 }
13989 static int
13991 {
13994 {
13997 }
13999 }
14000 #endif
14002 #ifdef FEAT_CLIENTSERVER
14005 static void
14010 {
14015 # ifdef WIN32
14016 HWND w;
14017 # else
14018 Window w;
14019 # endif
14024 # ifdef FEAT_X11
14027 # endif
14033 # ifdef WIN32
14035 # else
14038 # endif
14039 {
14042 else
14045 }
14050 {
14051 dictitem_T v;
14062 }
14063 }
14064 #endif
14066 /*
14067 * "remote_expr()" function
14068 */
14069 /*ARGSUSED*/
14070 static void
14074 {
14077 #ifdef FEAT_CLIENTSERVER
14079 #endif
14080 }
14082 /*
14083 * "remote_foreground()" function
14084 */
14085 /*ARGSUSED*/
14086 static void
14090 {
14092 #ifdef FEAT_CLIENTSERVER
14093 # ifdef WIN32
14094 /* On Win32 it's done in this application. */
14095 {
14100 }
14101 # else
14102 /* Send a foreground() expression to the server. */
14108 # endif
14109 #endif
14110 }
14112 /*ARGSUSED*/
14113 static void
14117 {
14118 #ifdef FEAT_CLIENTSERVER
14119 dictitem_T v;
14121 # ifdef WIN32
14123 # endif
14127 {
14130 }
14133 {
14136 }
14137 # ifdef WIN32
14141 else
14142 {
14145 }
14146 # else
14153 # endif
14156 {
14165 }
14166 #else
14168 #endif
14169 }
14171 /*ARGSUSED*/
14172 static void
14176 {
14179 #ifdef FEAT_CLIENTSERVER
14183 {
14184 # ifdef WIN32
14185 /* The server's HWND is encoded in the 'id' parameter */
14192 # else
14195 # endif
14197 }
14198 #endif
14201 }
14203 /*
14204 * "remote_send()" function
14205 */
14206 /*ARGSUSED*/
14207 static void
14211 {
14214 #ifdef FEAT_CLIENTSERVER
14216 #endif
14217 }
14219 /*
14220 * "remove()" function
14221 */
14222 static void
14226 {
14238 {
14243 {
14246 {
14250 else
14251 {
14255 }
14256 }
14257 }
14258 }
14263 {
14271 else
14272 {
14274 {
14275 /* Remove one item, return its value. */
14279 }
14280 else
14281 {
14282 /* Remove range of items, return list with values. */
14288 else
14289 {
14293 {
14297 }
14300 else
14301 {
14304 {
14311 }
14312 }
14313 }
14314 }
14315 }
14316 }
14317 }
14319 /*
14320 * "rename({from}, {to})" function
14321 */
14322 static void
14326 {
14331 else
14334 }
14336 /*
14337 * "repeat()" function
14338 */
14339 /*ARGSUSED*/
14340 static void
14344 {
14354 {
14360 }
14361 else
14362 {
14374 {
14378 }
14381 }
14382 }
14384 /*
14385 * "resolve()" function
14386 */
14387 static void
14391 {
14395 #ifdef FEAT_SHORTCUT
14396 {
14402 else
14404 }
14405 #else
14406 # ifdef HAVE_READLINK
14407 {
14429 {
14430 /* Separate the first path component in "p", and keep the
14431 * remainder (beginning with the path separator). */
14434 }
14437 {
14439 {
14446 {
14452 }
14454 /* Ensure that the result will have a trailing path separator
14455 * if the argument has one. */
14459 /* Separate the first path component in the link value and
14460 * concatenate the remainders. */
14463 {
14466 else
14467 {
14470 {
14473 }
14474 }
14476 }
14480 {
14481 /* Ignore trailing path separator. */
14484 }
14486 {
14487 /* symlink is relative to directory of argument */
14490 {
14495 }
14496 }
14497 else
14498 {
14501 }
14502 }
14507 /* Append the first path component of "remain" to "p". */
14512 {
14516 }
14517 /* Shorten "remain". */
14520 else
14521 {
14524 }
14525 }
14527 /* If the result is a relative path name, make it explicitly relative to
14528 * the current directory if and only if the argument had this form. */
14530 {
14539 {
14540 /* Prepend "./". */
14543 {
14546 }
14547 }
14549 {
14550 /* Strip leading "./". */
14556 }
14557 }
14559 /* Ensure that the result will have no trailing path separator
14560 * if the argument had none. But keep "/" or "//". */
14562 {
14566 }
14569 }
14570 # else
14572 # endif
14573 #endif
14577 #ifdef HAVE_READLINK
14578 fail:
14579 #endif
14581 }
14583 /*
14584 * "reverse({list})" function
14585 */
14586 static void
14590 {
14599 {
14604 {
14608 }
14613 }
14614 }
14626 /*
14627 * Get flags for a search function.
14628 * Possibly sets "p_ws".
14629 * Returns BACKWARD, FORWARD or zero (for an error).
14630 */
14631 static int
14635 {
14642 {
14647 {
14649 {
14656 {
14664 }
14666 {
14669 }
14670 else
14672 }
14676 }
14677 }
14679 }
14681 /*
14682 * Shared by search() and searchpos() functions
14683 */
14684 static int
14689 {
14692 pos_T pos;
14693 pos_T save_cursor;
14698 proftime_T tm;
14699 #ifdef FEAT_RELTIME
14701 #endif
14715 /* Optional arguments: line number to stop searching and timeout. */
14717 {
14721 #ifdef FEAT_RELTIME
14723 {
14727 }
14728 #endif
14729 }
14731 #ifdef FEAT_RELTIME
14732 /* Set the time limit, if there is one. */
14734 #endif
14736 /*
14737 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14738 * Check to make sure only those flags are set.
14739 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14740 * flags cannot be set. Check for that condition also.
14741 */
14744 {
14747 }
14753 {
14756 else
14762 {
14763 /* Store the match cursor position */
14766 }
14767 /* "/$" will put the cursor after the end of the line, may need to
14768 * correct that here */
14770 }
14772 /* If 'n' flag is used: restore cursor position. */
14775 else
14777 theend:
14781 }
14783 #ifdef FEAT_FLOAT
14784 /*
14785 * "round({float})" function
14786 */
14787 static void
14791 {
14792 float_T f;
14796 /* round() is not in C90, use ceil() or floor() instead. */
14798 else
14800 }
14801 #endif
14803 /*
14804 * "search()" function
14805 */
14806 static void
14810 {
14814 }
14816 /*
14817 * "searchdecl()" function
14818 */
14819 static void
14823 {
14833 {
14837 }
14841 }
14843 /*
14844 * Used by searchpair() and searchpairpos()
14845 */
14846 static int
14850 {
14863 /* Get the three pattern arguments: start, middle, end. */
14870 /* Handle the optional fourth argument: flags */
14875 /* Don't accept SP_END or SP_SUBPAT.
14876 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14877 */
14880 {
14883 }
14885 /* Using 'r' implies 'W', otherwise it doesn't work. */
14889 /* Optional fifth argument: skip expression */
14893 else
14894 {
14897 {
14901 #ifdef FEAT_RELTIME
14903 {
14907 }
14908 #endif
14909 }
14910 }
14917 theend:
14921 }
14923 /*
14924 * "searchpair()" function
14925 */
14926 static void
14930 {
14932 }
14934 /*
14935 * "searchpairpos()" function
14936 */
14937 static void
14941 {
14942 pos_T match_pos;
14952 {
14955 }
14959 }
14961 /*
14962 * Search for a start/middle/end thing.
14963 * Used by searchpair(), see its documentation for the details.
14964 * Returns 0 or -1 for no match,
14965 */
14966 long
14978 {
14982 pos_T pos;
14983 pos_T firstpos;
14984 pos_T foundpos;
14985 pos_T save_cursor;
14986 pos_T save_pos;
14992 proftime_T tm;
14994 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14998 #ifdef FEAT_RELTIME
14999 /* Set the time limit, if there is one. */
15001 #endif
15003 /* Make two search patterns: start/end (pat2, for in nested pairs) and
15004 * start/middle/end (pat3, for the top pair). */
15012 else
15024 {
15028 /* didn't find it or found the first match again: FAIL */
15034 {
15035 /* Found the same position again. Can happen with a pattern that
15036 * has "\zs" at the end and searching backwards. Advance one
15037 * character and try again. */
15040 else
15042 }
15045 /* clear the start flag to avoid getting stuck here */
15048 /* If the skip pattern matches, ignore this match. */
15050 {
15056 {
15057 /* Evaluating {skip} caused an error, break here. */
15061 }
15064 }
15067 {
15068 /* Found end when searching backwards or start when searching
15069 * forward: nested pair. */
15072 }
15073 else
15074 {
15075 /* Found end when searching forward or start when searching
15076 * backward: end of (nested) pair; or found middle in outer pair. */
15079 }
15082 {
15083 /* Found the match: return matchcount or line number. */
15086 else
15094 }
15095 }
15098 {
15099 /* Store the match cursor position */
15102 }
15104 /* If 'n' flag is used or search failed: restore cursor position. */
15108 theend:
15114 }
15116 /*
15117 * "searchpos()" function
15118 */
15119 static void
15123 {
15124 pos_T match_pos;
15137 {
15140 }
15146 }
15149 /*ARGSUSED*/
15150 static void
15154 {
15155 #ifdef FEAT_CLIENTSERVER
15165 # ifdef FEAT_X11
15168 # endif
15171 {
15174 }
15176 #else
15178 #endif
15179 }
15181 /*ARGSUSED*/
15182 static void
15186 {
15189 #ifdef FEAT_CLIENTSERVER
15190 # ifdef WIN32
15192 # else
15196 # endif
15197 #endif
15200 }
15202 /*
15203 * "setbufvar()" function
15204 */
15205 /*ARGSUSED*/
15206 static void
15210 {
15212 aco_save_T aco;
15227 {
15228 /* set curbuf to be our buf, temporarily */
15232 {
15242 }
15243 else
15244 {
15247 {
15252 }
15253 }
15255 /* reset notion of buffer */
15257 }
15258 }
15260 /*
15261 * "setcmdpos()" function
15262 */
15263 static void
15267 {
15272 }
15274 /*
15275 * "setline()" function
15276 */
15277 static void
15281 {
15282 linenr_T lnum;
15291 {
15294 }
15295 else
15300 {
15302 {
15303 /* list argument, get next string */
15308 }
15314 {
15315 /* existing line, replace it */
15317 {
15322 }
15323 }
15325 {
15326 /* lnum is one past the last line, append the line */
15330 }
15335 }
15339 }
15341 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15343 /*
15344 * Used by "setqflist()" and "setloclist()" functions
15345 */
15346 /*ARGSUSED*/
15347 static void
15353 {
15354 #ifdef FEAT_QUICKFIX
15357 #endif
15361 #ifdef FEAT_QUICKFIX
15364 else
15365 {
15369 {
15375 }
15379 }
15380 #endif
15381 }
15383 /*
15384 * "setloclist()" function
15385 */
15386 /*ARGSUSED*/
15387 static void
15391 {
15399 }
15401 /*
15402 * "setmatches()" function
15403 */
15404 static void
15408 {
15409 #ifdef FEAT_SEARCH_EXTRA
15416 {
15419 }
15421 {
15423 /* To some extent make sure that we are dealing with a list from
15424 * "getmatches()". */
15427 {
15430 {
15433 }
15438 {
15441 }
15443 }
15448 {
15455 }
15457 }
15458 #endif
15459 }
15461 /*
15462 * "setpos()" function
15463 */
15464 /*ARGSUSED*/
15465 static void
15469 {
15470 pos_T pos;
15477 {
15479 {
15482 {
15483 /* set cursor */
15485 {
15489 }
15490 else
15492 }
15494 {
15495 /* set mark */
15498 }
15499 else
15501 }
15502 }
15503 }
15505 /*
15506 * "setqflist()" function
15507 */
15508 /*ARGSUSED*/
15509 static void
15513 {
15515 }
15517 /*
15518 * "setreg()" function
15519 */
15520 static void
15524 {
15530 char_u yank_type;
15549 {
15555 {
15565 #ifdef FEAT_VISUAL
15569 {
15573 }
15575 #endif
15576 }
15577 }
15584 }
15586 /*
15587 * "settabwinvar()" function
15588 */
15589 static void
15593 {
15595 }
15597 /*
15598 * "setwinvar()" function
15599 */
15600 static void
15604 {
15606 }
15608 /*
15609 * "setwinvar()" and "settabwinvar()" functions
15610 */
15611 static void
15616 {
15618 #ifdef FEAT_WINDOWS
15621 #endif
15632 #ifdef FEAT_WINDOWS
15635 else
15637 #endif
15643 {
15644 #ifdef FEAT_WINDOWS
15645 /* set curwin to be our win, temporarily */
15653 #endif
15656 {
15666 }
15667 else
15668 {
15671 {
15676 }
15677 }
15679 #ifdef FEAT_WINDOWS
15680 /* Restore current tabpage and window, if still valid (autocomands can
15681 * make them invalid). */
15685 {
15688 }
15689 #endif
15690 }
15691 }
15693 /*
15694 * "shellescape({string})" function
15695 */
15696 static void
15700 {
15704 }
15706 /*
15707 * "simplify()" function
15708 */
15709 static void
15713 {
15720 }
15722 #ifdef FEAT_FLOAT
15723 /*
15724 * "sin()" function
15725 */
15726 static void
15730 {
15731 float_T f;
15736 else
15738 }
15739 #endif
15741 static int
15742 #ifdef __BORLANDC__
15743 _RTLENTRYF
15744 #endif
15746 static int
15747 #ifdef __BORLANDC__
15748 _RTLENTRYF
15749 #endif
15755 #define ITEM_COMPARE_FAIL 999
15757 /*
15758 * Compare functions for f_sort() below.
15759 */
15760 static int
15761 #ifdef __BORLANDC__
15762 _RTLENTRYF
15763 #endif
15767 {
15782 else
15787 }
15789 static int
15790 #ifdef __BORLANDC__
15791 _RTLENTRYF
15792 #endif
15796 {
15798 typval_T rettv;
15802 /* shortcut after failure in previous call; compare all items equal */
15806 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15807 * in the copy without changing the original list items. */
15819 else
15820 /* return value has wrong type */
15826 }
15828 /*
15829 * "sort({list})" function
15830 */
15831 static void
15835 {
15845 else
15846 {
15861 {
15864 else
15865 {
15873 else
15875 }
15876 }
15878 /* Make an array with each entry pointing to an item in the List. */
15887 /* test the compare function */
15892 else
15893 {
15894 /* Sort the array with item pointers. */
15899 {
15900 /* Clear the List and append the items in the sorted order. */
15905 }
15906 }
15909 }
15910 }
15912 /*
15913 * "soundfold({word})" function
15914 */
15915 static void
15919 {
15924 #ifdef FEAT_SPELL
15926 #else
15928 #endif
15929 }
15931 /*
15932 * "spellbadword()" function
15933 */
15934 /* ARGSUSED */
15935 static void
15939 {
15947 #ifdef FEAT_SPELL
15949 {
15950 /* Find the start and length of the badly spelled word. */
15954 }
15956 {
15961 {
15962 /* Check the argument for spelling. */
15964 {
15967 {
15970 }
15972 }
15973 }
15974 }
15975 #endif
15984 }
15986 /*
15987 * "spellsuggest()" function
15988 */
15989 /*ARGSUSED*/
15990 static void
15994 {
15995 #ifdef FEAT_SPELL
15999 garray_T ga;
16003 #endif
16008 #ifdef FEAT_SPELL
16010 {
16013 {
16018 {
16022 }
16023 }
16024 else
16030 {
16036 else
16037 {
16042 }
16043 }
16045 }
16046 #endif
16047 }
16049 static void
16053 {
16057 regmatch_T regmatch;
16065 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16071 {
16077 }
16088 {
16091 {
16094 else
16098 else
16102 {
16106 }
16109 /* Advance to just after the match. */
16112 else
16113 {
16114 /* Don't get stuck at the same match. */
16115 #ifdef FEAT_MBYTE
16117 #else
16119 #endif
16120 }
16122 }
16125 }
16128 }
16130 #ifdef FEAT_FLOAT
16131 /*
16132 * "sqrt()" function
16133 */
16134 static void
16138 {
16139 float_T f;
16144 else
16146 }
16148 /*
16149 * "str2float()" function
16150 */
16151 static void
16155 {
16162 }
16163 #endif
16165 /*
16166 * "str2nr()" function
16167 */
16168 static void
16172 {
16178 {
16181 {
16184 }
16185 }
16192 }
16194 #ifdef HAVE_STRFTIME
16195 /*
16196 * "strftime({format}[, {time}])" function
16197 */
16198 static void
16202 {
16213 else
16216 /* MSVC returns NULL for an invalid value of seconds. */
16219 else
16220 {
16221 # ifdef FEAT_MBYTE
16222 vimconv_T conv;
16230 # endif
16234 else
16237 # ifdef FEAT_MBYTE
16243 else
16244 # endif
16247 # ifdef FEAT_MBYTE
16248 /* Release conversion descriptors */
16251 # endif
16252 }
16253 }
16254 #endif
16256 /*
16257 * "stridx()" function
16258 */
16259 static void
16263 {
16278 {
16286 }
16291 }
16293 /*
16294 * "string()" function
16295 */
16296 static void
16300 {
16306 /* Make a copy if we have a value but it's not in allocated memory. */
16309 }
16311 /*
16312 * "strlen()" function
16313 */
16314 static void
16318 {
16321 }
16323 /*
16324 * "strpart()" function
16325 */
16326 static void
16330 {
16345 else
16348 /*
16349 * Only return the overlap between the specified part and the actual
16350 * string.
16351 */
16353 {
16356 }
16366 }
16368 /*
16369 * "strridx()" function
16370 */
16371 static void
16375 {
16392 {
16393 /* Third argument: upper limit for index */
16397 }
16398 else
16402 {
16403 /* Empty string matches past the end. */
16405 }
16406 else
16407 {
16409 {
16414 }
16415 }
16419 else
16421 }
16423 /*
16424 * "strtrans()" function
16425 */
16426 static void
16430 {
16433 }
16435 /*
16436 * "submatch()" function
16437 */
16438 static void
16442 {
16446 }
16448 /*
16449 * "substitute()" function
16450 */
16451 static void
16455 {
16468 else
16470 }
16472 /*
16473 * "synID(lnum, col, trans)" function
16474 */
16475 /*ARGSUSED*/
16476 static void
16480 {
16482 #ifdef FEAT_SYN_HL
16495 #endif
16498 }
16500 /*
16501 * "synIDattr(id, what [, mode])" function
16502 */
16503 /*ARGSUSED*/
16504 static void
16508 {
16510 #ifdef FEAT_SYN_HL
16520 {
16524 #ifdef FEAT_GUI
16526 #endif
16527 )
16529 }
16530 else
16531 {
16532 #ifdef FEAT_GUI
16535 else
16536 #endif
16539 else
16541 }
16545 {
16578 /* underline */
16580 else
16581 /* undercurl */
16584 }
16588 #endif
16591 }
16593 /*
16594 * "synIDtrans(id)" function
16595 */
16596 /*ARGSUSED*/
16597 static void
16601 {
16604 #ifdef FEAT_SYN_HL
16609 else
16610 #endif
16614 }
16616 /*
16617 * "synstack(lnum, col)" function
16618 */
16619 /*ARGSUSED*/
16620 static void
16624 {
16625 #ifdef FEAT_SYN_HL
16630 #endif
16635 #ifdef FEAT_SYN_HL
16642 {
16645 {
16651 }
16652 }
16653 #endif
16654 }
16656 /*
16657 * "system()" function
16658 */
16659 static void
16663 {
16675 {
16676 /*
16677 * Write the string to a temp file, to be used for input of the shell
16678 * command.
16679 */
16681 {
16684 }
16688 {
16691 }
16694 {
16697 }
16703 {
16706 }
16707 }
16712 #ifdef USE_CR
16713 /* translate <CR> into <NL> */
16715 {
16719 {
16722 }
16723 }
16724 #else
16725 # ifdef USE_CRNL
16726 /* translate <CR><NL> into <NL> */
16728 {
16733 {
16737 }
16739 }
16740 # endif
16741 #endif
16743 done:
16745 {
16748 }
16751 }
16753 /*
16754 * "tabpagebuflist()" function
16755 */
16756 /* ARGSUSED */
16757 static void
16761 {
16762 #ifndef FEAT_WINDOWS
16764 #else
16770 else
16771 {
16775 }
16778 else
16779 {
16782 else
16783 {
16788 }
16789 }
16790 #endif
16791 }
16794 /*
16795 * "tabpagenr()" function
16796 */
16797 /* ARGSUSED */
16798 static void
16802 {
16804 #ifdef FEAT_WINDOWS
16808 {
16812 {
16815 else
16817 }
16818 }
16819 else
16821 #endif
16823 }
16826 #ifdef FEAT_WINDOWS
16829 /*
16830 * Common code for tabpagewinnr() and winnr().
16831 */
16832 static int
16836 {
16844 {
16851 {
16855 }
16856 else
16857 {
16860 }
16861 }
16866 {
16868 {
16869 /* didn't find it in this tabpage */
16872 }
16874 }
16876 }
16877 #endif
16879 /*
16880 * "tabpagewinnr()" function
16881 */
16882 /* ARGSUSED */
16883 static void
16887 {
16889 #ifdef FEAT_WINDOWS
16895 else
16897 #endif
16899 }
16902 /*
16903 * "tagfiles()" function
16904 */
16905 /*ARGSUSED*/
16906 static void
16910 {
16912 tagname_T tn;
16916 {
16919 }
16926 }
16928 /*
16929 * "taglist()" function
16930 */
16931 static void
16935 {
16946 }
16948 /*
16949 * "tempname()" function
16950 */
16951 /*ARGSUSED*/
16952 static void
16956 {
16962 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16963 * names. Skip 'I' and 'O', they are used for shell redirection. */
16964 do
16965 {
16970 else
16971 {
16972 #ifdef EBCDIC
16977 else
16978 #endif
16980 }
16982 }
16984 /*
16985 * "test(list)" function: Just checking the walls...
16986 */
16987 /*ARGSUSED*/
16988 static void
16992 {
16993 /* Used for unit testing. Change the code below to your liking. */
16994 #if 0
17013 #endif
17014 }
17016 /*
17017 * "tolower(string)" function
17018 */
17019 static void
17023 {
17032 {
17033 #ifdef FEAT_MBYTE
17037 {
17043 /* TODO: reallocate string when byte count changes. */
17047 }
17050 else
17051 #endif
17052 {
17055 }
17056 }
17057 }
17059 /*
17060 * "toupper(string)" function
17061 */
17062 static void
17066 {
17069 }
17071 /*
17072 * "tr(string, fromstr, tostr)" function
17073 */
17074 static void
17078 {
17083 #ifdef FEAT_MBYTE
17091 #endif
17094 garray_T ga;
17100 /* Default return value: empty string. */
17107 #ifdef FEAT_MBYTE
17109 #endif
17110 /* not multi-byte: fromstr and tostr must be the same length */
17112 {
17113 #ifdef FEAT_MBYTE
17114 error:
17115 #endif
17119 }
17121 /* fromstr and tostr have to contain the same number of chars */
17123 {
17124 #ifdef FEAT_MBYTE
17126 {
17132 {
17135 {
17137 {
17140 {
17144 }
17145 }
17149 }
17151 }
17154 {
17155 /* Check that fromstr and tostr have the same number of
17156 * (multi-byte) characters. Done only once when a character
17157 * of instr doesn't appear in fromstr. */
17160 {
17163 }
17166 }
17173 }
17174 else
17175 #endif
17176 {
17177 /* When not using multi-byte chars we can do it faster. */
17181 else
17184 }
17185 }
17187 /* add a terminating NUL */
17192 }
17194 #ifdef FEAT_FLOAT
17195 /*
17196 * "trunc({float})" function
17197 */
17198 static void
17202 {
17203 float_T f;
17207 /* trunc() is not in C90, use floor() or ceil() instead. */
17209 else
17211 }
17212 #endif
17214 /*
17215 * "type(expr)" function
17216 */
17217 static void
17221 {
17225 {
17231 #ifdef FEAT_FLOAT
17233 #endif
17235 }
17237 }
17239 /*
17240 * "values(dict)" function
17241 */
17242 static void
17246 {
17248 }
17250 /*
17251 * "virtcol(string)" function
17252 */
17253 static void
17257 {
17265 {
17268 }
17271 }
17273 /*
17274 * "visualmode()" function
17275 */
17276 /*ARGSUSED*/
17277 static void
17281 {
17282 #ifdef FEAT_VISUAL
17290 /* A non-zero number or non-empty string argument: reset mode. */
17293 #else
17295 #endif
17296 }
17298 /*
17299 * "winbufnr(nr)" function
17300 */
17301 static void
17305 {
17311 else
17313 }
17315 /*
17316 * "wincol()" function
17317 */
17318 /*ARGSUSED*/
17319 static void
17323 {
17326 }
17328 /*
17329 * "winheight(nr)" function
17330 */
17331 static void
17335 {
17341 else
17343 }
17345 /*
17346 * "winline()" function
17347 */
17348 /*ARGSUSED*/
17349 static void
17353 {
17356 }
17358 /*
17359 * "winnr()" function
17360 */
17361 /* ARGSUSED */
17362 static void
17366 {
17369 #ifdef FEAT_WINDOWS
17371 #endif
17373 }
17375 /*
17376 * "winrestcmd()" function
17377 */
17378 /* ARGSUSED */
17379 static void
17383 {
17384 #ifdef FEAT_WINDOWS
17387 garray_T ga;
17392 {
17395 # ifdef FEAT_VERTSPLIT
17398 # endif
17400 }
17404 #else
17406 #endif
17408 }
17410 /*
17411 * "winrestview()" function
17412 */
17413 /* ARGSUSED */
17414 static void
17418 {
17424 else
17425 {
17428 #ifdef FEAT_VIRTUALEDIT
17430 #endif
17435 #ifdef FEAT_DIFF
17437 #endif
17450 #ifdef FEAT_DIFF
17452 #endif
17453 }
17454 }
17456 /*
17457 * "winsaveview()" function
17458 */
17459 /* ARGSUSED */
17460 static void
17464 {
17476 #ifdef FEAT_VIRTUALEDIT
17478 #endif
17483 #ifdef FEAT_DIFF
17485 #endif
17488 }
17490 /*
17491 * "winwidth(nr)" function
17492 */
17493 static void
17497 {
17503 else
17504 #ifdef FEAT_VERTSPLIT
17506 #else
17508 #endif
17509 }
17511 /*
17512 * "writefile()" function
17513 */
17514 static void
17518 {
17531 {
17534 }
17542 /* Always open the file in binary mode, library functions have a mind of
17543 * their own about CR-LF conversion. */
17546 {
17549 }
17550 else
17551 {
17554 {
17556 {
17559 else
17562 {
17565 }
17566 }
17569 {
17572 }
17574 {
17577 }
17578 }
17580 }
17583 }
17585 /*
17586 * Translate a String variable into a position.
17587 * Returns NULL when there is an error.
17588 */
17594 {
17599 /* Argument can be [lnum, col, coladd]. */
17601 {
17611 /* Get the line number */
17616 /* Get the column number */
17622 /* We accept "$" for the column number: last column. */
17629 /* Accept a position up to the NUL after the line. */
17634 #ifdef FEAT_VIRTUALEDIT
17635 /* Get the virtual offset. Defaults to zero. */
17639 #endif
17642 }
17649 #ifdef FEAT_VISUAL
17651 {
17655 }
17656 #endif
17658 {
17663 }
17665 #ifdef FEAT_VIRTUALEDIT
17667 #endif
17670 {
17673 {
17677 }
17679 {
17683 }
17684 }
17686 {
17688 {
17691 }
17692 else
17693 {
17696 }
17698 }
17700 }
17702 /*
17703 * Convert list in "arg" into a position and optional file number.
17704 * When "fnump" is NULL there is no file number, only 3 items.
17705 * Note that the column is passed on as-is, the caller may want to decrement
17706 * it to use 1 for the first column.
17707 * Return FAIL when conversion is not possible, doesn't check the position for
17708 * validity.
17709 */
17710 static int
17715 {
17720 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17721 * when "fnump" isn't NULL and "coladd" is optional. */
17729 {
17736 }
17748 #ifdef FEAT_VIRTUALEDIT
17752 else
17754 #endif
17757 }
17759 /*
17760 * Get the length of an environment variable name.
17761 * Advance "arg" to the first character after the name.
17762 * Return 0 for error.
17763 */
17764 static int
17767 {
17772 ;
17779 }
17781 /*
17782 * Get the length of the name of a function or internal variable.
17783 * "arg" is advanced to the first non-white character after the name.
17784 * Return 0 if something is wrong.
17785 */
17786 static int
17789 {
17793 /* Find the end of the name. */
17795 ;
17803 }
17805 /*
17806 * Get the length of the name of a variable or function.
17807 * Only the name is recognized, does not handle ".key" or "[idx]".
17808 * "arg" is advanced to the first non-white character after the name.
17809 * Return -1 if curly braces expansion failed.
17810 * Return 0 if something else is wrong.
17811 * If the name contains 'magic' {}'s, expand them and return the
17812 * expanded name in an allocated string via 'alias' - caller must free.
17813 */
17814 static int
17820 {
17830 {
17831 /* hard coded <SNR>, already translated */
17834 }
17837 {
17838 /* literal "<SID>", "s:" or "<SNR>" */
17840 }
17842 /*
17843 * Find the end of the name; check for {} construction.
17844 */
17848 {
17852 {
17856 }
17858 /*
17859 * Include any <SID> etc in the expanded string:
17860 * Thus the -len here.
17861 */
17868 }
17875 }
17877 /*
17878 * Find the end of a variable or function name, taking care of magic braces.
17879 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17880 * start and end of the first magic braces item.
17881 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17882 * Return a pointer to just after the name. Equal to "arg" if there is no
17883 * valid name.
17884 */
17891 {
17897 {
17900 }
17902 /* Quick check for valid starting character. */
17912 {
17914 {
17915 /* skip over 'string' to avoid counting [ and ] inside it. */
17917 ;
17920 }
17922 {
17923 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17929 }
17932 {
17937 }
17940 {
17942 {
17943 mb_nest++;
17946 }
17948 {
17949 mb_nest--;
17952 }
17953 }
17954 }
17957 }
17959 /*
17960 * Expands out the 'magic' {}'s in a variable/function name.
17961 * Note that this can call itself recursively, to deal with
17962 * constructs like foo{bar}{baz}{bam}
17963 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17964 * "in_start" ^
17965 * "expr_start" ^
17966 * "expr_end" ^
17967 * "in_end" ^
17968 *
17969 * Returns a new allocated string, which the caller must free.
17970 * Returns NULL for failure.
17971 */
17978 {
17979 char_u c1;
17993 {
17997 {
18001 }
18002 }
18010 {
18013 {
18014 /* Further expansion! */
18019 }
18020 }
18023 }
18025 /*
18026 * Return TRUE if character "c" can be used in a variable or function name.
18027 * Does not include '{' or '}' for magic braces.
18028 */
18029 static int
18032 {
18034 }
18036 /*
18037 * Return TRUE if character "c" can be used as the first character in a
18038 * variable or function name (excluding '{' and '}').
18039 */
18040 static int
18043 {
18045 }
18047 /*
18048 * Set number v: variable to "val".
18049 */
18050 void
18054 {
18056 }
18058 /*
18059 * Get number v: variable value.
18060 */
18061 long
18064 {
18066 }
18068 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18069 /*
18070 * Get string v: variable value. Uses a static buffer, can only be used once.
18071 */
18072 char_u *
18075 {
18077 }
18078 #endif
18080 /*
18081 * Set v:count, v:count1 and v:prevcount.
18082 */
18083 void
18087 {
18091 }
18093 /*
18094 * Set string v: variable to a copy of "val".
18095 */
18096 void
18101 {
18102 /* Need to do this (at least) once, since we can't initialize a union.
18103 * Will always be invoked when "v:progname" is set. */
18111 else
18113 }
18115 /*
18116 * Set v:register if needed.
18117 */
18118 void
18121 {
18122 char_u regname;
18126 else
18128 /* Avoid free/alloc when the value is already right. */
18131 }
18133 /*
18134 * Get or set v:exception. If "oldval" == NULL, return the current value.
18135 * Otherwise, restore the value to "oldval" and return NULL.
18136 * Must always be called in pairs to save and restore v:exception! Does not
18137 * take care of memory allocations.
18138 */
18139 char_u *
18142 {
18148 }
18150 /*
18151 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18152 * Otherwise, restore the value to "oldval" and return NULL.
18153 * Must always be called in pairs to save and restore v:throwpoint! Does not
18154 * take care of memory allocations.
18155 */
18156 char_u *
18159 {
18165 }
18167 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18168 /*
18169 * Set v:cmdarg.
18170 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18171 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18172 * Must always be called in pairs!
18173 */
18174 char_u *
18178 {
18185 {
18189 }
18195 else
18203 # ifdef FEAT_MBYTE
18208 # endif
18218 else
18227 # ifdef FEAT_MBYTE
18234 # endif
18237 }
18238 #endif
18240 /*
18241 * Get the value of internal variable "name".
18242 * Return OK or FAIL.
18243 */
18244 static int
18250 {
18253 typval_T atv;
18257 /* truncate the name, so that we can use strcmp() */
18261 /*
18262 * Check for "b:changedtick".
18263 */
18265 {
18269 }
18271 /*
18272 * Check for user-defined variables.
18273 */
18274 else
18275 {
18279 }
18282 {
18286 }
18293 }
18295 /*
18296 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18297 * Also handle function call with Funcref variable: func(expr)
18298 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18299 */
18300 static int
18306 {
18311 typval_T functv;
18318 {
18320 {
18321 /* need to copy the funcref so that we can clear rettv */
18325 /* Invoke the function. Recursive! */
18331 /* Clear the funcref afterwards, so that deleting it while
18332 * evaluating the arguments is possible (see test55). */
18335 /* Stop the expression evaluation when immediately aborting on
18336 * error, or when an interrupt occurred or an exception was thrown
18337 * but not caught. */
18339 {
18343 }
18346 }
18348 {
18351 {
18355 }
18356 else
18359 {
18362 }
18363 }
18364 }
18367 }
18369 /*
18370 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18371 * value).
18372 */
18375 {
18377 }
18379 /*
18380 * Allocate memory for a variable type-value, and assign a string to it.
18381 * The string "s" must have been allocated, it is consumed.
18382 * Return NULL for out of memory, the variable otherwise.
18383 */
18387 {
18392 {
18395 }
18396 else
18399 }
18401 /*
18402 * Free the memory for a variable type-value.
18403 */
18404 void
18407 {
18409 {
18411 {
18414 /*FALLTHROUGH*/
18425 #ifdef FEAT_FLOAT
18427 #endif
18433 }
18435 }
18436 }
18438 /*
18439 * Free the memory for a variable value and set the value to NULL or 0.
18440 */
18441 void
18444 {
18446 {
18448 {
18451 /*FALLTHROUGH*/
18467 #ifdef FEAT_FLOAT
18471 #endif
18476 }
18478 }
18479 }
18481 /*
18482 * Set the value of a variable to NULL without freeing items.
18483 */
18484 static void
18487 {
18490 }
18492 /*
18493 * Get the number value of a variable.
18494 * If it is a String variable, uses vim_str2nr().
18495 * For incompatible types, return 0.
18496 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18497 * caller of incompatible types: it sets *denote to TRUE if "denote"
18498 * is not NULL or returns -1 otherwise.
18499 */
18500 static long
18503 {
18507 }
18509 long
18513 {
18517 {
18520 #ifdef FEAT_FLOAT
18524 #endif
18542 }
18545 else
18548 }
18550 /*
18551 * Get the lnum from the first argument.
18552 * Also accepts ".", "$", etc., but that only works for the current buffer.
18553 * Returns -1 on error.
18554 */
18555 static linenr_T
18558 {
18559 typval_T rettv;
18560 linenr_T lnum;
18564 {
18569 }
18571 }
18573 /*
18574 * Get the lnum from the first argument.
18575 * Also accepts "$", then "buf" is used.
18576 * Returns 0 on error.
18577 */
18578 static linenr_T
18582 {
18589 }
18591 /*
18592 * Get the string value of a variable.
18593 * If it is a Number variable, the number is converted into a string.
18594 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18595 * get_tv_string_buf() uses a given buffer.
18596 * If the String variable has never been set, return an empty string.
18597 * Never returns NULL;
18598 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18599 * NULL on error.
18600 */
18604 {
18608 }
18614 {
18618 }
18620 char_u *
18623 {
18627 }
18633 {
18635 {
18648 #ifdef FEAT_FLOAT
18652 #endif
18660 }
18662 }
18664 /*
18665 * Find variable "name" in the list of variables.
18666 * Return a pointer to it if found, NULL if not found.
18667 * Careful: "a:0" variables don't have a name.
18668 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18669 * hashtab_T used.
18670 */
18675 {
18685 }
18687 /*
18688 * Find variable "varname" in hashtab "ht".
18689 * Returns NULL if not found.
18690 */
18696 {
18700 {
18701 /* Must be something like "s:", otherwise "ht" would be NULL. */
18703 {
18709 #ifdef FEAT_WINDOWS
18711 #endif
18716 }
18718 }
18722 {
18723 /* For global variables we may try auto-loading the script. If it
18724 * worked find the variable again. Don't auto-load a script if it was
18725 * loaded already, otherwise it would be loaded every time when
18726 * checking if a function name is a Funcref variable. */
18732 }
18734 }
18736 /*
18737 * Find the hashtab used for a variable name.
18738 * Set "varname" to the start of name without ':'.
18739 */
18744 {
18748 {
18749 /* The name must not start with a colon or #. */
18754 /* "version" is "v:version" in all scopes */
18762 }
18766 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18767 */
18775 #ifdef FEAT_WINDOWS
18778 #endif
18789 }
18791 /*
18792 * Get the string value of a (global/local) variable.
18793 * Returns NULL when it doesn't exist.
18794 */
18795 char_u *
18798 {
18805 }
18807 /*
18808 * Allocate a new hashtab for a sourced script. It will be used while
18809 * sourcing this script and when executing functions defined in the script.
18810 */
18811 void
18813 scid_T id;
18814 {
18820 {
18821 /* Re-allocating ga_data means that an ht_array pointing to
18822 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18823 * at its init value. Also reset "v_dict", it's always the same. */
18825 {
18831 }
18834 {
18838 }
18839 }
18840 }
18842 /*
18843 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18844 * point to it.
18845 */
18846 void
18850 {
18858 }
18860 /*
18861 * Clean up a list of internal variables.
18862 * Frees all allocated variables and the value they contain.
18863 * Clears hashtab "ht", does not free it.
18864 */
18865 void
18868 {
18870 }
18872 /*
18873 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18874 */
18875 static void
18879 {
18887 {
18889 {
18892 /* Free the variable. Don't remove it from the hashtab,
18893 * ht_array might change then. hash_clear() takes care of it
18894 * later. */
18900 }
18901 }
18904 }
18906 /*
18907 * Delete a variable from hashtab "ht" at item "hi".
18908 * Clear the variable value and free the dictitem.
18909 */
18910 static void
18914 {
18920 }
18922 /*
18923 * List the value of one internal variable.
18924 */
18925 static void
18930 {
18939 }
18941 static void
18948 {
18949 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18961 {
18965 }
18967 {
18971 }
18972 else
18980 {
18983 }
18984 }
18986 /*
18987 * Set variable "name" to value in "tv".
18988 * If the variable already exists, the value is updated.
18989 * Otherwise the variable is created.
18990 */
18991 static void
18996 {
19003 {
19007 {
19010 }
19012 {
19014 name);
19016 }
19017 }
19021 {
19024 }
19028 {
19029 /* existing variable, need to clear the value */
19038 #ifdef FEAT_FLOAT
19043 #endif
19044 )
19045 {
19048 }
19050 /*
19051 * Handle setting internal v: variables separately: we don't change
19052 * the type.
19053 */
19055 {
19057 {
19061 else
19062 {
19063 /* Take over the string to avoid an extra alloc/free. */
19066 }
19067 }
19070 else
19071 {
19075 }
19077 }
19080 }
19082 {
19083 /* Can't add "v:" variable. */
19085 {
19088 }
19090 /* Make sure the variable name is valid. */
19094 {
19097 }
19105 {
19108 }
19110 }
19114 else
19115 {
19119 }
19120 }
19122 /*
19123 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19124 * Also give an error message.
19125 */
19126 static int
19130 {
19132 {
19135 }
19137 {
19140 }
19142 }
19144 /*
19145 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19146 * Also give an error message.
19147 */
19148 static int
19152 {
19154 {
19157 }
19159 }
19161 /*
19162 * Return TRUE if typeval "tv" is set to be locked (immutable).
19163 * Also give an error message, using "name".
19164 */
19165 static int
19169 {
19171 {
19175 }
19177 {
19181 }
19183 }
19185 /*
19186 * Copy the values from typval_T "from" to typval_T "to".
19187 * When needed allocates string or increases reference count.
19188 * Does not make a copy of a list or dict but copies the reference!
19189 */
19190 static void
19194 {
19198 {
19202 #ifdef FEAT_FLOAT
19206 #endif
19211 else
19212 {
19216 }
19221 else
19222 {
19225 }
19230 else
19231 {
19234 }
19239 }
19240 }
19242 /*
19243 * Make a copy of an item.
19244 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19245 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19246 * reference to an already copied list/dict can be used.
19247 * Returns FAIL or OK.
19248 */
19249 static int
19255 {
19260 {
19263 }
19267 {
19269 #ifdef FEAT_FLOAT
19271 #endif
19282 {
19283 /* use the copy made earlier */
19286 }
19287 else
19298 {
19299 /* use the copy made earlier */
19302 }
19303 else
19311 }
19314 }
19316 /*
19317 * ":echo expr1 ..." print each argument separated with a space, add a
19318 * newline at the end.
19319 * ":echon expr1 ..." print each argument plain.
19320 */
19321 void
19324 {
19326 typval_T rettv;
19336 {
19337 /* If eval1() causes an error message the text from the command may
19338 * still need to be cleared. E.g., "echo 22,44". */
19343 {
19344 /*
19345 * Report the invalid expression unless the expression evaluation
19346 * has been cancelled due to an aborting error, an interrupt, or an
19347 * exception.
19348 */
19353 }
19357 {
19359 {
19361 /* Call msg_start() after eval1(), evaluating the expression
19362 * may cause a message to appear. */
19365 }
19371 {
19373 {
19375 {
19376 /* remove any text still there from the command */
19379 }
19381 }
19382 else
19383 {
19384 #ifdef FEAT_MBYTE
19386 {
19391 }
19392 else
19393 #endif
19395 }
19396 }
19398 }
19401 }
19406 else
19407 {
19408 /* remove text that may still be there from the command */
19413 }
19414 }
19416 /*
19417 * ":echohl {name}".
19418 */
19419 void
19422 {
19428 else
19430 }
19432 /*
19433 * ":execute expr1 ..." execute the result of an expression.
19434 * ":echomsg expr1 ..." Print a message
19435 * ":echoerr expr1 ..." Print an error
19436 * Each gets spaces around each argument and a newline at the end for
19437 * echo commands
19438 */
19439 void
19442 {
19444 typval_T rettv;
19447 garray_T ga;
19456 {
19459 {
19460 /*
19461 * Report the invalid expression unless the expression evaluation
19462 * has been cancelled due to an aborting error, an interrupt, or an
19463 * exception.
19464 */
19469 }
19472 {
19476 {
19480 }
19485 }
19489 }
19492 {
19494 {
19497 }
19499 {
19500 /* We don't want to abort following commands, restore did_emsg. */
19505 }
19509 }
19517 }
19519 /*
19520 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19521 * "arg" points to the "&" or '+' when called, to "option" when returning.
19522 * Returns NULL when no option name found. Otherwise pointer to the char
19523 * after the option name.
19524 */
19529 {
19534 {
19537 }
19539 {
19542 }
19543 else
19552 else
19556 }
19558 /*
19559 * ":function"
19560 */
19561 void
19564 {
19573 garray_T newargs;
19574 garray_T newlines;
19583 funcdict_T fudi;
19591 /*
19592 * ":function" without argument: list functions.
19593 */
19595 {
19597 {
19600 {
19602 {
19607 }
19608 }
19609 }
19612 }
19614 /*
19615 * ":function /pat": list functions matching pattern.
19616 */
19618 {
19621 {
19622 regmatch_T regmatch;
19629 {
19634 {
19636 {
19642 }
19643 }
19644 }
19645 }
19650 }
19652 /*
19653 * Get the function name. There are these situations:
19654 * func normal function name
19655 * "name" == func, "fudi.fd_dict" == NULL
19656 * dict.func new dictionary entry
19657 * "name" == NULL, "fudi.fd_dict" set,
19658 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19659 * dict.func existing dict entry with a Funcref
19660 * "name" == func, "fudi.fd_dict" set,
19661 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19662 * dict.func existing dict entry that's not a Funcref
19663 * "name" == NULL, "fudi.fd_dict" set,
19664 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19665 */
19670 {
19671 /*
19672 * Return on an invalid expression in braces, unless the expression
19673 * evaluation has been cancelled due to an aborting error, an
19674 * interrupt, or an exception.
19675 */
19677 {
19682 }
19683 else
19685 }
19687 /* An error in a function call during evaluation of an expression in magic
19688 * braces should not cause the function not to be defined. */
19692 /*
19693 * ":function func" with only function name: list function.
19694 */
19696 {
19698 {
19701 }
19706 {
19709 {
19712 {
19724 }
19726 {
19729 }
19730 }
19731 else
19733 }
19735 }
19737 /*
19738 * ":function name(arg1, arg2)" Define function.
19739 */
19742 {
19744 {
19747 }
19748 /* attempt to continue by skipping some text */
19751 }
19758 {
19759 /* Check the name of the function. Unless it's a dictionary function
19760 * (that we are overwriting). */
19763 else
19767 {
19770 else
19777 }
19778 }
19780 /*
19781 * Isolate the arguments: "arg1, arg2, ...)"
19782 */
19784 {
19786 {
19790 }
19791 else
19792 {
19799 {
19803 }
19816 else
19818 }
19821 {
19825 }
19826 }
19829 /* find extra arguments "range", "dict" and "abort" */
19831 {
19834 {
19837 }
19839 {
19842 }
19844 {
19847 }
19848 else
19850 }
19852 /* When there is a line break use what follows for the function body.
19853 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19859 /*
19860 * Read the body of the function, until ":endfunction" is found.
19861 */
19863 {
19864 /* Check if the function already exists, don't let the user type the
19865 * whole function before telling him it doesn't work! For a script we
19866 * need to skip the body to be able to find what follows. */
19868 {
19873 }
19880 }
19885 {
19891 {
19892 /* Use eap->arg, split up in parts by line breaks. */
19897 else
19898 {
19901 }
19902 }
19905 else
19910 {
19913 }
19915 /* Detect line continuation: sourcing_lnum increased more than one. */
19918 else
19922 {
19923 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19924 * don't check for ":endfunc". */
19926 {
19929 }
19930 }
19931 else
19932 {
19933 /* skip ':' and blanks*/
19935 ;
19937 /* Check for "endfunction". */
19939 {
19943 }
19945 /* Increase indent inside "if", "while", "for" and "try", decrease
19946 * at "end". */
19955 /* Check for defining a function inside this function. */
19957 {
19962 {
19965 {
19968 }
19969 }
19970 }
19972 /* Check for ":append" or ":insert". */
19980 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19993 ))
19994 {
19995 /* ":python <<" continues until a dot, like ":append" */
19999 else
20001 }
20002 }
20004 /* Add the line to the function. */
20006 {
20010 }
20012 /* Copy the line to newly allocated memory. get_one_sourceline()
20013 * allocates 250 bytes per line, this saves 80% on average. The cost
20014 * is an extra alloc/free. */
20017 {
20021 }
20025 /* Add NULL lines for continuation lines, so that the line count is
20026 * equal to the index in the growarray. */
20030 /* Check for end of eap->arg. */
20033 }
20035 /* Don't define the function when skipping commands or when an error was
20036 * detected. */
20040 /*
20041 * If there are no errors, add the function
20042 */
20044 {
20047 {
20049 name);
20051 }
20055 {
20057 {
20060 }
20062 {
20064 name);
20066 }
20067 /* redefine existing function */
20072 }
20073 }
20074 else
20075 {
20080 {
20083 }
20085 {
20086 /* Can't add a function to a locked dictionary */
20089 }
20090 /* Can't change an existing function if it is locked */
20094 /* Give the function a sequential number. Can only be used with a
20095 * Funcref! */
20101 }
20104 {
20106 {
20110 /* Check that the autoload name matches the script name. */
20113 {
20116 {
20124 }
20125 }
20127 {
20130 }
20131 }
20138 {
20140 {
20141 /* add new dict entry */
20144 {
20147 }
20149 {
20153 }
20154 }
20155 else
20156 /* overwrite existing dict entry */
20163 /* behave like "dict" was used */
20165 }
20167 /* insert the new function in the function list */
20170 }
20173 #ifdef FEAT_PROFILE
20180 #endif
20187 erret:
20190 ret_free:
20195 }
20197 /*
20198 * Get a function name, translating "<SID>" and "<SNR>".
20199 * Also handles a Funcref in a List or Dictionary.
20200 * Returns the function name in allocated memory, or NULL for failure.
20201 * flags:
20202 * TFN_INT: internal function name OK
20203 * TFN_QUIET: be quiet
20204 * Advances "pp" to just after the function name (if no error).
20205 */
20212 {
20219 lval_T lv;
20225 /* Check for hard coded <SNR>: already translated function ID (from a user
20226 * command). */
20229 {
20233 }
20235 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20236 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20244 {
20248 }
20250 {
20251 /*
20252 * Report an invalid expression in braces, unless the expression
20253 * evaluation has been cancelled due to an aborting error, an
20254 * interrupt, or an exception.
20255 */
20257 {
20260 }
20261 else
20264 }
20267 {
20269 {
20274 }
20276 {
20279 }
20280 else
20281 {
20285 else
20288 }
20290 }
20293 {
20294 /* Error found, but continue after the function name. */
20297 }
20299 /* Check if the name is a Funcref. If so, use the value. */
20301 {
20306 }
20307 else
20308 {
20313 }
20315 {
20319 }
20322 {
20326 {
20327 /* When there was "s:" already or the name expanded to get a
20328 * leading "s:" then remove it. */
20332 }
20333 }
20334 else
20335 {
20339 }
20341 /*
20342 * Copy the function name to allocated memory.
20343 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20344 * Accept <SNR>123_name() outside a script.
20345 */
20349 {
20353 {
20354 /* It's "s:" or "<SID>" */
20356 {
20359 }
20362 }
20363 }
20365 {
20368 }
20371 {
20373 {
20379 }
20382 }
20385 theend:
20388 }
20390 /*
20391 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20392 * Return 2 if "p" starts with "s:".
20393 * Return 0 otherwise.
20394 */
20395 static int
20398 {
20405 }
20407 /*
20408 * Return TRUE if "p" starts with "<SID>" or "s:".
20409 * Only works if eval_fname_script() returned non-zero for "p"!
20410 */
20411 static int
20414 {
20416 }
20418 /*
20419 * List the head of the function: "name(arg1, arg2)".
20420 */
20421 static void
20425 {
20433 {
20436 }
20437 else
20441 {
20445 }
20447 {
20451 }
20456 }
20458 /*
20459 * Find a function by name, return pointer to it in ufuncs.
20460 * Return NULL for unknown function.
20461 */
20465 {
20472 }
20474 #if defined(EXITFREE) || defined(PROTO)
20475 void
20477 {
20480 /* Need to start all over every time, because func_free() may change the
20481 * hash table. */
20485 {
20488 }
20489 }
20490 #endif
20492 /*
20493 * Return TRUE if a function "name" exists.
20494 */
20495 static int
20498 {
20506 /* Only accept "funcname", "funcname ", "funcname (..." and
20507 * "funcname(...", not "funcname!...". */
20509 {
20512 else
20514 }
20517 }
20519 /*
20520 * Return TRUE if "name" looks like a builtin function name: starts with a
20521 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20522 */
20523 static int
20526 {
20529 }
20531 #if defined(FEAT_PROFILE) || defined(PROTO)
20532 /*
20533 * Start profiling function "fp".
20534 */
20535 static void
20538 {
20557 }
20559 /*
20560 * Dump the profiling results for all functions in file "fd".
20561 */
20562 void
20565 {
20577 {
20579 {
20583 {
20589 else
20593 else
20601 {
20607 }
20609 }
20610 }
20611 }
20614 {
20616 prof_total_cmp);
20619 prof_self_cmp);
20621 }
20622 }
20624 static void
20631 {
20638 {
20641 prefer_self);
20644 else
20646 }
20648 }
20650 /*
20651 * Print the count and times for one function or function line.
20652 */
20653 static void
20660 {
20662 {
20666 else
20670 else
20672 }
20673 else
20675 }
20677 /*
20678 * Compare function for total time sorting.
20679 */
20680 static int
20681 #ifdef __BORLANDC__
20682 _RTLENTRYF
20683 #endif
20687 {
20693 }
20695 /*
20696 * Compare function for self time sorting.
20697 */
20698 static int
20699 #ifdef __BORLANDC__
20700 _RTLENTRYF
20701 #endif
20705 {
20711 }
20713 #endif
20715 /*
20716 * If "name" has a package name try autoloading the script for it.
20717 * Return TRUE if a package was loaded.
20718 */
20719 static int
20723 {
20729 /* If there is no '#' after name[0] there is no package name. */
20736 /* Find the name in the list of previously loaded package names. Skip
20737 * "autoload/", it's always the same. */
20743 else
20744 {
20745 /* Remember the name if it wasn't loaded already. */
20747 {
20750 }
20752 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20755 }
20759 }
20761 /*
20762 * Return the autoload script name for a function or variable name.
20763 * Returns NULL when out of memory.
20764 */
20768 {
20772 /* Get the script file name: replace '#' with '/', append ".vim". */
20783 }
20785 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20787 /*
20788 * Function given to ExpandGeneric() to obtain the list of user defined
20789 * function names.
20790 */
20791 char_u *
20795 {
20801 {
20804 }
20806 {
20818 {
20822 }
20824 }
20826 }
20830 /*
20831 * Copy the function name of "fp" to buffer "buf".
20832 * "buf" must be able to hold the function name plus three bytes.
20833 * Takes care of script-local function names.
20834 */
20835 static void
20839 {
20841 {
20844 }
20845 else
20847 }
20849 /*
20850 * ":delfunction {name}"
20851 */
20852 void
20855 {
20859 funcdict_T fudi;
20865 {
20869 }
20871 {
20875 }
20885 {
20887 {
20890 }
20892 {
20895 }
20898 {
20899 /* Delete the dict item that refers to the function, it will
20900 * invoke func_unref() and possibly delete the function. */
20902 }
20903 else
20905 }
20906 }
20908 /*
20909 * Free a function and remove it from the list of functions.
20910 */
20911 static void
20914 {
20917 /* clear this function */
20920 #ifdef FEAT_PROFILE
20924 #endif
20926 /* remove the function from the function hashtable */
20930 else
20934 }
20936 /*
20937 * Unreference a Function: decrement the reference count and free it when it
20938 * becomes zero. Only for numbered functions.
20939 */
20940 static void
20943 {
20947 {
20952 {
20953 /* Only delete it when it's not being used. Otherwise it's done
20954 * when "uf_calls" becomes zero. */
20957 }
20958 }
20959 }
20961 /*
20962 * Count a reference to a Function.
20963 */
20964 static void
20967 {
20971 {
20975 else
20977 }
20978 }
20980 /*
20981 * Call a user function.
20982 */
20983 static void
20992 {
20994 linenr_T save_sourcing_lnum;
20995 scid_T save_current_SID;
20996 funccall_T fc;
21005 #ifdef FEAT_PROFILE
21006 proftime_T wait_start;
21007 proftime_T call_start;
21008 #endif
21010 /* If depth of calling is getting too high, don't execute the function */
21012 {
21017 }
21030 /* Check if this function has a breakpoint. */
21034 /*
21035 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21036 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21037 * each argument variable and saves a lot of time.
21038 */
21039 /*
21040 * Init l: variables.
21041 */
21044 {
21045 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21046 * some compiler that checks the destination size. */
21056 }
21058 /*
21059 * Init a: variables.
21060 * Set a:0 to "argcount".
21061 * Set a:000 to a list with room for the "..." arguments.
21062 */
21077 /*
21078 * Set a:firstline to "firstline" and a:lastline to "lastline".
21079 * Set a:name to named arguments.
21080 * Set a:N to the "..." arguments.
21081 */
21087 {
21090 /* named argument a:name */
21092 else
21093 {
21094 /* "..." argument a:1, a:2, etc. */
21097 }
21099 {
21102 }
21103 else
21104 {
21110 }
21114 /* Note: the values are copied directly to avoid alloc/free.
21115 * "argvars" must have VAR_FIXED for v_lock. */
21120 {
21124 }
21125 }
21127 /* Don't redraw while executing the function. */
21135 {
21139 else
21144 {
21150 {
21158 {
21163 else
21164 {
21167 {
21171 }
21172 }
21173 }
21175 }
21180 }
21181 }
21182 #ifdef FEAT_PROFILE
21184 {
21189 {
21193 }
21195 }
21196 #endif
21203 /* call do_cmdline() to execute the lines */
21209 /* when the function was aborted because of an error, return -1 */
21211 {
21215 }
21217 #ifdef FEAT_PROFILE
21220 {
21226 {
21229 }
21230 }
21231 #endif
21233 /* when being verbose, mention the return value */
21235 {
21244 else
21245 {
21251 /* The value may be very long. Skip the middle part, so that we
21252 * have some idea how it starts and ends. smsg() would always
21253 * truncate it at the end. */
21256 {
21260 }
21261 }
21266 }
21272 #ifdef FEAT_PROFILE
21275 #endif
21278 {
21287 }
21292 /* The a: variables typevals were not allocated, only free the allocated
21293 * variables. */
21298 }
21300 /*
21301 * Add a number variable "name" to dict "dp" with value "nr".
21302 */
21303 static void
21308 varnumber_T nr;
21309 {
21316 }
21318 /*
21319 * ":return [expr]"
21320 */
21321 void
21324 {
21326 typval_T rettv;
21330 {
21333 }
21341 {
21344 else
21346 }
21347 /* It's safer to return also on error. */
21349 {
21350 /*
21351 * Return unless the expression evaluation has been cancelled due to an
21352 * aborting error, an interrupt, or an exception.
21353 */
21356 }
21358 /* When skipping or the return gets pending, advance to the next command
21359 * in this line (!returning). Otherwise, ignore the rest of the line.
21360 * Following lines will be ignored by get_func_line(). */
21368 }
21370 /*
21371 * Return from a function. Possibly makes the return pending. Also called
21372 * for a pending return at the ":endtry" or after returning from an extra
21373 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21374 * when called due to a ":return" command. "rettv" may point to a typval_T
21375 * with the return rettv. Returns TRUE when the return can be carried out,
21376 * FALSE when the return gets pending.
21377 */
21378 int
21384 {
21389 /* Undo the return. */
21392 /*
21393 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21394 * not in its finally clause (which then is to be executed next) is found.
21395 * In this case, make the ":return" pending for execution at the ":endtry".
21396 * Otherwise, return normally.
21397 */
21400 {
21404 /* A pending return again gets pending. "rettv" points to an
21405 * allocated variable with the rettv of the original ":return"'s
21406 * argument if present or is NULL else. */
21408 else
21409 {
21410 /* When undoing a return in order to make it pending, get the stored
21411 * return rettv. */
21416 {
21417 /* Store the value of the pending return. */
21420 else
21422 }
21423 else
21427 {
21428 /* The pending return value could be overwritten by a ":return"
21429 * without argument in a finally clause; reset the default
21430 * return value. */
21433 }
21434 }
21436 }
21437 else
21438 {
21441 /* If the return is carried out now, store the return value. For
21442 * a return immediately after reanimation, the value is already
21443 * there. */
21445 {
21450 }
21451 }
21454 }
21456 /*
21457 * Free the variable with a pending return value.
21458 */
21459 void
21462 {
21464 }
21466 /*
21467 * Generate a return command for producing the value of "rettv". The result
21468 * is an allocated string. Used by report_pending() for verbose messages.
21469 */
21470 char_u *
21473 {
21489 }
21491 /*
21492 * Get next function line.
21493 * Called by do_cmdline() to get the next line.
21494 * Returns allocated string, or NULL for end of function.
21495 */
21496 /* ARGSUSED */
21497 char_u *
21502 {
21508 /* If breakpoints have been added/deleted need to check for it. */
21510 {
21512 sourcing_lnum);
21514 }
21515 #ifdef FEAT_PROFILE
21518 #endif
21524 else
21525 {
21526 /* Skip NULL lines (continuation lines). */
21532 else
21533 {
21536 #ifdef FEAT_PROFILE
21539 #endif
21540 }
21541 }
21543 /* Did we encounter a breakpoint? */
21545 {
21547 /* Find next breakpoint. */
21549 sourcing_lnum);
21551 }
21554 }
21556 #if defined(FEAT_PROFILE) || defined(PROTO)
21557 /*
21558 * Called when starting to read a function line.
21559 * "sourcing_lnum" must be correct!
21560 * When skipping lines it may not actually be executed, but we won't find out
21561 * until later and we need to store the time now.
21562 */
21563 void
21566 {
21572 {
21574 /* Skip continuation lines. */
21581 }
21582 }
21584 /*
21585 * Called when actually executing a function line.
21586 */
21587 void
21590 {
21596 }
21598 /*
21599 * Called when done with a function line.
21600 */
21601 void
21604 {
21609 {
21611 {
21618 }
21620 }
21621 }
21622 #endif
21624 /*
21625 * Return TRUE if the currently active function should be ended, because a
21626 * return was encountered or an error occurred. Used inside a ":while".
21627 */
21628 int
21631 {
21634 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21635 * an error inside a try conditional. */
21638 }
21640 /*
21641 * return TRUE if cookie indicates a function which "abort"s on errors.
21642 */
21643 int
21646 {
21648 }
21650 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21652 {
21655 VAR_FLAVOUR_VIMINFO /* all uppercase */
21660 static var_flavour_T
21663 {
21667 {
21672 }
21673 else
21675 }
21676 #endif
21678 #if defined(FEAT_VIMINFO) || defined(PROTO)
21679 /*
21680 * Restore global vars that start with a capital from the viminfo file
21681 */
21682 int
21686 {
21689 typval_T tv;
21692 {
21695 {
21699 #ifdef FEAT_FLOAT
21702 #endif
21706 {
21711 #ifdef FEAT_FLOAT
21714 #endif
21715 else
21720 }
21721 }
21722 }
21725 }
21727 /*
21728 * Write global vars that start with a capital to the viminfo file
21729 */
21730 void
21733 {
21749 {
21751 {
21755 {
21757 {
21760 #ifdef FEAT_FLOAT
21762 #endif
21764 }
21770 }
21771 }
21772 }
21773 }
21774 #endif
21776 #if defined(FEAT_SESSION) || defined(PROTO)
21777 int
21780 {
21788 {
21790 {
21796 {
21797 /* Escape special characters with a backslash. Turn a LF and
21798 * CR into \n and \r. */
21812 p,
21816 {
21819 }
21821 }
21822 #ifdef FEAT_FLOAT
21825 {
21830 {
21833 }
21838 }
21839 #endif
21840 }
21841 }
21843 }
21844 #endif
21846 /*
21847 * Display script name where an item was last set.
21848 * Should only be invoked when 'verbose' is non-zero.
21849 */
21850 void
21852 scid_T scriptID;
21853 {
21857 {
21860 {
21866 }
21867 }
21868 }
21873 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21875 #ifdef WIN3264
21876 /*
21877 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21878 */
21880 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21883 /*
21884 * Get the short path (8.3) for the filename in "fnamep".
21885 * Only works for a valid file name.
21886 * When the path gets longer "fnamep" is changed and the allocated buffer
21887 * is put in "bufp".
21888 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21889 * Returns OK on success, FAIL on failure.
21890 */
21891 static int
21896 {
21903 {
21904 /* If that doesn't work (not enough space), then save the string
21905 * and try again with a new buffer big enough. */
21913 /* Really should always succeed, as the buffer is big enough. */
21915 }
21919 }
21921 /*
21922 * Get the short path (8.3) for the filename in "fname". The converted
21923 * path is returned in "bufp".
21924 *
21925 * Some of the directories specified in "fname" may not exist. This function
21926 * will shorten the existing directories at the beginning of the path and then
21927 * append the remaining non-existing path.
21928 *
21929 * fname - Pointer to the filename to shorten. On return, contains the
21930 * pointer to the shortened pathname
21931 * bufp - Pointer to an allocated buffer for the filename.
21932 * fnamelen - Length of the filename pointed to by fname
21933 *
21934 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21935 */
21936 static int
21941 {
21944 char_u ch;
21949 /* Make a copy */
21958 /*
21959 * Try shortening the supplied path till it succeeds by removing one
21960 * directory at a time from the tail of the path.
21961 */
21964 {
21965 /* go back one path-separator */
21971 /*
21972 * Replace the path separator with a NUL and try to shorten the
21973 * resulting path.
21974 */
21980 {
21983 }
21989 /* failed to shorten the path. Skip the path separator */
21991 }
21994 {
21995 /*
21996 * Succeeded in shortening the path. Now concatenate the shortened
21997 * path with the remaining path at the tail.
21998 */
22000 /* Compute the length of the new path. */
22007 {
22008 /* There is not enough space in the currently allocated string,
22009 * copy it to a buffer big enough. */
22012 {
22015 }
22016 }
22017 else
22018 {
22019 /* Transfer short_fname to the main buffer (it's big enough),
22020 * unless get_short_pathname() did its work in-place. */
22025 }
22027 /* concat the not-shortened part of the path */
22030 }
22032 theend:
22037 }
22039 /*
22040 * Get a pathname for a partial path.
22041 * Returns OK for success, FAIL for failure.
22042 */
22043 static int
22048 {
22054 /* Count up the path separators from the RHS.. so we know which part
22055 * of the path to return. */
22061 /* Need full path first (use expand_env() to remove a "~/") */
22065 else
22074 {
22075 /* Don't have a valid filename, so shorten the rest of the
22076 * path if we can. This CAN give us invalid 8.3 filenames, but
22077 * there's not a lot of point in guessing what it might be.
22078 */
22082 }
22084 /* Count the paths backward to find the beginning of the desired string. */
22086 {
22087 #ifdef FEAT_MBYTE
22090 #endif
22092 {
22095 else
22096 sepcount --;
22097 }
22098 }
22100 {
22104 else
22106 }
22107 else
22110 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22117 }
22120 /*
22121 * Adjust a filename, according to a string of modifiers.
22122 * *fnamep must be NUL terminated when called. When returning, the length is
22123 * determined by *fnamelen.
22124 * Returns VALID_ flags or -1 for failure.
22125 * When there is an error, *fnamep is set to NULL.
22126 */
22127 int
22134 {
22141 #ifdef WIN3264
22143 #endif
22145 repeat:
22146 /* ":p" - full path/file_name */
22148 {
22154 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22156 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22158 # ifdef BACKSLASH_IN_FILENAME
22160 # endif
22163 #endif
22164 )
22165 {
22171 }
22173 /* When "/." or "/.." is used: force expansion to get rid of it. */
22175 {
22183 }
22185 /* FullName_save() is slow, don't use it when not needed. */
22187 {
22193 }
22195 /* Append a path separator to a directory. */
22197 {
22198 /* Make room for one or two extra characters. */
22205 }
22206 }
22208 /* ":." - path relative to the current directory */
22209 /* ":~" - path relative to the home directory */
22210 /* ":8" - shortname path - postponed till after */
22213 {
22216 {
22217 #ifdef WIN3264
22219 #endif
22221 }
22223 /* Need full path first (use expand_env() to remove a "~/") */
22225 {
22228 else
22230 }
22231 else
22237 {
22239 {
22243 {
22246 {
22250 }
22251 }
22252 }
22253 else
22254 {
22256 /* Only replace it when it starts with '~' */
22258 {
22261 {
22265 }
22266 }
22267 }
22269 }
22270 }
22275 /* ":h" - head, remove "/file_name", can be repeated */
22276 /* Don't remove the first "/" or "c:\" */
22278 {
22285 #ifdef VMS
22288 #endif
22290 {
22291 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22298 }
22299 else
22300 {
22303 }
22304 }
22306 /* ":8" - shortname */
22308 {
22310 #ifdef WIN3264
22312 #endif
22313 }
22315 #ifdef WIN3264
22316 /* Check shortname after we have done 'heads' and before we do 'tails'
22317 */
22319 {
22321 /* Copy the string if it is shortened by :h */
22323 {
22329 }
22331 /* Split into two implementations - makes it easier. First is where
22332 * there isn't a full name already, second is where there is.
22333 */
22335 {
22338 }
22339 else
22340 {
22343 /* Simple case, already have the full-name
22344 * Nearly always shorter, so try first time. */
22350 {
22351 /* Couldn't find the filename.. search the paths.
22352 */
22356 }
22358 }
22359 }
22362 /* ":t" - tail, just the basename */
22364 {
22368 }
22370 /* ":e" - extension, can be repeated */
22371 /* ":r" - root, without extension, can be repeated */
22374 {
22375 /* find a '.' in the tail:
22376 * - for second :e: before the current fname
22377 * - otherwise: The last '.'
22378 */
22381 else
22387 {
22389 {
22392 #ifdef VMS
22393 /* cut version from the extension */
22400 #endif
22401 }
22404 }
22406 {
22409 }
22411 }
22413 /* ":s?pat?foo?" - substitute */
22414 /* ":gs?pat?foo?" - global substitute */
22418 {
22429 {
22432 }
22436 {
22437 /* find end of pattern */
22440 {
22443 {
22445 /* find end of substitution */
22448 {
22452 {
22456 {
22462 }
22463 }
22466 }
22468 }
22469 }
22470 /* after using ":s", repeat all the modifiers */
22473 }
22474 }
22477 }
22479 /*
22480 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22481 * "flags" can be "g" to do a global substitute.
22482 * Returns an allocated string, NULL for error.
22483 */
22484 char_u *
22490 {
22492 regmatch_T regmatch;
22496 garray_T ga;
22500 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22511 {
22514 {
22515 /*
22516 * Get some space for a temporary buffer to do the substitution
22517 * into. It will contain:
22518 * - The text up to where the match is.
22519 * - The substituted text.
22520 * - The text after the match.
22521 */
22525 {
22528 }
22530 /* copy the text up to where the match is */
22533 /* add the substituted text */
22537 /* avoid getting stuck on a match with an empty string */
22539 {
22544 }
22545 else
22546 {
22550 }
22553 }
22559 }
22566 }