To: vim_dev@googlegroups.com

Subject: Patch 7.4.330

Fcc: outbox

From: Bram Moolenaar <Bram@moolenaar.net>

Mime-Version: 1.0

Content-Type: text/plain; charset=UTF-8

Content-Transfer-Encoding: 8bit

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

Patch 7.4.330

Problem:    Using a regexp pattern to highlight a specific position can be

	    slow.

Solution:   Add matchaddpos() to highlight specific positions efficiently.

	    (Alexey Radkov)

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

	    runtime/plugin/matchparen.vim, src/eval.c, src/ex_docmd.c,

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

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

*** ../vim-7.4.329/runtime/doc/eval.txt	2014-05-28 20:31:37.500292805 +0200

--- runtime/doc/eval.txt	2014-06-17 16:31:35.572453748 +0200

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

*** 1887,1892 ****

--- 1887,1894 ----

  				Number	position where {pat} matches in {expr}

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

  				Number	highlight {pattern} with {group}

+ matchaddpos( {group}, {list}[, {priority}[, {id}]])

+ 				Number	highlight positions with {group}

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

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

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

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

*** 4342,4347 ****

--- 4382,4422 ----

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

  		one operation by |clearmatches()|.

+ matchaddpos({group}, {pos}[, {priority}[, {id}]])		*matchaddpos()*

+ 		Same as |matchadd()|, but requires a list of positions {pos}

+ 		instead of a pattern. This command is faster than |matchadd()|

+ 		because it does not require to handle regular expressions and

+ 		sets buffer line boundaries to redraw screen. It is supposed

+ 		to be used when fast match additions and deletions are

+ 		required, for example to highlight matching parentheses.

+ 

+ 		The list {pos} can contain one of these items:

+ 		- A number.  This while line will be highlighted.  The first

+ 		  line has number 1.

+ 		- A list with one number, e.g., [23]. The whole line with this

+ 		  number will be highlighted.

+ 		- A list with two numbers, e.g., [23, 11]. The first number is

+ 		  the line number, the second one the column number (first

+ 		  column is 1).  The character at this position will be

+ 		  highlighted.

+ 		- A list with three numbers, e.g., [23, 11, 3]. As above, but

+ 		  the third number gives the length of the highlight in screen

+ 		  cells.

+ 		

+ 		The maximum number of positions is 8.

+ 

+ 		Example: >

+ 			:highlight MyGroup ctermbg=green guibg=green

+ 			:let m = matchaddpos("MyGroup", [[23, 24], 34])

+ <		Deletion of the pattern: >

+ 			:call matchdelete(m)

+ 

+ <		Matches added by |matchaddpos()| are returned by

+ 		|getmatches()| with an entry "pos1", "pos2", etc., with the

+ 		value a list like the {pos} item.

+ 		These matches cannot be set via |setmatches()|, however they

+ 		can still be deleted by |clearmatches()|.

+ 

  matcharg({nr})							*matcharg()*

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

  		|:2match| or |:3match| command.

*** ../vim-7.4.329/runtime/doc/usr_41.txt	2014-05-28 18:22:37.872225054 +0200

--- runtime/doc/usr_41.txt	2014-06-17 14:06:44.836124965 +0200

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

*** 824,829 ****

--- 827,833 ----

  	synconcealed()		get info about concealing

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

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

+ 	matchaddpos()		define a list of positions to highlight

  	matcharg()		get info about |:match| arguments

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

  				|:match| command

*** ../vim-7.4.329/runtime/plugin/matchparen.vim	2013-05-08 05:15:53.000000000 +0200

--- runtime/plugin/matchparen.vim	2014-06-17 14:14:45.712143158 +0200

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

*** 1,6 ****

  " Vim plugin for showing matching parens

  " Maintainer:  Bram Moolenaar <Bram@vim.org>

! " Last Change: 2013 May 08

  " Exit quickly when:

  " - this plugin was already loaded (or disabled)

--- 1,6 ----

  " Vim plugin for showing matching parens

  " Maintainer:  Bram Moolenaar <Bram@vim.org>

! " Last Change: 2014 Jun 17

  " Exit quickly when:

  " - this plugin was already loaded (or disabled)

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

*** 39,45 ****

  function! s:Highlight_Matching_Pair()

    " Remove any previous match.

    if exists('w:paren_hl_on') && w:paren_hl_on

