To: vim-dev@vim.org

Subject: patch 7.1.040

Fcc: outbox

From: Bram Moolenaar <Bram@moolenaar.net>

Mime-Version: 1.0

Content-Type: text/plain; charset=ISO-8859-1

Content-Transfer-Encoding: 8bit

------------

Patch 7.1.040

Problem:    ":match" only supports three matches.

Solution:   Add functions clearmatches(), getmatches(), matchadd(),

	    matchdelete() and setmatches().  Changed the data structures for

	    this.  A small bug in syntax.c is fixed, so newly created

	    highlight groups can have their name resolved correctly from their

	    ID.  (Martin Toft)

Files:	    runtime/doc/eval.txt, runtime/doc/pattern.txt,

	    runtime/doc/usr_41.txt, src/eval.c, src/ex_docmd.c,

	    src/proto/window.pro, src/screen.c, src/structs.h, src/syntax.c,

	    src/testdir/Makefile, src/testdir/test63.in,

	    src/testdir/test63.ok, src/window.c

*** ../vim-7.1.039/runtime/doc/eval.txt	Tue Jul 17 16:31:15 2007

--- runtime/doc/eval.txt	Wed Jul 25 21:05:56 2007

***************

*** 1,4 ****

! *eval.txt*      For Vim version 7.1.  Last change: 2007 Jul 11

  		  VIM REFERENCE MANUAL    by Bram Moolenaar

--- 1,4 ----

! *eval.txt*      For Vim version 7.1.  Last change: 2007 Jul 25

  		  VIM REFERENCE MANUAL    by Bram Moolenaar

***************

*** 1557,1562 ****

--- 1557,1563 ----

  changenr()			Number  current change number

  char2nr( {expr})		Number	ASCII value of first char in {expr}

  cindent( {lnum})		Number	C indent for line {lnum}

+ clearmatches()			None	clear all matches

  col( {expr})			Number	column nr of cursor or mark

  complete({startcol}, {matches})	String  set Insert mode completion

  complete_add( {expr})		Number	add completion match

***************

*** 1622,1627 ****

--- 1623,1629 ----

  getline( {lnum})		String	line {lnum} of current buffer

  getline( {lnum}, {end})		List	lines {lnum} to {end} of current buffer

  getloclist({nr})		List	list of location list items

+ getmatches()			List	list of current matches

  getpos( {expr})			List	position of cursor, mark, etc.

  getqflist()			List	list of quickfix items

  getreg( [{regname} [, 1]])	String	contents of register

***************

*** 1676,1682 ****

--- 1678,1687 ----

  				String	check for mappings matching {name}

  match( {expr}, {pat}[, {start}[, {count}]])

  				Number	position where {pat} matches in {expr}

+ matchadd( {group}, {pattern}[, {priority}[, {id}]])

+ 				Number	highlight {pattern} with {group}

  matcharg( {nr})			List	arguments of |:match|

+ matchdelete( {id})		Number	delete match identified by {id}

  matchend( {expr}, {pat}[, {start}[, {count}]])

  				Number	position where {pat} ends in {expr}

  matchlist( {expr}, {pat}[, {start}[, {count}]])

***************

*** 1731,1736 ****

--- 1736,1742 ----

  setline( {lnum}, {line})	Number	set line {lnum} to {line}

  setloclist( {nr}, {list}[, {action}])

  				Number	modify location list using {list}

+ setmatches( {list})		Number	restore a list of matches

  setpos( {expr}, {list})		none	set the {expr} position to {list}

  setqflist( {list}[, {action}])	Number	modify quickfix list using {list}

  setreg( {n}, {v}[, {opt}])	Number	set register to value and type

***************

*** 2012,2017 ****

--- 2018,2027 ----

  		feature, -1 is returned.

  		See |C-indenting|.

+ clearmatches()						*clearmatches()*

+ 		Clears all matches previously defined by |matchadd()| and the

+ 		|:match| commands.

+ 

  							*col()*

  col({expr})	The result is a Number, which is the byte index of the column

  		position given with {expr}.  The accepted positions are:

***************

*** 2918,2923 ****

--- 2928,2955 ----

  		returned.  For an invalid window number {nr}, an empty list is

  		returned. Otherwise, same as getqflist().

+ getmatches()						*getmatches()*

+ 		Returns a |List| with all matches previously defined by

+ 		|matchadd()| and the |:match| commands.  |getmatches()| is

+ 		useful in combination with |setmatches()|, as |setmatches()|

