To: vim_dev@googlegroups.com

Subject: Patch 7.3.10

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.3.1090

Problem:    New regexp engine does not support \z1 .. \z9 and \z(.

Solution:   Implement the syntax submatches.

Files:	    src/regexp.h, src/regexp_nfa.c

*** ../vim-7.3.1089/src/regexp.h	2013-05-30 17:05:34.000000000 +0200

--- src/regexp.h	2013-06-01 22:18:07.000000000 +0200

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

*** 55,61 ****

--- 55,63 ----

      char_u		reganch;

      char_u		*regmust;

      int			regmlen;

+ #ifdef FEAT_SYN_HL

      char_u		reghasz;

+ #endif

      char_u		program[1];	/* actually longer.. */

  } bt_regprog_T;

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

*** 88,93 ****

--- 90,98 ----

      nfa_state_T		*start;

      int			has_zend;	/* pattern contains \ze */

      int			has_backref;	/* pattern contains \1 .. \9 */

+ #ifdef FEAT_SYN_HL

+     int			reghasz;

+ #endif

      int			nsubexp;	/* number of () */

      int			nstate;

      nfa_state_T		state[0];	/* actually longer.. */

*** ../vim-7.3.1089/src/regexp_nfa.c	2013-06-01 19:54:39.000000000 +0200

--- src/regexp_nfa.c	2013-06-01 22:54:08.000000000 +0200

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

*** 78,90 ****

      NFA_BACKREF7,		    /* \7 */

      NFA_BACKREF8,		    /* \8 */

      NFA_BACKREF9,		    /* \9 */

      NFA_SKIP,			    /* Skip characters */

      NFA_MOPEN,

!     NFA_MCLOSE = NFA_MOPEN + NSUBEXP,

      /* NFA_FIRST_NL */

!     NFA_ANY = NFA_MCLOSE + NSUBEXP, /*	Match any one character. */

      NFA_ANYOF,		/*	Match any character in this string. */

      NFA_ANYBUT,		/*	Match any character not in this string. */

      NFA_IDENT,		/*	Match identifier char */

--- 78,144 ----

      NFA_BACKREF7,		    /* \7 */

      NFA_BACKREF8,		    /* \8 */

      NFA_BACKREF9,		    /* \9 */

+ #ifdef FEAT_SYN_HL

+     NFA_ZREF1,			    /* \z1 */

+     NFA_ZREF2,			    /* \z2 */

+     NFA_ZREF3,			    /* \z3 */

+     NFA_ZREF4,			    /* \z4 */

+     NFA_ZREF5,			    /* \z5 */

+     NFA_ZREF6,			    /* \z6 */

+     NFA_ZREF7,			    /* \z7 */

+     NFA_ZREF8,			    /* \z8 */

+     NFA_ZREF9,			    /* \z9 */

+ #endif

      NFA_SKIP,			    /* Skip characters */

      NFA_MOPEN,

!     NFA_MOPEN1,

!     NFA_MOPEN2,

!     NFA_MOPEN3,

!     NFA_MOPEN4,

!     NFA_MOPEN5,

!     NFA_MOPEN6,

!     NFA_MOPEN7,

!     NFA_MOPEN8,

!     NFA_MOPEN9,

! 

!     NFA_MCLOSE,

!     NFA_MCLOSE1,

!     NFA_MCLOSE2,

!     NFA_MCLOSE3,

!     NFA_MCLOSE4,

!     NFA_MCLOSE5,

!     NFA_MCLOSE6,

!     NFA_MCLOSE7,

!     NFA_MCLOSE8,

!     NFA_MCLOSE9,

! 

! #ifdef FEAT_SYN_HL

!     NFA_ZOPEN,

!     NFA_ZOPEN1,

!     NFA_ZOPEN2,

!     NFA_ZOPEN3,

!     NFA_ZOPEN4,

!     NFA_ZOPEN5,

!     NFA_ZOPEN6,

!     NFA_ZOPEN7,

!     NFA_ZOPEN8,

!     NFA_ZOPEN9,

! 

!     NFA_ZCLOSE,

!     NFA_ZCLOSE1,

!     NFA_ZCLOSE2,

!     NFA_ZCLOSE3,

!     NFA_ZCLOSE4,

!     NFA_ZCLOSE5,