!     3match none

      let w:paren_hl_on = 0

    endif

--- 39,45 ----

  function! s:Highlight_Matching_Pair()

    " Remove any previous match.

    if exists('w:paren_hl_on') && w:paren_hl_on

!     silent! call matchdelete(3)

      let w:paren_hl_on = 0

    endif

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

*** 152,165 ****

    " If a match is found setup match highlighting.

    if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom 

!     exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) .

! 	  \ 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/'

      let w:paren_hl_on = 1

    endif

  endfunction

  " Define commands that will disable and enable the plugin.

! command! NoMatchParen windo 3match none | unlet! g:loaded_matchparen |

  	  \ au! matchparen

  command! DoMatchParen runtime plugin/matchparen.vim | windo doau CursorMoved

--- 152,169 ----

    " If a match is found setup match highlighting.

    if m_lnum > 0 && m_lnum >= stoplinetop && m_lnum <= stoplinebottom 

!     if exists('*matchaddpos')

!       call matchaddpos('MatchParen', [[c_lnum, c_col - before], [m_lnum, m_col]], 10, 3)

!     else

!       exe '3match MatchParen /\(\%' . c_lnum . 'l\%' . (c_col - before) .

! 	    \ 'c\)\|\(\%' . m_lnum . 'l\%' . m_col . 'c\)/'

!     endif

      let w:paren_hl_on = 1

    endif

  endfunction

  " Define commands that will disable and enable the plugin.

! command! NoMatchParen windo silent! call matchdelete(3) | unlet! g:loaded_matchparen |

  	  \ au! matchparen

  command! DoMatchParen runtime plugin/matchparen.vim | windo doau CursorMoved

*** ../vim-7.4.329/src/eval.c	2014-06-17 12:51:13.207953527 +0200

--- src/eval.c	2014-06-17 17:02:25.388523729 +0200

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

*** 622,627 ****

--- 622,628 ----

  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_matchaddpos __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));

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

*** 8054,8059 ****

--- 8055,8061 ----

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

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

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

+     {"matchaddpos",	2, 4, f_matchaddpos},

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

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

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

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

*** 11767,11772 ****

--- 11769,11775 ----

  #ifdef FEAT_SEARCH_EXTRA

      dict_T	*dict;

      matchitem_T	*cur = curwin->w_match_head;

+     int		i;

      if (rettv_list_alloc(rettv) == OK)

      {

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

*** 11775,11782 ****

  	    dict = dict_alloc();

  	    if (dict == NULL)

  		return;

  	    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);

--- 11778,11813 ----

  	    dict = dict_alloc();

  	    if (dict == NULL)

  		return;

+ 	    if (cur->match.regprog == NULL)

+ 	    {

+ 		/* match added with matchaddpos() */

+ 		for (i = 0; i < MAXPOSMATCH; ++i)

+ 		{

+ 		    llpos_T	*llpos;

+ 		    char	buf[6];

+ 		    list_T	*l;

+ 

+ 		    llpos = &cur->pos.pos[i];

+ 		    if (llpos->lnum == 0)

+ 			break;

+ 		    l = list_alloc();

+ 		    if (l == NULL)

+ 			break;

+ 		    list_append_number(l, (varnumber_T)llpos->lnum);

+ 		    if (llpos->col > 0)

+ 		    {

+ 			list_append_number(l, (varnumber_T)llpos->col);

+ 			list_append_number(l, (varnumber_T)llpos->len);

+ 		    }

+ 		    sprintf(buf, "pos%d", i + 1);

+ 		    dict_add_list(dict, buf, l);

+ 		}

+ 	    }

+ 	    else

+ 	    {

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

+ 	    }

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

  	    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);

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

*** 14313,14319 ****

  	return;

      }

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

  #endif

  }

--- 14344,14401 ----

  	return;

      }

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

! #endif

! }

! 

! /*

!  * "matchaddpos()" function

!  */

!     static void

! f_matchaddpos(argvars, rettv)

!     typval_T	*argvars UNUSED;

!     typval_T	*rettv UNUSED;

