Tree - rpms/vim - CentOS Git server

rpms / vim

Files

Commit: d9a6c535273618e845eba56aef878e32c55f3016

Blob Blame History Raw

 To: vim_dev@googlegroups.com
Subject: Patch 7.3.1076
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.1076
Problem:    New regexp engine: \@= and \& don't work.
Solution:   Make these items work.  Add column info to logging.
Files:	    src/regexp_nfa.c, src/testdir/test64.in, src/testdir/test64.ok
 
 
*** ../vim-7.3.1075/src/regexp_nfa.c	2013-05-30 19:18:27.000000000 +0200
--- src/regexp_nfa.c	2013-05-30 21:41:51.000000000 +0200
***************
*** 1740,1747 ****
  			    STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH"); break;
  	case NFA_PREV_ATOM_NO_WIDTH_NEG:
  			    STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH_NEG"); break;
! 	case NFA_NOPEN:		    STRCPY(code, "NFA_MOPEN_INVISIBLE"); break;
! 	case NFA_NCLOSE:	    STRCPY(code, "NFA_MCLOSE_INVISIBLE"); break;
  	case NFA_START_INVISIBLE:   STRCPY(code, "NFA_START_INVISIBLE"); break;
  	case NFA_END_INVISIBLE:	    STRCPY(code, "NFA_END_INVISIBLE"); break;
  
--- 1740,1747 ----
  			    STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH"); break;
  	case NFA_PREV_ATOM_NO_WIDTH_NEG:
  			    STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH_NEG"); break;
! 	case NFA_NOPEN:		    STRCPY(code, "NFA_NOPEN"); break;
! 	case NFA_NCLOSE:	    STRCPY(code, "NFA_NCLOSE"); break;
  	case NFA_START_INVISIBLE:   STRCPY(code, "NFA_START_INVISIBLE"); break;
  	case NFA_END_INVISIBLE:	    STRCPY(code, "NFA_END_INVISIBLE"); break;
  
***************
*** 2373,2384 ****
  	    break;
  
  	case NFA_PREV_ATOM_NO_WIDTH:
! 	    /* The \@= operator: match the preceding atom with 0 width.
  	     * Surrounds the preceding atom with START_INVISIBLE and
! 	     * END_INVISIBLE, similarly to MOPEN.
! 	     */
! 	    /* TODO: Maybe this drops the speed? */
! 	    goto theend;
  
  	    if (nfa_calc_size == TRUE)
  	    {
--- 2373,2381 ----
  	    break;
  
  	case NFA_PREV_ATOM_NO_WIDTH:
! 	    /* The \@= operator: match the preceding atom with zero width.
  	     * Surrounds the preceding atom with START_INVISIBLE and
! 	     * END_INVISIBLE, similarly to MOPEN. */
  
  	    if (nfa_calc_size == TRUE)
  	    {
***************
*** 2745,2750 ****
--- 2742,2750 ----
      int			save_in_use;
      char_u		*save_ptr;
      int			i;
+ #ifdef ENABLE_LOG
+     int			did_print = FALSE;
+ #endif
  
      if (l == NULL || state == NULL)
  	return;
***************
*** 2782,2788 ****
  	    /* 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)
! 		return;
  	    state->lastlist = l->id;
  	    break;
  
--- 2782,2788 ----
  	    /* 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)
! 		goto skip_add;
  	    state->lastlist = l->id;
  	    break;
  
***************
*** 2792,2798 ****
--- 2792,2806 ----
  		/* This state is already in the list, don't add it again,
  		 * unless it is an MOPEN that is used for a backreference. */
  		if (!nfa_has_backref)
+ 		{
+ skip_add:
+ #ifdef ENABLE_LOG
+ 		    nfa_set_code(state->c);
+ 		    fprintf(log_fd, "> Not adding state %d to list %d. char %d: %s\n",
+ 			    abs(state->id), l->id, state->c, code);
+ #endif
  		    return;
+ 		}
  
  		/* See if the same state is already in the list with the same
  		 * positions. */
***************
*** 2801,2807 ****
  		    thread = &l->t[i];
  		    if (thread->state->id == state->id
  					  && sub_equal(&thread->sub, sub))
! 			return;
  		}
  	    }
  
--- 2809,2815 ----
  		    thread = &l->t[i];
  		    if (thread->state->id == state->id
  					  && sub_equal(&thread->sub, sub))
