vim: src/eval.c comparison

comparison src/eval.c @ 271:8d34af900bae v7.0072

updated for version 7.0072

author	vimboss
date	Wed, 18 May 2005 22:24:46 +0000
parents	e7904492cb75
children	8fa8d7964cf1

comparison

equal deleted inserted replaced

-:a20218704019
+:8d34af900bae
 static win_T *find_win_by_nr __ARGS((typval_T *vp));
 static pos_T *var2fpos __ARGS((typval_T *varp, int lnum));
 static int get_env_len __ARGS((char_u **arg));
 static int get_id_len __ARGS((char_u **arg));
 static int get_name_len __ARGS((char_u **arg, char_u **alias, int evaluate, int verbose));
-static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int incl_br));
+static char_u *find_name_end __ARGS((char_u *arg, char_u **expr_start, char_u **expr_end, int flags));
+#define FNE_INCL_BR	1	/* find_name_end(): include [] in name */
+#define FNE_CHECK_START	2	/* find_name_end(): check name starts with
+				   valid character */
 static int eval_isnamec __ARGS((int c));
+static int eval_isnamec1 __ARGS((int c));
 static int get_var_tv __ARGS((char_u *name, int len, typval_T *rettv, int verbose));
 static int handle_subscript __ARGS((char_u **arg, typval_T *rettv, int evaluate, int verbose));
 static typval_T *alloc_tv __ARGS((void));
 static typval_T *alloc_string_tv __ARGS((char_u *string));
 static void free_tv __ARGS((typval_T *varp));
 static void list_win_vars __ARGS((void));
 static void list_vim_vars __ARGS((void));
 static char_u *list_arg_vars __ARGS((exarg_T *eap, char_u *arg));
 static char_u *ex_let_one __ARGS((char_u *arg, typval_T *tv, int copy, char_u *endchars, char_u *op));
 static int check_changedtick __ARGS((char_u *arg));
-static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet));
+static char_u *get_lval __ARGS((char_u *name, typval_T *rettv, lval_T *lp, int unlet, int skip, int quiet, int fne_flags));
 static void clear_lval __ARGS((lval_T *lp));
 static void set_var_lval __ARGS((lval_T *lp, char_u *endp, typval_T *rettv, int copy, char_u *op));
 static int tv_op __ARGS((typval_T *tv1, typval_T *tv2, char_u  *op));
 static void list_add_watch __ARGS((list_T *l, listwatch_T *lw));
 static void list_rem_watch __ARGS((list_T *l, listwatch_T *lwrem));
 static int do_unlet_var __ARGS((lval_T *lp, char_u *name_end, int forceit));
 static int do_lock_var __ARGS((lval_T *lp, char_u *name_end, int deep, int lock));
 static void item_lock __ARGS((typval_T *tv, int deep, int lock));
 static int tv_islocked __ARGS((typval_T *tv));
+/* Character used as separated in autoload function/variable names. */
+#define AUTOLOAD_CHAR '#'
 /*
 * Initialize the global and v: variables.
 */
 void
 eval_init()
 int		save_emsg;
 int		err;
 typval_T	tv;
 /* Make sure a valid variable name is specified */
-if (!eval_isnamec(*name) || VIM_ISDIGIT(*name))
+if (!eval_isnamec1(*name))
 {
 	EMSG(_(e_invarg));
 	return FAIL;
 }
 	var_redir_stop();
 	return FAIL;
 }
 /* Parse the variable name (can be a dict or list entry). */
