vim: src/eval.c comparison

comparison src/eval.c @ 156:c5b05f6de1ad v7.0047

updated for version 7.0047

author	vimboss
date	Wed, 02 Feb 2005 23:11:38 +0000
parents	40a0699b6c62
children	389c8abd5925

comparison

equal deleted inserted replaced

-:e91a302ad53a
+:c5b05f6de1ad
 static int dict_equal __ARGS((dict_T *d1, dict_T *d2, int ic));
 static int tv_equal __ARGS((typval_T *tv1, typval_T *tv2, int ic));
 static int string_isa_number __ARGS((char_u *s));
 static listitem_T *list_find __ARGS((list_T *l, long n));
 static long list_idx_of_item __ARGS((list_T *l, listitem_T *item));
-static listitem_T *list_find_ext __ARGS((list_T *l, long *ip));
 static void list_append __ARGS((list_T *l, listitem_T *item));
 static int list_append_tv __ARGS((list_T *l, typval_T *tv));
 static int list_insert_tv __ARGS((list_T *l, typval_T *tv, listitem_T *item));
 static int list_extend __ARGS((list_T	*l1, list_T *l2, listitem_T *bef));
 static int list_concat __ARGS((list_T *l1, list_T *l2, typval_T *tv));
 else
 {
 	/* If the result is a number, just return the number. */
 	if (tv.v_type == VAR_NUMBER)
 	    retval = tv.vval.v_number;
-	else if (tv.v_type == VAR_UNKNOWN
+	else if (tv.v_type != VAR_STRING || tv.vval.v_string == NULL)
-		|| tv.vval.v_string == NULL)
 	    retval = 0;
 	else
 	{
 	    /* If the result is a string, check if there is a non-digit before
 	     * the number. */
 }
 /*
 * ":let [v1, v2] = list" or ":for [v1, v2] in listlist"
 */
-l = tv->vval.v_list;
+if (tv->v_type != VAR_LIST || (l = tv->vval.v_list) == NULL)
-if (tv->v_type != VAR_LIST || l == NULL)
 {
 	EMSG(_(e_listreq));
 	return FAIL;
 }
 	if (copy)
 	    copy_tv(rettv, lp->ll_tv);
 	else
 	{
 	    *lp->ll_tv = *rettv;
+	    lp->ll_tv->v_lock = 0;
 	    init_tv(rettv);
 	}
 }
 }
 lw->lw_next = l->lv_watch;
 l->lv_watch = lw;
 }
 /*
-* Remove a watches from a list.
+* Remove a watcher from a list.
 * No warning when it isn't found...
 */
 static void
 list_rem_watch(l, lwrem)
 list_T	*l;
 */
 static long
 list_len(l)
 list_T	*l;
 {
-listitem_T	*item;
-long	len = 0;
 if (l == NULL)
 	return 0L;
-for (item = l->lv_first; item != NULL; item = item->li_next)
+return l->lv_len;
-	++len;
-return len;
 }
 /*
 * Return TRUE when two lists have exactly the same values.
 */
 listitem_T	*item;
 long	idx;
 if (l == NULL)
 	return NULL;
+/* Negative index is relative to the end. */
 if (n < 0)
