| blob | e4024986e27bf364524b8c8d3742fb3f7c74d8a9 |
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
4632 {
4633 typval_T var2;
4636 #ifdef FEAT_FLOAT
4639 #endif
4642 /*
4643 * Get the first variable.
4644 */
4648 /*
4649 * Repeat computing, until no '*', '/' or '%' is following.
4650 */
4652 {
4658 {
4659 #ifdef FEAT_FLOAT
4661 {
4665 }
4666 else
4667 #endif
4672 }
4673 else
4676 /*
4677 * Get the second variable.
4678 */
4684 {
4685 #ifdef FEAT_FLOAT
4687 {
4689 {
4692 }
4695 }
4696 else
4697 #endif
4698 {
4703 #ifdef FEAT_FLOAT
4706 #endif
4707 }
4709 /*
4710 * Compute the result.
4711 * When either side is a float the result is a float.
4712 */
4713 #ifdef FEAT_FLOAT
4715 {
4719 {
4720 /* We rely on the floating point library to handle divide
4721 * by zero to result in "inf" and not a crash. */
4723 }
4724 else
4725 {
4728 }
4731 }
4732 else
4733 #endif
4734 {
4738 {
4740 {
4745 else
4747 }
4748 else
4750 }
4751 else
4752 {
4755 else
4757 }
4760 }
4761 }
4762 }
4765 }
4767 /*
4768 * Handle sixth level expression:
4769 * number number constant
4770 * "string" string constant
4771 * 'string' literal string constant
4772 * &option-name option value
4773 * @r register contents
4774 * identifier variable value
4775 * function() function call
4776 * $VAR environment variable
4777 * (expression) nested expression
4778 * [expr, expr] List
4779 * {key: val, key: val} Dictionary
4780 *
4781 * Also handle:
4782 * ! in front logical NOT
4783 * - in front unary minus
4784 * + in front unary plus (ignored)
4785 * trailing [] subscript in String or List
4786 * trailing .name entry in Dictionary
4787 *
4788 * "arg" must point to the first non-white of the expression.
4789 * "arg" is advanced to the next non-white after the recognized expression.
4790 *
4791 * Return OK or FAIL.
4792 */
4793 static int
4799 {
4807 /*
4808 * Initialise variable so that clear_tv() can't mistake this for a
4809 * string and free a string that isn't there.
4810 */
4813 /*
4814 * Skip '!' and '-' characters. They are handled later.
4815 */
4822 {
4823 /*
4824 * Number constant.
4825 */
4836 {
4837 #ifdef FEAT_FLOAT
4841 /* We accept a float when the format matches
4842 * "[0-9]\+\.[0-9]\+\([eE][+-]\?[0-9]\+\)\?". This is very
4843 * strict to avoid backwards compatibility problems.
4844 * Don't look for a float after the "." operator, so that
4845 * ":let vers = 1.2.3" doesn't fail. */
4847 {
4851 {
4857 else
4859 }
4862 }
4864 {
4865 float_T f;
4869 {
4872 }
4873 }
4874 else
4875 #endif
4876 {
4880 {
4883 }
4884 }
4886 }
4888 /*
4889 * String constant: "string".
4890 */
4894 /*
4895 * Literal string constant: 'str''ing'.
4896 */
4900 /*
4901 * List: [expr, expr]
4902 */
4906 /*
4907 * Dictionary: {key: val, key: val}
4908 */
4912 /*
4913 * Option value: &name
4914 */
4918 /*
4919 * Environment variable: $VAR.
4920 */
4924 /*
4925 * Register contents: @r.
4926 */
4929 {
4932 }
4937 /*
4938 * nested expression: (expression).
4939 */
4945 {
4949 }
4954 }
4957 {
4958 /*
4959 * Must be a variable or function name.
4960 * Can also be a curly-braces kind of name: {expr}.
4961 */
4969 else
4970 {
4972 {
4973 /* If "s" is the name of a variable of type VAR_FUNC
4974 * use its contents. */
4977 /* Invoke the function. */
4981 /* Stop the expression evaluation when immediately
4982 * aborting on error, or when an interrupt occurred or
4983 * an exception was thrown but not caught. */
4985 {
4989 }
4990 }
4993 else
4995 }
4999 }
5003 /* Handle following '[', '(' and '.' for expr[expr], expr.name,
5004 * expr(expr). */
5008 /*
5009 * Apply logical NOT and unary '-', from right to left, ignore '+'.
5010 */
5012 {
5015 #ifdef FEAT_FLOAT
5020 else
5021 #endif
5024 {
5027 }
5028 else
5029 {
5031 {
5034 {
5035 #ifdef FEAT_FLOAT
5038 else
5039 #endif
5041 }
5043 {
5044 #ifdef FEAT_FLOAT
5047 else
5048 #endif
5050 }
5051 }
5052 #ifdef FEAT_FLOAT
5054 {
5057 }
5058 else
5059 #endif
5060 {
5064 }
5065 }
5066 }
5069 }
5071 /*
5072 * Evaluate an "[expr]" or "[expr:expr]" index. Also "dict.key".
5073 * "*arg" points to the '[' or '.'.
5074 * Returns FAIL or OK. "*arg" is advanced to after the ']'.
5075 */
5076 static int
5082 {
5092 #ifdef FEAT_FLOAT
5094 #endif
5095 )
5096 {
5100 }
5103 {
5104 /*
5105 * dict.name
5106 */
5109 ;
5113 }
5114 else
5115 {
5116 /*
5117 * something[idx]
5118 *
5119 * Get the (first) variable from inside the [].
5120 */
5127 {
5128 /* not a number or string */
5131 }
5133 /*
5134 * Get the second variable from inside the [:].
5135 */
5137 {
5143 {
5147 }
5149 {
5150 /* not a number or string */
5155 }
5156 }
5158 /* Check for the ']'. */
5160 {
5167 }
5169 }
5172 {
5175 {
5178 }
5180 {
5183 else
5184 {
5187 }
5188 }
5191 {
5197 {
5198 /* The resulting variable is a substring. If the indexes
5199 * are out of range the result is empty. */
5201 {
5205 }
5212 else
5214 }
5215 else
5216 {
5217 /* The resulting variable is a string of a single
5218 * character. If the index is too big or negative the
5219 * result is empty. */
5222 else
5224 }
5235 {
5236 /* For a range we allow invalid values and return an empty
5237 * list. A list index out of range is an error. */
5239 {
5243 }
5245 }
5247 {
5262 {
5264 {
5267 }
5269 }
5274 }
5275 else
5276 {
5280 }
5285 {
5291 }
5292 {
5296 {
5299 {
5304 }
5305 }
5319 }
5321 }
5322 }
5325 }
5327 /*
5328 * Get an option value.
5329 * "arg" points to the '&' or '+' before the option name.
5330 * "arg" is advanced to character after the option name.
5331 * Return OK or FAIL.
5332 */
5333 static int
5338 {
5348 /*
5349 * Isolate the option name and find its value.
5350 */
5353 {
5357 }
5360 {
5363 }
5371 {
5375 }
5377 {
5379 {
5382 }
5384 {
5387 }
5389 {
5392 }
5394 {
5397 }
5398 }
5406 }
5408 /*
5409 * Allocate a variable for a string constant.
5410 * Return OK or FAIL.
5411 */
5412 static int
5417 {
5422 /*
5423 * Find the end of the string, skipping backslashed characters.
5424 */
5426 {
5428 {
5430 /* A "\<x>" form occupies at least 4 characters, and produces up
5431 * to 6 characters: reserve space for 2 extra */
5434 }
5435 }
5438 {
5441 }
5443 /* If only parsing, set *arg and return here */
5445 {
5448 }
5450 /*
5451 * Copy the string into allocated memory, handling backslashed
5452 * characters.
5453 */
5461 {
5463 {
5465 {
5478 {
5484 else
5488 {
5491 }
5493 #ifdef FEAT_MBYTE
5494 /* For "\u" store the number according to
5495 * 'encoding'. */
5498 else
5499 #endif
5501 }
5504 /* octal: "\1", "\12", "\123" */
5514 {
5518 }
5522 /* Special key, e.g.: "\<C-W>" */
5525 {
5528 }
5529 /* FALLTHROUGH */
5533 }
5534 }
5535 else
5538 }
5543 }
5545 /*
5546 * Allocate a variable for a 'str''ing' constant.
5547 * Return OK or FAIL.
5548 */
5549 static int
5554 {
5559 /*
5560 * Find the end of the string, skipping ''.
5561 */
5563 {
5565 {
5570 }
5571 }
5574 {
5577 }
5579 /* If only parsing return after setting "*arg" */
5581 {
5584 }
5586 /*
5587 * Copy the string into allocated memory, handling '' to ' reduction.
5588 */
5596 {
5598 {
5602 }
5604 }
5609 }
5611 /*
5612 * Allocate a variable for a List and fill it from "*arg".
5613 * Return OK or FAIL.
5614 */
5615 static int
5620 {
5622 typval_T tv;
5626 {
5630 }
5634 {
5638 {
5641 {
5645 }
5646 else
5648 }
5653 {
5656 }
5658 }
5661 {
5663 failret:
5667 }
5671 {
5675 }
5678 }
5680 /*
5681 * Allocate an empty header for a list.
5682 * Caller should take care of the reference count.
5683 */
5684 list_T *
5686 {
5691 {
5692 /* Prepend the list to the list of lists for garbage collection. */
5698 }
5700 }
5702 /*
5703 * Allocate an empty list for a return value.
5704 * Returns OK or FAIL.
5705 */
5706 static int
5709 {
5719 }
5721 /*
5722 * Unreference a list: decrement the reference count and free it when it
5723 * becomes zero.
5724 */
5725 void
5728 {
5731 }
5733 /*
5734 * Free a list, including all items it points to.
5735 * Ignores the reference count.
5736 */
5737 void
5741 {
5744 /* Remove the list from the list of lists for garbage collection. */
5747 else
5753 {
5754 /* Remove the item before deleting it. */
5760 }
5762 }
5764 /*
5765 * Allocate a list item.
5766 */
5769 {
5771 }
5773 /*
5774 * Free a list item. Also clears the value. Does not notify watchers.
5775 */
5776 static void
5779 {
5782 }
5784 /*
5785 * Remove a list item from a List and free it. Also clears the value.
5786 */
5787 static void
5791 {
5794 }
5796 /*
5797 * Get the number of items in a list.
5798 */
5799 static long
5802 {
5806 }
5808 /*
5809 * Return TRUE when two lists have exactly the same values.
5810 */
5811 static int
5816 {
5830 }
5832 #if defined(FEAT_PYTHON) || defined(PROTO)
5833 /*
5834 * Return the dictitem that an entry in a hashtable points to.
5835 */
5836 dictitem_T *
5839 {
5841 }
5842 #endif
5844 /*
5845 * Return TRUE when two dictionaries have exactly the same key/values.
5846 */
5847 static int
5852 {
5864 {
5866 {
5873 }
5874 }
5876 }
5878 /*
5879 * Return TRUE if "tv1" and "tv2" have the same value.
5880 * Compares the items just like "==" would compare them, but strings and
5881 * numbers are different. Floats and numbers are also different.
5882 */
5883 static int
5888 {
5896 /* Catch lists and dicts that have an endless loop by limiting
5897 * recursiveness to 1000. We guess they are equal then. */
5902 {
5923 #ifdef FEAT_FLOAT
5926 #endif
5932 }
5936 }
5938 /*
5939 * Locate item with index "n" in list "l" and return it.
5940 * A negative index is counted from the end; -1 is the last item.
5941 * Returns NULL when "n" is out of range.
5942 */
5947 {
5954 /* Negative index is relative to the end. */
5958 /* Check for index out of range. */
5962 /* When there is a cached index may start search from there. */
5964 {
5966 {
5967 /* closest to the start of the list */
5970 }
5972 {
5973 /* closest to the end of the list */
5976 }
5977 else
5978 {
5979 /* closest to the cached index */
5982 }
5983 }
5984 else
5985 {
5987 {
5988 /* closest to the start of the list */
5991 }
5992 else
5993 {
5994 /* closest to the end of the list */
5997 }
5998 }
6001 {
6002 /* search forward */
6005 }
6007 {
6008 /* search backward */
6011 }
6013 /* cache the used index */
6018 }
6020 /*
6021 * Get list item "l[idx]" as a number.
6022 */
6023 static long
6028 {
6033 {
6037 }
6039 }
6041 /*
6042 * Locate "item" list "l" and return its index.
6043 * Returns -1 when "item" is not in the list.
6044 */
6045 static long
6049 {
6061 }
6063 /*
6064 * Append item "item" to the end of list "l".
6065 */
6066 static void
6070 {
6072 {
6073 /* empty list */
6077 }
6078 else
6079 {
6083 }
6086 }
6088 /*
6089 * Append typval_T "tv" to the end of list "l".
6090 * Return FAIL when out of memory.
6091 */
6092 static int
6096 {
6104 }
6106 /*
6107 * Add a dictionary to a list. Used by getqflist().
6108 * Return FAIL when out of memory.
6109 */
6110 int
6114 {
6125 }
6127 /*
6128 * Make a copy of "str" and append it as an item to list "l".
6129 * When "len" >= 0 use "str[len]".
6130 * Returns FAIL when out of memory.
6131 */
6132 static int
6137 {
6151 }
6153 /*
6154 * Append "n" to list "l".
6155 * Returns FAIL when out of memory.
6156 */
6157 static int
6160 varnumber_T n;
6161 {
6172 }
6174 /*
6175 * Insert typval_T "tv" in list "l" before "item".
6176 * If "item" is NULL append at the end.
6177 * Return FAIL when out of memory.
6178 */
6179 static int
6184 {
6191 /* Append new item at end of list. */
6193 else
6194 {
6195 /* Insert new item before existing item. */
6199 {
6202 }
6203 else
6204 {
6207 }
6210 }
6212 }
6214 /*
6215 * Extend "l1" with "l2".
6216 * If "bef" is NULL append at the end, otherwise insert before this item.
6217 * Returns FAIL when out of memory.
6218 */
6219 static int
6224 {
6231 }
6233 /*
6234 * Concatenate lists "l1" and "l2" into a new list, stored in "tv".
6235 * Return FAIL when out of memory.
6236 */
6237 static int
6242 {
6245 /* make a copy of the first list. */
6252 /* append all items from the second list */
6254 }
6256 /*
6257 * Make a copy of list "orig". Shallow if "deep" is FALSE.
6258 * The refcount of the new list is set to 1.
6259 * See item_copy() for "copyID".
6260 * Returns NULL when out of memory.
6261 */
6267 {
6277 {
6279 {
6280 /* Do this before adding the items, because one of the items may
6281 * refer back to this list. */
6284 }
6287 {
6292 {
6294 {
6297 }
6298 }
6299 else
6302 }
6305 {
6308 }
6309 }
6312 }
6314 /*
6315 * Remove items "item" to "item2" from list "l".
6316 * Does not free the listitem or the value!
6317 */
6318 static void
6323 {
6326 /* notify watchers */
6328 {
6333 }
6337 else
6341 else
6344 }
6346 /*
6347 * Return an allocated string with the string representation of a list.
6348 * May return NULL.
6349 */
6354 {
6355 garray_T ga;
6362 {
6365 }
6369 }
6371 /*
6372 * Join list "l" into a string in "*gap", using separator "sep".
6373 * When "echo" is TRUE use String as echoed, otherwise as inside a List.
6374 * Return FAIL or OK.
6375 */
6376 static int
6383 {
6391 {
6394 else
6399 else
6406 }
6408 }
6410 /*
6411 * Garbage collection for lists and dictionaries.
6412 *
6413 * We use reference counts to be able to free most items right away when they
6414 * are no longer used. But for composite items it's possible that it becomes
6415 * unused while the reference count is > 0: When there is a recursive
6416 * reference. Example:
6417 * :let l = [1, 2, 3]
6418 * :let d = {9: l}
6419 * :let l[1] = d
6420 *
6421 * Since this is quite unusual we handle this with garbage collection: every
6422 * once in a while find out which lists and dicts are not referenced from any
6423 * variable.
6424 *
6425 * Here is a good reference text about garbage collection (refers to Python
6426 * but it applies to all reference-counting mechanisms):
6427 * http://python.ca/nas/python/gc/
6428 */
6430 /*
6431 * Do garbage collection for lists and dicts.
6432 * Return TRUE if some memory was freed.
6433 */
6434 int
6436 {
6445 #ifdef FEAT_WINDOWS
6447 #endif
6449 /* Only do this once. */
6454 /*
6455 * 1. Go through all accessible variables and mark all lists and dicts
6456 * with copyID.
6457 */
6458 /* script-local variables */
6462 /* buffer-local variables */
6466 /* window-local variables */
6470 #ifdef FEAT_WINDOWS
6471 /* tabpage-local variables */
6474 #endif
6476 /* global variables */
6479 /* function-local variables */
6481 {
6484 }
6486 /*
6487 * 2. Go through the list of dicts and free items without the copyID.
6488 */
6491 {
6492 /* Free the Dictionary and ordinary items it contains, but don't
6493 * recurse into Lists and Dictionaries, they will be in the list
6494 * of dicts or list of lists. */
6498 /* restart, next dict may also have been freed */
6500 }
6501 else
6504 /*
6505 * 3. Go through the list of lists and free items without the copyID.
6506 * But don't free a list that has a watcher (used in a for loop), these
6507 * are not referenced anywhere.
6508 */
6511 {
6512 /* Free the List and ordinary items it contains, but don't recurse
6513 * into Lists and Dictionaries, they will be in the list of dicts
6514 * or list of lists. */
6518 /* restart, next list may also have been freed */
6520 }
6521 else
6525 }
6527 /*
6528 * Mark all lists and dicts referenced through hashtab "ht" with "copyID".
6529 */
6530 static void
6534 {
6541 {
6544 }
6545 }
6547 /*
6548 * Mark all lists and dicts referenced through list "l" with "copyID".
6549 */
6550 static void
6554 {
6559 }
6561 /*
6562 * Mark all lists and dicts referenced through typval "tv" with "copyID".
6563 */
6564 static void
6568 {
6573 {
6577 {
6578 /* Didn't see this dict yet. */
6581 }
6587 {
6588 /* Didn't see this list yet. */
6591 }
6593 }
6595 }
6597 /*
6598 * Allocate an empty header for a dictionary.
6599 */
6600 dict_T *
6602 {
6607 {
6608 /* Add the list to the list of dicts for garbage collection. */
6619 }
6621 }
6623 /*
6624 * Unreference a Dictionary: decrement the reference count and free it when it
6625 * becomes zero.
6626 */
6627 static void
6630 {
6633 }
6635 /*
6636 * Free a Dictionary, including all items it contains.
6637 * Ignores the reference count.
6638 */
6639 static void
6643 {
6648 /* Remove the dict from the list of dicts for garbage collection. */
6651 else
6656 /* Lock the hashtab, we don't want it to resize while freeing items. */
6660 {
6662 {
6663 /* Remove the item before deleting it, just in case there is
6664 * something recursive causing trouble. */
6672 }
6673 }
6676 }
6678 /*
6679 * Allocate a Dictionary item.
6680 * The "key" is copied to the new item.
6681 * Note that the value of the item "di_tv" still needs to be initialized!
6682 * Returns NULL when out of memory.
6683 */
6687 {
6692 {
6695 }
6697 }
6699 /*
6700 * Make a copy of a Dictionary item.
6701 */
6705 {
6711 {
6715 }
6717 }
6719 /*
6720 * Remove item "item" from Dictionary "dict" and free it.
6721 */
6722 static void
6726 {
6732 else
6735 }
6737 /*
6738 * Free a dict item. Also clears the value.
6739 */
6740 static void
6743 {
6746 }
6748 /*
6749 * Make a copy of dict "d". Shallow if "deep" is FALSE.
6750 * The refcount of the new dict is set to 1.
6751 * See item_copy() for "copyID".
6752 * Returns NULL when out of memory.
6753 */
6759 {
6770 {
6772 {
6775 }
6778 {
6780 {
6787 {
6790 {
6793 }
6794 }
6795 else
6798 {
6801 }
6802 }
6803 }
6807 {
6810 }
6811 }
6814 }
6816 /*
6817 * Add item "item" to Dictionary "d".
6818 * Returns FAIL when out of memory and when key already existed.
6819 */
6820 static int
6824 {
6826 }
6828 /*
6829 * Add a number or string entry to dictionary "d".
6830 * When "str" is NULL use number "nr", otherwise use "str".
6831 * Returns FAIL when out of memory and when key already exists.
6832 */
6833 int
6839 {
6847 {
6850 }
6851 else
6852 {
6855 }
6857 {
6860 }
6862 }
6864 /*
6865 * Get the number of items in a Dictionary.
6866 */
6867 static long
6870 {
6874 }
6876 /*
6877 * Find item "key[len]" in Dictionary "d".
6878 * If "len" is negative use strlen(key).
6879 * Returns NULL when not found.
6880 */
6886 {
6887 #define AKEYLEN 200
6896 {
6900 }
6901 else
6902 {
6903 /* Avoid a malloc/free by using buf[]. */
6906 }
6913 }
6915 /*
6916 * Get a string item from a dictionary.
6917 * When "save" is TRUE allocate memory for it.
6918 * Returns NULL if the entry doesn't exist or out of memory.
6919 */
6920 char_u *
6925 {
6936 }
6938 /*
6939 * Get a number item from a dictionary.
6940 * Returns 0 if the entry doesn't exist or out of memory.
6941 */
6942 long
6946 {
6953 }
6955 /*
6956 * Return an allocated string with the string representation of a Dictionary.
6957 * May return NULL.
6958 */
6963 {
6964 garray_T ga;
6980 {
6982 {
6987 else
6992 {
6995 }
7003 }
7004 }
7006 {
7009 }
7014 }
7016 /*
7017 * Allocate a variable for a Dictionary and fill it from "*arg".
7018 * Return OK or FAIL. Returns NOTDONE for {expr}.
7019 */
7020 static int
7025 {
7027 typval_T tvkey;
7028 typval_T tv;
7034 /*
7035 * First check if it's not a curly-braces thing: {expr}.
7036 * Must do this without evaluating, otherwise a function may be called
7037 * twice. Unfortunately this means we need to call eval1() twice for the
7038 * first item.
7039 * But {} is an empty Dictionary.
7040 */
7042 {
7047 }
7050 {
7054 }
7060 {
7064 {
7068 }
7070 {
7073 {
7074 /* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
7079 }
7080 }
7084 {
7088 }
7090 {
7093 {
7098 }
7102 {
7107 }
7108 }
7113 {
7116 }
7118 }
7121 {
7123 failret:
7127 }
7131 {
7135 }
7138 }
7140 /*
7141 * Return a string with the string representation of a variable.
7142 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7143 * "numbuf" is used for a number.
7144 * Does not put quotes around strings, as ":echo" displays values.
7145 * When "copyID" is not NULL replace recursive lists and dicts with "...".
7146 * May return NULL.
7147 */
7154 {
7159 {
7163 }
7167 {
7175 {
7178 }
7180 {
7183 }
7184 else
7185 {
7189 }
7194 {
7197 }
7199 {
7202 }
7203 else
7204 {
7208 }
7217 #ifdef FEAT_FLOAT
7223 #endif
7228 }
7232 }
7234 /*
7235 * Return a string with the string representation of a variable.
7236 * If the memory is allocated "tofree" is set to it, otherwise NULL.
7237 * "numbuf" is used for a number.
7238 * Puts quotes around strings, so that they can be parsed back by eval().
7239 * May return NULL.
7240 */
7247 {
7249 {
7256 #ifdef FEAT_FLOAT
7261 #endif
7268 }
7270 }
7272 /*
7273 * Return string "str" in ' quotes, doubling ' characters.
7274 * If "str" is NULL an empty string is assumed.
7275 * If "function" is TRUE make it function('string').
7276 */
7281 {
7287 {
7292 }
7295 {
7297 {
7300 }
7301 else
7305 {
7309 }
7314 }
7316 }
7318 #ifdef FEAT_FLOAT
7319 /*
7320 * Convert the string "text" to a floating point number.
7321 * This uses strtod(). setlocale(LC_NUMERIC, "C") has been used to make sure
7322 * this always uses a decimal point.
7323 * Returns the length of the text that was consumed.
7324 */
7325 static int
7329 {
7331 float_T f;
7336 }
7337 #endif
7339 /*
7340 * Get the value of an environment variable.
7341 * "arg" is pointing to the '$'. It is advanced to after the name.
7342 * If the environment variable was not set, silently assume it is empty.
7343 * Always return OK.
7344 */
7345 static int
7350 {
7361 {
7363 {
7366 /* first try vim_getenv(), fast for normal environment vars */
7369 {
7372 }
7373 else
7374 {
7378 /* next try expanding things like $VIM and ${HOME} */
7381 {
7384 }
7385 }
7387 }
7390 }
7393 }
7395 /*
7396 * Array with names and number of arguments of all internal functions
7397 * MUST BE KEPT SORTED IN strcmp() ORDER FOR BINARY SEARCH!
7398 */
7399 static struct fst
7400 {
7405 /* implementation of function */
7407 {
7408 #ifdef FEAT_FLOAT
7410 #endif
7416 #ifdef FEAT_FLOAT
7418 #endif
7433 #ifdef FEAT_FLOAT
7435 #endif
7441 #if defined(FEAT_INS_EXPAND)
7445 #endif
7448 #ifdef FEAT_FLOAT
7450 #endif
7474 #ifdef FEAT_FLOAT
7477 #endif
7552 #ifdef FEAT_FLOAT
7554 #endif
7567 #ifdef vim_mkdir
7569 #endif
7574 #ifdef FEAT_FLOAT
7576 #endif
7594 #ifdef FEAT_FLOAT
7596 #endif
7616 #ifdef FEAT_FLOAT
7618 #endif
7624 #ifdef FEAT_FLOAT
7627 #endif
7629 #ifdef HAVE_STRFTIME
7631 #endif
7655 #ifdef FEAT_FLOAT
7657 #endif
7672 };
7674 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
7676 /*
7677 * Function given to ExpandGeneric() to obtain the list of internal
7678 * or user defined function names.
7679 */
7680 char_u *
7684 {
7691 {
7695 }
7697 {
7703 }
7706 }
7708 /*
7709 * Function given to ExpandGeneric() to obtain the list of internal or
7710 * user defined variable or function names.
7711 */
7712 /*ARGSUSED*/
7713 char_u *
7717 {
7724 {
7728 }
7730 }
7734 /*
7735 * Find internal function in table above.
7736 * Return index, or -1 if not found
7737 */
7738 static int
7741 {
7747 /*
7748 * Find the function name in the table. Binary search.
7749 */
7751 {
7758 else
7760 }
7762 }
7764 /*
7765 * Check if "name" is a variable of type VAR_FUNC. If so, return the function
7766 * name it contains, otherwise return "name".
7767 */
7772 {
7781 {
7783 {
7786 }
7789 }
7792 }
7794 /*
7795 * Allocate a variable for the result of a function.
7796 * Return OK or FAIL.
7797 */
7798 static int
7810 {
7816 /*
7817 * Get the arguments.
7818 */
7821 {
7826 {
7829 }
7833 }
7836 else
7843 {
7846 else
7848 }
7855 }
7858 /*
7859 * Call a function with its resolved parameters
7860 * Return OK when the function can't be called, FAIL otherwise.
7861 * Also returns OK when an error was encountered while executing the function.
7862 */
7863 static int
7871 PLUS ONE elements! */
7877 {
7879 #define ERROR_UNKNOWN 0
7880 #define ERROR_TOOMANY 1
7881 #define ERROR_TOOFEW 2
7882 #define ERROR_SCRIPT 3
7883 #define ERROR_DICT 4
7884 #define ERROR_NONE 5
7885 #define ERROR_OTHER 6
7891 #define FLEN_FIXED 40
7895 /*
7896 * In a script change <SID>name() and s:name() to K_SNR 123_name().
7897 * Change <SNR>123_name() to K_SNR 123_name().
7898 * Use fname_buf[] when it fits, otherwise allocate memory (slow).
7899 */
7904 {
7910 {
7913 else
7914 {
7917 }
7918 }
7920 {
7923 }
7924 else
7925 {
7929 else
7930 {
7933 }
7934 }
7935 }
7936 else
7942 /* execute the function if no errors detected and executing */
7944 {
7949 {
7950 /*
7951 * User defined function.
7952 */
7955 #ifdef FEAT_AUTOCMD
7956 /* Trigger FuncUndefined event, may load the function. */
7961 {
7962 /* executed an autocommand, search for the function again */
7964 }
7965 #endif
7966 /* Try loading a package. */
7968 {
7969 /* loaded a package, search for the function again */
7971 }
7974 {
7983 else
7984 {
7985 /*
7986 * Call the user function.
7987 * Save and restore search patterns, script variables and
7988 * redo buffer.
7989 */
7998 /* Function was unreferenced while being used, free it
7999 * now. */
8004 }
8005 }
8006 }
8007 else
8008 {
8009 /*
8010 * Find the function name in the table, call its implementation.
8011 */
8014 {
8019 else
8020 {
8024 }
8025 }
8026 }
8027 /*
8028 * The function call (or "FuncUndefined" autocommand sequence) might
8029 * have been aborted by an error, an interrupt, or an explicitly thrown
8030 * exception that has not been caught so far. This situation can be
8031 * tested for by calling aborting(). For an error in an internal
8032 * function or for the "E132" error in call_user_func(), however, the
8033 * throw point at which the "force_abort" flag (temporarily reset by
8034 * emsg()) is normally updated has not been reached yet. We need to
8035 * update that flag first to make aborting() reliable.
8036 */
8038 }
8042 /*
8043 * Report an error unless the argument evaluation or function call has been
8044 * cancelled due to an aborting error, an interrupt, or an exception.
8045 */
8047 {
8049 {
8058 name);
8062 name);
8066 name);
8068 }
8069 }
8076 }
8078 /*
8079 * Give an error message with a function name. Handle <SNR> things.
8080 */
8081 static void
8085 {
8090 else
8095 }
8097 /*********************************************
8098 * Implementation of the built-in functions
8099 */
8101 #ifdef FEAT_FLOAT
8102 /*
8103 * "abs(expr)" function
8104 */
8105 static void
8109 {
8111 {
8114 }
8115 else
8116 {
8117 varnumber_T n;
8125 else
8127 }
8128 }
8129 #endif
8131 /*
8132 * "add(list, item)" function
8133 */
8134 static void
8138 {
8143 {
8148 }
8149 else
8151 }
8153 /*
8154 * "append(lnum, string/list)" function
8155 */
8156 static void
8160 {
8172 {
8174 {
8179 }
8182 {
8187 else
8191 {
8194 }
8200 }
8205 }
8206 else
8208 }
8210 /*
8211 * "argc()" function
8212 */
8213 /* ARGSUSED */
8214 static void
8218 {
8220 }
8222 /*
8223 * "argidx()" function
8224 */
8225 /* ARGSUSED */
8226 static void
8230 {
8232 }
8234 /*
8235 * "argv(nr)" function
8236 */
8237 static void
8241 {
8245 {
8249 else
8252 }
8257 }
8259 #ifdef FEAT_FLOAT
8262 /*
8263 * Get the float value of "argvars[0]" into "f".
8264 * Returns FAIL when the argument is not a Number or Float.
8265 */
8266 static int
8270 {
8272 {
8275 }
8277 {
8280 }
8283 }
8285 /*
8286 * "atan()" function
8287 */
8288 static void
8292 {
8293 float_T f;
8298 else
8300 }
8301 #endif
8303 /*
8304 * "browse(save, title, initdir, default)" function
8305 */
8306 /* ARGSUSED */
8307 static void
8311 {
8312 #ifdef FEAT_BROWSE
8328 else
8332 #else
8334 #endif
8336 }
8338 /*
8339 * "browsedir(title, initdir)" function
8340 */
8341 /* ARGSUSED */
8342 static void
8346 {
8347 #ifdef FEAT_BROWSE
8357 else
8360 #else
8362 #endif
8364 }
8368 /*
8369 * Find a buffer by number or exact name.
8370 */
8374 {
8380 {
8383 {
8384 /* No full path name match, try a match with a URL or a "nofile"
8385 * buffer, these don't use the full path. */
8389 #ifdef FEAT_QUICKFIX
8391 #endif
8392 )
8395 }
8396 }
8398 }
8400 /*
8401 * "bufexists(expr)" function
8402 */
8403 static void
8407 {
8409 }
8411 /*
8412 * "buflisted(expr)" function
8413 */
8414 static void
8418 {
8423 }
8425 /*
8426 * "bufloaded(expr)" function
8427 */
8428 static void
8432 {
8437 }
8441 /*
8442 * Get buffer by number or pattern.
8443 */
8447 {
8462 /* Ignore 'magic' and 'cpoptions' here to make scripts portable */
8474 /* If not found, try expanding the name, like done for bufexists(). */
8479 }
8481 /*
8482 * "bufname(expr)" function
8483 */
8484 static void
8488 {
8497 else
8500 }
8502 /*
8503 * "bufnr(expr)" function
8504 */
8505 static void
8509 {
8519 /* If the buffer isn't found and the second argument is not zero create a
8520 * new buffer. */
8524 && !error
8531 else
8533 }
8535 /*
8536 * "bufwinnr(nr)" function
8537 */
8538 static void
8542 {
8543 #ifdef FEAT_WINDOWS
8546 #endif
8552 #ifdef FEAT_WINDOWS
8554 {
8558 }
8560 #else
8562 #endif
8564 }
8566 /*
8567 * "byte2line(byte)" function
8568 */
8569 /*ARGSUSED*/
8570 static void
8574 {
8575 #ifndef FEAT_BYTEOFF
8577 #else
8583 else
8586 #endif
8587 }
8589 /*
8590 * "byteidx()" function
8591 */
8592 /*ARGSUSED*/
8593 static void
8597 {
8598 #ifdef FEAT_MBYTE
8600 #endif
8610 #ifdef FEAT_MBYTE
8613 {
8617 }
8619 #else
8622 #endif
8623 }
8625 /*
8626 * "call(func, arglist)" function
8627 */
8628 static void
8632 {
8642 {
8645 }
8651 else
8657 {
8659 {
8662 }
8664 }
8668 {
8670 {
8673 }
8674 /* Make a copy of each argument. This is needed to be able to set
8675 * v_lock to VAR_FIXED in the copy without changing the original list.
8676 */
8678 }
8685 /* Free the arguments. */
8688 }
8690 #ifdef FEAT_FLOAT
8691 /*
8692 * "ceil({float})" function
8693 */
8694 static void
8698 {
8699 float_T f;
8704 else
8706 }
8707 #endif
8709 /*
8710 * "changenr()" function
8711 */
8712 /*ARGSUSED*/
8713 static void
8717 {
8719 }
8721 /*
8722 * "char2nr(string)" function
8723 */
8724 static void
8728 {
8729 #ifdef FEAT_MBYTE
8732 else
8733 #endif
8735 }
8737 /*
8738 * "cindent(lnum)" function
8739 */
8740 static void
8744 {
8745 #ifdef FEAT_CINDENT
8746 pos_T pos;
8747 linenr_T lnum;
8752 {
8756 }
8757 else
8758 #endif
8760 }
8762 /*
8763 * "clearmatches()" function
8764 */
8765 /*ARGSUSED*/
8766 static void
8770 {
8771 #ifdef FEAT_SEARCH_EXTRA
8773 #endif
8774 }
8776 /*
8777 * "col(string)" function
8778 */
8779 static void
8783 {
8790 {
8792 {
8793 /* '> can be MAXCOL, get the length of the line then */
8796 else
8798 }
8799 else
8800 {
8802 #ifdef FEAT_VIRTUALEDIT
8803 /* col(".") when the cursor is on the NUL at the end of the line
8804 * because of "coladd" can be seen as an extra column. */
8806 {
8811 {
8812 # ifdef FEAT_MBYTE
8817 # else
8820 # endif
8821 }
8822 }
8823 #endif
8824 }
8825 }
8827 }
8829 #if defined(FEAT_INS_EXPAND)
8830 /*
8831 * "complete()" function
8832 */
8833 /*ARGSUSED*/
8834 static void
8838 {
8842 {
8845 }
8847 /* Check for undo allowed here, because if something was already inserted
8848 * the line was already saved for undo and this check isn't done. */
8853 {
8856 }
8863 }
8865 /*
8866 * "complete_add()" function
8867 */
8868 /*ARGSUSED*/
8869 static void
8873 {
8875 }
8877 /*
8878 * "complete_check()" function
8879 */
8880 /*ARGSUSED*/
8881 static void
8885 {
8892 }
8893 #endif
8895 /*
8896 * "confirm(message, buttons[, default [, type]])" function
8897 */
8898 /*ARGSUSED*/
8899 static void
8903 {
8904 #if defined(FEAT_GUI_DIALOG) || defined(FEAT_CON_DIALOG)
8918 {
8923 {
8926 {
8930 else
8931 {
8933 {
8939 }
8940 }
8941 }
8942 }
8943 }
8950 else
8953 #else
8955 #endif
8956 }
8958 /*
8959 * "copy()" function
8960 */
8961 static void
8965 {
8967 }
8969 #ifdef FEAT_FLOAT
8970 /*
8971 * "cos()" function
8972 */
8973 static void
8977 {
8978 float_T f;
8983 else
8985 }
8986 #endif
8988 /*
8989 * "count()" function
8990 */
8991 static void
8995 {
9000 {
9006 {
9009 {
9014 {
9017 {
9021 }
9022 }
9025 }
9030 }
9031 }
9033 {
9039 {
9043 {
9047 }
9051 {
9053 {
9057 }
9058 }
9059 }
9060 }
9061 else
9064 }
9066 /*
9067 * "cscope_connection([{num} , {dbpath} [, {prepend}]])" function
9068 *
9069 * Checks the existence of a cscope connection.
9070 */
9071 /*ARGSUSED*/
9072 static void
9076 {
9077 #ifdef FEAT_CSCOPE
9085 {
9090 }
9093 #else
9095 #endif
9096 }
9098 /*
9099 * "cursor(lnum, col)" function
9100 *
9101 * Moves the cursor to the specified line and column
9102 */
9103 /*ARGSUSED*/
9104 static void
9108 {
9110 #ifdef FEAT_VIRTUALEDIT
9112 #endif
9115 {
9116 pos_T pos;
9122 #ifdef FEAT_VIRTUALEDIT
9124 #endif
9125 }
9126 else
9127 {
9130 #ifdef FEAT_VIRTUALEDIT
9133 #endif
9134 }
9136 #ifdef FEAT_VIRTUALEDIT
9138 #endif
9139 )
9145 #ifdef FEAT_VIRTUALEDIT
9147 #endif
9149 /* Make sure the cursor is in a valid position. */
9151 #ifdef FEAT_MBYTE
9152 /* Correct cursor for multi-byte character. */
9155 #endif
9158 }
9160 /*
9161 * "deepcopy()" function
9162 */
9163 static void
9167 {
9174 else
9176 }
9178 /*
9179 * "delete()" function
9180 */
9181 static void
9185 {
9188 else
9190 }
9192 /*
9193 * "did_filetype()" function
9194 */
9195 /*ARGSUSED*/
9196 static void
9200 {
9201 #ifdef FEAT_AUTOCMD
9203 #else
9205 #endif
9206 }
9208 /*
9209 * "diff_filler()" function
9210 */
9211 /*ARGSUSED*/
9212 static void
9216 {
9217 #ifdef FEAT_DIFF
9219 #endif
9220 }
9222 /*
9223 * "diff_hlID()" function
9224 */
9225 /*ARGSUSED*/
9226 static void
9230 {
9231 #ifdef FEAT_DIFF
9247 {
9248 /* New line, buffer, change: need to get the values. */
9251 {
9253 {
9258 else
9260 }
9261 else
9263 }
9264 else
9269 }
9272 {
9276 else
9278 }
9280 #endif
9281 }
9283 /*
9284 * "empty({expr})" function
9285 */
9286 static void
9290 {
9294 {
9303 #ifdef FEAT_FLOAT
9307 #endif
9319 }
9322 }
9324 /*
9325 * "escape({string}, {chars})" function
9326 */
9327 static void
9331 {
9337 }
9339 /*
9340 * "eval()" function
9341 */
9342 /*ARGSUSED*/
9343 static void
9347 {
9355 {
9358 }
9361 }
9363 /*
9364 * "eventhandler()" function
9365 */
9366 /*ARGSUSED*/
9367 static void
9371 {
9373 }
9375 /*
9376 * "executable()" function
9377 */
9378 static void
9382 {
9384 }
9386 /*
9387 * "exists()" function
9388 */
9389 static void
9393 {
9401 {
9402 /* first try "normal" environment variables (fast) */
9405 else
9406 {
9407 /* try expanding things like $VIM and ${HOME} */
9412 }
9413 }
9415 {
9419 }
9421 {
9423 }
9425 {
9427 }
9429 {
9430 #ifdef FEAT_AUTOCMD
9433 else
9435 #endif
9436 }
9438 {
9440 typval_T tv;
9442 /* get_name_len() takes care of expanding curly braces */
9446 {
9451 {
9452 /* handle d.key, l[idx], f(expr) */
9456 }
9457 }
9462 }
9465 }
9467 /*
9468 * "expand()" function
9469 */
9470 static void
9474 {
9479 expand_T xpc;
9485 {
9489 }
9490 else
9491 {
9492 /* When the optional second argument is non-zero, don't remove matches
9493 * for 'suffixes' and 'wildignore' */
9498 {
9502 }
9503 else
9505 }
9506 }
9508 /*
9509 * "extend(list, list [, idx])" function
9510 * "extend(dict, dict [, action])" function
9511 */
9512 static void
9516 {
9519 {
9529 {
9531 {
9538 else
9539 {
9542 {
9545 }
9546 }
9547 }
9548 else
9553 }
9554 }
9556 {
9568 {
9569 /* Check the third argument. */
9571 {
9581 {
9584 }
9585 }
9586 else
9589 /* Go over all entries in the second dict and add them to the
9590 * first dict. */
9593 {
9595 {
9599 {
9603 }
9605 {
9608 }
9610 {
9613 }
9614 }
9615 }
9618 }
9619 }
9620 else
9622 }
9624 /*
9625 * "feedkeys()" function
9626 */
9627 /*ARGSUSED*/
9628 static void
9632 {
9639 /* This is not allowed in the sandbox. If the commands would still be
9640 * executed in the sandbox it would be OK, but it probably happens later,
9641 * when "sandbox" is no longer set. */
9648 {
9650 {
9653 {
9655 {
9659 }
9660 }
9661 }
9663 /* Need to escape K_SPECIAL and CSI before putting the string in the
9664 * typeahead buffer. */
9667 {
9673 }
9674 }
9675 }
9677 /*
9678 * "filereadable()" function
9679 */
9680 static void
9684 {
9691 {
9694 }
9695 else
9699 }
9701 /*
9702 * Return 0 for not writable, 1 for writable file, 2 for a dir which we have
9703 * rights to write into.
9704 */
9705 static void
9709 {
9711 }
9715 static void
9720 {
9721 #ifdef FEAT_SEARCHPATH
9730 #endif
9735 #ifdef FEAT_SEARCHPATH
9739 {
9743 else
9744 {
9750 }
9751 }
9757 {
9758 do
9759 {
9765 find_what,
9767 find_what == FINDFILE_DIR
9775 }
9779 #endif
9780 }
9785 /*
9786 * Implementation of map() and filter().
9787 */
9788 static void
9793 {
9802 typval_T save_val;
9803 typval_T save_key;
9811 {
9815 }
9817 {
9821 }
9822 else
9823 {
9826 }
9829 /* On type errors, the preceding call has already displayed an error
9830 * message. Avoid a misleading error message for an empty string that
9831 * was not passed as argument. */
9833 {
9837 /* We reset "did_emsg" to be able to detect whether an error
9838 * occurred during evaluation of the expression. */
9843 {
9851 {
9853 {
9865 }
9866 }
9870 }
9871 else
9872 {
9874 {
9883 }
9884 }
9889 }
9892 }
9894 static int
9900 {
9901 typval_T rettv;
9910 {
9913 }
9915 {
9916 /* map(): replace the list item value */
9920 }
9921 else
9922 {
9925 /* filter(): when expr is zero remove the item */
9928 /* On type error, nothing has been removed; return FAIL to stop the
9929 * loop. The error message was given by get_tv_number_chk(). */
9932 }
9934 theend:
9937 }
9939 /*
9940 * "filter()" function
9941 */
9942 static void
9946 {
9948 }
9950 /*
9951 * "finddir({fname}[, {path}[, {count}]])" function
9952 */
9953 static void
9957 {
9959 }
9961 /*
9962 * "findfile({fname}[, {path}[, {count}]])" function
9963 */
9964 static void
9968 {
9970 }
9972 #ifdef FEAT_FLOAT
9973 /*
9974 * "float2nr({float})" function
9975 */
9976 static void
9980 {
9981 float_T f;
9984 {
9989 else
9991 }
9992 else
9994 }
9996 /*
9997 * "floor({float})" function
9998 */
9999 static void
10003 {
10004 float_T f;
10009 else
10011 }
10012 #endif
10014 /*
10015 * "fnameescape({string})" function
10016 */
10017 static void
10021 {
10025 }
10027 /*
10028 * "fnamemodify({fname}, {mods})" function
10029 */
10030 static void
10034 {
10046 else
10047 {
10050 }
10055 else
10058 }
10062 /*
10063 * "foldclosed()" function
10064 */
10065 static void
10070 {
10071 #ifdef FEAT_FOLDING
10072 linenr_T lnum;
10077 {
10079 {
10082 else
10085 }
10086 }
10087 #endif
10089 }
10091 /*
10092 * "foldclosed()" function
10093 */
10094 static void
10098 {
10100 }
10102 /*
10103 * "foldclosedend()" function
10104 */
10105 static void
10109 {
10111 }
10113 /*
10114 * "foldlevel()" function
10115 */
10116 static void
10120 {
10121 #ifdef FEAT_FOLDING
10122 linenr_T lnum;
10127 else
10128 #endif
10130 }
10132 /*
10133 * "foldtext()" function
10134 */
10135 /*ARGSUSED*/
10136 static void
10140 {
10141 #ifdef FEAT_FOLDING
10142 linenr_T lnum;
10147 #endif
10151 #ifdef FEAT_FOLDING
10156 {
10157 /* Find first non-empty line in the fold. */
10160 {
10164 }
10166 /* Find interesting text in this line. */
10168 /* skip C comment-start */
10170 {
10174 {
10178 }
10179 }
10186 {
10192 /* remove 'foldmarker' and 'commentstring' */
10195 }
10196 }
10197 #endif
10198 }
10200 /*
10201 * "foldtextresult(lnum)" function
10202 */
10203 /*ARGSUSED*/
10204 static void
10208 {
10209 #ifdef FEAT_FOLDING
10210 linenr_T lnum;
10213 foldinfo_T foldinfo;
10215 #endif
10219 #ifdef FEAT_FOLDING
10221 /* treat illegal types and illegal string values for {lnum} the same */
10226 {
10232 }
10233 #endif
10234 }
10236 /*
10237 * "foreground()" function
10238 */
10239 /*ARGSUSED*/
10240 static void
10244 {
10246 #ifdef FEAT_GUI
10249 #else
10250 # ifdef WIN32
10252 # endif
10253 #endif
10254 }
10256 /*
10257 * "function()" function
10258 */
10259 /*ARGSUSED*/
10260 static void
10264 {
10273 else
10274 {
10277 }
10278 }
10280 /*
10281 * "garbagecollect()" function
10282 */
10283 /*ARGSUSED*/
10284 static void
10288 {
10289 /* This is postponed until we are back at the toplevel, because we may be
10290 * using Lists and Dicts internally. E.g.: ":echo [garbagecollect()]". */
10295 }
10297 /*
10298 * "get()" function
10299 */
10300 static void
10304 {
10312 {
10314 {
10320 }
10321 }
10323 {
10325 {
10329 }
10330 }
10331 else
10335 {
10338 else
10340 }
10341 else
10343 }
10345 static void get_buffer_lines __ARGS((buf_T *buf, linenr_T start, linenr_T end, int retlist, typval_T *rettv));
10347 /*
10348 * Get line or list of lines from buffer "buf" into "rettv".
10349 * Return a range (from start to end) of lines in rettv from the specified
10350 * buffer.
10351 * If 'retlist' is TRUE, then the lines are returned as a Vim List.
10352 */
10353 static void
10356 linenr_T start;
10357 linenr_T end;
10360 {
10364 {
10367 }
10368 else
10375 {
10378 else
10383 }
10384 else
10385 {
10397 }
10398 }
10400 /*
10401 * "getbufline()" function
10402 */
10403 static void
10407 {
10408 linenr_T lnum;
10409 linenr_T end;
10420 else
10424 }
10426 /*
10427 * "getbufvar()" function
10428 */
10429 static void
10433 {
10448 {
10449 /* set curbuf to be our buf, temporarily */
10455 else
10456 {
10458 /* let getbufvar({nr}, "") return the "b:" dictionary. The
10459 * scope prefix before the NUL byte is required by
10460 * find_var_in_ht(). */
10462 /* look up the variable */
10466 }
10468 /* restore previous notion of curbuf */
10470 }
10473 }
10475 /*
10476 * "getchar()" function
10477 */
10478 static void
10482 {
10483 varnumber_T n;
10486 /* Position the cursor. Needed after a message that ends in a space. */
10492 {
10494 /* getchar(): blocking wait. */
10497 /* getchar(1): only check if char avail */
10500 /* illegal argument or getchar(0) and no char avail: return zero */
10502 else
10503 /* getchar(0) and char avail: return char */
10508 }
10518 {
10522 /* Turn a special key into three bytes, plus modifier. */
10524 {
10528 }
10530 {
10534 }
10535 #ifdef FEAT_MBYTE
10538 #endif
10539 else
10545 #ifdef FEAT_MOUSE
10565 {
10569 linenr_T lnum;
10570 # ifdef FEAT_WINDOWS
10572 # endif
10576 {
10577 /* Find the window at the mouse coordinates and compute the
10578 * text position. */
10581 # ifdef FEAT_WINDOWS
10584 # endif
10588 }
10589 }
10590 #endif
10591 }
10592 }
10594 /*
10595 * "getcharmod()" function
10596 */
10597 /*ARGSUSED*/
10598 static void
10602 {
10604 }
10606 /*
10607 * "getcmdline()" function
10608 */
10609 /*ARGSUSED*/
10610 static void
10614 {
10617 }
10619 /*
10620 * "getcmdpos()" function
10621 */
10622 /*ARGSUSED*/
10623 static void
10627 {
10629 }
10631 /*
10632 * "getcmdtype()" function
10633 */
10634 /*ARGSUSED*/
10635 static void
10639 {
10643 {
10646 }
10647 }
10649 /*
10650 * "getcwd()" function
10651 */
10652 /*ARGSUSED*/
10653 static void
10657 {
10663 else
10664 {
10666 #ifdef BACKSLASH_IN_FILENAME
10669 #endif
10670 }
10671 }
10673 /*
10674 * "getfontname()" function
10675 */
10676 /*ARGSUSED*/
10677 static void
10681 {
10684 #ifdef FEAT_GUI
10686 {
10687 GuiFont font;
10691 {
10692 /* Get the "Normal" font. Either the name saved by
10693 * hl_set_font_name() or from the font ID. */
10696 }
10697 else
10698 {
10705 }
10709 }
10710 #endif
10711 }
10713 /*
10714 * "getfperm({fname})" function
10715 */
10716 static void
10720 {
10731 {
10734 {
10736 {
10739 }
10740 }
10741 }
10743 }
10745 /*
10746 * "getfsize({fname})" function
10747 */
10748 static void
10752 {
10761 {
10764 else
10765 {
10768 /* non-perfect check for overflow */
10771 }
10772 }
10773 else
10775 }
10777 /*
10778 * "getftime({fname})" function
10779 */
10780 static void
10784 {
10792 else
10794 }
10796 /*
10797 * "getftype({fname})" function
10798 */
10799 static void
10803 {
10813 {
10814 #ifdef S_ISREG
10819 # ifdef S_ISLNK
10822 # endif
10823 # ifdef S_ISBLK
10826 # endif
10827 # ifdef S_ISCHR
10830 # endif
10831 # ifdef S_ISFIFO
10834 # endif
10835 # ifdef S_ISSOCK
10838 # endif
10839 else
10841 #else
10842 # ifdef S_IFMT
10844 {
10847 # ifdef S_IFLNK
10849 # endif
10850 # ifdef S_IFBLK
10852 # endif
10853 # ifdef S_IFCHR
10855 # endif
10856 # ifdef S_IFIFO
10858 # endif
10859 # ifdef S_IFSOCK
10861 # endif
10863 }
10864 # else
10867 else
10869 # endif
10870 #endif
10872 }
10874 }
10876 /*
10877 * "getline(lnum, [end])" function
10878 */
10879 static void
10883 {
10884 linenr_T lnum;
10885 linenr_T end;
10890 {
10893 }
10894 else
10895 {
10898 }
10901 }
10903 /*
10904 * "getmatches()" function
10905 */
10906 /*ARGSUSED*/
10907 static void
10911 {
10912 #ifdef FEAT_SEARCH_EXTRA
10919 {
10921 {
10931 }
10932 }
10933 #endif
10934 }
10936 /*
10937 * "getpid()" function
10938 */
10939 /*ARGSUSED*/
10940 static void
10944 {
10946 }
10948 /*
10949 * "getpos(string)" function
10950 */
10951 static void
10955 {
10961 {
10966 else
10974 #ifdef FEAT_VIRTUALEDIT
10976 #endif
10978 }
10979 else
10981 }
10983 /*
10984 * "getqflist()" and "getloclist()" functions
10985 */
10986 /*ARGSUSED*/
10987 static void
10991 {
10992 #ifdef FEAT_QUICKFIX
10994 #endif
10997 #ifdef FEAT_QUICKFIX
10999 {
11002 {
11006 }
11009 }
11010 #endif
11011 }
11013 /*
11014 * "getreg()" function
11015 */
11016 static void
11020 {
11027 {
11032 }
11033 else
11042 }
11044 /*
11045 * "getregtype()" function
11046 */
11047 static void
11051 {
11058 {
11061 {
11065 }
11066 }
11067 else
11068 /* Default to v:register */
11078 {
11081 #ifdef FEAT_VISUAL
11086 #endif
11087 }
11090 }
11092 /*
11093 * "gettabwinvar()" function
11094 */
11095 static void
11099 {
11101 }
11103 /*
11104 * "getwinposx()" function
11105 */
11106 /*ARGSUSED*/
11107 static void
11111 {
11113 #ifdef FEAT_GUI
11115 {
11120 }
11121 #endif
11122 }
11124 /*
11125 * "getwinposy()" function
11126 */
11127 /*ARGSUSED*/
11128 static void
11132 {
11134 #ifdef FEAT_GUI
11136 {
11141 }
11142 #endif
11143 }
11145 /*
11146 * Find window specified by "vp" in tabpage "tp".
11147 */
11152 {
11153 #ifdef FEAT_WINDOWS
11155 #endif
11160 #ifdef FEAT_WINDOWS
11171 #else
11175 #endif
11176 }
11178 /*
11179 * "getwinvar()" function
11180 */
11181 static void
11185 {
11187 }
11189 /*
11190 * getwinvar() and gettabwinvar()
11191 */
11192 static void
11197 {
11203 #ifdef FEAT_WINDOWS
11206 else
11208 #endif
11217 {
11218 /* Set curwin to be our win, temporarily. Also set curbuf, so
11219 * that we can get buffer-local options. */
11226 else
11227 {
11229 /* let getwinvar({nr}, "") return the "w:" dictionary. The
11230 * scope prefix before the NUL byte is required by
11231 * find_var_in_ht(). */
11233 /* look up the variable */
11237 }
11239 /* restore previous notion of curwin */
11242 }
11245 }
11247 /*
11248 * "glob()" function
11249 */
11250 static void
11254 {
11255 expand_T xpc;
11262 }
11264 /*
11265 * "globpath()" function
11266 */
11267 static void
11271 {
11278 else
11280 }
11282 /*
11283 * "has()" function
11284 */
11285 static void
11289 {
11294 {
11295 #ifdef AMIGA
11297 # ifdef FEAT_ARP
11299 # endif
11300 #endif
11301 #ifdef __BEOS__
11303 #endif
11304 #ifdef MSDOS
11305 # ifdef DJGPP
11307 # else
11309 # endif
11310 #endif
11311 #ifdef MACOS
11313 #endif
11314 #if defined(MACOS_X_UNIX)
11316 #endif
11317 #ifdef OS2
11319 #endif
11320 #ifdef __QNX__
11322 #endif
11323 #ifdef RISCOS
11325 #endif
11326 #ifdef UNIX
11328 #endif
11329 #ifdef VMS
11331 #endif
11332 #ifdef WIN16
11334 #endif
11335 #ifdef WIN32
11337 #endif
11338 #if defined(UNIX) && (defined(__CYGWIN32__) || defined(__CYGWIN__))
11340 #endif
11341 #ifdef WIN64
11343 #endif
11344 #ifdef EBCDIC
11346 #endif
11347 #ifndef CASE_INSENSITIVE_FILENAME
11349 #endif
11350 #ifdef FEAT_ARABIC
11352 #endif
11353 #ifdef FEAT_AUTOCMD
11355 #endif
11356 #ifdef FEAT_BEVAL
11360 # endif
11361 #endif
11362 #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
11364 # ifdef ALL_BUILTIN_TCAPS
11366 # endif
11367 #endif
11368 #ifdef FEAT_BYTEOFF
11370 #endif
11371 #ifdef FEAT_CINDENT
11373 #endif
11374 #ifdef FEAT_CLIENTSERVER
11376 #endif
11377 #ifdef FEAT_CLIPBOARD
11379 #endif
11380 #ifdef FEAT_CMDL_COMPL
11382 #endif
11383 #ifdef FEAT_CMDHIST
11385 #endif
11386 #ifdef FEAT_COMMENTS
11388 #endif
11389 #ifdef FEAT_CRYPT
11391 #endif
11392 #ifdef FEAT_CSCOPE
11394 #endif
11395 #ifdef CURSOR_SHAPE
11397 #endif
11398 #ifdef DEBUG
11400 #endif
11401 #ifdef FEAT_CON_DIALOG
11403 #endif
11404 #ifdef FEAT_GUI_DIALOG
11406 #endif
11407 #ifdef FEAT_DIFF
11409 #endif
11410 #ifdef FEAT_DIGRAPHS
11412 #endif
11413 #ifdef FEAT_DND
11415 #endif
11416 #ifdef FEAT_EMACS_TAGS
11418 #endif
11420 #ifdef FEAT_EX_EXTRA
11422 #endif
11423 #ifdef FEAT_SEARCH_EXTRA
11425 #endif
11426 #ifdef FEAT_FKMAP
11428 #endif
11429 #ifdef FEAT_SEARCHPATH
11431 #endif
11432 #if defined(UNIX) && !defined(USE_SYSTEM)
11434 #endif
11435 #ifdef FEAT_FIND_ID
11437 #endif
11438 #ifdef FEAT_FLOAT
11440 #endif
11441 #ifdef FEAT_FOLDING
11443 #endif
11444 #ifdef FEAT_FOOTER
11446 #endif
11447 #if !defined(USE_SYSTEM) && defined(UNIX)
11449 #endif
11450 #ifdef FEAT_GETTEXT
11452 #endif
11453 #ifdef FEAT_GUI
11455 #endif
11456 #ifdef FEAT_GUI_ATHENA
11457 # ifdef FEAT_GUI_NEXTAW
11459 # else
11461 # endif
11462 #endif
11463 #ifdef FEAT_GUI_GTK
11465 # ifdef HAVE_GTK2
11467 # endif
11468 #endif
11469 #ifdef FEAT_GUI_GNOME
11471 #endif
11472 #ifdef FEAT_GUI_MAC
11474 #endif
11475 #ifdef FEAT_GUI_MOTIF
11477 #endif
11478 #ifdef FEAT_GUI_PHOTON
11480 #endif
11481 #ifdef FEAT_GUI_W16
11483 #endif
11484 #ifdef FEAT_GUI_W32
11486 #endif
11487 #ifdef FEAT_HANGULIN
11489 #endif
11490 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11492 #endif
11493 #ifdef FEAT_INS_EXPAND
11495 #endif
11496 #ifdef FEAT_JUMPLIST
11498 #endif
11499 #ifdef FEAT_KEYMAP
11501 #endif
11502 #ifdef FEAT_LANGMAP
11504 #endif
11505 #ifdef FEAT_LIBCALL
11507 #endif
11508 #ifdef FEAT_LINEBREAK
11510 #endif
11511 #ifdef FEAT_LISP
11513 #endif
11514 #ifdef FEAT_LISTCMDS
11516 #endif
11517 #ifdef FEAT_LOCALMAP
11519 #endif
11520 #ifdef FEAT_MENU
11522 #endif
11523 #ifdef FEAT_SESSION
11525 #endif
11526 #ifdef FEAT_MODIFY_FNAME
11528 #endif
11529 #ifdef FEAT_MOUSE
11531 #endif
11532 #ifdef FEAT_MOUSESHAPE
11534 #endif
11535 #if defined(UNIX) || defined(VMS)
11536 # ifdef FEAT_MOUSE_DEC
11538 # endif
11539 # ifdef FEAT_MOUSE_GPM
11541 # endif
11542 # ifdef FEAT_MOUSE_JSB
11544 # endif
11545 # ifdef FEAT_MOUSE_NET
11547 # endif
11548 # ifdef FEAT_MOUSE_PTERM
11550 # endif
11551 # ifdef FEAT_SYSMOUSE
11553 # endif
11554 # ifdef FEAT_MOUSE_XTERM
11556 # endif
11557 #endif
11558 #ifdef FEAT_MBYTE
11560 #endif
11561 #ifdef FEAT_MBYTE_IME
11563 #endif
11564 #ifdef FEAT_MULTI_LANG
11566 #endif
11567 #ifdef FEAT_MZSCHEME
11568 #ifndef DYNAMIC_MZSCHEME
11570 #endif
11571 #endif
11572 #ifdef FEAT_OLE
11574 #endif
11575 #ifdef FEAT_OSFILETYPE
11577 #endif
11578 #ifdef FEAT_PATH_EXTRA
11580 #endif
11581 #ifdef FEAT_PERL
11582 #ifndef DYNAMIC_PERL
11584 #endif
11585 #endif
11586 #ifdef FEAT_PYTHON
11587 #ifndef DYNAMIC_PYTHON
11589 #endif
11590 #endif
11591 #ifdef FEAT_POSTSCRIPT
11593 #endif
11594 #ifdef FEAT_PRINTER
11596 #endif
11597 #ifdef FEAT_PROFILE
11599 #endif
11600 #ifdef FEAT_RELTIME
11602 #endif
11603 #ifdef FEAT_QUICKFIX
11605 #endif
11606 #ifdef FEAT_RIGHTLEFT
11608 #endif
11609 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11611 #endif
11612 #ifdef FEAT_SCROLLBIND
11614 #endif
11615 #ifdef FEAT_CMDL_INFO
11618 #endif
11619 #ifdef FEAT_SIGNS
11621 #endif
11622 #ifdef FEAT_SMARTINDENT
11624 #endif
11625 #ifdef FEAT_SNIFF
11627 #endif
11628 #ifdef FEAT_STL_OPT
11630 #endif
11631 #ifdef FEAT_SUN_WORKSHOP
11633 #endif
11634 #ifdef FEAT_NETBEANS_INTG
11636 #endif
11637 #ifdef FEAT_SPELL
11639 #endif
11640 #ifdef FEAT_SYN_HL
11642 #endif
11643 #if defined(USE_SYSTEM) || !defined(UNIX)
11645 #endif
11646 #ifdef FEAT_TAG_BINS
11648 #endif
11649 #ifdef FEAT_TAG_OLDSTATIC
11651 #endif
11652 #ifdef FEAT_TAG_ANYWHITE
11654 #endif
11655 #ifdef FEAT_TCL
11656 # ifndef DYNAMIC_TCL
11658 # endif
11659 #endif
11660 #ifdef TERMINFO
11662 #endif
11663 #ifdef FEAT_TERMRESPONSE
11665 #endif
11666 #ifdef FEAT_TEXTOBJ
11668 #endif
11669 #ifdef HAVE_TGETENT
11671 #endif
11672 #ifdef FEAT_TITLE
11674 #endif
11675 #ifdef FEAT_TOOLBAR
11677 #endif
11678 #ifdef FEAT_USR_CMDS
11681 #endif
11682 #ifdef FEAT_VIMINFO
11684 #endif
11685 #ifdef FEAT_VERTSPLIT
11687 #endif
11688 #ifdef FEAT_VIRTUALEDIT
11690 #endif
11691 #ifdef FEAT_VISUAL
11693 #endif
11694 #ifdef FEAT_VISUALEXTRA
11696 #endif
11697 #ifdef FEAT_VREPLACE
11699 #endif
11700 #ifdef FEAT_WILDIGN
11702 #endif
11703 #ifdef FEAT_WILDMENU
11705 #endif
11706 #ifdef FEAT_WINDOWS
11708 #endif
11709 #ifdef FEAT_WAK
11711 #endif
11712 #ifdef FEAT_WRITEBACKUP
11714 #endif
11715 #ifdef FEAT_XIM
11717 #endif
11718 #ifdef FEAT_XFONTSET
11720 #endif
11721 #ifdef USE_XSMP
11723 #endif
11724 #ifdef USE_XSMP_INTERACT
11726 #endif
11727 #ifdef FEAT_XCLIPBOARD
11729 #endif
11730 #ifdef FEAT_XTERM_SAVE
11732 #endif
11733 #if defined(UNIX) && defined(FEAT_X11)
11735 #endif
11736 NULL
11737 };
11742 {
11745 }
11748 {
11753 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11756 #endif
11757 #ifdef DYNAMIC_TCL
11760 #endif
11761 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11764 #endif
11765 #ifdef DYNAMIC_MZSCHEME
11768 #endif
11769 #ifdef DYNAMIC_RUBY
11772 #endif
11773 #ifdef DYNAMIC_PYTHON
11776 #endif
11777 #ifdef DYNAMIC_PERL
11780 #endif
11781 #ifdef FEAT_GUI
11784 # ifdef FEAT_GUI_W32
11787 # endif
11788 # ifdef FEAT_BROWSE
11791 # endif
11792 #endif
11793 #ifdef FEAT_SYN_HL
11796 #endif
11797 #if defined(WIN3264)
11800 #endif
11801 #ifdef FEAT_NETBEANS_INTG
11804 #endif
11805 }
11808 }
11810 /*
11811 * "has_key()" function
11812 */
11813 static void
11817 {
11820 {
11823 }
11829 }
11831 /*
11832 * "haslocaldir()" function
11833 */
11834 /*ARGSUSED*/
11835 static void
11839 {
11841 }
11843 /*
11844 * "hasmapto()" function
11845 */
11846 static void
11850 {
11859 else
11860 {
11864 }
11868 else
11870 }
11872 /*
11873 * "histadd()" function
11874 */
11875 /*ARGSUSED*/
11876 static void
11880 {
11881 #ifdef FEAT_CMDHIST
11885 #endif
11890 #ifdef FEAT_CMDHIST
11894 {
11897 {
11901 }
11902 }
11903 #endif
11904 }
11906 /*
11907 * "histdel()" function
11908 */
11909 /*ARGSUSED*/
11910 static void
11914 {
11915 #ifdef FEAT_CMDHIST
11924 /* only one argument: clear entire history */
11927 /* index given: remove that entry */
11930 else
11931 /* string given: remove all matching entries */
11935 #else
11937 #endif
11938 }
11940 /*
11941 * "histget()" function
11942 */
11943 /*ARGSUSED*/
11944 static void
11948 {
11949 #ifdef FEAT_CMDHIST
11957 else
11958 {
11962 else
11964 /* -1 on type error */
11966 }
11967 #else
11969 #endif
11971 }
11973 /*
11974 * "histnr()" function
11975 */
11976 /*ARGSUSED*/
11977 static void
11981 {
11984 #ifdef FEAT_CMDHIST
11990 else
11991 #endif
11994 }
11996 /*
11997 * "highlightID(name)" function
11998 */
11999 static void
12003 {
12005 }
12007 /*
12008 * "highlight_exists()" function
12009 */
12010 static void
12014 {
12016 }
12018 /*
12019 * "hostname()" function
12020 */
12021 /*ARGSUSED*/
12022 static void
12026 {
12032 }
12034 /*
12035 * iconv() function
12036 */
12037 /*ARGSUSED*/
12038 static void
12042 {
12043 #ifdef FEAT_MBYTE
12047 vimconv_T vimconv;
12048 #endif
12053 #ifdef FEAT_MBYTE
12060 /* If the encodings are equal, no conversion needed. */
12063 else
12069 #endif
12070 }
12072 /*
12073 * "indent()" function
12074 */
12075 static void
12079 {
12080 linenr_T lnum;
12085 else
12087 }
12089 /*
12090 * "index()" function
12091 */
12092 static void
12096 {
12104 {
12107 }
12110 {
12113 {
12116 /* Start at specified item. Use the cached index that list_find()
12117 * sets, so that a negative number also works. */
12124 }
12128 {
12131 }
12132 }
12133 }
12139 /*
12140 * This function is used by f_input() and f_inputdialog() functions. The third
12141 * argument to f_input() specifies the type of completion to use at the
12142 * prompt. The third argument to f_inputdialog() specifies the value to return
12143 * when the user cancels the prompt.
12144 */
12145 static void
12150 {
12163 #ifdef NO_CONSOLE_INPUT
12164 /* While starting up, there is no place to enter text. */
12167 #endif
12171 {
12172 /* Only the part of the message after the last NL is considered as
12173 * prompt for the command line */
12177 else
12178 {
12188 }
12192 {
12198 {
12214 }
12215 }
12224 /* since the user typed this, no need to wait for return */
12227 }
12229 }
12231 /*
12232 * "input()" function
12233 * Also handles inputsecret() when inputsecret is set.
12234 */
12235 static void
12239 {
12241 }
12243 /*
12244 * "inputdialog()" function
12245 */
12246 static void
12250 {
12251 #if defined(FEAT_GUI_TEXTDIALOG)
12252 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12254 {
12263 else
12269 else
12270 {
12276 else
12278 }
12280 }
12281 else
12282 #endif
12284 }
12286 /*
12287 * "inputlist()" function
12288 */
12289 static void
12293 {
12299 #ifdef NO_CONSOLE_INPUT
12300 /* While starting up, there is no place to enter text. */
12303 #endif
12305 {
12308 }
12317 {
12320 }
12322 /* Ask for choice. */
12328 }
12333 /*
12334 * "inputrestore()" function
12335 */
12336 /*ARGSUSED*/
12337 static void
12341 {
12343 {
12348 }
12350 {
12353 }
12354 }
12356 /*
12357 * "inputsave()" function
12358 */
12359 /*ARGSUSED*/
12360 static void
12364 {
12365 /* Add an entry to the stack of typeahead storage. */
12367 {
12372 }
12373 else
12375 }
12377 /*
12378 * "inputsecret()" function
12379 */
12380 static void
12384 {
12390 }
12392 /*
12393 * "insert()" function
12394 */
12395 static void
12399 {
12410 {
12418 else
12419 {
12422 {
12425 }
12426 }
12428 {
12431 }
12432 }
12433 }
12435 /*
12436 * "isdirectory()" function
12437 */
12438 static void
12442 {
12444 }
12446 /*
12447 * "islocked()" function
12448 */
12449 static void
12453 {
12454 lval_T lv;
12460 FNE_CHECK_START);
12462 {
12465 else
12466 {
12468 {
12471 else
12472 {
12475 {
12476 /* Consider a variable locked when:
12477 * 1. the variable itself is locked
12478 * 2. the value of the variable is locked.
12479 * 3. the List or Dict value is locked.
12480 */
12483 }
12484 }
12485 }
12491 /* List item. */
12493 else
12494 /* Dictionary item. */
12496 }
12497 }
12500 }
12504 /*
12505 * Turn a dict into a list:
12506 * "what" == 0: list of keys
12507 * "what" == 1: list of values
12508 * "what" == 2: list of items
12509 */
12510 static void
12515 {
12526 {
12529 }
12538 {
12540 {
12550 {
12551 /* keys() */
12555 }
12557 {
12558 /* values() */
12560 }
12561 else
12562 {
12563 /* items() */
12585 }
12586 }
12587 }
12588 }
12590 /*
12591 * "items(dict)" function
12592 */
12593 static void
12597 {
12599 }
12601 /*
12602 * "join()" function
12603 */
12604 static void
12608 {
12609 garray_T ga;
12614 {
12617 }
12622 else
12628 {
12633 }
12634 else
12636 }
12638 /*
12639 * "keys()" function
12640 */
12641 static void
12645 {
12647 }
12649 /*
12650 * "last_buffer_nr()" function.
12651 */
12652 /*ARGSUSED*/
12653 static void
12657 {
12666 }
12668 /*
12669 * "len()" function
12670 */
12671 static void
12675 {
12677 {
12692 }
12693 }
12697 static void
12702 {
12703 #ifdef FEAT_LIBCALL
12707 #endif
12712 else
12718 #ifdef FEAT_LIBCALL
12719 /* The first two args must be strings, otherwise its meaningless */
12721 {
12727 else
12731 string_in,
12733 string_result,
12737 }
12738 #endif
12739 }
12741 /*
12742 * "libcall()" function
12743 */
12744 static void
12748 {
12750 }
12752 /*
12753 * "libcallnr()" function
12754 */
12755 static void
12759 {
12761 }
12763 /*
12764 * "line(string)" function
12765 */
12766 static void
12770 {
12779 }
12781 /*
12782 * "line2byte(lnum)" function
12783 */
12784 /*ARGSUSED*/
12785 static void
12789 {
12790 #ifndef FEAT_BYTEOFF
12792 #else
12793 linenr_T lnum;
12798 else
12802 #endif
12803 }
12805 /*
12806 * "lispindent(lnum)" function
12807 */
12808 static void
12812 {
12813 #ifdef FEAT_LISP
12814 pos_T pos;
12815 linenr_T lnum;
12820 {
12824 }
12825 else
12826 #endif
12828 }
12830 /*
12831 * "localtime()" function
12832 */
12833 /*ARGSUSED*/
12834 static void
12838 {
12840 }
12844 static void
12849 {
12856 garray_T ga;
12859 /* return empty string for failure */
12868 {
12872 }
12873 else
12884 {
12894 }
12895 }
12897 #ifdef FEAT_FLOAT
12898 /*
12899 * "log10()" function
12900 */
12901 static void
12905 {
12906 float_T f;
12911 else
12913 }
12914 #endif
12916 /*
12917 * "map()" function
12918 */
12919 static void
12923 {
12925 }
12927 /*
12928 * "maparg()" function
12929 */
12930 static void
12934 {
12936 }
12938 /*
12939 * "mapcheck()" function
12940 */
12941 static void
12945 {
12947 }
12951 static void
12956 {
12960 regmatch_T regmatch;
12973 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12979 {
12980 /* return empty list when there are no matches */
12983 }
12985 {
12988 }
12991 {
12995 }
12996 else
13004 {
13011 {
13016 }
13017 else
13018 {
13023 /* When "count" argument is there ignore matches before "start",
13024 * otherwise skip part of the string. Differs when pattern is "^"
13025 * or "\<". */
13028 else
13030 }
13036 }
13040 {
13044 {
13046 {
13048 {
13051 }
13056 }
13065 /* Advance to just after the match. */
13067 {
13070 }
13071 else
13072 {
13073 #ifdef FEAT_MBYTE
13076 #else
13078 #endif
13079 }
13080 }
13083 {
13085 {
13088 /* return list with matched string and submatches */
13090 {
13092 {
13096 }
13102 }
13103 }
13105 {
13106 /* return matched string */
13109 else
13112 }
13115 else
13116 {
13120 else
13124 }
13125 }
13127 }
13129 theend:
13132 }
13134 /*
13135 * "match()" function
13136 */
13137 static void
13141 {
13143 }
13145 /*
13146 * "matchadd()" function
13147 */
13148 static void
13152 {
13153 #ifdef FEAT_SEARCH_EXTRA
13166 {
13170 }
13174 {
13177 }
13180 #endif
13181 }
13183 /*
13184 * "matcharg()" function
13185 */
13186 static void
13190 {
13192 {
13193 #ifdef FEAT_SEARCH_EXTRA
13198 {
13200 {
13204 }
13205 else
13206 {
13209 }
13210 }
13211 #endif
13212 }
13213 }
13215 /*
13216 * "matchdelete()" function
13217 */
13218 static void
13222 {
13223 #ifdef FEAT_SEARCH_EXTRA
13226 #endif
13227 }
13229 /*
13230 * "matchend()" function
13231 */
13232 static void
13236 {
13238 }
13240 /*
13241 * "matchlist()" function
13242 */
13243 static void
13247 {
13249 }
13251 /*
13252 * "matchstr()" function
13253 */
13254 static void
13258 {
13260 }
13264 static void
13269 {
13275 {
13281 {
13284 {
13287 {
13294 }
13295 }
13296 }
13297 }
13299 {
13307 {
13310 {
13312 {
13316 {
13319 }
13322 }
13323 }
13324 }
13325 }
13326 else
13329 }
13331 /*
13332 * "max()" function
13333 */
13334 static void
13338 {
13340 }
13342 /*
13343 * "min()" function
13344 */
13345 static void
13349 {
13351 }
13355 /*
13356 * Create the directory in which "dir" is located, and higher levels when
13357 * needed.
13358 */
13359 static int
13363 {
13368 /* Get end of directory name in "dir".
13369 * We're done when it's "/" or "c:/". */
13374 /* If the directory exists we're done. Otherwise: create it.*/
13384 }
13386 #ifdef vim_mkdir
13387 /*
13388 * "mkdir()" function
13389 */
13390 static void
13394 {
13405 {
13410 }
13412 }
13413 #endif
13415 /*
13416 * "mode()" function
13417 */
13418 /*ARGSUSED*/
13419 static void
13423 {
13429 #ifdef FEAT_VISUAL
13431 {
13434 else
13436 }
13437 else
13438 #endif
13441 {
13447 }
13451 {
13452 #ifdef FEAT_VREPLACE
13454 {
13457 }
13458 else
13459 #endif
13462 else
13464 }
13466 {
13470 }
13472 {
13475 }
13476 else
13477 {
13481 }
13483 /* A zero number or empty string argument: return only major mode. */
13491 }
13493 /*
13494 * "nextnonblank()" function
13495 */
13496 static void
13500 {
13501 linenr_T lnum;
13504 {
13506 {
13509 }
13512 }
13514 }
13516 /*
13517 * "nr2char()" function
13518 */
13519 static void
13523 {
13526 #ifdef FEAT_MBYTE
13529 else
13530 #endif
13531 {
13534 }
13537 }
13539 /*
13540 * "pathshorten()" function
13541 */
13542 static void
13546 {
13553 else
13554 {
13559 }
13560 }
13562 #ifdef FEAT_FLOAT
13563 /*
13564 * "pow()" function
13565 */
13566 static void
13570 {
13577 else
13579 }
13580 #endif
13582 /*
13583 * "prevnonblank()" function
13584 */
13585 static void
13589 {
13590 linenr_T lnum;
13595 else
13599 }
13601 #ifdef HAVE_STDARG_H
13602 /* This dummy va_list is here because:
13603 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13604 * - locally in the function results in a "used before set" warning
13605 * - using va_start() to initialize it gives "function with fixed args" error */
13607 #endif
13609 /*
13610 * "printf()" function
13611 */
13612 static void
13616 {
13620 {
13627 /* Get the required length, allocate the buffer and do it for real. */
13632 {
13635 {
13638 }
13639 }
13641 }
13642 #endif
13643 }
13645 /*
13646 * "pumvisible()" function
13647 */
13648 /*ARGSUSED*/
13649 static void
13653 {
13655 #ifdef FEAT_INS_EXPAND
13658 #endif
13659 }
13661 /*
13662 * "range()" function
13663 */
13664 static void
13668 {
13677 {
13680 }
13681 else
13682 {
13686 }
13695 else
13696 {
13702 }
13703 }
13705 /*
13706 * "readfile()" function
13707 */
13708 static void
13712 {
13732 {
13737 }
13742 /* Always open the file in binary mode, library functions have a mind of
13743 * their own about CR-LF conversion. */
13746 {
13749 }
13753 {
13758 {
13760 {
13761 /* Only when in binary mode add an empty list item when the
13762 * last line ends in a '\n'. */
13766 /* Found end-of-line or end-of-file: add a text line to the
13767 * list. */
13776 else
13777 {
13780 {
13786 }
13787 }
13792 {
13795 }
13805 }
13808 }
13813 {
13814 /* "buf" is full, need to move text to an allocated buffer */
13816 {
13819 }
13820 else
13821 {
13824 {
13830 }
13831 }
13833 }
13834 else
13835 {
13838 }
13839 }
13841 /*
13842 * For a negative line count use only the lines at the end of the file,
13843 * free the rest.
13844 */
13847 {
13850 }
13854 }
13856 #if defined(FEAT_RELTIME)
13859 /*
13860 * Convert a List to proftime_T.
13861 * Return FAIL when there is something wrong.
13862 */
13863 static int
13867 {
13876 # ifdef WIN3264
13879 # else
13882 # endif
13884 }
13887 /*
13888 * "reltime()" function
13889 */
13890 static void
13894 {
13895 #ifdef FEAT_RELTIME
13896 proftime_T res;
13897 proftime_T start;
13900 {
13901 /* No arguments: get current time. */
13903 }
13905 {
13909 }
13910 else
13911 {
13912 /* Two arguments: compute the difference. */
13917 }
13920 {
13923 # ifdef WIN3264
13926 # else
13929 # endif
13932 }
13933 #endif
13934 }
13936 /*
13937 * "reltimestr()" function
13938 */
13939 static void
13943 {
13944 #ifdef FEAT_RELTIME
13945 proftime_T tm;
13946 #endif
13950 #ifdef FEAT_RELTIME
13953 #endif
13954 }
13956 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13960 static void
13962 {
13964 # ifdef FEAT_GUI
13966 # endif
13967 )
13968 {
13972 }
13973 }
13975 static int
13977 {
13980 {
13983 }
13985 }
13986 #endif
13988 #ifdef FEAT_CLIENTSERVER
13991 static void
13996 {
14001 # ifdef WIN32
14002 HWND w;
14003 # else
14004 Window w;
14005 # endif
14010 # ifdef FEAT_X11
14013 # endif
14019 # ifdef WIN32
14021 # else
14024 # endif
14025 {
14028 else
14031 }
14036 {
14037 dictitem_T v;
14048 }
14049 }
14050 #endif
14052 /*
14053 * "remote_expr()" function
14054 */
14055 /*ARGSUSED*/
14056 static void
14060 {
14063 #ifdef FEAT_CLIENTSERVER
14065 #endif
14066 }
14068 /*
14069 * "remote_foreground()" function
14070 */
14071 /*ARGSUSED*/
14072 static void
14076 {
14078 #ifdef FEAT_CLIENTSERVER
14079 # ifdef WIN32
14080 /* On Win32 it's done in this application. */
14081 {
14086 }
14087 # else
14088 /* Send a foreground() expression to the server. */
14094 # endif
14095 #endif
14096 }
14098 /*ARGSUSED*/
14099 static void
14103 {
14104 #ifdef FEAT_CLIENTSERVER
14105 dictitem_T v;
14107 # ifdef WIN32
14109 # endif
14113 {
14116 }
14119 {
14122 }
14123 # ifdef WIN32
14127 else
14128 {
14131 }
14132 # else
14139 # endif
14142 {
14151 }
14152 #else
14154 #endif
14155 }
14157 /*ARGSUSED*/
14158 static void
14162 {
14165 #ifdef FEAT_CLIENTSERVER
14169 {
14170 # ifdef WIN32
14171 /* The server's HWND is encoded in the 'id' parameter */
14178 # else
14181 # endif
14183 }
14184 #endif
14187 }
14189 /*
14190 * "remote_send()" function
14191 */
14192 /*ARGSUSED*/
14193 static void
14197 {
14200 #ifdef FEAT_CLIENTSERVER
14202 #endif
14203 }
14205 /*
14206 * "remove()" function
14207 */
14208 static void
14212 {
14224 {
14229 {
14232 {
14236 else
14237 {
14241 }
14242 }
14243 }
14244 }
14249 {
14257 else
14258 {
14260 {
14261 /* Remove one item, return its value. */
14265 }
14266 else
14267 {
14268 /* Remove range of items, return list with values. */
14274 else
14275 {
14279 {
14283 }
14286 else
14287 {
14290 {
14297 }
14298 }
14299 }
14300 }
14301 }
14302 }
14303 }
14305 /*
14306 * "rename({from}, {to})" function
14307 */
14308 static void
14312 {
14317 else
14320 }
14322 /*
14323 * "repeat()" function
14324 */
14325 /*ARGSUSED*/
14326 static void
14330 {
14340 {
14346 }
14347 else
14348 {
14360 {
14364 }
14367 }
14368 }
14370 /*
14371 * "resolve()" function
14372 */
14373 static void
14377 {
14381 #ifdef FEAT_SHORTCUT
14382 {
14388 else
14390 }
14391 #else
14392 # ifdef HAVE_READLINK
14393 {
14415 {
14416 /* Separate the first path component in "p", and keep the
14417 * remainder (beginning with the path separator). */
14420 }
14423 {
14425 {
14432 {
14438 }
14440 /* Ensure that the result will have a trailing path separator
14441 * if the argument has one. */
14445 /* Separate the first path component in the link value and
14446 * concatenate the remainders. */
14449 {
14452 else
14453 {
14456 {
14459 }
14460 }
14462 }
14466 {
14467 /* Ignore trailing path separator. */
14470 }
14472 {
14473 /* symlink is relative to directory of argument */
14476 {
14481 }
14482 }
14483 else
14484 {
14487 }
14488 }
14493 /* Append the first path component of "remain" to "p". */
14498 {
14502 }
14503 /* Shorten "remain". */
14506 else
14507 {
14510 }
14511 }
14513 /* If the result is a relative path name, make it explicitly relative to
14514 * the current directory if and only if the argument had this form. */
14516 {
14525 {
14526 /* Prepend "./". */
14529 {
14532 }
14533 }
14535 {
14536 /* Strip leading "./". */
14542 }
14543 }
14545 /* Ensure that the result will have no trailing path separator
14546 * if the argument had none. But keep "/" or "//". */
14548 {
14552 }
14555 }
14556 # else
14558 # endif
14559 #endif
14563 #ifdef HAVE_READLINK
14564 fail:
14565 #endif
14567 }
14569 /*
14570 * "reverse({list})" function
14571 */
14572 static void
14576 {
14585 {
14590 {
14594 }
14599 }
14600 }
14612 /*
14613 * Get flags for a search function.
14614 * Possibly sets "p_ws".
14615 * Returns BACKWARD, FORWARD or zero (for an error).
14616 */
14617 static int
14621 {
14628 {
14633 {
14635 {
14642 {
14650 }
14652 {
14655 }
14656 else
14658 }
14662 }
14663 }
14665 }
14667 /*
14668 * Shared by search() and searchpos() functions
14669 */
14670 static int
14675 {
14678 pos_T pos;
14679 pos_T save_cursor;
14684 proftime_T tm;
14685 #ifdef FEAT_RELTIME
14687 #endif
14701 /* Optional arguments: line number to stop searching and timeout. */
14703 {
14707 #ifdef FEAT_RELTIME
14709 {
14713 }
14714 #endif
14715 }
14717 #ifdef FEAT_RELTIME
14718 /* Set the time limit, if there is one. */
14720 #endif
14722 /*
14723 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14724 * Check to make sure only those flags are set.
14725 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14726 * flags cannot be set. Check for that condition also.
14727 */
14730 {
14733 }
14739 {
14742 else
14748 {
14749 /* Store the match cursor position */
14752 }
14753 /* "/$" will put the cursor after the end of the line, may need to
14754 * correct that here */
14756 }
14758 /* If 'n' flag is used: restore cursor position. */
14761 else
14763 theend:
14767 }
14769 #ifdef FEAT_FLOAT
14770 /*
14771 * "round({float})" function
14772 */
14773 static void
14777 {
14778 float_T f;
14782 /* round() is not in C90, use ceil() or floor() instead. */
14784 else
14786 }
14787 #endif
14789 /*
14790 * "search()" function
14791 */
14792 static void
14796 {
14800 }
14802 /*
14803 * "searchdecl()" function
14804 */
14805 static void
14809 {
14819 {
14823 }
14827 }
14829 /*
14830 * Used by searchpair() and searchpairpos()
14831 */
14832 static int
14836 {
14849 /* Get the three pattern arguments: start, middle, end. */
14856 /* Handle the optional fourth argument: flags */
14861 /* Don't accept SP_END or SP_SUBPAT.
14862 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14863 */
14866 {
14869 }
14871 /* Using 'r' implies 'W', otherwise it doesn't work. */
14875 /* Optional fifth argument: skip expression */
14879 else
14880 {
14883 {
14887 #ifdef FEAT_RELTIME
14889 {
14893 }
14894 #endif
14895 }
14896 }
14903 theend:
14907 }
14909 /*
14910 * "searchpair()" function
14911 */
14912 static void
14916 {
14918 }
14920 /*
14921 * "searchpairpos()" function
14922 */
14923 static void
14927 {
14928 pos_T match_pos;
14938 {
14941 }
14945 }
14947 /*
14948 * Search for a start/middle/end thing.
14949 * Used by searchpair(), see its documentation for the details.
14950 * Returns 0 or -1 for no match,
14951 */
14952 long
14964 {
14968 pos_T pos;
14969 pos_T firstpos;
14970 pos_T foundpos;
14971 pos_T save_cursor;
14972 pos_T save_pos;
14978 proftime_T tm;
14980 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
14984 #ifdef FEAT_RELTIME
14985 /* Set the time limit, if there is one. */
14987 #endif
14989 /* Make two search patterns: start/end (pat2, for in nested pairs) and
14990 * start/middle/end (pat3, for the top pair). */
14998 else
15010 {
15014 /* didn't find it or found the first match again: FAIL */
15020 {
15021 /* Found the same position again. Can happen with a pattern that
15022 * has "\zs" at the end and searching backwards. Advance one
15023 * character and try again. */
15026 else
15028 }
15031 /* clear the start flag to avoid getting stuck here */
15034 /* If the skip pattern matches, ignore this match. */
15036 {
15042 {
15043 /* Evaluating {skip} caused an error, break here. */
15047 }
15050 }
15053 {
15054 /* Found end when searching backwards or start when searching
15055 * forward: nested pair. */
15058 }
15059 else
15060 {
15061 /* Found end when searching forward or start when searching
15062 * backward: end of (nested) pair; or found middle in outer pair. */
15065 }
15068 {
15069 /* Found the match: return matchcount or line number. */
15072 else
15080 }
15081 }
15084 {
15085 /* Store the match cursor position */
15088 }
15090 /* If 'n' flag is used or search failed: restore cursor position. */
15094 theend:
15100 }
15102 /*
15103 * "searchpos()" function
15104 */
15105 static void
15109 {
15110 pos_T match_pos;
15123 {
15126 }
15132 }
15135 /*ARGSUSED*/
15136 static void
15140 {
15141 #ifdef FEAT_CLIENTSERVER
15151 # ifdef FEAT_X11
15154 # endif
15157 {
15160 }
15162 #else
15164 #endif
15165 }
15167 /*ARGSUSED*/
15168 static void
15172 {
15175 #ifdef FEAT_CLIENTSERVER
15176 # ifdef WIN32
15178 # else
15182 # endif
15183 #endif
15186 }
15188 /*
15189 * "setbufvar()" function
15190 */
15191 /*ARGSUSED*/
15192 static void
15196 {
15198 aco_save_T aco;
15213 {
15214 /* set curbuf to be our buf, temporarily */
15218 {
15228 }
15229 else
15230 {
15233 {
15238 }
15239 }
15241 /* reset notion of buffer */
15243 }
15244 }
15246 /*
15247 * "setcmdpos()" function
15248 */
15249 static void
15253 {
15258 }
15260 /*
15261 * "setline()" function
15262 */
15263 static void
15267 {
15268 linenr_T lnum;
15277 {
15280 }
15281 else
15286 {
15288 {
15289 /* list argument, get next string */
15294 }
15300 {
15301 /* existing line, replace it */
15303 {
15308 }
15309 }
15311 {
15312 /* lnum is one past the last line, append the line */
15316 }
15321 }
15325 }
15327 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15329 /*
15330 * Used by "setqflist()" and "setloclist()" functions
15331 */
15332 /*ARGSUSED*/
15333 static void
15339 {
15340 #ifdef FEAT_QUICKFIX
15343 #endif
15347 #ifdef FEAT_QUICKFIX
15350 else
15351 {
15355 {
15361 }
15365 }
15366 #endif
15367 }
15369 /*
15370 * "setloclist()" function
15371 */
15372 /*ARGSUSED*/
15373 static void
15377 {
15385 }
15387 /*
15388 * "setmatches()" function
15389 */
15390 static void
15394 {
15395 #ifdef FEAT_SEARCH_EXTRA
15402 {
15405 }
15407 {
15409 /* To some extent make sure that we are dealing with a list from
15410 * "getmatches()". */
15413 {
15416 {
15419 }
15424 {
15427 }
15429 }
15434 {
15441 }
15443 }
15444 #endif
15445 }
15447 /*
15448 * "setpos()" function
15449 */
15450 /*ARGSUSED*/
15451 static void
15455 {
15456 pos_T pos;
15463 {
15465 {
15468 {
15469 /* set cursor */
15471 {
15475 }
15476 else
15478 }
15480 {
15481 /* set mark */
15484 }
15485 else
15487 }
15488 }
15489 }
15491 /*
15492 * "setqflist()" function
15493 */
15494 /*ARGSUSED*/
15495 static void
15499 {
15501 }
15503 /*
15504 * "setreg()" function
15505 */
15506 static void
15510 {
15516 char_u yank_type;
15535 {
15541 {
15551 #ifdef FEAT_VISUAL
15555 {
15559 }
15561 #endif
15562 }
15563 }
15570 }
15572 /*
15573 * "settabwinvar()" function
15574 */
15575 static void
15579 {
15581 }
15583 /*
15584 * "setwinvar()" function
15585 */
15586 static void
15590 {
15592 }
15594 /*
15595 * "setwinvar()" and "settabwinvar()" functions
15596 */
15597 static void
15602 {
15604 #ifdef FEAT_WINDOWS
15607 #endif
15618 #ifdef FEAT_WINDOWS
15621 else
15623 #endif
15629 {
15630 #ifdef FEAT_WINDOWS
15631 /* set curwin to be our win, temporarily */
15639 #endif
15642 {
15652 }
15653 else
15654 {
15657 {
15662 }
15663 }
15665 #ifdef FEAT_WINDOWS
15666 /* Restore current tabpage and window, if still valid (autocomands can
15667 * make them invalid). */
15671 {
15674 }
15675 #endif
15676 }
15677 }
15679 /*
15680 * "shellescape({string})" function
15681 */
15682 static void
15686 {
15689 }
15691 /*
15692 * "simplify()" function
15693 */
15694 static void
15698 {
15705 }
15707 #ifdef FEAT_FLOAT
15708 /*
15709 * "sin()" function
15710 */
15711 static void
15715 {
15716 float_T f;
15721 else
15723 }
15724 #endif
15726 static int
15727 #ifdef __BORLANDC__
15728 _RTLENTRYF
15729 #endif
15731 static int
15732 #ifdef __BORLANDC__
15733 _RTLENTRYF
15734 #endif
15740 #define ITEM_COMPARE_FAIL 999
15742 /*
15743 * Compare functions for f_sort() below.
15744 */
15745 static int
15746 #ifdef __BORLANDC__
15747 _RTLENTRYF
15748 #endif
15752 {
15767 else
15772 }
15774 static int
15775 #ifdef __BORLANDC__
15776 _RTLENTRYF
15777 #endif
15781 {
15783 typval_T rettv;
15787 /* shortcut after failure in previous call; compare all items equal */
15791 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15792 * in the copy without changing the original list items. */
15804 else
15805 /* return value has wrong type */
15811 }
15813 /*
15814 * "sort({list})" function
15815 */
15816 static void
15820 {
15830 else
15831 {
15846 {
15849 else
15850 {
15858 else
15860 }
15861 }
15863 /* Make an array with each entry pointing to an item in the List. */
15872 /* test the compare function */
15877 else
15878 {
15879 /* Sort the array with item pointers. */
15884 {
15885 /* Clear the List and append the items in the sorted order. */
15890 }
15891 }
15894 }
15895 }
15897 /*
15898 * "soundfold({word})" function
15899 */
15900 static void
15904 {
15909 #ifdef FEAT_SPELL
15911 #else
15913 #endif
15914 }
15916 /*
15917 * "spellbadword()" function
15918 */
15919 /* ARGSUSED */
15920 static void
15924 {
15932 #ifdef FEAT_SPELL
15934 {
15935 /* Find the start and length of the badly spelled word. */
15939 }
15941 {
15946 {
15947 /* Check the argument for spelling. */
15949 {
15952 {
15955 }
15957 }
15958 }
15959 }
15960 #endif
15969 }
15971 /*
15972 * "spellsuggest()" function
15973 */
15974 /*ARGSUSED*/
15975 static void
15979 {
15980 #ifdef FEAT_SPELL
15984 garray_T ga;
15988 #endif
15993 #ifdef FEAT_SPELL
15995 {
15998 {
16003 {
16007 }
16008 }
16009 else
16015 {
16021 else
16022 {
16027 }
16028 }
16030 }
16031 #endif
16032 }
16034 static void
16038 {
16042 regmatch_T regmatch;
16050 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16056 {
16062 }
16073 {
16076 {
16079 else
16083 else
16087 {
16091 }
16094 /* Advance to just after the match. */
16097 else
16098 {
16099 /* Don't get stuck at the same match. */
16100 #ifdef FEAT_MBYTE
16102 #else
16104 #endif
16105 }
16107 }
16110 }
16113 }
16115 #ifdef FEAT_FLOAT
16116 /*
16117 * "sqrt()" function
16118 */
16119 static void
16123 {
16124 float_T f;
16129 else
16131 }
16133 /*
16134 * "str2float()" function
16135 */
16136 static void
16140 {
16147 }
16148 #endif
16150 /*
16151 * "str2nr()" function
16152 */
16153 static void
16157 {
16163 {
16166 {
16169 }
16170 }
16177 }
16179 #ifdef HAVE_STRFTIME
16180 /*
16181 * "strftime({format}[, {time}])" function
16182 */
16183 static void
16187 {
16198 else
16201 /* MSVC returns NULL for an invalid value of seconds. */
16204 else
16205 {
16206 # ifdef FEAT_MBYTE
16207 vimconv_T conv;
16215 # endif
16219 else
16222 # ifdef FEAT_MBYTE
16228 else
16229 # endif
16232 # ifdef FEAT_MBYTE
16233 /* Release conversion descriptors */
16236 # endif
16237 }
16238 }
16239 #endif
16241 /*
16242 * "stridx()" function
16243 */
16244 static void
16248 {
16263 {
16271 }
16276 }
16278 /*
16279 * "string()" function
16280 */
16281 static void
16285 {
16291 /* Make a copy if we have a value but it's not in allocated memory. */
16294 }
16296 /*
16297 * "strlen()" function
16298 */
16299 static void
16303 {
16306 }
16308 /*
16309 * "strpart()" function
16310 */
16311 static void
16315 {
16330 else
16333 /*
16334 * Only return the overlap between the specified part and the actual
16335 * string.
16336 */
16338 {
16341 }
16351 }
16353 /*
16354 * "strridx()" function
16355 */
16356 static void
16360 {
16377 {
16378 /* Third argument: upper limit for index */
16382 }
16383 else
16387 {
16388 /* Empty string matches past the end. */
16390 }
16391 else
16392 {
16394 {
16399 }
16400 }
16404 else
16406 }
16408 /*
16409 * "strtrans()" function
16410 */
16411 static void
16415 {
16418 }
16420 /*
16421 * "submatch()" function
16422 */
16423 static void
16427 {
16431 }
16433 /*
16434 * "substitute()" function
16435 */
16436 static void
16440 {
16453 else
16455 }
16457 /*
16458 * "synID(lnum, col, trans)" function
16459 */
16460 /*ARGSUSED*/
16461 static void
16465 {
16467 #ifdef FEAT_SYN_HL
16480 #endif
16483 }
16485 /*
16486 * "synIDattr(id, what [, mode])" function
16487 */
16488 /*ARGSUSED*/
16489 static void
16493 {
16495 #ifdef FEAT_SYN_HL
16505 {
16509 #ifdef FEAT_GUI
16511 #endif
16512 )
16514 }
16515 else
16516 {
16517 #ifdef FEAT_GUI
16520 else
16521 #endif
16524 else
16526 }
16530 {
16563 /* underline */
16565 else
16566 /* undercurl */
16569 }
16573 #endif
16576 }
16578 /*
16579 * "synIDtrans(id)" function
16580 */
16581 /*ARGSUSED*/
16582 static void
16586 {
16589 #ifdef FEAT_SYN_HL
16594 else
16595 #endif
16599 }
16601 /*
16602 * "synstack(lnum, col)" function
16603 */
16604 /*ARGSUSED*/
16605 static void
16609 {
16610 #ifdef FEAT_SYN_HL
16615 #endif
16620 #ifdef FEAT_SYN_HL
16627 {
16630 {
16636 }
16637 }
16638 #endif
16639 }
16641 /*
16642 * "system()" function
16643 */
16644 static void
16648 {
16660 {
16661 /*
16662 * Write the string to a temp file, to be used for input of the shell
16663 * command.
16664 */
16666 {
16669 }
16673 {
16676 }
16679 {
16682 }
16688 {
16691 }
16692 }
16697 #ifdef USE_CR
16698 /* translate <CR> into <NL> */
16700 {
16704 {
16707 }
16708 }
16709 #else
16710 # ifdef USE_CRNL
16711 /* translate <CR><NL> into <NL> */
16713 {
16718 {
16722 }
16724 }
16725 # endif
16726 #endif
16728 done:
16730 {
16733 }
16736 }
16738 /*
16739 * "tabpagebuflist()" function
16740 */
16741 /* ARGSUSED */
16742 static void
16746 {
16747 #ifndef FEAT_WINDOWS
16749 #else
16755 else
16756 {
16760 }
16763 else
16764 {
16767 else
16768 {
16773 }
16774 }
16775 #endif
16776 }
16779 /*
16780 * "tabpagenr()" function
16781 */
16782 /* ARGSUSED */
16783 static void
16787 {
16789 #ifdef FEAT_WINDOWS
16793 {
16797 {
16800 else
16802 }
16803 }
16804 else
16806 #endif
16808 }
16811 #ifdef FEAT_WINDOWS
16814 /*
16815 * Common code for tabpagewinnr() and winnr().
16816 */
16817 static int
16821 {
16829 {
16836 {
16840 }
16841 else
16842 {
16845 }
16846 }
16851 {
16853 {
16854 /* didn't find it in this tabpage */
16857 }
16859 }
16861 }
16862 #endif
16864 /*
16865 * "tabpagewinnr()" function
16866 */
16867 /* ARGSUSED */
16868 static void
16872 {
16874 #ifdef FEAT_WINDOWS
16880 else
16882 #endif
16884 }
16887 /*
16888 * "tagfiles()" function
16889 */
16890 /*ARGSUSED*/
16891 static void
16895 {
16897 tagname_T tn;
16901 {
16904 }
16911 }
16913 /*
16914 * "taglist()" function
16915 */
16916 static void
16920 {
16931 }
16933 /*
16934 * "tempname()" function
16935 */
16936 /*ARGSUSED*/
16937 static void
16941 {
16947 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16948 * names. Skip 'I' and 'O', they are used for shell redirection. */
16949 do
16950 {
16955 else
16956 {
16957 #ifdef EBCDIC
16962 else
16963 #endif
16965 }
16967 }
16969 /*
16970 * "test(list)" function: Just checking the walls...
16971 */
16972 /*ARGSUSED*/
16973 static void
16977 {
16978 /* Used for unit testing. Change the code below to your liking. */
16979 #if 0
16998 #endif
16999 }
17001 /*
17002 * "tolower(string)" function
17003 */
17004 static void
17008 {
17017 {
17018 #ifdef FEAT_MBYTE
17022 {
17028 /* TODO: reallocate string when byte count changes. */
17032 }
17035 else
17036 #endif
17037 {
17040 }
17041 }
17042 }
17044 /*
17045 * "toupper(string)" function
17046 */
17047 static void
17051 {
17054 }
17056 /*
17057 * "tr(string, fromstr, tostr)" function
17058 */
17059 static void
17063 {
17068 #ifdef FEAT_MBYTE
17076 #endif
17079 garray_T ga;
17085 /* Default return value: empty string. */
17092 #ifdef FEAT_MBYTE
17094 #endif
17095 /* not multi-byte: fromstr and tostr must be the same length */
17097 {
17098 #ifdef FEAT_MBYTE
17099 error:
17100 #endif
17104 }
17106 /* fromstr and tostr have to contain the same number of chars */
17108 {
17109 #ifdef FEAT_MBYTE
17111 {
17117 {
17120 {
17122 {
17125 {
17129 }
17130 }
17134 }
17136 }
17139 {
17140 /* Check that fromstr and tostr have the same number of
17141 * (multi-byte) characters. Done only once when a character
17142 * of instr doesn't appear in fromstr. */
17145 {
17148 }
17151 }
17158 }
17159 else
17160 #endif
17161 {
17162 /* When not using multi-byte chars we can do it faster. */
17166 else
17169 }
17170 }
17172 /* add a terminating NUL */
17177 }
17179 #ifdef FEAT_FLOAT
17180 /*
17181 * "trunc({float})" function
17182 */
17183 static void
17187 {
17188 float_T f;
17192 /* trunc() is not in C90, use floor() or ceil() instead. */
17194 else
17196 }
17197 #endif
17199 /*
17200 * "type(expr)" function
17201 */
17202 static void
17206 {
17210 {
17216 #ifdef FEAT_FLOAT
17218 #endif
17220 }
17222 }
17224 /*
17225 * "values(dict)" function
17226 */
17227 static void
17231 {
17233 }
17235 /*
17236 * "virtcol(string)" function
17237 */
17238 static void
17242 {
17250 {
17253 }
17256 }
17258 /*
17259 * "visualmode()" function
17260 */
17261 /*ARGSUSED*/
17262 static void
17266 {
17267 #ifdef FEAT_VISUAL
17275 /* A non-zero number or non-empty string argument: reset mode. */
17280 #else
17282 #endif
17283 }
17285 /*
17286 * "winbufnr(nr)" function
17287 */
17288 static void
17292 {
17298 else
17300 }
17302 /*
17303 * "wincol()" function
17304 */
17305 /*ARGSUSED*/
17306 static void
17310 {
17313 }
17315 /*
17316 * "winheight(nr)" function
17317 */
17318 static void
17322 {
17328 else
17330 }
17332 /*
17333 * "winline()" function
17334 */
17335 /*ARGSUSED*/
17336 static void
17340 {
17343 }
17345 /*
17346 * "winnr()" function
17347 */
17348 /* ARGSUSED */
17349 static void
17353 {
17356 #ifdef FEAT_WINDOWS
17358 #endif
17360 }
17362 /*
17363 * "winrestcmd()" function
17364 */
17365 /* ARGSUSED */
17366 static void
17370 {
17371 #ifdef FEAT_WINDOWS
17374 garray_T ga;
17379 {
17382 # ifdef FEAT_VERTSPLIT
17385 # endif
17387 }
17391 #else
17393 #endif
17395 }
17397 /*
17398 * "winrestview()" function
17399 */
17400 /* ARGSUSED */
17401 static void
17405 {
17411 else
17412 {
17415 #ifdef FEAT_VIRTUALEDIT
17417 #endif
17422 #ifdef FEAT_DIFF
17424 #endif
17437 #ifdef FEAT_DIFF
17439 #endif
17440 }
17441 }
17443 /*
17444 * "winsaveview()" function
17445 */
17446 /* ARGSUSED */
17447 static void
17451 {
17463 #ifdef FEAT_VIRTUALEDIT
17465 #endif
17470 #ifdef FEAT_DIFF
17472 #endif
17475 }
17477 /*
17478 * "winwidth(nr)" function
17479 */
17480 static void
17484 {
17490 else
17491 #ifdef FEAT_VERTSPLIT
17493 #else
17495 #endif
17496 }
17498 /*
17499 * "writefile()" function
17500 */
17501 static void
17505 {
17518 {
17521 }
17529 /* Always open the file in binary mode, library functions have a mind of
17530 * their own about CR-LF conversion. */
17533 {
17536 }
17537 else
17538 {
17541 {
17543 {
17546 else
17549 {
17552 }
17553 }
17556 {
17559 }
17561 {
17564 }
17565 }
17567 }
17570 }
17572 /*
17573 * Translate a String variable into a position.
17574 * Returns NULL when there is an error.
17575 */
17581 {
17586 /* Argument can be [lnum, col, coladd]. */
17588 {
17598 /* Get the line number */
17603 /* Get the column number */
17609 /* We accept "$" for the column number: last column. */
17616 /* Accept a position up to the NUL after the line. */
17621 #ifdef FEAT_VIRTUALEDIT
17622 /* Get the virtual offset. Defaults to zero. */
17626 #endif
17629 }
17636 #ifdef FEAT_VISUAL
17638 {
17642 }
17643 #endif
17645 {
17650 }
17652 #ifdef FEAT_VIRTUALEDIT
17654 #endif
17657 {
17660 {
17664 }
17666 {
17670 }
17671 }
17673 {
17675 {
17678 }
17679 else
17680 {
17683 }
17685 }
17687 }
17689 /*
17690 * Convert list in "arg" into a position and optional file number.
17691 * When "fnump" is NULL there is no file number, only 3 items.
17692 * Note that the column is passed on as-is, the caller may want to decrement
17693 * it to use 1 for the first column.
17694 * Return FAIL when conversion is not possible, doesn't check the position for
17695 * validity.
17696 */
17697 static int
17702 {
17707 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17708 * when "fnump" isn't NULL and "coladd" is optional. */
17716 {
17723 }
17735 #ifdef FEAT_VIRTUALEDIT
17739 else
17741 #endif
17744 }
17746 /*
17747 * Get the length of an environment variable name.
17748 * Advance "arg" to the first character after the name.
17749 * Return 0 for error.
17750 */
17751 static int
17754 {
17759 ;
17766 }
17768 /*
17769 * Get the length of the name of a function or internal variable.
17770 * "arg" is advanced to the first non-white character after the name.
17771 * Return 0 if something is wrong.
17772 */
17773 static int
17776 {
17780 /* Find the end of the name. */
17782 ;
17790 }
17792 /*
17793 * Get the length of the name of a variable or function.
17794 * Only the name is recognized, does not handle ".key" or "[idx]".
17795 * "arg" is advanced to the first non-white character after the name.
17796 * Return -1 if curly braces expansion failed.
17797 * Return 0 if something else is wrong.
17798 * If the name contains 'magic' {}'s, expand them and return the
17799 * expanded name in an allocated string via 'alias' - caller must free.
17800 */
17801 static int
17807 {
17817 {
17818 /* hard coded <SNR>, already translated */
17821 }
17824 {
17825 /* literal "<SID>", "s:" or "<SNR>" */
17827 }
17829 /*
17830 * Find the end of the name; check for {} construction.
17831 */
17835 {
17839 {
17843 }
17845 /*
17846 * Include any <SID> etc in the expanded string:
17847 * Thus the -len here.
17848 */
17855 }
17862 }
17864 /*
17865 * Find the end of a variable or function name, taking care of magic braces.
17866 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17867 * start and end of the first magic braces item.
17868 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17869 * Return a pointer to just after the name. Equal to "arg" if there is no
17870 * valid name.
17871 */
17878 {
17884 {
17887 }
17889 /* Quick check for valid starting character. */
17899 {
17901 {
17902 /* skip over 'string' to avoid counting [ and ] inside it. */
17904 ;
17907 }
17909 {
17910 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17916 }
17919 {
17924 }
17927 {
17929 {
17930 mb_nest++;
17933 }
17935 {
17936 mb_nest--;
17939 }
17940 }
17941 }
17944 }
17946 /*
17947 * Expands out the 'magic' {}'s in a variable/function name.
17948 * Note that this can call itself recursively, to deal with
17949 * constructs like foo{bar}{baz}{bam}
17950 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17951 * "in_start" ^
17952 * "expr_start" ^
17953 * "expr_end" ^
17954 * "in_end" ^
17955 *
17956 * Returns a new allocated string, which the caller must free.
17957 * Returns NULL for failure.
17958 */
17965 {
17966 char_u c1;
17980 {
17984 {
17988 }
17989 }
17997 {
18000 {
18001 /* Further expansion! */
18006 }
18007 }
18010 }
18012 /*
18013 * Return TRUE if character "c" can be used in a variable or function name.
18014 * Does not include '{' or '}' for magic braces.
18015 */
18016 static int
18019 {
18021 }
18023 /*
18024 * Return TRUE if character "c" can be used as the first character in a
18025 * variable or function name (excluding '{' and '}').
18026 */
18027 static int
18030 {
18032 }
18034 /*
18035 * Set number v: variable to "val".
18036 */
18037 void
18041 {
18043 }
18045 /*
18046 * Get number v: variable value.
18047 */
18048 long
18051 {
18053 }
18055 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18056 /*
18057 * Get string v: variable value. Uses a static buffer, can only be used once.
18058 */
18059 char_u *
18062 {
18064 }
18065 #endif
18067 /*
18068 * Set v:count, v:count1 and v:prevcount.
18069 */
18070 void
18074 {
18078 }
18080 /*
18081 * Set string v: variable to a copy of "val".
18082 */
18083 void
18088 {
18089 /* Need to do this (at least) once, since we can't initialize a union.
18090 * Will always be invoked when "v:progname" is set. */
18098 else
18100 }
18102 /*
18103 * Set v:register if needed.
18104 */
18105 void
18108 {
18109 char_u regname;
18113 else
18115 /* Avoid free/alloc when the value is already right. */
18118 }
18120 /*
18121 * Get or set v:exception. If "oldval" == NULL, return the current value.
18122 * Otherwise, restore the value to "oldval" and return NULL.
18123 * Must always be called in pairs to save and restore v:exception! Does not
18124 * take care of memory allocations.
18125 */
18126 char_u *
18129 {
18135 }
18137 /*
18138 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18139 * Otherwise, restore the value to "oldval" and return NULL.
18140 * Must always be called in pairs to save and restore v:throwpoint! Does not
18141 * take care of memory allocations.
18142 */
18143 char_u *
18146 {
18152 }
18154 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18155 /*
18156 * Set v:cmdarg.
18157 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18158 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18159 * Must always be called in pairs!
18160 */
18161 char_u *
18165 {
18172 {
18176 }
18182 else
18190 # ifdef FEAT_MBYTE
18195 # endif
18205 else
18214 # ifdef FEAT_MBYTE
18221 # endif
18224 }
18225 #endif
18227 /*
18228 * Get the value of internal variable "name".
18229 * Return OK or FAIL.
18230 */
18231 static int
18237 {
18240 typval_T atv;
18244 /* truncate the name, so that we can use strcmp() */
18248 /*
18249 * Check for "b:changedtick".
18250 */
18252 {
18256 }
18258 /*
18259 * Check for user-defined variables.
18260 */
18261 else
18262 {
18266 }
18269 {
18273 }
18280 }
18282 /*
18283 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18284 * Also handle function call with Funcref variable: func(expr)
18285 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18286 */
18287 static int
18293 {
18298 typval_T functv;
18305 {
18307 {
18308 /* need to copy the funcref so that we can clear rettv */
18312 /* Invoke the function. Recursive! */
18318 /* Clear the funcref afterwards, so that deleting it while
18319 * evaluating the arguments is possible (see test55). */
18322 /* Stop the expression evaluation when immediately aborting on
18323 * error, or when an interrupt occurred or an exception was thrown
18324 * but not caught. */
18326 {
18330 }
18333 }
18335 {
18338 {
18342 }
18343 else
18346 {
18349 }
18350 }
18351 }
18354 }
18356 /*
18357 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18358 * value).
18359 */
18362 {
18364 }
18366 /*
18367 * Allocate memory for a variable type-value, and assign a string to it.
18368 * The string "s" must have been allocated, it is consumed.
18369 * Return NULL for out of memory, the variable otherwise.
18370 */
18374 {
18379 {
18382 }
18383 else
18386 }
18388 /*
18389 * Free the memory for a variable type-value.
18390 */
18391 void
18394 {
18396 {
18398 {
18401 /*FALLTHROUGH*/
18412 #ifdef FEAT_FLOAT
18414 #endif
18420 }
18422 }
18423 }
18425 /*
18426 * Free the memory for a variable value and set the value to NULL or 0.
18427 */
18428 void
18431 {
18433 {
18435 {
18438 /*FALLTHROUGH*/
18454 #ifdef FEAT_FLOAT
18458 #endif
18463 }
18465 }
18466 }
18468 /*
18469 * Set the value of a variable to NULL without freeing items.
18470 */
18471 static void
18474 {
18477 }
18479 /*
18480 * Get the number value of a variable.
18481 * If it is a String variable, uses vim_str2nr().
18482 * For incompatible types, return 0.
18483 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18484 * caller of incompatible types: it sets *denote to TRUE if "denote"
18485 * is not NULL or returns -1 otherwise.
18486 */
18487 static long
18490 {
18494 }
18496 long
18500 {
18504 {
18507 #ifdef FEAT_FLOAT
18511 #endif
18529 }
18532 else
18535 }
18537 /*
18538 * Get the lnum from the first argument.
18539 * Also accepts ".", "$", etc., but that only works for the current buffer.
18540 * Returns -1 on error.
18541 */
18542 static linenr_T
18545 {
18546 typval_T rettv;
18547 linenr_T lnum;
18551 {
18556 }
18558 }
18560 /*
18561 * Get the lnum from the first argument.
18562 * Also accepts "$", then "buf" is used.
18563 * Returns 0 on error.
18564 */
18565 static linenr_T
18569 {
18576 }
18578 /*
18579 * Get the string value of a variable.
18580 * If it is a Number variable, the number is converted into a string.
18581 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18582 * get_tv_string_buf() uses a given buffer.
18583 * If the String variable has never been set, return an empty string.
18584 * Never returns NULL;
18585 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18586 * NULL on error.
18587 */
18591 {
18595 }
18601 {
18605 }
18607 char_u *
18610 {
18614 }
18620 {
18622 {
18635 #ifdef FEAT_FLOAT
18639 #endif
18647 }
18649 }
18651 /*
18652 * Find variable "name" in the list of variables.
18653 * Return a pointer to it if found, NULL if not found.
18654 * Careful: "a:0" variables don't have a name.
18655 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18656 * hashtab_T used.
18657 */
18662 {
18672 }
18674 /*
18675 * Find variable "varname" in hashtab "ht".
18676 * Returns NULL if not found.
18677 */
18683 {
18687 {
18688 /* Must be something like "s:", otherwise "ht" would be NULL. */
18690 {
18696 #ifdef FEAT_WINDOWS
18698 #endif
18703 }
18705 }
18709 {
18710 /* For global variables we may try auto-loading the script. If it
18711 * worked find the variable again. Don't auto-load a script if it was
18712 * loaded already, otherwise it would be loaded every time when
18713 * checking if a function name is a Funcref variable. */
18719 }
18721 }
18723 /*
18724 * Find the hashtab used for a variable name.
18725 * Set "varname" to the start of name without ':'.
18726 */
18731 {
18735 {
18736 /* The name must not start with a colon or #. */
18741 /* "version" is "v:version" in all scopes */
18749 }
18753 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18754 */
18762 #ifdef FEAT_WINDOWS
18765 #endif
18776 }
18778 /*
18779 * Get the string value of a (global/local) variable.
18780 * Returns NULL when it doesn't exist.
18781 */
18782 char_u *
18785 {
18792 }
18794 /*
18795 * Allocate a new hashtab for a sourced script. It will be used while
18796 * sourcing this script and when executing functions defined in the script.
18797 */
18798 void
18800 scid_T id;
18801 {
18807 {
18808 /* Re-allocating ga_data means that an ht_array pointing to
18809 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18810 * at its init value. Also reset "v_dict", it's always the same. */
18812 {
18818 }
18821 {
18825 }
18826 }
18827 }
18829 /*
18830 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18831 * point to it.
18832 */
18833 void
18837 {
18845 }
18847 /*
18848 * Clean up a list of internal variables.
18849 * Frees all allocated variables and the value they contain.
18850 * Clears hashtab "ht", does not free it.
18851 */
18852 void
18855 {
18857 }
18859 /*
18860 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18861 */
18862 static void
18866 {
18874 {
18876 {
18879 /* Free the variable. Don't remove it from the hashtab,
18880 * ht_array might change then. hash_clear() takes care of it
18881 * later. */
18887 }
18888 }
18891 }
18893 /*
18894 * Delete a variable from hashtab "ht" at item "hi".
18895 * Clear the variable value and free the dictitem.
18896 */
18897 static void
18901 {
18907 }
18909 /*
18910 * List the value of one internal variable.
18911 */
18912 static void
18917 {
18926 }
18928 static void
18935 {
18936 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18948 {
18952 }
18954 {
18958 }
18959 else
18967 {
18970 }
18971 }
18973 /*
18974 * Set variable "name" to value in "tv".
18975 * If the variable already exists, the value is updated.
18976 * Otherwise the variable is created.
18977 */
18978 static void
18983 {
18990 {
18994 {
18997 }
18999 {
19001 name);
19003 }
19004 }
19008 {
19011 }
19015 {
19016 /* existing variable, need to clear the value */
19025 #ifdef FEAT_FLOAT
19030 #endif
19031 )
19032 {
19035 }
19037 /*
19038 * Handle setting internal v: variables separately: we don't change
19039 * the type.
19040 */
19042 {
19044 {
19048 else
19049 {
19050 /* Take over the string to avoid an extra alloc/free. */
19053 }
19054 }
19057 else
19058 {
19062 }
19064 }
19067 }
19069 {
19070 /* Can't add "v:" variable. */
19072 {
19075 }
19077 /* Make sure the variable name is valid. */
19081 {
19084 }
19092 {
19095 }
19097 }
19101 else
19102 {
19106 }
19107 }
19109 /*
19110 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19111 * Also give an error message.
19112 */
19113 static int
19117 {
19119 {
19122 }
19124 {
19127 }
19129 }
19131 /*
19132 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19133 * Also give an error message.
19134 */
19135 static int
19139 {
19141 {
19144 }
19146 }
19148 /*
19149 * Return TRUE if typeval "tv" is set to be locked (immutable).
19150 * Also give an error message, using "name".
19151 */
19152 static int
19156 {
19158 {
19162 }
19164 {
19168 }
19170 }
19172 /*
19173 * Copy the values from typval_T "from" to typval_T "to".
19174 * When needed allocates string or increases reference count.
19175 * Does not make a copy of a list or dict but copies the reference!
19176 */
19177 static void
19181 {
19185 {
19189 #ifdef FEAT_FLOAT
19193 #endif
19198 else
19199 {
19203 }
19208 else
19209 {
19212 }
19217 else
19218 {
19221 }
19226 }
19227 }
19229 /*
19230 * Make a copy of an item.
19231 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19232 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19233 * reference to an already copied list/dict can be used.
19234 * Returns FAIL or OK.
19235 */
19236 static int
19242 {
19247 {
19250 }
19254 {
19256 #ifdef FEAT_FLOAT
19258 #endif
19269 {
19270 /* use the copy made earlier */
19273 }
19274 else
19285 {
19286 /* use the copy made earlier */
19289 }
19290 else
19298 }
19301 }
19303 /*
19304 * ":echo expr1 ..." print each argument separated with a space, add a
19305 * newline at the end.
19306 * ":echon expr1 ..." print each argument plain.
19307 */
19308 void
19311 {
19313 typval_T rettv;
19323 {
19324 /* If eval1() causes an error message the text from the command may
19325 * still need to be cleared. E.g., "echo 22,44". */
19330 {
19331 /*
19332 * Report the invalid expression unless the expression evaluation
19333 * has been cancelled due to an aborting error, an interrupt, or an
19334 * exception.
19335 */
19340 }
19344 {
19346 {
19348 /* Call msg_start() after eval1(), evaluating the expression
19349 * may cause a message to appear. */
19352 }
19358 {
19360 {
19362 {
19363 /* remove any text still there from the command */
19366 }
19368 }
19369 else
19370 {
19371 #ifdef FEAT_MBYTE
19373 {
19378 }
19379 else
19380 #endif
19382 }
19383 }
19385 }
19388 }
19393 else
19394 {
19395 /* remove text that may still be there from the command */
19400 }
19401 }
19403 /*
19404 * ":echohl {name}".
19405 */
19406 void
19409 {
19415 else
19417 }
19419 /*
19420 * ":execute expr1 ..." execute the result of an expression.
19421 * ":echomsg expr1 ..." Print a message
19422 * ":echoerr expr1 ..." Print an error
19423 * Each gets spaces around each argument and a newline at the end for
19424 * echo commands
19425 */
19426 void
19429 {
19431 typval_T rettv;
19434 garray_T ga;
19443 {
19446 {
19447 /*
19448 * Report the invalid expression unless the expression evaluation
19449 * has been cancelled due to an aborting error, an interrupt, or an
19450 * exception.
19451 */
19456 }
19459 {
19463 {
19467 }
19472 }
19476 }
19479 {
19481 {
19484 }
19486 {
19487 /* We don't want to abort following commands, restore did_emsg. */
19492 }
19496 }
19504 }
19506 /*
19507 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19508 * "arg" points to the "&" or '+' when called, to "option" when returning.
19509 * Returns NULL when no option name found. Otherwise pointer to the char
19510 * after the option name.
19511 */
19516 {
19521 {
19524 }
19526 {
19529 }
19530 else
19539 else
19543 }
19545 /*
19546 * ":function"
19547 */
19548 void
19551 {
19560 garray_T newargs;
19561 garray_T newlines;
19570 funcdict_T fudi;
19578 /*
19579 * ":function" without argument: list functions.
19580 */
19582 {
19584 {
19587 {
19589 {
19594 }
19595 }
19596 }
19599 }
19601 /*
19602 * ":function /pat": list functions matching pattern.
19603 */
19605 {
19608 {
19609 regmatch_T regmatch;
19616 {
19621 {
19623 {
19629 }
19630 }
19631 }
19632 }
19637 }
19639 /*
19640 * Get the function name. There are these situations:
19641 * func normal function name
19642 * "name" == func, "fudi.fd_dict" == NULL
19643 * dict.func new dictionary entry
19644 * "name" == NULL, "fudi.fd_dict" set,
19645 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19646 * dict.func existing dict entry with a Funcref
19647 * "name" == func, "fudi.fd_dict" set,
19648 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19649 * dict.func existing dict entry that's not a Funcref
19650 * "name" == NULL, "fudi.fd_dict" set,
19651 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19652 */
19657 {
19658 /*
19659 * Return on an invalid expression in braces, unless the expression
19660 * evaluation has been cancelled due to an aborting error, an
19661 * interrupt, or an exception.
19662 */
19664 {
19669 }
19670 else
19672 }
19674 /* An error in a function call during evaluation of an expression in magic
19675 * braces should not cause the function not to be defined. */
19679 /*
19680 * ":function func" with only function name: list function.
19681 */
19683 {
19685 {
19688 }
19693 {
19696 {
19699 {
19711 }
19713 {
19716 }
19717 }
19718 else
19720 }
19722 }
19724 /*
19725 * ":function name(arg1, arg2)" Define function.
19726 */
19729 {
19731 {
19734 }
19735 /* attempt to continue by skipping some text */
19738 }
19745 {
19746 /* Check the name of the function. Unless it's a dictionary function
19747 * (that we are overwriting). */
19750 else
19754 {
19757 else
19764 }
19765 }
19767 /*
19768 * Isolate the arguments: "arg1, arg2, ...)"
19769 */
19771 {
19773 {
19777 }
19778 else
19779 {
19786 {
19790 }
19803 else
19805 }
19808 {
19812 }
19813 }
19816 /* find extra arguments "range", "dict" and "abort" */
19818 {
19821 {
19824 }
19826 {
19829 }
19831 {
19834 }
19835 else
19837 }
19839 /* When there is a line break use what follows for the function body.
19840 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19846 /*
19847 * Read the body of the function, until ":endfunction" is found.
19848 */
19850 {
19851 /* Check if the function already exists, don't let the user type the
19852 * whole function before telling him it doesn't work! For a script we
19853 * need to skip the body to be able to find what follows. */
19855 {
19860 }
19867 }
19872 {
19878 {
19879 /* Use eap->arg, split up in parts by line breaks. */
19884 else
19885 {
19888 }
19889 }
19892 else
19897 {
19900 }
19902 /* Detect line continuation: sourcing_lnum increased more than one. */
19905 else
19909 {
19910 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19911 * don't check for ":endfunc". */
19913 {
19916 }
19917 }
19918 else
19919 {
19920 /* skip ':' and blanks*/
19922 ;
19924 /* Check for "endfunction". */
19926 {
19930 }
19932 /* Increase indent inside "if", "while", "for" and "try", decrease
19933 * at "end". */
19942 /* Check for defining a function inside this function. */
19944 {
19949 {
19952 {
19955 }
19956 }
19957 }
19959 /* Check for ":append" or ":insert". */
19967 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
19980 ))
19981 {
19982 /* ":python <<" continues until a dot, like ":append" */
19986 else
19988 }
19989 }
19991 /* Add the line to the function. */
19993 {
19997 }
19999 /* Copy the line to newly allocated memory. get_one_sourceline()
20000 * allocates 250 bytes per line, this saves 80% on average. The cost
20001 * is an extra alloc/free. */
20004 {
20008 }
20012 /* Add NULL lines for continuation lines, so that the line count is
20013 * equal to the index in the growarray. */
20017 /* Check for end of eap->arg. */
20020 }
20022 /* Don't define the function when skipping commands or when an error was
20023 * detected. */
20027 /*
20028 * If there are no errors, add the function
20029 */
20031 {
20034 {
20036 name);
20038 }
20042 {
20044 {
20047 }
20049 {
20051 name);
20053 }
20054 /* redefine existing function */
20059 }
20060 }
20061 else
20062 {
20067 {
20070 }
20072 {
20073 /* Can't add a function to a locked dictionary */
20076 }
20077 /* Can't change an existing function if it is locked */
20081 /* Give the function a sequential number. Can only be used with a
20082 * Funcref! */
20088 }
20091 {
20093 {
20097 /* Check that the autoload name matches the script name. */
20100 {
20103 {
20111 }
20112 }
20114 {
20117 }
20118 }
20125 {
20127 {
20128 /* add new dict entry */
20131 {
20134 }
20136 {
20140 }
20141 }
20142 else
20143 /* overwrite existing dict entry */
20150 /* behave like "dict" was used */
20152 }
20154 /* insert the new function in the function list */
20157 }
20160 #ifdef FEAT_PROFILE
20167 #endif
20174 erret:
20177 ret_free:
20182 }
20184 /*
20185 * Get a function name, translating "<SID>" and "<SNR>".
20186 * Also handles a Funcref in a List or Dictionary.
20187 * Returns the function name in allocated memory, or NULL for failure.
20188 * flags:
20189 * TFN_INT: internal function name OK
20190 * TFN_QUIET: be quiet
20191 * Advances "pp" to just after the function name (if no error).
20192 */
20199 {
20206 lval_T lv;
20212 /* Check for hard coded <SNR>: already translated function ID (from a user
20213 * command). */
20216 {
20220 }
20222 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20223 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20231 {
20235 }
20237 {
20238 /*
20239 * Report an invalid expression in braces, unless the expression
20240 * evaluation has been cancelled due to an aborting error, an
20241 * interrupt, or an exception.
20242 */
20244 {
20247 }
20248 else
20251 }
20254 {
20256 {
20261 }
20263 {
20266 }
20267 else
20268 {
20272 else
20275 }
20277 }
20280 {
20281 /* Error found, but continue after the function name. */
20284 }
20286 /* Check if the name is a Funcref. If so, use the value. */
20288 {
20293 }
20294 else
20295 {
20300 }
20302 {
20306 }
20309 {
20313 {
20314 /* When there was "s:" already or the name expanded to get a
20315 * leading "s:" then remove it. */
20319 }
20320 }
20321 else
20322 {
20326 }
20328 /*
20329 * Copy the function name to allocated memory.
20330 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20331 * Accept <SNR>123_name() outside a script.
20332 */
20336 {
20340 {
20341 /* It's "s:" or "<SID>" */
20343 {
20346 }
20349 }
20350 }
20352 {
20355 }
20358 {
20360 {
20366 }
20369 }
20372 theend:
20375 }
20377 /*
20378 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20379 * Return 2 if "p" starts with "s:".
20380 * Return 0 otherwise.
20381 */
20382 static int
20385 {
20392 }
20394 /*
20395 * Return TRUE if "p" starts with "<SID>" or "s:".
20396 * Only works if eval_fname_script() returned non-zero for "p"!
20397 */
20398 static int
20401 {
20403 }
20405 /*
20406 * List the head of the function: "name(arg1, arg2)".
20407 */
20408 static void
20412 {
20420 {
20423 }
20424 else
20428 {
20432 }
20434 {
20438 }
20443 }
20445 /*
20446 * Find a function by name, return pointer to it in ufuncs.
20447 * Return NULL for unknown function.
20448 */
20452 {
20459 }
20461 #if defined(EXITFREE) || defined(PROTO)
20462 void
20464 {
20467 /* Need to start all over every time, because func_free() may change the
20468 * hash table. */
20472 {
20475 }
20476 }
20477 #endif
20479 /*
20480 * Return TRUE if a function "name" exists.
20481 */
20482 static int
20485 {
20493 /* Only accept "funcname", "funcname ", "funcname (..." and
20494 * "funcname(...", not "funcname!...". */
20496 {
20499 else
20501 }
20504 }
20506 /*
20507 * Return TRUE if "name" looks like a builtin function name: starts with a
20508 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20509 */
20510 static int
20513 {
20516 }
20518 #if defined(FEAT_PROFILE) || defined(PROTO)
20519 /*
20520 * Start profiling function "fp".
20521 */
20522 static void
20525 {
20544 }
20546 /*
20547 * Dump the profiling results for all functions in file "fd".
20548 */
20549 void
20552 {
20564 {
20566 {
20570 {
20576 else
20580 else
20588 {
20594 }
20596 }
20597 }
20598 }
20601 {
20603 prof_total_cmp);
20606 prof_self_cmp);
20608 }
20609 }
20611 static void
20618 {
20625 {
20628 prefer_self);
20631 else
20633 }
20635 }
20637 /*
20638 * Print the count and times for one function or function line.
20639 */
20640 static void
20647 {
20649 {
20653 else
20657 else
20659 }
20660 else
20662 }
20664 /*
20665 * Compare function for total time sorting.
20666 */
20667 static int
20668 #ifdef __BORLANDC__
20669 _RTLENTRYF
20670 #endif
20674 {
20680 }
20682 /*
20683 * Compare function for self time sorting.
20684 */
20685 static int
20686 #ifdef __BORLANDC__
20687 _RTLENTRYF
20688 #endif
20692 {
20698 }
20700 #endif
20702 /*
20703 * If "name" has a package name try autoloading the script for it.
20704 * Return TRUE if a package was loaded.
20705 */
20706 static int
20710 {
20716 /* If there is no '#' after name[0] there is no package name. */
20723 /* Find the name in the list of previously loaded package names. Skip
20724 * "autoload/", it's always the same. */
20730 else
20731 {
20732 /* Remember the name if it wasn't loaded already. */
20734 {
20737 }
20739 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20742 }
20746 }
20748 /*
20749 * Return the autoload script name for a function or variable name.
20750 * Returns NULL when out of memory.
20751 */
20755 {
20759 /* Get the script file name: replace '#' with '/', append ".vim". */
20770 }
20772 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20774 /*
20775 * Function given to ExpandGeneric() to obtain the list of user defined
20776 * function names.
20777 */
20778 char_u *
20782 {
20788 {
20791 }
20793 {
20805 {
20809 }
20811 }
20813 }
20817 /*
20818 * Copy the function name of "fp" to buffer "buf".
20819 * "buf" must be able to hold the function name plus three bytes.
20820 * Takes care of script-local function names.
20821 */
20822 static void
20826 {
20828 {
20831 }
20832 else
20834 }
20836 /*
20837 * ":delfunction {name}"
20838 */
20839 void
20842 {
20846 funcdict_T fudi;
20852 {
20856 }
20858 {
20862 }
20872 {
20874 {
20877 }
20879 {
20882 }
20885 {
20886 /* Delete the dict item that refers to the function, it will
20887 * invoke func_unref() and possibly delete the function. */
20889 }
20890 else
20892 }
20893 }
20895 /*
20896 * Free a function and remove it from the list of functions.
20897 */
20898 static void
20901 {
20904 /* clear this function */
20907 #ifdef FEAT_PROFILE
20911 #endif
20913 /* remove the function from the function hashtable */
20917 else
20921 }
20923 /*
20924 * Unreference a Function: decrement the reference count and free it when it
20925 * becomes zero. Only for numbered functions.
20926 */
20927 static void
20930 {
20934 {
20939 {
20940 /* Only delete it when it's not being used. Otherwise it's done
20941 * when "uf_calls" becomes zero. */
20944 }
20945 }
20946 }
20948 /*
20949 * Count a reference to a Function.
20950 */
20951 static void
20954 {
20958 {
20962 else
20964 }
20965 }
20967 /*
20968 * Call a user function.
20969 */
20970 static void
20979 {
20981 linenr_T save_sourcing_lnum;
20982 scid_T save_current_SID;
20983 funccall_T fc;
20992 #ifdef FEAT_PROFILE
20993 proftime_T wait_start;
20994 proftime_T call_start;
20995 #endif
20997 /* If depth of calling is getting too high, don't execute the function */
20999 {
21004 }
21017 /* Check if this function has a breakpoint. */
21021 /*
21022 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21023 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21024 * each argument variable and saves a lot of time.
21025 */
21026 /*
21027 * Init l: variables.
21028 */
21031 {
21032 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21033 * some compiler that checks the destination size. */
21043 }
21045 /*
21046 * Init a: variables.
21047 * Set a:0 to "argcount".
21048 * Set a:000 to a list with room for the "..." arguments.
21049 */
21064 /*
21065 * Set a:firstline to "firstline" and a:lastline to "lastline".
21066 * Set a:name to named arguments.
21067 * Set a:N to the "..." arguments.
21068 */
21074 {
21077 /* named argument a:name */
21079 else
21080 {
21081 /* "..." argument a:1, a:2, etc. */
21084 }
21086 {
21089 }
21090 else
21091 {
21097 }
21101 /* Note: the values are copied directly to avoid alloc/free.
21102 * "argvars" must have VAR_FIXED for v_lock. */
21107 {
21111 }
21112 }
21114 /* Don't redraw while executing the function. */
21122 {
21126 else
21131 {
21137 {
21145 {
21150 else
21151 {
21154 {
21158 }
21159 }
21160 }
21162 }
21167 }
21168 }
21169 #ifdef FEAT_PROFILE
21171 {
21176 {
21180 }
21182 }
21183 #endif
21190 /* call do_cmdline() to execute the lines */
21196 /* when the function was aborted because of an error, return -1 */
21198 {
21202 }
21204 #ifdef FEAT_PROFILE
21207 {
21213 {
21216 }
21217 }
21218 #endif
21220 /* when being verbose, mention the return value */
21222 {
21231 else
21232 {
21238 /* The value may be very long. Skip the middle part, so that we
21239 * have some idea how it starts and ends. smsg() would always
21240 * truncate it at the end. */
21243 {
21247 }
21248 }
21253 }
21259 #ifdef FEAT_PROFILE
21262 #endif
21265 {
21274 }
21279 /* The a: variables typevals were not allocated, only free the allocated
21280 * variables. */
21285 }
21287 /*
21288 * Add a number variable "name" to dict "dp" with value "nr".
21289 */
21290 static void
21295 varnumber_T nr;
21296 {
21303 }
21305 /*
21306 * ":return [expr]"
21307 */
21308 void
21311 {
21313 typval_T rettv;
21317 {
21320 }
21328 {
21331 else
21333 }
21334 /* It's safer to return also on error. */
21336 {
21337 /*
21338 * Return unless the expression evaluation has been cancelled due to an
21339 * aborting error, an interrupt, or an exception.
21340 */
21343 }
21345 /* When skipping or the return gets pending, advance to the next command
21346 * in this line (!returning). Otherwise, ignore the rest of the line.
21347 * Following lines will be ignored by get_func_line(). */
21355 }
21357 /*
21358 * Return from a function. Possibly makes the return pending. Also called
21359 * for a pending return at the ":endtry" or after returning from an extra
21360 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21361 * when called due to a ":return" command. "rettv" may point to a typval_T
21362 * with the return rettv. Returns TRUE when the return can be carried out,
21363 * FALSE when the return gets pending.
21364 */
21365 int
21371 {
21376 /* Undo the return. */
21379 /*
21380 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21381 * not in its finally clause (which then is to be executed next) is found.
21382 * In this case, make the ":return" pending for execution at the ":endtry".
21383 * Otherwise, return normally.
21384 */
21387 {
21391 /* A pending return again gets pending. "rettv" points to an
21392 * allocated variable with the rettv of the original ":return"'s
21393 * argument if present or is NULL else. */
21395 else
21396 {
21397 /* When undoing a return in order to make it pending, get the stored
21398 * return rettv. */
21403 {
21404 /* Store the value of the pending return. */
21407 else
21409 }
21410 else
21414 {
21415 /* The pending return value could be overwritten by a ":return"
21416 * without argument in a finally clause; reset the default
21417 * return value. */
21420 }
21421 }
21423 }
21424 else
21425 {
21428 /* If the return is carried out now, store the return value. For
21429 * a return immediately after reanimation, the value is already
21430 * there. */
21432 {
21437 }
21438 }
21441 }
21443 /*
21444 * Free the variable with a pending return value.
21445 */
21446 void
21449 {
21451 }
21453 /*
21454 * Generate a return command for producing the value of "rettv". The result
21455 * is an allocated string. Used by report_pending() for verbose messages.
21456 */
21457 char_u *
21460 {
21476 }
21478 /*
21479 * Get next function line.
21480 * Called by do_cmdline() to get the next line.
21481 * Returns allocated string, or NULL for end of function.
21482 */
21483 /* ARGSUSED */
21484 char_u *
21489 {
21495 /* If breakpoints have been added/deleted need to check for it. */
21497 {
21499 sourcing_lnum);
21501 }
21502 #ifdef FEAT_PROFILE
21505 #endif
21511 else
21512 {
21513 /* Skip NULL lines (continuation lines). */
21519 else
21520 {
21523 #ifdef FEAT_PROFILE
21526 #endif
21527 }
21528 }
21530 /* Did we encounter a breakpoint? */
21532 {
21534 /* Find next breakpoint. */
21536 sourcing_lnum);
21538 }
21541 }
21543 #if defined(FEAT_PROFILE) || defined(PROTO)
21544 /*
21545 * Called when starting to read a function line.
21546 * "sourcing_lnum" must be correct!
21547 * When skipping lines it may not actually be executed, but we won't find out
21548 * until later and we need to store the time now.
21549 */
21550 void
21553 {
21559 {
21561 /* Skip continuation lines. */
21568 }
21569 }
21571 /*
21572 * Called when actually executing a function line.
21573 */
21574 void
21577 {
21583 }
21585 /*
21586 * Called when done with a function line.
21587 */
21588 void
21591 {
21596 {
21598 {
21605 }
21607 }
21608 }
21609 #endif
21611 /*
21612 * Return TRUE if the currently active function should be ended, because a
21613 * return was encountered or an error occurred. Used inside a ":while".
21614 */
21615 int
21618 {
21621 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21622 * an error inside a try conditional. */
21625 }
21627 /*
21628 * return TRUE if cookie indicates a function which "abort"s on errors.
21629 */
21630 int
21633 {
21635 }
21637 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21639 {
21642 VAR_FLAVOUR_VIMINFO /* all uppercase */
21647 static var_flavour_T
21650 {
21654 {
21659 }
21660 else
21662 }
21663 #endif
21665 #if defined(FEAT_VIMINFO) || defined(PROTO)
21666 /*
21667 * Restore global vars that start with a capital from the viminfo file
21668 */
21669 int
21673 {
21676 typval_T tv;
21679 {
21682 {
21686 #ifdef FEAT_FLOAT
21689 #endif
21693 {
21698 #ifdef FEAT_FLOAT
21701 #endif
21702 else
21707 }
21708 }
21709 }
21712 }
21714 /*
21715 * Write global vars that start with a capital to the viminfo file
21716 */
21717 void
21720 {
21736 {
21738 {
21742 {
21744 {
21747 #ifdef FEAT_FLOAT
21749 #endif
21751 }
21757 }
21758 }
21759 }
21760 }
21761 #endif
21763 #if defined(FEAT_SESSION) || defined(PROTO)
21764 int
21767 {
21775 {
21777 {
21783 {
21784 /* Escape special characters with a backslash. Turn a LF and
21785 * CR into \n and \r. */
21799 p,
21803 {
21806 }
21808 }
21809 #ifdef FEAT_FLOAT
21812 {
21817 {
21820 }
21825 }
21826 #endif
21827 }
21828 }
21830 }
21831 #endif
21833 /*
21834 * Display script name where an item was last set.
21835 * Should only be invoked when 'verbose' is non-zero.
21836 */
21837 void
21839 scid_T scriptID;
21840 {
21844 {
21847 {
21853 }
21854 }
21855 }
21860 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21862 #ifdef WIN3264
21863 /*
21864 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21865 */
21867 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21870 /*
21871 * Get the short path (8.3) for the filename in "fnamep".
21872 * Only works for a valid file name.
21873 * When the path gets longer "fnamep" is changed and the allocated buffer
21874 * is put in "bufp".
21875 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21876 * Returns OK on success, FAIL on failure.
21877 */
21878 static int
21883 {
21890 {
21891 /* If that doesn't work (not enough space), then save the string
21892 * and try again with a new buffer big enough. */
21900 /* Really should always succeed, as the buffer is big enough. */
21902 }
21906 }
21908 /*
21909 * Get the short path (8.3) for the filename in "fname". The converted
21910 * path is returned in "bufp".
21911 *
21912 * Some of the directories specified in "fname" may not exist. This function
21913 * will shorten the existing directories at the beginning of the path and then
21914 * append the remaining non-existing path.
21915 *
21916 * fname - Pointer to the filename to shorten. On return, contains the
21917 * pointer to the shortened pathname
21918 * bufp - Pointer to an allocated buffer for the filename.
21919 * fnamelen - Length of the filename pointed to by fname
21920 *
21921 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21922 */
21923 static int
21928 {
21931 char_u ch;
21936 /* Make a copy */
21945 /*
21946 * Try shortening the supplied path till it succeeds by removing one
21947 * directory at a time from the tail of the path.
21948 */
21951 {
21952 /* go back one path-separator */
21958 /*
21959 * Replace the path separator with a NUL and try to shorten the
21960 * resulting path.
21961 */
21967 {
21970 }
21976 /* failed to shorten the path. Skip the path separator */
21978 }
21981 {
21982 /*
21983 * Succeeded in shortening the path. Now concatenate the shortened
21984 * path with the remaining path at the tail.
21985 */
21987 /* Compute the length of the new path. */
21994 {
21995 /* There is not enough space in the currently allocated string,
21996 * copy it to a buffer big enough. */
21999 {
22002 }
22003 }
22004 else
22005 {
22006 /* Transfer short_fname to the main buffer (it's big enough),
22007 * unless get_short_pathname() did its work in-place. */
22012 }
22014 /* concat the not-shortened part of the path */
22017 }
22019 theend:
22024 }
22026 /*
22027 * Get a pathname for a partial path.
22028 * Returns OK for success, FAIL for failure.
22029 */
22030 static int
22035 {
22041 /* Count up the path separators from the RHS.. so we know which part
22042 * of the path to return. */
22048 /* Need full path first (use expand_env() to remove a "~/") */
22052 else
22061 {
22062 /* Don't have a valid filename, so shorten the rest of the
22063 * path if we can. This CAN give us invalid 8.3 filenames, but
22064 * there's not a lot of point in guessing what it might be.
22065 */
22069 }
22071 /* Count the paths backward to find the beginning of the desired string. */
22073 {
22074 #ifdef FEAT_MBYTE
22077 #endif
22079 {
22082 else
22083 sepcount --;
22084 }
22085 }
22087 {
22091 else
22093 }
22094 else
22097 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22104 }
22107 /*
22108 * Adjust a filename, according to a string of modifiers.
22109 * *fnamep must be NUL terminated when called. When returning, the length is
22110 * determined by *fnamelen.
22111 * Returns VALID_ flags or -1 for failure.
22112 * When there is an error, *fnamep is set to NULL.
22113 */
22114 int
22121 {
22128 #ifdef WIN3264
22130 #endif
22132 repeat:
22133 /* ":p" - full path/file_name */
22135 {
22141 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22143 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22145 # ifdef BACKSLASH_IN_FILENAME
22147 # endif
22150 #endif
22151 )
22152 {
22158 }
22160 /* When "/." or "/.." is used: force expansion to get rid of it. */
22162 {
22170 }
22172 /* FullName_save() is slow, don't use it when not needed. */
22174 {
22180 }
22182 /* Append a path separator to a directory. */
22184 {
22185 /* Make room for one or two extra characters. */
22192 }
22193 }
22195 /* ":." - path relative to the current directory */
22196 /* ":~" - path relative to the home directory */
22197 /* ":8" - shortname path - postponed till after */
22200 {
22203 {
22204 #ifdef WIN3264
22206 #endif
22208 }
22210 /* Need full path first (use expand_env() to remove a "~/") */
22212 {
22215 else
22217 }
22218 else
22224 {
22226 {
22230 {
22233 {
22237 }
22238 }
22239 }
22240 else
22241 {
22243 /* Only replace it when it starts with '~' */
22245 {
22248 {
22252 }
22253 }
22254 }
22256 }
22257 }
22262 /* ":h" - head, remove "/file_name", can be repeated */
22263 /* Don't remove the first "/" or "c:\" */
22265 {
22272 #ifdef VMS
22275 #endif
22277 {
22278 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22285 }
22286 else
22287 {
22290 }
22291 }
22293 /* ":8" - shortname */
22295 {
22297 #ifdef WIN3264
22299 #endif
22300 }
22302 #ifdef WIN3264
22303 /* Check shortname after we have done 'heads' and before we do 'tails'
22304 */
22306 {
22308 /* Copy the string if it is shortened by :h */
22310 {
22316 }
22318 /* Split into two implementations - makes it easier. First is where
22319 * there isn't a full name already, second is where there is.
22320 */
22322 {
22325 }
22326 else
22327 {
22330 /* Simple case, already have the full-name
22331 * Nearly always shorter, so try first time. */
22337 {
22338 /* Couldn't find the filename.. search the paths.
22339 */
22343 }
22345 }
22346 }
22349 /* ":t" - tail, just the basename */
22351 {
22355 }
22357 /* ":e" - extension, can be repeated */
22358 /* ":r" - root, without extension, can be repeated */
22361 {
22362 /* find a '.' in the tail:
22363 * - for second :e: before the current fname
22364 * - otherwise: The last '.'
22365 */
22368 else
22374 {
22376 {
22379 #ifdef VMS
22380 /* cut version from the extension */
22387 #endif
22388 }
22391 }
22393 {
22396 }
22398 }
22400 /* ":s?pat?foo?" - substitute */
22401 /* ":gs?pat?foo?" - global substitute */
22405 {
22416 {
22419 }
22423 {
22424 /* find end of pattern */
22427 {
22430 {
22432 /* find end of substitution */
22435 {
22439 {
22443 {
22449 }
22450 }
22453 }
22455 }
22456 }
22457 /* after using ":s", repeat all the modifiers */
22460 }
22461 }
22464 }
22466 /*
22467 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22468 * "flags" can be "g" to do a global substitute.
22469 * Returns an allocated string, NULL for error.
22470 */
22471 char_u *
22477 {
22479 regmatch_T regmatch;
22483 garray_T ga;
22487 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22498 {
22501 {
22502 /*
22503 * Get some space for a temporary buffer to do the substitution
22504 * into. It will contain:
22505 * - The text up to where the match is.
22506 * - The substituted text.
22507 * - The text after the match.
22508 */
22512 {
22515 }
22517 /* copy the text up to where the match is */
22520 /* add the substituted text */
22524 /* avoid getting stuck on a match with an empty string */
22526 {
22531 }
22532 else
22533 {
22537 }
22540 }
22546 }
22553 }