vim: src/regexp.c comparison

comparison src/regexp.c @ 167:c93c9cad9618

updated for version 7.0051

author	vimboss
date	Tue, 22 Feb 2005 08:39:57 +0000
parents	19670b05ee32
children	8c60f65311fa

comparison

equal deleted inserted replaced

-:3a28ed993bbe
+:c93c9cad9618
 * all nodes except BRANCH and BRACES_COMPLEX implement concatenation; a "next"
 * pointer with a BRANCH on both ends of it is connecting two alternatives.
 * (Here we have one of the subtle syntax dependencies:	an individual BRANCH
 * (as opposed to a collection of them) is never concatenated with anything
 * because of operator precedence).  The "next" pointer of a BRACES_COMPLEX
-* node points to the node after the stuff to be repeated.  The operand of some
+* node points to the node after the stuff to be repeated.
-* types of node is a literal string; for others, it is a node leading into a
+* The operand of some types of node is a literal string; for others, it is a
-* sub-FSM.  In particular, the operand of a BRANCH node is the first node of
+* node leading into a sub-FSM.  In particular, the operand of a BRANCH node
-* the branch.	(NB this is *not* a tree structure: the tail of the branch
+* is the first node of the branch.
-* connects to the thing following the set of BRANCHes.)
+* (NB this is *not* a tree structure: the tail of the branch connects to the
+* thing following the set of BRANCHes.)
 *
 * pattern	is coded like:
 *
 *			  +-----------------+
 *			  |		    V
 *		       V		  |
 * <aa>*	BRANCH BRANCH <aa> --> BACK BRANCH --> NOTHING --> END
 *		     |	    |		    ^			   ^
 *		     |	    +---------------+			   |
 *		     +---------------------------------------------+
+*
+*
+*		       +----------------------+
+*		       V		      |
+* <aa>\+	BRANCH <aa> --> BRANCH --> BACK BRANCH --> NOTHING --> END
+*		     |	             |	        ^		       ^
+*		     |	             +----------+		       |
+*		     +-------------------------------------------------+
 *
 *
 *					+-------------------------+
 *					V			  |
 * <aa>\{}	BRANCH BRACE_LIMITS --> BRACE_COMPLEX <aa> --> BACK  END
 */
 static char_u REGEXP_INRANGE[] = "]^-n\\";
 static char_u REGEXP_ABBR[] = "nrtebdoxuU";
 static int	backslash_trans __ARGS((int c));
-static int	skip_class_name __ARGS((char_u **pp));
+static int	get_char_class __ARGS((char_u **pp));
+static int	get_equi_class __ARGS((char_u **pp));
+static void	reg_equi_class __ARGS((int c));
+static int	get_coll_element __ARGS((char_u **pp));
 static char_u	*skip_anyof __ARGS((char_u *p));
 static void	init_class_tab __ARGS((void));
 /*
 * Translate '\x' to its control character, except "\n", which is Magic.
 }
 return c;
 }
 /*
-* Check for a character class name.  "pp" points to the '['.
+* Check for a character class name "[:name:]".  "pp" points to the '['.
 * Returns one of the CLASS_ items. CLASS_NONE means that no item was
 * recognized.  Otherwise "pp" is advanced to after the item.
 */
 static int
-skip_class_name(pp)
+get_char_class(pp)
 char_u	**pp;
 {
 static const char *(class_names[]) =
 {
 	"alnum:]",
 }
 return CLASS_NONE;
 }
 /*
-* Skip over a "[]" range.
-* "p" must point to the character after the '['.
-* The returned pointer is on the matching ']', or the terminating NUL.
-*/
-static char_u *
-skip_anyof(p)
-char_u	*p;
-{
-int		cpo_lit;	/* 'cpoptions' contains 'l' flag */
-#ifdef FEAT_MBYTE
-int		l;
-#endif
-cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL);
-if (*p == '^')	/* Complement of range. */
-	++p;
-if (*p == ']' || *p == '-')
-	++p;
-while (*p != NUL && *p != ']')
-{
-#ifdef FEAT_MBYTE
-	if (has_mbyte && (l = (*mb_ptr2len_check)(p)) > 1)
-	    p += l;
-	else
-#endif
-	    if (*p == '-')
-	    {
-		++p;
-		if (*p != ']' && *p != NUL)
-		    mb_ptr_adv(p);
-	    }
-	else if (*p == '\\'
-		&& (vim_strchr(REGEXP_INRANGE, p[1]) != NULL
-		    || (!cpo_lit && vim_strchr(REGEXP_ABBR, p[1]) != NULL)))
-	    p += 2;
-	else if (*p == '[')
-	{
-	    if (skip_class_name(&p) == CLASS_NONE)
-		++p; /* It was not a class name */
-	}
-	else
-	    ++p;
-}
-return p;
-}
-/*
 * Specific version of character class functions.
 * Using a table to keep this fast.
 */
 static short	class_tab[256];
 static int	prog_magic_wrong __ARGS((void));
 static char_u	*regnext __ARGS((char_u *));
 static void	regc __ARGS((int b));
 #ifdef FEAT_MBYTE
 static void	regmbc __ARGS((int c));