-{
+	n = l->lv_len + n;
-	idx = -1;	/* search from the end */
-	for (item = l->lv_last; item != NULL && idx > n; item = item->li_prev)
+/* Check for index out of range. */
-	    --idx;
+if (n < 0 || n >= l->lv_len)
+	return NULL;
+/* When there is a cached index may start search from there. */
+if (l->lv_idx_item != NULL)
+{
+	if (n < l->lv_idx / 2)
+	{
+	    /* closest to the start of the list */
+	    item = l->lv_first;
+	    idx = 0;
+	}
+	else if (n > (l->lv_idx + l->lv_len) / 2)
+	{
+	    /* closest to the end of the list */
+	    item = l->lv_last;
+	    idx = l->lv_len - 1;
+	}
+	else
+	{
+	    /* closest to the cached index */
+	    item = l->lv_idx_item;
+	    idx = l->lv_idx;
+	}
 }
 else
 {
-	idx = 0;	/* search from the start */
+	if (n < l->lv_len / 2)
-	for (item = l->lv_first; item != NULL && idx < n; item = item->li_next)
+	{
-	    ++idx;
+	    /* closest to the start of the list */
-}
+	    item = l->lv_first;
-if (idx != n)
+	    idx = 0;
-	return NULL;
+	}
+	else
+	{
+	    /* closest to the end of the list */
+	    item = l->lv_last;
+	    idx = l->lv_len - 1;
+	}
+}
+while (n > idx)
+{
+	/* search forward */
+	item = item->li_next;
+	++idx;
+}
+while (n < idx)
+{
+	/* search backward */
+	item = item->li_prev;
+	--idx;
+}
+/* cache the used index */
+l->lv_idx = idx;
+l->lv_idx_item = item;
 return item;
 }
 /*
 * Locate "item" list "l" and return its index.
 	return -1;
 return idx;;
 }
 /*
-* Like list_find(), but also find an item just past the end.
-* "*ip" is the item to find.
-* When found "*ip" is set to zero, when not found "*ip" is non-zero.
-* Returns NULL when item not found or item is just past the end.
-*/
-static listitem_T *
-list_find_ext(l, ip)
-list_T	*l;
-long	*ip;
-{
-long	n;
-listitem_T	*item;
-if (*ip < 0)
-{
-	/* Count from the end: -1 is before last item. */
-	item = l->lv_last;
-	for (n = *ip + 1; n < 0 && item != NULL; ++n)
-	    item = item->li_prev;
-	if (item == NULL)
-	    n = 1;	/* error! */
-}
-else
-{
-	item = l->lv_first;
-	for (n = *ip; n > 0 && item != NULL; --n)
-	    item = item->li_next;
-}
-*ip = n;
-return item;
-}
-/*
 * Append item "item" to the end of list "l".
 */
 static void
 list_append(l, item)
 list_T	*l;
 {
 	l->lv_last->li_next = item;
 	item->li_prev = l->lv_last;
 	l->lv_last = item;
 }
+++l->lv_len;
 item->li_next = NULL;
 }
 /*
 * Append typval_T "tv" to the end of list "l".
 {
 	/* Insert new item before existing item. */
 	ni->li_prev = item->li_prev;
 	ni->li_next = item;
 	if (item->li_prev == NULL)
+	{
 	    l->lv_first = ni;
+	    ++l->lv_idx;
+	}
 	else
+	{
 	    item->li_prev->li_next = ni;
+	    l->lv_idx_item = NULL;
+	}
 	item->li_prev = ni;
+	++l->lv_len;
 }
 return OK;
 }
 /*
 listitem_T	*ip;
 /* notify watchers */
 for (ip = item; ip != NULL; ip = ip->li_next)
 {
+	--l->lv_len;
 	list_fix_watch(l, ip);
 	if (ip == item2)
 	    break;
 }
 	item2->li_next->li_prev = item->li_prev;
 if (item->li_prev == NULL)
 	l->lv_first = item2->li_next;
 else
 	item->li_prev->li_next = item2->li_next;
