mirror of
git://slackware.nl/current.git
synced 2025-02-15 08:50:09 +01:00
75a4a592e5
Mon Apr 25 13:37:00 UTC 2011 Slackware 13.37 x86_64 stable is released! Thanks to everyone who pitched in on this release: the Slackware team, the folks producing upstream code, and linuxquestions.org for providing a great forum for collaboration and testing. The ISOs are off to be replicated, a 6 CD-ROM 32-bit set and a dual-sided 32-bit/64-bit x86/x86_64 DVD. Please consider supporting the Slackware project by picking up a copy from store.slackware.com. We're taking pre-orders now, and offer a discount if you sign up for a subscription. As always, thanks to the Slackware community for testing, suggestions, and feedback. :-) Have fun!
359 lines
10 KiB
Text
359 lines
10 KiB
Text
To: vim_dev@googlegroups.com
|
|
Subject: Patch 7.3.055
|
|
Fcc: outbox
|
|
From: Bram Moolenaar <Bram@moolenaar.net>
|
|
Mime-Version: 1.0
|
|
Content-Type: text/plain; charset=UTF-8
|
|
Content-Transfer-Encoding: 8bit
|
|
------------
|
|
|
|
Patch 7.3.055
|
|
Problem: Recursively nested lists and dictionaries cause a near-endless
|
|
loop when comparing them with a copy. (ZyX)
|
|
Solution: Limit recursiveness in a way that non-recursive structures can
|
|
still be nested very deep.
|
|
Files: src/eval.c, src/testdir/test55.in, src/testdir/test55.ok
|
|
|
|
|
|
*** ../vim-7.3.054/src/eval.c 2010-10-20 21:22:17.000000000 +0200
|
|
--- src/eval.c 2010-11-10 20:02:57.000000000 +0100
|
|
***************
|
|
*** 434,442 ****
|
|
static void listitem_free __ARGS((listitem_T *item));
|
|
static void listitem_remove __ARGS((list_T *l, listitem_T *item));
|
|
static long list_len __ARGS((list_T *l));
|
|
! static int list_equal __ARGS((list_T *l1, list_T *l2, int ic));
|
|
! 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 listitem_T *list_find __ARGS((list_T *l, long n));
|
|
static long list_find_nr __ARGS((list_T *l, long idx, int *errorp));
|
|
static long list_idx_of_item __ARGS((list_T *l, listitem_T *item));
|
|
--- 434,442 ----
|
|
static void listitem_free __ARGS((listitem_T *item));
|
|
static void listitem_remove __ARGS((list_T *l, listitem_T *item));
|
|
static long list_len __ARGS((list_T *l));
|
|
! static int list_equal __ARGS((list_T *l1, list_T *l2, int ic, int recursive));
|
|
! static int dict_equal __ARGS((dict_T *d1, dict_T *d2, int ic, int recursive));
|
|
! static int tv_equal __ARGS((typval_T *tv1, typval_T *tv2, int ic, int recursive));
|
|
static listitem_T *list_find __ARGS((list_T *l, long n));
|
|
static long list_find_nr __ARGS((list_T *l, long idx, int *errorp));
|
|
static long list_idx_of_item __ARGS((list_T *l, listitem_T *item));
|
|
***************
|
|
*** 4350,4356 ****
|
|
else
|
|
{
|
|
/* Compare two Lists for being equal or unequal. */
|
|
! n1 = list_equal(rettv->vval.v_list, var2.vval.v_list, ic);
|
|
if (type == TYPE_NEQUAL)
|
|
n1 = !n1;
|
|
}
|
|
--- 4350,4357 ----
|
|
else
|
|
{
|
|
/* Compare two Lists for being equal or unequal. */
|
|
! n1 = list_equal(rettv->vval.v_list, var2.vval.v_list,
|
|
! ic, FALSE);
|
|
if (type == TYPE_NEQUAL)
|
|
n1 = !n1;
|
|
}
|
|
***************
|
|
*** 4379,4385 ****
|
|
else
|
|
{
|
|
/* Compare two Dictionaries for being equal or unequal. */
|
|
! n1 = dict_equal(rettv->vval.v_dict, var2.vval.v_dict, ic);
|
|
if (type == TYPE_NEQUAL)
|
|
n1 = !n1;
|
|
}
|
|
--- 4380,4387 ----
|
|
else
|
|
{
|
|
/* Compare two Dictionaries for being equal or unequal. */
|
|
! n1 = dict_equal(rettv->vval.v_dict, var2.vval.v_dict,
|
|
! ic, FALSE);
|
|
if (type == TYPE_NEQUAL)
|
|
n1 = !n1;
|
|
}
|
|
***************
|
|
*** 5914,5923 ****
|
|
* Return TRUE when two lists have exactly the same values.
|
|
*/
|
|
static int
|
|
! list_equal(l1, l2, ic)
|
|
list_T *l1;
|
|
list_T *l2;
|
|
int ic; /* ignore case for strings */
|
|
{
|
|
listitem_T *item1, *item2;
|
|
|
|
--- 5916,5926 ----
|
|
* Return TRUE when two lists have exactly the same values.
|
|
*/
|
|
static int
|
|
! list_equal(l1, l2, ic, recursive)
|
|
list_T *l1;
|
|
list_T *l2;
|
|
int ic; /* ignore case for strings */
|
|
+ int recursive; /* TRUE when used recursively */
|
|
{
|
|
listitem_T *item1, *item2;
|
|
|
|
***************
|
|
*** 5931,5937 ****
|
|
for (item1 = l1->lv_first, item2 = l2->lv_first;
|
|
item1 != NULL && item2 != NULL;
|
|
item1 = item1->li_next, item2 = item2->li_next)
|
|
! if (!tv_equal(&item1->li_tv, &item2->li_tv, ic))
|
|
return FALSE;
|
|
return item1 == NULL && item2 == NULL;
|
|
}
|
|
--- 5934,5940 ----
|
|
for (item1 = l1->lv_first, item2 = l2->lv_first;
|
|
item1 != NULL && item2 != NULL;
|
|
item1 = item1->li_next, item2 = item2->li_next)
|
|
! if (!tv_equal(&item1->li_tv, &item2->li_tv, ic, recursive))
|
|
return FALSE;
|
|
return item1 == NULL && item2 == NULL;
|
|
}
|
|
***************
|
|
*** 5953,5962 ****
|
|
* Return TRUE when two dictionaries have exactly the same key/values.
|
|
*/
|
|
static int
|
|
! dict_equal(d1, d2, ic)
|
|
dict_T *d1;
|
|
dict_T *d2;
|
|
int ic; /* ignore case for strings */
|
|
{
|
|
hashitem_T *hi;
|
|
dictitem_T *item2;
|
|
--- 5956,5966 ----
|
|
* Return TRUE when two dictionaries have exactly the same key/values.
|
|
*/
|
|
static int
|
|
! dict_equal(d1, d2, ic, recursive)
|
|
dict_T *d1;
|
|
dict_T *d2;
|
|
int ic; /* ignore case for strings */
|
|
+ int recursive; /* TRUE when used recursively */
|
|
{
|
|
hashitem_T *hi;
|
|
dictitem_T *item2;
|
|
***************
|
|
*** 5977,5983 ****
|
|
item2 = dict_find(d2, hi->hi_key, -1);
|
|
if (item2 == NULL)
|
|
return FALSE;
|
|
! if (!tv_equal(&HI2DI(hi)->di_tv, &item2->di_tv, ic))
|
|
return FALSE;
|
|
--todo;
|
|
}
|
|
--- 5981,5987 ----
|
|
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;
|
|
}
|
|
***************
|
|
*** 5985,6025 ****
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* Return TRUE if "tv1" and "tv2" have the same value.
|
|
* Compares the items just like "==" would compare them, but strings and
|
|
* numbers are different. Floats and numbers are also different.
|
|
*/
|
|
static int
|
|
! tv_equal(tv1, tv2, ic)
|
|
typval_T *tv1;
|
|
typval_T *tv2;
|
|
! int ic; /* ignore case */
|
|
{
|
|
char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
|
|
char_u *s1, *s2;
|
|
! static int recursive = 0; /* cach recursive loops */
|
|
int r;
|
|
|
|
if (tv1->v_type != tv2->v_type)
|
|
return FALSE;
|
|
/* Catch lists and dicts that have an endless loop by limiting
|
|
! * recursiveness to 1000. We guess they are equal then. */
|
|
! if (recursive >= 1000)
|
|
return TRUE;
|
|
|
|
switch (tv1->v_type)
|
|
{
|
|
case VAR_LIST:
|
|
! ++recursive;
|
|
! r = list_equal(tv1->vval.v_list, tv2->vval.v_list, ic);
|
|
! --recursive;
|
|
return r;
|
|
|
|
case VAR_DICT:
|
|
! ++recursive;
|
|
! r = dict_equal(tv1->vval.v_dict, tv2->vval.v_dict, ic);
|
|
! --recursive;
|
|
return r;
|
|
|
|
case VAR_FUNC:
|
|
--- 5989,6042 ----
|
|
return TRUE;
|
|
}
|
|
|
|
+ static int tv_equal_recurse_limit;
|
|
+
|
|
/*
|
|
* Return TRUE if "tv1" and "tv2" have the same value.
|
|
* Compares the items just like "==" would compare them, but strings and
|
|
* numbers are different. Floats and numbers are also different.
|
|
*/
|
|
static int
|
|
! tv_equal(tv1, tv2, ic, recursive)
|
|
typval_T *tv1;
|
|
typval_T *tv2;
|
|
! int ic; /* ignore case */
|
|
! int recursive; /* TRUE when used recursively */
|
|
{
|
|
char_u buf1[NUMBUFLEN], buf2[NUMBUFLEN];
|
|
char_u *s1, *s2;
|
|
! static int recursive_cnt = 0; /* catch recursive loops */
|
|
int r;
|
|
|
|
if (tv1->v_type != tv2->v_type)
|
|
return FALSE;
|
|
+
|
|
/* Catch lists and dicts that have an endless loop by limiting
|
|
! * recursiveness to a limit. We guess they are equal then.
|
|
! * A fixed limit has the problem of still taking an awful long time.
|
|
! * Reduce the limit every time running into it. That should work fine for
|
|
! * deeply linked structures that are not recursively linked and catch
|
|
! * recursiveness quickly. */
|
|
! if (!recursive)
|
|
! tv_equal_recurse_limit = 1000;
|
|
! if (recursive_cnt >= tv_equal_recurse_limit)
|
|
! {
|
|
! --tv_equal_recurse_limit;
|
|
return TRUE;
|
|
+ }
|
|
|
|
switch (tv1->v_type)
|
|
{
|
|
case VAR_LIST:
|
|
! ++recursive_cnt;
|
|
! r = list_equal(tv1->vval.v_list, tv2->vval.v_list, ic, TRUE);
|
|
! --recursive_cnt;
|
|
return r;
|
|
|
|
case VAR_DICT:
|
|
! ++recursive_cnt;
|
|
! r = dict_equal(tv1->vval.v_dict, tv2->vval.v_dict, ic, TRUE);
|
|
! --recursive_cnt;
|
|
return r;
|
|
|
|
case VAR_FUNC:
|
|
***************
|
|
*** 9391,9397 ****
|
|
}
|
|
|
|
for ( ; li != NULL; li = li->li_next)
|
|
! if (tv_equal(&li->li_tv, &argvars[1], ic))
|
|
++n;
|
|
}
|
|
}
|
|
--- 9408,9414 ----
|
|
}
|
|
|
|
for ( ; li != NULL; li = li->li_next)
|
|
! if (tv_equal(&li->li_tv, &argvars[1], ic, FALSE))
|
|
++n;
|
|
}
|
|
}
|
|
***************
|
|
*** 9418,9424 ****
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
--todo;
|
|
! if (tv_equal(&HI2DI(hi)->di_tv, &argvars[1], ic))
|
|
++n;
|
|
}
|
|
}
|
|
--- 9435,9441 ----
|
|
if (!HASHITEM_EMPTY(hi))
|
|
{
|
|
--todo;
|
|
! if (tv_equal(&HI2DI(hi)->di_tv, &argvars[1], ic, FALSE))
|
|
++n;
|
|
}
|
|
}
|
|
***************
|
|
*** 12574,12580 ****
|
|
}
|
|
|
|
for ( ; item != NULL; item = item->li_next, ++idx)
|
|
! if (tv_equal(&item->li_tv, &argvars[1], ic))
|
|
{
|
|
rettv->vval.v_number = idx;
|
|
break;
|
|
--- 12591,12597 ----
|
|
}
|
|
|
|
for ( ; item != NULL; item = item->li_next, ++idx)
|
|
! if (tv_equal(&item->li_tv, &argvars[1], ic, FALSE))
|
|
{
|
|
rettv->vval.v_number = idx;
|
|
break;
|
|
*** ../vim-7.3.054/src/testdir/test55.in 2010-08-15 21:57:29.000000000 +0200
|
|
--- src/testdir/test55.in 2010-11-10 20:15:27.000000000 +0100
|
|
***************
|
|
*** 342,348 ****
|
|
--- 342,359 ----
|
|
:$put =(d == d)
|
|
:$put =(l != deepcopy(l))
|
|
:$put =(d != deepcopy(d))
|
|
+ :"
|
|
+ :" compare complex recursively linked list and dict
|
|
+ :let l = []
|
|
+ :call add(l, l)
|
|
+ :let dict4 = {"l": l}
|
|
+ :call add(dict4.l, dict4)
|
|
+ :let lcopy = deepcopy(l)
|
|
+ :let dict4copy = deepcopy(dict4)
|
|
+ :$put =(l == lcopy)
|
|
+ :$put =(dict4 == dict4copy)
|
|
:endfun
|
|
+ :"
|
|
:call Test(1, 2, [3, 4], {5: 6}) " This may take a while
|
|
:"
|
|
:delfunc Test
|
|
*** ../vim-7.3.054/src/testdir/test55.ok 2010-08-15 21:57:29.000000000 +0200
|
|
--- src/testdir/test55.ok 2010-11-10 20:16:37.000000000 +0100
|
|
***************
|
|
*** 109,111 ****
|
|
--- 109,113 ----
|
|
1
|
|
0
|
|
0
|
|
+ 1
|
|
+ 1
|
|
*** ../vim-7.3.054/src/version.c 2010-11-10 18:59:50.000000000 +0100
|
|
--- src/version.c 2010-11-10 20:10:51.000000000 +0100
|
|
***************
|
|
*** 716,717 ****
|
|
--- 716,719 ----
|
|
{ /* Add new patch number below this line */
|
|
+ /**/
|
|
+ 55,
|
|
/**/
|
|
|
|
--
|
|
A special law prohibits unmarried women from parachuting on Sunday or she
|
|
shall risk arrest, fine, and/or jailing.
|
|
[real standing law in Florida, United States of America]
|
|
|
|
/// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
|
|
/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
|
|
\\\ download, build and distribute -- http://www.A-A-P.org ///
|
|
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///
|