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
+ 	    {
  		subidx = state->c - NFA_MOPEN;
+ 		sub = &subs->norm;
+ 	    }
  
  	    /* Set the position (with "off") in the subexpression.  Save and
  	     * restore it when it was in use.  Otherwise fill any gap. */
***************
*** 3007,3013 ****
  		sub->list.line[subidx].start = reginput + off;
  	    }
  
! 	    addstate(l, state->out, sub, off);
  
  	    if (save_in_use == -1)
  	    {
--- 3270,3276 ----
  		sub->list.line[subidx].start = reginput + off;
  	    }
  
! 	    addstate(l, state->out, subs, off);
  
  	    if (save_in_use == -1)
  	    {
***************
*** 3020,3047 ****
  		sub->in_use = save_in_use;
  	    break;
  
! 	case NFA_MCLOSE + 0:
  	    if (nfa_has_zend)
  	    {
  		/* Do not overwrite the position set by \ze. If no \ze
  		 * encountered end will be set in nfa_regtry(). */
! 		addstate(l, state->out, sub, off);
  		break;
  	    }
! 	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:
  	case NFA_ZEND:
  	    if (state->c == NFA_ZEND)
  		subidx = 0;
  	    else
  		subidx = state->c - NFA_MCLOSE;
  
  	    /* We don't fill in gaps here, there must have been an MOPEN that
  	     * has done that. */
--- 3283,3335 ----
  		sub->in_use = save_in_use;
  	    break;
  
! 	case NFA_MCLOSE:
  	    if (nfa_has_zend)
  	    {
  		/* Do not overwrite the position set by \ze. If no \ze
  		 * encountered end will be set in nfa_regtry(). */
! 		addstate(l, state->out, subs, off);
  		break;
  	    }
! 	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
  	case NFA_ZEND:
  	    if (state->c == NFA_ZEND)
+ 	    {
  		subidx = 0;
+ 		sub = &subs->norm;
+ 	    }
+ #ifdef FEAT_SYN_HL
+ 	    else if (state->c >= NFA_ZCLOSE)
+ 	    {
+ 		subidx = state->c - NFA_ZCLOSE;
+ 		sub = &subs->synt;
+ 	    }
+ #endif
  	    else
+ 	    {
  		subidx = state->c - NFA_MCLOSE;
+ 		sub = &subs->norm;
+ 	    }
  
  	    /* We don't fill in gaps here, there must have been an MOPEN that
  	     * has done that. */
***************
*** 3069,3075 ****
  		sub->list.line[subidx].end = reginput + off;
  	    }
  
! 	    addstate(l, state->out, sub, off);
  
  	    if (REG_MULTI)
  		sub->list.multi[subidx].end = save_lpos;
--- 3357,3363 ----
  		sub->list.line[subidx].end = reginput + off;
  	    }
  
! 	    addstate(l, state->out, subs, off);
  
  	    if (REG_MULTI)
  		sub->list.multi[subidx].end = save_lpos;
***************
*** 3087,3096 ****
   * matters for alternatives.
   */
      static void
! addstate_here(l, state, sub, ip)
      nfa_list_T		*l;	/* runtime state list */
      nfa_state_T		*state;	/* state to update */
