*** pgsql/src/backend/regex/regexec.c	2005/10/15 02:49:24	1.27
--- pgsql/src/backend/regex/regexec.c	2010/02/01 02:45:29	1.28
***************
*** 27,33 ****
   * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
!  * $PostgreSQL: pgsql/src/backend/regex/regexec.c,v 1.26 2005/09/24 22:54:38 tgl Exp $
   *
   */
  
--- 27,33 ----
   * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
!  * $PostgreSQL: pgsql/src/backend/regex/regexec.c,v 1.27 2005/10/15 02:49:24 momjian Exp $
   *
   */
  
*************** static int	dissect(struct vars *, struct
*** 141,146 ****
--- 141,147 ----
  static int	condissect(struct vars *, struct subre *, chr *, chr *);
  static int	altdissect(struct vars *, struct subre *, chr *, chr *);
  static int	cdissect(struct vars *, struct subre *, chr *, chr *);
+ static int	ccaptdissect(struct vars *, struct subre *, chr *, chr *);
  static int	ccondissect(struct vars *, struct subre *, chr *, chr *);
  static int	crevdissect(struct vars *, struct subre *, chr *, chr *);
  static int	cbrdissect(struct vars *, struct subre *, chr *, chr *);
*************** dissect(struct vars * v,
*** 560,586 ****
  		case '=':				/* terminal node */
  			assert(t->left == NULL && t->right == NULL);
  			return REG_OKAY;	/* no action, parent did the work */
- 			break;
  		case '|':				/* alternation */
  			assert(t->left != NULL);
  			return altdissect(v, t, begin, end);
- 			break;
  		case 'b':				/* back ref -- shouldn't be calling us! */
  			return REG_ASSERT;
- 			break;
  		case '.':				/* concatenation */
  			assert(t->left != NULL && t->right != NULL);
  			return condissect(v, t, begin, end);
- 			break;
  		case '(':				/* capturing */
  			assert(t->left != NULL && t->right == NULL);
  			assert(t->subno > 0);
  			subset(v, t, begin, end);
  			return dissect(v, t->left, begin, end);
- 			break;
  		default:
  			return REG_ASSERT;
- 			break;
  	}
  }
  
--- 561,581 ----
*************** cdissect(struct vars * v,
*** 710,717 ****
  		 chr *begin,			/* beginning of relevant substring */
  		 chr *end)				/* end of same */
  {
- 	int			er;
- 
  	assert(t != NULL);
  	MDEBUG(("cdissect %ld-%ld %c\n", LOFF(begin), LOFF(end), t->op));
  
--- 705,710 ----
*************** cdissect(struct vars * v,
*** 720,753 ****
  		case '=':				/* terminal node */
  			assert(t->left == NULL && t->right == NULL);
  			return REG_OKAY;	/* no action, parent did the work */
- 			break;
  		case '|':				/* alternation */
  			assert(t->left != NULL);
  			return caltdissect(v, t, begin, end);
- 			break;
  		case 'b':				/* back ref -- shouldn't be calling us! */
  			assert(t->left == NULL && t->right == NULL);
  			return cbrdissect(v, t, begin, end);
- 			break;
  		case '.':				/* concatenation */
  			assert(t->left != NULL && t->right != NULL);
  			return ccondissect(v, t, begin, end);
- 			break;
  		case '(':				/* capturing */
  			assert(t->left != NULL && t->right == NULL);
! 			assert(t->subno > 0);
! 			er = cdissect(v, t->left, begin, end);
! 			if (er == REG_OKAY)
! 				subset(v, t, begin, end);
! 			return er;
! 			break;
  		default:
  			return REG_ASSERT;
- 			break;
  	}
  }
  
  /*
   * ccondissect - concatenation subexpression matches (with complications)
   * The retry memory stores the offset of the trial midpoint from begin,
   * plus 1 so that 0 uniquely means "clean slate".
--- 713,755 ----
  		case '=':				/* terminal node */
  			assert(t->left == NULL && t->right == NULL);
  			return REG_OKAY;	/* no action, parent did the work */
  		case '|':				/* alternation */
  			assert(t->left != NULL);
  			return caltdissect(v, t, begin, end);
  		case 'b':				/* back ref -- shouldn't be calling us! */
  			assert(t->left == NULL && t->right == NULL);
  			return cbrdissect(v, t, begin, end);
  		case '.':				/* concatenation */
  			assert(t->left != NULL && t->right != NULL);
  			return ccondissect(v, t, begin, end);
  		case '(':				/* capturing */
  			assert(t->left != NULL && t->right == NULL);
