vim/7.4.218

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    ///