!     regsub_T		*sub;	/* pointers to subexpressions */
      int			*ip;
  {
      int tlen = l->n;
--- 3375,3384 ----
   * matters for alternatives.
   */
      static void
! addstate_here(l, state, subs, ip)
      nfa_list_T		*l;	/* runtime state list */
      nfa_state_T		*state;	/* state to update */
!     regsubs_T		*subs;	/* pointers to subexpressions */
      int			*ip;
  {
      int tlen = l->n;
***************
*** 3098,3104 ****
      int i = *ip;
  
      /* first add the state(s) at the end, so that we know how many there are */
!     addstate(l, state, sub, 0);
  
      /* when "*ip" was at the end of the list, nothing to do */
      if (i + 1 == tlen)
--- 3386,3392 ----
      int i = *ip;
  
      /* first add the state(s) at the end, so that we know how many there are */
!     addstate(l, state, subs, 0);
  
      /* when "*ip" was at the end of the list, nothing to do */
      if (i + 1 == tlen)
***************
*** 3212,3218 ****
  
  /*
   * Check for a match with subexpression "subidx".
!  * return TRUE if it matches.
   */
      static int
  match_backref(sub, subidx, bytelen)
--- 3500,3506 ----
  
  /*
   * Check for a match with subexpression "subidx".
!  * Return TRUE if it matches.
   */
      static int
  match_backref(sub, subidx, bytelen)
***************
*** 3260,3265 ****
--- 3548,3586 ----
      return FALSE;
  }
  
+ #ifdef FEAT_SYN_HL
+ 
+ static int match_zref __ARGS((int subidx, int *bytelen));
+ 
+ /*
+  * Check for a match with \z subexpression "subidx".
+  * Return TRUE if it matches.
+  */
+     static int
+ match_zref(subidx, bytelen)
+     int		subidx;
+     int		*bytelen;   /* out: length of match in bytes */
+ {
+     int		len;
+ 
+     cleanup_zsubexpr();
+     if (re_extmatch_in == NULL || re_extmatch_in->matches[subidx] == NULL)
+     {
+ 	/* backref was not set, match an empty string */
+ 	*bytelen = 0;
+ 	return TRUE;
+     }
+ 
+     len = (int)STRLEN(re_extmatch_in->matches[subidx]);
+     if (cstrncmp(re_extmatch_in->matches[subidx], reginput, &len) == 0)
+     {
+ 	*bytelen = len;
+ 	return TRUE;
+     }
+     return FALSE;
+ }
+ #endif
+ 
  /*
   * Set all NFA nodes' list ID equal to -1.
   */
***************
*** 3334,3340 ****
      return val == pos;
  }
  
! static int nfa_regmatch __ARGS((nfa_state_T *start, regsub_T *submatch, regsub_T *m, save_se_T *endp));
  
  /*
   * Main matching routine.
--- 3655,3661 ----
      return val == pos;
  }
  
! static int nfa_regmatch __ARGS((nfa_state_T *start, regsubs_T *submatch, regsubs_T *m, save_se_T *endp));
  
  /*
   * Main matching routine.
***************
*** 3349,3356 ****
      static int
  nfa_regmatch(start, submatch, m, endp)
      nfa_state_T		*start;
!     regsub_T		*submatch;
!     regsub_T		*m;
      save_se_T		*endp;
  {
      int		result;
--- 3670,3677 ----
      static int
  nfa_regmatch(start, submatch, m, endp)
      nfa_state_T		*start;
!     regsubs_T		*submatch;
!     regsubs_T		*m;
      save_se_T		*endp;
  {
      int		result;
***************
*** 3429,3435 ****
  #define	ADD_POS_NEG_STATE(node)						    \
      ll = listtbl[result ? 1 : 0][node->negated];			    \
      if (ll != NULL)							    \
! 	addstate(ll, node->out , &t->sub, clen);
  
  
      /*
--- 3750,3756 ----
  #define	ADD_POS_NEG_STATE(node)						    \
      ll = listtbl[result ? 1 : 0][node->negated];			    \
      if (ll != NULL)							    \
! 	addstate(ll, node->out , &t->subs, clen);
  
  
      /*
***************
*** 3531,3556 ****
  	    {
  	    case NFA_MATCH:
  	      {
- 		int j;
- 
  		nfa_match = TRUE;
! 		submatch->in_use = t->sub.in_use;
! 		if (REG_MULTI)
! 		    for (j = 0; j < submatch->in_use; j++)
! 		    {
! 			submatch->list.multi[j].start =
! 						   t->sub.list.multi[j].start;
! 			submatch->list.multi[j].end = t->sub.list.multi[j].end;
! 		    }
! 		else
! 		    for (j = 0; j < submatch->in_use; j++)
! 		    {
! 			submatch->list.line[j].start =
! 						    t->sub.list.line[j].start;
! 			submatch->list.line[j].end = t->sub.list.line[j].end;
! 		    }
  #ifdef ENABLE_LOG
! 		log_subexpr(&t->sub);
  #endif
  		/* Found the left-most longest match, do not look at any other
  		 * states at this position.  When the list of states is going
--- 3852,3864 ----
  	    {
  	    case NFA_MATCH:
  	      {
  		nfa_match = TRUE;
! 		copy_sub(&submatch->norm, &t->subs.norm);
! #ifdef FEAT_SYN_HL
! 		copy_sub(&submatch->synt, &t->subs.synt);
! #endif
  #ifdef ENABLE_LOG
! 		log_subsexpr(&t->subs);
  #endif
  		/* Found the left-most longest match, do not look at any other
  		 * states at this position.  When the list of states is going
***************
*** 3570,3578 ****
  		 * finished successfully, so return control to the parent
  		 * nfa_regmatch().  Submatches are stored in *m, and used in
  		 * the parent call. */