+ 		can restore a list of matches saved by |getmatches()|.

+ 		Example: >

+ 			:echo getmatches()

+ <			[{'group': 'MyGroup1', 'pattern': 'TODO',

+ 			'priority': 10, 'id': 1}, {'group': 'MyGroup2',

+ 			'pattern': 'FIXME', 'priority': 10, 'id': 2}] >

+ 			:let m = getmatches()

+ 			:call clearmatches()

+ 			:echo getmatches()

+ <			[] >

+ 			:call setmatches(m)

+ 			:echo getmatches()

+ <			[{'group': 'MyGroup1', 'pattern': 'TODO',

+ 			'priority': 10, 'id': 1}, {'group': 'MyGroup2',

+ 			'pattern': 'FIXME', 'priority': 10, 'id': 2}] >

+ 			:unlet m

+ <

+ 

  getqflist()						*getqflist()*

  		Returns a list with all the current quickfix errors.  Each

  		list item is a dictionary with these entries:

***************

*** 3622,3627 ****

--- 3654,3697 ----

  		the pattern.  'smartcase' is NOT used.  The matching is always

  		done like 'magic' is set and 'cpoptions' is empty.

+ 					*matchadd()* *E798* *E799* *E801*

+ matchadd({group}, {pattern}[, {priority}[, {id}]])

+ 		Defines a pattern to be highlighted in the current window (a

+ 		"match").  It will be highlighted with {group}.  Returns an

+ 		identification number (ID), which can be used to delete the

+ 		match using |matchdelete()|.

+ 

+ 		The optional {priority} argument assigns a priority to the

+ 		match.  A match with a high priority will have its

+ 		highlighting overrule that of a match with a lower priority.

+ 		A priority is specified as an integer (negative numbers are no

+ 		exception).  If the {priority} argument is not specified, the

+ 		default priority is 10.  The priority of 'hlsearch' is zero,

+ 		hence all matches with a priority greater than zero will

+ 		overrule it.  Syntax highlighting (see 'syntax') is a separate

+ 		mechanism, and regardless of the chosen priority a match will

+ 		always overrule syntax highlighting.

+ 

+ 		The optional {id} argument allows the request for a specific

+ 		match ID.  If a specified ID is already taken, an error

+ 		message will appear and the match will not be added.  An ID

+ 		is specified as a positive integer (zero excluded).  IDs 1, 2

+ 		and 3 are reserved for |:match|, |:2match| and |:3match|,

+ 		respectively.  If the {id} argument is not specified,

+ 		|matchadd()| automatically chooses a free ID.

+ 

+ 		The number of matches is not limited, as it is the case with

+ 		the |:match| commands.

+ 

+ 		Example: >

+ 			:highlight MyGroup ctermbg=green guibg=green

+ 			:let m = matchadd("MyGroup", "TODO")

+ <		Deletion of the pattern: >

+ 			:call matchdelete(m)

+ 

+ <		A list of matches defined by |matchadd()| and |:match| are

+ 		available from |getmatches()|.  All matches can be deleted in

+ 		one operation by |clearmatches()|.

  matcharg({nr})							*matcharg()*

  		Selects the {nr} match item, as set with a |:match|,

***************

*** 3631,3638 ****

  			The pattern used.

  		When {nr} is not 1, 2 or 3 returns an empty |List|.

  		When there is no match item set returns ['', ''].

! 		This is usef to save and restore a |:match|.

! 

  matchend({expr}, {pat}[, {start}[, {count}]])			*matchend()*

  		Same as match(), but return the index of first character after

--- 3701,3715 ----

  			The pattern used.

  		When {nr} is not 1, 2 or 3 returns an empty |List|.

  		When there is no match item set returns ['', ''].

! 		This is useful to save and restore a |:match|.

! 		Highlighting matches using the |:match| commands are limited

! 		to three matches. |matchadd()| does not have this limitation.

! 

! matchdelete({id})			       *matchdelete()* *E802* *E803*

! 		Deletes a match with ID {id} previously defined by |matchadd()|

! 		or one of the |:match| commands.  Returns 0 if succesfull,

! 		otherwise -1.  See example for |matchadd()|.  All matches can

! 		be deleted in one operation by |clearmatches()|.

  matchend({expr}, {pat}[, {start}[, {count}]])			*matchend()*

  		Same as match(), but return the index of first character after

***************