!     NFA_ZCLOSE6,

!     NFA_ZCLOSE7,

!     NFA_ZCLOSE8,

!     NFA_ZCLOSE9,

! #endif

      /* NFA_FIRST_NL */

!     NFA_ANY,		/*	Match any one character. */

      NFA_ANYOF,		/*	Match any character in this string. */

      NFA_ANYBUT,		/*	Match any character not in this string. */

      NFA_IDENT,		/*	Match identifier char */

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

*** 221,227 ****

  static void nfa_save_listids __ARGS((nfa_state_T *start, int *list));

  static void nfa_restore_listids __ARGS((nfa_state_T *start, int *list));

  static int nfa_re_num_cmp __ARGS((long_u val, int op, long_u pos));

! static long nfa_regtry __ARGS((nfa_state_T *start, colnr_T col));

  static long nfa_regexec_both __ARGS((char_u *line, colnr_T col));

  static regprog_T *nfa_regcomp __ARGS((char_u *expr, int re_flags));

  static int nfa_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));

--- 275,281 ----

  static void nfa_save_listids __ARGS((nfa_state_T *start, int *list));

  static void nfa_restore_listids __ARGS((nfa_state_T *start, int *list));

  static int nfa_re_num_cmp __ARGS((long_u val, int op, long_u pos));

! static long nfa_regtry __ARGS((nfa_regprog_T *prog, colnr_T col));

  static long nfa_regexec_both __ARGS((char_u *line, colnr_T col));

  static regprog_T *nfa_regcomp __ARGS((char_u *expr, int re_flags));

  static int nfa_regexec __ARGS((regmatch_T *rmp, char_u *line, colnr_T col));

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

*** 267,272 ****

--- 321,327 ----

      nfa_has_zend = FALSE;

      nfa_has_backref = FALSE;

+     /* shared with BT engine */

      regcomp_start(expr, re_flags);

      return OK;

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

*** 799,804 ****

--- 854,860 ----

  		    EMIT(NFA_ZEND);

  		    nfa_has_zend = TRUE;

  		    break;

+ #ifdef FEAT_SYN_HL

  		case '1':

  		case '2':

  		case '3':

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

*** 808,816 ****

  		case '7':

  		case '8':

  		case '9':

  		case '(':

! 		    /* TODO: \z1...\z9 and \z( not yet supported */

! 		    return FAIL;

  		default:

  		    syntax_error = TRUE;

  		    EMSGN(_("E867: (NFA) Unknown operator '\\z%c'"),

--- 864,882 ----

  		case '7':

  		case '8':

  		case '9':

+ 		    /* \z1...\z9 */

+ 		    EMIT(NFA_ZREF1 + (no_Magic(c) - '1'));

+ 		    /* No need to set nfa_has_backref, the sub-matches don't

+ 		     * change when \z1 .. \z9 maches or not. */

+ 		    re_has_z = REX_USE;

+ 		    break;

  		case '(':

! 		    /* \z(  */

! 		    if (nfa_reg(REG_ZPAREN) == FAIL)

! 			return FAIL;	    /* cascaded error */

! 		    re_has_z = REX_SET;

! 		    break;

! #endif

  		default:

  		    syntax_error = TRUE;

  		    EMSGN(_("E867: (NFA) Unknown operator '\\z%c'"),

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

*** 1651,1658 ****

  {

      int		parno = 0;

- #ifdef FEAT_SYN_HL

- #endif

      if (paren == REG_PAREN)

      {

  	if (regnpar >= NSUBEXP) /* Too many `(' */

--- 1717,1722 ----

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

*** 1662,1667 ****

--- 1726,1743 ----

  	}

  	parno = regnpar++;

      }

+ #ifdef FEAT_SYN_HL

+     else if (paren == REG_ZPAREN)

+     {

+ 	/* Make a ZOPEN node. */

+ 	if (regnzpar >= NSUBEXP)

+ 	{

+ 	    syntax_error = TRUE;

+ 	    EMSG_RET_FAIL(_("E879: (NFA regexp) Too many \\z("));

+ 	}

+ 	parno = regnzpar++;

+     }

+ #endif

      if (nfa_regbranch() == FAIL)

  	return FAIL;	    /* cascaded error */

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

*** 1700,1705 ****

--- 1776,1785 ----

  	had_endbrace[parno] = TRUE;     /* have seen the close paren */

  	EMIT(NFA_MOPEN + parno);

      }

+ #ifdef FEAT_SYN_HL

+     else if (paren == REG_ZPAREN)

+ 	EMIT(NFA_ZOPEN + parno);

+ #endif

      return OK;

  }

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

