# HG changeset patch # User Christian Brabandt # Date 1456178405 -3600 # Node ID c16aa03d8db50924e90aecd6b054e2b636ee45b6 # Parent 44e24e181cb67e272ec9d9cd62c49306cd6cac98 commit https://github.com/vim/vim/commit/0b962473ddc7cee3cb45253dea273573bcca9bf9 Author: Bram Moolenaar Date: Mon Feb 22 22:51:33 2016 +0100 patch 7.4.1394 Problem: Can't sort inside a sort function. Solution: Use a struct to store the sort parameters. (Jacob Niehus) diff --git a/src/eval.c b/src/eval.c --- a/src/eval.c +++ b/src/eval.c @@ -18790,16 +18790,21 @@ typedef struct int idx; } sortItem_T; -static int item_compare_ic; -static int item_compare_numeric; -static int item_compare_numbers; -#ifdef FEAT_FLOAT -static int item_compare_float; -#endif -static char_u *item_compare_func; -static dict_T *item_compare_selfdict; -static int item_compare_func_err; -static int item_compare_keep_zero; +/* struct storing information about current sort */ +typedef struct +{ + int item_compare_ic; + int item_compare_numeric; + int item_compare_numbers; +#ifdef FEAT_FLOAT + int item_compare_float; +#endif + char_u *item_compare_func; + dict_T *item_compare_selfdict; + int item_compare_func_err; + int item_compare_keep_zero; +} sortinfo_T; +static sortinfo_T *sortinfo = NULL; static void do_sort_uniq(typval_T *argvars, typval_T *rettv, int sort); #define ITEM_COMPARE_FAIL 999 @@ -18825,7 +18830,7 @@ item_compare(const void *s1, const void tv1 = &si1->item->li_tv; tv2 = &si2->item->li_tv; - if (item_compare_numbers) + if (sortinfo->item_compare_numbers) { long v1 = get_tv_number(tv1); long v2 = get_tv_number(tv2); @@ -18834,7 +18839,7 @@ item_compare(const void *s1, const void } #ifdef FEAT_FLOAT - if (item_compare_float) + if (sortinfo->item_compare_float) { float_T v1 = get_tv_float(tv1); float_T v2 = get_tv_float(tv2); @@ -18848,7 +18853,7 @@ item_compare(const void *s1, const void * non-string to do what the docs promise. */ if (tv1->v_type == VAR_STRING) { - if (tv2->v_type != VAR_STRING || item_compare_numeric) + if (tv2->v_type != VAR_STRING || sortinfo->item_compare_numeric) p1 = (char_u *)"'"; else p1 = tv1->vval.v_string; @@ -18857,7 +18862,7 @@ item_compare(const void *s1, const void p1 = tv2string(tv1, &tofree1, numbuf1, 0); if (tv2->v_type == VAR_STRING) { - if (tv1->v_type != VAR_STRING || item_compare_numeric) + if (tv1->v_type != VAR_STRING || sortinfo->item_compare_numeric) p2 = (char_u *)"'"; else p2 = tv2->vval.v_string; @@ -18868,9 +18873,9 @@ item_compare(const void *s1, const void p1 = (char_u *)""; if (p2 == NULL) p2 = (char_u *)""; - if (!item_compare_numeric) - { - if (item_compare_ic) + if (!sortinfo->item_compare_numeric) + { + if (sortinfo->item_compare_ic) res = STRICMP(p1, p2); else res = STRCMP(p1, p2); @@ -18885,7 +18890,7 @@ item_compare(const void *s1, const void /* When the result would be zero, compare the item indexes. Makes the * sort stable. */ - if (res == 0 && !item_compare_keep_zero) + if (res == 0 && !sortinfo->item_compare_keep_zero) res = si1->idx > si2->idx ? 1 : -1; vim_free(tofree1); @@ -18906,7 +18911,7 @@ item_compare2(const void *s1, const void int dummy; /* shortcut after failure in previous call; compare all items equal */ - if (item_compare_func_err) + if (sortinfo->item_compare_func_err) return 0; si1 = (sortItem_T *)s1; @@ -18918,23 +18923,24 @@ item_compare2(const void *s1, const void copy_tv(&si2->item->li_tv, &argv[1]); rettv.v_type = VAR_UNKNOWN; /* clear_tv() uses this */ - res = call_func(item_compare_func, (int)STRLEN(item_compare_func), + res = call_func(sortinfo->item_compare_func, + (int)STRLEN(sortinfo->item_compare_func), &rettv, 2, argv, 0L, 0L, &dummy, TRUE, - item_compare_selfdict); + sortinfo->item_compare_selfdict); clear_tv(&argv[0]); clear_tv(&argv[1]); if (res == FAIL) res = ITEM_COMPARE_FAIL; else - res = get_tv_number_chk(&rettv, &item_compare_func_err); - if (item_compare_func_err) + res = get_tv_number_chk(&rettv, &sortinfo->item_compare_func_err); + if (sortinfo->item_compare_func_err) res = ITEM_COMPARE_FAIL; /* return value has wrong type */ clear_tv(&rettv); /* When the result would be zero, compare the pointers themselves. Makes * the sort stable. */ - if (res == 0 && !item_compare_keep_zero) + if (res == 0 && !sortinfo->item_compare_keep_zero) res = si1->idx > si2->idx ? 1 : -1; return res; @@ -18949,9 +18955,16 @@ do_sort_uniq(typval_T *argvars, typval_T list_T *l; listitem_T *li; sortItem_T *ptrs; + sortinfo_T *old_sortinfo; + sortinfo_T info; long len; long i; + /* Pointer to current info struct used in compare function. Save and + * restore the current one for nested calls. */ + old_sortinfo = sortinfo; + sortinfo = &info; + if (argvars[0].v_type != VAR_LIST) EMSG2(_(e_listarg), sort ? "sort()" : "uniq()"); else @@ -18960,62 +18973,62 @@ do_sort_uniq(typval_T *argvars, typval_T if (l == NULL || tv_check_lock(l->lv_lock, (char_u *)(sort ? N_("sort() argument") : N_("uniq() argument")), TRUE)) - return; + goto theend; rettv->vval.v_list = l; rettv->v_type = VAR_LIST; ++l->lv_refcount; len = list_len(l); if (len <= 1) - return; /* short list sorts pretty quickly */ - - item_compare_ic = FALSE; - item_compare_numeric = FALSE; - item_compare_numbers = FALSE; -#ifdef FEAT_FLOAT - item_compare_float = FALSE; -#endif - item_compare_func = NULL; - item_compare_selfdict = NULL; + goto theend; /* short list sorts pretty quickly */ + + info.item_compare_ic = FALSE; + info.item_compare_numeric = FALSE; + info.item_compare_numbers = FALSE; +#ifdef FEAT_FLOAT + info.item_compare_float = FALSE; +#endif + info.item_compare_func = NULL; + info.item_compare_selfdict = NULL; if (argvars[1].v_type != VAR_UNKNOWN) { /* optional second argument: {func} */ if (argvars[1].v_type == VAR_FUNC) - item_compare_func = argvars[1].vval.v_string; + info.item_compare_func = argvars[1].vval.v_string; else { int error = FALSE; i = get_tv_number_chk(&argvars[1], &error); if (error) - return; /* type error; errmsg already given */ + goto theend; /* type error; errmsg already given */ if (i == 1) - item_compare_ic = TRUE; - else - item_compare_func = get_tv_string(&argvars[1]); - if (item_compare_func != NULL) - { - if (STRCMP(item_compare_func, "n") == 0) - { - item_compare_func = NULL; - item_compare_numeric = TRUE; - } - else if (STRCMP(item_compare_func, "N") == 0) - { - item_compare_func = NULL; - item_compare_numbers = TRUE; - } -#ifdef FEAT_FLOAT - else if (STRCMP(item_compare_func, "f") == 0) - { - item_compare_func = NULL; - item_compare_float = TRUE; - } -#endif - else if (STRCMP(item_compare_func, "i") == 0) - { - item_compare_func = NULL; - item_compare_ic = TRUE; + info.item_compare_ic = TRUE; + else + info.item_compare_func = get_tv_string(&argvars[1]); + if (info.item_compare_func != NULL) + { + if (STRCMP(info.item_compare_func, "n") == 0) + { + info.item_compare_func = NULL; + info.item_compare_numeric = TRUE; + } + else if (STRCMP(info.item_compare_func, "N") == 0) + { + info.item_compare_func = NULL; + info.item_compare_numbers = TRUE; + } +#ifdef FEAT_FLOAT + else if (STRCMP(info.item_compare_func, "f") == 0) + { + info.item_compare_func = NULL; + info.item_compare_float = TRUE; + } +#endif + else if (STRCMP(info.item_compare_func, "i") == 0) + { + info.item_compare_func = NULL; + info.item_compare_ic = TRUE; } } } @@ -19026,16 +19039,16 @@ do_sort_uniq(typval_T *argvars, typval_T if (argvars[2].v_type != VAR_DICT) { EMSG(_(e_dictreq)); - return; - } - item_compare_selfdict = argvars[2].vval.v_dict; + goto theend; + } + info.item_compare_selfdict = argvars[2].vval.v_dict; } } /* Make an array with each entry pointing to an item in the List. */ ptrs = (sortItem_T *)alloc((int)(len * sizeof(sortItem_T))); if (ptrs == NULL) - return; + goto theend; i = 0; if (sort) @@ -19048,10 +19061,10 @@ do_sort_uniq(typval_T *argvars, typval_T ++i; } - item_compare_func_err = FALSE; - item_compare_keep_zero = FALSE; + info.item_compare_func_err = FALSE; + info.item_compare_keep_zero = FALSE; /* test the compare function */ - if (item_compare_func != NULL + if (info.item_compare_func != NULL && item_compare2((void *)&ptrs[0], (void *)&ptrs[1]) == ITEM_COMPARE_FAIL) EMSG(_("E702: Sort compare function failed")); @@ -19059,9 +19072,10 @@ do_sort_uniq(typval_T *argvars, typval_T { /* Sort the array with item pointers. */ qsort((void *)ptrs, (size_t)len, sizeof(sortItem_T), - item_compare_func == NULL ? item_compare : item_compare2); - - if (!item_compare_func_err) + info.item_compare_func == NULL + ? item_compare : item_compare2); + + if (!info.item_compare_func_err) { /* Clear the List and append the items in sorted order. */ l->lv_first = l->lv_last = l->lv_idx_item = NULL; @@ -19076,9 +19090,9 @@ do_sort_uniq(typval_T *argvars, typval_T int (*item_compare_func_ptr)(const void *, const void *); /* f_uniq(): ptrs will be a stack of items to remove */ - item_compare_func_err = FALSE; - item_compare_keep_zero = TRUE; - item_compare_func_ptr = item_compare_func + info.item_compare_func_err = FALSE; + info.item_compare_keep_zero = TRUE; + item_compare_func_ptr = info.item_compare_func ? item_compare2 : item_compare; for (li = l->lv_first; li != NULL && li->li_next != NULL; @@ -19087,14 +19101,14 @@ do_sort_uniq(typval_T *argvars, typval_T if (item_compare_func_ptr((void *)&li, (void *)&li->li_next) == 0) ptrs[i++].item = li; - if (item_compare_func_err) + if (info.item_compare_func_err) { EMSG(_("E882: Uniq compare function failed")); break; } } - if (!item_compare_func_err) + if (!info.item_compare_func_err) { while (--i >= 0) { @@ -19113,6 +19127,8 @@ do_sort_uniq(typval_T *argvars, typval_T vim_free(ptrs); } +theend: + sortinfo = old_sortinfo; } /* diff --git a/src/testdir/test_sort.vim b/src/testdir/test_sort.vim --- a/src/testdir/test_sort.vim +++ b/src/testdir/test_sort.vim @@ -1,5 +1,14 @@ " Test sort() +:func Compare1(a, b) abort + call sort(range(3), 'Compare2') + return a:a ># a:b +:endfunc + +:func Compare2(a, b) abort + return a:a <# a:b +:endfunc + func Test_sort_strings() " numbers compared as strings call assert_equal([1, 2, 3], sort([3, 2, 1])) @@ -21,3 +30,8 @@ endfunc func Test_sort_float() call assert_equal([0.28, 3, 13.5], sort([13.5, 0.28, 3], 'f')) endfunc + +func Test_sort_nested() + " test ability to call sort() from a compare function + call assert_equal([1, 3, 5], sort([3, 1, 5], 'Compare1')) +endfunc diff --git a/src/version.c b/src/version.c --- a/src/version.c +++ b/src/version.c @@ -749,6 +749,8 @@ static char *(features[]) = static int included_patches[] = { /* Add new patch number below this line */ /**/ + 1394, +/**/ 1393, /**/ 1392,