path: root/data/vim/patches/8.1.0614

To: vim_dev@googlegroups.com
Subject: Patch 8.1.0614
Fcc: outbox
From: Bram Moolenaar <Bram@moolenaar.net>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
------------

Patch 8.1.0614
Problem:    Placing signs can be complicated.
Solution:   Add functions for defining and placing signs.  Introduce a group
            name to avoid different plugins using the same signs. (Yegappan
            Lakshmanan, closes #3652)
Files:	    runtime/doc/eval.txt, runtime/doc/sign.txt,
            runtime/doc/usr_41.txt, src/alloc.h, src/buffer.c, src/evalfunc.c,
            src/ex_cmds.c, src/globals.h, src/list.c, src/misc2.c,
            src/netbeans.c, src/proto/buffer.pro, src/proto/ex_cmds.pro,
            src/proto/list.pro, src/proto/misc2.pro, src/structs.h,
            src/testdir/test_signs.vim, src/workshop.c


*** ../vim-8.1.0613/runtime/doc/eval.txt	2018-12-13 22:17:52.869941530 +0100
--- runtime/doc/eval.txt	2018-12-21 14:49:21.627875310 +0100
***************
*** 2395,2400 ****
--- 2408,2422 ----
  				String	escape {string} for use as shell
  					command argument
  shiftwidth([{col}])		Number	effective value of 'shiftwidth'
+ sign_define({name} [, {dict}])	Number	define or update a sign
+ sign_getdefined([{name}])	List	get a list of defined signs
+ sign_getplaced([{expr} [, {dict}]])
+ 				List	get a list of placed signs
+ sign_place({id}, {group}, {name}, {expr} [, {dict}])
+ 				Number	place a sign
+ sign_undefine([{name}])		Number	undefine a sign
+ sign_unplace({group} [, {dict}])
+ 				Number	unplace a sign
  simplify({filename})		String	simplify filename as much as possible
  sin({expr})			Float	sine of {expr}
  sinh({expr})			Float	hyperbolic sine of {expr}
***************
*** 7841,7847 ****
--- 7867,8083 ----
  		'vartabstop' feature. If the 'vartabstop' setting is enabled and
  		no {col} argument is given, column 1 will be assumed.
  
+ sign_define({name} [, {dict}])				*sign_define()*
+ 		Define a new sign named {name} or modify the attributes of an
+ 		existing sign.  This is similar to the |:sign-define| command.
  
+ 		Prefix {name} with a unique text to avoid name collisions.
+ 		There is no {group} like with placing signs.
+ 
+ 		The {name} can be a String or a Number.  The optional {dict}
+ 		argument specifies the sign attributes.  The following values
+ 		are supported:
+ 		    icon	full path to the bitmap file for the sign.
+ 		    linehl	highlight group used for the whole line the
+ 				sign is placed in.
+ 		    text	text that is displayed when there is no icon
+ 				or the GUI is not being used.
+ 		    texthl	highlight group used for the text item
+ 		For an existing sign, the attributes are updated.
+ 
+ 		Returns 0 on success and -1 on failure.
+ 
+ 		Examples: >
+ 			call sign_define("mySign", {"text" : "=>", "texthl" :
+ 					\ "Error", "linehl" : "Search"})
+ <
+ sign_getdefined([{name}])				*sign_getdefined()*
+ 		Get a list of defined signs and their attributes.
+ 		This is similar to the |:sign-list| command.
+ 
+ 		If the {name} is not supplied, then a list of all the defined
+ 		signs is returned. Otherwise the attribute of the specified
+ 		sign is returned.
+ 
+ 		Each list item in the returned value is a dictionary with the
+ 		following entries:
+ 			icon	full path to the bitmap file of the sign
+ 			linehl	highlight group used for the whole line the
+ 				sign is placed in.
+ 			name	name of the sign
+ 			text	text that is displayed when there is no icon
+ 				or the GUI is not being used.
+ 			texthl	highlight group used for the text item
+ 
+ 		Returns an empty List if there are no signs and when {name} is
+ 		not found.
+ 
+ 		Examples: >
+ 			" Get a list of all the defined signs
+ 			echo sign_getdefined()
+ 
+ 			" Get the attribute of the sign named mySign
+ 			echo sign_getdefined("mySign")
+ <
+ sign_getplaced([{expr} [, {dict}]])			*sign_getplaced()*
+ 		Return a list of signs placed in a buffer or all the buffers.
+ 		This is similar to the |:sign-place-list| command.
+ 
+ 		If the optional buffer name {expr} is specified, then only the
+ 		list of signs placed in that buffer is returned.  For the use
+ 		of {expr}, see |bufname()|. The optional {dict} can contain
+ 		the following entries:
+ 			group	select only signs in this group
+ 			id	select sign with this identifier
+ 			lnum	select signs placed in this line. For the use
+ 				of {lnum}, see |line()|.
+ 		If {group} is '*', then signs in all the groups including the
+ 		global group are returned. If {group} is not supplied, then
+ 		only signs in the global group are returned.  If no arguments
+ 		are supplied, then signs in the global group placed in all the
+ 		buffers are returned.
+ 
+ 		Each list item in the returned value is a dictionary with the
+ 		following entries:
+ 			bufnr	number of the buffer with the sign
+ 			signs	list of signs placed in {bufnr}. Each list
+ 				item is a dictionary with the below listed
+ 				entries
+ 
+ 		The dictionary for each sign contains the following entries:
+ 			group	sign group. Set to '' for the global group.
+ 			id	identifier of the sign
+ 			lnum	line number where the sign is placed
+ 			name	name of the defined sign
+ 			priority	sign priority
+ 
+ 		Returns an empty list on failure.
+ 
+ 		Examples: >
+ 			" Get a List of signs placed in eval.c in the
+ 			" global group
+ 			echo sign_getplaced("eval.c")
+ 
+ 			" Get a List of signs in group 'g1' placed in eval.c
+ 			echo sign_getplaced("eval.c", {'group' : 'g1'})
+ 
+ 			" Get a List of signs placed at line 10 in eval.c
+ 			echo sign_getplaced("eval.c", {'lnum' : 10})
+ 
+ 			" Get sign with identifier 10 placed in a.py
+ 			echo sign_getplaced("a.py", {'id' : 10'})
+ 
+ 			" Get sign with id 20 in group 'g1' placed in a.py
+ 			echo sign_getplaced("a.py", {'group' : 'g1',
+ 							\  'id' : 20'})
+ 
+ 			" Get a List of all the placed signs
+ 			echo sign_getplaced()
+ <
+ 							*sign_place()*
+ sign_place({id}, {group}, {name}, {expr} [, {dict}])
+ 		Place the sign defined as {name} at line {lnum} in file {expr}
+ 		and assign {id} and {group} to sign.  This is similar to the
+ 		|:sign-place| command.
+ 
+ 		If the sign identifier {id} is zero, then a new identifier is
+ 		allocated.  Otherwise the specified number is used. {group} is
+ 		the sign group name. To use the global sign group, use an
+ 		empty string.  {group} functions as a namespace for {id}, thus
+ 		two groups can use the same IDs.
+ 		
+ 		{name} refers to a defined sign.
+ 		{expr} refers to a buffer name or number. For the accepted
+ 		values, see |bufname()|.
+ 
+ 		The optional {dict} argument supports the following entries:
+ 			lnum		line number in the buffer {expr} where
+ 					the sign is to be placed. For the
+ 					accepted values, see |line()|.
+ 			priority	priority of the sign. See
+ 					|sign-priority| for more information.
+ 
+ 		If the optional {dict} is not specified, then it modifies the
+ 		placed sign {id} in group {group} to use the defined sign
+ 		{name}.
+ 
+ 		Returns the sign identifier on success and -1 on failure.
+ 
+ 		Examples: >
+ 			" Place a sign named sign1 with id 5 at line 20 in
+ 			" buffer json.c
+ 			call sign_place(5, '', 'sign1', 'json.c',
+ 							\ {'lnum' : 20})
+ 
+ 			" Updates sign 5 in buffer json.c to use sign2
+ 			call sign_place(5, '', 'sign2', 'json.c')
+ 
+ 			" Place a sign named sign3 at line 30 in
+ 			" buffer json.c with a new identifier
+ 			let id = sign_place(0, '', 'sign3', 'json.c',
+ 							\ {'lnum' : 30})
+ 
+ 			" Place a sign named sign4 with id 10 in group 'g3'
+ 			" at line 40 in buffer json.c with priority 90
+ 			call sign_place(10, 'g3', 'sign4', 'json.c',
+ 					\ {'lnum' : 40, 'priority' : 90})
+ <
+ sign_undefine([{name}])					*sign_undefine()*
+ 		Deletes a previously defined sign {name}. This is similar to
+ 		the |:sign-undefine| command. If {name} is not supplied, then
+ 		deletes all the defined signs.
+ 
+ 		Returns 0 on success and -1 on failure.
+ 
+ 		Examples: >
+ 			" Delete a sign named mySign
+ 			call sign_undefine("mySign")
+ 
+ 			" Delete all the signs
+ 			call sign_undefine()
+ <
+ sign_unplace({group} [, {dict}])			*sign_unplace()*
+ 		Remove a previously placed sign in one or more buffers.  This
+ 		is similar to the |:sign-unplace()| command.
+ 
+ 		{group} is the sign group name. To use the global sign group,
+ 		use an empty string.  If {group} is set to '*', then all the
+ 		groups including the global group are used.
+ 		The signs in {group} are selected based on the entries in
+ 		{dict}.  The following optional entries in {dict} are
+ 		supported:
+ 			buffer	buffer name or number. See |bufname()|.
+ 			id	sign identifier
+ 		If {dict} is not supplied, then all the signs in {group} are
+ 		removed.
+ 
+ 		Returns 0 on success and -1 on failure.
+ 
+ 		Examples: >
+ 			" Remove sign 10 from buffer a.vim
+ 			call sign_unplace('', {'buffer' : "a.vim", 'id' : 10})
+ 
+ 			" Remove sign 20 in group 'g1' from buffer 3
+ 			call sign_unplace('g1', {'buffer' : 3, 'id' : 20})
+ 
+ 			" Remove all the signs in group 'g2' from buffer 10
+ 			call sign_unplace('g2', {'buffer' : 10})
+ 
+ 			" Remove sign 30 in group 'g3' from all the buffers
+ 			call sign_unplace('g3', {'id' : 30})
+ 
+ 			" Remove all the signs placed in buffer 5
+ 			call sign_unplace('*', {'buffer' : 5})
+ 
+ 			" Remove the signs in group 'g4' from all the buffers
+ 			call sign_unplace('g4')
+ 
+ 			" Remove sign 40 from all the buffers
+ 			call sign_unplace('*', {'id' : 40})
+ 
+ 			" Remove all the placed signs from all the buffers
+ 			call sign_unplace('*')
+ <
  simplify({filename})					*simplify()*
  		Simplify the file name as much as possible without changing
  		the meaning.  Shortcuts (on MS-Windows) or symbolic links (on
*** ../vim-8.1.0613/runtime/doc/sign.txt	2018-05-17 13:42:02.000000000 +0200
--- runtime/doc/sign.txt	2018-12-21 14:52:11.058495079 +0100
***************
*** 51,56 ****
--- 51,70 ----
  Example to set the color: >
  
  	:highlight SignColumn guibg=darkgrey
+ <
+ 							*sign-group*
+ Each sign can be assigned to either the global group or a named group. When
+ placing a sign, if a group name is not supplied, or an empty string is used,
+ then the sign is placed in the global group. Otherwise the sign is placed in
+ the named group. The sign identifier is unique within a group. The sign group
+ allows Vim plugins to use unique signs without interfering with other plugins
+ using signs.
+ 
+ 							*sign-priority*
+ Each placed sign is assigned a priority value. When multiple signs are placed
+ on the same line, the attributes of the sign with the highest priority is used
+ independent of the sign group. The default priority for a sign is 10. The
+ priority is assigned at the time of placing a sign.
  
  ==============================================================================
  2. Commands					*sign-commands* *:sig* *:sign*
***************
*** 69,74 ****
--- 83,90 ----
  
  DEFINING A SIGN.			*:sign-define* *E255* *E160* *E612*
  
+ See |sign_define()| for the equivalent Vim script function.
+ 
  :sign define {name} {argument}...
  		Define a new sign or set attributes for an existing sign.
  		The {name} can either be a number (all digits) or a name
***************
*** 106,118 ****
--- 122,139 ----
  
  DELETING A SIGN						*:sign-undefine* *E155*
  
+ See |sign_undefine()| for the equivalent Vim script function.
+ 
  :sign undefine {name}
  		Deletes a previously defined sign.  If signs with this {name}
  		are still placed this will cause trouble.
  
  
+ 
  LISTING SIGNS						*:sign-list* *E156*
  
+ See |sign_getdefined()| for the equivalent Vim script function.
+ 
  :sign list	Lists all defined signs and their attributes.
  
  :sign list {name}
***************
*** 121,126 ****
--- 142,149 ----
  
  PLACING SIGNS						*:sign-place* *E158*
  
+ See |sign_place()| for the equivalent Vim script function.
+ 
  :sign place {id} line={lnum} name={name} file={fname}
  		Place sign defined as {name} at line {lnum} in file {fname}.
  							*:sign-fname*
***************
*** 136,141 ****
--- 159,183 ----
  		to be done several times and making changes may not work as
  		expected).
  
+ 		The following optional sign attributes can be specified before
+ 		"file=":
+ 			group={group}	Place sign in sign group {group}
+ 			priority={prio}	Assign priority {prio} to sign
+ 
+ 		By default, the sign is placed in the global sign group.
+ 
+ 		By default, the sign is assigned a default priority of 10. To
+ 		assign a different priority value, use "priority={prio}" to
+ 		specify a value. The priority is used to determine the
+ 		highlight group used when multiple signs are placed on the
+ 		same line.
+ 
+ 		Examples: >
+ 			:sign place 5 line=3 name=sign1 file=a.py
+ 			:sign place 6 group=g2 line=2 name=sign2 file=x.py
+ 			:sign place 9 group=g2 priority=50 line=5
+ 							\ name=sign1 file=a.py
+ <
  :sign place {id} line={lnum} name={name} buffer={nr}
  		Same, but use buffer {nr}.
  
***************
*** 146,176 ****
  		This can be used to change the displayed sign without moving
  		it (e.g., when the debugger has stopped at a breakpoint).
  
  :sign place {id} name={name} buffer={nr}
  		Same, but use buffer {nr}.
  
  
  REMOVING SIGNS						*:sign-unplace* *E159*
  
  :sign unplace {id} file={fname}
  		Remove the previously placed sign {id} from file {fname}.
  		See remark above about {fname} |:sign-fname|.
  
  :sign unplace * file={fname}
  		Remove all placed signs in file {fname}.
  
  :sign unplace {id} buffer={nr}
  		Remove the previously placed sign {id} from buffer {nr}.
  
  :sign unplace * buffer={nr}
  		Remove all placed signs in buffer {nr}.
  
  :sign unplace {id}
  		Remove the previously placed sign {id} from all files it
  		appears in.
  
  :sign unplace *
! 		Remove all placed signs.
  
  :sign unplace
  		Remove the placed sign at the cursor position.
--- 188,260 ----
  		This can be used to change the displayed sign without moving
  		it (e.g., when the debugger has stopped at a breakpoint).
  
+ 		The optional "group={group}" attribute can be used before
+ 		"file=" to select a sign in a particular group.
+ 
  :sign place {id} name={name} buffer={nr}
  		Same, but use buffer {nr}.
  
  
  REMOVING SIGNS						*:sign-unplace* *E159*
  
+ See |sign_unplace()| for the equivalent Vim script function.
+ 
  :sign unplace {id} file={fname}
  		Remove the previously placed sign {id} from file {fname}.
  		See remark above about {fname} |:sign-fname|.
  
+ :sign unplace {id} group={group} file={fname}
+ 		Same but remove the sign {id} in sign group {group}.
+ 
+ :sign unplace {id} group=* file={fname}
+ 		Same but remove the sign {id} from all the sign groups.
+ 
  :sign unplace * file={fname}
  		Remove all placed signs in file {fname}.
  
+ :sign unplace * group={group} file={fname}
+ 		Remove all placed signs in group {group} from file {fname}.
+ 
+ :sign unplace * group=* file={fname}
+ 		Remove all placed signs in all the groups from file {fname}.
+ 
  :sign unplace {id} buffer={nr}
  		Remove the previously placed sign {id} from buffer {nr}.
  
+ :sign unplace {id} group={group} buffer={nr}
+ 		Remove the previously placed sign {id} in group {group} from
+ 		buffer {nr}.
+ 
+ :sign unplace {id} group=* buffer={nr}
+ 		Remove the previously placed sign {id} in all the groups from
+ 		buffer {nr}.
+ 
  :sign unplace * buffer={nr}
  		Remove all placed signs in buffer {nr}.
  
+ :sign unplace * group={group} buffer={nr}
+ 		Remove all placed signs in group {group} from buffer {nr}.
+ 
+ :sign unplace * group=* buffer={nr}
+ 		Remove all placed signs in all the groups from buffer {nr}.
+ 
  :sign unplace {id}
  		Remove the previously placed sign {id} from all files it
  		appears in.
  
+ :sign unplace {id} group={group}
+ 		Remove the previously placed sign {id} in group {group} from
+ 		all files it appears in.
+ 
+ :sign unplace {id} group=*
+ 		Remove the previously placed sign {id} in all the groups from
+ 		all the files it appears in.
+ 
  :sign unplace *
! 		Remove all placed signs in the global group.
! 
! :sign unplace * group=*
! 		Remove all placed signs in all the groups.
  
  :sign unplace
  		Remove the placed sign at the cursor position.
***************
*** 178,192 ****
--- 262,287 ----
  
  LISTING PLACED SIGNS					*:sign-place-list*
  
+ See |sign_getplaced()| for the equivalent Vim script function.
+ 
  :sign place file={fname}
  		List signs placed in file {fname}.
  		See remark above about {fname} |:sign-fname|.
  
+ :sign place group={group} file={fname}
+ 		List signs in group {group} placed in file {fname}.
+ 
  :sign place buffer={nr}
  		List signs placed in buffer {nr}.
  
+ :sign place group={group} buffer={nr}
+ 		List signs in group {group} placed in buffer {nr}.
+ 
  :sign place	List placed signs in all files.
  
+ :sign place group={group}
+ 		List placed signs in all sign groups in all the files.
+ 
  
  JUMPING TO A SIGN					*:sign-jump* *E157*
  
***************
*** 202,205 ****
  		have a name.
  
  
!  vim:tw=78:ts=8:ft=help:norl:
--- 297,300 ----
  		have a name.
  
  
!  vim:tw=78:ts=8:noet:ft=help:norl:
*** ../vim-8.1.0613/runtime/doc/usr_41.txt	2018-11-11 15:20:32.432704446 +0100
--- runtime/doc/usr_41.txt	2018-12-21 14:36:57.238303578 +0100
***************
*** 973,978 ****
--- 983,996 ----
  	job_info()		get information about a job
  	job_setoptions()	set options for a job
  
+ Signs:						*sign-functions*
+ 	sign_define()		define or update a sign
+ 	sign_getdefined()	get a list of defined signs
+ 	sign_getplaced()	get a list of placed signs
+ 	sign_place()		place a sign
+ 	sign_undefine()		undefine a sign
+ 	sign_unplace()		unplace a sign
+ 
  Terminal window:				*terminal-functions*
  	term_start()		open a terminal window and run a job
  	term_list()		get the list of terminal buffers
*** ../vim-8.1.0613/src/alloc.h	2018-11-11 15:20:32.432704446 +0100
--- src/alloc.h	2018-12-21 14:36:57.238303578 +0100
***************
*** 21,25 ****
--- 21,33 ----
  	aid_tagstack_items,
  	aid_tagstack_from,
  	aid_tagstack_details,
+ 	aid_sign_getdefined,
+ 	aid_sign_getplaced,
+ 	aid_sign_define_by_name,
+ 	aid_sign_getlist,
+ 	aid_sign_getplaced_dict,
+ 	aid_sign_getplaced_list,
+ 	aid_insert_sign,
+ 	aid_sign_getinfo,
  	aid_last
  } alloc_id_T;
*** ../vim-8.1.0613/src/buffer.c	2018-12-21 13:03:24.292337854 +0100
--- src/buffer.c	2018-12-21 14:54:24.453442611 +0100
***************
*** 936,942 ****
      uc_clear(&buf->b_ucmds);		/* clear local user commands */
  #endif
  #ifdef FEAT_SIGNS
!     buf_delete_signs(buf);		/* delete any signs */
  #endif
  #ifdef FEAT_NETBEANS_INTG
      netbeans_file_killed(buf);
--- 936,942 ----
      uc_clear(&buf->b_ucmds);		/* clear local user commands */
  #endif
  #ifdef FEAT_SIGNS
!     buf_delete_signs(buf, (char_u *)"*");	// delete any signs */
  #endif
  #ifdef FEAT_NETBEANS_INTG
      netbeans_file_killed(buf);
***************
*** 5866,5890 ****
  
  #if defined(FEAT_SIGNS) || defined(PROTO)
  /*
!  * Insert the sign into the signlist.
   */
      static void
  insert_sign(
!     buf_T	*buf,		/* buffer to store sign in */
!     signlist_T	*prev,		/* previous sign entry */
!     signlist_T	*next,		/* next sign entry */
!     int		id,		/* sign ID */
!     linenr_T	lnum,		/* line number which gets the mark */
!     int		typenr)		/* typenr of sign we are adding */
  {
      signlist_T	*newsign;
  
!     newsign = (signlist_T *)lalloc((long_u)sizeof(signlist_T), FALSE);
      if (newsign != NULL)
      {
  	newsign->id = id;
  	newsign->lnum = lnum;
  	newsign->typenr = typenr;
  	newsign->next = next;
  	newsign->prev = prev;
  	if (next != NULL)
--- 5866,5899 ----
  
  #if defined(FEAT_SIGNS) || defined(PROTO)
  /*
!  * Insert a new sign into the signlist for buffer 'buf' between the 'prev' and
!  * 'next' signs.
   */
      static void
  insert_sign(
!     buf_T	*buf,		// buffer to store sign in
!     signlist_T	*prev,		// previous sign entry
!     signlist_T	*next,		// next sign entry
!     int		id,		// sign ID
!     char_u	*group,		// sign group; NULL for global group
!     int		prio,		// sign priority
!     linenr_T	lnum,		// line number which gets the mark
!     int		typenr)		// typenr of sign we are adding
  {
      signlist_T	*newsign;
  
!     newsign = (signlist_T *)lalloc_id((long_u)sizeof(signlist_T), FALSE,
! 							aid_insert_sign);
      if (newsign != NULL)
      {
  	newsign->id = id;
  	newsign->lnum = lnum;
  	newsign->typenr = typenr;
+ 	if (group != NULL)
+ 	    newsign->group = vim_strsave(group);
+ 	else
+ 	    newsign->group = NULL;
+ 	newsign->priority = prio;
  	newsign->next = next;
  	newsign->prev = prev;
  	if (next != NULL)
***************
*** 5892,5906 ****
  
  	if (prev == NULL)
  	{
! 	    /* When adding first sign need to redraw the windows to create the
! 	     * column for signs. */
  	    if (buf->b_signlist == NULL)
  	    {
  		redraw_buf_later(buf, NOT_VALID);
  		changed_cline_bef_curs();
  	    }
  
! 	    /* first sign in signlist */
  	    buf->b_signlist = newsign;
  #ifdef FEAT_NETBEANS_INTG
  	    if (netbeans_active())
--- 5901,5915 ----
  
  	if (prev == NULL)
  	{
! 	    // When adding first sign need to redraw the windows to create the
! 	    // column for signs.
  	    if (buf->b_signlist == NULL)
  	    {
  		redraw_buf_later(buf, NOT_VALID);
  		changed_cline_bef_curs();
  	    }
  
! 	    // first sign in signlist
  	    buf->b_signlist = newsign;
  #ifdef FEAT_NETBEANS_INTG
  	    if (netbeans_active())
***************
*** 5913,5962 ****
  }
  
  /*
   * Add the sign into the signlist. Find the right spot to do it though.
   */
      void
  buf_addsign(
!     buf_T	*buf,		/* buffer to store sign in */
!     int		id,		/* sign ID */
!     linenr_T	lnum,		/* line number which gets the mark */
!     int		typenr)		/* typenr of sign we are adding */
  {
!     signlist_T	*sign;		/* a sign in the signlist */
!     signlist_T	*prev;		/* the previous sign */
  
      prev = NULL;
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
      {
! 	if (lnum == sign->lnum && id == sign->id)
  	{
  	    sign->typenr = typenr;
  	    return;
  	}
  	else if (lnum < sign->lnum)
  	{
! 	    // keep signs sorted by lnum: insert new sign at head of list for
! 	    // this lnum
! 	    while (prev != NULL && prev->lnum == lnum)
! 		prev = prev->prev;
! 	    if (prev == NULL)
! 		sign = buf->b_signlist;
! 	    else
! 		sign = prev->next;
! 	    insert_sign(buf, prev, sign, id, lnum, typenr);
  	    return;
  	}
  	prev = sign;
      }
  
!     // insert new sign at head of list for this lnum
!     while (prev != NULL && prev->lnum == lnum)
! 	prev = prev->prev;
!     if (prev == NULL)
! 	sign = buf->b_signlist;
!     else
! 	sign = prev->next;
!     insert_sign(buf, prev, sign, id, lnum, typenr);
  
      return;
  }
--- 5922,6021 ----
  }
  
  /*
+  * Insert a new sign sorted by line number and sign priority.
+  */
+     static void
+ insert_sign_by_lnum_prio(
+     buf_T	*buf,		// buffer to store sign in
+     signlist_T	*prev,		// previous sign entry
+     int		id,		// sign ID
+     char_u	*group,		// sign group; NULL for global group
+     int		prio,		// sign priority
+     linenr_T	lnum,		// line number which gets the mark
+     int		typenr)		// typenr of sign we are adding
+ {
+     signlist_T	*sign;
+ 
+     // keep signs sorted by lnum and by priority: insert new sign at
+     // the proper position in the list for this lnum.
+     while (prev != NULL && prev->lnum == lnum && prev->priority <= prio)
+ 	prev = prev->prev;
+     if (prev == NULL)
+ 	sign = buf->b_signlist;
+     else
+ 	sign = prev->next;
+ 
+     insert_sign(buf, prev, sign, id, group, prio, lnum, typenr);
+ }
+ 
+ /*
+  * Returns TRUE if 'sign' is in 'group'.
+  * A sign can either be in the global group (sign->group == NULL)
+  * or in a named group. If 'group' is '*', then the sign is part of the group.
+  */
+     int
+ sign_in_group(signlist_T *sign, char_u *group)
+ {
+     return ((group != NULL && STRCMP(group, "*") == 0) ||
+ 	    (group == NULL && sign->group == NULL) ||
+ 	    (group != NULL && sign->group != NULL &&
+ 					STRCMP(group, sign->group) == 0));
+ }
+ 
+ /*
+  * Return information about a sign in a Dict
+  */
+     dict_T *
+ sign_get_info(signlist_T *sign)
+ {
+     dict_T	*d;
+ 
+     if ((d = dict_alloc_id(aid_sign_getinfo)) == NULL)
+ 	return NULL;
+     dict_add_number(d, "id", sign->id);
+     dict_add_string(d, "group", (sign->group == NULL) ?
+ 						(char_u *)"" : sign->group);
+     dict_add_number(d, "lnum", sign->lnum);
+     dict_add_string(d, "name", sign_typenr2name(sign->typenr));
+     dict_add_number(d, "priority", sign->priority);
+ 
+     return d;
+ }
+ 
+ /*
   * Add the sign into the signlist. Find the right spot to do it though.
   */
      void
  buf_addsign(
!     buf_T	*buf,		// buffer to store sign in
!     int		id,		// sign ID
!     char_u	*group,		// sign group
!     int		prio,		// sign priority
!     linenr_T	lnum,		// line number which gets the mark
!     int		typenr)		// typenr of sign we are adding
  {
!     signlist_T	*sign;		// a sign in the signlist
!     signlist_T	*prev;		// the previous sign
  
      prev = NULL;
!     FOR_ALL_SIGNS_IN_BUF(buf)
      {
! 	if (lnum == sign->lnum && id == sign->id &&
! 		sign_in_group(sign, group))
  	{
+ 	    // Update an existing sign
  	    sign->typenr = typenr;
  	    return;
  	}
  	else if (lnum < sign->lnum)
  	{
! 	    insert_sign_by_lnum_prio(buf, prev, id, group, prio, lnum, typenr);
  	    return;
  	}
  	prev = sign;
      }
  
!     insert_sign_by_lnum_prio(buf, prev, id, group, prio, lnum, typenr);
  
      return;
  }
***************
*** 5967,5981 ****
   */
      linenr_T
  buf_change_sign_type(
!     buf_T	*buf,		/* buffer to store sign in */
!     int		markId,		/* sign ID */
!     int		typenr)		/* typenr of sign we are adding */
  {
!     signlist_T	*sign;		/* a sign in the signlist */
  
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
      {
! 	if (sign->id == markId)
  	{
  	    sign->typenr = typenr;
  	    return sign->lnum;
--- 6026,6041 ----
   */
      linenr_T
  buf_change_sign_type(
!     buf_T	*buf,		// buffer to store sign in
!     int		markId,		// sign ID
!     char_u	*group,		// sign group
!     int		typenr)		// typenr of sign we are adding
  {
!     signlist_T	*sign;		// a sign in the signlist
  
!     FOR_ALL_SIGNS_IN_BUF(buf)
      {
! 	if (sign->id == markId && sign_in_group(sign, group))
  	{
  	    sign->typenr = typenr;
  	    return sign->lnum;
***************
*** 5985,5990 ****
--- 6045,6055 ----
      return (linenr_T)0;
  }
  
+ /*
+  * Return the type number of the sign at line number 'lnum' in buffer 'buf'
+  * which has the attribute specifed by 'type'. Returns 0 if a sign is not found
+  * at the line number or it doesn't have the specified attribute.
+  */
      int
  buf_getsigntype(
      buf_T	*buf,
***************
*** 5993,5999 ****
  {
      signlist_T	*sign;		/* a sign in a b_signlist */
  
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
  	if (sign->lnum == lnum
  		&& (type == SIGN_ANY
  # ifdef FEAT_SIGN_ICONS
--- 6058,6064 ----
  {
      signlist_T	*sign;		/* a sign in a b_signlist */
  
!     FOR_ALL_SIGNS_IN_BUF(buf)
  	if (sign->lnum == lnum
  		&& (type == SIGN_ANY
  # ifdef FEAT_SIGN_ICONS
***************
*** 6008,6044 ****
      return 0;
  }
  
! 
      linenr_T
  buf_delsign(
!     buf_T	*buf,		/* buffer sign is stored in */
!     int		id)		/* sign id */
! {
!     signlist_T	**lastp;	/* pointer to pointer to current sign */
!     signlist_T	*sign;		/* a sign in a b_signlist */
!     signlist_T	*next;		/* the next sign in a b_signlist */
!     linenr_T	lnum;		/* line number whose sign was deleted */
  
      lastp = &buf->b_signlist;
      lnum = 0;
      for (sign = buf->b_signlist; sign != NULL; sign = next)
      {
  	next = sign->next;
! 	if (sign->id == id)
  	{
  	    *lastp = next;
  	    if (next != NULL)
  		next->prev = sign->prev;
  	    lnum = sign->lnum;
  	    vim_free(sign);
! 	    break;
  	}
  	else
  	    lastp = &sign->next;
      }
  
!     /* When deleted the last sign need to redraw the windows to remove the
!      * sign column. */
      if (buf->b_signlist == NULL)
      {
  	redraw_buf_later(buf, NOT_VALID);
--- 6073,6123 ----
      return 0;
  }
  
! /*
!  * Delete sign 'id' in group 'group' from buffer 'buf'.
!  * If 'id' is zero, then delete all the signs in group 'group'. Otherwise
!  * delete only the specified sign.
!  * If 'group' is '*', then delete the sign in all the groups. If 'group' is
!  * NULL, then delete the sign in the global group. Otherwise delete the sign in
!  * the specified group.
!  * Returns the line number of the deleted sign. If multiple signs are deleted,
!  * then returns the line number of the last sign deleted.
!  */
      linenr_T
  buf_delsign(
!     buf_T	*buf,		// buffer sign is stored in
!     int		id,		// sign id
!     char_u	*group)		// sign group
! {
!     signlist_T	**lastp;	// pointer to pointer to current sign
!     signlist_T	*sign;		// a sign in a b_signlist
!     signlist_T	*next;		// the next sign in a b_signlist
!     linenr_T	lnum;		// line number whose sign was deleted
  
      lastp = &buf->b_signlist;
      lnum = 0;
      for (sign = buf->b_signlist; sign != NULL; sign = next)
      {
  	next = sign->next;
! 	if ((id == 0 || sign->id == id) && sign_in_group(sign, group))
! 
  	{
  	    *lastp = next;
  	    if (next != NULL)
  		next->prev = sign->prev;
  	    lnum = sign->lnum;
+ 	    vim_free(sign->group);
  	    vim_free(sign);
! 	    // Check whether only one sign needs to be deleted
! 	    if (group == NULL || (*group != '*' && id != 0))
! 		break;
  	}
  	else
  	    lastp = &sign->next;
      }
  
!     // When deleted the last sign need to redraw the windows to remove the
!     // sign column.
      if (buf->b_signlist == NULL)
      {
  	redraw_buf_later(buf, NOT_VALID);
***************
*** 6050,6088 ****
  
  
  /*
!  * Find the line number of the sign with the requested id. If the sign does
!  * not exist, return 0 as the line number. This will still let the correct file
!  * get loaded.
   */
      int
  buf_findsign(
!     buf_T	*buf,		/* buffer to store sign in */
!     int		id)		/* sign ID */
  {
!     signlist_T	*sign;		/* a sign in the signlist */
  
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
! 	if (sign->id == id)
  	    return sign->lnum;
  
      return 0;
  }
  
      int
  buf_findsign_id(
!     buf_T	*buf,		/* buffer whose sign we are searching for */
!     linenr_T	lnum)		/* line number of sign */
  {
!     signlist_T	*sign;		/* a sign in the signlist */
  
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
! 	if (sign->lnum == lnum)
! 	    return sign->id;
  
      return 0;
  }
  
- 
  # if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
  /*
   * See if a given type of sign exists on a specific line.
--- 6129,6206 ----
  
  
  /*
!  * Find the line number of the sign with the requested id in group 'group'. If
!  * the sign does not exist, return 0 as the line number. This will still let
!  * the correct file get loaded.
   */
      int
  buf_findsign(
!     buf_T	*buf,		// buffer to store sign in
!     int		id,		// sign ID
!     char_u	*group)		// sign group
  {
!     signlist_T	*sign;		// a sign in the signlist
  
!     FOR_ALL_SIGNS_IN_BUF(buf)
! 	if (sign->id == id && sign_in_group(sign, group))
  	    return sign->lnum;
  
      return 0;
  }
  
+ /*
+  * Return the sign at line 'lnum' in buffer 'buf'. Returns NULL if a sign is
+  * not found at the line.
+  */
+     static signlist_T *
+ buf_getsign_at_line(
+     buf_T	*buf,		// buffer whose sign we are searching for
+     linenr_T	lnum)		// line number of sign
+ {
+     signlist_T	*sign;		// a sign in the signlist
+ 
+     FOR_ALL_SIGNS_IN_BUF(buf)
+ 	if (sign->lnum == lnum)
+ 	    return sign;
+ 
+     return NULL;
+ }
+ 
+ /*
+  * Return the sign with identifier 'id' in group 'group' placed in buffer 'buf'
+  */
+     signlist_T *
+ buf_getsign_with_id(
+     buf_T	*buf,		// buffer whose sign we are searching for
+     int		id,		// sign identifier
+     char_u	*group)		// sign group
+ {
+     signlist_T	*sign;		// a sign in the signlist
+ 
+     FOR_ALL_SIGNS_IN_BUF(buf)
+ 	if (sign->id == id && sign_in_group(sign, group))
+ 	    return sign;
+ 
+     return NULL;
+ }
+ 
+ /*
+  * Return the identifier of the sign at line number 'lnum' in buffer 'buf'.
+  */
      int
  buf_findsign_id(
!     buf_T	*buf,		// buffer whose sign we are searching for
!     linenr_T	lnum)		// line number of sign
  {
!     signlist_T	*sign;		// a sign in the signlist
  
!     sign = buf_getsign_at_line(buf, lnum);
!     if (sign != NULL)
! 	return sign->id;
  
      return 0;
  }
  
  # if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
  /*
   * See if a given type of sign exists on a specific line.
***************
*** 6095,6101 ****
  {
      signlist_T	*sign;		/* a sign in the signlist */
  
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
  	if (sign->lnum == lnum && sign->typenr == typenr)
  	    return sign->id;
  
--- 6213,6219 ----
  {
      signlist_T	*sign;		/* a sign in the signlist */
  
!     FOR_ALL_SIGNS_IN_BUF(buf)
  	if (sign->lnum == lnum && sign->typenr == typenr)
  	    return sign->id;
  
***************
*** 6110,6119 ****
      int
  buf_signcount(buf_T *buf, linenr_T lnum)
  {
!     signlist_T	*sign;		/* a sign in the signlist */
      int		count = 0;
  
!     for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
  	if (sign->lnum == lnum)
  	    if (sign_get_image(sign->typenr) != NULL)
  		count++;
--- 6228,6237 ----
      int
  buf_signcount(buf_T *buf, linenr_T lnum)
  {
!     signlist_T	*sign;		// a sign in the signlist
      int		count = 0;
  
!     FOR_ALL_SIGNS_IN_BUF(buf)
  	if (sign->lnum == lnum)
  	    if (sign_get_image(sign->typenr) != NULL)
  		count++;
***************
*** 6123,6150 ****
  #  endif /* FEAT_SIGN_ICONS */
  # endif /* FEAT_NETBEANS_INTG */
  
- 
  /*
!  * Delete signs in buffer "buf".
   */
      void
! buf_delete_signs(buf_T *buf)
  {
      signlist_T	*next;
  
!     /* When deleting the last sign need to redraw the windows to remove the
!      * sign column. Not when curwin is NULL (this means we're exiting). */
      if (buf->b_signlist != NULL && curwin != NULL)
      {
  	redraw_buf_later(buf, NOT_VALID);
  	changed_cline_bef_curs();
      }
  
!     while (buf->b_signlist != NULL)
      {
! 	next = buf->b_signlist->next;
! 	vim_free(buf->b_signlist);
! 	buf->b_signlist = next;
      }
  }
  
--- 6241,6279 ----
  #  endif /* FEAT_SIGN_ICONS */
  # endif /* FEAT_NETBEANS_INTG */
  
  /*
!  * Delete signs in group 'group' in buffer "buf". If 'group' is '*', then
!  * delete all the signs.
   */
      void
! buf_delete_signs(buf_T *buf, char_u *group)
  {
+     signlist_T	*sign;
+     signlist_T	**lastp;	// pointer to pointer to current sign
      signlist_T	*next;
  
!     // When deleting the last sign need to redraw the windows to remove the
!     // sign column. Not when curwin is NULL (this means we're exiting).
      if (buf->b_signlist != NULL && curwin != NULL)
      {
  	redraw_buf_later(buf, NOT_VALID);
  	changed_cline_bef_curs();
      }
  
!     lastp = &buf->b_signlist;
!     for (sign = buf->b_signlist; sign != NULL; sign = next)
      {
! 	next = sign->next;
! 	if (sign_in_group(sign, group))
! 	{
! 	    *lastp = next;
! 	    if (next != NULL)
! 		next->prev = sign->prev;
! 	    vim_free(sign->group);
! 	    vim_free(sign);
! 	}
! 	else
! 	    lastp = &sign->next;
      }
  }
  
***************
*** 6158,6175 ****
  
      FOR_ALL_BUFFERS(buf)
  	if (buf->b_signlist != NULL)
! 	    buf_delete_signs(buf);
  }
  
  /*
   * List placed signs for "rbuf".  If "rbuf" is NULL do it for all buffers.
   */
      void
! sign_list_placed(buf_T *rbuf)
  {
      buf_T	*buf;
!     signlist_T	*p;
      char	lbuf[BUFSIZ];
  
      MSG_PUTS_TITLE(_("\n--- Signs ---"));
      msg_putchar('\n');
--- 6287,6305 ----
  
      FOR_ALL_BUFFERS(buf)
  	if (buf->b_signlist != NULL)
! 	    buf_delete_signs(buf, (char_u *)"*");
  }
  
  /*
   * List placed signs for "rbuf".  If "rbuf" is NULL do it for all buffers.
   */
      void
! sign_list_placed(buf_T *rbuf, char_u *sign_group)
  {
      buf_T	*buf;
!     signlist_T	*sign;
      char	lbuf[BUFSIZ];
+     char	group[BUFSIZ];
  
      MSG_PUTS_TITLE(_("\n--- Signs ---"));
      msg_putchar('\n');
***************
*** 6185,6194 ****
  	    MSG_PUTS_ATTR(lbuf, HL_ATTR(HLF_D));
  	    msg_putchar('\n');
  	}
! 	for (p = buf->b_signlist; p != NULL && !got_int; p = p->next)
  	{
! 	    vim_snprintf(lbuf, BUFSIZ, _("    line=%ld  id=%d  name=%s"),
! 			   (long)p->lnum, p->id, sign_typenr2name(p->typenr));
  	    MSG_PUTS(lbuf);
  	    msg_putchar('\n');
  	}
--- 6315,6332 ----
  	    MSG_PUTS_ATTR(lbuf, HL_ATTR(HLF_D));
  	    msg_putchar('\n');
  	}
! 	FOR_ALL_SIGNS_IN_BUF(buf)
  	{
! 	    if (!sign_in_group(sign, sign_group))
! 		continue;
! 	    if (sign->group != NULL)
! 		vim_snprintf(group, BUFSIZ, "  group=%s", sign->group);
! 	    else
! 		group[0] = '\0';
! 	    vim_snprintf(lbuf, BUFSIZ, _("    line=%ld  id=%d%s  name=%s "
! 							"priority=%d"),
! 			   (long)sign->lnum, sign->id, group,
! 			   sign_typenr2name(sign->typenr), sign->priority);
  	    MSG_PUTS(lbuf);
  	    msg_putchar('\n');
  	}
***************
*** 6210,6216 ****
  {
      signlist_T	*sign;		/* a sign in a b_signlist */
  
!     for (sign = curbuf->b_signlist; sign != NULL; sign = sign->next)
      {
  	if (sign->lnum >= line1 && sign->lnum <= line2)
  	{
--- 6348,6354 ----
  {
      signlist_T	*sign;		/* a sign in a b_signlist */
  
!     FOR_ALL_SIGNS_IN_BUF(curbuf)
      {
  	if (sign->lnum >= line1 && sign->lnum <= line2)
  	{
*** ../vim-8.1.0613/src/evalfunc.c	2018-12-14 15:38:28.327597664 +0100
--- src/evalfunc.c	2018-12-21 14:36:57.242303552 +0100
***************
*** 367,372 ****
--- 367,380 ----
  #endif /* FEAT_CRYPT */
  static void f_shellescape(typval_T *argvars, typval_T *rettv);
  static void f_shiftwidth(typval_T *argvars, typval_T *rettv);
+ #ifdef FEAT_SIGNS
+ static void f_sign_define(typval_T *argvars, typval_T *rettv);
+ static void f_sign_getdefined(typval_T *argvars, typval_T *rettv);
+ static void f_sign_getplaced(typval_T *argvars, typval_T *rettv);
+ static void f_sign_place(typval_T *argvars, typval_T *rettv);
+ static void f_sign_undefine(typval_T *argvars, typval_T *rettv);
+ static void f_sign_unplace(typval_T *argvars, typval_T *rettv);
+ #endif
  static void f_simplify(typval_T *argvars, typval_T *rettv);
  #ifdef FEAT_FLOAT
  static void f_sin(typval_T *argvars, typval_T *rettv);
***************
*** 847,852 ****
--- 855,868 ----
  #endif
      {"shellescape",	1, 2, f_shellescape},
      {"shiftwidth",	0, 1, f_shiftwidth},
+ #ifdef FEAT_SIGNS
+     {"sign_define",	1, 2, f_sign_define},
+     {"sign_getdefined",	0, 1, f_sign_getdefined},
+     {"sign_getplaced",	0, 2, f_sign_getplaced},
+     {"sign_place",	4, 5, f_sign_place},
+     {"sign_undefine",	0, 1, f_sign_undefine},
+     {"sign_unplace",	1, 2, f_sign_unplace},
+ #endif
      {"simplify",	1, 1, f_simplify},
  #ifdef FEAT_FLOAT
      {"sin",		1, 1, f_sin},
***************
*** 4417,4435 ****
  get_buffer_signs(buf_T *buf, list_T *l)
  {
      signlist_T	*sign;
  
!     for (sign = buf->b_signlist; sign; sign = sign->next)
      {
! 	dict_T *d = dict_alloc();
! 
! 	if (d != NULL)
! 	{
! 	    dict_add_number(d, "id", sign->id);
! 	    dict_add_number(d, "lnum", sign->lnum);
! 	    dict_add_string(d, "name", sign_typenr2name(sign->typenr));
! 
  	    list_append_dict(l, d);
- 	}
      }
  }
  #endif
--- 4433,4444 ----
  get_buffer_signs(buf_T *buf, list_T *l)
  {
      signlist_T	*sign;
+     dict_T	*d;
  
!     FOR_ALL_SIGNS_IN_BUF(buf)
      {
! 	if ((d = sign_get_info(sign)) != NULL)
  	    list_append_dict(l, d);
      }
  }
  #endif
***************
*** 11285,11290 ****
--- 11294,11612 ----
      rettv->vval.v_number = get_sw_value(curbuf);
  }
  
+ #ifdef FEAT_SIGNS
+ /*
+  * "sign_define()" function
+  */
+     static void
+ f_sign_define(typval_T *argvars, typval_T *rettv)
+ {
+     char_u	*name;
+     dict_T	*dict;
+     char_u	*icon = NULL;
+     char_u	*linehl = NULL;
+     char_u	*text = NULL;
+     char_u	*texthl = NULL;
+ 
+     rettv->vval.v_number = -1;
+ 
+     name = get_tv_string_chk(&argvars[0]);
+     if (name == NULL)
+ 	return;
+ 
+     if (argvars[1].v_type != VAR_UNKNOWN)
+     {
+ 	if (argvars[1].v_type != VAR_DICT)
+ 	{
+ 	    EMSG(_(e_dictreq));
+ 	    return;
+ 	}
+ 
+ 	// sign attributes
+ 	dict = argvars[1].vval.v_dict;
+ 	if (dict_find(dict, (char_u *)"icon", -1) != NULL)
+ 	    icon = dict_get_string(dict, (char_u *)"icon", TRUE);
+ 	if (dict_find(dict, (char_u *)"linehl", -1) != NULL)
+ 	    linehl = dict_get_string(dict, (char_u *)"linehl", TRUE);
+ 	if (dict_find(dict, (char_u *)"text", -1) != NULL)
+ 	    text = dict_get_string(dict, (char_u *)"text", TRUE);
+ 	if (dict_find(dict, (char_u *)"texthl", -1) != NULL)
+ 	    texthl = dict_get_string(dict, (char_u *)"texthl", TRUE);
+     }
+ 
+     if (sign_define_by_name(name, icon, linehl, text, texthl) == OK)
+ 	rettv->vval.v_number = 0;
+ 
+     vim_free(icon);
+     vim_free(linehl);
+     vim_free(text);
+     vim_free(texthl);
+ }
+ 
+ /*
+  * "sign_getdefined()" function
+  */
+     static void
+ f_sign_getdefined(typval_T *argvars, typval_T *rettv)
+ {
+     char_u	*name = NULL;
+ 
+     if (rettv_list_alloc_id(rettv, aid_sign_getdefined) != OK)
+ 	return;
+ 
+     if (argvars[0].v_type != VAR_UNKNOWN)
+ 	name = get_tv_string(&argvars[0]);
+ 
+     sign_getlist(name, rettv->vval.v_list);
+ }
+ 
+ /*
+  * "sign_getplaced()" function
+  */
+     static void
+ f_sign_getplaced(typval_T *argvars, typval_T *rettv)
+ {
+     buf_T	*buf = NULL;
+     dict_T	*dict;
+     dictitem_T	*di;
+     linenr_T	lnum = 0;
+     int		sign_id = 0;
+     char_u	*group = NULL;
+     int		notanum = FALSE;
+ 
+     if (rettv_list_alloc_id(rettv, aid_sign_getplaced) != OK)
+ 	return;
+ 
+     if (argvars[0].v_type != VAR_UNKNOWN)
+     {
+ 	// get signs placed in this buffer
+ 	buf = find_buffer(&argvars[0]);
+ 	if (buf == NULL)
+ 	{
+ 	    EMSG2(_("E158: Invalid buffer name: %s"),
+ 						get_tv_string(&argvars[0]));
+ 	    return;
+ 	}
+ 
+ 	if (argvars[1].v_type != VAR_UNKNOWN)
+ 	{
+ 	    if (argvars[1].v_type != VAR_DICT ||
+ 				((dict = argvars[1].vval.v_dict) == NULL))
+ 	    {
+ 		EMSG(_(e_dictreq));
+ 		return;
+ 	    }
+ 	    if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
+ 	    {
+ 		// get signs placed at this line
+ 		(void)get_tv_number_chk(&di->di_tv, &notanum);
+ 		if (notanum)
+ 		    return;
+ 		lnum = get_tv_lnum(&di->di_tv);
+ 	    }
+ 	    if ((di = dict_find(dict, (char_u *)"id", -1)) != NULL)
+ 	    {
+ 		// get sign placed with this identifier
+ 		sign_id = (int)get_tv_number_chk(&di->di_tv, &notanum);
+ 		if (notanum)
+ 		    return;
+ 	    }
+ 	    if ((di = dict_find(dict, (char_u *)"group", -1)) != NULL)
+ 	    {
+ 		group = get_tv_string_chk(&di->di_tv);
+ 		if (group == NULL)
+ 		    return;
+ 	    }
+ 	}
+     }
+ 
+     sign_get_placed(buf, lnum, sign_id, group, rettv->vval.v_list);
+ }
+ 
+ /*
+  * "sign_place()" function
+  */
+     static void
+ f_sign_place(typval_T *argvars, typval_T *rettv)
+ {
+     int		sign_id;
+     char_u	*group = NULL;
+     char_u	*sign_name;
+     buf_T	*buf;
+     dict_T	*dict;
+     dictitem_T	*di;
+     linenr_T	lnum = 0;
+     int		prio = SIGN_DEF_PRIO;
+     int		notanum = FALSE;
+ 
+     rettv->vval.v_number = -1;
+ 
+     // Sign identifer
+     sign_id = (int)get_tv_number_chk(&argvars[0], &notanum);
+     if (notanum)
+ 	return;
+     if (sign_id < 0)
+     {
+ 	EMSG(_(e_invarg));
+ 	return;
+     }
+ 
+     // Sign group
+     group = get_tv_string_chk(&argvars[1]);
+     if (group == NULL)
+ 	return;
+     if (group[0] == '\0')
+ 	group = NULL;			// global sign group
+     else
+     {
+ 	group = vim_strsave(group);
+ 	if (group == NULL)
+ 	    return;
+     }
+ 
+     // Sign name
+     sign_name = get_tv_string_chk(&argvars[2]);
+     if (sign_name == NULL)
+ 	goto cleanup;
+ 
+     // Buffer to place the sign
+     buf = find_buffer(&argvars[3]);
+     if (buf == NULL)
+     {
+ 	EMSG2(_("E158: Invalid buffer name: %s"), get_tv_string(&argvars[2]));
+ 	goto cleanup;
+     }
+ 
+     if (argvars[4].v_type != VAR_UNKNOWN)
+     {
+ 	if (argvars[4].v_type != VAR_DICT ||
+ 				((dict = argvars[4].vval.v_dict) == NULL))
+ 	{
+ 	    EMSG(_(e_dictreq));
+ 	    goto cleanup;
+ 	}
+ 
+ 	// Line number where the sign is to be placed
+ 	if ((di = dict_find(dict, (char_u *)"lnum", -1)) != NULL)
+ 	{
+ 	    (void)get_tv_number_chk(&di->di_tv, &notanum);
+ 	    if (notanum)
+ 		goto cleanup;
+ 	    lnum = get_tv_lnum(&di->di_tv);
+ 	}
+ 	if ((di = dict_find(dict, (char_u *)"priority", -1)) != NULL)
+ 	{
+ 	    // Sign priority
+ 	    prio = (int)get_tv_number_chk(&di->di_tv, &notanum);
+ 	    if (notanum)
+ 		goto cleanup;
+ 	}
+     }
+ 
+     if (sign_place(&sign_id, group, sign_name, buf, lnum, prio) == OK)
+ 	rettv->vval.v_number = sign_id;
+ 
+ cleanup:
+     vim_free(group);
+ }
+ 
+ /*
+  * "sign_undefine()" function
+  */
+     static void
+ f_sign_undefine(typval_T *argvars, typval_T *rettv)
+ {
+     char_u *name;
+ 
+     rettv->vval.v_number = -1;
+ 
+     if (argvars[0].v_type == VAR_UNKNOWN)
+     {
+ 	// Free all the signs
+ 	free_signs();
+ 	rettv->vval.v_number = 0;
+     }
+     else
+     {
+ 	// Free only the specified sign
+ 	name = get_tv_string_chk(&argvars[0]);
+ 	if (name == NULL)
+ 	    return;
+ 
+ 	if (sign_undefine_by_name(name) == OK)
+ 	    rettv->vval.v_number = 0;
+     }
+ }
+ 
+ /*
+  * "sign_unplace()" function
+  */
+     static void
+ f_sign_unplace(typval_T *argvars, typval_T *rettv)
+ {
+     dict_T	*dict;
+     dictitem_T	*di;
+     int		sign_id = 0;
+     buf_T	*buf = NULL;
+     char_u	*group = NULL;
+ 
+     rettv->vval.v_number = -1;
+ 
+     if (argvars[0].v_type != VAR_STRING)
+     {
+ 	EMSG(_(e_invarg));
+ 	return;
+     }
+ 
+     group = get_tv_string(&argvars[0]);
+     if (group[0] == '\0')
+ 	group = NULL;			// global sign group
+     else
+     {
+ 	group = vim_strsave(group);
+ 	if (group == NULL)
+ 	    return;
+     }
+ 
+     if (argvars[1].v_type != VAR_UNKNOWN)
+     {
+ 	if (argvars[1].v_type != VAR_DICT)
+ 	{
+ 	    EMSG(_(e_dictreq));
+ 	    return;
+ 	}
+ 	dict = argvars[1].vval.v_dict;
+ 
+ 	if ((di = dict_find(dict, (char_u *)"buffer", -1)) != NULL)
+ 	{
+ 	    buf = find_buffer(&di->di_tv);
+ 	    if (buf == NULL)
+ 	    {
+ 		EMSG2(_("E158: Invalid buffer name: %s"),
+ 						get_tv_string(&di->di_tv));
+ 		return;
+ 	    }
+ 	}
+ 	if (dict_find(dict, (char_u *)"id", -1) != NULL)
+ 	    sign_id = dict_get_number(dict, (char_u *)"id");
+     }
+ 
+     if (buf == NULL)
+     {
+ 	// Delete the sign in all the buffers
+ 	FOR_ALL_BUFFERS(buf)
+ 	    if (sign_unplace(sign_id, group, buf) == OK)
+ 		rettv->vval.v_number = 0;
+     }
+     else
+     {
+ 	if (sign_unplace(sign_id, group, buf) == OK)
+ 	    rettv->vval.v_number = 0;
+     }
+     vim_free(group);
+ }
+ #endif
+ 
  /*
   * "simplify()" function
   */
*** ../vim-8.1.0613/src/ex_cmds.c	2018-12-14 19:37:03.677899412 +0100
--- src/ex_cmds.c	2018-12-21 14:36:57.242303552 +0100
***************
*** 7644,7649 ****
--- 7644,7932 ----
  }
  
  /*
+  * Find a sign by name. Also returns pointer to the previous sign.
+  */
+     static sign_T *
+ sign_find(char_u *name, sign_T **sp_prev)
+ {
+     sign_T *sp;
+ 
+     if (sp_prev != NULL)
+ 	*sp_prev = NULL;
+     for (sp = first_sign; sp != NULL; sp = sp->sn_next)
+     {
+ 	if (STRCMP(sp->sn_name, name) == 0)
+ 	    break;
+ 	if (sp_prev != NULL)
+ 	    *sp_prev = sp;
+     }
+ 
+     return sp;
+ }
+ 
+ /*
+  * Define a new sign or update an existing sign
+  */
+     int
+ sign_define_by_name(
+ 	char_u	*name,
+ 	char_u	*icon,
+ 	char_u	*linehl,
+ 	char_u	*text,
+ 	char_u	*texthl)
+ {
+     sign_T	*sp_prev;
+     sign_T	*sp;
+ 
+     sp = sign_find(name, &sp_prev);
+     if (sp == NULL)
+     {
+ 	sign_T	*lp;
+ 	int	start = next_sign_typenr;
+ 
+ 	// Allocate a new sign.
+ 	sp = (sign_T *)alloc_clear_id((unsigned)sizeof(sign_T),
+ 						aid_sign_define_by_name);
+ 	if (sp == NULL)
+ 	    return FAIL;
+ 
+ 	// Check that next_sign_typenr is not already being used.
+ 	// This only happens after wrapping around.  Hopefully
+ 	// another one got deleted and we can use its number.
+ 	for (lp = first_sign; lp != NULL; )
+ 	{
+ 	    if (lp->sn_typenr == next_sign_typenr)
+ 	    {
+ 		++next_sign_typenr;
+ 		if (next_sign_typenr == MAX_TYPENR)
+ 		    next_sign_typenr = 1;
+ 		if (next_sign_typenr == start)
+ 		{
+ 		    vim_free(sp);
+ 		    EMSG(_("E612: Too many signs defined"));
+ 		    return FAIL;
+ 		}
+ 		lp = first_sign;  // start all over
+ 		continue;
+ 	    }
+ 	    lp = lp->sn_next;
+ 	}
+ 
+ 	sp->sn_typenr = next_sign_typenr;
+ 	if (++next_sign_typenr == MAX_TYPENR)
+ 	    next_sign_typenr = 1; // wrap around
+ 
+ 	sp->sn_name = vim_strsave(name);
+ 	if (sp->sn_name == NULL)  // out of memory
+ 	{
+ 	    vim_free(sp);
+ 	    return FAIL;
+ 	}
+ 
+ 	// add the new sign to the list of signs
+ 	if (sp_prev == NULL)
+ 	    first_sign = sp;
+ 	else
+ 	    sp_prev->sn_next = sp;
+     }
+ 
+     // set values for a defined sign.
+     if (icon != NULL)
+     {
+ 	vim_free(sp->sn_icon);
+ 	sp->sn_icon = vim_strsave(icon);
+ 	backslash_halve(sp->sn_icon);
+ # ifdef FEAT_SIGN_ICONS
+ 	if (gui.in_use)
+ 	{
+ 	    out_flush();
+ 	    if (sp->sn_image != NULL)
+ 		gui_mch_destroy_sign(sp->sn_image);
+ 	    sp->sn_image = gui_mch_register_sign(sp->sn_icon);
+ 	}
+ # endif
+     }
+ 
+     if (text != NULL)
+     {
+ 	char_u	*s;
+ 	char_u	*endp;
+ 	int	cells;
+ 	int	len;
+ 
+ 	endp = text + (int)STRLEN(text);
+ 	for (s = text; s + 1 < endp; ++s)
+ 	    if (*s == '\\')
+ 	    {
+ 		// Remove a backslash, so that it is possible
+ 		// to use a space.
+ 		STRMOVE(s, s + 1);
+ 		--endp;
+ 	    }
+ # ifdef FEAT_MBYTE
+ 	// Count cells and check for non-printable chars
+ 	if (has_mbyte)
+ 	{
+ 	    cells = 0;
+ 	    for (s = text; s < endp; s += (*mb_ptr2len)(s))
+ 	    {
+ 		if (!vim_isprintc((*mb_ptr2char)(s)))
+ 		    break;
+ 		cells += (*mb_ptr2cells)(s);
+ 	    }
+ 	}
+ 	else
+ # endif
+ 	{
+ 	    for (s = text; s < endp; ++s)
+ 		if (!vim_isprintc(*s))
+ 		    break;
+ 	    cells = (int)(s - text);
+ 	}
+ 	// Currently must be one or two display cells
+ 	if (s != endp || cells < 1 || cells > 2)
+ 	{
+ 	    EMSG2(_("E239: Invalid sign text: %s"), text);
+ 	    return FAIL;
+ 	}
+ 
+ 	vim_free(sp->sn_text);
+ 	// Allocate one byte more if we need to pad up
+ 	// with a space.
+ 	len = (int)(endp - text + ((cells == 1) ? 1 : 0));
+ 	sp->sn_text = vim_strnsave(text, len);
+ 
+ 	if (sp->sn_text != NULL && cells == 1)
+ 	    STRCPY(sp->sn_text + len - 1, " ");
+     }
+ 
+     if (linehl != NULL)
+ 	sp->sn_line_hl = syn_check_group(linehl, (int)STRLEN(linehl));
+ 
+     if (texthl != NULL)
+ 	sp->sn_text_hl = syn_check_group(texthl, (int)STRLEN(texthl));
+ 
+     return OK;
+ }
+ 
+ /*
+  * Free the sign specified by 'name'.
+  */
+     int
+ sign_undefine_by_name(char_u *name)
+ {
+     sign_T	*sp_prev;
+     sign_T	*sp;
+ 
+     sp = sign_find(name, &sp_prev);
+     if (sp == NULL)
+     {
+ 	EMSG2(_("E155: Unknown sign: %s"), name);
+ 	return FAIL;
+     }
+     sign_undefine(sp, sp_prev);
+ 
+     return OK;
+ }
+ 
+ /*
+  * List the signs matching 'name'
+  */
+     static void
+ sign_list_by_name(char_u *name)
+ {
+     sign_T	*sp;
+ 
+     sp = sign_find(name, NULL);
+     if (sp != NULL)
+ 	sign_list_defined(sp);
+     else
+ 	EMSG2(_("E155: Unknown sign: %s"), name);
+ }
+ 
+ /*
+  * Place a sign at the specifed file location or update a sign.
+  */
+     int
+ sign_place(
+ 	int		*sign_id,
+ 	char_u		*sign_group,
+ 	char_u		*sign_name,
+ 	buf_T		*buf,
+ 	linenr_T	lnum,
+ 	int		prio)
+ {
+     sign_T	*sp;
+ 
+     // Check for reserved character '*' in group name
+     if (sign_group != NULL && (*sign_group == '*' || *sign_group == '\0'))
+ 	return FAIL;
+ 
+     for (sp = first_sign; sp != NULL; sp = sp->sn_next)
+ 	if (STRCMP(sp->sn_name, sign_name) == 0)
+ 	    break;
+     if (sp == NULL)
+     {
+ 	EMSG2(_("E155: Unknown sign: %s"), sign_name);
+ 	return FAIL;
+     }
+     if (*sign_id == 0)
+     {
+ 	// Allocate a new sign id
+ 	int		id = 1;
+ 	signlist_T	*sign;
+ 
+ 	while ((sign = buf_getsign_with_id(buf, id, sign_group)) != NULL)
+ 	    id++;
+ 
+ 	*sign_id = id;
+     }
+ 
+     if (lnum > 0)
+ 	// ":sign place {id} line={lnum} name={name} file={fname}":
+ 	// place a sign
+ 	buf_addsign(buf, *sign_id, sign_group, prio, lnum, sp->sn_typenr);
+     else
+ 	// ":sign place {id} file={fname}": change sign type
+ 	lnum = buf_change_sign_type(buf, *sign_id, sign_group, sp->sn_typenr);
+     if (lnum > 0)
+ 	update_debug_sign(buf, lnum);
+     else
+     {
+ 	EMSG2(_("E885: Not possible to change sign %s"), sign_name);
+ 	return FAIL;
+     }
+ 
+     return OK;
+ }
+ 
+ /*
+  * Unplace the specified sign
+  */
+     int
+ sign_unplace(int sign_id, char_u *sign_group, buf_T *buf)
+ {
+     if (sign_id == 0)
+     {
+ 	// Delete all the signs in the specified buffer
+ 	redraw_buf_later(buf, NOT_VALID);
+ 	buf_delete_signs(buf, sign_group);
+     }
+     else
+     {
+ 	linenr_T	lnum;
+ 
+ 	// Delete only the specified signs
+ 	lnum = buf_delsign(buf, sign_id, sign_group);
+ 	if (lnum == 0)
+ 	    return FAIL;
+ 	update_debug_sign(buf, lnum);
+     }
+ 
+     return OK;
+ }
+ 
+ /*
   * ":sign" command
   */
      void
***************
*** 7653,7659 ****
      char_u	*p;
      int		idx;
      sign_T	*sp;
-     sign_T	*sp_prev;
      buf_T	*buf = NULL;
  
      /* Parse the subcommand. */
--- 7936,7941 ----
***************
*** 7681,7686 ****
--- 7963,7974 ----
  	    EMSG(_("E156: Missing sign name"));
  	else
  	{
+ 	    char_u	*name;
+ 	    char_u	*icon = NULL;
+ 	    char_u	*text = NULL;
+ 	    char_u	*linehl = NULL;
+ 	    char_u	*texthl = NULL;
+ 
  	    /* Isolate the sign name.  If it's a number skip leading zeroes,
  	     * so that "099" and "99" are the same sign.  But keep "0". */
  	    p = skiptowhite(arg);
***************
*** 7688,7753 ****
  		*p++ = NUL;
  	    while (arg[0] == '0' && arg[1] != NUL)
  		++arg;
  
- 	    sp_prev = NULL;
- 	    for (sp = first_sign; sp != NULL; sp = sp->sn_next)
- 	    {
- 		if (STRCMP(sp->sn_name, arg) == 0)
- 		    break;
- 		sp_prev = sp;
- 	    }
  	    if (idx == SIGNCMD_DEFINE)
  	    {
! 		/* ":sign define {name} ...": define a sign */
! 		if (sp == NULL)
! 		{
! 		    sign_T	*lp;
! 		    int		start = next_sign_typenr;
! 
! 		    /* Allocate a new sign. */
! 		    sp = (sign_T *)alloc_clear((unsigned)sizeof(sign_T));
! 		    if (sp == NULL)
! 			return;
! 
! 		    /* Check that next_sign_typenr is not already being used.
! 		     * This only happens after wrapping around.  Hopefully
! 		     * another one got deleted and we can use its number. */
! 		    for (lp = first_sign; lp != NULL; )
! 		    {
! 			if (lp->sn_typenr == next_sign_typenr)
! 			{
! 			    ++next_sign_typenr;
! 			    if (next_sign_typenr == MAX_TYPENR)
! 				next_sign_typenr = 1;
! 			    if (next_sign_typenr == start)
! 			    {
! 				vim_free(sp);
! 				EMSG(_("E612: Too many signs defined"));
! 				return;
! 			    }
! 			    lp = first_sign;  /* start all over */
! 			    continue;
! 			}
! 			lp = lp->sn_next;
! 		    }
! 
! 		    sp->sn_typenr = next_sign_typenr;
! 		    if (++next_sign_typenr == MAX_TYPENR)
! 			next_sign_typenr = 1; /* wrap around */
! 
! 		    sp->sn_name = vim_strsave(arg);
! 		    if (sp->sn_name == NULL)  /* out of memory */
! 		    {
! 			vim_free(sp);
! 			return;
! 		    }
  
! 		    /* add the new sign to the list of signs */
! 		    if (sp_prev == NULL)
! 			first_sign = sp;
! 		    else
! 			sp_prev->sn_next = sp;
! 		}
  
  		/* set values for a defined sign. */
  		for (;;)
--- 7976,7988 ----
  		*p++ = NUL;
  	    while (arg[0] == '0' && arg[1] != NUL)
  		++arg;
+ 	    name = vim_strsave(arg);
  
  	    if (idx == SIGNCMD_DEFINE)
  	    {
! 		int failed = FALSE;
  
! 		/* ":sign define {name} ...": define a sign */
  
  		/* set values for a defined sign. */
  		for (;;)
***************
*** 7759,7854 ****
  		    if (STRNCMP(arg, "icon=", 5) == 0)
  		    {
  			arg += 5;
! 			vim_free(sp->sn_icon);
! 			sp->sn_icon = vim_strnsave(arg, (int)(p - arg));
! 			backslash_halve(sp->sn_icon);
! # ifdef FEAT_SIGN_ICONS
! 			if (gui.in_use)
! 			{
! 			    out_flush();
! 			    if (sp->sn_image != NULL)
! 				gui_mch_destroy_sign(sp->sn_image);
! 			    sp->sn_image = gui_mch_register_sign(sp->sn_icon);
! 			}
! # endif
  		    }
  		    else if (STRNCMP(arg, "text=", 5) == 0)
  		    {
- 			char_u	*s;
- 			int	cells;
- 			int	len;
- 
  			arg += 5;
! 			for (s = arg; s + 1 < p; ++s)
! 			    if (*s == '\\')
! 			    {
! 				// Remove a backslash, so that it is possible
! 				// to use a space.
! 				STRMOVE(s, s + 1);
! 				--p;
! 			    }
! # ifdef FEAT_MBYTE
! 			/* Count cells and check for non-printable chars */
! 			if (has_mbyte)
! 			{
! 			    cells = 0;
! 			    for (s = arg; s < p; s += (*mb_ptr2len)(s))
! 			    {
! 				if (!vim_isprintc((*mb_ptr2char)(s)))
! 				    break;
! 				cells += (*mb_ptr2cells)(s);
! 			    }
! 			}
! 			else
! # endif
! 			{
! 			    for (s = arg; s < p; ++s)
! 				if (!vim_isprintc(*s))
! 				    break;
! 			    cells = (int)(s - arg);
! 			}
! 			/* Currently must be one or two display cells */
! 			if (s != p || cells < 1 || cells > 2)
! 			{
! 			    *p = NUL;
! 			    EMSG2(_("E239: Invalid sign text: %s"), arg);
! 			    return;
! 			}
! 
! 			vim_free(sp->sn_text);
! 			/* Allocate one byte more if we need to pad up
! 			 * with a space. */
! 			len = (int)(p - arg + ((cells == 1) ? 1 : 0));
! 			sp->sn_text = vim_strnsave(arg, len);
! 
! 			if (sp->sn_text != NULL && cells == 1)
! 			    STRCPY(sp->sn_text + len - 1, " ");
  		    }
  		    else if (STRNCMP(arg, "linehl=", 7) == 0)
  		    {
  			arg += 7;
! 			sp->sn_line_hl = syn_check_group(arg, (int)(p - arg));
  		    }
  		    else if (STRNCMP(arg, "texthl=", 7) == 0)
  		    {
  			arg += 7;
! 			sp->sn_text_hl = syn_check_group(arg, (int)(p - arg));
  		    }
  		    else
  		    {
  			EMSG2(_(e_invarg2), arg);
! 			return;
  		    }
  		}
  	    }
- 	    else if (sp == NULL)
- 		EMSG2(_("E155: Unknown sign: %s"), arg);
  	    else if (idx == SIGNCMD_LIST)
  		/* ":sign list {name}" */
! 		sign_list_defined(sp);
  	    else
  		/* ":sign undefine {name}" */
! 		sign_undefine(sp, sp_prev);
  	}
      }
      else
--- 7994,8041 ----
  		    if (STRNCMP(arg, "icon=", 5) == 0)
  		    {
  			arg += 5;
! 			icon = vim_strnsave(arg, (int)(p - arg));
  		    }
  		    else if (STRNCMP(arg, "text=", 5) == 0)
  		    {
  			arg += 5;
! 			text = vim_strnsave(arg, (int)(p - arg));
  		    }
  		    else if (STRNCMP(arg, "linehl=", 7) == 0)
  		    {
  			arg += 7;
! 			linehl = vim_strnsave(arg, (int)(p - arg));
  		    }
  		    else if (STRNCMP(arg, "texthl=", 7) == 0)
  		    {
  			arg += 7;
! 			texthl = vim_strnsave(arg, (int)(p - arg));
  		    }
  		    else
  		    {
  			EMSG2(_(e_invarg2), arg);
! 			failed = TRUE;
! 			break;
  		    }
  		}
+ 
+ 		if (!failed)
+ 		    sign_define_by_name(name, icon, linehl, text, texthl);
+ 
+ 		vim_free(icon);
+ 		vim_free(text);
+ 		vim_free(linehl);
+ 		vim_free(texthl);
  	    }
  	    else if (idx == SIGNCMD_LIST)
  		/* ":sign list {name}" */
! 		sign_list_by_name(name);
  	    else
  		/* ":sign undefine {name}" */
! 		sign_undefine_by_name(name);
! 
! 	    vim_free(name);
! 	    return;
  	}
      }
      else
***************
*** 7856,7879 ****
  	int		id = -1;
  	linenr_T	lnum = -1;
  	char_u		*sign_name = NULL;
  	char_u		*arg1;
  
  	if (*arg == NUL)
  	{
  	    if (idx == SIGNCMD_PLACE)
  	    {
  		/* ":sign place": list placed signs in all buffers */
! 		sign_list_placed(NULL);
  	    }
  	    else if (idx == SIGNCMD_UNPLACE)
  	    {
  		/* ":sign unplace": remove placed sign at cursor */
  		id = buf_findsign_id(curwin->w_buffer, curwin->w_cursor.lnum);
  		if (id > 0)
! 		{
! 		    buf_delsign(curwin->w_buffer, id);
! 		    update_debug_sign(curwin->w_buffer, curwin->w_cursor.lnum);
! 		}
  		else
  		    EMSG(_("E159: Missing sign number"));
  	    }
--- 8043,8066 ----
  	int		id = -1;
  	linenr_T	lnum = -1;
  	char_u		*sign_name = NULL;
+ 	char_u		*group = NULL;
+ 	int		prio = SIGN_DEF_PRIO;
  	char_u		*arg1;
+ 	int		bufarg = FALSE;
  
  	if (*arg == NUL)
  	{
  	    if (idx == SIGNCMD_PLACE)
  	    {
  		/* ":sign place": list placed signs in all buffers */
! 		sign_list_placed(NULL, NULL);
  	    }
  	    else if (idx == SIGNCMD_UNPLACE)
  	    {
  		/* ":sign unplace": remove placed sign at cursor */
  		id = buf_findsign_id(curwin->w_buffer, curwin->w_cursor.lnum);
  		if (id > 0)
! 		    sign_unplace(id, NULL, curwin->w_buffer);
  		else
  		    EMSG(_("E159: Missing sign number"));
  	    }
***************
*** 7906,7923 ****
  		{
  		    /* ":sign unplace {id}": remove placed sign by number */
  		    FOR_ALL_BUFFERS(buf)
! 			if ((lnum = buf_delsign(buf, id)) != 0)
! 			    update_debug_sign(buf, lnum);
  		    return;
  		}
  	    }
  	}
  
  	/*
! 	 * Check for line={lnum} name={name} and file={fname} or buffer={nr}.
! 	 * Leave "arg" pointing to {fname}.
  	 */
! 	for (;;)
  	{
  	    if (STRNCMP(arg, "line=", 5) == 0)
  	    {
--- 8093,8109 ----
  		{
  		    /* ":sign unplace {id}": remove placed sign by number */
  		    FOR_ALL_BUFFERS(buf)
! 			sign_unplace(id, NULL, buf);
  		    return;
  		}
  	    }
  	}
  
  	/*
! 	 * Check for line={lnum} name={name} group={group} priority={prio}
! 	 * and file={fname} or buffer={nr}.  Leave "arg" pointing to {fname}.
  	 */
! 	while (*arg != NUL)
  	{
  	    if (STRNCMP(arg, "line=", 5) == 0)
  	    {
***************
*** 7945,7954 ****
  		while (sign_name[0] == '0' && sign_name[1] != NUL)
  		    ++sign_name;
  	    }
  	    else if (STRNCMP(arg, "file=", 5) == 0)
  	    {
  		arg += 5;
! 		buf = buflist_findname(arg);
  		break;
  	    }
  	    else if (STRNCMP(arg, "buffer=", 7) == 0)
--- 8131,8155 ----
  		while (sign_name[0] == '0' && sign_name[1] != NUL)
  		    ++sign_name;
  	    }
+ 	    else if (STRNCMP(arg, "group=", 6) == 0)
+ 	    {
+ 		arg += 6;
+ 		group = arg;
+ 		arg = skiptowhite(arg);
+ 		if (*arg != NUL)
+ 		    *arg++ = NUL;
+ 	    }
+ 	    else if (STRNCMP(arg, "priority=", 9) == 0)
+ 	    {
+ 		arg += 9;
+ 		prio = atoi((char *)arg);
+ 		arg = skiptowhite(arg);
+ 	    }
  	    else if (STRNCMP(arg, "file=", 5) == 0)
  	    {
  		arg += 5;
! 		buf = buflist_findname_exp(arg);
! 		bufarg = TRUE;
  		break;
  	    }
  	    else if (STRNCMP(arg, "buffer=", 7) == 0)
***************
*** 7957,7962 ****
--- 8158,8164 ----
  		buf = buflist_findnr((int)getdigits(&arg));
  		if (*skipwhite(arg) != NUL)
  		    EMSG(_(e_trailing));
+ 		bufarg = TRUE;
  		break;
  	    }
  	    else
***************
*** 7967,7990 ****
  	    arg = skipwhite(arg);
  	}
  
! 	if (buf == NULL)
  	{
  	    EMSG2(_("E158: Invalid buffer name: %s"), arg);
  	}
  	else if (id <= 0 && !(idx == SIGNCMD_UNPLACE && id == -2))
  	{
! 	    if (lnum >= 0 || sign_name != NULL)
  		EMSG(_(e_invarg));
  	    else
! 		/* ":sign place file={fname}": list placed signs in one file */
! 		sign_list_placed(buf);
  	}
  	else if (idx == SIGNCMD_JUMP)
  	{
  	    /* ":sign jump {id} file={fname}" */
  	    if (lnum >= 0 || sign_name != NULL)
  		EMSG(_(e_invarg));
! 	    else if ((lnum = buf_findsign(buf, id)) > 0)
  	    {				/* goto a sign ... */
  		if (buf_jump_open_win(buf) != NULL)
  		{			/* ... in a current window */
--- 8169,8201 ----
  	    arg = skipwhite(arg);
  	}
  
! 	if ((!bufarg && group == NULL) || (group != NULL && *group == '\0'))
! 	{
! 	    // File or buffer is not specified or an empty group is used
! 	    EMSG(_(e_invarg));
! 	    return;
! 	}
! 
! 	if (bufarg && buf == NULL)
  	{
  	    EMSG2(_("E158: Invalid buffer name: %s"), arg);
  	}
  	else if (id <= 0 && !(idx == SIGNCMD_UNPLACE && id == -2))
  	{
! 	    if ((group == NULL) && (lnum >= 0 || sign_name != NULL))
  		EMSG(_(e_invarg));
  	    else
! 		// ":sign place file={fname}": list placed signs in one file
! 		// ":sign place group={group} file={fname}"
! 		// ":sign place group=* file={fname}"
! 		sign_list_placed(buf, group);
  	}
  	else if (idx == SIGNCMD_JUMP)
  	{
  	    /* ":sign jump {id} file={fname}" */
  	    if (lnum >= 0 || sign_name != NULL)
  		EMSG(_(e_invarg));
! 	    else if ((lnum = buf_findsign(buf, id, group)) > 0)
  	    {				/* goto a sign ... */
  		if (buf_jump_open_win(buf) != NULL)
  		{			/* ... in a current window */
***************
*** 8021,8065 ****
  		EMSG(_(e_invarg));
  	    else if (id == -2)
  	    {
! 		/* ":sign unplace * file={fname}" */
! 		redraw_buf_later(buf, NOT_VALID);
! 		buf_delete_signs(buf);
  	    }
  	    else
  	    {
! 		/* ":sign unplace {id} file={fname}" */
! 		lnum = buf_delsign(buf, id);
! 		update_debug_sign(buf, lnum);
  	    }
  	}
  	    /* idx == SIGNCMD_PLACE */
! 	else if (sign_name != NULL)
! 	{
! 	    for (sp = first_sign; sp != NULL; sp = sp->sn_next)
! 		if (STRCMP(sp->sn_name, sign_name) == 0)
! 		    break;
! 	    if (sp == NULL)
! 	    {
! 		EMSG2(_("E155: Unknown sign: %s"), sign_name);
! 		return;
! 	    }
! 	    if (lnum > 0)
! 		/* ":sign place {id} line={lnum} name={name} file={fname}":
! 		 * place a sign */
! 		buf_addsign(buf, id, lnum, sp->sn_typenr);
! 	    else
! 		/* ":sign place {id} file={fname}": change sign type */
! 		lnum = buf_change_sign_type(buf, id, sp->sn_typenr);
! 	    if (lnum > 0)
! 		update_debug_sign(buf, lnum);
! 	    else
! 		EMSG2(_("E885: Not possible to change sign %s"), sign_name);
! 	}
  	else
  	    EMSG(_(e_invarg));
      }
  }
  
  # if defined(FEAT_SIGN_ICONS) || defined(PROTO)
  /*
   * Allocate the icons.  Called when the GUI has started.  Allows defining
--- 8232,8395 ----
  		EMSG(_(e_invarg));
  	    else if (id == -2)
  	    {
! 		if (buf != NULL)
! 		    // ":sign unplace * file={fname}"
! 		    sign_unplace(0, group, buf);
! 		else
! 		    // ":sign unplace * group=*": remove all placed signs
! 		    FOR_ALL_BUFFERS(buf)
! 			if (buf->b_signlist != NULL)
! 			    buf_delete_signs(buf, group);
  	    }
  	    else
  	    {
! 		if (buf != NULL)
! 		    // ":sign unplace {id} file={fname}"
! 		    // ":sign unplace {id} group={group} file={fname}"
! 		    // ":sign unplace {id} group=* file={fname}"
! 		    sign_unplace(id, group, buf);
! 		else
! 		    // ":sign unplace {id} group={group}":
! 		    // ":sign unplace {id} group=*":
! 		    //     remove all placed signs in this group.
! 		    FOR_ALL_BUFFERS(buf)
! 			if (buf->b_signlist != NULL)
! 			    sign_unplace(id, group, buf);
  	    }
  	}
  	    /* idx == SIGNCMD_PLACE */
! 	else if (sign_name != NULL && buf != NULL)
! 	    sign_place(&id, group, sign_name, buf, lnum, prio);
  	else
  	    EMSG(_(e_invarg));
      }
  }
  
+ /*
+  * Return information about a specified sign
+  */
+     static void
+ sign_getinfo(sign_T *sp, dict_T *retdict)
+ {
+     char_u	*p;
+ 
+     dict_add_string(retdict, "name", (char_u *)sp->sn_name);
+     if (sp->sn_icon != NULL)
+ 	dict_add_string(retdict, "icon", (char_u *)sp->sn_icon);
+     if (sp->sn_text != NULL)
+ 	dict_add_string(retdict, "text", (char_u *)sp->sn_text);
+     if (sp->sn_line_hl > 0)
+     {
+ 	p = get_highlight_name_ext(NULL, sp->sn_line_hl - 1, FALSE);
+ 	if (p == NULL)
+ 	    p = (char_u *)"NONE";
+ 	dict_add_string(retdict, "linehl", (char_u *)p);
+     }
+     if (sp->sn_text_hl > 0)
+     {
+ 	p = get_highlight_name_ext(NULL, sp->sn_text_hl - 1, FALSE);
+ 	if (p == NULL)
+ 	    p = (char_u *)"NONE";
+ 	dict_add_string(retdict, "texthl", (char_u *)p);
+     }
+ }
+ 
+ /*
+  * If 'name' is NULL, return a list of all the defined signs.
+  * Otherwise, return information about the specified sign.
+  */
+     void
+ sign_getlist(char_u *name, list_T *retlist)
+ {
+     sign_T	*sp = first_sign;
+     dict_T	*dict;
+ 
+     if (name != NULL)
+     {
+ 	sp = sign_find(name, NULL);
+ 	if (sp == NULL)
+ 	    return;
+     }
+ 
+     for (; sp != NULL && !got_int; sp = sp->sn_next)
+     {
+ 	if ((dict = dict_alloc_id(aid_sign_getlist)) == NULL)
+ 	    return;
+ 	if (list_append_dict(retlist, dict) == FAIL)
+ 	    return;
+ 	sign_getinfo(sp, dict);
+ 
+ 	if (name != NULL)	    // handle only the specified sign
+ 	    break;
+     }
+ }
+ 
+ /*
+  * Return information about all the signs placed in a buffer
+  */
+     static void
+ sign_get_placed_in_buf(
+ 	buf_T		*buf,
+ 	linenr_T	lnum,
+ 	int		sign_id,
+ 	char_u		*sign_group,
+ 	list_T		*retlist)
+ {
+     dict_T	*d;
+     list_T	*l;
+     signlist_T	*sign;
+     dict_T	*sdict;
+ 
+     if ((d = dict_alloc_id(aid_sign_getplaced_dict)) == NULL)
+ 	return;
+     list_append_dict(retlist, d);
+ 
+     dict_add_number(d, "bufnr", (long)buf->b_fnum);
+ 
+     if ((l = list_alloc_id(aid_sign_getplaced_list)) == NULL)
+ 	return;
+     dict_add_list(d, "signs", l);
+ 
+     FOR_ALL_SIGNS_IN_BUF(buf)
+     {
+ 	if (!sign_in_group(sign, sign_group))
+ 	    continue;
+ 	if ((lnum == 0 && sign_id == 0) ||
+ 		(sign_id == 0 && lnum == sign->lnum) ||
+ 		(lnum == 0 && sign_id == sign->id) ||
+ 		(lnum == sign->lnum && sign_id == sign->id))
+ 	{
+ 	    if ((sdict = sign_get_info(sign)) != NULL)
+ 		list_append_dict(l, sdict);
+ 	}
+     }
+ }
+ 
+ /*
+  * Get a list of signs placed in buffer 'buf'. If 'num' is non-zero, return the
+  * sign placed at the line number. If 'lnum' is zero, return all the signs
+  * placed in 'buf'. If 'buf' is NULL, return signs placed in all the buffers.
+  */
+     void
+ sign_get_placed(
+ 	buf_T		*buf,
+ 	linenr_T	lnum,
+ 	int		sign_id,
+ 	char_u		*sign_group,
+ 	list_T		*retlist)
+ {
+     if (buf != NULL)
+ 	sign_get_placed_in_buf(buf, lnum, sign_id, sign_group, retlist);
+     else
+     {
+ 	FOR_ALL_BUFFERS(buf)
+ 	{
+ 	    if (buf->b_signlist != NULL)
+ 		sign_get_placed_in_buf(buf, 0, sign_id, sign_group, retlist);
+ 	}
+     }
+ }
+ 
  # if defined(FEAT_SIGN_ICONS) || defined(PROTO)
  /*
   * Allocate the icons.  Called when the GUI has started.  Allows defining
***************
*** 8214,8220 ****
      return (char_u *)_("[Deleted]");
  }
  
- # if defined(EXITFREE) || defined(PROTO)
  /*
   * Undefine/free all signs.
   */
--- 8544,8549 ----
***************
*** 8224,8230 ****
      while (first_sign != NULL)
  	sign_undefine(first_sign, NULL);
  }
- # endif
  
  # if defined(FEAT_CMDL_COMPL) || defined(PROTO)
  static enum
--- 8553,8558 ----
*** ../vim-8.1.0613/src/globals.h	2018-11-10 17:33:23.087518814 +0100
--- src/globals.h	2018-12-21 14:36:57.242303552 +0100
***************
*** 606,611 ****
--- 606,615 ----
  
  #define FOR_ALL_BUFFERS(buf) for (buf = firstbuf; buf != NULL; buf = buf->b_next)
  
+ // Iterate through all the signs placed in a buffer
+ #define FOR_ALL_SIGNS_IN_BUF(buf) \
+ 	for (sign = buf->b_signlist; sign != NULL; sign = sign->next)
+ 
  /* Flag that is set when switching off 'swapfile'.  It means that all blocks
   * are to be loaded into memory.  Shouldn't be global... */
  EXTERN int	mf_dont_release INIT(= FALSE);	/* don't release blocks */
*** ../vim-8.1.0613/src/list.c	2018-11-11 15:20:32.432704446 +0100
--- src/list.c	2018-12-21 14:36:57.242303552 +0100
***************
*** 116,121 ****
--- 116,135 ----
  }
  
  /*
+  * Same as rettv_list_alloc() but uses an allocation id for testing.
+  */
+     int
+ rettv_list_alloc_id(typval_T *rettv, alloc_id_T id UNUSED)
+ {
+ #ifdef FEAT_EVAL
+     if (alloc_fail_id == id && alloc_does_fail((long_u)sizeof(list_T)))
+ 	return FAIL;
+ #endif
+     return rettv_list_alloc(rettv);
+ }
+ 
+ 
+ /*
   * Set a list as the return value
   */
      void
*** ../vim-8.1.0613/src/misc2.c	2018-12-16 16:30:17.810717978 +0100
--- src/misc2.c	2018-12-21 14:36:57.246303525 +0100
***************
*** 895,900 ****
--- 895,913 ----
  }
  
  /*
+  * Same as alloc_clear() but with allocation id for testing
+  */
+     char_u *
+ alloc_clear_id(unsigned size, alloc_id_T id UNUSED)
+ {
+ #ifdef FEAT_EVAL
+     if (alloc_fail_id == id && alloc_does_fail((long_u)size))
+ 	return NULL;
+ #endif
+     return alloc_clear(size);
+ }
+ 
+ /*
   * alloc() with check for maximum line length
   */
      char_u *
*** ../vim-8.1.0613/src/netbeans.c	2018-09-30 21:43:17.199693265 +0200
--- src/netbeans.c	2018-12-21 14:36:57.246303525 +0100
***************
*** 1042,1048 ****
  		cp = (char *)args;
  		serNum = strtol(cp, &cp, 10);
  		/* If the sign isn't found linenum will be zero. */
! 		linenum = (long)buf_findsign(buf->bufp, serNum);
  	    }
  #endif
  	    nb_reply_nr(cmdno, linenum);
--- 1042,1048 ----
  		cp = (char *)args;
  		serNum = strtol(cp, &cp, 10);
  		/* If the sign isn't found linenum will be zero. */
! 		linenum = (long)buf_findsign(buf->bufp, serNum, NULL);
  	    }
  #endif
  	    nb_reply_nr(cmdno, linenum);
***************
*** 1256,1262 ****
  			{
  			    nbdebug(("    Deleting sign %d on line %d\n",
  								      id, i));
! 			    buf_delsign(buf->bufp, id);
  			}
  			else
  			{
--- 1256,1262 ----
  			{
  			    nbdebug(("    Deleting sign %d on line %d\n",
  								      id, i));
! 			    buf_delsign(buf->bufp, id, NULL);
  			}
  			else
  			{
*** ../vim-8.1.0613/src/proto/buffer.pro	2018-12-18 21:56:25.084495836 +0100
--- src/proto/buffer.pro	2018-12-21 14:36:57.246303525 +0100
***************
*** 69,85 ****
  void switch_to_win_for_buf(buf_T *buf, win_T **save_curwinp, tabpage_T **save_curtabp, bufref_T *save_curbuf);
  void restore_win_for_buf(win_T *save_curwin, tabpage_T *save_curtab, bufref_T *save_curbuf);
  int find_win_for_buf(buf_T *buf, win_T **wp, tabpage_T **tp);
! void buf_addsign(buf_T *buf, int id, linenr_T lnum, int typenr);
! linenr_T buf_change_sign_type(buf_T *buf, int markId, int typenr);
  int buf_getsigntype(buf_T *buf, linenr_T lnum, int type);
! linenr_T buf_delsign(buf_T *buf, int id);
! int buf_findsign(buf_T *buf, int id);
  int buf_findsign_id(buf_T *buf, linenr_T lnum);
  int buf_findsigntype_id(buf_T *buf, linenr_T lnum, int typenr);
  int buf_signcount(buf_T *buf, linenr_T lnum);
! void buf_delete_signs(buf_T *buf);
  void buf_delete_all_signs(void);
! void sign_list_placed(buf_T *rbuf);
  void sign_mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after);
  void set_buflisted(int on);
  int buf_contents_changed(buf_T *buf);
--- 69,90 ----
  void switch_to_win_for_buf(buf_T *buf, win_T **save_curwinp, tabpage_T **save_curtabp, bufref_T *save_curbuf);
  void restore_win_for_buf(win_T *save_curwin, tabpage_T *save_curtab, bufref_T *save_curbuf);
  int find_win_for_buf(buf_T *buf, win_T **wp, tabpage_T **tp);
! void buf_addsign(buf_T *buf, int id, char_u *group, int prio, linenr_T lnum, int typenr);
! linenr_T buf_change_sign_type(buf_T *buf, int markId, char_u *group, int typenr);
  int buf_getsigntype(buf_T *buf, linenr_T lnum, int type);
! linenr_T buf_delsign(buf_T *buf, int id, char_u *group);
! int buf_findsign(buf_T *buf, int id, char_u *group);
! #ifdef FEAT_SIGNS
! int sign_in_group(signlist_T *sign, char_u *group);
! dict_T *sign_get_info(signlist_T *sign);
! signlist_T *buf_getsign_with_id(buf_T *buf, int id, char_u *group);
! #endif
  int buf_findsign_id(buf_T *buf, linenr_T lnum);
  int buf_findsigntype_id(buf_T *buf, linenr_T lnum, int typenr);
  int buf_signcount(buf_T *buf, linenr_T lnum);
! void buf_delete_signs(buf_T *buf, char_u *group);
  void buf_delete_all_signs(void);
! void sign_list_placed(buf_T *rbuf, char_u *sign_group);
  void sign_mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after);
  void set_buflisted(int on);
  int buf_contents_changed(buf_T *buf);
*** ../vim-8.1.0613/src/proto/ex_cmds.pro	2018-12-18 21:56:25.084495836 +0100
--- src/proto/ex_cmds.pro	2018-12-21 14:36:57.246303525 +0100
***************
*** 61,70 ****
--- 61,77 ----
  void *sign_get_image(int typenr);
  char_u *sign_typenr2name(int typenr);
  void free_signs(void);
+ void free_signs(void);
  char_u *get_sign_name(expand_T *xp, int idx);
  void set_context_in_sign_cmd(expand_T *xp, char_u *arg);
  void ex_smile(exarg_T *eap);
  void ex_drop(exarg_T *eap);
  char_u *skip_vimgrep_pat(char_u *p, char_u **s, int *flags);
  void ex_oldfiles(exarg_T *eap);
+ int sign_define_by_name(char_u *name, char_u *icon, char_u *linehl, char_u *text, char_u *texthl);
+ int sign_undefine_by_name(char_u *name);
+ void sign_getlist(char_u *name, list_T *retlist);
+ int sign_place(int *sign_id, char_u *group, char_u *sign_name, buf_T *buf, linenr_T lnum, int prio);
+ int sign_unplace(int id, char_u *group, buf_T *buf);
+ void sign_get_placed(buf_T *buf, linenr_T lnum, int id, char_u *group, list_T *retlist);
  /* vim: set ft=c : */
*** ../vim-8.1.0613/src/proto/list.pro	2018-11-11 15:20:32.436704418 +0100
--- src/proto/list.pro	2018-12-21 14:36:57.246303525 +0100
***************
*** 5,10 ****
--- 5,11 ----
  list_T *list_alloc(void);
  list_T *list_alloc_id(alloc_id_T id);
  int rettv_list_alloc(typval_T *rettv);
+ int rettv_list_alloc_id(typval_T *rettv, alloc_id_T id);
  void rettv_list_set(typval_T *rettv, list_T *l);
  void list_unref(list_T *l);
  int list_free_nonref(int copyID);
*** ../vim-8.1.0613/src/proto/misc2.pro	2018-12-18 21:56:25.084495836 +0100
--- src/proto/misc2.pro	2018-12-21 14:36:57.246303525 +0100
***************
*** 24,29 ****
--- 24,30 ----
  char_u *alloc(unsigned size);
  char_u *alloc_id(unsigned size, alloc_id_T id);
  char_u *alloc_clear(unsigned size);
+ char_u * alloc_clear_id(unsigned size, alloc_id_T id);
  char_u *alloc_check(unsigned size);
  char_u *lalloc_clear(long_u size, int message);
  char_u *lalloc(long_u size, int message);
*** ../vim-8.1.0613/src/structs.h	2018-12-13 22:17:52.881941445 +0100
--- src/structs.h	2018-12-21 14:36:57.246303525 +0100
***************
*** 740,749 ****
--- 740,754 ----
      int		id;		/* unique identifier for each placed sign */
      linenr_T	lnum;		/* line number which has this sign */
      int		typenr;		/* typenr of sign */
+     char_u	*group;		/* sign group */
+     int		priority;	/* priority for highlighting */
      signlist_T	*next;		/* next signlist entry */
      signlist_T  *prev;		/* previous entry -- for easy reordering */
  };
  
+ // Default sign priority for highlighting
+ #define SIGN_DEF_PRIO	10
+ 
  /* type argument for buf_getsigntype() */
  #define SIGN_ANY	0
  #define SIGN_LINEHL	1
*** ../vim-8.1.0613/src/testdir/test_signs.vim	2018-12-14 19:37:03.677899412 +0100
--- src/testdir/test_signs.vim	2018-12-21 14:44:27.834440393 +0100
***************
*** 16,23 ****
    try
      sign define Sign2 text=xy texthl=Title linehl=Error icon=../../pixmaps/stock_vim_find_help.png
    catch /E255:/
!     " ignore error: E255: Couldn't read in sign data!
!     " This error can happen when running in gui.
      " Some gui like Motif do not support the png icon format.
    endtry
  
--- 16,23 ----
    try
      sign define Sign2 text=xy texthl=Title linehl=Error icon=../../pixmaps/stock_vim_find_help.png
    catch /E255:/
!     " Ignore error: E255: Couldn't read in sign data!
!     " This error can happen when running in the GUI.
      " Some gui like Motif do not support the png icon format.
    endtry
  
***************
*** 63,69 ****
  
    " Check placed signs
    let a=execute('sign place')
!   call assert_equal("\n--- Signs ---\nSigns for [NULL]:\n    line=3  id=41  name=Sign1\n", a)
  
    " Unplace the sign and try jumping to it again should fail.
    sign unplace 41
--- 63,69 ----
  
    " Check placed signs
    let a=execute('sign place')
!   call assert_equal("\n--- Signs ---\nSigns for [NULL]:\n    line=3  id=41  name=Sign1 priority=10\n", a)
  
    " Unplace the sign and try jumping to it again should fail.
    sign unplace 41
***************
*** 112,118 ****
    " Only 1 or 2 character text is allowed
    call assert_fails("sign define Sign4 text=abc linehl=Comment", 'E239:')
    call assert_fails("sign define Sign4 text= linehl=Comment", 'E239:')
!   call assert_fails("sign define Sign4 text=\ ab  linehl=Comment", 'E239:')
  
    " define sign with whitespace
    sign define Sign4 text=\ X linehl=Comment
--- 112,118 ----
    " Only 1 or 2 character text is allowed
    call assert_fails("sign define Sign4 text=abc linehl=Comment", 'E239:')
    call assert_fails("sign define Sign4 text= linehl=Comment", 'E239:')
!   call assert_fails("sign define Sign4 text=\\ ab  linehl=Comment", 'E239:')
  
    " define sign with whitespace
    sign define Sign4 text=\ X linehl=Comment
***************
*** 131,136 ****
--- 131,158 ----
    sign define Sign4 text=\\ linehl=Comment
    sign undefine Sign4
  
+   " Error cases
+   call assert_fails("exe 'sign place abc line=3 name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign unplace abc name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign place 1abc line=3 name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign unplace 2abc name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("sign unplace 2 *", 'E474:')
+   call assert_fails("exe 'sign place 1 line=3 name=Sign1 buffer=' . bufnr('%') a", 'E488:')
+   call assert_fails("exe 'sign place name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign place line=10 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign unplace 2 line=10 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign unplace 2 name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("exe 'sign place 2 line=3 buffer=' . bufnr('%')", 'E474:')
+   call assert_fails("sign place 2", 'E474:')
+   call assert_fails("sign place abc", 'E474:')
+   call assert_fails("sign place 5 line=3", 'E474:')
+   call assert_fails("sign place 5 name=Sign1", 'E474:')
+   call assert_fails("sign place 5 group=g1", 'E474:')
+   call assert_fails("sign place 5 group=*", 'E474:')
+   call assert_fails("sign place 5 priority=10", 'E474:')
+   call assert_fails("sign place 5 line=3 name=Sign1", 'E474:')
+   call assert_fails("sign place 5 group=g1 line=3 name=Sign1", 'E474:')
+ 
    " After undefining the sign, we should no longer be able to place it.
    sign undefine Sign1
    sign undefine Sign2
***************
*** 152,158 ****
  
    " Listing placed sign should show that sign is deleted.
    let a=execute('sign place')
!   call assert_equal("\n--- Signs ---\nSigns for foobar:\n    line=1  id=41  name=[Deleted]\n", a)
  
    sign unplace 41
    let a=execute('sign place')
--- 174,180 ----
  
    " Listing placed sign should show that sign is deleted.
    let a=execute('sign place')
!   call assert_equal("\n--- Signs ---\nSigns for foobar:\n    line=1  id=41  name=[Deleted] priority=10\n", a)
  
    sign unplace 41
    let a=execute('sign place')
***************
*** 202,207 ****
--- 224,231 ----
  endfunc
  
  func Test_sign_invalid_commands()
+   sign define Sign1 text=x
+ 
    call assert_fails('sign', 'E471:')
    call assert_fails('sign jump', 'E471:')
    call assert_fails('sign xxx', 'E160:')
***************
*** 211,216 ****
--- 235,286 ----
    call assert_fails('sign list xxx', 'E155:')
    call assert_fails('sign place 1 buffer=999', 'E158:')
    call assert_fails('sign define Sign2 text=', 'E239:')
+   " Non-numeric identifier for :sign place
+   call assert_fails("exe 'sign place abc line=3 name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   " Non-numeric identifier for :sign unplace
+   call assert_fails("exe 'sign unplace abc name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   " Number followed by an alphabet as sign identifier for :sign place
+   call assert_fails("exe 'sign place 1abc line=3 name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   " Number followed by an alphabet as sign identifier for :sign unplace
+   call assert_fails("exe 'sign unplace 2abc name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   " Sign identifier and '*' for :sign unplace
+   call assert_fails("sign unplace 2 *", 'E474:')
+   " Trailing characters after buffer number for :sign place
+   call assert_fails("exe 'sign place 1 line=3 name=Sign1 buffer=' . bufnr('%') . 'xxx'", 'E488:')
+   " Trailing characters after buffer number for :sign unplace
+   call assert_fails("exe 'sign unplace 1 buffer=' . bufnr('%') . 'xxx'", 'E488:')
+   call assert_fails("exe 'sign unplace * buffer=' . bufnr('%') . 'xxx'", 'E488:')
+   call assert_fails("sign unplace 1 xxx", 'E474:')
+   call assert_fails("sign unplace * xxx", 'E474:')
+   call assert_fails("sign unplace xxx", 'E474:')
+   " Placing a sign without line number
+   call assert_fails("exe 'sign place name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   " Placing a sign without sign name
+   call assert_fails("exe 'sign place line=10 buffer=' . bufnr('%')", 'E474:')
+   " Unplacing a sign with line number
+   call assert_fails("exe 'sign unplace 2 line=10 buffer=' . bufnr('%')", 'E474:')
+   " Unplacing a sign with sign name
+   call assert_fails("exe 'sign unplace 2 name=Sign1 buffer=' . bufnr('%')", 'E474:')
+   " Placing a sign without sign name
+   call assert_fails("exe 'sign place 2 line=3 buffer=' . bufnr('%')", 'E474:')
+   " Placing a sign with only sign identifier
+   call assert_fails("sign place 2", 'E474:')
+   " Placing a sign with only a name
+   call assert_fails("sign place abc", 'E474:')
+   " Placing a sign with only line number
+   call assert_fails("sign place 5 line=3", 'E474:')
+   " Placing a sign with only sign name
+   call assert_fails("sign place 5 name=Sign1", 'E474:')
+   " Placing a sign with only sign group
+   call assert_fails("sign place 5 group=g1", 'E474:')
+   call assert_fails("sign place 5 group=*", 'E474:')
+   " Placing a sign with only sign priority
+   call assert_fails("sign place 5 priority=10", 'E474:')
+   " Placing a sign without buffer number or file name
+   call assert_fails("sign place 5 line=3 name=Sign1", 'E474:')
+   call assert_fails("sign place 5 group=g1 line=3 name=Sign1", 'E474:')
+ 
+   sign undefine Sign1
  endfunc
  
  func Test_sign_delete_buffer()
***************
*** 224,226 ****
--- 294,842 ----
    sign unplace 61
    sign undefine Sign
  endfunc
+ 
+ " Test for VimL functions for managing signs
+ func Test_sign_funcs()
+   " Remove all the signs
+   call sign_unplace('*')
+   call sign_undefine()
+ 
+   " Tests for sign_define()
+   let attr = {'text' : '=>', 'linehl' : 'Search', 'texthl' : 'Error'}
+   call assert_equal(0, sign_define("sign1", attr))
+   call assert_equal([{'name' : 'sign1', 'texthl' : 'Error',
+ 	      \ 'linehl' : 'Search', 'text' : '=>'}], sign_getdefined())
+ 
+   " Define a new sign without attributes and then update it
+   call sign_define("sign2")
+   let attr = {'text' : '!!', 'linehl' : 'DiffAdd', 'texthl' : 'DiffChange',
+ 	      \ 'icon' : 'sign2.ico'}
+   try
+     call sign_define("sign2", attr)
+   catch /E255:/
+     " ignore error: E255: Couldn't read in sign data!
+     " This error can happen when running in gui.
+   endtry
+   call assert_equal([{'name' : 'sign2', 'texthl' : 'DiffChange',
+ 	      \ 'linehl' : 'DiffAdd', 'text' : '!!', 'icon' : 'sign2.ico'}],
+ 	      \ sign_getdefined("sign2"))
+ 
+   " Test for a sign name with digits
+   call assert_equal(0, sign_define(0002, {'linehl' : 'StatusLine'}))
+   call assert_equal([{'name' : '2', 'linehl' : 'StatusLine'}],
+ 	      \ sign_getdefined(0002))
+   call sign_undefine(0002)
+ 
+   " Tests for invalid arguments to sign_define()
+   call assert_fails('call sign_define("sign4", {"text" : "===>"})', 'E239:')
+   call assert_fails('call sign_define("sign5", {"text" : ""})', 'E239:')
+   call assert_fails('call sign_define([])', 'E730:')
+   call assert_fails('call sign_define("sign6", [])', 'E715:')
+ 
+   " Tests for sign_getdefined()
+   call assert_equal([], sign_getdefined("none"))
+   call assert_fails('call sign_getdefined({})', 'E731:')
+ 
+   " Tests for sign_place()
+   call writefile(repeat(["Sun is shining"], 30), "Xsign")
+   edit Xsign
+ 
+   call assert_equal(10, sign_place(10, '', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 20}))
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' :
+ 	      \ [{'id' : 10, 'group' : '', 'lnum' : 20, 'name' : 'sign1',
+ 	      \ 'priority' : 10}]}], sign_getplaced('Xsign'))
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' :
+ 	      \ [{'id' : 10, 'group' : '', 'lnum' : 20, 'name' : 'sign1',
+ 	      \ 'priority' : 10}]}],
+ 	      \ sign_getplaced('Xsign', {'lnum' : 20}))
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' :
+ 	      \ [{'id' : 10, 'group' : '', 'lnum' : 20, 'name' : 'sign1',
+ 	      \ 'priority' : 10}]}],
+ 	      \ sign_getplaced('Xsign', {'id' : 10}))
+ 
+   " Tests for invalid arguments to sign_place()
+   call assert_fails('call sign_place([], "", "mySign", 1)', 'E745:')
+   call assert_fails('call sign_place(5, "", "mySign", -1)', 'E158:')
+   call assert_fails('call sign_place(-1, "", "sign1", "Xsign", [])',
+ 	      \ 'E474:')
+   call assert_fails('call sign_place(-1, "", "sign1", "Xsign",
+ 	      \ {"lnum" : 30})', 'E474:')
+   call assert_fails('call sign_place(10, "", "xsign1x", "Xsign",
+ 	      \ {"lnum" : 30})', 'E155:')
+   call assert_fails('call sign_place(10, "", "", "Xsign",
+ 	      \ {"lnum" : 30})', 'E155:')
+   call assert_fails('call sign_place(10, "", [], "Xsign",
+ 	      \ {"lnum" : 30})', 'E730:')
+   call assert_fails('call sign_place(5, "", "sign1", "abcxyz.xxx",
+ 	      \ {"lnum" : 10})', 'E158:')
+   call assert_fails('call sign_place(5, "", "sign1", "", {"lnum" : 10})',
+ 	      \ 'E158:')
+   call assert_fails('call sign_place(5, "", "sign1", [], {"lnum" : 10})',
+ 	      \ 'E158:')
+   call assert_fails('call sign_place(21, "", "sign1", "Xsign",
+ 	      \ {"lnum" : -1})', 'E885:')
+   call assert_fails('call sign_place(22, "", "sign1", "Xsign",
+ 	      \ {"lnum" : 0})', 'E885:')
+   call assert_equal(-1, sign_place(1, "*", "sign1", "Xsign", {"lnum" : 10}))
+ 
+   " Tests for sign_getplaced()
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' :
+ 	      \ [{'id' : 10, 'group' : '', 'lnum' : 20, 'name' : 'sign1',
+ 	      \ 'priority' : 10}]}],
+ 	      \ sign_getplaced(bufnr('Xsign')))
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' :
+ 	      \ [{'id' : 10, 'group' : '', 'lnum' : 20, 'name' : 'sign1',
+ 	      \ 'priority' : 10}]}],
+ 	      \ sign_getplaced())
+   call assert_fails("call sign_getplaced('dummy.sign')", 'E158:')
+   call assert_fails('call sign_getplaced("")', 'E158:')
+   call assert_fails('call sign_getplaced(-1)', 'E158:')
+   call assert_fails('call sign_getplaced("Xsign", [])', 'E715:')
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' : []}],
+ 	      \ sign_getplaced('Xsign', {'lnum' : 1000000}))
+   call assert_fails("call sign_getplaced('Xsign', {'lnum' : []})",
+ 	      \ 'E745:')
+   call assert_equal([{'bufnr' : bufnr(''), 'signs' : []}],
+ 	      \ sign_getplaced('Xsign', {'id' : 44}))
+   call assert_fails("call sign_getplaced('Xsign', {'id' : []})",
+ 	      \ 'E745:')
+ 
+   " Tests for sign_unplace()
+   call sign_place(20, '', 'sign2', 'Xsign', {"lnum" : 30})
+   call assert_equal(0, sign_unplace('',
+ 	      \ {'id' : 20, 'buffer' : 'Xsign'}))
+   call assert_equal(-1, sign_unplace('',
+ 	      \ {'id' : 30, 'buffer' : 'Xsign'}))
+   call sign_place(20, '', 'sign2', 'Xsign', {"lnum" : 30})
+   call assert_fails("call sign_unplace('',
+ 	      \ {'id' : 20, 'buffer' : 'buffer.c'})", 'E158:')
+   call assert_fails("call sign_unplace('',
+ 	      \ {'id' : 20, 'buffer' : ''})", 'E158:')
+   call assert_fails("call sign_unplace('',
+ 	      \ {'id' : 20, 'buffer' : 200})", 'E158:')
+   call assert_fails("call sign_unplace('', 'mySign')", 'E715:')
+ 
+   " Tests for sign_undefine()
+   call assert_equal(0, sign_undefine("sign1"))
+   call assert_equal([], sign_getdefined("sign1"))
+   call assert_fails('call sign_undefine("none")', 'E155:')
+   call assert_fails('call sign_undefine([])', 'E730:')
+ 
+   call delete("Xsign")
+   call sign_unplace('*')
+   call sign_undefine()
+   enew | only
+ endfunc
+ 
+ " Tests for sign groups
+ func Test_sign_group()
+   enew | only
+   " Remove all the signs
+   call sign_unplace('*')
+   call sign_undefine()
+ 
+   call writefile(repeat(["Sun is shining"], 30), "Xsign")
+ 
+   let attr = {'text' : '=>', 'linehl' : 'Search', 'texthl' : 'Error'}
+   call assert_equal(0, sign_define("sign1", attr))
+ 
+   edit Xsign
+   let bnum = bufnr('%')
+   let fname = fnamemodify('Xsign', ':p')
+ 
+   " Error case
+   call assert_fails("call sign_place(5, [], 'sign1', 'Xsign',
+ 	      \ {'lnum' : 30})", 'E730:')
+ 
+   " place three signs with the same identifier. One in the global group and
+   " others in the named groups
+   call assert_equal(5, sign_place(5, '', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 10}))
+   call assert_equal(5, sign_place(5, 'g1', 'sign1', bnum, {'lnum' : 20}))
+   call assert_equal(5, sign_place(5, 'g2', 'sign1', bnum, {'lnum' : 30}))
+ 
+   " Test for sign_getplaced() with group
+   let s = sign_getplaced('Xsign')
+   call assert_equal(1, len(s[0].signs))
+   call assert_equal(s[0].signs[0].group, '')
+   let s = sign_getplaced(bnum, {'group' : 'g2'})
+   call assert_equal('g2', s[0].signs[0].group)
+   let s = sign_getplaced(bnum, {'group' : 'g3'})
+   call assert_equal([], s[0].signs)
+   let s = sign_getplaced(bnum, {'group' : '*'})
+   call assert_equal([{'id' : 5, 'group' : '', 'name' : 'sign1', 'lnum' : 10,
+ 	      \ 'priority' : 10},
+ 	      \ {'id' : 5, 'group' : 'g1', 'name' : 'sign1', 'lnum' : 20,
+ 	      \  'priority' : 10},
+ 	      \ {'id' : 5, 'group' : 'g2', 'name' : 'sign1', 'lnum' : 30,
+ 	      \  'priority' : 10}],
+ 	      \ s[0].signs)
+ 
+   " Test for sign_getplaced() with id
+   let s = sign_getplaced(bnum, {'id' : 5})
+   call assert_equal([{'id' : 5, 'group' : '', 'name' : 'sign1', 'lnum' : 10,
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+   let s = sign_getplaced(bnum, {'id' : 5, 'group' : 'g2'})
+   call assert_equal(
+ 	      \ [{'id' : 5, 'name' : 'sign1', 'lnum' : 30, 'group' : 'g2',
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+   let s = sign_getplaced(bnum, {'id' : 5, 'group' : '*'})
+   call assert_equal([{'id' : 5, 'group' : '', 'name' : 'sign1', 'lnum' : 10,
+ 	      \ 'priority' : 10},
+ 	      \ {'id' : 5, 'group' : 'g1', 'name' : 'sign1', 'lnum' : 20,
+ 	      \ 'priority' : 10},
+ 	      \ {'id' : 5, 'group' : 'g2', 'name' : 'sign1', 'lnum' : 30,
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+   let s = sign_getplaced(bnum, {'id' : 5, 'group' : 'g3'})
+   call assert_equal([], s[0].signs)
+ 
+   " Test for sign_getplaced() with lnum
+   let s = sign_getplaced(bnum, {'lnum' : 20})
+   call assert_equal([], s[0].signs)
+   let s = sign_getplaced(bnum, {'lnum' : 20, 'group' : 'g1'})
+   call assert_equal(
+ 	      \ [{'id' : 5, 'name' : 'sign1', 'lnum' : 20, 'group' : 'g1',
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+   let s = sign_getplaced(bnum, {'lnum' : 30, 'group' : '*'})
+   call assert_equal(
+ 	      \ [{'id' : 5, 'name' : 'sign1', 'lnum' : 30, 'group' : 'g2',
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+   let s = sign_getplaced(bnum, {'lnum' : 40, 'group' : '*'})
+   call assert_equal([], s[0].signs)
+ 
+   " Error case
+   call assert_fails("call sign_getplaced(bnum, {'group' : []})",
+ 	      \ 'E730:')
+ 
+   " Clear the sign in global group
+   call sign_unplace('', {'id' : 5, 'buffer' : bnum})
+   let s = sign_getplaced(bnum, {'group' : '*'})
+   call assert_equal([
+ 	      \ {'id' : 5, 'name' : 'sign1', 'lnum' : 20, 'group' : 'g1',
+ 	      \ 'priority' : 10},
+ 	      \ {'id' : 5, 'name' : 'sign1', 'lnum' : 30, 'group' : 'g2',
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+ 
+   " Clear the sign in one of the groups
+   call sign_unplace('g1', {'buffer' : 'Xsign'})
+   let s = sign_getplaced(bnum, {'group' : '*'})
+   call assert_equal([
+ 	      \ {'id' : 5, 'name' : 'sign1', 'lnum' : 30, 'group' : 'g2',
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+ 
+   " Clear all the signs from the buffer
+   call sign_unplace('*', {'buffer' : bnum})
+   call assert_equal([], sign_getplaced(bnum, {'group' : '*'})[0].signs)
+ 
+   " Clear sign across groups using an identifier
+   call sign_place(25, '', 'sign1', bnum, {'lnum' : 10})
+   call sign_place(25, 'g1', 'sign1', bnum, {'lnum' : 11})
+   call sign_place(25, 'g2', 'sign1', bnum, {'lnum' : 12})
+   call assert_equal(0, sign_unplace('*', {'id' : 25}))
+   call assert_equal([], sign_getplaced(bnum, {'group' : '*'})[0].signs)
+ 
+   " Error case
+   call assert_fails("call sign_unplace([])", 'E474:')
+ 
+   " Place a sign in the global group and try to delete it using a group
+   call assert_equal(5, sign_place(5, '', 'sign1', bnum, {'lnum' : 10}))
+   call assert_equal(-1, sign_unplace('g1', {'id' : 5}))
+ 
+   " Place signs in multiple groups and delete all the signs in one of the
+   " group
+   call assert_equal(5, sign_place(5, '', 'sign1', bnum, {'lnum' : 10}))
+   call assert_equal(6, sign_place(6, '', 'sign1', bnum, {'lnum' : 11}))
+   call assert_equal(5, sign_place(5, 'g1', 'sign1', bnum, {'lnum' : 10}))
+   call assert_equal(5, sign_place(5, 'g2', 'sign1', bnum, {'lnum' : 10}))
+   call assert_equal(6, sign_place(6, 'g1', 'sign1', bnum, {'lnum' : 11}))
+   call assert_equal(6, sign_place(6, 'g2', 'sign1', bnum, {'lnum' : 11}))
+   call assert_equal(0, sign_unplace('g1'))
+   let s = sign_getplaced(bnum, {'group' : 'g1'})
+   call assert_equal([], s[0].signs)
+   let s = sign_getplaced(bnum)
+   call assert_equal(2, len(s[0].signs))
+   let s = sign_getplaced(bnum, {'group' : 'g2'})
+   call assert_equal('g2', s[0].signs[0].group)
+   call assert_equal(0, sign_unplace('', {'id' : 5}))
+   call assert_equal(0, sign_unplace('', {'id' : 6}))
+   let s = sign_getplaced(bnum, {'group' : 'g2'})
+   call assert_equal('g2', s[0].signs[0].group)
+   call assert_equal(0, sign_unplace('', {'buffer' : bnum}))
+ 
+   call sign_unplace('*')
+ 
+   " Test for :sign command and groups
+   exe 'sign place 5 line=10 name=sign1 file=' . fname
+   exe 'sign place 5 group=g1 line=10 name=sign1 file=' . fname
+   exe 'sign place 5 group=g2 line=10 name=sign1 file=' . fname
+ 
+   " Test for :sign place group={group} file={fname}
+   let a = execute('sign place file=' . fname)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n    line=10  id=5  name=sign1 priority=10\n", a)
+ 
+   let a = execute('sign place group=g2 file=' . fname)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n    line=10  id=5  group=g2  name=sign1 priority=10\n", a)
+ 
+   let a = execute('sign place group=* file=' . fname)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=10  id=5  group=g2  name=sign1 priority=10\n" .
+ 	      \ "    line=10  id=5  group=g1  name=sign1 priority=10\n" .
+ 	      \ "    line=10  id=5  name=sign1 priority=10\n", a)
+ 
+   let a = execute('sign place group=xyz file=' . fname)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n", a)
+ 
+   call sign_unplace('*')
+ 
+   " Test for :sign place group={group} buffer={nr}
+   let bnum = bufnr('Xsign')
+   exe 'sign place 5 line=10 name=sign1 buffer=' . bnum
+   exe 'sign place 5 group=g1 line=11 name=sign1 buffer=' . bnum
+   exe 'sign place 5 group=g2 line=12 name=sign1 buffer=' . bnum
+ 
+   let a = execute('sign place buffer=' . bnum)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n    line=10  id=5  name=sign1 priority=10\n", a)
+ 
+   let a = execute('sign place group=g2 buffer=' . bnum)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n    line=12  id=5  group=g2  name=sign1 priority=10\n", a)
+ 
+   let a = execute('sign place group=* buffer=' . bnum)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=10  id=5  name=sign1 priority=10\n" .
+ 	      \ "    line=11  id=5  group=g1  name=sign1 priority=10\n" .
+ 	      \ "    line=12  id=5  group=g2  name=sign1 priority=10\n", a)
+ 
+   let a = execute('sign place group=xyz buffer=' . bnum)
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n", a)
+ 
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=10  id=5  name=sign1 priority=10\n" .
+ 	      \ "    line=11  id=5  group=g1  name=sign1 priority=10\n" .
+ 	      \ "    line=12  id=5  group=g2  name=sign1 priority=10\n", a)
+ 
+   " Test for :sign unplace
+   exe 'sign unplace 5 group=g2 file=' . fname
+   call assert_equal([], sign_getplaced(bnum, {'group' : 'g2'})[0].signs)
+ 
+   exe 'sign unplace 5 group=g1 buffer=' . bnum
+   call assert_equal([], sign_getplaced(bnum, {'group' : 'g1'})[0].signs)
+ 
+   exe 'sign unplace 5 group=xy file=' . fname
+   call assert_equal(1, len(sign_getplaced(bnum, {'group' : '*'})[0].signs))
+ 
+   " Test for removing all the signs. Place the signs again for this test
+   exe 'sign place 5 group=g1 line=11 name=sign1 file=' . fname
+   exe 'sign place 5 group=g2 line=12 name=sign1 file=' . fname
+   exe 'sign place 6 line=20 name=sign1 file=' . fname
+   exe 'sign place 6 group=g1 line=21 name=sign1 file=' . fname
+   exe 'sign place 6 group=g2 line=22 name=sign1 file=' . fname
+   exe 'sign unplace 5 group=* file=' . fname
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=20  id=6  name=sign1 priority=10\n" .
+ 	      \ "    line=21  id=6  group=g1  name=sign1 priority=10\n" .
+ 	      \ "    line=22  id=6  group=g2  name=sign1 priority=10\n", a)
+ 
+   " Remove all the signs from the global group
+   exe 'sign unplace * file=' . fname
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=21  id=6  group=g1  name=sign1 priority=10\n" .
+ 	      \ "    line=22  id=6  group=g2  name=sign1 priority=10\n", a)
+ 
+   " Remove all the signs from a particular group
+   exe 'sign place 5 line=10 name=sign1 file=' . fname
+   exe 'sign place 5 group=g1 line=11 name=sign1 file=' . fname
+   exe 'sign place 5 group=g2 line=12 name=sign1 file=' . fname
+   exe 'sign unplace * group=g1 file=' . fname
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=10  id=5  name=sign1 priority=10\n" .
+ 	      \ "    line=12  id=5  group=g2  name=sign1 priority=10\n" .
+ 	      \ "    line=22  id=6  group=g2  name=sign1 priority=10\n", a)
+ 
+   " Remove all the signs from all the groups in a file
+   exe 'sign place 5 group=g1 line=11 name=sign1 file=' . fname
+   exe 'sign place 6 line=20 name=sign1 file=' . fname
+   exe 'sign place 6 group=g1 line=21 name=sign1 file=' . fname
+   exe 'sign unplace * group=* file=' . fname
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\n", a)
+ 
+   " Remove a particular sign id in a group from all the files
+   exe 'sign place 5 group=g1 line=11 name=sign1 file=' . fname
+   sign unplace 5 group=g1
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\n", a)
+ 
+   " Remove a particular sign id in all the groups from all the files
+   exe 'sign place 5 line=10 name=sign1 file=' . fname
+   exe 'sign place 5 group=g1 line=11 name=sign1 file=' . fname
+   exe 'sign place 5 group=g2 line=12 name=sign1 file=' . fname
+   exe 'sign place 6 line=20 name=sign1 file=' . fname
+   exe 'sign place 6 group=g1 line=21 name=sign1 file=' . fname
+   exe 'sign place 6 group=g2 line=22 name=sign1 file=' . fname
+   sign unplace 5 group=*
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=20  id=6  name=sign1 priority=10\n" .
+ 	      \ "    line=21  id=6  group=g1  name=sign1 priority=10\n" .
+ 	      \ "    line=22  id=6  group=g2  name=sign1 priority=10\n", a)
+ 
+   " Remove all the signs from all the groups in all the files
+   exe 'sign place 5 line=10 name=sign1 file=' . fname
+   exe 'sign place 5 group=g1 line=11 name=sign1 file=' . fname
+   sign unplace * group=*
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\n", a)
+ 
+   " Error cases
+   call assert_fails("exe 'sign place 3 group= name=sign1 buffer=' . bnum", 'E474:')
+ 
+   call delete("Xsign")
+   call sign_unplace('*')
+   call sign_undefine()
+   enew  | only
+ endfunc
+ 
+ " Tests for auto-generating the sign identifier
+ func Test_sign_id_autogen()
+   enew | only
+   call sign_unplace('*')
+   call sign_undefine()
+ 
+   let attr = {'text' : '=>', 'linehl' : 'Search', 'texthl' : 'Error'}
+   call assert_equal(0, sign_define("sign1", attr))
+ 
+   call writefile(repeat(["Sun is shining"], 30), "Xsign")
+   edit Xsign
+ 
+   call assert_equal(1, sign_place(0, '', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 10}))
+   call assert_equal(2, sign_place(2, '', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 12}))
+   call assert_equal(3, sign_place(0, '', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 14}))
+   call sign_unplace('', {'buffer' : 'Xsign', 'id' : 2})
+   call assert_equal(2, sign_place(0, '', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 12}))
+ 
+   call assert_equal(1, sign_place(0, 'g1', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 11}))
+   call assert_equal(0, sign_unplace('g1', {'id' : 1}))
+   call assert_equal(10,
+ 	      \ sign_getplaced('Xsign', {'id' : 1})[0].signs[0].lnum)
+ 
+   call delete("Xsign")
+   call sign_unplace('*')
+   call sign_undefine()
+   enew  | only
+ endfunc
+ 
+ " Test for sign priority
+ func Test_sign_priority()
+   enew | only
+   call sign_unplace('*')
+   call sign_undefine()
+ 
+   let attr = {'text' : '=>', 'linehl' : 'Search', 'texthl' : 'Search'}
+   call sign_define("sign1", attr)
+   call sign_define("sign2", attr)
+   call sign_define("sign3", attr)
+ 
+   " Place three signs with different priority in the same line
+   call writefile(repeat(["Sun is shining"], 30), "Xsign")
+   edit Xsign
+   let fname = fnamemodify('Xsign', ':p')
+ 
+   call sign_place(1, 'g1', 'sign1', 'Xsign',
+ 	      \ {'lnum' : 11, 'priority' : 50})
+   call sign_place(2, 'g2', 'sign2', 'Xsign',
+ 	      \ {'lnum' : 11, 'priority' : 100})
+   call sign_place(3, '', 'sign3', 'Xsign', {'lnum' : 11})
+   let s = sign_getplaced('Xsign', {'group' : '*'})
+   call assert_equal([
+ 	      \ {'id' : 2, 'name' : 'sign2', 'lnum' : 11, 'group' : 'g2',
+ 	      \ 'priority' : 100},
+ 	      \ {'id' : 1, 'name' : 'sign1', 'lnum' : 11, 'group' : 'g1',
+ 	      \ 'priority' : 50},
+ 	      \ {'id' : 3, 'name' : 'sign3', 'lnum' : 11, 'group' : '',
+ 	      \ 'priority' : 10}],
+ 	      \ s[0].signs)
+ 
+   " Error case
+   call assert_fails("call sign_place(1, 'g1', 'sign1', 'Xsign',
+ 	      \ [])", 'E715:')
+   call sign_unplace('*')
+ 
+   " Tests for the :sign place command with priority
+   sign place 5 line=10 name=sign1 priority=30 file=Xsign
+   sign place 5 group=g1 line=10 name=sign1 priority=20 file=Xsign
+   sign place 5 group=g2 line=10 name=sign1 priority=25 file=Xsign
+   let a = execute('sign place group=*')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=10  id=5  name=sign1 priority=30\n" .
+ 	      \ "    line=10  id=5  group=g2  name=sign1 priority=25\n" .
+ 	      \ "    line=10  id=5  group=g1  name=sign1 priority=20\n", a)
+ 
+   " Test for :sign place group={group}
+   let a = execute('sign place group=g1')
+   call assert_equal("\n--- Signs ---\nSigns for Xsign:\n" .
+ 	      \ "    line=10  id=5  group=g1  name=sign1 priority=20\n", a)
+ 
+   call sign_unplace('*')
+   call sign_undefine()
+   enew  | only
+   call delete("Xsign")
+ endfunc
+ 
+ " Tests for memory allocation failures in sign functions
+ func Test_sign_memfailures()
+   call writefile(repeat(["Sun is shining"], 30), "Xsign")
+   edit Xsign
+ 
+   call test_alloc_fail(GetAllocId('sign_getdefined'), 0, 0)
+   call assert_fails('call sign_getdefined("sign1")', 'E342:')
+   call test_alloc_fail(GetAllocId('sign_getplaced'), 0, 0)
+   call assert_fails('call sign_getplaced("Xsign")', 'E342:')
+   call test_alloc_fail(GetAllocId('sign_define_by_name'), 0, 0)
+   let attr = {'text' : '=>', 'linehl' : 'Search', 'texthl' : 'Error'}
+   call assert_fails('call sign_define("sign1", attr)', 'E342:')
+ 
+   let attr = {'text' : '=>', 'linehl' : 'Search', 'texthl' : 'Error'}
+   call sign_define("sign1", attr)
+   call test_alloc_fail(GetAllocId('sign_getlist'), 0, 0)
+   call assert_fails('call sign_getdefined("sign1")', 'E342:')
+ 
+   call sign_place(3, 'g1', 'sign1', 'Xsign', {'lnum' : 10})
+   call test_alloc_fail(GetAllocId('sign_getplaced_dict'), 0, 0)
+   call assert_fails('call sign_getplaced("Xsign")', 'E342:')
+   call test_alloc_fail(GetAllocId('sign_getplaced_list'), 0, 0)
+   call assert_fails('call sign_getplaced("Xsign")', 'E342:')
+ 
+   call test_alloc_fail(GetAllocId('insert_sign'), 0, 0)
+   call assert_fails('call sign_place(4, "g1", "sign1", "Xsign", {"lnum" : 11})',
+ 								\ 'E342:')
+ 
+   call test_alloc_fail(GetAllocId('sign_getinfo'), 0, 0)
+   call assert_fails('call getbufinfo()', 'E342:')
+   call sign_place(4, 'g1', 'sign1', 'Xsign', {'lnum' : 11})
+   call test_alloc_fail(GetAllocId('sign_getinfo'), 0, 0)
+   call assert_fails('let binfo=getbufinfo("Xsign")', 'E342:')
+   call assert_equal([{'lnum': 11, 'id': 4, 'name': 'sign1',
+ 	      \ 'priority': 10, 'group': 'g1'}], binfo[0].signs)
+ 
+   call sign_unplace('*')
+   call sign_undefine()
+   enew  | only
+   call delete("Xsign")
+ endfunc
*** ../vim-8.1.0613/src/workshop.c	2018-09-30 21:43:17.207693209 +0200
--- src/workshop.c	2018-12-21 14:36:57.246303525 +0100
***************
*** 491,497 ****
      lineno = 0;
      buf = buflist_findname((char_u *)filename);
      if (buf != NULL)
! 	lineno = buf_findsign(buf, markId);
  
      return lineno;
  }
--- 491,497 ----
      lineno = 0;
      buf = buflist_findname((char_u *)filename);
      if (buf != NULL)
! 	lineno = buf_findsign(buf, markId, NULL);
  
      return lineno;
  }
*** ../vim-8.1.0613/src/version.c	2018-12-21 13:03:24.296337825 +0100
--- src/version.c	2018-12-21 14:37:53.945927817 +0100
***************
*** 801,802 ****
--- 801,804 ----
  {   /* Add new patch number below this line */
+ /**/
+     614,
  /**/

-- 
hundred-and-one symptoms of being an internet addict:
31. You code your homework in HTML and give your instructor the URL.

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