-redir_endp = get_lval(redir_varname, NULL, redir_lval, FALSE, FALSE, FALSE);
+redir_endp = get_lval(redir_varname, NULL, redir_lval, FALSE, FALSE, FALSE,
+							     FNE_CHECK_START);
 if (redir_endp == NULL || redir_lval->ll_name == NULL || *redir_endp != NUL)
 {
 	if (redir_endp != NULL && *redir_endp != NUL)
 	    /* Trailing characters are present after the variable name */
 	    EMSG(_(e_trailing));
 skip_var_one(arg)
 char_u	*arg;
 {
 if (vim_strchr((char_u *)"$@&", *arg) != NULL)
 	++arg;
-return find_name_end(arg, NULL, NULL, TRUE);
+return find_name_end(arg, NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
 }
 /*
 * List variables for hashtab "ht" with prefix "prefix".
 * If "empty" is TRUE also list NULL strings as empty strings.
 while (!ends_excmd(*arg) && !got_int)
 {
 	if (error || eap->skip)
 	{
-	    arg = find_name_end(arg, NULL, NULL, TRUE);
+	    arg = find_name_end(arg, NULL, NULL, FNE_INCL_BR | FNE_CHECK_START);
 	    if (!vim_iswhite(*arg) && !ends_excmd(*arg))
 	    {
 		emsg_severe = TRUE;
 		EMSG(_(e_trailing));
 		break;
 /*
 * ":let var = expr": Set internal variable.
 * ":let {expr} = expr": Idem, name made with curly braces
 */
-else if ((eval_isnamec(*arg) && !VIM_ISDIGIT(*arg)) || *arg == '{')
+else if (eval_isnamec1(*arg) || *arg == '{')
 {
 	lval_T	lv;
-	p = get_lval(arg, tv, &lv, FALSE, FALSE, FALSE);
+	p = get_lval(arg, tv, &lv, FALSE, FALSE, FALSE, FNE_CHECK_START);
 	if (p != NULL && lv.ll_name != NULL)
 	{
 	    if (endchars != NULL && vim_strchr(endchars, *skipwhite(p)) == NULL)
 		EMSG(_(e_letunexp));
 	    else
 * Returns a pointer to just after the name, including indexes.
 * When an evaluation error occurs "lp->ll_name" is NULL;
 * Returns NULL for a parsing error.  Still need to free items in "lp"!
 */
 static char_u *
-get_lval(name, rettv, lp, unlet, skip, quiet)
+get_lval(name, rettv, lp, unlet, skip, quiet, fne_flags)
 char_u	*name;
 typval_T	*rettv;
 lval_T	*lp;
 int		unlet;
 int		skip;
 int		quiet;	    /* don't give error messages */
+int		fne_flags;  /* flags for find_name_end() */
 {
 char_u	*p;
 char_u	*expr_start, *expr_end;
 int		cc;
 dictitem_T	*v;
 if (skip)
 {
 	/* When skipping just find the end of the name. */
 	lp->ll_name = name;
-	return find_name_end(name, NULL, NULL, TRUE);
+	return find_name_end(name, NULL, NULL, FNE_INCL_BR | fne_flags);
 }
 /* Find the end of the name. */
-p = find_name_end(name, &expr_start, &expr_end, FALSE);
+p = find_name_end(name, &expr_start, &expr_end, fne_flags);
 if (expr_start != NULL)
 {
 	/* Don't expand the name when we already know there is an error. */
 	if (unlet && !vim_iswhite(*p) && !ends_excmd(*p)
 						    && *p != '[' && *p != '.')
 lval_T	lv;
 do
 {
 	/* Parse the name and find the end. */
-	name_end = get_lval(arg, NULL, &lv, TRUE, eap->skip || error, FALSE);
+	name_end = get_lval(arg, NULL, &lv, TRUE, eap->skip || error, FALSE,
+							     FNE_CHECK_START);
 	if (lv.ll_name == NULL)
 	    error = TRUE;	    /* error but continue parsing */
 	if (name_end == NULL || (!vim_iswhite(*name_end)
 						   && !ends_excmd(*name_end)))
 	{
 lval_T	lv;
 char_u	*end;
 dictitem_T	*di;
 rettv->vval.v_number = -1;
-end = get_lval(get_tv_string(&argvars[0]), NULL, &lv, FALSE, FALSE, FALSE);
+end = get_lval(get_tv_string(&argvars[0]), NULL, &lv, FALSE, FALSE, FALSE,
+							     FNE_CHECK_START);
 if (end != NULL && lv.ll_name != NULL)
 {
 	if (*end != NUL)
 	    EMSG(_(e_trailing));
 	else
 }
 /*
 * Find the end of the name; check for {} construction.
 */
-p = find_name_end(*arg, &expr_start, &expr_end, FALSE);
+p = find_name_end(*arg, &expr_start, &expr_end,
+					       len > 0 ? 0 : FNE_CHECK_START);
 if (expr_start != NULL)
 {
 	char_u	*temp_string;
 	if (!evaluate)
 /*
 * Find the end of a variable or function name, taking care of magic braces.
 * If "expr_start" is not NULL then "expr_start" and "expr_end" are set to the
 * start and end of the first magic braces item.
+* "flags" can have FNE_INCL_BR and FNE_CHECK_START.
 * Return a pointer to just after the name.  Equal to "arg" if there is no
 * valid name.
 */
 static char_u *
-find_name_end(arg, expr_start, expr_end, incl_br)
+find_name_end(arg, expr_start, expr_end, flags)
 char_u	*arg;
 char_u	**expr_start;
 char_u	**expr_end;
-int		incl_br;	/* Include [] indexes and .name */
+int		flags;
 {
 int		mb_nest = 0;
 int		br_nest = 0;
 char_u	*p;
 {
 	*expr_start = NULL;
 	*expr_end = NULL;
 }
+/* Quick check for valid starting character. */
+if ((flags & FNE_CHECK_START) && !eval_isnamec1(*arg) && *arg != '{')
+	return arg;
 for (p = arg; *p != NUL
 		    && (eval_isnamec(*p)
 			|| *p == '{'
-			|| (incl_br && (*p == '[' || *p == '.'))
+			|| ((flags & FNE_INCL_BR) && (*p == '[' || *p == '.'))
 			|| mb_nest != 0
 			|| br_nest != 0); ++p)
 {
 	if (mb_nest == 0)
 	{
 *expr_start = '{';
 *expr_end = '}';
 if (retval != NULL)
 {
-	temp_result = find_name_end(retval, &expr_start, &expr_end, FALSE);
+	temp_result = find_name_end(retval, &expr_start, &expr_end, 0);
 	if (expr_start != NULL)
 	{
 	    /* Further expansion! */
 	    temp_result = make_expanded_name(retval, expr_start,
 						       expr_end, temp_result);
 */
 static int
 eval_isnamec(c)
 int	    c;
 {
-return (ASCII_ISALNUM(c) || c == '_' || c == ':');
+return (ASCII_ISALNUM(c) || c == '_' || c == ':' || c == AUTOLOAD_CHAR);
+}
+/*
+* Return TRUE if character "c" can be used as the first character in a
+* variable or function name (excluding '{' and '}').
+*/
+static int
+eval_isnamec1(c)
+int	    c;
+{
+return (ASCII_ISALPHA(c) || c == '_');
 }
 /*
 * Set number v: variable to "val".
 */
 char_u  *name;
 char_u  **varname;
 {
 if (name[1] != ':')
 {
-	/* The name must not start with a colon. */
+	/* The name must not start with a colon or #. */
-	if (name[0] == ':')
+	if (name[0] == ':' || name[0] == AUTOLOAD_CHAR)
 	    return NULL;
 	*varname = name;
 	/* "version" is "v:version" in all scopes */
 	if (!HASHITEM_EMPTY(hash_find(&compat_hashtab, name)))
 	return &current_funccal->l_vars.dv_hashtab; /* l: variable */
 }
 *varname = name + 2;
 if (*name == 'g')				/* global variable */
 	return &globvarht;
-/* There must be no ':' in the rest of the name, unless g: is used */
+/* There must be no ':' or '#' in the rest of the name, unless g: is used
-if (vim_strchr(name + 2, ':') != NULL)
+*/
+if (vim_strchr(name + 2, ':') != NULL
+			       || vim_strchr(name + 2, AUTOLOAD_CHAR) != NULL)
 	return NULL;
 if (*name == 'b')				/* buffer variable */
 	return &curbuf->b_vars.dv_hashtab;
 if (*name == 'w')				/* window variable */
 	return &curwin->w_vars.dv_hashtab;
 	    goto erret;
 }
 if (fp == NULL)
 {
-	if (fudi.fd_dict == NULL && vim_strchr(name, ':') != NULL)
+	if (fudi.fd_dict == NULL && vim_strchr(name, AUTOLOAD_CHAR) != NULL)
 	{
 	    int	    slen, plen;
 	    char_u  *scriptname;
 	    /* Check that the autoload name matches the script name. */
 * don't skip over "s:", get_lval() needs it for "s:dict.func". */
 lead = eval_fname_script(start);
 if (lead > 2)
 	start += lead;
-end = get_lval(start, NULL, &lv, FALSE, skip, flags & TFN_QUIET);
+end = get_lval(start, NULL, &lv, FALSE, skip, flags & TFN_QUIET,
+					      lead > 2 ? 0 : FNE_CHECK_START);
 if (end == start)
 {
 	if (!skip)
 	    EMSG(_("E129: Function name required"));
 	goto theend;
 	{
 	    if (end != NULL)
 		EMSG2(_(e_invarg2), start);
 	}
 	else
-	    *pp = find_name_end(start, NULL, NULL, TRUE);
+	    *pp = find_name_end(start, NULL, NULL, FNE_INCL_BR);
 	goto theend;
 }
 if (lv.ll_tv != NULL)
 {
 return n;
 }
 /*
 * Return TRUE if "name" looks like a builtin function name: starts with a
-* lower case letter and doesn't contain a ':'.
+* lower case letter and doesn't contain a ':' or AUTOLOAD_CHAR.
 */
 static int
 builtin_function(name)
 char_u *name;
 {
-return ASCII_ISLOWER(name[0]) && vim_strchr(name, ':') == NULL;
+return ASCII_ISLOWER(name[0]) && vim_strchr(name, ':') == NULL
+				   && vim_strchr(name, AUTOLOAD_CHAR) == NULL;
 }
 #if defined(FEAT_PROFILE) || defined(PROTO)
 /*
 * Start profiling function "fp".
 char_u	*p;
 char_u	*scriptname;
 int		ret = FALSE;
 /* If there is no colon after name[1] there is no package name. */
-p = vim_strchr(name, ':');
+p = vim_strchr(name, AUTOLOAD_CHAR);
 if (p == NULL || p <= name + 2)
 	return FALSE;
 /* Try loading the package from $VIMRUNTIME/autoload/<name>.vim */
 scriptname = autoload_name(name);
 char_u	*name;
 {
 char_u	*p;
 char_u	*scriptname;
-/* Get the script file name: replace ':' with '/', append ".vim". */
+/* Get the script file name: replace '#' with '/', append ".vim". */
 scriptname = alloc((unsigned)(STRLEN(name) + 14));
 if (scriptname == NULL)
 	return FALSE;
 STRCPY(scriptname, "autoload/");
 STRCAT(scriptname, name);
-*vim_strrchr(scriptname, ':') = NUL;
+*vim_strrchr(scriptname, AUTOLOAD_CHAR) = NUL;
 STRCAT(scriptname, ".vim");
-while ((p = vim_strchr(scriptname, ':')) != NULL)
+while ((p = vim_strchr(scriptname, AUTOLOAD_CHAR)) != NULL)
 	*p = '/';
 return scriptname;
 }
 #if defined(FEAT_CMDL_COMPL) || defined(PROTO)
 		    if (argvars[i].v_type == VAR_NUMBER)
 			msg_outnum((long)argvars[i].vval.v_number);
 		    else
 		    {
 			trunc_string(tv2string(&argvars[i], &tofree, numbuf),
-							    buf, MSG_BUF_LEN);
+							    buf, MSG_BUF_CLEN);
 			msg_puts(buf);
 			vim_free(tofree);
 		    }
 		}
 		msg_puts((char_u *)")");
 	    char_u	buf[MSG_BUF_LEN];
 	    char_u	numbuf[NUMBUFLEN];
 	    char_u	*tofree;
 	    trunc_string(tv2string(fc.rettv, &tofree, numbuf),
-							    buf, MSG_BUF_LEN);
+							   buf, MSG_BUF_CLEN);
 	    smsg((char_u *)_("%s returning %s"), sn, buf);
 	    vim_free(tofree);
 	}
 	msg_puts((char_u *)"\n");   /* don't overwrite this either */
 	cmdline_row = msg_row;

Mercurial > vim

comparison src/eval.c @ 271:8d34af900bae v7.0072