X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/9f7f391326e967b539b86ed051c163bbf8f6e7de..93d343c6c59d1d6b5e6307c31585c77ab830183d:/regexec.c

diff --git a/regexec.c b/regexec.c
index 9cb15b8..34fd1ac 100644
--- a/regexec.c
+++ b/regexec.c
@@ -107,7 +107,7 @@
 #define	STATIC	static
 #endif
 
-#define REGINCLASS(p,c)  (ANYOF_FLAGS(p) ? reginclass(p,c,0,0) : ANYOF_BITMAP_TEST(p,*(c)))
+#define REGINCLASS(prog,p,c)  (ANYOF_FLAGS(p) ? reginclass(prog,p,c,0,0) : ANYOF_BITMAP_TEST(p,*(c)))
 
 /*
  * Forwards.
@@ -213,11 +213,10 @@ S_regcppush(pTHX_ I32 parenfloor)
 				(IV)(cp), (IV)PL_savestack_ix) : 0); regcpblow(cp)
 
 STATIC char *
-S_regcppop(pTHX)
+S_regcppop(pTHX_ const regexp *rex)
 {
     dVAR;
     I32 i;
-    U32 paren = 0;
     char *input;
 
     GET_RE_DEBUG_FLAGS_DECL;
@@ -235,7 +234,7 @@ S_regcppop(pTHX)
     for (i -= (REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
 	 i > 0; i -= REGCP_PAREN_ELEMS) {
 	I32 tmps;
-	paren = (U32)SSPOPINT;
+	U32 paren = (U32)SSPOPINT;
 	PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
 	PL_regstartp[paren] = SSPOPINT;
 	tmps = SSPOPINT;
@@ -251,10 +250,10 @@ S_regcppop(pTHX)
 	);
     }
     DEBUG_EXECUTE_r(
-	if ((I32)(*PL_reglastparen + 1) <= PL_regnpar) {
+	if ((I32)(*PL_reglastparen + 1) <= rex->nparens) {
 	    PerlIO_printf(Perl_debug_log,
 			  "     restoring \\%"IVdf"..\\%"IVdf" to undef\n",
-			  (IV)(*PL_reglastparen + 1), (IV)PL_regnpar);
+			  (IV)(*PL_reglastparen + 1), (IV)rex->nparens);
 	}
     );
 #if 1
@@ -268,10 +267,10 @@ S_regcppop(pTHX)
      * building DynaLoader will fail:
      * "Error: '*' not in typemap in DynaLoader.xs, line 164"
      * --jhi */
-    for (paren = *PL_reglastparen + 1; (I32)paren <= PL_regnpar; paren++) {
-	if ((I32)paren > PL_regsize)
-	    PL_regstartp[paren] = -1;
-	PL_regendp[paren] = -1;
+    for (i = *PL_reglastparen + 1; i <= rex->nparens; i++) {
+	if (i > PL_regsize)
+	    PL_regstartp[i] = -1;
+	PL_regendp[i] = -1;
     }
 #endif
     return input;
@@ -316,18 +315,6 @@ Perl_pregexec(pTHX_ register regexp *prog, char *stringarg, register char *stren
 		      nosave ? 0 : REXEC_COPY_STR);
 }
 
-STATIC void
-S_cache_re(pTHX_ regexp *prog)
-{
-    dVAR;
-    PL_regprecomp = prog->precomp;		/* Needed for FAIL. */
-#ifdef DEBUGGING
-    PL_regprogram = prog->program;
-#endif
-    PL_regnpar = prog->nparens;
-    PL_regdata = prog->data;
-    PL_reg_re = prog;
-}
 
 /*
  * Need to implement the following flags for reg_anch:
@@ -852,8 +839,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		   : strend);
 
 	t = s;
-	cache_re(prog);
-        s = find_byclass(prog, prog->regstclass, s, endpos, 1);
+        s = find_byclass(prog, prog->regstclass, s, endpos, NULL);
 	if (!s) {
 #ifdef DEBUGGING
 	    const char *what = NULL;
@@ -945,8 +931,11 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 }
 
 /* We know what class REx starts with.  Try to find this position... */
+/* if reginfo is NULL, its a dryrun */
+
 STATIC char *
