aniani/vim
0
0
Fork 1
mirror of https://github.com/vim/vim.git synced 2025-07-26 11:04:33 -04:00
Code

patch 7.4.2055

Browse Source 
Problem:    eval.c is too big.
Solution:   Move Dictionary functions to dict.c.
This commit is contained in:
Bram Moolenaar 2016-07-17 14:57:05 +02:00
parent 42ebd06642
commit cd52459c38
9 changed files with 902 additions and 847 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Filelist
View File

@ -18,6 +18,7 @@ SRC_ALL = \
src/charset.c \
src/crypt.c \
src/crypt_zip.c \
src/dict.c \
src/diff.c \
src/digraph.c \
src/edit.c \
@ -53,6 +54,7 @@ SRC_ALL = \
src/memline.c \
src/menu.c \
src/message.c \
src/message_test.c \
src/misc1.c \
src/misc2.c \
src/move.c \
@ -125,6 +127,7 @@ SRC_ALL = \
src/proto/charset.pro \
src/proto/crypt.pro \
src/proto/crypt_zip.pro \
src/proto/dict.pro \
src/proto/diff.pro \
src/proto/digraph.pro \
src/proto/edit.pro \

10
src/Makefile
View File

@ -1484,6 +1484,7 @@ BASIC_SRC = \
charset.c \
crypt.c \
crypt_zip.c \
dict.c \
diff.c \
digraph.c \
edit.c \
@ -1585,6 +1586,7 @@ OBJ_COMMON = \
objects/charset.o \
objects/crypt.o \
objects/crypt_zip.o \
objects/dict.o \
objects/diff.o \
objects/digraph.o \
objects/edit.o \
@ -1672,6 +1674,7 @@ PRO_AUTO = \
charset.pro \
crypt.pro \
crypt_zip.pro \
dict.pro \
diff.pro \
digraph.pro \
edit.pro \
@ -2806,6 +2809,9 @@ objects/crypt.o: crypt.c
objects/crypt_zip.o: crypt_zip.c
$(CCC) -o $@ crypt_zip.c
objects/dict.o: dict.c
$(CCC) -o $@ dict.c
objects/diff.o: diff.c
$(CCC) -o $@ diff.c
@ -3182,6 +3188,10 @@ objects/crypt_zip.o: crypt_zip.c vim.h auto/config.h feature.h os_unix.h \
auto/osdef.h ascii.h keymap.h term.h macros.h option.h structs.h \
regexp.h gui.h gui_beval.h proto/gui_beval.pro alloc.h ex_cmds.h proto.h \
globals.h farsi.h arabic.h
objects/dict.o: dict.c vim.h auto/config.h feature.h os_unix.h auto/osdef.h \
ascii.h keymap.h term.h macros.h option.h structs.h regexp.h gui.h \
gui_beval.h proto/gui_beval.pro alloc.h ex_cmds.h proto.h globals.h \
farsi.h arabic.h
objects/diff.o: diff.c vim.h auto/config.h feature.h os_unix.h auto/osdef.h \
ascii.h keymap.h term.h macros.h option.h structs.h regexp.h gui.h \
gui_beval.h proto/gui_beval.pro alloc.h ex_cmds.h proto.h globals.h \

820
src/dict.c Normal file
View File