*** 1738,1743 ****

--- 1818,1834 ----

  	case NFA_BACKREF7:  STRCPY(code, "NFA_BACKREF7"); break;

  	case NFA_BACKREF8:  STRCPY(code, "NFA_BACKREF8"); break;

  	case NFA_BACKREF9:  STRCPY(code, "NFA_BACKREF9"); break;

+ #ifdef FEAT_SYN_HL

+ 	case NFA_ZREF1:	    STRCPY(code, "NFA_ZREF1"); break;

+ 	case NFA_ZREF2:	    STRCPY(code, "NFA_ZREF2"); break;

+ 	case NFA_ZREF3:	    STRCPY(code, "NFA_ZREF3"); break;

+ 	case NFA_ZREF4:	    STRCPY(code, "NFA_ZREF4"); break;

+ 	case NFA_ZREF5:	    STRCPY(code, "NFA_ZREF5"); break;

+ 	case NFA_ZREF6:	    STRCPY(code, "NFA_ZREF6"); break;

+ 	case NFA_ZREF7:	    STRCPY(code, "NFA_ZREF7"); break;

+ 	case NFA_ZREF8:	    STRCPY(code, "NFA_ZREF8"); break;

+ 	case NFA_ZREF9:	    STRCPY(code, "NFA_ZREF9"); break;

+ #endif

  	case NFA_SKIP:	    STRCPY(code, "NFA_SKIP"); break;

  	case NFA_PREV_ATOM_NO_WIDTH:

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

*** 1758,1789 ****

  	case NFA_COMPOSING:	    STRCPY(code, "NFA_COMPOSING"); break;

  	case NFA_END_COMPOSING:	    STRCPY(code, "NFA_END_COMPOSING"); break;

! 	case NFA_MOPEN + 0:

! 	case NFA_MOPEN + 1:

! 	case NFA_MOPEN + 2:

! 	case NFA_MOPEN + 3:

! 	case NFA_MOPEN + 4:

! 	case NFA_MOPEN + 5:

! 	case NFA_MOPEN + 6:

! 	case NFA_MOPEN + 7:

! 	case NFA_MOPEN + 8:

! 	case NFA_MOPEN + 9:

  	    STRCPY(code, "NFA_MOPEN(x)");

  	    code[10] = c - NFA_MOPEN + '0';

  	    break;

! 	case NFA_MCLOSE + 0:

! 	case NFA_MCLOSE + 1:

! 	case NFA_MCLOSE + 2:

! 	case NFA_MCLOSE + 3:

! 	case NFA_MCLOSE + 4:

! 	case NFA_MCLOSE + 5:

! 	case NFA_MCLOSE + 6:

! 	case NFA_MCLOSE + 7:

! 	case NFA_MCLOSE + 8:

! 	case NFA_MCLOSE + 9:

  	    STRCPY(code, "NFA_MCLOSE(x)");

  	    code[11] = c - NFA_MCLOSE + '0';

  	    break;

  	case NFA_EOL:		STRCPY(code, "NFA_EOL "); break;

  	case NFA_BOL:		STRCPY(code, "NFA_BOL "); break;

  	case NFA_EOW:		STRCPY(code, "NFA_EOW "); break;

--- 1849,1908 ----

  	case NFA_COMPOSING:	    STRCPY(code, "NFA_COMPOSING"); break;

  	case NFA_END_COMPOSING:	    STRCPY(code, "NFA_END_COMPOSING"); break;

! 	case NFA_MOPEN:

! 	case NFA_MOPEN1:

! 	case NFA_MOPEN2:

! 	case NFA_MOPEN3:

! 	case NFA_MOPEN4:

! 	case NFA_MOPEN5:

! 	case NFA_MOPEN6:

! 	case NFA_MOPEN7:

! 	case NFA_MOPEN8:

! 	case NFA_MOPEN9:

  	    STRCPY(code, "NFA_MOPEN(x)");

  	    code[10] = c - NFA_MOPEN + '0';

  	    break;