! 			goto skip_add;
  		}
  	    }
  
***************
*** 2832,2843 ****
  				&sub->list.line[0],
  				sizeof(struct linepos) * sub->in_use);
  	    }
      }
  
  #ifdef ENABLE_LOG
!     nfa_set_code(state->c);
!     fprintf(log_fd, "> Adding state %d to list. Character %d: %s\n",
! 	abs(state->id), state->c, code);
  #endif
      switch (state->c)
      {
--- 2840,2878 ----
  				&sub->list.line[0],
  				sizeof(struct linepos) * sub->in_use);
  	    }
+ #ifdef ENABLE_LOG
+ 	    {
+ 		int col;
+ 
+ 		if (thread->sub.in_use <= 0)
+ 		    col = -1;
+ 		else if (REG_MULTI)
+ 		    col = thread->sub.list.multi[0].start.col;
+ 		else
+ 		    col = (int)(thread->sub.list.line[0].start - regline);
+ 		nfa_set_code(state->c);
+ 		fprintf(log_fd, "> Adding state %d to list %d. char %d: %s (start col %d)\n",
+ 		        abs(state->id), l->id, state->c, code, col);
+ 		did_print = TRUE;
+ 	    }
+ #endif
      }
  
  #ifdef ENABLE_LOG
!     if (!did_print)
!     {
! 	int col;
! 
! 	if (sub->in_use <= 0)
! 	    col = -1;
! 	else if (REG_MULTI)
! 	    col = sub->list.multi[0].start.col;
! 	else
! 	    col = (int)(sub->list.line[0].start - regline);
! 	nfa_set_code(state->c);
! 	fprintf(log_fd, "> Processing state %d for list %d. char %d: %s (start col %d)\n",
! 		abs(state->id), l->id, state->c, code, col);
!     }
  #endif
      switch (state->c)
      {
***************
*** 2873,2886 ****
  	    addstate(l, state->out, sub, off);
  	    break;
  
- 	/* If this state is reached, then a recursive call of nfa_regmatch()
- 	 * succeeded. the next call saves the found submatches in the
- 	 * first state after the "invisible" branch. */
- #if 0
- 	case NFA_END_INVISIBLE:
- 	    break;
- #endif
- 
  	case NFA_MOPEN + 0:
  	case NFA_MOPEN + 1:
  	case NFA_MOPEN + 2:
--- 2908,2913 ----
***************
*** 3450,3458 ****
  	    fprintf(debug, "%s, ", code);
  #endif
  #ifdef ENABLE_LOG
! 	    nfa_set_code(t->state->c);
! 	    fprintf(log_fd, "(%d) %s, code %d ... \n", abs(t->state->id),
! 						      code, (int)t->state->c);
  #endif
  
  	    /*
--- 3477,3495 ----
  	    fprintf(debug, "%s, ", code);
  #endif
  #ifdef ENABLE_LOG
! 	    {
! 		int col;
! 
! 		if (t->sub.in_use <= 0)
! 		    col = -1;
! 		else if (REG_MULTI)
! 		    col = t->sub.list.multi[0].start.col;
! 		else
! 		    col = (int)(t->sub.list.line[0].start - regline);
! 		nfa_set_code(t->state->c);
! 		fprintf(log_fd, "(%d) char %d %s (start col %d) ... \n",
! 			abs(t->state->id), (int)t->state->c, code, col);
! 	    }
  #endif
  
  	    /*
***************
*** 3504,3509 ****
--- 3541,3547 ----
  		    addstate_here(thislist, t->state->out, &t->sub, &listidx);
  		else
  		{
+ 		    /* TODO: only copy positions in use. */
  		    *m = t->sub;
  		    nfa_match = TRUE;
  		}
***************
*** 3538,3543 ****
--- 3576,3582 ----
  		result = nfa_regmatch(t->state->out, submatch, m);
  		nfa_set_neg_listids(start);
  		nfa_restore_listids(start, listids);
+ 		nfa_match = FALSE;
  
  #ifdef ENABLE_LOG
  		log_fd = fopen(NFA_REGEXP_RUN_LOG, "a");
***************
*** 3575,3583 ****
  			    t->sub.list.line[j].start = m->list.line[j].start;
  			    t->sub.list.line[j].end = m->list.line[j].end;
  			}
! 		    t->sub.in_use = m->in_use;
  