+l->lv_idx_item = NULL;
 }
 /*
 * Return an allocated string with the string representation of a list.
 * May return NULL.
 {
 buf_T	*buf = NULL;
 if (avar->v_type == VAR_NUMBER)
 	buf = buflist_findnr((int)avar->vval.v_number);
-else if (avar->vval.v_string != NULL)
+else if (avar->v_type == VAR_STRING && avar->vval.v_string != NULL)
 {
 	buf = buflist_findname_exp(avar->vval.v_string);
 	if (buf == NULL)
 	{
 	    /* No full path name match, try a match with a URL or a "nofile"
 char_u	*save_cpo;
 buf_T	*buf;
 if (tv->v_type == VAR_NUMBER)
 	return buflist_findnr((int)tv->vval.v_number);
+if (tv->v_type != VAR_STRING)
+	return NULL;
 if (name == NULL || *name == NUL)
 	return curbuf;
 if (name[0] == '$' && name[1] == NUL)
 	return lastbuf;
 typval_T	*argvars;
 typval_T	*rettv;
 {
 char_u	buf[NUMBUFLEN];
-rettv->vval.v_string =
+rettv->vval.v_string = vim_strsave_escaped(get_tv_string(&argvars[0]),
-	vim_strsave_escaped(get_tv_string(&argvars[0]),
+					 get_tv_string_buf(&argvars[1], buf));
-		get_tv_string_buf(&argvars[1], buf));
 rettv->v_type = VAR_STRING;
 }
 /*
 * "eval()" function
 if (argvars[0].v_type == VAR_LIST && argvars[1].v_type == VAR_LIST)
 {
 	list_T		*l1, *l2;
 	listitem_T	*item;
 	long		before;
-	long		n;
 	l1 = argvars[0].vval.v_list;
 	l2 = argvars[1].vval.v_list;
 	if (l1 != NULL && !tv_check_lock(l1->lv_lock, (char_u *)"extend()")
 		&& l2 != NULL)
 	{
 	    if (argvars[2].v_type != VAR_UNKNOWN)
 	    {
-		n = before = get_tv_number(&argvars[2]);
+		before = get_tv_number(&argvars[2]);
-		item = list_find_ext(l1, &n);
+		if (before == l1->lv_len)
-		if (n != 0)
+		    item = NULL;
+		else
 		{
-		    EMSGN(_(e_listidx), before);
+		    item = list_find(l1, before);
-		    return;
+		    if (item == NULL)
+		    {
+			EMSGN(_(e_listidx), before);
+			return;
+		    }
 		}
 	    }
 	    else
 		item = NULL;
 	    list_extend(l1, l2, item);
 typval_T	*rettv;
 {
 list_T	*l;
 listitem_T	*item;
 long	idx = 0;
-long	min_idx = 0;
 int		ic = FALSE;
 rettv->vval.v_number = -1;
 if (argvars[0].v_type != VAR_LIST)
 {
 	return;
 }
 l = argvars[0].vval.v_list;
 if (l != NULL)
 {
+	item = l->lv_first;
 	if (argvars[2].v_type != VAR_UNKNOWN)
 	{
-	    min_idx = get_tv_number(&argvars[2]);
+	    /* Start at specified item.  Use the cached index that list_find()
+	     * sets, so that a negative number also works. */
+	    item = list_find(l, get_tv_number(&argvars[2]));
+	    idx = l->lv_idx;
 	    if (argvars[3].v_type != VAR_UNKNOWN)
 		ic = get_tv_number(&argvars[3]);
 	}
-	for (item = l->lv_first; item != NULL; item = item->li_next, ++idx)
+	for ( ; item != NULL; item = item->li_next, ++idx)
-	    if (idx >= min_idx && tv_equal(&item->li_tv, &argvars[1], ic))
+	    if (tv_equal(&item->li_tv, &argvars[1], ic))
 	    {
 		rettv->vval.v_number = idx;
 		break;
 	    }
 }
 f_insert(argvars, rettv)
 typval_T	*argvars;
 typval_T	*rettv;
 {
 long	before = 0;
-long	n;
 listitem_T	*item;
 list_T	*l;
 rettv->vval.v_number = 0;
 if (argvars[0].v_type != VAR_LIST)
 	    && !tv_check_lock(l->lv_lock, (char_u *)"insert()"))
 {
 	if (argvars[2].v_type != VAR_UNKNOWN)
 	    before = get_tv_number(&argvars[2]);
-	n = before;
+	if (before == l->lv_len)
-	item = list_find_ext(l, &n);
+	    item = NULL;
-	if (n > 0)
-	    EMSGN(_(e_listidx), before);
 	else
+	{
+	    item = list_find(l, before);
+	    if (item == NULL)
+	    {
+		EMSGN(_(e_listidx), before);
+		l = NULL;
+	    }
+	}
+	if (l != NULL)
 	{
 	    list_insert_tv(l, &argvars[1], item);
 	    ++l->lv_refcount;
 	    copy_tv(&argvars[0], rettv);
 	}
 #ifdef FEAT_LIBCALL
 /* The first two args must be strings, otherwise its meaningless */
 if (argvars[0].v_type == VAR_STRING && argvars[1].v_type == VAR_STRING)
 {
-	if (argvars[2].v_type == VAR_NUMBER)
+	string_in = NULL;
-	    string_in = NULL;
+	if (argvars[2].v_type == VAR_STRING)
-	else
 	    string_in = argvars[2].vval.v_string;
 	if (type == VAR_NUMBER)
 	    string_result = NULL;
 	else
 	    string_result = &rettv->vval.v_string;
 	if (l != NULL)
 	{
 	    li = list_find(l, start);
 	    if (li == NULL)
 		goto theend;
-	    if (start < 0)
+	    idx = l->lv_idx;	/* use the cached index */
-	    {
-		listitem_T *ni;
-		/* Need to compute the index. */
-		for (ni = li; ni->li_prev != NULL; ni = ni->li_prev)
-		    ++idx;
-	    }
-	    else
-		idx = start;
 	}
 	else
 	{
 	    if (start < 0)
 		start = 0;
 		}
 	    }
 	}
 }
 else