*** 4385,4391 ****

  		When {nr} is zero the current window is used. For a location

  		list window, the displayed location list is modified.  For an

  		invalid window number {nr}, -1 is returned.

! 		Otherwise, same as setqflist().

  							*setpos()*

  setpos({expr}, {list})

--- 4462,4474 ----

  		When {nr} is zero the current window is used. For a location

  		list window, the displayed location list is modified.  For an

  		invalid window number {nr}, -1 is returned.

! 		Otherwise, same as |setqflist()|.

! 		Also see |location-list|.

! 

! setmatches({list})					*setmatches()*

! 		Restores a list of matches saved by |getmatches()|.  Returns 0

! 		if succesfull, otherwise -1.  All current matches are cleared

! 		before the list is restored.  See example for |getmatches()|.

  							*setpos()*

  setpos({expr}, {list})

*** ../vim-7.1.039/runtime/doc/pattern.txt	Sat May 12 16:57:31 2007

--- runtime/doc/pattern.txt	Tue Jul 24 15:47:01 2007

***************

*** 1212,1218 ****

  		{group} must exist at the moment this command is executed.

  		The {group} highlighting still applies when a character is

! 		to be highlighted for 'hlsearch'.

  		Note that highlighting the last used search pattern with

  		'hlsearch' is used in all windows, while the pattern defined

--- 1212,1221 ----

  		{group} must exist at the moment this command is executed.

  		The {group} highlighting still applies when a character is

! 		to be highlighted for 'hlsearch', as the highlighting for

! 		matches is given higher priority than that of 'hlsearch'.

! 		Syntax highlighting (see 'syntax') is also overruled by

! 		matches.

  		Note that highlighting the last used search pattern with

  		'hlsearch' is used in all windows, while the pattern defined

***************

*** 1226,1233 ****

  		display you may get unexpected results.  That is because Vim

  		looks for a match in the line where redrawing starts.

! 		Also see |matcharg()|, it returns the highlight group and

! 		pattern of a previous :match command.

  		Another example, which highlights all characters in virtual

  		column 72 and more: >

--- 1229,1243 ----

  		display you may get unexpected results.  That is because Vim

  		looks for a match in the line where redrawing starts.

! 		Also see |matcharg()|and |getmatches()|. The former returns

! 		the highlight group and pattern of a previous |:match|

! 		command.  The latter returns a list with highlight groups and

! 		patterns defined by both |matchadd()| and |:match|.

! 

! 		Highlighting matches using |:match| are limited to three

! 		matches (aside from |:match|, |:2match| and |:3match|are

! 		available). |matchadd()| does not have this limitation and in

! 		addition makes it possible to prioritize matches.

  		Another example, which highlights all characters in virtual

  		column 72 and more: >

*** ../vim-7.1.039/runtime/doc/usr_41.txt	Sat May 12 15:54:55 2007

--- runtime/doc/usr_41.txt	Tue Jul 24 15:47:01 2007

***************

*** 763,775 ****

--- 763,784 ----

  	foldtextresult()	get the text displayed for a closed fold

  Syntax and highlighting:

+ 	clearmatches()		clear all matches defined by |matchadd()| and

+ 				the |:match| commands

+ 	getmatches()		get all matches defined by |matchadd()| and

+ 				the |:match| commands

  	hlexists()		check if a highlight group exists

  	hlID()			get ID of a highlight group

  	synID()			get syntax ID at a specific position

  	synIDattr()		get a specific attribute of a syntax ID

  	synIDtrans()		get translated syntax ID

  	diff_hlID()		get highlight ID for diff mode at a position

+ 	matchadd()		define a pattern to highlight (a "match")

  	matcharg()		get info about |:match| arguments

+ 	matchdelete()		delete a match defined by |matchadd()| or a

+ 				|:match| command

+ 	setmatches()		restore a list of matches saved by

+ 				|getmatches()|

  Spelling:

  	spellbadword()		locate badly spelled word at or after cursor

*** ../vim-7.1.039/src/eval.c	Tue Jul 24 14:32:44 2007

--- src/eval.c	Tue Jul 24 20:40:52 2007

***************

*** 475,480 ****

--- 475,481 ----

  static void f_changenr __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_char2nr __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_cindent __ARGS((typval_T *argvars, typval_T *rettv));

+ static void f_clearmatches __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_col __ARGS((typval_T *argvars, typval_T *rettv));

  #if defined(FEAT_INS_EXPAND)

  static void f_complete __ARGS((typval_T *argvars, typval_T *rettv));

***************