! 		    /* t->state->out1 is the corresponding END_INVISIBLE node */
  		    addstate_here(thislist, t->state->out1->out, &t->sub,
  								    &listidx);
  		}
--- 3614,3624 ----
  			    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);
  		}
***************
*** 4146,4152 ****
  	fprintf(f, "\tRegexp is \"%s\"\n", nfa_regengine.expr);
  #endif
  	fprintf(f, "\tInput text is \"%s\" \n", reginput);
! 	fprintf(f, "		=======================================================\n\n\n\n\n\n\n");
  	nfa_print_state(f, start);
  	fprintf(f, "\n\n");
  	fclose(f);
--- 4187,4193 ----
  	fprintf(f, "\tRegexp is \"%s\"\n", nfa_regengine.expr);
  #endif
  	fprintf(f, "\tInput text is \"%s\" \n", reginput);
! 	fprintf(f, "		=======================================================\n\n");
  	nfa_print_state(f, start);
  	fprintf(f, "\n\n");
  	fclose(f);
*** ../vim-7.3.1075/src/testdir/test64.in	2013-05-30 18:45:20.000000000 +0200
--- src/testdir/test64.in	2013-05-30 21:28:06.000000000 +0200
***************
*** 294,315 ****
  :call add(tl, [2, '\v(a \zsif .*){2}', 'a if then a if last', 'if last', 'a if last'])
  :call add(tl, [2, '\>\zs.', 'aword. ', '.'])
  :"
! :"""" Tests for \@ features
! :call add(tl, [0, 'abc\@=', 'abc', 'ab'])
! :call add(tl, [0, 'abc\@=cd', 'abcd', 'abcd'])
! :call add(tl, [0, 'abc\@=', 'ababc', 'ab'])
  :" will never match, no matter the input text
  :call add(tl, [2, 'abcd\@=e', 'abcd'])
  :" will never match
  :call add(tl, [2, 'abcd\@=e', 'any text in here ... '])
! :call add(tl, [0, '\v(abc)@=..', 'xabcd', 'ab', 'abc'])
  :" no match
  :call add(tl, [2, '\(.*John\)\@=.*Bob', 'here is John, and here is B'])
! :call add(tl, [0, '\(John.*\)\@=.*Bob', 'John is Bobs friend', 'John is Bob', 'John is Bobs friend'])
  :" no match
  :call add(tl, [2, '.*John\&.*Bob', 'here is John, and here is B'])
! :call add(tl, [0, '.*John\&.*Bob', 'John is Bobs friend', 'John is Bob'])
! :call add(tl, [0, '\v(test1)@=.*yep', 'this is a test1, yep it is', 'test1, yep', 'test1'])
  :"
  :"""" Combining different tests and features
  :call add(tl, [2, '[[:alpha:]]\{-2,6}', '787abcdiuhsasiuhb4', 'ab'])
--- 294,315 ----
  :call add(tl, [2, '\v(a \zsif .*){2}', 'a if then a if last', 'if last', 'a if last'])
  :call add(tl, [2, '\>\zs.', 'aword. ', '.'])
  :"
! :"""" Tests for \@= and \& features
! :call add(tl, [2, 'abc\@=', 'abc', 'ab'])
! :call add(tl, [2, 'abc\@=cd', 'abcd', 'abcd'])
! :call add(tl, [2, 'abc\@=', 'ababc', 'ab'])
  :" will never match, no matter the input text
  :call add(tl, [2, 'abcd\@=e', 'abcd'])
  :" will never match
  :call add(tl, [2, 'abcd\@=e', 'any text in here ... '])
! :call add(tl, [2, '\v(abc)@=..', 'xabcd', 'ab', 'abc'])
  :" no match
  :call add(tl, [2, '\(.*John\)\@=.*Bob', 'here is John, and here is B'])
! :call add(tl, [2, '\(John.*\)\@=.*Bob', 'John is Bobs friend', 'John is Bob', 'John is Bobs friend'])
  :" no match
  :call add(tl, [2, '.*John\&.*Bob', 'here is John, and here is B'])
! :call add(tl, [2, '.*John\&.*Bob', 'John is Bobs friend', 'John is Bob'])
! :call add(tl, [2, '\v(test1)@=.*yep', 'this is a test1, yep it is', 'test1, yep', 'test1'])
  :"
  :"""" Combining different tests and features
  :call add(tl, [2, '[[:alpha:]]\{-2,6}', '787abcdiuhsasiuhb4', 'ab'])