-S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32 norun)
+S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char
+*strend, const regmatch_info *reginfo)
 {
 	dVAR;
 	const I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
@@ -967,9 +956,9 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		 while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		      if ((ANYOF_FLAGS(c) & ANYOF_UNICODE) ||
 			  !UTF8_IS_INVARIANT((U8)s[0]) ?
-			  reginclass(c, (U8*)s, 0, do_utf8) :
-			  REGINCLASS(c, (U8*)s)) {
-			   if (tmp && (norun || regtry(prog, s)))
+			  reginclass(prog, c, (U8*)s, 0, do_utf8) :
+			  REGINCLASS(prog, c, (U8*)s)) {
+			   if (tmp && (!reginfo || regtry(reginfo, s)))
 				goto got_it;
 			   else
 				tmp = doevery;
@@ -983,12 +972,12 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		 while (s < strend) {
 		      STRLEN skip = 1;
 
-		      if (REGINCLASS(c, (U8*)s) ||
+		      if (REGINCLASS(prog, c, (U8*)s) ||
 			  (ANYOF_FOLD_SHARP_S(c, s, strend) &&
 			   /* The assignment of 2 is intentional:
 			    * for the folded sharp s, the skip is 2. */
 			   (skip = SHARP_S_SKIP))) {
-			   if (tmp && (norun || regtry(prog, s)))
+			   if (tmp && (!reginfo || regtry(reginfo, s)))
 				goto got_it;
 			   else
 				tmp = doevery;
@@ -1001,7 +990,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    break;
 	case CANY:
 	    while (s < strend) {
-	        if (tmp && (norun || regtry(prog, s)))
+	        if (tmp && (!reginfo || regtry(reginfo, s)))
 		    goto got_it;
 		else
 		    tmp = doevery;
@@ -1046,7 +1035,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	  do_exactf:
 	    e = HOP3c(strend, -((I32)lnc), s);
 
-	    if (norun && e < s)
+	    if (!reginfo && e < s)
 		e = s;			/* Due to minlen logic of intuit() */
 
 	    /* The idea in the EXACTF* cases is to first find the
@@ -1075,7 +1064,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 			     && (ln == len ||
 				 ibcmp_utf8(s, (char **)0, 0,  do_utf8,
 					    m, (char **)0, ln, (bool)UTF))
-			     && (norun || regtry(prog, s)) )
+			     && (!reginfo || regtry(reginfo, s)) )
 			    goto got_it;
 			else {
 			     U8 foldbuf[UTF8_MAXBYTES_CASE+1];
@@ -1088,7 +1077,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 						  (char **)0, foldlen, do_utf8,
 						  m,
 						  (char **)0, ln, (bool)UTF))
-				  && (norun || regtry(prog, s)) )
+				  && (!reginfo || regtry(reginfo, s)) )
 				  goto got_it;
 			}
 			s += len;
@@ -1114,7 +1103,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 			     && (ln == len ||
 				 ibcmp_utf8(s, (char **)0, 0,  do_utf8,
 					    m, (char **)0, ln, (bool)UTF))
-			     && (norun || regtry(prog, s)) )
+			     && (!reginfo || regtry(reginfo, s)) )
 			    goto got_it;
 			else {
 			     U8 foldbuf[UTF8_MAXBYTES_CASE+1];
@@ -1127,7 +1116,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 						  (char **)0, foldlen, do_utf8,
 						  m,
 						  (char **)0, ln, (bool)UTF))
-				  && (norun || regtry(prog, s)) )
+				  && (!reginfo || regtry(reginfo, s)) )
 				  goto got_it;
 			}
 			s += len;
@@ -1141,7 +1130,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 			     && (ln == 1 || !(OP(c) == EXACTF
 					      ? ibcmp(s, m, ln)
 					      : ibcmp_locale(s, m, ln)))
-			     && (norun || regtry(prog, s)) )
+			     && (!reginfo || regtry(reginfo, s)) )
 			    goto got_it;
 			s++;
 		    }
@@ -1151,7 +1140,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 			     && (ln == 1 || !(OP(c) == EXACTF
 					      ? ibcmp(s, m, ln)
 					      : ibcmp_locale(s, m, ln)))
-			     && (norun || regtry(prog, s)) )
+			     && (!reginfo || regtry(reginfo, s)) )
 			    goto got_it;
 			s++;
 		    }
@@ -1177,7 +1166,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 				 isALNUM_LC_utf8((U8*)s)))
 		    {
 			tmp = !tmp;
-			if ((norun || regtry(prog, s)))
+			if ((!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 		    }
 		    s += uskip;
@@ -1190,13 +1179,13 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		    if (tmp ==
 			!(OP(c) == BOUND ? isALNUM(*s) : isALNUM_LC(*s))) {
 			tmp = !tmp;
-			if ((norun || regtry(prog, s)))
+			if ((!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 		    }
 		    s++;
 		}
 	    }
-	    if ((!prog->minlen && tmp) && (norun || regtry(prog, s)))
+	    if ((!prog->minlen && tmp) && (!reginfo || regtry(reginfo, s)))
 		goto got_it;
 	    break;
 	case NBOUNDL:
@@ -1218,7 +1207,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 				 swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8) :
 				 isALNUM_LC_utf8((U8*)s)))
 			tmp = !tmp;
-		    else if ((norun || regtry(prog, s)))
+		    else if ((!reginfo || regtry(reginfo, s)))
 			goto got_it;
 		    s += uskip;
 		}
@@ -1231,12 +1220,12 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		    if (tmp ==
 			!(OP(c) == NBOUND ? isALNUM(*s) : isALNUM_LC(*s)))
 			tmp = !tmp;
-		    else if ((norun || regtry(prog, s)))
+		    else if ((!reginfo || regtry(reginfo, s)))
 			goto got_it;
 		    s++;
 		}
 	    }
-	    if ((!prog->minlen && !tmp) && (norun || regtry(prog, s)))
+	    if ((!prog->minlen && !tmp) && (!reginfo || regtry(reginfo, s)))
 		goto got_it;
 	    break;
 	case ALNUM:
@@ -1244,7 +1233,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		LOAD_UTF8_CHARCLASS_ALNUM();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1257,7 +1246,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (isALNUM(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1273,7 +1262,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    if (do_utf8) {
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (isALNUM_LC_utf8((U8*)s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1286,7 +1275,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (isALNUM_LC(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1302,7 +1291,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		LOAD_UTF8_CHARCLASS_ALNUM();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (!swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1315,7 +1304,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (!isALNUM(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1331,7 +1320,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    if (do_utf8) {
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (!isALNUM_LC_utf8((U8*)s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1344,7 +1333,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (!isALNUM_LC(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1360,7 +1349,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		LOAD_UTF8_CHARCLASS_SPACE();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, do_utf8)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1373,7 +1362,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (isSPACE(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1389,7 +1378,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    if (do_utf8) {
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (*s == ' ' || isSPACE_LC_utf8((U8*)s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1402,7 +1391,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (isSPACE_LC(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1418,7 +1407,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		LOAD_UTF8_CHARCLASS_SPACE();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (!(*s == ' ' || swash_fetch(PL_utf8_space,(U8*)s, do_utf8))) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1431,7 +1420,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (!isSPACE(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1447,7 +1436,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    if (do_utf8) {
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (!(*s == ' ' || isSPACE_LC_utf8((U8*)s))) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1460,7 +1449,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (!isSPACE_LC(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1476,7 +1465,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		LOAD_UTF8_CHARCLASS_DIGIT();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (swash_fetch(PL_utf8_digit,(U8*)s, do_utf8)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1489,7 +1478,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (isDIGIT(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1505,7 +1494,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    if (do_utf8) {
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (isDIGIT_LC_utf8((U8*)s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1518,7 +1507,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (isDIGIT_LC(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1534,7 +1523,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 		LOAD_UTF8_CHARCLASS_DIGIT();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (!swash_fetch(PL_utf8_digit,(U8*)s, do_utf8)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1547,7 +1536,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (!isDIGIT(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1563,7 +1552,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    if (do_utf8) {
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (!isDIGIT_LC_utf8((U8*)s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1576,7 +1565,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, const char *strend, I32
 	    else {
 		while (s < strend) {
 		    if (!isDIGIT_LC(*s)) {
-			if (tmp && (norun || regtry(prog, s)))
+			if (tmp && (!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 			else
 			    tmp = doevery;
@@ -1619,21 +1608,16 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
     char *scream_olds = NULL;
     SV* oreplsv = GvSV(PL_replgv);
     const bool do_utf8 = DO_UTF8(sv);
-    const I32 multiline = prog->reganch & PMf_MULTILINE;
+    I32 multiline;
 #ifdef DEBUGGING
-    SV * const dsv0 = PERL_DEBUG_PAD_ZERO(0);
-    SV * const dsv1 = PERL_DEBUG_PAD_ZERO(1);
+    SV* dsv0;
+    SV* dsv1;
 #endif
+    regmatch_info reginfo;  /* create some info to pass to regtry etc */
 
     GET_RE_DEBUG_FLAGS_DECL;
 
     PERL_UNUSED_ARG(data);
-    RX_MATCH_UTF8_set(prog,do_utf8);
-
-    cache_re(prog);
-#ifdef DEBUGGING
-    PL_regnarrate = DEBUG_r_TEST;
-#endif
 
     /* Be paranoid... */
     if (prog == NULL || startpos == NULL) {
@@ -1641,6 +1625,16 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	return 0;
     }
 
+    multiline = prog->reganch & PMf_MULTILINE;
+    reginfo.prog = prog;
+
+#ifdef DEBUGGING
+    dsv0 = PERL_DEBUG_PAD_ZERO(0);
+    dsv1 = PERL_DEBUG_PAD_ZERO(1);
+#endif
+
+    RX_MATCH_UTF8_set(prog, do_utf8);
+
     minlen = prog->minlen;
     if (strend - startpos < minlen) {
         DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
@@ -1661,40 +1655,37 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	PL_reg_flags |= RF_utf8;
 
     /* Mark beginning of line for ^ and lookbehind. */
-    PL_regbol = startpos;
+    reginfo.bol = startpos; /* XXX not used ??? */
     PL_bostr  = strbeg;
-    PL_reg_sv = sv;
+    reginfo.sv = sv;
 
     /* Mark end of line for $ (and such) */
     PL_regeol = strend;
 
     /* see how far we have to get to not match where we matched before */
-    PL_regtill = startpos+minend;
-
-    /* We start without call_cc context.  */
-    PL_reg_call_cc = 0;
+    reginfo.till = startpos+minend;
 
     /* If there is a "must appear" string, look for it. */
     s = startpos;
 
-    if (prog->reganch & ROPT_GPOS_SEEN) { /* Need to have PL_reg_ganch */
+    if (prog->reganch & ROPT_GPOS_SEEN) { /* Need to set reginfo->ganch */
 	MAGIC *mg;
 
 	if (flags & REXEC_IGNOREPOS)	/* Means: check only at start */
-	    PL_reg_ganch = startpos;
+	    reginfo.ganch = startpos;
 	else if (sv && SvTYPE(sv) >= SVt_PVMG
 		  && SvMAGIC(sv)
 		  && (mg = mg_find(sv, PERL_MAGIC_regex_global))
 		  && mg->mg_len >= 0) {
-	    PL_reg_ganch = strbeg + mg->mg_len;	/* Defined pos() */
+	    reginfo.ganch = strbeg + mg->mg_len;	/* Defined pos() */
 	    if (prog->reganch & ROPT_ANCH_GPOS) {
-	        if (s > PL_reg_ganch)
+	        if (s > reginfo.ganch)
 		    goto phooey;
-		s = PL_reg_ganch;
+		s = reginfo.ganch;
 	    }
 	}
 	else				/* pos() not defined */
-	    PL_reg_ganch = strbeg;
+	    reginfo.ganch = strbeg;
     }
 
     if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
@@ -1736,7 +1727,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
     /* Simplest case:  anchored match need be tried only once. */
     /*  [unless only anchor is BOL and multiline is set] */
     if (prog->reganch & (ROPT_ANCH & ~ROPT_ANCH_GPOS)) {
-	if (s == startpos && regtry(prog, startpos))
+	if (s == startpos && regtry(&reginfo, startpos))
 	    goto got_it;
 	else if (multiline || (prog->reganch & ROPT_IMPLICIT)
 		 || (prog->reganch & ROPT_ANCH_MBOL)) /* XXXX SBOL? */
@@ -1751,7 +1742,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 		if (s == startpos)
 		    goto after_try;
 		while (1) {
-		    if (regtry(prog, s))
+		    if (regtry(&reginfo, s))
 			goto got_it;
 		  after_try:
 		    if (s >= end)
@@ -1769,7 +1760,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 		    s--;
 		while (s < end) {
 		    if (*s++ == '\n') {	/* don't need PL_utf8skip here */
-			if (regtry(prog, s))
+			if (regtry(&reginfo, s))
 			    goto got_it;
 		    }
 		}		
@@ -1777,7 +1768,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	}
 	goto phooey;
     } else if (prog->reganch & ROPT_ANCH_GPOS) {
-	if (regtry(prog, PL_reg_ganch))
+	if (regtry(&reginfo, reginfo.ganch))
 	    goto got_it;
 	goto phooey;
     }
@@ -1798,7 +1789,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    while (s < strend) {
 		if (*s == ch) {
 		    DEBUG_EXECUTE_r( did_match = 1 );
-		    if (regtry(prog, s)) goto got_it;
+		    if (regtry(&reginfo, s)) goto got_it;
 		    s += UTF8SKIP(s);
 		    while (s < strend && *s == ch)
 			s += UTF8SKIP(s);
@@ -1810,7 +1801,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    while (s < strend) {
 		if (*s == ch) {
 		    DEBUG_EXECUTE_r( did_match = 1 );
-		    if (regtry(prog, s)) goto got_it;
+		    if (regtry(&reginfo, s)) goto got_it;
 		    s++;
 		    while (s < strend && *s == ch)
 			s++;
@@ -1888,14 +1879,14 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    }
 	    if (do_utf8) {
 		while (s <= last1) {
-		    if (regtry(prog, s))
+		    if (regtry(&reginfo, s))
 			goto got_it;
 		    s += UTF8SKIP(s);
 		}
 	    }
 	    else {
 		while (s <= last1) {
-		    if (regtry(prog, s))
+		    if (regtry(&reginfo, s))
 			goto got_it;
 		    s++;
 		}
@@ -1927,7 +1918,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    int len0;
 	    int len1;
 
-	    regprop(prop, c);
+	    regprop(prog, prop, c);
 	    s0 = UTF ?
 	      pv_uni_display(dsv0, (U8*)SvPVX_const(prop), SvCUR(prop), 60,
 			     UNI_DISPLAY_REGEX) :
@@ -1941,7 +1932,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 			  len0, len0, s0,
 			  len1, len1, s1);
 	});
-        if (find_byclass(prog, c, s, strend, 0))
+        if (find_byclass(prog, c, s, strend, &reginfo))
 	    goto got_it;
 	DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass...\n"));
     }
@@ -1999,7 +1990,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	/* We don't know much -- general case. */
 	if (do_utf8) {
 	    for (;;) {
-		if (regtry(prog, s))
+		if (regtry(&reginfo, s))
 		    goto got_it;
 		if (s >= strend)
 		    break;
@@ -2008,7 +1999,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	}
 	else {
 	    do {
-		if (regtry(prog, s))
+		if (regtry(&reginfo, s))
 		    goto got_it;
 	    } while (s++ < strend);
 	}
@@ -2026,7 +2017,7 @@ got_it:
 	    sv_setsv(oreplsv, GvSV(PL_replgv));/* So that when GvSV(replgv) is
 						  restored, the value remains
 						  the same. */
-	restore_pos(aTHX_ 0);
+	restore_pos(aTHX_ prog);
     }
 
     /* make sure $`, $&, $', and $digit will work later */
@@ -2066,7 +2057,7 @@ phooey:
     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
 			  PL_colors[4], PL_colors[5]));
     if (PL_reg_eval_set)
-	restore_pos(aTHX_ 0);
+	restore_pos(aTHX_ prog);
     return 0;
 }
 
@@ -2074,13 +2065,13 @@ phooey:
  - regtry - try match at specific point
  */
 STATIC I32			/* 0 failure, 1 success */
-S_regtry(pTHX_ regexp *prog, char *startpos)
+S_regtry(pTHX_ const regmatch_info *reginfo, char *startpos)
 {
     dVAR;
-    register I32 i;
     register I32 *sp;
     register I32 *ep;
     CHECKPOINT lastcp;
+    regexp *prog = reginfo->prog;
     GET_RE_DEBUG_FLAGS_DECL;
 
 #ifdef DEBUGGING
@@ -2102,27 +2093,27 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
 	/* SAVEI8(cxstack[cxstack_ix].blk_gimme);
 	   cxstack[cxstack_ix].blk_gimme = G_SCALAR; */
 
-	if (PL_reg_sv) {
+	if (reginfo->sv) {
 	    /* Make $_ available to executed code. */
-	    if (PL_reg_sv != DEFSV) {
+	    if (reginfo->sv != DEFSV) {
 		SAVE_DEFSV;
-		DEFSV = PL_reg_sv;
+		DEFSV = reginfo->sv;
 	    }
 	
-	    if (!(SvTYPE(PL_reg_sv) >= SVt_PVMG && SvMAGIC(PL_reg_sv)
-		  && (mg = mg_find(PL_reg_sv, PERL_MAGIC_regex_global)))) {
+	    if (!(SvTYPE(reginfo->sv) >= SVt_PVMG && SvMAGIC(reginfo->sv)
+		  && (mg = mg_find(reginfo->sv, PERL_MAGIC_regex_global)))) {
 		/* prepare for quick setting of pos */
 #ifdef PERL_OLD_COPY_ON_WRITE
 		if (SvIsCOW(sv))
 		    sv_force_normal_flags(sv, 0);
 #endif
-		mg = sv_magicext(PL_reg_sv, (SV*)0, PERL_MAGIC_regex_global,
+		mg = sv_magicext(reginfo->sv, (SV*)0, PERL_MAGIC_regex_global,
 				 &PL_vtbl_mglob, NULL, 0);
 		mg->mg_len = -1;
 	    }
 	    PL_reg_magic    = mg;
 	    PL_reg_oldpos   = mg->mg_len;
-	    SAVEDESTRUCTOR_X(restore_pos, 0);
+	    SAVEDESTRUCTOR_X(restore_pos, prog);
         }
         if (!PL_reg_curpm) {
 	    Newxz(PL_reg_curpm, 1, PMOP);
@@ -2192,6 +2183,7 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
     sp = prog->startp;
     ep = prog->endp;
     if (prog->nparens) {
+	register I32 i;
 	for (i = prog->nparens; i > (I32)*PL_reglastparen; i--) {
 	    *++sp = -1;
 	    *++ep = -1;
@@ -2199,7 +2191,7 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
     }
 #endif
     REGCP_SET(lastcp);
-    if (regmatch(prog->program + 1)) {
+    if (regmatch(reginfo, prog->program + 1)) {
 	prog->endp[0] = PL_reginput - PL_bostr;
 	return 1;
     }
@@ -2226,6 +2218,7 @@ typedef struct {
     regnode *next;
     char *locinput;
     I32 nextchr;
+    int minmod;
 #ifdef DEBUGGING
     int regindent;
 #endif
@@ -2250,7 +2243,7 @@ typedef union re_unwind_t {
 #define POSCACHE_SEEN 1		/* we know what we're caching */
 #define POSCACHE_START 2	/* the real cache: this bit maps to pos 0 */
 #define CACHEsayYES STMT_START { \
-    if (st->whilem.cache_offset | st->whilem.cache_bit) { \
+    if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
 	if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
 	    PL_reg_poscache[0] |= (1<<POSCACHE_SUCCESS) || (1<<POSCACHE_SEEN); \
         else if (!(PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
@@ -2260,13 +2253,13 @@ typedef union re_unwind_t {
 		    "%*s  (remove success from failure cache)\n", \
 		    REPORT_CODE_OFF+PL_regindent*2, "") \
 	    ); \
-	    PL_reg_poscache[st->whilem.cache_offset] &= ~(1<<st->whilem.cache_bit); \
+	    PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
 	} \
     } \
     sayYES; \
 } STMT_END
 #define CACHEsayNO STMT_START { \
-    if (st->whilem.cache_offset | st->whilem.cache_bit) { \
+    if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
 	if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
 	    PL_reg_poscache[0] |= (1<<POSCACHE_SEEN); \
         else if ((PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
@@ -2276,7 +2269,7 @@ typedef union re_unwind_t {
 		    "%*s  (remove failure from success cache)\n", \
 		    REPORT_CODE_OFF+PL_regindent*2, "") \
 	    ); \
-	    PL_reg_poscache[st->whilem.cache_offset] &= ~(1<<st->whilem.cache_bit); \
+	    PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
 	} \
     } \
     sayNO; \
@@ -2319,6 +2312,44 @@ S_push_slab(pTHX)
     goto start_recurse; \
     resume_point_##where:
 
+
+/* push a new regex state. Set newst to point to it */
+
+#define PUSH_STATE(newst, resume) \
+    depth++;	\
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "PUSH STATE(%d)\n", depth)); \
+    st->scan = scan;	\
+    st->next = next;	\
+    st->n = n;	\
+    st->locinput = locinput;	\
+    st->resume_state = resume;	\
+    newst = st+1;   \
+    if (newst >  &(PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1])) \
+	newst = S_push_slab(aTHX);  \
+    PL_regmatch_state = newst;	\
+    newst->cc = 0;  \
+    newst->minmod = 0;	\
+    newst->sw = 0;  \
+    newst->logical = 0;	\
+    newst->unwind = 0;	\
+    locinput = PL_reginput; \
+    nextchr = UCHARAT(locinput);    
+
+#define POP_STATE \
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "POP STATE(%d)\n", depth)); \
+    depth--; \
+    st--; \
+    if (st < &PL_regmatch_slab->states[0]) { \
+	PL_regmatch_slab = PL_regmatch_slab->prev; \
+	st = &PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1]; \
+    } \
+    PL_regmatch_state = st; \
+    scan	= st->scan; \
+    next	= st->next; \
+    n		= st->n; \
+    locinput	= st->locinput; \
+    nextchr = UCHARAT(locinput);
+
 /*
  - regmatch - main matching routine
  *
@@ -2426,12 +2457,14 @@ S_push_slab(pTHX)
  
 
 STATIC I32			/* 0 failure, 1 success */
-S_regmatch(pTHX_ regnode *prog)
+S_regmatch(pTHX_ const regmatch_info *reginfo, regnode *prog)
 {
     dVAR;
     register const bool do_utf8 = PL_reg_match_utf8;
     const U32 uniflags = UTF8_ALLOW_DEFAULT;
 
+    regexp *rex = reginfo->prog;
+
     regmatch_slab  *orig_slab;
     regmatch_state *orig_state;
 
@@ -2449,6 +2482,8 @@ S_regmatch(pTHX_ regnode *prog)
     bool result;	    /* return value of S_regmatch */
     regnode *inner;	    /* Next node in internal branch. */
     int depth = 0;	    /* depth of recursion */
+    regmatch_state *newst;  /* when pushing a state, this is the new one */
+    regmatch_state *cur_eval = NULL;  /* most recent (??{}) state */
     
 #ifdef DEBUGGING
     SV *re_debug_flags = NULL;
@@ -2511,7 +2546,7 @@ S_regmatch(pTHX_ regnode *prog)
 		pref0_len = 0;
 	    if (pref0_len > pref_len)
 		pref0_len = pref_len;
-	    regprop(prop, scan);
+	    regprop(rex, prop, scan);
 	    {
 	      const char * const s0 =
 		do_utf8 && OP(scan) != CANY ?
@@ -2545,7 +2580,7 @@ S_regmatch(pTHX_ regnode *prog)
 			    PL_colors[1],
 			    15 - l - pref_len + 1,
 			    "",
-			    (IV)(scan - PL_regprogram), PL_regindent*2, "",
+			    (IV)(scan - rex->program), PL_regindent*2, "",
 			    SvPVX_const(prop));
 	    }
 	});
@@ -2558,7 +2593,7 @@ S_regmatch(pTHX_ regnode *prog)
 	case BOL:
 	    if (locinput == PL_bostr)
 	    {
-		/* regtill = regbol; */
+		/* reginfo->till = reginfo->bol; */
 		break;
 	    }
 	    sayNO;
@@ -2574,7 +2609,7 @@ S_regmatch(pTHX_ regnode *prog)
 		break;
 	    sayNO;
 	case GPOS:
-	    if (locinput == PL_reg_ganch)
+	    if (locinput == reginfo->ganch)
 		break;
 	    sayNO;
 	case EOL:
@@ -2653,14 +2688,14 @@ S_regmatch(pTHX_ regnode *prog)
 
 		/* what trie are we using right now */
 		reg_trie_data *trie
-		    = (reg_trie_data*)PL_regdata->data[ ARG( scan ) ];
-	    	st->trie.accepted = 0; /* how many accepting states we have seen */
+		    = (reg_trie_data*)rex->data->data[ ARG( scan ) ];
+	    	st->u.trie.accepted = 0; /* how many accepting states we have seen */
 		result = 0;
 
 		while ( state && uc <= (U8*)PL_regeol ) {
 
 		    if (trie->states[ state ].wordnum) {
-			if (!st->trie.accepted ) {
+			if (!st->u.trie.accepted ) {
 			    ENTER;
 			    SAVETMPS;
 			    bufflen = TRIE_INITAL_ACCEPT_BUFFLEN;
@@ -2670,22 +2705,22 @@ S_regmatch(pTHX_ regnode *prog)
 						sizeof(reg_trie_accepted));
 			    SvPOK_on(sv_accept_buff);
 			    sv_2mortal(sv_accept_buff);
-			    st->trie.accept_buff =
+			    st->u.trie.accept_buff =
 				(reg_trie_accepted*)SvPV_nolen(sv_accept_buff );
 			}
 			else {
-			    if (st->trie.accepted >= bufflen) {
+			    if (st->u.trie.accepted >= bufflen) {
 				bufflen *= 2;
-				st->trie.accept_buff =(reg_trie_accepted*)
+				st->u.trie.accept_buff =(reg_trie_accepted*)
 				    SvGROW(sv_accept_buff,
 				       	bufflen * sizeof(reg_trie_accepted));
 			    }
 			    SvCUR_set(sv_accept_buff,SvCUR(sv_accept_buff)
 				+ sizeof(reg_trie_accepted));
 			}
-			st->trie.accept_buff[st->trie.accepted].wordnum = trie->states[state].wordnum;
-			st->trie.accept_buff[st->trie.accepted].endpos = uc;
-			++st->trie.accepted;
+			st->u.trie.accept_buff[st->u.trie.accepted].wordnum = trie->states[state].wordnum;
+			st->u.trie.accept_buff[st->u.trie.accepted].endpos = uc;
+			++st->u.trie.accepted;
 		    }
 
 		    base = trie->states[ state ].trans.base;
@@ -2694,7 +2729,7 @@ S_regmatch(pTHX_ regnode *prog)
 			        PerlIO_printf( Perl_debug_log,
 			            "%*s  %sState: %4"UVxf", Base: %4"UVxf", Accepted: %4"UVxf" ",
 			            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
-			            (UV)state, (UV)base, (UV)st->trie.accepted );
+			            (UV)state, (UV)base, (UV)st->u.trie.accepted );
 		    );
 
 		    if ( base ) {
@@ -2761,7 +2796,7 @@ S_regmatch(pTHX_ regnode *prog)
 		            charid, uvc, (UV)state, PL_colors[5] );
 		    );
 		}
-		if (!st->trie.accepted )
+		if (!st->u.trie.accepted )
 		   sayNO;
 
 	    /*
@@ -2777,17 +2812,17 @@ S_regmatch(pTHX_ regnode *prog)
 	       have been tried.
 	    */
 
-		if ( st->trie.accepted == 1 ) {
+		if ( st->u.trie.accepted == 1 ) {
 		    DEBUG_EXECUTE_r({
-                        SV **tmp = av_fetch( trie->words, st->trie.accept_buff[ 0 ].wordnum-1, 0 );
+                        SV ** const tmp = av_fetch( trie->words, st->u.trie.accept_buff[ 0 ].wordnum-1, 0 );
        	                PerlIO_printf( Perl_debug_log,
 			    "%*s  %sonly one match : #%d <%s>%s\n",
 			    REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],
-        		    st->trie.accept_buff[ 0 ].wordnum,
+        		    st->u.trie.accept_buff[ 0 ].wordnum,
         		    tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",
         		    PL_colors[5] );
 		    });
-		    PL_reginput = (char *)st->trie.accept_buff[ 0 ].endpos;
+		    PL_reginput = (char *)st->u.trie.accept_buff[ 0 ].endpos;
 		    /* in this case we free tmps/leave before we call regmatch
 		       as we wont be using accept_buff again. */
 		    FREETMPS;
@@ -2797,40 +2832,42 @@ S_regmatch(pTHX_ regnode *prog)
 		} else {
                     DEBUG_EXECUTE_r(
                         PerlIO_printf( Perl_debug_log,"%*s  %sgot %"IVdf" possible matches%s\n",
-                            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4], (IV)st->trie.accepted,
+                            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4], (IV)st->u.trie.accepted,
                             PL_colors[5] );
                     );
-		    while ( !result && st->trie.accepted-- ) {
+		    while ( !result && st->u.trie.accepted-- ) {
 			U32 best = 0;
 			U32 cur;
-			for( cur = 1 ; cur <= st->trie.accepted ; cur++ ) {
+			for( cur = 1 ; cur <= st->u.trie.accepted ; cur++ ) {
 			    DEBUG_TRIE_EXECUTE_r(
 			        PerlIO_printf( Perl_debug_log,
 			            "%*s  %sgot %"IVdf" (%d) as best, looking at %"IVdf" (%d)%s\n",
 			            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
-			            (IV)best, st->trie.accept_buff[ best ].wordnum, (IV)cur,
-			            st->trie.accept_buff[ cur ].wordnum, PL_colors[5] );
+			            (IV)best, st->u.trie.accept_buff[ best ].wordnum, (IV)cur,
+			            st->u.trie.accept_buff[ cur ].wordnum, PL_colors[5] );
 			    );
 
-			    if (st->trie.accept_buff[cur].wordnum <
-				    st->trie.accept_buff[best].wordnum)
+			    if (st->u.trie.accept_buff[cur].wordnum <
+				    st->u.trie.accept_buff[best].wordnum)
 				best = cur;
 			}
 			DEBUG_EXECUTE_r({
-			    SV ** const tmp = av_fetch( trie->words, st->trie.accept_buff[ best ].wordnum - 1, 0 );
+			    reg_trie_data * const trie = (reg_trie_data*)
+					    rex->data->data[ARG(scan)];
+			    SV ** const tmp = av_fetch( trie->words, st->u.trie.accept_buff[ best ].wordnum - 1, 0 );
     			    PerlIO_printf( Perl_debug_log, "%*s  %strying alternation #%d <%s> at 0x%p%s\n",
     			        REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],
-    			        st->trie.accept_buff[best].wordnum,
+    			        st->u.trie.accept_buff[best].wordnum,
         		        tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",scan,
         		        PL_colors[5] );
 			});
-			if ( best<st->trie.accepted ) {
-			    reg_trie_accepted tmp = st->trie.accept_buff[ best ];
-			    st->trie.accept_buff[ best ] = st->trie.accept_buff[ st->trie.accepted ];
-			    st->trie.accept_buff[ st->trie.accepted ] = tmp;
-			    best = st->trie.accepted;
+			if ( best<st->u.trie.accepted ) {
+			    reg_trie_accepted tmp = st->u.trie.accept_buff[ best ];
+			    st->u.trie.accept_buff[ best ] = st->u.trie.accept_buff[ st->u.trie.accepted ];
+			    st->u.trie.accept_buff[ st->u.trie.accepted ] = tmp;
+			    best = st->u.trie.accepted;
 			}
-			PL_reginput = (char *)st->trie.accept_buff[ best ].endpos;
+			PL_reginput = (char *)st->u.trie.accept_buff[ best ].endpos;
 
                         /* 
                            as far as I can tell we only need the SAVETMPS/FREETMPS 
@@ -2958,7 +2995,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (do_utf8) {
 	        STRLEN inclasslen = PL_regeol - locinput;
 
-	        if (!reginclass(scan, (U8*)locinput, &inclasslen, do_utf8))
+	        if (!reginclass(rex, scan, (U8*)locinput, &inclasslen, do_utf8))
 		    sayNO_ANYOF;
 		if (locinput >= PL_regeol)
 		    sayNO;
@@ -2969,7 +3006,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    else {
 		if (nextchr < 0)
 		    nextchr = UCHARAT(locinput);
-		if (!REGINCLASS(scan, (U8*)locinput))
+		if (!REGINCLASS(rex, scan, (U8*)locinput))
 		    sayNO_ANYOF;
 		if (!nextchr && locinput >= PL_regeol)
 		    sayNO;
@@ -3263,21 +3300,21 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	case EVAL:
 	{
-	    dSP;
-	    OP_4tree * const oop = PL_op;
-	    COP * const ocurcop = PL_curcop;
-	    PAD *old_comppad;
 	    SV *ret;
-	    struct regexp * const oreg = PL_reg_re;
-	
-	    n = ARG(scan);
-	    PL_op = (OP_4tree*)PL_regdata->data[n];
-	    DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log, "  re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
-	    PAD_SAVE_LOCAL(old_comppad, (PAD*)PL_regdata->data[n + 2]);
-	    PL_regendp[0] = PL_reg_magic->mg_len = locinput - PL_bostr;
-
 	    {
+		/* execute the code in the {...} */
+		dSP;
 		SV ** const before = SP;
+		OP_4tree * const oop = PL_op;
+		COP * const ocurcop = PL_curcop;
+		PAD *old_comppad;
+	    
+		n = ARG(scan);
+		PL_op = (OP_4tree*)rex->data->data[n];
+		DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log, "  re_eval 0x%"UVxf"\n", PTR2UV(PL_op)) );
+		PAD_SAVE_LOCAL(old_comppad, (PAD*)rex->data->data[n + 2]);
+		PL_regendp[0] = PL_reg_magic->mg_len = locinput - PL_bostr;
+
 		CALLRUNOPS(aTHX);			/* Scalar context. */
 		SPAGAIN;
 		if (SP == before)
@@ -3286,19 +3323,24 @@ S_regmatch(pTHX_ regnode *prog)
 		    ret = POPs;
 		    PUTBACK;
 		}
+
+		PL_op = oop;
+		PAD_RESTORE_LOCAL(old_comppad);
+		PL_curcop = ocurcop;
+		if (!st->logical) {
+		    /* /(?{...})/ */
+		    sv_setsv(save_scalar(PL_replgv), ret);
+		    break;
+		}
 	    }
+	    if (st->logical == 2) { /* Postponed subexpression: /(??{...})/ */
+		regexp *re;
+		{
+		    /* extract RE object from returned value; compiling if
+		     * necessary */
 
-	    PL_op = oop;
-	    PAD_RESTORE_LOCAL(old_comppad);
-	    PL_curcop = ocurcop;
-	    if (st->logical) {
-		if (st->logical == 2) {	/* Postponed subexpression. */
-		    regexp *re;
 		    MAGIC *mg = NULL;
-		    re_cc_state state;
-                    int toggleutf;
-		    register SV *sv;
-
+		    SV *sv;
 		    if(SvROK(ret) && SvSMAGICAL(sv = SvRV(ret)))
 			mg = mg_find(sv, PERL_MAGIC_qr);
 		    else if (SvSMAGICAL(ret)) {
@@ -3316,95 +3358,62 @@ S_regmatch(pTHX_ regnode *prog)
 			STRLEN len;
 			const char * const t = SvPV_const(ret, len);
 			PMOP pm;
-			char * const oprecomp = PL_regprecomp;
 			const I32 osize = PL_regsize;
-			const I32 onpar = PL_regnpar;
 
 			Zero(&pm, 1, PMOP);
-                        if (DO_UTF8(ret)) pm.op_pmdynflags |= PMdf_DYN_UTF8;
+			if (DO_UTF8(ret)) pm.op_pmdynflags |= PMdf_DYN_UTF8;
 			re = CALLREGCOMP(aTHX_ (char*)t, (char*)t + len, &pm);
 			if (!(SvFLAGS(ret)
 			      & (SVs_TEMP | SVs_PADTMP | SVf_READONLY
 				| SVs_GMG)))
 			    sv_magic(ret,(SV*)ReREFCNT_inc(re),
 					PERL_MAGIC_qr,0,0);
-			PL_regprecomp = oprecomp;
 			PL_regsize = osize;
-			PL_regnpar = onpar;
 		    }
-		    DEBUG_EXECUTE_r(
-			PerlIO_printf(Perl_debug_log,
-				      "Entering embedded \"%s%.60s%s%s\"\n",
-				      PL_colors[0],
-				      re->precomp,
-				      PL_colors[1],
-				      (strlen(re->precomp) > 60 ? "..." : ""))
-			);
-		    state.node = next;
-		    state.prev = PL_reg_call_cc;
-		    state.cc = st->cc;
-		    state.re = PL_reg_re;
+		}
 
-		    st->cc = 0;
-		
-		    st->eval.cp = regcppush(0);	/* Save *all* the positions. */
-		    REGCP_SET(st->eval.lastcp);
-		    cache_re(re);
-		    state.ss = PL_savestack_ix;
-		    *PL_reglastparen = 0;
-		    *PL_reglastcloseparen = 0;
-		    PL_reg_call_cc = &state;
-		    PL_reginput = locinput;
-		    toggleutf = ((PL_reg_flags & RF_utf8) != 0) ^
-				((re->reganch & ROPT_UTF8) != 0);
-		    if (toggleutf) PL_reg_flags ^= RF_utf8;
-
-		    /* XXXX This is too dramatic a measure... */
-		    PL_reg_maxiter = 0;
-
-		    /* XXX the only recursion left in regmatch() */
-		    if (regmatch(re->program + 1)) {
-			/* Even though we succeeded, we need to restore
-			   global variables, since we may be wrapped inside
-			   SUSPEND, thus the match may be not finished yet. */
-
-			/* XXXX Do this only if SUSPENDed? */
-			PL_reg_call_cc = state.prev;
-			st->cc = state.cc;
-			PL_reg_re = state.re;
-			cache_re(PL_reg_re);
-			if (toggleutf) PL_reg_flags ^= RF_utf8;
-
-			/* XXXX This is too dramatic a measure... */
-			PL_reg_maxiter = 0;
-
-			/* These are needed even if not SUSPEND. */
-			ReREFCNT_dec(re);
-			regcpblow(st->eval.cp);
-			sayYES;
-		    }
-		    ReREFCNT_dec(re);
-		    REGCP_UNWIND(st->eval.lastcp);
-		    regcppop();
-		    PL_reg_call_cc = state.prev;
-		    st->cc = state.cc;
-		    PL_reg_re = state.re;
-		    cache_re(PL_reg_re);
-		    if (toggleutf) PL_reg_flags ^= RF_utf8;
-
-		    /* XXXX This is too dramatic a measure... */
-		    PL_reg_maxiter = 0;
+		/* run the pattern returned from (??{...}) */
+
+		DEBUG_EXECUTE_r(
+		    PerlIO_printf(Perl_debug_log,
+				  "Entering embedded \"%s%.60s%s%s\"\n",
+				  PL_colors[0],
+				  re->precomp,
+				  PL_colors[1],
+				  (strlen(re->precomp) > 60 ? "..." : ""))
+		    );
+
+		st->u.eval.cp = regcppush(0);	/* Save *all* the positions. */
+		REGCP_SET(st->u.eval.lastcp);
+		*PL_reglastparen = 0;
+		*PL_reglastcloseparen = 0;
+		PL_reginput = locinput;
+
+		/* XXXX This is too dramatic a measure... */
+		PL_reg_maxiter = 0;
 
-		    st->logical = 0;
-		    sayNO;
-		}
-		st->sw = SvTRUE(ret);
 		st->logical = 0;
+		st->u.eval.toggleutf = ((PL_reg_flags & RF_utf8) != 0) ^
+			    ((re->reganch & ROPT_UTF8) != 0);
+		if (st->u.eval.toggleutf) PL_reg_flags ^= RF_utf8;
+		st->u.eval.prev_rex = rex;
+		rex = re;
+
+		st->u.eval.prev_eval = cur_eval;
+		st->u.eval.prev_slab = PL_regmatch_slab;
+		st->u.eval.depth = depth;
+		cur_eval = st;
+		PUSH_STATE(newst, resume_EVAL);
+		st = newst;
+
+		/* now continue  from first node in postoned RE */
+		next = re->program + 1;
+		break;
+		/* NOTREACHED */
 	    }
-	    else {
-		sv_setsv(save_scalar(PL_replgv), ret);
-		cache_re(oreg);
-	    }
+	    /* /(?(?{...})X|Y)/ */
+	    st->sw = SvTRUE(ret);
+	    st->logical = 0;
 	    break;
 	}
 	case OPEN:
@@ -3439,20 +3448,21 @@ S_regmatch(pTHX_ regnode *prog)
 	    st->logical = scan->flags;
 	    break;
 /*******************************************************************
- cc contains infoblock about the innermost (...)* loop, and
- a pointer to the next outer infoblock.
+ cc points to the regmatch_state associated with the most recent CURLYX.
+ This struct contains info about the innermost (...)* loop (an
+ "infoblock"), and a pointer to the next outer cc.
 
  Here is how Y(A)*Z is processed (if it is compiled into CURLYX/WHILEM):
 
    1) After matching Y, regnode for CURLYX is processed;
 
-   2) This regnode mallocs an infoblock, and calls regmatch() recursively
+   2) This regnode populates cc, and calls regmatch() recursively
       with the starting point at WHILEM node;
 
    3) Each hit of WHILEM node tries to match A and Z (in the order
       depending on the current iteration, min/max of {min,max} and
       greediness).  The information about where are nodes for "A"
-      and "Z" is read from the infoblock, as is info on how many times "A"
+      and "Z" is read from cc, as is info on how many times "A"
       was already matched, and greediness.
 
    4) After A matches, the same WHILEM node is hit again.
@@ -3463,7 +3473,7 @@ S_regmatch(pTHX_ regnode *prog)
       as in (Y(A)*Z)*.  If Z matches, the automaton will hit the WHILEM node
       of the external loop.
 
- Currently present infoblocks form a tree with a stem formed by PL_curcc
+ Currently present infoblocks form a tree with a stem formed by st->cc
  and whatever it mentions via ->next, and additional attached trees
  corresponding to temporarily unset infoblocks as in "5" above.
 
@@ -3518,34 +3528,32 @@ S_regmatch(pTHX_ regnode *prog)
 		/* No need to save/restore up to this paren */
 		I32 parenfloor = scan->flags;
 
-		{
-		    CURCUR *newcc;
-		    Newx(newcc, 1, CURCUR);
-		    st->curlyx.savecc = st->cc;
-		    newcc->oldcc = st->cc;
-		    st->cc = newcc;
-		}
-		st->curlyx.cp = PL_savestack_ix;
-		if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
+		if (next && (OP(PREVOPER(next)) == NOTHING)) /* LONGJMP */
 		    next += ARG(next);
 		/* XXXX Probably it is better to teach regpush to support
 		   parenfloor > PL_regsize... */
 		if (parenfloor > (I32)*PL_reglastparen)
 		    parenfloor = *PL_reglastparen; /* Pessimization... */
-		st->cc->parenfloor = parenfloor;
-		st->cc->cur = -1;
-		st->cc->min = ARG1(scan);
-		st->cc->max  = ARG2(scan);
-		st->cc->scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
-		st->cc->next = next;
-		st->cc->minmod = st->minmod;
-		st->cc->lastloc = 0;
+
+		st->u.curlyx.cp = PL_savestack_ix;
+		st->u.curlyx.outercc = st->cc;
+		st->cc = st;
+		/* these fields contain the state of the current curly.
+		 * they are accessed by subsequent WHILEMs;
+		 * cur and lastloc are also updated by WHILEM */
+		st->u.curlyx.parenfloor = parenfloor;
+		st->u.curlyx.cur = -1; /* this will be updated by WHILEM */
+		st->u.curlyx.min = ARG1(scan);
+		st->u.curlyx.max  = ARG2(scan);
+		st->u.curlyx.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
+		st->u.curlyx.lastloc = 0;
+		/* st->next and st->minmod are also read by WHILEM */
+
 		PL_reginput = locinput;
 		REGMATCH(PREVOPER(next), CURLYX); /* start on the WHILEM */
 		/*** all unsaved local vars undefined at this point */
-		regcpblow(st->curlyx.cp);
-		Safefree(st->cc);
-		st->cc = st->curlyx.savecc;
+		regcpblow(st->u.curlyx.cp);
+		st->cc = st->u.curlyx.outercc;
 		saySAME(result);
 	    }
 	    /* NOTREACHED */
