| blob | 3cb64c0063d1eb1b246914f0a8f389544834bf6f |
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) || defined(FEAT_GUI_MACVIM)
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_FULLSCREEN
11452 #endif
11453 #ifdef FEAT_GETTEXT
11455 #endif
11456 #ifdef FEAT_GUI
11458 #endif
11459 #ifdef FEAT_GUI_ATHENA
11460 # ifdef FEAT_GUI_NEXTAW
11462 # else
11464 # endif
11465 #endif
11466 #ifdef FEAT_GUI_GTK
11468 # ifdef HAVE_GTK2
11470 # endif
11471 #endif
11472 #ifdef FEAT_GUI_GNOME
11474 #endif
11475 #ifdef FEAT_GUI_MAC
11477 #endif
11478 #ifdef FEAT_GUI_MACVIM
11480 #endif
11481 #ifdef FEAT_GUI_MOTIF
11483 #endif
11484 #ifdef FEAT_GUI_PHOTON
11486 #endif
11487 #ifdef FEAT_GUI_W16
11489 #endif
11490 #ifdef FEAT_GUI_W32
11492 #endif
11493 #ifdef FEAT_HANGULIN
11495 #endif
11496 #if defined(HAVE_ICONV_H) && defined(USE_ICONV)
11498 #endif
11499 #ifdef FEAT_INS_EXPAND
11501 #endif
11502 #ifdef FEAT_JUMPLIST
11504 #endif
11505 #ifdef FEAT_KEYMAP
11507 #endif
11508 #ifdef FEAT_LANGMAP
11510 #endif
11511 #ifdef FEAT_LIBCALL
11513 #endif
11514 #ifdef FEAT_LINEBREAK
11516 #endif
11517 #ifdef FEAT_LISP
11519 #endif
11520 #ifdef FEAT_LISTCMDS
11522 #endif
11523 #ifdef FEAT_LOCALMAP
11525 #endif
11526 #ifdef FEAT_MENU
11528 #endif
11529 #ifdef FEAT_SESSION
11531 #endif
11532 #ifdef FEAT_MODIFY_FNAME
11534 #endif
11535 #ifdef FEAT_MOUSE
11537 #endif
11538 #ifdef FEAT_MOUSESHAPE
11540 #endif
11541 #if defined(UNIX) || defined(VMS)
11542 # ifdef FEAT_MOUSE_DEC
11544 # endif
11545 # ifdef FEAT_MOUSE_GPM
11547 # endif
11548 # ifdef FEAT_MOUSE_JSB
11550 # endif
11551 # ifdef FEAT_MOUSE_NET
11553 # endif
11554 # ifdef FEAT_MOUSE_PTERM
11556 # endif
11557 # ifdef FEAT_SYSMOUSE
11559 # endif
11560 # ifdef FEAT_MOUSE_XTERM
11562 # endif
11563 #endif
11564 #ifdef FEAT_MBYTE
11566 #endif
11567 #ifdef FEAT_MBYTE_IME
11569 #endif
11570 #ifdef FEAT_MULTI_LANG
11572 #endif
11573 #ifdef FEAT_MZSCHEME
11574 #ifndef DYNAMIC_MZSCHEME
11576 #endif
11577 #endif
11578 #ifdef FEAT_OLE
11580 #endif
11581 #ifdef FEAT_OSFILETYPE
11583 #endif
11584 #ifdef FEAT_PATH_EXTRA
11586 #endif
11587 #ifdef FEAT_PERL
11588 #ifndef DYNAMIC_PERL
11590 #endif
11591 #endif
11592 #ifdef FEAT_PYTHON
11593 #ifndef DYNAMIC_PYTHON
11595 #endif
11596 #endif
11597 #ifdef FEAT_POSTSCRIPT
11599 #endif
11600 #ifdef FEAT_PRINTER
11602 #endif
11603 #ifdef FEAT_PROFILE
11605 #endif
11606 #ifdef FEAT_RELTIME
11608 #endif
11609 #ifdef FEAT_QUICKFIX
11611 #endif
11612 #ifdef FEAT_RIGHTLEFT
11614 #endif
11615 #if defined(FEAT_RUBY) && !defined(DYNAMIC_RUBY)
11617 #endif
11618 #ifdef FEAT_SCROLLBIND
11620 #endif
11621 #ifdef FEAT_CMDL_INFO
11624 #endif
11625 #ifdef FEAT_SIGNS
11627 #endif
11628 #ifdef FEAT_SMARTINDENT
11630 #endif
11631 #ifdef FEAT_SNIFF
11633 #endif
11634 #ifdef FEAT_STL_OPT
11636 #endif
11637 #ifdef FEAT_SUN_WORKSHOP
11639 #endif
11640 #ifdef FEAT_NETBEANS_INTG
11642 #endif
11643 #ifdef FEAT_ODB_EDITOR
11645 #endif
11646 #ifdef FEAT_SPELL
11648 #endif
11649 #ifdef FEAT_SYN_HL
11651 #endif
11652 #if defined(USE_SYSTEM) || !defined(UNIX)
11654 #endif
11655 #ifdef FEAT_TAG_BINS
11657 #endif
11658 #ifdef FEAT_TAG_OLDSTATIC
11660 #endif
11661 #ifdef FEAT_TAG_ANYWHITE
11663 #endif
11664 #ifdef FEAT_TCL
11665 # ifndef DYNAMIC_TCL
11667 # endif
11668 #endif
11669 #ifdef TERMINFO
11671 #endif
11672 #ifdef FEAT_TERMRESPONSE
11674 #endif
11675 #ifdef FEAT_TEXTOBJ
11677 #endif
11678 #ifdef HAVE_TGETENT
11680 #endif
11681 #ifdef FEAT_TITLE
11683 #endif
11684 #ifdef FEAT_TOOLBAR
11686 #endif
11687 #ifdef FEAT_TRANSPARENCY
11689 #endif
11690 #ifdef FEAT_USR_CMDS
11693 #endif
11694 #ifdef FEAT_VIMINFO
11696 #endif
11697 #ifdef FEAT_VERTSPLIT
11699 #endif
11700 #ifdef FEAT_VIRTUALEDIT
11702 #endif
11703 #ifdef FEAT_VISUAL
11705 #endif
11706 #ifdef FEAT_VISUALEXTRA
11708 #endif
11709 #ifdef FEAT_VREPLACE
11711 #endif
11712 #ifdef FEAT_WILDIGN
11714 #endif
11715 #ifdef FEAT_WILDMENU
11717 #endif
11718 #ifdef FEAT_WINDOWS
11720 #endif
11721 #ifdef FEAT_WAK
11723 #endif
11724 #ifdef FEAT_WRITEBACKUP
11726 #endif
11727 #ifdef FEAT_XIM
11729 #endif
11730 #ifdef FEAT_XFONTSET
11732 #endif
11733 #ifdef USE_XSMP
11735 #endif
11736 #ifdef USE_XSMP_INTERACT
11738 #endif
11739 #ifdef FEAT_XCLIPBOARD
11741 #endif
11742 #ifdef FEAT_XTERM_SAVE
11744 #endif
11745 #if defined(UNIX) && defined(FEAT_X11)
11747 #endif
11748 NULL
11749 };
11754 {
11757 }
11760 {
11765 #if defined(FEAT_BEVAL) && defined(FEAT_GUI_W32)
11768 #endif
11769 #ifdef DYNAMIC_TCL
11772 #endif
11773 #if defined(USE_ICONV) && defined(DYNAMIC_ICONV)
11776 #endif
11777 #ifdef DYNAMIC_MZSCHEME
11780 #endif
11781 #ifdef DYNAMIC_RUBY
11784 #endif
11785 #ifdef DYNAMIC_PYTHON
11788 #endif
11789 #ifdef DYNAMIC_PERL
11792 #endif
11793 #ifdef FEAT_GUI
11796 # ifdef FEAT_GUI_W32
11799 # endif
11800 # ifdef FEAT_BROWSE
11803 # endif
11804 #endif
11805 #ifdef FEAT_SYN_HL
11808 #endif
11809 #if defined(WIN3264)
11812 #endif
11813 #ifdef FEAT_NETBEANS_INTG
11816 #endif
11817 }
11820 }
11822 /*
11823 * "has_key()" function
11824 */
11825 static void
11829 {
11832 {
11835 }
11841 }
11843 /*
11844 * "haslocaldir()" function
11845 */
11846 /*ARGSUSED*/
11847 static void
11851 {
11853 }
11855 /*
11856 * "hasmapto()" function
11857 */
11858 static void
11862 {
11871 else
11872 {
11876 }
11880 else
11882 }
11884 /*
11885 * "histadd()" function
11886 */
11887 /*ARGSUSED*/
11888 static void
11892 {
11893 #ifdef FEAT_CMDHIST
11897 #endif
11902 #ifdef FEAT_CMDHIST
11906 {
11909 {
11913 }
11914 }
11915 #endif
11916 }
11918 /*
11919 * "histdel()" function
11920 */
11921 /*ARGSUSED*/
11922 static void
11926 {
11927 #ifdef FEAT_CMDHIST
11936 /* only one argument: clear entire history */
11939 /* index given: remove that entry */
11942 else
11943 /* string given: remove all matching entries */
11947 #else
11949 #endif
11950 }
11952 /*
11953 * "histget()" function
11954 */
11955 /*ARGSUSED*/
11956 static void
11960 {
11961 #ifdef FEAT_CMDHIST
11969 else
11970 {
11974 else
11976 /* -1 on type error */
11978 }
11979 #else
11981 #endif
11983 }
11985 /*
11986 * "histnr()" function
11987 */
11988 /*ARGSUSED*/
11989 static void
11993 {
11996 #ifdef FEAT_CMDHIST
12002 else
12003 #endif
12006 }
12008 /*
12009 * "highlightID(name)" function
12010 */
12011 static void
12015 {
12017 }
12019 /*
12020 * "highlight_exists()" function
12021 */
12022 static void
12026 {
12028 }
12030 /*
12031 * "hostname()" function
12032 */
12033 /*ARGSUSED*/
12034 static void
12038 {
12044 }
12046 /*
12047 * iconv() function
12048 */
12049 /*ARGSUSED*/
12050 static void
12054 {
12055 #ifdef FEAT_MBYTE
12059 vimconv_T vimconv;
12060 #endif
12065 #ifdef FEAT_MBYTE
12072 /* If the encodings are equal, no conversion needed. */
12075 else
12081 #endif
12082 }
12084 /*
12085 * "indent()" function
12086 */
12087 static void
12091 {
12092 linenr_T lnum;
12097 else
12099 }
12101 /*
12102 * "index()" function
12103 */
12104 static void
12108 {
12116 {
12119 }
12122 {
12125 {
12128 /* Start at specified item. Use the cached index that list_find()
12129 * sets, so that a negative number also works. */
12136 }
12140 {
12143 }
12144 }
12145 }
12151 /*
12152 * This function is used by f_input() and f_inputdialog() functions. The third
12153 * argument to f_input() specifies the type of completion to use at the
12154 * prompt. The third argument to f_inputdialog() specifies the value to return
12155 * when the user cancels the prompt.
12156 */
12157 static void
12162 {
12175 #ifdef NO_CONSOLE_INPUT
12176 /* While starting up, there is no place to enter text. */
12179 #endif
12183 {
12184 /* Only the part of the message after the last NL is considered as
12185 * prompt for the command line */
12189 else
12190 {
12200 }
12204 {
12210 {
12226 }
12227 }
12236 /* since the user typed this, no need to wait for return */
12239 }
12241 }
12243 /*
12244 * "input()" function
12245 * Also handles inputsecret() when inputsecret is set.
12246 */
12247 static void
12251 {
12253 }
12255 /*
12256 * "inputdialog()" function
12257 */
12258 static void
12262 {
12263 #if defined(FEAT_GUI_TEXTDIALOG)
12264 /* Use a GUI dialog if the GUI is running and 'c' is not in 'guioptions' */
12266 {
12275 else
12281 else
12282 {
12288 else
12290 }
12292 }
12293 else
12294 #endif
12296 }
12298 /*
12299 * "inputlist()" function
12300 */
12301 static void
12305 {
12311 #ifdef NO_CONSOLE_INPUT
12312 /* While starting up, there is no place to enter text. */
12315 #endif
12317 {
12320 }
12329 {
12332 }
12334 /* Ask for choice. */
12340 }
12345 /*
12346 * "inputrestore()" function
12347 */
12348 /*ARGSUSED*/
12349 static void
12353 {
12355 {
12360 }
12362 {
12365 }
12366 }
12368 /*
12369 * "inputsave()" function
12370 */
12371 /*ARGSUSED*/
12372 static void
12376 {
12377 /* Add an entry to the stack of typeahead storage. */
12379 {
12384 }
12385 else
12387 }
12389 /*
12390 * "inputsecret()" function
12391 */
12392 static void
12396 {
12402 }
12404 /*
12405 * "insert()" function
12406 */
12407 static void
12411 {
12422 {
12430 else
12431 {
12434 {
12437 }
12438 }
12440 {
12443 }
12444 }
12445 }
12447 /*
12448 * "isdirectory()" function
12449 */
12450 static void
12454 {
12456 }
12458 /*
12459 * "islocked()" function
12460 */
12461 static void
12465 {
12466 lval_T lv;
12472 FNE_CHECK_START);
12474 {
12477 else
12478 {
12480 {
12483 else
12484 {
12487 {
12488 /* Consider a variable locked when:
12489 * 1. the variable itself is locked
12490 * 2. the value of the variable is locked.
12491 * 3. the List or Dict value is locked.
12492 */
12495 }
12496 }
12497 }
12503 /* List item. */
12505 else
12506 /* Dictionary item. */
12508 }
12509 }
12512 }
12516 /*
12517 * Turn a dict into a list:
12518 * "what" == 0: list of keys
12519 * "what" == 1: list of values
12520 * "what" == 2: list of items
12521 */
12522 static void
12527 {
12538 {
12541 }
12550 {
12552 {
12562 {
12563 /* keys() */
12567 }
12569 {
12570 /* values() */
12572 }
12573 else
12574 {
12575 /* items() */
12597 }
12598 }
12599 }
12600 }
12602 /*
12603 * "items(dict)" function
12604 */
12605 static void
12609 {
12611 }
12613 /*
12614 * "join()" function
12615 */
12616 static void
12620 {
12621 garray_T ga;
12626 {
12629 }
12634 else
12640 {
12645 }
12646 else
12648 }
12650 /*
12651 * "keys()" function
12652 */
12653 static void
12657 {
12659 }
12661 /*
12662 * "last_buffer_nr()" function.
12663 */
12664 /*ARGSUSED*/
12665 static void
12669 {
12678 }
12680 /*
12681 * "len()" function
12682 */
12683 static void
12687 {
12689 {
12704 }
12705 }
12709 static void
12714 {
12715 #ifdef FEAT_LIBCALL
12719 #endif
12724 else
12730 #ifdef FEAT_LIBCALL
12731 /* The first two args must be strings, otherwise its meaningless */
12733 {
12739 else
12743 string_in,
12745 string_result,
12749 }
12750 #endif
12751 }
12753 /*
12754 * "libcall()" function
12755 */
12756 static void
12760 {
12762 }
12764 /*
12765 * "libcallnr()" function
12766 */
12767 static void
12771 {
12773 }
12775 /*
12776 * "line(string)" function
12777 */
12778 static void
12782 {
12791 }
12793 /*
12794 * "line2byte(lnum)" function
12795 */
12796 /*ARGSUSED*/
12797 static void
12801 {
12802 #ifndef FEAT_BYTEOFF
12804 #else
12805 linenr_T lnum;
12810 else
12814 #endif
12815 }
12817 /*
12818 * "lispindent(lnum)" function
12819 */
12820 static void
12824 {
12825 #ifdef FEAT_LISP
12826 pos_T pos;
12827 linenr_T lnum;
12832 {
12836 }
12837 else
12838 #endif
12840 }
12842 /*
12843 * "localtime()" function
12844 */
12845 /*ARGSUSED*/
12846 static void
12850 {
12852 }
12856 static void
12861 {
12868 garray_T ga;
12871 /* return empty string for failure */
12880 {
12884 }
12885 else
12896 {
12906 }
12907 }
12909 #ifdef FEAT_FLOAT
12910 /*
12911 * "log10()" function
12912 */
12913 static void
12917 {
12918 float_T f;
12923 else
12925 }
12926 #endif
12928 /*
12929 * "map()" function
12930 */
12931 static void
12935 {
12937 }
12939 /*
12940 * "maparg()" function
12941 */
12942 static void
12946 {
12948 }
12950 /*
12951 * "mapcheck()" function
12952 */
12953 static void
12957 {
12959 }
12963 static void
12968 {
12972 regmatch_T regmatch;
12985 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
12991 {
12992 /* return empty list when there are no matches */
12995 }
12997 {
13000 }
13003 {
13007 }
13008 else
13016 {
13023 {
13028 }
13029 else
13030 {
13035 /* When "count" argument is there ignore matches before "start",
13036 * otherwise skip part of the string. Differs when pattern is "^"
13037 * or "\<". */
13040 else
13042 }
13048 }
13052 {
13056 {
13058 {
13060 {
13063 }
13068 }
13077 /* Advance to just after the match. */
13079 {
13082 }
13083 else
13084 {
13085 #ifdef FEAT_MBYTE
13088 #else
13090 #endif
13091 }
13092 }
13095 {
13097 {
13100 /* return list with matched string and submatches */
13102 {
13104 {
13108 }
13114 }
13115 }
13117 {
13118 /* return matched string */
13121 else
13124 }
13127 else
13128 {
13132 else
13136 }
13137 }
13139 }
13141 theend:
13144 }
13146 /*
13147 * "match()" function
13148 */
13149 static void
13153 {
13155 }
13157 /*
13158 * "matchadd()" function
13159 */
13160 static void
13164 {
13165 #ifdef FEAT_SEARCH_EXTRA
13178 {
13182 }
13186 {
13189 }
13192 #endif
13193 }
13195 /*
13196 * "matcharg()" function
13197 */
13198 static void
13202 {
13204 {
13205 #ifdef FEAT_SEARCH_EXTRA
13210 {
13212 {
13216 }
13217 else
13218 {
13221 }
13222 }
13223 #endif
13224 }
13225 }
13227 /*
13228 * "matchdelete()" function
13229 */
13230 static void
13234 {
13235 #ifdef FEAT_SEARCH_EXTRA
13238 #endif
13239 }
13241 /*
13242 * "matchend()" function
13243 */
13244 static void
13248 {
13250 }
13252 /*
13253 * "matchlist()" function
13254 */
13255 static void
13259 {
13261 }
13263 /*
13264 * "matchstr()" function
13265 */
13266 static void
13270 {
13272 }
13276 static void
13281 {
13287 {
13293 {
13296 {
13299 {
13306 }
13307 }
13308 }
13309 }
13311 {
13319 {
13322 {
13324 {
13328 {
13331 }
13334 }
13335 }
13336 }
13337 }
13338 else
13341 }
13343 /*
13344 * "max()" function
13345 */
13346 static void
13350 {
13352 }
13354 /*
13355 * "min()" function
13356 */
13357 static void
13361 {
13363 }
13367 /*
13368 * Create the directory in which "dir" is located, and higher levels when
13369 * needed.
13370 */
13371 static int
13375 {
13380 /* Get end of directory name in "dir".
13381 * We're done when it's "/" or "c:/". */
13386 /* If the directory exists we're done. Otherwise: create it.*/
13396 }
13398 #ifdef vim_mkdir
13399 /*
13400 * "mkdir()" function
13401 */
13402 static void
13406 {
13417 {
13422 }
13424 }
13425 #endif
13427 /*
13428 * "mode()" function
13429 */
13430 /*ARGSUSED*/
13431 static void
13435 {
13441 #ifdef FEAT_VISUAL
13443 {
13446 else
13448 }
13449 else
13450 #endif
13453 {
13459 }
13463 {
13464 #ifdef FEAT_VREPLACE
13466 {
13469 }
13470 else
13471 #endif
13474 else
13476 }
13478 {
13482 }
13484 {
13487 }
13488 else
13489 {
13493 }
13495 /* A zero number or empty string argument: return only major mode. */
13503 }
13505 /*
13506 * "nextnonblank()" function
13507 */
13508 static void
13512 {
13513 linenr_T lnum;
13516 {
13518 {
13521 }
13524 }
13526 }
13528 /*
13529 * "nr2char()" function
13530 */
13531 static void
13535 {
13538 #ifdef FEAT_MBYTE
13541 else
13542 #endif
13543 {
13546 }
13549 }
13551 /*
13552 * "pathshorten()" function
13553 */
13554 static void
13558 {
13565 else
13566 {
13571 }
13572 }
13574 #ifdef FEAT_FLOAT
13575 /*
13576 * "pow()" function
13577 */
13578 static void
13582 {
13589 else
13591 }
13592 #endif
13594 /*
13595 * "prevnonblank()" function
13596 */
13597 static void
13601 {
13602 linenr_T lnum;
13607 else
13611 }
13613 #ifdef HAVE_STDARG_H
13614 /* This dummy va_list is here because:
13615 * - passing a NULL pointer doesn't work when va_list isn't a pointer
13616 * - locally in the function results in a "used before set" warning
13617 * - using va_start() to initialize it gives "function with fixed args" error */
13619 #endif
13621 /*
13622 * "printf()" function
13623 */
13624 static void
13628 {
13632 {
13639 /* Get the required length, allocate the buffer and do it for real. */
13644 {
13647 {
13650 }
13651 }
13653 }
13654 #endif
13655 }
13657 /*
13658 * "pumvisible()" function
13659 */
13660 /*ARGSUSED*/
13661 static void
13665 {
13667 #ifdef FEAT_INS_EXPAND
13670 #endif
13671 }
13673 /*
13674 * "range()" function
13675 */
13676 static void
13680 {
13689 {
13692 }
13693 else
13694 {
13698 }
13707 else
13708 {
13714 }
13715 }
13717 /*
13718 * "readfile()" function
13719 */
13720 static void
13724 {
13744 {
13749 }
13754 /* Always open the file in binary mode, library functions have a mind of
13755 * their own about CR-LF conversion. */
13758 {
13761 }
13765 {
13770 {
13772 {
13773 /* Only when in binary mode add an empty list item when the
13774 * last line ends in a '\n'. */
13778 /* Found end-of-line or end-of-file: add a text line to the
13779 * list. */
13788 else
13789 {
13792 {
13798 }
13799 }
13804 {
13807 }
13817 }
13820 }
13825 {
13826 /* "buf" is full, need to move text to an allocated buffer */
13828 {
13831 }
13832 else
13833 {
13836 {
13842 }
13843 }
13845 }
13846 else
13847 {
13850 }
13851 }
13853 /*
13854 * For a negative line count use only the lines at the end of the file,
13855 * free the rest.
13856 */
13859 {
13862 }
13866 }
13868 #if defined(FEAT_RELTIME)
13871 /*
13872 * Convert a List to proftime_T.
13873 * Return FAIL when there is something wrong.
13874 */
13875 static int
13879 {
13888 # ifdef WIN3264
13891 # else
13894 # endif
13896 }
13899 /*
13900 * "reltime()" function
13901 */
13902 static void
13906 {
13907 #ifdef FEAT_RELTIME
13908 proftime_T res;
13909 proftime_T start;
13912 {
13913 /* No arguments: get current time. */
13915 }
13917 {
13921 }
13922 else
13923 {
13924 /* Two arguments: compute the difference. */
13929 }
13932 {
13935 # ifdef WIN3264
13938 # else
13941 # endif
13944 }
13945 #endif
13946 }
13948 /*
13949 * "reltimestr()" function
13950 */
13951 static void
13955 {
13956 #ifdef FEAT_RELTIME
13957 proftime_T tm;
13958 #endif
13962 #ifdef FEAT_RELTIME
13965 #endif
13966 }
13968 #if defined(FEAT_CLIENTSERVER) && defined(FEAT_X11)
13972 static void
13974 {
13976 # ifdef FEAT_GUI
13978 # endif
13979 )
13980 {
13984 }
13985 }
13987 static int
13989 {
13992 {
13995 }
13997 }
13998 #endif
14000 #ifdef FEAT_CLIENTSERVER
14003 static void
14008 {
14013 # ifdef WIN32
14014 HWND w;
14015 # elif defined(FEAT_X11)
14016 Window w;
14017 # elif defined(MAC_CLIENTSERVER)
14019 # endif
14024 # ifdef FEAT_X11
14027 # endif
14033 # ifdef WIN32
14035 # elif defined(FEAT_X11)
14038 # elif defined(MAC_CLIENTSERVER)
14040 # endif
14041 {
14044 else
14047 }
14052 {
14053 dictitem_T v;
14064 }
14065 }
14066 #endif
14068 /*
14069 * "remote_expr()" function
14070 */
14071 /*ARGSUSED*/
14072 static void
14076 {
14079 #ifdef FEAT_CLIENTSERVER
14081 #endif
14082 }
14084 /*
14085 * "remote_foreground()" function
14086 */
14087 /*ARGSUSED*/
14088 static void
14092 {
14094 #ifdef FEAT_CLIENTSERVER
14095 # ifdef WIN32
14096 /* On Win32 it's done in this application. */
14097 {
14102 }
14103 # elif defined(FEAT_X11) || defined(MAC_CLIENTSERVER)
14104 /* Send a foreground() expression to the server. */
14110 # endif
14111 #endif
14112 }
14114 /*ARGSUSED*/
14115 static void
14119 {
14120 #ifdef FEAT_CLIENTSERVER
14121 dictitem_T v;
14123 # ifdef WIN32
14125 # endif
14129 {
14132 }
14135 {
14138 }
14139 # ifdef WIN32
14143 else
14144 {
14147 }
14148 # elif defined(FEAT_X11)
14155 # elif defined(MAC_CLIENTSERVER)
14157 # endif
14160 {
14169 }
14170 #else
14172 #endif
14173 }
14175 /*ARGSUSED*/
14176 static void
14180 {
14183 #ifdef FEAT_CLIENTSERVER
14187 {
14188 # ifdef WIN32
14189 /* The server's HWND is encoded in the 'id' parameter */
14196 # elif defined(FEAT_X11)
14199 # elif defined(MAC_CLIENTSERVER)
14201 # endif
14203 }
14204 #endif
14207 }
14209 /*
14210 * "remote_send()" function
14211 */
14212 /*ARGSUSED*/
14213 static void
14217 {
14220 #ifdef FEAT_CLIENTSERVER
14222 #endif
14223 }
14225 /*
14226 * "remove()" function
14227 */
14228 static void
14232 {
14244 {
14249 {
14252 {
14256 else
14257 {
14261 }
14262 }
14263 }
14264 }
14269 {
14277 else
14278 {
14280 {
14281 /* Remove one item, return its value. */
14285 }
14286 else
14287 {
14288 /* Remove range of items, return list with values. */
14294 else
14295 {
14299 {
14303 }
14306 else
14307 {
14310 {
14317 }
14318 }
14319 }
14320 }
14321 }
14322 }
14323 }
14325 /*
14326 * "rename({from}, {to})" function
14327 */
14328 static void
14332 {
14337 else
14340 }
14342 /*
14343 * "repeat()" function
14344 */
14345 /*ARGSUSED*/
14346 static void
14350 {
14360 {
14366 }
14367 else
14368 {
14380 {
14384 }
14387 }
14388 }
14390 /*
14391 * "resolve()" function
14392 */
14393 static void
14397 {
14401 #ifdef FEAT_SHORTCUT
14402 {
14408 else
14410 }
14411 #else
14412 # ifdef HAVE_READLINK
14413 {
14435 {
14436 /* Separate the first path component in "p", and keep the
14437 * remainder (beginning with the path separator). */
14440 }
14443 {
14445 {
14452 {
14458 }
14460 /* Ensure that the result will have a trailing path separator
14461 * if the argument has one. */
14465 /* Separate the first path component in the link value and
14466 * concatenate the remainders. */
14469 {
14472 else
14473 {
14476 {
14479 }
14480 }
14482 }
14486 {
14487 /* Ignore trailing path separator. */
14490 }
14492 {
14493 /* symlink is relative to directory of argument */
14496 {
14501 }
14502 }
14503 else
14504 {
14507 }
14508 }
14513 /* Append the first path component of "remain" to "p". */
14518 {
14522 }
14523 /* Shorten "remain". */
14526 else
14527 {
14530 }
14531 }
14533 /* If the result is a relative path name, make it explicitly relative to
14534 * the current directory if and only if the argument had this form. */
14536 {
14545 {
14546 /* Prepend "./". */
14549 {
14552 }
14553 }
14555 {
14556 /* Strip leading "./". */
14562 }
14563 }
14565 /* Ensure that the result will have no trailing path separator
14566 * if the argument had none. But keep "/" or "//". */
14568 {
14572 }
14575 }
14576 # else
14578 # endif
14579 #endif
14583 #ifdef HAVE_READLINK
14584 fail:
14585 #endif
14587 }
14589 /*
14590 * "reverse({list})" function
14591 */
14592 static void
14596 {
14605 {
14610 {
14614 }
14619 }
14620 }
14632 /*
14633 * Get flags for a search function.
14634 * Possibly sets "p_ws".
14635 * Returns BACKWARD, FORWARD or zero (for an error).
14636 */
14637 static int
14641 {
14648 {
14653 {
14655 {
14662 {
14670 }
14672 {
14675 }
14676 else
14678 }
14682 }
14683 }
14685 }
14687 /*
14688 * Shared by search() and searchpos() functions
14689 */
14690 static int
14695 {
14698 pos_T pos;
14699 pos_T save_cursor;
14704 proftime_T tm;
14705 #ifdef FEAT_RELTIME
14707 #endif
14721 /* Optional arguments: line number to stop searching and timeout. */
14723 {
14727 #ifdef FEAT_RELTIME
14729 {
14733 }
14734 #endif
14735 }
14737 #ifdef FEAT_RELTIME
14738 /* Set the time limit, if there is one. */
14740 #endif
14742 /*
14743 * This function does not accept SP_REPEAT and SP_RETCOUNT flags.
14744 * Check to make sure only those flags are set.
14745 * Also, Only the SP_NOMOVE or the SP_SETPCMARK flag can be set. Both
14746 * flags cannot be set. Check for that condition also.
14747 */
14750 {
14753 }
14759 {
14762 else
14768 {
14769 /* Store the match cursor position */
14772 }
14773 /* "/$" will put the cursor after the end of the line, may need to
14774 * correct that here */
14776 }
14778 /* If 'n' flag is used: restore cursor position. */
14781 else
14783 theend:
14787 }
14789 #ifdef FEAT_FLOAT
14790 /*
14791 * "round({float})" function
14792 */
14793 static void
14797 {
14798 float_T f;
14802 /* round() is not in C90, use ceil() or floor() instead. */
14804 else
14806 }
14807 #endif
14809 /*
14810 * "search()" function
14811 */
14812 static void
14816 {
14820 }
14822 /*
14823 * "searchdecl()" function
14824 */
14825 static void
14829 {
14839 {
14843 }
14847 }
14849 /*
14850 * Used by searchpair() and searchpairpos()
14851 */
14852 static int
14856 {
14869 /* Get the three pattern arguments: start, middle, end. */
14876 /* Handle the optional fourth argument: flags */
14881 /* Don't accept SP_END or SP_SUBPAT.
14882 * Only one of the SP_NOMOVE or SP_SETPCMARK flags can be set.
14883 */
14886 {
14889 }
14891 /* Using 'r' implies 'W', otherwise it doesn't work. */
14895 /* Optional fifth argument: skip expression */
14899 else
14900 {
14903 {
14907 #ifdef FEAT_RELTIME
14909 {
14913 }
14914 #endif
14915 }
14916 }
14923 theend:
14927 }
14929 /*
14930 * "searchpair()" function
14931 */
14932 static void
14936 {
14938 }
14940 /*
14941 * "searchpairpos()" function
14942 */
14943 static void
14947 {
14948 pos_T match_pos;
14958 {
14961 }
14965 }
14967 /*
14968 * Search for a start/middle/end thing.
14969 * Used by searchpair(), see its documentation for the details.
14970 * Returns 0 or -1 for no match,
14971 */
14972 long
14984 {
14988 pos_T pos;
14989 pos_T firstpos;
14990 pos_T foundpos;
14991 pos_T save_cursor;
14992 pos_T save_pos;
14998 proftime_T tm;
15000 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
15004 #ifdef FEAT_RELTIME
15005 /* Set the time limit, if there is one. */
15007 #endif
15009 /* Make two search patterns: start/end (pat2, for in nested pairs) and
15010 * start/middle/end (pat3, for the top pair). */
15018 else
15030 {
15034 /* didn't find it or found the first match again: FAIL */
15040 {
15041 /* Found the same position again. Can happen with a pattern that
15042 * has "\zs" at the end and searching backwards. Advance one
15043 * character and try again. */
15046 else
15048 }
15051 /* clear the start flag to avoid getting stuck here */
15054 /* If the skip pattern matches, ignore this match. */
15056 {
15062 {
15063 /* Evaluating {skip} caused an error, break here. */
15067 }
15070 }
15073 {
15074 /* Found end when searching backwards or start when searching
15075 * forward: nested pair. */
15078 }
15079 else
15080 {
15081 /* Found end when searching forward or start when searching
15082 * backward: end of (nested) pair; or found middle in outer pair. */
15085 }
15088 {
15089 /* Found the match: return matchcount or line number. */
15092 else
15100 }
15101 }
15104 {
15105 /* Store the match cursor position */
15108 }
15110 /* If 'n' flag is used or search failed: restore cursor position. */
15114 theend:
15120 }
15122 /*
15123 * "searchpos()" function
15124 */
15125 static void
15129 {
15130 pos_T match_pos;
15143 {
15146 }
15152 }
15155 /*ARGSUSED*/
15156 static void
15160 {
15161 #ifdef FEAT_CLIENTSERVER
15171 # ifdef FEAT_X11
15174 # endif
15177 {
15180 }
15182 #else
15184 #endif
15185 }
15187 /*ARGSUSED*/
15188 static void
15192 {
15195 #ifdef FEAT_CLIENTSERVER
15196 # if defined(WIN32) || defined(MAC_CLIENTSERVER)
15198 # elif defined(FEAT_X11)
15202 # endif
15203 #endif
15206 }
15208 /*
15209 * "setbufvar()" function
15210 */
15211 /*ARGSUSED*/
15212 static void
15216 {
15218 aco_save_T aco;
15233 {
15234 /* set curbuf to be our buf, temporarily */
15238 {
15248 }
15249 else
15250 {
15253 {
15258 }
15259 }
15261 /* reset notion of buffer */
15263 }
15264 }
15266 /*
15267 * "setcmdpos()" function
15268 */
15269 static void
15273 {
15278 }
15280 /*
15281 * "setline()" function
15282 */
15283 static void
15287 {
15288 linenr_T lnum;
15297 {
15300 }
15301 else
15306 {
15308 {
15309 /* list argument, get next string */
15314 }
15320 {
15321 /* existing line, replace it */
15323 {
15328 }
15329 }
15331 {
15332 /* lnum is one past the last line, append the line */
15336 }
15341 }
15345 }
15347 static void set_qf_ll_list __ARGS((win_T *wp, typval_T *list_arg, typval_T *action_arg, typval_T *rettv));
15349 /*
15350 * Used by "setqflist()" and "setloclist()" functions
15351 */
15352 /*ARGSUSED*/
15353 static void
15359 {
15360 #ifdef FEAT_QUICKFIX
15363 #endif
15367 #ifdef FEAT_QUICKFIX
15370 else
15371 {
15375 {
15381 }
15385 }
15386 #endif
15387 }
15389 /*
15390 * "setloclist()" function
15391 */
15392 /*ARGSUSED*/
15393 static void
15397 {
15405 }
15407 /*
15408 * "setmatches()" function
15409 */
15410 static void
15414 {
15415 #ifdef FEAT_SEARCH_EXTRA
15422 {
15425 }
15427 {
15429 /* To some extent make sure that we are dealing with a list from
15430 * "getmatches()". */
15433 {
15436 {
15439 }
15444 {
15447 }
15449 }
15454 {
15461 }
15463 }
15464 #endif
15465 }
15467 /*
15468 * "setpos()" function
15469 */
15470 /*ARGSUSED*/
15471 static void
15475 {
15476 pos_T pos;
15483 {
15485 {
15488 {
15489 /* set cursor */
15491 {
15495 }
15496 else
15498 }
15500 {
15501 /* set mark */
15504 }
15505 else
15507 }
15508 }
15509 }
15511 /*
15512 * "setqflist()" function
15513 */
15514 /*ARGSUSED*/
15515 static void
15519 {
15521 }
15523 /*
15524 * "setreg()" function
15525 */
15526 static void
15530 {
15536 char_u yank_type;
15555 {
15561 {
15571 #ifdef FEAT_VISUAL
15575 {
15579 }
15581 #endif
15582 }
15583 }
15590 }
15592 /*
15593 * "settabwinvar()" function
15594 */
15595 static void
15599 {
15601 }
15603 /*
15604 * "setwinvar()" function
15605 */
15606 static void
15610 {
15612 }
15614 /*
15615 * "setwinvar()" and "settabwinvar()" functions
15616 */
15617 static void
15622 {
15624 #ifdef FEAT_WINDOWS
15627 #endif
15638 #ifdef FEAT_WINDOWS
15641 else
15643 #endif
15649 {
15650 #ifdef FEAT_WINDOWS
15651 /* set curwin to be our win, temporarily */
15659 #endif
15662 {
15672 }
15673 else
15674 {
15677 {
15682 }
15683 }
15685 #ifdef FEAT_WINDOWS
15686 /* Restore current tabpage and window, if still valid (autocomands can
15687 * make them invalid). */
15691 {
15694 }
15695 #endif
15696 }
15697 }
15699 /*
15700 * "shellescape({string})" function
15701 */
15702 static void
15706 {
15709 }
15711 /*
15712 * "simplify()" function
15713 */
15714 static void
15718 {
15725 }
15727 #ifdef FEAT_FLOAT
15728 /*
15729 * "sin()" function
15730 */
15731 static void
15735 {
15736 float_T f;
15741 else
15743 }
15744 #endif
15746 static int
15747 #ifdef __BORLANDC__
15748 _RTLENTRYF
15749 #endif
15751 static int
15752 #ifdef __BORLANDC__
15753 _RTLENTRYF
15754 #endif
15760 #define ITEM_COMPARE_FAIL 999
15762 /*
15763 * Compare functions for f_sort() below.
15764 */
15765 static int
15766 #ifdef __BORLANDC__
15767 _RTLENTRYF
15768 #endif
15772 {
15787 else
15792 }
15794 static int
15795 #ifdef __BORLANDC__
15796 _RTLENTRYF
15797 #endif
15801 {
15803 typval_T rettv;
15807 /* shortcut after failure in previous call; compare all items equal */
15811 /* copy the values. This is needed to be able to set v_lock to VAR_FIXED
15812 * in the copy without changing the original list items. */
15824 else
15825 /* return value has wrong type */
15831 }
15833 /*
15834 * "sort({list})" function
15835 */
15836 static void
15840 {
15850 else
15851 {
15866 {
15869 else
15870 {
15878 else
15880 }
15881 }
15883 /* Make an array with each entry pointing to an item in the List. */
15892 /* test the compare function */
15897 else
15898 {
15899 /* Sort the array with item pointers. */
15904 {
15905 /* Clear the List and append the items in the sorted order. */
15910 }
15911 }
15914 }
15915 }
15917 /*
15918 * "soundfold({word})" function
15919 */
15920 static void
15924 {
15929 #ifdef FEAT_SPELL
15931 #else
15933 #endif
15934 }
15936 /*
15937 * "spellbadword()" function
15938 */
15939 /* ARGSUSED */
15940 static void
15944 {
15952 #ifdef FEAT_SPELL
15954 {
15955 /* Find the start and length of the badly spelled word. */
15959 }
15961 {
15966 {
15967 /* Check the argument for spelling. */
15969 {
15972 {
15975 }
15977 }
15978 }
15979 }
15980 #endif
15989 }
15991 /*
15992 * "spellsuggest()" function
15993 */
15994 /*ARGSUSED*/
15995 static void
15999 {
16000 #ifdef FEAT_SPELL
16004 garray_T ga;
16008 #endif
16013 #ifdef FEAT_SPELL
16015 {
16018 {
16023 {
16027 }
16028 }
16029 else
16035 {
16041 else
16042 {
16047 }
16048 }
16050 }
16051 #endif
16052 }
16054 static void
16058 {
16062 regmatch_T regmatch;
16070 /* Make 'cpoptions' empty, the 'l' flag should not be used here. */
16076 {
16082 }
16093 {
16096 {
16099 else
16103 else
16107 {
16111 }
16114 /* Advance to just after the match. */
16117 else
16118 {
16119 /* Don't get stuck at the same match. */
16120 #ifdef FEAT_MBYTE
16122 #else
16124 #endif
16125 }
16127 }
16130 }
16133 }
16135 #ifdef FEAT_FLOAT
16136 /*
16137 * "sqrt()" function
16138 */
16139 static void
16143 {
16144 float_T f;
16149 else
16151 }
16153 /*
16154 * "str2float()" function
16155 */
16156 static void
16160 {
16167 }
16168 #endif
16170 /*
16171 * "str2nr()" function
16172 */
16173 static void
16177 {
16183 {
16186 {
16189 }
16190 }
16197 }
16199 #ifdef HAVE_STRFTIME
16200 /*
16201 * "strftime({format}[, {time}])" function
16202 */
16203 static void
16207 {
16218 else
16221 /* MSVC returns NULL for an invalid value of seconds. */
16224 else
16225 {
16226 # ifdef FEAT_MBYTE
16227 vimconv_T conv;
16235 # endif
16239 else
16242 # ifdef FEAT_MBYTE
16248 else
16249 # endif
16252 # ifdef FEAT_MBYTE
16253 /* Release conversion descriptors */
16256 # endif
16257 }
16258 }
16259 #endif
16261 /*
16262 * "stridx()" function
16263 */
16264 static void
16268 {
16283 {
16291 }
16296 }
16298 /*
16299 * "string()" function
16300 */
16301 static void
16305 {
16311 /* Make a copy if we have a value but it's not in allocated memory. */
16314 }
16316 /*
16317 * "strlen()" function
16318 */
16319 static void
16323 {
16326 }
16328 /*
16329 * "strpart()" function
16330 */
16331 static void
16335 {
16350 else
16353 /*
16354 * Only return the overlap between the specified part and the actual
16355 * string.
16356 */
16358 {
16361 }
16371 }
16373 /*
16374 * "strridx()" function
16375 */
16376 static void
16380 {
16397 {
16398 /* Third argument: upper limit for index */
16402 }
16403 else
16407 {
16408 /* Empty string matches past the end. */
16410 }
16411 else
16412 {
16414 {
16419 }
16420 }
16424 else
16426 }
16428 /*
16429 * "strtrans()" function
16430 */
16431 static void
16435 {
16438 }
16440 /*
16441 * "submatch()" function
16442 */
16443 static void
16447 {
16451 }
16453 /*
16454 * "substitute()" function
16455 */
16456 static void
16460 {
16473 else
16475 }
16477 /*
16478 * "synID(lnum, col, trans)" function
16479 */
16480 /*ARGSUSED*/
16481 static void
16485 {
16487 #ifdef FEAT_SYN_HL
16500 #endif
16503 }
16505 /*
16506 * "synIDattr(id, what [, mode])" function
16507 */
16508 /*ARGSUSED*/
16509 static void
16513 {
16515 #ifdef FEAT_SYN_HL
16525 {
16529 #ifdef FEAT_GUI
16531 #endif
16532 )
16534 }
16535 else
16536 {
16537 #ifdef FEAT_GUI
16540 else
16541 #endif
16544 else
16546 }
16550 {
16583 /* underline */
16585 else
16586 /* undercurl */
16589 }
16593 #endif
16596 }
16598 /*
16599 * "synIDtrans(id)" function
16600 */
16601 /*ARGSUSED*/
16602 static void
16606 {
16609 #ifdef FEAT_SYN_HL
16614 else
16615 #endif
16619 }
16621 /*
16622 * "synstack(lnum, col)" function
16623 */
16624 /*ARGSUSED*/
16625 static void
16629 {
16630 #ifdef FEAT_SYN_HL
16635 #endif
16640 #ifdef FEAT_SYN_HL
16647 {
16650 {
16656 }
16657 }
16658 #endif
16659 }
16661 /*
16662 * "system()" function
16663 */
16664 static void
16668 {
16680 {
16681 /*
16682 * Write the string to a temp file, to be used for input of the shell
16683 * command.
16684 */
16686 {
16689 }
16693 {
16696 }
16699 {
16702 }
16708 {
16711 }
16712 }
16717 #ifdef USE_CR
16718 /* translate <CR> into <NL> */
16720 {
16724 {
16727 }
16728 }
16729 #else
16730 # ifdef USE_CRNL
16731 /* translate <CR><NL> into <NL> */
16733 {
16738 {
16742 }
16744 }
16745 # endif
16746 #endif
16748 done:
16750 {
16753 }
16756 }
16758 /*
16759 * "tabpagebuflist()" function
16760 */
16761 /* ARGSUSED */
16762 static void
16766 {
16767 #ifndef FEAT_WINDOWS
16769 #else
16775 else
16776 {
16780 }
16783 else
16784 {
16787 else
16788 {
16793 }
16794 }
16795 #endif
16796 }
16799 /*
16800 * "tabpagenr()" function
16801 */
16802 /* ARGSUSED */
16803 static void
16807 {
16809 #ifdef FEAT_WINDOWS
16813 {
16817 {
16820 else
16822 }
16823 }
16824 else
16826 #endif
16828 }
16831 #ifdef FEAT_WINDOWS
16834 /*
16835 * Common code for tabpagewinnr() and winnr().
16836 */
16837 static int
16841 {
16849 {
16856 {
16860 }
16861 else
16862 {
16865 }
16866 }
16871 {
16873 {
16874 /* didn't find it in this tabpage */
16877 }
16879 }
16881 }
16882 #endif
16884 /*
16885 * "tabpagewinnr()" function
16886 */
16887 /* ARGSUSED */
16888 static void
16892 {
16894 #ifdef FEAT_WINDOWS
16900 else
16902 #endif
16904 }
16907 /*
16908 * "tagfiles()" function
16909 */
16910 /*ARGSUSED*/
16911 static void
16915 {
16917 tagname_T tn;
16921 {
16924 }
16931 }
16933 /*
16934 * "taglist()" function
16935 */
16936 static void
16940 {
16951 }
16953 /*
16954 * "tempname()" function
16955 */
16956 /*ARGSUSED*/
16957 static void
16961 {
16967 /* Advance 'x' to use A-Z and 0-9, so that there are at least 34 different
16968 * names. Skip 'I' and 'O', they are used for shell redirection. */
16969 do
16970 {
16975 else
16976 {
16977 #ifdef EBCDIC
16982 else
16983 #endif
16985 }
16987 }
16989 /*
16990 * "test(list)" function: Just checking the walls...
16991 */
16992 /*ARGSUSED*/
16993 static void
16997 {
16998 /* Used for unit testing. Change the code below to your liking. */
16999 #if 0
17018 #endif
17019 }
17021 /*
17022 * "tolower(string)" function
17023 */
17024 static void
17028 {
17037 {
17038 #ifdef FEAT_MBYTE
17042 {
17048 /* TODO: reallocate string when byte count changes. */
17052 }
17055 else
17056 #endif
17057 {
17060 }
17061 }
17062 }
17064 /*
17065 * "toupper(string)" function
17066 */
17067 static void
17071 {
17074 }
17076 /*
17077 * "tr(string, fromstr, tostr)" function
17078 */
17079 static void
17083 {
17088 #ifdef FEAT_MBYTE
17096 #endif
17099 garray_T ga;
17105 /* Default return value: empty string. */
17112 #ifdef FEAT_MBYTE
17114 #endif
17115 /* not multi-byte: fromstr and tostr must be the same length */
17117 {
17118 #ifdef FEAT_MBYTE
17119 error:
17120 #endif
17124 }
17126 /* fromstr and tostr have to contain the same number of chars */
17128 {
17129 #ifdef FEAT_MBYTE
17131 {
17137 {
17140 {
17142 {
17145 {
17149 }
17150 }
17154 }
17156 }
17159 {
17160 /* Check that fromstr and tostr have the same number of
17161 * (multi-byte) characters. Done only once when a character
17162 * of instr doesn't appear in fromstr. */
17165 {
17168 }
17171 }
17178 }
17179 else
17180 #endif
17181 {
17182 /* When not using multi-byte chars we can do it faster. */
17186 else
17189 }
17190 }
17192 /* add a terminating NUL */
17197 }
17199 #ifdef FEAT_FLOAT
17200 /*
17201 * "trunc({float})" function
17202 */
17203 static void
17207 {
17208 float_T f;
17212 /* trunc() is not in C90, use floor() or ceil() instead. */
17214 else
17216 }
17217 #endif
17219 /*
17220 * "type(expr)" function
17221 */
17222 static void
17226 {
17230 {
17236 #ifdef FEAT_FLOAT
17238 #endif
17240 }
17242 }
17244 /*
17245 * "values(dict)" function
17246 */
17247 static void
17251 {
17253 }
17255 /*
17256 * "virtcol(string)" function
17257 */
17258 static void
17262 {
17270 {
17273 }
17276 }
17278 /*
17279 * "visualmode()" function
17280 */
17281 /*ARGSUSED*/
17282 static void
17286 {
17287 #ifdef FEAT_VISUAL
17295 /* A non-zero number or non-empty string argument: reset mode. */
17300 #else
17302 #endif
17303 }
17305 /*
17306 * "winbufnr(nr)" function
17307 */
17308 static void
17312 {
17318 else
17320 }
17322 /*
17323 * "wincol()" function
17324 */
17325 /*ARGSUSED*/
17326 static void
17330 {
17333 }
17335 /*
17336 * "winheight(nr)" function
17337 */
17338 static void
17342 {
17348 else
17350 }
17352 /*
17353 * "winline()" function
17354 */
17355 /*ARGSUSED*/
17356 static void
17360 {
17363 }
17365 /*
17366 * "winnr()" function
17367 */
17368 /* ARGSUSED */
17369 static void
17373 {
17376 #ifdef FEAT_WINDOWS
17378 #endif
17380 }
17382 /*
17383 * "winrestcmd()" function
17384 */
17385 /* ARGSUSED */
17386 static void
17390 {
17391 #ifdef FEAT_WINDOWS
17394 garray_T ga;
17399 {
17402 # ifdef FEAT_VERTSPLIT
17405 # endif
17407 }
17411 #else
17413 #endif
17415 }
17417 /*
17418 * "winrestview()" function
17419 */
17420 /* ARGSUSED */
17421 static void
17425 {
17431 else
17432 {
17435 #ifdef FEAT_VIRTUALEDIT
17437 #endif
17442 #ifdef FEAT_DIFF
17444 #endif
17457 #ifdef FEAT_DIFF
17459 #endif
17460 }
17461 }
17463 /*
17464 * "winsaveview()" function
17465 */
17466 /* ARGSUSED */
17467 static void
17471 {
17483 #ifdef FEAT_VIRTUALEDIT
17485 #endif
17490 #ifdef FEAT_DIFF
17492 #endif
17495 }
17497 /*
17498 * "winwidth(nr)" function
17499 */
17500 static void
17504 {
17510 else
17511 #ifdef FEAT_VERTSPLIT
17513 #else
17515 #endif
17516 }
17518 /*
17519 * "writefile()" function
17520 */
17521 static void
17525 {
17538 {
17541 }
17549 /* Always open the file in binary mode, library functions have a mind of
17550 * their own about CR-LF conversion. */
17553 {
17556 }
17557 else
17558 {
17561 {
17563 {
17566 else
17569 {
17572 }
17573 }
17576 {
17579 }
17581 {
17584 }
17585 }
17587 }
17590 }
17592 /*
17593 * Translate a String variable into a position.
17594 * Returns NULL when there is an error.
17595 */
17601 {
17606 /* Argument can be [lnum, col, coladd]. */
17608 {
17618 /* Get the line number */
17623 /* Get the column number */
17629 /* We accept "$" for the column number: last column. */
17636 /* Accept a position up to the NUL after the line. */
17641 #ifdef FEAT_VIRTUALEDIT
17642 /* Get the virtual offset. Defaults to zero. */
17646 #endif
17649 }
17656 #ifdef FEAT_VISUAL
17658 {
17662 }
17663 #endif
17665 {
17670 }
17672 #ifdef FEAT_VIRTUALEDIT
17674 #endif
17677 {
17680 {
17684 }
17686 {
17690 }
17691 }
17693 {
17695 {
17698 }
17699 else
17700 {
17703 }
17705 }
17707 }
17709 /*
17710 * Convert list in "arg" into a position and optional file number.
17711 * When "fnump" is NULL there is no file number, only 3 items.
17712 * Note that the column is passed on as-is, the caller may want to decrement
17713 * it to use 1 for the first column.
17714 * Return FAIL when conversion is not possible, doesn't check the position for
17715 * validity.
17716 */
17717 static int
17722 {
17727 /* List must be: [fnum, lnum, col, coladd], where "fnum" is only there
17728 * when "fnump" isn't NULL and "coladd" is optional. */
17736 {
17743 }
17755 #ifdef FEAT_VIRTUALEDIT
17759 else
17761 #endif
17764 }
17766 /*
17767 * Get the length of an environment variable name.
17768 * Advance "arg" to the first character after the name.
17769 * Return 0 for error.
17770 */
17771 static int
17774 {
17779 ;
17786 }
17788 /*
17789 * Get the length of the name of a function or internal variable.
17790 * "arg" is advanced to the first non-white character after the name.
17791 * Return 0 if something is wrong.
17792 */
17793 static int
17796 {
17800 /* Find the end of the name. */
17802 ;
17810 }
17812 /*
17813 * Get the length of the name of a variable or function.
17814 * Only the name is recognized, does not handle ".key" or "[idx]".
17815 * "arg" is advanced to the first non-white character after the name.
17816 * Return -1 if curly braces expansion failed.
17817 * Return 0 if something else is wrong.
17818 * If the name contains 'magic' {}'s, expand them and return the
17819 * expanded name in an allocated string via 'alias' - caller must free.
17820 */
17821 static int
17827 {
17837 {
17838 /* hard coded <SNR>, already translated */
17841 }
17844 {
17845 /* literal "<SID>", "s:" or "<SNR>" */
17847 }
17849 /*
17850 * Find the end of the name; check for {} construction.
17851 */
17855 {
17859 {
17863 }
17865 /*
17866 * Include any <SID> etc in the expanded string:
17867 * Thus the -len here.
17868 */
17875 }
17882 }
17884 /*
17885 * Find the end of a variable or function name, taking care of magic braces.
17886 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
17887 * start and end of the first magic braces item.
17888 * "flags" can have FNE_INCL_BR and FNE_CHECK_START.
17889 * Return a pointer to just after the name. Equal to "arg" if there is no
17890 * valid name.
17891 */
17898 {
17904 {
17907 }
17909 /* Quick check for valid starting character. */
17919 {
17921 {
17922 /* skip over 'string' to avoid counting [ and ] inside it. */
17924 ;
17927 }
17929 {
17930 /* skip over "str\"ing" to avoid counting [ and ] inside it. */
17936 }
17939 {
17944 }
17947 {
17949 {
17950 mb_nest++;
17953 }
17955 {
17956 mb_nest--;
17959 }
17960 }
17961 }
17964 }
17966 /*
17967 * Expands out the 'magic' {}'s in a variable/function name.
17968 * Note that this can call itself recursively, to deal with
17969 * constructs like foo{bar}{baz}{bam}
17970 * The four pointer arguments point to "foo{expre}ss{ion}bar"
17971 * "in_start" ^
17972 * "expr_start" ^
17973 * "expr_end" ^
17974 * "in_end" ^
17975 *
17976 * Returns a new allocated string, which the caller must free.
17977 * Returns NULL for failure.
17978 */
17985 {
17986 char_u c1;
18000 {
18004 {
18008 }
18009 }
18017 {
18020 {
18021 /* Further expansion! */
18026 }
18027 }
18030 }
18032 /*
18033 * Return TRUE if character "c" can be used in a variable or function name.
18034 * Does not include '{' or '}' for magic braces.
18035 */
18036 static int
18039 {
18041 }
18043 /*
18044 * Return TRUE if character "c" can be used as the first character in a
18045 * variable or function name (excluding '{' and '}').
18046 */
18047 static int
18050 {
18052 }
18054 /*
18055 * Set number v: variable to "val".
18056 */
18057 void
18061 {
18063 }
18065 /*
18066 * Get number v: variable value.
18067 */
18068 long
18071 {
18073 }
18075 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18076 /*
18077 * Get string v: variable value. Uses a static buffer, can only be used once.
18078 */
18079 char_u *
18082 {
18084 }
18085 #endif
18087 /*
18088 * Set v:count, v:count1 and v:prevcount.
18089 */
18090 void
18094 {
18098 }
18100 /*
18101 * Set string v: variable to a copy of "val".
18102 */
18103 void
18108 {
18109 /* Need to do this (at least) once, since we can't initialize a union.
18110 * Will always be invoked when "v:progname" is set. */
18118 else
18120 }
18122 /*
18123 * Set v:register if needed.
18124 */
18125 void
18128 {
18129 char_u regname;
18133 else
18135 /* Avoid free/alloc when the value is already right. */
18138 }
18140 /*
18141 * Get or set v:exception. If "oldval" == NULL, return the current value.
18142 * Otherwise, restore the value to "oldval" and return NULL.
18143 * Must always be called in pairs to save and restore v:exception! Does not
18144 * take care of memory allocations.
18145 */
18146 char_u *
18149 {
18155 }
18157 /*
18158 * Get or set v:throwpoint. If "oldval" == NULL, return the current value.
18159 * Otherwise, restore the value to "oldval" and return NULL.
18160 * Must always be called in pairs to save and restore v:throwpoint! Does not
18161 * take care of memory allocations.
18162 */
18163 char_u *
18166 {
18172 }
18174 #if defined(FEAT_AUTOCMD) || defined(PROTO)
18175 /*
18176 * Set v:cmdarg.
18177 * If "eap" != NULL, use "eap" to generate the value and return the old value.
18178 * If "oldarg" != NULL, restore the value to "oldarg" and return NULL.
18179 * Must always be called in pairs!
18180 */
18181 char_u *
18185 {
18192 {
18196 }
18202 else
18210 # ifdef FEAT_MBYTE
18215 # endif
18225 else
18234 # ifdef FEAT_MBYTE
18241 # endif
18244 }
18245 #endif
18247 /*
18248 * Get the value of internal variable "name".
18249 * Return OK or FAIL.
18250 */
18251 static int
18257 {
18260 typval_T atv;
18264 /* truncate the name, so that we can use strcmp() */
18268 /*
18269 * Check for "b:changedtick".
18270 */
18272 {
18276 }
18278 /*
18279 * Check for user-defined variables.
18280 */
18281 else
18282 {
18286 }
18289 {
18293 }
18300 }
18302 /*
18303 * Handle expr[expr], expr[expr:expr] subscript and .name lookup.
18304 * Also handle function call with Funcref variable: func(expr)
18305 * Can all be combined: dict.func(expr)[idx]['func'](expr)
18306 */
18307 static int
18313 {
18318 typval_T functv;
18325 {
18327 {
18328 /* need to copy the funcref so that we can clear rettv */
18332 /* Invoke the function. Recursive! */
18338 /* Clear the funcref afterwards, so that deleting it while
18339 * evaluating the arguments is possible (see test55). */
18342 /* Stop the expression evaluation when immediately aborting on
18343 * error, or when an interrupt occurred or an exception was thrown
18344 * but not caught. */
18346 {
18350 }
18353 }
18355 {
18358 {
18362 }
18363 else
18366 {
18369 }
18370 }
18371 }
18374 }
18376 /*
18377 * Allocate memory for a variable type-value, and make it empty (0 or NULL
18378 * value).
18379 */
18382 {
18384 }
18386 /*
18387 * Allocate memory for a variable type-value, and assign a string to it.
18388 * The string "s" must have been allocated, it is consumed.
18389 * Return NULL for out of memory, the variable otherwise.
18390 */
18394 {
18399 {
18402 }
18403 else
18406 }
18408 /*
18409 * Free the memory for a variable type-value.
18410 */
18411 void
18414 {
18416 {
18418 {
18421 /*FALLTHROUGH*/
18432 #ifdef FEAT_FLOAT
18434 #endif
18440 }
18442 }
18443 }
18445 /*
18446 * Free the memory for a variable value and set the value to NULL or 0.
18447 */
18448 void
18451 {
18453 {
18455 {
18458 /*FALLTHROUGH*/
18474 #ifdef FEAT_FLOAT
18478 #endif
18483 }
18485 }
18486 }
18488 /*
18489 * Set the value of a variable to NULL without freeing items.
18490 */
18491 static void
18494 {
18497 }
18499 /*
18500 * Get the number value of a variable.
18501 * If it is a String variable, uses vim_str2nr().
18502 * For incompatible types, return 0.
18503 * get_tv_number_chk() is similar to get_tv_number(), but informs the
18504 * caller of incompatible types: it sets *denote to TRUE if "denote"
18505 * is not NULL or returns -1 otherwise.
18506 */
18507 static long
18510 {
18514 }
18516 long
18520 {
18524 {
18527 #ifdef FEAT_FLOAT
18531 #endif
18549 }
18552 else
18555 }
18557 /*
18558 * Get the lnum from the first argument.
18559 * Also accepts ".", "$", etc., but that only works for the current buffer.
18560 * Returns -1 on error.
18561 */
18562 static linenr_T
18565 {
18566 typval_T rettv;
18567 linenr_T lnum;
18571 {
18576 }
18578 }
18580 /*
18581 * Get the lnum from the first argument.
18582 * Also accepts "$", then "buf" is used.
18583 * Returns 0 on error.
18584 */
18585 static linenr_T
18589 {
18596 }
18598 /*
18599 * Get the string value of a variable.
18600 * If it is a Number variable, the number is converted into a string.
18601 * get_tv_string() uses a single, static buffer. YOU CAN ONLY USE IT ONCE!
18602 * get_tv_string_buf() uses a given buffer.
18603 * If the String variable has never been set, return an empty string.
18604 * Never returns NULL;
18605 * get_tv_string_chk() and get_tv_string_buf_chk() are similar, but return
18606 * NULL on error.
18607 */
18611 {
18615 }
18621 {
18625 }
18627 char_u *
18630 {
18634 }
18640 {
18642 {
18655 #ifdef FEAT_FLOAT
18659 #endif
18667 }
18669 }
18671 /*
18672 * Find variable "name" in the list of variables.
18673 * Return a pointer to it if found, NULL if not found.
18674 * Careful: "a:0" variables don't have a name.
18675 * When "htp" is not NULL we are writing to the variable, set "htp" to the
18676 * hashtab_T used.
18677 */
18682 {
18692 }
18694 /*
18695 * Find variable "varname" in hashtab "ht".
18696 * Returns NULL if not found.
18697 */
18703 {
18707 {
18708 /* Must be something like "s:", otherwise "ht" would be NULL. */
18710 {
18716 #ifdef FEAT_WINDOWS
18718 #endif
18723 }
18725 }
18729 {
18730 /* For global variables we may try auto-loading the script. If it
18731 * worked find the variable again. Don't auto-load a script if it was
18732 * loaded already, otherwise it would be loaded every time when
18733 * checking if a function name is a Funcref variable. */
18739 }
18741 }
18743 /*
18744 * Find the hashtab used for a variable name.
18745 * Set "varname" to the start of name without ':'.
18746 */
18751 {
18755 {
18756 /* The name must not start with a colon or #. */
18761 /* "version" is "v:version" in all scopes */
18769 }
18773 /* There must be no ':' or '#' in the rest of the name, unless g: is used
18774 */
18782 #ifdef FEAT_WINDOWS
18785 #endif
18796 }
18798 /*
18799 * Get the string value of a (global/local) variable.
18800 * Returns NULL when it doesn't exist.
18801 */
18802 char_u *
18805 {
18812 }
18814 /*
18815 * Allocate a new hashtab for a sourced script. It will be used while
18816 * sourcing this script and when executing functions defined in the script.
18817 */
18818 void
18820 scid_T id;
18821 {
18827 {
18828 /* Re-allocating ga_data means that an ht_array pointing to
18829 * ht_smallarray becomes invalid. We can recognize this: ht_mask is
18830 * at its init value. Also reset "v_dict", it's always the same. */
18832 {
18838 }
18841 {
18845 }
18846 }
18847 }
18849 /*
18850 * Initialize dictionary "dict" as a scope and set variable "dict_var" to
18851 * point to it.
18852 */
18853 void
18857 {
18865 }
18867 /*
18868 * Clean up a list of internal variables.
18869 * Frees all allocated variables and the value they contain.
18870 * Clears hashtab "ht", does not free it.
18871 */
18872 void
18875 {
18877 }
18879 /*
18880 * Like vars_clear(), but only free the value if "free_val" is TRUE.
18881 */
18882 static void
18886 {
18894 {
18896 {
18899 /* Free the variable. Don't remove it from the hashtab,
18900 * ht_array might change then. hash_clear() takes care of it
18901 * later. */
18907 }
18908 }
18911 }
18913 /*
18914 * Delete a variable from hashtab "ht" at item "hi".
18915 * Clear the variable value and free the dictitem.
18916 */
18917 static void
18921 {
18927 }
18929 /*
18930 * List the value of one internal variable.
18931 */
18932 static void
18937 {
18946 }
18948 static void
18955 {
18956 /* don't use msg() or msg_attr() to avoid overwriting "v:statusmsg" */
18968 {
18972 }
18974 {
18978 }
18979 else
18987 {
18990 }
18991 }
18993 /*
18994 * Set variable "name" to value in "tv".
18995 * If the variable already exists, the value is updated.
18996 * Otherwise the variable is created.
18997 */
18998 static void
19003 {
19010 {
19014 {
19017 }
19019 {
19021 name);
19023 }
19024 }
19028 {
19031 }
19035 {
19036 /* existing variable, need to clear the value */
19045 #ifdef FEAT_FLOAT
19050 #endif
19051 )
19052 {
19055 }
19057 /*
19058 * Handle setting internal v: variables separately: we don't change
19059 * the type.
19060 */
19062 {
19064 {
19068 else
19069 {
19070 /* Take over the string to avoid an extra alloc/free. */
19073 }
19074 }
19077 else
19078 {
19082 }
19084 }
19087 }
19089 {
19090 /* Can't add "v:" variable. */
19092 {
19095 }
19097 /* Make sure the variable name is valid. */
19101 {
19104 }
19112 {
19115 }
19117 }
19121 else
19122 {
19126 }
19127 }
19129 /*
19130 * Return TRUE if di_flags "flags" indicates variable "name" is read-only.
19131 * Also give an error message.
19132 */
19133 static int
19137 {
19139 {
19142 }
19144 {
19147 }
19149 }
19151 /*
19152 * Return TRUE if di_flags "flags" indicates variable "name" is fixed.
19153 * Also give an error message.
19154 */
19155 static int
19159 {
19161 {
19164 }
19166 }
19168 /*
19169 * Return TRUE if typeval "tv" is set to be locked (immutable).
19170 * Also give an error message, using "name".
19171 */
19172 static int
19176 {
19178 {
19182 }
19184 {
19188 }
19190 }
19192 /*
19193 * Copy the values from typval_T "from" to typval_T "to".
19194 * When needed allocates string or increases reference count.
19195 * Does not make a copy of a list or dict but copies the reference!
19196 */
19197 static void
19201 {
19205 {
19209 #ifdef FEAT_FLOAT
19213 #endif
19218 else
19219 {
19223 }
19228 else
19229 {
19232 }
19237 else
19238 {
19241 }
19246 }
19247 }
19249 /*
19250 * Make a copy of an item.
19251 * Lists and Dictionaries are also copied. A deep copy if "deep" is set.
19252 * For deepcopy() "copyID" is zero for a full copy or the ID for when a
19253 * reference to an already copied list/dict can be used.
19254 * Returns FAIL or OK.
19255 */
19256 static int
19262 {
19267 {
19270 }
19274 {
19276 #ifdef FEAT_FLOAT
19278 #endif
19289 {
19290 /* use the copy made earlier */
19293 }
19294 else
19305 {
19306 /* use the copy made earlier */
19309 }
19310 else
19318 }
19321 }
19323 /*
19324 * ":echo expr1 ..." print each argument separated with a space, add a
19325 * newline at the end.
19326 * ":echon expr1 ..." print each argument plain.
19327 */
19328 void
19331 {
19333 typval_T rettv;
19343 {
19344 /* If eval1() causes an error message the text from the command may
19345 * still need to be cleared. E.g., "echo 22,44". */
19350 {
19351 /*
19352 * Report the invalid expression unless the expression evaluation
19353 * has been cancelled due to an aborting error, an interrupt, or an
19354 * exception.
19355 */
19360 }
19364 {
19366 {
19368 /* Call msg_start() after eval1(), evaluating the expression
19369 * may cause a message to appear. */
19372 }
19378 {
19380 {
19382 {
19383 /* remove any text still there from the command */
19386 }
19388 }
19389 else
19390 {
19391 #ifdef FEAT_MBYTE
19393 {
19398 }
19399 else
19400 #endif
19402 }
19403 }
19405 }
19408 }
19413 else
19414 {
19415 /* remove text that may still be there from the command */
19420 }
19421 }
19423 /*
19424 * ":echohl {name}".
19425 */
19426 void
19429 {
19435 else
19437 }
19439 /*
19440 * ":execute expr1 ..." execute the result of an expression.
19441 * ":echomsg expr1 ..." Print a message
19442 * ":echoerr expr1 ..." Print an error
19443 * Each gets spaces around each argument and a newline at the end for
19444 * echo commands
19445 */
19446 void
19449 {
19451 typval_T rettv;
19454 garray_T ga;
19463 {
19466 {
19467 /*
19468 * Report the invalid expression unless the expression evaluation
19469 * has been cancelled due to an aborting error, an interrupt, or an
19470 * exception.
19471 */
19476 }
19479 {
19483 {
19487 }
19492 }
19496 }
19499 {
19501 {
19504 }
19506 {
19507 /* We don't want to abort following commands, restore did_emsg. */
19512 }
19516 }
19524 }
19526 /*
19527 * Skip over the name of an option: "&option", "&g:option" or "&l:option".
19528 * "arg" points to the "&" or '+' when called, to "option" when returning.
19529 * Returns NULL when no option name found. Otherwise pointer to the char
19530 * after the option name.
19531 */
19536 {
19541 {
19544 }
19546 {
19549 }
19550 else
19559 else
19563 }
19565 /*
19566 * ":function"
19567 */
19568 void
19571 {
19580 garray_T newargs;
19581 garray_T newlines;
19590 funcdict_T fudi;
19598 /*
19599 * ":function" without argument: list functions.
19600 */
19602 {
19604 {
19607 {
19609 {
19614 }
19615 }
19616 }
19619 }
19621 /*
19622 * ":function /pat": list functions matching pattern.
19623 */
19625 {
19628 {
19629 regmatch_T regmatch;
19636 {
19641 {
19643 {
19649 }
19650 }
19651 }
19652 }
19657 }
19659 /*
19660 * Get the function name. There are these situations:
19661 * func normal function name
19662 * "name" == func, "fudi.fd_dict" == NULL
19663 * dict.func new dictionary entry
19664 * "name" == NULL, "fudi.fd_dict" set,
19665 * "fudi.fd_di" == NULL, "fudi.fd_newkey" == func
19666 * dict.func existing dict entry with a Funcref
19667 * "name" == func, "fudi.fd_dict" set,
19668 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19669 * dict.func existing dict entry that's not a Funcref
19670 * "name" == NULL, "fudi.fd_dict" set,
19671 * "fudi.fd_di" set, "fudi.fd_newkey" == NULL
19672 */
19677 {
19678 /*
19679 * Return on an invalid expression in braces, unless the expression
19680 * evaluation has been cancelled due to an aborting error, an
19681 * interrupt, or an exception.
19682 */
19684 {
19689 }
19690 else
19692 }
19694 /* An error in a function call during evaluation of an expression in magic
19695 * braces should not cause the function not to be defined. */
19699 /*
19700 * ":function func" with only function name: list function.
19701 */
19703 {
19705 {
19708 }
19713 {
19716 {
19719 {
19731 }
19733 {
19736 }
19737 }
19738 else
19740 }
19742 }
19744 /*
19745 * ":function name(arg1, arg2)" Define function.
19746 */
19749 {
19751 {
19754 }
19755 /* attempt to continue by skipping some text */
19758 }
19765 {
19766 /* Check the name of the function. Unless it's a dictionary function
19767 * (that we are overwriting). */
19770 else
19774 {
19777 else
19784 }
19785 }
19787 /*
19788 * Isolate the arguments: "arg1, arg2, ...)"
19789 */
19791 {
19793 {
19797 }
19798 else
19799 {
19806 {
19810 }
19823 else
19825 }
19828 {
19832 }
19833 }
19836 /* find extra arguments "range", "dict" and "abort" */
19838 {
19841 {
19844 }
19846 {
19849 }
19851 {
19854 }
19855 else
19857 }
19859 /* When there is a line break use what follows for the function body.
19860 * Makes 'exe "func Test()\n...\nendfunc"' work. */
19866 /*
19867 * Read the body of the function, until ":endfunction" is found.
19868 */
19870 {
19871 /* Check if the function already exists, don't let the user type the
19872 * whole function before telling him it doesn't work! For a script we
19873 * need to skip the body to be able to find what follows. */
19875 {
19880 }
19887 }
19892 {
19898 {
19899 /* Use eap->arg, split up in parts by line breaks. */
19904 else
19905 {
19908 }
19909 }
19912 else
19917 {
19920 }
19922 /* Detect line continuation: sourcing_lnum increased more than one. */
19925 else
19929 {
19930 /* between ":append" and "." and between ":python <<EOF" and "EOF"
19931 * don't check for ":endfunc". */
19933 {
19936 }
19937 }
19938 else
19939 {
19940 /* skip ':' and blanks*/
19942 ;
19944 /* Check for "endfunction". */
19946 {
19950 }
19952 /* Increase indent inside "if", "while", "for" and "try", decrease
19953 * at "end". */
19962 /* Check for defining a function inside this function. */
19964 {
19969 {
19972 {
19975 }
19976 }
19977 }
19979 /* Check for ":append" or ":insert". */
19987 /* Check for ":python <<EOF", ":tcl <<EOF", etc. */
20000 ))
20001 {
20002 /* ":python <<" continues until a dot, like ":append" */
20006 else
20008 }
20009 }
20011 /* Add the line to the function. */
20013 {
20017 }
20019 /* Copy the line to newly allocated memory. get_one_sourceline()
20020 * allocates 250 bytes per line, this saves 80% on average. The cost
20021 * is an extra alloc/free. */
20024 {
20028 }
20032 /* Add NULL lines for continuation lines, so that the line count is
20033 * equal to the index in the growarray. */
20037 /* Check for end of eap->arg. */
20040 }
20042 /* Don't define the function when skipping commands or when an error was
20043 * detected. */
20047 /*
20048 * If there are no errors, add the function
20049 */
20051 {
20054 {
20056 name);
20058 }
20062 {
20064 {
20067 }
20069 {
20071 name);
20073 }
20074 /* redefine existing function */
20079 }
20080 }
20081 else
20082 {
20087 {
20090 }
20092 {
20093 /* Can't add a function to a locked dictionary */
20096 }
20097 /* Can't change an existing function if it is locked */
20101 /* Give the function a sequential number. Can only be used with a
20102 * Funcref! */
20108 }
20111 {
20113 {
20117 /* Check that the autoload name matches the script name. */
20120 {
20123 {
20131 }
20132 }
20134 {
20137 }
20138 }
20145 {
20147 {
20148 /* add new dict entry */
20151 {
20154 }
20156 {
20160 }
20161 }
20162 else
20163 /* overwrite existing dict entry */
20170 /* behave like "dict" was used */
20172 }
20174 /* insert the new function in the function list */
20177 }
20180 #ifdef FEAT_PROFILE
20187 #endif
20194 erret:
20197 ret_free:
20202 }
20204 /*
20205 * Get a function name, translating "<SID>" and "<SNR>".
20206 * Also handles a Funcref in a List or Dictionary.
20207 * Returns the function name in allocated memory, or NULL for failure.
20208 * flags:
20209 * TFN_INT: internal function name OK
20210 * TFN_QUIET: be quiet
20211 * Advances "pp" to just after the function name (if no error).
20212 */
20219 {
20226 lval_T lv;
20232 /* Check for hard coded <SNR>: already translated function ID (from a user
20233 * command). */
20236 {
20240 }
20242 /* A name starting with "<SID>" or "<SNR>" is local to a script. But
20243 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
20251 {
20255 }
20257 {
20258 /*
20259 * Report an invalid expression in braces, unless the expression
20260 * evaluation has been cancelled due to an aborting error, an
20261 * interrupt, or an exception.
20262 */
20264 {
20267 }
20268 else
20271 }
20274 {
20276 {
20281 }
20283 {
20286 }
20287 else
20288 {
20292 else
20295 }
20297 }
20300 {
20301 /* Error found, but continue after the function name. */
20304 }
20306 /* Check if the name is a Funcref. If so, use the value. */
20308 {
20313 }
20314 else
20315 {
20320 }
20322 {
20326 }
20329 {
20333 {
20334 /* When there was "s:" already or the name expanded to get a
20335 * leading "s:" then remove it. */
20339 }
20340 }
20341 else
20342 {
20346 }
20348 /*
20349 * Copy the function name to allocated memory.
20350 * Accept <SID>name() inside a script, translate into <SNR>123_name().
20351 * Accept <SNR>123_name() outside a script.
20352 */
20356 {
20360 {
20361 /* It's "s:" or "<SID>" */
20363 {
20366 }
20369 }
20370 }
20372 {
20375 }
20378 {
20380 {
20386 }
20389 }
20392 theend:
20395 }
20397 /*
20398 * Return 5 if "p" starts with "<SID>" or "<SNR>" (ignoring case).
20399 * Return 2 if "p" starts with "s:".
20400 * Return 0 otherwise.
20401 */
20402 static int
20405 {
20412 }
20414 /*
20415 * Return TRUE if "p" starts with "<SID>" or "s:".
20416 * Only works if eval_fname_script() returned non-zero for "p"!
20417 */
20418 static int
20421 {
20423 }
20425 /*
20426 * List the head of the function: "name(arg1, arg2)".
20427 */
20428 static void
20432 {
20440 {
20443 }
20444 else
20448 {
20452 }
20454 {
20458 }
20463 }
20465 /*
20466 * Find a function by name, return pointer to it in ufuncs.
20467 * Return NULL for unknown function.
20468 */
20472 {
20479 }
20481 #if defined(EXITFREE) || defined(PROTO)
20482 void
20484 {
20487 /* Need to start all over every time, because func_free() may change the
20488 * hash table. */
20492 {
20495 }
20496 }
20497 #endif
20499 /*
20500 * Return TRUE if a function "name" exists.
20501 */
20502 static int
20505 {
20513 /* Only accept "funcname", "funcname ", "funcname (..." and
20514 * "funcname(...", not "funcname!...". */
20516 {
20519 else
20521 }
20524 }
20526 /*
20527 * Return TRUE if "name" looks like a builtin function name: starts with a
20528 * lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
20529 */
20530 static int
20533 {
20536 }
20538 #if defined(FEAT_PROFILE) || defined(PROTO)
20539 /*
20540 * Start profiling function "fp".
20541 */
20542 static void
20545 {
20564 }
20566 /*
20567 * Dump the profiling results for all functions in file "fd".
20568 */
20569 void
20572 {
20584 {
20586 {
20590 {
20596 else
20600 else
20608 {
20614 }
20616 }
20617 }
20618 }
20621 {
20623 prof_total_cmp);
20626 prof_self_cmp);
20628 }
20629 }
20631 static void
20638 {
20645 {
20648 prefer_self);
20651 else
20653 }
20655 }
20657 /*
20658 * Print the count and times for one function or function line.
20659 */
20660 static void
20667 {
20669 {
20673 else
20677 else
20679 }
20680 else
20682 }
20684 /*
20685 * Compare function for total time sorting.
20686 */
20687 static int
20688 #ifdef __BORLANDC__
20689 _RTLENTRYF
20690 #endif
20694 {
20700 }
20702 /*
20703 * Compare function for self time sorting.
20704 */
20705 static int
20706 #ifdef __BORLANDC__
20707 _RTLENTRYF
20708 #endif
20712 {
20718 }
20720 #endif
20722 /*
20723 * If "name" has a package name try autoloading the script for it.
20724 * Return TRUE if a package was loaded.
20725 */
20726 static int
20730 {
20736 /* If there is no '#' after name[0] there is no package name. */
20743 /* Find the name in the list of previously loaded package names. Skip
20744 * "autoload/", it's always the same. */
20750 else
20751 {
20752 /* Remember the name if it wasn't loaded already. */
20754 {
20757 }
20759 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
20762 }
20766 }
20768 /*
20769 * Return the autoload script name for a function or variable name.
20770 * Returns NULL when out of memory.
20771 */
20775 {
20779 /* Get the script file name: replace '#' with '/', append ".vim". */
20790 }
20792 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
20794 /*
20795 * Function given to ExpandGeneric() to obtain the list of user defined
20796 * function names.
20797 */
20798 char_u *
20802 {
20808 {
20811 }
20813 {
20825 {
20829 }
20831 }
20833 }
20837 /*
20838 * Copy the function name of "fp" to buffer "buf".
20839 * "buf" must be able to hold the function name plus three bytes.
20840 * Takes care of script-local function names.
20841 */
20842 static void
20846 {
20848 {
20851 }
20852 else
20854 }
20856 /*
20857 * ":delfunction {name}"
20858 */
20859 void
20862 {
20866 funcdict_T fudi;
20872 {
20876 }
20878 {
20882 }
20892 {
20894 {
20897 }
20899 {
20902 }
20905 {
20906 /* Delete the dict item that refers to the function, it will
20907 * invoke func_unref() and possibly delete the function. */
20909 }
20910 else
20912 }
20913 }
20915 /*
20916 * Free a function and remove it from the list of functions.
20917 */
20918 static void
20921 {
20924 /* clear this function */
20927 #ifdef FEAT_PROFILE
20931 #endif
20933 /* remove the function from the function hashtable */
20937 else
20941 }
20943 /*
20944 * Unreference a Function: decrement the reference count and free it when it
20945 * becomes zero. Only for numbered functions.
20946 */
20947 static void
20950 {
20954 {
20959 {
20960 /* Only delete it when it's not being used. Otherwise it's done
20961 * when "uf_calls" becomes zero. */
20964 }
20965 }
20966 }
20968 /*
20969 * Count a reference to a Function.
20970 */
20971 static void
20974 {
20978 {
20982 else
20984 }
20985 }
20987 /*
20988 * Call a user function.
20989 */
20990 static void
20999 {
21001 linenr_T save_sourcing_lnum;
21002 scid_T save_current_SID;
21003 funccall_T fc;
21012 #ifdef FEAT_PROFILE
21013 proftime_T wait_start;
21014 proftime_T call_start;
21015 #endif
21017 /* If depth of calling is getting too high, don't execute the function */
21019 {
21024 }
21037 /* Check if this function has a breakpoint. */
21041 /*
21042 * Note about using fc.fixvar[]: This is an array of FIXVAR_CNT variables
21043 * with names up to VAR_SHORT_LEN long. This avoids having to alloc/free
21044 * each argument variable and saves a lot of time.
21045 */
21046 /*
21047 * Init l: variables.
21048 */
21051 {
21052 /* Set l:self to "selfdict". Use "name" to avoid a warning from
21053 * some compiler that checks the destination size. */
21063 }
21065 /*
21066 * Init a: variables.
21067 * Set a:0 to "argcount".
21068 * Set a:000 to a list with room for the "..." arguments.
21069 */
21084 /*
21085 * Set a:firstline to "firstline" and a:lastline to "lastline".
21086 * Set a:name to named arguments.
21087 * Set a:N to the "..." arguments.
21088 */
21094 {
21097 /* named argument a:name */
21099 else
21100 {
21101 /* "..." argument a:1, a:2, etc. */
21104 }
21106 {
21109 }
21110 else
21111 {
21117 }
21121 /* Note: the values are copied directly to avoid alloc/free.
21122 * "argvars" must have VAR_FIXED for v_lock. */
21127 {
21131 }
21132 }
21134 /* Don't redraw while executing the function. */
21142 {
21146 else
21151 {
21157 {
21165 {
21170 else
21171 {
21174 {
21178 }
21179 }
21180 }
21182 }
21187 }
21188 }
21189 #ifdef FEAT_PROFILE
21191 {
21196 {
21200 }
21202 }
21203 #endif
21210 /* call do_cmdline() to execute the lines */
21216 /* when the function was aborted because of an error, return -1 */
21218 {
21222 }
21224 #ifdef FEAT_PROFILE
21227 {
21233 {
21236 }
21237 }
21238 #endif
21240 /* when being verbose, mention the return value */
21242 {
21251 else
21252 {
21258 /* The value may be very long. Skip the middle part, so that we
21259 * have some idea how it starts and ends. smsg() would always
21260 * truncate it at the end. */
21263 {
21267 }
21268 }
21273 }
21279 #ifdef FEAT_PROFILE
21282 #endif
21285 {
21294 }
21299 /* The a: variables typevals were not allocated, only free the allocated
21300 * variables. */
21305 }
21307 /*
21308 * Add a number variable "name" to dict "dp" with value "nr".
21309 */
21310 static void
21315 varnumber_T nr;
21316 {
21323 }
21325 /*
21326 * ":return [expr]"
21327 */
21328 void
21331 {
21333 typval_T rettv;
21337 {
21340 }
21348 {
21351 else
21353 }
21354 /* It's safer to return also on error. */
21356 {
21357 /*
21358 * Return unless the expression evaluation has been cancelled due to an
21359 * aborting error, an interrupt, or an exception.
21360 */
21363 }
21365 /* When skipping or the return gets pending, advance to the next command
21366 * in this line (!returning). Otherwise, ignore the rest of the line.
21367 * Following lines will be ignored by get_func_line(). */
21375 }
21377 /*
21378 * Return from a function. Possibly makes the return pending. Also called
21379 * for a pending return at the ":endtry" or after returning from an extra
21380 * do_cmdline(). "reanimate" is used in the latter case. "is_cmd" is set
21381 * when called due to a ":return" command. "rettv" may point to a typval_T
21382 * with the return rettv. Returns TRUE when the return can be carried out,
21383 * FALSE when the return gets pending.
21384 */
21385 int
21391 {
21396 /* Undo the return. */
21399 /*
21400 * Cleanup (and inactivate) conditionals, but stop when a try conditional
21401 * not in its finally clause (which then is to be executed next) is found.
21402 * In this case, make the ":return" pending for execution at the ":endtry".
21403 * Otherwise, return normally.
21404 */
21407 {
21411 /* A pending return again gets pending. "rettv" points to an
21412 * allocated variable with the rettv of the original ":return"'s
21413 * argument if present or is NULL else. */
21415 else
21416 {
21417 /* When undoing a return in order to make it pending, get the stored
21418 * return rettv. */
21423 {
21424 /* Store the value of the pending return. */
21427 else
21429 }
21430 else
21434 {
21435 /* The pending return value could be overwritten by a ":return"
21436 * without argument in a finally clause; reset the default
21437 * return value. */
21440 }
21441 }
21443 }
21444 else
21445 {
21448 /* If the return is carried out now, store the return value. For
21449 * a return immediately after reanimation, the value is already
21450 * there. */
21452 {
21457 }
21458 }
21461 }
21463 /*
21464 * Free the variable with a pending return value.
21465 */
21466 void
21469 {
21471 }
21473 /*
21474 * Generate a return command for producing the value of "rettv". The result
21475 * is an allocated string. Used by report_pending() for verbose messages.
21476 */
21477 char_u *
21480 {
21496 }
21498 /*
21499 * Get next function line.
21500 * Called by do_cmdline() to get the next line.
21501 * Returns allocated string, or NULL for end of function.
21502 */
21503 /* ARGSUSED */
21504 char_u *
21509 {
21515 /* If breakpoints have been added/deleted need to check for it. */
21517 {
21519 sourcing_lnum);
21521 }
21522 #ifdef FEAT_PROFILE
21525 #endif
21531 else
21532 {
21533 /* Skip NULL lines (continuation lines). */
21539 else
21540 {
21543 #ifdef FEAT_PROFILE
21546 #endif
21547 }
21548 }
21550 /* Did we encounter a breakpoint? */
21552 {
21554 /* Find next breakpoint. */
21556 sourcing_lnum);
21558 }
21561 }
21563 #if defined(FEAT_PROFILE) || defined(PROTO)
21564 /*
21565 * Called when starting to read a function line.
21566 * "sourcing_lnum" must be correct!
21567 * When skipping lines it may not actually be executed, but we won't find out
21568 * until later and we need to store the time now.
21569 */
21570 void
21573 {
21579 {
21581 /* Skip continuation lines. */
21588 }
21589 }
21591 /*
21592 * Called when actually executing a function line.
21593 */
21594 void
21597 {
21603 }
21605 /*
21606 * Called when done with a function line.
21607 */
21608 void
21611 {
21616 {
21618 {
21625 }
21627 }
21628 }
21629 #endif
21631 /*
21632 * Return TRUE if the currently active function should be ended, because a
21633 * return was encountered or an error occurred. Used inside a ":while".
21634 */
21635 int
21638 {
21641 /* Ignore the "abort" flag if the abortion behavior has been changed due to
21642 * an error inside a try conditional. */
21645 }
21647 /*
21648 * return TRUE if cookie indicates a function which "abort"s on errors.
21649 */
21650 int
21653 {
21655 }
21657 #if defined(FEAT_VIMINFO) || defined(FEAT_SESSION)
21659 {
21662 VAR_FLAVOUR_VIMINFO /* all uppercase */
21667 static var_flavour_T
21670 {
21674 {
21679 }
21680 else
21682 }
21683 #endif
21685 #if defined(FEAT_VIMINFO) || defined(PROTO)
21686 /*
21687 * Restore global vars that start with a capital from the viminfo file
21688 */
21689 int
21693 {
21696 typval_T tv;
21699 {
21702 {
21706 #ifdef FEAT_FLOAT
21709 #endif
21713 {
21718 #ifdef FEAT_FLOAT
21721 #endif
21722 else
21727 }
21728 }
21729 }
21732 }
21734 /*
21735 * Write global vars that start with a capital to the viminfo file
21736 */
21737 void
21740 {
21756 {
21758 {
21762 {
21764 {
21767 #ifdef FEAT_FLOAT
21769 #endif
21771 }
21777 }
21778 }
21779 }
21780 }
21781 #endif
21783 #if defined(FEAT_SESSION) || defined(PROTO)
21784 int
21787 {
21795 {
21797 {
21803 {
21804 /* Escape special characters with a backslash. Turn a LF and
21805 * CR into \n and \r. */
21819 p,
21823 {
21826 }
21828 }
21829 #ifdef FEAT_FLOAT
21832 {
21837 {
21840 }
21845 }
21846 #endif
21847 }
21848 }
21850 }
21851 #endif
21853 /*
21854 * Display script name where an item was last set.
21855 * Should only be invoked when 'verbose' is non-zero.
21856 */
21857 void
21859 scid_T scriptID;
21860 {
21864 {
21867 {
21873 }
21874 }
21875 }
21880 #if defined(FEAT_MODIFY_FNAME) || defined(FEAT_EVAL) || defined(PROTO)
21882 #ifdef WIN3264
21883 /*
21884 * Functions for ":8" filename modifier: get 8.3 version of a filename.
21885 */
21887 static int shortpath_for_invalid_fname __ARGS((char_u **fname, char_u **bufp, int *fnamelen));
21890 /*
21891 * Get the short path (8.3) for the filename in "fnamep".
21892 * Only works for a valid file name.
21893 * When the path gets longer "fnamep" is changed and the allocated buffer
21894 * is put in "bufp".
21895 * *fnamelen is the length of "fnamep" and set to 0 for a nonexistent path.
21896 * Returns OK on success, FAIL on failure.
21897 */
21898 static int
21903 {
21910 {
21911 /* If that doesn't work (not enough space), then save the string
21912 * and try again with a new buffer big enough. */
21920 /* Really should always succeed, as the buffer is big enough. */
21922 }
21926 }
21928 /*
21929 * Get the short path (8.3) for the filename in "fname". The converted
21930 * path is returned in "bufp".
21931 *
21932 * Some of the directories specified in "fname" may not exist. This function
21933 * will shorten the existing directories at the beginning of the path and then
21934 * append the remaining non-existing path.
21935 *
21936 * fname - Pointer to the filename to shorten. On return, contains the
21937 * pointer to the shortened pathname
21938 * bufp - Pointer to an allocated buffer for the filename.
21939 * fnamelen - Length of the filename pointed to by fname
21940 *
21941 * Returns OK on success (or nothing done) and FAIL on failure (out of memory).
21942 */
21943 static int
21948 {
21951 char_u ch;
21956 /* Make a copy */
21965 /*
21966 * Try shortening the supplied path till it succeeds by removing one
21967 * directory at a time from the tail of the path.
21968 */
21971 {
21972 /* go back one path-separator */
21978 /*
21979 * Replace the path separator with a NUL and try to shorten the
21980 * resulting path.
21981 */
21987 {
21990 }
21996 /* failed to shorten the path. Skip the path separator */
21998 }
22001 {
22002 /*
22003 * Succeeded in shortening the path. Now concatenate the shortened
22004 * path with the remaining path at the tail.
22005 */
22007 /* Compute the length of the new path. */
22014 {
22015 /* There is not enough space in the currently allocated string,
22016 * copy it to a buffer big enough. */
22019 {
22022 }
22023 }
22024 else
22025 {
22026 /* Transfer short_fname to the main buffer (it's big enough),
22027 * unless get_short_pathname() did its work in-place. */
22032 }
22034 /* concat the not-shortened part of the path */
22037 }
22039 theend:
22044 }
22046 /*
22047 * Get a pathname for a partial path.
22048 * Returns OK for success, FAIL for failure.
22049 */
22050 static int
22055 {
22061 /* Count up the path separators from the RHS.. so we know which part
22062 * of the path to return. */
22068 /* Need full path first (use expand_env() to remove a "~/") */
22072 else
22081 {
22082 /* Don't have a valid filename, so shorten the rest of the
22083 * path if we can. This CAN give us invalid 8.3 filenames, but
22084 * there's not a lot of point in guessing what it might be.
22085 */
22089 }
22091 /* Count the paths backward to find the beginning of the desired string. */
22093 {
22094 #ifdef FEAT_MBYTE
22097 #endif
22099 {
22102 else
22103 sepcount --;
22104 }
22105 }
22107 {
22111 else
22113 }
22114 else
22117 /* Copy in the string - p indexes into tfname - allocated at pbuf */
22124 }
22127 /*
22128 * Adjust a filename, according to a string of modifiers.
22129 * *fnamep must be NUL terminated when called. When returning, the length is
22130 * determined by *fnamelen.
22131 * Returns VALID_ flags or -1 for failure.
22132 * When there is an error, *fnamep is set to NULL.
22133 */
22134 int
22141 {
22148 #ifdef WIN3264
22150 #endif
22152 repeat:
22153 /* ":p" - full path/file_name */
22155 {
22161 /* Expand "~/path" for all systems and "~user/path" for Unix and VMS */
22163 #if !defined(UNIX) && !(defined(VMS) && defined(USER_HOME))
22165 # ifdef BACKSLASH_IN_FILENAME
22167 # endif
22170 #endif
22171 )
22172 {
22178 }
22180 /* When "/." or "/.." is used: force expansion to get rid of it. */
22182 {
22190 }
22192 /* FullName_save() is slow, don't use it when not needed. */
22194 {
22200 }
22202 /* Append a path separator to a directory. */
22204 {
22205 /* Make room for one or two extra characters. */
22212 }
22213 }
22215 /* ":." - path relative to the current directory */
22216 /* ":~" - path relative to the home directory */
22217 /* ":8" - shortname path - postponed till after */
22220 {
22223 {
22224 #ifdef WIN3264
22226 #endif
22228 }
22230 /* Need full path first (use expand_env() to remove a "~/") */
22232 {
22235 else
22237 }
22238 else
22244 {
22246 {
22250 {
22253 {
22257 }
22258 }
22259 }
22260 else
22261 {
22263 /* Only replace it when it starts with '~' */
22265 {
22268 {
22272 }
22273 }
22274 }
22276 }
22277 }
22282 /* ":h" - head, remove "/file_name", can be repeated */
22283 /* Don't remove the first "/" or "c:\" */
22285 {
22292 #ifdef VMS
22295 #endif
22297 {
22298 /* Result is empty. Turn it into "." to make ":cd %:h" work. */
22305 }
22306 else
22307 {
22310 }
22311 }
22313 /* ":8" - shortname */
22315 {
22317 #ifdef WIN3264
22319 #endif
22320 }
22322 #ifdef WIN3264
22323 /* Check shortname after we have done 'heads' and before we do 'tails'
22324 */
22326 {
22328 /* Copy the string if it is shortened by :h */
22330 {
22336 }
22338 /* Split into two implementations - makes it easier. First is where
22339 * there isn't a full name already, second is where there is.
22340 */
22342 {
22345 }
22346 else
22347 {
22350 /* Simple case, already have the full-name
22351 * Nearly always shorter, so try first time. */
22357 {
22358 /* Couldn't find the filename.. search the paths.
22359 */
22363 }
22365 }
22366 }
22369 /* ":t" - tail, just the basename */
22371 {
22375 }
22377 /* ":e" - extension, can be repeated */
22378 /* ":r" - root, without extension, can be repeated */
22381 {
22382 /* find a '.' in the tail:
22383 * - for second :e: before the current fname
22384 * - otherwise: The last '.'
22385 */
22388 else
22394 {
22396 {
22399 #ifdef VMS
22400 /* cut version from the extension */
22407 #endif
22408 }
22411 }
22413 {
22416 }
22418 }
22420 /* ":s?pat?foo?" - substitute */
22421 /* ":gs?pat?foo?" - global substitute */
22425 {
22436 {
22439 }
22443 {
22444 /* find end of pattern */
22447 {
22450 {
22452 /* find end of substitution */
22455 {
22459 {
22463 {
22469 }
22470 }
22473 }
22475 }
22476 }
22477 /* after using ":s", repeat all the modifiers */
22480 }
22481 }
22484 }
22486 /*
22487 * Perform a substitution on "str" with pattern "pat" and substitute "sub".
22488 * "flags" can be "g" to do a global substitute.
22489 * Returns an allocated string, NULL for error.
22490 */
22491 char_u *
22497 {
22499 regmatch_T regmatch;
22503 garray_T ga;
22507 /* Make 'cpoptions' empty, so that the 'l' flag doesn't work here */
22518 {
22521 {
22522 /*
22523 * Get some space for a temporary buffer to do the substitution
22524 * into. It will contain:
22525 * - The text up to where the match is.
22526 * - The substituted text.
22527 * - The text after the match.
22528 */
22532 {
22535 }
22537 /* copy the text up to where the match is */
22540 /* add the substituted text */
22544 /* avoid getting stuck on a match with an empty string */
22546 {
22551 }
22552 else
22553 {
22557 }
22560 }
22566 }
22573 }