*** ../vim-7.3.1075/src/testdir/test64.ok	2013-05-30 18:45:20.000000000 +0200
--- src/testdir/test64.ok	2013-05-30 21:29:06.000000000 +0200
***************
*** 647,656 ****
--- 647,659 ----
  OK 2 - \>\zs.
  OK 0 - abc\@=
  OK 1 - abc\@=
+ OK 2 - abc\@=
  OK 0 - abc\@=cd
  OK 1 - abc\@=cd
+ OK 2 - abc\@=cd
  OK 0 - abc\@=
  OK 1 - abc\@=
+ OK 2 - abc\@=
  OK 0 - abcd\@=e
  OK 1 - abcd\@=e
  OK 2 - abcd\@=e
***************
*** 659,676 ****
--- 662,683 ----
  OK 2 - abcd\@=e
  OK 0 - \v(abc)@=..
  OK 1 - \v(abc)@=..
+ OK 2 - \v(abc)@=..
  OK 0 - \(.*John\)\@=.*Bob
  OK 1 - \(.*John\)\@=.*Bob
  OK 2 - \(.*John\)\@=.*Bob
  OK 0 - \(John.*\)\@=.*Bob
  OK 1 - \(John.*\)\@=.*Bob
+ OK 2 - \(John.*\)\@=.*Bob
  OK 0 - .*John\&.*Bob
  OK 1 - .*John\&.*Bob
  OK 2 - .*John\&.*Bob
  OK 0 - .*John\&.*Bob
  OK 1 - .*John\&.*Bob
+ OK 2 - .*John\&.*Bob
  OK 0 - \v(test1)@=.*yep
  OK 1 - \v(test1)@=.*yep
+ OK 2 - \v(test1)@=.*yep
  OK 0 - [[:alpha:]]\{-2,6}
  OK 1 - [[:alpha:]]\{-2,6}
  OK 2 - [[:alpha:]]\{-2,6}