! 		if (start->c == NFA_MOPEN + 0)
  		    /* TODO: do we ever get here? */
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		else
  		{
  #ifdef ENABLE_LOG
--- 3878,3886 ----
  		 * finished successfully, so return control to the parent
  		 * nfa_regmatch().  Submatches are stored in *m, and used in
  		 * the parent call. */
! 		if (start->c == NFA_MOPEN)
  		    /* TODO: do we ever get here? */
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		else
  		{
  #ifdef ENABLE_LOG
***************
*** 3600,3607 ****
  
  		    /* do not set submatches for \@! */
  		    if (!t->state->negated)
! 			/* TODO: only copy positions in use. */
! 			*m = t->sub;
  		    nfa_match = TRUE;
  		}
  		break;
--- 3908,3919 ----
  
  		    /* do not set submatches for \@! */
  		    if (!t->state->negated)
! 		    {
! 			copy_sub(&m->norm, &t->subs.norm);
! #ifdef FEAT_SYN_HL
! 			copy_sub(&m->synt, &t->subs.synt);
! #endif
! 		    }
  		    nfa_match = TRUE;
  		}
  		break;
***************
*** 3630,3636 ****
  
  		    /* Go back the specified number of bytes, or as far as the
  		     * start of the previous line, to try matching "\@<=" or
! 		     * not matching "\@<!". */
  		    if (t->state->val <= 0)
  		    {
  			if (REG_MULTI)
--- 3942,3950 ----
  
  		    /* Go back the specified number of bytes, or as far as the
  		     * start of the previous line, to try matching "\@<=" or
! 		     * not matching "\@<!".
! 		     * TODO: This is very inefficient! Would be better to
! 		     * first check for a match with what follows. */
  		    if (t->state->val <= 0)
  		    {
  			if (REG_MULTI)
***************
*** 3722,3748 ****
  		/* for \@! it is a match when result is FALSE */
  		if (result != t->state->negated)
  		{
- 		    int j;
- 
  		    /* Copy submatch info from the recursive call */
! 		    if (REG_MULTI)
! 			for (j = 1; j < m->in_use; j++)
! 			{
! 			    t->sub.list.multi[j].start = m->list.multi[j].start;
! 			    t->sub.list.multi[j].end = m->list.multi[j].end;
! 			}
! 		    else
! 			for (j = 1; j < m->in_use; j++)
! 			{
! 			    t->sub.list.line[j].start = m->list.line[j].start;
! 			    t->sub.list.line[j].end = m->list.line[j].end;
! 			}
! 		    if (m->in_use > t->sub.in_use)
! 			t->sub.in_use = m->in_use;
  
  		    /* t->state->out1 is the corresponding END_INVISIBLE node;
  		     * Add it to the current list (zero-width match). */
! 		    addstate_here(thislist, t->state->out1->out, &t->sub,
  								    &listidx);
  		}
  		break;
--- 4036,4050 ----
  		/* for \@! it is a match when result is FALSE */
  		if (result != t->state->negated)
  		{
  		    /* Copy submatch info from the recursive call */
! 		    copy_sub_off(&t->subs.norm, &m->norm);
! #ifdef FEAT_SYN_HL
! 		    copy_sub_off(&t->subs.synt, &m->synt);
! #endif
  
  		    /* t->state->out1 is the corresponding END_INVISIBLE node;
  		     * Add it to the current list (zero-width match). */
! 		    addstate_here(thislist, t->state->out1->out, &t->subs,
  								    &listidx);
  		}
  		break;
***************
*** 3750,3761 ****
  
  	    case NFA_BOL:
  		if (reginput == regline)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    case NFA_EOL:
  		if (curc == NUL)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    case NFA_BOW:
--- 4052,4063 ----
  
  	    case NFA_BOL:
  		if (reginput == regline)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    case NFA_EOL:
  		if (curc == NUL)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    case NFA_BOW:
***************
*** 3782,3788 ****
  				   && vim_iswordc_buf(reginput[-1], reg_buf)))
  		    bow = FALSE;
  		if (bow)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  	    }
  
