开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编辑器/阅读器 > 查看源码
eval.c
资源名称：vim53src.zip　[点击查看]
上传用户：gddssl
上传日期：2007-01-06
资源大小：1003k
文件大小：93k
源码类别：

编辑器/阅读器

开发平台：

DOS

eval.c：源码内容
  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.  */
  9. /*
  10.  * eval.c: Expression evaluation.
  11.  */
  13. #include "vim.h"
  15. #ifdef HAVE_FCNTL_H
  16. # include <fcntl.h> /* contains setenv() declaration for Amiga */
  17. #endif
  18. #ifdef AMIGA
  19. # include <time.h> /* for strftime() */
  20. #endif
  22. #ifdef WANT_EVAL
  24. /*
  25.  * Structure to hold an internal variable.
  26.  */
  27. typedef struct
  28. {
  29.     char_u *var_name; /* name of variable */
  30.     char var_type; /* VAR_NUMBER or VAR_STRING */
  31.     union
  32.     {
  33. #if SIZEOF_INT <= 3 /* use long if int is smaller than 32 bits */
  34. long var_number; /* number value */
  35. #else
  36. int var_number; /* number value */
  37. #endif
  38. char_u *var_string; /* string value (Careful: can be NULL!) */
  39.     } var_val;
  40. } var;
  42. #define VAR_UNKNOWN 0
  43. #define VAR_NUMBER  1
  44. #define VAR_STRING  2
  46. typedef var * VAR;
  48. /*
  49.  * All user-defined internal variables are stored in "variables".
  50.  */
  51. struct growarray    variables = {0, 0, sizeof(var), 4, NULL};
  53. #define VAR_ENTRY(idx) (((VAR)(variables.ga_data))[idx])
  54. #define VAR_GAP_ENTRY(idx, gap) (((VAR)(gap->ga_data))[idx])
  55. #define BVAR_ENTRY(idx) (((VAR)(curbuf->b_vars.ga_data))[idx])
  56. #define WVAR_ENTRY(idx) (((VAR)(curwin->w_vars.ga_data))[idx])
  58. static int echo_attr = 0;   /* attributes used for ":echo" */
  60. /*
  61.  * Structure to hold info for a user function.
  62.  */
  63. struct ufunc
  64. {
  65.     struct ufunc *next; /* next function in list */
  66.     char_u *name; /* name of function */
  67.     int varargs; /* variable nr of arguments */
  68.     int flags;
  69.     struct growarray args; /* arguments */
  70.     struct growarray lines; /* function lines */
  71. };
  73. /* function flags */
  74. #define FC_ABORT    1 /* abort function on error */
  75. #define FC_RANGE    2 /* function accepts range */
  77. /*
  78.  * All user-defined functions are found in the forward-linked function list.
  79.  * The first function is pointed at by firstfunc.
  80.  */
  81. struct ufunc     *firstfunc = NULL;
  83. #define FUNCARG(fp, j) ((char_u **)(fp->args.ga_data))[j]
  84. #define FUNCLINE(fp, j) ((char_u **)(fp->lines.ga_data))[j]
  86. /* structure to hold info for a function that is currently being executed. */
  87. struct funccall
  88. {
  89.     struct ufunc *func; /* function being called */
  90.     int linenr; /* next line to be executed */
  91.     int argcount; /* nr of arguments */
  92.     VAR argvars; /* arguments */
  93.     var a0_var; /* "a:0" variable */
  94.     var firstline; /* "a:firstline" variable */
  95.     var lastline; /* "a:lastline" variable */
  96.     struct growarray l_vars; /* local function variables */
  97.     VAR retvar; /* return value variable */
  98. };
  100. /* pointer to funccal for currently active function */
  101. struct funccall *current_funccal = NULL;
  103. static char_u *cat_prefix_varname __ARGS((int prefix, char_u *name));
  104. static int eval0 __ARGS((char_u *arg,  VAR retvar, char_u **nextcmd));
  105. static int eval1 __ARGS((char_u **arg, VAR retvar));
  106. static int eval2 __ARGS((char_u **arg, VAR retvar));
  107. static int eval3 __ARGS((char_u **arg, VAR retvar));
  108. static int eval4 __ARGS((char_u **arg, VAR retvar));
  109. static int eval5 __ARGS((char_u **arg, VAR retvar));
  110. static int eval6 __ARGS((char_u **arg, VAR retvar));
  111. static int get_option_var __ARGS((char_u **arg, VAR retvar));
  112. static int get_string_var __ARGS((char_u **arg, VAR retvar));
  113. static int get_lit_string_var __ARGS((char_u **arg, VAR retvar));
  114. static int get_env_var __ARGS((char_u **arg, VAR retvar));
  115. static int get_func_var __ARGS((char_u *name, int len, VAR retvar, char_u **arg, linenr_t firstline, linenr_t lastline, int *doesrange));
  116. static void f_argc __ARGS((VAR argvars, VAR retvar));
  117. static void f_argv __ARGS((VAR argvars, VAR retvar));
  118. static void f_browse __ARGS((VAR argvars, VAR retvar));
  119. static void f_bufexists __ARGS((VAR argvars, VAR retvar));
  120. static BUF *get_buf_var __ARGS((VAR avar));
  121. static void f_bufname __ARGS((VAR argvars, VAR retvar));
  122. static void f_bufnr __ARGS((VAR argvars, VAR retvar));
  123. static void f_char2nr __ARGS((VAR argvars, VAR retvar));
  124. static void f_col __ARGS((VAR argvars, VAR retvar));
  125. static void f_confirm __ARGS((VAR argvars, VAR retvar));
  126. static void f_delete __ARGS((VAR argvars, VAR retvar));
  127. static void f_escape __ARGS((VAR argvars, VAR retvar));
  128. static void f_exists __ARGS((VAR argvars, VAR retvar));
  129. static void f_expand __ARGS((VAR argvars, VAR retvar));
  130. static void f_filereadable __ARGS((VAR argvars, VAR retvar));
  131. static void f_fnamemodify __ARGS((VAR argvars, VAR retvar));
  132. static void f_getcwd __ARGS((VAR argvars, VAR retvar));
  133. static void f_getline __ARGS((VAR argvars, VAR retvar));
  134. static void f_has __ARGS((VAR argvars, VAR retvar));
  135. static void f_hlexists __ARGS((VAR argvars, VAR retvar));
  136. static void f_hlID __ARGS((VAR argvars, VAR retvar));
  137. static void f_hostname __ARGS((VAR argvars, VAR retvar));
  138. static void f_isdirectory __ARGS((VAR argvars, VAR retvar));
  139. static void f_input __ARGS((VAR argvars, VAR retvar));
  140. static void f_last_buffer_nr __ARGS((VAR argvars, VAR retvar));
  141. static void f_line __ARGS((VAR argvars, VAR retvar));
  142. static void f_match __ARGS((VAR argvars, VAR retvar));
  143. static void f_matchend __ARGS((VAR argvars, VAR retvar));
  144. static void f_matchstr __ARGS((VAR argvars, VAR retvar));
  145. static void f_nr2char __ARGS((VAR argvars, VAR retvar));
  146. static void f_setline __ARGS((VAR argvars, VAR retvar));
  147. static void f_some_match __ARGS((VAR argvars, VAR retvar, int start));
  148. static void f_strftime __ARGS((VAR argvars, VAR retvar));
  149. static void f_strlen __ARGS((VAR argvars, VAR retvar));
  150. static void f_strpart __ARGS((VAR argvars, VAR retvar));
  151. static void f_synID __ARGS((VAR argvars, VAR retvar));
  152. static void f_synIDattr __ARGS((VAR argvars, VAR retvar));
  153. static void f_synIDtrans __ARGS((VAR argvars, VAR retvar));
  154. static void f_substitute __ARGS((VAR argvars, VAR retvar));
  155. static void f_tempname __ARGS((VAR argvars, VAR retvar));
  156. static void f_virtcol __ARGS((VAR argvars, VAR retvar));
  157. static void f_winbufnr __ARGS((VAR argvars, VAR retvar));
  158. static void f_winheight __ARGS((VAR argvars, VAR retvar));
  159. static void f_winnr __ARGS((VAR argvars, VAR retvar));
  160. static WIN *find_win_by_nr __ARGS((VAR vp));
  161. static FPOS *var2fpos __ARGS((VAR varp));
  162. static int get_env_len __ARGS((char_u **arg));
  163. char_u *get_env_string __ARGS((char_u **arg));
  164. static int get_id_len __ARGS((char_u **arg));
  165. static int eval_isnamec __ARGS((int c));
  166. static int get_var_var __ARGS((char_u *name, int len, VAR retvar));
  167. static VAR alloc_var __ARGS((void));
  168. static VAR alloc_string_var __ARGS((char_u *string));
  169. static void free_var __ARGS((VAR varp));
  170. static void clear_var __ARGS((VAR varp));
  171. static long get_var_number __ARGS((VAR varp));
  172. static char_u *get_var_string __ARGS((VAR varp));
  173. static char_u *get_var_string_buf __ARGS((VAR varp, char_u *buf));
  174. static VAR find_var __ARGS((char_u *name, int writing));
  175. static struct growarray *find_var_ga __ARGS((char_u *name, char_u **varname));
  176. static void var_free_one __ARGS((VAR v));
  177. static void list_one_var __ARGS((VAR v, char_u *prefix));
  178. static void set_var __ARGS((char_u *name, VAR varp));
  179. static char_u *find_option_end __ARGS((char_u *p));
  180. static void list_func_head __ARGS((struct ufunc *fp));
  181. static struct ufunc *find_func __ARGS((char_u *name));
  182. static void call_func __ARGS((struct ufunc *fp, int argcount, VAR argvars, VAR retvar, linenr_t firstline, linenr_t lastline));
  184. /*
  185.  * Set an internal variable to a string value. Creates the variable if it does
  186.  * not already exist.
  187.  */
  188.     void
  189. set_internal_string_var(name, value)
  190.     char_u *name;
  191.     char_u *value;
  192. {
  193.     char_u  *val;
  194.     VAR     varp;
  196.     val = vim_strsave(value);
  197.     if (val != NULL)
  198.     {
  199. varp = alloc_string_var(val);
  200. if (varp != NULL)
  201. {
  202.     set_var(name, varp);
  203.     free_var(varp);
  204. }
  205.     }
  206. }
  208. /*
  209.  * Top level evaluation function, returning a boolean.
  210.  * Sets "error" to TRUE if there was an error.
  211.  * Return TRUE or FALSE.
  212.  */
  213.     int
  214. eval_to_bool(arg, error, nextcmd)
  215.     char_u *arg;
  216.     int *error;
  217.     char_u **nextcmd;
  218. {
  219.     var retvar;
  220.     int retval;
  222.     if (eval0(arg, &retvar, nextcmd) == FAIL)
  223.     {
  224. *error = TRUE;
  225. retval = FALSE;
  226.     }
  227.     else
  228.     {
  229. *error = FALSE;
  230. retval = (get_var_number(&retvar) != 0);
  231. clear_var(&retvar);
  232.     }
  234.     return retval;
  235. }
  237. /*
  238.  * Top level evaluation function, returning a string.
  239.  * Return pointer to allocated memory, or NULL for failure.
  240.  */
  241.     char_u *
  242. eval_to_string(arg, nextcmd)
  243.     char_u *arg;
  244.     char_u **nextcmd;
  245. {
  246.     var retvar;
  247.     char_u *retval;
  249.     if (eval0(arg, &retvar, nextcmd) == FAIL)
  250. retval = NULL;
  251.     else
  252.     {
  253. retval = vim_strsave(get_var_string(&retvar));
  254. clear_var(&retvar);
  255.     }
  257.     return retval;
  258. }
  260. /*
  261.  * ":let var = expr" assignment command.
  262.  * ":let var" list one variable value
  263.  * ":let" list all variable values
  264.  */
  265.     void
  266. do_let(eap)
  267.     EXARG *eap;
  268. {
  269.     char_u *arg = eap->arg;
  270.     char_u *expr;
  271.     char_u *name;
  272.     VAR varp;
  273.     var retvar;
  274.     char_u *p;
  275.     int c1, c2;
  276.     int i;
  277. #ifndef HAVE_SETENV
  278.     char_u *envbuf;
  279. #endif
  281.     expr = vim_strchr(arg, '=');
  282.     if (expr == NULL)
  283.     {
  284. if (ends_excmd(*arg))
  285. {
  286.     if (!eap->skip)
  287.     {
  288. /*
  289.  * List all variables.
  290.  */
  291. for (i = 0; i < variables.ga_len; ++i)
  292.     if (VAR_ENTRY(i).var_name != NULL)
  293. list_one_var(&VAR_ENTRY(i), (char_u *)"");
  294. for (i = 0; i < curbuf->b_vars.ga_len; ++i)
  295.     if (BVAR_ENTRY(i).var_name != NULL)
  296. list_one_var(&BVAR_ENTRY(i), (char_u *)"b:");
  297. for (i = 0; i < curwin->w_vars.ga_len; ++i)
  298.     if (WVAR_ENTRY(i).var_name != NULL)
  299. list_one_var(&WVAR_ENTRY(i), (char_u *)"w:");
  300.     }
  301. }
  302. else
  303. {
  304.     /*
  305.      * List variables.
  306.      */
  307.     while (!ends_excmd(*arg))
  308.     {
  309. for (p = arg; eval_isnamec(*p); ++p)
  310.     ;
  311. if (!vim_iswhite(*p) && !ends_excmd(*p))
  312. {
  313.     EMSG(e_trailing);
  314.     break;
  315. }
  316. if (!eap->skip)
  317. {
  318.     c1 = *p;
  319.     *p = NUL;
  320.     varp = find_var(arg, FALSE);
  321.     if (varp == NULL)
  322. EMSG2("Unknown variable: "%s"", arg);
  323.     else
  324.     {
  325. name = vim_strchr(arg, ':');
  326. if (name != NULL)
  327. {
  328.     c2 = *++name;
  329.     *name = NUL;
  330.     list_one_var(varp, arg);
  331.     *name = c2;
  332. }
  333. else
  334.     list_one_var(varp, (char_u *)"");
  335.     }
  336.     *p = c1;
  337. }
  338. arg = skipwhite(p);
  339.     }
  340. }
  341. eap->nextcmd = check_nextcmd(arg);
  342.     }
  343.     else
  344.     {
  345. if (eap->skip)
  346.     ++emsg_off;
  347. i = eval0(expr + 1, &retvar, &eap->nextcmd);
  348. if (eap->skip)
  349. {
  350.     if (i != FAIL)
  351. clear_var(&retvar);
  352.     --emsg_off;
  353. }
  354. else if (i != FAIL)
  355. {
  356.     /*
  357.      * ":let $VAR = expr": Set environment variable.
  358.      */
  359.     if (*arg == '$')
  360.     {
  361. int len;
  362. int cc;
  364. /* Find the end of the name. */
  365. ++arg;
  366. name = arg;
  367. len = get_env_len(&arg);
  368. if (name != NULL)
  369. {
  370.     if (*skipwhite(arg) != '=')
  371. EMSG(e_letunexp);
  372.     else
  373.     {
  374. cc = name[len];
  375. name[len] = NUL;
  376. p = get_var_string(&retvar);
  377. #ifdef HAVE_SETENV
  378. mch_setenv((char *)name, (char *)p, 1);
  379. #else
  380. /*
  381.  * Putenv does not copy the string, it has to remain
  382.  * valid.  The allocated memory will never be freed.
  383.  */
  384. envbuf = alloc((unsigned)(STRLEN(p) +
  385.    STRLEN(name) + 2));
  386. if (envbuf != NULL)
  387. {
  388.     sprintf((char *)envbuf, "%s=%s", name, p);
  389.     putenv((char *)envbuf);
  390. }
  391. #endif
  392. if (STRICMP(name, "home") == 0)
  393.     init_homedir();
  394. name[len] = cc;
  395.     }
  396. }
  397.     }
  399.     /*
  400.      * ":let &option = expr": Set option value.
  401.      */
  402.     else if (*arg == '&')
  403.     {
  404. /*
  405.  * Find the end of the name;
  406.  */
  407. ++arg;
  408. p = find_option_end(arg);
  409. if (*skipwhite(p) != '=')
  410.     EMSG(e_letunexp);
  411. else
  412. {
  413.     c1 = *p;
  414.     *p = NUL;
  415.     set_option_value(arg, get_var_number(&retvar),
  416.      get_var_string(&retvar));
  417.     *p = c1;     /* put back for error messages */
  418. }
  419.     }
  421.     /*
  422.      * ":let @r = expr": Set register contents.
  423.      */
  424.     else if (*arg == '@')
  425.     {
  426. ++arg;
  427. if (*skipwhite(arg + 1) != '=')
  428.     EMSG(e_letunexp);
  429. else
  430.     write_reg_contents(*arg == '@' ? '"' : *arg,
  431.      get_var_string(&retvar));
  432.     }
  434.     /*
  435.      * ":let var = expr": Set internal variable.
  436.      */
  437.     else if (eval_isnamec(*arg) && !isdigit(*arg))
  438.     {
  439. /*
  440.  * Find the end of the name;
  441.  */
  442. for (p = arg; eval_isnamec(*p); ++p)
  443.     ;
  444. if (*skipwhite(p) != '=')
  445.     EMSG(e_letunexp);
  446. else
  447. {
  448.     c1 = *p;
  449.     *p = NUL;
  450.     set_var(arg, &retvar);
  451.     *p = c1; /* put char back for error messages */
  452. }
  453.     }
  455.     else
  456.     {
  457. EMSG2(e_invarg2, arg);
  458.     }
  460.     clear_var(&retvar);
  461. }
  462.     }
  463. }
  465. /*
  466.  * ":1,25call func(arg1, arg2)" function call.
  467.  */
  468.     void
  469. do_call(eap)
  470.     EXARG *eap;
  471. {
  472.     char_u *arg = eap->arg;
  473.     char_u *startarg;
  474.     char_u *name;
  475.     var retvar;
  476.     int len;
  477.     linenr_t lnum;
  478.     int doesrange;
  480.     name = arg;
  481.     len = get_id_len(&arg);
  482.     startarg = arg;
  484.     if (*startarg != '(')
  485.     {
  486. EMSG2("Missing braces: %s", name);
  487. return;
  488.     }
  490.     /*
  491.      * When skipping, evaluate the function once, to find the end of the
  492.      * arguments.
  493.      * When the function takes a range, this is discovered after the first
  494.      * call, and the loop is broken.
  495.      */
  496.     if (eap->skip)
  497. ++emsg_off;
  498.     for (lnum = eap->line1; lnum <= eap->line2; ++lnum)
  499.     {
  500. if (!eap->skip && eap->line1 != eap->line2)
  501. {
  502.     curwin->w_cursor.lnum = lnum;
  503.     curwin->w_cursor.col = 0;
  504. }
  505. arg = startarg;
  506. if (get_func_var(name, len, &retvar, &arg,
  507.   eap->line1, eap->line2, &doesrange) == FAIL)
  508.     break;
  509. clear_var(&retvar);
  510. if (doesrange || eap->skip)
  511.     break;
  512.     }
  513.     if (eap->skip)
  514. --emsg_off;
  515.     eap->nextcmd = check_nextcmd(arg);
  516. }
  518. /*
  519.  * ":unlet[!] var1 ... " command.
  520.  */
  521.     void
  522. do_unlet(arg, forceit)
  523.     char_u *arg;
  524.     int forceit;
  525. {
  526.     char_u *name_end;
  527.     VAR v;
  528.     char_u cc;
  530.     do
  531.     {
  532. name_end = skiptowhite(arg);
  533. cc = *name_end;
  534. *name_end = NUL;
  536. v = find_var(arg, TRUE);
  537. if (v != NULL)     /* existing variable, may need to free string */
  538.     var_free_one(v);
  539. else if (!forceit)  /* non-existing variable */
  540. {
  541.     *name_end = cc;
  542.     EMSG2("No such variable: "%s"", arg);
  543.     break;
  544. }
  546. *name_end = cc;
  547. arg = skipwhite(name_end);
  548.     } while (*arg != NUL);
  549. }
  551. /*
  552.  * Local string buffer for the next two functions to store a variable name
  553.  * with its prefix. Allocated in cat_prefix_varname(), freed later in
  554.  * get_user_var_name().
  555.  */
  557. static char_u *varnamebuf = NULL;
  558. static int varnamebuflen = 0;
  560. /*
  561.  * Function to concatenate a prefix and a variable name.
  562.  * TODO: Use string instead of char for 'prefix' when allowing 'b3:' like vars.
  563.  */
  564.     static char_u *
  565. cat_prefix_varname(prefix, name)
  566.     int prefix;
  567.     char_u *name;
  568. {
  569.     int len;
  571.     len = STRLEN( name ) + 3;
  572.     if ( len > varnamebuflen )
  573.     {
  574. vim_free(varnamebuf);
  575. len += 10; /* some additional space */
  576. varnamebuf = alloc(len);
  577. if (varnamebuf)
  578.     varnamebuflen = len;
  579. else
  580. {
  581.     varnamebuflen = 0;
  582.     return NULL;
  583. }
  584.     }
  585.     *varnamebuf = prefix;
  586.     varnamebuf[1] = ':';
  587.     STRCPY(varnamebuf+2, name);
  588.     return varnamebuf;
  589. }
  591. /*
  592.  * Function given to ExpandGeneric() to obtain the list of user defined
  593.  * (global/buffer/window) variable names.
  594.  */
  595.     char_u *
  596. get_user_var_name(idx)
  597.     int     idx;
  598. {
  599.     if (idx < variables.ga_len) /* Global variables */
  600. return VAR_ENTRY(idx).var_name;
  601. /* Current buffer variables */
  602.     else if ((idx -= variables.ga_len) < curbuf->b_vars.ga_len)
  603. return cat_prefix_varname('b', BVAR_ENTRY(idx).var_name);
  604. /* Current window variables */
  605.     else if ((idx -= curbuf->b_vars.ga_len) < curwin->w_vars.ga_len)
  606. return cat_prefix_varname('w', WVAR_ENTRY(idx).var_name);
  607.     else
  608.     {
  609. vim_free(varnamebuf);
  610. varnamebuf = NULL;
  611. varnamebuflen = 0;
  612. return NULL;
  613.     }
  614. }
  616. /*
  617.  * types for expressions.
  618.  */
  619. enum exp_type
  620. {
  621.     TYPE_UNKNOWN = 0,
  622.     TYPE_EQUAL, /* == */
  623.     TYPE_NEQUAL, /* != */
  624.     TYPE_GREATER, /* >  */
  625.     TYPE_GEQUAL, /* >= */
  626.     TYPE_SMALLER, /* <  */
  627.     TYPE_SEQUAL, /* <= */
  628.     TYPE_MATCH, /* =~ */
  629.     TYPE_NOMATCH /* !~ */
  630. };
  632. /*
  633.  * Handle zero level expression.
  634.  * This calls eval1() and handles error message and nextcmd.
  635.  * Return OK or FAIL.
  636.  */
  637.     static int
  638. eval0(arg, retvar, nextcmd)
  639.     char_u *arg;
  640.     VAR retvar;
  641.     char_u **nextcmd;
  642. {
  643.     int ret;
  644.     char_u *p;
  646.     p = skipwhite(arg);
  647.     ret = eval1(&p, retvar);
  648.     if (ret == FAIL || !ends_excmd(*p))
  649.     {
  650. if (ret != FAIL)
  651.     clear_var(retvar);
  652. EMSG2(e_invexpr2, arg);
  653. ret = FAIL;
  654.     }
  655.     if (nextcmd != NULL)
  656. *nextcmd = check_nextcmd(p);
  658.     return ret;
  659. }
  661. /*
  662.  * Handle first level expression:
  663.  * expr2 || expr2 || expr2     logical OR
  664.  *
  665.  * "arg" must point to the first non-white of the expression.
  666.  * "arg" is advanced to the next non-white after the recognized expression.
  667.  *
  668.  * Return OK or FAIL.
  669.  */
  670.     static int
  671. eval1(arg, retvar)
  672.     char_u **arg;
  673.     VAR retvar;
  674. {
  675.     var var2;
  676.     long n1, n2;
  678.     /*
  679.      * Get the first variable.
  680.      */
  681.     if (eval2(arg, retvar) == FAIL)
  682. return FAIL;
  684.     /*
  685.      * Repeat until there is no following "||".
  686.      */
  687.     while ((*arg)[0] == '|' && (*arg)[1] == '|')
  688.     {
  689. n1 = get_var_number(retvar);
  690. clear_var(retvar);
  692. /*
  693.  * Get the second variable.
  694.  */
  695. *arg = skipwhite(*arg + 2);
  696. if (eval2(arg, &var2) == FAIL)
  697.     return FAIL;
  699. /*
  700.  * Compute the result.
  701.  */
  702. n2 = get_var_number(&var2);
  703. clear_var(&var2);
  704. retvar->var_type = VAR_NUMBER;
  705. retvar->var_val.var_number = (n1 || n2);
  706.     }
  708.     return OK;
  709. }
  711. /*
  712.  * Handle second level expression:
  713.  * expr3 && expr3 && expr3     logical AND
  714.  *
  715.  * "arg" must point to the first non-white of the expression.
  716.  * "arg" is advanced to the next non-white after the recognized expression.
  717.  *
  718.  * Return OK or FAIL.
  719.  */
  720.     static int
  721. eval2(arg, retvar)
  722.     char_u **arg;
  723.     VAR retvar;
  724. {
  725.     var var2;
  726.     long n1, n2;
  728.     /*
  729.      * Get the first variable.
  730.      */
  731.     if (eval3(arg, retvar) == FAIL)
  732. return FAIL;
  734.     /*
  735.      * Repeat until there is no following "&&".
  736.      */
  737.     while ((*arg)[0] == '&' && (*arg)[1] == '&')
  738.     {
  739. n1 = get_var_number(retvar);
  740. clear_var(retvar);
  742. /*
  743.  * Get the second variable.
  744.  */
  745. *arg = skipwhite(*arg + 2);
  746. if (eval3(arg, &var2) == FAIL)
  747.     return FAIL;
  749. /*
  750.  * Compute the result.
  751.  */
  752. n2 = get_var_number(&var2);
  753. clear_var(&var2);
  754. retvar->var_type = VAR_NUMBER;
  755. retvar->var_val.var_number = (n1 && n2);
  756.     }
  758.     return OK;
  759. }
  761. /*
  762.  * Handle third level expression:
  763.  * var1 == var2
  764.  * var1 =~ var2
  765.  * var1 != var2
  766.  * var1 !~ var2
  767.  * var1 > var2
  768.  * var1 >= var2
  769.  * var1 < var2
  770.  * var1 <= var2
  771.  *
  772.  * "arg" must point to the first non-white of the expression.
  773.  * "arg" is advanced to the next non-white after the recognized expression.
  774.  *
  775.  * Return OK or FAIL.
  776.  */
  777.     static int
  778. eval3(arg, retvar)
  779.     char_u **arg;
  780.     VAR retvar;
  781. {
  782.     var var2;
  783.     char_u *p;
  784.     int i = 0;
  785.     enum exp_type type = TYPE_UNKNOWN;
  786.     int len = 2;
  787.     long n1 = FALSE, n2;
  788.     char_u *s1, *s2;
  789.     char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
  790.     vim_regexp *prog;
  792.     /*
  793.      * Get the first variable.
  794.      */
  795.     if (eval4(arg, retvar) == FAIL)
  796. return FAIL;
  798.     p = *arg;
  799.     switch (p[0])
  800.     {
  801. case '=':   if (p[1] == '=')
  802. type = TYPE_EQUAL;
  803.     else if (p[1] == '~')
  804. type = TYPE_MATCH;
  805.     break;
  806. case '!':   if (p[1] == '=')
  807. type = TYPE_NEQUAL;
  808.     else if (p[1] == '~')
  809. type = TYPE_NOMATCH;
  810.     break;
  811. case '>':   if (p[1] != '=')
  812.     {
  813. type = TYPE_GREATER;
  814. len = 1;
  815.     }
  816.     else
  817. type = TYPE_GEQUAL;
  818.     break;
  819. case '<':   if (p[1] != '=')
  820.     {
  821. type = TYPE_SMALLER;
  822. len = 1;
  823.     }
  824.     else
  825. type = TYPE_SEQUAL;
  826.     break;
  827.     }
  829.     /*
  830.      * If there is a comparitive operator, use it.
  831.      */
  832.     if (type != TYPE_UNKNOWN)
  833.     {
  834. /*
  835.  * Get the second variable.
  836.  */
  837. *arg = skipwhite(p + len);
  838. if (eval4(arg, &var2) == FAIL)
  839. {
  840.     clear_var(retvar);
  841.     return FAIL;
  842. }
  844. /*
  845.  * If one of the two variables is a number, compare as a number.
  846.  * When using "=~" or "!~", always compare as string.
  847.  */
  848. if ((retvar->var_type == VAR_NUMBER || var2.var_type == VAR_NUMBER)
  849. && type != TYPE_MATCH && type != TYPE_NOMATCH)
  850. {
  851.     n1 = get_var_number(retvar);
  852.     n2 = get_var_number(&var2);
  853.     switch (type)
  854.     {
  855. case TYPE_EQUAL:    n1 = (n1 == n2); break;
  856. case TYPE_NEQUAL:   n1 = (n1 != n2); break;
  857. case TYPE_GREATER:  n1 = (n1 > n2); break;
  858. case TYPE_GEQUAL:   n1 = (n1 >= n2); break;
  859. case TYPE_SMALLER:  n1 = (n1 < n2); break;
  860. case TYPE_SEQUAL:   n1 = (n1 <= n2); break;
  861. case TYPE_UNKNOWN:
  862. case TYPE_MATCH:
  863. case TYPE_NOMATCH:  break;  /* avoid gcc warning */
  864.     }
  865. }
  866. else
  867. {
  868.     s1 = get_var_string_buf(retvar, buf1);
  869.     s2 = get_var_string_buf(&var2, buf2);
  870.     if (type != TYPE_MATCH && type != TYPE_NOMATCH)
  871. i = STRCMP(s1, s2);
  872.     switch (type)
  873.     {
  874. case TYPE_EQUAL:    n1 = (i == 0); break;
  875. case TYPE_NEQUAL:   n1 = (i != 0); break;
  876. case TYPE_GREATER:  n1 = (i > 0); break;
  877. case TYPE_GEQUAL:   n1 = (i >= 0); break;
  878. case TYPE_SMALLER:  n1 = (i < 0); break;
  879. case TYPE_SEQUAL:   n1 = (i <= 0); break;
  880. case TYPE_MATCH:
  881. case TYPE_NOMATCH:  reg_ic = p_ic;
  882.     prog = vim_regcomp(s2, TRUE);
  883.     if (prog != NULL)
  884.     {
  885. n1 = vim_regexec(prog, s1, TRUE);
  886. vim_free(prog);
  887. if (type == TYPE_NOMATCH)
  888.     n1 = !n1;
  889.     }
  890.     break;
  891. case TYPE_UNKNOWN:  break;  /* avoid gcc warning */
  892.     }
  893. }
  894. clear_var(retvar);
  895. clear_var(&var2);
  896. retvar->var_type = VAR_NUMBER;
  897. retvar->var_val.var_number = n1;
  898.     }
  900.     return OK;
  901. }
  903. /*
  904.  * Handle fourth level expression:
  905.  * + number addition
  906.  * - number subtraction
  907.  * . string concatenation
  908.  *
  909.  * "arg" must point to the first non-white of the expression.
  910.  * "arg" is advanced to the next non-white after the recognized expression.
  911.  *
  912.  * Return OK or FAIL.
  913.  */
  914.     static int
  915. eval4(arg, retvar)
  916.     char_u **arg;
  917.     VAR retvar;
  918. {
  919.     var var2;
  920.     int op;
  921.     long n1, n2;
  922.     char_u *s1, *s2;
  923.     char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
  924.     char_u *p;
  926.     /*
  927.      * Get the first variable.
  928.      */
  929.     if (eval5(arg, retvar) == FAIL)
  930. return FAIL;
  932.     /*
  933.      * Repeat computing, until no '+', '-' or '.' is following.
  934.      */
  935.     for (;;)
  936.     {
  937. op = **arg;
  938. if (op != '+' && op != '-' && op != '.')
  939.     break;
  941. /*
  942.  * Get the second variable.
  943.  */
  944. *arg = skipwhite(*arg + 1);
  945. if (eval5(arg, &var2) == FAIL)
  946. {
  947.     clear_var(retvar);
  948.     return FAIL;
  949. }
  951. /*
  952.  * Compute the result.
  953.  */
  954. if (op == '.')
  955. {
  956.     s1 = get_var_string_buf(retvar, buf1);
  957.     s2 = get_var_string_buf(&var2, buf2);
  958.     p = alloc((unsigned)(STRLEN(s1) + STRLEN(s2) + 1));
  959.     if (p != NULL)
  960.     {
  961. STRCPY(p, s1);
  962. STRCAT(p, s2);
  963.     }
  964.     clear_var(retvar);
  965.     retvar->var_type = VAR_STRING;
  966.     retvar->var_val.var_string = p;
  967. }
  968. else
  969. {
  970.     n1 = get_var_number(retvar);
  971.     n2 = get_var_number(&var2);
  972.     clear_var(retvar);
  973.     if (op == '+')
  974. n1 = n1 + n2;
  975.     else
  976. n1 = n1 - n2;
  977.     retvar->var_type = VAR_NUMBER;
  978.     retvar->var_val.var_number = n1;
  979. }
  980. clear_var(&var2);
  981.     }
  982.     return OK;
  983. }
  985. /*
  986.  * Handle fifth level expression:
  987.  * * number multiplication
  988.  * / number division
  989.  * % number modulo
  990.  *
  991.  * "arg" must point to the first non-white of the expression.
  992.  * "arg" is advanced to the next non-white after the recognized expression.
  993.  *
  994.  * Return OK or FAIL.
  995.  */
  996.     static int
  997. eval5(arg, retvar)
  998.     char_u **arg;
  999.     VAR retvar;
  1000. {
  1001.     var var2;
  1002.     int op;
  1003.     long n1, n2;
  1005.     /*
  1006.      * Get the first variable.
  1007.      */
  1008.     if (eval6(arg, retvar) == FAIL)
  1009. return FAIL;
  1011.     /*
  1012.      * Repeat computing, until no '*', '/' or '%' is following.
  1013.      */
  1014.     for (;;)
  1015.     {
  1016. op = **arg;
  1017. if (op != '*' && op != '/' && op != '%')
  1018.     break;
  1020. n1 = get_var_number(retvar);
  1021. clear_var(retvar);
  1023. /*
  1024.  * Get the second variable.
  1025.  */
  1026. *arg = skipwhite(*arg + 1);
  1027. if (eval6(arg, &var2) == FAIL)
  1028.     return FAIL;
  1029. n2 = get_var_number(&var2);
  1030. clear_var(&var2);
  1032. /*
  1033.  * Compute the result.
  1034.  */
  1035. if (op == '*')
  1036.     n1 = n1 * n2;
  1037. else if (op == '/')
  1038. {
  1039.     if (n2 == 0) /* give an error message? */
  1040. n1 = 0x7fffffff;
  1041.     else
  1042. n1 = n1 / n2;
  1043. }
  1044. else
  1045. {
  1046.     if (n2 == 0) /* give an error message? */
  1047. n1 = 0;
  1048.     else
  1049. n1 = n1 % n2;
  1050. }
  1051. retvar->var_type = VAR_NUMBER;
  1052. retvar->var_val.var_number = n1;
  1053.     }
  1055.     return OK;
  1056. }
  1058. /*
  1059.  * Handle sixth level expression:
  1060.  *  number number constant
  1061.  *  "string" string contstant
  1062.  *  *option-name option value
  1063.  *  @r register contents
  1064.  *  identifier variable value
  1065.  *  $VAR environment variable
  1066.  *  (expression) nested expression
  1067.  *
  1068.  *  Also handle:
  1069.  *  ! in front logical NOT
  1070.  *  - in front unary minus
  1071.  *  trailing [] subscript in String
  1072.  *
  1073.  * "arg" must point to the first non-white of the expression.
  1074.  * "arg" is advanced to the next non-white after the recognized expression.
  1075.  *
  1076.  * Return OK or FAIL.
  1077.  */
  1078.     static int
  1079. eval6(arg, retvar)
  1080.     char_u **arg;
  1081.     VAR retvar;
  1082. {
  1083.     var var2;
  1084.     long n;
  1085.     int len;
  1086.     char_u *s;
  1087.     int val;
  1088.     char_u *start_leader, *end_leader;
  1089.     int ret = OK;
  1091.     /*
  1092.      * Skip '!' and '-' characters.  They are handled later.
  1093.      */
  1094.     start_leader = *arg;
  1095.     while (**arg == '!' || **arg == '-')
  1096. *arg = skipwhite(*arg + 1);
  1097.     end_leader = *arg;
  1099.     switch (**arg)
  1100.     {
  1101.     /*
  1102.      * Number constant.
  1103.      */
  1104.     case '0':
  1105.     case '1':
  1106.     case '2':
  1107.     case '3':
  1108.     case '4':
  1109.     case '5':
  1110.     case '6':
  1111.     case '7':
  1112.     case '8':
  1113.     case '9':
  1114. retvar->var_type = VAR_NUMBER;
  1115. vim_str2nr(*arg, NULL, &len, TRUE, TRUE, &n, NULL);
  1116. retvar->var_val.var_number = n;
  1117. *arg += len;
  1118. break;
  1120.     /*
  1121.      * String constant: "string".
  1122.      */
  1123.     case '"': ret = get_string_var(arg, retvar);
  1124. break;
  1126.     /*
  1127.      * Literal string constant: 'string'.
  1128.      */
  1129.     case ''': ret = get_lit_string_var(arg, retvar);
  1130. break;
  1132.     /*
  1133.      * Option value: &name
  1134.      */
  1135.     case '&': ret = get_option_var(arg, retvar);
  1136. break;
  1138.     /*
  1139.      * Environment variable: $VAR.
  1140.      */
  1141.     case '$': ret = get_env_var(arg, retvar);
  1142. break;
  1144.     /*
  1145.      * Register contents: @r.
  1146.      */
  1147.     case '@': retvar->var_type = VAR_STRING;
  1148. retvar->var_val.var_string = get_reg_contents(*++*arg);
  1149. if (**arg != NUL)
  1150.     ++*arg;
  1151. break;
  1153.     /*
  1154.      * nested expression: (expression).
  1155.      */
  1156.     case '(': *arg = skipwhite(*arg + 1);
  1157. ret = eval1(arg, retvar); /* recursive! */
  1158. if (**arg != ')')
  1159.     EMSG("Missing ')'");
  1160. else
  1161.     ++*arg;
  1162. break;
  1164.     /*
  1165.      * Must be a variable or function name then.
  1166.      */
  1167.     default: s = *arg;
  1168. len = get_id_len(arg);
  1169. if (len)
  1170. {
  1171.     if (**arg == '(') /* recursive! */
  1172. ret = get_func_var(s, len, retvar, arg,
  1173.   curwin->w_cursor.lnum, curwin->w_cursor.lnum, &len);
  1174.     else
  1175. ret = get_var_var(s, len, retvar);
  1176. }
  1177. else
  1178.     ret = FAIL;
  1179. break;
  1180.     }
  1181.     *arg = skipwhite(*arg);
  1183.     /*
  1184.      * Handle expr[expr] subscript.
  1185.      */
  1186.     if (**arg == '[' && ret == OK)
  1187.     {
  1188. /*
  1189.  * Get the variable from inside the [].
  1190.  */
  1191. *arg = skipwhite(*arg + 1);
  1192. if (eval1(arg, &var2) == FAIL) /* recursive! */
  1193. {
  1194.     clear_var(retvar);
  1195.     return FAIL;
  1196. }
  1197. n = get_var_number(&var2);
  1198. clear_var(&var2);
  1200. /* Check for the ']'. */
  1201. if (**arg != ']')
  1202. {
  1203.     EMSG("Missing ']'");
  1204.     clear_var(retvar);
  1205.     return FAIL;
  1206. }
  1208. /*
  1209.  * The resulting variable is a string of a single character.
  1210.  * If the index is too big or negative, the result is empty.
  1211.  */
  1212. s = get_var_string(retvar);
  1213. if (n >= (long)STRLEN(s) || n < 0)
  1214.     s = NULL;
  1215. else
  1216.     s = vim_strnsave(s + n, 1);
  1217. clear_var(retvar);
  1218. retvar->var_type = VAR_STRING;
  1219. retvar->var_val.var_string = s;
  1221. *arg = skipwhite(*arg + 1); /* skip the ']' */
  1222.     }
  1224.     /*
  1225.      * Apply logical NOT and unary '-', from right to left.
  1226.      */
  1227.     if (ret == OK && end_leader > start_leader)
  1228.     {
  1229. val = get_var_number(retvar);
  1230. while (end_leader > start_leader)
  1231. {
  1232.     --end_leader;
  1233.     if (*end_leader == '!')
  1234. val = !val;
  1235.     else if (*end_leader == '-')
  1236. val = -val;
  1237. }
  1238. clear_var(retvar);
  1239. retvar->var_type = VAR_NUMBER;
  1240. retvar->var_val.var_number = val;
  1241.     }
  1243.     return ret;
  1244. }
  1246. /*
  1247.  * Get an option value.
  1248.  * "arg" points to the '&' before the option name.
  1249.  * "arg" is advanced to character after the option name.
  1250.  * Return OK or FAIL.
  1251.  */
  1252.     static int
  1253. get_option_var(arg, retvar)
  1254.     char_u **arg;
  1255.     VAR retvar; /* when NULL, only check if option exists */
  1256. {
  1257.     char_u *option_end;
  1258.     long numval;
  1259.     char_u *stringval;
  1260.     int opt_type;
  1261.     int c;
  1262.     int ret = OK;
  1264.     /*
  1265.      * Isolate the option name and find its value.
  1266.      */
  1267.     option_end = find_option_end(*arg + 1);
  1268.     if (option_end == *arg + 1)
  1269.     {
  1270. if (retvar != NULL)
  1271.     EMSG2("Option name missing: %s", *arg);
  1272. return FAIL;
  1273.     }
  1275.     c = *option_end;
  1276.     *option_end = NUL;
  1277.     opt_type = get_option_value(*arg + 1, &numval,
  1278.   retvar == NULL ? NULL : &stringval);
  1280.     if (opt_type < 0)     /* invalid name */
  1281.     {
  1282. if (retvar != NULL)
  1283.     EMSG2("Unknown option: %s", *arg + 1);
  1284. ret = FAIL;
  1285.     }
  1286.     else if (retvar != NULL)
  1287.     {
  1288. if (opt_type == 1) /* number option */
  1289. {
  1290.     retvar->var_type = VAR_NUMBER;
  1291.     retvar->var_val.var_number = numval;
  1292. }
  1293. else /* string option */
  1294. {
  1295.     retvar->var_type = VAR_STRING;
  1296.     retvar->var_val.var_string = stringval;
  1297. }
  1298.     }
  1300.     *option_end = c;     /* put back for error messages */
  1301.     *arg = option_end;
  1303.     return ret;
  1304. }
  1306. /*
  1307.  * Allocate a variable for an string constant.
  1308.  * Return OK or FAIL.
  1309.  */
  1310.     static int
  1311. get_string_var(arg, retvar)
  1312.     char_u **arg;
  1313.     VAR retvar;
  1314. {
  1315.     char_u *p;
  1316.     char_u *name;
  1317.     int i;
  1318.     int extra = 0;
  1320.     /*
  1321.      * Find the end of the string, skipping backslashed characters.
  1322.      */
  1323.     for (p = *arg + 1; *p && *p != '"'; ++p)
  1324. if (*p == '\' && p[1] != NUL)
  1325. {
  1326.     ++p;
  1327.     /* A "<x>" form occupies at least 4 characters, and produces up
  1328.      * to 6 characters: reserve space for 2 extra */
  1329.     if (*p == '<')
  1330. extra += 2;
  1331. }
  1332.     if (*p != '"')
  1333.     {
  1334. EMSG2("Missing quote: %s", *arg);
  1335. return FAIL;
  1336.     }
  1338.     /*
  1339.      * Copy the string into allocated memory, handling backslashed
  1340.      * characters.
  1341.      */
  1342.     name = alloc((unsigned)(p - *arg + extra));
  1343.     if (name == NULL)
  1344. return FAIL;
  1346.     i = 0;
  1347.     for (p = *arg + 1; *p && *p != '"'; ++p)
  1348.     {
  1349. if (*p == '\')
  1350. {
  1351.     switch (*++p)
  1352.     {
  1353. case 'b': name[i++] = BS; break;
  1354. case 'e': name[i++] = ESC; break;
  1355. case 'f': name[i++] = FF; break;
  1356. case 'n': name[i++] = NL; break;
  1357. case 'r': name[i++] = CR; break;
  1358. case 't': name[i++] = TAB; break;
  1360.   /* hex: "x1", "x12" */
  1361. case 'X':
  1362. case 'x': if (isxdigit(p[1]))
  1363.   {
  1364.       ++p;
  1365.       name[i] = hex2nr(*p);
  1366.       if (isxdigit(p[1]))
  1367.       {
  1368.   ++p;
  1369.   name[i] = (name[i] << 4) + hex2nr(*p);
  1370.       }
  1371.       ++i;
  1372.   }
  1373.   else
  1374.       name[i++] = *p;
  1375.   break;
  1377.   /* octal: "1", "12", "123" */
  1378. case '0':
  1379. case '1':
  1380. case '2':
  1381. case '3':
  1382. case '4':
  1383. case '5':
  1384. case '6':
  1385. case '7': name[i] = *p - '0';
  1386.   if (p[1] >= '0' && p[1] <= '7')
  1387.   {
  1388.       ++p;
  1389.       name[i] = (name[i] << 3) + *p - '0';
  1390.       if (p[1] >= '0' && p[1] <= '7')
  1391.       {
  1392.   ++p;
  1393.   name[i] = (name[i] << 3) + *p - '0';
  1394.       }
  1395.   }
  1396.   ++i;
  1397.   break;
  1399.     /* Special key, e.g.: "<C-W>" */
  1400. case '<': extra = trans_special(&p, name + i, FALSE);
  1401.   if (extra)
  1402.   {
  1403.       i += extra;
  1404.       --p;
  1405.       break;
  1406.   }
  1407.   /* FALLTHROUGH */
  1409. default:  name[i++] = *p;
  1410.   break;
  1411.     }
  1412. }
  1413. else
  1414.     name[i++] = *p;
  1415.     }
  1416.     name[i] = NUL;
  1417.     *arg = p + 1;
  1419.     retvar->var_type = VAR_STRING;
  1420.     retvar->var_val.var_string = name;
  1422.     return OK;
  1423. }
  1425. /*
  1426.  * Allocate a variable for an backtick-string constant.
  1427.  * Return OK or FAIL.
  1428.  */
  1429.     static int
  1430. get_lit_string_var(arg, retvar)
  1431.     char_u **arg;
  1432.     VAR retvar;
  1433. {
  1434.     char_u *p;
  1435.     char_u *name;
  1437.     /*
  1438.      * Find the end of the string.
  1439.      */
  1440.     p = vim_strchr(*arg + 1, ''');
  1441.     if (p == NULL)
  1442.     {
  1443. EMSG2("Missing quote: %s", *arg);
  1444. return FAIL;
  1445.     }
  1447.     /*
  1448.      * Copy the string into allocated memory.
  1449.      */
  1450.     name = vim_strnsave(*arg + 1, (int)(p - (*arg + 1)));
  1451.     if (name == NULL)
  1452. return FAIL;
  1454.     *arg = p + 1;
  1456.     retvar->var_type = VAR_STRING;
  1457.     retvar->var_val.var_string = name;
  1459.     return OK;
  1460. }
  1462. /*
  1463.  * Get the value of an environment variable.
  1464.  * Return OK or FAIL.
  1465.  */
  1466.     static int
  1467. get_env_var(arg, retvar)
  1468.     char_u **arg;
  1469.     VAR retvar;
  1470. {
  1471.     char_u *string;
  1473.     string = get_env_string(arg);
  1475.     /*
  1476.      * Allocate a variable.  If the environment variable was not set, silently
  1477.      * assume it is empty.
  1478.      */
  1479.     if (string != NULL)
  1480. string = vim_strsave(string);
  1481.     retvar->var_type = VAR_STRING;
  1482.     retvar->var_val.var_string = string;
  1484.     return OK;
  1485. }
  1487. /*
  1488.  * Allocate a variable for the result of a function.
  1489.  * Return OK or FAIL.
  1490.  */
  1491.     static int
  1492. get_func_var(name, len, retvar, arg, firstline, lastline, doesrange)
  1493.     char_u *name; /* name of the function */
  1494.     int len; /* length of "name" */
  1495.     VAR retvar;
  1496.     char_u **arg; /* argument, pointing to the '(' */
  1497.     linenr_t firstline; /* first line of range */
  1498.     linenr_t lastline; /* last line of range */
  1499.     int *doesrange; /* return: function handled range */
  1500. {
  1501.     char_u *argp;
  1502.     int ret = FAIL;
  1503. #define MAX_FUNC_ARGS 20
  1504.     var argvars[MAX_FUNC_ARGS]; /* vars for arguments */
  1505.     int argcount = 0; /* number of arguments found */
  1506.     static char *errors[] =
  1507. {"Invalid arguments for function %s",
  1508.  "Unknown function: %s",
  1509.  "Too many arguments for function: %s",
  1510.  "Not enough arguments for function: %s",
  1511. };
  1512. #define ERROR_INVARG 0
  1513. #define ERROR_UNKOWN 1
  1514. #define ERROR_TOOMANY 2
  1515. #define ERROR_TOOFEW 3
  1516. #define ERROR_NONE 4
  1517. #define ERROR_OTHER 5
  1518.     int error = ERROR_NONE;
  1519.     int i;
  1520.     struct ufunc *fp;
  1521.     int cc;
  1522.     static struct fst
  1523.     {
  1524. char *f_name; /* function name */
  1525. char f_min_argc; /* minimal number of arguments */
  1526. char f_max_argc; /* miximal number of arguments */
  1527. void (*f_func) __ARGS((VAR args, VAR rvar));    /* impl. function */
  1528.     } functions[] =
  1529.     {
  1530. {"argc", 0, 0, f_argc},
  1531. {"argv", 1, 1, f_argv},
  1532. {"browse", 4, 4, f_browse},
  1533. {"buffer_exists", 1, 1, f_bufexists}, /* obsolete */
  1534. {"bufexists", 1, 1, f_bufexists},
  1535. {"buffer_name", 1, 1, f_bufname}, /* obsolete */
  1536. {"buffer_number", 1, 1, f_bufnr}, /* obsolete */
  1537. {"bufname", 1, 1, f_bufname},
  1538. {"bufnr", 1, 1, f_bufnr},
  1539. {"char2nr", 1, 1, f_char2nr},
  1540. {"col", 1, 1, f_col},
  1541. {"confirm", 2, 4, f_confirm},
  1542. {"delete", 1, 1, f_delete},
  1543. {"escape", 2, 2, f_escape},
  1544. {"exists", 1, 1, f_exists},
  1545. {"expand", 1, 1, f_expand},
  1546. {"file_readable", 1, 1, f_filereadable}, /* obsolete */
  1547. {"filereadable", 1, 1, f_filereadable},
  1548. {"fnamemodify", 2, 2, f_fnamemodify},
  1549. {"getcwd", 0, 0, f_getcwd},
  1550. {"getline", 1, 1, f_getline},
  1551. {"has", 1, 1, f_has},
  1552. {"highlight_exists", 1, 1, f_hlexists}, /* obsolete */
  1553. {"highlightID", 1, 1, f_hlID}, /* obsolete */
  1554. {"hlexists", 1, 1, f_hlexists},
  1555. {"hlID", 1, 1, f_hlID},
  1556. {"hostname", 0, 0, f_hostname},
  1557. {"input", 1, 1, f_input },
  1558. {"isdirectory", 1, 1, f_isdirectory},
  1559. {"last_buffer_nr", 0, 0, f_last_buffer_nr},/* obsolete */
  1560. {"line", 1, 1, f_line},
  1561. {"match", 2, 2, f_match},
  1562. {"matchend", 2, 2, f_matchend},
  1563. {"matchstr", 2, 2, f_matchstr},
  1564. {"nr2char", 1, 1, f_nr2char},
  1565. {"setline", 2, 2, f_setline},
  1566. #ifdef HAVE_STRFTIME
  1567. {"strftime", 1, 1, f_strftime},
  1568. #endif
  1569. {"strlen", 1, 1, f_strlen},
  1570. {"strpart", 3, 3, f_strpart},
  1571. {"synID", 3, 3, f_synID},
  1572. {"synIDattr", 2, 3, f_synIDattr},
  1573. {"synIDtrans", 1, 1, f_synIDtrans},
  1574. {"substitute", 4, 4, f_substitute},
  1575. {"tempname", 0, 0, f_tempname},
  1576. {"virtcol", 1, 1, f_virtcol},
  1577. {"winbufnr", 1, 1, f_winbufnr},
  1578. {"winheight", 1, 1, f_winheight},
  1579. {"winnr", 0, 0, f_winnr},
  1580.     };
  1582.     cc = name[len];
  1583.     name[len] = NUL;
  1584.     *doesrange = FALSE;
  1586.     /*
  1587.      * Get the arguments.
  1588.      */
  1589.     argp = *arg;
  1590.     while (argcount < MAX_FUNC_ARGS)
  1591.     {
  1592. argp = skipwhite(argp + 1);     /* skip the '(' or ',' */
  1593. if (*argp == ')' || *argp == ',' || *argp == NUL)
  1594.     break;
  1595. if (eval1(&argp, &argvars[argcount]) == FAIL)
  1596. {
  1597.     error = ERROR_OTHER;
  1598.     break;
  1599. }
  1600. ++argcount;
  1601. if (*argp != ',')
  1602.     break;
  1603.     }
  1604.     if (*argp != ')' && error == ERROR_NONE)
  1605. error = ERROR_INVARG;
  1607.     /* execute the function if no errors detected and executing */
  1608.     if (error == ERROR_NONE && !emsg_off)
  1609.     {
  1610. retvar->var_type = VAR_NUMBER; /* default is number retvar */
  1612. error = ERROR_UNKOWN;
  1613. if (!islower(name[0]))
  1614. {
  1615.     /*
  1616.      * User defined function.
  1617.      */
  1618.     fp = find_func(name);
  1619.     if (fp != NULL)
  1620.     {
  1621. if (fp->flags & FC_RANGE)
  1622.     *doesrange = TRUE;
  1623. if (argcount < fp->args.ga_len)
  1624.     error = ERROR_TOOFEW;
  1625. else if (!fp->varargs && argcount > fp->args.ga_len)
  1626.     error = ERROR_TOOMANY;
  1627. else
  1628. {
  1629.     /*
  1630.      * Call the user function.
  1631.      * Save and restore search patterns and redo buffer.
  1632.      */
  1633.     save_search_patterns();
  1634.     saveRedobuff();
  1635.     call_func(fp, argcount, argvars, retvar,
  1636.  firstline, lastline);
  1637.     restoreRedobuff();
  1638.     restore_search_patterns();
  1639.     error = ERROR_NONE;
  1640. }
  1641.     }
  1642. }
  1643. else
  1644. {
  1645.     /*
  1646.      * Find the function name in the table, call its implementation.
  1647.      */
  1648.     for (i = 0; i < (int)(sizeof(functions) / sizeof(struct fst)); ++i)
  1649. if (STRCMP(name, functions[i].f_name) == 0)
  1650. {
  1651.     if (argcount < functions[i].f_min_argc)
  1652. error = ERROR_TOOFEW;
  1653.     else if (argcount > functions[i].f_max_argc)
  1654. error = ERROR_TOOMANY;
  1655.     else
  1656.     {
  1657. argvars[argcount].var_type = VAR_UNKNOWN;
  1658. functions[i].f_func(argvars, retvar);
  1659. error = ERROR_NONE;
  1660.     }
  1661.     break;
  1662. }
  1663. }
  1665. *arg = skipwhite(argp + 1);
  1666. if (error == ERROR_NONE)
  1667.     ret = OK;
  1668.     }
  1670.     while (--argcount >= 0)
  1671. clear_var(&argvars[argcount]);
  1673.     if (error < ERROR_NONE)
  1674. EMSG2((char_u *)errors[error], name);
  1676.     name[len] = cc;
  1678.     return ret;
  1679. }
  1681. /*
  1682.  * "argc()" function.
  1683.  */
  1684. /* ARGSUSED */
  1685.     static void
  1686. f_argc(argvars, retvar)
  1687.     VAR argvars;
  1688.     VAR retvar;
  1689. {
  1690.     retvar->var_val.var_number = arg_file_count;
  1691. }
  1693. /*
  1694.  * "argv()" function.
  1695.  */
  1696.     static void
  1697. f_argv(argvars, retvar)
  1698.     VAR argvars;
  1699.     VAR retvar;
  1700. {
  1701.     int idx;
  1703.     idx = get_var_number(&argvars[0]);
  1704.     if (idx >= 0 && idx < arg_file_count)
  1705. retvar->var_val.var_string = vim_strsave(arg_files[idx]);
  1706.     else
  1707. retvar->var_val.var_string = NULL;
  1708.     retvar->var_type = VAR_STRING;
  1709. }
  1711.     static BUF *
  1712. get_buf_var(avar)
  1713.     VAR avar;
  1714. {
  1715.     char_u *name = avar->var_val.var_string;
  1717.     if (avar->var_type == VAR_NUMBER)
  1718. return buflist_findnr((int)avar->var_val.var_number);
  1719.     else if (name == NULL || *name == NUL)
  1720. return curbuf;
  1721.     else if (name[0] == '$' && name[1] == NUL)
  1722. return lastbuf;
  1723.     else
  1724. return buflist_findnr(buflist_findpat(name, name + STRLEN(name)));
  1725. }
  1727. /*
  1728.  * "buffer_name()" function.
  1729.  */
  1730.     static void
  1731. f_bufname(argvars, retvar)
  1732.     VAR argvars;
  1733.     VAR retvar;
  1734. {
  1735.     BUF *buf;
  1737.     ++emsg_off;
  1738.     buf = get_buf_var(&argvars[0]);
  1739.     retvar->var_type = VAR_STRING;
  1740.     if (buf != NULL && buf->b_fname != NULL)
  1741. retvar->var_val.var_string = vim_strsave(buf->b_fname);
  1742.     else
  1743. retvar->var_val.var_string = NULL;
  1744.     --emsg_off;
  1745. }
  1747. /*
  1748.  * "buffer_number()" function.
  1749.  */
  1750.     static void
  1751. f_bufnr(argvars, retvar)
  1752.     VAR argvars;
  1753.     VAR retvar;
  1754. {
  1755.     BUF *buf;
  1757.     ++emsg_off;
  1758.     buf = get_buf_var(&argvars[0]);
  1759.     if (buf != NULL)
  1760. retvar->var_val.var_number = buf->b_fnum;
  1761.     else
  1762. retvar->var_val.var_number = -1;
  1763.     --emsg_off;
  1764. }
  1766. /*
  1767.  * "buffer_exists()" function.
  1768.  */
  1769.     static void
  1770. f_bufexists(argvars, retvar)
  1771.     VAR argvars;
  1772.     VAR retvar;
  1773. {
  1774.     int n = FALSE;
  1775.     char_u *name;
  1777.     if (argvars[0].var_type == VAR_NUMBER)
  1778. n = (buflist_findnr((int)argvars[0].var_val.var_number) != NULL);
  1779.     else if (argvars[0].var_val.var_string != NULL)
  1780.     {
  1781. /* First make the name into a full path name */
  1782. name = FullName_save(argvars[0].var_val.var_string,
  1783. #ifdef UNIX
  1784. TRUE     /* force expansion, get rid of symbolic links */
  1785. #else
  1786. FALSE
  1787. #endif
  1788. );
  1789. if (name != NULL)
  1790. {
  1791.     n = (buflist_findname(name) != NULL);
  1792.     vim_free(name);
  1793. }
  1794.     }
  1796.     retvar->var_val.var_number = n;
  1797. }
  1799. /*
  1800.  * "char2nr()" function
  1801.  */
  1802.     static void
  1803. f_char2nr(argvars, retvar)
  1804.     VAR argvars;
  1805.     VAR retvar;
  1806. {
  1807.     retvar->var_val.var_number = get_var_string(&argvars[0])[0];
  1808. }
  1810. /*
  1811.  * "col(string)" function
  1812.  */
  1813.     static void
  1814. f_col(argvars, retvar)
  1815.     VAR argvars;
  1816.     VAR retvar;
  1817. {
  1818.     colnr_t col = 0;
  1819.     FPOS *fp;
  1821.     fp = var2fpos(&argvars[0]);
  1822.     if (fp != NULL && fp->lnum > 0)
  1823. col = fp->col + 1;
  1825.     retvar->var_val.var_number = col;
  1826. }
  1828. /*
  1829.  * "confirm(message, buttons[, default [, type]])" function
  1830.  */
  1831.     static void
  1832. f_confirm(argvars, retvar)
  1833.     VAR argvars;
  1834.     VAR retvar;
  1835. {
  1836. #if defined(GUI_DIALOG) || defined(CON_DIALOG)
  1837.     char_u *message;
  1838.     char_u *buttons;
  1839.     char_u buf[NUMBUFLEN];
  1840.     char_u buf2[NUMBUFLEN];
  1841.     int def = 0;
  1842.     int type = VIM_GENERIC;
  1843.     int c;
  1845.     message = get_var_string(&argvars[0]);
  1846.     buttons = get_var_string_buf(&argvars[1], buf);
  1847.     if (argvars[2].var_type != VAR_UNKNOWN)
  1848.     {
  1849. def = get_var_number(&argvars[2]);
  1850. if (argvars[3].var_type != VAR_UNKNOWN)
  1851. {
  1852.     /* avoid that TO_UPPER calls get_var_string_buf() twice */
  1853.     c = *get_var_string_buf(&argvars[3], buf2);
  1854.     switch (TO_UPPER(c))
  1855.     {
  1856. case 'E': type = VIM_ERROR; break;
  1857. case 'Q': type = VIM_QUESTION; break;
  1858. case 'I': type = VIM_INFO; break;
  1859. case 'W': type = VIM_WARNING; break;
  1860. case 'G': type = VIM_GENERIC; break;
  1861.     }
  1862. }
  1863.     }
  1865.     retvar->var_val.var_number = do_dialog(type, NULL, message, buttons, def);
  1866. #else
  1867.     retvar->var_val.var_number = 0;
  1868. #endif
  1869. }
  1872. /*
  1873.  * "browse(save, title, initdir, default)" function
  1874.  */
  1875. /* ARGSUSED */
  1876.     static void
  1877. f_browse(argvars, retvar)
  1878.     VAR argvars;
  1879.     VAR retvar;
  1880. {
  1881. #ifdef USE_BROWSE
  1882.     int save;
  1883.     char_u *title;
  1884.     char_u *initdir;
  1885.     char_u *defname;
  1886.     char_u buf[NUMBUFLEN];
  1887.     char_u buf2[NUMBUFLEN];
  1889.     save = get_var_number(&argvars[0]);
  1890.     title = get_var_string(&argvars[1]);
  1891.     initdir = get_var_string_buf(&argvars[2], buf);
  1892.     defname = get_var_string_buf(&argvars[3], buf2);
  1894.     retvar->var_val.var_string =
  1895.  do_browse(save, title, defname, NULL, initdir, NULL, curbuf);
  1896. #else
  1897.     retvar->var_val.var_string = NULL;
  1898. #endif
  1899.     retvar->var_type = VAR_STRING;
  1900. }
  1902. /*
  1903.  * "delete()" function
  1904.  */
  1905.     static void
  1906. f_delete(argvars, retvar)
  1907.     VAR argvars;
  1908.     VAR retvar;
  1909. {
  1910.     retvar->var_val.var_number = mch_remove(get_var_string(&argvars[0]));
  1911. }
  1913. /*
  1914.  * "escape({string}, {chars})" function
  1915.  */
  1916.     static void
  1917. f_escape(argvars, retvar)
  1918.     VAR argvars;
  1919.     VAR retvar;
  1920. {
  1921.     char_u buf[NUMBUFLEN];
  1923.     retvar->var_val.var_string =
  1924. vim_strsave_escaped(get_var_string(&argvars[0]),
  1925. get_var_string_buf(&argvars[1], buf));
  1926.     retvar->var_type = VAR_STRING;
  1927. }
  1929. /*
  1930.  * "exists()" function
  1931.  */
  1932.     static void
  1933. f_exists(argvars, retvar)
  1934.     VAR argvars;
  1935.     VAR retvar;
  1936. {
  1937.     char_u *p;
  1938.     char_u *name;
  1939.     int n = FALSE;
  1940.     int len;
  1942.     p = get_var_string(&argvars[0]);
  1943.     if (*p == '$') /* environment variable */
  1944. n = (get_env_string(&p) != NULL);
  1945.     else if (*p == '&') /* option */
  1946. n = (get_option_var(&p, NULL) == OK);
  1947.     else /* internal variable */
  1948.     {
  1949. name = p;
  1950. len = get_id_len(&p);
  1951. if (len != 0)
  1952.     n = (get_var_var(name, len, NULL) == OK);
  1953.     }
  1955.     retvar->var_val.var_number = n;
  1956. }
  1958. /*
  1959.  * "expand()" function
  1960.  */
  1961.     static void
  1962. f_expand(argvars, retvar)
  1963.     VAR argvars;
  1964.     VAR retvar;
  1965. {
  1966.     char_u *s;
  1967.     int len;
  1968.     char_u *errormsg;
  1970.     retvar->var_type = VAR_STRING;
  1971.     s = get_var_string(&argvars[0]);
  1972.     if (*s == '%' || *s == '#' || *s == '<')
  1973. retvar->var_val.var_string = eval_vars(s, &len, NULL, &errormsg, s);
  1974.     else
  1975. retvar->var_val.var_string = ExpandOne(s, NULL, WILD_USE_NL, WILD_ALL);
  1976. }
  1978. /*
  1979.  * "filereadable()" function
  1980.  */
  1981.     static void
  1982. f_filereadable(argvars, retvar)
  1983.     VAR argvars;
  1984.     VAR retvar;
  1985. {
  1986.     FILE *fd;
  1987.     char_u *p;
  1988.     int n;
  1990.     p = get_var_string(&argvars[0]);
  1991.     if (*p && !mch_isdir(p) && (fd = fopen((char *)p, "r")) != NULL)
  1992.     {
  1993. n = TRUE;
  1994. fclose(fd);
  1995.     }
  1996.     else
  1997. n = FALSE;
  1999.     retvar->var_val.var_number = n;
  2000. }
  2002. /*
  2003.  * "fnamemodify({fname}, {mods})" function
  2004.  */
  2005.     static void
  2006. f_fnamemodify(argvars, retvar)
  2007.     VAR argvars;
  2008.     VAR retvar;
  2009. {
  2010.     char_u *fname;
  2011.     char_u *mods;
  2012.     int usedlen = 0;
  2013.     int len;
  2014.     char_u *fbuf = NULL;
  2015.     char_u buf[NUMBUFLEN];
  2017.     fname = get_var_string(&argvars[0]);
  2018.     mods = get_var_string_buf(&argvars[1], buf);
  2019.     len = STRLEN(fname);
  2021.     (void)modify_fname(mods, &usedlen, &fname, &fbuf, &len);
  2023.     retvar->var_type = VAR_STRING;
  2024.     if (fname == NULL)
  2025. retvar->var_val.var_string = NULL;
  2026.     else
  2027. retvar->var_val.var_string = vim_strnsave(fname, len);
  2028.     vim_free(fbuf);
  2029. }
  2031. /*
  2032.  * "getcwd()" function
  2033.  */
  2034. /*ARGSUSED*/
  2035.     static void
  2036. f_getcwd(argvars, retvar)
  2037.     VAR argvars;
  2038.     VAR retvar;
  2039. {
  2040.     char_u cwd[MAXPATHL];
  2042.     retvar->var_type = VAR_STRING;
  2043.     if (mch_dirname(cwd, MAXPATHL) == FAIL)
  2044. retvar->var_val.var_string = NULL;
  2045.     else
  2046. retvar->var_val.var_string = vim_strsave(cwd);
  2047. }
  2049. /*
  2050.  * "getline(lnum)" function
  2051.  */
  2052.     static void
  2053. f_getline(argvars, retvar)
  2054.     VAR argvars;
  2055.     VAR retvar;
  2056. {
  2057.     linenr_t lnum;
  2058.     char_u *p;
  2060.     lnum = get_var_number(&argvars[0]);
  2061.     if (lnum == 0)  /* no valid number, try using line() */
  2062.     {
  2063. f_line(argvars, retvar);
  2064. lnum = retvar->var_val.var_number;
  2065. clear_var(retvar);
  2066.     }
  2068.     if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
  2069. p = ml_get(lnum);
  2070.     else
  2071. p = (char_u *)"";
  2073.     retvar->var_type = VAR_STRING;
  2074.     retvar->var_val.var_string = vim_strsave(p);
  2075. }
  2077. /*
  2078.  * "has()" function
  2079.  */
  2080.     static void
  2081. f_has(argvars, retvar)
  2082.     VAR argvars;
  2083.     VAR retvar;
  2084. {
  2085.     int i;
  2086.     char_u *name;
  2087.     int n = FALSE;
  2088.     static char *(has_list[]) =
  2089.     {
  2090. #ifdef AMIGA
  2091. "amiga",
  2092. # ifndef NO_ARP
  2093. "arp",
  2094. # endif
  2095. #endif
  2096. #ifdef __BEOS__
  2097. "beos",
  2098. #endif
  2099. #ifdef MSDOS
  2100. # ifdef DJGPP
  2101. "dos32",
  2102. # else
  2103. "dos16",
  2104. # endif
  2105. #endif
  2106. #ifdef macintosh
  2107. "mac",
  2108. #endif
  2109. #ifdef RISCOS
  2110. "riscos",
  2111. #endif
  2112. #ifdef UNIX
  2113. "unix",
  2114. #endif
  2115. #ifdef VMS
  2116. "vms",
  2117. #endif
  2118. #ifdef WIN32
  2119. "win32",
  2120. #endif
  2121. #ifndef CASE_INSENSITIVE_FILENAME
  2122. "fname_case",
  2123. #endif
  2124. #ifdef AUTOCMD
  2125. "autocmd",
  2126. #endif
  2127. #if defined(SOME_BUILTIN_TCAPS) || defined(ALL_BUILTIN_TCAPS)
  2128. "builtin_terms",
  2129. # ifdef ALL_BUILTIN_TCAPS
  2130. "all_builtin_terms",
  2131. # endif
  2132. #endif
  2133. #ifdef CINDENT
  2134. "cindent",
  2135. #endif
  2136. #ifdef USE_CSCOPE
  2137. "cscope",
  2138. #endif
  2139. #ifdef DEBUG
  2140. "debug",
  2141. #endif
  2142. #ifdef CON_DIALOG
  2143. "dialog_con",
  2144. #endif
  2145. #ifdef GUI_DIALOG
  2146. "dialog_gui",
  2147. #endif
  2148. #ifdef DIGRAPHS
  2149. "digraphs",
  2150. #endif
  2151. #ifdef EMACS_TAGS
  2152. "emacs_tags",
  2153. #endif
  2154. "eval",     /* always present, of course! */
  2155. #ifdef EX_EXTRA
  2156. "ex_extra",
  2157. #endif
  2158. #ifdef EXTRA_SEARCH
  2159. "extra_search",
  2160. #endif
  2161. #ifdef FKMAP
  2162. "farsi",
  2163. #endif
  2164. #ifdef FILE_IN_PATH
  2165. "file_in_path",
  2166. #endif
  2167. #ifdef WANT_FILETYPE
  2168. "filetype",
  2169. #endif
  2170. #ifdef FIND_IN_PATH
  2171. "find_in_path",
  2172. #endif
  2173. #if !defined(USE_SYSTEM) && defined(UNIX)
  2174. "fork",
  2175. #endif
  2176. #ifdef USE_GUI
  2177. "gui",
  2178. #endif
  2179. #ifdef USE_GUI_ATHENA
  2180. "gui_athena",
  2181. #endif
  2182. #ifdef USE_GUI_BEOS
  2183. "gui_beos",
  2184. #endif
  2185. #ifdef USE_GUI_MAC
  2186. "gui_mac",
  2187. #endif
  2188. #ifdef USE_GUI_MOTIF
  2189. "gui_motif",
  2190. #endif
  2191. #ifdef USE_GUI_WIN32
  2192. "gui_win32",
  2193. #endif
  2194. #ifdef INSERT_EXPAND
  2195. "insert_expand",
  2196. #endif
  2197. #ifdef HAVE_LANGMAP
  2198. "langmap",
  2199. #endif
  2200. #ifdef LISPINDENT
  2201. "lispindent",
  2202. #endif
  2203. #ifdef WANT_MODIFY_FNAME
  2204. "modify_fname",
  2205. #endif
  2206. #ifdef USE_MOUSE
  2207. "mouse",
  2208. #endif
  2209. #ifdef UNIX
  2210. # ifdef DEC_MOUSE
  2211. "mouse_dec",
  2212. # endif
  2213. # ifdef NETTERM_MOUSE
  2214. "mouse_netterm",
  2215. # endif
  2216. # ifdef XTERM_MOUSE
  2217. "mouse_xterm",
  2218. # endif
  2219. #endif
  2220. #ifdef MULTI_BYTE
  2221. "multi_byte",
  2222. #endif
  2223. #ifdef MULTI_BYTE_IME
  2224. "multi_byte_ime",
  2225. #endif
  2226. #ifdef HAVE_OLE
  2227. "ole",
  2228. #endif
  2229. #ifdef HAVE_PERL_INTERP
  2230. "perl",
  2231. #endif
  2232. #ifdef HAVE_PYTHON
  2233. "python",
  2234. #endif
  2235. #ifdef QUICKFIX
  2236. "quickfix",
  2237. #endif
  2238. #ifdef RIGHTLEFT
  2239. "rightleft",
  2240. #endif
  2241. #ifdef SHOWCMD
  2242. "showcmd",
  2243. #endif
  2244. #ifdef SMARTINDENT
  2245. "smartindent",
  2246. #endif
  2247. #ifdef SYNTAX_HL
  2248. "syntax",
  2249. #endif
  2250. #if defined(USE_SYSTEM) || !defined(UNIX)
  2251. "system",
  2252. #endif
  2253. #ifdef BINARY_TAGS
  2254. "tag_binary",
  2255. #endif
  2256. #ifdef OLD_STATIC_TAGS
  2257. "tag_old_static",
  2258. #endif
  2259. #ifdef TAG_ANY_WHITE
  2260. "tag_any_white",
  2261. #endif
  2262. #ifdef HAVE_TCL
  2263. "tcl",
  2264. #endif
  2265. #ifdef TERMINFO
  2266. "terminfo",
  2267. #endif
  2268. #ifdef TEXT_OBJECTS
  2269. "textobjects",
  2270. #endif
  2271. #ifdef HAVE_TGETENT
  2272. "tgetent",
  2273. #endif
  2274. #ifdef USER_COMMANDS
  2275. "user-commands",
  2276. #endif
  2277. #ifdef VIMINFO
  2278. "viminfo",
  2279. #endif
  2280. #ifdef WILDIGNORE
  2281. "wildignore",
  2282. #endif
  2283. #ifdef WRITEBACKUP
  2284. "writebackup",
  2285. #endif
  2286. #ifdef SAVE_XTERM_SCREEN
  2287. "xterm_save",
  2288. #endif
  2289. #if defined(UNIX) && defined(WANT_X11) && defined(HAVE_X11)
  2290. "X11",
  2291. #endif
  2292. NULL
  2293.     };
  2295.     name = get_var_string(&argvars[0]);
  2296.     for (i = 0; has_list[i] != NULL; ++i)
  2297. if (STRICMP(name, has_list[i]) == 0)
  2298. {
  2299.     n = TRUE;
  2300.     break;
  2301. }
  2303.     if (n == FALSE)
  2304.     {
  2305. #ifdef USE_GUI
  2306. if (STRICMP(name, "gui_running") == 0)
  2307. {
  2308.     n = (gui.in_use || gui.starting);
  2309. }
  2310. # ifdef USE_GUI_WIN32
  2311. else if (STRICMP(name, "gui_win32s") == 0)
  2312. {
  2313.     n = gui_is_win32s();
  2314. }
  2315. # endif
  2316. #ifdef USE_BROWSE
  2317. else if (STRICMP(name, "browse") == 0)
  2318. {
  2319.     n = gui.in_use; /* gui_mch_browse() works when GUI is running */
  2320. }
  2321. #endif
  2322. #endif
  2323. #ifdef SYNTAX_HL
  2324. # ifdef USE_GUI
  2325. else
  2326. # endif
  2327.     if (STRICMP(name, "syntax_items") == 0)
  2328. {
  2329.     n = syntax_present(curbuf);
  2330. }
  2331. #endif
  2332.     }
  2334.     retvar->var_val.var_number = n;
  2335. }
  2337. /*
  2338.  * "highlight_exists()" function
  2339.  */
  2340.     static void
  2341. f_hlexists(argvars, retvar)
  2342.     VAR argvars;
  2343.     VAR retvar;
  2344. {
  2345.     retvar->var_val.var_number = highlight_exists(get_var_string(&argvars[0]));
  2346. }
  2348. /*
  2349.  * "highlightID(name)" function
  2350.  */
  2351.     static void
  2352. f_hlID(argvars, retvar)
  2353.     VAR argvars;
  2354.     VAR retvar;
  2355. {
  2356.     retvar->var_val.var_number = syn_name2id(get_var_string(&argvars[0]));
  2357. }
  2359. /*
  2360.  * "hostname()" function
  2361.  */
  2362. /*ARGSUSED*/
  2363.     static void
  2364. f_hostname(argvars, retvar)
  2365.     VAR argvars;
  2366.     VAR retvar;
  2367. {
  2368.     char_u hostname[256];
  2370.     mch_get_host_name(hostname, 256);
  2371.     retvar->var_type = VAR_STRING;
  2372.     retvar->var_val.var_string = vim_strsave(hostname);
  2373. }
  2375. /*
  2376.  * "input()" function
  2377.  */
  2378.     static void
  2379. f_input(argvars, retvar)
  2380.     VAR argvars;
  2381.     VAR retvar;
  2382. {
  2383.     char_u *prompt = get_var_string(&argvars[0]);
  2384.     char_u *p;
  2385.     int c;
  2387.     retvar->var_type = VAR_STRING;
  2389. #ifdef NO_CONSOLE
  2390.     /*
  2391.      * While starting up, there is no place to enter text.
  2392.      */
  2393.     if (!gui.in_use || gui.starting)
  2394.     {
  2395. retvar->var_val.var_string = NULL;
  2396. return;
  2397.     }
  2398. #endif
  2400.     if (prompt != NULL)
  2401.     {
  2402. /* Only the part of the message after the last NL is considered as
  2403.  * prompt for the command line */
  2404. p = vim_strrchr(prompt, 'n');
  2405. if (p == NULL)
  2406.     p = prompt;
  2407. else
  2408. {
  2409.     ++p;
  2410.     c = *p;
  2411.     *p = NUL;
  2412.     msg_start();
  2413.     msg_clr_eos();
  2414.     msg_puts_attr(prompt, echo_attr);
  2415.     msg_didout = FALSE;
  2416.     *p = c;
  2417. }
  2418. cmdline_prompt(p, echo_attr);
  2419. cmdline_row = msg_row;
  2420.     }
  2421.     retvar->var_val.var_string = getexline('@', NULL, 0);
  2422.     cmdline_prompt(NULL, 0);
  2423.     /* since the user typed this, no need to wait for return */
  2424.     need_wait_return = FALSE;
  2425.     msg_didout = FALSE;
  2426.     dont_wait_return = TRUE;
  2427. }
  2429. /*
  2430.  * "isdirectory()" function
  2431.  */
  2432.     static void
  2433. f_isdirectory(argvars, retvar)
  2434.     VAR argvars;
  2435.     VAR retvar;
  2436. {
  2437.     retvar->var_val.var_number = mch_isdir(get_var_string(&argvars[0]));
  2438. }
  2440. /*
  2441.  * "last_buffer_nr()" function.
  2442.  */
  2443. /*ARGSUSED*/
  2444.     static void
  2445. f_last_buffer_nr(argvars, retvar)
  2446.     VAR argvars;
  2447.     VAR retvar;
  2448. {
  2449.     int n = 0;
  2450.     BUF *buf;
  2452.     for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  2453. if (n < buf->b_fnum)
  2454.     n = buf->b_fnum;
  2456.     retvar->var_val.var_number = n;
  2457. }
  2459. /*
  2460.  * "line(string)" function
  2461.  */
  2462.     static void
  2463. f_line(argvars, retvar)
  2464.     VAR argvars;
  2465.     VAR retvar;
  2466. {
  2467.     linenr_t lnum = 0;
  2468.     FPOS *fp;
  2470.     fp = var2fpos(&argvars[0]);
  2471.     if (fp != NULL)
  2472. lnum = fp->lnum;
  2473.     else if (get_var_string(&argvars[0])[0] == '$')   /* last line in buffer */
  2474. lnum = curbuf->b_ml.ml_line_count;
  2476.     retvar->var_val.var_number = lnum;
  2477. }
  2479. /*
  2480.  * "match()" function
  2481.  */
  2482.     static void
  2483. f_match(argvars, retvar)
  2484.     VAR argvars;
  2485.     VAR retvar;
  2486. {
  2487.     f_some_match(argvars, retvar, 1);
  2488. }
  2490. /*
  2491.  * "matchend()" function
  2492.  */
  2493.     static void
  2494. f_matchend(argvars, retvar)
  2495.     VAR argvars;
  2496.     VAR retvar;
  2497. {
  2498.     f_some_match(argvars, retvar, 0);
  2499. }
  2501. /*
  2502.  * "matchstr()" function
  2503.  */
  2504.     static void
  2505. f_matchstr(argvars, retvar)
  2506.     VAR argvars;
  2507.     VAR retvar;
  2508. {
  2509.     f_some_match(argvars, retvar, 2);
  2510. }
  2512.     static void
  2513. f_some_match(argvars, retvar, type)
  2514.     VAR argvars;
  2515.     VAR retvar;
  2516.     int type;
  2517. {
  2518.     char_u *str;
  2519.     char_u *pat;
  2520.     vim_regexp *prog;
  2521.     char_u patbuf[NUMBUFLEN];
  2523.     str = get_var_string(&argvars[0]);
  2524.     pat = get_var_string_buf(&argvars[1], patbuf);
  2526.     if (type == 2)
  2527.     {
  2528. retvar->var_type = VAR_STRING;
  2529. retvar->var_val.var_string = NULL;
  2530.     }
  2531.     else
  2532. retvar->var_val.var_number = -1;
  2533.     prog = vim_regcomp(pat, TRUE);
  2534.     if (prog != NULL)
  2535.     {
  2536. reg_ic = p_ic;
  2537. if (vim_regexec(prog, str, TRUE))
  2538. {
  2539.     if (type == 2)
  2540. retvar->var_val.var_string = vim_strnsave(prog->startp[0],
  2541.       (int)(prog->endp[0] - prog->startp[0]));
  2542.     else if (type)
  2543. retvar->var_val.var_number = prog->startp[0] - str;
  2544.     else
  2545. retvar->var_val.var_number = prog->endp[0] - str;
  2546. }
  2547. vim_free(prog);
  2548.     }
  2549. }
  2551. /*
  2552.  * "nr2char()" function
  2553.  */
  2554.     static void
  2555. f_nr2char(argvars, retvar)
  2556.     VAR argvars;
  2557.     VAR retvar;
  2558. {
  2559.     char_u buf[2];
  2561.     buf[0] = (char_u)get_var_number(&argvars[0]);
  2562.     retvar->var_type = VAR_STRING;
  2563.     retvar->var_val.var_string = vim_strnsave(buf, 1);
  2564. }
  2566. /*
  2567.  * "setline()" function
  2568.  */
  2569.     static void
  2570. f_setline(argvars, retvar)
  2571.     VAR argvars;
  2572.     VAR retvar;
  2573. {
  2574.     linenr_t lnum;
  2575.     char_u *line;
  2577.     lnum = get_var_number(&argvars[0]);
  2578.     line = get_var_string(&argvars[1]);
  2579.     retvar->var_val.var_number = 1; /* FAIL is default */
  2581.     if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
  2582.     {
  2583. if (u_savesub(lnum) == OK && ml_replace(lnum, line, TRUE) == OK)
  2584. {
  2585.     changed();
  2586. #ifdef SYNTAX_HL
  2587.     /* recompute syntax hl. for this line */
  2588.     syn_changed(lnum);
  2589. #endif
  2590.     redraw_curbuf_later(NOT_VALID);
  2591.     retvar->var_val.var_number = 0;
  2592. }
  2593.     }
  2594. }
  2596. #ifdef HAVE_STRFTIME
  2597. /*
  2598.  * "strftime()" function
  2599.  */
  2600.     static void
  2601. f_strftime(argvars, retvar)
  2602.     VAR argvars;
  2603.     VAR retvar;
  2604. {
  2605.     char_u result_buf[80];
  2606.     struct tm *curtime;
  2607.     time_t seconds;
  2608.     char_u *p;
  2610.     p = get_var_string(&argvars[0]);
  2611.     seconds = time(NULL);
  2612.     curtime = localtime(&seconds);
  2613.     (void)strftime((char *)result_buf, (size_t)80, (char *)p, curtime);
  2615.     retvar->var_type = VAR_STRING;
  2616.     retvar->var_val.var_string = vim_strsave(result_buf);
  2617. }
  2618. #endif
  2620. /*
  2621.  * "strlen()" function
  2622.  */
  2623.     static void
  2624. f_strlen(argvars, retvar)
  2625.     VAR argvars;
  2626.     VAR retvar;
  2627. {
  2628.     retvar->var_val.var_number = STRLEN(get_var_string(&argvars[0]));
  2629. }
  2631. /*
  2632.  * "strpart()" function
  2633.  */
  2634.     static void
  2635. f_strpart(argvars, retvar)
  2636.     VAR argvars;
  2637.     VAR retvar;
  2638. {
  2639.     char_u *p;
  2640.     int n;
  2641.     int len;
  2642.     int slen;
  2644.     p = get_var_string(&argvars[0]);
  2645.     n = get_var_number(&argvars[1]);
  2646.     len = get_var_number(&argvars[2]);
  2647.     slen = STRLEN(p);
  2648.     /*
  2649.      * Only return the overlap between the specified part and the actual
  2650.      * string.
  2651.      */
  2652.     if (n < 0)
  2653.     {
  2654. len += n;
  2655. n = 0;
  2656.     }
  2657.     else if (n > slen)
  2658. n = slen;
  2659.     if (len < 0)
  2660. len = 0;
  2661.     else if (n + len > slen)
  2662. len = slen - n;
  2664.     retvar->var_type = VAR_STRING;
  2665.     retvar->var_val.var_string = vim_strnsave(p + n, len);
  2666. }
  2668. /*
  2669.  * "synID(line, col, trans)" function
  2670.  */
  2671.     static void
  2672. f_synID(argvars, retvar)
  2673.     VAR argvars;
  2674.     VAR retvar;
  2675. {
  2676.     int id = 0;
  2677. #ifdef SYNTAX_HL
  2678.     long line;
  2679.     long col;
  2680.     int trans;
  2682.     line = get_var_number(&argvars[0]);
  2683.     col = get_var_number(&argvars[1]) - 1;
  2684.     trans = get_var_number(&argvars[2]);
  2686.     if (line >= 1 && line <= curbuf->b_ml.ml_line_count
  2687.     && col >= 0 && col < (long)STRLEN(ml_get(line)))
  2688. id = syn_get_id(line, col, trans);
  2689. #endif
  2691.     retvar->var_val.var_number = id;
  2692. }
  2694. /*
  2695.  * "synIDattr(id, what [, mode])" function
  2696.  */
  2697.     static void
  2698. f_synIDattr(argvars, retvar)
  2699.     VAR argvars;
  2700.     VAR retvar;
  2701. {
  2702.     char_u *p = NULL;
  2703. #ifdef SYNTAX_HL
  2704.     int id;
  2705.     char_u *what;
  2706.     char_u *mode;
  2707.     char_u modebuf[NUMBUFLEN];
  2708.     int modec;
  2710.     id = get_var_number(&argvars[0]);
  2711.     what = get_var_string(&argvars[1]);
  2712.     if (argvars[2].var_type != VAR_UNKNOWN)
  2713.     {
  2714. mode = get_var_string_buf(&argvars[2], modebuf);
  2715. modec = TO_LOWER(mode[0]);
  2716. if (modec != 't' && modec != 'c'
  2717. #ifdef USE_GUI
  2718. && modec != 'g'
  2719. #endif
  2720. )
  2721.     modec = 0; /* replace invalid with current */
  2722.     }
  2723.     else
  2724.     {
  2725. #ifdef USE_GUI
  2726. if (gui.in_use)
  2727.     modec = 'g';
  2728. else
  2729. #endif
  2730.     if (*T_CCO)
  2731.     modec = 'c';
  2732. else
  2733.     modec = 't';
  2734.     }
  2737.     switch (TO_LOWER(what[0]))
  2738.     {
  2739. case 'b':
  2740. if (TO_LOWER(what[1]) == 'g') /* bg[#] */
  2741.     p = highlight_color(id, what, modec);
  2742. else /* bold */
  2743.     p = highlight_has_attr(id, HL_BOLD, modec);
  2744. break;
  2746. case 'f': /* fg[#] */
  2747. p = highlight_color(id, what, modec);
  2748. break;
  2750. case 'i':
  2751. if (TO_LOWER(what[1]) == 'n') /* inverse */
  2752.     p = highlight_has_attr(id, HL_INVERSE, modec);
  2753. else /* italic */
  2754.     p = highlight_has_attr(id, HL_ITALIC, modec);
  2755. break;
  2757. case 'n': /* name */
  2758. p = get_highlight_name(id - 1);
  2759. break;
  2761. case 'r': /* reverse */
  2762. p = highlight_has_attr(id, HL_INVERSE, modec);
  2763. break;
  2765. case 's': /* standout */
  2766. p = highlight_has_attr(id, HL_STANDOUT, modec);
  2767. break;
  2769. case 'u': /* underline */
  2770. p = highlight_has_attr(id, HL_UNDERLINE, modec);
  2771. break;
  2772.     }
  2774.     if (p != NULL)
  2775. p = vim_strsave(p);
  2776. #endif
  2777.     retvar->var_type = VAR_STRING;
  2778.     retvar->var_val.var_string = p;
  2779. }
  2781. /*
  2782.  * "synIDtrans(id)" function
  2783.  */
  2784.     static void
  2785. f_synIDtrans(argvars, retvar)
  2786.     VAR argvars;
  2787.     VAR retvar;
  2788. {
  2789.     int id;
  2791. #ifdef SYNTAX_HL
  2792.     id = get_var_number(&argvars[0]);
  2794.     if (id > 0)
  2795. id = syn_get_final_id(id);
  2796.     else
  2797. #endif
  2798. id = 0;
  2800.     retvar->var_val.var_number = id;
  2801. }
  2803. /*
  2804.  * "substitute()" function
  2805.  */
  2806.     static void
  2807. f_substitute(argvars, retvar)
  2808.     VAR argvars;
  2809.     VAR retvar;
  2810. {
  2811.     char_u patbuf[NUMBUFLEN];
  2812.     char_u subbuf[NUMBUFLEN];
  2813.     char_u flagsbuf[NUMBUFLEN];
  2815.     retvar->var_type = VAR_STRING;
  2816.     retvar->var_val.var_string = do_string_sub(
  2817.     get_var_string(&argvars[0]),
  2818.     get_var_string_buf(&argvars[1], patbuf),
  2819.     get_var_string_buf(&argvars[2], subbuf),
  2820.     get_var_string_buf(&argvars[3], flagsbuf));
  2821. }
  2823. /*
  2824.  * "tempname()" function
  2825.  */
  2826. /*ARGSUSED*/
  2827.     static void
  2828. f_tempname(argvars, retvar)
  2829.     VAR argvars;
  2830.     VAR retvar;
  2831. {
  2832.     static int x = 'A';
  2834.     retvar->var_type = VAR_STRING;
  2835.     retvar->var_val.var_string = vim_tempname(x);
  2836.     /* advance 'x', so that there are at least 26 different names */
  2837.     if (x == 'Z')
  2838. x = 'A';
  2839.     else
  2840. ++x;
  2841. }
  2843. /*
  2844.  * "virtcol(string)" function
  2845.  */
  2846.     static void
  2847. f_virtcol(argvars, retvar)
  2848.     VAR argvars;
  2849.     VAR retvar;
  2850. {
  2851.     colnr_t vcol = 0;
  2852.     FPOS *fp;
  2854.     fp = var2fpos(&argvars[0]);
  2855.     if (fp != NULL)
  2856.     {
  2857. getvcol(curwin, fp, NULL, NULL, &vcol);
  2858. ++vcol;
  2859.     }
  2861.     retvar->var_val.var_number = vcol;
  2862. }
  2864. /*
  2865.  * "winbufnr(nr)" function
  2866.  */
  2867.     static void
  2868. f_winbufnr(argvars, retvar)
  2869.     VAR argvars;
  2870.     VAR retvar;
  2871. {
  2872.     WIN *wp;
  2874.     wp = find_win_by_nr(&argvars[0]);
  2875.     if (wp == NULL)
  2876. retvar->var_val.var_number = -1;
  2877.     else
  2878. retvar->var_val.var_number = wp->w_buffer->b_fnum;
  2879. }
  2881. /*
  2882.  * "winheight(nr)" function
  2883.  */
  2884.     static void
  2885. f_winheight(argvars, retvar)
  2886.     VAR argvars;
  2887.     VAR retvar;
  2888. {
  2889.     WIN *wp;
  2891.     wp = find_win_by_nr(&argvars[0]);
  2892.     if (wp == NULL)
  2893. retvar->var_val.var_number = -1;
  2894.     else
  2895. retvar->var_val.var_number = wp->w_height;
  2896. }
  2898. /*
  2899.  * "winnr()" function
  2900.  */
  2901. /* ARGSUSED */
  2902.     static void
  2903. f_winnr(argvars, retvar)
  2904.     VAR argvars;
  2905.     VAR retvar;
  2906. {
  2907.     int nr;
  2908.     WIN *wp;
  2910.     nr = 1;
  2911.     for (wp = firstwin; wp != curwin; wp = wp->w_next)
  2912. ++nr;
  2913.     retvar->var_val.var_number = nr;
  2914. }
  2916.     static WIN *
  2917. find_win_by_nr(vp)
  2918.     VAR vp;
  2919. {
  2920.     WIN *wp;
  2921.     int nr;
  2923.     nr = get_var_number(vp);
  2925.     if (nr == 0)
  2926. return curwin;
  2928.     for (wp = firstwin; wp != NULL; wp = wp->w_next)
  2929.     {
  2930. if (--nr <= 0)
  2931.     break;
  2932.     }
  2933.     return wp;
  2934. }
  2936. /*
  2937.  * Translate a String variable into a position (for col() and virtcol()).
  2938.  */
  2939.     static FPOS *
  2940. var2fpos(varp)
  2941.     VAR varp;
  2942. {
  2943.     char_u *name;
  2945.     name = get_var_string(varp);
  2946.     if (name[0] == '.') /* cursor */
  2947. return &curwin->w_cursor;
  2948.     if (name[0] == ''') /* mark */
  2949. return getmark(name[1], FALSE);
  2950.     return NULL;
  2951. }
  2953. /*
  2954.  * Get the lenght of an environment variable name.
  2955.  * Advance "arg" to the first character after the name.
  2956.  * Return 0 for error.
  2957.  */
  2958.     static int
  2959. get_env_len(arg)
  2960.     char_u **arg;
  2961. {
  2962.     char_u *p;
  2963.     int len;
  2965.     for (p = *arg; vim_isIDc(*p); ++p)
  2966. ;
  2967.     if (p == *arg)     /* no name found */
  2968. return 0;
  2970.     len = p - *arg;
  2971.     *arg = p;
  2972.     return len;
  2973. }
  2975. /*
  2976.  * Get the value of an environment variable.
  2977.  * "arg" points to the '$' before the env var name.
  2978.  * "arg" is advanced to the first character after the name.
  2979.  * Return NULL for failure.
  2980.  */
  2981.     char_u *
  2982. get_env_string(arg)
  2983.     char_u **arg;
  2984. {
  2985.     int     len;
  2986.     int     cc;
  2987.     char_u  *name;
  2988.     char_u  *s;
  2990.     ++*arg;
  2991.     name = *arg;
  2992.     len = get_env_len(arg);
  2993.     if (len == 0)
  2994. return NULL;
  2995.     cc = name[len];
  2996.     name[len] = NUL;
  2997.     s = mch_getenv(name);
  2998.     name[len] = cc;
  3000.     return s;
  3001. }
  3003. /*
  3004.  * Get the length of the name of a function or internal variable.
  3005.  * "arg" is advanced to the first non-white character after the name.
  3006.  * Return 0 if something is wrong.
  3007.  */
  3008.     static int
  3009. get_id_len(arg)
  3010.     char_u **arg;
  3011. {
  3012.     char_u *p;
  3013.     int len;
  3015.     /* Find the end of the name. */
  3016.     for (p = *arg; eval_isnamec(*p); ++p)
  3017. ;
  3018.     if (p == *arg)     /* no name found */
  3019. return 0;
  3021.     len = p - *arg;
  3022.     *arg = skipwhite(p);
  3024.     return len;
  3025. }
  3027.     static int
  3028. eval_isnamec(c)
  3029.     int     c;
  3030. {
  3031.     return (isalpha(c) || isdigit(c) || c == '_' || c == ':');
  3032. }
  3034. /*
  3035.  * Get the value of internal variable "name".
  3036.  * Return OK or FAIL.
  3037.  */
  3038.     static int
  3039. get_var_var(name, len, retvar)
  3040.     char_u *name;
  3041.     int len; /* length of "name" */
  3042.     VAR retvar; /* NULL when only checking existence */
  3043. {
  3044.     int ret = OK;
  3045.     int type = VAR_UNKNOWN;
  3046.     long number = 1;
  3047.     char_u *string = NULL;
  3048.     VAR v;
  3049.     int cc;
  3051.     cc = name[len];
  3052.     name[len] = NUL;
  3054.     /*
  3055.      * Check for built-in variables.
  3056.      */
  3057.     if (len == 7 && STRCMP(name, "version") == 0)
  3058.     {
  3059. type = VAR_NUMBER;
  3060. number = get_version();
  3061.     }
  3062.     else if (len == 5 && STRCMP(name, "count") == 0)
  3063.     {
  3064. type = VAR_NUMBER;
  3065. number = global_opnum;
  3066.     }
  3067.     else if (len == 11 && STRCMP(name, "shell_error") == 0)
  3068.     {
  3069. type = VAR_NUMBER;
  3070. number = call_shell_retval;
  3071.     }
  3073.     /*
  3074.      * Check for user-defined variables.
  3075.      */
  3076.     else
  3077.     {
  3078. v = find_var(name, FALSE);
  3079. if (v != NULL)
  3080. {
  3081.     type = v->var_type;
  3082.     number = v->var_val.var_number;
  3083.     string = v->var_val.var_string;
  3084. }
  3085.     }
  3087.     if (type == VAR_UNKNOWN)
  3088.     {
  3089. if (retvar != NULL)
  3090.     EMSG2("Undefined variable: %s", name);
  3091. ret = FAIL;
  3092.     }
  3093.     else if (retvar != NULL)
  3094.     {
  3095. retvar->var_type = type;
  3096. if (type == VAR_NUMBER)
  3097.     retvar->var_val.var_number = number;
  3098. else
  3099. {
  3100.     if (string != NULL)
  3101. string = vim_strsave(string);
  3102.     retvar->var_val.var_string = string;
  3103. }
  3104.     }
  3106.     name[len] = cc;
  3108.     return ret;
  3109. }
  3111. /*
  3112.  * Allocate memory for a variable, and make it emtpy (0 or NULL value).
  3113.  */
  3114.     static VAR
  3115. alloc_var()
  3116. {
  3117.     return (VAR)alloc_clear((unsigned)sizeof(var));
  3118. }
  3120. /*
  3121.  * Allocate memory for a variable, and assign a string to it.
  3122.  * The string "s" must have been allocated, it is consumed.
  3123.  * Return NULL for out of memory, the variable otherwise.
  3124.  */
  3125.     static VAR
  3126. alloc_string_var(s)
  3127.     char_u *s;
  3128. {
  3129.     VAR     retvar;
  3131.     retvar = alloc_var();
  3132.     if (retvar != NULL)
  3133.     {
  3134. retvar->var_type = VAR_STRING;
  3135. retvar->var_val.var_string = s;
  3136.     }
  3137.     else
  3138. vim_free(s);
  3139.     return retvar;
  3140. }
  3142. /*
  3143.  * Free the memory for a variable.
  3144.  */
  3145.     static void
  3146. free_var(varp)
  3147.     VAR     varp;
  3148. {
  3149.     if (varp != NULL)
  3150.     {
  3151. if (varp->var_type == VAR_STRING)
  3152.     vim_free(varp->var_val.var_string);
  3153. vim_free(varp->var_name);
  3154. vim_free(varp);
  3155.     }
  3156. }
  3158. /*
  3159.  * Free the memory for a variable value and set the value to NULL or 0.
  3160.  */
  3161.     static void
  3162. clear_var(varp)
  3163.     VAR     varp;
  3164. {
  3165.     if (varp != NULL)
  3166.     {
  3167. if (varp->var_type == VAR_STRING)
  3168. {
  3169.     vim_free(varp->var_val.var_string);
  3170.     varp->var_val.var_string = NULL;
  3171. }
  3172. else
  3173.     varp->var_val.var_number = 0;
  3174.     }
  3175. }
  3177. /*
  3178.  * Get the number value of a variable.
  3179.  * If it is a String variable, use vim_str2nr().
  3180.  */
  3181.     static long
  3182. get_var_number(varp)
  3183.     VAR varp;
  3184. {
  3185.     long n;
  3187.     if (varp->var_type == VAR_NUMBER)
  3188. return (long)(varp->var_val.var_number);
  3189.     else if (varp->var_val.var_string == NULL)
  3190. return 0L;
  3191.     else
  3192.     {
  3193. vim_str2nr(varp->var_val.var_string, NULL, NULL, TRUE, TRUE, &n, NULL);
  3194. return n;
  3195.     }
  3196. }
  3198. /*
  3199.  * Get the string value of a variable.
  3200.  * If it is a Number variable, the number is converted into a string.
  3201.  * get_var_string() uses a single, static buffer.  You can only use it once!
  3202.  * get_var_string_buf() uses a given buffer.
  3203.  * If the String variable has never been set, return an empty string.
  3204.  * Never returns NULL;
  3205.  */
  3206.     static char_u *
  3207. get_var_string(varp)
  3208.     VAR     varp;
  3209. {
  3210.     static char_u   mybuf[NUMBUFLEN];
  3212.     return get_var_string_buf(varp, mybuf);
  3213. }
  3215.     static char_u *
  3216. get_var_string_buf(varp, buf)
  3217.     VAR     varp;
  3218.     char_u  *buf;
  3219. {
  3220.     if (varp->var_type == VAR_NUMBER)
  3221.     {
  3222. sprintf((char *)buf, "%ld", (long)varp->var_val.var_number);
  3223. return buf;
  3224.     }
  3225.     else if (varp->var_val.var_string == NULL)
  3226. return (char_u *)"";
  3227.     else
  3228. return varp->var_val.var_string;
  3229. }
  3231. /*
  3232.  * Find variable "name" in the list of variables.
  3233.  * Return a pointer to it if found, NULL if not found.
  3234.  */
  3235.     static VAR
  3236. find_var(name, writing)
  3237.     char_u *name;
  3238.     int writing;
  3239. {
  3240.     int i;
  3241.     char_u *varname;
  3242.     struct growarray *gap;
  3244.     /* When not writing, check for function arguments "a:" */
  3245.     if (!writing && name[0] == 'a' && name[1] == ':')
  3246.     {
  3247. name += 2;
  3248. if (current_funccal == NULL)
  3249.     return NULL;
  3250. if (isdigit(*name))
  3251. {
  3252.     i = atol((char *)name);
  3253.     if (i == 0) /* a:0 */
  3254. return &current_funccal->a0_var;
  3255.     i += current_funccal->func->args.ga_len;
  3256.     if (i > current_funccal->argcount) /* a:999 */
  3257. return NULL;
  3258.     return &(current_funccal->argvars[i - 1]); /* a:1, a:2, etc. */
  3259. }
  3260. if (STRCMP(name, "firstline") == 0)
  3261.     return &(current_funccal->firstline);
  3262. if (STRCMP(name, "lastline") == 0)
  3263.     return &(current_funccal->lastline);
  3264. for (i = 0; i < current_funccal->func->args.ga_len; ++i)
  3265.     if (STRCMP(name, ((char_u **)
  3266.       (current_funccal->func->args.ga_data))[i]) == 0)
  3267.     return &(current_funccal->argvars[i]); /* a:name */
  3268. return NULL;
  3269.     }
  3271.     gap = find_var_ga(name, &varname);
  3272.     if (gap == NULL)
  3273. return NULL;
  3275.     for (i = gap->ga_len; --i >= 0; )
  3276. if (VAR_GAP_ENTRY(i, gap).var_name != NULL
  3277. && STRCMP(VAR_GAP_ENTRY(i, gap).var_name, varname) == 0)
  3278.     break;
  3279.     if (i < 0)
  3280. return NULL;
  3281.     return &VAR_GAP_ENTRY(i, gap);
  3282. }
  3284. /*
  3285.  * Find the growarray and start of name without ':' for a variable name.
  3286.  */
  3287.     static struct growarray *
  3288. find_var_ga(name, varname)
  3289.     char_u  *name;
  3290.     char_u  **varname;
  3291. {
  3292.     if (name[1] != ':')
  3293.     {
  3294. *varname = name;
  3295. if (current_funccal == NULL)
  3296.     return &variables; /* global variable */
  3297. return &current_funccal->l_vars; /* local function variable */
  3298.     }
  3299.     *varname = name + 2;
  3300.     if (*name == 'b') /* buffer variable */
  3301. return &curbuf->b_vars;
  3302.     if (*name == 'w') /* window variable */
  3303. return &curwin->w_vars;
  3304.     if (*name == 'g') /* global variable */
  3305. return &variables;
  3306.     if (*name == 'l' && current_funccal != NULL)/* local function variable */
  3307. return &current_funccal->l_vars;
  3308.     return NULL;
  3309. }
  3311. /*
  3312.  * Initialize internal variables for use.
  3313.  */
  3314.     void
  3315. var_init(gap)
  3316.     struct growarray *gap;
  3317. {
  3318.     ga_init2(gap, (int)sizeof(var), 4);
  3319. }
  3321. /*
  3322.  * Clean up a list of internal variables.
  3323.  */
  3324.     void
  3325. var_clear(gap)
  3326.     struct growarray *gap;
  3327. {
  3328.     int     i;
  3330.     for (i = gap->ga_len; --i >= 0; )
  3331. var_free_one(&VAR_GAP_ENTRY(i, gap));
  3332.     ga_clear(gap);
  3333. }
  3335.     static void
  3336. var_free_one(v)
  3337.     VAR     v;
  3338. {
  3339.     vim_free(v->var_name);
  3340.     v->var_name = NULL;
  3341.     if (v->var_type == VAR_STRING)
  3342. vim_free(v->var_val.var_string);
  3343.     v->var_val.var_string = NULL;
  3344. }
  3346. /*
  3347.  * List the value of one internal variable.
  3348.  */
  3349.     static void
  3350. list_one_var(v, prefix)
  3351.     VAR     v;
  3352.     char_u  *prefix;
  3353. {
  3354.     msg(prefix);
  3355.     msg_puts(v->var_name);
  3356.     msg_putchar(' ');
  3357.     msg_advance(22);
  3358.     if (v->var_type == VAR_NUMBER)
  3359. msg_putchar('#');
  3360.     else
  3361. msg_putchar(' ');
  3362.     msg_outtrans(get_var_string(v));
  3363. }
  3365. /*
  3366.  * Set variable "name" to value in "varp".
  3367.  * If the variable already exists, the value is updated.
  3368.  * Otherwise the variable is created.
  3369.  */
  3370.     static void
  3371. set_var(name, varp)
  3372.     char_u *name;
  3373.     VAR varp;
  3374. {
  3375.     int i;
  3376.     VAR v;
  3377.     char_u *varname;
  3378.     struct growarray *gap;
  3380.     v = find_var(name, TRUE);
  3381.     if (v != NULL)     /* existing variable, only need to free string */
  3382.     {
  3383. if (v->var_type == VAR_STRING)
  3384.     vim_free(v->var_val.var_string);
  3385.     }
  3386.     else     /* add a new variable */
  3387.     {
  3388. gap = find_var_ga(name, &varname);
  3389. if (gap == NULL)    /* illegal name */
  3390.     return;
  3392. /* Try to use an empty entry */
  3393. for (i = gap->ga_len; --i >= 0; )
  3394.     if (VAR_GAP_ENTRY(i, gap).var_name == NULL)
  3395. break;
  3396. if (i < 0)     /* need to allocated more room */
  3397. {
  3398.     if (ga_grow(gap, 1) == FAIL)
  3399. return;
  3400.     i = gap->ga_len;
  3401. }
  3402. v = &VAR_GAP_ENTRY(i, gap);
  3403. if ((v->var_name = vim_strsave(varname)) == NULL)
  3404.     return;
  3405. if (i == gap->ga_len)
  3406. {
  3407.     ++gap->ga_len;
  3408.     --gap->ga_room;
  3409. }
  3410.     }
  3412.     v->var_type = varp->var_type;
  3413.     if (varp->var_type == VAR_STRING)
  3414. v->var_val.var_string = vim_strsave(get_var_string(varp));
  3415.     else
  3416. v->var_val.var_number = varp->var_val.var_number;
  3417. }
  3419. /*
  3420.  * Implementation of
  3421.  * ":echo expr1 ..." print each argument separated with a space, add a
  3422.  * newline at the end.
  3423.  * ":echon expr1 ..." print each argument plain.
  3424.  */
  3425.     void
  3426. do_echo(eap, echo)
  3427.     EXARG *eap;
  3428.     int echo;     /* TRUE for ":echo" command, FALSE for ":echon" */
  3429. {
  3430.     char_u *arg = eap->arg;
  3431.     var retvar;
  3432.     char_u *p;
  3433.     int needclr = TRUE;
  3434.     int atstart = TRUE;
  3436.     if (eap->skip)
  3437. ++emsg_off;
  3438.     else if (echo)
  3439. msg_start();
  3440.     while (*arg != NUL && *arg != '|' && *arg != 'n')
  3441.     {
  3442. if (eval1(&arg, &retvar) == FAIL)
  3443.     break;
  3444. if (!eap->skip)
  3445. {
  3446.     if (atstart)
  3447. atstart = FALSE;
  3448.     else if (echo)
  3449. msg_puts_attr((char_u *)" ", echo_attr);
  3450.     for (p = get_var_string(&retvar); *p != NUL; ++p)
  3451. if (*p == 'n' || *p == 'r' || *p == TAB)
  3452. {
  3453.     if (*p != TAB && needclr)
  3454.     {
  3455. /* remove any text still there from the command */
  3456. msg_clr_eos();
  3457. needclr = FALSE;
  3458.     }
  3459.     msg_putchar_attr(*p, echo_attr);
  3460. }
  3461. else
  3462.     (void)msg_outtrans_len_attr(p, 1, echo_attr);
  3463. }
  3464. clear_var(&retvar);
  3465. arg = skipwhite(arg);
  3466.     }
  3467.     eap->nextcmd = check_nextcmd(arg);
  3469.     if (eap->skip)
  3470. --emsg_off;
  3471.     else
  3472.     {
  3473. /* remove text that may still be there from the command */
  3474. if (needclr)
  3475.     msg_clr_eos();
  3476. if (echo)
  3477.     msg_end();
  3478.     }
  3479. }
  3481. /*
  3482.  * Implementation of ":echohl {name}".
  3483.  */
  3484.     void
  3485. do_echohl(arg)
  3486.     char_u *arg;
  3487. {
  3488.     int id;
  3490.     id = syn_name2id(arg);
  3491.     if (id == 0)
  3492. echo_attr = 0;
  3493.     else
  3494. echo_attr = syn_id2attr(id);
  3495. }
  3497. /*
  3498.  * Implementation of
  3499.  * ":execute expr1 ..." execute the result of an expression.
  3500.  */
  3501.     void
  3502. do_execute(eap, getline, cookie)
  3503.     EXARG *eap;
  3504.     char_u *(*getline) __ARGS((int, void *, int));
  3505.     void *cookie; /* argument for getline() */
  3506. {
  3507.     char_u *arg = eap->arg;
  3508.     var retvar;
  3509.     int ret = OK;
  3510.     char_u *p;
  3511.     struct growarray ga;
  3512.     int len;
  3514.     ga_init2(&ga, 1, 80);
  3516.     if (eap->skip)
  3517. ++emsg_off;
  3518.     while (*arg != NUL && *arg != '|' && *arg != 'n')
  3519.     {
  3520. if (eval1(&arg, &retvar) == FAIL)
  3521. {
  3522.     ret = FAIL;
  3523.     break;
  3524. }
  3526. if (!eap->skip)
  3527. {
  3528.     p = get_var_string(&retvar);
  3529.     len = STRLEN(p);
  3530.     if (ga_grow(&ga, len + 2) == FAIL)
  3531.     {
  3532. clear_var(&retvar);
  3533. ret = FAIL;
  3534. break;
  3535.     }
  3536.     if (ga.ga_len)
  3537.     {
  3538. ((char_u *)(ga.ga_data))[ga.ga_len++] = ' ';
  3539. --ga.ga_room;
  3540.     }
  3541.     STRCPY((char_u *)(ga.ga_data) + ga.ga_len, p);
  3542.     ga.ga_room -= len;
  3543.     ga.ga_len += len;
  3544. }
  3546. clear_var(&retvar);
  3547. arg = skipwhite(arg);
  3548.     }
  3550.     if (ret != FAIL && ga.ga_data != NULL)
  3551. do_cmdline((char_u *)ga.ga_data,
  3552.  getline, cookie, DOCMD_NOWAIT|DOCMD_VERBOSE);
  3554.     ga_clear(&ga);
  3556.     if (eap->skip)
  3557. --emsg_off;
  3559.     eap->nextcmd = check_nextcmd(arg);
  3560. }
  3562.     static char_u *
  3563. find_option_end(p)
  3564.     char_u  *p;
  3565. {
  3566.     while (isalnum(*p) || *p == '_')
  3567. ++p;
  3568.     return p;
  3569. }
  3571. /*
  3572.  * Handle the ":function" command.
  3573.  * "getline" can be NULL, in which case a line is obtained from the user.
  3574.  */
  3575.     void
  3576. do_function(eap, getline, cookie)
  3577.     EXARG *eap;
  3578.     char_u *(*getline) __ARGS((int, void *, int));
  3579.     void *cookie; /* argument for getline() */
  3580. {
  3581.     char_u *theline;
  3582.     int j;
  3583.     int c;
  3584.     char_u *name;
  3585.     char_u *nameend;
  3586.     char_u *p;
  3587.     char_u *arg;
  3588.     struct growarray newargs;
  3589.     struct growarray newlines;
  3590.     int varargs = FALSE;
  3591.     int mustend = FALSE;
  3592.     int flags = 0;
  3593.     struct ufunc *fp;
  3595.     /*
  3596.      * ":function" without argument: list functions.
  3597.      */
  3598.     if (*eap->arg == NUL)
  3599.     {
  3600. if (!eap->skip)
  3601.     for (fp = firstfunc; fp != NULL; fp = fp->next)
  3602. list_func_head(fp);
  3603. return;
  3604.     }
  3606.     if (!isupper(*eap->arg))
  3607.     {
  3608. EMSG2("Function name must start with a capital: %s", eap->arg);
  3609. return;
  3610.     }
  3612.     /*
  3613.      * ":function func" with only function name: list function.
  3614.      */
  3615.     if (vim_strchr(eap->arg, '(') == NULL)
  3616.     {
  3617. if (!eap->skip)
  3618. {
  3619.     fp = find_func(eap->arg);
  3620.     if (fp != NULL)
  3621.     {
  3622. list_func_head(fp);
  3623. for (j = 0; j < fp->lines.ga_len; ++j)
  3624. {
  3625.     msg_putchar('n');
  3626.     msg_prt_line(FUNCLINE(fp, j));
  3627. }
  3628. MSG("endfunction");
  3629.     }
  3630.     else
  3631. EMSG2("Undefined function: %s", eap->arg);
  3632. }
  3633. return;
  3634.     }
  3636.     /*
  3637.      * ":function name(arg1, arg2)" Define function.
  3638.      */
  3639.     name = eap->arg;
  3640.     for (p = name; isalpha(*p) || isdigit(*p) || *p == '_'; ++p)
  3641. ;
  3642.     if (p == name)
  3643.     {
  3644. EMSG("Function name required");
  3645. return;
  3646.     }
  3647.     nameend = p;
  3648.     p = skipwhite(p);
  3649.     if (*p != '(')
  3650.     {
  3651. EMSG2("Missing '(': %s", name);
  3652. return;
  3653.     }
  3654.     p = skipwhite(p + 1);
  3656.     ga_init2(&newargs, (int)sizeof(char_u *), 3);
  3657.     ga_init2(&newlines, (int)sizeof(char_u *), 3);
  3659.     /*
  3660.      * Isolate the arguments: "arg1, arg2, ...)"
  3661.      */
  3662.     while (*p != ')')
  3663.     {
  3664. if (p[0] == '.' && p[1] == '.' && p[2] == '.')
  3665. {
  3666.     varargs = TRUE;
  3667.     p += 3;
  3668.     mustend = TRUE;
  3669. }
  3670. else
  3671. {
  3672.     arg = p;
  3673.     while (isalpha(*p) || isdigit(*p) || *p == '_')
  3674. ++p;
  3675.     if (arg == p || isdigit(*arg))
  3676.     {
  3677. EMSG2("Illegal argument: %s", arg);
  3678. goto erret;
  3679.     }
  3680.     if (ga_grow(&newargs, 1) == FAIL)
  3681. goto erret;
  3682.     c = *p;
  3683.     *p = NUL;
  3684.     arg = vim_strsave(arg);
  3685.     if (arg == NULL)
  3686. goto erret;
  3687.     ((char_u **)(newargs.ga_data))[newargs.ga_len] = arg;
  3688.     *p = c;
  3689.     newargs.ga_len++;
  3690.     newargs.ga_room--;
  3691.     if (*p == ',')
  3692. ++p;
  3693.     else
  3694. mustend = TRUE;
  3695. }
  3696. p = skipwhite(p);
  3697. if (mustend && *p != ')')
  3698. {
  3699.     EMSG2(e_invarg2, eap->arg);
  3700.     goto erret;
  3701. }
  3702.     }
  3703.     ++p; /* skip the ')' */
  3705.     /* find extra arguments "range" and "abort" */
  3706.     for (;;)
  3707.     {
  3708. p = skipwhite(p);
  3709. if (STRNCMP(p, "range", 5) == 0)
  3710. {
  3711.     flags |= FC_RANGE;
  3712.     p += 5;
  3713. }
  3714. else if (STRNCMP(p, "abort", 5) == 0)
  3715. {
  3716.     flags |= FC_ABORT;
  3717.     p += 5;
  3718. }
  3719. else
  3720.     break;
  3721.     }
  3723.     if (*p != NUL && *p != '"' && *p != 'n')
  3724.     {
  3725. EMSG(e_trailing);
  3726. goto erret;
  3727.     }
  3729.     /*
  3730.      * Read the body of the function, until ":endfunction" is found.
  3731.      */
  3732.     if (KeyTyped)
  3733.     {
  3734. msg_putchar('n');     /* don't overwrite the function name */
  3735. cmdline_row = msg_row;
  3736.     }
  3737.     for (;;)
  3738.     {
  3739. msg_scroll = TRUE;
  3740. need_wait_return = FALSE;
  3741. if (getline == NULL)
  3742.     theline = getcmdline(':', 0L, 2);
  3743. else
  3744.     theline = getline(':', cookie, 2);
  3745. lines_left = Rows - 1;
  3746. if (theline == NULL)
  3747.     goto erret;
  3749. for (p = theline; vim_iswhite(*p) || *p == ':'; ++p)
  3750.     ;
  3751. if (STRNCMP(p, "endf", 4) == 0)
  3752. {
  3753.     vim_free(theline);
  3754.     break;
  3755. }
  3756. if (ga_grow(&newlines, 1) == FAIL)
  3757.     goto erret;
  3758. ((char_u **)(newlines.ga_data))[newlines.ga_len] = theline;
  3759. newlines.ga_len++;
  3760. newlines.ga_room--;
  3761.     }
  3763.     if (eap->skip)
  3764. goto erret;
  3766.     /*
  3767.      * If there are no errors, add the function
  3768.      */
  3769.     *nameend = NUL;
  3770.     fp = find_func(name);
  3771.     if (fp != NULL)
  3772.     {
  3773. if (!eap->forceit)
  3774. {
  3775.     EMSG2("Function %s already exists, use ! to replace", name);
  3776.     goto erret;
  3777. }
  3778. /* redefine existing function */
  3779. ga_clear_strings(&(fp->args));
  3780. ga_clear_strings(&(fp->lines));
  3781.     }
  3782.     else
  3783.     {
  3784. fp = (struct ufunc *)alloc((unsigned)sizeof(struct ufunc));
  3785. if (fp == NULL)
  3786.     goto erret;
  3787. name = vim_strsave(name);
  3788. if (name == NULL)
  3789. {
  3790.     vim_free(fp);
  3791.     goto erret;
  3792. }
  3793. /* insert the new function in the function list */
  3794. fp->next = firstfunc;
  3795. firstfunc = fp;
  3796. fp->name = name;
  3797.     }
  3798.     fp->args = newargs;
  3799.     fp->lines = newlines;
  3800.     fp->varargs = varargs;
  3801.     fp->flags = flags;
  3802.     return;
  3804. erret:
  3805.     ga_clear_strings(&newargs);
  3806.     ga_clear_strings(&newlines);
  3807. }
  3809. /*
  3810.  * List the head of the function: "name(arg1, arg2)".
  3811.  */
  3812.     static void
  3813. list_func_head(fp)
  3814.     struct ufunc *fp;
  3815. {
  3816.     int j;
  3818.     MSG("function ");
  3819.     msg_puts(fp->name);
  3820.     msg_putchar('(');
  3821.     for (j = 0; j < fp->args.ga_len; ++j)
  3822.     {
  3823. if (j)
  3824.     MSG_PUTS(", ");
  3825. msg_puts(FUNCARG(fp, j));
  3826.     }
  3827.     if (fp->varargs)
  3828.     {
  3829. if (j)
  3830.     MSG_PUTS(", ");
  3831. MSG_PUTS("...");
  3832.     }
  3833.     msg_putchar(')');
  3834. }
  3836. /*
  3837.  * Find a function by name, return its index in ufuncs.
  3838.  * Return -1 for unknown function.
  3839.  */
  3840.     static struct ufunc *
  3841. find_func(name)
  3842.     char_u *name;
  3843. {
  3844.     struct ufunc *fp;
  3846.     for (fp = firstfunc; fp != NULL; fp = fp->next)
  3847. if (STRCMP(name, fp->name) == 0)
  3848.     break;
  3849.     return fp;
  3850. }
  3852. /*
  3853.  * Handle ":delfunction {name}".
  3854.  */
  3855.     void
  3856. do_delfunction(arg)
  3857.     char_u *arg;
  3858. {
  3859.     struct ufunc *fp, *pfp;
  3861.     fp = find_func(arg);
  3862.     if (fp == NULL)
  3863.     {
  3864. EMSG2("Undefined function: %s", arg);
  3865. return;
  3866.     }
  3868.     /* clear this function */
  3869.     vim_free(fp->name);
  3870.     ga_clear_strings(&(fp->args));
  3871.     ga_clear_strings(&(fp->lines));
  3873.     /* remove the function from the function list */
  3874.     if (firstfunc == fp)
  3875. firstfunc = fp->next;
  3876.     else
  3877. for (pfp = firstfunc; pfp != NULL; pfp = pfp->next)
  3878.     if (pfp->next == fp)
  3879.     {
  3880. pfp->next = fp->next;
  3881. break;
  3882.     }
  3883. }
  3885. /*
  3886.  * Call a user function.
  3887.  */
  3888.     static void
  3889. call_func(fp, argcount, argvars, retvar, firstline, lastline)
  3890.     struct ufunc *fp; /* pointer to function */
  3891.     int argcount; /* nr of args */
  3892.     VAR argvars; /* arguments */
  3893.     VAR retvar; /* return value */
  3894.     linenr_t firstline; /* first line of range */
  3895.     linenr_t lastline; /* last line of range */
  3896. {
  3897.     char_u *save_sourcing_name;
  3898.     int save_redrawing = RedrawingDisabled;
  3899.     struct funccall fc;
  3900.     struct funccall *save_fcp = current_funccal;
  3901.     int save_did_emsg;
  3902.     static int depth = 0;
  3904.     /* If depth of calling is getting too high, don't execute the function */
  3905.     if (depth >= p_mfd)
  3906.     {
  3907. EMSG("Function call depth is higher than 'maxfuncdepth'");
  3908. retvar->var_type = VAR_NUMBER;
  3909. retvar->var_val.var_number = -1;
  3910. return;
  3911.     }
  3912.     ++depth;
  3914.     line_breakcheck(); /* check for CTRL-C hit */
  3916.     /* set local variables */
  3917.     var_init(&fc.l_vars);
  3918.     fc.func = fp;
  3919.     fc.argcount = argcount;
  3920.     fc.argvars = argvars;
  3921.     fc.retvar = retvar;
  3922.     retvar->var_val.var_number = 0;
  3923.     fc.linenr = 0;
  3924.     fc.a0_var.var_type = VAR_NUMBER;
  3925.     fc.a0_var.var_val.var_number = argcount - fp->args.ga_len;
  3926.     fc.a0_var.var_name = NULL;
  3927.     current_funccal = &fc;
  3928.     fc.firstline.var_type = VAR_NUMBER;
  3929.     fc.firstline.var_val.var_number = firstline;
  3930.     fc.firstline.var_name = NULL;
  3931.     fc.lastline.var_type = VAR_NUMBER;
  3932.     fc.lastline.var_val.var_number = lastline;
  3933.     fc.lastline.var_name = NULL;
  3935.     /* Don't redraw while executing the function. */
  3936.     RedrawingDisabled = TRUE;
  3937.     save_sourcing_name = sourcing_name;
  3938.     sourcing_name = alloc((unsigned)((save_sourcing_name == NULL ? 0
  3939. : STRLEN(save_sourcing_name)) + STRLEN(fp->name) + 10));
  3940.     if (sourcing_name != NULL)
  3941.     {
  3942. if (save_sourcing_name != NULL
  3943.   && STRNCMP(save_sourcing_name, "function ", 9) == 0)
  3944.     sprintf((char *)sourcing_name, "%s->", save_sourcing_name);
  3945. else
  3946.     STRCPY(sourcing_name, "function ");
  3947. STRCAT(sourcing_name, fp->name);
  3948.     }
  3949.     save_did_emsg = did_emsg;
  3950.     did_emsg = FALSE;
  3952.     /* call do_cmdline() to execute the lines */
  3953.     do_cmdline(NULL, get_func_line, (void *)&fc,
  3954.      DOCMD_NOWAIT|DOCMD_VERBOSE|DOCMD_REPEAT);
  3956.     RedrawingDisabled = save_redrawing;
  3957.     vim_free(sourcing_name);
  3958.     sourcing_name = save_sourcing_name;
  3960.     /* when the function was aborted because of an error, return -1 */
  3961.     if (did_emsg && (fp->flags & FC_ABORT))
  3962.     {
  3963. clear_var(retvar);
  3964. retvar->var_type = VAR_NUMBER;
  3965. retvar->var_val.var_number = -1;
  3966.     }
  3967.     did_emsg |= save_did_emsg;
  3968.     current_funccal = save_fcp;
  3970.     var_clear(&fc.l_vars); /* free all local variables */
  3971.     --depth;
  3972. }
  3974. /*
  3975.  * Save the current function call pointer, and set it to NULL.
  3976.  * Used when executing autocommands and for ":source".
  3977.  */
  3978.     void *
  3979. save_funccal()
  3980. {
  3981.     struct funccall *fc;
  3983.     fc = current_funccal;
  3984.     current_funccal = NULL;
  3985.     return (void *)fc;
  3986. }
  3988.     void
  3989. restore_funccal(fc)
  3990.     void *fc;
  3991. {
  3992.     current_funccal = (struct funccall *)fc;
  3993. }
  3995. /*
  3996.  * Handle ":return [expr]".
  3997.  */
  3998.     void
  3999. do_return(eap)
  4000.     EXARG *eap;
  4001. {
  4002.     char_u *arg = eap->arg;
  4003.     var retvar;
  4005.     if (current_funccal == NULL)
  4006.     {
  4007. EMSG(":return not inside a function");
  4008. return;
  4009.     }
  4011.     if (eap->skip)
  4012. ++emsg_off;
  4013.     else
  4014. current_funccal->linenr = -1;
  4016.     if (*arg != NUL && *arg != '|' && *arg != 'n')
  4017.     {
  4018. if (eval1(&arg, &retvar) != FAIL)
  4019. {
  4020.     if (!eap->skip)
  4021.     {
  4022. clear_var(current_funccal->retvar);
  4023. *current_funccal->retvar = retvar;
  4024.     }
  4025.     else
  4026. clear_var(&retvar);
  4027. }
  4028.     }
  4030.     /* when skipping, advance to the next command in this line.  When not
  4031.      * skipping, ignore the rest of the line.  Following lines will be ignored
  4032.      * by get_func_line(). */
  4033.     if (eap->skip)
  4034.     {
  4035. --emsg_off;
  4036. eap->nextcmd = check_nextcmd(arg);
  4037.     }
  4038.     else
  4039. eap->nextcmd = NULL;
  4040. }
  4042. /*
  4043.  * Get next function line.
  4044.  * Called by do_cmdline() to get the next line.
  4045.  * Returns allocated string, or NULL for end of function.
  4046.  */
  4047. /* ARGSUSED */
  4048.     char_u *
  4049. get_func_line(c, cookie, indent)
  4050.     int     c;     /* not used */
  4051.     void    *cookie;
  4052.     int     indent;     /* not used */
  4053. {
  4054.     struct funccall  *fcp = (struct funccall *)cookie;
  4055.     char_u     *retval;
  4056.     struct growarray *gap;  /* growarray with function lines */
  4058.     gap = &fcp->func->lines;
  4059.     if ((fcp->func->flags & FC_ABORT) && did_emsg)
  4060. retval = NULL;
  4061.     else if (fcp->linenr < 0 || fcp->linenr >= gap->ga_len)
  4062. retval = NULL;
  4063.     else
  4064. retval = vim_strsave(((char_u **)(gap->ga_data))[fcp->linenr++]);
  4066.     if (p_verbose >= 15)
  4067.     {
  4068. msg_scroll = TRUE;     /* always scroll up, don't overwrite */
  4069. if (retval == NULL)
  4070.     msg((char_u *)"function returning");
  4071. else
  4072.     smsg((char_u *)"function line %s", retval);
  4073. msg_puts((char_u *)"n");   /* don't overwrite this either */
  4074. cmdline_row = msg_row;
  4075.     }
  4076.     return retval;
  4077. }
  4079. /*
  4080.  * Return TRUE if the currently active function should be ended, because a
  4081.  * return was encountered or an error occured.  Used inside a ":while".
  4082.  */
  4083.     int
  4084. func_has_ended(cookie)
  4085.     void    *cookie;
  4086. {
  4087.     struct funccall  *fcp = (struct funccall *)cookie;
  4089.     return (((fcp->func->flags & FC_ABORT) && did_emsg) || fcp->linenr < 0);
  4090. }
  4092. /*
  4093.  * return TRUE if cookie indicates a function which "abort"s on errors.
  4094.  */
  4095.     int
  4096. func_has_abort(cookie)
  4097.     void    *cookie;
  4098. {
  4099.     return ((struct funccall *)cookie)->func->flags & FC_ABORT;
  4100. }
  4101. #endif /* WANT_EVAL */
  4103. #if defined(WANT_MODIFY_FNAME) || defined(WANT_EVAL)
  4105. /*
  4106.  * Adjust a filename, according to a string of modifiers.
  4107.  * *fnamep must be NUL terminated when called.  When returning, the length is
  4108.  * determined by *fnamelen.
  4109.  * Returns valid flags.
  4110.  * When there is an error, *fnamep is set to NULL.
  4111.  */
  4112.     int
  4113. modify_fname(src, usedlen, fnamep, bufp, fnamelen)
  4114.     char_u *src; /* string with modifiers */
  4115.     int *usedlen; /* characters after src that are used */
  4116.     char_u **fnamep; /* file name so far */
  4117.     char_u **bufp; /* buffer for allocated file name or NULL */
  4118.     int *fnamelen; /* length of fnamep */
  4119. {
  4120.     int valid = 0;
  4121.     char_u *tail;
  4122.     char_u *s, *p;
  4123.     char_u dirname[MAXPATHL];
  4125. repeat:
  4126.     /* ":p" - full path/file_name */
  4127.     if (src[*usedlen] == ':' && src[*usedlen + 1] == 'p')
  4128.     {
  4129. valid |= VALID_PATH;
  4130. *usedlen += 2;
  4131. *fnamep = FullName_save(*fnamep, FALSE);
  4132. vim_free(*bufp); /* free any allocated file name */
  4133. *bufp = *fnamep;
  4134. if (*fnamep == NULL)
  4135.     return -1;
  4136.     }
  4138.     /* ":." - path relative to the current directory */
  4139.     if (src[*usedlen] == ':' && src[*usedlen + 1] == '.')
  4140.     {
  4141. *usedlen += 2;
  4142. /* Need full path first (use force to remove a "~/") */
  4143. p = FullName_save(*fnamep, **fnamep == '~');
  4144. if (p != NULL)
  4145. {
  4146.     mch_dirname(dirname, MAXPATHL);
  4147.     s = shorten_fname(p, dirname);
  4148.     if (s != NULL)
  4149.     {
  4150. *fnamep = s;
  4151. vim_free(*bufp); /* free any allocated file name */
  4152. *bufp = p;
  4153.     }
  4154.     else
  4155. vim_free(p);
  4156. }
  4157.     }
  4159.     /* ":~" - path relative to the home directory */
  4160.     if (src[*usedlen] == ':' && src[*usedlen + 1] == '~')
  4161.     {
  4162. *usedlen += 2;
  4163. /* Need full path first */
  4164. p = FullName_save(*fnamep, FALSE);
  4165. if (p != NULL)
  4166. {
  4167.     home_replace(NULL, p, dirname, MAXPATHL, TRUE);
  4168.     /* Only replace it when it starts with '~' */
  4169.     if (*dirname == '~')
  4170.     {
  4171. s = vim_strsave(dirname);
  4172. if (s != NULL)
  4173. {
  4174.     *fnamep = s;
  4175.     vim_free(*bufp);
  4176.     *bufp = s;
  4177. }
  4178.     }
  4179.     vim_free(p);
  4180. }
  4181.     }
  4183.     tail = gettail(*fnamep);
  4184.     *fnamelen = STRLEN(*fnamep);
  4186.     /* ":h" - head, remove "/file_name", can be repeated  */
  4187.     /* Don't remove the first "/" or "c:" */
  4188.     while (src[*usedlen] == ':' && src[*usedlen + 1] == 'h')
  4189.     {
  4190. valid |= VALID_HEAD;
  4191. *usedlen += 2;
  4192. s = get_past_head(*fnamep);
  4193. while (tail > s && vim_ispathsep(tail[-1]))
  4194.     --tail;
  4195. *fnamelen = tail - *fnamep;
  4196. while (tail > s && !vim_ispathsep(tail[-1]))
  4197.     --tail;
  4198.     }
  4200.     /* ":t" - tail, just the basename */
  4201.     if (src[*usedlen] == ':' && src[*usedlen + 1] == 't')
  4202.     {
  4203. *usedlen += 2;
  4204. *fnamelen -= tail - *fnamep;
  4205. *fnamep = tail;
  4206.     }
  4208.     /* ":e" - extension, can be repeated */
  4209.     /* ":r" - root, without extension, can be repeated */
  4210.     while (src[*usedlen] == ':'
  4211.     && (src[*usedlen + 1] == 'e' || src[*usedlen + 1] == 'r'))
  4212.     {
  4213. /* find a '.' in the tail:
  4214.  * - for second :e: before the current fname
  4215.  * - otherwise: The last '.'
  4216.  */
  4217. if (src[*usedlen + 1] == 'e' && *fnamep > tail)
  4218.     s = *fnamep - 2;
  4219. else
  4220.     s = *fnamep + *fnamelen - 1;
  4221. for ( ; s > tail; --s)
  4222.     if (s[0] == '.')
  4223. break;
  4224. if (src[*usedlen + 1] == 'e') /* :e */
  4225. {
  4226.     if (s > tail)
  4227.     {
  4228. *fnamelen += *fnamep - (s + 1);
  4229. *fnamep = s + 1;
  4230.     }
  4231.     else if (*fnamep <= tail)
  4232. *fnamelen = 0;
  4233. }
  4234. else /* :r */
  4235. {
  4236.     if (s > tail) /* remove one extension */
  4237. *fnamelen = s - *fnamep;
  4238. }
  4239. *usedlen += 2;
  4240.     }
  4242.     /* ":s?pat?foo?" - substitute */
  4243.     /* ":gs?pat?foo?" - global substitute */
  4244.     if (src[*usedlen] == ':'
  4245.     && (src[*usedlen + 1] == 's'
  4246. || (src[*usedlen + 1] == 'g' && src[*usedlen + 2] == 's')))
  4247.     {
  4248. char_u     *str;
  4249. char_u     *pat;
  4250. char_u     *sub;
  4251. int     sep;
  4252. char_u     *flags;
  4253. int     didit = FALSE;
  4255. flags = (char_u *)"";
  4256. s = src + *usedlen + 2;
  4257. if (src[*usedlen + 1] == 'g')
  4258. {
  4259.     flags = (char_u *)"g";
  4260.     ++s;
  4261. }
  4263. sep = *s++;
  4264. if (sep)
  4265. {
  4266.     /* find end of pattern */
  4267.     p = vim_strchr(s, sep);
  4268.     if (p != NULL)
  4269.     {
  4270. pat = vim_strnsave(s, (int)(p - s));
  4271. if (pat != NULL)
  4272. {
  4273.     s = p + 1;
  4274.     /* find end of substitution */
  4275.     p = vim_strchr(s, sep);
  4276.     if (p != NULL)
  4277.     {
  4278. sub = vim_strnsave(s, (int)(p - s));
  4279. str = vim_strnsave(*fnamep, *fnamelen);
  4280. if (sub != NULL && str != NULL)
  4281. {
  4282.     *usedlen = p + 1 - src;
  4283.     s = do_string_sub(str, pat, sub, flags);
  4284.     if (s != NULL)
  4285.     {
  4286. *fnamep = s;
  4287. *fnamelen = STRLEN(s);
  4288. vim_free(*bufp);
  4289. *bufp = s;
  4290. didit = TRUE;
  4291.     }
  4292. }
  4293. vim_free(sub);
  4294. vim_free(str);
  4295.     }
  4296.     vim_free(pat);
  4297. }
  4298.     }
  4299.     /* after using ":s", repeat all the modifiers */
  4300.     if (didit)
  4301. goto repeat;
  4302. }
  4303.     }
  4305.     return valid;
  4306. }
  4308. /*
  4309.  * Perform a substitution on "str" with pattern "pat" and substitute "sub".
  4310.  * "flags" can be "g" to do a global substitute.
  4311.  * Returns an allocated string, NULL for error.
  4312.  */
  4313.     char_u *
  4314. do_string_sub(str, pat, sub, flags)
  4315.     char_u *str;
  4316.     char_u *pat;
  4317.     char_u *sub;
  4318.     char_u *flags;
  4319. {
  4320.     int sublen;
  4321.     vim_regexp *prog;
  4322.     int i;
  4323.     int do_all;
  4324.     char_u *tail;
  4325.     struct growarray ga;
  4326.     char_u *ret;
  4328.     ga_init2(&ga, 1, 200);
  4330.     do_all = (flags[0] == 'g');
  4332.     reg_ic = p_ic;
  4333.     prog = vim_regcomp(pat, TRUE);
  4334.     if (prog != NULL)
  4335.     {
  4336. tail = str;
  4337. while (vim_regexec(prog, tail, tail == str))
  4338. {
  4339.     /*
  4340.      * Get some space for a temporary buffer to do the substitution
  4341.      * into.  It will contain:
  4342.      * - The text up to where the match is.
  4343.      * - The substituted text.
  4344.      * - The text after the match.
  4345.      */
  4346.     sublen = vim_regsub(prog, sub, tail, FALSE, TRUE);
  4347.     if (ga_grow(&ga, (int)(STRLEN(tail) + sublen -
  4348.   (prog->endp[0] - prog->startp[0]))) == FAIL)
  4349.     {
  4350. ga_clear(&ga);
  4351. break;
  4352.     }
  4354.     /* copy the text up to where the match is */
  4355.     i = prog->startp[0] - tail;
  4356.     mch_memmove((char_u *)ga.ga_data + ga.ga_len, tail, (size_t)i);
  4357.     /* add the substituted text */
  4358.     (void)vim_regsub(prog, sub, (char_u *)ga.ga_data + ga.ga_len + i,
  4359.   TRUE, TRUE);
  4360.     ga.ga_len += i + sublen - 1;
  4361.     ga.ga_room -= i + sublen - 1;
  4362.     /* avoid getting stuck on a match with an empty string */
  4363.     if (tail == prog->endp[0])
  4364.     {
  4365. *((char_u *)ga.ga_data + ga.ga_len) = *tail++;
  4366. ++ga.ga_len;
  4367. --ga.ga_room;
  4368.     }
  4369.     else
  4370.     {
  4371. tail = prog->endp[0];
  4372. if (*tail == NUL)
  4373.     break;
  4374.     }
  4375.     if (!do_all)
  4376. break;
  4377. }
  4379. if (ga.ga_data != NULL)
  4380.     STRCPY((char *)ga.ga_data + ga.ga_len, tail);
  4382. vim_free(prog);
  4383.     }
  4385.     ret = vim_strsave(ga.ga_data == NULL ? str : (char_u *)ga.ga_data);
  4386.     ga_clear(&ga);
  4387.     return ret;
  4388. }
  4390. #endif /* defined(WANT_MODIFY_FNAME) || defined(WANT_EVAL) */