| blob | 3994b17274e8384651b8a493c9e0e7ae3e4b690a |
1 /* vi:set ts=8 sts=4 sw=4:
2 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
10 /*
11 * eval.c: Expression evaluation.
12 */
13 #if defined(MSDOS) || defined(MSWIN)
15 #endif
19 #if defined(FEAT_EVAL) || defined(PROTO)
21 #ifdef AMIGA
23 #endif
25 #ifdef MACOS
27 #endif
29 #if defined(FEAT_FLOAT) && defined(HAVE_MATH_H)
30 # include <math.h>
31 #endif
35 /*
36 * In a hashtab item "hi_key" points to "di_key" in a dictitem.
37 * This avoids adding a pointer to the hashtab item.
38 * DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
39 * HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
40 * HI2DI() converts a hashitem pointer to a dictitem pointer.
41 */
43 #define DI2HIKEY(di) ((di)->di_key)
44 #define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
45 #define HI2DI(hi) HIKEY2DI((hi)->hi_key)
47 /*
48 * Structure returned by get_lval() and used by set_var_lval().
49 * For a plain name:
50 * "name" points to the variable name.
51 * "exp_name" is NULL.
52 * "tv" is NULL
53 * For a magic braces name:
54 * "name" points to the expanded variable name.
55 * "exp_name" is non-NULL, to be freed later.
56 * "tv" is NULL
57 * For an index in a list:
58 * "name" points to the (expanded) variable name.
59 * "exp_name" NULL or non-NULL, to be freed later.
60 * "tv" points to the (first) list item value
61 * "li" points to the (first) list item
62 * "range", "n1", "n2" and "empty2" indicate what items are used.
63 * For an existing Dict item:
64 * "name" points to the (expanded) variable name.
65 * "exp_name" NULL or non-NULL, to be freed later.
66 * "tv" points to the dict item value
67 * "newkey" is NULL
68 * For a non-existing Dict item:
69 * "name" points to the (expanded) variable name.
70 * "exp_name" NULL or non-NULL, to be freed later.
71 * "tv" points to the Dictionary typval_T
72 * "newkey" is the key for the new item.
73 */
75 {
79 isn't NULL it's the Dict to which to add
80 the item. */
112 /*
113 * All user-defined global variables are stored in dictionary "globvardict".
114 * "globvars_var" is the variable that is used for "g:".
115 */
118 #define globvarht globvardict.dv_hashtab
120 /*
121 * Old Vim variables such as "v:version" are also available without the "v:".
122 * Also in functions. We need a special hashtable for them.
123 */
126 /*
127 * When recursively copying lists and dicts we need to remember which ones we
128 * have done to avoid endless recursiveness. This unique ID is used for that.
129 */
132 /*
133 * Array to hold the hashtab with variables local to each sourced script.
134 * Each item holds a variable (nameless) that points to the dict_T.
135 */
137 {
138 dictitem_T sv_var;
139 dict_T sv_dict;
143 #define SCRIPT_SV(id) (((scriptvar_T *)ga_scripts.ga_data)[(id) - 1])
144 #define SCRIPT_VARS(id) (SCRIPT_SV(id).sv_dict.dv_hashtab)
148 /* Values for trans_function_name() argument: */
152 /*
153 * Structure to hold info for a user function.
154 */
157 struct ufunc
158 {
164 #ifdef FEAT_PROFILE
166 /* profiling the function as a whole */
171 /* profiling the function per line */
180 #endif
182 used for s: variables */
185 start with <SNR>123_ (<SNR> is K_SPECIAL
186 KS_EXTRA KE_SNR) */
187 };
189 /* function flags */
194 /*
195 * All user-defined functions are found in this hashtable.
196 */
199 /* The names of packages that once were loaded are remembered. */
202 /* list heads for garbage collection */
206 /* From user function to hashitem and back. */
208 #define UF2HIKEY(fp) ((fp)->uf_name)
209 #define HIKEY2UF(p) ((ufunc_T *)(p - (dumuf.uf_name - (char_u *)&dumuf)))
210 #define HI2UF(hi) HIKEY2UF((hi)->hi_key)
212 #define FUNCARG(fp, j) ((char_u **)(fp->uf_args.ga_data))[j]
213 #define FUNCLINE(fp, j) ((char_u **)(fp->uf_lines.ga_data))[j]
219 /* structure to hold info for a function that is currently being executed. */
222 struct funccall_S
223 {
228 {
242 #ifdef FEAT_PROFILE
244 #endif
246 };
248 /*
249 * Info used by a ":for" loop.
250 */
252 {
259 /*
260 * Struct used by trans_function_name()
261 */
263 {
270 /*
271 * Array to hold the value of v: variables.
272 * The value is in a dictitem, so that it can also be used in the v: scope.
273 * The reason to use this table anyway is for very quick access to the
274 * variables with the VV_ defines.
275 */
278 /* values for vv_flags: */
283 #define VV_NAME(s, t) s, {{t}}, {0}
285 static struct vimvar
286 {
292 {
293 /*
294 * The order here must match the VV_ defines in vim.h!
295 * Initializing a union does not work, leave tv.vval empty to get zero's.
296 */
351 };
353 /* shorthand */
354 #define vv_type vv_di.di_tv.v_type
355 #define vv_nr vv_di.di_tv.vval.v_number
356 #define vv_float vv_di.di_tv.vval.v_float
357 #define vv_str vv_di.di_tv.vval.v_string
358 #define vv_tv vv_di.di_tv
360 /*
361 * The v: variables are stored in dictionary "vimvardict".
362 * "vimvars_var" is the variable that is used for the "l:" scope.
363 */
366 #define vimvarht vimvardict.dv_hashtab
370 #if defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)
371 static int call_vim_function __ARGS((char_u *func, int argc, char_u **argv, int safe, typval_T *rettv));
372 #endif
373 static int ex_let_vars __ARGS((char_u *arg, typval_T *tv, int copy, int semicolon, int var_count, char_u *nextchars));
380 #ifdef FEAT_WINDOWS
382 #endif
387 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
389 static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
391 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
456 #ifdef FEAT_FLOAT
458 #endif
462 static int get_func_tv __ARGS((char_u *name, int len, typval_T *rettv, char_u **arg, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
463 static int call_func __ARGS((char_u *name, int len, typval_T *rettv, int argcount, typval_T *argvars, linenr_T firstline, linenr_T lastline, int *doesrange, int evaluate, dict_T *selfdict));
466 #ifdef FEAT_FLOAT
468 #endif
474 #ifdef FEAT_FLOAT
476 #endif
488 #ifdef FEAT_FLOAT
490 #endif
496 #if defined(FEAT_INS_EXPAND)
500 #endif
503 #ifdef FEAT_FLOAT
505 #endif
528 #ifdef FEAT_FLOAT
531 #endif
603 #ifdef FEAT_FLOAT
605 #endif
618 #ifdef vim_mkdir
620 #endif
625 #ifdef FEAT_FLOAT
627 #endif
645 #ifdef FEAT_FLOAT
647 #endif
667 #ifdef FEAT_FLOAT
669 #endif
675 #ifdef FEAT_FLOAT
678 #endif
680 #ifdef HAVE_STRFTIME
682 #endif
706 #ifdef FEAT_FLOAT
708 #endif
729 static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
732 valid character */
733 static char_u * make_expanded_name __ARGS((char_u *in_start, char_u *expr_start, char_u *expr_end, char_u *in_end));
753 static void list_one_var_a __ARGS((char_u *prefix, char_u *name, int type, char_u *string, int *first));
768 #ifdef FEAT_PROFILE
770 static void prof_sort_list __ARGS((FILE *fd, ufunc_T **sorttab, int st_len, char *title, int prefer_self));
771 static void prof_func_line __ARGS((FILE *fd, int count, proftime_T *total, proftime_T *self, int prefer_self));
772 static int
773 # ifdef __BORLANDC__
774 _RTLENTRYF
775 # endif
777 static int
778 # ifdef __BORLANDC__
779 _RTLENTRYF
780 # endif
782 #endif
789 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));
797 /* Character used as separated in autoload function/variable names. */
800 /*
801 * Initialize the global and v: variables.
802 */
803 void
805 {
815 {
822 else
825 /* add to v: scope dict, unless the value is not always available */
829 /* add to compat scope dict */
831 }
833 }
835 #if defined(EXITFREE) || defined(PROTO)
836 void
838 {
843 {
846 {
849 }
850 }
854 /* script-local variables */
860 /* global variables */
863 /* autoloaded script names */
866 /* unreferenced lists and dicts */
869 /* functions */
872 }
873 #endif
875 /*
876 * Return the name of the executed function.
877 */
878 char_u *
881 {
883 }
885 /*
886 * Return the address holding the next breakpoint line for a funccall cookie.
887 */
888 linenr_T *
891 {
893 }
895 /*
896 * Return the address holding the debug tick for a funccall cookie.
897 */
901 {
903 }
905 /*
906 * Return the nesting level for a funccall cookie.
907 */
908 int
911 {
913 }
915 /* pointer to funccal for currently active function */
918 /*
919 * Return TRUE when a function was ended by a ":return" command.
920 */
921 int
923 {
925 }
928 /*
929 * Set an internal variable to a string value. Creates the variable if it does
930 * not already exist.
931 */
932 void
936 {
942 {
945 {
948 }
949 }
950 }
957 /*
958 * Start recording command output to a variable
959 * Returns OK if successfully completed the setup. FAIL otherwise.
960 */
961 int
965 {
968 typval_T tv;
970 /* Make sure a valid variable name is specified */
972 {
975 }
983 {
986 }
988 /* The output is stored in growarray "redir_ga" until redirection ends. */
991 /* Parse the variable name (can be a dict or list entry). */
993 FNE_CHECK_START);
995 {
997 /* Trailing characters are present after the variable name */
999 else
1003 }
1005 /* check if we can write to the variable: set it to or append an empty
1006 * string */
1013 else
1018 {
1021 }
1023 {
1024 /* Dictionary item was created, don't do it again. */
1027 }
1030 }
1032 /*
1033 * Append "value[value_len]" to the variable set by var_redir_start().
1034 * The actual appending is postponed until redirection ends, because the value
1035 * appended may in fact be the string we write to, changing it may cause freed
1036 * memory to be used:
1037 * :redir => foo
1038 * :let foo
1039 * :redir END
1040 */
1041 void
1045 {
1053 else
1057 {
1060 }
1061 else
1063 }
1065 /*
1066 * Stop redirecting command output to a variable.
1067 */
1068 void
1070 {
1071 typval_T tv;
1074 {
1075 /* Append the trailing NUL. */
1078 /* Assign the text to the variable. */
1087 }
1090 }
1092 # if defined(FEAT_MBYTE) || defined(PROTO)
1093 int
1099 {
1116 }
1117 # endif
1119 # if defined(FEAT_POSTSCRIPT) || defined(PROTO)
1120 int
1124 {
1135 {
1138 }
1140 }
1141 # endif
1143 # if defined(FEAT_DIFF) || defined(PROTO)
1144 void
1149 {
1159 }
1161 void
1166 {
1176 }
1177 # endif
1179 /*
1180 * Top level evaluation function, returning a boolean.
1181 * Sets "error" to TRUE if there was an error.
1182 * Return TRUE or FALSE.
1183 */
1184 int
1190 {
1191 typval_T tv;
1198 else
1199 {
1202 {
1205 }
1206 }
1211 }
1213 /*
1214 * Top level evaluation function, returning a string. If "skip" is TRUE,
1215 * only parsing to "nextcmd" is done, without reporting errors. Return
1216 * pointer to allocated memory, or NULL for failure or when "skip" is TRUE.
1217 */
1218 char_u *
1223 {
1224 typval_T tv;
1231 else
1232 {
1235 }
1240 }
1242 /*
1243 * Skip over an expression at "*pp".
1244 * Return FAIL for an error, OK otherwise.
1245 */
1246 int
1249 {
1250 typval_T rettv;
1254 }
1256 /*
1257 * Top level evaluation function, returning a string.
1258 * Return pointer to allocated memory, or NULL for failure.
1259 */
1260 char_u *
1265 {
1266 typval_T tv;
1268 garray_T ga;
1272 else
1273 {
1275 {
1280 }
1281 else
1284 }
1287 }
1289 /*
1290 * Call eval_to_string() without using current local variables and using
1291 * textlock. When "use_sandbox" is TRUE use the sandbox.
1292 */
1293 char_u *
1298 {
1312 }
1314 /*
1315 * Top level evaluation function, returning a number.
1316 * Evaluates "expr" silently.
1317 * Returns -1 for an error.
1318 */
1319 int
1322 {
1323 typval_T rettv;
1331 else
1332 {
1335 }
1339 }
1341 /*
1342 * Prepare v: variable "idx" to be used.
1343 * Save the current typeval in "save_tv".
1344 * When not used yet add the variable to the v: hashtable.
1345 */
1346 static void
1350 {
1354 }
1356 /*
1357 * Restore v: variable "idx" to typeval "save_tv".
1358 * When no longer defined, remove the variable from the v: hashtable.
1359 */
1360 static void
1364 {
1369 {
1373 else
1375 }
1376 }
1378 #if defined(FEAT_SPELL) || defined(PROTO)
1379 /*
1380 * Evaluate an expression to a list with suggestions.
1381 * For the "expr:" part of 'spellsuggest'.
1382 */
1383 list_T *
1387 {
1388 typval_T save_val;
1389 typval_T rettv;
1393 /* Set "v:val" to the bad word. */
1401 {
1404 else
1406 }
1413 }
1415 /*
1416 * "list" is supposed to contain two items: a word and a number. Return the
1417 * word in "pp" and the number as the return value.
1418 * Return -1 if anything isn't right.
1419 * Used to get the good word and score from the eval_spell_expr() result.
1420 */
1421 int
1425 {
1437 }
1438 #endif
1440 /*
1441 * Top level evaluation function.
1442 * Returns an allocated typval_T with the result.
1443 * Returns NULL when there is an error.
1444 */
1445 typval_T *
1449 {
1454 {
1457 }
1460 }
1463 #if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) \
1464 || defined(FEAT_COMPL_FUNC) || defined(PROTO)
1465 /*
1466 * Call some vimL function and return the result in "*rettv".
1467 * Uses argv[argc] for the function arguments. Only Number and String
1468 * arguments are currently supported.
1469 * Returns OK or FAIL.
1470 */
1471 static int
1478 {
1492 {
1493 /* Pass a NULL or empty argument as an empty string */
1495 {
1499 }
1501 /* Recognize a number argument, the others must be strings. */
1504 {
1507 }
1508 else
1509 {
1512 }
1513 }
1516 {
1519 }
1526 {
1529 }
1536 }
1538 # if (defined(FEAT_USR_CMDS) && defined(FEAT_CMDL_COMPL)) || defined(PROTO)
1539 /*
1540 * Call vimL function "func" and return the result as a string.
1541 * Returns NULL when calling the function fails.
1542 * Uses argv[argc] for the function arguments.
1543 */
1550 {
1551 typval_T rettv;
1560 }
1561 # endif
1563 # if defined(FEAT_COMPL_FUNC) || defined(PROTO)
1564 /*
1565 * Call vimL function "func" and return the result as a number.
1566 * Returns -1 when calling the function fails.
1567 * Uses argv[argc] for the function arguments.
1568 */
1569 long
1575 {
1576 typval_T rettv;
1585 }
1586 # endif
1588 /*
1589 * Call vimL function "func" and return the result as a list
1590 * Uses argv[argc] for the function arguments.
1591 */
1598 {
1599 typval_T rettv;
1605 {
1608 }
1611 }
1612 #endif
1615 /*
1616 * Save the current function call pointer, and set it to NULL.
1617 * Used when executing autocommands and for ":source".
1618 */
1621 {
1626 }
1628 void
1631 {
1635 }
1637 #if defined(FEAT_PROFILE) || defined(PROTO)
1638 /*
1639 * Prepare profiling for entering a child or something else that is not
1640 * counted for the script/function itself.
1641 * Should always be called in pair with prof_child_exit().
1642 */
1643 void
1646 {
1652 }
1654 /*
1655 * Take care of time spent in a child.
1656 * Should always be called after prof_child_enter().
1657 */
1658 void
1661 {
1665 {
1670 }
1672 }
1673 #endif
1676 #ifdef FEAT_FOLDING
1677 /*
1678 * Evaluate 'foldexpr'. Returns the foldlevel, and any character preceding
1679 * it in "*cp". Doesn't give error messages.
1680 */
1681 int
1685 {
1686 typval_T tv;
1690 OPT_LOCAL);
1699 else
1700 {
1701 /* If the result is a number, just return the number. */
1706 else
1707 {
1708 /* If the result is a string, check if there is a non-digit before
1709 * the number. */
1714 }
1716 }
1723 }
1724 #endif
1726 /*
1727 * ":let" list all variable values
1728 * ":let var1 var2" list variable values
1729 * ":let var = expr" assignment command.
1730 * ":let var += expr" assignment command.
1731 * ":let var -= expr" assignment command.
1732 * ":let var .= expr" assignment command.
1733 * ":let [var1, var2] = expr" unpack list.
1734 */
1735 void
1738 {
1741 typval_T rettv;
1756 {
1757 /*
1758 * ":let" without "=": list variables
1759 */
1763 /* ":let var1 var2" */
1766 {
1767 /* ":let" */
1771 #ifdef FEAT_WINDOWS
1773 #endif
1777 }
1779 }
1780 else
1781 {
1785 {
1788 }
1795 {
1799 }
1801 {
1803 op);
1805 }
1806 }
1807 }
1809 /*
1810 * Assign the typevalue "tv" to the variable or variables at "arg_start".
1811 * Handles both "var" with any type and "[var, var; var]" with a list type.
1812 * When "nextchars" is not NULL it points to a string with characters that
1813 * must appear after the variable(s). Use "+", "-" or "." for add, subtract
1814 * or concatenate.
1815 * Returns OK or FAIL;
1816 */
1817 static int
1825 {
1830 typval_T ltv;
1833 {
1834 /*
1835 * ":let var = expr" or ":for var in list"
1836 */
1840 }
1842 /*
1843 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
1844 */
1846 {
1849 }
1853 {
1856 }
1858 {
1861 }
1865 {
1874 {
1875 /* Put the rest of the list (may be empty) in the var after ';'.
1876 * Create a new list for this. */
1881 {
1884 }
1897 }
1899 {
1902 }
1903 }
1906 }
1908 /*
1909 * Skip over assignable variable "var" or list of variables "[var, var]".
1910 * Used for ":let varvar = expr" and ":for varvar in expr".
1911 * For "[var, var]" increment "*var_count" for each variable.
1912 * for "[var, var; var]" set "semicolon".
1913 * Return NULL for an error.
1914 */
1920 {
1924 {
1925 /* "[var, var]": find the matching ']'. */
1928 {
1932 {
1935 }
1942 {
1944 {
1947 }
1949 }
1951 {
1954 }
1955 }
1957 }
1958 else
1960 }
1962 /*
1963 * Skip one (assignable) variable name, including @r, $VAR, &option, d.key,
1964 * l[idx].
1965 */
1969 {
1974 }
1976 /*
1977 * List variables for hashtab "ht" with prefix "prefix".
1978 * If "empty" is TRUE also list NULL strings as empty strings.
1979 */
1980 static void
1986 {
1993 {
1995 {
2001 }
2002 }
2003 }
2005 /*
2006 * List global variables.
2007 */
2008 static void
2011 {
2013 }
2015 /*
2016 * List buffer variables.
2017 */
2018 static void
2021 {
2030 }
2032 /*
2033 * List window variables.
2034 */
2035 static void
2038 {
2041 }
2043 #ifdef FEAT_WINDOWS
2044 /*
2045 * List tab page variables.
2046 */
2047 static void
2050 {
2053 }
2054 #endif
2056 /*
2057 * List Vim variables.
2058 */
2059 static void
2062 {
2064 }
2066 /*
2067 * List script-local variables, if there is a script.
2068 */
2069 static void
2072 {
2076 }
2078 /*
2079 * List function variables, if there is a function.
2080 */
2081 static void
2084 {
2088 }
2090 /*
2091 * List variables in "arg".
2092 */
2098 {
2105 typval_T tv;
2108 {
2110 {
2113 {
2117 }
2118 }
2119 else
2120 {
2121 /* get_name_len() takes care of expanding curly braces */
2125 {
2126 /* This is mainly to keep test 49 working: when expanding
2127 * curly braces fails overrule the exception error message. */
2129 {
2133 }
2135 }
2136 else
2137 {
2142 else
2143 {
2144 /* handle d.key, l[idx], f(expr) */
2148 else
2149 {
2151 {
2153 {
2157 #ifdef FEAT_WINDOWS
2159 #endif
2165 }
2166 }
2167 else
2168 {
2181 first);
2184 }
2186 }
2187 }
2188 }
2191 }
2194 }
2197 }
2199 /*
2200 * Set one item of ":let var = expr" or ":let [v1, v2] = list" to its value.
2201 * Returns a pointer to the char just after the var name.
2202 * Returns NULL if there is an error.
2203 */
2211 {
2220 /*
2221 * ":let $VAR = expr": Set environment variable.
2222 */
2224 {
2225 /* Find the end of the name. */
2231 else
2232 {
2238 else
2239 {
2244 {
2249 {
2253 }
2254 }
2256 {
2266 }
2269 }
2270 }
2271 }
2273 /*
2274 * ":let &option = expr": Set option value.
2275 * ":let &l:option = expr": Set local option value.
2276 * ":let &g:option = expr": Set global option value.
2277 */
2279 {
2280 /* Find the end of the name. */
2285 else
2286 {
2299 {
2305 else
2306 {
2308 {
2311 else
2313 }
2315 {
2319 }
2320 }
2321 }
2323 {
2326 }
2329 }
2330 }
2332 /*
2333 * ":let @r = expr": Set register contents.
2334 */
2336 {
2343 else
2344 {
2350 {
2353 {
2356 }
2357 }
2359 {
2362 }
2364 }
2365 }
2367 /*
2368 * ":let var = expr": Set internal variable.
2369 * ":let {expr} = expr": Idem, name made with curly braces
2370 */
2372 {
2373 lval_T lv;
2377 {
2380 else
2381 {
2384 }
2385 }
2387 }
2389 else
2393 }
2395 /*
2396 * If "arg" is equal to "b:changedtick" give an error and return TRUE.
2397 */
2398 static int
2401 {
2403 {
2406 }
2408 }
2410 /*
2411 * Get an lval: variable, Dict item or List item that can be assigned a value
2412 * to: "name", "na{me}", "name[expr]", "name[expr:expr]", "name[expr][expr]",
2413 * "name.key", "name.key[expr]" etc.
2414 * Indexing only works if "name" is an existing List or Dictionary.
2415 * "name" points to the start of the name.
2416 * If "rettv" is not NULL it points to the value to be assigned.
2417 * "unlet" is TRUE for ":unlet": slightly different behavior when something is
2418 * wrong; must end in space or cmd separator.
2419 *
2420 * Returns a pointer to just after the name, including indexes.
2421 * When an evaluation error occurs "lp->ll_name" is NULL;
2422 * Returns NULL for a parsing error. Still need to free items in "lp"!
2423 */
2433 {
2438 typval_T var1;
2439 typval_T var2;
2446 /* Clear everything in "lp". */
2450 {
2451 /* When skipping just find the end of the name. */
2454 }
2456 /* Find the end of the name. */
2459 {
2460 /* Don't expand the name when we already know there is an error. */
2463 {
2466 }
2470 {
2471 /* Report an invalid expression in braces, unless the
2472 * expression evaluation has been cancelled due to an
2473 * aborting error, an interrupt, or an exception. */
2475 {
2479 }
2480 }
2482 }
2483 else
2486 /* Without [idx] or .key we are done. */
2499 /*
2500 * Loop until no more [idx] or .key is following.
2501 */
2504 {
2508 {
2512 }
2514 {
2518 }
2522 {
2525 ;
2527 {
2531 }
2533 }
2534 else
2535 {
2536 /* Get the index [expr] or the first index [expr: ]. */
2540 else
2541 {
2546 {
2547 /* not a number or string */
2550 }
2551 }
2553 /* Optionally get the second index [ :expr]. */
2555 {
2557 {
2563 }
2566 {
2572 }
2576 else
2577 {
2580 {
2584 }
2586 {
2587 /* not a number or string */
2592 }
2593 }
2595 }
2596 else
2600 {
2608 }
2610 /* Skip to past ']'. */
2612 }
2615 {
2617 {
2618 /* "[key]": get key from "var1" */
2621 {
2626 }
2627 }
2632 {
2633 /* Key does not exist in dict: may need to add it. */
2635 {
2641 }
2644 else
2651 }
2655 }
2656 else
2657 {
2658 /*
2659 * Get the number and item for the only or first index of the List.
2660 */
2663 else
2664 {
2667 }
2672 {
2674 {
2677 }
2678 }
2680 {
2684 }
2686 /*
2687 * May need to find the item or absolute index for the second
2688 * index of a range.
2689 * When no index given: "lp->ll_empty2" is TRUE.
2690 * Otherwise "lp->ll_n2" is set to the second index.
2691 */
2693 {
2697 {
2702 }
2704 /* Check that lp->ll_n2 isn't before lp->ll_n1. */
2709 }
2712 }
2713 }
2716 }
2718 /*
2719 * Clear lval "lp" that was filled by get_lval().
2720 */
2721 static void
2724 {
2727 }
2729 /*
2730 * Set a variable that was parsed by get_lval() to "rettv".
2731 * "endp" points to just after the parsed name.
2732 * "op" is NULL, "+" for "+=", "-" for "-=", "." for ".=" or "=" for "=".
2733 */
2734 static void
2741 {
2747 {
2749 {
2753 {
2754 typval_T tv;
2756 /* handle +=, -= and .= */
2759 {
2763 }
2764 }
2765 else
2768 }
2769 }
2773 ;
2775 {
2776 /*
2777 * Assign the List values to the list items.
2778 */
2780 {
2783 else
2784 {
2787 }
2792 {
2793 /* Need to add an empty item. */
2795 {
2798 }
2799 }
2802 }
2809 }
2810 else
2811 {
2812 /*
2813 * Assign to a List or Dictionary item.
2814 */
2816 {
2818 {
2821 }
2823 /* Need to add an item to the Dictionary. */
2828 {
2831 }
2833 }
2835 {
2838 }
2839 else
2842 /*
2843 * Assign the value to the variable or list item.
2844 */
2847 else
2848 {
2852 }
2853 }
2854 }
2856 /*
2857 * Handle "tv1 += tv2", "tv1 -= tv2" and "tv1 .= tv2"
2858 * Returns OK or FAIL.
2859 */
2860 static int
2865 {
2870 /* Can't do anything with a Funcref or a Dict on the right. */
2872 {
2874 {
2882 /* List += List */
2892 {
2893 /* nr += nr or nr -= nr*/
2895 #ifdef FEAT_FLOAT
2897 {
2902 else
2907 }
2908 else
2909 #endif
2910 {
2913 else
2918 }
2919 }
2920 else
2921 {
2925 /* str .= str */
2931 }
2934 #ifdef FEAT_FLOAT
2936 {
2937 float_T f;
2945 else
2949 else
2951 }
2953 #endif
2954 }
2955 }
2959 }
2961 /*
2962 * Add a watcher to a list.
2963 */
2964 static void
2968 {
2971 }
2973 /*
2974 * Remove a watcher from a list.
2975 * No warning when it isn't found...
2976 */
2977 static void
2981 {
2986 {
2988 {
2991 }
2993 }
2994 }
2996 /*
2997 * Just before removing an item from a list: advance watchers to the next
2998 * item.
2999 */
3000 static void
3004 {
3010 }
3012 /*
3013 * Evaluate the expression used in a ":for var in expr" command.
3014 * "arg" points to "var".
3015 * Set "*errp" to TRUE for an error, FALSE otherwise;
3016 * Return a pointer that holds the info. Null when there is an error.
3017 */
3024 {
3027 typval_T tv;
3042 {
3045 }
3050 {
3053 {
3056 {
3059 }
3060 else
3061 {
3062 /* No need to increment the refcount, it's already set for the
3063 * list being used in "tv". */
3067 }
3068 }
3069 }
3074 }
3076 /*
3077 * Use the first item in a ":for" list. Advance to the next.
3078 * Assign the values to the variable (list). "arg" points to the first one.
3079 * Return TRUE when a valid item was found, FALSE when at end of list or
3080 * something wrong.
3081 */
3082 int
3086 {
3094 else
3095 {
3099 }
3101 }
3103 /*
3104 * Free the structure used to store info used by ":for".
3105 */
3106 void
3109 {
3113 {
3116 }
3118 }
3120 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3122 void
3126 cmdidx_T cmdidx;
3127 {
3133 {
3136 {
3137 /* ":let var1 var2 ...": find last space. */
3139 {
3144 }
3146 }
3147 }
3148 else
3153 {
3156 {
3159 {
3163 }
3165 {
3170 }
3171 }
3173 {
3174 /* environment variable */
3176 }
3178 {
3181 }
3185 {
3186 /* Function name can start with "<SNR>" */
3188 }
3190 {
3192 {
3197 }
3199 {
3200 /* Trick: '' is like stopping and starting a literal string. */
3204 }
3206 {
3208 {
3211 }
3212 else
3214 }
3215 else
3217 }
3218 else
3219 /* Doesn't look like something valid, expand as an expression
3220 * anyway. */
3226 }
3228 }
3232 /*
3233 * ":1,25call func(arg1, arg2)" function call.
3234 */
3235 void
3238 {
3244 typval_T rettv;
3245 linenr_T lnum;
3248 funcdict_T fudi;
3252 {
3253 /* Still need to give an error message for missing key. */
3256 }
3260 /* Increase refcount on dictionary, it could get deleted when evaluating
3261 * the arguments. */
3265 /* If it is the name of a variable of type VAR_FUNC use its contents. */
3269 /* Skip white space to allow ":call func ()". Not good, but required for
3270 * backward compatibility. */
3275 {
3278 }
3280 /*
3281 * When skipping, evaluate the function once, to find the end of the
3282 * arguments.
3283 * When the function takes a range, this is discovered after the first
3284 * call, and the loop is broken.
3285 */
3287 {
3290 }
3291 else
3294 {
3296 {
3299 }
3304 {
3307 }
3309 /* Handle a function returning a Funcref, Dictionary or List. */
3311 {
3314 }
3320 /* Stop when immediately aborting on error, or when an interrupt
3321 * occurred or an exception was thrown but not caught.
3322 * get_func_tv() returned OK, so that the check for trailing
3323 * characters below is executed. */
3326 }
3331 {
3332 /* Check for trailing illegal characters and a following command. */
3334 {
3337 }
3338 else
3340 }
3342 end:
3345 }
3347 /*
3348 * ":unlet[!] var1 ... " command.
3349 */
3350 void
3353 {
3355 }
3357 /*
3358 * ":lockvar" and ":unlockvar" commands
3359 */
3360 void
3363 {
3370 {
3373 }
3376 }
3378 /*
3379 * ":unlet", ":lockvar" and ":unlockvar" are quite similar.
3380 */
3381 static void
3386 {
3390 lval_T lv;
3392 do
3393 {
3394 /* Parse the name and find the end. */
3396 FNE_CHECK_START);
3401 {
3403 {
3406 }
3410 }
3413 {
3415 {
3418 }
3419 else
3420 {
3424 }
3425 }
3434 }
3436 static int
3441 {
3446 {
3450 /* Normal name or expanded name. */
3456 }
3460 {
3463 /* Delete a range of List items. */
3465 {
3470 }
3471 }
3472 else
3473 {
3475 /* unlet a List item. */
3477 else
3478 /* unlet a Dictionary item. */
3480 }
3483 }
3485 /*
3486 * "unlet" a variable. Return OK if it existed, FAIL if not.
3487 * When "forceit" is TRUE don't complain if the variable doesn't exist.
3488 */
3489 int
3493 {
3501 {
3504 {
3511 }
3512 }
3517 }
3519 /*
3520 * Lock or unlock variable indicated by "lp".
3521 * "deep" is the levels to go (-1 for unlimited);
3522 * "lock" is TRUE for ":lockvar", FALSE for ":unlockvar".
3523 */
3524 static int
3530 {
3539 {
3543 /* Normal name or expanded name. */
3546 else
3547 {
3551 else
3552 {
3555 else
3558 }
3559 }
3561 }
3563 {
3566 /* (un)lock a range of List items. */
3568 {
3572 }
3573 }
3575 /* (un)lock a List item. */
3577 else
3578 /* un(lock) a Dictionary item. */
3582 }
3584 /*
3585 * Lock or unlock an item. "deep" is nr of levels to go.
3586 */
3587 static void
3592 {
3601 {
3604 }
3609 /* lock/unlock the item itself */
3612 else
3616 {
3619 {
3622 else
3625 /* recursive: lock/unlock the items the List contains */
3628 }
3632 {
3635 else
3638 {
3639 /* recursive: lock/unlock the items the List contains */
3642 {
3644 {
3647 }
3648 }
3649 }
3650 }
3651 }
3653 }
3655 /*
3656 * Return TRUE if typeval "tv" is locked: Either tha value is locked itself or
3657 * it refers to a List or Dictionary that is locked.
3658 */
3659 static int
3662 {
3670 }
3672 #if (defined(FEAT_MENU) && defined(FEAT_MULTI_LANG)) || defined(PROTO)
3673 /*
3674 * Delete all "menutrans_" variables.
3675 */
3676 void
3678 {
3685 {
3687 {
3691 }
3692 }
3694 }
3695 #endif
3697 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
3699 /*
3700 * Local string buffer for the next two functions to store a variable name
3701 * with its prefix. Allocated in cat_prefix_varname(), freed later in
3702 * get_user_var_name().
3703 */
3710 /*
3711 * Function to concatenate a prefix and a variable name.
3712 */
3717 {
3722 {
3727 {
3730 }
3732 }
3737 }
3739 /*
3740 * Function given to ExpandGeneric() to obtain the list of user defined
3741 * (global/buffer/window/built-in) variable names.
3742 */
3743 /*ARGSUSED*/
3744 char_u *
3748 {
3752 #ifdef FEAT_WINDOWS
3754 #endif
3760 {
3762 #ifdef FEAT_WINDOWS
3764 #endif
3765 }
3767 /* Global variables */
3769 {
3772 else
3779 }
3781 /* b: variables */
3784 {
3787 else
3792 }
3794 {
3797 }
3799 /* w: variables */
3802 {
3805 else
3810 }
3812 #ifdef FEAT_WINDOWS
3813 /* t: variables */
3816 {
3819 else
3824 }
3825 #endif
3827 /* v: variables */
3835 }
3839 /*
3840 * types for expressions.
3841 */
3843 {
3855 /*
3856 * The "evaluate" argument: When FALSE, the argument is only parsed but not
3857 * executed. The function may return OK, but the rettv will be of type
3858 * VAR_UNKNOWN. The function still returns FAIL for a syntax error.
3859 */
3861 /*
3862 * Handle zero level expression.
3863 * This calls eval1() and handles error message and nextcmd.
3864 * Put the result in "rettv" when returning OK and "evaluate" is TRUE.
3865 * Note: "rettv.v_lock" is not set.
3866 * Return OK or FAIL.
3867 */
3868 static int
3874 {
3881 {
3884 /*
3885 * Report the invalid expression unless the expression evaluation has
3886 * been cancelled due to an aborting error, an interrupt, or an
3887 * exception.
3888 */
3892 }
3897 }
3899 /*
3900 * Handle top level expression:
3901 * expr1 ? expr0 : expr0
3902 *
3903 * "arg" must point to the first non-white of the expression.
3904 * "arg" is advanced to the next non-white after the recognized expression.
3905 *
3906 * Note: "rettv.v_lock" is not set.
3907 *
3908 * Return OK or FAIL.
3909 */
3910 static int
3915 {
3917 typval_T var2;
3919 /*
3920 * Get the first variable.
3921 */
3926 {
3929 {
3937 }
3939 /*
3940 * Get the second variable.
3941 */
3946 /*
3947 * Check for the ":".
3948 */
3950 {
3955 }
3957 /*
3958 * Get the third variable.
3959 */
3962 {
3966 }
3969 }
3972 }
3974 /*
3975 * Handle first level expression:
3976 * expr2 || expr2 || expr2 logical OR
3977 *
3978 * "arg" must point to the first non-white of the expression.
3979 * "arg" is advanced to the next non-white after the recognized expression.
3980 *
3981 * Return OK or FAIL.
3982 */
3983 static int
3988 {
3989 typval_T var2;
3994 /*
3995 * Get the first variable.
3996 */
4000 /*
4001 * Repeat until there is no following "||".
4002 */
4006 {
4008 {
4015 }
4017 /*
4018 * Get the second variable.
4019 */
4024 /*
4025 * Compute the result.
4026 */
4028 {
4034 }
4036 {
4039 }
4040 }
4043 }
4045 /*
4046 * Handle second level expression:
4047 * expr3 && expr3 && expr3 logical AND
4048 *
4049 * "arg" must point to the first non-white of the expression.
4050 * "arg" is advanced to the next non-white after the recognized expression.
4051 *
4052 * Return OK or FAIL.
4053 */
4054 static int
4059 {
4060 typval_T var2;
4065 /*
4066 * Get the first variable.
4067 */
4071 /*
4072 * Repeat until there is no following "&&".
4073 */
4077 {
4079 {
4086 }
4088 /*
4089 * Get the second variable.
4090 */
4095 /*
4096 * Compute the result.
4097 */
4099 {
4105 }
4107 {
4110 }
4111 }
4114 }
4116 /*
4117 * Handle third level expression:
4118 * var1 == var2
4119 * var1 =~ var2
4120 * var1 != var2
4121 * var1 !~ var2
4122 * var1 > var2
4123 * var1 >= var2
4124 * var1 < var2
4125 * var1 <= var2
4126 * var1 is var2
4127 * var1 isnot var2
4128 *
4129 * "arg" must point to the first non-white of the expression.
4130 * "arg" is advanced to the next non-white after the recognized expression.
4131 *
4132 * Return OK or FAIL.
4133 */
4134 static int
4139 {
4140 typval_T var2;
4149 regmatch_T regmatch;
4153 /*
4154 * Get the first variable.
4155 */
4161 {
4173 {
4176 }
4177 else
4181 {
4184 }
4185 else
4189 {
4193 {
4196 }
4197 }
4199 }
4201 /*
4202 * If there is a comparative operator, use it.
4203 */
4205 {
4206 /* extra question mark appended: ignore case */
4208 {
4211 }
4212 /* extra '#' appended: match case */
4214 {
4217 }
4218 /* nothing appended: use 'ignorecase' */
4219 else
4222 /*
4223 * Get the second variable.
4224 */
4227 {
4230 }
4233 {
4235 {
4236 /* For "is" a different type always means FALSE, for "notis"
4237 * it means TRUE. */
4239 }
4241 {
4243 {
4248 }
4251 {
4254 else
4259 }
4260 else
4261 {
4262 /* Compare two Lists for being equal or unequal. */
4266 }
4267 }
4270 {
4272 {
4277 }
4280 {
4283 else
4288 }
4289 else
4290 {
4291 /* Compare two Dictionaries for being equal or unequal. */
4295 }
4296 }
4299 {
4302 {
4305 else
4310 }
4311 else
4312 {
4313 /* Compare two Funcrefs for being equal or unequal. */
4317 else
4322 }
4323 }
4325 #ifdef FEAT_FLOAT
4326 /*
4327 * If one of the two variables is a float, compare as a float.
4328 * When using "=~" or "!~", always compare as string.
4329 */
4332 {
4337 else
4341 else
4345 {
4355 }
4356 }
4357 #endif
4359 /*
4360 * If one of the two variables is a number, compare as a number.
4361 * When using "=~" or "!~", always compare as string.
4362 */
4365 {
4369 {
4379 }
4380 }
4381 else
4382 {
4387 else
4391 {
4401 /* avoid 'l' flag in 'cpoptions' */
4408 {
4413 }
4418 }
4419 }
4424 }
4425 }
4428 }
4430 /*
4431 * Handle fourth level expression:
4432 * + number addition
4433 * - number subtraction
4434 * . string concatenation
4435 *
4436 * "arg" must point to the first non-white of the expression.
4437 * "arg" is advanced to the next non-white after the recognized expression.
4438 *
4439 * Return OK or FAIL.
4440 */
4441 static int
4446 {
4447 typval_T var2;
4448 typval_T var3;
4451 #ifdef FEAT_FLOAT
4453 #endif
4458 /*
4459 * Get the first variable.
4460 */
4464 /*
4465 * Repeat computing, until no '+', '-' or '.' is following.
4466 */
4468 {
4474 #ifdef FEAT_FLOAT
4476 #endif
4477 )
4478 {
4479 /* For "list + ...", an illegal use of the first operand as
4480 * a number cannot be determined before evaluating the 2nd
4481 * operand: if this is also a list, all is ok.
4482 * For "something . ...", "something - ..." or "non-list + ...",
4483 * we know that the first operand needs to be a string or number
4484 * without evaluating the 2nd operand. So check before to avoid
4485 * side effects after an error. */
4487 {
4490 }
4491 }
4493 /*
4494 * Get the second variable.
4495 */
4498 {
4501 }
4504 {
4505 /*
4506 * Compute the result.
4507 */
4509 {
4513 {
4517 }
4522 }
4525 {
4526 /* concatenate Lists */
4529 {
4533 }
4536 }
4537 else
4538 {
4541 #ifdef FEAT_FLOAT
4543 {
4546 }
4547 else
4548 #endif
4549 {
4552 {
4553 /* This can only happen for "list + non-list". For
4554 * "non-list + ..." or "something - ...", we returned
4555 * before evaluating the 2nd operand. */
4558 }
4559 #ifdef FEAT_FLOAT
4562 #endif
4563 }
4564 #ifdef FEAT_FLOAT
4566 {
4569 }
4570 else
4571 #endif
4572 {
4575 {
4579 }
4580 #ifdef FEAT_FLOAT
4583 #endif
4584 }
4587 #ifdef FEAT_FLOAT
4588 /* If there is a float on either side the result is a float. */
4590 {
4593 else
4597 }
4598 else
4599 #endif
4600 {
4603 else
4607 }
4608 }
4610 }
4611 }
4613 }
4615 /*
4616 * Handle fifth level expression:
4617 * * number multiplication
4618 * / number division
4619 * % number modulo
4620 *
4621 * "arg" must point to the first non-white of the expression.
4622 * "arg" is advanced to the next non-white after the recognized expression.
4623 *
4624 * Return OK or FAIL.
4625 */
4626 static int
4631 {
4632 typval_T var2;
4635 #ifdef FEAT_FLOAT
4638 #endif
4641 /*
4642 * Get the first variable.
4643 */
4647 /*
4648 * Repeat computing, until no '*', '/' or '%' is following.
4649 */
4651 {
4657 {
4658 #ifdef FEAT_FLOAT
4660 {
4664 }
4665 else
4666 #endif
4671 }
4672 else
4675 /*
4676 * Get the second variable.
4677 */
4683 {
4684 #ifdef FEAT_FLOAT
4686 {
4688 {
4691 }
4694 }
4695 else
4696 #endif
4697 {
4702 #ifdef FEAT_FLOAT
4705 #endif
4706 }
4708 /*
4709 * Compute the result.
4710 * When either side is a float the result is a float.
4711 */
4712 #ifdef FEAT_FLOAT
4714 {
4718 {
4719 /* We rely on the floating point library to handle divide
4720 * by zero to result in "inf" and not a crash. */
4722 }
4723 else
4724 {
4727 }
4730 }
4731 else
4732 #endif
4733 {
4737 {
4739 {
4744 else
4746 }
4747 else
4749 }
4750 else
4751 {
4754 else
4756 }
4759 }
4760 }
4761 }
4764 }
4766 /*
4767 * Handle sixth level expression:
4768 * number number constant
4769 * "string" string constant
4770 * 'string' literal string constant
4771 * &option-name option value
4772 * @r register contents
4773 * identifier variable value
4774 * function() function call
4775 * $VAR environment variable
4776 * (expression) nested expression
4777 * [expr, expr] List
4778 * {key: val, key: val} Dictionary
4779 *
4780 * Also handle:
4781 * ! in front logical NOT
4782 * - in front unary minus
4783 * + in front unary plus (ignored)
4784 * trailing [] subscript in String or List
4785 * trailing .name entry in Dictionary
4786 *
4787 * "arg" must point to the first non-white of the expression.
4788 * "arg" is advanced to the next non-white after the recognized expression.
4789 *
4790 * Return OK or FAIL.
4791 */
4792 static int
4797 {
4805 /*
4806 * Initialise variable so that clear_tv() can't mistake this for a
4807 * string and free a string that isn't there.
4808 */
4811 /*
4812 * Skip '!' and '-' characters. They are handled later.
4813 */
4820 {
4821 /*
4822 * Number constant.
4823 */
4834 {
4835 #ifdef FEAT_FLOAT
4839 /* We accept a float when the format matches
4840 * "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very
4841 * strict to avoid backwards compatibility problems. */
4843 {
4847 {
4853 else
4855 }
4858 }
4860 {
4861 float_T f;
4865 {
4868 }
4869 }
4870 else
4871 #endif
4872 {
4876 {
4879 }
4880 }
4882 }
4884 /*
4885 * String constant: "string".
4886 */
4890 /*
4891 * Literal string constant: 'str''ing'.
4892 */
4896 /*
4897 * List: [expr, expr]
4898 */
4902 /*
4903 * Dictionary: {key: val, key: val}
4904 */
4908 /*
4909 * Option value: &name
4910 */
4914 /*
4915 * Environment variable: $VAR.
4916 */
4920 /*
4921 * Register contents: @r.
4922 */
4925 {
4928 }
4933 /*
4934 * nested expression: (expression).
4935 */
4941 {
4945 }
4950 }
4953 {
4954 /*
4955 * Must be a variable or function name.
4956 * Can also be a curly-braces kind of name: {expr}.
4957 */
4965 else
4966 {
4968 {
4969 /* If "s" is the name of a variable of type VAR_FUNC
4970 * use its contents. */
4973 /* Invoke the function. */
4977 /* Stop the expression evaluation when immediately
4978 * aborting on error, or when an interrupt occurred or
4979 * an exception was thrown but not caught. */
4981 {
4985 }
4986 }
4989 else
4991 }
4995 }
4999 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
5000 * expr(expr). */
5004 /*
5005 * Apply logical NOT and unary '-', from right to left, ignore '+'.
5006 */
5008 {
5011 #ifdef FEAT_FLOAT
5016 else
5017 #endif
5020 {
5023 }
5024 else
5025 {
5027 {
5030 {
5031 #ifdef FEAT_FLOAT
5034 else
5035 #endif
5037 }
5039 {
5040 #ifdef FEAT_FLOAT
5043 else
5044 #endif
5046 }
5047 }
5048 #ifdef FEAT_FLOAT
5050 {
5053 }
5054 else
5055 #endif
5056 {
5060 }
5061 }
5062 }
5065 }
5067 /*
5068 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
5069 * "*arg" points to the '[' or '.'.
5070 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
5071 */
5072 static int
5078 {
5088 #ifdef FEAT_FLOAT
5090 #endif
5091 )
5092 {
5096 }
5099 {
5100 /*
5101 * dict.name
5102 */
5105 ;
5109 }
5110 else
5111 {
5112 /*
5113 * something[idx]
5114 *
5115 * Get the (first) variable from inside the [].
5116 */
5123 {
5124 /* not a number or string */
5127 }
5129 /*
5130 * Get the second variable from inside the [:].
5131 */
5133 {
5139 {
5143 }
5145 {
5146 /* not a number or string */
5151 }
5152 }
5154 /* Check for the ']'. */
5156 {
5163 }
5165 }
5168 {
5171 {
5174 }
5176 {
5179 else
5180 {
5183 }
5184 }
5187 {
5193 {
5194 /* The resulting variable is a substring. If the indexes
5195 * are out of range the result is empty. */
5197 {
5201 }
5208 else
5210 }
5211 else
5212 {
5213 /* The resulting variable is a string of a single
5214 * character. If the index is too big or negative the
5215 * result is empty. */
5218 else
5220 }
5231 {
5232 /* For a range we allow invalid values and return an empty
5233 * list. A list index out of range is an error. */
5235 {
5239 }
5241 }
5243 {
5258 {
5260 {
5263 }
5265 }
5270 }
5271 else
5272 {
5276 }
5281 {
5287 }
5288 {
5292 {
5295 {
5300 }
5301 }
5315 }
5317 }
5318 }
5321 }
5323 /*
5324 * Get an option value.
5325 * "arg" points to the '&' or '+' before the option name.
5326 * "arg" is advanced to character after the option name.
5327 * Return OK or FAIL.
5328 */
5329 static int
5334 {
5344 /*
5345 * Isolate the option name and find its value.
5346 */
5349 {
5353 }
5356 {
5359 }
5367 {
5371 }
5373 {
5375 {
5378 }
5380 {
5383 }
5385 {
5388 }
5390 {
5393 }
5394 }
5402 }
5404 /*
5405 * Allocate a variable for a string constant.
5406 * Return OK or FAIL.
5407 */
5408 static int
5413 {
5418 /*
5419 * Find the end of the string, skipping backslashed characters.
5420 */
5422 {
5424 {
5426 /* A "\<x>" form occupies at least 4 characters, and produces up
5427 * to 6 characters: reserve space for 2 extra */
5430 }
5431 }
5434 {
5437 }
5439 /* If only parsing, set *arg and return here */
5441 {
5444 }
5446 /*
5447 * Copy the string into allocated memory, handling backslashed
5448 * characters.
5449 */
5457 {
5459 {
5461 {
5474 {
5480 else
5484 {
5487 }
5489 #ifdef FEAT_MBYTE
5490 /* For "\u" store the number according to
5491 * 'encoding'. */
5494 else
5495 #endif
5497 }
5500 /* octal: "\1", "\12", "\123" */
5510 {
5514 }
5518 /* Special key, e.g.: "\<C-W>" */
5521 {
5524 }
5525 /* FALLTHROUGH */
5529 }
5530 }
5531 else
5534 }
5539 }
5541 /*
5542 * Allocate a variable for a 'str''ing' constant.
5543 * Return OK or FAIL.
5544 */
5545 static int
5550 {
5555 /*
5556 * Find the end of the string, skipping ''.
5557 */
5559 {
5561 {
5566 }
5567 }
5570 {
5573 }
5575 /* If only parsing return after setting "*arg" */
5577 {
5580 }
5582 /*
5583 * Copy the string into allocated memory, handling '' to ' reduction.
5584 */
5592 {
5594 {
5598 }
5600 }
5605 }
5607 /*
5608 * Allocate a variable for a List and fill it from "*arg".
5609 * Return OK or FAIL.
5610 */
5611 static int
5616 {
5618 typval_T tv;
5622 {
5626 }
5630 {
5634 {
5637 {
5641 }
5642 else
5644 }
5649 {
5652 }
5654 }
5657 {
5659 failret:
5663 }
5667 {
5671 }
5674 }
5676 /*
5677 * Allocate an empty header for a list.
5678 * Caller should take care of the reference count.
5679 */
5680 list_T *
5682 {
5687 {
5688 /* Prepend the list to the list of lists for garbage collection. */
5694 }
5696 }
5698 /*
5699 * Allocate an empty list for a return value.
5700 * Returns OK or FAIL.
5701 */
5702 static int
5705 {
5715 }
5717 /*
5718 * Unreference a list: decrement the reference count and free it when it
5719 * becomes zero.
5720 */
5721 void
5724 {
5727 }
5729 /*
5730 * Free a list, including all items it points to.
5731 * Ignores the reference count.
5732 */
5733 void
5737 {
5740 /* Remove the list from the list of lists for garbage collection. */
5743 else
5749 {
5750 /* Remove the item before deleting it. */
5756 }
5758 }
5760 /*
5761 * Allocate a list item.
5762 */
5765 {
5767 }
5769 /*
5770 * Free a list item. Also clears the value. Does not notify watchers.
5771 */
5772 static void
5775 {
5778 }
5780 /*
5781 * Remove a list item from a List and free it. Also clears the value.
5782 */
5783 static void
5787 {
5790 }
5792 /*
5793 * Get the number of items in a list.
5794 */
5795 static long
5798 {
5802 }
5804 /*
5805 * Return TRUE when two lists have exactly the same values.
5806 */
5807 static int
5812 {
5826 }
5828 #if defined(FEAT_PYTHON) || defined(PROTO)
5829 /*
5830 * Return the dictitem that an entry in a hashtable points to.
5831 */
5832 dictitem_T *
5835 {
5837 }
5838 #endif
5840 /*
5841 * Return TRUE when two dictionaries have exactly the same key/values.
5842 */
5843 static int
5848 {
5860 {
5862 {
5869 }
5870 }
5872 }
5874 /*
5875 * Return TRUE if "tv1" and "tv2" have the same value.
5876 * Compares the items just like "==" would compare them, but strings and
5877 * numbers are different. Floats and numbers are also different.
5878 */
5879 static int
5884 {
5892 /* Catch lists and dicts that have an endless loop by limiting
5893 * recursiveness to 1000. We guess they are equal then. */
5898 {
5919 #ifdef FEAT_FLOAT
5922 #endif
5928 }
5932 }
5934 /*
5935 * Locate item with index "n" in list "l" and return it.
5936 * A negative index is counted from the end; -1 is the last item.
5937 * Returns NULL when "n" is out of range.
5938 */
5943 {
5950 /* Negative index is relative to the end. */
5954 /* Check for index out of range. */
5958 /* When there is a cached index may start search from there. */
5960 {
5962 {
5963 /* closest to the start of the list */
5966 }
5968 {
5969 /* closest to the end of the list */
5972 }
5973 else
5974 {
5975 /* closest to the cached index */
5978 }
5979 }
5980 else
5981 {
5983 {
5984 /* closest to the start of the list */
5987 }
5988 else
5989 {
5990 /* closest to the end of the list */
5993 }
5994 }
5997 {
5998 /* search forward */
6001 }
6003 {
6004 /* search backward */
6007 }
6009 /* cache the used index */
6014 }
6016 /*
6017 * Get list item "l[idx]" as a number.
6018 */
6019 static long
6024 {
6029 {
6033 }
6035 }
6037 /*
6038 * Locate "item" list "l" and return its index.
6039 * Returns -1 when "item" is not in the list.
6040 */
6041 static long
6045 {
6057 }
6059 /*
6060 * Append item "item" to the end of list "l".
6061 */
6062 static void
6066 {
6068 {
6069 /* empty list */
6073 }
6074 else
6075 {
6079 }
6082 }
6084 /*
6085 * Append typval_T "tv" to the end of list "l".
6086 * Return FAIL when out of memory.
6087 */
6088 static int
6092 {
6100 }
6102 /*
6103 * Add a dictionary to a list. Used by getqflist().
6104 * Return FAIL when out of memory.
6105 */
6106 int
6110 {
6121 }
6123 /*
6124 * Make a copy of "str" and append it as an item to list "l".
6125 * When "len" >= 0 use "str[len]".
6126 * Returns FAIL when out of memory.
6127 */
6128 static int
6133 {
6147 }
6149 /*
6150 * Append "n" to list "l".
6151 * Returns FAIL when out of memory.
6152 */
6153 static int
6156 varnumber_T n;
6157 {
6168 }
6170 /*
6171 * Insert typval_T "tv" in list "l" before "item".
6172 * If "item" is NULL append at the end.
6173 * Return FAIL when out of memory.
6174 */
6175 static int
6180 {
6187 /* Append new item at end of list. */
6189 else
6190 {
6191 /* Insert new item before existing item. */
6195 {
6198 }
6199 else
6200 {
6203 }
6206 }
6208 }
6210 /*
6211 * Extend "l1" with "l2".
6212 * If "bef" is NULL append at the end, otherwise insert before this item.
6213 * Returns FAIL when out of memory.
6214 */
6215 static int
6220 {
6227 }
6229 /*
6230 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
6231 * Return FAIL when out of memory.
6232 */
6233 static int
6238 {
6241 /* make a copy of the first list. */
6248 /* append all items from the second list */
6250 }
6252 /*
6253 * Make a copy of list "orig". Shallow if "deep" is FALSE.
6254 * The refcount of the new list is set to 1.
6255 * See item_copy() for "copyID".
6256 * Returns NULL when out of memory.
6257 */
6263 {
6273 {
6275 {
6276 /* Do this before adding the items, because one of the items may
6277 * refer back to this list. */
6280 }
6283 {
6288 {
6290 {
6293 }
6294 }
6295 else
6298 }
6301 {
6304 }
6305 }
6308 }
6310 /*
6311 * Remove items "item" to "item2" from list "l".
6312 * Does not free the listitem or the value!
6313 */
6314 static void
6319 {
6322 /* notify watchers */
6324 {
6329 }
6333 else
6337 else
6340 }
6342 /*
6343 * Return an allocated string with the string representation of a list.
6344 * May return NULL.
6345 */
6350 {
6351 garray_T ga;
6358 {
6361 }
6365 }
6367 /*
6368 * Join list "l" into a string in "*gap", using separator "sep".
6369 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6370 * Return FAIL or OK.
6371 */
6372 static int
6379 {
6387 {
6390 else
6395 else
6402 }
6404 }
6406 /*
6407 * Garbage collection for lists and dictionaries.
6408 *
6409 * We use reference counts to be able to free most items right away when they
6410 * are no longer used. But for composite items it's possible that it becomes
6411 * unused while the reference count is > 0: When there is a recursive
6412 * reference. Example:
6413 * :let l = [1, 2, 3]
6414 * :let d = {9: l}
6415 * :let l[1] = d
6416 *
6417 * Since this is quite unusual we handle this with garbage collection: every
6418 * once in a while find out which lists and dicts are not referenced from any
6419 * variable.
6420 *
6421 * Here is a good reference text about garbage collection (refers to Python
6422 * but it applies to all reference-counting mechanisms):
6423 * http://python.ca/nas/python/gc/
6424 */
6426 /*
6427 * Do garbage collection for lists and dicts.
6428 * Return TRUE if some memory was freed.
6429 */
6430 int
6432 {
6441 #ifdef FEAT_WINDOWS
6443 #endif
6445 /* Only do this once. */
6450 /*
6451 * 1. Go through all accessible variables and mark all lists and dicts
6452 * with copyID.
6453 */
6454 /* script-local variables */
6458 /* buffer-local variables */
6462 /* window-local variables */
6466 #ifdef FEAT_WINDOWS
6467 /* tabpage-local variables */
6470 #endif
6472 /* global variables */
6475 /* function-local variables */
6477 {
6480 }
6482 /*
6483 * 2. Go through the list of dicts and free items without the copyID.
6484 */
6487 {
6488 /* Free the Dictionary and ordinary items it contains, but don't
6489 * recurse into Lists and Dictionaries, they will be in the list
6490 * of dicts or list of lists. */
6494 /* restart, next dict may also have been freed */
6496 }
6497 else
6500 /*
6501 * 3. Go through the list of lists and free items without the copyID.
6502 * But don't free a list that has a watcher (used in a for loop), these
6503 * are not referenced anywhere.
6504 */
6507 {
6508 /* Free the List and ordinary items it contains, but don't recurse
6509 * into Lists and Dictionaries, they will be in the list of dicts
6510 * or list of lists. */
6514 /* restart, next list may also have been freed */
6516 }
6517 else
6521 }
6523 /*
6524 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6525 */
6526 static void
6530 {
6537 {
6540 }
6541 }
6543 /*
6544 * Mark all lists and dicts referenced through list "l" with "copyID".
6545 */
6546 static void
6550 {
6555 }
6557 /*
6558 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6559 */
6560 static void
6564 {
6569 {
6573 {
6574 /* Didn't see this dict yet. */
6577 }
6583 {
6584 /* Didn't see this list yet. */
6587 }
6589 }
6591 }
6593 /*
6594 * Allocate an empty header for a dictionary.
6595 */
6596 dict_T *
6598 {
6603 {
6604 /* Add the list to the list of dicts for garbage collection. */
6615 }
6617 }
6619 /*
6620 * Unreference a Dictionary: decrement the reference count and free it when it
6621 * becomes zero.
6622 */
6623 static void
6626 {
6629 }
6631 /*
6632 * Free a Dictionary, including all items it contains.
6633 * Ignores the reference count.
6634 */
6635 static void
6639 {
6644 /* Remove the dict from the list of dicts for garbage collection. */
6647 else
6652 /* Lock the hashtab, we don't want it to resize while freeing items. */
6656 {
6658 {
6659 /* Remove the item before deleting it, just in case there is
6660 * something recursive causing trouble. */
6668 }
6669 }
6672 }
6674 /*
6675 * Allocate a Dictionary item.
6676 * The "key" is copied to the new item.
6677 * Note that the value of the item "di_tv" still needs to be initialized!
6678 * Returns NULL when out of memory.
6679 */
6683 {
6688 {
6691 }
6693 }
6695 /*
6696 * Make a copy of a Dictionary item.
6697 */
6701 {
6707 {
6711 }
6713 }
6715 /*
6716 * Remove item "item" from Dictionary "dict" and free it.
6717 */
6718 static void
6722 {
6728 else
6731 }
6733 /*
6734 * Free a dict item. Also clears the value.
6735 */
6736 static void
6739 {
6742 }
6744 /*
6745 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6746 * The refcount of the new dict is set to 1.
6747 * See item_copy() for "copyID".
6748 * Returns NULL when out of memory.
6749 */
6755 {
6766 {
6768 {
6771 }
6774 {
6776 {
6783 {
6786 {
6789 }
6790 }
6791 else
6794 {
6797 }
6798 }
6799 }
6803 {
6806 }
6807 }
6810 }
6812 /*
6813 * Add item "item" to Dictionary "d".
6814 * Returns FAIL when out of memory and when key already existed.
6815 */
6816 static int
6820 {
6822 }
6824 /*
6825 * Add a number or string entry to dictionary "d".
6826 * When "str" is NULL use number "nr", otherwise use "str".
6827 * Returns FAIL when out of memory and when key already exists.
6828 */
6829 int
6835 {
6843 {
6846 }
6847 else
6848 {
6851 }
6853 {
6856 }
6858 }
6860 /*
6861 * Get the number of items in a Dictionary.
6862 */
6863 static long
6866 {
6870 }
6872 /*
6873 * Find item "key[len]" in Dictionary "d".
6874 * If "len" is negative use strlen(key).
6875 * Returns NULL when not found.
6876 */
6882 {
6883 #define AKEYLEN 200
6892 {
6896 }
6897 else
6898 {
6899 /* Avoid a malloc/free by using buf[]. */
6902 }
6909 }
6911 /*
6912 * Get a string item from a dictionary.
6913 * When "save" is TRUE allocate memory for it.
6914 * Returns NULL if the entry doesn't exist or out of memory.
6915 */
6916 char_u *
6921 {
6932 }
6934 /*
6935 * Get a number item from a dictionary.
6936 * Returns 0 if the entry doesn't exist or out of memory.
6937 */
6938 long
6942 {
6949 }
6951 /*
6952 * Return an allocated string with the string representation of a Dictionary.
6953 * May return NULL.
6954 */
6959 {
6960 garray_T ga;
6976 {
6978 {
6983 else
6988 {
6991 }
6999 }
7000 }
7002 {
7005 }
7010 }
7012 /*
7013 * Allocate a variable for a Dictionary and fill it from "*arg".
7014 * Return OK or FAIL. Returns NOTDONE for {expr}.
7015 */
7016 static int
7021 {
7023 typval_T tvkey;
7024 typval_T tv;
7030 /*
7031 * First check if it's not a curly-braces thing: {expr}.
7032 * Must do this without evaluating, otherwise a function may be called
7033 * twice. Unfortunately this means we need to call eval1() twice for the
7034 * first item.
7035 * But {} is an empty Dictionary.
7036 */
7038 {
7043 }
7046 {
7050 }
7056 {
7060 {
7064 }
7066 {
7069 {
7070 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
7075 }
7076 }
7080 {
7084 }
7086 {
7089 {
7094 }
7098 {
7103 }
7104 }
7109 {
7112 }
7114 }
7117 {
7119 failret:
7123 }
7127 {
7131 }
7134 }
7136 /*
7137 * Return a string with the string representation of a variable.
7138 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7139 * "numbuf" is used for a number.
7140 * Does not put quotes around strings, as ":echo" displays values.
7141 * When "copyID" is not NULL replace recursive lists and dicts with "...".
7142 * May return NULL.
7143 */
7150 {
7155 {
7159 }
7163 {
7171 {
7174 }
7176 {
7179 }
7180 else
7181 {
7185 }
7190 {
7193 }
7195 {
7198 }
7199 else
7200 {
7204 }
7213 #ifdef FEAT_FLOAT
7219 #endif
7224 }
7228 }
7230 /*
7231 * Return a string with the string representation of a variable.
7232 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7233 * "numbuf" is used for a number.
7234 * Puts quotes around strings, so that they can be parsed back by eval().
7235 * May return NULL.
7236 */
7243 {
7245 {
7252 #ifdef FEAT_FLOAT
7257 #endif
7264 }
7266 }
7268 /*
7269 * Return string "str" in ' quotes, doubling ' characters.
7270 * If "str" is NULL an empty string is assumed.
7271 * If "function" is TRUE make it function('string').
7272 */
7277 {
7283 {
7288 }
7291 {
7293 {
7296 }
7297 else
7301 {
7305 }
7310 }
7312 }
7314 #ifdef FEAT_FLOAT
7315 /*
7316 * Convert the string "text" to a floating point number.
7317 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
7318 * this always uses a decimal point.
7319 * Returns the length of the text that was consumed.
7320 */
7321 static int
7325 {
7327 float_T f;
7332 }
7333 #endif
7335 /*
7336 * Get the value of an environment variable.
7337 * "arg" is pointing to the '$'. It is advanced to after the name.
7338 * If the environment variable was not set, silently assume it is empty.
7339 * Always return OK.
7340 */
7341 static int
7346 {
7357 {
7359 {
7362 /* first try vim_getenv(), fast for normal environment vars */
7365 {
7368 }
7369 else
7370 {
7374 /* next try expanding things like $VIM and ${HOME} */
7377 {
7380 }
7381 }
7383 }
7386 }
7389 }
7391 /*
7392 * Array with names and number of arguments of all internal functions
7393 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7394 */
7395 static struct fst
7396 {
7401 /* implementation of function */
7403 {
7404 #ifdef FEAT_FLOAT
7406 #endif
7412 #ifdef FEAT_FLOAT
7414 #endif
7429 #ifdef FEAT_FLOAT
7431 #endif
7437 #if defined(FEAT_INS_EXPAND)
7441 #endif
7444 #ifdef FEAT_FLOAT
7446 #endif
7470 #ifdef FEAT_FLOAT
7473 #endif
7548 #ifdef FEAT_FLOAT
7550 #endif
7563 #ifdef vim_mkdir
7565 #endif
7570 #ifdef FEAT_FLOAT
7572 #endif
7590 #ifdef FEAT_FLOAT
7592 #endif
7612 #ifdef FEAT_FLOAT
7614 #endif
7620 #ifdef FEAT_FLOAT
7623 #endif
7625 #ifdef HAVE_STRFTIME
7627 #endif
7651 #ifdef FEAT_FLOAT
7653 #endif
7668 };
7670 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7672 /*
7673 * Function given to ExpandGeneric() to obtain the list of internal
7674 * or user defined function names.
7675 */
7676 char_u *
7680 {
7687 {
7691 }
7693 {
7699 }
7702 }
7704 /*
7705 * Function given to ExpandGeneric() to obtain the list of internal or
7706 * user defined variable or function names.
7707 */
7708 /*ARGSUSED*/
7709 char_u *
7713 {
7720 {
7724 }
7726 }
7730 /*
7731 * Find internal function in table above.
7732 * Return index, or -1 if not found
7733 */
7734 static int
7737 {
7743 /*
7744 * Find the function name in the table. Binary search.
7745 */
7747 {
7754 else
7756 }
7758 }
7760 /*
7761 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7762 * name it contains, otherwise return "name".
7763 */
7768 {
7777 {
7779 {
7782 }
7785 }
7788 }
7790 /*
7791 * Allocate a variable for the result of a function.
7792 * Return OK or FAIL.
7793 */
7794 static int
7806 {
7812 /*
7813 * Get the arguments.
7814 */
7817 {
7822 {
7825 }
7829 }
7832 else
7839 {
7842 else
7844 }
7851 }
7854 /*
7855 * Call a function with its resolved parameters
7856 * Return OK when the function can't be called, FAIL otherwise.
7857 * Also returns OK when an error was encountered while executing the function.
7858 */
7859 static int
7867 PLUS ONE elements! */
7873 {
7875 #define ERROR_UNKNOWN 0
7876 #define ERROR_TOOMANY 1
7877 #define ERROR_TOOFEW 2
7878 #define ERROR_SCRIPT 3
7879 #define ERROR_DICT 4
7880 #define ERROR_NONE 5
7881 #define ERROR_OTHER 6
7887 #define FLEN_FIXED 40
7891 /*
7892 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7893 * Change <SNR>123_name() to K_SNR 123_name().
7894 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7895 */
7900 {
7906 {
7909 else
7910 {
7913 }
7914 }
7916 {
7919 }
7920 else
7921 {
7925 else
7926 {
7929 }
7930 }
7931 }
7932 else
7938 /* execute the function if no errors detected and executing */
7940 {
7945 {
7946 /*
7947 * User defined function.
7948 */
7951 #ifdef FEAT_AUTOCMD
7952 /* Trigger FuncUndefined event, may load the function. */
7957 {
7958 /* executed an autocommand, search for the function again */
7960 }
7961 #endif
7962 /* Try loading a package. */
7964 {
7965 /* loaded a package, search for the function again */
7967 }
7970 {
7979 else
7980 {
7981 /*
7982 * Call the user function.
7983 * Save and restore search patterns, script variables and
7984 * redo buffer.
7985 */
7994 /* Function was unreferenced while being used, free it
7995 * now. */
8000 }
8001 }
8002 }
8003 else
8004 {
8005 /*
8006 * Find the function name in the table, call its implementation.
8007 */
8010 {
8015 else
8016 {
8020 }
8021 }
8022 }
8023 /*
8024 * The function call (or "FuncUndefined" autocommand sequence) might
8025 * have been aborted by an error, an interrupt, or an explicitly thrown
8026 * exception that has not been caught so far. This situation can be
8027 * tested for by calling aborting(). For an error in an internal
8028 * function or for the "E132" error in call_user_func(), however, the
8029 * throw point at which the "force_abort" flag (temporarily reset by
8030 * emsg()) is normally updated has not been reached yet. We need to
8031 * update that flag first to make aborting() reliable.
8032 */
8034 }
8038 /*
8039 * Report an error unless the argument evaluation or function call has been
8040 * cancelled due to an aborting error, an interrupt, or an exception.
8041 */
8043 {
8045 {
8054 name);
8058 name);
8062 name);
8064 }
8065 }
8072 }
8074 /*
8075 * Give an error message with a function name. Handle <SNR> things.
8076 */
8077 static void
8081 {
8086 else
8091 }
8093 /*********************************************
8094 * Implementation of the built-in functions
8095 */
8097 #ifdef FEAT_FLOAT
8098 /*
8099 * "abs(expr)" function
8100 */
8101 static void
8105 {
8107 {
8110 }
8111 else
8112 {
8113 varnumber_T n;
8121 else
8123 }
8124 }
8125 #endif
8127 /*
8128 * "add(list, item)" function
8129 */
8130 static void
8134 {
8139 {
8144 }
8145 else
8147 }
8149 /*
8150 * "append(lnum, string/list)" function
8151 */
8152 static void
8156 {
8168 {
8170 {
8175 }
8178 {
8183 else
8187 {
8190 }
8196 }
8201 }
8202 else
8204 }
8206 /*
8207 * "argc()" function
8208 */
8209 /* ARGSUSED */
8210 static void
8214 {
8216 }
8218 /*
8219 * "argidx()" function
8220 */
8221 /* ARGSUSED */
8222 static void
8226 {
8228 }
8230 /*
8231 * "argv(nr)" function
8232 */
8233 static void
8237 {
8241 {
8245 else
8248 }
8253 }
8255 #ifdef FEAT_FLOAT
8258 /*
8259 * Get the float value of "argvars[0]" into "f".
8260 * Returns FAIL when the argument is not a Number or Float.
8261 */
8262 static int
8266 {
8268 {
8271 }
8273 {
8276 }
8279 }
8281 /*
8282 * "atan()" function
8283 */
8284 static void
8288 {
8289 float_T f;
8294 else
8296 }
8297 #endif
8299 /*
8300 * "browse(save, title, initdir, default)" function
8301 */
8302 /* ARGSUSED */
8303 static void
8307 {
8308 #ifdef FEAT_BROWSE
8324 else
8328 #else
8330 #endif
8332 }
8334 /*
8335 * "browsedir(title, initdir)" function
8336 */
8337 /* ARGSUSED */
8338 static void
8342 {
8343 #ifdef FEAT_BROWSE
8353 else
8356 #else
8358 #endif
8360 }
8364 /*
8365 * Find a buffer by number or exact name.
8366 */
8370 {
8376 {
8379 {
8380 /* No full path name match, try a match with a URL or a "nofile"
8381 * buffer, these don't use the full path. */
8385 #ifdef FEAT_QUICKFIX
8387 #endif
8388 )
8391 }
8392 }
8394 }
8396 /*
8397 * "bufexists(expr)" function
8398 */
8399 static void
8403 {
8405 }
8407 /*
8408 * "buflisted(expr)" function
8409 */
8410 static void
8414 {
8419 }
8421 /*
8422 * "bufloaded(expr)" function
8423 */
8424 static void
8428 {
8433 }
8437 /*
8438 * Get buffer by number or pattern.
8439 */
8443 {
8458 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8470 /* If not found, try expanding the name, like done for bufexists(). */
8475 }
8477 /*
8478 * "bufname(expr)" function
8479 */
8480 static void
8484 {
8493 else
8496 }
8498 /*
8499 * "bufnr(expr)" function
8500 */
8501 static void
8505 {
8515 /* If the buffer isn't found and the second argument is not zero create a
8516 * new buffer. */
8520 && !error
8527 else
8529 }
8531 /*
8532 * "bufwinnr(nr)" function
8533 */
8534 static void
8538 {
8539 #ifdef FEAT_WINDOWS
8542 #endif
8548 #ifdef FEAT_WINDOWS
8550 {
8554 }
8556 #else
8558 #endif
8560 }
8562 /*
8563 * "byte2line(byte)" function
8564 */
8565 /*ARGSUSED*/
8566 static void
8570 {
8571 #ifndef FEAT_BYTEOFF
8573 #else
8579 else
8582 #endif
8583 }
8585 /*
8586 * "byteidx()" function
8587 */
8588 /*ARGSUSED*/
8589 static void
8593 {
8594 #ifdef FEAT_MBYTE
8596 #endif
8606 #ifdef FEAT_MBYTE
8609 {
8613 }
8615 #else
8618 #endif
8619 }
8621 /*
8622 * "call(func, arglist)" function
8623 */
8624 static void
8628 {
8638 {
8641 }
8647 else
8653 {
8655 {
8658 }
8660 }
8664 {
8666 {
8669 }
8670 /* Make a copy of each argument. This is needed to be able to set
8671 * v_lock to VAR_FIXED in the copy without changing the original list.
8672 */
8674 }
8681 /* Free the arguments. */
8684 }
8686 #ifdef FEAT_FLOAT
8687 /*
8688 * "ceil({float})" function
8689 */
8690 static void
8694 {
8695 float_T f;
8700 else
8702 }
8703 #endif
8705 /*
8706 * "changenr()" function
8707 */
8708 /*ARGSUSED*/
8709 static void
8713 {
8715 }
8717 /*
8718 * "char2nr(string)" function
8719 */
8720 static void
8724 {
8725 #ifdef FEAT_MBYTE
8728 else
8729 #endif
8731 }
8733 /*
8734 * "cindent(lnum)" function
8735 */
8736 static void
8740 {
8741 #ifdef FEAT_CINDENT
8742 pos_T pos;
8743 linenr_T lnum;
8748 {
8752 }
8753 else
8754 #endif
8756 }
8758 /*
8759 * "clearmatches()" function
8760 */
8761 /*ARGSUSED*/
8762 static void
8766 {
8767 #ifdef FEAT_SEARCH_EXTRA
8769 #endif
8770 }
8772 /*
8773 * "col(string)" function
8774 */
8775 static void
8779 {
8786 {
8788 {
8789 /* '> can be MAXCOL, get the length of the line then */
8792 else
8794 }
8795 else
8796 {
8798 #ifdef FEAT_VIRTUALEDIT
8799 /* col(".") when the cursor is on the NUL at the end of the line
8800 * because of "coladd" can be seen as an extra column. */
8802 {
8807 {
8808 # ifdef FEAT_MBYTE
8813 # else
8816 # endif
8817 }
8818 }
8819 #endif
8820 }
8821 }
8823 }
8825 #if defined(FEAT_INS_EXPAND)
8826 /*
8827 * "complete()" function
8828 */
8829 /*ARGSUSED*/
8830 static void
8834 {
8838 {
8841 }
8843 /* Check for undo allowed here, because if something was already inserted
8844 * the line was already saved for undo and this check isn't done. */
8849 {
8852 }
8859 }
8861 /*
8862 * "complete_add()" function
8863 */
8864 /*ARGSUSED*/
8865 static void
8869 {
8871 }
8873 /*
8874 * "complete_check()" function
8875 */
8876 /*ARGSUSED*/
8877 static void
8881 {
8888 }
8889 #endif
8891 /*
8892 * "confirm(message, buttons[, default [, type]])" function
8893 */
8894 /*ARGSUSED*/
8895 static void
8899 {
8900 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8914 {
8919 {
8922 {
8926 else
8927 {
8929 {
8935 }
8936 }
8937 }
8938 }
8939 }
8946 else
8949 #else
8951 #endif
8952 }
8954 /*
8955 * "copy()" function
8956 */
8957 static void
8961 {
8963 }
8965 #ifdef FEAT_FLOAT
8966 /*
8967 * "cos()" function
8968 */
8969 static void
8973 {
8974 float_T f;
8979 else
8981 }
8982 #endif
8984 /*
8985 * "count()" function
8986 */
8987 static void
8991 {
8996 {
9002 {
9005 {
9010 {
9013 {
9017 }
9018 }
9021 }
9026 }
9027 }
9029 {
9035 {
9039 {
9043 }
9047 {
9049 {
9053 }
9054 }
9055 }
9056 }
9057 else
9060 }
9062 /*
9063 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
9064 *
9065 * Checks the existence of a cscope connection.
9066 */
9067 /*ARGSUSED*/
9068 static void
9072 {
9073 #ifdef FEAT_CSCOPE
9081 {
9086 }
9089 #else
9091 #endif
9092 }
9094 /*
9095 * "cursor(lnum, col)" function
9096 *
9097 * Moves the cursor to the specified line and column
9098 */
9099 /*ARGSUSED*/
9100 static void
9104 {
9106 #ifdef FEAT_VIRTUALEDIT
9108 #endif
9111 {
9112 pos_T pos;
9118 #ifdef FEAT_VIRTUALEDIT
9120 #endif
9121 }
9122 else
9123 {
9126 #ifdef FEAT_VIRTUALEDIT
9129 #endif
9130 }
9132 #ifdef FEAT_VIRTUALEDIT
9134 #endif
9135 )
9141 #ifdef FEAT_VIRTUALEDIT
9143 #endif
9145 /* Make sure the cursor is in a valid position. */
9147 #ifdef FEAT_MBYTE
9148 /* Correct cursor for multi-byte character. */
9151 #endif
9154 }
9156 /*
9157 * "deepcopy()" function
9158 */
9159 static void
9163 {
9170 else
9172 }
9174 /*
9175 * "delete()" function
9176 */
9177 static void
9181 {
9184 else
9186 }
9188 /*
9189 * "did_filetype()" function
9190 */
9191 /*ARGSUSED*/
9192 static void
9196 {
9197 #ifdef FEAT_AUTOCMD
9199 #else
9201 #endif
9202 }
9204 /*
9205 * "diff_filler()" function
9206 */
9207 /*ARGSUSED*/
9208 static void
9212 {
9213 #ifdef FEAT_DIFF
9215 #endif
9216 }
9218 /*
9219 * "diff_hlID()" function
9220 */
9221 /*ARGSUSED*/
9222 static void
9226 {
9227 #ifdef FEAT_DIFF
9243 {
9244 /* New line, buffer, change: need to get the values. */
9247 {
9249 {
9254 else
9256 }
9257 else
9259 }
9260 else
9265 }
9268 {
9272 else
9274 }
9276 #endif
9277 }
9279 /*
9280 * "empty({expr})" function
9281 */
9282 static void
9286 {
9290 {
9299 #ifdef FEAT_FLOAT
9303 #endif
9315 }
9318 }
9320 /*
9321 * "escape({string}, {chars})" function
9322 */
9323 static void
9327 {
9333 }
9335 /*
9336 * "eval()" function
9337 */
9338 /*ARGSUSED*/
9339 static void
9343 {
9351 {
9354 }
9357 }
9359 /*
9360 * "eventhandler()" function
9361 */
9362 /*ARGSUSED*/
9363 static void
9367 {
9369 }
9371 /*
9372 * "executable()" function
9373 */
9374 static void
9378 {
9380 }
9382 /*
9383 * "exists()" function
9384 */
9385 static void
9389 {
9397 {
9398 /* first try "normal" environment variables (fast) */
9401 else
9402 {
9403 /* try expanding things like $VIM and ${HOME} */
9408 }
9409 }
9411 {
9415 }
9417 {
9419 }
9421 {
9423 }
9425 {
9426 #ifdef FEAT_AUTOCMD
9429 else
9431 #endif
9432 }
9434 {
9436 typval_T tv;
9438 /* get_name_len() takes care of expanding curly braces */
9442 {
9447 {
9448 /* handle d.key, l[idx], f(expr) */
9452 }
9453 }
9458 }
9461 }
9463 /*
9464 * "expand()" function
9465 */
9466 static void
9470 {
9475 expand_T xpc;
9481 {
9485 }
9486 else
9487 {
9488 /* When the optional second argument is non-zero, don't remove matches
9489 * for 'suffixes' and 'wildignore' */
9494 {
9498 }
9499 else
9501 }
9502 }
9504 /*
9505 * "extend(list, list [, idx])" function
9506 * "extend(dict, dict [, action])" function
9507 */
9508 static void
9512 {
9515 {
9525 {
9527 {
9534 else
9535 {
9538 {
9541 }
9542 }
9543 }
9544 else
9549 }
9550 }
9552 {
9564 {
9565 /* Check the third argument. */
9567 {
9577 {
9580 }
9581 }
9582 else
9585 /* Go over all entries in the second dict and add them to the
9586 * first dict. */
9589 {
9591 {
9595 {
9599 }
9601 {
9604 }
9606 {
9609 }
9610 }
9611 }
9614 }
9615 }
9616 else
9618 }
9620 /*
9621 * "feedkeys()" function
9622 */
9623 /*ARGSUSED*/
9624 static void
9628 {
9635 /* This is not allowed in the sandbox. If the commands would still be
9636 * executed in the sandbox it would be OK, but it probably happens later,
9637 * when "sandbox" is no longer set. */
9644 {
9646 {
9649 {
9651 {
9655 }
9656 }
9657 }
9659 /* Need to escape K_SPECIAL and CSI before putting the string in the
9660 * typeahead buffer. */
9663 {
9669 }
9670 }
9671 }
9673 /*
9674 * "filereadable()" function
9675 */
9676 static void
9680 {
9687 {
9690 }
9691 else
9695 }
9697 /*
9698 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9699 * rights to write into.
9700 */
9701 static void
9705 {
9707 }
9711 static void
9716 {
9717 #ifdef FEAT_SEARCHPATH
9726 #endif
9731 #ifdef FEAT_SEARCHPATH
9735 {
9739 else
9740 {
9746 }
9747 }
9753 {
9754 do
9755 {
9761 find_what,
9763 find_what == FINDFILE_DIR
9771 }
9775 #endif
9776 }
9781 /*
9782 * Implementation of map() and filter().
9783 */
9784 static void
9789 {
9798 typval_T save_val;
9799 typval_T save_key;
9807 {
9811 }
9813 {
9817 }
9818 else
9819 {
9822 }
9825 /* On type errors, the preceding call has already displayed an error
9826 * message. Avoid a misleading error message for an empty string that
9827 * was not passed as argument. */
9829 {
9833 /* We reset "did_emsg" to be able to detect whether an error
9834 * occurred during evaluation of the expression. */
9839 {
9847 {
9849 {
9861 }
9862 }
9866 }
9867 else
9868 {
9870 {
9879 }
9880 }
9885 }
9888 }
9890 static int
9896 {
9897 typval_T rettv;
9906 {
9909 }
9911 {
9912 /* map(): replace the list item value */
9916 }
9917 else
9918 {
9921 /* filter(): when expr is zero remove the item */
9924 /* On type error, nothing has been removed; return FAIL to stop the
9925 * loop. The error message was given by get_tv_number_chk(). */
9928 }
9930 theend:
9933 }
9935 /*
9936 * "filter()" function
9937 */
9938 static void
9942 {
9944 }
9946 /*
9947 * "finddir({fname}[, {path}[, {count}]])" function
9948 */
9949 static void
9953 {
9955 }
9957 /*
9958 * "findfile({fname}[, {path}[, {count}]])" function
9959 */
9960 static void
9964 {
9966 }
9968 #ifdef FEAT_FLOAT
9969 /*
9970 * "float2nr({float})" function
9971 */
9972 static void
9976 {
9977 float_T f;
9980 {
9985 else
9987 }
9988 else
9990 }
9992 /*
9993 * "floor({float})" function
9994 */
9995 static void
9999 {
10000 float_T f;
10005 else
10007 }
10008 #endif
10010 /*
10011 * "fnameescape({string})" function
10012 */
10013 static void
10017 {
10021 }
10023 /*
10024 * "fnamemodify({fname}, {mods})" function
10025 */
10026 static void
10030 {
10042 else
10043 {
10046 }
10051 else
10054 }
10058 /*
10059 * "foldclosed()" function
10060 */
10061 static void
10066 {
10067 #ifdef FEAT_FOLDING
10068 linenr_T lnum;
10073 {
10075 {
10078 else
10081 }
10082 }
10083 #endif
10085 }
10087 /*
10088 * "foldclosed()" function
10089 */
10090 static void
10094 {
10096 }
10098 /*
10099 * "foldclosedend()" function
10100 */
10101 static void
10105 {
10107 }
10109 /*
10110 * "foldlevel()" function
10111 */
10112 static void
10116 {
10117 #ifdef FEAT_FOLDING
10118 linenr_T lnum;
10123 else
10124 #endif
10126 }
10128 /*
10129 * "foldtext()" function
10130 */
10131 /*ARGSUSED*/
10132 static void
10136 {
10137 #ifdef FEAT_FOLDING
10138 linenr_T lnum;
10143 #endif
10147 #ifdef FEAT_FOLDING
10152 {
10153 /* Find first non-empty line in the fold. */
10156 {
10160 }
10162 /* Find interesting text in this line. */
10164 /* skip C comment-start */
10166 {
10170 {
10174 }
10175 }
10182 {
10188 /* remove 'foldmarker' and 'commentstring' */
10191 }
10192 }
10193 #endif
10194 }
10196 /*
10197 * "foldtextresult(lnum)" function
10198 */
10199 /*ARGSUSED*/
10200 static void
10204 {
10205 #ifdef FEAT_FOLDING
10206 linenr_T lnum;
10209 foldinfo_T foldinfo;
10211 #endif
10215 #ifdef FEAT_FOLDING
10217 /* treat illegal types and illegal string values for {lnum} the same */
10222 {
10228 }
10229 #endif
10230 }
10232 /*
10233 * "foreground()" function
10234 */
10235 /*ARGSUSED*/
10236 static void
10240 {
10242 #ifdef FEAT_GUI
10245 #else
10246 # ifdef WIN32
10248 # endif
10249 #endif
10250 }
10252 /*
10253 * "function()" function
10254 */
10255 /*ARGSUSED*/
10256 static void
10260 {
10269 else
10270 {
10273 }
10274 }
10276 /*
10277 * "garbagecollect()" function
10278 */
10279 /*ARGSUSED*/
10280 static void
10284 {
10285 /* This is postponed until we are back at the toplevel, because we may be
10286 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
10291 }
10293 /*
10294 * "get()" function
10295 */
10296 static void
10300 {
10308 {
10310 {
10316 }
10317 }
10319 {
10321 {
10325 }
10326 }
10327 else
10331 {
10334 else
10336 }
10337 else
10339 }
10341 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
10343 /*
10344 * Get line or list of lines from buffer "buf" into "rettv".
10345 * Return a range (from start to end) of lines in rettv from the specified
10346 * buffer.
10347 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
10348 */
10349 static void
10352 linenr_T start;
10353 linenr_T end;
10356 {
10360 {
10363 }
10364 else
10371 {
10374 else
10379 }
10380 else
10381 {
10393 }
10394 }
10396 /*
10397 * "getbufline()" function
10398 */
10399 static void
10403 {
10404 linenr_T lnum;
10405 linenr_T end;
10416 else
10420 }
10422 /*
10423 * "getbufvar()" function
10424 */
10425 static void
10429 {
10444 {
10445 /* set curbuf to be our buf, temporarily */
10451 else
10452 {
10454 /* let getbufvar({nr}, "") return the "b:" dictionary. The
10455 * scope prefix before the NUL byte is required by
10456 * find_var_in_ht(). */
10458 /* look up the variable */
10462 }
10464 /* restore previous notion of curbuf */
10466 }
10469 }
10471 /*
10472 * "getchar()" function
10473 */
10474 static void
10478 {
10479 varnumber_T n;
10482 /* Position the cursor. Needed after a message that ends in a space. */
10488 {
10490 /* getchar(): blocking wait. */
10493 /* getchar(1): only check if char avail */
10496 /* illegal argument or getchar(0) and no char avail: return zero */
10498 else
10499 /* getchar(0) and char avail: return char */
10504 }
10514 {
10518 /* Turn a special key into three bytes, plus modifier. */
10520 {
10524 }
10526 {
10530 }
10531 #ifdef FEAT_MBYTE
10534 #endif
10535 else
10541 #ifdef FEAT_MOUSE
10561 {
10565 linenr_T lnum;
10566 # ifdef FEAT_WINDOWS
10568 # endif
10572 {
10573 /* Find the window at the mouse coordinates and compute the
10574 * text position. */
10577 # ifdef FEAT_WINDOWS
10580 # endif
10584 }
10585 }
10586 #endif
10587 }
10588 }
10590 /*
10591 * "getcharmod()" function
10592 */
10593 /*ARGSUSED*/
10594 static void
10598 {
10600 }
10602 /*
10603 * "getcmdline()" function
10604 */
10605 /*ARGSUSED*/
10606 static void
10610 {
10613 }
10615 /*
10616 * "getcmdpos()" function
10617 */
10618 /*ARGSUSED*/
10619 static void
10623 {
10625 }
10627 /*
10628 * "getcmdtype()" function
10629 */
10630 /*ARGSUSED*/
10631 static void
10635 {
10639 {
10642 }
10643 }
10645 /*
10646 * "getcwd()" function
10647 */
10648 /*ARGSUSED*/
10649 static void
10653 {
10659 else
10660 {
10662 #ifdef BACKSLASH_IN_FILENAME
10665 #endif
10666 }
10667 }
10669 /*
10670 * "getfontname()" function
10671 */
10672 /*ARGSUSED*/
10673 static void
10677 {
10680 #ifdef FEAT_GUI
10682 {
10683 GuiFont font;
10687 {
10688 /* Get the "Normal" font. Either the name saved by
10689 * hl_set_font_name() or from the font ID. */
10692 }
10693 else
10694 {
10701 }
10705 }
10706 #endif
10707 }
10709 /*
10710 * "getfperm({fname})" function
10711 */
10712 static void
10716 {
10727 {
10730 {
10732 {
10735 }
10736 }
10737 }
10739 }
10741 /*
10742 * "getfsize({fname})" function
10743 */
10744 static void
10748 {
10757 {
10760 else
10761 {
10764 /* non-perfect check for overflow */
10767 }
10768 }
10769 else
10771 }
10773 /*
10774 * "getftime({fname})" function
10775 */
10776 static void
10780 {
10788 else
10790 }
10792 /*
10793 * "getftype({fname})" function
10794 */
10795 static void
10799 {
10809 {
10810 #ifdef S_ISREG
10815 # ifdef S_ISLNK
10818 # endif
10819 # ifdef S_ISBLK
10822 # endif
10823 # ifdef S_ISCHR
10826 # endif
10827 # ifdef S_ISFIFO
10830 # endif
10831 # ifdef S_ISSOCK
10834 # endif
10835 else
10837 #else
10838 # ifdef S_IFMT
10840 {
10843 # ifdef S_IFLNK
10845 # endif
10846 # ifdef S_IFBLK
10848 # endif
10849 # ifdef S_IFCHR
10851 # endif
10852 # ifdef S_IFIFO
10854 # endif
10855 # ifdef S_IFSOCK
10857 # endif
10859 }
10860 # else
10863 else
10865 # endif
10866 #endif
10868 }
10870 }
10872 /*
10873 * "getline(lnum, [end])" function
10874 */
10875 static void
10879 {
10880 linenr_T lnum;
10881 linenr_T end;
10886 {
10889 }
10890 else
10891 {
10894 }
10897 }
10899 /*
10900 * "getmatches()" function
10901 */
10902 /*ARGSUSED*/
10903 static void
10907 {
10908 #ifdef FEAT_SEARCH_EXTRA
10915 {
10917 {
10927 }
10928 }
10929 #endif
10930 }
10932 /*
10933 * "getpid()" function
10934 */
10935 /*ARGSUSED*/
10936 static void
10940 {
10942 }
10944 /*
10945 * "getpos(string)" function
10946 */
10947 static void
10951 {
10957 {
10962 else
10970 #ifdef FEAT_VIRTUALEDIT
10972 #endif
10974 }
10975 else
10977 }
10979 /*
10980 * "getqflist()" and "getloclist()" functions
10981 */
10982 /*ARGSUSED*/
10983 static void
10987 {
10988 #ifdef FEAT_QUICKFIX
10990 #endif
10993 #ifdef FEAT_QUICKFIX
10995 {
10998 {
11002 }
11005 }
11006 #endif
11007 }
11009 /*
11010 * "getreg()" function
11011 */
11012 static void
11016 {
11023 {
11028 }
11029 else
11038 }
11040 /*
11041 * "getregtype()" function
11042 */
11043 static void
11047 {
11054 {
11057 {
11061 }
11062 }
11063 else
11064 /* Default to v:register */
11074 {
11077 #ifdef FEAT_VISUAL
11082 #endif
11083 }
11086 }
11088 /*
11089 * "gettabwinvar()" function
11090 */
11091 static void
11095 {
11097 }
11099 /*
11100 * "getwinposx()" function
11101 */
11102 /*ARGSUSED*/
11103 static void
11107 {
11109 #ifdef FEAT_GUI
11111 {
11116 }
11117 #endif
11118 }
11120 /*
11121 * "getwinposy()" function
11122 */
11123 /*ARGSUSED*/
11124 static void
11128 {
11130 #ifdef FEAT_GUI
11132 {
11137 }
11138 #endif
11139 }
11141 /*
11142 * Find window specified by "vp" in tabpage "tp".
11143 */
11148 {
11149 #ifdef FEAT_WINDOWS
11151 #endif
11156 #ifdef FEAT_WINDOWS
11167 #else
11171 #endif
11172 }
11174 /*
11175 * "getwinvar()" function
11176 */
11177 static void
11181 {
11183 }
11185 /*
11186 * getwinvar() and gettabwinvar()
11187 */
11188 static void
11193 {
11199 #ifdef FEAT_WINDOWS
11202 else
11204 #endif
11213 {
11214 /* Set curwin to be our win, temporarily. Also set curbuf, so
11215 * that we can get buffer-local options. */
11222 else
11223 {
11225 /* let getwinvar({nr}, "") return the "w:" dictionary. The
11226 * scope prefix before the NUL byte is required by
11227 * find_var_in_ht(). */
11229 /* look up the variable */
11233 }
11235 /* restore previous notion of curwin */
11238 }
11241 }
11243 /*
11244 * "glob()" function
11245 */
11246 static void
11250 {
11251 expand_T xpc;
11258 }
11260 /*
11261 * "globpath()" function
11262 */
11263 static void
11267 {
11274 else
11276 }
11278 /*
11279 * "has()" function
11280 */
11281 static void
11285 {
11290 {
11291 #ifdef AMIGA
11293 # ifdef FEAT_ARP
11295 # endif
11296 #endif
11297 #ifdef __BEOS__
11299 #endif
11300 #ifdef MSDOS
11301 # ifdef DJGPP
11303 # else
11305 # endif
11306 #endif
11307 #ifdef MACOS
11309 #endif
11310 #if defined(MACOS_X_UNIX)
11312 #endif
11313 #ifdef OS2
11315 #endif
11316 #ifdef __QNX__
11318 #endif
11319 #ifdef RISCOS
11321 #endif
11322 #ifdef UNIX
11324 #endif
11325 #ifdef VMS
11327 #endif
11328 #ifdef WIN16
11330 #endif
11331 #ifdef WIN32
11333 #endif
11334 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
11336 #endif
11337 #ifdef WIN64
11339 #endif
11340 #ifdef EBCDIC
11342 #endif
11343 #ifndef CASE_INSENSITIVE_FILENAME
11345 #endif
11346 #ifdef FEAT_ARABIC
11348 #endif
11349 #ifdef FEAT_AUTOCMD
11351 #endif
11352 #ifdef FEAT_BEVAL
11356 # endif
11357 #endif
11358 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
11360 # ifdef ALL_BUILTIN_TCAPS
11362 # endif
11363 #endif
11364 #ifdef FEAT_BYTEOFF
11366 #endif
11367 #ifdef FEAT_CINDENT
11369 #endif
11370 #ifdef FEAT_CLIENTSERVER
11372 #endif
11373 #ifdef FEAT_CLIPBOARD
11375 #endif
11376 #ifdef FEAT_CMDL_COMPL
11378 #endif
11379 #ifdef FEAT_CMDHIST
11381 #endif
11382 #ifdef FEAT_COMMENTS
11384 #endif
11385 #ifdef FEAT_CRYPT
11387 #endif
11388 #ifdef FEAT_CSCOPE
11390 #endif
11391 #ifdef CURSOR_SHAPE
11393 #endif
11394 #ifdef DEBUG
11396 #endif
11397 #ifdef FEAT_CON_DIALOG
11399 #endif
11400 #ifdef FEAT_GUI_DIALOG
11402 #endif
11403 #ifdef FEAT_DIFF
11405 #endif
11406 #ifdef FEAT_DIGRAPHS
11408 #endif
11409 #ifdef FEAT_DND
11411 #endif
11412 #ifdef FEAT_EMACS_TAGS
11414 #endif
11416 #ifdef FEAT_EX_EXTRA
11418 #endif
11419 #ifdef FEAT_SEARCH_EXTRA
11421 #endif
11422 #ifdef FEAT_FKMAP
11424 #endif
11425 #ifdef FEAT_SEARCHPATH
11427 #endif
11428 #if defined(UNIX) && !defined(USE_SYSTEM)
11430 #endif
11431 #ifdef FEAT_FIND_ID
11433 #endif
11434 #ifdef FEAT_FLOAT
11436 #endif
11437 #ifdef FEAT_FOLDING
11439 #endif
11440 #ifdef FEAT_FOOTER
11442 #endif
11443 #if !defined(USE_SYSTEM) && defined(UNIX)
11445 #endif
11446 #ifdef FEAT_GETTEXT
11448 #endif
11449 #ifdef FEAT_GUI
11451 #endif
11452 #ifdef FEAT_GUI_ATHENA
11453 # ifdef FEAT_GUI_NEXTAW
11455 # else
11457 # endif
11458 #endif
11459 #ifdef FEAT_GUI_GTK
11461 # ifdef HAVE_GTK2
11463 # endif
11464 #endif
11465 #ifdef FEAT_GUI_GNOME
11467 #endif
11468 #ifdef FEAT_GUI_MAC
11470 #endif
11471 #ifdef FEAT_GUI_MOTIF
11473 #endif
11474 #ifdef FEAT_GUI_PHOTON
11476 #endif
11477 #ifdef FEAT_GUI_W16
11479 #endif
11480 #ifdef FEAT_GUI_W32
11482 #endif
11483 #ifdef FEAT_HANGULIN
11485 #endif
11486 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11488 #endif
11489 #ifdef FEAT_INS_EXPAND
11491 #endif
11492 #ifdef FEAT_JUMPLIST
11494 #endif
11495 #ifdef FEAT_KEYMAP
11497 #endif
11498 #ifdef FEAT_LANGMAP
11500 #endif
11501 #ifdef FEAT_LIBCALL
11503 #endif
11504 #ifdef FEAT_LINEBREAK
11506 #endif
11507 #ifdef FEAT_LISP
11509 #endif
11510 #ifdef FEAT_LISTCMDS
11512 #endif
11513 #ifdef FEAT_LOCALMAP
11515 #endif
11516 #ifdef FEAT_MENU
11518 #endif
11519 #ifdef FEAT_SESSION
11521 #endif
11522 #ifdef FEAT_MODIFY_FNAME
11524 #endif
11525 #ifdef FEAT_MOUSE
11527 #endif
11528 #ifdef FEAT_MOUSESHAPE
11530 #endif
11531 #if defined(UNIX) || defined(VMS)
11532 # ifdef FEAT_MOUSE_DEC
11534 # endif
11535 # ifdef FEAT_MOUSE_GPM
11537 # endif
11538 # ifdef FEAT_MOUSE_JSB
11540 # endif
11541 # ifdef FEAT_MOUSE_NET
11543 # endif
11544 # ifdef FEAT_MOUSE_PTERM
11546 # endif
11547 # ifdef FEAT_SYSMOUSE
11549 # endif
11550 # ifdef FEAT_MOUSE_XTERM
11552 # endif
11553 #endif
11554 #ifdef FEAT_MBYTE
11556 #endif
11557 #ifdef FEAT_MBYTE_IME
11559 #endif
11560 #ifdef FEAT_MULTI_LANG
11562 #endif
11563 #ifdef FEAT_MZSCHEME
11564 #ifndef DYNAMIC_MZSCHEME
11566 #endif
11567 #endif
11568 #ifdef FEAT_OLE
11570 #endif
11571 #ifdef FEAT_OSFILETYPE
11573 #endif
11574 #ifdef FEAT_PATH_EXTRA
11576 #endif
11577 #ifdef FEAT_PERL
11578 #ifndef DYNAMIC_PERL
11580 #endif
11581 #endif
11582 #ifdef FEAT_PYTHON
11583 #ifndef DYNAMIC_PYTHON
11585 #endif
11586 #endif
11587 #ifdef FEAT_POSTSCRIPT
11589 #endif
11590 #ifdef FEAT_PRINTER
11592 #endif
11593 #ifdef FEAT_PROFILE
11595 #endif
11596 #ifdef FEAT_RELTIME
11598 #endif
11599 #ifdef FEAT_QUICKFIX
11601 #endif
11602 #ifdef FEAT_RIGHTLEFT
11604 #endif
11605 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11607 #endif
11608 #ifdef FEAT_SCROLLBIND
11610 #endif
11611 #ifdef FEAT_CMDL_INFO
11614 #endif
11615 #ifdef FEAT_SIGNS
11617 #endif
11618 #ifdef FEAT_SMARTINDENT
11620 #endif
11621 #ifdef FEAT_SNIFF
11623 #endif
11624 #ifdef FEAT_STL_OPT
11626 #endif
11627 #ifdef FEAT_SUN_WORKSHOP
11629 #endif
11630 #ifdef FEAT_NETBEANS_INTG
11632 #endif
11633 #ifdef FEAT_SPELL
11635 #endif
11636 #ifdef FEAT_SYN_HL
11638 #endif
11639 #if defined(USE_SYSTEM) || !defined(UNIX)
11641 #endif
11642 #ifdef FEAT_TAG_BINS
11644 #endif
11645 #ifdef FEAT_TAG_OLDSTATIC
11647 #endif
11648 #ifdef FEAT_TAG_ANYWHITE
11650 #endif
11651 #ifdef FEAT_TCL
11652 # ifndef DYNAMIC_TCL
11654 # endif
11655 #endif
11656 #ifdef TERMINFO
11658 #endif
11659 #ifdef FEAT_TERMRESPONSE
11661 #endif
11662 #ifdef FEAT_TEXTOBJ
11664 #endif
11665 #ifdef HAVE_TGETENT
11667 #endif
11668 #ifdef FEAT_TITLE
11670 #endif
11671 #ifdef FEAT_TOOLBAR
11673 #endif
11674 #ifdef FEAT_USR_CMDS
11677 #endif
11678 #ifdef FEAT_VIMINFO
11680 #endif
11681 #ifdef FEAT_VERTSPLIT
11683 #endif
11684 #ifdef FEAT_VIRTUALEDIT
11686 #endif
11687 #ifdef FEAT_VISUAL
11689 #endif
11690 #ifdef FEAT_VISUALEXTRA
11692 #endif
11693 #ifdef FEAT_VREPLACE
11695 #endif
11696 #ifdef FEAT_WILDIGN
11698 #endif
11699 #ifdef FEAT_WILDMENU
11701 #endif
11702 #ifdef FEAT_WINDOWS
11704 #endif
11705 #ifdef FEAT_WAK
11707 #endif
11708 #ifdef FEAT_WRITEBACKUP
11710 #endif
11711 #ifdef FEAT_XIM
11713 #endif
11714 #ifdef FEAT_XFONTSET
11716 #endif
11717 #ifdef USE_XSMP
11719 #endif
11720 #ifdef USE_XSMP_INTERACT
11722 #endif
11723 #ifdef FEAT_XCLIPBOARD
11725 #endif
11726 #ifdef FEAT_XTERM_SAVE
11728 #endif
11729 #if defined(UNIX) && defined(FEAT_X11)
11731 #endif
11732 NULL
11733 };
11738 {
11741 }
11744 {
11749 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11752 #endif
11753 #ifdef DYNAMIC_TCL
11756 #endif
11757 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11760 #endif
11761 #ifdef DYNAMIC_MZSCHEME
11764 #endif
11765 #ifdef DYNAMIC_RUBY
11768 #endif
11769 #ifdef DYNAMIC_PYTHON
11772 #endif
11773 #ifdef DYNAMIC_PERL
11776 #endif
11777 #ifdef FEAT_GUI
11780 # ifdef FEAT_GUI_W32
11783 # endif
11784 # ifdef FEAT_BROWSE
11787 # endif
11788 #endif
11789 #ifdef FEAT_SYN_HL
11792 #endif
11793 #if defined(WIN3264)
11796 #endif
11797 #ifdef FEAT_NETBEANS_INTG
11800 #endif
11801 }
11804 }
11806 /*
11807 * "has_key()" function
11808 */
11809 static void
11813 {
11816 {
11819 }
11825 }
11827 /*
11828 * "haslocaldir()" function
11829 */
11830 /*ARGSUSED*/
11831 static void
11835 {
11837 }
11839 /*
11840 * "hasmapto()" function
11841 */
11842 static void
11846 {
11855 else
11856 {
11860 }
11864 else
11866 }
11868 /*
11869 * "histadd()" function
11870 */
11871 /*ARGSUSED*/
11872 static void
11876 {
11877 #ifdef FEAT_CMDHIST
11881 #endif
11886 #ifdef FEAT_CMDHIST
11890 {
11893 {
11897 }
11898 }
11899 #endif
11900 }
11902 /*
11903 * "histdel()" function
11904 */
11905 /*ARGSUSED*/
11906 static void
11910 {
11911 #ifdef FEAT_CMDHIST
11920 /* only one argument: clear entire history */
11923 /* index given: remove that entry */
11926 else
11927 /* string given: remove all matching entries */
11931 #else
11933 #endif
11934 }
11936 /*
11937 * "histget()" function
11938 */
11939 /*ARGSUSED*/
11940 static void
11944 {
11945 #ifdef FEAT_CMDHIST
11953 else
11954 {
11958 else
11960 /* -1 on type error */
11962 }
11963 #else
11965 #endif
11967 }
11969 /*
11970 * "histnr()" function
11971 */
11972 /*ARGSUSED*/
11973 static void
11977 {
11980 #ifdef FEAT_CMDHIST
11986 else
11987 #endif
11990 }
11992 /*
11993 * "highlightID(name)" function
11994 */
11995 static void
11999 {
12001 }
12003 /*
12004 * "highlight_exists()" function
12005 */
12006 static void
12010 {
12012 }
12014 /*
12015 * "hostname()" function
12016 */
12017 /*ARGSUSED*/
12018 static void
12022 {
12028 }
12030 /*
12031 * iconv() function
12032 */
12033 /*ARGSUSED*/
12034 static void
12038 {
12039 #ifdef FEAT_MBYTE
12043 vimconv_T vimconv;
12044 #endif
12049 #ifdef FEAT_MBYTE
12056 /* If the encodings are equal, no conversion needed. */
12059 else
12065 #endif
12066 }
12068 /*
12069 * "indent()" function
12070 */
12071 static void
12075 {
12076 linenr_T lnum;
12081 else
12083 }
12085 /*
12086 * "index()" function
12087 */
12088 static void
12092 {
12100 {
12103 }
12106 {
12109 {
12112 /* Start at specified item. Use the cached index that list_find()
12113 * sets, so that a negative number also works. */
12120 }
12124 {
12127 }
12128 }
12129 }
12135 /*
12136 * This function is used by f_input() and f_inputdialog() functions. The third
12137 * argument to f_input() specifies the type of completion to use at the
12138 * prompt. The third argument to f_inputdialog() specifies the value to return
12139 * when the user cancels the prompt.
12140 */
12141 static void
12146 {
12159 #ifdef NO_CONSOLE_INPUT
12160 /* While starting up, there is no place to enter text. */
12163 #endif
12167 {
12168 /* Only the part of the message after the last NL is considered as
12169 * prompt for the command line */
12173 else
12174 {
12184 }
12188 {
12194 {
12210 }
12211 }
12220 /* since the user typed this, no need to wait for return */
12223 }
12225 }
12227 /*
12228 * "input()" function
12229 * Also handles inputsecret() when inputsecret is set.
12230 */
12231 static void
12235 {
12237 }
12239 /*
12240 * "inputdialog()" function
12241 */
12242 static void
12246 {
12247 #if defined(FEAT_GUI_TEXTDIALOG)
12248 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12250 {
12259 else
12265 else
12266 {
12272 else
12274 }
12276 }
12277 else
12278 #endif
12280 }
12282 /*
12283 * "inputlist()" function
12284 */
12285 static void
12289 {
12295 #ifdef NO_CONSOLE_INPUT
12296 /* While starting up, there is no place to enter text. */
12299 #endif
12301 {
12304 }
12313 {
12316 }
12318 /* Ask for choice. */
12324 }
12329 /*
12330 * "inputrestore()" function
12331 */
12332 /*ARGSUSED*/
12333 static void
12337 {
12339 {
12344 }
12346 {
12349 }
12350 }
12352 /*
12353 * "inputsave()" function
12354 */
12355 /*ARGSUSED*/
12356 static void
12360 {
12361 /* Add an entry to the stack of typeahead storage. */
12363 {
12368 }
12369 else
12371 }
12373 /*
12374 * "inputsecret()" function
12375 */
12376 static void
12380 {
12386 }
12388 /*
12389 * "insert()" function
12390 */
12391 static void
12395 {
12406 {
12414 else
12415 {
12418 {
12421 }
12422 }
12424 {
12427 }
12428 }
12429 }
12431 /*
12432 * "isdirectory()" function
12433 */
12434 static void
12438 {
12440 }
12442 /*
12443 * "islocked()" function
12444 */
12445 static void
12449 {
12450 lval_T lv;
12456 FNE_CHECK_START);
12458 {
12461 else
12462 {
12464 {
12467 else
12468 {
12471 {
12472 /* Consider a variable locked when:
12473 * 1. the variable itself is locked
12474 * 2. the value of the variable is locked.
12475 * 3. the List or Dict value is locked.
12476 */
12479 }
12480 }
12481 }
12487 /* List item. */
12489 else
12490 /* Dictionary item. */
12492 }
12493 }
12496 }
12500 /*
12501 * Turn a dict into a list:
12502 * "what" == 0: list of keys
12503 * "what" == 1: list of values
12504 * "what" == 2: list of items
12505 */
12506 static void
12511 {
12522 {
12525 }
12534 {
12536 {
12546 {
12547 /* keys() */
12551 }
12553 {
12554 /* values() */
12556 }
12557 else
12558 {
12559 /* items() */
12581 }
12582 }
12583 }
12584 }
12586 /*
12587 * "items(dict)" function
12588 */
12589 static void
12593 {
12595 }
12597 /*
12598 * "join()" function
12599 */
12600 static void
12604 {
12605 garray_T ga;
12610 {
12613 }
12618 else
12624 {
12629 }
12630 else
12632 }
12634 /*
12635 * "keys()" function
12636 */
12637 static void
12641 {
12643 }
12645 /*
12646 * "last_buffer_nr()" function.
12647 */
12648 /*ARGSUSED*/
12649 static void
12653 {
12662 }
12664 /*
12665 * "len()" function
12666 */
12667 static void
12671 {
12673 {
12688 }
12689 }
12693 static void
12698 {
12699 #ifdef FEAT_LIBCALL
12703 #endif
12708 else
12714 #ifdef FEAT_LIBCALL
12715 /* The first two args must be strings, otherwise its meaningless */
12717 {
12723 else
12727 string_in,
12729 string_result,
12733 }
12734 #endif
12735 }
12737 /*
12738 * "libcall()" function
12739 */
12740 static void
12744 {
12746 }
12748 /*
12749 * "libcallnr()" function
12750 */
12751 static void
12755 {
12757 }
12759 /*
12760 * "line(string)" function
12761 */
12762 static void
12766 {
12775 }
12777 /*
12778 * "line2byte(lnum)" function
12779 */
12780 /*ARGSUSED*/
12781 static void
12785 {
12786 #ifndef FEAT_BYTEOFF
12788 #else
12789 linenr_T lnum;
12794 else
12798 #endif
12799 }
12801 /*
12802 * "lispindent(lnum)" function
12803 */
12804 static void
12808 {
12809 #ifdef FEAT_LISP
12810 pos_T pos;
12811 linenr_T lnum;
12816 {
12820 }
12821 else
12822 #endif
12824 }
12826 /*
12827 * "localtime()" function
12828 */
12829 /*ARGSUSED*/
12830 static void
12834 {
12836 }
12840 static void
12845 {
12852 garray_T ga;
12855 /* return empty string for failure */
12864 {
12868 }
12869 else
12880 {
12890 }
12891 }
12893 #ifdef FEAT_FLOAT
12894 /*
12895 * "log10()" function
12896 */
12897 static void
12901 {
12902 float_T f;
12907 else
12909 }
12910 #endif
12912 /*
12913 * "map()" function
12914 */
12915 static void
12919 {
12921 }
12923 /*
12924 * "maparg()" function
12925 */
12926 static void
12930 {
12932 }
12934 /*
12935 * "mapcheck()" function
12936 */
12937 static void
12941 {
12943 }
12947 static void
12952 {
12956 regmatch_T regmatch;
12969 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12975 {
12976 /* return empty list when there are no matches */
12979 }
12981 {
12984 }
12987 {
12991 }
12992 else
13000 {
13007 {
13012 }
13013 else
13014 {
13019 /* When "count" argument is there ignore matches before "start",
13020 * otherwise skip part of the string. Differs when pattern is "^"
13021 * or "\<". */
13024 else
13026 }
13032 }
13036 {
13040 {
13042 {
13044 {
13047 }
13052 }
13061 /* Advance to just after the match. */
13063 {
13066 }
13067 else
13068 {
13069 #ifdef FEAT_MBYTE
13072 #else
13074 #endif
13075 }
13076 }
13079 {
13081 {
13084 /* return list with matched string and submatches */
13086 {
13088 {
13092 }
13098 }
13099 }
13101 {
13102 /* return matched string */
13105 else
13108 }
13111 else
13112 {
13116 else
13120 }
13121 }
13123 }
13125 theend:
13128 }
13130 /*
13131 * "match()" function
13132 */
13133 static void
13137 {
13139 }
13141 /*
13142 * "matchadd()" function
13143 */
13144 static void
13148 {
13149 #ifdef FEAT_SEARCH_EXTRA
13162 {
13166 }
13170 {
13173 }
13176 #endif
13177 }
13179 /*
13180 * "matcharg()" function
13181 */
13182 static void
13186 {
13188 {
13189 #ifdef FEAT_SEARCH_EXTRA
13194 {
13196 {
13200 }
13201 else
13202 {
13205 }
13206 }
13207 #endif
13208 }
13209 }
13211 /*
13212 * "matchdelete()" function
13213 */
13214 static void
13218 {
13219 #ifdef FEAT_SEARCH_EXTRA
13222 #endif
13223 }
13225 /*
13226 * "matchend()" function
13227 */
13228 static void
13232 {
13234 }
13236 /*
13237 * "matchlist()" function
13238 */
13239 static void
13243 {
13245 }
13247 /*
13248 * "matchstr()" function
13249 */
13250 static void
13254 {
13256 }
13260 static void
13265 {
13271 {
13277 {
13280 {
13283 {
13290 }
13291 }
13292 }
13293 }
13295 {
13303 {
13306 {
13308 {
13312 {
13315 }
13318 }
13319 }
13320 }
13321 }
13322 else
13325 }
13327 /*
13328 * "max()" function
13329 */
13330 static void
13334 {
13336 }
13338 /*
13339 * "min()" function
13340 */
13341 static void
13345 {
13347 }
13351 /*
13352 * Create the directory in which "dir" is located, and higher levels when
13353 * needed.
13354 */
13355 static int
13359 {
13364 /* Get end of directory name in "dir".
13365 * We're done when it's "/" or "c:/". */
13370 /* If the directory exists we're done. Otherwise: create it.*/
13380 }
13382 #ifdef vim_mkdir
13383 /*
13384 * "mkdir()" function
13385 */
13386 static void
13390 {
13401 {
13406 }
13408 }
13409 #endif
13411 /*
13412 * "mode()" function
13413 */
13414 /*ARGSUSED*/
13415 static void
13419 {
13425 #ifdef FEAT_VISUAL
13427 {
13430 else
13432 }
13433 else
13434 #endif
13437 {
13443 }
13447 {
13448 #ifdef FEAT_VREPLACE
13450 {
13453 }
13454 else
13455 #endif
13458 else
13460 }
13462 {
13466 }
13468 {
13471 }
13472 else
13473 {
13477 }
13479 /* A zero number or empty string argument: return only major mode. */
13487 }
13489 /*
13490 * "nextnonblank()" function
13491 */
13492 static void
13496 {
13497 linenr_T lnum;
13500 {
13502 {
13505 }
13508 }
13510 }
13512 /*
13513 * "nr2char()" function
13514 */
13515 static void
13519 {
13522 #ifdef FEAT_MBYTE
13525 else
13526 #endif
13527 {
13530 }
13533 }
13535 /*
13536 * "pathshorten()" function
13537 */
13538 static void
13542 {
13549 else
13550 {
13555 }
13556 }
13558 #ifdef FEAT_FLOAT
13559 /*
13560 * "pow()" function
13561 */
13562 static void
13566 {
13573 else
13575 }
13576 #endif
13578 /*
13579 * "prevnonblank()" function
13580 */
13581 static void
13585 {
13586 linenr_T lnum;
13591 else
13595 }
13597 #ifdef HAVE_STDARG_H
13598 /* This dummy va_list is here because:
13599 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13600 * - locally in the function results in a "used before set" warning
13601 * - using va_start() to initialize it gives "function with fixed args" error */
13603 #endif
13605 /*
13606 * "printf()" function
13607 */
13608 static void
13612 {
13616 {
13623 /* Get the required length, allocate the buffer and do it for real. */
13628 {
13631 {
13634 }
13635 }
13637 }
13638 #endif
13639 }
13641 /*
13642 * "pumvisible()" function
13643 */
13644 /*ARGSUSED*/
13645 static void
13649 {
13651 #ifdef FEAT_INS_EXPAND
13654 #endif
13655 }
13657 /*
13658 * "range()" function
13659 */
13660 static void
13664 {
13673 {
13676 }
13677 else
13678 {
13682 }
13691 else
13692 {
13698 }
13699 }
13701 /*
13702 * "readfile()" function
13703 */
13704 static void
13708 {
13728 {
13733 }
13738 /* Always open the file in binary mode, library functions have a mind of
13739 * their own about CR-LF conversion. */
13742 {
13745 }
13749 {
13754 {
13756 {
13757 /* Only when in binary mode add an empty list item when the
13758 * last line ends in a '\n'. */
13762 /* Found end-of-line or end-of-file: add a text line to the
13763 * list. */
13772 else
13773 {
13776 {
13782 }
13783 }
13788 {
13791 }
13801 }
13804 }
13809 {
13810 /* "buf" is full, need to move text to an allocated buffer */
13812 {
13815 }
13816 else
13817 {
13820 {
13826 }
13827 }
13829 }
13830 else
13831 {
13834 }
13835 }
13837 /*
13838 * For a negative line count use only the lines at the end of the file,
13839 * free the rest.
13840 */
13843 {
13846 }
13850 }
13852 #if defined(FEAT_RELTIME)
13855 /*
13856 * Convert a List to proftime_T.
13857 * Return FAIL when there is something wrong.
13858 */
13859 static int
13863 {
13872 # ifdef WIN3264
13875 # else
13878 # endif
13880 }
13883 /*
13884 * "reltime()" function
13885 */
13886 static void
13890 {
13891 #ifdef FEAT_RELTIME
13892 proftime_T res;
13893 proftime_T start;
13896 {
13897 /* No arguments: get current time. */
13899 }
13901 {
13905 }
13906 else
13907 {
13908 /* Two arguments: compute the difference. */
13913 }
13916 {
13919 # ifdef WIN3264
13922 # else
13925 # endif
13928 }
13929 #endif
13930 }
13932 /*
13933 * "reltimestr()" function
13934 */
13935 static void
13939 {
13940 #ifdef FEAT_RELTIME
13941 proftime_T tm;
13942 #endif
13946 #ifdef FEAT_RELTIME
13949 #endif
13950 }
13952 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13956 static void
13958 {
13960 # ifdef FEAT_GUI
13962 # endif
13963 )
13964 {
13968 }
13969 }
13971 static int
13973 {
13976 {
13979 }
13981 }
13982 #endif
13984 #ifdef FEAT_CLIENTSERVER
13987 static void
13992 {
13997 # ifdef WIN32
13998 HWND w;
13999 # else
14000 Window w;
14001 # endif
14006 # ifdef FEAT_X11
14009 # endif
14015 # ifdef WIN32
14017 # else
14020 # endif
14021 {
14024 else
14027 }
14032 {
14033 dictitem_T v;
14044 }
14045 }
14046 #endif
14048 /*
14049 * "remote_expr()" function
14050 */
14051 /*ARGSUSED*/
14052 static void
14056 {
14059 #ifdef FEAT_CLIENTSERVER
14061 #endif
14062 }
14064 /*
14065 * "remote_foreground()" function
14066 */
14067 /*ARGSUSED*/
14068 static void
14072 {
14074 #ifdef FEAT_CLIENTSERVER
14075 # ifdef WIN32
14076 /* On Win32 it's done in this application. */
14077 {
14082 }
14083 # else
14084 /* Send a foreground() expression to the server. */
14090 # endif
14091 #endif
14092 }
14094 /*ARGSUSED*/
14095 static void
14099 {
14100 #ifdef FEAT_CLIENTSERVER
14101 dictitem_T v;
14103 # ifdef WIN32
14105 # endif
14109 {
14112 }
14115 {
14118 }
14119 # ifdef WIN32
14123 else
14124 {
14127 }
14128 # else
14135 # endif
14138 {
14147 }
14148 #else
14150 #endif
14151 }
14153 /*ARGSUSED*/
14154 static void
14158 {
14161 #ifdef FEAT_CLIENTSERVER
14165 {
14166 # ifdef WIN32
14167 /* The server's HWND is encoded in the 'id' parameter */
14174 # else
14177 # endif
14179 }
14180 #endif
14183 }
14185 /*
14186 * "remote_send()" function
14187 */
14188 /*ARGSUSED*/
14189 static void
14193 {
14196 #ifdef FEAT_CLIENTSERVER
14198 #endif
14199 }
14201 /*
14202 * "remove()" function
14203 */
14204 static void
14208 {
14220 {
14225 {
14228 {
14232 else
14233 {
14237 }
14238 }
14239 }
14240 }
14245 {
14253 else
14254 {
14256 {
14257 /* Remove one item, return its value. */
14261 }
14262 else
14263 {
14264 /* Remove range of items, return list with values. */
14270 else
14271 {
14275 {
14279 }
14282 else
14283 {
14286 {
14293 }
14294 }
14295 }
14296 }
14297 }
14298 }
14299 }
14301 /*
14302 * "rename({from}, {to})" function
14303 */
14304 static void
14308 {
14313 else
14316 }
14318 /*
14319 * "repeat()" function
14320 */
14321 /*ARGSUSED*/
14322 static void
14326 {
14336 {
14342 }
14343 else
14344 {
14356 {
14360 }
14363 }
14364 }
14366 /*
14367 * "resolve()" function
14368 */
14369 static void
14373 {
14377 #ifdef FEAT_SHORTCUT
14378 {
14384 else
14386 }
14387 #else
14388 # ifdef HAVE_READLINK
14389 {
14411 {
14412 /* Separate the first path component in "p", and keep the
14413 * remainder (beginning with the path separator). */
14416 }
14419 {
14421 {
14428 {
14434 }
14436 /* Ensure that the result will have a trailing path separator
14437 * if the argument has one. */
14441 /* Separate the first path component in the link value and
14442 * concatenate the remainders. */
14445 {
14448 else
14449 {
14452 {
14455 }
14456 }
14458 }
14462 {
14463 /* Ignore trailing path separator. */
14466 }
14468 {
14469 /* symlink is relative to directory of argument */
14472 {
14477 }
14478 }
14479 else
14480 {
14483 }
14484 }
14489 /* Append the first path component of "remain" to "p". */
14494 {
14498 }
14499 /* Shorten "remain". */
14502 else
14503 {
14506 }
14507 }
14509 /* If the result is a relative path name, make it explicitly relative to
14510 * the current directory if and only if the argument had this form. */
14512 {
14521 {
14522 /* Prepend "./". */
14525 {
14528 }
14529 }
14531 {
14532 /* Strip leading "./". */
14538 }
14539 }
14541 /* Ensure that the result will have no trailing path separator
14542 * if the argument had none. But keep "/" or "//". */
14544 {
14548 }
14551 }
14552 # else
14554 # endif
14555 #endif
14559 #ifdef HAVE_READLINK
14560 fail:
14561 #endif
14563 }
14565 /*
14566 * "reverse({list})" function
14567 */
14568 static void
14572 {
14581 {
14586 {
14590 }
14595 }
14596 }
14608 /*
14609 * Get flags for a search function.
14610 * Possibly sets "p_ws".
14611 * Returns BACKWARD, FORWARD or zero (for an error).
14612 */
14613 static int
14617 {
14624 {
14629 {
14631 {
14638 {
14646 }
14648 {
14651 }
14652 else
14654 }
14658 }
14659 }
14661 }
14663 /*
14664 * Shared by search() and searchpos() functions
14665 */
14666 static int
14671 {
14674 pos_T pos;
14675 pos_T save_cursor;
14680 proftime_T tm;
14681 #ifdef FEAT_RELTIME
14683 #endif
14697 /* Optional arguments: line number to stop searching and timeout. */
14699 {
14703 #ifdef FEAT_RELTIME
14705 {
14709 }
14710 #endif
14711 }
14713 #ifdef FEAT_RELTIME
14714 /* Set the time limit, if there is one. */
14716 #endif
14718 /*
14719 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14720 * Check to make sure only those flags are set.
14721 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14722 * flags cannot be set. Check for that condition also.
14723 */
14726 {
14729 }
14735 {
14738 else
14744 {
14745 /* Store the match cursor position */
14748 }
14749 /* "/$" will put the cursor after the end of the line, may need to
14750 * correct that here */
14752 }
14754 /* If 'n' flag is used: restore cursor position. */
14757 else
14759 theend:
14763 }
14765 #ifdef FEAT_FLOAT
14766 /*
14767 * "round({float})" function
14768 */
14769 static void
14773 {
14774 float_T f;
14778 /* round() is not in C90, use ceil() or floor() instead. */
14780 else
14782 }
14783 #endif
14785 /*
14786 * "search()" function
14787 */
14788 static void
14792 {
14796 }
14798 /*
14799 * "searchdecl()" function
14800 */
14801 static void
14805 {
14815 {
14819 }
14823 }
14825 /*
14826 * Used by searchpair() and searchpairpos()
14827 */
14828 static int
14832 {
14845 /* Get the three pattern arguments: start, middle, end. */
14852 /* Handle the optional fourth argument: flags */
14857 /* Don't accept SP_END or SP_SUBPAT.
14858 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14859 */
14862 {
14865 }
14867 /* Using 'r' implies 'W', otherwise it doesn't work. */
14871 /* Optional fifth argument: skip expression */
14875 else
14876 {
14879 {
14883 #ifdef FEAT_RELTIME
14885 {
14889 }
14890 #endif
14891 }
14892 }
14899 theend:
14903 }
14905 /*
14906 * "searchpair()" function
14907 */
14908 static void
14912 {
14914 }
14916 /*
14917 * "searchpairpos()" function
14918 */
14919 static void
14923 {
14924 pos_T match_pos;
14934 {
14937 }
14941 }
14943 /*
14944 * Search for a start/middle/end thing.
14945 * Used by searchpair(), see its documentation for the details.
14946 * Returns 0 or -1 for no match,
14947 */
14948 long
14960 {
14964 pos_T pos;
14965 pos_T firstpos;
14966 pos_T foundpos;
14967 pos_T save_cursor;
14968 pos_T save_pos;
14974 proftime_T tm;
14976 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14980 #ifdef FEAT_RELTIME
14981 /* Set the time limit, if there is one. */
14983 #endif
14985 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14986 * start/middle/end (pat3, for the top pair). */
14994 else
15006 {
15010 /* didn't find it or found the first match again: FAIL */
15016 {
15017 /* Found the same position again. Can happen with a pattern that
15018 * has "\zs" at the end and searching backwards. Advance one
15019 * character and try again. */
15022 else
15024 }
15027 /* clear the start flag to avoid getting stuck here */
15030 /* If the skip pattern matches, ignore this match. */
15032 {
15038 {
15039 /* Evaluating {skip} caused an error, break here. */
15043 }
15046 }
15049 {
15050 /* Found end when searching backwards or start when searching
15051 * forward: nested pair. */
15054 }
15055 else
15056 {
15057 /* Found end when searching forward or start when searching
15058 * backward: end of (nested) pair; or found middle in outer pair. */
15061 }
15064 {
15065 /* Found the match: return matchcount or line number. */
15068 else
15076 }
15077 }
15080 {
15081 /* Store the match cursor position */
15084 }
15086 /* If 'n' flag is used or search failed: restore cursor position. */
15090 theend:
15096 }
15098 /*
15099 * "searchpos()" function
15100 */
15101 static void
15105 {
15106 pos_T match_pos;
15119 {
15122 }
15128 }
15131 /*ARGSUSED*/
15132 static void
15136 {
15137 #ifdef FEAT_CLIENTSERVER
15147 # ifdef FEAT_X11
15150 # endif
15153 {
15156 }
15158 #else
15160 #endif
15161 }
15163 /*ARGSUSED*/
15164 static void
15168 {
15171 #ifdef FEAT_CLIENTSERVER
15172 # ifdef WIN32
15174 # else
15178 # endif
15179 #endif
15182 }
15184 /*
15185 * "setbufvar()" function
15186 */
15187 /*ARGSUSED*/
15188 static void
15192 {
15194 aco_save_T aco;
15209 {
15210 /* set curbuf to be our buf, temporarily */
15214 {
15224 }
15225 else
15226 {
15229 {
15234 }
15235 }
15237 /* reset notion of buffer */
15239 }
15240 }
15242 /*
15243 * "setcmdpos()" function
15244 */
15245 static void
15249 {
15254 }
15256 /*
15257 * "setline()" function
15258 */
15259 static void
15263 {
15264 linenr_T lnum;
15273 {
15276 }
15277 else
15282 {
15284 {
15285 /* list argument, get next string */
15290 }
15296 {
15297 /* existing line, replace it */
15299 {
15304 }
15305 }
15307 {
15308 /* lnum is one past the last line, append the line */
15312 }
15317 }
15321 }
15323 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15325 /*
15326 * Used by "setqflist()" and "setloclist()" functions
15327 */
15328 /*ARGSUSED*/
15329 static void
15335 {
15336 #ifdef FEAT_QUICKFIX
15339 #endif
15343 #ifdef FEAT_QUICKFIX
15346 else
15347 {
15351 {
15357 }
15361 }
15362 #endif
15363 }
15365 /*
15366 * "setloclist()" function
15367 */
15368 /*ARGSUSED*/
15369 static void
15373 {
15381 }
15383 /*
15384 * "setmatches()" function
15385 */
15386 static void
15390 {
15391 #ifdef FEAT_SEARCH_EXTRA
15398 {
15401 }
15403 {
15405 /* To some extent make sure that we are dealing with a list from
15406 * "getmatches()". */
15409 {
15412 {
15415 }
15420 {
15423 }
15425 }
15430 {
15437 }
15439 }
15440 #endif
15441 }
15443 /*
15444 * "setpos()" function
15445 */
15446 /*ARGSUSED*/
15447 static void
15451 {
15452 pos_T pos;
15459 {
15461 {
15464 {
15465 /* set cursor */
15467 {
15471 }
15472 else
15474 }
15476 {
15477 /* set mark */
15480 }
15481 else
15483 }
15484 }
15485 }
15487 /*
15488 * "setqflist()" function
15489 */
15490 /*ARGSUSED*/
15491 static void
15495 {
15497 }
15499 /*
15500 * "setreg()" function
15501 */
15502 static void
15506 {
15512 char_u yank_type;
15531 {
15537 {
15547 #ifdef FEAT_VISUAL
15551 {
15555 }
15557 #endif
15558 }
15559 }
15566 }
15568 /*
15569 * "settabwinvar()" function
15570 */
15571 static void
15575 {
15577 }
15579 /*
15580 * "setwinvar()" function
15581 */
15582 static void
15586 {
15588 }
15590 /*
15591 * "setwinvar()" and "settabwinvar()" functions
15592 */
15593 static void
15598 {
15600 #ifdef FEAT_WINDOWS
15603 #endif
15614 #ifdef FEAT_WINDOWS
15617 else
15619 #endif
15625 {
15626 #ifdef FEAT_WINDOWS
15627 /* set curwin to be our win, temporarily */
15635 #endif
15638 {
15648 }
15649 else
15650 {
15653 {
15658 }
15659 }
15661 #ifdef FEAT_WINDOWS
15662 /* Restore current tabpage and window, if still valid (autocomands can
15663 * make them invalid). */
15667 {
15670 }
15671 #endif
15672 }
15673 }
15675 /*
15676 * "shellescape({string})" function
15677 */
15678 static void
15682 {
15685 }
15687 /*
15688 * "simplify()" function
15689 */
15690 static void
15694 {
15701 }
15703 #ifdef FEAT_FLOAT
15704 /*
15705 * "sin()" function
15706 */
15707 static void
15711 {
15712 float_T f;
15717 else
15719 }
15720 #endif
15722 static int
15723 #ifdef __BORLANDC__
15724 _RTLENTRYF
15725 #endif
15727 static int
15728 #ifdef __BORLANDC__
15729 _RTLENTRYF
15730 #endif
15736 #define ITEM_COMPARE_FAIL 999
15738 /*
15739 * Compare functions for f_sort() below.
15740 */
15741 static int
15742 #ifdef __BORLANDC__
15743 _RTLENTRYF
15744 #endif
15748 {
15763 else
15768 }
15770 static int
15771 #ifdef __BORLANDC__
15772 _RTLENTRYF
15773 #endif
15777 {
15779 typval_T rettv;
15783 /* shortcut after failure in previous call; compare all items equal */
15787 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15788 * in the copy without changing the original list items. */
15800 else
15801 /* return value has wrong type */
15807 }
15809 /*
15810 * "sort({list})" function
15811 */
15812 static void
15816 {
15826 else
15827 {
15842 {
15845 else
15846 {
15854 else
15856 }
15857 }
15859 /* Make an array with each entry pointing to an item in the List. */
15868 /* test the compare function */
15873 else
15874 {
15875 /* Sort the array with item pointers. */
15880 {
15881 /* Clear the List and append the items in the sorted order. */
15886 }
15887 }
15890 }
15891 }
15893 /*
15894 * "soundfold({word})" function
15895 */
15896 static void
15900 {
15905 #ifdef FEAT_SPELL
15907 #else
15909 #endif
15910 }
15912 /*
15913 * "spellbadword()" function
15914 */
15915 /* ARGSUSED */
15916 static void
15920 {
15928 #ifdef FEAT_SPELL
15930 {
15931 /* Find the start and length of the badly spelled word. */
15935 }
15937 {
15942 {
15943 /* Check the argument for spelling. */
15945 {
15948 {
15951 }
15953 }
15954 }
15955 }
15956 #endif
15965 }
15967 /*
15968 * "spellsuggest()" function
15969 */
15970 /*ARGSUSED*/
15971 static void
15975 {
15976 #ifdef FEAT_SPELL
15980 garray_T ga;
15984 #endif
15989 #ifdef FEAT_SPELL
15991 {
15994 {
15999 {
16003 }
16004 }
16005 else
16011 {
16017 else
16018 {
16023 }
16024 }
16026 }
16027 #endif
16028 }
16030 static void
16034 {
16038 regmatch_T regmatch;
16046 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16052 {
16058 }
16069 {
16072 {
16075 else
16079 else
16083 {
16087 }
16090 /* Advance to just after the match. */
16093 else
16094 {
16095 /* Don't get stuck at the same match. */
16096 #ifdef FEAT_MBYTE
16098 #else
16100 #endif
16101 }
16103 }
16106 }
16109 }
16111 #ifdef FEAT_FLOAT
16112 /*
16113 * "sqrt()" function
16114 */
16115 static void
16119 {
16120 float_T f;
16125 else
16127 }
16129 /*
16130 * "str2float()" function
16131 */
16132 static void
16136 {
16143 }
16144 #endif
16146 /*
16147 * "str2nr()" function
16148 */
16149 static void
16153 {
16159 {
16162 {
16165 }
16166 }
16173 }
16175 #ifdef HAVE_STRFTIME
16176 /*
16177 * "strftime({format}[, {time}])" function
16178 */
16179 static void
16183 {
16194 else
16197 /* MSVC returns NULL for an invalid value of seconds. */
16200 else
16201 {
16202 # ifdef FEAT_MBYTE
16203 vimconv_T conv;
16211 # endif
16215 else
16218 # ifdef FEAT_MBYTE
16224 else
16225 # endif
16228 # ifdef FEAT_MBYTE
16229 /* Release conversion descriptors */
16232 # endif
16233 }
16234 }
16235 #endif
16237 /*
16238 * "stridx()" function
16239 */
16240 static void
16244 {
16259 {
16267 }
16272 }
16274 /*
16275 * "string()" function
16276 */
16277 static void
16281 {
16287 /* Make a copy if we have a value but it's not in allocated memory. */
16290 }
16292 /*
16293 * "strlen()" function
16294 */
16295 static void
16299 {
16302 }
16304 /*
16305 * "strpart()" function
16306 */
16307 static void
16311 {
16326 else
16329 /*
16330 * Only return the overlap between the specified part and the actual
16331 * string.
16332 */
16334 {
16337 }
16347 }
16349 /*
16350 * "strridx()" function
16351 */
16352 static void
16356 {
16373 {
16374 /* Third argument: upper limit for index */
16378 }
16379 else
16383 {
16384 /* Empty string matches past the end. */
16386 }
16387 else
16388 {
16390 {
16395 }
16396 }
16400 else
16402 }
16404 /*
16405 * "strtrans()" function
16406 */
16407 static void
16411 {
16414 }
16416 /*
16417 * "submatch()" function
16418 */
16419 static void
16423 {
16427 }
16429 /*
16430 * "substitute()" function
16431 */
16432 static void
16436 {
16449 else
16451 }
16453 /*
16454 * "synID(lnum, col, trans)" function
16455 */
16456 /*ARGSUSED*/
16457 static void
16461 {
16463 #ifdef FEAT_SYN_HL
16476 #endif
16479 }
16481 /*
16482 * "synIDattr(id, what [, mode])" function
16483 */
16484 /*ARGSUSED*/
16485 static void
16489 {
16491 #ifdef FEAT_SYN_HL
16501 {
16505 #ifdef FEAT_GUI
16507 #endif
16508 )
16510 }
16511 else
16512 {
16513 #ifdef FEAT_GUI
16516 else
16517 #endif
16520 else
16522 }
16526 {
16559 /* underline */
16561 else
16562 /* undercurl */
16565 }
16569 #endif
16572 }
16574 /*
16575 * "synIDtrans(id)" function
16576 */
16577 /*ARGSUSED*/
16578 static void
16582 {
16585 #ifdef FEAT_SYN_HL
16590 else
16591 #endif
16595 }
16597 /*
16598 * "synstack(lnum, col)" function
16599 */
16600 /*ARGSUSED*/
16601 static void
16605 {
16606 #ifdef FEAT_SYN_HL
16611 #endif
16616 #ifdef FEAT_SYN_HL
16623 {
16626 {
16632 }
16633 }
16634 #endif
16635 }
16637 /*
16638 * "system()" function
16639 */
16640 static void
16644 {
16656 {
16657 /*
16658 * Write the string to a temp file, to be used for input of the shell
16659 * command.
16660 */
16662 {
16665 }
16669 {
16672 }
16675 {
16678 }
16684 {
16687 }
16688 }
16693 #ifdef USE_CR
16694 /* translate <CR> into <NL> */
16696 {
16700 {
16703 }
16704 }
16705 #else
16706 # ifdef USE_CRNL
16707 /* translate <CR><NL> into <NL> */
16709 {
16714 {
16718 }
16720 }
16721 # endif
16722 #endif
16724 done:
16726 {
16729 }
16732 }
16734 /*
16735 * "tabpagebuflist()" function
16736 */
16737 /* ARGSUSED */
16738 static void
16742 {
16743 #ifndef FEAT_WINDOWS
16745 #else
16751 else
16752 {
16756 }
16759 else
16760 {
16763 else
16764 {
16769 }
16770 }
16771 #endif
16772 }
16775 /*
16776 * "tabpagenr()" function
16777 */
16778 /* ARGSUSED */
16779 static void
16783 {
16785 #ifdef FEAT_WINDOWS
16789 {
16793 {
16796 else
16798 }
16799 }
16800 else
16802 #endif
16804 }
16807 #ifdef FEAT_WINDOWS
16810 /*
16811 * Common code for tabpagewinnr() and winnr().
16812 */
16813 static int
16817 {
16825 {
16832 {
16836 }
16837 else
16838 {
16841 }
16842 }
16847 {
16849 {
16850 /* didn't find it in this tabpage */
16853 }
16855 }
16857 }
16858 #endif
16860 /*
16861 * "tabpagewinnr()" function
16862 */
16863 /* ARGSUSED */
16864 static void
16868 {
16870 #ifdef FEAT_WINDOWS
16876 else
16878 #endif
16880 }
16883 /*
16884 * "tagfiles()" function
16885 */
16886 /*ARGSUSED*/
16887 static void
16891 {
16893 tagname_T tn;
16897 {
16900 }
16907 }
16909 /*
16910 * "taglist()" function
16911 */
16912 static void
16916 {
16927 }
16929 /*
16930 * "tempname()" function
16931 */
16932 /*ARGSUSED*/
16933 static void
16937 {
16943 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16944 * names. Skip 'I' and 'O', they are used for shell redirection. */
16945 do
16946 {
16951 else
16952 {
16953 #ifdef EBCDIC
16958 else
16959 #endif
16961 }
16963 }
16965 /*
16966 * "test(list)" function: Just checking the walls...
16967 */
16968 /*ARGSUSED*/
16969 static void
16973 {
16974 /* Used for unit testing. Change the code below to your liking. */
16975 #if 0
16994 #endif
16995 }
16997 /*
16998 * "tolower(string)" function
16999 */
17000 static void
17004 {
17013 {
17014 #ifdef FEAT_MBYTE
17018 {
17024 /* TODO: reallocate string when byte count changes. */
17028 }
17031 else
17032 #endif
17033 {
17036 }
17037 }
17038 }
17040 /*
17041 * "toupper(string)" function
17042 */
17043 static void
17047 {
17050 }
17052 /*
17053 * "tr(string, fromstr, tostr)" function
17054 */
17055 static void
17059 {
17064 #ifdef FEAT_MBYTE
17072 #endif
17075 garray_T ga;
17081 /* Default return value: empty string. */
17088 #ifdef FEAT_MBYTE
17090 #endif
17091 /* not multi-byte: fromstr and tostr must be the same length */
17093 {
17094 #ifdef FEAT_MBYTE
17095 error:
17096 #endif
17100 }
17102 /* fromstr and tostr have to contain the same number of chars */
17104 {
17105 #ifdef FEAT_MBYTE
17107 {
17113 {
17116 {
17118 {
17121 {
17125 }
17126 }
17130 }
17132 }
17135 {
17136 /* Check that fromstr and tostr have the same number of
17137 * (multi-byte) characters. Done only once when a character
17138 * of instr doesn't appear in fromstr. */
17141 {
17144 }
17147 }
17154 }
17155 else
17156 #endif
17157 {
17158 /* When not using multi-byte chars we can do it faster. */
17162 else
17165 }
17166 }
17168 /* add a terminating NUL */
17173 }
17175 #ifdef FEAT_FLOAT
17176 /*
17177 * "trunc({float})" function
17178 */
17179 static void
17183 {
17184 float_T f;
17188 /* trunc() is not in C90, use floor() or ceil() instead. */
17190 else
17192 }
17193 #endif
17195 /*
17196 * "type(expr)" function
17197 */
17198 static void
17202 {
17206 {
17212 #ifdef FEAT_FLOAT
17214 #endif
17216 }
17218 }
17220 /*
17221 * "values(dict)" function
17222 */
17223 static void
17227 {
17229 }
17231 /*
17232 * "virtcol(string)" function
17233 */
17234 static void
17238 {
17246 {
17249 }
17252 }
17254 /*
17255 * "visualmode()" function
17256 */
17257 /*ARGSUSED*/
17258 static void
17262 {
17263 #ifdef FEAT_VISUAL
17271 /* A non-zero number or non-empty string argument: reset mode. */
17276 #else
17278 #endif
17279 }
17281 /*
17282 * "winbufnr(nr)" function
17283 */
17284 static void
17288 {
17294 else
17296 }
17298 /*
17299 * "wincol()" function
17300 */
17301 /*ARGSUSED*/
17302 static void
17306 {
17309 }
17311 /*
17312 * "winheight(nr)" function
17313 */
17314 static void
17318 {
17324 else
17326 }
17328 /*
17329 * "winline()" function
17330 */
17331 /*ARGSUSED*/
17332 static void
17336 {
17339 }
17341 /*
17342 * "winnr()" function
17343 */
17344 /* ARGSUSED */
17345 static void
17349 {
17352 #ifdef FEAT_WINDOWS
17354 #endif
17356 }
17358 /*
17359 * "winrestcmd()" function
17360 */
17361 /* ARGSUSED */
17362 static void
17366 {
17367 #ifdef FEAT_WINDOWS
17370 garray_T ga;
17375 {
17378 # ifdef FEAT_VERTSPLIT
17381 # endif
17383 }
17387 #else
17389 #endif
17391 }
17393 /*
17394 * "winrestview()" function
17395 */
17396 /* ARGSUSED */
17397 static void
17401 {
17407 else
17408 {
17411 #ifdef FEAT_VIRTUALEDIT
17413 #endif
17418 #ifdef FEAT_DIFF
17420 #endif
17433 #ifdef FEAT_DIFF
17435 #endif
17436 }
17437 }
17439 /*
17440 * "winsaveview()" function
17441 */
17442 /* ARGSUSED */
17443 static void
17447 {
17459 #ifdef FEAT_VIRTUALEDIT
17461 #endif
17466 #ifdef FEAT_DIFF
17468 #endif
17471 }
17473 /*
17474 * "winwidth(nr)" function
17475 */
17476 static void
17480 {
17486 else
17487 #ifdef FEAT_VERTSPLIT
17489 #else
17491 #endif
17492 }
17494 /*
17495 * "writefile()" function
17496 */
17497 static void
17501 {
17514 {
17517 }
17525 /* Always open the file in binary mode, library functions have a mind of
17526 * their own about CR-LF conversion. */
17529 {
17532 }
17533 else
17534 {
17537 {
17539 {
17542 else
17545 {
17548 }
17549 }
17552 {
17555 }
17557 {
17560 }
17561 }
17563 }
17566 }
17568 /*
17569 * Translate a String variable into a position.
17570 * Returns NULL when there is an error.
17571 */
17577 {
17582 /* Argument can be [lnum, col, coladd]. */
17584 {
17594 /* Get the line number */
17599 /* Get the column number */
17605 /* We accept "$" for the column number: last column. */
17612 /* Accept a position up to the NUL after the line. */
17617 #ifdef FEAT_VIRTUALEDIT
17618 /* Get the virtual offset. Defaults to zero. */
17622 #endif
17625 }
17632 #ifdef FEAT_VISUAL
17634 {
17638 }
17639 #endif
17641 {
17646 }
17648 #ifdef FEAT_VIRTUALEDIT
17650 #endif
17653 {
17656 {
17660 }
17662 {
17666 }
17667 }
17669 {
17671 {
17674 }
17675 else
17676 {
17679 }
17681 }
17683 }
17685 /*
17686 * Convert list in "arg" into a position and optional file number.
17687 * When "fnump" is NULL there is no file number, only 3 items.
17688 * Note that the column is passed on as-is, the caller may want to decrement
17689 * it to use 1 for the first column.
17690 * Return FAIL when conversion is not possible, doesn't check the position for
17691 * validity.
17692 */
17693 static int
17698 {
17703 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17704 * when "fnump" isn't NULL and "coladd" is optional. */
17712 {
17719 }
17731 #ifdef FEAT_VIRTUALEDIT
17735 else
17737 #endif
17740 }
17742 /*
17743 * Get the length of an environment variable name.
17744 * Advance "arg" to the first character after the name.
17745 * Return 0 for error.
17746 */
17747 static int
17750 {
17755 ;
17762 }
17764 /*
17765 * Get the length of the name of a function or internal variable.
17766 * "arg" is advanced to the first non-white character after the name.
17767 * Return 0 if something is wrong.
17768 */
17769 static int
17772 {
17776 /* Find the end of the name. */
17778 ;
17786 }
17788 /*
17789 * Get the length of the name of a variable or function.
17790 * Only the name is recognized, does not handle ".key" or "[idx]".
17791 * "arg" is advanced to the first non-white character after the name.
17792 * Return -1 if curly braces expansion failed.
17793 * Return 0 if something else is wrong.
17794 * If the name contains 'magic' {}'s, expand them and return the
17795 * expanded name in an allocated string via 'alias' - caller must free.
17796 */
17797 static int
17803 {
17813 {
17814 /* hard coded <SNR>, already translated */
17817 }
17820 {
17821 /* literal "<SID>", "s:" or "<SNR>" */
17823 }
17825 /*
17826 * Find the end of the name; check for {} construction.
17827 */
17831 {
17835 {
17839 }
17841 /*
17842 * Include any <SID> etc in the expanded string:
17843 * Thus the -len here.
17844 */
17851 }
17858 }
17860 /*
17861 * Find the end of a variable or function name, taking care of magic braces.
17862 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17863 * start and end of the first magic braces item.
17864 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17865 * Return a pointer to just after the name. Equal to "arg" if there is no
17866 * valid name.
17867 */
17874 {
17880 {
17883 }
17885 /* Quick check for valid starting character. */
17895 {
17897 {
17898 /* skip over 'string' to avoid counting [ and ] inside it. */
17900 ;
17903 }
17905 {
17906 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17912 }
17915 {
17920 }
17923 {
17925 {
17926 mb_nest++;
17929 }
17931 {
17932 mb_nest--;
17935 }
17936 }
17937 }
17940 }
17942 /*
17943 * Expands out the 'magic' {}'s in a variable/function name.
17944 * Note that this can call itself recursively, to deal with
17945 * constructs like foo{bar}{baz}{bam}
17946 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17947 * "in_start" ^
17948 * "expr_start" ^
17949 * "expr_end" ^
17950 * "in_end" ^
17951 *
17952 * Returns a new allocated string, which the caller must free.
17953 * Returns NULL for failure.
17954 */
17961 {
17962 char_u c1;
17976 {
17980 {
17984 }
17985 }
17993 {
17996 {
17997 /* Further expansion! */
18002 }
18003 }
18006 }
18008 /*
18009 * Return TRUE if character "c" can be used in a variable or function name.
18010 * Does not include '{' or '}' for magic braces.
18011 */
18012 static int
18015 {
18017 }
18019 /*
18020 * Return TRUE if character "c" can be used as the first character in a
18021 * variable or function name (excluding '{' and '}').
18022 */
18023 static int
18026 {
18028 }
18030 /*
18031 * Set number v: variable to "val".
18032 */
18033 void
18037 {
18039 }
18041 /*
18042 * Get number v: variable value.
18043 */
18044 long
18047 {
18049 }
18051 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18052 /*
18053 * Get string v: variable value. Uses a static buffer, can only be used once.
18054 */
18055 char_u *
18058 {
18060 }
18061 #endif
18063 /*
18064 * Set v:count, v:count1 and v:prevcount.
18065 */
18066 void
18070 {
18074 }
18076 /*
18077 * Set string v: variable to a copy of "val".
18078 */
18079 void
18084 {
18085 /* Need to do this (at least) once, since we can't initialize a union.
18086 * Will always be invoked when "v:progname" is set. */
18094 else
18096 }
18098 /*
18099 * Set v:register if needed.
18100 */
18101 void
18104 {
18105 char_u regname;
18109 else
18111 /* Avoid free/alloc when the value is already right. */
18114 }
18116 /*
18117 * Get or set v:exception. If "oldval" == NULL, return the current value.
18118 * Otherwise, restore the value to "oldval" and return NULL.
18119 * Must always be called in pairs to save and restore v:exception! Does not
18120 * take care of memory allocations.
18121 */
18122 char_u *
18125 {
18131 }
18133 /*
18134 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18135 * Otherwise, restore the value to "oldval" and return NULL.
18136 * Must always be called in pairs to save and restore v:throwpoint! Does not
18137 * take care of memory allocations.
18138 */
18139 char_u *
18142 {
18148 }
18150 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18151 /*
18152 * Set v:cmdarg.
18153 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18154 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18155 * Must always be called in pairs!
18156 */
18157 char_u *
18161 {
18168 {
18172 }
18178 else
18186 # ifdef FEAT_MBYTE
18191 # endif
18201 else
18210 # ifdef FEAT_MBYTE
18217 # endif
18220 }
18221 #endif
18223 /*
18224 * Get the value of internal variable "name".
18225 * Return OK or FAIL.
18226 */
18227 static int
18233 {
18236 typval_T atv;
18240 /* truncate the name, so that we can use strcmp() */
18244 /*
18245 * Check for "b:changedtick".
18246 */
18248 {
18252 }
18254 /*
18255 * Check for user-defined variables.
18256 */
18257 else
18258 {
18262 }
18265 {
18269 }
18276 }
18278 /*
18279 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18280 * Also handle function call with Funcref variable: func(expr)
18281 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18282 */
18283 static int
18289 {
18294 typval_T functv;
18301 {
18303 {
18304 /* need to copy the funcref so that we can clear rettv */
18308 /* Invoke the function. Recursive! */
18314 /* Clear the funcref afterwards, so that deleting it while
18315 * evaluating the arguments is possible (see test55). */
18318 /* Stop the expression evaluation when immediately aborting on
18319 * error, or when an interrupt occurred or an exception was thrown
18320 * but not caught. */
18322 {
18326 }
18329 }
18331 {
18334 {
18338 }
18339 else
18342 {
18345 }
18346 }
18347 }
18350 }
18352 /*
18353 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18354 * value).
18355 */
18358 {
18360 }
18362 /*
18363 * Allocate memory for a variable type-value, and assign a string to it.
18364 * The string "s" must have been allocated, it is consumed.
18365 * Return NULL for out of memory, the variable otherwise.
18366 */
18370 {
18375 {
18378 }
18379 else
18382 }
18384 /*
18385 * Free the memory for a variable type-value.
18386 */
18387 void
18390 {
18392 {
18394 {
18397 /*FALLTHROUGH*/
18408 #ifdef FEAT_FLOAT
18410 #endif
18416 }
18418 }
18419 }
18421 /*
18422 * Free the memory for a variable value and set the value to NULL or 0.
18423 */
18424 void
18427 {
18429 {
18431 {
18434 /*FALLTHROUGH*/
18450 #ifdef FEAT_FLOAT
18454 #endif
18459 }
18461 }
18462 }
18464 /*
18465 * Set the value of a variable to NULL without freeing items.
18466 */
18467 static void
18470 {
18473 }
18475 /*
18476 * Get the number value of a variable.
18477 * If it is a String variable, uses vim_str2nr().
18478 * For incompatible types, return 0.
18479 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18480 * caller of incompatible types: it sets *denote to TRUE if "denote"
18481 * is not NULL or returns -1 otherwise.
18482 */
18483 static long
18486 {
18490 }
18492 long
18496 {
18500 {
18503 #ifdef FEAT_FLOAT
18507 #endif
18525 }
18528 else
18531 }
18533 /*
18534 * Get the lnum from the first argument.
18535 * Also accepts ".", "$", etc., but that only works for the current buffer.
18536 * Returns -1 on error.
18537 */
18538 static linenr_T
18541 {
18542 typval_T rettv;
18543 linenr_T lnum;
18547 {
18552 }
18554 }
18556 /*
18557 * Get the lnum from the first argument.
18558 * Also accepts "$", then "buf" is used.
18559 * Returns 0 on error.
18560 */
18561 static linenr_T
18565 {
18572 }
18574 /*
18575 * Get the string value of a variable.
18576 * If it is a Number variable, the number is converted into a string.
18577 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18578 * get_tv_string_buf() uses a given buffer.
18579 * If the String variable has never been set, return an empty string.
18580 * Never returns NULL;
18581 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18582 * NULL on error.
18583 */
18587 {
18591 }
18597 {
18601 }
18603 char_u *
18606 {
18610 }
18616 {
18618 {
18631 #ifdef FEAT_FLOAT
18635 #endif
18643 }
18645 }
18647 /*
18648 * Find variable "name" in the list of variables.
18649 * Return a pointer to it if found, NULL if not found.
18650 * Careful: "a:0" variables don't have a name.
18651 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18652 * hashtab_T used.
18653 */
18658 {
18668 }
18670 /*
18671 * Find variable "varname" in hashtab "ht".
18672 * Returns NULL if not found.
18673 */
18679 {
18683 {
18684 /* Must be something like "s:", otherwise "ht" would be NULL. */
18686 {
18692 #ifdef FEAT_WINDOWS
18694 #endif
18699 }
18701 }
18705 {
18706 /* For global variables we may try auto-loading the script. If it
18707 * worked find the variable again. Don't auto-load a script if it was
18708 * loaded already, otherwise it would be loaded every time when
18709 * checking if a function name is a Funcref variable. */
18715 }
18717 }
18719 /*
18720 * Find the hashtab used for a variable name.
18721 * Set "varname" to the start of name without ':'.
18722 */
18727 {
18731 {
18732 /* The name must not start with a colon or #. */
18737 /* "version" is "v:version" in all scopes */
18745 }
18749 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18750 */
18758 #ifdef FEAT_WINDOWS
18761 #endif
18772 }
18774 /*
18775 * Get the string value of a (global/local) variable.
18776 * Returns NULL when it doesn't exist.
18777 */
18778 char_u *
18781 {
18788 }
18790 /*
18791 * Allocate a new hashtab for a sourced script. It will be used while
18792 * sourcing this script and when executing functions defined in the script.
18793 */
18794 void
18796 scid_T id;
18797 {
18803 {
18804 /* Re-allocating ga_data means that an ht_array pointing to
18805 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18806 * at its init value. Also reset "v_dict", it's always the same. */
18808 {
18814 }
18817 {
18821 }
18822 }
18823 }
18825 /*
18826 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18827 * point to it.
18828 */
18829 void
18833 {
18841 }
18843 /*
18844 * Clean up a list of internal variables.
18845 * Frees all allocated variables and the value they contain.
18846 * Clears hashtab "ht", does not free it.
18847 */
18848 void
18851 {
18853 }
18855 /*
18856 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18857 */
18858 static void
18862 {
18870 {
18872 {
18875 /* Free the variable. Don't remove it from the hashtab,
18876 * ht_array might change then. hash_clear() takes care of it
18877 * later. */
18883 }
18884 }
18887 }
18889 /*
18890 * Delete a variable from hashtab "ht" at item "hi".
18891 * Clear the variable value and free the dictitem.
18892 */
18893 static void
18897 {
18903 }
18905 /*
18906 * List the value of one internal variable.
18907 */
18908 static void
18913 {
18922 }
18924 static void
18931 {
18932 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18944 {
18948 }
18950 {
18954 }
18955 else
18963 {
18966 }
18967 }
18969 /*
18970 * Set variable "name" to value in "tv".
18971 * If the variable already exists, the value is updated.
18972 * Otherwise the variable is created.
18973 */
18974 static void
18979 {
18986 {
18990 {
18993 }
18995 {
18997 name);
18999 }
19000 }
19004 {
19007 }
19011 {
19012 /* existing variable, need to clear the value */
19021 #ifdef FEAT_FLOAT
19026 #endif
19027 )
19028 {
19031 }
19033 /*
19034 * Handle setting internal v: variables separately: we don't change
19035 * the type.
19036 */
19038 {
19040 {
19044 else
19045 {
19046 /* Take over the string to avoid an extra alloc/free. */
19049 }
19050 }
19053 else
19054 {
19058 }
19060 }
19063 }
19065 {
19066 /* Can't add "v:" variable. */
19068 {
19071 }
19073 /* Make sure the variable name is valid. */
19077 {
19080 }
19088 {
19091 }
19093 }
19097 else
19098 {
19102 }
19103 }
19105 /*
19106 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19107 * Also give an error message.
19108 */
19109 static int
19113 {
19115 {
19118 }
19120 {
19123 }
19125 }
19127 /*
19128 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19129 * Also give an error message.
19130 */
19131 static int
19135 {
19137 {
19140 }
19142 }
19144 /*
19145 * Return TRUE if typeval "tv" is set to be locked (immutable).
19146 * Also give an error message, using "name".
19147 */
19148 static int
19152 {
19154 {
19158 }
19160 {
19164 }
19166 }
19168 /*
19169 * Copy the values from typval_T "from" to typval_T "to".
19170 * When needed allocates string or increases reference count.
19171 * Does not make a copy of a list or dict but copies the reference!
19172 */
19173 static void
19177 {
19181 {
19185 #ifdef FEAT_FLOAT
19189 #endif
19194 else
19195 {
19199 }
19204 else
19205 {
19208 }
19213 else
19214 {
19217 }
19222 }
19223 }
19225 /*
19226 * Make a copy of an item.
19227 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19228 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19229 * reference to an already copied list/dict can be used.
19230 * Returns FAIL or OK.
19231 */
19232 static int
19238 {
19243 {
19246 }
19250 {
19252 #ifdef FEAT_FLOAT
19254 #endif
19265 {
19266 /* use the copy made earlier */
19269 }
19270 else
19281 {
19282 /* use the copy made earlier */
19285 }
19286 else
19294 }
19297 }
19299 /*
19300 * ":echo expr1 ..." print each argument separated with a space, add a
19301 * newline at the end.
19302 * ":echon expr1 ..." print each argument plain.
19303 */
19304 void
19307 {
19309 typval_T rettv;
19319 {
19320 /* If eval1() causes an error message the text from the command may
19321 * still need to be cleared. E.g., "echo 22,44". */
19326 {
19327 /*
19328 * Report the invalid expression unless the expression evaluation
19329 * has been cancelled due to an aborting error, an interrupt, or an
19330 * exception.
19331 */
19336 }
19340 {
19342 {
19344 /* Call msg_start() after eval1(), evaluating the expression
19345 * may cause a message to appear. */
19348 }
19354 {
19356 {
19358 {
19359 /* remove any text still there from the command */
19362 }
19364 }
19365 else
19366 {
19367 #ifdef FEAT_MBYTE
19369 {
19374 }
19375 else
19376 #endif
19378 }
19379 }
19381 }
19384 }
19389 else
19390 {
19391 /* remove text that may still be there from the command */
19396 }
19397 }
19399 /*
19400 * ":echohl {name}".
19401 */
19402 void
19405 {
19411 else
19413 }
19415 /*
19416 * ":execute expr1 ..." execute the result of an expression.
19417 * ":echomsg expr1 ..." Print a message
19418 * ":echoerr expr1 ..." Print an error
19419 * Each gets spaces around each argument and a newline at the end for
19420 * echo commands
19421 */
19422 void
19425 {
19427 typval_T rettv;
19430 garray_T ga;
19439 {
19442 {
19443 /*
19444 * Report the invalid expression unless the expression evaluation
19445 * has been cancelled due to an aborting error, an interrupt, or an
19446 * exception.
19447 */
19452 }
19455 {
19459 {
19463 }
19468 }
19472 }
19475 {
19477 {
19480 }
19482 {
19483 /* We don't want to abort following commands, restore did_emsg. */
19488 }
19492 }
19500 }
19502 /*
19503 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19504 * "arg" points to the "&" or '+' when called, to "option" when returning.
19505 * Returns NULL when no option name found. Otherwise pointer to the char
19506 * after the option name.
19507 */
19512 {
19517 {
19520 }
19522 {
19525 }
19526 else
19535 else
19539 }
19541 /*
19542 * ":function"
19543 */
19544 void
19547 {
19556 garray_T newargs;
19557 garray_T newlines;
19566 funcdict_T fudi;
19574 /*
19575 * ":function" without argument: list functions.
19576 */
19578 {
19580 {
19583 {
19585 {
19590 }
19591 }
19592 }
19595 }
19597 /*
19598 * ":function /pat": list functions matching pattern.
19599 */
19601 {
19604 {
19605 regmatch_T regmatch;
19612 {
19617 {
19619 {
19625 }
19626 }
19627 }
19628 }
19633 }
19635 /*
19636 * Get the function name. There are these situations:
19637 * func normal function name
19638 * "name" == func, "fudi.fd_dict" == NULL
19639 * dict.func new dictionary entry
19640 * "name" == NULL, "fudi.fd_dict" set,
19641 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19642 * dict.func existing dict entry with a Funcref
19643 * "name" == func, "fudi.fd_dict" set,
19644 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19645 * dict.func existing dict entry that's not a Funcref
19646 * "name" == NULL, "fudi.fd_dict" set,
19647 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19648 */
19653 {
19654 /*
19655 * Return on an invalid expression in braces, unless the expression
19656 * evaluation has been cancelled due to an aborting error, an
19657 * interrupt, or an exception.
19658 */
19660 {
19665 }
19666 else
19668 }
19670 /* An error in a function call during evaluation of an expression in magic
19671 * braces should not cause the function not to be defined. */
19675 /*
19676 * ":function func" with only function name: list function.
19677 */
19679 {
19681 {
19684 }
19689 {
19692 {
19695 {
19707 }
19709 {
19712 }
19713 }
19714 else
19716 }
19718 }
19720 /*
19721 * ":function name(arg1, arg2)" Define function.
19722 */
19725 {
19727 {
19730 }
19731 /* attempt to continue by skipping some text */
19734 }
19741 {
19742 /* Check the name of the function. Unless it's a dictionary function
19743 * (that we are overwriting). */
19746 else
19750 {
19753 else
19760 }
19761 }
19763 /*
19764 * Isolate the arguments: "arg1, arg2, ...)"
19765 */
19767 {
19769 {
19773 }
19774 else
19775 {
19782 {
19786 }
19799 else
19801 }
19804 {
19808 }
19809 }
19812 /* find extra arguments "range", "dict" and "abort" */
19814 {
19817 {
19820 }
19822 {
19825 }
19827 {
19830 }
19831 else
19833 }
19835 /* When there is a line break use what follows for the function body.
19836 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19842 /*
19843 * Read the body of the function, until ":endfunction" is found.
19844 */
19846 {
19847 /* Check if the function already exists, don't let the user type the
19848 * whole function before telling him it doesn't work! For a script we
19849 * need to skip the body to be able to find what follows. */
19851 {
19856 }
19863 }
19868 {
19874 {
19875 /* Use eap->arg, split up in parts by line breaks. */
19880 else
19881 {
19884 }
19885 }
19888 else
19893 {
19896 }
19898 /* Detect line continuation: sourcing_lnum increased more than one. */
19901 else
19905 {
19906 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19907 * don't check for ":endfunc". */
19909 {
19912 }
19913 }
19914 else
19915 {
19916 /* skip ':' and blanks*/
19918 ;
19920 /* Check for "endfunction". */
19922 {
19926 }
19928 /* Increase indent inside "if", "while", "for" and "try", decrease
19929 * at "end". */
19938 /* Check for defining a function inside this function. */
19940 {
19945 {
19948 {
19951 }
19952 }
19953 }
19955 /* Check for ":append" or ":insert". */
19963 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19976 ))
19977 {
19978 /* ":python <<" continues until a dot, like ":append" */
19982 else
19984 }
19985 }
19987 /* Add the line to the function. */
19989 {
19993 }
19995 /* Copy the line to newly allocated memory. get_one_sourceline()
19996 * allocates 250 bytes per line, this saves 80% on average. The cost
19997 * is an extra alloc/free. */
20000 {
20004 }
20008 /* Add NULL lines for continuation lines, so that the line count is
20009 * equal to the index in the growarray. */
20013 /* Check for end of eap->arg. */
20016 }
20018 /* Don't define the function when skipping commands or when an error was
20019 * detected. */
20023 /*
20024 * If there are no errors, add the function
20025 */
20027 {
20030 {
20032 name);
20034 }
20038 {
20040 {
20043 }
20045 {
20047 name);
20049 }
20050 /* redefine existing function */
20055 }
20056 }
20057 else
20058 {
20063 {
20066 }
20068 {
20069 /* Can't add a function to a locked dictionary */
20072 }
20073 /* Can't change an existing function if it is locked */
20077 /* Give the function a sequential number. Can only be used with a
20078 * Funcref! */
20084 }
20087 {
20089 {
20093 /* Check that the autoload name matches the script name. */
20096 {
20099 {
20107 }
20108 }
20110 {
20113 }
20114 }
20121 {
20123 {
20124 /* add new dict entry */
20127 {
20130 }
20132 {
20136 }
20137 }
20138 else
20139 /* overwrite existing dict entry */
20146 /* behave like "dict" was used */
20148 }
20150 /* insert the new function in the function list */
20153 }
20156 #ifdef FEAT_PROFILE
20163 #endif
20170 erret:
20173 ret_free:
20178 }
20180 /*
20181 * Get a function name, translating "<SID>" and "<SNR>".
20182 * Also handles a Funcref in a List or Dictionary.
20183 * Returns the function name in allocated memory, or NULL for failure.
20184 * flags:
20185 * TFN_INT: internal function name OK
20186 * TFN_QUIET: be quiet
20187 * Advances "pp" to just after the function name (if no error).
20188 */
20195 {
20202 lval_T lv;
20208 /* Check for hard coded <SNR>: already translated function ID (from a user
20209 * command). */
20212 {
20216 }
20218 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20219 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20227 {
20231 }
20233 {
20234 /*
20235 * Report an invalid expression in braces, unless the expression
20236 * evaluation has been cancelled due to an aborting error, an
20237 * interrupt, or an exception.
20238 */
20240 {
20243 }
20244 else
20247 }
20250 {
20252 {
20257 }
20259 {
20262 }
20263 else
20264 {
20268 else
20271 }
20273 }
20276 {
20277 /* Error found, but continue after the function name. */
20280 }
20282 /* Check if the name is a Funcref. If so, use the value. */
20284 {
20289 }
20290 else
20291 {
20296 }
20298 {
20302 }
20305 {
20309 {
20310 /* When there was "s:" already or the name expanded to get a
20311 * leading "s:" then remove it. */
20315 }
20316 }
20317 else
20318 {
20322 }
20324 /*
20325 * Copy the function name to allocated memory.
20326 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20327 * Accept <SNR>123_name() outside a script.
20328 */
20332 {
20336 {
20337 /* It's "s:" or "<SID>" */
20339 {
20342 }
20345 }
20346 }
20348 {
20351 }
20354 {
20356 {
20362 }
20365 }
20368 theend:
20371 }
20373 /*
20374 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20375 * Return 2 if "p" starts with "s:".
20376 * Return 0 otherwise.
20377 */
20378 static int
20381 {
20388 }
20390 /*
20391 * Return TRUE if "p" starts with "<SID>" or "s:".
20392 * Only works if eval_fname_script() returned non-zero for "p"!
20393 */
20394 static int
20397 {
20399 }
20401 /*
20402 * List the head of the function: "name(arg1, arg2)".
20403 */
20404 static void
20408 {
20416 {
20419 }
20420 else
20424 {
20428 }
20430 {
20434 }
20439 }
20441 /*
20442 * Find a function by name, return pointer to it in ufuncs.
20443 * Return NULL for unknown function.
20444 */
20448 {
20455 }
20457 #if defined(EXITFREE) || defined(PROTO)
20458 void
20460 {
20463 /* Need to start all over every time, because func_free() may change the
20464 * hash table. */
20468 {
20471 }
20472 }
20473 #endif
20475 /*
20476 * Return TRUE if a function "name" exists.
20477 */
20478 static int
20481 {
20489 /* Only accept "funcname", "funcname ", "funcname (..." and
20490 * "funcname(...", not "funcname!...". */
20492 {
20495 else
20497 }
20500 }
20502 /*
20503 * Return TRUE if "name" looks like a builtin function name: starts with a
20504 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20505 */
20506 static int
20509 {
20512 }
20514 #if defined(FEAT_PROFILE) || defined(PROTO)
20515 /*
20516 * Start profiling function "fp".
20517 */
20518 static void
20521 {
20540 }
20542 /*
20543 * Dump the profiling results for all functions in file "fd".
20544 */
20545 void
20548 {
20560 {
20562 {
20566 {
20572 else
20576 else
20584 {
20590 }
20592 }
20593 }
20594 }
20597 {
20599 prof_total_cmp);
20602 prof_self_cmp);
20604 }
20605 }
20607 static void
20614 {
20621 {
20624 prefer_self);
20627 else
20629 }
20631 }
20633 /*
20634 * Print the count and times for one function or function line.
20635 */
20636 static void
20643 {
20645 {
20649 else
20653 else
20655 }
20656 else
20658 }
20660 /*
20661 * Compare function for total time sorting.
20662 */
20663 static int
20664 #ifdef __BORLANDC__
20665 _RTLENTRYF
20666 #endif
20670 {
20676 }
20678 /*
20679 * Compare function for self time sorting.
20680 */
20681 static int
20682 #ifdef __BORLANDC__
20683 _RTLENTRYF
20684 #endif
20688 {
20694 }
20696 #endif
20698 /*
20699 * If "name" has a package name try autoloading the script for it.
20700 * Return TRUE if a package was loaded.
20701 */
20702 static int
20706 {
20712 /* If there is no '#' after name[0] there is no package name. */
20719 /* Find the name in the list of previously loaded package names. Skip
20720 * "autoload/", it's always the same. */
20726 else
20727 {
20728 /* Remember the name if it wasn't loaded already. */
20730 {
20733 }
20735 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20738 }
20742 }
20744 /*
20745 * Return the autoload script name for a function or variable name.
20746 * Returns NULL when out of memory.
20747 */
20751 {
20755 /* Get the script file name: replace '#' with '/', append ".vim". */
20766 }
20768 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20770 /*
20771 * Function given to ExpandGeneric() to obtain the list of user defined
20772 * function names.
20773 */
20774 char_u *
20778 {
20784 {
20787 }
20789 {
20801 {
20805 }
20807 }
20809 }
20813 /*
20814 * Copy the function name of "fp" to buffer "buf".
20815 * "buf" must be able to hold the function name plus three bytes.
20816 * Takes care of script-local function names.
20817 */
20818 static void
20822 {
20824 {
20827 }
20828 else
20830 }
20832 /*
20833 * ":delfunction {name}"
20834 */
20835 void
20838 {
20842 funcdict_T fudi;
20848 {
20852 }
20854 {
20858 }
20868 {
20870 {
20873 }
20875 {
20878 }
20881 {
20882 /* Delete the dict item that refers to the function, it will
20883 * invoke func_unref() and possibly delete the function. */
20885 }
20886 else
20888 }
20889 }
20891 /*
20892 * Free a function and remove it from the list of functions.
20893 */
20894 static void
20897 {
20900 /* clear this function */
20903 #ifdef FEAT_PROFILE
20907 #endif
20909 /* remove the function from the function hashtable */
20913 else
20917 }
20919 /*
20920 * Unreference a Function: decrement the reference count and free it when it
20921 * becomes zero. Only for numbered functions.
20922 */
20923 static void
20926 {
20930 {
20935 {
20936 /* Only delete it when it's not being used. Otherwise it's done
20937 * when "uf_calls" becomes zero. */
20940 }
20941 }
20942 }
20944 /*
20945 * Count a reference to a Function.
20946 */
20947 static void
20950 {
20954 {
20958 else
20960 }
20961 }
20963 /*
20964 * Call a user function.
20965 */
20966 static void
20975 {
20977 linenr_T save_sourcing_lnum;
20978 scid_T save_current_SID;
20979 funccall_T fc;
20988 #ifdef FEAT_PROFILE
20989 proftime_T wait_start;
20990 proftime_T call_start;
20991 #endif
20993 /* If depth of calling is getting too high, don't execute the function */
20995 {
21000 }
21013 /* Check if this function has a breakpoint. */
21017 /*
21018 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21019 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21020 * each argument variable and saves a lot of time.
21021 */
21022 /*
21023 * Init l: variables.
21024 */
21027 {
21028 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21029 * some compiler that checks the destination size. */
21039 }
21041 /*
21042 * Init a: variables.
21043 * Set a:0 to "argcount".
21044 * Set a:000 to a list with room for the "..." arguments.
21045 */
21060 /*
21061 * Set a:firstline to "firstline" and a:lastline to "lastline".
21062 * Set a:name to named arguments.
21063 * Set a:N to the "..." arguments.
21064 */
21070 {
21073 /* named argument a:name */
21075 else
21076 {
21077 /* "..." argument a:1, a:2, etc. */
21080 }
21082 {
21085 }
21086 else
21087 {
21093 }
21097 /* Note: the values are copied directly to avoid alloc/free.
21098 * "argvars" must have VAR_FIXED for v_lock. */
21103 {
21107 }
21108 }
21110 /* Don't redraw while executing the function. */
21118 {
21122 else
21127 {
21133 {
21141 {
21146 else
21147 {
21150 {
21154 }
21155 }
21156 }
21158 }
21163 }
21164 }
21165 #ifdef FEAT_PROFILE
21167 {
21172 {
21176 }
21178 }
21179 #endif
21186 /* call do_cmdline() to execute the lines */
21192 /* when the function was aborted because of an error, return -1 */
21194 {
21198 }
21200 #ifdef FEAT_PROFILE
21203 {
21209 {
21212 }
21213 }
21214 #endif
21216 /* when being verbose, mention the return value */
21218 {
21227 else
21228 {
21234 /* The value may be very long. Skip the middle part, so that we
21235 * have some idea how it starts and ends. smsg() would always
21236 * truncate it at the end. */
21239 {
21243 }
21244 }
21249 }
21255 #ifdef FEAT_PROFILE
21258 #endif
21261 {
21270 }
21275 /* The a: variables typevals were not allocated, only free the allocated
21276 * variables. */
21281 }
21283 /*
21284 * Add a number variable "name" to dict "dp" with value "nr".
21285 */
21286 static void
21291 varnumber_T nr;
21292 {
21299 }
21301 /*
21302 * ":return [expr]"
21303 */
21304 void
21307 {
21309 typval_T rettv;
21313 {
21316 }
21324 {
21327 else
21329 }
21330 /* It's safer to return also on error. */
21332 {
21333 /*
21334 * Return unless the expression evaluation has been cancelled due to an
21335 * aborting error, an interrupt, or an exception.
21336 */
21339 }
21341 /* When skipping or the return gets pending, advance to the next command
21342 * in this line (!returning). Otherwise, ignore the rest of the line.
21343 * Following lines will be ignored by get_func_line(). */
21351 }
21353 /*
21354 * Return from a function. Possibly makes the return pending. Also called
21355 * for a pending return at the ":endtry" or after returning from an extra
21356 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21357 * when called due to a ":return" command. "rettv" may point to a typval_T
21358 * with the return rettv. Returns TRUE when the return can be carried out,
21359 * FALSE when the return gets pending.
21360 */
21361 int
21367 {
21372 /* Undo the return. */
21375 /*
21376 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21377 * not in its finally clause (which then is to be executed next) is found.
21378 * In this case, make the ":return" pending for execution at the ":endtry".
21379 * Otherwise, return normally.
21380 */
21383 {
21387 /* A pending return again gets pending. "rettv" points to an
21388 * allocated variable with the rettv of the original ":return"'s
21389 * argument if present or is NULL else. */
21391 else
21392 {
21393 /* When undoing a return in order to make it pending, get the stored
21394 * return rettv. */
21399 {
21400 /* Store the value of the pending return. */
21403 else
21405 }
21406 else
21410 {
21411 /* The pending return value could be overwritten by a ":return"
21412 * without argument in a finally clause; reset the default
21413 * return value. */
21416 }
21417 }
21419 }
21420 else
21421 {
21424 /* If the return is carried out now, store the return value. For
21425 * a return immediately after reanimation, the value is already
21426 * there. */
21428 {
21433 }
21434 }
21437 }
21439 /*
21440 * Free the variable with a pending return value.
21441 */
21442 void
21445 {
21447 }
21449 /*
21450 * Generate a return command for producing the value of "rettv". The result
21451 * is an allocated string. Used by report_pending() for verbose messages.
21452 */
21453 char_u *
21456 {
21472 }
21474 /*
21475 * Get next function line.
21476 * Called by do_cmdline() to get the next line.
21477 * Returns allocated string, or NULL for end of function.
21478 */
21479 /* ARGSUSED */
21480 char_u *
21485 {
21491 /* If breakpoints have been added/deleted need to check for it. */
21493 {
21495 sourcing_lnum);
21497 }
21498 #ifdef FEAT_PROFILE
21501 #endif
21507 else
21508 {
21509 /* Skip NULL lines (continuation lines). */
21515 else
21516 {
21519 #ifdef FEAT_PROFILE
21522 #endif
21523 }
21524 }
21526 /* Did we encounter a breakpoint? */
21528 {
21530 /* Find next breakpoint. */
21532 sourcing_lnum);
21534 }
21537 }
21539 #if defined(FEAT_PROFILE) || defined(PROTO)
21540 /*
21541 * Called when starting to read a function line.
21542 * "sourcing_lnum" must be correct!
21543 * When skipping lines it may not actually be executed, but we won't find out
21544 * until later and we need to store the time now.
21545 */
21546 void
21549 {
21555 {
21557 /* Skip continuation lines. */
21564 }
21565 }
21567 /*
21568 * Called when actually executing a function line.
21569 */
21570 void
21573 {
21579 }
21581 /*
21582 * Called when done with a function line.
21583 */
21584 void
21587 {
21592 {
21594 {
21601 }
21603 }
21604 }
21605 #endif
21607 /*
21608 * Return TRUE if the currently active function should be ended, because a
21609 * return was encountered or an error occurred. Used inside a ":while".
21610 */
21611 int
21614 {
21617 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21618 * an error inside a try conditional. */
21621 }
21623 /*
21624 * return TRUE if cookie indicates a function which "abort"s on errors.
21625 */
21626 int
21629 {
21631 }
21633 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21635 {
21638 VAR_FLAVOUR_VIMINFO /* all uppercase */
21643 static var_flavour_T
21646 {
21650 {
21655 }
21656 else
21658 }
21659 #endif
21661 #if defined(FEAT_VIMINFO) || defined(PROTO)
21662 /*
21663 * Restore global vars that start with a capital from the viminfo file
21664 */
21665 int
21669 {
21672 typval_T tv;
21675 {
21678 {
21682 #ifdef FEAT_FLOAT
21685 #endif
21689 {
21694 #ifdef FEAT_FLOAT
21697 #endif
21698 else
21703 }
21704 }
21705 }
21708 }
21710 /*
21711 * Write global vars that start with a capital to the viminfo file
21712 */
21713 void
21716 {
21732 {
21734 {
21738 {
21740 {
21743 #ifdef FEAT_FLOAT
21745 #endif
21747 }
21753 }
21754 }
21755 }
21756 }
21757 #endif
21759 #if defined(FEAT_SESSION) || defined(PROTO)
21760 int
21763 {
21771 {
21773 {
21779 {
21780 /* Escape special characters with a backslash. Turn a LF and
21781 * CR into \n and \r. */
21795 p,
21799 {
21802 }
21804 }
21805 #ifdef FEAT_FLOAT
21808 {
21813 {
21816 }
21821 }
21822 #endif
21823 }
21824 }
21826 }
21827 #endif
21829 /*
21830 * Display script name where an item was last set.
21831 * Should only be invoked when 'verbose' is non-zero.
21832 */
21833 void
21835 scid_T scriptID;
21836 {
21840 {
21843 {
21849 }
21850 }
21851 }
21856 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21858 #ifdef WIN3264
21859 /*
21860 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21861 */
21863 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21866 /*
21867 * Get the short path (8.3) for the filename in "fnamep".
21868 * Only works for a valid file name.
21869 * When the path gets longer "fnamep" is changed and the allocated buffer
21870 * is put in "bufp".
21871 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21872 * Returns OK on success, FAIL on failure.
21873 */
21874 static int
21879 {
21886 {
21887 /* If that doesn't work (not enough space), then save the string
21888 * and try again with a new buffer big enough. */
21896 /* Really should always succeed, as the buffer is big enough. */
21898 }
21902 }
21904 /*
21905 * Get the short path (8.3) for the filename in "fname". The converted
21906 * path is returned in "bufp".
21907 *
21908 * Some of the directories specified in "fname" may not exist. This function
21909 * will shorten the existing directories at the beginning of the path and then
21910 * append the remaining non-existing path.
21911 *
21912 * fname - Pointer to the filename to shorten. On return, contains the
21913 * pointer to the shortened pathname
21914 * bufp - Pointer to an allocated buffer for the filename.
21915 * fnamelen - Length of the filename pointed to by fname
21916 *
21917 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21918 */
21919 static int
21924 {
21927 char_u ch;
21932 /* Make a copy */
21941 /*
21942 * Try shortening the supplied path till it succeeds by removing one
21943 * directory at a time from the tail of the path.
21944 */
21947 {
21948 /* go back one path-separator */
21954 /*
21955 * Replace the path separator with a NUL and try to shorten the
21956 * resulting path.
21957 */
21963 {
21966 }
21972 /* failed to shorten the path. Skip the path separator */
21974 }
21977 {
21978 /*
21979 * Succeeded in shortening the path. Now concatenate the shortened
21980 * path with the remaining path at the tail.
21981 */
21983 /* Compute the length of the new path. */
21990 {
21991 /* There is not enough space in the currently allocated string,
21992 * copy it to a buffer big enough. */
21995 {
21998 }
21999 }
22000 else
22001 {
22002 /* Transfer short_fname to the main buffer (it's big enough),
22003 * unless get_short_pathname() did its work in-place. */
22008 }
22010 /* concat the not-shortened part of the path */
22013 }
22015 theend:
22020 }
22022 /*
22023 * Get a pathname for a partial path.
22024 * Returns OK for success, FAIL for failure.
22025 */
22026 static int
22031 {
22037 /* Count up the path separators from the RHS.. so we know which part
22038 * of the path to return. */
22044 /* Need full path first (use expand_env() to remove a "~/") */
22048 else
22057 {
22058 /* Don't have a valid filename, so shorten the rest of the
22059 * path if we can. This CAN give us invalid 8.3 filenames, but
22060 * there's not a lot of point in guessing what it might be.
22061 */
22065 }
22067 /* Count the paths backward to find the beginning of the desired string. */
22069 {
22070 #ifdef FEAT_MBYTE
22073 #endif
22075 {
22078 else
22079 sepcount --;
22080 }
22081 }
22083 {
22087 else
22089 }
22090 else
22093 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22100 }
22103 /*
22104 * Adjust a filename, according to a string of modifiers.
22105 * *fnamep must be NUL terminated when called. When returning, the length is
22106 * determined by *fnamelen.
22107 * Returns VALID_ flags or -1 for failure.
22108 * When there is an error, *fnamep is set to NULL.
22109 */
22110 int
22117 {
22124 #ifdef WIN3264
22126 #endif
22128 repeat:
22129 /* ":p" - full path/file_name */
22131 {
22137 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22139 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22141 # ifdef BACKSLASH_IN_FILENAME
22143 # endif
22146 #endif
22147 )
22148 {
22154 }
22156 /* When "/." or "/.." is used: force expansion to get rid of it. */
22158 {
22166 }
22168 /* FullName_save() is slow, don't use it when not needed. */
22170 {
22176 }
22178 /* Append a path separator to a directory. */
22180 {
22181 /* Make room for one or two extra characters. */
22188 }
22189 }
22191 /* ":." - path relative to the current directory */
22192 /* ":~" - path relative to the home directory */
22193 /* ":8" - shortname path - postponed till after */
22196 {
22199 {
22200 #ifdef WIN3264
22202 #endif
22204 }
22206 /* Need full path first (use expand_env() to remove a "~/") */
22208 {
22211 else
22213 }
22214 else
22220 {
22222 {
22226 {
22229 {
22233 }
22234 }
22235 }
22236 else
22237 {
22239 /* Only replace it when it starts with '~' */
22241 {
22244 {
22248 }
22249 }
22250 }
22252 }
22253 }
22258 /* ":h" - head, remove "/file_name", can be repeated */
22259 /* Don't remove the first "/" or "c:\" */
22261 {
22268 #ifdef VMS
22271 #endif
22273 {
22274 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22281 }
22282 else
22283 {
22286 }
22287 }
22289 /* ":8" - shortname */
22291 {
22293 #ifdef WIN3264
22295 #endif
22296 }
22298 #ifdef WIN3264
22299 /* Check shortname after we have done 'heads' and before we do 'tails'
22300 */
22302 {
22304 /* Copy the string if it is shortened by :h */
22306 {
22312 }
22314 /* Split into two implementations - makes it easier. First is where
22315 * there isn't a full name already, second is where there is.
22316 */
22318 {
22321 }
22322 else
22323 {
22326 /* Simple case, already have the full-name
22327 * Nearly always shorter, so try first time. */
22333 {
22334 /* Couldn't find the filename.. search the paths.
22335 */
22339 }
22341 }
22342 }
22345 /* ":t" - tail, just the basename */
22347 {
22351 }
22353 /* ":e" - extension, can be repeated */
22354 /* ":r" - root, without extension, can be repeated */
22357 {
22358 /* find a '.' in the tail:
22359 * - for second :e: before the current fname
22360 * - otherwise: The last '.'
22361 */
22364 else
22370 {
22372 {
22375 #ifdef VMS
22376 /* cut version from the extension */
22383 #endif
22384 }
22387 }
22389 {
22392 }
22394 }
22396 /* ":s?pat?foo?" - substitute */
22397 /* ":gs?pat?foo?" - global substitute */
22401 {
22412 {
22415 }
22419 {
22420 /* find end of pattern */
22423 {
22426 {
22428 /* find end of substitution */
22431 {
22435 {
22439 {
22445 }
22446 }
22449 }
22451 }
22452 }
22453 /* after using ":s", repeat all the modifiers */
22456 }
22457 }
22460 }
22462 /*
22463 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22464 * "flags" can be "g" to do a global substitute.
22465 * Returns an allocated string, NULL for error.
22466 */
22467 char_u *
22473 {
22475 regmatch_T regmatch;
22479 garray_T ga;
22483 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22494 {
22497 {
22498 /*
22499 * Get some space for a temporary buffer to do the substitution
22500 * into. It will contain:
22501 * - The text up to where the match is.
22502 * - The substituted text.
22503 * - The text after the match.
22504 */
22508 {
22511 }
22513 /* copy the text up to where the match is */
22516 /* add the substituted text */
22520 /* avoid getting stuck on a match with an empty string */
22522 {
22527 }
22528 else
22529 {
22533 }
22536 }
22542 }
22549 }