--- 4084,4090 ----
  				   && vim_iswordc_buf(reginput[-1], reg_buf)))
  		    bow = FALSE;
  		if (bow)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  	    }
  
***************
*** 3810,3828 ****
  					   && vim_iswordc_buf(curc, reg_buf)))
  		    eow = FALSE;
  		if (eow)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  	    }
  
  	    case NFA_BOF:
  		if (reglnum == 0 && reginput == regline
  					&& (!REG_MULTI || reg_firstlnum == 1))
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    case NFA_EOF:
  		if (reglnum == reg_maxline && curc == NUL)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  #ifdef FEAT_MBYTE
--- 4112,4130 ----
  					   && vim_iswordc_buf(curc, reg_buf)))
  		    eow = FALSE;
  		if (eow)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  	    }
  
  	    case NFA_BOF:
  		if (reglnum == 0 && reginput == regline
  					&& (!REG_MULTI || reg_firstlnum == 1))
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    case NFA_EOF:
  		if (reglnum == reg_maxline && curc == NUL)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  #ifdef FEAT_MBYTE
***************
*** 3911,3922 ****
  		    go_to_nextline = TRUE;
  		    /* Pass -1 for the offset, which means taking the position
  		     * at the start of the next line. */
! 		    addstate(nextlist, t->state->out, &t->sub, -1);
  		}
  		else if (curc == '\n' && reg_line_lbr)
  		{
  		    /* match \n as if it is an ordinary character */
! 		    addstate(nextlist, t->state->out, &t->sub, 1);
  		}
  		break;
  
--- 4213,4224 ----
  		    go_to_nextline = TRUE;
  		    /* Pass -1 for the offset, which means taking the position
  		     * at the start of the next line. */
! 		    addstate(nextlist, t->state->out, &t->subs, -1);
  		}
  		else if (curc == '\n' && reg_line_lbr)
  		{
  		    /* match \n as if it is an ordinary character */
! 		    addstate(nextlist, t->state->out, &t->subs, 1);
  		}
  		break;
  
***************
*** 3944,3956 ****
  		/* This follows a series of negated nodes, like:
  		 * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */
  		if (curc > 0)
! 		    addstate(nextlist, t->state->out, &t->sub, clen);
  		break;
  
  	    case NFA_ANY:
  		/* Any char except '\0', (end of input) does not match. */
  		if (curc > 0)
! 		    addstate(nextlist, t->state->out, &t->sub, clen);
  		break;
  
  	    /*
--- 4246,4258 ----
  		/* This follows a series of negated nodes, like:
  		 * CHAR(x), NFA_NOT, CHAR(y), NFA_NOT etc. */
  		if (curc > 0)
! 		    addstate(nextlist, t->state->out, &t->subs, clen);
  		break;
  
  	    case NFA_ANY:
  		/* Any char except '\0', (end of input) does not match. */
  		if (curc > 0)