! {

! #ifdef FEAT_SEARCH_EXTRA

!     char_u	buf[NUMBUFLEN];

!     char_u	*group;

!     int		prio = 10;

!     int		id = -1;

!     int		error = FALSE;

!     list_T	*l;

! 

!     rettv->vval.v_number = -1;

! 

!     group = get_tv_string_buf_chk(&argvars[0], buf);

!     if (group == NULL)

! 	return;

! 

!     if (argvars[1].v_type != VAR_LIST)

!     {

! 	EMSG2(_(e_listarg), "matchaddpos()");

! 	return;

!     }

!     l = argvars[1].vval.v_list;

!     if (l == 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;

! 

!     /* id == 3 is ok because matchaddpos() is supposed to substitute :3match */

!     if (id == 1 || id == 2)

!     {

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

! 	return;

!     }

! 

!     rettv->vval.v_number = match_add(curwin, group, NULL, prio, id, l);

  #endif

  }

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

*** 16816,16822 ****

  	    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;

--- 16898,16904 ----

  	    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"), NULL);

  	    li = li->li_next;

  	}

  	rettv->vval.v_number = 0;

*** ../vim-7.4.329/src/ex_docmd.c	2014-05-28 18:22:37.876225054 +0200

--- src/ex_docmd.c	2014-06-17 14:06:44.844124966 +0200

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

*** 11489,11495 ****

  	    c = *end;

  	    *end = NUL;

! 	    match_add(curwin, g, p + 1, 10, id);

  	    vim_free(g);

  	    *end = c;

  	}

--- 11489,11495 ----

  	    c = *end;

  	    *end = NUL;

! 	    match_add(curwin, g, p + 1, 10, id, NULL);

  	    vim_free(g);

  	    *end = c;

  	}

*** ../vim-7.4.329/src/proto/window.pro	2013-08-14 17:11:14.000000000 +0200

--- src/proto/window.pro	2014-06-17 14:06:44.844124966 +0200

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

*** 75,81 ****

  void switch_buffer __ARGS((buf_T **save_curbuf, buf_T *buf));

  void restore_buffer __ARGS((buf_T *save_curbuf));

  int win_hasvertsplit __ARGS((void));

! int match_add __ARGS((win_T *wp, char_u *grp, char_u *pat, int prio, int id));

  int match_delete __ARGS((win_T *wp, int id, int perr));

  void clear_matches __ARGS((win_T *wp));

  matchitem_T *get_match __ARGS((win_T *wp, int id));

--- 75,81 ----

  void switch_buffer __ARGS((buf_T **save_curbuf, buf_T *buf));

  void restore_buffer __ARGS((buf_T *save_curbuf));

  int win_hasvertsplit __ARGS((void));

! int match_add __ARGS((win_T *wp, char_u *grp, char_u *pat, int prio, int id, list_T *pos));

  int match_delete __ARGS((win_T *wp, int id, int perr));

  void clear_matches __ARGS((win_T *wp));

  matchitem_T *get_match __ARGS((win_T *wp, int id));

*** ../vim-7.4.329/src/screen.c	2014-05-28 21:40:47.092329130 +0200

--- src/screen.c	2014-06-17 17:04:08.064527614 +0200

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

*** 144,150 ****

  static void end_search_hl __ARGS((void));

  static void init_search_hl __ARGS((win_T *wp));

  static void prepare_search_hl __ARGS((win_T *wp, linenr_T lnum));

! static void next_search_hl __ARGS((win_T *win, match_T *shl, linenr_T lnum, colnr_T mincol));

  #endif

  static void screen_start_highlight __ARGS((int attr));

  static void screen_char __ARGS((unsigned off, int row, int col));

--- 144,151 ----

  static void end_search_hl __ARGS((void));

  static void init_search_hl __ARGS((win_T *wp));

  static void prepare_search_hl __ARGS((win_T *wp, linenr_T lnum));

! static void next_search_hl __ARGS((win_T *win, match_T *shl, linenr_T lnum, colnr_T mincol, matchitem_T *cur));

! static int next_search_hl_pos __ARGS((match_T *shl, linenr_T lnum, posmatch_T *pos, colnr_T mincol));

  #endif

  static void screen_start_highlight __ARGS((int attr));

  static void screen_char __ARGS((unsigned off, int row, int col));

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

*** 2929,2934 ****

--- 2930,2937 ----

      match_T	*shl;			/* points to search_hl or a match */

      int		shl_flag;		/* flag to indicate whether search_hl

  					   has been processed or not */

+     int		pos_inprogress;		/* marks that position match search is

+ 					   in progress */

      int		prevcol_hl_flag;	/* flag to indicate whether prevcol

  					   equals startcol of search_hl or one

  					   of the matches */

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

