vim: src/regexp_nfa.c comparison

comparison src/regexp_nfa.c @ 4799:e3f9e33fb28c v7.3.1146

updated for version 7.3.1146 Problem: New regexp engine: look-behind match not checked when followed by zero-width match. Solution: Do the look-behind match before adding the zero-width state.

author	Bram Moolenaar <bram@vim.org>
date	Sat, 08 Jun 2013 13:33:37 +0200
parents	a30e3762957d
children	3cd3cc1e9119

comparison

equal deleted inserted replaced

-:b4b5c5eadd9a
+:e3f9e33fb28c
 int		listidx;
 nfa_list_T	*thislist;
 nfa_list_T	*nextlist;
 int		*listids = NULL;
 nfa_state_T *add_state;
+int		add_here;
 int		add_count;
 int		add_off;
 garray_T	pimlist;
 int		toplevel = start->c == NFA_MOPEN;
 #ifdef NFA_REGEXP_DEBUG_LOG
 	    /*
 	     * Handle the possible codes of the current state.
 	     * The most important is NFA_MATCH.
 	     */
 	    add_state = NULL;
+	    add_here = FALSE;
 	    add_count = 0;
 	    switch (t->state->c)
 	    {
 	    case NFA_MATCH:
 	      {
 #endif
 			    /* t->state->out1 is the corresponding
 			     * END_INVISIBLE node; Add its out to the current
 			     * list (zero-width match). */
-			    addstate_here(thislist, t->state->out1->out,
+			    add_here = TRUE;
-						  &t->subs, t->pim, &listidx);
+			    add_state = t->state->out1->out;
 			}
 		    }
 		    else
 		    {
 			/*
 			 * First try matching what follows at the current
-			 * position.  Only if a match is found, addstate() is
+			 * position.  Only if a match is found, before
-			 * called, then verify the invisible match matches.
+			 * addstate() is called, then verify the invisible
-			 * Add a nfa_pim_T to the following states, it
+			 * match matches.  Add a nfa_pim_T to the following
-			 * contains info about the invisible match.
+			 * states, it contains info about the invisible match.
 			 */
 			if (ga_grow(&pimlist, 1) == FAIL)
 			    goto theend;
 			pim = (nfa_pim_T *)pimlist.ga_data + pimlist.ga_len;
 			++pimlist.ga_len;
 		    if (bytelen == 0)
 		    {
 			/* empty match, output of corresponding
 			 * NFA_END_PATTERN/NFA_SKIP to be used at current
 			 * position */
-			addstate_here(thislist, t->state->out1->out->out,
+			add_here = TRUE;
-						  &t->subs, t->pim, &listidx);
+			add_state = t->state->out1->out->out;
 		    }
 		    else if (bytelen <= clen)
 		    {
 			/* match current character, output of corresponding
 			 * NFA_END_PATTERN to be used at next position. */
 		break;
 	      }
 	    case NFA_BOL:
 		if (reginput == regline)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_EOL:
 		if (curc == NUL)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_BOW:
 		result = TRUE;
 		else if (!vim_iswordc_buf(curc, reg_buf)
 			   || (reginput > regline
 				   && vim_iswordc_buf(reginput[-1], reg_buf)))
 		    result = FALSE;
 		if (result)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_EOW:
 		result = TRUE;
 		if (reginput == regline)
 		else if (!vim_iswordc_buf(reginput[-1], reg_buf)
 			|| (reginput[0] != NUL
 					   && vim_iswordc_buf(curc, reg_buf)))
 		    result = FALSE;
 		if (result)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_BOF:
 		if (reglnum == 0 && reginput == regline
 					&& (!REG_MULTI || reg_firstlnum == 1))
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_EOF:
 		if (reglnum == reg_maxline && curc == NUL)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 #ifdef FEAT_MBYTE
 	    case NFA_COMPOSING:
 	    {
 		{
 		    if (bytelen == 0)
 		    {
 			/* empty match always works, output of NFA_SKIP to be
 			 * used next */
-			addstate_here(thislist, t->state->out->out, &t->subs,
+			add_here = TRUE;
-							    t->pim, &listidx);
+			add_state = t->state->out->out;
 		    }
 		    else if (bytelen <= clen)
 		    {
 			/* match current character, jump ahead to out of
 			 * NFA_SKIP */
 	    case NFA_LNUM_LT:
 		result = (REG_MULTI &&
 			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,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_COL:
 	    case NFA_COL_GT:
 	    case NFA_COL_LT:
 		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,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_VCOL:
 	    case NFA_VCOL_GT:
 	    case NFA_VCOL_LT:
 		result = nfa_re_num_cmp(t->state->val, t->state->c - NFA_VCOL,
 		    (long_u)win_linetabsize(
 			    reg_win == NULL ? curwin : reg_win,
 			    regline, (colnr_T)(reginput - regline)) + 1);
 		if (result)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_MARK:
 	    case NFA_MARK_GT:
 	    case NFA_MARK_LT:
 					: t->state->c == NFA_MARK_LT))
 				: (pos->lnum < reglnum + reg_firstlnum
 				    ? t->state->c == NFA_MARK_GT
 				    : t->state->c == NFA_MARK_LT)));
 		if (result)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	      }
 	    case NFA_CURSOR:
 		result = (reg_win != NULL
 			&& (reglnum + reg_firstlnum == reg_win->w_cursor.lnum)
 			&& ((colnr_T)(reginput - regline)
 						   == reg_win->w_cursor.col));
 		if (result)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 		break;
 	    case NFA_VISUAL:
 #ifdef FEAT_VISUAL
 		result = reg_match_visual();
 		if (result)
-		    addstate_here(thislist, t->state->out, &t->subs,
+		{
-							    t->pim, &listidx);
+		    add_here = TRUE;
+		    add_state = t->state->out;
+		}
 #endif
 		break;
 	    default:	/* regular character */
 	      {
 	    if (add_state != NULL)
 	    {
 		if (t->pim != NULL)
 		{
 		    /* postponed invisible match */
-		    /* TODO: also do t->pim->pim recursively? */
 		    if (t->pim->result == NFA_PIM_TODO)
 		    {
 #ifdef ENABLE_LOG
 			fprintf(log_fd, "\n");
 			fprintf(log_fd, "==================================\n");
 		    else
 			/* look-behind match failed, don't add the state */
 			continue;
 		}
-		addstate(nextlist, add_state, &t->subs, add_off);
+		if (add_here)
-		if (add_count > 0)
+		    addstate_here(thislist, add_state, &t->subs, NULL, &listidx);
-		    nextlist->t[nextlist->n - 1].count = add_count;
+		else
+		{
+		    addstate(nextlist, add_state, &t->subs, add_off);
+		    if (add_count > 0)
+			nextlist->t[nextlist->n - 1].count = add_count;
+		}
 	    }
 	} /* for (thislist = thislist; thislist->state; thislist++) */
 	/* Look for the start of a match in the current position by adding the

Mercurial > vim

comparison src/regexp_nfa.c @ 4799:e3f9e33fb28c v7.3.1146