! 	case NFA_MCLOSE:

! 	case NFA_MCLOSE1:

! 	case NFA_MCLOSE2:

! 	case NFA_MCLOSE3:

! 	case NFA_MCLOSE4:

! 	case NFA_MCLOSE5:

! 	case NFA_MCLOSE6:

! 	case NFA_MCLOSE7:

! 	case NFA_MCLOSE8:

! 	case NFA_MCLOSE9:

  	    STRCPY(code, "NFA_MCLOSE(x)");

  	    code[11] = c - NFA_MCLOSE + '0';

  	    break;

+ #ifdef FEAT_SYN_HL

+ 	case NFA_ZOPEN:

+ 	case NFA_ZOPEN1:

+ 	case NFA_ZOPEN2:

+ 	case NFA_ZOPEN3:

+ 	case NFA_ZOPEN4:

+ 	case NFA_ZOPEN5:

+ 	case NFA_ZOPEN6:

+ 	case NFA_ZOPEN7:

+ 	case NFA_ZOPEN8:

+ 	case NFA_ZOPEN9:

+ 	    STRCPY(code, "NFA_ZOPEN(x)");

+ 	    code[10] = c - NFA_ZOPEN + '0';

+ 	    break;

+ 	case NFA_ZCLOSE:

+ 	case NFA_ZCLOSE1:

+ 	case NFA_ZCLOSE2:

+ 	case NFA_ZCLOSE3:

+ 	case NFA_ZCLOSE4:

+ 	case NFA_ZCLOSE5:

+ 	case NFA_ZCLOSE6:

+ 	case NFA_ZCLOSE7:

+ 	case NFA_ZCLOSE8:

+ 	case NFA_ZCLOSE9:

+ 	    STRCPY(code, "NFA_ZCLOSE(x)");

+ 	    code[11] = c - NFA_ZCLOSE + '0';

+ 	    break;

+ #endif

  	case NFA_EOL:		STRCPY(code, "NFA_EOL "); break;

  	case NFA_BOL:		STRCPY(code, "NFA_BOL "); break;

  	case NFA_EOW:		STRCPY(code, "NFA_EOW "); break;

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

*** 2437,2453 ****

  	    /* FALLTHROUGH */

  #endif

! 	case NFA_MOPEN + 0:	/* Submatch */

! 	case NFA_MOPEN + 1:

! 	case NFA_MOPEN + 2:

! 	case NFA_MOPEN + 3:

! 	case NFA_MOPEN + 4:

! 	case NFA_MOPEN + 5:

! 	case NFA_MOPEN + 6:

! 	case NFA_MOPEN + 7:

! 	case NFA_MOPEN + 8:

! 	case NFA_MOPEN + 9:

! 	case NFA_NOPEN:		/* \%( "Invisible Submatch" */

  	    if (nfa_calc_size == TRUE)

  	    {

  		nstate += 2;

--- 2556,2584 ----

  	    /* FALLTHROUGH */

  #endif

! 	case NFA_MOPEN:	/* \( \) Submatch */

! 	case NFA_MOPEN1:

! 	case NFA_MOPEN2:

! 	case NFA_MOPEN3:

! 	case NFA_MOPEN4:

! 	case NFA_MOPEN5:

! 	case NFA_MOPEN6:

! 	case NFA_MOPEN7:

! 	case NFA_MOPEN8:

! 	case NFA_MOPEN9:

! #ifdef FEAT_SYN_HL

! 	case NFA_ZOPEN:	/* \z( \) Submatch */

! 	case NFA_ZOPEN1:

! 	case NFA_ZOPEN2:

! 	case NFA_ZOPEN3:

! 	case NFA_ZOPEN4:

! 	case NFA_ZOPEN5:

! 	case NFA_ZOPEN6:

! 	case NFA_ZOPEN7:

! 	case NFA_ZOPEN8:

! 	case NFA_ZOPEN9:

! #endif

! 	case NFA_NOPEN:	/* \%( \) "Invisible Submatch" */

  	    if (nfa_calc_size == TRUE)

  	    {

  		nstate += 2;

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

*** 2457,2472 ****

  	    mopen = *p;

  	    switch (*p)

  	    {

! 		case NFA_NOPEN:

! 		    mclose = NFA_NCLOSE;

! 		    break;

  #ifdef FEAT_MBYTE

! 		case NFA_COMPOSING:

! 		    mclose = NFA_END_COMPOSING;

! 		    break;

  #endif

  		default:

! 		    /* NFA_MOPEN(0) ... NFA_MOPEN(9) */

  		    mclose = *p + NSUBEXP;

  		    break;

  	    }

--- 2588,2611 ----

  	    mopen = *p;

  	    switch (*p)

  	    {

! 		case NFA_NOPEN: mclose = NFA_NCLOSE; break;

! #ifdef FEAT_SYN_HL

! 		case NFA_ZOPEN: mclose = NFA_ZCLOSE; break;

! 		case NFA_ZOPEN1: mclose = NFA_ZCLOSE1; break;

! 		case NFA_ZOPEN2: mclose = NFA_ZCLOSE2; break;

! 		case NFA_ZOPEN3: mclose = NFA_ZCLOSE3; break;

! 		case NFA_ZOPEN4: mclose = NFA_ZCLOSE4; break;

! 		case NFA_ZOPEN5: mclose = NFA_ZCLOSE5; break;

! 		case NFA_ZOPEN6: mclose = NFA_ZCLOSE6; break;

! 		case NFA_ZOPEN7: mclose = NFA_ZCLOSE7; break;

! 		case NFA_ZOPEN8: mclose = NFA_ZCLOSE8; break;

! 		case NFA_ZOPEN9: mclose = NFA_ZCLOSE9; break;

! #endif

  #ifdef FEAT_MBYTE

! 		case NFA_COMPOSING: mclose = NFA_END_COMPOSING; break;

  #endif

  		default:

! 		    /* NFA_MOPEN, NFA_MOPEN1 .. NFA_MOPEN9 */

  		    mclose = *p + NSUBEXP;

  		    break;

  	    }

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

*** 2518,2523 ****

--- 2657,2673 ----

  	case NFA_BACKREF7:

  	case NFA_BACKREF8:

  	case NFA_BACKREF9:

+ #ifdef FEAT_SYN_HL

+ 	case NFA_ZREF1:

+ 	case NFA_ZREF2:

+ 	case NFA_ZREF3:

+ 	case NFA_ZREF4:

+ 	case NFA_ZREF5:

+ 	case NFA_ZREF6:

+ 	case NFA_ZREF7:

+ 	case NFA_ZREF8:

+ 	case NFA_ZREF9:

+ #endif

  	    if (nfa_calc_size == TRUE)

  	    {

  		nstate += 2;

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

*** 2630,2641 ****

      } list;

  } regsub_T;

  /* nfa_thread_T contains execution information of a NFA state */

  typedef struct

  {

      nfa_state_T	*state;

      int		count;

!     regsub_T	sub;		/* submatch info, only party used */

  } nfa_thread_T;

  /* nfa_list_T contains the alternative NFA execution states. */

--- 2780,2799 ----

      } list;

  } regsub_T;

+ typedef struct

+ {

+     regsub_T	norm; /* \( .. \) matches */

+ #ifdef FEAT_SYN_HL

+     regsub_T	synt; /* \z( .. \) matches */

+ #endif

+ } regsubs_T;

+ 

  /* nfa_thread_T contains execution information of a NFA state */

  typedef struct

  {

      nfa_state_T	*state;

      int		count;

!     regsubs_T	subs;		/* submatch info, only party used */

  } nfa_thread_T;

  /* nfa_list_T contains the alternative NFA execution states. */

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

*** 2648,2653 ****

--- 2806,2824 ----

  } nfa_list_T;

  #ifdef ENABLE_LOG

+ static void log_subsexpr __ARGS((regsubs_T *subs));

+ static void log_subexpr __ARGS((regsub_T *sub));

+ 

+     static void

+ log_subsexpr(subs)

+     regsubs_T *subs;

+ {

+     log_subexpr(&subs->norm);

+ # ifdef FEAT_SYN_HL

+     log_subexpr(&subs->synt);

+ # endif

+ }

+ 

      static void

  log_subexpr(sub)

      regsub_T *sub;

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