-	EMSG(_(e_listreq));
+	EMSG(_(e_listdictarg));
 rettv->vval.v_number = n;
 }
 /*
 * "max()" function
 if (argvars[0].v_type == VAR_DICT)
 {
 	if (argvars[2].v_type != VAR_UNKNOWN)
 	    EMSG2(_(e_toomanyarg), "remove()");
 	else if ((d = argvars[0].vval.v_dict) != NULL
-	    && !tv_check_lock(d->dv_lock, (char_u *)"remove()"))
+		&& !tv_check_lock(d->dv_lock, (char_u *)"remove()"))
 	{
 	    key = get_tv_string(&argvars[1]);
 	    di = dict_find(d, key, -1);
 	    if (di == NULL)
 		EMSG2(_(e_dictkey), key);
 		item2 = list_find(l, end);
 		if (item2 == NULL)
 		    EMSGN(_(e_listidx), end);
 		else
 		{
-		    for (li = item; li != item2 && li != NULL; li = li->li_next)
+		    int	    cnt = 0;
-			;
+		    for (li = item; li != NULL; li = li->li_next)
+		    {
+			++cnt;
+			if (li == item2)
+			    break;
+		    }
 		    if (li == NULL)  /* didn't find "item2" after "item" */
 			EMSG(_(e_invrange));
 		    else
 		    {
 			list_remove(l, item, item2);
 			    l->lv_first = item;
 			    l->lv_last = item2;
 			    l->lv_refcount = 1;
 			    item->li_prev = NULL;
 			    item2->li_next = NULL;
+			    l->lv_len = cnt;
 			}
 		    }
 		}
 	    }
 	}
 else if ((l = argvars[0].vval.v_list) != NULL
 	    && !tv_check_lock(l->lv_lock, (char_u *)"reverse()"))
 {
 	li = l->lv_last;
 	l->lv_first = l->lv_last = li;
+	l->lv_len = 0;
 	while (li != NULL)
 	{
 	    ni = li->li_prev;
 	    list_append(l, li);
 	    li = ni;
 	    qsort((void *)ptrs, (size_t)len, sizeof(listitem_T *),
 		    item_compare_func == NULL ? item_compare : item_compare2);
 	    /* Clear the List and append the items in the sorted order. */
 	    l->lv_first = l->lv_last = NULL;
+	    l->lv_len = 0;
 	    for (i = 0; i < len; ++i)
 		list_append(l, ptrs[i]);
 	}
 	vim_free(ptrs);
 {
 	case VAR_NUMBER: n = 0; break;
 	case VAR_STRING: n = 1; break;
 	case VAR_FUNC:   n = 2; break;
 	case VAR_LIST:   n = 3; break;
+	case VAR_DICT:   n = 4; break;
 	default: EMSG2(_(e_intern2), "f_type()"); n = 0; break;
 }
 rettv->vval.v_number = n;
 }
 		list_unref(varp->vval.v_list);
 		break;
 	    case VAR_DICT:
 		dict_unref(varp->vval.v_dict);
 		break;
+	    case VAR_NUMBER:
+	    case VAR_UNKNOWN:
+		break;
 	    default:
+		EMSG2(_(e_intern2), "free_tv()");
 		break;
 	}
 	vim_free(varp);
 }
 }
 	    if (varp->vval.v_string != NULL)
 		vim_str2nr(varp->vval.v_string, NULL, NULL,
 							TRUE, TRUE, &n, NULL);
 	    break;
 	case VAR_LIST:
-	    EMSG(_("E703: Using a List as a number"));
+	    EMSG(_("E745: Using a List as a number"));
 	    break;
 	case VAR_DICT:
 	    EMSG(_("E728: Using a Dictionary as a number"));
 	    break;
 	default:
 	    EMSG2(_("E706: Variable type mismatch for: %s"), name);
 	    return;
 	}
 	/*
-	 * Handle setting internal v: variables separately: we keep the type.
+	 * Handle setting internal v: variables separately: we don't change
+	 * the type.
 	 */
 	if (ht == &vimvarht)
 	{
 	    if (v->di_tv.v_type == VAR_STRING)
 	    {
 	if (fudi.fd_newkey == NULL && !eap->forceit)
 	{
 	    EMSG(_(e_funcdict));
 	    goto erret;
 	}
+	if (fudi.fd_di == NULL)
+	{
+	    /* Can't add a function to a locked dictionary */
+	    if (tv_check_lock(fudi.fd_dict->dv_lock, eap->arg))
+		goto erret;
+	}
+	    /* Can't change an existing function if it is locked */
+	else if (tv_check_lock(fudi.fd_di->di_tv.v_lock, eap->arg))
+	    goto erret;
 	/* Give the function a sequential number.  Can only be used with a
 	 * Funcref! */
 	vim_free(name);
 	sprintf(numbuf, "%d", ++func_nr);
 	    msg_scroll = TRUE;	    /* always scroll up, don't overwrite */
 	    msg_str((char_u *)_("calling %s"), sourcing_name);
 	    if (p_verbose >= 14)
 	    {
 		char_u	buf[MSG_BUF_LEN];
+		char_u	numbuf[NUMBUFLEN];
+		char_u	*tofree;
 		msg_puts((char_u *)"(");
 		for (i = 0; i < argcount; ++i)
 		{
 		    if (i > 0)
 			msg_puts((char_u *)", ");
 		    if (argvars[i].v_type == VAR_NUMBER)
 			msg_outnum((long)argvars[i].vval.v_number);
 		    else
 		    {
-			trunc_string(get_tv_string(&argvars[i]),
+			trunc_string(tv2string(&argvars[i], &tofree, numbuf),
 							    buf, MSG_BUF_LEN);
-			msg_puts((char_u *)"\"");
 			msg_puts(buf);
-			msg_puts((char_u *)"\"");
+			vim_free(tofree);
 		    }
 		}
 		msg_puts((char_u *)")");
 	    }
 	    msg_puts((char_u *)"\n");   /* don't overwrite this either */
 }
 /* when being verbose, mention the return value */
 if (p_verbose >= 12)
 {
-	char_u	*sn, *val;
+	char_u	*sn;
 	++no_wait_return;
 	msg_scroll = TRUE;	    /* always scroll up, don't overwrite */
 	/* Make sure the output fits in IObuff. */
 	if (aborting())
 	    smsg((char_u *)_("%s aborted"), sn);
 	else if (fc.rettv->v_type == VAR_NUMBER)
 	    smsg((char_u *)_("%s returning #%ld"), sn,
 					      (long)fc.rettv->vval.v_number);
-	else if (fc.rettv->v_type == VAR_STRING)
+	else
 	{
-	    val = get_tv_string(fc.rettv);
+	    char_u	buf[MSG_BUF_LEN];
-	    if (STRLEN(val) > IOSIZE / 2 - 50)
+	    char_u	numbuf[NUMBUFLEN];
-		val = val + STRLEN(val) - (IOSIZE / 2 - 50);
+	    char_u	*tofree;
-	    smsg((char_u *)_("%s returning \"%s\""), sn, val);
+	    trunc_string(tv2string(fc.rettv, &tofree, numbuf),
+							    buf, MSG_BUF_LEN);
+	    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;
 	--no_wait_return;
 }

Mercurial > vim

comparison src/eval.c @ 156:c5b05f6de1ad v7.0047