! 			return ccaptdissect(v, t, begin, end);
  		default:
  			return REG_ASSERT;
  	}
  }
  
  /*
+  * ccaptdissect - capture subexpression matches (with complications)
+  */
+ static int						/* regexec return code */
+ ccaptdissect(struct vars * v,
+ 			 struct subre * t,
+ 			 chr *begin,		/* beginning of relevant substring */
+ 			 chr *end)			/* end of same */
+ {
+ 	int			er;
+ 
+ 	assert(t->subno > 0);
+ 
+ 	er = cdissect(v, t->left, begin, end);
+ 	if (er == REG_OKAY)
+ 		subset(v, t, begin, end);
+ 	return er;
+ }
+ 
+ /*
   * ccondissect - concatenation subexpression matches (with complications)
   * The retry memory stores the offset of the trial midpoint from begin,
   * plus 1 so that 0 uniquely means "clean slate".
*************** ccondissect(struct vars * v,
*** 804,820 ****
  	for (;;)
  	{
  		/* try this midpoint on for size */
! 		er = cdissect(v, t->left, begin, mid);
! 		if (er == REG_OKAY &&
! 			longest(v, d2, mid, end, (int *) NULL) == end &&
! 			(er = cdissect(v, t->right, mid, end)) ==
! 			REG_OKAY)
! 			break;				/* NOTE BREAK OUT */
! 		if (er != REG_OKAY && er != REG_NOMATCH)
  		{
! 			freedfa(d);
! 			freedfa(d2);
! 			return er;
  		}
  
  		/* that midpoint didn't work, find a new one */
--- 806,832 ----
  	for (;;)
  	{
  		/* try this midpoint on for size */
! 		if (longest(v, d2, mid, end, (int *) NULL) == end)
  		{
! 			er = cdissect(v, t->left, begin, mid);
! 			if (er == REG_OKAY)
! 			{
! 				er = cdissect(v, t->right, mid, end);
! 				if (er == REG_OKAY)
! 				{
! 					/* satisfaction */
! 					MDEBUG(("successful\n"));
! 					freedfa(d);
! 					freedfa(d2);
! 					return REG_OKAY;
! 				}
! 			}
! 			if (er != REG_OKAY && er != REG_NOMATCH)
! 			{
! 				freedfa(d);
! 				freedfa(d2);
! 				return er;
! 			}
  		}
  
  		/* that midpoint didn't work, find a new one */
*************** ccondissect(struct vars * v,
*** 841,851 ****
  		zapmem(v, t->right);
  	}
  
! 	/* satisfaction */
! 	MDEBUG(("successful\n"));
! 	freedfa(d);
! 	freedfa(d2);
! 	return REG_OKAY;
  }
  
  /*
--- 853,860 ----
  		zapmem(v, t->right);
  	}
  
! 	/* can't get here */
! 	return REG_ASSERT;
  }
  
  /*
*************** crevdissect(struct vars * v,
*** 904,920 ****
  	for (;;)
  	{
  		/* try this midpoint on for size */
! 		er = cdissect(v, t->left, begin, mid);
! 		if (er == REG_OKAY &&
! 			longest(v, d2, mid, end, (int *) NULL) == end &&
! 			(er = cdissect(v, t->right, mid, end)) ==
! 			REG_OKAY)
! 			break;				/* NOTE BREAK OUT */
! 		if (er != REG_OKAY && er != REG_NOMATCH)
  		{
! 			freedfa(d);
! 			freedfa(d2);
! 			return er;
  		}
  
  		/* that midpoint didn't work, find a new one */
--- 913,939 ----
  	for (;;)
  	{
  		/* try this midpoint on for size */
! 		if (longest(v, d2, mid, end, (int *) NULL) == end)
  		{
! 			er = cdissect(v, t->left, begin, mid);
! 			if (er == REG_OKAY)
! 			{
! 				er = cdissect(v, t->right, mid, end);
! 				if (er == REG_OKAY)
! 				{
! 					/* satisfaction */
! 					MDEBUG(("successful\n"));
! 					freedfa(d);
! 					freedfa(d2);
! 					return REG_OKAY;
! 				}
! 			}
! 			if (er != REG_OKAY && er != REG_NOMATCH)
! 			{
! 				freedfa(d);
! 				freedfa(d2);
! 				return er;
! 			}
  		}
  
  		/* that midpoint didn't work, find a new one */
*************** crevdissect(struct vars * v,
*** 941,951 ****
  		zapmem(v, t->right);
  	}
  
! 	/* satisfaction */
! 	MDEBUG(("successful\n"));
! 	freedfa(d);
! 	freedfa(d2);
! 	return REG_OKAY;
  }
  
  /*
--- 960,967 ----
  		zapmem(v, t->right);
  	}
  
! 	/* can't get here */
! 	return REG_ASSERT;
  }
  
  /*