*** 2674,2682 ****

  /* Used during execution: whether a match has been found. */

  static int nfa_match;

  static int sub_equal __ARGS((regsub_T *sub1, regsub_T *sub2));

! static void addstate __ARGS((nfa_list_T *l, nfa_state_T *state, regsub_T *sub, int off));

! static void addstate_here __ARGS((nfa_list_T *l, nfa_state_T *state, regsub_T *sub, int *ip));

  /*

   * Return TRUE if "sub1" and "sub2" have the same positions.

--- 2845,2916 ----

  /* Used during execution: whether a match has been found. */

  static int nfa_match;

+ static void clear_sub __ARGS((regsub_T *sub));

+ static void copy_sub __ARGS((regsub_T *to, regsub_T *from));

+ static void copy_sub_off __ARGS((regsub_T *to, regsub_T *from));

  static int sub_equal __ARGS((regsub_T *sub1, regsub_T *sub2));

! static void addstate __ARGS((nfa_list_T *l, nfa_state_T *state, regsubs_T *subs, int off));

! static void addstate_here __ARGS((nfa_list_T *l, nfa_state_T *state, regsubs_T *subs, int *ip));

! 

!     static void

! clear_sub(sub)

!     regsub_T *sub;

! {

!     if (REG_MULTI)

! 	/* Use 0xff to set lnum to -1 */

! 	vim_memset(sub->list.multi, 0xff,

! 				      sizeof(struct multipos) * nfa_nsubexpr);

!     else

! 	vim_memset(sub->list.line, 0, sizeof(struct linepos) * nfa_nsubexpr);

!     sub->in_use = 0;

! }

! 

! /*

!  * Copy the submatches from "from" to "to".

!  */

!     static void

! copy_sub(to, from)

!     regsub_T	*to;

!     regsub_T	*from;

! {

!     to->in_use = from->in_use;

!     if (from->in_use > 0)

!     {

! 	/* Copy the match start and end positions. */

! 	if (REG_MULTI)

! 	    mch_memmove(&to->list.multi[0],

! 			&from->list.multi[0],

! 			sizeof(struct multipos) * from->in_use);

! 	else

! 	    mch_memmove(&to->list.line[0],

! 			&from->list.line[0],

! 			sizeof(struct linepos) * from->in_use);

!     }

! }

! 

! /*

!  * Like copy_sub() but exclude the main match.

!  */

!     static void

! copy_sub_off(to, from)

!     regsub_T	*to;

!     regsub_T	*from;

! {

!     if (to->in_use < from->in_use)

! 	to->in_use = from->in_use;

!     if (from->in_use > 1)

!     {

! 	/* Copy the match start and end positions. */

! 	if (REG_MULTI)

! 	    mch_memmove(&to->list.multi[1],

! 			&from->list.multi[1],

! 			sizeof(struct multipos) * (from->in_use - 1));

! 	else

! 	    mch_memmove(&to->list.line[1],

! 			&from->list.line[1],

! 			sizeof(struct linepos) * (from->in_use - 1));

!     }

! }

  /*

   * Return TRUE if "sub1" and "sub2" have the same positions.

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

*** 2761,2770 ****

  }

      static void

! addstate(l, state, sub, off)

      nfa_list_T		*l;	/* runtime state list */

      nfa_state_T		*state;	/* state to update */

!     regsub_T		*sub;	/* pointers to subexpressions */

      int			off;	/* byte offset, when -1 go to next line */

  {

      int			subidx;

--- 2995,3004 ----

  }

      static void

! addstate(l, state, subs, off)

      nfa_list_T		*l;	/* runtime state list */

      nfa_state_T		*state;	/* state to update */