*** 3439,3482 ****

  	shl->startcol = MAXCOL;

  	shl->endcol = MAXCOL;

  	shl->attr_cur = 0;

! 	if (shl->rm.regprog != NULL)

! 	{

! 	    v = (long)(ptr - line);

! 	    next_search_hl(wp, shl, lnum, (colnr_T)v);

! 

! 	    /* Need to get the line again, a multi-line regexp may have made it

! 	     * invalid. */

! 	    line = ml_get_buf(wp->w_buffer, lnum, FALSE);

! 	    ptr = line + v;

! 	    if (shl->lnum != 0 && shl->lnum <= lnum)

  	    {

- 		if (shl->lnum == lnum)

- 		    shl->startcol = shl->rm.startpos[0].col;

- 		else

- 		    shl->startcol = 0;

- 		if (lnum == shl->lnum + shl->rm.endpos[0].lnum

- 						  - shl->rm.startpos[0].lnum)

- 		    shl->endcol = shl->rm.endpos[0].col;

- 		else

- 		    shl->endcol = MAXCOL;

- 		/* Highlight one character for an empty match. */

- 		if (shl->startcol == shl->endcol)

- 		{

  #ifdef FEAT_MBYTE

! 		    if (has_mbyte && line[shl->endcol] != NUL)

! 			shl->endcol += (*mb_ptr2len)(line + shl->endcol);

! 		    else

  #endif

! 			++shl->endcol;

! 		}

! 		if ((long)shl->startcol < v)  /* match at leftcol */

! 		{

! 		    shl->attr_cur = shl->attr;

! 		    search_attr = shl->attr;

! 		}

! 		area_highlighting = TRUE;

  	    }

  	}

  	if (shl != &search_hl && cur != NULL)

  	    cur = cur->next;

--- 3442,3484 ----

  	shl->startcol = MAXCOL;

  	shl->endcol = MAXCOL;

  	shl->attr_cur = 0;

! 	v = (long)(ptr - line);

! 	if (cur != NULL)

! 	    cur->pos.cur = 0;

! 	next_search_hl(wp, shl, lnum, (colnr_T)v, cur);

! 

! 	/* Need to get the line again, a multi-line regexp may have made it

! 	 * invalid. */

! 	line = ml_get_buf(wp->w_buffer, lnum, FALSE);

! 	ptr = line + v;

! 	if (shl->lnum != 0 && shl->lnum <= lnum)

! 	{

! 	    if (shl->lnum == lnum)

! 		shl->startcol = shl->rm.startpos[0].col;

! 	    else

! 		shl->startcol = 0;

! 	    if (lnum == shl->lnum + shl->rm.endpos[0].lnum

! 						- shl->rm.startpos[0].lnum)

! 		shl->endcol = shl->rm.endpos[0].col;

! 	    else

! 		shl->endcol = MAXCOL;

! 	    /* Highlight one character for an empty match. */

! 	    if (shl->startcol == shl->endcol)

  	    {

  #ifdef FEAT_MBYTE

! 		if (has_mbyte && line[shl->endcol] != NUL)

! 		    shl->endcol += (*mb_ptr2len)(line + shl->endcol);

! 		else

  #endif

! 		    ++shl->endcol;

  	    }

+ 	    if ((long)shl->startcol < v)  /* match at leftcol */

+ 	    {

+ 		shl->attr_cur = shl->attr;

+ 		search_attr = shl->attr;

+ 	    }

+ 	    area_highlighting = TRUE;

  	}

  	if (shl != &search_hl && cur != NULL)

  	    cur = cur->next;

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