*** 529,534 ****

--- 530,536 ----

  static void f_getftime __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_getftype __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_getline __ARGS((typval_T *argvars, typval_T *rettv));

+ static void f_getmatches __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_getpos __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_getqflist __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_getreg __ARGS((typval_T *argvars, typval_T *rettv));

***************

*** 577,583 ****

--- 579,587 ----

  static void f_maparg __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_mapcheck __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_match __ARGS((typval_T *argvars, typval_T *rettv));

+ static void f_matchadd __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_matcharg __ARGS((typval_T *argvars, typval_T *rettv));

+ static void f_matchdelete __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_matchend __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_matchlist __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_matchstr __ARGS((typval_T *argvars, typval_T *rettv));

***************

*** 618,623 ****

--- 622,628 ----

  static void f_setcmdpos __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_setline __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_setloclist __ARGS((typval_T *argvars, typval_T *rettv));

+ static void f_setmatches __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_setpos __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_setqflist __ARGS((typval_T *argvars, typval_T *rettv));

  static void f_setreg __ARGS((typval_T *argvars, typval_T *rettv));

***************

*** 7046,7051 ****

--- 7051,7057 ----

      {"changenr",	0, 0, f_changenr},

      {"char2nr",		1, 1, f_char2nr},

      {"cindent",		1, 1, f_cindent},

+     {"clearmatches",	0, 0, f_clearmatches},

      {"col",		1, 1, f_col},

  #if defined(FEAT_INS_EXPAND)

      {"complete",	2, 2, f_complete},

***************

*** 7102,7107 ****

--- 7108,7114 ----

      {"getftype",	1, 1, f_getftype},

      {"getline",		1, 2, f_getline},

      {"getloclist",	1, 1, f_getqflist},

+     {"getmatches",  	0, 0, f_getmatches},

      {"getpos",		1, 1, f_getpos},

      {"getqflist",	0, 0, f_getqflist},

      {"getreg",		0, 2, f_getreg},

***************

*** 7152,7158 ****

--- 7159,7167 ----

      {"maparg",		1, 3, f_maparg},

      {"mapcheck",	1, 3, f_mapcheck},

      {"match",		2, 4, f_match},

+     {"matchadd",	2, 4, f_matchadd},

      {"matcharg",	1, 1, f_matcharg},

+     {"matchdelete",	1, 1, f_matchdelete},

      {"matchend",	2, 4, f_matchend},

      {"matchlist",	2, 4, f_matchlist},

      {"matchstr",	2, 4, f_matchstr},

***************

*** 7193,7198 ****

--- 7202,7208 ----

      {"setcmdpos",	1, 1, f_setcmdpos},

      {"setline",		2, 2, f_setline},

      {"setloclist",	2, 3, f_setloclist},

+     {"setmatches",	1, 1, f_setmatches},

      {"setpos",		2, 2, f_setpos},

      {"setqflist",	1, 2, f_setqflist},

      {"setreg",		2, 3, f_setreg},

***************

*** 8243,8248 ****

--- 8253,8272 ----

  }

  /*

+  * "clearmatches()" function

+  */

+ /*ARGSUSED*/

+     static void

+ f_clearmatches(argvars, rettv)

+     typval_T	*argvars;

+     typval_T	*rettv;

+ {

+ #ifdef FEAT_SEARCH_EXTRA

+     clear_matches(curwin);

+ #endif

+ }

+ 

+ /*

   * "col(string)" function

   */

      static void

***************

*** 10278,10283 ****

--- 10302,10341 ----

  }

  /*

+  * "getmatches()" function

+  */

+ /*ARGSUSED*/

+     static void

+ f_getmatches(argvars, rettv)

+     typval_T	*argvars;

+     typval_T	*rettv;

+ {

+ #ifdef FEAT_SEARCH_EXTRA

+     dict_T	*dict;

+     matchitem_T	*cur = curwin->w_match_head;

+ 

+     rettv->vval.v_number = 0;

+ 

+     if (rettv_list_alloc(rettv) == OK)

+     {

+ 	while (cur != NULL)

+ 	{

+ 	    dict = dict_alloc();

+ 	    if (dict == NULL)

+ 		return;

+ 	    ++dict->dv_refcount;

+ 	    dict_add_nr_str(dict, "group", 0L, syn_id2name(cur->hlg_id));

+ 	    dict_add_nr_str(dict, "pattern", 0L, cur->pattern);

+ 	    dict_add_nr_str(dict, "priority", (long)cur->priority, NULL);

+ 	    dict_add_nr_str(dict, "id", (long)cur->id, NULL);

+ 	    list_append_dict(rettv->vval.v_list, dict);

+ 	    cur = cur->next;

+ 	}

+     }

+ #endif

+ }