!     regsubs_T		*subs;	/* pointers to subexpressions */

      int			off;	/* byte offset, when -1 go to next line */

  {

      int			subidx;

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

*** 2773,2778 ****

--- 3007,3013 ----

      int			save_in_use;

      char_u		*save_ptr;

      int			i;

+     regsub_T		*sub;

  #ifdef ENABLE_LOG

      int			did_print = FALSE;

  #endif

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

*** 2787,2815 ****

  	case NFA_NOPEN:

  	case NFA_NCLOSE:

  	case NFA_MCLOSE:

! 	case NFA_MCLOSE + 1:

! 	case NFA_MCLOSE + 2:

! 	case NFA_MCLOSE + 3:

! 	case NFA_MCLOSE + 4:

! 	case NFA_MCLOSE + 5:

! 	case NFA_MCLOSE + 6:

! 	case NFA_MCLOSE + 7:

! 	case NFA_MCLOSE + 8:

! 	case NFA_MCLOSE + 9:

  	    /* These nodes are not added themselves but their "out" and/or

  	     * "out1" may be added below.  */

  	    break;

  	case NFA_MOPEN:

! 	case NFA_MOPEN + 1:

! 	case NFA_MOPEN + 2:

! 	case NFA_MOPEN + 3:

! 	case NFA_MOPEN + 4:

! 	case NFA_MOPEN + 5:

! 	case NFA_MOPEN + 6:

! 	case NFA_MOPEN + 7:

! 	case NFA_MOPEN + 8:

! 	case NFA_MOPEN + 9:

  	    /* These nodes do not need to be added, but we need to bail out

  	     * when it was tried to be added to this list before. */

  	    if (state->lastlist == l->id)

--- 3022,3074 ----

  	case NFA_NOPEN:

  	case NFA_NCLOSE:

  	case NFA_MCLOSE:

! 	case NFA_MCLOSE1:

! 	case NFA_MCLOSE2:

! 	case NFA_MCLOSE3:

! 	case NFA_MCLOSE4:

! 	case NFA_MCLOSE5:

! 	case NFA_MCLOSE6:

! 	case NFA_MCLOSE7:

! 	case NFA_MCLOSE8:

! 	case NFA_MCLOSE9:

! #ifdef FEAT_SYN_HL

! 	case NFA_ZCLOSE:

! 	case NFA_ZCLOSE1:

! 	case NFA_ZCLOSE2:

! 	case NFA_ZCLOSE3:

! 	case NFA_ZCLOSE4:

! 	case NFA_ZCLOSE5:

! 	case NFA_ZCLOSE6:

! 	case NFA_ZCLOSE7:

! 	case NFA_ZCLOSE8:

! 	case NFA_ZCLOSE9:

! #endif

  	    /* These nodes are not added themselves but their "out" and/or

  	     * "out1" may be added below.  */

  	    break;

  	case NFA_MOPEN:

! 	case NFA_MOPEN1:

! 	case NFA_MOPEN2:

! 	case NFA_MOPEN3:

! 	case NFA_MOPEN4:

! 	case NFA_MOPEN5:

! 	case NFA_MOPEN6:

! 	case NFA_MOPEN7:

! 	case NFA_MOPEN8:

! 	case NFA_MOPEN9:

! #ifdef FEAT_SYN_HL

! 	case NFA_ZOPEN:

! 	case NFA_ZOPEN1:

! 	case NFA_ZOPEN2:

! 	case NFA_ZOPEN3:

! 	case NFA_ZOPEN4:

! 	case NFA_ZOPEN5:

! 	case NFA_ZOPEN6:

! 	case NFA_ZOPEN7:

! 	case NFA_ZOPEN8:

! 	case NFA_ZOPEN9:

! #endif

  	    /* These nodes do not need to be added, but we need to bail out

  	     * when it was tried to be added to this list before. */

  	    if (state->lastlist == l->id)

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

*** 2839,2845 ****

  		{

  		    thread = &l->t[i];

  		    if (thread->state->id == state->id

! 					  && sub_equal(&thread->sub, sub))

  			goto skip_add;

  		}

  	    }

--- 3098,3108 ----

  		{

  		    thread = &l->t[i];

  		    if (thread->state->id == state->id

! 			    && sub_equal(&thread->subs.norm, &subs->norm)

! #ifdef FEAT_SYN_HL

! 			    && sub_equal(&thread->subs.synt, &subs->synt)

! #endif

! 					  )

  			goto skip_add;

  		}

  	    }

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

*** 2858,2876 ****

  	    state->lastlist = l->id;

  	    thread = &l->t[l->n++];

  	    thread->state = state;

! 	    thread->sub.in_use = sub->in_use;

! 	    if (sub->in_use > 0)

