| blob | 5d073c70672df9e2c746ca8568bf0b03026f8c76 |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(WIN16) || defined(WIN32) || defined(_WIN64)
15 #endif
19 #if defined(FEAT_EVAL) || defined(PROTO)
21 #ifdef AMIGA
23 #endif
25 #ifdef MACOS
27 #endif
29 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
30 # include <math.h>
31 #endif
35 /*
36 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
37 * This avoids adding a pointer to the hashtab item.
38 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
39 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
40 * HI2DI() converts a hashitem pointer to a dictitem pointer.
41 */
43 #define DI2HIKEY(di) ((di)->di_key)
44 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
45 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
47 /*
48 * Structure returned by get_lval() and used by set_var_lval().
49 * For a plain name:
50 * "name" points to the variable name.
51 * "exp_name" is NULL.
52 * "tv" is NULL
53 * For a magic braces name:
54 * "name" points to the expanded variable name.
55 * "exp_name" is non-NULL, to be freed later.
56 * "tv" is NULL
57 * For an index in a list:
58 * "name" points to the (expanded) variable name.
59 * "exp_name" NULL or non-NULL, to be freed later.
60 * "tv" points to the (first) list item value
61 * "li" points to the (first) list item
62 * "range", "n1", "n2" and "empty2" indicate what items are used.
63 * For an existing Dict item:
64 * "name" points to the (expanded) variable name.
65 * "exp_name" NULL or non-NULL, to be freed later.
66 * "tv" points to the dict item value
67 * "newkey" is NULL
68 * For a non-existing Dict item:
69 * "name" points to the (expanded) variable name.
70 * "exp_name" NULL or non-NULL, to be freed later.
71 * "tv" points to the Dictionary typval_T
72 * "newkey" is the key for the new item.
73 */
75 {
79 isn't NULL it's the Dict to which to add
80 the item. */
112 /*
113 * All user-defined global variables are stored in dictionary "globvardict".
114 * "globvars_var" is the variable that is used for "g:".
115 */
118 #define globvarht globvardict.dv_hashtab
120 /*
121 * Old Vim variables such as "v:version" are also available without the "v:".
122 * Also in functions. We need a special hashtable for them.
123 */
126 /*
127 * When recursively copying lists and dicts we need to remember which ones we
128 * have done to avoid endless recursiveness. This unique ID is used for that.
129 */
132 /*
133 * Array to hold the hashtab with variables local to each sourced script.
134 * Each item holds a variable (nameless) that points to the dict_T.
135 */
137 {
138 dictitem_T sv_var;
139 dict_T sv_dict;
143 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
144 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
148 /* Values for trans_function_name() argument: */
152 /*
153 * Structure to hold info for a user function.
154 */
157 struct ufunc
158 {
164 #ifdef FEAT_PROFILE
166 /* profiling the function as a whole */
171 /* profiling the function per line */
180 #endif
182 used for s: variables */
185 start with <SNR>123_ (<SNR> is K_SPECIAL
186 KS_EXTRA KE_SNR) */
187 };
189 /* function flags */
194 /*
195 * All user-defined functions are found in this hashtable.
196 */
199 /* The names of packages that once were loaded are remembered. */
202 /* list heads for garbage collection */
206 /* From user function to hashitem and back. */
208 #define UF2HIKEY(fp) ((fp)->uf_name)
209 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
210 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
212 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
213 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
219 /* structure to hold info for a function that is currently being executed. */
222 struct funccall_S
223 {
228 {
242 #ifdef FEAT_PROFILE
244 #endif
246 };
248 /*
249 * Info used by a ":for" loop.
250 */
252 {
259 /*
260 * Struct used by trans_function_name()
261 */
263 {
270 /*
271 * Array to hold the value of v: variables.
272 * The value is in a dictitem, so that it can also be used in the v: scope.
273 * The reason to use this table anyway is for very quick access to the
274 * variables with the VV_ defines.
275 */
278 /* values for vv_flags: */
283 #define VV_NAME(s, t) s, {{t}}, {0}
285 static struct vimvar
286 {
292 {
293 /*
294 * The order here must match the VV_ defines in vim.h!
295 * Initializing a union does not work, leave tv.vval empty to get zero's.
296 */
351 };
353 /* shorthand */
354 #define vv_type vv_di.di_tv.v_type
355 #define vv_nr vv_di.di_tv.vval.v_number
356 #define vv_float vv_di.di_tv.vval.v_float
357 #define vv_str vv_di.di_tv.vval.v_string
358 #define vv_tv vv_di.di_tv
360 /*
361 * The v: variables are stored in dictionary "vimvardict".
362 * "vimvars_var" is the variable that is used for the "l:" scope.
363 */
366 #define vimvarht vimvardict.dv_hashtab
370 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
371 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
372 #endif
373 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
380 #ifdef FEAT_WINDOWS
382 #endif
387 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
389 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
391 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
456 #ifdef FEAT_FLOAT
458 #endif
462 static int get_func_tv __ARGS((char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
463 static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
467 #ifdef FEAT_FLOAT
469 #endif
475 #ifdef FEAT_FLOAT
477 #endif
489 #ifdef FEAT_FLOAT
491 #endif
497 #if defined(FEAT_INS_EXPAND)
501 #endif
504 #ifdef FEAT_FLOAT
506 #endif
529 #ifdef FEAT_FLOAT
532 #endif
604 #ifdef FEAT_FLOAT
606 #endif
619 #ifdef vim_mkdir
621 #endif
626 #ifdef FEAT_FLOAT
628 #endif
646 #ifdef FEAT_FLOAT
648 #endif
668 #ifdef FEAT_FLOAT
670 #endif
676 #ifdef FEAT_FLOAT
679 #endif
681 #ifdef HAVE_STRFTIME
683 #endif
707 #ifdef FEAT_FLOAT
709 #endif
730 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
733 valid character */
734 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
754 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
769 #ifdef FEAT_PROFILE
771 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
772 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
773 static int
774 # ifdef __BORLANDC__
775 _RTLENTRYF
776 # endif
778 static int
779 # ifdef __BORLANDC__
780 _RTLENTRYF
781 # endif
783 #endif
790 static void call_user_func __ARGS((ufunc_T *fp, int argcount, typval_T *argvars, typval_T *rettv, linenr_T firstline, linenr_T lastline, dict_T *selfdict));
798 /* Character used as separated in autoload function/variable names. */
801 /*
802 * Initialize the global and v: variables.
803 */
804 void
806 {
816 {
823 else
826 /* add to v: scope dict, unless the value is not always available */
830 /* add to compat scope dict */
832 }
834 }
836 #if defined(EXITFREE) || defined(PROTO)
837 void
839 {
844 {
847 {
850 }
851 }
855 /* script-local variables */
861 /* global variables */
864 /* autoloaded script names */
867 /* unreferenced lists and dicts */
870 /* functions */
873 }
874 #endif
876 /*
877 * Return the name of the executed function.
878 */
879 char_u *
882 {
884 }
886 /*
887 * Return the address holding the next breakpoint line for a funccall cookie.
888 */
889 linenr_T *
892 {
894 }
896 /*
897 * Return the address holding the debug tick for a funccall cookie.
898 */
902 {
904 }
906 /*
907 * Return the nesting level for a funccall cookie.
908 */
909 int
912 {
914 }
916 /* pointer to funccal for currently active function */
919 /*
920 * Return TRUE when a function was ended by a ":return" command.
921 */
922 int
924 {
926 }
929 /*
930 * Set an internal variable to a string value. Creates the variable if it does
931 * not already exist.
932 */
933 void
937 {
943 {
946 {
949 }
950 }
951 }
958 /*
959 * Start recording command output to a variable
960 * Returns OK if successfully completed the setup. FAIL otherwise.
961 */
962 int
966 {
969 typval_T tv;
971 /* Make sure a valid variable name is specified */
973 {
976 }
984 {
987 }
989 /* The output is stored in growarray "redir_ga" until redirection ends. */
992 /* Parse the variable name (can be a dict or list entry). */
994 FNE_CHECK_START);
996 {
998 /* Trailing characters are present after the variable name */
1000 else
1004 }
1006 /* check if we can write to the variable: set it to or append an empty
1007 * string */
1014 else
1019 {
1022 }
1024 {
1025 /* Dictionary item was created, don't do it again. */
1028 }
1031 }
1033 /*
1034 * Append "value[value_len]" to the variable set by var_redir_start().
1035 * The actual appending is postponed until redirection ends, because the value
1036 * appended may in fact be the string we write to, changing it may cause freed
1037 * memory to be used:
1038 * :redir => foo
1039 * :let foo
1040 * :redir END
1041 */
1042 void
1046 {
1054 else
1058 {
1061 }
1062 else
1064 }
1066 /*
1067 * Stop redirecting command output to a variable.
1068 */
1069 void
1071 {
1072 typval_T tv;
1075 {
1076 /* Append the trailing NUL. */
1079 /* Assign the text to the variable. */
1088 }
1091 }
1093 # if defined(FEAT_MBYTE) || defined(PROTO)
1094 int
1100 {
1117 }
1118 # endif
1120 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1121 int
1125 {
1136 {
1139 }
1141 }
1142 # endif
1144 # if defined(FEAT_DIFF) || defined(PROTO)
1145 void
1150 {
1160 }
1162 void
1167 {
1177 }
1178 # endif
1180 /*
1181 * Top level evaluation function, returning a boolean.
1182 * Sets "error" to TRUE if there was an error.
1183 * Return TRUE or FALSE.
1184 */
1185 int
1191 {
1192 typval_T tv;
1199 else
1200 {
1203 {
1206 }
1207 }
1212 }
1214 /*
1215 * Top level evaluation function, returning a string. If "skip" is TRUE,
1216 * only parsing to "nextcmd" is done, without reporting errors. Return
1217 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1218 */
1219 char_u *
1224 {
1225 typval_T tv;
1232 else
1233 {
1236 }
1241 }
1243 /*
1244 * Skip over an expression at "*pp".
1245 * Return FAIL for an error, OK otherwise.
1246 */
1247 int
1250 {
1251 typval_T rettv;
1255 }
1257 /*
1258 * Top level evaluation function, returning a string.
1259 * Return pointer to allocated memory, or NULL for failure.
1260 */
1261 char_u *
1266 {
1267 typval_T tv;
1269 garray_T ga;
1273 else
1274 {
1276 {
1282 }
1283 else
1286 }
1289 }
1291 /*
1292 * Call eval_to_string() without using current local variables and using
1293 * textlock. When "use_sandbox" is TRUE use the sandbox.
1294 */
1295 char_u *
1300 {
1314 }
1316 /*
1317 * Top level evaluation function, returning a number.
1318 * Evaluates "expr" silently.
1319 * Returns -1 for an error.
1320 */
1321 int
1324 {
1325 typval_T rettv;
1333 else
1334 {
1337 }
1341 }
1343 /*
1344 * Prepare v: variable "idx" to be used.
1345 * Save the current typeval in "save_tv".
1346 * When not used yet add the variable to the v: hashtable.
1347 */
1348 static void
1352 {
1356 }
1358 /*
1359 * Restore v: variable "idx" to typeval "save_tv".
1360 * When no longer defined, remove the variable from the v: hashtable.
1361 */
1362 static void
1366 {
1371 {
1375 else
1377 }
1378 }
1380 #if defined(FEAT_SPELL) || defined(PROTO)
1381 /*
1382 * Evaluate an expression to a list with suggestions.
1383 * For the "expr:" part of 'spellsuggest'.
1384 * Returns NULL when there is an error.
1385 */
1386 list_T *
1390 {
1391 typval_T save_val;
1392 typval_T rettv;
1396 /* Set "v:val" to the bad word. */
1404 {
1407 else
1409 }
1416 }
1418 /*
1419 * "list" is supposed to contain two items: a word and a number. Return the
1420 * word in "pp" and the number as the return value.
1421 * Return -1 if anything isn't right.
1422 * Used to get the good word and score from the eval_spell_expr() result.
1423 */
1424 int
1428 {
1440 }
1441 #endif
1443 /*
1444 * Top level evaluation function.
1445 * Returns an allocated typval_T with the result.
1446 * Returns NULL when there is an error.
1447 */
1448 typval_T *
1452 {
1457 {
1460 }
1463 }
1466 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1467 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1468 /*
1469 * Call some vimL function and return the result in "*rettv".
1470 * Uses argv[argc] for the function arguments. Only Number and String
1471 * arguments are currently supported.
1472 * Returns OK or FAIL.
1473 */
1474 static int
1481 {
1495 {
1496 /* Pass a NULL or empty argument as an empty string */
1498 {
1502 }
1504 /* Recognize a number argument, the others must be strings. */
1507 {
1510 }
1511 else
1512 {
1515 }
1516 }
1519 {
1522 }
1529 {
1532 }
1539 }
1541 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1542 /*
1543 * Call vimL function "func" and return the result as a string.
1544 * Returns NULL when calling the function fails.
1545 * Uses argv[argc] for the function arguments.
1546 */
1553 {
1554 typval_T rettv;
1563 }
1564 # endif
1566 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1567 /*
1568 * Call vimL function "func" and return the result as a number.
1569 * Returns -1 when calling the function fails.
1570 * Uses argv[argc] for the function arguments.
1571 */
1572 long
1578 {
1579 typval_T rettv;
1588 }
1589 # endif
1591 /*
1592 * Call vimL function "func" and return the result as a List.
1593 * Uses argv[argc] for the function arguments.
1594 * Returns NULL when there is something wrong.
1595 */
1602 {
1603 typval_T rettv;
1609 {
1612 }
1615 }
1616 #endif
1619 /*
1620 * Save the current function call pointer, and set it to NULL.
1621 * Used when executing autocommands and for ":source".
1622 */
1625 {
1630 }
1632 void
1635 {
1639 }
1641 #if defined(FEAT_PROFILE) || defined(PROTO)
1642 /*
1643 * Prepare profiling for entering a child or something else that is not
1644 * counted for the script/function itself.
1645 * Should always be called in pair with prof_child_exit().
1646 */
1647 void
1650 {
1656 }
1658 /*
1659 * Take care of time spent in a child.
1660 * Should always be called after prof_child_enter().
1661 */
1662 void
1665 {
1669 {
1674 }
1676 }
1677 #endif
1680 #ifdef FEAT_FOLDING
1681 /*
1682 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1683 * it in "*cp". Doesn't give error messages.
1684 */
1685 int
1689 {
1690 typval_T tv;
1694 OPT_LOCAL);
1703 else
1704 {
1705 /* If the result is a number, just return the number. */
1710 else
1711 {
1712 /* If the result is a string, check if there is a non-digit before
1713 * the number. */
1718 }
1720 }
1727 }
1728 #endif
1730 /*
1731 * ":let" list all variable values
1732 * ":let var1 var2" list variable values
1733 * ":let var = expr" assignment command.
1734 * ":let var += expr" assignment command.
1735 * ":let var -= expr" assignment command.
1736 * ":let var .= expr" assignment command.
1737 * ":let [var1, var2] = expr" unpack list.
1738 */
1739 void
1742 {
1745 typval_T rettv;
1760 {
1761 /*
1762 * ":let" without "=": list variables
1763 */
1767 /* ":let var1 var2" */
1770 {
1771 /* ":let" */
1775 #ifdef FEAT_WINDOWS
1777 #endif
1781 }
1783 }
1784 else
1785 {
1789 {
1792 }
1799 {
1803 }
1805 {
1807 op);
1809 }
1810 }
1811 }
1813 /*
1814 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1815 * Handles both "var" with any type and "[var, var; var]" with a list type.
1816 * When "nextchars" is not NULL it points to a string with characters that
1817 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1818 * or concatenate.
1819 * Returns OK or FAIL;
1820 */
1821 static int
1829 {
1834 typval_T ltv;
1837 {
1838 /*
1839 * ":let var = expr" or ":for var in list"
1840 */
1844 }
1846 /*
1847 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1848 */
1850 {
1853 }
1857 {
1860 }
1862 {
1865 }
1869 {
1878 {
1879 /* Put the rest of the list (may be empty) in the var after ';'.
1880 * Create a new list for this. */
1885 {
1888 }
1901 }
1903 {
1906 }
1907 }
1910 }
1912 /*
1913 * Skip over assignable variable "var" or list of variables "[var, var]".
1914 * Used for ":let varvar = expr" and ":for varvar in expr".
1915 * For "[var, var]" increment "*var_count" for each variable.
1916 * for "[var, var; var]" set "semicolon".
1917 * Return NULL for an error.
1918 */
1924 {
1928 {
1929 /* "[var, var]": find the matching ']'. */
1932 {
1936 {
1939 }
1946 {
1948 {
1951 }
1953 }
1955 {
1958 }
1959 }
1961 }
1962 else
1964 }
1966 /*
1967 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1968 * l[idx].
1969 */
1973 {
1978 }
1980 /*
1981 * List variables for hashtab "ht" with prefix "prefix".
1982 * If "empty" is TRUE also list NULL strings as empty strings.
1983 */
1984 static void
1990 {
1997 {
1999 {
2005 }
2006 }
2007 }
2009 /*
2010 * List global variables.
2011 */
2012 static void
2015 {
2017 }
2019 /*
2020 * List buffer variables.
2021 */
2022 static void
2025 {
2034 }
2036 /*
2037 * List window variables.
2038 */
2039 static void
2042 {
2045 }
2047 #ifdef FEAT_WINDOWS
2048 /*
2049 * List tab page variables.
2050 */
2051 static void
2054 {
2057 }
2058 #endif
2060 /*
2061 * List Vim variables.
2062 */
2063 static void
2066 {
2068 }
2070 /*
2071 * List script-local variables, if there is a script.
2072 */
2073 static void
2076 {
2080 }
2082 /*
2083 * List function variables, if there is a function.
2084 */
2085 static void
2088 {
2092 }
2094 /*
2095 * List variables in "arg".
2096 */
2102 {
2109 typval_T tv;
2112 {
2114 {
2117 {
2121 }
2122 }
2123 else
2124 {
2125 /* get_name_len() takes care of expanding curly braces */
2129 {
2130 /* This is mainly to keep test 49 working: when expanding
2131 * curly braces fails overrule the exception error message. */
2133 {
2137 }
2139 }
2140 else
2141 {
2146 else
2147 {
2148 /* handle d.key, l[idx], f(expr) */
2152 else
2153 {
2155 {
2157 {
2161 #ifdef FEAT_WINDOWS
2163 #endif
2169 }
2170 }
2171 else
2172 {
2185 first);
2188 }
2190 }
2191 }
2192 }
2195 }
2198 }
2201 }
2203 /*
2204 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2205 * Returns a pointer to the char just after the var name.
2206 * Returns NULL if there is an error.
2207 */
2215 {
2224 /*
2225 * ":let $VAR = expr": Set environment variable.
2226 */
2228 {
2229 /* Find the end of the name. */
2235 else
2236 {
2242 else
2243 {
2248 {
2253 {
2257 }
2258 }
2260 {
2270 }
2273 }
2274 }
2275 }
2277 /*
2278 * ":let &option = expr": Set option value.
2279 * ":let &l:option = expr": Set local option value.
2280 * ":let &g:option = expr": Set global option value.
2281 */
2283 {
2284 /* Find the end of the name. */
2289 else
2290 {
2303 {
2309 else
2310 {
2312 {
2315 else
2317 }
2319 {
2323 }
2324 }
2325 }
2327 {
2330 }
2333 }
2334 }
2336 /*
2337 * ":let @r = expr": Set register contents.
2338 */
2340 {
2347 else
2348 {
2354 {
2357 {
2360 }
2361 }
2363 {
2366 }
2368 }
2369 }
2371 /*
2372 * ":let var = expr": Set internal variable.
2373 * ":let {expr} = expr": Idem, name made with curly braces
2374 */
2376 {
2377 lval_T lv;
2381 {
2384 else
2385 {
2388 }
2389 }
2391 }
2393 else
2397 }
2399 /*
2400 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2401 */
2402 static int
2405 {
2407 {
2410 }
2412 }
2414 /*
2415 * Get an lval: variable, Dict item or List item that can be assigned a value
2416 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2417 * "name.key", "name.key[expr]" etc.
2418 * Indexing only works if "name" is an existing List or Dictionary.
2419 * "name" points to the start of the name.
2420 * If "rettv" is not NULL it points to the value to be assigned.
2421 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2422 * wrong; must end in space or cmd separator.
2423 *
2424 * Returns a pointer to just after the name, including indexes.
2425 * When an evaluation error occurs "lp->ll_name" is NULL;
2426 * Returns NULL for a parsing error. Still need to free items in "lp"!
2427 */
2437 {
2442 typval_T var1;
2443 typval_T var2;
2450 /* Clear everything in "lp". */
2454 {
2455 /* When skipping just find the end of the name. */
2458 }
2460 /* Find the end of the name. */
2463 {
2464 /* Don't expand the name when we already know there is an error. */
2467 {
2470 }
2474 {
2475 /* Report an invalid expression in braces, unless the
2476 * expression evaluation has been cancelled due to an
2477 * aborting error, an interrupt, or an exception. */
2479 {
2483 }
2484 }
2486 }
2487 else
2490 /* Without [idx] or .key we are done. */
2503 /*
2504 * Loop until no more [idx] or .key is following.
2505 */
2508 {
2512 {
2516 }
2518 {
2522 }
2526 {
2529 ;
2531 {
2535 }
2537 }
2538 else
2539 {
2540 /* Get the index [expr] or the first index [expr: ]. */
2544 else
2545 {
2550 {
2551 /* not a number or string */
2554 }
2555 }
2557 /* Optionally get the second index [ :expr]. */
2559 {
2561 {
2567 }
2570 {
2576 }
2580 else
2581 {
2584 {
2588 }
2590 {
2591 /* not a number or string */
2596 }
2597 }
2599 }
2600 else
2604 {
2612 }
2614 /* Skip to past ']'. */
2616 }
2619 {
2621 {
2622 /* "[key]": get key from "var1" */
2625 {
2630 }
2631 }
2636 {
2637 /* Key does not exist in dict: may need to add it. */
2639 {
2645 }
2648 else
2655 }
2659 }
2660 else
2661 {
2662 /*
2663 * Get the number and item for the only or first index of the List.
2664 */
2667 else
2668 {
2671 }
2676 {
2678 {
2681 }
2682 }
2684 {
2688 }
2690 /*
2691 * May need to find the item or absolute index for the second
2692 * index of a range.
2693 * When no index given: "lp->ll_empty2" is TRUE.
2694 * Otherwise "lp->ll_n2" is set to the second index.
2695 */
2697 {
2701 {
2706 }
2708 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2713 }
2716 }
2717 }
2720 }
2722 /*
2723 * Clear lval "lp" that was filled by get_lval().
2724 */
2725 static void
2728 {
2731 }
2733 /*
2734 * Set a variable that was parsed by get_lval() to "rettv".
2735 * "endp" points to just after the parsed name.
2736 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2737 */
2738 static void
2745 {
2751 {
2753 {
2757 {
2758 typval_T tv;
2760 /* handle +=, -= and .= */
2763 {
2767 }
2768 }
2769 else
2772 }
2773 }
2777 ;
2779 {
2780 /*
2781 * Assign the List values to the list items.
2782 */
2784 {
2787 else
2788 {
2791 }
2796 {
2797 /* Need to add an empty item. */
2799 {
2802 }
2803 }
2806 }
2813 }
2814 else
2815 {
2816 /*
2817 * Assign to a List or Dictionary item.
2818 */
2820 {
2822 {
2825 }
2827 /* Need to add an item to the Dictionary. */
2832 {
2835 }
2837 }
2839 {
2842 }
2843 else
2846 /*
2847 * Assign the value to the variable or list item.
2848 */
2851 else
2852 {
2856 }
2857 }
2858 }
2860 /*
2861 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2862 * Returns OK or FAIL.
2863 */
2864 static int
2869 {
2874 /* Can't do anything with a Funcref or a Dict on the right. */
2876 {
2878 {
2886 /* List += List */
2896 {
2897 /* nr += nr or nr -= nr*/
2899 #ifdef FEAT_FLOAT
2901 {
2906 else
2911 }
2912 else
2913 #endif
2914 {
2917 else
2922 }
2923 }
2924 else
2925 {
2929 /* str .= str */
2935 }
2938 #ifdef FEAT_FLOAT
2940 {
2941 float_T f;
2949 else
2953 else
2955 }
2957 #endif
2958 }
2959 }
2963 }
2965 /*
2966 * Add a watcher to a list.
2967 */
2968 static void
2972 {
2975 }
2977 /*
2978 * Remove a watcher from a list.
2979 * No warning when it isn't found...
2980 */
2981 static void
2985 {
2990 {
2992 {
2995 }
2997 }
2998 }
3000 /*
3001 * Just before removing an item from a list: advance watchers to the next
3002 * item.
3003 */
3004 static void
3008 {
3014 }
3016 /*
3017 * Evaluate the expression used in a ":for var in expr" command.
3018 * "arg" points to "var".
3019 * Set "*errp" to TRUE for an error, FALSE otherwise;
3020 * Return a pointer that holds the info. Null when there is an error.
3021 */
3028 {
3031 typval_T tv;
3046 {
3049 }
3054 {
3057 {
3060 {
3063 }
3064 else
3065 {
3066 /* No need to increment the refcount, it's already set for the
3067 * list being used in "tv". */
3071 }
3072 }
3073 }
3078 }
3080 /*
3081 * Use the first item in a ":for" list. Advance to the next.
3082 * Assign the values to the variable (list). "arg" points to the first one.
3083 * Return TRUE when a valid item was found, FALSE when at end of list or
3084 * something wrong.
3085 */
3086 int
3090 {
3098 else
3099 {
3103 }
3105 }
3107 /*
3108 * Free the structure used to store info used by ":for".
3109 */
3110 void
3113 {
3117 {
3120 }
3122 }
3124 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3126 void
3130 cmdidx_T cmdidx;
3131 {
3137 {
3140 {
3141 /* ":let var1 var2 ...": find last space. */
3143 {
3148 }
3150 }
3151 }
3152 else
3157 {
3160 {
3163 {
3167 }
3169 {
3174 }
3175 }
3177 {
3178 /* environment variable */
3180 }
3182 {
3185 }
3189 {
3190 /* Function name can start with "<SNR>" */
3192 }
3194 {
3196 {
3201 }
3203 {
3204 /* Trick: '' is like stopping and starting a literal string. */
3208 }
3210 {
3212 {
3215 }
3216 else
3218 }
3219 else
3221 }
3222 else
3223 /* Doesn't look like something valid, expand as an expression
3224 * anyway. */
3230 }
3232 }
3236 /*
3237 * ":1,25call func(arg1, arg2)" function call.
3238 */
3239 void
3242 {
3248 typval_T rettv;
3249 linenr_T lnum;
3252 funcdict_T fudi;
3256 {
3257 /* Still need to give an error message for missing key. */
3260 }
3264 /* Increase refcount on dictionary, it could get deleted when evaluating
3265 * the arguments. */
3269 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3273 /* Skip white space to allow ":call func ()". Not good, but required for
3274 * backward compatibility. */
3279 {
3282 }
3284 /*
3285 * When skipping, evaluate the function once, to find the end of the
3286 * arguments.
3287 * When the function takes a range, this is discovered after the first
3288 * call, and the loop is broken.
3289 */
3291 {
3294 }
3295 else
3298 {
3300 {
3303 }
3308 {
3311 }
3313 /* Handle a function returning a Funcref, Dictionary or List. */
3315 {
3318 }
3324 /* Stop when immediately aborting on error, or when an interrupt
3325 * occurred or an exception was thrown but not caught.
3326 * get_func_tv() returned OK, so that the check for trailing
3327 * characters below is executed. */
3330 }
3335 {
3336 /* Check for trailing illegal characters and a following command. */
3338 {
3341 }
3342 else
3344 }
3346 end:
3349 }
3351 /*
3352 * ":unlet[!] var1 ... " command.
3353 */
3354 void
3357 {
3359 }
3361 /*
3362 * ":lockvar" and ":unlockvar" commands
3363 */
3364 void
3367 {
3374 {
3377 }
3380 }
3382 /*
3383 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3384 */
3385 static void
3390 {
3394 lval_T lv;
3396 do
3397 {
3398 /* Parse the name and find the end. */
3400 FNE_CHECK_START);
3405 {
3407 {
3410 }
3414 }
3417 {
3419 {
3422 }
3423 else
3424 {
3428 }
3429 }
3438 }
3440 static int
3445 {
3450 {
3454 /* Normal name or expanded name. */
3460 }
3464 {
3467 /* Delete a range of List items. */
3469 {
3474 }
3475 }
3476 else
3477 {
3479 /* unlet a List item. */
3481 else
3482 /* unlet a Dictionary item. */
3484 }
3487 }
3489 /*
3490 * "unlet" a variable. Return OK if it existed, FAIL if not.
3491 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3492 */
3493 int
3497 {
3505 {
3508 {
3515 }
3516 }
3521 }
3523 /*
3524 * Lock or unlock variable indicated by "lp".
3525 * "deep" is the levels to go (-1 for unlimited);
3526 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3527 */
3528 static int
3534 {
3543 {
3547 /* Normal name or expanded name. */
3550 else
3551 {
3555 else
3556 {
3559 else
3562 }
3563 }
3565 }
3567 {
3570 /* (un)lock a range of List items. */
3572 {
3576 }
3577 }
3579 /* (un)lock a List item. */
3581 else
3582 /* un(lock) a Dictionary item. */
3586 }
3588 /*
3589 * Lock or unlock an item. "deep" is nr of levels to go.
3590 */
3591 static void
3596 {
3605 {
3608 }
3613 /* lock/unlock the item itself */
3616 else
3620 {
3623 {
3626 else
3629 /* recursive: lock/unlock the items the List contains */
3632 }
3636 {
3639 else
3642 {
3643 /* recursive: lock/unlock the items the List contains */
3646 {
3648 {
3651 }
3652 }
3653 }
3654 }
3655 }
3657 }
3659 /*
3660 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3661 * it refers to a List or Dictionary that is locked.
3662 */
3663 static int
3666 {
3674 }
3676 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3677 /*
3678 * Delete all "menutrans_" variables.
3679 */
3680 void
3682 {
3689 {
3691 {
3695 }
3696 }
3698 }
3699 #endif
3701 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3703 /*
3704 * Local string buffer for the next two functions to store a variable name
3705 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3706 * get_user_var_name().
3707 */
3714 /*
3715 * Function to concatenate a prefix and a variable name.
3716 */
3721 {
3726 {
3731 {
3734 }
3736 }
3741 }
3743 /*
3744 * Function given to ExpandGeneric() to obtain the list of user defined
3745 * (global/buffer/window/built-in) variable names.
3746 */
3747 /*ARGSUSED*/
3748 char_u *
3752 {
3756 #ifdef FEAT_WINDOWS
3758 #endif
3764 {
3766 #ifdef FEAT_WINDOWS
3768 #endif
3769 }
3771 /* Global variables */
3773 {
3776 else
3783 }
3785 /* b: variables */
3788 {
3791 else
3796 }
3798 {
3801 }
3803 /* w: variables */
3806 {
3809 else
3814 }
3816 #ifdef FEAT_WINDOWS
3817 /* t: variables */
3820 {
3823 else
3828 }
3829 #endif
3831 /* v: variables */
3839 }
3843 /*
3844 * types for expressions.
3845 */
3847 {
3859 /*
3860 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3861 * executed. The function may return OK, but the rettv will be of type
3862 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3863 */
3865 /*
3866 * Handle zero level expression.
3867 * This calls eval1() and handles error message and nextcmd.
3868 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3869 * Note: "rettv.v_lock" is not set.
3870 * Return OK or FAIL.
3871 */
3872 static int
3878 {
3885 {
3888 /*
3889 * Report the invalid expression unless the expression evaluation has
3890 * been cancelled due to an aborting error, an interrupt, or an
3891 * exception.
3892 */
3896 }
3901 }
3903 /*
3904 * Handle top level expression:
3905 * expr1 ? expr0 : expr0
3906 *
3907 * "arg" must point to the first non-white of the expression.
3908 * "arg" is advanced to the next non-white after the recognized expression.
3909 *
3910 * Note: "rettv.v_lock" is not set.
3911 *
3912 * Return OK or FAIL.
3913 */
3914 static int
3919 {
3921 typval_T var2;
3923 /*
3924 * Get the first variable.
3925 */
3930 {
3933 {
3941 }
3943 /*
3944 * Get the second variable.
3945 */
3950 /*
3951 * Check for the ":".
3952 */
3954 {
3959 }
3961 /*
3962 * Get the third variable.
3963 */
3966 {
3970 }
3973 }
3976 }
3978 /*
3979 * Handle first level expression:
3980 * expr2 || expr2 || expr2 logical OR
3981 *
3982 * "arg" must point to the first non-white of the expression.
3983 * "arg" is advanced to the next non-white after the recognized expression.
3984 *
3985 * Return OK or FAIL.
3986 */
3987 static int
3992 {
3993 typval_T var2;
3998 /*
3999 * Get the first variable.
4000 */
4004 /*
4005 * Repeat until there is no following "||".
4006 */
4010 {
4012 {
4019 }
4021 /*
4022 * Get the second variable.
4023 */
4028 /*
4029 * Compute the result.
4030 */
4032 {
4038 }
4040 {
4043 }
4044 }
4047 }
4049 /*
4050 * Handle second level expression:
4051 * expr3 && expr3 && expr3 logical AND
4052 *
4053 * "arg" must point to the first non-white of the expression.
4054 * "arg" is advanced to the next non-white after the recognized expression.
4055 *
4056 * Return OK or FAIL.
4057 */
4058 static int
4063 {
4064 typval_T var2;
4069 /*
4070 * Get the first variable.
4071 */
4075 /*
4076 * Repeat until there is no following "&&".
4077 */
4081 {
4083 {
4090 }
4092 /*
4093 * Get the second variable.
4094 */
4099 /*
4100 * Compute the result.
4101 */
4103 {
4109 }
4111 {
4114 }
4115 }
4118 }
4120 /*
4121 * Handle third level expression:
4122 * var1 == var2
4123 * var1 =~ var2
4124 * var1 != var2
4125 * var1 !~ var2
4126 * var1 > var2
4127 * var1 >= var2
4128 * var1 < var2
4129 * var1 <= var2
4130 * var1 is var2
4131 * var1 isnot var2
4132 *
4133 * "arg" must point to the first non-white of the expression.
4134 * "arg" is advanced to the next non-white after the recognized expression.
4135 *
4136 * Return OK or FAIL.
4137 */
4138 static int
4143 {
4144 typval_T var2;
4153 regmatch_T regmatch;
4157 /*
4158 * Get the first variable.
4159 */
4165 {
4177 {
4180 }
4181 else
4185 {
4188 }
4189 else
4193 {
4197 {
4200 }
4201 }
4203 }
4205 /*
4206 * If there is a comparative operator, use it.
4207 */
4209 {
4210 /* extra question mark appended: ignore case */
4212 {
4215 }
4216 /* extra '#' appended: match case */
4218 {
4221 }
4222 /* nothing appended: use 'ignorecase' */
4223 else
4226 /*
4227 * Get the second variable.
4228 */
4231 {
4234 }
4237 {
4239 {
4240 /* For "is" a different type always means FALSE, for "notis"
4241 * it means TRUE. */
4243 }
4245 {
4247 {
4252 }
4255 {
4258 else
4263 }
4264 else
4265 {
4266 /* Compare two Lists for being equal or unequal. */
4270 }
4271 }
4274 {
4276 {
4281 }
4284 {
4287 else
4292 }
4293 else
4294 {
4295 /* Compare two Dictionaries for being equal or unequal. */
4299 }
4300 }
4303 {
4306 {
4309 else
4314 }
4315 else
4316 {
4317 /* Compare two Funcrefs for being equal or unequal. */
4321 else
4326 }
4327 }
4329 #ifdef FEAT_FLOAT
4330 /*
4331 * If one of the two variables is a float, compare as a float.
4332 * When using "=~" or "!~", always compare as string.
4333 */
4336 {
4341 else
4345 else
4349 {
4359 }
4360 }
4361 #endif
4363 /*
4364 * If one of the two variables is a number, compare as a number.
4365 * When using "=~" or "!~", always compare as string.
4366 */
4369 {
4373 {
4383 }
4384 }
4385 else
4386 {
4391 else
4395 {
4405 /* avoid 'l' flag in 'cpoptions' */
4412 {
4417 }
4422 }
4423 }
4428 }
4429 }
4432 }
4434 /*
4435 * Handle fourth level expression:
4436 * + number addition
4437 * - number subtraction
4438 * . string concatenation
4439 *
4440 * "arg" must point to the first non-white of the expression.
4441 * "arg" is advanced to the next non-white after the recognized expression.
4442 *
4443 * Return OK or FAIL.
4444 */
4445 static int
4450 {
4451 typval_T var2;
4452 typval_T var3;
4455 #ifdef FEAT_FLOAT
4457 #endif
4462 /*
4463 * Get the first variable.
4464 */
4468 /*
4469 * Repeat computing, until no '+', '-' or '.' is following.
4470 */
4472 {
4478 #ifdef FEAT_FLOAT
4480 #endif
4481 )
4482 {
4483 /* For "list + ...", an illegal use of the first operand as
4484 * a number cannot be determined before evaluating the 2nd
4485 * operand: if this is also a list, all is ok.
4486 * For "something . ...", "something - ..." or "non-list + ...",
4487 * we know that the first operand needs to be a string or number
4488 * without evaluating the 2nd operand. So check before to avoid
4489 * side effects after an error. */
4491 {
4494 }
4495 }
4497 /*
4498 * Get the second variable.
4499 */
4502 {
4505 }
4508 {
4509 /*
4510 * Compute the result.
4511 */
4513 {
4517 {
4521 }
4526 }
4529 {
4530 /* concatenate Lists */
4533 {
4537 }
4540 }
4541 else
4542 {
4545 #ifdef FEAT_FLOAT
4547 {
4550 }
4551 else
4552 #endif
4553 {
4556 {
4557 /* This can only happen for "list + non-list". For
4558 * "non-list + ..." or "something - ...", we returned
4559 * before evaluating the 2nd operand. */
4562 }
4563 #ifdef FEAT_FLOAT
4566 #endif
4567 }
4568 #ifdef FEAT_FLOAT
4570 {
4573 }
4574 else
4575 #endif
4576 {
4579 {
4583 }
4584 #ifdef FEAT_FLOAT
4587 #endif
4588 }
4591 #ifdef FEAT_FLOAT
4592 /* If there is a float on either side the result is a float. */
4594 {
4597 else
4601 }
4602 else
4603 #endif
4604 {
4607 else
4611 }
4612 }
4614 }
4615 }
4617 }
4619 /*
4620 * Handle fifth level expression:
4621 * * number multiplication
4622 * / number division
4623 * % number modulo
4624 *
4625 * "arg" must point to the first non-white of the expression.
4626 * "arg" is advanced to the next non-white after the recognized expression.
4627 *
4628 * Return OK or FAIL.
4629 */
4630 static int
4636 {
4637 typval_T var2;
4640 #ifdef FEAT_FLOAT
4643 #endif
4646 /*
4647 * Get the first variable.
4648 */
4652 /*
4653 * Repeat computing, until no '*', '/' or '%' is following.
4654 */
4656 {
4662 {
4663 #ifdef FEAT_FLOAT
4665 {
4669 }
4670 else
4671 #endif
4676 }
4677 else
4680 /*
4681 * Get the second variable.
4682 */
4688 {
4689 #ifdef FEAT_FLOAT
4691 {
4693 {
4696 }
4699 }
4700 else
4701 #endif
4702 {
4707 #ifdef FEAT_FLOAT
4710 #endif
4711 }
4713 /*
4714 * Compute the result.
4715 * When either side is a float the result is a float.
4716 */
4717 #ifdef FEAT_FLOAT
4719 {
4723 {
4724 /* We rely on the floating point library to handle divide
4725 * by zero to result in "inf" and not a crash. */
4727 }
4728 else
4729 {
4732 }
4735 }
4736 else
4737 #endif
4738 {
4742 {
4744 {
4749 else
4751 }
4752 else
4754 }
4755 else
4756 {
4759 else
4761 }
4764 }
4765 }
4766 }
4769 }
4771 /*
4772 * Handle sixth level expression:
4773 * number number constant
4774 * "string" string constant
4775 * 'string' literal string constant
4776 * &option-name option value
4777 * @r register contents
4778 * identifier variable value
4779 * function() function call
4780 * $VAR environment variable
4781 * (expression) nested expression
4782 * [expr, expr] List
4783 * {key: val, key: val} Dictionary
4784 *
4785 * Also handle:
4786 * ! in front logical NOT
4787 * - in front unary minus
4788 * + in front unary plus (ignored)
4789 * trailing [] subscript in String or List
4790 * trailing .name entry in Dictionary
4791 *
4792 * "arg" must point to the first non-white of the expression.
4793 * "arg" is advanced to the next non-white after the recognized expression.
4794 *
4795 * Return OK or FAIL.
4796 */
4797 static int
4803 {
4811 /*
4812 * Initialise variable so that clear_tv() can't mistake this for a
4813 * string and free a string that isn't there.
4814 */
4817 /*
4818 * Skip '!' and '-' characters. They are handled later.
4819 */
4826 {
4827 /*
4828 * Number constant.
4829 */
4840 {
4841 #ifdef FEAT_FLOAT
4845 /* We accept a float when the format matches
4846 * "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very
4847 * strict to avoid backwards compatibility problems.
4848 * Don't look for a float after the "." operator, so that
4849 * ":let vers = 1.2.3" doesn't fail. */
4851 {
4855 {
4861 else
4863 }
4866 }
4868 {
4869 float_T f;
4873 {
4876 }
4877 }
4878 else
4879 #endif
4880 {
4884 {
4887 }
4888 }
4890 }
4892 /*
4893 * String constant: "string".
4894 */
4898 /*
4899 * Literal string constant: 'str''ing'.
4900 */
4904 /*
4905 * List: [expr, expr]
4906 */
4910 /*
4911 * Dictionary: {key: val, key: val}
4912 */
4916 /*
4917 * Option value: &name
4918 */
4922 /*
4923 * Environment variable: $VAR.
4924 */
4928 /*
4929 * Register contents: @r.
4930 */
4933 {
4936 }
4941 /*
4942 * nested expression: (expression).
4943 */
4949 {
4953 }
4958 }
4961 {
4962 /*
4963 * Must be a variable or function name.
4964 * Can also be a curly-braces kind of name: {expr}.
4965 */
4973 else
4974 {
4976 {
4977 /* If "s" is the name of a variable of type VAR_FUNC
4978 * use its contents. */
4981 /* Invoke the function. */
4985 /* Stop the expression evaluation when immediately
4986 * aborting on error, or when an interrupt occurred or
4987 * an exception was thrown but not caught. */
4989 {
4993 }
4994 }
4997 else
4999 }
5003 }
5007 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
5008 * expr(expr). */
5012 /*
5013 * Apply logical NOT and unary '-', from right to left, ignore '+'.
5014 */
5016 {
5019 #ifdef FEAT_FLOAT
5024 else
5025 #endif
5028 {
5031 }
5032 else
5033 {
5035 {
5038 {
5039 #ifdef FEAT_FLOAT
5042 else
5043 #endif
5045 }
5047 {
5048 #ifdef FEAT_FLOAT
5051 else
5052 #endif
5054 }
5055 }
5056 #ifdef FEAT_FLOAT
5058 {
5061 }
5062 else
5063 #endif
5064 {
5068 }
5069 }
5070 }
5073 }
5075 /*
5076 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
5077 * "*arg" points to the '[' or '.'.
5078 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
5079 */
5080 static int
5086 {
5096 #ifdef FEAT_FLOAT
5098 #endif
5099 )
5100 {
5104 }
5107 {
5108 /*
5109 * dict.name
5110 */
5113 ;
5117 }
5118 else
5119 {
5120 /*
5121 * something[idx]
5122 *
5123 * Get the (first) variable from inside the [].
5124 */
5131 {
5132 /* not a number or string */
5135 }
5137 /*
5138 * Get the second variable from inside the [:].
5139 */
5141 {
5147 {
5151 }
5153 {
5154 /* not a number or string */
5159 }
5160 }
5162 /* Check for the ']'. */
5164 {
5171 }
5173 }
5176 {
5179 {
5182 }
5184 {
5187 else
5188 {
5191 }
5192 }
5195 {
5201 {
5202 /* The resulting variable is a substring. If the indexes
5203 * are out of range the result is empty. */
5205 {
5209 }
5216 else
5218 }
5219 else
5220 {
5221 /* The resulting variable is a string of a single
5222 * character. If the index is too big or negative the
5223 * result is empty. */
5226 else
5228 }
5239 {
5240 /* For a range we allow invalid values and return an empty
5241 * list. A list index out of range is an error. */
5243 {
5247 }
5249 }
5251 {
5266 {
5268 {
5271 }
5273 }
5278 }
5279 else
5280 {
5284 }
5289 {
5295 }
5296 {
5300 {
5303 {
5308 }
5309 }
5323 }
5325 }
5326 }
5329 }
5331 /*
5332 * Get an option value.
5333 * "arg" points to the '&' or '+' before the option name.
5334 * "arg" is advanced to character after the option name.
5335 * Return OK or FAIL.
5336 */
5337 static int
5342 {
5352 /*
5353 * Isolate the option name and find its value.
5354 */
5357 {
5361 }
5364 {
5367 }
5375 {
5379 }
5381 {
5383 {
5386 }
5388 {
5391 }
5393 {
5396 }
5398 {
5401 }
5402 }
5410 }
5412 /*
5413 * Allocate a variable for a string constant.
5414 * Return OK or FAIL.
5415 */
5416 static int
5421 {
5426 /*
5427 * Find the end of the string, skipping backslashed characters.
5428 */
5430 {
5432 {
5434 /* A "\<x>" form occupies at least 4 characters, and produces up
5435 * to 6 characters: reserve space for 2 extra */
5438 }
5439 }
5442 {
5445 }
5447 /* If only parsing, set *arg and return here */
5449 {
5452 }
5454 /*
5455 * Copy the string into allocated memory, handling backslashed
5456 * characters.
5457 */
5465 {
5467 {
5469 {
5482 {
5488 else
5492 {
5495 }
5497 #ifdef FEAT_MBYTE
5498 /* For "\u" store the number according to
5499 * 'encoding'. */
5502 else
5503 #endif
5505 }
5508 /* octal: "\1", "\12", "\123" */
5518 {
5522 }
5526 /* Special key, e.g.: "\<C-W>" */
5529 {
5532 }
5533 /* FALLTHROUGH */
5537 }
5538 }
5539 else
5542 }
5547 }
5549 /*
5550 * Allocate a variable for a 'str''ing' constant.
5551 * Return OK or FAIL.
5552 */
5553 static int
5558 {
5563 /*
5564 * Find the end of the string, skipping ''.
5565 */
5567 {
5569 {
5574 }
5575 }
5578 {
5581 }
5583 /* If only parsing return after setting "*arg" */
5585 {
5588 }
5590 /*
5591 * Copy the string into allocated memory, handling '' to ' reduction.
5592 */
5600 {
5602 {
5606 }
5608 }
5613 }
5615 /*
5616 * Allocate a variable for a List and fill it from "*arg".
5617 * Return OK or FAIL.
5618 */
5619 static int
5624 {
5626 typval_T tv;
5630 {
5634 }
5638 {
5642 {
5645 {
5649 }
5650 else
5652 }
5657 {
5660 }
5662 }
5665 {
5667 failret:
5671 }
5675 {
5679 }
5682 }
5684 /*
5685 * Allocate an empty header for a list.
5686 * Caller should take care of the reference count.
5687 */
5688 list_T *
5690 {
5695 {
5696 /* Prepend the list to the list of lists for garbage collection. */
5702 }
5704 }
5706 /*
5707 * Allocate an empty list for a return value.
5708 * Returns OK or FAIL.
5709 */
5710 static int
5713 {
5723 }
5725 /*
5726 * Unreference a list: decrement the reference count and free it when it
5727 * becomes zero.
5728 */
5729 void
5732 {
5735 }
5737 /*
5738 * Free a list, including all items it points to.
5739 * Ignores the reference count.
5740 */
5741 void
5745 {
5748 /* Remove the list from the list of lists for garbage collection. */
5751 else
5757 {
5758 /* Remove the item before deleting it. */
5764 }
5766 }
5768 /*
5769 * Allocate a list item.
5770 */
5773 {
5775 }
5777 /*
5778 * Free a list item. Also clears the value. Does not notify watchers.
5779 */
5780 static void
5783 {
5786 }
5788 /*
5789 * Remove a list item from a List and free it. Also clears the value.
5790 */
5791 static void
5795 {
5798 }
5800 /*
5801 * Get the number of items in a list.
5802 */
5803 static long
5806 {
5810 }
5812 /*
5813 * Return TRUE when two lists have exactly the same values.
5814 */
5815 static int
5820 {
5836 }
5838 #if defined(FEAT_PYTHON) || defined(PROTO) || defined(FEAT_GUI_MACVIM)
5839 /*
5840 * Return the dictitem that an entry in a hashtable points to.
5841 */
5842 dictitem_T *
5845 {
5847 }
5848 #endif
5850 /*
5851 * Return TRUE when two dictionaries have exactly the same key/values.
5852 */
5853 static int
5858 {
5872 {
5874 {
5881 }
5882 }
5884 }
5886 /*
5887 * Return TRUE if "tv1" and "tv2" have the same value.
5888 * Compares the items just like "==" would compare them, but strings and
5889 * numbers are different. Floats and numbers are also different.
5890 */
5891 static int
5896 {
5904 /* Catch lists and dicts that have an endless loop by limiting
5905 * recursiveness to 1000. We guess they are equal then. */
5910 {
5931 #ifdef FEAT_FLOAT
5934 #endif
5940 }
5944 }
5946 /*
5947 * Locate item with index "n" in list "l" and return it.
5948 * A negative index is counted from the end; -1 is the last item.
5949 * Returns NULL when "n" is out of range.
5950 */
5955 {
5962 /* Negative index is relative to the end. */
5966 /* Check for index out of range. */
5970 /* When there is a cached index may start search from there. */
5972 {
5974 {
5975 /* closest to the start of the list */
5978 }
5980 {
5981 /* closest to the end of the list */
5984 }
5985 else
5986 {
5987 /* closest to the cached index */
5990 }
5991 }
5992 else
5993 {
5995 {
5996 /* closest to the start of the list */
5999 }
6000 else
6001 {
6002 /* closest to the end of the list */
6005 }
6006 }
6009 {
6010 /* search forward */
6013 }
6015 {
6016 /* search backward */
6019 }
6021 /* cache the used index */
6026 }
6028 /*
6029 * Get list item "l[idx]" as a number.
6030 */
6031 static long
6036 {
6041 {
6045 }
6047 }
6049 /*
6050 * Locate "item" list "l" and return its index.
6051 * Returns -1 when "item" is not in the list.
6052 */
6053 static long
6057 {
6069 }
6071 /*
6072 * Append item "item" to the end of list "l".
6073 */
6074 static void
6078 {
6080 {
6081 /* empty list */
6085 }
6086 else
6087 {
6091 }
6094 }
6096 /*
6097 * Append typval_T "tv" to the end of list "l".
6098 * Return FAIL when out of memory.
6099 */
6100 static int
6104 {
6112 }
6114 /*
6115 * Add a dictionary to a list. Used by getqflist().
6116 * Return FAIL when out of memory.
6117 */
6118 int
6122 {
6133 }
6135 /*
6136 * Make a copy of "str" and append it as an item to list "l".
6137 * When "len" >= 0 use "str[len]".
6138 * Returns FAIL when out of memory.
6139 */
6140 static int
6145 {
6159 }
6161 /*
6162 * Append "n" to list "l".
6163 * Returns FAIL when out of memory.
6164 */
6165 static int
6168 varnumber_T n;
6169 {
6180 }
6182 /*
6183 * Insert typval_T "tv" in list "l" before "item".
6184 * If "item" is NULL append at the end.
6185 * Return FAIL when out of memory.
6186 */
6187 static int
6192 {
6199 /* Append new item at end of list. */
6201 else
6202 {
6203 /* Insert new item before existing item. */
6207 {
6210 }
6211 else
6212 {
6215 }
6218 }
6220 }
6222 /*
6223 * Extend "l1" with "l2".
6224 * If "bef" is NULL append at the end, otherwise insert before this item.
6225 * Returns FAIL when out of memory.
6226 */
6227 static int
6232 {
6236 /* We also quit the loop when we have inserted the original item count of
6237 * the list, avoid a hang when we extend a list with itself. */
6242 }
6244 /*
6245 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
6246 * Return FAIL when out of memory.
6247 */
6248 static int
6253 {
6259 /* make a copy of the first list. */
6266 /* append all items from the second list */
6268 }
6270 /*
6271 * Make a copy of list "orig". Shallow if "deep" is FALSE.
6272 * The refcount of the new list is set to 1.
6273 * See item_copy() for "copyID".
6274 * Returns NULL when out of memory.
6275 */
6281 {
6291 {
6293 {
6294 /* Do this before adding the items, because one of the items may
6295 * refer back to this list. */
6298 }
6301 {
6306 {
6308 {
6311 }
6312 }
6313 else
6316 }
6319 {
6322 }
6323 }
6326 }
6328 /*
6329 * Remove items "item" to "item2" from list "l".
6330 * Does not free the listitem or the value!
6331 */
6332 static void
6337 {
6340 /* notify watchers */
6342 {
6347 }
6351 else
6355 else
6358 }
6360 /*
6361 * Return an allocated string with the string representation of a list.
6362 * May return NULL.
6363 */
6368 {
6369 garray_T ga;
6376 {
6379 }
6383 }
6385 /*
6386 * Join list "l" into a string in "*gap", using separator "sep".
6387 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6388 * Return FAIL or OK.
6389 */
6390 static int
6397 {
6405 {
6408 else
6413 else
6420 }
6422 }
6424 /*
6425 * Garbage collection for lists and dictionaries.
6426 *
6427 * We use reference counts to be able to free most items right away when they
6428 * are no longer used. But for composite items it's possible that it becomes
6429 * unused while the reference count is > 0: When there is a recursive
6430 * reference. Example:
6431 * :let l = [1, 2, 3]
6432 * :let d = {9: l}
6433 * :let l[1] = d
6434 *
6435 * Since this is quite unusual we handle this with garbage collection: every
6436 * once in a while find out which lists and dicts are not referenced from any
6437 * variable.
6438 *
6439 * Here is a good reference text about garbage collection (refers to Python
6440 * but it applies to all reference-counting mechanisms):
6441 * http://python.ca/nas/python/gc/
6442 */
6444 /*
6445 * Do garbage collection for lists and dicts.
6446 * Return TRUE if some memory was freed.
6447 */
6448 int
6450 {
6459 #ifdef FEAT_WINDOWS
6461 #endif
6463 /* Only do this once. */
6468 /*
6469 * 1. Go through all accessible variables and mark all lists and dicts
6470 * with copyID.
6471 */
6472 /* script-local variables */
6476 /* buffer-local variables */
6480 /* window-local variables */
6484 #ifdef FEAT_WINDOWS
6485 /* tabpage-local variables */
6488 #endif
6490 /* global variables */
6493 /* function-local variables */
6495 {
6498 }
6500 /*
6501 * 2. Go through the list of dicts and free items without the copyID.
6502 */
6505 {
6506 /* Free the Dictionary and ordinary items it contains, but don't
6507 * recurse into Lists and Dictionaries, they will be in the list
6508 * of dicts or list of lists. */
6512 /* restart, next dict may also have been freed */
6514 }
6515 else
6518 /*
6519 * 3. Go through the list of lists and free items without the copyID.
6520 * But don't free a list that has a watcher (used in a for loop), these
6521 * are not referenced anywhere.
6522 */
6525 {
6526 /* Free the List and ordinary items it contains, but don't recurse
6527 * into Lists and Dictionaries, they will be in the list of dicts
6528 * or list of lists. */
6532 /* restart, next list may also have been freed */
6534 }
6535 else
6539 }
6541 /*
6542 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6543 */
6544 static void
6548 {
6555 {
6558 }
6559 }
6561 /*
6562 * Mark all lists and dicts referenced through list "l" with "copyID".
6563 */
6564 static void
6568 {
6573 }
6575 /*
6576 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6577 */
6578 static void
6582 {
6587 {
6591 {
6592 /* Didn't see this dict yet. */
6595 }
6601 {
6602 /* Didn't see this list yet. */
6605 }
6607 }
6609 }
6611 /*
6612 * Allocate an empty header for a dictionary.
6613 */
6614 dict_T *
6616 {
6621 {
6622 /* Add the list to the list of dicts for garbage collection. */
6633 }
6635 }
6637 /*
6638 * Unreference a Dictionary: decrement the reference count and free it when it
6639 * becomes zero.
6640 */
6641 static void
6644 {
6647 }
6649 /*
6650 * Free a Dictionary, including all items it contains.
6651 * Ignores the reference count.
6652 */
6653 static void
6657 {
6662 /* Remove the dict from the list of dicts for garbage collection. */
6665 else
6670 /* Lock the hashtab, we don't want it to resize while freeing items. */
6674 {
6676 {
6677 /* Remove the item before deleting it, just in case there is
6678 * something recursive causing trouble. */
6686 }
6687 }
6690 }
6692 /*
6693 * Allocate a Dictionary item.
6694 * The "key" is copied to the new item.
6695 * Note that the value of the item "di_tv" still needs to be initialized!
6696 * Returns NULL when out of memory.
6697 */
6701 {
6706 {
6709 }
6711 }
6713 /*
6714 * Make a copy of a Dictionary item.
6715 */
6719 {
6725 {
6729 }
6731 }
6733 /*
6734 * Remove item "item" from Dictionary "dict" and free it.
6735 */
6736 static void
6740 {
6746 else
6749 }
6751 /*
6752 * Free a dict item. Also clears the value.
6753 */
6754 static void
6757 {
6760 }
6762 /*
6763 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6764 * The refcount of the new dict is set to 1.
6765 * See item_copy() for "copyID".
6766 * Returns NULL when out of memory.
6767 */
6773 {
6784 {
6786 {
6789 }
6792 {
6794 {
6801 {
6804 {
6807 }
6808 }
6809 else
6812 {
6815 }
6816 }
6817 }
6821 {
6824 }
6825 }
6828 }
6830 /*
6831 * Add item "item" to Dictionary "d".
6832 * Returns FAIL when out of memory and when key already existed.
6833 */
6834 static int
6838 {
6840 }
6842 /*
6843 * Add a number or string entry to dictionary "d".
6844 * When "str" is NULL use number "nr", otherwise use "str".
6845 * Returns FAIL when out of memory and when key already exists.
6846 */
6847 int
6853 {
6861 {
6864 }
6865 else
6866 {
6869 }
6871 {
6874 }
6876 }
6878 /*
6879 * Get the number of items in a Dictionary.
6880 */
6881 static long
6884 {
6888 }
6890 /*
6891 * Find item "key[len]" in Dictionary "d".
6892 * If "len" is negative use strlen(key).
6893 * Returns NULL when not found.
6894 */
6900 {
6901 #define AKEYLEN 200
6910 {
6914 }
6915 else
6916 {
6917 /* Avoid a malloc/free by using buf[]. */
6920 }
6927 }
6929 /*
6930 * Get a string item from a dictionary.
6931 * When "save" is TRUE allocate memory for it.
6932 * Returns NULL if the entry doesn't exist or out of memory.
6933 */
6934 char_u *
6939 {
6950 }
6952 /*
6953 * Get a number item from a dictionary.
6954 * Returns 0 if the entry doesn't exist or out of memory.
6955 */
6956 long
6960 {
6967 }
6969 /*
6970 * Return an allocated string with the string representation of a Dictionary.
6971 * May return NULL.
6972 */
6977 {
6978 garray_T ga;
6994 {
6996 {
7001 else
7006 {
7009 }
7017 }
7018 }
7020 {
7023 }
7028 }
7030 /*
7031 * Allocate a variable for a Dictionary and fill it from "*arg".
7032 * Return OK or FAIL. Returns NOTDONE for {expr}.
7033 */
7034 static int
7039 {
7041 typval_T tvkey;
7042 typval_T tv;
7048 /*
7049 * First check if it's not a curly-braces thing: {expr}.
7050 * Must do this without evaluating, otherwise a function may be called
7051 * twice. Unfortunately this means we need to call eval1() twice for the
7052 * first item.
7053 * But {} is an empty Dictionary.
7054 */
7056 {
7061 }
7064 {
7068 }
7074 {
7078 {
7082 }
7084 {
7087 {
7088 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
7093 }
7094 }
7098 {
7102 }
7104 {
7107 {
7112 }
7116 {
7121 }
7122 }
7127 {
7130 }
7132 }
7135 {
7137 failret:
7141 }
7145 {
7149 }
7152 }
7154 /*
7155 * Return a string with the string representation of a variable.
7156 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7157 * "numbuf" is used for a number.
7158 * Does not put quotes around strings, as ":echo" displays values.
7159 * When "copyID" is not NULL replace recursive lists and dicts with "...".
7160 * May return NULL.
7161 */
7168 {
7173 {
7177 }
7181 {
7189 {
7192 }
7194 {
7197 }
7198 else
7199 {
7203 }
7208 {
7211 }
7213 {
7216 }
7217 else
7218 {
7222 }
7231 #ifdef FEAT_FLOAT
7237 #endif
7242 }
7246 }
7248 /*
7249 * Return a string with the string representation of a variable.
7250 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7251 * "numbuf" is used for a number.
7252 * Puts quotes around strings, so that they can be parsed back by eval().
7253 * May return NULL.
7254 */
7261 {
7263 {
7270 #ifdef FEAT_FLOAT
7275 #endif
7282 }
7284 }
7286 /*
7287 * Return string "str" in ' quotes, doubling ' characters.
7288 * If "str" is NULL an empty string is assumed.
7289 * If "function" is TRUE make it function('string').
7290 */
7295 {
7301 {
7306 }
7309 {
7311 {
7314 }
7315 else
7319 {
7323 }
7328 }
7330 }
7332 #ifdef FEAT_FLOAT
7333 /*
7334 * Convert the string "text" to a floating point number.
7335 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
7336 * this always uses a decimal point.
7337 * Returns the length of the text that was consumed.
7338 */
7339 static int
7343 {
7345 float_T f;
7350 }
7351 #endif
7353 /*
7354 * Get the value of an environment variable.
7355 * "arg" is pointing to the '$'. It is advanced to after the name.
7356 * If the environment variable was not set, silently assume it is empty.
7357 * Always return OK.
7358 */
7359 static int
7364 {
7375 {
7377 {
7380 /* first try vim_getenv(), fast for normal environment vars */
7383 {
7386 }
7387 else
7388 {
7392 /* next try expanding things like $VIM and ${HOME} */
7395 {
7398 }
7399 }
7401 }
7404 }
7407 }
7409 /*
7410 * Array with names and number of arguments of all internal functions
7411 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7412 */
7413 static struct fst
7414 {
7419 /* implementation of function */
7421 {
7422 #ifdef FEAT_FLOAT
7424 #endif
7430 #ifdef FEAT_FLOAT
7432 #endif
7447 #ifdef FEAT_FLOAT
7449 #endif
7455 #if defined(FEAT_INS_EXPAND)
7459 #endif
7462 #ifdef FEAT_FLOAT
7464 #endif
7488 #ifdef FEAT_FLOAT
7491 #endif
7566 #ifdef FEAT_FLOAT
7568 #endif
7581 #ifdef vim_mkdir
7583 #endif
7588 #ifdef FEAT_FLOAT
7590 #endif
7608 #ifdef FEAT_FLOAT
7610 #endif
7630 #ifdef FEAT_FLOAT
7632 #endif
7638 #ifdef FEAT_FLOAT
7641 #endif
7643 #ifdef HAVE_STRFTIME
7645 #endif
7669 #ifdef FEAT_FLOAT
7671 #endif
7686 };
7688 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7690 /*
7691 * Function given to ExpandGeneric() to obtain the list of internal
7692 * or user defined function names.
7693 */
7694 char_u *
7698 {
7705 {
7709 }
7711 {
7717 }
7720 }
7722 /*
7723 * Function given to ExpandGeneric() to obtain the list of internal or
7724 * user defined variable or function names.
7725 */
7726 /*ARGSUSED*/
7727 char_u *
7731 {
7738 {
7742 }
7744 }
7748 /*
7749 * Find internal function in table above.
7750 * Return index, or -1 if not found
7751 */
7752 static int
7755 {
7761 /*
7762 * Find the function name in the table. Binary search.
7763 */
7765 {
7772 else
7774 }
7776 }
7778 /*
7779 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7780 * name it contains, otherwise return "name".
7781 */
7786 {
7795 {
7797 {
7800 }
7803 }
7806 }
7808 /*
7809 * Allocate a variable for the result of a function.
7810 * Return OK or FAIL.
7811 */
7812 static int
7824 {
7830 /*
7831 * Get the arguments.
7832 */
7835 {
7840 {
7843 }
7847 }
7850 else
7857 {
7860 else
7862 }
7869 }
7872 /*
7873 * Call a function with its resolved parameters
7874 * Return OK when the function can't be called, FAIL otherwise.
7875 * Also returns OK when an error was encountered while executing the function.
7876 */
7877 static int
7885 PLUS ONE elements! */
7891 {
7893 #define ERROR_UNKNOWN 0
7894 #define ERROR_TOOMANY 1
7895 #define ERROR_TOOFEW 2
7896 #define ERROR_SCRIPT 3
7897 #define ERROR_DICT 4
7898 #define ERROR_NONE 5
7899 #define ERROR_OTHER 6
7905 #define FLEN_FIXED 40
7909 /*
7910 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7911 * Change <SNR>123_name() to K_SNR 123_name().
7912 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7913 */
7918 {
7924 {
7927 else
7928 {
7931 }
7932 }
7934 {
7937 }
7938 else
7939 {
7943 else
7944 {
7947 }
7948 }
7949 }
7950 else
7956 /* execute the function if no errors detected and executing */
7958 {
7963 {
7964 /*
7965 * User defined function.
7966 */
7969 #ifdef FEAT_AUTOCMD
7970 /* Trigger FuncUndefined event, may load the function. */
7975 {
7976 /* executed an autocommand, search for the function again */
7978 }
7979 #endif
7980 /* Try loading a package. */
7982 {
7983 /* loaded a package, search for the function again */
7985 }
7988 {
7997 else
7998 {
7999 /*
8000 * Call the user function.
8001 * Save and restore search patterns, script variables and
8002 * redo buffer.
8003 */
8012 /* Function was unreferenced while being used, free it
8013 * now. */
8018 }
8019 }
8020 }
8021 else
8022 {
8023 /*
8024 * Find the function name in the table, call its implementation.
8025 */
8028 {
8033 else
8034 {
8038 }
8039 }
8040 }
8041 /*
8042 * The function call (or "FuncUndefined" autocommand sequence) might
8043 * have been aborted by an error, an interrupt, or an explicitly thrown
8044 * exception that has not been caught so far. This situation can be
8045 * tested for by calling aborting(). For an error in an internal
8046 * function or for the "E132" error in call_user_func(), however, the
8047 * throw point at which the "force_abort" flag (temporarily reset by
8048 * emsg()) is normally updated has not been reached yet. We need to
8049 * update that flag first to make aborting() reliable.
8050 */
8052 }
8056 /*
8057 * Report an error unless the argument evaluation or function call has been
8058 * cancelled due to an aborting error, an interrupt, or an exception.
8059 */
8061 {
8063 {
8072 name);
8076 name);
8080 name);
8082 }
8083 }
8090 }
8092 /*
8093 * Give an error message with a function name. Handle <SNR> things.
8094 */
8095 static void
8099 {
8104 else
8109 }
8111 /*
8112 * Return TRUE for a non-zero Number and a non-empty String.
8113 */
8114 static int
8117 {
8123 }
8125 /*********************************************
8126 * Implementation of the built-in functions
8127 */
8129 #ifdef FEAT_FLOAT
8130 /*
8131 * "abs(expr)" function
8132 */
8133 static void
8137 {
8139 {
8142 }
8143 else
8144 {
8145 varnumber_T n;
8153 else
8155 }
8156 }
8157 #endif
8159 /*
8160 * "add(list, item)" function
8161 */
8162 static void
8166 {
8171 {
8176 }
8177 else
8179 }
8181 /*
8182 * "append(lnum, string/list)" function
8183 */
8184 static void
8188 {
8200 {
8202 {
8207 }
8210 {
8215 else
8219 {
8222 }
8228 }
8233 }
8234 else
8236 }
8238 /*
8239 * "argc()" function
8240 */
8241 /* ARGSUSED */
8242 static void
8246 {
8248 }
8250 /*
8251 * "argidx()" function
8252 */
8253 /* ARGSUSED */
8254 static void
8258 {
8260 }
8262 /*
8263 * "argv(nr)" function
8264 */
8265 static void
8269 {
8273 {
8277 else
8280 }
8285 }
8287 #ifdef FEAT_FLOAT
8290 /*
8291 * Get the float value of "argvars[0]" into "f".
8292 * Returns FAIL when the argument is not a Number or Float.
8293 */
8294 static int
8298 {
8300 {
8303 }
8305 {
8308 }
8311 }
8313 /*
8314 * "atan()" function
8315 */
8316 static void
8320 {
8321 float_T f;
8326 else
8328 }
8329 #endif
8331 /*
8332 * "browse(save, title, initdir, default)" function
8333 */
8334 /* ARGSUSED */
8335 static void
8339 {
8340 #ifdef FEAT_BROWSE
8356 else
8360 #else
8362 #endif
8364 }
8366 /*
8367 * "browsedir(title, initdir)" function
8368 */
8369 /* ARGSUSED */
8370 static void
8374 {
8375 #ifdef FEAT_BROWSE
8385 else
8388 #else
8390 #endif
8392 }
8396 /*
8397 * Find a buffer by number or exact name.
8398 */
8402 {
8408 {
8411 {
8412 /* No full path name match, try a match with a URL or a "nofile"
8413 * buffer, these don't use the full path. */
8417 #ifdef FEAT_QUICKFIX
8419 #endif
8420 )
8423 }
8424 }
8426 }
8428 /*
8429 * "bufexists(expr)" function
8430 */
8431 static void
8435 {
8437 }
8439 /*
8440 * "buflisted(expr)" function
8441 */
8442 static void
8446 {
8451 }
8453 /*
8454 * "bufloaded(expr)" function
8455 */
8456 static void
8460 {
8465 }
8469 /*
8470 * Get buffer by number or pattern.
8471 */
8475 {
8490 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8502 /* If not found, try expanding the name, like done for bufexists(). */
8507 }
8509 /*
8510 * "bufname(expr)" function
8511 */
8512 static void
8516 {
8525 else
8528 }
8530 /*
8531 * "bufnr(expr)" function
8532 */
8533 static void
8537 {
8547 /* If the buffer isn't found and the second argument is not zero create a
8548 * new buffer. */
8552 && !error
8559 else
8561 }
8563 /*
8564 * "bufwinnr(nr)" function
8565 */
8566 static void
8570 {
8571 #ifdef FEAT_WINDOWS
8574 #endif
8580 #ifdef FEAT_WINDOWS
8582 {
8586 }
8588 #else
8590 #endif
8592 }
8594 /*
8595 * "byte2line(byte)" function
8596 */
8597 /*ARGSUSED*/
8598 static void
8602 {
8603 #ifndef FEAT_BYTEOFF
8605 #else
8611 else
8614 #endif
8615 }
8617 /*
8618 * "byteidx()" function
8619 */
8620 /*ARGSUSED*/
8621 static void
8625 {
8626 #ifdef FEAT_MBYTE
8628 #endif
8638 #ifdef FEAT_MBYTE
8641 {
8645 }
8647 #else
8650 #endif
8651 }
8653 /*
8654 * "call(func, arglist)" function
8655 */
8656 static void
8660 {
8670 {
8673 }
8679 else
8685 {
8687 {
8690 }
8692 }
8696 {
8698 {
8701 }
8702 /* Make a copy of each argument. This is needed to be able to set
8703 * v_lock to VAR_FIXED in the copy without changing the original list.
8704 */
8706 }
8713 /* Free the arguments. */
8716 }
8718 #ifdef FEAT_FLOAT
8719 /*
8720 * "ceil({float})" function
8721 */
8722 static void
8726 {
8727 float_T f;
8732 else
8734 }
8735 #endif
8737 /*
8738 * "changenr()" function
8739 */
8740 /*ARGSUSED*/
8741 static void
8745 {
8747 }
8749 /*
8750 * "char2nr(string)" function
8751 */
8752 static void
8756 {
8757 #ifdef FEAT_MBYTE
8760 else
8761 #endif
8763 }
8765 /*
8766 * "cindent(lnum)" function
8767 */
8768 static void
8772 {
8773 #ifdef FEAT_CINDENT
8774 pos_T pos;
8775 linenr_T lnum;
8780 {
8784 }
8785 else
8786 #endif
8788 }
8790 /*
8791 * "clearmatches()" function
8792 */
8793 /*ARGSUSED*/
8794 static void
8798 {
8799 #ifdef FEAT_SEARCH_EXTRA
8801 #endif
8802 }
8804 /*
8805 * "col(string)" function
8806 */
8807 static void
8811 {
8818 {
8820 {
8821 /* '> can be MAXCOL, get the length of the line then */
8824 else
8826 }
8827 else
8828 {
8830 #ifdef FEAT_VIRTUALEDIT
8831 /* col(".") when the cursor is on the NUL at the end of the line
8832 * because of "coladd" can be seen as an extra column. */
8834 {
8839 {
8840 # ifdef FEAT_MBYTE
8845 # else
8848 # endif
8849 }
8850 }
8851 #endif
8852 }
8853 }
8855 }
8857 #if defined(FEAT_INS_EXPAND)
8858 /*
8859 * "complete()" function
8860 */
8861 /*ARGSUSED*/
8862 static void
8866 {
8870 {
8873 }
8875 /* Check for undo allowed here, because if something was already inserted
8876 * the line was already saved for undo and this check isn't done. */
8881 {
8884 }
8891 }
8893 /*
8894 * "complete_add()" function
8895 */
8896 /*ARGSUSED*/
8897 static void
8901 {
8903 }
8905 /*
8906 * "complete_check()" function
8907 */
8908 /*ARGSUSED*/
8909 static void
8913 {
8920 }
8921 #endif
8923 /*
8924 * "confirm(message, buttons[, default [, type]])" function
8925 */
8926 /*ARGSUSED*/
8927 static void
8931 {
8932 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8946 {
8951 {
8954 {
8958 else
8959 {
8961 {
8967 }
8968 }
8969 }
8970 }
8971 }
8978 else
8981 #else
8983 #endif
8984 }
8986 /*
8987 * "copy()" function
8988 */
8989 static void
8993 {
8995 }
8997 #ifdef FEAT_FLOAT
8998 /*
8999 * "cos()" function
9000 */
9001 static void
9005 {
9006 float_T f;
9011 else
9013 }
9014 #endif
9016 /*
9017 * "count()" function
9018 */
9019 static void
9023 {
9028 {
9034 {
9037 {
9042 {
9045 {
9049 }
9050 }
9053 }
9058 }
9059 }
9061 {
9067 {
9071 {
9075 }
9079 {
9081 {
9085 }
9086 }
9087 }
9088 }
9089 else
9092 }
9094 /*
9095 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
9096 *
9097 * Checks the existence of a cscope connection.
9098 */
9099 /*ARGSUSED*/
9100 static void
9104 {
9105 #ifdef FEAT_CSCOPE
9113 {
9118 }
9121 #else
9123 #endif
9124 }
9126 /*
9127 * "cursor(lnum, col)" function
9128 *
9129 * Moves the cursor to the specified line and column
9130 */
9131 /*ARGSUSED*/
9132 static void
9136 {
9138 #ifdef FEAT_VIRTUALEDIT
9140 #endif
9143 {
9144 pos_T pos;
9150 #ifdef FEAT_VIRTUALEDIT
9152 #endif
9153 }
9154 else
9155 {
9158 #ifdef FEAT_VIRTUALEDIT
9161 #endif
9162 }
9164 #ifdef FEAT_VIRTUALEDIT
9166 #endif
9167 )
9173 #ifdef FEAT_VIRTUALEDIT
9175 #endif
9177 /* Make sure the cursor is in a valid position. */
9179 #ifdef FEAT_MBYTE
9180 /* Correct cursor for multi-byte character. */
9183 #endif
9186 }
9188 /*
9189 * "deepcopy()" function
9190 */
9191 static void
9195 {
9202 else
9204 }
9206 /*
9207 * "delete()" function
9208 */
9209 static void
9213 {
9216 else
9218 }
9220 /*
9221 * "did_filetype()" function
9222 */
9223 /*ARGSUSED*/
9224 static void
9228 {
9229 #ifdef FEAT_AUTOCMD
9231 #else
9233 #endif
9234 }
9236 /*
9237 * "diff_filler()" function
9238 */
9239 /*ARGSUSED*/
9240 static void
9244 {
9245 #ifdef FEAT_DIFF
9247 #endif
9248 }
9250 /*
9251 * "diff_hlID()" function
9252 */
9253 /*ARGSUSED*/
9254 static void
9258 {
9259 #ifdef FEAT_DIFF
9275 {
9276 /* New line, buffer, change: need to get the values. */
9279 {
9281 {
9286 else
9288 }
9289 else
9291 }
9292 else
9297 }
9300 {
9304 else
9306 }
9308 #endif
9309 }
9311 /*
9312 * "empty({expr})" function
9313 */
9314 static void
9318 {
9322 {
9331 #ifdef FEAT_FLOAT
9335 #endif
9347 }
9350 }
9352 /*
9353 * "escape({string}, {chars})" function
9354 */
9355 static void
9359 {
9365 }
9367 /*
9368 * "eval()" function
9369 */
9370 /*ARGSUSED*/
9371 static void
9375 {
9383 {
9386 }
9389 }
9391 /*
9392 * "eventhandler()" function
9393 */
9394 /*ARGSUSED*/
9395 static void
9399 {
9401 }
9403 /*
9404 * "executable()" function
9405 */
9406 static void
9410 {
9412 }
9414 /*
9415 * "exists()" function
9416 */
9417 static void
9421 {
9429 {
9430 /* first try "normal" environment variables (fast) */
9433 else
9434 {
9435 /* try expanding things like $VIM and ${HOME} */
9440 }
9441 }
9443 {
9447 }
9449 {
9451 }
9453 {
9455 }
9457 {
9458 #ifdef FEAT_AUTOCMD
9461 else
9463 #endif
9464 }
9466 {
9468 typval_T tv;
9470 /* get_name_len() takes care of expanding curly braces */
9474 {
9479 {
9480 /* handle d.key, l[idx], f(expr) */
9484 }
9485 }
9490 }
9493 }
9495 /*
9496 * "expand()" function
9497 */
9498 static void
9502 {
9507 expand_T xpc;
9513 {
9517 }
9518 else
9519 {
9520 /* When the optional second argument is non-zero, don't remove matches
9521 * for 'suffixes' and 'wildignore' */
9526 {
9530 }
9531 else
9533 }
9534 }
9536 /*
9537 * "extend(list, list [, idx])" function
9538 * "extend(dict, dict [, action])" function
9539 */
9540 static void
9544 {
9547 {
9557 {
9559 {
9566 else
9567 {
9570 {
9573 }
9574 }
9575 }
9576 else
9581 }
9582 }
9584 {
9596 {
9597 /* Check the third argument. */
9599 {
9609 {
9612 }
9613 }
9614 else
9617 /* Go over all entries in the second dict and add them to the
9618 * first dict. */
9621 {
9623 {
9627 {
9631 }
9633 {
9636 }
9638 {
9641 }
9642 }
9643 }
9646 }
9647 }
9648 else
9650 }
9652 /*
9653 * "feedkeys()" function
9654 */
9655 /*ARGSUSED*/
9656 static void
9660 {
9667 /* This is not allowed in the sandbox. If the commands would still be
9668 * executed in the sandbox it would be OK, but it probably happens later,
9669 * when "sandbox" is no longer set. */
9676 {
9678 {
9681 {
9683 {
9687 }
9688 }
9689 }
9691 /* Need to escape K_SPECIAL and CSI before putting the string in the
9692 * typeahead buffer. */
9695 {
9701 }
9702 }
9703 }
9705 /*
9706 * "filereadable()" function
9707 */
9708 static void
9712 {
9717 #ifndef O_NONBLOCK
9718 # define O_NONBLOCK 0
9719 #endif
9723 {
9726 }
9727 else
9731 }
9733 /*
9734 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9735 * rights to write into.
9736 */
9737 static void
9741 {
9743 }
9747 static void
9752 {
9753 #ifdef FEAT_SEARCHPATH
9762 #endif
9767 #ifdef FEAT_SEARCHPATH
9771 {
9775 else
9776 {
9782 }
9783 }
9789 {
9790 do
9791 {
9797 find_what,
9799 find_what == FINDFILE_DIR
9807 }
9811 #endif
9812 }
9817 /*
9818 * Implementation of map() and filter().
9819 */
9820 static void
9825 {
9834 typval_T save_val;
9835 typval_T save_key;
9843 {
9847 }
9849 {
9853 }
9854 else
9855 {
9858 }
9861 /* On type errors, the preceding call has already displayed an error
9862 * message. Avoid a misleading error message for an empty string that
9863 * was not passed as argument. */
9865 {
9869 /* We reset "did_emsg" to be able to detect whether an error
9870 * occurred during evaluation of the expression. */
9875 {
9883 {
9885 {
9897 }
9898 }
9902 }
9903 else
9904 {
9906 {
9915 }
9916 }
9921 }
9924 }
9926 static int
9932 {
9933 typval_T rettv;
9942 {
9945 }
9947 {
9948 /* map(): replace the list item value */
9952 }
9953 else
9954 {
9957 /* filter(): when expr is zero remove the item */
9960 /* On type error, nothing has been removed; return FAIL to stop the
9961 * loop. The error message was given by get_tv_number_chk(). */
9964 }
9966 theend:
9969 }
9971 /*
9972 * "filter()" function
9973 */
9974 static void
9978 {
9980 }
9982 /*
9983 * "finddir({fname}[, {path}[, {count}]])" function
9984 */
9985 static void
9989 {
9991 }
9993 /*
9994 * "findfile({fname}[, {path}[, {count}]])" function
9995 */
9996 static void
10000 {
10002 }
10004 #ifdef FEAT_FLOAT
10005 /*
10006 * "float2nr({float})" function
10007 */
10008 static void
10012 {
10013 float_T f;
10016 {
10021 else
10023 }
10024 else
10026 }
10028 /*
10029 * "floor({float})" function
10030 */
10031 static void
10035 {
10036 float_T f;
10041 else
10043 }
10044 #endif
10046 /*
10047 * "fnameescape({string})" function
10048 */
10049 static void
10053 {
10057 }
10059 /*
10060 * "fnamemodify({fname}, {mods})" function
10061 */
10062 static void
10066 {
10078 else
10079 {
10082 }
10087 else
10090 }
10094 /*
10095 * "foldclosed()" function
10096 */
10097 static void
10102 {
10103 #ifdef FEAT_FOLDING
10104 linenr_T lnum;
10109 {
10111 {
10114 else
10117 }
10118 }
10119 #endif
10121 }
10123 /*
10124 * "foldclosed()" function
10125 */
10126 static void
10130 {
10132 }
10134 /*
10135 * "foldclosedend()" function
10136 */
10137 static void
10141 {
10143 }
10145 /*
10146 * "foldlevel()" function
10147 */
10148 static void
10152 {
10153 #ifdef FEAT_FOLDING
10154 linenr_T lnum;
10159 else
10160 #endif
10162 }
10164 /*
10165 * "foldtext()" function
10166 */
10167 /*ARGSUSED*/
10168 static void
10172 {
10173 #ifdef FEAT_FOLDING
10174 linenr_T lnum;
10179 #endif
10183 #ifdef FEAT_FOLDING
10188 {
10189 /* Find first non-empty line in the fold. */
10192 {
10196 }
10198 /* Find interesting text in this line. */
10200 /* skip C comment-start */
10202 {
10206 {
10210 }
10211 }
10218 {
10224 /* remove 'foldmarker' and 'commentstring' */
10227 }
10228 }
10229 #endif
10230 }
10232 /*
10233 * "foldtextresult(lnum)" function
10234 */
10235 /*ARGSUSED*/
10236 static void
10240 {
10241 #ifdef FEAT_FOLDING
10242 linenr_T lnum;
10245 foldinfo_T foldinfo;
10247 #endif
10251 #ifdef FEAT_FOLDING
10253 /* treat illegal types and illegal string values for {lnum} the same */
10258 {
10264 }
10265 #endif
10266 }
10268 /*
10269 * "foreground()" function
10270 */
10271 /*ARGSUSED*/
10272 static void
10276 {
10278 #ifdef FEAT_GUI
10281 #else
10282 # ifdef WIN32
10284 # endif
10285 #endif
10286 }
10288 /*
10289 * "function()" function
10290 */
10291 /*ARGSUSED*/
10292 static void
10296 {
10305 else
10306 {
10309 }
10310 }
10312 /*
10313 * "garbagecollect()" function
10314 */
10315 /*ARGSUSED*/
10316 static void
10320 {
10321 /* This is postponed until we are back at the toplevel, because we may be
10322 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
10327 }
10329 /*
10330 * "get()" function
10331 */
10332 static void
10336 {
10344 {
10346 {
10352 }
10353 }
10355 {
10357 {
10361 }
10362 }
10363 else
10367 {
10370 else
10372 }
10373 else
10375 }
10377 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
10379 /*
10380 * Get line or list of lines from buffer "buf" into "rettv".
10381 * Return a range (from start to end) of lines in rettv from the specified
10382 * buffer.
10383 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
10384 */
10385 static void
10388 linenr_T start;
10389 linenr_T end;
10392 {
10396 {
10399 }
10400 else
10407 {
10410 else
10415 }
10416 else
10417 {
10429 }
10430 }
10432 /*
10433 * "getbufline()" function
10434 */
10435 static void
10439 {
10440 linenr_T lnum;
10441 linenr_T end;
10452 else
10456 }
10458 /*
10459 * "getbufvar()" function
10460 */
10461 static void
10465 {
10480 {
10481 /* set curbuf to be our buf, temporarily */
10487 else
10488 {
10490 /* let getbufvar({nr}, "") return the "b:" dictionary. The
10491 * scope prefix before the NUL byte is required by
10492 * find_var_in_ht(). */
10494 /* look up the variable */
10498 }
10500 /* restore previous notion of curbuf */
10502 }
10505 }
10507 /*
10508 * "getchar()" function
10509 */
10510 static void
10514 {
10515 varnumber_T n;
10518 /* Position the cursor. Needed after a message that ends in a space. */
10524 {
10526 /* getchar(): blocking wait. */
10529 /* getchar(1): only check if char avail */
10532 /* illegal argument or getchar(0) and no char avail: return zero */
10534 else
10535 /* getchar(0) and char avail: return char */
10540 }
10550 {
10554 /* Turn a special key into three bytes, plus modifier. */
10556 {
10560 }
10562 {
10566 }
10567 #ifdef FEAT_MBYTE
10570 #endif
10571 else
10577 #ifdef FEAT_MOUSE
10597 {
10601 linenr_T lnum;
10602 # ifdef FEAT_WINDOWS
10604 # endif
10608 {
10609 /* Find the window at the mouse coordinates and compute the
10610 * text position. */
10613 # ifdef FEAT_WINDOWS
10616 # endif
10620 }
10621 }
10622 #endif
10623 }
10624 }
10626 /*
10627 * "getcharmod()" function
10628 */
10629 /*ARGSUSED*/
10630 static void
10634 {
10636 }
10638 /*
10639 * "getcmdline()" function
10640 */
10641 /*ARGSUSED*/
10642 static void
10646 {
10649 }
10651 /*
10652 * "getcmdpos()" function
10653 */
10654 /*ARGSUSED*/
10655 static void
10659 {
10661 }
10663 /*
10664 * "getcmdtype()" function
10665 */
10666 /*ARGSUSED*/
10667 static void
10671 {
10675 {
10678 }
10679 }
10681 /*
10682 * "getcwd()" function
10683 */
10684 /*ARGSUSED*/
10685 static void
10689 {
10695 else
10696 {
10698 #ifdef BACKSLASH_IN_FILENAME
10701 #endif
10702 }
10703 }
10705 /*
10706 * "getfontname()" function
10707 */
10708 /*ARGSUSED*/
10709 static void
10713 {
10716 #ifdef FEAT_GUI
10718 {
10719 GuiFont font;
10723 {
10724 /* Get the "Normal" font. Either the name saved by
10725 * hl_set_font_name() or from the font ID. */
10728 }
10729 else
10730 {
10737 }
10741 }
10742 #endif
10743 }
10745 /*
10746 * "getfperm({fname})" function
10747 */
10748 static void
10752 {
10763 {
10766 {
10768 {
10771 }
10772 }
10773 }
10775 }
10777 /*
10778 * "getfsize({fname})" function
10779 */
10780 static void
10784 {
10793 {
10796 else
10797 {
10800 /* non-perfect check for overflow */
10803 }
10804 }
10805 else
10807 }
10809 /*
10810 * "getftime({fname})" function
10811 */
10812 static void
10816 {
10824 else
10826 }
10828 /*
10829 * "getftype({fname})" function
10830 */
10831 static void
10835 {
10845 {
10846 #ifdef S_ISREG
10851 # ifdef S_ISLNK
10854 # endif
10855 # ifdef S_ISBLK
10858 # endif
10859 # ifdef S_ISCHR
10862 # endif
10863 # ifdef S_ISFIFO
10866 # endif
10867 # ifdef S_ISSOCK
10870 # endif
10871 else
10873 #else
10874 # ifdef S_IFMT
10876 {
10879 # ifdef S_IFLNK
10881 # endif
10882 # ifdef S_IFBLK
10884 # endif
10885 # ifdef S_IFCHR
10887 # endif
10888 # ifdef S_IFIFO
10890 # endif
10891 # ifdef S_IFSOCK
10893 # endif
10895 }
10896 # else
10899 else
10901 # endif
10902 #endif
10904 }
10906 }
10908 /*
10909 * "getline(lnum, [end])" function
10910 */
10911 static void
10915 {
10916 linenr_T lnum;
10917 linenr_T end;
10922 {
10925 }
10926 else
10927 {
10930 }
10933 }
10935 /*
10936 * "getmatches()" function
10937 */
10938 /*ARGSUSED*/
10939 static void
10943 {
10944 #ifdef FEAT_SEARCH_EXTRA
10951 {
10953 {
10963 }
10964 }
10965 #endif
10966 }
10968 /*
10969 * "getpid()" function
10970 */
10971 /*ARGSUSED*/
10972 static void
10976 {
10978 }
10980 /*
10981 * "getpos(string)" function
10982 */
10983 static void
10987 {
10993 {
10998 else
11006 #ifdef FEAT_VIRTUALEDIT
11008 #endif
11010 }
11011 else
11013 }
11015 /*
11016 * "getqflist()" and "getloclist()" functions
11017 */
11018 /*ARGSUSED*/
11019 static void
11023 {
11024 #ifdef FEAT_QUICKFIX
11026 #endif
11029 #ifdef FEAT_QUICKFIX
11031 {
11034 {
11038 }
11041 }
11042 #endif
11043 }
11045 /*
11046 * "getreg()" function
11047 */
11048 static void
11052 {
11059 {
11064 }
11065 else
11074 }
11076 /*
11077 * "getregtype()" function
11078 */
11079 static void
11083 {
11090 {
11093 {
11097 }
11098 }
11099 else
11100 /* Default to v:register */
11110 {
11113 #ifdef FEAT_VISUAL
11118 #endif
11119 }
11122 }
11124 /*
11125 * "gettabwinvar()" function
11126 */
11127 static void
11131 {
11133 }
11135 /*
11136 * "getwinposx()" function
11137 */
11138 /*ARGSUSED*/
11139 static void
11143 {
11145 #ifdef FEAT_GUI
11147 {
11152 }
11153 #endif
11154 }
11156 /*
11157 * "getwinposy()" function
11158 */
11159 /*ARGSUSED*/
11160 static void
11164 {
11166 #ifdef FEAT_GUI
11168 {
11173 }
11174 #endif
11175 }
11177 /*
11178 * Find window specified by "vp" in tabpage "tp".
11179 */
11184 {
11185 #ifdef FEAT_WINDOWS
11187 #endif
11192 #ifdef FEAT_WINDOWS
11203 #else
11207 #endif
11208 }
11210 /*
11211 * "getwinvar()" function
11212 */
11213 static void
11217 {
11219 }
11221 /*
11222 * getwinvar() and gettabwinvar()
11223 */
11224 static void
11229 {
11235 #ifdef FEAT_WINDOWS
11238 else
11240 #endif
11249 {
11250 /* Set curwin to be our win, temporarily. Also set curbuf, so
11251 * that we can get buffer-local options. */
11258 else
11259 {
11261 /* let getwinvar({nr}, "") return the "w:" dictionary. The
11262 * scope prefix before the NUL byte is required by
11263 * find_var_in_ht(). */
11265 /* look up the variable */
11269 }
11271 /* restore previous notion of curwin */
11274 }
11277 }
11279 /*
11280 * "glob()" function
11281 */
11282 static void
11286 {
11287 expand_T xpc;
11294 }
11296 /*
11297 * "globpath()" function
11298 */
11299 static void
11303 {
11310 else
11312 }
11314 /*
11315 * "has()" function
11316 */
11317 static void
11321 {
11326 {
11327 #ifdef AMIGA
11329 # ifdef FEAT_ARP
11331 # endif
11332 #endif
11333 #ifdef __BEOS__
11335 #endif
11336 #ifdef MSDOS
11337 # ifdef DJGPP
11339 # else
11341 # endif
11342 #endif
11343 #ifdef MACOS
11345 #endif
11346 #if defined(MACOS_X_UNIX)
11348 #endif
11349 #ifdef OS2
11351 #endif
11352 #ifdef __QNX__
11354 #endif
11355 #ifdef RISCOS
11357 #endif
11358 #ifdef UNIX
11360 #endif
11361 #ifdef VMS
11363 #endif
11364 #ifdef WIN16
11366 #endif
11367 #ifdef WIN32
11369 #endif
11370 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
11372 #endif
11373 #ifdef WIN64
11375 #endif
11376 #ifdef EBCDIC
11378 #endif
11379 #ifndef CASE_INSENSITIVE_FILENAME
11381 #endif
11382 #ifdef FEAT_ARABIC
11384 #endif
11385 #ifdef FEAT_AUTOCMD
11387 #endif
11388 #ifdef FEAT_BEVAL
11392 # endif
11393 #endif
11394 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
11396 # ifdef ALL_BUILTIN_TCAPS
11398 # endif
11399 #endif
11400 #ifdef FEAT_BYTEOFF
11402 #endif
11403 #ifdef FEAT_CINDENT
11405 #endif
11406 #ifdef FEAT_CLIENTSERVER
11408 #endif
11409 #ifdef FEAT_CLIPBOARD
11411 #endif
11412 #ifdef FEAT_CMDL_COMPL
11414 #endif
11415 #ifdef FEAT_CMDHIST
11417 #endif
11418 #ifdef FEAT_COMMENTS
11420 #endif
11421 #ifdef FEAT_CRYPT
11423 #endif
11424 #ifdef FEAT_CSCOPE
11426 #endif
11427 #ifdef CURSOR_SHAPE
11429 #endif
11430 #ifdef DEBUG
11432 #endif
11433 #ifdef FEAT_CON_DIALOG
11435 #endif
11436 #ifdef FEAT_GUI_DIALOG
11438 #endif
11439 #ifdef FEAT_DIFF
11441 #endif
11442 #ifdef FEAT_DIGRAPHS
11444 #endif
11445 #ifdef FEAT_DND
11447 #endif
11448 #ifdef FEAT_EMACS_TAGS
11450 #endif
11452 #ifdef FEAT_EX_EXTRA
11454 #endif
11455 #ifdef FEAT_SEARCH_EXTRA
11457 #endif
11458 #ifdef FEAT_FKMAP
11460 #endif
11461 #ifdef FEAT_SEARCHPATH
11463 #endif
11464 #if defined(UNIX) && !defined(USE_SYSTEM)
11466 #endif
11467 #ifdef FEAT_FIND_ID
11469 #endif
11470 #ifdef FEAT_FLOAT
11472 #endif
11473 #ifdef FEAT_FOLDING
11475 #endif
11476 #ifdef FEAT_FOOTER
11478 #endif
11479 #if !defined(USE_SYSTEM) && defined(UNIX)
11481 #endif
11482 #ifdef FEAT_FULLSCREEN
11484 #endif
11485 #ifdef FEAT_GETTEXT
11487 #endif
11488 #ifdef FEAT_GUI
11490 #endif
11491 #ifdef FEAT_GUI_ATHENA
11492 # ifdef FEAT_GUI_NEXTAW
11494 # else
11496 # endif
11497 #endif
11498 #ifdef FEAT_GUI_GTK
11500 # ifdef HAVE_GTK2
11502 # endif
11503 #endif
11504 #ifdef FEAT_GUI_GNOME
11506 #endif
11507 #ifdef FEAT_GUI_MAC
11509 #endif
11510 #ifdef FEAT_GUI_MACVIM
11512 #endif
11513 #ifdef FEAT_GUI_MOTIF
11515 #endif
11516 #ifdef FEAT_GUI_PHOTON
11518 #endif
11519 #ifdef FEAT_GUI_W16
11521 #endif
11522 #ifdef FEAT_GUI_W32
11524 #endif
11525 #ifdef FEAT_HANGULIN
11527 #endif
11528 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11530 #endif
11531 #ifdef FEAT_INS_EXPAND
11533 #endif
11534 #ifdef FEAT_JUMPLIST
11536 #endif
11537 #ifdef FEAT_KEYMAP
11539 #endif
11540 #ifdef FEAT_LANGMAP
11542 #endif
11543 #ifdef FEAT_LIBCALL
11545 #endif
11546 #ifdef FEAT_LINEBREAK
11548 #endif
11549 #ifdef FEAT_LISP
11551 #endif
11552 #ifdef FEAT_LISTCMDS
11554 #endif
11555 #ifdef FEAT_LOCALMAP
11557 #endif
11558 #ifdef FEAT_MENU
11560 #endif
11561 #ifdef FEAT_SESSION
11563 #endif
11564 #ifdef FEAT_MODIFY_FNAME
11566 #endif
11567 #ifdef FEAT_MOUSE
11569 #endif
11570 #ifdef FEAT_MOUSESHAPE
11572 #endif
11573 #if defined(UNIX) || defined(VMS)
11574 # ifdef FEAT_MOUSE_DEC
11576 # endif
11577 # ifdef FEAT_MOUSE_GPM
11579 # endif
11580 # ifdef FEAT_MOUSE_JSB
11582 # endif
11583 # ifdef FEAT_MOUSE_NET
11585 # endif
11586 # ifdef FEAT_MOUSE_PTERM
11588 # endif
11589 # ifdef FEAT_SYSMOUSE
11591 # endif
11592 # ifdef FEAT_MOUSE_XTERM
11594 # endif
11595 #endif
11596 #ifdef FEAT_MBYTE
11598 #endif
11599 #ifdef FEAT_MBYTE_IME
11601 #endif
11602 #ifdef FEAT_MULTI_LANG
11604 #endif
11605 #ifdef FEAT_MZSCHEME
11606 #ifndef DYNAMIC_MZSCHEME
11608 #endif
11609 #endif
11610 #ifdef FEAT_OLE
11612 #endif
11613 #ifdef FEAT_OSFILETYPE
11615 #endif
11616 #ifdef FEAT_PATH_EXTRA
11618 #endif
11619 #ifdef FEAT_PERL
11620 #ifndef DYNAMIC_PERL
11622 #endif
11623 #endif
11624 #ifdef FEAT_PYTHON
11625 #ifndef DYNAMIC_PYTHON
11627 #endif
11628 #endif
11629 #ifdef FEAT_POSTSCRIPT
11631 #endif
11632 #ifdef FEAT_PRINTER
11634 #endif
11635 #ifdef FEAT_PROFILE
11637 #endif
11638 #ifdef FEAT_RELTIME
11640 #endif
11641 #ifdef FEAT_QUICKFIX
11643 #endif
11644 #ifdef FEAT_RIGHTLEFT
11646 #endif
11647 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11649 #endif
11650 #ifdef FEAT_SCROLLBIND
11652 #endif
11653 #ifdef FEAT_CMDL_INFO
11656 #endif
11657 #ifdef FEAT_SIGNS
11659 #endif
11660 #ifdef FEAT_SMARTINDENT
11662 #endif
11663 #ifdef FEAT_SNIFF
11665 #endif
11666 #ifdef FEAT_STL_OPT
11668 #endif
11669 #ifdef FEAT_SUN_WORKSHOP
11671 #endif
11672 #ifdef FEAT_NETBEANS_INTG
11674 #endif
11675 #ifdef FEAT_ODB_EDITOR
11677 #endif
11678 #ifdef FEAT_SPELL
11680 #endif
11681 #ifdef FEAT_SYN_HL
11683 #endif
11684 #if defined(USE_SYSTEM) || !defined(UNIX)
11686 #endif
11687 #ifdef FEAT_TAG_BINS
11689 #endif
11690 #ifdef FEAT_TAG_OLDSTATIC
11692 #endif
11693 #ifdef FEAT_TAG_ANYWHITE
11695 #endif
11696 #ifdef FEAT_TCL
11697 # ifndef DYNAMIC_TCL
11699 # endif
11700 #endif
11701 #ifdef TERMINFO
11703 #endif
11704 #ifdef FEAT_TERMRESPONSE
11706 #endif
11707 #ifdef FEAT_TEXTOBJ
11709 #endif
11710 #ifdef HAVE_TGETENT
11712 #endif
11713 #ifdef FEAT_TITLE
11715 #endif
11716 #ifdef FEAT_TOOLBAR
11718 #endif
11719 #ifdef FEAT_TRANSPARENCY
11721 #endif
11722 #ifdef FEAT_USR_CMDS
11725 #endif
11726 #ifdef FEAT_VIMINFO
11728 #endif
11729 #ifdef FEAT_VERTSPLIT
11731 #endif
11732 #ifdef FEAT_VIRTUALEDIT
11734 #endif
11735 #ifdef FEAT_VISUAL
11737 #endif
11738 #ifdef FEAT_VISUALEXTRA
11740 #endif
11741 #ifdef FEAT_VREPLACE
11743 #endif
11744 #ifdef FEAT_WILDIGN
11746 #endif
11747 #ifdef FEAT_WILDMENU
11749 #endif
11750 #ifdef FEAT_WINDOWS
11752 #endif
11753 #ifdef FEAT_WAK
11755 #endif
11756 #ifdef FEAT_WRITEBACKUP
11758 #endif
11759 #ifdef FEAT_XIM
11761 #endif
11762 #ifdef FEAT_XFONTSET
11764 #endif
11765 #ifdef USE_XSMP
11767 #endif
11768 #ifdef USE_XSMP_INTERACT
11770 #endif
11771 #ifdef FEAT_XCLIPBOARD
11773 #endif
11774 #ifdef FEAT_XTERM_SAVE
11776 #endif
11777 #if defined(UNIX) && defined(FEAT_X11)
11779 #endif
11780 NULL
11781 };
11786 {
11789 }
11792 {
11797 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11800 #endif
11801 #ifdef DYNAMIC_TCL
11804 #endif
11805 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11808 #endif
11809 #ifdef DYNAMIC_MZSCHEME
11812 #endif
11813 #ifdef DYNAMIC_RUBY
11816 #endif
11817 #ifdef DYNAMIC_PYTHON
11820 #endif
11821 #ifdef DYNAMIC_PERL
11824 #endif
11825 #ifdef FEAT_GUI
11828 # ifdef FEAT_GUI_W32
11831 # endif
11832 # ifdef FEAT_BROWSE
11835 # endif
11836 #endif
11837 #ifdef FEAT_SYN_HL
11840 #endif
11841 #if defined(WIN3264)
11844 #endif
11845 #ifdef FEAT_NETBEANS_INTG
11848 #endif
11849 }
11852 }
11854 /*
11855 * "has_key()" function
11856 */
11857 static void
11861 {
11864 {
11867 }
11873 }
11875 /*
11876 * "haslocaldir()" function
11877 */
11878 /*ARGSUSED*/
11879 static void
11883 {
11885 }
11887 /*
11888 * "hasmapto()" function
11889 */
11890 static void
11894 {
11903 else
11904 {
11908 }
11912 else
11914 }
11916 /*
11917 * "histadd()" function
11918 */
11919 /*ARGSUSED*/
11920 static void
11924 {
11925 #ifdef FEAT_CMDHIST
11929 #endif
11934 #ifdef FEAT_CMDHIST
11938 {
11941 {
11945 }
11946 }
11947 #endif
11948 }
11950 /*
11951 * "histdel()" function
11952 */
11953 /*ARGSUSED*/
11954 static void
11958 {
11959 #ifdef FEAT_CMDHIST
11968 /* only one argument: clear entire history */
11971 /* index given: remove that entry */
11974 else
11975 /* string given: remove all matching entries */
11979 #else
11981 #endif
11982 }
11984 /*
11985 * "histget()" function
11986 */
11987 /*ARGSUSED*/
11988 static void
11992 {
11993 #ifdef FEAT_CMDHIST
12001 else
12002 {
12006 else
12008 /* -1 on type error */
12010 }
12011 #else
12013 #endif
12015 }
12017 /*
12018 * "histnr()" function
12019 */
12020 /*ARGSUSED*/
12021 static void
12025 {
12028 #ifdef FEAT_CMDHIST
12034 else
12035 #endif
12038 }
12040 /*
12041 * "highlightID(name)" function
12042 */
12043 static void
12047 {
12049 }
12051 /*
12052 * "highlight_exists()" function
12053 */
12054 static void
12058 {
12060 }
12062 /*
12063 * "hostname()" function
12064 */
12065 /*ARGSUSED*/
12066 static void
12070 {
12076 }
12078 /*
12079 * iconv() function
12080 */
12081 /*ARGSUSED*/
12082 static void
12086 {
12087 #ifdef FEAT_MBYTE
12091 vimconv_T vimconv;
12092 #endif
12097 #ifdef FEAT_MBYTE
12104 /* If the encodings are equal, no conversion needed. */
12107 else
12113 #endif
12114 }
12116 /*
12117 * "indent()" function
12118 */
12119 static void
12123 {
12124 linenr_T lnum;
12129 else
12131 }
12133 /*
12134 * "index()" function
12135 */
12136 static void
12140 {
12148 {
12151 }
12154 {
12157 {
12160 /* Start at specified item. Use the cached index that list_find()
12161 * sets, so that a negative number also works. */
12168 }
12172 {
12175 }
12176 }
12177 }
12183 /*
12184 * This function is used by f_input() and f_inputdialog() functions. The third
12185 * argument to f_input() specifies the type of completion to use at the
12186 * prompt. The third argument to f_inputdialog() specifies the value to return
12187 * when the user cancels the prompt.
12188 */
12189 static void
12194 {
12207 #ifdef NO_CONSOLE_INPUT
12208 /* While starting up, there is no place to enter text. */
12211 #endif
12215 {
12216 /* Only the part of the message after the last NL is considered as
12217 * prompt for the command line */
12221 else
12222 {
12232 }
12236 {
12242 {
12258 }
12259 }
12268 /* since the user typed this, no need to wait for return */
12271 }
12273 }
12275 /*
12276 * "input()" function
12277 * Also handles inputsecret() when inputsecret is set.
12278 */
12279 static void
12283 {
12285 }
12287 /*
12288 * "inputdialog()" function
12289 */
12290 static void
12294 {
12295 #if defined(FEAT_GUI_TEXTDIALOG)
12296 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12298 {
12307 else
12313 else
12314 {
12320 else
12322 }
12324 }
12325 else
12326 #endif
12328 }
12330 /*
12331 * "inputlist()" function
12332 */
12333 static void
12337 {
12343 #ifdef NO_CONSOLE_INPUT
12344 /* While starting up, there is no place to enter text. */
12347 #endif
12349 {
12352 }
12361 {
12364 }
12366 /* Ask for choice. */
12372 }
12377 /*
12378 * "inputrestore()" function
12379 */
12380 /*ARGSUSED*/
12381 static void
12385 {
12387 {
12392 }
12394 {
12397 }
12398 }
12400 /*
12401 * "inputsave()" function
12402 */
12403 /*ARGSUSED*/
12404 static void
12408 {
12409 /* Add an entry to the stack of typeahead storage. */
12411 {
12416 }
12417 else
12419 }
12421 /*
12422 * "inputsecret()" function
12423 */
12424 static void
12428 {
12434 }
12436 /*
12437 * "insert()" function
12438 */
12439 static void
12443 {
12454 {
12462 else
12463 {
12466 {
12469 }
12470 }
12472 {
12475 }
12476 }
12477 }
12479 /*
12480 * "isdirectory()" function
12481 */
12482 static void
12486 {
12488 }
12490 /*
12491 * "islocked()" function
12492 */
12493 static void
12497 {
12498 lval_T lv;
12504 FNE_CHECK_START);
12506 {
12509 else
12510 {
12512 {
12515 else
12516 {
12519 {
12520 /* Consider a variable locked when:
12521 * 1. the variable itself is locked
12522 * 2. the value of the variable is locked.
12523 * 3. the List or Dict value is locked.
12524 */
12527 }
12528 }
12529 }
12535 /* List item. */
12537 else
12538 /* Dictionary item. */
12540 }
12541 }
12544 }
12548 /*
12549 * Turn a dict into a list:
12550 * "what" == 0: list of keys
12551 * "what" == 1: list of values
12552 * "what" == 2: list of items
12553 */
12554 static void
12559 {
12570 {
12573 }
12582 {
12584 {
12594 {
12595 /* keys() */
12599 }
12601 {
12602 /* values() */
12604 }
12605 else
12606 {
12607 /* items() */
12629 }
12630 }
12631 }
12632 }
12634 /*
12635 * "items(dict)" function
12636 */
12637 static void
12641 {
12643 }
12645 /*
12646 * "join()" function
12647 */
12648 static void
12652 {
12653 garray_T ga;
12658 {
12661 }
12666 else
12672 {
12677 }
12678 else
12680 }
12682 /*
12683 * "keys()" function
12684 */
12685 static void
12689 {
12691 }
12693 /*
12694 * "last_buffer_nr()" function.
12695 */
12696 /*ARGSUSED*/
12697 static void
12701 {
12710 }
12712 /*
12713 * "len()" function
12714 */
12715 static void
12719 {
12721 {
12736 }
12737 }
12741 static void
12746 {
12747 #ifdef FEAT_LIBCALL
12751 #endif
12756 else
12762 #ifdef FEAT_LIBCALL
12763 /* The first two args must be strings, otherwise its meaningless */
12765 {
12771 else
12775 string_in,
12777 string_result,
12781 }
12782 #endif
12783 }
12785 /*
12786 * "libcall()" function
12787 */
12788 static void
12792 {
12794 }
12796 /*
12797 * "libcallnr()" function
12798 */
12799 static void
12803 {
12805 }
12807 /*
12808 * "line(string)" function
12809 */
12810 static void
12814 {
12823 }
12825 /*
12826 * "line2byte(lnum)" function
12827 */
12828 /*ARGSUSED*/
12829 static void
12833 {
12834 #ifndef FEAT_BYTEOFF
12836 #else
12837 linenr_T lnum;
12842 else
12846 #endif
12847 }
12849 /*
12850 * "lispindent(lnum)" function
12851 */
12852 static void
12856 {
12857 #ifdef FEAT_LISP
12858 pos_T pos;
12859 linenr_T lnum;
12864 {
12868 }
12869 else
12870 #endif
12872 }
12874 /*
12875 * "localtime()" function
12876 */
12877 /*ARGSUSED*/
12878 static void
12882 {
12884 }
12888 static void
12893 {
12900 garray_T ga;
12903 /* return empty string for failure */
12912 {
12916 }
12917 else
12928 {
12938 }
12939 }
12941 #ifdef FEAT_FLOAT
12942 /*
12943 * "log10()" function
12944 */
12945 static void
12949 {
12950 float_T f;
12955 else
12957 }
12958 #endif
12960 /*
12961 * "map()" function
12962 */
12963 static void
12967 {
12969 }
12971 /*
12972 * "maparg()" function
12973 */
12974 static void
12978 {
12980 }
12982 /*
12983 * "mapcheck()" function
12984 */
12985 static void
12989 {
12991 }
12995 static void
13000 {
13004 regmatch_T regmatch;
13017 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
13023 {
13024 /* return empty list when there are no matches */
13027 }
13029 {
13032 }
13035 {
13039 }
13040 else
13048 {
13055 {
13060 }
13061 else
13062 {
13067 /* When "count" argument is there ignore matches before "start",
13068 * otherwise skip part of the string. Differs when pattern is "^"
13069 * or "\<". */
13072 else
13074 }
13080 }
13084 {
13088 {
13090 {
13092 {
13095 }
13100 }
13109 /* Advance to just after the match. */
13111 {
13114 }
13115 else
13116 {
13117 #ifdef FEAT_MBYTE
13120 #else
13122 #endif
13123 }
13124 }
13127 {
13129 {
13132 /* return list with matched string and submatches */
13134 {
13136 {
13140 }
13146 }
13147 }
13149 {
13150 /* return matched string */
13153 else
13156 }
13159 else
13160 {
13164 else
13168 }
13169 }
13171 }
13173 theend:
13176 }
13178 /*
13179 * "match()" function
13180 */
13181 static void
13185 {
13187 }
13189 /*
13190 * "matchadd()" function
13191 */
13192 static void
13196 {
13197 #ifdef FEAT_SEARCH_EXTRA
13210 {
13214 }
13218 {
13221 }
13224 #endif
13225 }
13227 /*
13228 * "matcharg()" function
13229 */
13230 static void
13234 {
13236 {
13237 #ifdef FEAT_SEARCH_EXTRA
13242 {
13244 {
13248 }
13249 else
13250 {
13253 }
13254 }
13255 #endif
13256 }
13257 }
13259 /*
13260 * "matchdelete()" function
13261 */
13262 static void
13266 {
13267 #ifdef FEAT_SEARCH_EXTRA
13270 #endif
13271 }
13273 /*
13274 * "matchend()" function
13275 */
13276 static void
13280 {
13282 }
13284 /*
13285 * "matchlist()" function
13286 */
13287 static void
13291 {
13293 }
13295 /*
13296 * "matchstr()" function
13297 */
13298 static void
13302 {
13304 }
13308 static void
13313 {
13319 {
13325 {
13328 {
13331 {
13338 }
13339 }
13340 }
13341 }
13343 {
13351 {
13354 {
13356 {
13360 {
13363 }
13366 }
13367 }
13368 }
13369 }
13370 else
13373 }
13375 /*
13376 * "max()" function
13377 */
13378 static void
13382 {
13384 }
13386 /*
13387 * "min()" function
13388 */
13389 static void
13393 {
13395 }
13399 /*
13400 * Create the directory in which "dir" is located, and higher levels when
13401 * needed.
13402 */
13403 static int
13407 {
13412 /* Get end of directory name in "dir".
13413 * We're done when it's "/" or "c:/". */
13418 /* If the directory exists we're done. Otherwise: create it.*/
13428 }
13430 #ifdef vim_mkdir
13431 /*
13432 * "mkdir()" function
13433 */
13434 static void
13438 {
13449 {
13454 }
13456 }
13457 #endif
13459 /*
13460 * "mode()" function
13461 */
13462 /*ARGSUSED*/
13463 static void
13467 {
13473 #ifdef FEAT_VISUAL
13475 {
13478 else
13480 }
13481 else
13482 #endif
13485 {
13491 }
13495 {
13496 #ifdef FEAT_VREPLACE
13498 {
13501 }
13502 else
13503 #endif
13506 else
13508 }
13510 {
13514 }
13516 {
13519 }
13520 else
13521 {
13525 }
13527 /* Clear out the minor mode when the argument is not a non-zero number or
13528 * non-empty string. */
13534 }
13536 /*
13537 * "nextnonblank()" function
13538 */
13539 static void
13543 {
13544 linenr_T lnum;
13547 {
13549 {
13552 }
13555 }
13557 }
13559 /*
13560 * "nr2char()" function
13561 */
13562 static void
13566 {
13569 #ifdef FEAT_MBYTE
13572 else
13573 #endif
13574 {
13577 }
13580 }
13582 /*
13583 * "pathshorten()" function
13584 */
13585 static void
13589 {
13596 else
13597 {
13602 }
13603 }
13605 #ifdef FEAT_FLOAT
13606 /*
13607 * "pow()" function
13608 */
13609 static void
13613 {
13620 else
13622 }
13623 #endif
13625 /*
13626 * "prevnonblank()" function
13627 */
13628 static void
13632 {
13633 linenr_T lnum;
13638 else
13642 }
13644 #ifdef HAVE_STDARG_H
13645 /* This dummy va_list is here because:
13646 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13647 * - locally in the function results in a "used before set" warning
13648 * - using va_start() to initialize it gives "function with fixed args" error */
13650 #endif
13652 /*
13653 * "printf()" function
13654 */
13655 static void
13659 {
13663 {
13670 /* Get the required length, allocate the buffer and do it for real. */
13675 {
13678 {
13681 }
13682 }
13684 }
13685 #endif
13686 }
13688 /*
13689 * "pumvisible()" function
13690 */
13691 /*ARGSUSED*/
13692 static void
13696 {
13698 #ifdef FEAT_INS_EXPAND
13701 #endif
13702 }
13704 /*
13705 * "range()" function
13706 */
13707 static void
13711 {
13720 {
13723 }
13724 else
13725 {
13729 }
13738 else
13739 {
13745 }
13746 }
13748 /*
13749 * "readfile()" function
13750 */
13751 static void
13755 {
13775 {
13780 }
13785 /* Always open the file in binary mode, library functions have a mind of
13786 * their own about CR-LF conversion. */
13789 {
13792 }
13796 {
13801 {
13803 {
13804 /* Only when in binary mode add an empty list item when the
13805 * last line ends in a '\n'. */
13809 /* Found end-of-line or end-of-file: add a text line to the
13810 * list. */
13819 else
13820 {
13823 {
13829 }
13830 }
13835 {
13838 }
13848 }
13851 }
13856 {
13857 /* "buf" is full, need to move text to an allocated buffer */
13859 {
13862 }
13863 else
13864 {
13867 {
13873 }
13874 }
13876 }
13877 else
13878 {
13881 }
13882 }
13884 /*
13885 * For a negative line count use only the lines at the end of the file,
13886 * free the rest.
13887 */
13890 {
13893 }
13897 }
13899 #if defined(FEAT_RELTIME)
13902 /*
13903 * Convert a List to proftime_T.
13904 * Return FAIL when there is something wrong.
13905 */
13906 static int
13910 {
13919 # ifdef WIN3264
13922 # else
13925 # endif
13927 }
13930 /*
13931 * "reltime()" function
13932 */
13933 static void
13937 {
13938 #ifdef FEAT_RELTIME
13939 proftime_T res;
13940 proftime_T start;
13943 {
13944 /* No arguments: get current time. */
13946 }
13948 {
13952 }
13953 else
13954 {
13955 /* Two arguments: compute the difference. */
13960 }
13963 {
13966 # ifdef WIN3264
13969 # else
13972 # endif
13975 }
13976 #endif
13977 }
13979 /*
13980 * "reltimestr()" function
13981 */
13982 static void
13986 {
13987 #ifdef FEAT_RELTIME
13988 proftime_T tm;
13989 #endif
13993 #ifdef FEAT_RELTIME
13996 #endif
13997 }
13999 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
14003 static void
14005 {
14007 # ifdef FEAT_GUI
14009 # endif
14010 )
14011 {
14015 }
14016 }
14018 static int
14020 {
14023 {
14026 }
14028 }
14029 #endif
14031 #ifdef FEAT_CLIENTSERVER
14034 static void
14039 {
14044 # ifdef WIN32
14045 HWND w;
14046 # elif defined(FEAT_X11)
14047 Window w;
14048 # elif defined(MAC_CLIENTSERVER)
14050 # endif
14055 # ifdef FEAT_X11
14058 # endif
14064 # ifdef WIN32
14066 # elif defined(FEAT_X11)
14069 # elif defined(MAC_CLIENTSERVER)
14071 # endif
14072 {
14075 else
14078 }
14083 {
14084 dictitem_T v;
14095 }
14096 }
14097 #endif
14099 /*
14100 * "remote_expr()" function
14101 */
14102 /*ARGSUSED*/
14103 static void
14107 {
14110 #ifdef FEAT_CLIENTSERVER
14112 #endif
14113 }
14115 /*
14116 * "remote_foreground()" function
14117 */
14118 /*ARGSUSED*/
14119 static void
14123 {
14125 #ifdef FEAT_CLIENTSERVER
14126 # ifdef WIN32
14127 /* On Win32 it's done in this application. */
14128 {
14133 }
14134 # elif defined(FEAT_X11) || defined(MAC_CLIENTSERVER)
14135 /* Send a foreground() expression to the server. */
14141 # endif
14142 #endif
14143 }
14145 /*ARGSUSED*/
14146 static void
14150 {
14151 #ifdef FEAT_CLIENTSERVER
14152 dictitem_T v;
14154 # ifdef WIN32
14156 # endif
14160 {
14163 }
14166 {
14169 }
14170 # ifdef WIN32
14174 else
14175 {
14178 }
14179 # elif defined(FEAT_X11)
14186 # elif defined(MAC_CLIENTSERVER)
14188 # endif
14191 {
14200 }
14201 #else
14203 #endif
14204 }
14206 /*ARGSUSED*/
14207 static void
14211 {
14214 #ifdef FEAT_CLIENTSERVER
14218 {
14219 # ifdef WIN32
14220 /* The server's HWND is encoded in the 'id' parameter */
14227 # elif defined(FEAT_X11)
14230 # elif defined(MAC_CLIENTSERVER)
14232 # endif
14234 }
14235 #endif
14238 }
14240 /*
14241 * "remote_send()" function
14242 */
14243 /*ARGSUSED*/
14244 static void
14248 {
14251 #ifdef FEAT_CLIENTSERVER
14253 #endif
14254 }
14256 /*
14257 * "remove()" function
14258 */
14259 static void
14263 {
14275 {
14280 {
14283 {
14287 else
14288 {
14292 }
14293 }
14294 }
14295 }
14300 {
14308 else
14309 {
14311 {
14312 /* Remove one item, return its value. */
14316 }
14317 else
14318 {
14319 /* Remove range of items, return list with values. */
14325 else
14326 {
14330 {
14334 }
14337 else
14338 {
14341 {
14348 }
14349 }
14350 }
14351 }
14352 }
14353 }
14354 }
14356 /*
14357 * "rename({from}, {to})" function
14358 */
14359 static void
14363 {
14368 else
14371 }
14373 /*
14374 * "repeat()" function
14375 */
14376 /*ARGSUSED*/
14377 static void
14381 {
14391 {
14397 }
14398 else
14399 {
14411 {
14415 }
14418 }
14419 }
14421 /*
14422 * "resolve()" function
14423 */
14424 static void
14428 {
14432 #ifdef FEAT_SHORTCUT
14433 {
14439 else
14441 }
14442 #else
14443 # ifdef HAVE_READLINK
14444 {
14466 {
14467 /* Separate the first path component in "p", and keep the
14468 * remainder (beginning with the path separator). */
14471 }
14474 {
14476 {
14483 {
14489 }
14491 /* Ensure that the result will have a trailing path separator
14492 * if the argument has one. */
14496 /* Separate the first path component in the link value and
14497 * concatenate the remainders. */
14500 {
14503 else
14504 {
14507 {
14510 }
14511 }
14513 }
14517 {
14518 /* Ignore trailing path separator. */
14521 }
14523 {
14524 /* symlink is relative to directory of argument */
14527 {
14532 }
14533 }
14534 else
14535 {
14538 }
14539 }
14544 /* Append the first path component of "remain" to "p". */
14549 {
14553 }
14554 /* Shorten "remain". */
14557 else
14558 {
14561 }
14562 }
14564 /* If the result is a relative path name, make it explicitly relative to
14565 * the current directory if and only if the argument had this form. */
14567 {
14576 {
14577 /* Prepend "./". */
14580 {
14583 }
14584 }
14586 {
14587 /* Strip leading "./". */
14593 }
14594 }
14596 /* Ensure that the result will have no trailing path separator
14597 * if the argument had none. But keep "/" or "//". */
14599 {
14603 }
14606 }
14607 # else
14609 # endif
14610 #endif
14614 #ifdef HAVE_READLINK
14615 fail:
14616 #endif
14618 }
14620 /*
14621 * "reverse({list})" function
14622 */
14623 static void
14627 {
14636 {
14641 {
14645 }
14650 }
14651 }
14663 /*
14664 * Get flags for a search function.
14665 * Possibly sets "p_ws".
14666 * Returns BACKWARD, FORWARD or zero (for an error).
14667 */
14668 static int
14672 {
14679 {
14684 {
14686 {
14693 {
14701 }
14703 {
14706 }
14707 else
14709 }
14713 }
14714 }
14716 }
14718 /*
14719 * Shared by search() and searchpos() functions
14720 */
14721 static int
14726 {
14729 pos_T pos;
14730 pos_T save_cursor;
14735 proftime_T tm;
14736 #ifdef FEAT_RELTIME
14738 #endif
14752 /* Optional arguments: line number to stop searching and timeout. */
14754 {
14758 #ifdef FEAT_RELTIME
14760 {
14764 }
14765 #endif
14766 }
14768 #ifdef FEAT_RELTIME
14769 /* Set the time limit, if there is one. */
14771 #endif
14773 /*
14774 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14775 * Check to make sure only those flags are set.
14776 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14777 * flags cannot be set. Check for that condition also.
14778 */
14781 {
14784 }
14790 {
14793 else
14799 {
14800 /* Store the match cursor position */
14803 }
14804 /* "/$" will put the cursor after the end of the line, may need to
14805 * correct that here */
14807 }
14809 /* If 'n' flag is used: restore cursor position. */
14812 else
14814 theend:
14818 }
14820 #ifdef FEAT_FLOAT
14821 /*
14822 * "round({float})" function
14823 */
14824 static void
14828 {
14829 float_T f;
14833 /* round() is not in C90, use ceil() or floor() instead. */
14835 else
14837 }
14838 #endif
14840 /*
14841 * "search()" function
14842 */
14843 static void
14847 {
14851 }
14853 /*
14854 * "searchdecl()" function
14855 */
14856 static void
14860 {
14870 {
14874 }
14878 }
14880 /*
14881 * Used by searchpair() and searchpairpos()
14882 */
14883 static int
14887 {
14900 /* Get the three pattern arguments: start, middle, end. */
14907 /* Handle the optional fourth argument: flags */
14912 /* Don't accept SP_END or SP_SUBPAT.
14913 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14914 */
14917 {
14920 }
14922 /* Using 'r' implies 'W', otherwise it doesn't work. */
14926 /* Optional fifth argument: skip expression */
14930 else
14931 {
14934 {
14938 #ifdef FEAT_RELTIME
14940 {
14944 }
14945 #endif
14946 }
14947 }
14954 theend:
14958 }
14960 /*
14961 * "searchpair()" function
14962 */
14963 static void
14967 {
14969 }
14971 /*
14972 * "searchpairpos()" function
14973 */
14974 static void
14978 {
14979 pos_T match_pos;
14989 {
14992 }
14996 }
14998 /*
14999 * Search for a start/middle/end thing.
15000 * Used by searchpair(), see its documentation for the details.
15001 * Returns 0 or -1 for no match,
15002 */
15003 long
15015 {
15019 pos_T pos;
15020 pos_T firstpos;
15021 pos_T foundpos;
15022 pos_T save_cursor;
15023 pos_T save_pos;
15029 proftime_T tm;
15031 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15035 #ifdef FEAT_RELTIME
15036 /* Set the time limit, if there is one. */
15038 #endif
15040 /* Make two search patterns: start/end (pat2, for in nested pairs) and
15041 * start/middle/end (pat3, for the top pair). */
15049 else
15061 {
15065 /* didn't find it or found the first match again: FAIL */
15071 {
15072 /* Found the same position again. Can happen with a pattern that
15073 * has "\zs" at the end and searching backwards. Advance one
15074 * character and try again. */
15077 else
15079 }
15082 /* clear the start flag to avoid getting stuck here */
15085 /* If the skip pattern matches, ignore this match. */
15087 {
15093 {
15094 /* Evaluating {skip} caused an error, break here. */
15098 }
15101 }
15104 {
15105 /* Found end when searching backwards or start when searching
15106 * forward: nested pair. */
15109 }
15110 else
15111 {
15112 /* Found end when searching forward or start when searching
15113 * backward: end of (nested) pair; or found middle in outer pair. */
15116 }
15119 {
15120 /* Found the match: return matchcount or line number. */
15123 else
15131 }
15132 }
15135 {
15136 /* Store the match cursor position */
15139 }
15141 /* If 'n' flag is used or search failed: restore cursor position. */
15145 theend:
15150 else
15151 /* Darn, evaluating the {skip} expression changed the value. */
15155 }
15157 /*
15158 * "searchpos()" function
15159 */
15160 static void
15164 {
15165 pos_T match_pos;
15178 {
15181 }
15187 }
15190 /*ARGSUSED*/
15191 static void
15195 {
15196 #ifdef FEAT_CLIENTSERVER
15206 # ifdef FEAT_X11
15209 # endif
15212 {
15215 }
15217 #else
15219 #endif
15220 }
15222 /*ARGSUSED*/
15223 static void
15227 {
15230 #ifdef FEAT_CLIENTSERVER
15231 # if defined(WIN32) || defined(MAC_CLIENTSERVER)
15233 # elif defined(FEAT_X11)
15237 # endif
15238 #endif
15241 }
15243 /*
15244 * "setbufvar()" function
15245 */
15246 /*ARGSUSED*/
15247 static void
15251 {
15253 aco_save_T aco;
15268 {
15269 /* set curbuf to be our buf, temporarily */
15273 {
15283 }
15284 else
15285 {
15288 {
15293 }
15294 }
15296 /* reset notion of buffer */
15298 }
15299 }
15301 /*
15302 * "setcmdpos()" function
15303 */
15304 static void
15308 {
15313 }
15315 /*
15316 * "setline()" function
15317 */
15318 static void
15322 {
15323 linenr_T lnum;
15332 {
15335 }
15336 else
15341 {
15343 {
15344 /* list argument, get next string */
15349 }
15355 {
15356 /* existing line, replace it */
15358 {
15363 }
15364 }
15366 {
15367 /* lnum is one past the last line, append the line */
15371 }
15376 }
15380 }
15382 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15384 /*
15385 * Used by "setqflist()" and "setloclist()" functions
15386 */
15387 /*ARGSUSED*/
15388 static void
15394 {
15395 #ifdef FEAT_QUICKFIX
15398 #endif
15402 #ifdef FEAT_QUICKFIX
15405 else
15406 {
15410 {
15416 }
15420 }
15421 #endif
15422 }
15424 /*
15425 * "setloclist()" function
15426 */
15427 /*ARGSUSED*/
15428 static void
15432 {
15440 }
15442 /*
15443 * "setmatches()" function
15444 */
15445 static void
15449 {
15450 #ifdef FEAT_SEARCH_EXTRA
15457 {
15460 }
15462 {
15464 /* To some extent make sure that we are dealing with a list from
15465 * "getmatches()". */
15468 {
15471 {
15474 }
15479 {
15482 }
15484 }
15489 {
15496 }
15498 }
15499 #endif
15500 }
15502 /*
15503 * "setpos()" function
15504 */
15505 /*ARGSUSED*/
15506 static void
15510 {
15511 pos_T pos;
15518 {
15520 {
15523 {
15524 /* set cursor */
15526 {
15530 }
15531 else
15533 }
15535 {
15536 /* set mark */
15539 }
15540 else
15542 }
15543 }
15544 }
15546 /*
15547 * "setqflist()" function
15548 */
15549 /*ARGSUSED*/
15550 static void
15554 {
15556 }
15558 /*
15559 * "setreg()" function
15560 */
15561 static void
15565 {
15571 char_u yank_type;
15590 {
15596 {
15606 #ifdef FEAT_VISUAL
15610 {
15614 }
15616 #endif
15617 }
15618 }
15625 }
15627 /*
15628 * "settabwinvar()" function
15629 */
15630 static void
15634 {
15636 }
15638 /*
15639 * "setwinvar()" function
15640 */
15641 static void
15645 {
15647 }
15649 /*
15650 * "setwinvar()" and "settabwinvar()" functions
15651 */
15652 static void
15657 {
15659 #ifdef FEAT_WINDOWS
15662 #endif
15673 #ifdef FEAT_WINDOWS
15676 else
15678 #endif
15684 {
15685 #ifdef FEAT_WINDOWS
15686 /* set curwin to be our win, temporarily */
15694 #endif
15697 {
15707 }
15708 else
15709 {
15712 {
15717 }
15718 }
15720 #ifdef FEAT_WINDOWS
15721 /* Restore current tabpage and window, if still valid (autocomands can
15722 * make them invalid). */
15726 {
15729 }
15730 #endif
15731 }
15732 }
15734 /*
15735 * "shellescape({string})" function
15736 */
15737 static void
15741 {
15745 }
15747 /*
15748 * "simplify()" function
15749 */
15750 static void
15754 {
15761 }
15763 #ifdef FEAT_FLOAT
15764 /*
15765 * "sin()" function
15766 */
15767 static void
15771 {
15772 float_T f;
15777 else
15779 }
15780 #endif
15782 static int
15783 #ifdef __BORLANDC__
15784 _RTLENTRYF
15785 #endif
15787 static int
15788 #ifdef __BORLANDC__
15789 _RTLENTRYF
15790 #endif
15796 #define ITEM_COMPARE_FAIL 999
15798 /*
15799 * Compare functions for f_sort() below.
15800 */
15801 static int
15802 #ifdef __BORLANDC__
15803 _RTLENTRYF
15804 #endif
15808 {
15823 else
15828 }
15830 static int
15831 #ifdef __BORLANDC__
15832 _RTLENTRYF
15833 #endif
15837 {
15839 typval_T rettv;
15843 /* shortcut after failure in previous call; compare all items equal */
15847 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15848 * in the copy without changing the original list items. */
15860 else
15861 /* return value has wrong type */
15867 }
15869 /*
15870 * "sort({list})" function
15871 */
15872 static void
15876 {
15886 else
15887 {
15902 {
15905 else
15906 {
15914 else
15916 }
15917 }
15919 /* Make an array with each entry pointing to an item in the List. */
15928 /* test the compare function */
15933 else
15934 {
15935 /* Sort the array with item pointers. */
15940 {
15941 /* Clear the List and append the items in the sorted order. */
15946 }
15947 }
15950 }
15951 }
15953 /*
15954 * "soundfold({word})" function
15955 */
15956 static void
15960 {
15965 #ifdef FEAT_SPELL
15967 #else
15969 #endif
15970 }
15972 /*
15973 * "spellbadword()" function
15974 */
15975 /* ARGSUSED */
15976 static void
15980 {
15988 #ifdef FEAT_SPELL
15990 {
15991 /* Find the start and length of the badly spelled word. */
15995 }
15997 {
16002 {
16003 /* Check the argument for spelling. */
16005 {
16008 {
16011 }
16013 }
16014 }
16015 }
16016 #endif
16025 }
16027 /*
16028 * "spellsuggest()" function
16029 */
16030 /*ARGSUSED*/
16031 static void
16035 {
16036 #ifdef FEAT_SPELL
16040 garray_T ga;
16044 #endif
16049 #ifdef FEAT_SPELL
16051 {
16054 {
16059 {
16063 }
16064 }
16065 else
16071 {
16077 else
16078 {
16083 }
16084 }
16086 }
16087 #endif
16088 }
16090 static void
16094 {
16098 regmatch_T regmatch;
16106 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16112 {
16118 }
16129 {
16132 {
16135 else
16139 else
16143 {
16147 }
16150 /* Advance to just after the match. */
16153 else
16154 {
16155 /* Don't get stuck at the same match. */
16156 #ifdef FEAT_MBYTE
16158 #else
16160 #endif
16161 }
16163 }
16166 }
16169 }
16171 #ifdef FEAT_FLOAT
16172 /*
16173 * "sqrt()" function
16174 */
16175 static void
16179 {
16180 float_T f;
16185 else
16187 }
16189 /*
16190 * "str2float()" function
16191 */
16192 static void
16196 {
16203 }
16204 #endif
16206 /*
16207 * "str2nr()" function
16208 */
16209 static void
16213 {
16219 {
16222 {
16225 }
16226 }
16233 }
16235 #ifdef HAVE_STRFTIME
16236 /*
16237 * "strftime({format}[, {time}])" function
16238 */
16239 static void
16243 {
16254 else
16257 /* MSVC returns NULL for an invalid value of seconds. */
16260 else
16261 {
16262 # ifdef FEAT_MBYTE
16263 vimconv_T conv;
16271 # endif
16275 else
16278 # ifdef FEAT_MBYTE
16284 else
16285 # endif
16288 # ifdef FEAT_MBYTE
16289 /* Release conversion descriptors */
16292 # endif
16293 }
16294 }
16295 #endif
16297 /*
16298 * "stridx()" function
16299 */
16300 static void
16304 {
16319 {
16327 }
16332 }
16334 /*
16335 * "string()" function
16336 */
16337 static void
16341 {
16347 /* Make a copy if we have a value but it's not in allocated memory. */
16350 }
16352 /*
16353 * "strlen()" function
16354 */
16355 static void
16359 {
16362 }
16364 /*
16365 * "strpart()" function
16366 */
16367 static void
16371 {
16386 else
16389 /*
16390 * Only return the overlap between the specified part and the actual
16391 * string.
16392 */
16394 {
16397 }
16407 }
16409 /*
16410 * "strridx()" function
16411 */
16412 static void
16416 {
16433 {
16434 /* Third argument: upper limit for index */
16438 }
16439 else
16443 {
16444 /* Empty string matches past the end. */
16446 }
16447 else
16448 {
16450 {
16455 }
16456 }
16460 else
16462 }
16464 /*
16465 * "strtrans()" function
16466 */
16467 static void
16471 {
16474 }
16476 /*
16477 * "submatch()" function
16478 */
16479 static void
16483 {
16487 }
16489 /*
16490 * "substitute()" function
16491 */
16492 static void
16496 {
16509 else
16511 }
16513 /*
16514 * "synID(lnum, col, trans)" function
16515 */
16516 /*ARGSUSED*/
16517 static void
16521 {
16523 #ifdef FEAT_SYN_HL
16536 #endif
16539 }
16541 /*
16542 * "synIDattr(id, what [, mode])" function
16543 */
16544 /*ARGSUSED*/
16545 static void
16549 {
16551 #ifdef FEAT_SYN_HL
16561 {
16565 #ifdef FEAT_GUI
16567 #endif
16568 )
16570 }
16571 else
16572 {
16573 #ifdef FEAT_GUI
16576 else
16577 #endif
16580 else
16582 }
16586 {
16619 /* underline */
16621 else
16622 /* undercurl */
16625 }
16629 #endif
16632 }
16634 /*
16635 * "synIDtrans(id)" function
16636 */
16637 /*ARGSUSED*/
16638 static void
16642 {
16645 #ifdef FEAT_SYN_HL
16650 else
16651 #endif
16655 }
16657 /*
16658 * "synstack(lnum, col)" function
16659 */
16660 /*ARGSUSED*/
16661 static void
16665 {
16666 #ifdef FEAT_SYN_HL
16671 #endif
16676 #ifdef FEAT_SYN_HL
16683 {
16686 {
16692 }
16693 }
16694 #endif
16695 }
16697 /*
16698 * "system()" function
16699 */
16700 static void
16704 {
16716 {
16717 /*
16718 * Write the string to a temp file, to be used for input of the shell
16719 * command.
16720 */
16722 {
16725 }
16729 {
16732 }
16735 {
16738 }
16744 {
16747 }
16748 }
16753 #ifdef USE_CR
16754 /* translate <CR> into <NL> */
16756 {
16760 {
16763 }
16764 }
16765 #else
16766 # ifdef USE_CRNL
16767 /* translate <CR><NL> into <NL> */
16769 {
16774 {
16778 }
16780 }
16781 # endif
16782 #endif
16784 done:
16786 {
16789 }
16792 }
16794 /*
16795 * "tabpagebuflist()" function
16796 */
16797 /* ARGSUSED */
16798 static void
16802 {
16803 #ifndef FEAT_WINDOWS
16805 #else
16811 else
16812 {
16816 }
16819 else
16820 {
16823 else
16824 {
16829 }
16830 }
16831 #endif
16832 }
16835 /*
16836 * "tabpagenr()" function
16837 */
16838 /* ARGSUSED */
16839 static void
16843 {
16845 #ifdef FEAT_WINDOWS
16849 {
16853 {
16856 else
16858 }
16859 }
16860 else
16862 #endif
16864 }
16867 #ifdef FEAT_WINDOWS
16870 /*
16871 * Common code for tabpagewinnr() and winnr().
16872 */
16873 static int
16877 {
16885 {
16892 {
16896 }
16897 else
16898 {
16901 }
16902 }
16907 {
16909 {
16910 /* didn't find it in this tabpage */
16913 }
16915 }
16917 }
16918 #endif
16920 /*
16921 * "tabpagewinnr()" function
16922 */
16923 /* ARGSUSED */
16924 static void
16928 {
16930 #ifdef FEAT_WINDOWS
16936 else
16938 #endif
16940 }
16943 /*
16944 * "tagfiles()" function
16945 */
16946 /*ARGSUSED*/
16947 static void
16951 {
16953 tagname_T tn;
16957 {
16960 }
16967 }
16969 /*
16970 * "taglist()" function
16971 */
16972 static void
16976 {
16987 }
16989 /*
16990 * "tempname()" function
16991 */
16992 /*ARGSUSED*/
16993 static void
16997 {
17003 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
17004 * names. Skip 'I' and 'O', they are used for shell redirection. */
17005 do
17006 {
17011 else
17012 {
17013 #ifdef EBCDIC
17018 else
17019 #endif
17021 }
17023 }
17025 /*
17026 * "test(list)" function: Just checking the walls...
17027 */
17028 /*ARGSUSED*/
17029 static void
17033 {
17034 /* Used for unit testing. Change the code below to your liking. */
17035 #if 0
17054 #endif
17055 }
17057 /*
17058 * "tolower(string)" function
17059 */
17060 static void
17064 {
17073 {
17074 #ifdef FEAT_MBYTE
17078 {
17084 /* TODO: reallocate string when byte count changes. */
17088 }
17091 else
17092 #endif
17093 {
17096 }
17097 }
17098 }
17100 /*
17101 * "toupper(string)" function
17102 */
17103 static void
17107 {
17110 }
17112 /*
17113 * "tr(string, fromstr, tostr)" function
17114 */
17115 static void
17119 {
17124 #ifdef FEAT_MBYTE
17132 #endif
17135 garray_T ga;
17141 /* Default return value: empty string. */
17148 #ifdef FEAT_MBYTE
17150 #endif
17151 /* not multi-byte: fromstr and tostr must be the same length */
17153 {
17154 #ifdef FEAT_MBYTE
17155 error:
17156 #endif
17160 }
17162 /* fromstr and tostr have to contain the same number of chars */
17164 {
17165 #ifdef FEAT_MBYTE
17167 {
17173 {
17176 {
17178 {
17181 {
17185 }
17186 }
17190 }
17192 }
17195 {
17196 /* Check that fromstr and tostr have the same number of
17197 * (multi-byte) characters. Done only once when a character
17198 * of instr doesn't appear in fromstr. */
17201 {
17204 }
17207 }
17214 }
17215 else
17216 #endif
17217 {
17218 /* When not using multi-byte chars we can do it faster. */
17222 else
17225 }
17226 }
17228 /* add a terminating NUL */
17233 }
17235 #ifdef FEAT_FLOAT
17236 /*
17237 * "trunc({float})" function
17238 */
17239 static void
17243 {
17244 float_T f;
17248 /* trunc() is not in C90, use floor() or ceil() instead. */
17250 else
17252 }
17253 #endif
17255 /*
17256 * "type(expr)" function
17257 */
17258 static void
17262 {
17266 {
17272 #ifdef FEAT_FLOAT
17274 #endif
17276 }
17278 }
17280 /*
17281 * "values(dict)" function
17282 */
17283 static void
17287 {
17289 }
17291 /*
17292 * "virtcol(string)" function
17293 */
17294 static void
17298 {
17306 {
17309 }
17312 }
17314 /*
17315 * "visualmode()" function
17316 */
17317 /*ARGSUSED*/
17318 static void
17322 {
17323 #ifdef FEAT_VISUAL
17331 /* A non-zero number or non-empty string argument: reset mode. */
17334 #else
17336 #endif
17337 }
17339 /*
17340 * "winbufnr(nr)" function
17341 */
17342 static void
17346 {
17352 else
17354 }
17356 /*
17357 * "wincol()" function
17358 */
17359 /*ARGSUSED*/
17360 static void
17364 {
17367 }
17369 /*
17370 * "winheight(nr)" function
17371 */
17372 static void
17376 {
17382 else
17384 }
17386 /*
17387 * "winline()" function
17388 */
17389 /*ARGSUSED*/
17390 static void
17394 {
17397 }
17399 /*
17400 * "winnr()" function
17401 */
17402 /* ARGSUSED */
17403 static void
17407 {
17410 #ifdef FEAT_WINDOWS
17412 #endif
17414 }
17416 /*
17417 * "winrestcmd()" function
17418 */
17419 /* ARGSUSED */
17420 static void
17424 {
17425 #ifdef FEAT_WINDOWS
17428 garray_T ga;
17433 {
17436 # ifdef FEAT_VERTSPLIT
17439 # endif
17441 }
17445 #else
17447 #endif
17449 }
17451 /*
17452 * "winrestview()" function
17453 */
17454 /* ARGSUSED */
17455 static void
17459 {
17465 else
17466 {
17469 #ifdef FEAT_VIRTUALEDIT
17471 #endif
17476 #ifdef FEAT_DIFF
17478 #endif
17491 #ifdef FEAT_DIFF
17493 #endif
17494 }
17495 }
17497 /*
17498 * "winsaveview()" function
17499 */
17500 /* ARGSUSED */
17501 static void
17505 {
17517 #ifdef FEAT_VIRTUALEDIT
17519 #endif
17524 #ifdef FEAT_DIFF
17526 #endif
17529 }
17531 /*
17532 * "winwidth(nr)" function
17533 */
17534 static void
17538 {
17544 else
17545 #ifdef FEAT_VERTSPLIT
17547 #else
17549 #endif
17550 }
17552 /*
17553 * "writefile()" function
17554 */
17555 static void
17559 {
17572 {
17575 }
17583 /* Always open the file in binary mode, library functions have a mind of
17584 * their own about CR-LF conversion. */
17587 {
17590 }
17591 else
17592 {
17595 {
17597 {
17600 else
17603 {
17606 }
17607 }
17610 {
17613 }
17615 {
17618 }
17619 }
17621 }
17624 }
17626 /*
17627 * Translate a String variable into a position.
17628 * Returns NULL when there is an error.
17629 */
17635 {
17640 /* Argument can be [lnum, col, coladd]. */
17642 {
17652 /* Get the line number */
17657 /* Get the column number */
17663 /* We accept "$" for the column number: last column. */
17670 /* Accept a position up to the NUL after the line. */
17675 #ifdef FEAT_VIRTUALEDIT
17676 /* Get the virtual offset. Defaults to zero. */
17680 #endif
17683 }
17690 #ifdef FEAT_VISUAL
17692 {
17696 }
17697 #endif
17699 {
17704 }
17706 #ifdef FEAT_VIRTUALEDIT
17708 #endif
17711 {
17714 {
17718 }
17720 {
17724 }
17725 }
17727 {
17729 {
17732 }
17733 else
17734 {
17737 }
17739 }
17741 }
17743 /*
17744 * Convert list in "arg" into a position and optional file number.
17745 * When "fnump" is NULL there is no file number, only 3 items.
17746 * Note that the column is passed on as-is, the caller may want to decrement
17747 * it to use 1 for the first column.
17748 * Return FAIL when conversion is not possible, doesn't check the position for
17749 * validity.
17750 */
17751 static int
17756 {
17761 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17762 * when "fnump" isn't NULL and "coladd" is optional. */
17770 {
17777 }
17789 #ifdef FEAT_VIRTUALEDIT
17793 else
17795 #endif
17798 }
17800 /*
17801 * Get the length of an environment variable name.
17802 * Advance "arg" to the first character after the name.
17803 * Return 0 for error.
17804 */
17805 static int
17808 {
17813 ;
17820 }
17822 /*
17823 * Get the length of the name of a function or internal variable.
17824 * "arg" is advanced to the first non-white character after the name.
17825 * Return 0 if something is wrong.
17826 */
17827 static int
17830 {
17834 /* Find the end of the name. */
17836 ;
17844 }
17846 /*
17847 * Get the length of the name of a variable or function.
17848 * Only the name is recognized, does not handle ".key" or "[idx]".
17849 * "arg" is advanced to the first non-white character after the name.
17850 * Return -1 if curly braces expansion failed.
17851 * Return 0 if something else is wrong.
17852 * If the name contains 'magic' {}'s, expand them and return the
17853 * expanded name in an allocated string via 'alias' - caller must free.
17854 */
17855 static int
17861 {
17871 {
17872 /* hard coded <SNR>, already translated */
17875 }
17878 {
17879 /* literal "<SID>", "s:" or "<SNR>" */
17881 }
17883 /*
17884 * Find the end of the name; check for {} construction.
17885 */
17889 {
17893 {
17897 }
17899 /*
17900 * Include any <SID> etc in the expanded string:
17901 * Thus the -len here.
17902 */
17909 }
17916 }
17918 /*
17919 * Find the end of a variable or function name, taking care of magic braces.
17920 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17921 * start and end of the first magic braces item.
17922 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17923 * Return a pointer to just after the name. Equal to "arg" if there is no
17924 * valid name.
17925 */
17932 {
17938 {
17941 }
17943 /* Quick check for valid starting character. */
17953 {
17955 {
17956 /* skip over 'string' to avoid counting [ and ] inside it. */
17958 ;
17961 }
17963 {
17964 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17970 }
17973 {
17978 }
17981 {
17983 {
17984 mb_nest++;
17987 }
17989 {
17990 mb_nest--;
17993 }
17994 }
17995 }
17998 }
18000 /*
18001 * Expands out the 'magic' {}'s in a variable/function name.
18002 * Note that this can call itself recursively, to deal with
18003 * constructs like foo{bar}{baz}{bam}
18004 * The four pointer arguments point to "foo{expre}ss{ion}bar"
18005 * "in_start" ^
18006 * "expr_start" ^
18007 * "expr_end" ^
18008 * "in_end" ^
18009 *
18010 * Returns a new allocated string, which the caller must free.
18011 * Returns NULL for failure.
18012 */
18019 {
18020 char_u c1;
18034 {
18038 {
18042 }
18043 }
18051 {
18054 {
18055 /* Further expansion! */
18060 }
18061 }
18064 }
18066 /*
18067 * Return TRUE if character "c" can be used in a variable or function name.
18068 * Does not include '{' or '}' for magic braces.
18069 */
18070 static int
18073 {
18075 }
18077 /*
18078 * Return TRUE if character "c" can be used as the first character in a
18079 * variable or function name (excluding '{' and '}').
18080 */
18081 static int
18084 {
18086 }
18088 /*
18089 * Set number v: variable to "val".
18090 */
18091 void
18095 {
18097 }
18099 /*
18100 * Get number v: variable value.
18101 */
18102 long
18105 {
18107 }
18109 /*
18110 * Get string v: variable value. Uses a static buffer, can only be used once.
18111 */
18112 char_u *
18115 {
18117 }
18119 /*
18120 * Set v:count, v:count1 and v:prevcount.
18121 */
18122 void
18126 {
18130 }
18132 /*
18133 * Set string v: variable to a copy of "val".
18134 */
18135 void
18140 {
18141 /* Need to do this (at least) once, since we can't initialize a union.
18142 * Will always be invoked when "v:progname" is set. */
18150 else
18152 }
18154 /*
18155 * Set v:register if needed.
18156 */
18157 void
18160 {
18161 char_u regname;
18165 else
18167 /* Avoid free/alloc when the value is already right. */
18170 }
18172 /*
18173 * Get or set v:exception. If "oldval" == NULL, return the current value.
18174 * Otherwise, restore the value to "oldval" and return NULL.
18175 * Must always be called in pairs to save and restore v:exception! Does not
18176 * take care of memory allocations.
18177 */
18178 char_u *
18181 {
18187 }
18189 /*
18190 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18191 * Otherwise, restore the value to "oldval" and return NULL.
18192 * Must always be called in pairs to save and restore v:throwpoint! Does not
18193 * take care of memory allocations.
18194 */
18195 char_u *
18198 {
18204 }
18206 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18207 /*
18208 * Set v:cmdarg.
18209 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18210 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18211 * Must always be called in pairs!
18212 */
18213 char_u *
18217 {
18224 {
18228 }
18234 else
18242 # ifdef FEAT_MBYTE
18247 # endif
18257 else
18266 # ifdef FEAT_MBYTE
18273 # endif
18276 }
18277 #endif
18279 /*
18280 * Get the value of internal variable "name".
18281 * Return OK or FAIL.
18282 */
18283 static int
18289 {
18292 typval_T atv;
18296 /* truncate the name, so that we can use strcmp() */
18300 /*
18301 * Check for "b:changedtick".
18302 */
18304 {
18308 }
18310 /*
18311 * Check for user-defined variables.
18312 */
18313 else
18314 {
18318 }
18321 {
18325 }
18332 }
18334 /*
18335 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18336 * Also handle function call with Funcref variable: func(expr)
18337 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18338 */
18339 static int
18345 {
18350 typval_T functv;
18357 {
18359 {
18360 /* need to copy the funcref so that we can clear rettv */
18364 /* Invoke the function. Recursive! */
18370 /* Clear the funcref afterwards, so that deleting it while
18371 * evaluating the arguments is possible (see test55). */
18374 /* Stop the expression evaluation when immediately aborting on
18375 * error, or when an interrupt occurred or an exception was thrown
18376 * but not caught. */
18378 {
18382 }
18385 }
18387 {
18390 {
18394 }
18395 else
18398 {
18401 }
18402 }
18403 }
18406 }
18408 /*
18409 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18410 * value).
18411 */
18414 {
18416 }
18418 /*
18419 * Allocate memory for a variable type-value, and assign a string to it.
18420 * The string "s" must have been allocated, it is consumed.
18421 * Return NULL for out of memory, the variable otherwise.
18422 */
18426 {
18431 {
18434 }
18435 else
18438 }
18440 /*
18441 * Free the memory for a variable type-value.
18442 */
18443 void
18446 {
18448 {
18450 {
18453 /*FALLTHROUGH*/
18464 #ifdef FEAT_FLOAT
18466 #endif
18472 }
18474 }
18475 }
18477 /*
18478 * Free the memory for a variable value and set the value to NULL or 0.
18479 */
18480 void
18483 {
18485 {
18487 {
18490 /*FALLTHROUGH*/
18506 #ifdef FEAT_FLOAT
18510 #endif
18515 }
18517 }
18518 }
18520 /*
18521 * Set the value of a variable to NULL without freeing items.
18522 */
18523 static void
18526 {
18529 }
18531 /*
18532 * Get the number value of a variable.
18533 * If it is a String variable, uses vim_str2nr().
18534 * For incompatible types, return 0.
18535 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18536 * caller of incompatible types: it sets *denote to TRUE if "denote"
18537 * is not NULL or returns -1 otherwise.
18538 */
18539 static long
18542 {
18546 }
18548 long
18552 {
18556 {
18559 #ifdef FEAT_FLOAT
18563 #endif
18581 }
18584 else
18587 }
18589 /*
18590 * Get the lnum from the first argument.
18591 * Also accepts ".", "$", etc., but that only works for the current buffer.
18592 * Returns -1 on error.
18593 */
18594 static linenr_T
18597 {
18598 typval_T rettv;
18599 linenr_T lnum;
18603 {
18608 }
18610 }
18612 /*
18613 * Get the lnum from the first argument.
18614 * Also accepts "$", then "buf" is used.
18615 * Returns 0 on error.
18616 */
18617 static linenr_T
18621 {
18628 }
18630 /*
18631 * Get the string value of a variable.
18632 * If it is a Number variable, the number is converted into a string.
18633 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18634 * get_tv_string_buf() uses a given buffer.
18635 * If the String variable has never been set, return an empty string.
18636 * Never returns NULL;
18637 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18638 * NULL on error.
18639 */
18643 {
18647 }
18653 {
18657 }
18659 char_u *
18662 {
18666 }
18672 {
18674 {
18687 #ifdef FEAT_FLOAT
18691 #endif
18699 }
18701 }
18703 /*
18704 * Find variable "name" in the list of variables.
18705 * Return a pointer to it if found, NULL if not found.
18706 * Careful: "a:0" variables don't have a name.
18707 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18708 * hashtab_T used.
18709 */
18714 {
18724 }
18726 /*
18727 * Find variable "varname" in hashtab "ht".
18728 * Returns NULL if not found.
18729 */
18735 {
18739 {
18740 /* Must be something like "s:", otherwise "ht" would be NULL. */
18742 {
18748 #ifdef FEAT_WINDOWS
18750 #endif
18755 }
18757 }
18761 {
18762 /* For global variables we may try auto-loading the script. If it
18763 * worked find the variable again. Don't auto-load a script if it was
18764 * loaded already, otherwise it would be loaded every time when
18765 * checking if a function name is a Funcref variable. */
18771 }
18773 }
18775 /*
18776 * Find the hashtab used for a variable name.
18777 * Set "varname" to the start of name without ':'.
18778 */
18783 {
18787 {
18788 /* The name must not start with a colon or #. */
18793 /* "version" is "v:version" in all scopes */
18801 }
18805 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18806 */
18814 #ifdef FEAT_WINDOWS
18817 #endif
18828 }
18830 /*
18831 * Get the string value of a (global/local) variable.
18832 * Returns NULL when it doesn't exist.
18833 */
18834 char_u *
18837 {
18844 }
18846 /*
18847 * Allocate a new hashtab for a sourced script. It will be used while
18848 * sourcing this script and when executing functions defined in the script.
18849 */
18850 void
18852 scid_T id;
18853 {
18859 {
18860 /* Re-allocating ga_data means that an ht_array pointing to
18861 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18862 * at its init value. Also reset "v_dict", it's always the same. */
18864 {
18870 }
18873 {
18877 }
18878 }
18879 }
18881 /*
18882 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18883 * point to it.
18884 */
18885 void
18889 {
18897 }
18899 /*
18900 * Clean up a list of internal variables.
18901 * Frees all allocated variables and the value they contain.
18902 * Clears hashtab "ht", does not free it.
18903 */
18904 void
18907 {
18909 }
18911 /*
18912 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18913 */
18914 static void
18918 {
18926 {
18928 {
18931 /* Free the variable. Don't remove it from the hashtab,
18932 * ht_array might change then. hash_clear() takes care of it
18933 * later. */
18939 }
18940 }
18943 }
18945 /*
18946 * Delete a variable from hashtab "ht" at item "hi".
18947 * Clear the variable value and free the dictitem.
18948 */
18949 static void
18953 {
18959 }
18961 /*
18962 * List the value of one internal variable.
18963 */
18964 static void
18969 {
18978 }
18980 static void
18987 {
18988 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
19000 {
19004 }
19006 {
19010 }
19011 else
19019 {
19022 }
19023 }
19025 /*
19026 * Set variable "name" to value in "tv".
19027 * If the variable already exists, the value is updated.
19028 * Otherwise the variable is created.
19029 */
19030 static void
19035 {
19042 {
19046 {
19049 }
19051 {
19053 name);
19055 }
19056 }
19060 {
19063 }
19067 {
19068 /* existing variable, need to clear the value */
19077 #ifdef FEAT_FLOAT
19082 #endif
19083 )
19084 {
19087 }
19089 /*
19090 * Handle setting internal v: variables separately: we don't change
19091 * the type.
19092 */
19094 {
19096 {
19100 else
19101 {
19102 /* Take over the string to avoid an extra alloc/free. */
19105 }
19106 }
19109 else
19110 {
19114 }
19116 }
19119 }
19121 {
19122 /* Can't add "v:" variable. */
19124 {
19127 }
19129 /* Make sure the variable name is valid. */
19133 {
19136 }
19144 {
19147 }
19149 }
19153 else
19154 {
19158 }
19159 }
19161 /*
19162 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19163 * Also give an error message.
19164 */
19165 static int
19169 {
19171 {
19174 }
19176 {
19179 }
19181 }
19183 /*
19184 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19185 * Also give an error message.
19186 */
19187 static int
19191 {
19193 {
19196 }
19198 }
19200 /*
19201 * Return TRUE if typeval "tv" is set to be locked (immutable).
19202 * Also give an error message, using "name".
19203 */
19204 static int
19208 {
19210 {
19214 }
19216 {
19220 }
19222 }
19224 /*
19225 * Copy the values from typval_T "from" to typval_T "to".
19226 * When needed allocates string or increases reference count.
19227 * Does not make a copy of a list or dict but copies the reference!
19228 */
19229 static void
19233 {
19237 {
19241 #ifdef FEAT_FLOAT
19245 #endif
19250 else
19251 {
19255 }
19260 else
19261 {
19264 }
19269 else
19270 {
19273 }
19278 }
19279 }
19281 /*
19282 * Make a copy of an item.
19283 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19284 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19285 * reference to an already copied list/dict can be used.
19286 * Returns FAIL or OK.
19287 */
19288 static int
19294 {
19299 {
19302 }
19306 {
19308 #ifdef FEAT_FLOAT
19310 #endif
19321 {
19322 /* use the copy made earlier */
19325 }
19326 else
19337 {
19338 /* use the copy made earlier */
19341 }
19342 else
19350 }
19353 }
19355 /*
19356 * ":echo expr1 ..." print each argument separated with a space, add a
19357 * newline at the end.
19358 * ":echon expr1 ..." print each argument plain.
19359 */
19360 void
19363 {
19365 typval_T rettv;
19375 {
19376 /* If eval1() causes an error message the text from the command may
19377 * still need to be cleared. E.g., "echo 22,44". */
19382 {
19383 /*
19384 * Report the invalid expression unless the expression evaluation
19385 * has been cancelled due to an aborting error, an interrupt, or an
19386 * exception.
19387 */
19392 }
19396 {
19398 {
19400 /* Call msg_start() after eval1(), evaluating the expression
19401 * may cause a message to appear. */
19404 }
19410 {
19412 {
19414 {
19415 /* remove any text still there from the command */
19418 }
19420 }
19421 else
19422 {
19423 #ifdef FEAT_MBYTE
19425 {
19430 }
19431 else
19432 #endif
19434 }
19435 }
19437 }
19440 }
19445 else
19446 {
19447 /* remove text that may still be there from the command */
19452 }
19453 }
19455 /*
19456 * ":echohl {name}".
19457 */
19458 void
19461 {
19467 else
19469 }
19471 /*
19472 * ":execute expr1 ..." execute the result of an expression.
19473 * ":echomsg expr1 ..." Print a message
19474 * ":echoerr expr1 ..." Print an error
19475 * Each gets spaces around each argument and a newline at the end for
19476 * echo commands
19477 */
19478 void
19481 {
19483 typval_T rettv;
19486 garray_T ga;
19495 {
19498 {
19499 /*
19500 * Report the invalid expression unless the expression evaluation
19501 * has been cancelled due to an aborting error, an interrupt, or an
19502 * exception.
19503 */
19508 }
19511 {
19515 {
19519 }
19524 }
19528 }
19531 {
19533 {
19536 }
19538 {
19539 /* We don't want to abort following commands, restore did_emsg. */
19544 }
19548 }
19556 }
19558 /*
19559 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19560 * "arg" points to the "&" or '+' when called, to "option" when returning.
19561 * Returns NULL when no option name found. Otherwise pointer to the char
19562 * after the option name.
19563 */
19568 {
19573 {
19576 }
19578 {
19581 }
19582 else
19591 else
19595 }
19597 /*
19598 * ":function"
19599 */
19600 void
19603 {
19612 garray_T newargs;
19613 garray_T newlines;
19622 funcdict_T fudi;
19630 /*
19631 * ":function" without argument: list functions.
19632 */
19634 {
19636 {
19639 {
19641 {
19646 }
19647 }
19648 }
19651 }
19653 /*
19654 * ":function /pat": list functions matching pattern.
19655 */
19657 {
19660 {
19661 regmatch_T regmatch;
19668 {
19673 {
19675 {
19681 }
19682 }
19683 }
19684 }
19689 }
19691 /*
19692 * Get the function name. There are these situations:
19693 * func normal function name
19694 * "name" == func, "fudi.fd_dict" == NULL
19695 * dict.func new dictionary entry
19696 * "name" == NULL, "fudi.fd_dict" set,
19697 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19698 * dict.func existing dict entry with a Funcref
19699 * "name" == func, "fudi.fd_dict" set,
19700 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19701 * dict.func existing dict entry that's not a Funcref
19702 * "name" == NULL, "fudi.fd_dict" set,
19703 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19704 */
19709 {
19710 /*
19711 * Return on an invalid expression in braces, unless the expression
19712 * evaluation has been cancelled due to an aborting error, an
19713 * interrupt, or an exception.
19714 */
19716 {
19721 }
19722 else
19724 }
19726 /* An error in a function call during evaluation of an expression in magic
19727 * braces should not cause the function not to be defined. */
19731 /*
19732 * ":function func" with only function name: list function.
19733 */
19735 {
19737 {
19740 }
19745 {
19748 {
19751 {
19763 }
19765 {
19768 }
19769 }
19770 else
19772 }
19774 }
19776 /*
19777 * ":function name(arg1, arg2)" Define function.
19778 */
19781 {
19783 {
19786 }
19787 /* attempt to continue by skipping some text */
19790 }
19797 {
19798 /* Check the name of the function. Unless it's a dictionary function
19799 * (that we are overwriting). */
19802 else
19806 {
19809 else
19816 }
19817 }
19819 /*
19820 * Isolate the arguments: "arg1, arg2, ...)"
19821 */
19823 {
19825 {
19829 }
19830 else
19831 {
19838 {
19842 }
19855 else
19857 }
19860 {
19864 }
19865 }
19868 /* find extra arguments "range", "dict" and "abort" */
19870 {
19873 {
19876 }
19878 {
19881 }
19883 {
19886 }
19887 else
19889 }
19891 /* When there is a line break use what follows for the function body.
19892 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19898 /*
19899 * Read the body of the function, until ":endfunction" is found.
19900 */
19902 {
19903 /* Check if the function already exists, don't let the user type the
19904 * whole function before telling him it doesn't work! For a script we
19905 * need to skip the body to be able to find what follows. */
19907 {
19912 }
19919 }
19924 {
19930 {
19931 /* Use eap->arg, split up in parts by line breaks. */
19936 else
19937 {
19940 }
19941 }
19944 else
19949 {
19952 }
19954 /* Detect line continuation: sourcing_lnum increased more than one. */
19957 else
19961 {
19962 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19963 * don't check for ":endfunc". */
19965 {
19968 }
19969 }
19970 else
19971 {
19972 /* skip ':' and blanks*/
19974 ;
19976 /* Check for "endfunction". */
19978 {
19982 }
19984 /* Increase indent inside "if", "while", "for" and "try", decrease
19985 * at "end". */
19994 /* Check for defining a function inside this function. */
19996 {
20001 {
20004 {
20007 }
20008 }
20009 }
20011 /* Check for ":append" or ":insert". */
20019 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
20032 ))
20033 {
20034 /* ":python <<" continues until a dot, like ":append" */
20038 else
20040 }
20041 }
20043 /* Add the line to the function. */
20045 {
20049 }
20051 /* Copy the line to newly allocated memory. get_one_sourceline()
20052 * allocates 250 bytes per line, this saves 80% on average. The cost
20053 * is an extra alloc/free. */
20056 {
20060 }
20064 /* Add NULL lines for continuation lines, so that the line count is
20065 * equal to the index in the growarray. */
20069 /* Check for end of eap->arg. */
20072 }
20074 /* Don't define the function when skipping commands or when an error was
20075 * detected. */
20079 /*
20080 * If there are no errors, add the function
20081 */
20083 {
20086 {
20088 name);
20090 }
20094 {
20096 {
20099 }
20101 {
20103 name);
20105 }
20106 /* redefine existing function */
20111 }
20112 }
20113 else
20114 {
20119 {
20122 }
20124 {
20125 /* Can't add a function to a locked dictionary */
20128 }
20129 /* Can't change an existing function if it is locked */
20133 /* Give the function a sequential number. Can only be used with a
20134 * Funcref! */
20140 }
20143 {
20145 {
20149 /* Check that the autoload name matches the script name. */
20152 {
20155 {
20163 }
20164 }
20166 {
20169 }
20170 }
20177 {
20179 {
20180 /* add new dict entry */
20183 {
20186 }
20188 {
20192 }
20193 }
20194 else
20195 /* overwrite existing dict entry */
20202 /* behave like "dict" was used */
20204 }
20206 /* insert the new function in the function list */
20209 }
20212 #ifdef FEAT_PROFILE
20219 #endif
20226 erret:
20229 ret_free:
20234 }
20236 /*
20237 * Get a function name, translating "<SID>" and "<SNR>".
20238 * Also handles a Funcref in a List or Dictionary.
20239 * Returns the function name in allocated memory, or NULL for failure.
20240 * flags:
20241 * TFN_INT: internal function name OK
20242 * TFN_QUIET: be quiet
20243 * Advances "pp" to just after the function name (if no error).
20244 */
20251 {
20258 lval_T lv;
20264 /* Check for hard coded <SNR>: already translated function ID (from a user
20265 * command). */
20268 {
20272 }
20274 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20275 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20283 {
20287 }
20289 {
20290 /*
20291 * Report an invalid expression in braces, unless the expression
20292 * evaluation has been cancelled due to an aborting error, an
20293 * interrupt, or an exception.
20294 */
20296 {
20299 }
20300 else
20303 }
20306 {
20308 {
20313 }
20315 {
20318 }
20319 else
20320 {
20324 else
20327 }
20329 }
20332 {
20333 /* Error found, but continue after the function name. */
20336 }
20338 /* Check if the name is a Funcref. If so, use the value. */
20340 {
20345 }
20346 else
20347 {
20352 }
20354 {
20358 }
20361 {
20365 {
20366 /* When there was "s:" already or the name expanded to get a
20367 * leading "s:" then remove it. */
20371 }
20372 }
20373 else
20374 {
20378 }
20380 /*
20381 * Copy the function name to allocated memory.
20382 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20383 * Accept <SNR>123_name() outside a script.
20384 */
20388 {
20392 {
20393 /* It's "s:" or "<SID>" */
20395 {
20398 }
20401 }
20402 }
20404 {
20407 }
20410 {
20412 {
20418 }
20421 }
20424 theend:
20427 }
20429 /*
20430 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20431 * Return 2 if "p" starts with "s:".
20432 * Return 0 otherwise.
20433 */
20434 static int
20437 {
20444 }
20446 /*
20447 * Return TRUE if "p" starts with "<SID>" or "s:".
20448 * Only works if eval_fname_script() returned non-zero for "p"!
20449 */
20450 static int
20453 {
20455 }
20457 /*
20458 * List the head of the function: "name(arg1, arg2)".
20459 */
20460 static void
20464 {
20472 {
20475 }
20476 else
20480 {
20484 }
20486 {
20490 }
20495 }
20497 /*
20498 * Find a function by name, return pointer to it in ufuncs.
20499 * Return NULL for unknown function.
20500 */
20504 {
20511 }
20513 #if defined(EXITFREE) || defined(PROTO)
20514 void
20516 {
20519 /* Need to start all over every time, because func_free() may change the
20520 * hash table. */
20524 {
20527 }
20528 }
20529 #endif
20531 /*
20532 * Return TRUE if a function "name" exists.
20533 */
20534 static int
20537 {
20545 /* Only accept "funcname", "funcname ", "funcname (..." and
20546 * "funcname(...", not "funcname!...". */
20548 {
20551 else
20553 }
20556 }
20558 /*
20559 * Return TRUE if "name" looks like a builtin function name: starts with a
20560 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20561 */
20562 static int
20565 {
20568 }
20570 #if defined(FEAT_PROFILE) || defined(PROTO)
20571 /*
20572 * Start profiling function "fp".
20573 */
20574 static void
20577 {
20596 }
20598 /*
20599 * Dump the profiling results for all functions in file "fd".
20600 */
20601 void
20604 {
20616 {
20618 {
20622 {
20628 else
20632 else
20640 {
20646 }
20648 }
20649 }
20650 }
20653 {
20655 prof_total_cmp);
20658 prof_self_cmp);
20660 }
20661 }
20663 static void
20670 {
20677 {
20680 prefer_self);
20683 else
20685 }
20687 }
20689 /*
20690 * Print the count and times for one function or function line.
20691 */
20692 static void
20699 {
20701 {
20705 else
20709 else
20711 }
20712 else
20714 }
20716 /*
20717 * Compare function for total time sorting.
20718 */
20719 static int
20720 #ifdef __BORLANDC__
20721 _RTLENTRYF
20722 #endif
20726 {
20732 }
20734 /*
20735 * Compare function for self time sorting.
20736 */
20737 static int
20738 #ifdef __BORLANDC__
20739 _RTLENTRYF
20740 #endif
20744 {
20750 }
20752 #endif
20754 /*
20755 * If "name" has a package name try autoloading the script for it.
20756 * Return TRUE if a package was loaded.
20757 */
20758 static int
20762 {
20768 /* If there is no '#' after name[0] there is no package name. */
20775 /* Find the name in the list of previously loaded package names. Skip
20776 * "autoload/", it's always the same. */
20782 else
20783 {
20784 /* Remember the name if it wasn't loaded already. */
20786 {
20789 }
20791 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20794 }
20798 }
20800 /*
20801 * Return the autoload script name for a function or variable name.
20802 * Returns NULL when out of memory.
20803 */
20807 {
20811 /* Get the script file name: replace '#' with '/', append ".vim". */
20822 }
20824 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20826 /*
20827 * Function given to ExpandGeneric() to obtain the list of user defined
20828 * function names.
20829 */
20830 char_u *
20834 {
20840 {
20843 }
20845 {
20857 {
20861 }
20863 }
20865 }
20869 /*
20870 * Copy the function name of "fp" to buffer "buf".
20871 * "buf" must be able to hold the function name plus three bytes.
20872 * Takes care of script-local function names.
20873 */
20874 static void
20878 {
20880 {
20883 }
20884 else
20886 }
20888 /*
20889 * ":delfunction {name}"
20890 */
20891 void
20894 {
20898 funcdict_T fudi;
20904 {
20908 }
20910 {
20914 }
20924 {
20926 {
20929 }
20931 {
20934 }
20937 {
20938 /* Delete the dict item that refers to the function, it will
20939 * invoke func_unref() and possibly delete the function. */
20941 }
20942 else
20944 }
20945 }
20947 /*
20948 * Free a function and remove it from the list of functions.
20949 */
20950 static void
20953 {
20956 /* clear this function */
20959 #ifdef FEAT_PROFILE
20963 #endif
20965 /* remove the function from the function hashtable */
20969 else
20973 }
20975 /*
20976 * Unreference a Function: decrement the reference count and free it when it
20977 * becomes zero. Only for numbered functions.
20978 */
20979 static void
20982 {
20986 {
20991 {
20992 /* Only delete it when it's not being used. Otherwise it's done
20993 * when "uf_calls" becomes zero. */
20996 }
20997 }
20998 }
21000 /*
21001 * Count a reference to a Function.
21002 */
21003 static void
21006 {
21010 {
21014 else
21016 }
21017 }
21019 /*
21020 * Call a user function.
21021 */
21022 static void
21031 {
21033 linenr_T save_sourcing_lnum;
21034 scid_T save_current_SID;
21035 funccall_T fc;
21044 #ifdef FEAT_PROFILE
21045 proftime_T wait_start;
21046 proftime_T call_start;
21047 #endif
21049 /* If depth of calling is getting too high, don't execute the function */
21051 {
21056 }
21069 /* Check if this function has a breakpoint. */
21073 /*
21074 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21075 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21076 * each argument variable and saves a lot of time.
21077 */
21078 /*
21079 * Init l: variables.
21080 */
21083 {
21084 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21085 * some compiler that checks the destination size. */
21095 }
21097 /*
21098 * Init a: variables.
21099 * Set a:0 to "argcount".
21100 * Set a:000 to a list with room for the "..." arguments.
21101 */
21116 /*
21117 * Set a:firstline to "firstline" and a:lastline to "lastline".
21118 * Set a:name to named arguments.
21119 * Set a:N to the "..." arguments.
21120 */
21126 {
21129 /* named argument a:name */
21131 else
21132 {
21133 /* "..." argument a:1, a:2, etc. */
21136 }
21138 {
21141 }
21142 else
21143 {
21149 }
21153 /* Note: the values are copied directly to avoid alloc/free.
21154 * "argvars" must have VAR_FIXED for v_lock. */
21159 {
21163 }
21164 }
21166 /* Don't redraw while executing the function. */
21174 {
21178 else
21183 {
21189 {
21197 {
21202 else
21203 {
21206 {
21210 }
21211 }
21212 }
21214 }
21219 }
21220 }
21221 #ifdef FEAT_PROFILE
21223 {
21228 {
21232 }
21234 }
21235 #endif
21242 /* call do_cmdline() to execute the lines */
21248 /* when the function was aborted because of an error, return -1 */
21250 {
21254 }
21256 #ifdef FEAT_PROFILE
21259 {
21265 {
21268 }
21269 }
21270 #endif
21272 /* when being verbose, mention the return value */
21274 {
21283 else
21284 {
21290 /* The value may be very long. Skip the middle part, so that we
21291 * have some idea how it starts and ends. smsg() would always
21292 * truncate it at the end. */
21295 {
21299 }
21300 }
21305 }
21311 #ifdef FEAT_PROFILE
21314 #endif
21317 {
21326 }
21331 /* The a: variables typevals were not allocated, only free the allocated
21332 * variables. */
21337 }
21339 /*
21340 * Add a number variable "name" to dict "dp" with value "nr".
21341 */
21342 static void
21347 varnumber_T nr;
21348 {
21355 }
21357 /*
21358 * ":return [expr]"
21359 */
21360 void
21363 {
21365 typval_T rettv;
21369 {
21372 }
21380 {
21383 else
21385 }
21386 /* It's safer to return also on error. */
21388 {
21389 /*
21390 * Return unless the expression evaluation has been cancelled due to an
21391 * aborting error, an interrupt, or an exception.
21392 */
21395 }
21397 /* When skipping or the return gets pending, advance to the next command
21398 * in this line (!returning). Otherwise, ignore the rest of the line.
21399 * Following lines will be ignored by get_func_line(). */
21407 }
21409 /*
21410 * Return from a function. Possibly makes the return pending. Also called
21411 * for a pending return at the ":endtry" or after returning from an extra
21412 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21413 * when called due to a ":return" command. "rettv" may point to a typval_T
21414 * with the return rettv. Returns TRUE when the return can be carried out,
21415 * FALSE when the return gets pending.
21416 */
21417 int
21423 {
21428 /* Undo the return. */
21431 /*
21432 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21433 * not in its finally clause (which then is to be executed next) is found.
21434 * In this case, make the ":return" pending for execution at the ":endtry".
21435 * Otherwise, return normally.
21436 */
21439 {
21443 /* A pending return again gets pending. "rettv" points to an
21444 * allocated variable with the rettv of the original ":return"'s
21445 * argument if present or is NULL else. */
21447 else
21448 {
21449 /* When undoing a return in order to make it pending, get the stored
21450 * return rettv. */
21455 {
21456 /* Store the value of the pending return. */
21459 else
21461 }
21462 else
21466 {
21467 /* The pending return value could be overwritten by a ":return"
21468 * without argument in a finally clause; reset the default
21469 * return value. */
21472 }
21473 }
21475 }
21476 else
21477 {
21480 /* If the return is carried out now, store the return value. For
21481 * a return immediately after reanimation, the value is already
21482 * there. */
21484 {
21489 }
21490 }
21493 }
21495 /*
21496 * Free the variable with a pending return value.
21497 */
21498 void
21501 {
21503 }
21505 /*
21506 * Generate a return command for producing the value of "rettv". The result
21507 * is an allocated string. Used by report_pending() for verbose messages.
21508 */
21509 char_u *
21512 {
21528 }
21530 /*
21531 * Get next function line.
21532 * Called by do_cmdline() to get the next line.
21533 * Returns allocated string, or NULL for end of function.
21534 */
21535 /* ARGSUSED */
21536 char_u *
21541 {
21547 /* If breakpoints have been added/deleted need to check for it. */
21549 {
21551 sourcing_lnum);
21553 }
21554 #ifdef FEAT_PROFILE
21557 #endif
21563 else
21564 {
21565 /* Skip NULL lines (continuation lines). */
21571 else
21572 {
21575 #ifdef FEAT_PROFILE
21578 #endif
21579 }
21580 }
21582 /* Did we encounter a breakpoint? */
21584 {
21586 /* Find next breakpoint. */
21588 sourcing_lnum);
21590 }
21593 }
21595 #if defined(FEAT_PROFILE) || defined(PROTO)
21596 /*
21597 * Called when starting to read a function line.
21598 * "sourcing_lnum" must be correct!
21599 * When skipping lines it may not actually be executed, but we won't find out
21600 * until later and we need to store the time now.
21601 */
21602 void
21605 {
21611 {
21613 /* Skip continuation lines. */
21620 }
21621 }
21623 /*
21624 * Called when actually executing a function line.
21625 */
21626 void
21629 {
21635 }
21637 /*
21638 * Called when done with a function line.
21639 */
21640 void
21643 {
21648 {
21650 {
21657 }
21659 }
21660 }
21661 #endif
21663 /*
21664 * Return TRUE if the currently active function should be ended, because a
21665 * return was encountered or an error occurred. Used inside a ":while".
21666 */
21667 int
21670 {
21673 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21674 * an error inside a try conditional. */
21677 }
21679 /*
21680 * return TRUE if cookie indicates a function which "abort"s on errors.
21681 */
21682 int
21685 {
21687 }
21689 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21691 {
21694 VAR_FLAVOUR_VIMINFO /* all uppercase */
21699 static var_flavour_T
21702 {
21706 {
21711 }
21712 else
21714 }
21715 #endif
21717 #if defined(FEAT_VIMINFO) || defined(PROTO)
21718 /*
21719 * Restore global vars that start with a capital from the viminfo file
21720 */
21721 int
21725 {
21728 typval_T tv;
21731 {
21734 {
21738 #ifdef FEAT_FLOAT
21741 #endif
21745 {
21750 #ifdef FEAT_FLOAT
21753 #endif
21754 else
21759 }
21760 }
21761 }
21764 }
21766 /*
21767 * Write global vars that start with a capital to the viminfo file
21768 */
21769 void
21772 {
21788 {
21790 {
21794 {
21796 {
21799 #ifdef FEAT_FLOAT
21801 #endif
21803 }
21809 }
21810 }
21811 }
21812 }
21813 #endif
21815 #if defined(FEAT_SESSION) || defined(PROTO)
21816 int
21819 {
21827 {
21829 {
21835 {
21836 /* Escape special characters with a backslash. Turn a LF and
21837 * CR into \n and \r. */
21851 p,
21855 {
21858 }
21860 }
21861 #ifdef FEAT_FLOAT
21864 {
21869 {
21872 }
21877 }
21878 #endif
21879 }
21880 }
21882 }
21883 #endif
21885 /*
21886 * Display script name where an item was last set.
21887 * Should only be invoked when 'verbose' is non-zero.
21888 */
21889 void
21891 scid_T scriptID;
21892 {
21896 {
21899 {
21905 }
21906 }
21907 }
21912 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21914 #ifdef WIN3264
21915 /*
21916 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21917 */
21919 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21922 /*
21923 * Get the short path (8.3) for the filename in "fnamep".
21924 * Only works for a valid file name.
21925 * When the path gets longer "fnamep" is changed and the allocated buffer
21926 * is put in "bufp".
21927 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21928 * Returns OK on success, FAIL on failure.
21929 */
21930 static int
21935 {
21942 {
21943 /* If that doesn't work (not enough space), then save the string
21944 * and try again with a new buffer big enough. */
21952 /* Really should always succeed, as the buffer is big enough. */
21954 }
21958 }
21960 /*
21961 * Get the short path (8.3) for the filename in "fname". The converted
21962 * path is returned in "bufp".
21963 *
21964 * Some of the directories specified in "fname" may not exist. This function
21965 * will shorten the existing directories at the beginning of the path and then
21966 * append the remaining non-existing path.
21967 *
21968 * fname - Pointer to the filename to shorten. On return, contains the
21969 * pointer to the shortened pathname
21970 * bufp - Pointer to an allocated buffer for the filename.
21971 * fnamelen - Length of the filename pointed to by fname
21972 *
21973 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21974 */
21975 static int
21980 {
21983 char_u ch;
21988 /* Make a copy */
21997 /*
21998 * Try shortening the supplied path till it succeeds by removing one
21999 * directory at a time from the tail of the path.
22000 */
22003 {
22004 /* go back one path-separator */
22010 /*
22011 * Replace the path separator with a NUL and try to shorten the
22012 * resulting path.
22013 */
22019 {
22022 }
22028 /* failed to shorten the path. Skip the path separator */
22030 }
22033 {
22034 /*
22035 * Succeeded in shortening the path. Now concatenate the shortened
22036 * path with the remaining path at the tail.
22037 */
22039 /* Compute the length of the new path. */
22046 {
22047 /* There is not enough space in the currently allocated string,
22048 * copy it to a buffer big enough. */
22051 {
22054 }
22055 }
22056 else
22057 {
22058 /* Transfer short_fname to the main buffer (it's big enough),
22059 * unless get_short_pathname() did its work in-place. */
22064 }
22066 /* concat the not-shortened part of the path */
22069 }
22071 theend:
22076 }
22078 /*
22079 * Get a pathname for a partial path.
22080 * Returns OK for success, FAIL for failure.
22081 */
22082 static int
22087 {
22093 /* Count up the path separators from the RHS.. so we know which part
22094 * of the path to return. */
22100 /* Need full path first (use expand_env() to remove a "~/") */
22104 else
22113 {
22114 /* Don't have a valid filename, so shorten the rest of the
22115 * path if we can. This CAN give us invalid 8.3 filenames, but
22116 * there's not a lot of point in guessing what it might be.
22117 */
22121 }
22123 /* Count the paths backward to find the beginning of the desired string. */
22125 {
22126 #ifdef FEAT_MBYTE
22129 #endif
22131 {
22134 else
22135 sepcount --;
22136 }
22137 }
22139 {
22143 else
22145 }
22146 else
22149 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22156 }
22159 /*
22160 * Adjust a filename, according to a string of modifiers.
22161 * *fnamep must be NUL terminated when called. When returning, the length is
22162 * determined by *fnamelen.
22163 * Returns VALID_ flags or -1 for failure.
22164 * When there is an error, *fnamep is set to NULL.
22165 */
22166 int
22173 {
22180 #ifdef WIN3264
22182 #endif
22184 repeat:
22185 /* ":p" - full path/file_name */
22187 {
22193 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22195 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22197 # ifdef BACKSLASH_IN_FILENAME
22199 # endif
22202 #endif
22203 )
22204 {
22210 }
22212 /* When "/." or "/.." is used: force expansion to get rid of it. */
22214 {
22222 }
22224 /* FullName_save() is slow, don't use it when not needed. */
22226 {
22232 }
22234 /* Append a path separator to a directory. */
22236 {
22237 /* Make room for one or two extra characters. */
22244 }
22245 }
22247 /* ":." - path relative to the current directory */
22248 /* ":~" - path relative to the home directory */
22249 /* ":8" - shortname path - postponed till after */
22252 {
22255 {
22256 #ifdef WIN3264
22258 #endif
22260 }
22262 /* Need full path first (use expand_env() to remove a "~/") */
22264 {
22267 else
22269 }
22270 else
22276 {
22278 {
22282 {
22285 {
22289 }
22290 }
22291 }
22292 else
22293 {
22295 /* Only replace it when it starts with '~' */
22297 {
22300 {
22304 }
22305 }
22306 }
22308 }
22309 }
22314 /* ":h" - head, remove "/file_name", can be repeated */
22315 /* Don't remove the first "/" or "c:\" */
22317 {
22324 #ifdef VMS
22327 #endif
22329 {
22330 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22337 }
22338 else
22339 {
22342 }
22343 }
22345 /* ":8" - shortname */
22347 {
22349 #ifdef WIN3264
22351 #endif
22352 }
22354 #ifdef WIN3264
22355 /* Check shortname after we have done 'heads' and before we do 'tails'
22356 */
22358 {
22360 /* Copy the string if it is shortened by :h */
22362 {
22368 }
22370 /* Split into two implementations - makes it easier. First is where
22371 * there isn't a full name already, second is where there is.
22372 */
22374 {
22377 }
22378 else
22379 {
22382 /* Simple case, already have the full-name
22383 * Nearly always shorter, so try first time. */
22389 {
22390 /* Couldn't find the filename.. search the paths.
22391 */
22395 }
22397 }
22398 }
22401 /* ":t" - tail, just the basename */
22403 {
22407 }
22409 /* ":e" - extension, can be repeated */
22410 /* ":r" - root, without extension, can be repeated */
22413 {
22414 /* find a '.' in the tail:
22415 * - for second :e: before the current fname
22416 * - otherwise: The last '.'
22417 */
22420 else
22426 {
22428 {
22431 #ifdef VMS
22432 /* cut version from the extension */
22439 #endif
22440 }
22443 }
22445 {
22448 }
22450 }
22452 /* ":s?pat?foo?" - substitute */
22453 /* ":gs?pat?foo?" - global substitute */
22457 {
22468 {
22471 }
22475 {
22476 /* find end of pattern */
22479 {
22482 {
22484 /* find end of substitution */
22487 {
22491 {
22495 {
22501 }
22502 }
22505 }
22507 }
22508 }
22509 /* after using ":s", repeat all the modifiers */
22512 }
22513 }
22516 }
22518 /*
22519 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22520 * "flags" can be "g" to do a global substitute.
22521 * Returns an allocated string, NULL for error.
22522 */
22523 char_u *
22529 {
22531 regmatch_T regmatch;
22535 garray_T ga;
22539 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22550 {
22553 {
22554 /*
22555 * Get some space for a temporary buffer to do the substitution
22556 * into. It will contain:
22557 * - The text up to where the match is.
22558 * - The substituted text.
22559 * - The text after the match.
22560 */
22564 {
22567 }
22569 /* copy the text up to where the match is */
22572 /* add the substituted text */
22576 /* avoid getting stuck on a match with an empty string */
22578 {
22583 }
22584 else
22585 {
22589 }
22592 }
22598 }
22604 else
22605 /* Darn, evaluating {sub} expression changed the value. */
22609 }