[vim] - patchlevel 055
Karsten Hopp
karsten at fedoraproject.org
Wed Nov 10 23:11:06 UTC 2010
commit 634b7246249fd58cfc3b6bdc05801f461ed84e30
Author: Karsten Hopp <karsten at redhat.com>
Date: Thu Nov 11 00:10:21 2010 +0100
- patchlevel 055
7.3.055 | 359 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 359 insertions(+), 0 deletions(-)
---
diff --git a/7.3.055 b/7.3.055
new file mode 100644
index 0000000..5e6ca16
--- /dev/null
+++ b/7.3.055
@@ -0,0 +1,359 @@
+To: vim_dev at googlegroups.com
+Subject: Patch 7.3.055
+Fcc: outbox
+From: Bram Moolenaar <Bram at 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 at 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 ///
More information about the scm-commits
mailing list