@ -0,0 +1,820 @@
/* vi:set ts=8 sts=4 sw=4:
*
* VIM - Vi IMproved by Bram Moolenaar
*
* Do ":help uganda" in Vim to read copying and usage conditions.
* Do ":help credits" in Vim to see a list of people who contributed.
* See README.txt for an overview of the Vim source code.
*/
/*
* dict.c: Dictionary support
*/
#define USING_FLOAT_STUFF
#include "vim.h"
#if defined(FEAT_EVAL) || defined(PROTO)
/* List head for garbage collection. Although there can be a reference loop
* from partial to dict to partial, we don't need to keep track of the partial,
* since it will get freed when the dict is unused and gets freed. */
static dict_T *first_dict = NULL; /* list of all dicts */
/*
* Allocate an empty header for a dictionary.
*/
dict_T *
dict_alloc(void)
{
dict_T *d;
d = (dict_T *)alloc(sizeof(dict_T));
if (d != NULL)
{
/* Add the dict to the list of dicts for garbage collection. */
if (first_dict != NULL)
first_dict->dv_used_prev = d;
d->dv_used_next = first_dict;
d->dv_used_prev = NULL;
first_dict = d;
hash_init(&d->dv_hashtab);
d->dv_lock = 0;
d->dv_scope = 0;
d->dv_refcount = 0;
d->dv_copyID = 0;
}
return d;
}
/*
* Allocate an empty dict for a return value.
* Returns OK or FAIL.
*/
int
rettv_dict_alloc(typval_T *rettv)
{
dict_T *d = dict_alloc();
if (d == NULL)
return FAIL;
rettv->vval.v_dict = d;
rettv->v_type = VAR_DICT;
rettv->v_lock = 0;
++d->dv_refcount;
return OK;
}
/*
* Free a Dictionary, including all non-container items it contains.
* Ignores the reference count.
*/
static void
dict_free_contents(dict_T *d)
{
int todo;
hashitem_T *hi;
dictitem_T *di;
/* Lock the hashtab, we don't want it to resize while freeing items. */
hash_lock(&d->dv_hashtab);
todo = (int)d->dv_hashtab.ht_used;
for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
/* Remove the item before deleting it, just in case there is
* something recursive causing trouble. */
di = HI2DI(hi);
hash_remove(&d->dv_hashtab, hi);
clear_tv(&di->di_tv);
vim_free(di);
--todo;
}
}
hash_clear(&d->dv_hashtab);
}
static void
dict_free_dict(dict_T *d)
{
/* Remove the dict from the list of dicts for garbage collection. */
if (d->dv_used_prev == NULL)
first_dict = d->dv_used_next;
else
d->dv_used_prev->dv_used_next = d->dv_used_next;
if (d->dv_used_next != NULL)
d->dv_used_next->dv_used_prev = d->dv_used_prev;
vim_free(d);
}
static void
dict_free(dict_T *d)
{
if (!in_free_unref_items)
{
dict_free_contents(d);
dict_free_dict(d);
}
}
/*
* Unreference a Dictionary: decrement the reference count and free it when it
* becomes zero.
*/
void
dict_unref(dict_T *d)
{
if (d != NULL && --d->dv_refcount <= 0)
dict_free(d);
}
/*
* Go through the list of dicts and free items without the copyID.
* Returns TRUE if something was freed.
*/
int
dict_free_nonref(int copyID)
{
dict_T *dd;
int did_free = FALSE;
for (dd = first_dict; dd != NULL; dd = dd->dv_used_next)
if ((dd->dv_copyID & COPYID_MASK) != (copyID & COPYID_MASK))
{
/* Free the Dictionary and ordinary items it contains, but don't
* recurse into Lists and Dictionaries, they will be in the list
* of dicts or list of lists. */
dict_free_contents(dd);
did_free = TRUE;
}
return did_free;
}
void
dict_free_items(int copyID)
{
dict_T *dd, *dd_next;
for (dd = first_dict; dd != NULL; dd = dd_next)
{
dd_next = dd->dv_used_next;
if ((dd->dv_copyID & COPYID_MASK) != (copyID & COPYID_MASK))
dict_free_dict(dd);
}
}
/*
* Allocate a Dictionary item.
* The "key" is copied to the new item.
* Note that the value of the item "di_tv" still needs to be initialized!
* Returns NULL when out of memory.
*/
dictitem_T *
dictitem_alloc(char_u *key)
{
dictitem_T *di;
di = (dictitem_T *)alloc((unsigned)(sizeof(dictitem_T) + STRLEN(key)));
if (di != NULL)
{
STRCPY(di->di_key, key);
di->di_flags = DI_FLAGS_ALLOC;
}
return di;
}
/*
* Make a copy of a Dictionary item.
*/
static dictitem_T *
dictitem_copy(dictitem_T *org)
{
dictitem_T *di;
di = (dictitem_T *)alloc((unsigned)(sizeof(dictitem_T)
+ STRLEN(org->di_key)));
if (di != NULL)
{
STRCPY(di->di_key, org->di_key);
di->di_flags = DI_FLAGS_ALLOC;
copy_tv(&org->di_tv, &di->di_tv);
}
return di;
}
/*
* Remove item "item" from Dictionary "dict" and free it.
*/
void
dictitem_remove(dict_T *dict, dictitem_T *item)
{
hashitem_T *hi;
hi = hash_find(&dict->dv_hashtab, item->di_key);
if (HASHITEM_EMPTY(hi))
EMSG2(_(e_intern2), "dictitem_remove()");
else
hash_remove(&dict->dv_hashtab, hi);
dictitem_free(item);
}
/*
* Free a dict item. Also clears the value.
*/
void
dictitem_free(dictitem_T *item)
{
clear_tv(&item->di_tv);
if (item->di_flags & DI_FLAGS_ALLOC)
vim_free(item);
}
/*
* Make a copy of dict "d". Shallow if "deep" is FALSE.
* The refcount of the new dict is set to 1.
* See item_copy() for "copyID".
* Returns NULL when out of memory.
*/
dict_T *
dict_copy(dict_T *orig, int deep, int copyID)
{
dict_T *copy;
dictitem_T *di;
int todo;
hashitem_T *hi;
if (orig == NULL)
return NULL;
copy = dict_alloc();
if (copy != NULL)
{
if (copyID != 0)
{
orig->dv_copyID = copyID;
orig->dv_copydict = copy;
}
todo = (int)orig->dv_hashtab.ht_used;
for (hi = orig->dv_hashtab.ht_array; todo > 0 && !got_int; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
--todo;
di = dictitem_alloc(hi->hi_key);
if (di == NULL)
break;
if (deep)
{
if (item_copy(&HI2DI(hi)->di_tv, &di->di_tv, deep,
copyID) == FAIL)
{
vim_free(di);
break;
}
}
else
copy_tv(&HI2DI(hi)->di_tv, &di->di_tv);
if (dict_add(copy, di) == FAIL)
{
dictitem_free(di);
break;
}
}
}
++copy->dv_refcount;
if (todo > 0)
{
dict_unref(copy);
copy = NULL;
}
}
return copy;
}
/*
* Add item "item" to Dictionary "d".
* Returns FAIL when out of memory and when key already exists.
*/
int
dict_add(dict_T *d, dictitem_T *item)
{
return hash_add(&d->dv_hashtab, item->di_key);
}
/*
* Add a number or string entry to dictionary "d".
* When "str" is NULL use number "nr", otherwise use "str".
* Returns FAIL when out of memory and when key already exists.
*/
int
dict_add_nr_str(
dict_T *d,
char *key,
varnumber_T nr,
char_u *str)
{
dictitem_T *item;
item = dictitem_alloc((char_u *)key);
if (item == NULL)
return FAIL;
item->di_tv.v_lock = 0;
if (str == NULL)
{
item->di_tv.v_type = VAR_NUMBER;
item->di_tv.vval.v_number = nr;
}
else
{
item->di_tv.v_type = VAR_STRING;
item->di_tv.vval.v_string = vim_strsave(str);
}
if (dict_add(d, item) == FAIL)
{
dictitem_free(item);
return FAIL;
}
return OK;
}
/*
* Add a list entry to dictionary "d".
* Returns FAIL when out of memory and when key already exists.
*/
int
dict_add_list(dict_T *d, char *key, list_T *list)
{
dictitem_T *item;
item = dictitem_alloc((char_u *)key);
if (item == NULL)
return FAIL;
item->di_tv.v_lock = 0;
item->di_tv.v_type = VAR_LIST;
item->di_tv.vval.v_list = list;
if (dict_add(d, item) == FAIL)
{
dictitem_free(item);
return FAIL;
}
++list->lv_refcount;
return OK;
}
/*
* Get the number of items in a Dictionary.
*/
long
dict_len(dict_T *d)
{
if (d == NULL)
return 0L;
return (long)d->dv_hashtab.ht_used;
}
/*
* Find item "key[len]" in Dictionary "d".
* If "len" is negative use strlen(key).
* Returns NULL when not found.
*/
dictitem_T *
dict_find(dict_T *d, char_u *key, int len)
{
#define AKEYLEN 200
char_u buf[AKEYLEN];
char_u *akey;
char_u *tofree = NULL;
hashitem_T *hi;
if (d == NULL)
return NULL;
if (len < 0)
akey = key;
else if (len >= AKEYLEN)
{
tofree = akey = vim_strnsave(key, len);
if (akey == NULL)
return NULL;
}
else
{
/* Avoid a malloc/free by using buf[]. */
vim_strncpy(buf, key, len);
akey = buf;
}
hi = hash_find(&d->dv_hashtab, akey);
vim_free(tofree);
if (HASHITEM_EMPTY(hi))
return NULL;
return HI2DI(hi);
}
/*
* Get a string item from a dictionary.
* When "save" is TRUE allocate memory for it.
* Returns NULL if the entry doesn't exist or out of memory.
*/
char_u *
get_dict_string(dict_T *d, char_u *key, int save)
{
dictitem_T *di;
char_u *s;
di = dict_find(d, key, -1);
if (di == NULL)
return NULL;
s = get_tv_string(&di->di_tv);
if (save && s != NULL)
s = vim_strsave(s);
return s;
}
/*
* Get a number item from a dictionary.
* Returns 0 if the entry doesn't exist.
*/
varnumber_T
get_dict_number(dict_T *d, char_u *key)
{
dictitem_T *di;
di = dict_find(d, key, -1);
if (di == NULL)
return 0;
return get_tv_number(&di->di_tv);
}
/*
* Return an allocated string with the string representation of a Dictionary.
* May return NULL.
*/
char_u *
dict2string(typval_T *tv, int copyID, int restore_copyID)
{
garray_T ga;
int first = TRUE;
char_u *tofree;
char_u numbuf[NUMBUFLEN];
hashitem_T *hi;
char_u *s;
dict_T *d;
int todo;
if ((d = tv->vval.v_dict) == NULL)
return NULL;
ga_init2(&ga, (int)sizeof(char), 80);
ga_append(&ga, '{');
todo = (int)d->dv_hashtab.ht_used;
for (hi = d->dv_hashtab.ht_array; todo > 0 && !got_int; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
--todo;
if (first)
first = FALSE;
else
ga_concat(&ga, (char_u *)", ");
tofree = string_quote(hi->hi_key, FALSE);
if (tofree != NULL)
{
ga_concat(&ga, tofree);
vim_free(tofree);
}
ga_concat(&ga, (char_u *)": ");
s = echo_string_core(&HI2DI(hi)->di_tv, &tofree, numbuf, copyID,
FALSE, restore_copyID, TRUE);
if (s != NULL)
ga_concat(&ga, s);
vim_free(tofree);
if (s == NULL || did_echo_string_emsg)
break;
line_breakcheck();
}
}
if (todo > 0)
{
vim_free(ga.ga_data);
return NULL;
}
ga_append(&ga, '}');
ga_append(&ga, NUL);
return (char_u *)ga.ga_data;
}
/*
* Allocate a variable for a Dictionary and fill it from "*arg".
* Return OK or FAIL. Returns NOTDONE for {expr}.
*/
int
get_dict_tv(char_u **arg, typval_T *rettv, int evaluate)
{
dict_T *d = NULL;
typval_T tvkey;
typval_T tv;
char_u *key = NULL;
dictitem_T *item;
char_u *start = skipwhite(*arg + 1);
char_u buf[NUMBUFLEN];
/*
* First check if it's not a curly-braces thing: {expr}.
* Must do this without evaluating, otherwise a function may be called
* twice. Unfortunately this means we need to call eval1() twice for the
* first item.
* But {} is an empty Dictionary.
*/
if (*start != '}')
{
if (eval1(&start, &tv, FALSE) == FAIL) /* recursive! */
return FAIL;
if (*start == '}')
return NOTDONE;
}
if (evaluate)
{
d = dict_alloc();
if (d == NULL)
return FAIL;
}
tvkey.v_type = VAR_UNKNOWN;
tv.v_type = VAR_UNKNOWN;
*arg = skipwhite(*arg + 1);
while (**arg != '}' && **arg != NUL)
{
if (eval1(arg, &tvkey, evaluate) == FAIL) /* recursive! */
goto failret;
if (**arg != ':')
{
EMSG2(_("E720: Missing colon in Dictionary: %s"), *arg);
clear_tv(&tvkey);
goto failret;
}
if (evaluate)
{
key = get_tv_string_buf_chk(&tvkey, buf);
if (key == NULL)
{
/* "key" is NULL when get_tv_string_buf_chk() gave an errmsg */
clear_tv(&tvkey);
goto failret;
}
}
*arg = skipwhite(*arg + 1);
if (eval1(arg, &tv, evaluate) == FAIL) /* recursive! */
{
if (evaluate)
clear_tv(&tvkey);
goto failret;
}
if (evaluate)
{
item = dict_find(d, key, -1);
if (item != NULL)
{
EMSG2(_("E721: Duplicate key in Dictionary: \"%s\""), key);
clear_tv(&tvkey);
clear_tv(&tv);
goto failret;
}
item = dictitem_alloc(key);
clear_tv(&tvkey);
if (item != NULL)
{
item->di_tv = tv;
item->di_tv.v_lock = 0;
if (dict_add(d, item) == FAIL)
dictitem_free(item);
}
}
if (**arg == '}')
break;
if (**arg != ',')
{
EMSG2(_("E722: Missing comma in Dictionary: %s"), *arg);
goto failret;
}
*arg = skipwhite(*arg + 1);
}
if (**arg != '}')
{
EMSG2(_("E723: Missing end of Dictionary '}': %s"), *arg);
failret:
if (evaluate)
dict_free(d);
return FAIL;
}
*arg = skipwhite(*arg + 1);
if (evaluate)
{
rettv->v_type = VAR_DICT;
rettv->vval.v_dict = d;
++d->dv_refcount;
}
return OK;
}
/*
* Go over all entries in "d2" and add them to "d1".
* When "action" is "error" then a duplicate key is an error.
* When "action" is "force" then a duplicate key is overwritten.
* Otherwise duplicate keys are ignored ("action" is "keep").
*/
void
dict_extend(dict_T *d1, dict_T *d2, char_u *action)
{
dictitem_T *di1;
hashitem_T *hi2;
int todo;
char_u *arg_errmsg = (char_u *)N_("extend() argument");
todo = (int)d2->dv_hashtab.ht_used;
for (hi2 = d2->dv_hashtab.ht_array; todo > 0; ++hi2)
{
if (!HASHITEM_EMPTY(hi2))
{
--todo;
di1 = dict_find(d1, hi2->hi_key, -1);
if (d1->dv_scope != 0)
{
/* Disallow replacing a builtin function in l: and g:.
* Check the key to be valid when adding to any scope. */
if (d1->dv_scope == VAR_DEF_SCOPE
&& HI2DI(hi2)->di_tv.v_type == VAR_FUNC
&& var_check_func_name(hi2->hi_key, di1 == NULL))
break;
if (!valid_varname(hi2->hi_key))
break;
}
if (di1 == NULL)
{
di1 = dictitem_copy(HI2DI(hi2));
if (di1 != NULL && dict_add(d1, di1) == FAIL)
dictitem_free(di1);
}
else if (*action == 'e')
{
EMSG2(_("E737: Key already exists: %s"), hi2->hi_key);
break;
}
else if (*action == 'f' && HI2DI(hi2) != di1)
{
if (tv_check_lock(di1->di_tv.v_lock, arg_errmsg, TRUE)
|| var_check_ro(di1->di_flags, arg_errmsg, TRUE))
break;
clear_tv(&di1->di_tv);
copy_tv(&HI2DI(hi2)->di_tv, &di1->di_tv);
}
}
}
}
/*
* Return the dictitem that an entry in a hashtable points to.
*/
dictitem_T *
dict_lookup(hashitem_T *hi)
{
return HI2DI(hi);
}
/*
* Return TRUE when two dictionaries have exactly the same key/values.
*/
int
dict_equal(
dict_T *d1,
dict_T *d2,
int ic, /* ignore case for strings */
int recursive) /* TRUE when used recursively */
{
hashitem_T *hi;
dictitem_T *item2;
int todo;
if (d1 == NULL && d2 == NULL)
return TRUE;
if (d1 == NULL || d2 == NULL)
return FALSE;
if (d1 == d2)
return TRUE;
if (dict_len(d1) != dict_len(d2))
return FALSE;
todo = (int)d1->dv_hashtab.ht_used;
for (hi = d1->dv_hashtab.ht_array; todo > 0; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
item2 = dict_find(d2, hi->hi_key, -1);
if (item2 == NULL)
return FALSE;
if (!tv_equal(&HI2DI(hi)->di_tv, &item2->di_tv, ic, recursive))
return FALSE;
--todo;
}
}
return TRUE;
}
/*
* Turn a dict into a list:
* "what" == 0: list of keys
* "what" == 1: list of values
* "what" == 2: list of items
*/
void
dict_list(typval_T *argvars, typval_T *rettv, int what)
{
list_T *l2;
dictitem_T *di;
hashitem_T *hi;
listitem_T *li;
listitem_T *li2;
dict_T *d;
int todo;
if (argvars[0].v_type != VAR_DICT)
{
EMSG(_(e_dictreq));
return;
}
if ((d = argvars[0].vval.v_dict) == NULL)
return;
if (rettv_list_alloc(rettv) == FAIL)
return;
todo = (int)d->dv_hashtab.ht_used;
for (hi = d->dv_hashtab.ht_array; todo > 0; ++hi)
{
if (!HASHITEM_EMPTY(hi))
{
--todo;
di = HI2DI(hi);
li = listitem_alloc();
if (li == NULL)
break;
list_append(rettv->vval.v_list, li);
if (what == 0)
{
/* keys() */
li->li_tv.v_type = VAR_STRING;
li->li_tv.v_lock = 0;
li->li_tv.vval.v_string = vim_strsave(di->di_key);
}
else if (what == 1)
{
/* values() */
copy_tv(&di->di_tv, &li->li_tv);
}
else
{
/* items() */
l2 = list_alloc();
li->li_tv.v_type = VAR_LIST;
li->li_tv.v_lock = 0;
li->li_tv.vval.v_list = l2;
if (l2 == NULL)
break;
++l2->lv_refcount;
li2 = listitem_alloc();
if (li2 == NULL)
break;
list_append(l2, li2);
li2->li_tv.v_type = VAR_STRING;
li2->li_tv.v_lock = 0;
li2->li_tv.vval.v_string = vim_strsave(di->di_key);
li2 = listitem_alloc();
if (li2 == NULL)
break;
list_append(l2, li2);
copy_tv(&di->di_tv, &li2->li_tv);
}
}
}
}
#endif /* defined(FEAT_EVAL) */

