*** pgsql/src/backend/regex/regexec.c	2003/08/08 21:41:56	1.23
--- pgsql/src/backend/regex/regexec.c	2010/02/01 02:46:08	1.23.4.1
***************
*** 27,33 ****
   * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
!  * $Header: /projects/cvsroot/pgsql/src/backend/regex/regexec.c,v 1.23 2003/08/08 21:41:56 momjian Exp $
   *
   */
  
--- 27,33 ----
   * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
   * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   *
!  * $Header: /projects/cvsroot/pgsql/src/backend/regex/regexec.c,v 1.23.4.1 2010/02/01 02:46:08 tgl Exp $
   *
   */
  
*************** static int	dissect(struct vars *, struct
*** 142,147 ****
--- 142,148 ----
  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,
*** 559,585 ****
  		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;
  	}
  }
  
--- 560,580 ----
*************** cdissect(struct vars * v,
*** 709,716 ****
  		 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));
  
--- 704,709 ----
*************** cdissect(struct vars * v,
*** 719,752 ****
  		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".
--- 712,754 ----
  		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,
*** 803,819 ****
  	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 */
--- 805,831 ----
  	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,
*** 840,850 ****
  		zapmem(v, t->right);
  	}
  
! 	/* satisfaction */
! 	MDEBUG(("successful\n"));
! 	freedfa(d);
! 	freedfa(d2);
! 	return REG_OKAY;
  }
  
  /*
--- 852,859 ----
  		zapmem(v, t->right);
  	}
  
! 	/* can't get here */
! 	return REG_ASSERT;
  }
  
  /*
*************** crevdissect(struct vars * v,
*** 903,919 ****
  	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 */
--- 912,938 ----
  	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,
*** 940,950 ****
  		zapmem(v, t->right);
  	}
  
! 	/* satisfaction */
! 	MDEBUG(("successful\n"));
! 	freedfa(d);
! 	freedfa(d2);
! 	return REG_OKAY;
  }
  
  /*
--- 959,966 ----
  		zapmem(v, t->right);
  	}
  
! 	/* can't get here */
! 	return REG_ASSERT;
  }
  
  /*