! 		    addstate(nextlist, t->state->out, &t->subs, clen);
  		break;
  
  	    /*
***************
*** 4096,4114 ****
  	    case NFA_BACKREF7:
  	    case NFA_BACKREF8:
  	    case NFA_BACKREF9:
! 		/* \1 .. \9 */
  	      {
! 		int subidx = t->state->c - NFA_BACKREF1 + 1;
  		int bytelen;
  
! 		result = match_backref(&t->sub, subidx, &bytelen);
  		if (result)
  		{
  		    if (bytelen == 0)
  		    {
  			/* empty match always works, add NFA_SKIP with zero to
  			 * be used next */
! 			addstate_here(thislist, t->state->out, &t->sub,
  								    &listidx);
  			thislist->t[listidx + 1].count = 0;
  		    }
--- 4398,4439 ----
  	    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
! 		/* \1 .. \9  \z1 .. \z9 */
  	      {
! 		int subidx;
  		int bytelen;
  
! 		if (t->state->c <= NFA_BACKREF9)
! 		{
! 		    subidx = t->state->c - NFA_BACKREF1 + 1;
! 		    result = match_backref(&t->subs.norm, subidx, &bytelen);
! 		}
! #ifdef FEAT_SYN_HL
! 		else
! 		{
! 		    subidx = t->state->c - NFA_ZREF1 + 1;
! 		    result = match_zref(subidx, &bytelen);
! 		}
! #endif
! 
  		if (result)
  		{
  		    if (bytelen == 0)
  		    {
  			/* empty match always works, add NFA_SKIP with zero to
  			 * be used next */
! 			addstate_here(thislist, t->state->out, &t->subs,
  								    &listidx);
  			thislist->t[listidx + 1].count = 0;
  		    }
***************
*** 4116,4134 ****
  		    {
  			/* match current character, jump ahead to out of
  			 * NFA_SKIP */
! 			addstate(nextlist, t->state->out->out, &t->sub, clen);
  #ifdef ENABLE_LOG
! 			log_subexpr(&nextlist->t[nextlist->n - 1].sub);
  #endif
  		    }
  		    else
  		    {
  			/* skip ofer the matched characters, set character
  			 * count in NFA_SKIP */
! 			addstate(nextlist, t->state->out, &t->sub, bytelen);
  			nextlist->t[nextlist->n - 1].count = bytelen - clen;
  #ifdef ENABLE_LOG
! 			log_subexpr(&nextlist->t[nextlist->n - 1].sub);
  #endif
  		    }
  
--- 4441,4459 ----
  		    {
  			/* match current character, jump ahead to out of
  			 * NFA_SKIP */
! 			addstate(nextlist, t->state->out->out, &t->subs, clen);
  #ifdef ENABLE_LOG
! 			log_subsexpr(&nextlist->t[nextlist->n - 1].subs);
  #endif
  		    }
  		    else
  		    {
  			/* skip ofer the matched characters, set character
  			 * count in NFA_SKIP */
! 			addstate(nextlist, t->state->out, &t->subs, bytelen);
  			nextlist->t[nextlist->n - 1].count = bytelen - clen;
  #ifdef ENABLE_LOG
! 			log_subsexpr(&nextlist->t[nextlist->n - 1].subs);
  #endif
  		    }
  
***************
*** 4140,4157 ****
  	      if (t->count - clen <= 0)
  	      {
  		  /* end of match, go to what follows */
! 		  addstate(nextlist, t->state->out, &t->sub, clen);
  #ifdef ENABLE_LOG
! 		  log_subexpr(&nextlist->t[nextlist->n - 1].sub);
  #endif
  	      }
  	      else
  	      {
  		  /* add state again with decremented count */
! 		  addstate(nextlist, t->state, &t->sub, 0);
  		  nextlist->t[nextlist->n - 1].count = t->count - clen;
  #ifdef ENABLE_LOG
! 		  log_subexpr(&nextlist->t[nextlist->n - 1].sub);
  #endif
  	      }
  	      break;
--- 4465,4482 ----
  	      if (t->count - clen <= 0)
  	      {
  		  /* end of match, go to what follows */
! 		  addstate(nextlist, t->state->out, &t->subs, clen);
  #ifdef ENABLE_LOG
! 		  log_subsexpr(&nextlist->t[nextlist->n - 1].subs);
  #endif
  	      }
  	      else
  	      {
  		  /* add state again with decremented count */
! 		  addstate(nextlist, t->state, &t->subs, 0);
  		  nextlist->t[nextlist->n - 1].count = t->count - clen;
  #ifdef ENABLE_LOG
! 		  log_subsexpr(&nextlist->t[nextlist->n - 1].subs);
  #endif
  	      }
  	      break;
***************
*** 4169,4175 ****
  			nfa_re_num_cmp(t->state->val, t->state->c - NFA_LNUM,
  			    (long_u)(reglnum + reg_firstlnum)));
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    case NFA_COL:
--- 4494,4500 ----
  			nfa_re_num_cmp(t->state->val, t->state->c - NFA_LNUM,
  			    (long_u)(reglnum + reg_firstlnum)));
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    case NFA_COL:
***************
*** 4178,4184 ****
  		result = nfa_re_num_cmp(t->state->val, t->state->c - NFA_COL,
  			(long_u)(reginput - regline) + 1);
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    case NFA_VCOL:
--- 4503,4509 ----
  		result = nfa_re_num_cmp(t->state->val, t->state->c - NFA_COL,
  			(long_u)(reginput - regline) + 1);
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    case NFA_VCOL:
***************
*** 4189,4195 ****
  			    reg_win == NULL ? curwin : reg_win,
  			    regline, (colnr_T)(reginput - regline)) + 1);
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    case NFA_CURSOR:
--- 4514,4520 ----
  			    reg_win == NULL ? curwin : reg_win,
  			    regline, (colnr_T)(reginput - regline)) + 1);
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    case NFA_CURSOR:
***************
*** 4198,4204 ****
  			&& ((colnr_T)(reginput - regline)
  						   == reg_win->w_cursor.col));
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		break;
  
  	    default:	/* regular character */