846
src/eval.c
View File

File diff suppressed because it is too large Load Diff

16
src/globals.h
View File

@ -1534,6 +1534,7 @@ EXTERN char_u e_readonly[] INIT(= N_("E45: 'readonly' option is set (add ! to ov
EXTERN char_u e_readonlyvar[] INIT(= N_("E46: Cannot change read-only variable \"%s\""));
EXTERN char_u e_readonlysbx[] INIT(= N_("E794: Cannot set variable in the sandbox: \"%s\""));
EXTERN char_u e_emptykey[] INIT(= N_("E713: Cannot use empty key for Dictionary"));
EXTERN char_u e_dictreq[] INIT(= N_("E715: Dictionary required"));
#endif
#ifdef FEAT_QUICKFIX
EXTERN char_u e_readerrf[] INIT(= N_("E47: Error while reading errorfile"));
@ -1644,6 +1645,21 @@ EXTERN int did_add_timer INIT(= FALSE);
#ifdef FEAT_EVAL
EXTERN time_T time_for_testing INIT(= 0);
/*
* In a hashtab item "hi_key" points to "di_key" in a dictitem.
* This avoids adding a pointer to the hashtab item.
* DI2HIKEY() converts a dictitem pointer to a hashitem key pointer.
* HIKEY2DI() converts a hashitem key pointer to a dictitem pointer.
* HI2DI() converts a hashitem pointer to a dictitem pointer.
*/
EXTERN dictitem_T dumdi;
# define DI2HIKEY(di) ((di)->di_key)
# define HIKEY2DI(p) ((dictitem_T *)(p - (dumdi.di_key - (char_u *)&dumdi)))
# define HI2DI(hi) HIKEY2DI((hi)->hi_key)
/* Abort conversion to string after a recursion error. */
EXTERN int did_echo_string_emsg INIT(= FALSE);
#endif
/*

24
src/proto/dict.pro Normal file
View File

@ -0,0 +1,24 @@
/* dict.c */
dict_T *dict_alloc(void);
int rettv_dict_alloc(typval_T *rettv);
void dict_unref(dict_T *d);
int dict_free_nonref(int copyID);
void dict_free_items(int copyID);
dictitem_T *dictitem_alloc(char_u *key);
void dictitem_remove(dict_T *dict, dictitem_T *item);
void dictitem_free(dictitem_T *item);
dict_T *dict_copy(dict_T *orig, int deep, int copyID);
int dict_add(dict_T *d, dictitem_T *item);
int dict_add_nr_str(dict_T *d, char *key, varnumber_T nr, char_u *str);
int dict_add_list(dict_T *d, char *key, list_T *list);
long dict_len(dict_T *d);
dictitem_T *dict_find(dict_T *d, char_u *key, int len);
char_u *get_dict_string(dict_T *d, char_u *key, int save);
varnumber_T get_dict_number(dict_T *d, char_u *key);
char_u *dict2string(typval_T *tv, int copyID, int restore_copyID);
int get_dict_tv(char_u **arg, typval_T *rettv, int evaluate);
void dict_extend(dict_T *d1, dict_T *d2, char_u *action);
dictitem_T *dict_lookup(hashitem_T *hi);
int dict_equal(dict_T *d1, dict_T *d2, int ic, int recursive);
void dict_list(typval_T *argvars, typval_T *rettv, int what);
/* vim: set ft=c : */

23
src/proto/eval.pro
View File

@ -45,6 +45,7 @@ void ex_lockvar(exarg_T *eap);
int do_unlet(char_u *name, int forceit);
void del_menutrans_vars(void);
char_u *get_user_var_name(expand_T *xp, int idx);
int eval1(char_u **arg, typval_T *rettv, int evaluate);
void partial_unref(partial_T *pt);
list_T *list_alloc(void);
int rettv_list_alloc(typval_T *rettv);
@ -53,7 +54,7 @@ void list_free(list_T *l);
listitem_T *listitem_alloc(void);
void listitem_free(listitem_T *item);
void listitem_remove(list_T *l, listitem_T *item);
dictitem_T *dict_lookup(hashitem_T *hi);
int tv_equal(typval_T *tv1, typval_T *tv2, int ic, int recursive);
listitem_T *list_find(list_T *l, long n);
char_u *list_find_str(list_T *l, long idx);
void list_append(list_T *l, listitem_T *item);
@ -69,19 +70,9 @@ int garbage_collect(int testing);
int set_ref_in_ht(hashtab_T *ht, int copyID, list_stack_T **list_stack);
int set_ref_in_list(list_T *l, int copyID, ht_stack_T **ht_stack);
int set_ref_in_item(typval_T *tv, int copyID, ht_stack_T **ht_stack, list_stack_T **list_stack);
dict_T *dict_alloc(void);
int rettv_dict_alloc(typval_T *rettv);
void dict_unref(dict_T *d);
void dict_free(dict_T *d);
dictitem_T *dictitem_alloc(char_u *key);
void dictitem_free(dictitem_T *item);
int dict_add(dict_T *d, dictitem_T *item);
int dict_add_nr_str(dict_T *d, char *key, varnumber_T nr, char_u *str);
int dict_add_list(dict_T *d, char *key, list_T *list);
dictitem_T *dict_find(dict_T *d, char_u *key, int len);
char_u *get_dict_string(dict_T *d, char_u *key, int save);
varnumber_T get_dict_number(dict_T *d, char_u *key);
char_u *echo_string_core(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID, int echo_style, int restore_copyID, int dict_val);
char_u *tv2string(typval_T *tv, char_u **tofree, char_u *numbuf, int copyID);
char_u *string_quote(char_u *str, int function);
int string2float(char_u *text, float_T *value);
char_u *get_function_name(expand_T *xp, int idx);
char_u *get_expr_name(expand_T *xp, int idx);
@ -89,7 +80,6 @@ int call_func(char_u *funcname, int len, typval_T *rettv, int argcount_in, typva
buf_T *buflist_find_by_name(char_u *name, int curtab_only);
int func_call(char_u *name, typval_T *args, partial_T *partial, dict_T *selfdict, typval_T *rettv);
void execute_redir_str(char_u *value, int value_len);
void dict_extend(dict_T *d1, dict_T *d2, char_u *action);
void mzscheme_call_vim(char_u *name, typval_T *args, typval_T *rettv);
float_T vim_round(float_T f);
long do_searchpair(char_u *spat, char_u *mpat, char_u *epat, int dir, char_u *skip, int flags, pos_T *match_pos, linenr_T lnum_stop, long time_limit);
@ -122,7 +112,12 @@ void new_script_vars(scid_T id);
void init_var_dict(dict_T *dict, dictitem_T *dict_var, int scope);
void unref_var_dict(dict_T *dict);
void vars_clear(hashtab_T *ht);
int var_check_ro(int flags, char_u *name, int use_gettext);
int var_check_func_name(char_u *name, int new_var);
int valid_varname(char_u *varname);
int tv_check_lock(int lock, char_u *name, int use_gettext);
void copy_tv(typval_T *from, typval_T *to);
int item_copy(typval_T *from, typval_T *to, int deep, int copyID);
void ex_echo(exarg_T *eap);
void ex_echohl(exarg_T *eap);
void ex_execute(exarg_T *eap);

2
src/version.c
View File

@ -758,6 +758,8 @@ static char *(features[]) =
static int included_patches[] =
{ /* Add new patch number below this line */
/**/
2055,
/**/
2054,
/**/

5
src/vim.h
View File

@ -932,6 +932,7 @@ extern char *(*dyn_libintl_textdomain)(const char *domainname);
#define BLN_DUMMY 4 /* allocating dummy buffer */
#define BLN_NEW 8 /* create a new buffer */
#define BLN_NOOPT 16 /* don't copy options to existing buffer */
#define BLN_DUMMY_OK 32 /* also find an existing dummy buffer */
/* Values for in_cinkeys() */
#define KEY_OPEN_FORW 0x101
@ -2402,4 +2403,8 @@ int vim_main2(int argc, char **argv);
/* Lowest number used for window ID. Cannot have this many windows. */
#define LOWEST_WIN_ID 1000
/* Used by the garbage collector. */
#define COPYID_INC 2
#define COPYID_MASK (~0x1)
#endif /* VIM__H */