*** 3488,3494 ****

       * when Visual mode is active, because it's not clear what is selected

       * then. */

      if (wp->w_p_cul && lnum == wp->w_cursor.lnum

! 					 && !(wp == curwin  && VIsual_active))

      {

  	line_attr = hl_attr(HLF_CUL);

  	area_highlighting = TRUE;

--- 3490,3496 ----

       * when Visual mode is active, because it's not clear what is selected

       * then. */

      if (wp->w_p_cul && lnum == wp->w_cursor.lnum

! 					 && !(wp == curwin && VIsual_active))

      {

  	line_attr = hl_attr(HLF_CUL);

  	area_highlighting = TRUE;

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

*** 3792,3798 ****

  		    }

  		    else

  			shl = &cur->hl;

! 		    while (shl->rm.regprog != NULL)

  		    {

  			if (shl->startcol != MAXCOL

  				&& v >= (long)shl->startcol

--- 3794,3804 ----

  		    }

  		    else

  			shl = &cur->hl;

! 		    if (cur != NULL)

! 			cur->pos.cur = 0;

! 		    pos_inprogress = TRUE;

! 		    while (shl->rm.regprog != NULL

! 					   || (cur != NULL && pos_inprogress))

  		    {

  			if (shl->startcol != MAXCOL

  				&& v >= (long)shl->startcol

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

*** 3803,3810 ****

  			else if (v == (long)shl->endcol)

  			{

  			    shl->attr_cur = 0;

! 

! 			    next_search_hl(wp, shl, lnum, (colnr_T)v);

  			    /* Need to get the line again, a multi-line regexp

  			     * may have made it invalid. */

--- 3809,3817 ----

  			else if (v == (long)shl->endcol)

  			{

  			    shl->attr_cur = 0;

! 			    next_search_hl(wp, shl, lnum, (colnr_T)v, cur);

! 			    pos_inprogress = cur == NULL || cur->pos.cur == 0

! 							      ? FALSE : TRUE;

  			    /* Need to get the line again, a multi-line regexp

  			     * may have made it invalid. */

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

*** 7277,7282 ****

--- 7284,7291 ----

      match_T	*shl;		/* points to search_hl or a match */

      int		shl_flag;	/* flag to indicate whether search_hl

  				   has been processed or not */

+     int		pos_inprogress;	/* marks that position match search is

+ 				   in progress */

      int		n;

      /*

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

*** 7311,7320 ****

  		shl->first_lnum = wp->w_topline;

  # endif

  	    }

  	    n = 0;

! 	    while (shl->first_lnum < lnum && shl->rm.regprog != NULL)

  	    {

! 		next_search_hl(wp, shl, shl->first_lnum, (colnr_T)n);

  		if (shl->lnum != 0)

  		{

  		    shl->first_lnum = shl->lnum

--- 7320,7335 ----

  		shl->first_lnum = wp->w_topline;

  # endif

  	    }

+ 	    if (cur != NULL)

+ 		cur->pos.cur = 0;

+ 	    pos_inprogress = TRUE;

  	    n = 0;

! 	    while (shl->first_lnum < lnum && (shl->rm.regprog != NULL

! 					  || (cur != NULL && pos_inprogress)))

  	    {

! 		next_search_hl(wp, shl, shl->first_lnum, (colnr_T)n, cur);

! 		pos_inprogress = cur == NULL || cur->pos.cur == 0

! 							      ? FALSE : TRUE;

  		if (shl->lnum != 0)

  		{

  		    shl->first_lnum = shl->lnum

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

*** 7343,7353 ****

   * Careful: Any pointers for buffer lines will become invalid.

   */

      static void

! next_search_hl(win, shl, lnum, mincol)

!     win_T	*win;

!     match_T	*shl;		/* points to search_hl or a match */

!     linenr_T	lnum;

!     colnr_T	mincol;		/* minimal column for a match */

  {

      linenr_T	l;

      colnr_T	matchcol;

--- 7358,7369 ----

   * Careful: Any pointers for buffer lines will become invalid.

   */

      static void

! next_search_hl(win, shl, lnum, mincol, cur)

!     win_T	    *win;

!     match_T	    *shl;	/* points to search_hl or a match */

!     linenr_T	    lnum;

!     colnr_T	    mincol;	/* minimal column for a match */

!     matchitem_T	    *cur;	/* to retrieve match postions if any */

  {

      linenr_T	l;

      colnr_T	matchcol;

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

*** 7415,7440 ****

  	    matchcol = shl->rm.endpos[0].col;

  	shl->lnum = lnum;

! 	nmatched = vim_regexec_multi(&shl->rm, win, shl->buf, lnum, matchcol,

  #ifdef FEAT_RELTIME

! 		&(shl->tm)

  #else

! 		NULL

  #endif

! 		);

! 	if (called_emsg || got_int)

! 	{

! 	    /* Error while handling regexp: stop using this regexp. */

! 	    if (shl == &search_hl)

  	    {

! 		/* don't free regprog in the match list, it's a copy */

! 		vim_regfree(shl->rm.regprog);

! 		SET_NO_HLSEARCH(TRUE);

  	    }

! 	    shl->rm.regprog = NULL;

! 	    shl->lnum = 0;

! 	    got_int = FALSE;  /* avoid the "Type :quit to exit Vim" message */

! 	    break;

  	}

  	if (nmatched == 0)

  	{

--- 7431,7465 ----

  	    matchcol = shl->rm.endpos[0].col;

  	shl->lnum = lnum;

! 	if (shl->rm.regprog != NULL)

! 	{

! 	    nmatched = vim_regexec_multi(&shl->rm, win, shl->buf, lnum,

! 		    matchcol,

  #ifdef FEAT_RELTIME

! 		    &(shl->tm)

  #else

! 		    NULL

  #endif

! 		    );

! 	    if (called_emsg || got_int)

  	    {

! 		/* Error while handling regexp: stop using this regexp. */

! 		if (shl == &search_hl)

! 		{

! 		    /* don't free regprog in the match list, it's a copy */

! 		    vim_regfree(shl->rm.regprog);

! 		    SET_NO_HLSEARCH(TRUE);

! 		}

! 		shl->rm.regprog = NULL;

! 		shl->lnum = 0;

! 		got_int = FALSE;  /* avoid the "Type :quit to exit Vim"

! 				     message */

! 		break;

  	    }

! 	}

! 	else if (cur != NULL)

! 	{

! 	    nmatched = next_search_hl_pos(shl, lnum, &(cur->pos), matchcol);

  	}

  	if (nmatched == 0)

  	{

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

*** 7453,7458 ****

--- 7478,7539 ----

  }

  #endif

+     static int

+ next_search_hl_pos(shl, lnum, posmatch, mincol)

+     match_T	    *shl;	/* points to a match */

+     linenr_T	    lnum;

+     posmatch_T	    *posmatch;	/* match positions */

+     colnr_T	    mincol;	/* minimal column for a match */

+ {

+     int	    i;

+     int     bot = -1;

+ 

+     shl->lnum = 0;

+     for (i = posmatch->cur; i < MAXPOSMATCH; i++)

+     {

+ 	if (posmatch->pos[i].lnum == 0)

+ 	    break;

+ 	if (posmatch->pos[i].col < mincol)

+ 	    continue;

+ 	if (posmatch->pos[i].lnum == lnum)

+ 	{

+ 	    if (shl->lnum == lnum)

+ 	    {

+ 		/* partially sort positions by column numbers

+ 		 * on the same line */

+ 		if (posmatch->pos[i].col < posmatch->pos[bot].col)

+ 		{

+ 		    llpos_T	tmp = posmatch->pos[i];

+ 

+ 		    posmatch->pos[i] = posmatch->pos[bot];

+ 		    posmatch->pos[bot] = tmp;

+ 		}

+ 	    }

+ 	    else

+ 	    {

+ 		bot = i;

+ 		shl->lnum = lnum;

+ 	    }

+ 	}

+     }

+     posmatch->cur = 0;

+     if (shl->lnum == lnum)

+     {

+ 	colnr_T	start = posmatch->pos[bot].col == 0

+ 					     ? 0 : posmatch->pos[bot].col - 1;

+ 	colnr_T	end = posmatch->pos[bot].col == 0

+ 				    ? MAXCOL : start + posmatch->pos[bot].len;

+ 

+ 	shl->rm.startpos[0].lnum = 0;

+ 	shl->rm.startpos[0].col = start;

+ 	shl->rm.endpos[0].lnum = 0;

+ 	shl->rm.endpos[0].col = end;

+ 	posmatch->cur = bot + 1;

+ 	return TRUE;

+     }

+     return FALSE;

+ }

+ 

        static void

  screen_start_highlight(attr)

        int	attr;

*** ../vim-7.4.329/src/structs.h	2014-05-28 18:22:37.876225054 +0200

--- src/structs.h	2014-06-17 17:00:55.524520330 +0200

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

*** 1927,1932 ****

--- 1927,1958 ----

  #endif

  } match_T;

+ /* number of positions supported by matchaddpos() */

+ #define MAXPOSMATCH 8

+ 

+ /*

+  * Same as lpos_T, but with additional field len.

+  */

+ typedef struct

+ {

+     linenr_T	lnum;	/* line number */

+     colnr_T	col;	/* column number */

+     int		len;	/* length: 0 - to the end of line */

+ } llpos_T;

+ 

+ /*

+  * posmatch_T provides an array for storing match items for matchaddpos()

+  * function.

+  */

+ typedef struct posmatch posmatch_T;

+ struct posmatch

+ {

+     llpos_T	pos[MAXPOSMATCH];	/* array of positions */

+     int		cur;			/* internal position counter */

+     linenr_T	toplnum;		/* top buffer line */

+     linenr_T	botlnum;		/* bottom buffer line */

+ };

+ 

  /*

   * matchitem_T provides a linked list for storing match items for ":match" and

   * the match functions.

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

*** 1940,1945 ****

--- 1966,1972 ----

      char_u	*pattern;   /* pattern to highlight */

      int		hlg_id;	    /* highlight group ID */

      regmmatch_T	match;	    /* regexp program for pattern */

+     posmatch_T	pos;	    /* position matches */

      match_T	hl;	    /* struct for doing the actual highlighting */

  };

*** ../vim-7.4.329/src/testdir/test63.in	2010-05-15 13:04:10.000000000 +0200

--- src/testdir/test63.in	2014-06-17 16:29:36.056449227 +0200

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

*** 1,5 ****

  Test for ":match", ":2match", ":3match", "clearmatches()", "getmatches()",

! "matchadd()", "matcharg()", "matchdelete()", and "setmatches()".

  STARTTEST

  :so small.vim

--- 1,5 ----

  Test for ":match", ":2match", ":3match", "clearmatches()", "getmatches()",

! "matchadd()", "matchaddpos", "matcharg()", "matchdelete()", and "setmatches()".

  STARTTEST

  :so small.vim

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

*** 147,155 ****

  :unlet rf1

  :unlet rf2

  :unlet rf3

! :highlight clear MyGroup1

! :highlight clear MyGroup2

! :highlight clear MyGroup3

  G"rp

  :/^Results/,$wq! test.out

  ENDTEST

--- 147,172 ----

  :unlet rf1

  :unlet rf2

  :unlet rf3

! :" --- Check that "matchaddpos()" positions matches correctly

! :let @r .= "*** Test 11:\n"

! :set nolazyredraw

! :call setline(1, 'abcdefghijklmnopq')

! :call matchaddpos("MyGroup1", [[1, 5], [1, 8, 3]], 10, 3)

! :1

! :redraw!

! :let v1 = screenattr(1, 1)

! :let v5 = screenattr(1, 5)

! :let v6 = screenattr(1, 6)

! :let v8 = screenattr(1, 8)

! :let v10 = screenattr(1, 10)

! :let v11 = screenattr(1, 11)

! :let @r .= string(getmatches())."\n"

! :if v1 != v5 && v6 == v1 && v8 == v5 && v10 == v5 && v11 == v1

! :  let @r .= "OK\n"

! :else

! :  let @r .= "FAILED\n"

! :endif

! :call clearmatches()

  G"rp

  :/^Results/,$wq! test.out

  ENDTEST

*** ../vim-7.4.329/src/testdir/test63.ok	2010-05-15 13:04:10.000000000 +0200

--- src/testdir/test63.ok	2014-06-17 17:32:57.036593023 +0200

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

*** 9,11 ****

--- 9,14 ----

  *** Test 8: OK

  *** Test 9: OK

  *** Test 10: OK

+ *** Test 11:

+ [{'group': 'MyGroup1', 'id': 3, 'priority': 10, 'pos1': [1, 5, 1], 'pos2': [1, 8, 3]}]

+ OK

*** ../vim-7.4.329/src/window.c	2014-06-17 13:52:35.868092848 +0200

--- src/window.c	2014-06-17 17:04:51.060529240 +0200

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

*** 6751,6770 ****

   * Return ID of added match, -1 on failure.

   */

      int

! match_add(wp, grp, pat, prio, id)

      win_T	*wp;

      char_u	*grp;

      char_u	*pat;

      int		prio;

      int		id;

  {

!     matchitem_T *cur;

!     matchitem_T *prev;

!     matchitem_T *m;

      int		hlg_id;

!     regprog_T	*regprog;

!     if (*grp == NUL || *pat == NUL)

  	return -1;

      if (id < -1 || id == 0)

      {

--- 6751,6772 ----

   * Return ID of added match, -1 on failure.

   */

      int

! match_add(wp, grp, pat, prio, id, pos_list)

      win_T	*wp;

      char_u	*grp;

      char_u	*pat;

      int		prio;

      int		id;