+ 

+ /*

   * "getpos(string)" function

   */

      static void

***************

*** 12448,12453 ****

--- 12506,12547 ----

  }

  /*

+  * "matchadd()" function

+  */

+     static void

+ f_matchadd(argvars, rettv)

+     typval_T	*argvars;

+     typval_T	*rettv;

+ {

+ #ifdef FEAT_SEARCH_EXTRA

+     char_u	buf[NUMBUFLEN];

+     char_u	*grp = get_tv_string_buf_chk(&argvars[0], buf);	/* group */

+     char_u	*pat = get_tv_string_buf_chk(&argvars[1], buf);	/* pattern */

+     int		prio = 10;	/* default priority */

+     int		id = -1;

+     int		error = FALSE;

+ 

+     rettv->vval.v_number = -1;

+ 

+     if (grp == NULL || pat == NULL)

+ 	return;

+     if (argvars[2].v_type != VAR_UNKNOWN)

+ 	prio = get_tv_number_chk(&argvars[2], &error);

+     if (argvars[3].v_type != VAR_UNKNOWN)

+ 	id = get_tv_number_chk(&argvars[3], &error);

+     if (error == TRUE)

+ 	return;

+     if (id >= 1 && id <= 3)

+     {

+ 	EMSGN("E798: ID is reserved for \":match\": %ld", id);

+ 	return;

+     }

+ 

+     rettv->vval.v_number = match_add(curwin, grp, pat, prio, id);

+ #endif

+ }

+ 

+ /*

   * "matcharg()" function

   */

      static void

***************

*** 12458,12477 ****

      if (rettv_list_alloc(rettv) == OK)

      {

  #ifdef FEAT_SEARCH_EXTRA

! 	int	mi = get_tv_number(&argvars[0]);

! 	if (mi >= 1 && mi <= 3)

  	{

! 	    list_append_string(rettv->vval.v_list,

! 				 syn_id2name(curwin->w_match_id[mi - 1]), -1);

! 	    list_append_string(rettv->vval.v_list,

! 					     curwin->w_match_pat[mi - 1], -1);

  	}

  #endif

      }

  }

  /*

   * "matchend()" function

   */

      static void

--- 12552,12593 ----

      if (rettv_list_alloc(rettv) == OK)

      {

  #ifdef FEAT_SEARCH_EXTRA

! 	int	    id = get_tv_number(&argvars[0]);

! 	matchitem_T *m;

! 	if (id >= 1 && id <= 3)

  	{

! 	    if ((m = (matchitem_T *)get_match(curwin, id)) != NULL)

! 	    {

! 		list_append_string(rettv->vval.v_list,

! 						syn_id2name(m->hlg_id), -1);

! 		list_append_string(rettv->vval.v_list, m->pattern, -1);

! 	    }

! 	    else

! 	    {

! 		list_append_string(rettv->vval.v_list, NUL, -1);

! 		list_append_string(rettv->vval.v_list, NUL, -1);

! 	    }

  	}

  #endif

      }

  }

  /*

+  * "matchdelete()" function

+  */

+     static void

+ f_matchdelete(argvars, rettv)

+     typval_T	*argvars;

+     typval_T	*rettv;

+ {

+ #ifdef FEAT_SEARCH_EXTRA

+     rettv->vval.v_number = match_delete(curwin,

+ 				       (int)get_tv_number(&argvars[0]), TRUE);

+ #endif

+ }

+ 

+ /*

   * "matchend()" function

   */

      static void

***************

*** 14506,14511 ****

--- 14622,14687 ----

      win = find_win_by_nr(&argvars[0], NULL);

      if (win != NULL)

  	set_qf_ll_list(win, &argvars[1], &argvars[2], rettv);

+ }

+ 

+ /*

+  * "setmatches()" function

+  */

+     static void

+ f_setmatches(argvars, rettv)

+     typval_T	*argvars;

+     typval_T	*rettv;