--- 4523,4529 ----
  			&& ((colnr_T)(reginput - regline)
  						   == reg_win->w_cursor.col));
  		if (result)
! 		    addstate_here(thislist, t->state->out, &t->subs, &listidx);
  		break;
  
  	    default:	/* regular character */
***************
*** 4238,4244 ****
  	 * Unless "endp" is not NULL, then we match the end position.
  	 * Also don't start a match past the first line. */
  	if (nfa_match == FALSE
! 		&& ((start->c == NFA_MOPEN + 0
  			&& reglnum == 0
  			&& clen != 0
  			&& (ireg_maxcol == 0
--- 4563,4569 ----
  	 * Unless "endp" is not NULL, then we match the end position.
  	 * Also don't start a match past the first line. */
  	if (nfa_match == FALSE
! 		&& ((start->c == NFA_MOPEN
  			&& reglnum == 0
  			&& clen != 0
  			&& (ireg_maxcol == 0
***************
*** 4305,4322 ****
   * Returns 0 for failure, number of lines contained in the match otherwise.
   */
      static long
! nfa_regtry(start, col)
!     nfa_state_T	*start;
!     colnr_T	col;
  {
      int		i;
!     regsub_T	sub, m;
  #ifdef ENABLE_LOG
      FILE	*f;
  #endif
  
      reginput = regline + col;
      need_clear_subexpr = TRUE;
  
  #ifdef ENABLE_LOG
      f = fopen(NFA_REGEXP_RUN_LOG, "a");
--- 4630,4653 ----
   * Returns 0 for failure, number of lines contained in the match otherwise.
   */
      static long
! nfa_regtry(prog, col)
!     nfa_regprog_T   *prog;
!     colnr_T	    col;
  {
      int		i;
!     regsubs_T	subs, m;
!     nfa_state_T	*start = prog->start;
  #ifdef ENABLE_LOG
      FILE	*f;
  #endif
  
      reginput = regline + col;
      need_clear_subexpr = TRUE;
+ #ifdef FEAT_SYN_HL
+     /* Clear the external match subpointers if necessary. */
+     if (prog->reghasz == REX_SET)
+ 	need_clear_zsubexpr = TRUE;
+ #endif
  
  #ifdef ENABLE_LOG
      f = fopen(NFA_REGEXP_RUN_LOG, "a");
***************
*** 4337,4366 ****
  	EMSG(_("Could not open temporary log file for writing "));
  #endif
  
!     if (REG_MULTI)
!     {
! 	/* Use 0xff to set lnum to -1 */
! 	vim_memset(sub.list.multi, 0xff, sizeof(struct multipos) * nfa_nsubexpr);
! 	vim_memset(m.list.multi, 0xff, sizeof(struct multipos) * nfa_nsubexpr);
!     }
!     else
!     {
! 	vim_memset(sub.list.line, 0, sizeof(struct linepos) * nfa_nsubexpr);
! 	vim_memset(m.list.line, 0, sizeof(struct linepos) * nfa_nsubexpr);
!     }
!     sub.in_use = 0;
!     m.in_use = 0;
  
!     if (nfa_regmatch(start, &sub, &m, NULL) == FALSE)
  	return 0;
  
      cleanup_subexpr();
      if (REG_MULTI)
      {
! 	for (i = 0; i < sub.in_use; i++)
  	{
! 	    reg_startpos[i] = sub.list.multi[i].start;
! 	    reg_endpos[i] = sub.list.multi[i].end;
  	}
  
  	if (reg_startpos[0].lnum < 0)
--- 4668,4690 ----
  	EMSG(_("Could not open temporary log file for writing "));
  #endif
  
!     clear_sub(&subs.norm);
!     clear_sub(&m.norm);
! #ifdef FEAT_SYN_HL
!     clear_sub(&subs.synt);
!     clear_sub(&m.synt);
! #endif
  
!     if (nfa_regmatch(start, &subs, &m, NULL) == FALSE)
  	return 0;
  
      cleanup_subexpr();
      if (REG_MULTI)
      {
! 	for (i = 0; i < subs.norm.in_use; i++)
  	{
! 	    reg_startpos[i] = subs.norm.list.multi[i].start;
! 	    reg_endpos[i] = subs.norm.list.multi[i].end;
  	}
  
  	if (reg_startpos[0].lnum < 0)
***************
*** 4380,4389 ****
      }
      else
      {
! 	for (i = 0; i < sub.in_use; i++)
  	{
! 	    reg_startp[i] = sub.list.line[i].start;
! 	    reg_endp[i] = sub.list.line[i].end;
  	}
  
  	if (reg_startp[0] == NULL)
--- 4704,4713 ----
      }
      else
      {
! 	for (i = 0; i < subs.norm.in_use; i++)
  	{
! 	    reg_startp[i] = subs.norm.list.line[i].start;
! 	    reg_endp[i] = subs.norm.list.line[i].end;
  	}
  
  	if (reg_startp[0] == NULL)
***************
*** 4392,4397 ****
--- 4716,4758 ----
  	    reg_endp[0] = reginput;
      }
  
+ #ifdef FEAT_SYN_HL
+     /* Package any found \z(...\) matches for export. Default is none. */
+     unref_extmatch(re_extmatch_out);
+     re_extmatch_out = NULL;
+ 
+     if (prog->reghasz == REX_SET)
+     {
+ 	int		i;
+ 
+ 	cleanup_zsubexpr();
+ 	re_extmatch_out = make_extmatch();
+ 	for (i = 0; i < subs.synt.in_use; i++)
+ 	{
+ 	    if (REG_MULTI)
+ 	    {
+ 		struct multipos *mpos = &subs.synt.list.multi[i];
+ 
+ 		/* Only accept single line matches. */
+ 		if (mpos->start.lnum >= 0 && mpos->start.lnum == mpos->end.lnum)
+ 		    re_extmatch_out->matches[i] =
+ 			vim_strnsave(reg_getline(mpos->start.lnum)
+ 							    + mpos->start.col,
+ 					     mpos->end.col - mpos->start.col);
+ 	    }
+ 	    else
+ 	    {
+ 		struct linepos *lpos = &subs.synt.list.line[i];
+ 
+ 		if (lpos->start != NULL && lpos->end != NULL)
+ 		    re_extmatch_out->matches[i] =
+ 			    vim_strnsave(lpos->start,
+ 					      (int)(lpos->end - lpos->start));
+ 	    }
+ 	}
+     }
+ #endif
+ 
      return 1 + reglnum;
  }
  
***************
*** 4461,4467 ****
  	prog->state[i].lastlist = 0;
      }
  
!     retval = nfa_regtry(prog->start, col);
  
  theend:
      return retval;
--- 4822,4828 ----
  	prog->state[i].lastlist = 0;
      }
  
!     retval = nfa_regtry(prog, col);
  
  theend:
      return retval;
***************
*** 4552,4557 ****
--- 4913,4922 ----
      nfa_postfix_dump(expr, OK);
      nfa_dump(prog);
  #endif
+ #ifdef FEAT_SYN_HL
+     /* Remember whether this pattern has any \z specials in it. */
+     prog->reghasz = re_has_z;
+ #endif
  
  out:
      vim_free(post_start);
*** ../vim-7.3.1089/src/version.c	2013-06-01 20:32:09.000000000 +0200
--- src/version.c	2013-06-01 22:29:51.000000000 +0200
***************
*** 730,731 ****
--- 730,733 ----
  {   /* Add new patch number below this line */
+ /**/
+     1090,
  /**/
 
-- 
Despite the cost of living, have you noticed how it remains so popular?
 
 /// 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    ///