@@ -3559,54 +3567,54 @@ S_regmatch(pTHX_ regnode *prog)
 		 * that we can try again after backing off.
 		 */
 
-		st->whilem.lastloc = st->cc->lastloc; /* Detection of 0-len. */
-		st->whilem.cache_offset = 0;
-		st->whilem.cache_bit = 0;
+		st->u.whilem.lastloc = st->cc->u.curlyx.lastloc; /* Detection of 0-len. */
+		st->u.whilem.cache_offset = 0;
+		st->u.whilem.cache_bit = 0;
 		
-		n = st->cc->cur + 1;	/* how many we know we matched */
+		n = st->cc->u.curlyx.cur + 1; /* how many we know we matched */
 		PL_reginput = locinput;
 
 		DEBUG_EXECUTE_r(
 		    PerlIO_printf(Perl_debug_log,
 				  "%*s  %ld out of %ld..%ld  cc=%"UVxf"\n",
 				  REPORT_CODE_OFF+PL_regindent*2, "",
-				  (long)n, (long)st->cc->min,
-				  (long)st->cc->max, PTR2UV(st->cc))
+				  (long)n, (long)st->cc->u.curlyx.min,
+				  (long)st->cc->u.curlyx.max, PTR2UV(st->cc))
 		    );
 
 		/* If degenerate scan matches "", assume scan done. */
 