+ {

+ #ifdef FEAT_SEARCH_EXTRA

+     list_T	*l;

+     listitem_T	*li;

+     dict_T	*d;

+ 

+     rettv->vval.v_number = -1;

+     if (argvars[0].v_type != VAR_LIST)

+     {

+ 	EMSG(_(e_listreq));

+ 	return;

+     }

+     if ((l = argvars[0].vval.v_list) != NULL)

+     {

+ 

+ 	/* To some extent make sure that we are dealing with a list from

+ 	 * "getmatches()". */

+ 	li = l->lv_first;

+ 	while (li != NULL)

+ 	{

+ 	    if (li->li_tv.v_type != VAR_DICT

+ 		    || (d = li->li_tv.vval.v_dict) == NULL)

+ 	    {

+ 		EMSG(_(e_invarg));

+ 		return;

+ 	    }

+ 	    if (!(dict_find(d, (char_u *)"group", -1) != NULL

+ 			&& dict_find(d, (char_u *)"pattern", -1) != NULL

+ 			&& dict_find(d, (char_u *)"priority", -1) != NULL

+ 			&& dict_find(d, (char_u *)"id", -1) != NULL))

+ 	    {

+ 		EMSG(_(e_invarg));

+ 		return;

+ 	    }

+ 	    li = li->li_next;

+ 	}

+ 

+ 	clear_matches(curwin);

+ 	li = l->lv_first;

+ 	while (li != NULL)

+ 	{

+ 	    d = li->li_tv.vval.v_dict;

+ 	    match_add(curwin, get_dict_string(d, (char_u *)"group", FALSE),

+ 		    get_dict_string(d, (char_u *)"pattern", FALSE),

+ 		    (int)get_dict_number(d, (char_u *)"priority"),

+ 		    (int)get_dict_number(d, (char_u *)"id"));

+ 	    li = li->li_next;

+ 	}

+ 	rettv->vval.v_number = 0;

+     }

+ #endif

  }

  /*

*** ../vim-7.1.039/src/ex_docmd.c	Tue Jul 24 14:32:44 2007

--- src/ex_docmd.c	Tue Jul 24 15:47:01 2007

***************

*** 10817,10828 ****

      exarg_T	*eap;

  {

      char_u	*p;

      char_u	*end;

      int		c;

!     int		mi;

      if (eap->line2 <= 3)

! 	mi = eap->line2 - 1;

      else

      {

  	EMSG(e_invcmd);

--- 10817,10829 ----

      exarg_T	*eap;

  {

      char_u	*p;

+     char_u	*g;

      char_u	*end;

      int		c;

!     int		id;

      if (eap->line2 <= 3)

! 	id = eap->line2;

      else

      {

  	EMSG(e_invcmd);

***************

*** 10831,10843 ****

      /* First clear any old pattern. */

      if (!eap->skip)

!     {

! 	vim_free(curwin->w_match[mi].regprog);

! 	curwin->w_match[mi].regprog = NULL;

! 	vim_free(curwin->w_match_pat[mi]);

! 	curwin->w_match_pat[mi] = NULL;

! 	redraw_later(SOME_VALID);	/* always need a redraw */

!     }

      if (ends_excmd(*eap->arg))

  	end = eap->arg;

--- 10832,10838 ----

      /* First clear any old pattern. */

      if (!eap->skip)

! 	match_delete(curwin, id, FALSE);

      if (ends_excmd(*eap->arg))

  	end = eap->arg;

***************

*** 10848,10862 ****

      {

  	p = skiptowhite(eap->arg);

  	if (!eap->skip)

! 	{

! 	    curwin->w_match_id[mi] = syn_namen2id(eap->arg,

! 							 (int)(p - eap->arg));

! 	    if (curwin->w_match_id[mi] == 0)

! 	    {

! 		EMSG2(_(e_nogroup), eap->arg);

! 		return;

! 	    }

! 	}

  	p = skipwhite(p);

  	if (*p == NUL)

  	{

--- 10843,10849 ----

      {

  	p = skiptowhite(eap->arg);

  	if (!eap->skip)

! 	    g = vim_strnsave(eap->arg, (int)(p - eap->arg));

  	p = skipwhite(p);

  	if (*p == NUL)

  	{

***************

*** 10880,10893 ****

  	    c = *end;

  	    *end = NUL;

! 	    curwin->w_match[mi].regprog = vim_regcomp(p + 1, RE_MAGIC);

! 	    if (curwin->w_match[mi].regprog == NULL)

! 	    {

! 		EMSG2(_(e_invarg2), p);

! 		*end = c;

! 		return;

! 	    }

! 	    curwin->w_match_pat[mi] = vim_strsave(p + 1);

  	    *end = c;