+#else
+# define regmbc(c) regc(c)
 #endif
 static void	reginsert __ARGS((int, char_u *));
 static void	reginsert_limits __ARGS((int, long, long, char_u *));
 static char_u	*re_put_long __ARGS((char_u *pr, long_u val));
 static int	read_limits __ARGS((long *, long *));
 int
 re_lookbehind(prog)
 regprog_T *prog;
 {
 return (prog->regflags & RF_LOOKBH);
+}
+/*
+* Check for an equivalence class name "[=a=]".  "pp" points to the '['.
+* Returns a character representing the class. Zero means that no item was
+* recognized.  Otherwise "pp" is advanced to after the item.
+*/
+static int
+get_equi_class(pp)
+char_u	**pp;
+{
+int		c;
+int		l = 1;
+char_u	*p = *pp;
+if (p[1] == '=')
+{
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	    l = mb_ptr2len_check(p + 2);
+#endif
+	if (p[l + 2] == '=' && p[l + 3] == ']')
+	{
+#ifdef FEAT_MBYTE
+	    if (has_mbyte)
+		c = mb_ptr2char(p + 2);
+	    else
+#endif
+		c = p[2];
+	    *pp += l + 4;
+	    return c;
+	}
+}
+return 0;
+}
+/*
+* Produce the bytes for equivalence class "c".
+* Currently only handles latin1, latin9 and utf-8.
+*/
+static void
+reg_equi_class(c)
+int	    c;
+{
+#ifdef FEAT_MBYTE
+if (enc_utf8 || STRCMP(p_enc, "latin1") == 0
+					      || STRCMP(p_enc, "latin9") == 0)
+#endif
+{
+	switch (c)
+	{
+	    case 'A': case '�': case '�': case '�':
+	    case '�': case '�': case '�':
+		      regmbc('A'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�'); regmbc('�'); regmbc('�');
+		      return;
+	    case 'C': case '�':
+		      regmbc('C'); regmbc('�');
+		      return;
+	    case 'E': case '�': case '�': case '�': case '�':
+		      regmbc('E'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�');
+		      return;
+	    case 'I': case '�': case '�': case '�': case '�':
+		      regmbc('I'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�');
+		      return;
+	    case 'N': case '�':
+		      regmbc('N'); regmbc('�');
+		      return;
+	    case 'O': case '�': case '�': case '�': case '�': case '�':
+		      regmbc('O'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�'); regmbc('�');
+		      return;
+	    case 'U': case '�': case '�': case '�': case '�':
+		      regmbc('U'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�');
+		      return;
+	    case 'Y': case '�':
+		      regmbc('Y'); regmbc('�');
+		      return;
+	    case 'a': case '�': case '�': case '�':
+	    case '�': case '�': case '�':
+		      regmbc('a'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�'); regmbc('�'); regmbc('�');
+		      return;
+	    case 'c': case '�':
+		      regmbc('c'); regmbc('�');
+		      return;
+	    case 'e': case '�': case '�': case '�': case '�':
+		      regmbc('e'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�');
+		      return;
+	    case 'i': case '�': case '�': case '�': case '�':
+		      regmbc('i'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�');
+		      return;
+	    case 'n': case '�':
+		      regmbc('n'); regmbc('�');
+		      return;
+	    case 'o': case '�': case '�': case '�': case '�': case '�':
+		      regmbc('o'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�'); regmbc('�');
+		      return;
+	    case 'u': case '�': case '�': case '�': case '�':
+		      regmbc('u'); regmbc('�'); regmbc('�'); regmbc('�');
+		      regmbc('�');
+		      return;
+	    case 'y': case '�': case '�':
+		      regmbc('y'); regmbc('�'); regmbc('�');
+		      return;
+	}
+}
+regmbc(c);
+}
+/*
+* Check for a collating element "[.a.]".  "pp" points to the '['.
+* Returns a character. Zero means that no item was recognized.  Otherwise
+* "pp" is advanced to after the item.
+* Currently only single characters are recognized!
+*/
+static int
+get_coll_element(pp)
+char_u	**pp;
+{
+int		c;
+int		l = 1;
+char_u	*p = *pp;
+if (p[1] == '.')
+{
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	    l = mb_ptr2len_check(p + 2);
+#endif
+	if (p[l + 2] == '.' && p[l + 3] == ']')
+	{
+#ifdef FEAT_MBYTE
+	    if (has_mbyte)
+		c = mb_ptr2char(p + 2);
+	    else
+#endif
+		c = p[2];
+	    *pp += l + 4;
+	    return c;
+	}
+}
+return 0;
+}
+/*
+* Skip over a "[]" range.
+* "p" must point to the character after the '['.
+* The returned pointer is on the matching ']', or the terminating NUL.
+*/
+static char_u *
+skip_anyof(p)
+char_u	*p;
+{
+int		cpo_lit;	/* 'cpoptions' contains 'l' flag */
+int		cpo_bsl;	/* 'cpoptions' contains '\' flag */
+#ifdef FEAT_MBYTE
+int		l;
+#endif
+cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL);
+cpo_bsl = (!reg_syn && vim_strchr(p_cpo, CPO_BACKSL) != NULL);
+if (*p == '^')	/* Complement of range. */
+	++p;
+if (*p == ']' || *p == '-')
+	++p;
+while (*p != NUL && *p != ']')
+{
+#ifdef FEAT_MBYTE
+	if (has_mbyte && (l = (*mb_ptr2len_check)(p)) > 1)
+	    p += l;
+	else
+#endif
+	    if (*p == '-')
+	    {
+		++p;
+		if (*p != ']' && *p != NUL)
+		    mb_ptr_adv(p);
+	    }
+	else if (*p == '\\'
+		&& !cpo_bsl
+		&& (vim_strchr(REGEXP_INRANGE, p[1]) != NULL
+		    || (!cpo_lit && vim_strchr(REGEXP_ABBR, p[1]) != NULL)))
+	    p += 2;
+	else if (*p == '[')
+	{
+	    if (get_char_class(&p) == CLASS_NONE
+		    && get_equi_class(&p) == 0
+		    && get_coll_element(&p) == 0)
+		++p; /* It was not a class name */
+	}
+	else
+	    ++p;
+}
+return p;
 }
 /*
 * Skip past regular expression.
 * Stop at end of "startp" or where "dirc" is found ('/', '?', etc).
 if (re_multi_type(op) == NOT_MULTI)
 {
 	*flagp = flags;
 	return ret;
 }
-if (!(flags & HASWIDTH) && re_multi_type(op) == MULTI_MULT)
-{
-	if (op == Magic('*'))
-	    EMSG_M_RET_NULL(_("E56: %s* operand could be empty"),
-						       reg_magic >= MAGIC_ON);
-	if (op == Magic('+'))
-	    EMSG_M_RET_NULL(_("E57: %s+ operand could be empty"),
-						       reg_magic == MAGIC_ALL);
-	/* "\{}" is checked below, it's allowed when there is an upper limit */
-}
 /* default flags */
 *flagp = (WORST | SPSTART | (flags & (HASNL | HASLOOKBH)));
 skipchr();
 switch (op)
 	    break;
 	case Magic('{'):
 	    if (!read_limits(&minval, &maxval))
 		return NULL;
-	    if (!(flags & HASWIDTH) && (maxval > minval
-				 ? maxval >= MAX_LIMIT : minval >= MAX_LIMIT))
-		EMSG_M_RET_NULL(_("E58: %s{ operand could be empty"),
-						      reg_magic == MAGIC_ALL);
 	    if (flags & SIMPLE)
 	    {
 		reginsert(BRACE_SIMPLE, ret);
 		reginsert_limits(BRACE_LIMITS, minval, maxval, ret);
 	    }
 int		   *flagp;
 {
 char_u	    *ret;
 int		    flags;
 int		    cpo_lit;	    /* 'cpoptions' contains 'l' flag */
+int		    cpo_bsl;	    /* 'cpoptions' contains '\' flag */
 int		    c;
 static char_u   *classchars = (char_u *)".iIkKfFpPsSdDxXoOwWhHaAlLuU";
 static int	    classcodes[] = {ANY, IDENT, SIDENT, KWORD, SKWORD,
 				    FNAME, SFNAME, PRINT, SPRINT,
 				    WHITE, NWHITE, DIGIT, NDIGIT,
 char_u	    *p;
 int		    extra = 0;
 *flagp = WORST;		/* Tentatively. */
 cpo_lit = (!reg_syn && vim_strchr(p_cpo, CPO_LITERAL) != NULL);
+cpo_bsl = (!reg_syn && vim_strchr(p_cpo, CPO_BACKSL) != NULL);
 c = getchr();
 switch (c)
 {
 case Magic('^'):
 		else
 		    ret = regnode(ANYOF + extra);
 		/* At the start ']' and '-' mean the literal character. */
 		if (*regparse == ']' || *regparse == '-')
+		{
+		    startc = *regparse;
 		    regc(*regparse++);
+		}
 		while (*regparse != NUL && *regparse != ']')
 		{
 		    if (*regparse == '-')
 		    {
 			    regc('-');
 			    startc = '-';	/* [--x] is a range */
 			}
 			else
 			{
+			    /* Also accept "a-[.z.]" */
+			    endc = 0;
+			    if (*regparse == '[')
+				endc = get_coll_element(&regparse);
+			    if (endc == 0)
+			    {
 #ifdef FEAT_MBYTE
-			    if (has_mbyte)
+				if (has_mbyte)
-				endc = mb_ptr2char_adv(&regparse);
+				    endc = mb_ptr2char_adv(&regparse);
-			    else
+				else
 #endif
-				endc = *regparse++;
+				    endc = *regparse++;
+			    }
 			    /* Handle \o40, \x20 and \u20AC style sequences */
-			    if (endc == '\\' && !cpo_lit)
+			    if (endc == '\\' && !cpo_lit && !cpo_bsl)
 				endc = coll_get_char();
 			    if (startc > endc)
 				EMSG_RET_NULL(_(e_invrange));
 #ifdef FEAT_MBYTE
 		    }
 		    /*
 		     * Only "\]", "\^", "\]" and "\\" are special in Vi.  Vim
 		     * accepts "\t", "\e", etc., but only when the 'l' flag in
 		     * 'cpoptions' is not included.
+		     * Posix doesn't recognize backslash at all.
 		     */
 		    else if (*regparse == '\\'
+			    && !cpo_bsl
 			    && (vim_strchr(REGEXP_INRANGE, regparse[1]) != NULL
 				|| (!cpo_lit
 				    && vim_strchr(REGEXP_ABBR,
 						       regparse[1]) != NULL)))
 		    {
 		    else if (*regparse == '[')
 		    {
 			int c_class;
 			int cu;
-			c_class = skip_class_name(&regparse);
+			c_class = get_char_class(&regparse);
 			startc = -1;
 			/* Characters assumed to be 8 bits! */
 			switch (c_class)
 			{
 			    case CLASS_NONE:
-				/* literal '[', allow [[-x] as a range */
+				c_class = get_equi_class(&regparse);
-				startc = *regparse++;
+				if (c_class != 0)
-				regc(startc);
+				{
+				    /* produce equivalence class */
+				    reg_equi_class(c_class);
+				}
+				else if ((c_class =
+					    get_coll_element(&regparse)) != 0)
+				{
+				    /* produce a collating element */
+				    regmbc(c_class);
+				}
+				else
+				{
+				    /* literal '[', allow [[-x] as a range */
+				    startc = *regparse++;
+				    regc(startc);
+				}
 				break;
 			    case CLASS_ALNUM:
 				for (cu = 1; cu <= 255; cu++)
 				    if (isalnum(cu))
 					regc(cu);
 }
 static int
 peekchr()
 {
+static int	after_slash = FALSE;
 if (curchr == -1)
 {
 	switch (curchr = regparse[0])
 	{
 	case '.':
 	    /* magic only after "\v" */
 	    if (reg_magic == MAGIC_ALL)
 		curchr = Magic(curchr);
 	    break;
 	case '*':
-	    /* * is not magic as the very first character, eg "?*ptr" and when
+	    /* * is not magic as the very first character, eg "?*ptr", when
-	     * after '^', eg "/^*ptr" */
+	     * after '^', eg "/^*ptr" and when after "\(", "\|", "\&".  But
-	    if (reg_magic >= MAGIC_ON && !at_start
+	     * "\(\*" is not magic, thus must be magic if "after_slash" */
-				 && !(prev_at_start && prevchr == Magic('^')))
+	    if (reg_magic >= MAGIC_ON
+		    && !at_start
+		    && !(prev_at_start && prevchr == Magic('^'))
+		    && (after_slash
+			|| (prevchr != Magic('(')
+			    && prevchr != Magic('&')
+			    && prevchr != Magic('|'))))
 		curchr = Magic('*');
 	    break;
 	case '^':
 	    /* '^' is only magic as the very first character and if it's after
 	     * "\(", "\|", "\&' or "\n" */
 		     */
 		    curchr = -1;
 		    prev_at_start = at_start;
 		    at_start = FALSE;	/* be able to say "/\*ptr" */
 		    ++regparse;
+		    ++after_slash;
 		    peekchr();
 		    --regparse;
+		    --after_slash;
 		    curchr = toggle_Magic(curchr);
 		}
 		else if (vim_strchr(REGEXP_ABBR, c))
 		{
 		    /*
 	*maxval = *minval;	    /* It was \{n} or \{-n} */
 else
 	*maxval = MAX_LIMIT;	    /* It was \{} or \{-} */
 if (*regparse == '\\')
 	regparse++;	/* Allow either \{...} or \{...\} */
-if (*regparse != '}' || (*maxval == 0 && *minval == 0))
+if (*regparse != '}')
 {
 	sprintf((char *)IObuff, _("E554: Syntax error in %s{...}"),
 					  reg_magic == MAGIC_ALL ? "" : "\\");
 	EMSG_RET_FAIL(IObuff);
 }
 	*(posp) = (savep)->se_u.pos; \
 else \
 	*(pp) = (savep)->se_u.ptr; }
 static int	re_num_cmp __ARGS((long_u val, char_u *scan));
-static int	regmatch __ARGS((char_u *prog));
+static int	regmatch __ARGS((char_u *prog, regsave_T *startp));
 static int	regrepeat __ARGS((char_u *p, long maxcount));
 #ifdef DEBUG
 int		regnarrate = 0;
 #endif
 /* Clear the external match subpointers if necessary. */
 if (prog->reghasz == REX_SET)
 	need_clear_zsubexpr = TRUE;
 #endif
-if (regmatch(prog->program + 1))
+if (regmatch(prog->program + 1, NULL))
 {
 	cleanup_subexpr();
 	if (REG_MULTI)
 	{
 	    if (reg_startpos[0].lnum < 0)
 * the last matched character.
 * Returns FALSE when there is no match.  Leaves reginput and reglnum in an
 * undefined state!
 */
 static int
-regmatch(scan)
+regmatch(scan, startp)
 char_u	*scan;		/* Current node. */
+regsave_T	*startp;	/* start position for BACK */
 {
 char_u	*next;		/* Next node. */
 int		op;
 int		c;
 	  case NOTHING:
 	    break;
 	  case BACK:
+	    /* When we run into BACK without matching something non-empty, we
+	     * fail. */
+	    if (startp != NULL && reg_save_equal(startp))
+		return FALSE;
 	    break;
 	  case MOPEN + 0:   /* Match start: \zs */
 	  case MOPEN + 1:   /* \( */
 	  case MOPEN + 2:
 		no = op - MOPEN;
 		cleanup_subexpr();
 		save_se(&save, &reg_startpos[no], &reg_startp[no]);
-		if (regmatch(next))
+		if (regmatch(next, startp))
 		    return TRUE;
 		restore_se(&save, &reg_startpos[no], &reg_startp[no]);
 		return FALSE;
 	    }
 	    /* break; Not Reached */
 	  case NOPEN:	    /* \%( */
 	  case NCLOSE:	    /* \) after \%( */
-		if (regmatch(next))
+		if (regmatch(next, startp))
 		    return TRUE;
 		return FALSE;
 		/* break; Not Reached */
 #ifdef FEAT_SYN_HL
 		no = op - ZOPEN;
 		cleanup_zsubexpr();
 		save_se(&save, &reg_startzpos[no], &reg_startzp[no]);
-		if (regmatch(next))
+		if (regmatch(next, startp))
 		    return TRUE;
 		restore_se(&save, &reg_startzpos[no], &reg_startzp[no]);
 		return FALSE;
 	    }
 		no = op - MCLOSE;
 		cleanup_subexpr();
 		save_se(&save, &reg_endpos[no], &reg_endp[no]);
-		if (regmatch(next))
+		if (regmatch(next, startp))
 		    return TRUE;
 		restore_se(&save, &reg_endpos[no], &reg_endp[no]);
 		return FALSE;
 	    }
 		no = op - ZCLOSE;
 		cleanup_zsubexpr();
 		save_se(&save, &reg_endzpos[no], &reg_endzp[no]);
-		if (regmatch(next))
+		if (regmatch(next, startp))
 		    return TRUE;
 		restore_se(&save, &reg_endzpos[no], &reg_endzp[no]);
 		return FALSE;
 	    }
 		    regsave_T	save;
 		    do
 		    {
 			reg_save(&save);
-			if (regmatch(OPERAND(scan)))
+			if (regmatch(OPERAND(scan), &save))
 			    return TRUE;
 			reg_restore(&save);
 			scan = regnext(scan);
 		    } while (scan != NULL && OP(scan) == BRANCH);
 		    return FALSE;
 		/* If not matched enough times yet, try one more */
 		if (brace_count[no] <= (brace_min[no] <= brace_max[no]
 				    ? brace_min[no] : brace_max[no]))
 		{
 		    reg_save(&save);
-		    if (regmatch(OPERAND(scan)))
+		    if (regmatch(OPERAND(scan), &save))
 			return TRUE;
 		    reg_restore(&save);
 		    --brace_count[no];	/* failed, decrement match count */
 		    return FALSE;
 		}
 		{
 		    /* Range is the normal way around, use longest match */
 		    if (brace_count[no] <= brace_max[no])
 		    {
 			reg_save(&save);
-			if (regmatch(OPERAND(scan)))
+			if (regmatch(OPERAND(scan), &save))
 			    return TRUE;	/* matched some more times */
 			reg_restore(&save);
 			--brace_count[no];  /* matched just enough times */
-			/* continue with the items after \{} */
+			/* {  continue with the items after \{} */
 		    }
 		}
 		else
 		{
 		    /* Range is backwards, use shortest match first */
 		    if (brace_count[no] <= brace_min[no])
 		    {
 			reg_save(&save);
-			if (regmatch(next))
+			if (regmatch(next, &save))
 			    return TRUE;
 			reg_restore(&save);
 			next = OPERAND(scan);
 			/* must try to match one more item */
 		    }
 			/* If it could match, try it. */
 			if (nextb == NUL || *reginput == nextb
 						    || *reginput == nextb_ic)
 			{
 			    reg_save(&save);
-			    if (regmatch(next))
+			    if (regmatch(next, startp))
 				return TRUE;
 			    reg_restore(&save);
 			}
 			/* Couldn't or didn't match -- back up one char. */
 			if (--count < minval)
 			/* If it could work, try it. */
 			if (nextb == NUL || *reginput == nextb
 						    || *reginput == nextb_ic)
 			{
 			    reg_save(&save);
-			    if (regmatch(next))
+			    if (regmatch(next, &save))
 				return TRUE;
 			    reg_restore(&save);
 			}
 			/* Couldn't or didn't match: try advancing one char. */
 			if (count == minval
 		regsave_T	save;
 		/* If the operand matches, we fail.  Otherwise backup and
 		 * continue with the next item. */
 		reg_save(&save);
-		if (regmatch(OPERAND(scan)))
+		if (regmatch(OPERAND(scan), startp))
 		    return FALSE;
 		reg_restore(&save);
 	    }
 	    break;
 		regsave_T	save;
 		/* If the operand doesn't match, we fail.  Otherwise backup
 		 * and continue with the next item. */
 		reg_save(&save);
-		if (!regmatch(OPERAND(scan)))
+		if (!regmatch(OPERAND(scan), startp))
 		    return FALSE;
 		if (op == MATCH)	    /* zero-width */
 		    reg_restore(&save);
 	    }
 	    break;
 		 * the match ends at the current position.
 		 * First check if the next item matches, that's probably
 		 * faster.
 		 */
 		reg_save(&save_start);
-		if (regmatch(next))
+		if (regmatch(next, startp))
 		{
 		    /* save the position after the found match for next */
 		    reg_save(&save_after);
 		    /* start looking for a match with operand at the current
 		    save_behind_pos = behind_pos;
 		    behind_pos = save_start;
 		    for (;;)
 		    {
 			reg_restore(&save_start);
-			if (regmatch(OPERAND(scan))
+			if (regmatch(OPERAND(scan), startp)
 				&& reg_save_equal(&behind_pos))
 			{
 			    behind_pos = save_behind_pos;
 			    /* found a match that ends where "next" started */
 			    if (needmatch)

Mercurial > vim

comparison src/regexp.c @ 167:c93c9cad9618