-		if (locinput == st->cc->lastloc && n >= st->cc->min) {
-		    st->whilem.savecc = st->cc;
-		    st->cc = st->cc->oldcc;
+		if (locinput == st->cc->u.curlyx.lastloc && n >= st->cc->u.curlyx.min) {
+		    st->u.whilem.savecc = st->cc;
+		    st->cc = st->cc->u.curlyx.outercc;
 		    if (st->cc)
-			st->ln = st->cc->cur;
+			st->ln = st->cc->u.curlyx.cur;
 		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 			   "%*s  empty match detected, try continuation...\n",
 			   REPORT_CODE_OFF+PL_regindent*2, "")
 			);
-		    REGMATCH(st->whilem.savecc->next, WHILEM1);
+		    REGMATCH(st->u.whilem.savecc->next, WHILEM1);
 		    /*** all unsaved local vars undefined at this point */
-		    st->cc = st->whilem.savecc;
+		    st->cc = st->u.whilem.savecc;
 		    if (result)
 			sayYES;
-		    if (st->cc->oldcc)
-			st->cc->oldcc->cur = st->ln;
+		    if (st->cc->u.curlyx.outercc)
+			st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
 		    sayNO;
 		}
 
 		/* First just match a string of min scans. */
 
-		if (n < st->cc->min) {
-		    st->cc->cur = n;
-		    st->cc->lastloc = locinput;
-		    REGMATCH(st->cc->scan, WHILEM2);
+		if (n < st->cc->u.curlyx.min) {
+		    st->cc->u.curlyx.cur = n;
+		    st->cc->u.curlyx.lastloc = locinput;
+		    REGMATCH(st->cc->u.curlyx.scan, WHILEM2);
 		    /*** all unsaved local vars undefined at this point */
 		    if (result)
 			sayYES;
-		    st->cc->cur = n - 1;
-		    st->cc->lastloc = st->whilem.lastloc;
+		    st->cc->u.curlyx.cur = n - 1;
+		    st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		    sayNO;
 		}
 
@@ -3638,13 +3646,13 @@ S_regmatch(pTHX_ regnode *prog)
 			);
 		}
 		if (PL_reg_leftiter < 0) {
-		    st->whilem.cache_offset = locinput - PL_bostr;
+		    st->u.whilem.cache_offset = locinput - PL_bostr;
 
-		    st->whilem.cache_offset = (scan->flags & 0xf) - 1 + POSCACHE_START
-			    + st->whilem.cache_offset * (scan->flags>>4);
-		    st->whilem.cache_bit = st->whilem.cache_offset % 8;
-		    st->whilem.cache_offset /= 8;
-		    if (PL_reg_poscache[st->whilem.cache_offset] & (1<<st->whilem.cache_bit)) {
+		    st->u.whilem.cache_offset = (scan->flags & 0xf) - 1 + POSCACHE_START
+			    + st->u.whilem.cache_offset * (scan->flags>>4);
+		    st->u.whilem.cache_bit = st->u.whilem.cache_offset % 8;
+		    st->u.whilem.cache_offset /= 8;
+		    if (PL_reg_poscache[st->u.whilem.cache_offset] & (1<<st->u.whilem.cache_bit)) {
 		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 				      "%*s  already tried at this position...\n",
@@ -3657,32 +3665,32 @@ S_regmatch(pTHX_ regnode *prog)
 			    /* cache records failure */
 			    sayNO_SILENT;
 		    }
-		    PL_reg_poscache[st->whilem.cache_offset] |= (1<<st->whilem.cache_bit);
+		    PL_reg_poscache[st->u.whilem.cache_offset] |= (1<<st->u.whilem.cache_bit);
 		}
 		}
 
 		/* Prefer next over scan for minimal matching. */
 
 		if (st->cc->minmod) {
-		    st->whilem.savecc = st->cc;
-		    st->cc = st->cc->oldcc;
+		    st->u.whilem.savecc = st->cc;
+		    st->cc = st->cc->u.curlyx.outercc;
 		    if (st->cc)
-			st->ln = st->cc->cur;
-		    st->whilem.cp = regcppush(st->whilem.savecc->parenfloor);
-		    REGCP_SET(st->whilem.lastcp);
-		    REGMATCH(st->whilem.savecc->next, WHILEM3);
+			st->ln = st->cc->u.curlyx.cur;
+		    st->u.whilem.cp = regcppush(st->u.whilem.savecc->u.curlyx.parenfloor);
+		    REGCP_SET(st->u.whilem.lastcp);
+		    REGMATCH(st->u.whilem.savecc->next, WHILEM3);
 		    /*** all unsaved local vars undefined at this point */
-		    st->cc = st->whilem.savecc;
+		    st->cc = st->u.whilem.savecc;
 		    if (result) {
-			regcpblow(st->whilem.cp);
+			regcpblow(st->u.whilem.cp);
 			CACHEsayYES;	/* All done. */
 		    }
-		    REGCP_UNWIND(st->whilem.lastcp);
-		    regcppop();
-		    if (st->cc->oldcc)
-			st->cc->oldcc->cur = st->ln;
+		    REGCP_UNWIND(st->u.whilem.lastcp);
+		    regcppop(rex);
+		    if (st->cc->u.curlyx.outercc)
+			st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
 
-		    if (n >= st->cc->max) {	/* Maximum greed exceeded? */
+		    if (n >= st->cc->u.curlyx.max) { /* Maximum greed exceeded? */
 			if (ckWARN(WARN_REGEXP) && n >= REG_INFTY
 			    && !(PL_reg_flags & RF_warned)) {
 			    PL_reg_flags |= RF_warned;
@@ -3700,38 +3708,38 @@ S_regmatch(pTHX_ regnode *prog)
 			);
 		    /* Try scanning more and see if it helps. */
 		    PL_reginput = locinput;
-		    st->cc->cur = n;
-		    st->cc->lastloc = locinput;
-		    st->whilem.cp = regcppush(st->cc->parenfloor);
-		    REGCP_SET(st->whilem.lastcp);
-		    REGMATCH(st->cc->scan, WHILEM4);
+		    st->cc->u.curlyx.cur = n;
+		    st->cc->u.curlyx.lastloc = locinput;
+		    st->u.whilem.cp = regcppush(st->cc->u.curlyx.parenfloor);
+		    REGCP_SET(st->u.whilem.lastcp);
+		    REGMATCH(st->cc->u.curlyx.scan, WHILEM4);
 		    /*** all unsaved local vars undefined at this point */
 		    if (result) {
-			regcpblow(st->whilem.cp);
+			regcpblow(st->u.whilem.cp);
 			CACHEsayYES;
 		    }
-		    REGCP_UNWIND(st->whilem.lastcp);
-		    regcppop();
-		    st->cc->cur = n - 1;
-		    st->cc->lastloc = st->whilem.lastloc;
+		    REGCP_UNWIND(st->u.whilem.lastcp);
+		    regcppop(rex);
+		    st->cc->u.curlyx.cur = n - 1;
+		    st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		    CACHEsayNO;
 		}
 
 		/* Prefer scan over next for maximal matching. */
 
-		if (n < st->cc->max) {	/* More greed allowed? */
-		    st->whilem.cp = regcppush(st->cc->parenfloor);
-		    st->cc->cur = n;
-		    st->cc->lastloc = locinput;
-		    REGCP_SET(st->whilem.lastcp);
-		    REGMATCH(st->cc->scan, WHILEM5);
+		if (n < st->cc->u.curlyx.max) {	/* More greed allowed? */
+		    st->u.whilem.cp = regcppush(st->cc->u.curlyx.parenfloor);
+		    st->cc->u.curlyx.cur = n;
+		    st->cc->u.curlyx.lastloc = locinput;
+		    REGCP_SET(st->u.whilem.lastcp);
+		    REGMATCH(st->cc->u.curlyx.scan, WHILEM5);
 		    /*** all unsaved local vars undefined at this point */
 		    if (result) {
-			regcpblow(st->whilem.cp);
+			regcpblow(st->u.whilem.cp);
 			CACHEsayYES;
 		    }
-		    REGCP_UNWIND(st->whilem.lastcp);
-		    regcppop();		/* Restore some previous $<digit>s? */
+		    REGCP_UNWIND(st->u.whilem.lastcp);
+		    regcppop(rex);	/* Restore some previous $<digit>s? */
 		    PL_reginput = locinput;
 		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
@@ -3748,19 +3756,19 @@ S_regmatch(pTHX_ regnode *prog)
 		}
 
 		/* Failed deeper matches of scan, so see if this one works. */
-		st->whilem.savecc = st->cc;
-		st->cc = st->cc->oldcc;
+		st->u.whilem.savecc = st->cc;
+		st->cc = st->cc->u.curlyx.outercc;
 		if (st->cc)
-		    st->ln = st->cc->cur;
-		REGMATCH(st->whilem.savecc->next, WHILEM6);
+		    st->ln = st->cc->u.curlyx.cur;
+		REGMATCH(st->u.whilem.savecc->next, WHILEM6);
 		/*** all unsaved local vars undefined at this point */
-		st->cc = st->whilem.savecc;
+		st->cc = st->u.whilem.savecc;
 		if (result)
 		    CACHEsayYES;
-		if (st->cc->oldcc)
-		    st->cc->oldcc->cur = st->ln;
-		st->cc->cur = n - 1;
-		st->cc->lastloc = st->whilem.lastloc;
+		if (st->cc->u.curlyx.outercc)
+		    st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
+		st->cc->u.curlyx.cur = n - 1;
+		st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		CACHEsayNO;
 	    }
 	    /* NOTREACHED */
@@ -3776,7 +3784,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    {
 		I32 type;
 		type = OP(scan);
-		if (OP(next) != type)	/* No choice. */
+		if (!next || OP(next) != type)	/* No choice. */
 		    next = inner;	/* Avoid recursion. */
 		else {
 		    const I32 lastparen = *PL_reglastparen;
@@ -3793,6 +3801,7 @@ S_regmatch(pTHX_ regnode *prog)
 		    uw->next = next;
 		    uw->locinput = locinput;
 		    uw->nextchr = nextchr;
+		    uw->minmod = st->minmod;
 #ifdef DEBUGGING
 		    uw->regindent = ++PL_regindent;
 #endif
@@ -3809,45 +3818,45 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	case CURLYM:
 	{
-	    st->curlym.l = st->curlym.matches = 0;
+	    st->u.curlym.l = st->u.curlym.matches = 0;
 	
 	    /* We suppose that the next guy does not need
 	       backtracking: in particular, it is of constant non-zero length,
 	       and has no parenths to influence future backrefs. */
 	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
-	    st->curlym.paren = scan->flags;
-	    if (st->curlym.paren) {
-		if (st->curlym.paren > PL_regsize)
-		    PL_regsize = st->curlym.paren;
-		if (st->curlym.paren > (I32)*PL_reglastparen)
-		    *PL_reglastparen = st->curlym.paren;
+	    st->u.curlym.paren = scan->flags;
+	    if (st->u.curlym.paren) {
+		if (st->u.curlym.paren > PL_regsize)
+		    PL_regsize = st->u.curlym.paren;
+		if (st->u.curlym.paren > (I32)*PL_reglastparen)
+		    *PL_reglastparen = st->u.curlym.paren;
 	    }
 	    scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
-	    if (st->curlym.paren)
+	    if (st->u.curlym.paren)
 		scan += NEXT_OFF(scan); /* Skip former OPEN. */
 	    PL_reginput = locinput;
-	    st->curlym.maxwanted = st->minmod ? st->ln : n;
-	    if (st->curlym.maxwanted) {
-		while (PL_reginput < PL_regeol && st->curlym.matches < st->curlym.maxwanted) {
+	    st->u.curlym.maxwanted = st->minmod ? st->ln : n;
+	    if (st->u.curlym.maxwanted) {
+		while (PL_reginput < PL_regeol && st->u.curlym.matches < st->u.curlym.maxwanted) {
 		    REGMATCH(scan, CURLYM1);
 		    /*** all unsaved local vars undefined at this point */
 		    if (!result)
 			break;
-		    /* on first match, determine length, curlym.l */
-		    if (!st->curlym.matches++) {
+		    /* on first match, determine length, u.curlym.l */
+		    if (!st->u.curlym.matches++) {
 			if (PL_reg_match_utf8) {
 			    char *s = locinput;
 			    while (s < PL_reginput) {
-				st->curlym.l++;
+				st->u.curlym.l++;
 				s += UTF8SKIP(s);
 			    }
 			}
 			else {
-			    st->curlym.l = PL_reginput - locinput;
+			    st->u.curlym.l = PL_reginput - locinput;
 			}
-			if (st->curlym.l == 0) {
-			    st->curlym.matches = st->curlym.maxwanted;
+			if (st->u.curlym.l == 0) {
+			    st->u.curlym.matches = st->u.curlym.maxwanted;
 			    break;
 			}
 		    }
@@ -3859,52 +3868,52 @@ S_regmatch(pTHX_ regnode *prog)
 
 	    if (st->minmod) {
 		st->minmod = 0;
-		if (st->ln && st->curlym.matches < st->ln)
+		if (st->ln && st->u.curlym.matches < st->ln)
 		    sayNO;
 		if (HAS_TEXT(next) || JUMPABLE(next)) {
 		    regnode *text_node = next;
 
 		    if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-		    if (! HAS_TEXT(text_node)) st->curlym.c1 = st->curlym.c2 = -1000;
+		    if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 		    else {
 			if (PL_regkind[(U8)OP(text_node)] == REF) {
-			    st->curlym.c1 = st->curlym.c2 = -1000;
+			    st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 			    goto assume_ok_MM;
 			}
-			else { st->curlym.c1 = (U8)*STRING(text_node); }
+			else { st->u.curlym.c1 = (U8)*STRING(text_node); }
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-			    st->curlym.c2 = PL_fold[st->curlym.c1];
+			    st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
 			else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-			    st->curlym.c2 = PL_fold_locale[st->curlym.c1];
+			    st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
 			else
-			    st->curlym.c2 = st->curlym.c1;
+			    st->u.curlym.c2 = st->u.curlym.c1;
 		    }
 		}
 		else
-		    st->curlym.c1 = st->curlym.c2 = -1000;
+		    st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 	    assume_ok_MM:
-		REGCP_SET(st->curlym.lastcp);
+		REGCP_SET(st->u.curlym.lastcp);
 		while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
 		    /* If it could work, try it. */
-		    if (st->curlym.c1 == -1000 ||
-			UCHARAT(PL_reginput) == st->curlym.c1 ||
-			UCHARAT(PL_reginput) == st->curlym.c2)
+		    if (st->u.curlym.c1 == -1000 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c2)
 		    {
-			if (st->curlym.paren) {
+			if (st->u.curlym.paren) {
 			    if (st->ln) {
-				PL_regstartp[st->curlym.paren] =
-				    HOPc(PL_reginput, -st->curlym.l) - PL_bostr;
-				PL_regendp[st->curlym.paren] = PL_reginput - PL_bostr;
+				PL_regstartp[st->u.curlym.paren] =
+				    HOPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+				PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
 			    }
 			    else
-				PL_regendp[st->curlym.paren] = -1;
+				PL_regendp[st->u.curlym.paren] = -1;
 			}
 			REGMATCH(next, CURLYM2);
 			/*** all unsaved local vars undefined at this point */
 			if (result)
 			    sayYES;
-			REGCP_UNWIND(st->curlym.lastcp);
+			REGCP_UNWIND(st->u.curlym.lastcp);
 		    }
 		    /* Couldn't or didn't -- move forward. */
 		    PL_reginput = locinput;
@@ -3923,65 +3932,65 @@ S_regmatch(pTHX_ regnode *prog)
 		    PerlIO_printf(Perl_debug_log,
 			      "%*s  matched %"IVdf" times, len=%"IVdf"...\n",
 			      (int)(REPORT_CODE_OFF+PL_regindent*2), "",
-			      (IV) st->curlym.matches, (IV)st->curlym.l)
+			      (IV) st->u.curlym.matches, (IV)st->u.curlym.l)
 		    );
-		if (st->curlym.matches >= st->ln) {
+		if (st->u.curlym.matches >= st->ln) {
 		    if (HAS_TEXT(next) || JUMPABLE(next)) {
 			regnode *text_node = next;
 
 			if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-			if (! HAS_TEXT(text_node)) st->curlym.c1 = st->curlym.c2 = -1000;
+			if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 			else {
 			    if (PL_regkind[(U8)OP(text_node)] == REF) {
-				st->curlym.c1 = st->curlym.c2 = -1000;
+				st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 				goto assume_ok_REG;
 			    }
-			    else { st->curlym.c1 = (U8)*STRING(text_node); }
+			    else { st->u.curlym.c1 = (U8)*STRING(text_node); }
 
 			    if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-				st->curlym.c2 = PL_fold[st->curlym.c1];
+				st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
 			    else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-				st->curlym.c2 = PL_fold_locale[st->curlym.c1];
+				st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
 			    else
-				st->curlym.c2 = st->curlym.c1;
+				st->u.curlym.c2 = st->u.curlym.c1;
 			}
 		    }
 		    else
-			st->curlym.c1 = st->curlym.c2 = -1000;
+			st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 		}
 	    assume_ok_REG:
-		REGCP_SET(st->curlym.lastcp);
-		while (st->curlym.matches >= st->ln) {
+		REGCP_SET(st->u.curlym.lastcp);
+		while (st->u.curlym.matches >= st->ln) {
 		    /* If it could work, try it. */
-		    if (st->curlym.c1 == -1000 ||
-			UCHARAT(PL_reginput) == st->curlym.c1 ||
-			UCHARAT(PL_reginput) == st->curlym.c2)
+		    if (st->u.curlym.c1 == -1000 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c2)
 		    {
 			DEBUG_EXECUTE_r(
 			    PerlIO_printf(Perl_debug_log,
 				"%*s  trying tail with matches=%"IVdf"...\n",
 				(int)(REPORT_CODE_OFF+PL_regindent*2),
-				"", (IV)st->curlym.matches)
+				"", (IV)st->u.curlym.matches)
 			    );
-			if (st->curlym.paren) {
-			    if (st->curlym.matches) {
-				PL_regstartp[st->curlym.paren]
-				    = HOPc(PL_reginput, -st->curlym.l) - PL_bostr;
-				PL_regendp[st->curlym.paren] = PL_reginput - PL_bostr;
+			if (st->u.curlym.paren) {
+			    if (st->u.curlym.matches) {
+				PL_regstartp[st->u.curlym.paren]
+				    = HOPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+				PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
 			    }
 			    else
-				PL_regendp[st->curlym.paren] = -1;
+				PL_regendp[st->u.curlym.paren] = -1;
 			}
 			REGMATCH(next, CURLYM4);
 			/*** all unsaved local vars undefined at this point */
 			if (result)
 			    sayYES;
-			REGCP_UNWIND(st->curlym.lastcp);
+			REGCP_UNWIND(st->u.curlym.lastcp);
 		    }
 		    /* Couldn't or didn't -- back up. */
-		    st->curlym.matches--;
-		    locinput = HOPc(locinput, -st->curlym.l);
+		    st->u.curlym.matches--;
+		    locinput = HOPc(locinput, -st->u.curlym.l);
 		    PL_reginput = locinput;
 		}
 	    }
@@ -3990,17 +3999,17 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	}
 	case CURLYN:
-	    st->plus.paren = scan->flags;	/* Which paren to set */
-	    if (st->plus.paren > PL_regsize)
-		PL_regsize = st->plus.paren;
-	    if (st->plus.paren > (I32)*PL_reglastparen)
-		*PL_reglastparen = st->plus.paren;
+	    st->u.plus.paren = scan->flags;	/* Which paren to set */
+	    if (st->u.plus.paren > PL_regsize)
+		PL_regsize = st->u.plus.paren;
+	    if (st->u.plus.paren > (I32)*PL_reglastparen)
+		*PL_reglastparen = st->u.plus.paren;
 	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
             scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
 	    goto repeat;
 	case CURLY:
-	    st->plus.paren = 0;
+	    st->u.plus.paren = 0;
 	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
 	    scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
@@ -4009,13 +4018,13 @@ S_regmatch(pTHX_ regnode *prog)
 	    st->ln = 0;
 	    n = REG_INFTY;
 	    scan = NEXTOPER(scan);
-	    st->plus.paren = 0;
+	    st->u.plus.paren = 0;
 	    goto repeat;
 	case PLUS:
 	    st->ln = 1;
 	    n = REG_INFTY;
 	    scan = NEXTOPER(scan);
-	    st->plus.paren = 0;
+	    st->u.plus.paren = 0;
 	  repeat:
 	    /*
 	    * Lookahead to avoid useless match attempts
@@ -4034,20 +4043,20 @@ S_regmatch(pTHX_ regnode *prog)
 
 		if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-		if (! HAS_TEXT(text_node)) st->plus.c1 = st->plus.c2 = -1000;
+		if (! HAS_TEXT(text_node)) st->u.plus.c1 = st->u.plus.c2 = -1000;
 		else {
 		    if (PL_regkind[(U8)OP(text_node)] == REF) {
-			st->plus.c1 = st->plus.c2 = -1000;
+			st->u.plus.c1 = st->u.plus.c2 = -1000;
 			goto assume_ok_easy;
 		    }
 		    else { s = (U8*)STRING(text_node); }
 
 		    if (!UTF) {
-			st->plus.c2 = st->plus.c1 = *s;
+			st->u.plus.c2 = st->u.plus.c1 = *s;
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-			    st->plus.c2 = PL_fold[st->plus.c1];
+			    st->u.plus.c2 = PL_fold[st->u.plus.c1];
 			else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-			    st->plus.c2 = PL_fold_locale[st->plus.c1];
+			    st->u.plus.c2 = PL_fold_locale[st->u.plus.c1];
 		    }
 		    else { /* UTF */
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF) {
@@ -4058,117 +4067,117 @@ S_regmatch(pTHX_ regnode *prog)
 			     to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
 			     to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
 
-			     st->plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
+			     st->u.plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
 						 uniflags);
-			     st->plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
+			     st->u.plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
 						 uniflags);
 			}
 			else {
-			    st->plus.c2 = st->plus.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
+			    st->u.plus.c2 = st->u.plus.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
 						     uniflags);
 			}
 		    }
 		}
 	    }
 	    else
-		st->plus.c1 = st->plus.c2 = -1000;
+		st->u.plus.c1 = st->u.plus.c2 = -1000;
 	assume_ok_easy:
 	    PL_reginput = locinput;
 	    if (st->minmod) {
 		st->minmod = 0;
-		if (st->ln && regrepeat(scan, st->ln) < st->ln)
+		if (st->ln && regrepeat(rex, scan, st->ln) < st->ln)
 		    sayNO;
 		locinput = PL_reginput;
-		REGCP_SET(st->plus.lastcp);
-		if (st->plus.c1 != -1000) {
-		    st->plus.old = locinput;
-		    st->plus.count = 0;
+		REGCP_SET(st->u.plus.lastcp);
+		if (st->u.plus.c1 != -1000) {
+		    st->u.plus.old = locinput;
+		    st->u.plus.count = 0;
 
 		    if  (n == REG_INFTY) {
-			st->plus.e = PL_regeol - 1;
+			st->u.plus.e = PL_regeol - 1;
 			if (do_utf8)
-			    while (UTF8_IS_CONTINUATION(*(U8*)st->plus.e))
-				st->plus.e--;
+			    while (UTF8_IS_CONTINUATION(*(U8*)st->u.plus.e))
+				st->u.plus.e--;
 		    }
 		    else if (do_utf8) {
 			int m = n - st->ln;
-			for (st->plus.e = locinput;
-			     m >0 && st->plus.e + UTF8SKIP(st->plus.e) <= PL_regeol; m--)
-			    st->plus.e += UTF8SKIP(st->plus.e);
+			for (st->u.plus.e = locinput;
+			     m >0 && st->u.plus.e + UTF8SKIP(st->u.plus.e) <= PL_regeol; m--)
+			    st->u.plus.e += UTF8SKIP(st->u.plus.e);
 		    }
 		    else {
-			st->plus.e = locinput + n - st->ln;
-			if (st->plus.e >= PL_regeol)
-			    st->plus.e = PL_regeol - 1;
+			st->u.plus.e = locinput + n - st->ln;
+			if (st->u.plus.e >= PL_regeol)
+			    st->u.plus.e = PL_regeol - 1;
 		    }
 		    while (1) {
 			/* Find place 'next' could work */
 			if (!do_utf8) {
-			    if (st->plus.c1 == st->plus.c2) {
-				while (locinput <= st->plus.e &&
-				       UCHARAT(locinput) != st->plus.c1)
+			    if (st->u.plus.c1 == st->u.plus.c2) {
+				while (locinput <= st->u.plus.e &&
+				       UCHARAT(locinput) != st->u.plus.c1)
 				    locinput++;
 			    } else {
-				while (locinput <= st->plus.e
-				       && UCHARAT(locinput) != st->plus.c1
-				       && UCHARAT(locinput) != st->plus.c2)
+				while (locinput <= st->u.plus.e
+				       && UCHARAT(locinput) != st->u.plus.c1
+				       && UCHARAT(locinput) != st->u.plus.c2)
 				    locinput++;
 			    }
-			    st->plus.count = locinput - st->plus.old;
+			    st->u.plus.count = locinput - st->u.plus.old;
 			}
 			else {
-			    if (st->plus.c1 == st->plus.c2) {
+			    if (st->u.plus.c1 == st->u.plus.c2) {
 				STRLEN len;
 				/* count initialised to
 				 * utf8_distance(old, locinput) */
-				while (locinput <= st->plus.e &&
+				while (locinput <= st->u.plus.e &&
 				       utf8n_to_uvchr((U8*)locinput,
 						      UTF8_MAXBYTES, &len,
-						      uniflags) != (UV)st->plus.c1) {
+						      uniflags) != (UV)st->u.plus.c1) {
 				    locinput += len;
-				    st->plus.count++;
+				    st->u.plus.count++;
 				}
 			    } else {
 				STRLEN len;
 				/* count initialised to
 				 * utf8_distance(old, locinput) */
-				while (locinput <= st->plus.e) {
+				while (locinput <= st->u.plus.e) {
 				    UV c = utf8n_to_uvchr((U8*)locinput,
 							  UTF8_MAXBYTES, &len,
 							  uniflags);
-				    if (c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+				    if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 					break;
 				    locinput += len;
-				    st->plus.count++;
+				    st->u.plus.count++;
 				}
 			    }
 			}
-			if (locinput > st->plus.e)
+			if (locinput > st->u.plus.e)
 			    sayNO;
 			/* PL_reginput == old now */
-			if (locinput != st->plus.old) {
+			if (locinput != st->u.plus.old) {
 			    st->ln = 1;	/* Did some */
-			    if (regrepeat(scan, st->plus.count) < st->plus.count)
+			    if (regrepeat(rex, scan, st->u.plus.count) < st->u.plus.count)
 				sayNO;
 			}
 			/* PL_reginput == locinput now */
-			TRYPAREN(st->plus.paren, st->ln, locinput, PLUS1);
+			TRYPAREN(st->u.plus.paren, st->ln, locinput, PLUS1);
 			/*** all unsaved local vars undefined at this point */
 			PL_reginput = locinput;	/* Could be reset... */
-			REGCP_UNWIND(st->plus.lastcp);
+			REGCP_UNWIND(st->u.plus.lastcp);
 			/* Couldn't or didn't -- move forward. */
-			st->plus.old = locinput;
+			st->u.plus.old = locinput;
 			if (do_utf8)
 			    locinput += UTF8SKIP(locinput);
 			else
 			    locinput++;
-			st->plus.count = 1;
+			st->u.plus.count = 1;
 		    }
 		}
 		else
 		while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
 		    UV c;
-		    if (st->plus.c1 != -1000) {
+		    if (st->u.plus.c1 != -1000) {
 			if (do_utf8)
 			    c = utf8n_to_uvchr((U8*)PL_reginput,
 					       UTF8_MAXBYTES, 0,
@@ -4176,23 +4185,23 @@ S_regmatch(pTHX_ regnode *prog)
 			else
 			    c = UCHARAT(PL_reginput);
 			/* If it could work, try it. */
-		        if (c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+		        if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 		        {
-			    TRYPAREN(st->plus.paren, st->ln, PL_reginput, PLUS2);
+			    TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS2);
 			    /*** all unsaved local vars undefined at this point */
-			    REGCP_UNWIND(st->plus.lastcp);
+			    REGCP_UNWIND(st->u.plus.lastcp);
 		        }
 		    }
 		    /* If it could work, try it. */
-		    else if (st->plus.c1 == -1000)
+		    else if (st->u.plus.c1 == -1000)
 		    {
-			TRYPAREN(st->plus.paren, st->ln, PL_reginput, PLUS3);
+			TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS3);
 			/*** all unsaved local vars undefined at this point */
-			REGCP_UNWIND(st->plus.lastcp);
+			REGCP_UNWIND(st->u.plus.lastcp);
 		    }
 		    /* Couldn't or didn't -- move forward. */
 		    PL_reginput = locinput;
-		    if (regrepeat(scan, 1)) {
+		    if (regrepeat(rex, scan, 1)) {
 			st->ln++;
 			locinput = PL_reginput;
 		    }
@@ -4201,7 +4210,7 @@ S_regmatch(pTHX_ regnode *prog)
 		}
 	    }
 	    else {
-		n = regrepeat(scan, n);
+		n = regrepeat(rex, scan, n);
 		locinput = PL_reginput;
 		if (st->ln < n && PL_regkind[(U8)OP(next)] == EOL &&
 		    (OP(next) != MEOL ||
@@ -4214,11 +4223,11 @@ S_regmatch(pTHX_ regnode *prog)
 		    if (UCHARAT(PL_reginput - 1) == '\n' && OP(next) != EOS)
 			st->ln--;
 		}
-		REGCP_SET(st->plus.lastcp);
+		REGCP_SET(st->u.plus.lastcp);
 		{
 		    UV c = 0;
 		    while (n >= st->ln) {
-			if (st->plus.c1 != -1000) {
+			if (st->u.plus.c1 != -1000) {
 			    if (do_utf8)
 				c = utf8n_to_uvchr((U8*)PL_reginput,
 						   UTF8_MAXBYTES, 0,
@@ -4227,11 +4236,11 @@ S_regmatch(pTHX_ regnode *prog)
 				c = UCHARAT(PL_reginput);
 			}
 			/* If it could work, try it. */
-			if (st->plus.c1 == -1000 || c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+			if (st->u.plus.c1 == -1000 || c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 			    {
-				TRYPAREN(st->plus.paren, n, PL_reginput, PLUS4);
+				TRYPAREN(st->u.plus.paren, n, PL_reginput, PLUS4);
 				/*** all unsaved local vars undefined at this point */
-				REGCP_UNWIND(st->plus.lastcp);
+				REGCP_UNWIND(st->u.plus.lastcp);
 			    }
 			/* Couldn't or didn't -- back up. */
 			n--;
@@ -4242,56 +4251,54 @@ S_regmatch(pTHX_ regnode *prog)
 	    sayNO;
 	    break;
 	case END:
-	    if (PL_reg_call_cc) {
-		st->end.cur_call_cc = PL_reg_call_cc;
-		st->end.end_re = PL_reg_re;
+	    if (cur_eval) {
+		/* we have successfully completed the execution of a
+		 * postponed re. Pop all states back to the last EVAL
+		 * then continue with the node following the (??{...})
+		 */
+
+		/* this simulates a POP_STATE, except that it pops several
+		 * levels, and doesn't restore locinput */
+
+		st = cur_eval;
+		PL_regmatch_slab = st->u.eval.prev_slab;
+		cur_eval = st->u.eval.prev_eval;
+		depth = st->u.eval.depth;
 
-		/* Save *all* the positions. */
-		st->end.cp = regcppush(0);
-		REGCP_SET(st->end.lastcp);
+		PL_regmatch_state = st;
+		scan	= st->scan;
+		next	= st->next;
+		n		= st->n;
 
-		/* Restore parens of the caller. */
+		if (st->u.eval.toggleutf)
+		    PL_reg_flags ^= RF_utf8;
+		ReREFCNT_dec(rex);
+		rex = st->u.eval.prev_rex;
+		/* XXXX This is too dramatic a measure... */
+		PL_reg_maxiter = 0;
+
+		/* Restore parens of the caller without popping the
+		 * savestack */
 		{
 		    I32 tmp = PL_savestack_ix;
-		    PL_savestack_ix = PL_reg_call_cc->ss;
-		    regcppop();
+		    PL_savestack_ix = st->u.eval.lastcp;
+		    regcppop(rex);
 		    PL_savestack_ix = tmp;
 		}
 
-		/* Make position available to the callcc. */
-		PL_reginput = locinput;
 
-		cache_re(PL_reg_call_cc->re);
-		st->end.savecc = st->cc;
-		st->cc = PL_reg_call_cc->cc;
-		PL_reg_call_cc = PL_reg_call_cc->prev;
-		REGMATCH(st->end.cur_call_cc->node, END);
-		/*** all unsaved local vars undefined at this point */
-		if (result) {
-		    PL_reg_call_cc = st->end.cur_call_cc;
-		    regcpblow(st->end.cp);
-		    sayYES;
-		}
-		REGCP_UNWIND(st->end.lastcp);
-		regcppop();
-		PL_reg_call_cc = st->end.cur_call_cc;
-		st->cc = st->end.savecc;
-		PL_reg_re = st->end.end_re;
-		cache_re(st->end.end_re);
+		PL_reginput = locinput;
+		/* resume at node following the (??{...}) */
+		break;
 
-		DEBUG_EXECUTE_r(
-		    PerlIO_printf(Perl_debug_log,
-				  "%*s  continuation failed...\n",
-				  REPORT_CODE_OFF+PL_regindent*2, "")
-		    );
-		sayNO_SILENT;
 	    }
-	    if (locinput < PL_regtill) {
+
+	    if (locinput < reginfo->till) {
 		DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 				      "%sMatch possible, but length=%ld is smaller than requested=%ld, failing!%s\n",
 				      PL_colors[4],
 				      (long)(locinput - PL_reg_starttry),
-				      (long)(PL_regtill - PL_reg_starttry),
+				      (long)(reginfo->till - PL_reg_starttry),
 				      PL_colors[5]));
 		sayNO_FINAL;		/* Cannot match: too short. */
 	    }
@@ -4387,7 +4394,6 @@ S_regmatch(pTHX_ regnode *prog)
 	    oldst->next = next;
 	    oldst->n = n;
 	    oldst->locinput = locinput;
-	    oldst->reg_call_cc = PL_reg_call_cc;
 
 	    st->cc = oldst->cc;
 	    locinput = PL_reginput;
@@ -4402,6 +4408,8 @@ S_regmatch(pTHX_ regnode *prog)
 	}
     }
 
+
+
     /*
     * We get here only if there's trouble -- normally "case END" is
     * the terminating point.
@@ -4426,7 +4434,56 @@ yes:
 #endif
 
     result = 1;
-    goto exit_level;
+    /* XXX this is duplicate(ish) code to that in the do_no section.
+     * eventually a yes should just pop the whole stack */
+    if (depth) {
+	/* restore previous state and re-enter */
+	POP_STATE;
+
+	switch (st->resume_state) {
+	case resume_TRIE1:
+	    goto resume_point_TRIE1;
+	case resume_TRIE2:
+	    goto resume_point_TRIE2;
+	case resume_EVAL:
+	    break;
+	case resume_CURLYX:
+	    goto resume_point_CURLYX;
+	case resume_WHILEM1:
+	    goto resume_point_WHILEM1;
+	case resume_WHILEM2:
+	    goto resume_point_WHILEM2;
+	case resume_WHILEM3:
+	    goto resume_point_WHILEM3;
+	case resume_WHILEM4:
+	    goto resume_point_WHILEM4;
+	case resume_WHILEM5:
+	    goto resume_point_WHILEM5;
+	case resume_WHILEM6:
+	    goto resume_point_WHILEM6;
+	case resume_CURLYM1:
+	    goto resume_point_CURLYM1;
+	case resume_CURLYM2:
+	    goto resume_point_CURLYM2;
+	case resume_CURLYM3:
+	    goto resume_point_CURLYM3;
+	case resume_CURLYM4:
+	    goto resume_point_CURLYM4;
+	case resume_IFMATCH:
+	    goto resume_point_IFMATCH;
+	case resume_PLUS1:
+	    goto resume_point_PLUS1;
+	case resume_PLUS2:
+	    goto resume_point_PLUS2;
+	case resume_PLUS3:
+	    goto resume_point_PLUS3;
+	case resume_PLUS4:
+	    goto resume_point_PLUS4;
+	default:
+	    Perl_croak(aTHX_ "regexp resume memory corruption");
+	}
+    }
+    goto final_exit;
 
 no:
     DEBUG_EXECUTE_r(
@@ -4452,6 +4509,7 @@ do_no:
 		PL_regendp[n] = -1;
 	    *PL_reglastparen = n;
 	    scan = next = uwb->next;
+	    st->minmod = uwb->minmod;
 	    if ( !scan ||
 		 OP(scan) != (uwb->type == RE_UNWIND_BRANCH
 			      ? BRANCH : BRANCHJ) ) {		/* Failure */
@@ -4485,33 +4543,37 @@ do_no:
 	}
 	/* NOTREACHED */
     }
+
 #ifdef DEBUGGING
     PL_regindent--;
 #endif
     result = 0;
-exit_level:
-
-    if (depth--) {
-	/* restore previous state and re-enter */
-	st--;
-	if (st < &PL_regmatch_slab->states[0]) {
-	    PL_regmatch_slab = PL_regmatch_slab->prev;
-	    st = &PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1];
-	}
-	PL_regmatch_state = st;
-
-	PL_reg_call_cc	= st->reg_call_cc;
-	scan		= st->scan;
-	next		= st->next;
-	n		= st->n;
-	locinput	= st->locinput;
-	nextchr = UCHARAT(locinput);
 
+    if (depth) {
+	/* there's a previous state to backtrack to */
+	POP_STATE;
 	switch (st->resume_state) {
 	case resume_TRIE1:
 	    goto resume_point_TRIE1;
 	case resume_TRIE2:
 	    goto resume_point_TRIE2;
+	case resume_EVAL:
+	    /* we have failed an (??{...}). Restore state to the outer re
+	     * then re-throw the failure */
+	    if (st->u.eval.toggleutf)
+		PL_reg_flags ^= RF_utf8;
+	    ReREFCNT_dec(rex);
+	    rex = st->u.eval.prev_rex;
+	    cur_eval = st->u.eval.prev_eval;
+
+	    /* XXXX This is too dramatic a measure... */
+	    PL_reg_maxiter = 0;
+
+	    PL_reginput = locinput;
+	    REGCP_UNWIND(st->u.eval.lastcp);
+	    regcppop(rex);
+	    goto do_no;
+
 	case resume_CURLYX:
 	    goto resume_point_CURLYX;
 	case resume_WHILEM1:
@@ -4544,13 +4606,13 @@ exit_level:
 	    goto resume_point_PLUS3;
 	case resume_PLUS4:
 	    goto resume_point_PLUS4;
-	case resume_END:
-	    goto resume_point_END;
 	default:
 	    Perl_croak(aTHX_ "regexp resume memory corruption");
 	}
-	/* NOTREACHED */
     }
+
+final_exit:
+
     /* restore original high-water mark */
     PL_regmatch_slab  = orig_slab;
     PL_regmatch_state = orig_state;
@@ -4562,6 +4624,7 @@ exit_level:
 	while (sl) {
 	    osl = sl;
 	    sl = sl->next;
+	    Safefree(osl);
 	}
     }
 
@@ -4578,7 +4641,7 @@ exit_level:
  * rather than incrementing count on every character.  [Er, except utf8.]]
  */
 STATIC I32
-S_regrepeat(pTHX_ const regnode *p, I32 max)
+S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max)
 {
     dVAR;
     register char *scan;
@@ -4591,7 +4654,7 @@ S_regrepeat(pTHX_ const regnode *p, I32 max)
     if (max == REG_INFTY)
 	max = I32_MAX;
     else if (max < loceol - scan)
-      loceol = scan + max;
+	loceol = scan + max;
     switch (OP(p)) {
     case REG_ANY:
 	if (do_utf8) {
@@ -4641,12 +4704,12 @@ S_regrepeat(pTHX_ const regnode *p, I32 max)
 	if (do_utf8) {
 	    loceol = PL_regeol;
 	    while (hardcount < max && scan < loceol &&
-		   reginclass(p, (U8*)scan, 0, do_utf8)) {
+		   reginclass(prog, p, (U8*)scan, 0, do_utf8)) {
 		scan += UTF8SKIP(scan);
 		hardcount++;
 	    }
 	} else {
-	    while (scan < loceol && REGINCLASS(p, (U8*)scan))
+	    while (scan < loceol && REGINCLASS(prog, p, (U8*)scan))
 		scan++;
 	}
 	break;
@@ -4807,7 +4870,7 @@ S_regrepeat(pTHX_ const regnode *p, I32 max)
 		SV * const prop = sv_newmortal();
                 GET_RE_DEBUG_FLAGS;
                 DEBUG_EXECUTE_r({
-		regprop(prop, p);
+		regprop(prog, prop, p);
 		PerlIO_printf(Perl_debug_log,
 			      "%*s  %s can match %"IVdf" times out of %"IVdf"...\n",
 			      REPORT_CODE_OFF+1, "", SvPVX_const(prop),(IV)c,(IV)max);
@@ -4823,18 +4886,19 @@ S_regrepeat(pTHX_ const regnode *p, I32 max)
 */
 
 SV *
-Perl_regclass_swash(pTHX_ register const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
+Perl_regclass_swash(pTHX_ const regexp *prog, register const regnode* node, bool doinit, SV** listsvp, SV **altsvp)
 {
     dVAR;
     SV *sw  = NULL;
     SV *si  = NULL;
     SV *alt = NULL;
+    const struct reg_data *data = prog ? prog->data : NULL;
 
-    if (PL_regdata && PL_regdata->count) {
+    if (data && data->count) {
 	const U32 n = ARG(node);
 
-	if (PL_regdata->what[n] == 's') {
-	    SV * const rv = (SV*)PL_regdata->data[n];
+	if (data->what[n] == 's') {
+	    SV * const rv = (SV*)data->data[n];
 	    AV * const av = (AV*)SvRV((SV*)rv);
 	    SV **const ary = AvARRAY(av);
 	    SV **a, **b;
@@ -4876,7 +4940,7 @@ Perl_regclass_swash(pTHX_ register const regnode* node, bool doinit, SV** listsv
  */
 
 STATIC bool
-S_reginclass(pTHX_ register const regnode *n, register const U8* p, STRLEN* lenp, register bool do_utf8)
+S_reginclass(pTHX_ const regexp *prog, register const regnode *n, register const U8* p, STRLEN* lenp, register bool do_utf8)
 {
     dVAR;
     const char flags = ANYOF_FLAGS(n);
@@ -4905,7 +4969,7 @@ S_reginclass(pTHX_ register const regnode *n, register const U8* p, STRLEN* lenp
 	    match = TRUE;
 	if (!match) {
 	    AV *av;
-	    SV * const sw = regclass_swash(n, TRUE, 0, (SV**)&av);
+	    SV * const sw = regclass_swash(prog, n, TRUE, 0, (SV**)&av);
 	
 	    if (sw) {
 		if (swash_fetch(sw, p, do_utf8))
@@ -5058,15 +5122,15 @@ static void
 restore_pos(pTHX_ void *arg)
 {
     dVAR;
-    PERL_UNUSED_ARG(arg);
+    regexp * const rex = (regexp *)arg;
     if (PL_reg_eval_set) {
 	if (PL_reg_oldsaved) {
-	    PL_reg_re->subbeg = PL_reg_oldsaved;
-	    PL_reg_re->sublen = PL_reg_oldsavedlen;
+	    rex->subbeg = PL_reg_oldsaved;
+	    rex->sublen = PL_reg_oldsavedlen;
 #ifdef PERL_OLD_COPY_ON_WRITE
-	    PL_reg_re->saved_copy = PL_nrs;
+	    rex->saved_copy = PL_nrs;
 #endif
-	    RX_MATCH_COPIED_on(PL_reg_re);
+	    RX_MATCH_COPIED_on(rex);
 	}
 	PL_reg_magic->mg_len = PL_reg_oldpos;
 	PL_reg_eval_set = 0;
@@ -5078,8 +5142,8 @@ STATIC void
 S_to_utf8_substr(pTHX_ register regexp *prog)
 {
     if (prog->float_substr && !prog->float_utf8) {
-	SV* sv;
-	prog->float_utf8 = sv = newSVsv(prog->float_substr);
+	SV* const sv = newSVsv(prog->float_substr);
+	prog->float_utf8 = sv;
 	sv_utf8_upgrade(sv);
 	if (SvTAIL(prog->float_substr))
 	    SvTAIL_on(sv);
@@ -5087,8 +5151,8 @@ S_to_utf8_substr(pTHX_ register regexp *prog)
 	    prog->check_utf8 = sv;
     }
     if (prog->anchored_substr && !prog->anchored_utf8) {
-	SV* sv;
-	prog->anchored_utf8 = sv = newSVsv(prog->anchored_substr);
+	SV* const sv = newSVsv(prog->anchored_substr);
+	prog->anchored_utf8 = sv;
 	sv_utf8_upgrade(sv);
 	if (SvTAIL(prog->anchored_substr))
 	    SvTAIL_on(sv);
@@ -5102,8 +5166,8 @@ S_to_byte_substr(pTHX_ register regexp *prog)
 {
     dVAR;
     if (prog->float_utf8 && !prog->float_substr) {
-	SV* sv;
-	prog->float_substr = sv = newSVsv(prog->float_utf8);
+	SV* sv = newSVsv(prog->float_utf8);
+	prog->float_substr = sv;
 	if (sv_utf8_downgrade(sv, TRUE)) {
 	    if (SvTAIL(prog->float_utf8))
 		SvTAIL_on(sv);
@@ -5115,8 +5179,8 @@ S_to_byte_substr(pTHX_ register regexp *prog)
 	    prog->check_substr = sv;
     }
     if (prog->anchored_utf8 && !prog->anchored_substr) {
-	SV* sv;
-	prog->anchored_substr = sv = newSVsv(prog->anchored_utf8);
+	SV* sv = newSVsv(prog->anchored_utf8);
+	prog->anchored_substr = sv;
 	if (sv_utf8_downgrade(sv, TRUE)) {
 	    if (SvTAIL(prog->anchored_utf8))
 		SvTAIL_on(sv);