! 	    {

! 		/* Copy the match start and end positions. */

! 		if (REG_MULTI)

! 		    mch_memmove(&thread->sub.list.multi[0],

! 				&sub->list.multi[0],

! 				sizeof(struct multipos) * sub->in_use);

! 		else

! 		    mch_memmove(&thread->sub.list.line[0],

! 				&sub->list.line[0],

! 				sizeof(struct linepos) * sub->in_use);

! 	    }

  #ifdef ENABLE_LOG

  	    {

  		int col;

--- 3121,3130 ----

  	    state->lastlist = l->id;

  	    thread = &l->t[l->n++];

  	    thread->state = state;

! 	    copy_sub(&thread->subs.norm, &subs->norm);

! #ifdef FEAT_SYN_HL

! 	    copy_sub(&thread->subs.synt, &subs->synt);

! #endif

  #ifdef ENABLE_LOG

  	    {

  		int col;

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

*** 2912,2959 ****

  	    break;

  	case NFA_SPLIT:

! 	    addstate(l, state->out, sub, off);

! 	    addstate(l, state->out1, sub, off);

  	    break;

- #if 0

- 	case NFA_END_NEG_RANGE:

- 	    /* Nothing to handle here. nfa_regmatch() will take care of it */

- 	    break;

- 

- 	case NFA_NOT:

- 	    EMSG(_("E999: (NFA regexp internal error) Should not process NOT node !"));

- #ifdef ENABLE_LOG

- 	fprintf(f, "\n\n>>> E999: Added state NFA_NOT to a list ... Something went wrong ! Why wasn't it processed already? \n\n");

- #endif

- 	    break;

- 

- 	case NFA_COMPOSING:

- 	    /* nfa_regmatch() will match all the bytes of this composing char. */

- 	    break;

- #endif

- 

  	case NFA_SKIP_CHAR:

  	case NFA_NOPEN:

  	case NFA_NCLOSE:

! 	    addstate(l, state->out, sub, off);

  	    break;

! 	case NFA_MOPEN + 0:

! 	case NFA_MOPEN + 1:

! 	case NFA_MOPEN + 2:

! 	case NFA_MOPEN + 3:

! 	case NFA_MOPEN + 4:

! 	case NFA_MOPEN + 5:

! 	case NFA_MOPEN + 6:

! 	case NFA_MOPEN + 7:

! 	case NFA_MOPEN + 8:

! 	case NFA_MOPEN + 9:

  	case NFA_ZSTART:

  	    if (state->c == NFA_ZSTART)

  		subidx = 0;

  	    else

  		subidx = state->c - NFA_MOPEN;

  	    /* Set the position (with "off") in the subexpression.  Save and

  	     * restore it when it was in use.  Otherwise fill any gap. */

--- 3166,3222 ----

  	    break;

  	case NFA_SPLIT:

! 	    /* order matters here */

! 	    addstate(l, state->out, subs, off);

! 	    addstate(l, state->out1, subs, off);

  	    break;

  	case NFA_SKIP_CHAR:

  	case NFA_NOPEN:

  	case NFA_NCLOSE:

! 	    addstate(l, state->out, subs, off);

  	    break;

! 	case NFA_MOPEN:

! 	case NFA_MOPEN1:

! 	case NFA_MOPEN2:

! 	case NFA_MOPEN3:

! 	case NFA_MOPEN4:

! 	case NFA_MOPEN5:

! 	case NFA_MOPEN6:

! 	case NFA_MOPEN7:

! 	case NFA_MOPEN8:

! 	case NFA_MOPEN9:

! #ifdef FEAT_SYN_HL

! 	case NFA_ZOPEN:

! 	case NFA_ZOPEN1:

! 	case NFA_ZOPEN2:

! 	case NFA_ZOPEN3:

! 	case NFA_ZOPEN4:

! 	case NFA_ZOPEN5:

! 	case NFA_ZOPEN6:

! 	case NFA_ZOPEN7:

! 	case NFA_ZOPEN8:

! 	case NFA_ZOPEN9:

! #endif

  	case NFA_ZSTART:

  	    if (state->c == NFA_ZSTART)

+ 	    {

  		subidx = 0;

+ 		sub = &subs->norm;

+ 	    }

+ #ifdef FEAT_SYN_HL

+ 	    else if (state->c >= NFA_ZOPEN)

+ 	    {

+ 		subidx = state->c - NFA_ZOPEN;

+ 		sub = &subs->synt;

+ 	    }

+ #endif

  	    else