*** ../vim-7.3.1075/src/version.c	2013-05-30 19:18:27.000000000 +0200
--- src/version.c	2013-05-30 21:34:53.000000000 +0200
***************
*** 730,731 ****
--- 730,733 ----
  {   /* Add new patch number below this line */
+ /**/
+     1076,
  /**/
 
-- 
I'm not familiar with this proof, but I'm aware of a significant
following of toddlers who believe that peanut butter is the solution
to all of life's problems... 		-- Tim Hammerquist
 
 /// 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    ///

	To: vim_dev@googlegroups.com
	Subject: Patch 7.3.1076
	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.1076
	Problem: New regexp engine: \@= and \& don't work.
	Solution: Make these items work. Add column info to logging.
	Files: src/regexp_nfa.c, src/testdir/test64.in, src/testdir/test64.ok


	*** ../vim-7.3.1075/src/regexp_nfa.c 2013-05-30 19:18:27.000000000 +0200
	--- src/regexp_nfa.c 2013-05-30 21:41:51.000000000 +0200
	***************
	* 1740,1747 **
	STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH"); break;
	case NFA_PREV_ATOM_NO_WIDTH_NEG:
	STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH_NEG"); break;
	! case NFA_NOPEN: STRCPY(code, "NFA_MOPEN_INVISIBLE"); break;
	! case NFA_NCLOSE: STRCPY(code, "NFA_MCLOSE_INVISIBLE"); break;
	case NFA_START_INVISIBLE: STRCPY(code, "NFA_START_INVISIBLE"); break;
	case NFA_END_INVISIBLE: STRCPY(code, "NFA_END_INVISIBLE"); break;

	--- 1740,1747 ----
	STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH"); break;
	case NFA_PREV_ATOM_NO_WIDTH_NEG:
	STRCPY(code, "NFA_PREV_ATOM_NO_WIDTH_NEG"); break;
	! case NFA_NOPEN: STRCPY(code, "NFA_NOPEN"); break;
	! case NFA_NCLOSE: STRCPY(code, "NFA_NCLOSE"); break;
	case NFA_START_INVISIBLE: STRCPY(code, "NFA_START_INVISIBLE"); break;
	case NFA_END_INVISIBLE: STRCPY(code, "NFA_END_INVISIBLE"); break;

	***************
	* 2373,2384 **
	break;

	case NFA_PREV_ATOM_NO_WIDTH:
	! /* The \@= operator: match the preceding atom with 0 width.
	* Surrounds the preceding atom with START_INVISIBLE and
	! * END_INVISIBLE, similarly to MOPEN.
	! */
	! /* TODO: Maybe this drops the speed? */
	! goto theend;

	if (nfa_calc_size == TRUE)
	{
	--- 2373,2381 ----
	break;

	case NFA_PREV_ATOM_NO_WIDTH:
	! /* The \@= operator: match the preceding atom with zero width.
	* Surrounds the preceding atom with START_INVISIBLE and
	! * END_INVISIBLE, similarly to MOPEN. */

	if (nfa_calc_size == TRUE)
	{
	***************
	* 2745,2750 **
	--- 2742,2750 ----
	int save_in_use;
	char_u *save_ptr;
	int i;
	+ #ifdef ENABLE_LOG
	+ int did_print = FALSE;
	+ #endif

	if (l == NULL \|\| state == NULL)
	return;
	***************
	* 2782,2788 **
	/* 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)
	! return;
	state->lastlist = l->id;
	break;

	--- 2782,2788 ----
	/* 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)
	! goto skip_add;
	state->lastlist = l->id;
	break;

	***************
	* 2792,2798 **
	--- 2792,2806 ----
	/* This state is already in the list, don't add it again,
	* unless it is an MOPEN that is used for a backreference. */
	if (!nfa_has_backref)
	+ {
	+ skip_add:
	+ #ifdef ENABLE_LOG
	+ nfa_set_code(state->c);
	+ fprintf(log_fd, "> Not adding state %d to list %d. char %d: %s\n",
	+ abs(state->id), l->id, state->c, code);
	+ #endif
	return;
	+ }

	/* See if the same state is already in the list with the same
	* positions. */
	***************
	* 2801,2807 **
	thread = &l->t[i];
	if (thread->state->id == state->id
	&& sub_equal(&thread->sub, sub))
	! return;
	}
	}

	--- 2809,2815 ----
	thread = &l->t[i];
	if (thread->state->id == state->id
	&& sub_equal(&thread->sub, sub))
	! goto skip_add;
	}
	}

	***************
	* 2832,2843 **
	&sub->list.line[0],
	sizeof(struct linepos) * sub->in_use);
	}
	}

	#ifdef ENABLE_LOG
	! nfa_set_code(state->c);
	! fprintf(log_fd, "> Adding state %d to list. Character %d: %s\n",
	! abs(state->id), state->c, code);
	#endif
	switch (state->c)
	{
	--- 2840,2878 ----
	&sub->list.line[0],
	sizeof(struct linepos) * sub->in_use);
	}
	+ #ifdef ENABLE_LOG
	+ {
	+ int col;
	+
	+ if (thread->sub.in_use <= 0)
	+ col = -1;
	+ else if (REG_MULTI)
	+ col = thread->sub.list.multi[0].start.col;
	+ else
	+ col = (int)(thread->sub.list.line[0].start - regline);
	+ nfa_set_code(state->c);
	+ fprintf(log_fd, "> Adding state %d to list %d. char %d: %s (start col %d)\n",
	+ abs(state->id), l->id, state->c, code, col);
	+ did_print = TRUE;
	+ }
	+ #endif
	}

	#ifdef ENABLE_LOG
	! if (!did_print)
	! {
	! int col;
	!
	! if (sub->in_use <= 0)
	! col = -1;
	! else if (REG_MULTI)
	! col = sub->list.multi[0].start.col;
	! else
	! col = (int)(sub->list.line[0].start - regline);
	! nfa_set_code(state->c);
	! fprintf(log_fd, "> Processing state %d for list %d. char %d: %s (start col %d)\n",
	! abs(state->id), l->id, state->c, code, col);
	! }
	#endif
	switch (state->c)
	{
	***************
	* 2873,2886 **
	addstate(l, state->out, sub, off);
	break;

	- /* If this state is reached, then a recursive call of nfa_regmatch()
	- * succeeded. the next call saves the found submatches in the
	- * first state after the "invisible" branch. */
	- #if 0
	- case NFA_END_INVISIBLE:
	- break;
	- #endif
	-
	case NFA_MOPEN + 0:
	case NFA_MOPEN + 1:
	case NFA_MOPEN + 2:
	--- 2908,2913 ----
	***************
	* 3450,3458 **
	fprintf(debug, "%s, ", code);
	#endif
	#ifdef ENABLE_LOG
	! nfa_set_code(t->state->c);
	! fprintf(log_fd, "(%d) %s, code %d ... \n", abs(t->state->id),
	! code, (int)t->state->c);
	#endif

	/*
	--- 3477,3495 ----
	fprintf(debug, "%s, ", code);
	#endif
	#ifdef ENABLE_LOG
	! {
	! int col;
	!
	! if (t->sub.in_use <= 0)
	! col = -1;
	! else if (REG_MULTI)
	! col = t->sub.list.multi[0].start.col;
	! else
	! col = (int)(t->sub.list.line[0].start - regline);
	! nfa_set_code(t->state->c);
	! fprintf(log_fd, "(%d) char %d %s (start col %d) ... \n",
	! abs(t->state->id), (int)t->state->c, code, col);
	! }
	#endif

	/*
	***************
	* 3504,3509 **
	--- 3541,3547 ----
	addstate_here(thislist, t->state->out, &t->sub, &listidx);
	else
	{
	+ /* TODO: only copy positions in use. */
	*m = t->sub;
	nfa_match = TRUE;
	}
	***************
	* 3538,3543 **
	--- 3576,3582 ----
	result = nfa_regmatch(t->state->out, submatch, m);
	nfa_set_neg_listids(start);
	nfa_restore_listids(start, listids);
	+ nfa_match = FALSE;

	#ifdef ENABLE_LOG
	log_fd = fopen(NFA_REGEXP_RUN_LOG, "a");
	***************
	* 3575,3583 **
	t->sub.list.line[j].start = m->list.line[j].start;
	t->sub.list.line[j].end = m->list.line[j].end;
	}
	! t->sub.in_use = m->in_use;

	! /* t->state->out1 is the corresponding END_INVISIBLE node */
	addstate_here(thislist, t->state->out1->out, &t->sub,
	&listidx);
	}
	--- 3614,3624 ----
	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);
	}
	***************
	* 4146,4152 **
	fprintf(f, "\tRegexp is \"%s\"\n", nfa_regengine.expr);
	#endif
	fprintf(f, "\tInput text is \"%s\" \n", reginput);
	! fprintf(f, " =======================================================\n\n\n\n\n\n\n");
	nfa_print_state(f, start);
	fprintf(f, "\n\n");
	fclose(f);
	--- 4187,4193 ----
	fprintf(f, "\tRegexp is \"%s\"\n", nfa_regengine.expr);
	#endif
	fprintf(f, "\tInput text is \"%s\" \n", reginput);
	! fprintf(f, " =======================================================\n\n");
	nfa_print_state(f, start);
	fprintf(f, "\n\n");
	fclose(f);
	*** ../vim-7.3.1075/src/testdir/test64.in 2013-05-30 18:45:20.000000000 +0200
	--- src/testdir/test64.in 2013-05-30 21:28:06.000000000 +0200
	***************
	* 294,315 **
	:call add(tl, [2, '\v(a \zsif .*){2}', 'a if then a if last', 'if last', 'a if last'])
	:call add(tl, [2, '\>\zs.', 'aword. ', '.'])
	:"
	! :"""" Tests for \@ features
	! :call add(tl, [0, 'abc\@=', 'abc', 'ab'])
	! :call add(tl, [0, 'abc\@=cd', 'abcd', 'abcd'])
	! :call add(tl, [0, 'abc\@=', 'ababc', 'ab'])
	:" will never match, no matter the input text
	:call add(tl, [2, 'abcd\@=e', 'abcd'])
	:" will never match
	:call add(tl, [2, 'abcd\@=e', 'any text in here ... '])
	! :call add(tl, [0, '\v(abc)@=..', 'xabcd', 'ab', 'abc'])
	:" no match
	:call add(tl, [2, '\(.John\)\@=.Bob', 'here is John, and here is B'])
	! :call add(tl, [0, '\(John.\)\@=.Bob', 'John is Bobs friend', 'John is Bob', 'John is Bobs friend'])
	:" no match
	:call add(tl, [2, '.John\&.Bob', 'here is John, and here is B'])
	! :call add(tl, [0, '.John\&.Bob', 'John is Bobs friend', 'John is Bob'])
	! :call add(tl, [0, '\v(test1)@=.*yep', 'this is a test1, yep it is', 'test1, yep', 'test1'])
	:"
	:"""" Combining different tests and features
	:call add(tl, [2, '[[:alpha:]]\{-2,6}', '787abcdiuhsasiuhb4', 'ab'])
	--- 294,315 ----
	:call add(tl, [2, '\v(a \zsif .*){2}', 'a if then a if last', 'if last', 'a if last'])
	:call add(tl, [2, '\>\zs.', 'aword. ', '.'])
	:"
	! :"""" Tests for \@= and \& features
	! :call add(tl, [2, 'abc\@=', 'abc', 'ab'])
	! :call add(tl, [2, 'abc\@=cd', 'abcd', 'abcd'])
	! :call add(tl, [2, 'abc\@=', 'ababc', 'ab'])
	:" will never match, no matter the input text
	:call add(tl, [2, 'abcd\@=e', 'abcd'])
	:" will never match
	:call add(tl, [2, 'abcd\@=e', 'any text in here ... '])
	! :call add(tl, [2, '\v(abc)@=..', 'xabcd', 'ab', 'abc'])
	:" no match
	:call add(tl, [2, '\(.John\)\@=.Bob', 'here is John, and here is B'])
	! :call add(tl, [2, '\(John.\)\@=.Bob', 'John is Bobs friend', 'John is Bob', 'John is Bobs friend'])
	:" no match
	:call add(tl, [2, '.John\&.Bob', 'here is John, and here is B'])
	! :call add(tl, [2, '.John\&.Bob', 'John is Bobs friend', 'John is Bob'])
	! :call add(tl, [2, '\v(test1)@=.*yep', 'this is a test1, yep it is', 'test1, yep', 'test1'])
	:"
	:"""" Combining different tests and features
	:call add(tl, [2, '[[:alpha:]]\{-2,6}', '787abcdiuhsasiuhb4', 'ab'])
	*** ../vim-7.3.1075/src/testdir/test64.ok 2013-05-30 18:45:20.000000000 +0200
	--- src/testdir/test64.ok 2013-05-30 21:29:06.000000000 +0200
	***************
	* 647,656 **
	--- 647,659 ----
	OK 2 - \>\zs.
	OK 0 - abc\@=
	OK 1 - abc\@=
	+ OK 2 - abc\@=
	OK 0 - abc\@=cd
	OK 1 - abc\@=cd
	+ OK 2 - abc\@=cd
	OK 0 - abc\@=
	OK 1 - abc\@=
	+ OK 2 - abc\@=
	OK 0 - abcd\@=e
	OK 1 - abcd\@=e
	OK 2 - abcd\@=e
	***************
	* 659,676 **
	--- 662,683 ----
	OK 2 - abcd\@=e
	OK 0 - \v(abc)@=..
	OK 1 - \v(abc)@=..
	+ OK 2 - \v(abc)@=..
	OK 0 - \(.John\)\@=.Bob
	OK 1 - \(.John\)\@=.Bob
	OK 2 - \(.John\)\@=.Bob
	OK 0 - \(John.\)\@=.Bob
	OK 1 - \(John.\)\@=.Bob
	+ OK 2 - \(John.\)\@=.Bob
	OK 0 - .John\&.Bob
	OK 1 - .John\&.Bob
	OK 2 - .John\&.Bob
	OK 0 - .John\&.Bob
	OK 1 - .John\&.Bob
	+ OK 2 - .John\&.Bob
	OK 0 - \v(test1)@=.*yep
	OK 1 - \v(test1)@=.*yep
	+ OK 2 - \v(test1)@=.*yep
	OK 0 - [[:alpha:]]\{-2,6}
	OK 1 - [[:alpha:]]\{-2,6}
	OK 2 - [[:alpha:]]\{-2,6}
	*** ../vim-7.3.1075/src/version.c 2013-05-30 19:18:27.000000000 +0200
	--- src/version.c 2013-05-30 21:34:53.000000000 +0200
	***************
	* 730,731 **
	--- 730,733 ----
	{ /* Add new patch number below this line */
	+ /**/
	+ 1076,
	/**/

	--
	I'm not familiar with this proof, but I'm aware of a significant
	following of toddlers who believe that peanut butter is the solution
	to all of life's problems... -- Tim Hammerquist

	/// 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 ///

rpms / vim

Source Code

Files