rpms/vim
6
0
Fork 0
Code Issues Pull Requests Releases Activity

- patchlevel 218

Browse Source
This commit is contained in:
Karsten Hopp 2014-04-07 13:13:16 +02:00
parent 665cc5115a
commit 805f60a7b4
1 changed files with 578 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

578
7.4.218 Normal file
View File

@ -0,0 +1,578 @@
To: vim_dev@googlegroups.com
Subject: Patch 7.4.218
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.4.218
Problem: It's not easy to remove duplicates from a list.
Solution: Add the uniq() function. (LCD)
Files: runtime/doc/change.txt, runtime/doc/eval.txt,
runtime/doc/usr_41.txt, runtime/doc/version7.txt, src/eval.c,
src/testdir/test55.in, src/testdir/test55.ok
*** ../vim-7.4.217/runtime/doc/change.txt 2013-09-22 15:23:38.000000000 +0200
--- runtime/doc/change.txt 2014-03-25 17:32:29.510040841 +0100
***************
*** 1645,1651 ****
7. Sorting text *sorting*
Vim has a sorting function and a sorting command. The sorting function can be
! found here: |sort()|.
*:sor* *:sort*
:[range]sor[t][!] [i][u][r][n][x][o] [/{pattern}/]
--- 1650,1656 ----
7. Sorting text *sorting*
Vim has a sorting function and a sorting command. The sorting function can be
! found here: |sort()|, |uniq()|.
*:sor* *:sort*
:[range]sor[t][!] [i][u][r][n][x][o] [/{pattern}/]
*** ../vim-7.4.217/runtime/doc/eval.txt 2014-02-23 23:38:58.820760280 +0100
--- runtime/doc/eval.txt 2014-03-25 17:47:18.750054467 +0100
***************
*** 326,331 ****
--- 327,333 ----
Changing the order of items in a list: >
:call sort(list) " sort a list alphabetically
:call reverse(list) " reverse the order of items
+ :call uniq(sort(list)) " sort and remove duplicates
For loop ~
***************
*** 1518,1523 ****
--- 1520,1526 ----
startup. These are the files that Vim remembers marks for.
The length of the List is limited by the ' argument of the
'viminfo' option (default is 100).
+ When the |viminfo| file is not used the List is empty.
Also see |:oldfiles| and |c_#<|.
The List can be modified, but this has no effect on what is
stored in the |viminfo| file later. If you use values other
***************
*** 2003,2008 ****
--- 2006,2013 ----
type( {name}) Number type of variable {name}
undofile( {name}) String undo file name for {name}
undotree() List undo file tree
+ uniq( {list} [, {func} [, {dict}]])
+ List remove adjacent duplicates from a list
values( {dict}) List values in {dict}
virtcol( {expr}) Number screen column of cursor or mark
visualmode( [expr]) String last visual mode used
***************
*** 5474,5493 ****
sort({list} [, {func} [, {dict}]]) *sort()* *E702*
! Sort the items in {list} in-place. Returns {list}. If you
! want a list to remain unmodified make a copy first: >
:let sortedlist = sort(copy(mylist))
< Uses the string representation of each item to sort on.
Numbers sort after Strings, |Lists| after Numbers.
For sorting text in the current buffer use |:sort|.
When {func} is given and it is one then case is ignored.
- {dict} is for functions with the "dict" attribute. It will be
- used to set the local variable "self". |Dictionary-function|
When {func} is a |Funcref| or a function name, this function
is called to compare items. The function is invoked with two
items as argument and must return zero if they are equal, 1 or
bigger if the first one sorts after the second one, -1 or
smaller if the first one sorts before the second one.
Example: >
func MyCompare(i1, i2)
return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
--- 5491,5516 ----
sort({list} [, {func} [, {dict}]]) *sort()* *E702*
! Sort the items in {list} in-place. Returns {list}.
!
! If you want a list to remain unmodified make a copy first: >
:let sortedlist = sort(copy(mylist))
< Uses the string representation of each item to sort on.
Numbers sort after Strings, |Lists| after Numbers.
For sorting text in the current buffer use |:sort|.
+
When {func} is given and it is one then case is ignored.
When {func} is a |Funcref| or a function name, this function
is called to compare items. The function is invoked with two
items as argument and must return zero if they are equal, 1 or
bigger if the first one sorts after the second one, -1 or
smaller if the first one sorts before the second one.
+
+ {dict} is for functions with the "dict" attribute. It will be
+ used to set the local variable "self". |Dictionary-function|
+
+ Also see |uniq()|.
+
Example: >
func MyCompare(i1, i2)
return a:i1 == a:i2 ? 0 : a:i1 > a:i2 ? 1 : -1
***************
*** 6155,6160 ****
--- 6178,6191 ----
blocks. Each item may again have an "alt"
item.
+ uniq({list} [, {func} [, {dict}]]) *uniq()* *E882*
+ Remove second and succeeding copies of repeated adjacent
+ {list} items in-place. Returns {list}. If you want a list
+ to remain unmodified make a copy first: >
+ :let newlist = uniq(copy(mylist))
+ < The default compare function uses the string representation of
+ each item. For the use of {func} and {dict} see |sort()|.
+
values({dict}) *values()*
Return a |List| with all the values of {dict}. The |List| is
in arbitrary order.
*** ../vim-7.4.217/runtime/doc/usr_41.txt 2013-08-10 13:25:05.000000000 +0200
--- runtime/doc/usr_41.txt 2014-03-25 17:32:29.518040841 +0100
***************
*** 1,4 ****
! *usr_41.txt* For Vim version 7.4. Last change: 2013 Feb 20
VIM USER MANUAL - by Bram Moolenaar
--- 1,4 ----
! *usr_41.txt* For Vim version 7.4. Last change: 2014 Jan 10
VIM USER MANUAL - by Bram Moolenaar
***************
*** 595,607 ****
matchlist() like matchstr() and also return submatches
stridx() first index of a short string in a long string
strridx() last index of a short string in a long string
! strlen() length of a string
substitute() substitute a pattern match with a string
submatch() get a specific match in ":s" and substitute()
strpart() get part of a string
expand() expand special keywords
iconv() convert text from one encoding to another
byteidx() byte index of a character in a string
repeat() repeat a string multiple times
eval() evaluate a string expression
--- 595,611 ----
matchlist() like matchstr() and also return submatches
stridx() first index of a short string in a long string
strridx() last index of a short string in a long string
! strlen() length of a string in bytes
! strchars() length of a string in characters
! strwidth() size of string when displayed
! strdisplaywidth() size of string when displayed, deals with tabs
substitute() substitute a pattern match with a string
submatch() get a specific match in ":s" and substitute()
strpart() get part of a string
expand() expand special keywords
iconv() convert text from one encoding to another
byteidx() byte index of a character in a string
+ byteidxcomp() like byteidx() but count composing characters
repeat() repeat a string multiple times
eval() evaluate a string expression
***************
*** 619,624 ****
--- 623,629 ----
map() change each List item
sort() sort a List
reverse() reverse the order of a List
+ uniq() remove copies of repeated adjacent items
split() split a String into a List
join() join List items into a String
range() return a List with a sequence of numbers
***************
*** 656,661 ****
--- 661,669 ----
ceil() round up
floor() round down
trunc() remove value after decimal point
+ fmod() remainder of division
+ exp() exponential
+ log() natural logarithm (logarithm to base e)
log10() logarithm to base 10
pow() value of x to the exponent y
sqrt() square root
***************
*** 675,680 ****
--- 683,689 ----
invert() bitwise invert
or() bitwise OR
xor() bitwise XOR
+ sha256() SHA-256 hash
Variables: *var-functions*
type() type of a variable
***************
*** 697,707 ****
--- 706,720 ----
wincol() window column number of the cursor
winline() window line number of the cursor
cursor() position the cursor at a line/column
+ screencol() get screen column of the cursor
+ screenrow() get screen row of the cursor
getpos() get position of cursor, mark, etc.
setpos() set position of cursor, mark, etc.
byte2line() get line number at a specific byte count
line2byte() byte count at a specific line
diff_filler() get the number of filler lines above a line
+ screenattr() get attribute at a screen line/row
+ screenchar() get character code at a screen line/row
Working with text in the current buffer: *text-functions*
getline() get a line or list of lines from the buffer
***************
*** 883,896 ****
--- 896,917 ----
libcall() call a function in an external library
libcallnr() idem, returning a number
+ undofile() get the name of the undo file
+ undotree() return the state of the undo tree
+
getreg() get contents of a register
getregtype() get type of a register
setreg() set contents and type of a register
+ shiftwidth() effective value of 'shiftwidth'
+
taglist() get list of matching tags
tagfiles() get a list of tags files
+ luaeval() evaluate Lua expression
mzeval() evaluate |MzScheme| expression
+ py3eval() evaluate Python expression (|+python3|)
+ pyeval() evaluate Python expression (|+python|)
==============================================================================
*41.7* Defining a function
*** ../vim-7.4.217/runtime/doc/version7.txt 2013-08-10 14:23:06.000000000 +0200
--- runtime/doc/version7.txt 2014-03-25 17:32:29.518040841 +0100
***************
*** 942,947 ****
--- 942,948 ----
|tagfiles()| List with tags file names
|taglist()| get list of matching tags (Yegappan Lakshmanan)
|tr()| translate characters (Ron Aaron)
+ |uniq()| remove copies of repeated adjacent list items
|values()| get List of Dictionary values
|winnr()| takes an argument: what window to use
|winrestview()| restore the view of the current window
*** ../vim-7.4.217/src/eval.c 2014-03-23 15:12:29.915264336 +0100
--- src/eval.c 2014-03-25 17:52:09.554058923 +0100
***************
*** 744,749 ****
--- 744,750 ----
static void f_type __ARGS((typval_T *argvars, typval_T *rettv));
static void f_undofile __ARGS((typval_T *argvars, typval_T *rettv));
static void f_undotree __ARGS((typval_T *argvars, typval_T *rettv));
+ static void f_uniq __ARGS((typval_T *argvars, typval_T *rettv));
static void f_values __ARGS((typval_T *argvars, typval_T *rettv));
static void f_virtcol __ARGS((typval_T *argvars, typval_T *rettv));
static void f_visualmode __ARGS((typval_T *argvars, typval_T *rettv));
***************
*** 8150,8155 ****
--- 8151,8157 ----
{"type", 1, 1, f_type},
{"undofile", 1, 1, f_undofile},
{"undotree", 0, 0, f_undotree},
+ {"uniq", 1, 3, f_uniq},
{"values", 1, 1, f_values},
{"virtcol", 1, 1, f_virtcol},
{"visualmode", 0, 1, f_visualmode},
***************
*** 17023,17032 ****
static char_u *item_compare_func;
static dict_T *item_compare_selfdict;
static int item_compare_func_err;
#define ITEM_COMPARE_FAIL 999
/*
! * Compare functions for f_sort() below.
*/
static int
#ifdef __BORLANDC__
--- 17025,17035 ----
static char_u *item_compare_func;
static dict_T *item_compare_selfdict;
static int item_compare_func_err;
+ static void do_sort_uniq __ARGS((typval_T *argvars, typval_T *rettv, int sort));
#define ITEM_COMPARE_FAIL 999
/*
! * Compare functions for f_sort() and f_uniq() below.
*/
static int
#ifdef __BORLANDC__
***************
*** 17100,17108 ****
* "sort({list})" function
*/
static void
! f_sort(argvars, rettv)
typval_T *argvars;
typval_T *rettv;
{
list_T *l;
listitem_T *li;
--- 17103,17112 ----
* "sort({list})" function
*/
static void
! do_sort_uniq(argvars, rettv, sort)
typval_T *argvars;
typval_T *rettv;
+ int sort;
{
list_T *l;
listitem_T *li;
***************
*** 17111,17122 ****
long i;
if (argvars[0].v_type != VAR_LIST)
! EMSG2(_(e_listarg), "sort()");
else
{
l = argvars[0].vval.v_list;
if (l == NULL || tv_check_lock(l->lv_lock,
! (char_u *)_("sort() argument")))
return;
rettv->vval.v_list = l;
rettv->v_type = VAR_LIST;
--- 17115,17126 ----
long i;
if (argvars[0].v_type != VAR_LIST)
! EMSG2(_(e_listarg), sort ? "sort()" : "uniq()");
else
{
l = argvars[0].vval.v_list;
if (l == NULL || tv_check_lock(l->lv_lock,
! (char_u *)(sort ? _("sort() argument") : _("uniq() argument"))))
return;
rettv->vval.v_list = l;
rettv->v_type = VAR_LIST;
***************
*** 17163,17191 ****
ptrs = (listitem_T **)alloc((int)(len * sizeof(listitem_T *)));
if (ptrs == NULL)
return;
- i = 0;
- for (li = l->lv_first; li != NULL; li = li->li_next)
- ptrs[i++] = li;
! item_compare_func_err = FALSE;
! /* test the compare function */
! if (item_compare_func != NULL
! && item_compare2((void *)&ptrs[0], (void *)&ptrs[1])
== ITEM_COMPARE_FAIL)
! EMSG(_("E702: Sort compare function failed"));
else
{
! /* Sort the array with item pointers. */
! qsort((void *)ptrs, (size_t)len, sizeof(listitem_T *),
! item_compare_func == NULL ? item_compare : item_compare2);
if (!item_compare_func_err)
{
! /* Clear the List and append the items in the sorted order. */
! l->lv_first = l->lv_last = l->lv_idx_item = NULL;
! l->lv_len = 0;
! for (i = 0; i < len; ++i)
! list_append(l, ptrs[i]);
}
}
--- 17167,17238 ----
ptrs = (listitem_T **)alloc((int)(len * sizeof(listitem_T *)));
if (ptrs == NULL)
return;
! 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;
!
! item_compare_func_err = FALSE;
! /* test the compare function */
! if (item_compare_func != NULL
! && item_compare2((void *)&ptrs[0], (void *)&ptrs[1])
== ITEM_COMPARE_FAIL)
! EMSG(_("E702: Sort compare function failed"));
! else
! {
! /* Sort the array with item pointers. */
! qsort((void *)ptrs, (size_t)len, sizeof(listitem_T *),
! item_compare_func == NULL ? item_compare : item_compare2);
!
! if (!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;
! l->lv_len = 0;
! for (i = 0; i < len; ++i)
! list_append(l, ptrs[i]);
! }
! }
! }
else
{
! int (*item_compare_func_ptr)__ARGS((const void *, const void *));
!
! /* f_uniq(): ptrs will be a stack of items to remove */
! item_compare_func_err = FALSE;
! 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((void *)&li, (void *)&li->li_next)
! == 0)
! ptrs[i++] = li;
! if (item_compare_func_err)
! {
! EMSG(_("E882: Uniq compare function failed"));
! break;
! }
! }
if (!item_compare_func_err)
{
! while (--i >= 0)
! {
! li = ptrs[i]->li_next;
! ptrs[i]->li_next = li->li_next;
! if (li->li_next != NULL)
! li->li_next->li_prev = ptrs[i];
! else
! l->lv_last = ptrs[i];
! list_fix_watch(l, li);
! listitem_free(li);
! l->lv_len--;
! }
}
}
***************
*** 17194,17199 ****
--- 17241,17268 ----
}
/*
+ * "sort({list})" function
+ */
+ static void
+ f_sort(argvars, rettv)
+ typval_T *argvars;
+ typval_T *rettv;
+ {
+ do_sort_uniq(argvars, rettv, TRUE);
+ }
+
+ /*
+ * "uniq({list})" function
+ */
+ static void
+ f_uniq(argvars, rettv)
+ typval_T *argvars;
+ typval_T *rettv;
+ {
+ do_sort_uniq(argvars, rettv, FALSE);
+ }
+
+ /*
* "soundfold({word})" function
*/
static void
*** ../vim-7.4.217/src/testdir/test55.in 2014-01-14 15:24:24.000000000 +0100
--- src/testdir/test55.in 2014-03-25 17:32:29.522040841 +0100
***************
*** 323,335 ****
: $put ='caught ' . v:exception
:endtry
:"
! :" reverse() and sort()
! :let l = ['-0', 'A11', 2, 'xaaa', 4, 'foo', 'foo6', [0, 1, 2], 'x8']
:$put =string(reverse(l))
:$put =string(reverse(reverse(l)))
:$put =string(sort(l))
:$put =string(reverse(sort(l)))
:$put =string(sort(reverse(sort(l))))
:"
:" splitting a string to a List
:$put =string(split(' aa bb '))
--- 323,337 ----
: $put ='caught ' . v:exception
:endtry
:"
! :" reverse(), sort(), uniq()
! :let l = ['-0', 'A11', 2, 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5]
! :$put =string(uniq(copy(l)))
:$put =string(reverse(l))
:$put =string(reverse(reverse(l)))
:$put =string(sort(l))
:$put =string(reverse(sort(l)))
:$put =string(sort(reverse(sort(l))))
+ :$put =string(uniq(sort(l)))
:"
:" splitting a string to a List
:$put =string(split(' aa bb '))
*** ../vim-7.4.217/src/testdir/test55.ok 2014-01-14 15:24:24.000000000 +0100
--- src/testdir/test55.ok 2014-03-25 17:32:29.522040841 +0100
***************
*** 94,104 ****
caught a:000[2]
caught a:000[3]
[1, 2, [3, 9, 5, 6], {'a': 12, '5': 8}]
! ['x8', [0, 1, 2], 'foo6', 'foo', 4, 'xaaa', 2, 'A11', '-0']
! ['x8', [0, 1, 2], 'foo6', 'foo', 4, 'xaaa', 2, 'A11', '-0']
! ['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 2, 4, [0, 1, 2]]
! [[0, 1, 2], 4, 2, 'xaaa', 'x8', 'foo6', 'foo', 'A11', '-0']
! ['-0', 'A11', 'foo', 'foo6', 'x8', 'xaaa', 2, 4, [0, 1, 2]]
['aa', 'bb']
['aa', 'bb']
['', 'aa', 'bb', '']
--- 94,106 ----
caught a:000[2]
caught a:000[3]
[1, 2, [3, 9, 5, 6], {'a': 12, '5': 8}]
! ['-0', 'A11', 2, 'xaaa', 4, 'foo', 'foo6', 'foo', [0, 1, 2], 'x8', [0, 1, 2], 1.5]
! [1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0']
! [1.5, [0, 1, 2], 'x8', [0, 1, 2], 'foo', 'foo6', 'foo', 4, 'xaaa', 2, 2, 'A11', '-0']
! ['-0', 'A11', 'foo', 'foo', 'foo6', 'x8', 'xaaa', 1.5, 2, 2, 4, [0, 1, 2], [0, 1, 2]]
! [[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]]
['aa', 'bb']
['aa', 'bb']
['', 'aa', 'bb', '']
*** ../vim-7.4.217/src/version.c 2014-03-25 18:05:45.242071421 +0100
--- src/version.c 2014-03-25 17:34:51.918043023 +0100
***************
*** 736,737 ****
--- 736,739 ----
{ /* Add new patch number below this line */
+ /**/
+ 218,
/**/
--
Never under any circumstances take a sleeping pill
and a laxative on the same night.
/// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
\\\ an exciting new programming language -- http://www.Zimbu.org ///
\\\ help me help AIDS victims -- http://ICCF-Holland.org ///