kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-20 19:25:11 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1140 from atwupack/vp-7.4.341

Browse Source 
vim-patch:7.4.341, 7.4.347, 7.4.351, 7.4.358
This commit is contained in:
Justin M. Keyes 2014-09-15 14:08:55 -04:00
commit 3b7b79e37d
4 changed files with 84 additions and 24 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

90
src/nvim/eval.c
View File

@ -13386,11 +13386,18 @@ static void f_sinh(typval_T *argvars, typval_T *rettv)
rettv->vval.v_float = 0.0;
}
/// struct used in the array that's given to qsort()
typedef struct {
listitem_T *item;
int idx;
} sortItem_T;
static int item_compare_ic;
static bool item_compare_numeric;
static char_u *item_compare_func;
static dict_T *item_compare_selfdict;
static int item_compare_func_err;
static bool item_compare_keep_zero;
#define ITEM_COMPARE_FAIL 999
/*
@ -13398,22 +13405,40 @@ static int item_compare_func_err;
*/
static int item_compare(const void *s1, const void *s2)
{
sortItem_T *si1, *si2;
char_u *p1, *p2;
char_u *tofree1, *tofree2;
int res;
char_u numbuf1[NUMBUFLEN];
char_u numbuf2[NUMBUFLEN];
p1 = tv2string(&(*(listitem_T **)s1)->li_tv, &tofree1, numbuf1, 0);
p2 = tv2string(&(*(listitem_T **)s2)->li_tv, &tofree2, numbuf2, 0);
si1 = (sortItem_T *)s1;
si2 = (sortItem_T *)s2;
p1 = tv2string(&si1->item->li_tv, &tofree1, numbuf1, 0);
p2 = tv2string(&si2->item->li_tv, &tofree2, numbuf2, 0);
if (p1 == NULL)
p1 = (char_u *)"";
if (p2 == NULL)
p2 = (char_u *)"";
if (item_compare_ic)
res = STRICMP(p1, p2);
else
res = STRCMP(p1, p2);
if (!item_compare_numeric) {
if (item_compare_ic) {
res = STRICMP(p1, p2);
} else {
res = STRCMP(p1, p2);
}
} else {
double n1, n2;
n1 = strtod((char *)p1, (char **)&p1);
n2 = strtod((char *)p2, (char **)&p2);
res = n1 == n2 ? 0 : n1 > n2 ? 1 : -1;
}
// When the result would be zero, compare the pointers themselves. Makes
// the sort stable.
if (res == 0 && !item_compare_keep_zero) {
res = si1->idx > si2->idx ? 1 : -1;
}
free(tofree1);
free(tofree2);
return res;
@ -13421,6 +13446,7 @@ static int item_compare(const void *s1, const void *s2)
static int item_compare2(const void *s1, const void *s2)
{
sortItem_T *si1, *si2;
int res;
typval_T rettv;
typval_T argv[3];
@ -13430,10 +13456,13 @@ static int item_compare2(const void *s1, const void *s2)
if (item_compare_func_err)
return 0;
/* copy the values. This is needed to be able to set v_lock to VAR_FIXED
* in the copy without changing the original list items. */
copy_tv(&(*(listitem_T **)s1)->li_tv, &argv[0]);
copy_tv(&(*(listitem_T **)s2)->li_tv, &argv[1]);
si1 = (sortItem_T *)s1;
si2 = (sortItem_T *)s2;
// Copy the values. This is needed to be able to set v_lock to VAR_FIXED
// in the copy without changing the original list items.
copy_tv(&si1->item->li_tv, &argv[0]);
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),
@ -13449,6 +13478,13 @@ static int item_compare2(const void *s1, const void *s2)
if (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) {
res = si1->idx > si2->idx ? 1 : -1;
}
return res;
}
@ -13459,7 +13495,7 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
{
list_T *l;
listitem_T *li;
listitem_T **ptrs;
sortItem_T *ptrs;
long len;
long i;
@ -13480,6 +13516,7 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
return; /* short list sorts pretty quickly */
item_compare_ic = FALSE;
item_compare_numeric = false;
item_compare_func = NULL;
item_compare_selfdict = NULL;
@ -13497,6 +13534,15 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
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, "i") == 0) {
item_compare_func = NULL;
item_compare_ic = TRUE;
}
}
}
if (argvars[2].v_type != VAR_UNKNOWN) {
@ -13510,23 +13556,26 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
}
/* Make an array with each entry pointing to an item in the List. */
ptrs = xmalloc((size_t)(len * sizeof (listitem_T *)));
ptrs = xmalloc((size_t)(len * sizeof (sortItem_T)));
i = 0;
if (sort) {
// sort(): ptrs will be the list to sort.
for (li = l->lv_first; li != NULL; li = li->li_next) {
ptrs[i++] = li;
ptrs[i].item = li;
ptrs[i].idx = i;
i++;
}
item_compare_func_err = FALSE;
item_compare_keep_zero = false;
// Test the compare function.
if (item_compare_func != NULL
&& item_compare2(&ptrs[0], &ptrs[1]) == ITEM_COMPARE_FAIL) {
EMSG(_("E702: Sort compare function failed"));
} else {
// Sort the array with item pointers.
qsort(ptrs, (size_t)len, sizeof (listitem_T *),
qsort(ptrs, (size_t)len, sizeof (sortItem_T),
item_compare_func == NULL ? item_compare : item_compare2);
if (!item_compare_func_err) {
@ -13537,7 +13586,7 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
l->lv_len = 0;
for (i = 0; i < len; i++) {
list_append(l, ptrs[i]);
list_append(l, ptrs[i].item);
}
}
}
@ -13546,11 +13595,12 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
// 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 ? item_compare2 : item_compare;
for (li = l->lv_first; li != NULL && li->li_next != NULL; li = li->li_next) {
if (item_compare_func_ptr(&li, &li->li_next) == 0) {
ptrs[i++] = li;
ptrs[i++].item = li;
}
if (item_compare_func_err) {
EMSG(_("E882: Uniq compare function failed"));
@ -13560,12 +13610,12 @@ static void do_sort_uniq(typval_T *argvars, typval_T *rettv, bool sort)
if (!item_compare_func_err) {
while (--i >= 0) {
li = ptrs[i]->li_next;
ptrs[i]->li_next = li->li_next;
li = ptrs[i].item->li_next;
ptrs[i].item->li_next = li->li_next;
if (li->li_next != NULL) {
li->li_next->li_prev = ptrs[i];
li->li_next->li_prev = ptrs[i].item;
} else {
l->lv_last = ptrs[i];
l->lv_last = ptrs[i].item;
}
list_fix_watch(l, li);
listitem_free(li);

6
src/nvim/testdir/test55.in
View File

@ -332,6 +332,12 @@ let l = [0, 1, 2, 3]
:$put =string(reverse(sort(l)))
:$put =string(sort(reverse(sort(l))))
:$put =string(uniq(sort(l)))
:let l=[7, 9, 'one', 18, 12, 22, 'two', 10.0e-16, -1, 'three', 0xff, 0.22, 'four']
:$put =string(sort(copy(l), 'n'))
:let l=[7, 9, 18, 12, 22, 10.0e-16, -1, 0xff, 0, -0, 0.22, 'bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', {}, []]
:$put =string(sort(copy(l), 1))
:$put =string(sort(copy(l), 'i'))
:$put =string(sort(copy(l)))
:"
:" splitting a string to a List
:$put =string(split(' aa bb '))

4
src/nvim/testdir/test55.ok
View File

@ -101,6 +101,10 @@ caught a:000[3]
[[0, 1, 2], [0, 1, 2], 4, 2, 2, 1.5, 'xaaa', 'x8', 'foo6', 'foo', 'foo', 'A11', '-0']
['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]]
['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 4, [0, 1, 2]]
[-1, 'one', 'two', 'three', 'four', 1.0e-15, 0.22, 7, 9, 12, 18, 22, 255]
['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}]
['bar', 'BAR', 'Bar', 'Foo', 'FOO', 'foo', 'FOOBAR', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}]
['BAR', 'Bar', 'FOO', 'FOOBAR', 'Foo', 'bar', 'foo', -1, 0, 0, 0.22, 1.0e-15, 12, 18, 22, 255, 7, 9, [], {}]
['aa', 'bb']
['aa', 'bb']
['', 'aa', 'bb', '']

8
src/nvim/version.c
View File

@ -237,24 +237,24 @@ static int included_patches[] = {
//361,
//360,
//359,
//358,
358,
357,
//356 NA
//355,
//354 NA
353,
352,
//351,
351,
//350,
349,
348,
//347,
347,
346,
345,
344,
343,
//342 NA
//341,
341,
//340 NA
339,
338,