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

diff --git a/regexec.c b/regexec.c
index 6a7f064..34fd1ac 100644
--- a/regexec.c
+++ b/regexec.c
@@ -55,7 +55,6 @@
 #  define PERL_NO_GET_CONTEXT
 #endif
 
-/*SUPPRESS 112*/
 /*
  * pregcomp and pregexec -- regsub and regerror are not used in perl
  *
@@ -79,7 +78,7 @@
  ****    Alterations to Henry's code are...
  ****
  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- ****    2000, 2001, 2002, 2003, 2004, by Larry Wall and others
+ ****    2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
  ****
  ****    You may distribute under the terms of either the GNU General Public
  ****    License or the Artistic License, as specified in the README file.
@@ -98,7 +97,6 @@
 #define RF_warned	2		/* warned about big count? */
 #define RF_evaled	4		/* Did an EVAL with setting? */
 #define RF_utf8		8		/* String contains multibyte chars? */
-#define RF_false	16		/* odd number of nested negatives */
 
 #define UTF ((PL_reg_flags & RF_utf8) != 0)
 
@@ -109,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.
@@ -118,30 +116,27 @@
 #define CHR_SVLEN(sv) (do_utf8 ? sv_len_utf8(sv) : SvCUR(sv))
 #define CHR_DIST(a,b) (PL_reg_match_utf8 ? utf8_distance(a,b) : a - b)
 
-#define reghop_c(pos,off) ((char*)reghop((U8*)pos, off))
-#define reghopmaybe_c(pos,off) ((char*)reghopmaybe((U8*)pos, off))
-#define HOP(pos,off) (PL_reg_match_utf8 ? reghop((U8*)pos, off) : (U8*)(pos + off))
-#define HOPMAYBE(pos,off) (PL_reg_match_utf8 ? reghopmaybe((U8*)pos, off) : (U8*)(pos + off))
-#define HOPc(pos,off) ((char*)HOP(pos,off))
-#define HOPMAYBEc(pos,off) ((char*)HOPMAYBE(pos,off))
-
-#define HOPBACK(pos, off) (		\
-    (PL_reg_match_utf8)			\
-	? reghopmaybe((U8*)pos, -off)	\
+#define HOPc(pos,off) ((char *)(PL_reg_match_utf8 \
+	    ? reghop3((U8*)pos, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr)) \
+	    : (U8*)(pos + off)))
+#define HOPBACKc(pos, off) ((char*)	\
+    ((PL_reg_match_utf8)		\
+	? reghopmaybe3((U8*)pos, -off, ((U8*)(off < 0 ? PL_regeol : PL_bostr))) \
     : (pos - off >= PL_bostr)		\
 	? (U8*)(pos - off)		\
-    : (U8*)NULL				\
+    : (U8*)NULL)			\
 )
-#define HOPBACKc(pos, off) (char*)HOPBACK(pos, off)
 
-#define reghop3_c(pos,off,lim) ((char*)reghop3((U8*)pos, off, (U8*)lim))
 #define reghopmaybe3_c(pos,off,lim) ((char*)reghopmaybe3((U8*)pos, off, (U8*)lim))
 #define HOP3(pos,off,lim) (PL_reg_match_utf8 ? reghop3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
-#define HOPMAYBE3(pos,off,lim) (PL_reg_match_utf8 ? reghopmaybe3((U8*)pos, off, (U8*)lim) : (U8*)(pos + off))
 #define HOP3c(pos,off,lim) ((char*)HOP3(pos,off,lim))
-#define HOPMAYBE3c(pos,off,lim) ((char*)HOPMAYBE3(pos,off,lim))
 
-#define LOAD_UTF8_CHARCLASS(a,b) STMT_START { if (!CAT2(PL_utf8_,a)) { ENTER; save_re_context(); (void)CAT2(is_utf8_, a)((U8*)b); LEAVE; } } STMT_END
+#define LOAD_UTF8_CHARCLASS(class,str) STMT_START { \
+    if (!CAT2(PL_utf8_,class)) { bool ok; ENTER; save_re_context(); ok=CAT2(is_utf8_,class)((const U8*)str); assert(ok); LEAVE; } } STMT_END
+#define LOAD_UTF8_CHARCLASS_ALNUM() LOAD_UTF8_CHARCLASS(alnum,"a")
+#define LOAD_UTF8_CHARCLASS_DIGIT() LOAD_UTF8_CHARCLASS(digit,"0")
+#define LOAD_UTF8_CHARCLASS_SPACE() LOAD_UTF8_CHARCLASS(space," ")
+#define LOAD_UTF8_CHARCLASS_MARK()  LOAD_UTF8_CHARCLASS(mark, "\xcd\x86")
 
 /* for use after a quantifier and before an EXACT-like node -- japhy */
 #define JUMPABLE(rn) ( \
@@ -175,9 +170,10 @@ static void restore_pos(pTHX_ void *arg);
 STATIC CHECKPOINT
 S_regcppush(pTHX_ I32 parenfloor)
 {
-    int retval = PL_savestack_ix;
+    dVAR;
+    const int retval = PL_savestack_ix;
 #define REGCP_PAREN_ELEMS 4
-    int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
+    const int paren_elems_to_push = (PL_regsize - parenfloor) * REGCP_PAREN_ELEMS;
     int p;
 
     if (paren_elems_to_push < 0)
@@ -207,22 +203,23 @@ S_regcppush(pTHX_ I32 parenfloor)
 }
 
 /* These are needed since we do not localize EVAL nodes: */
-#  define REGCP_SET(cp)  DEBUG_r(PerlIO_printf(Perl_debug_log,		\
+#  define REGCP_SET(cp)  DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,		\
 			     "  Setting an EVAL scope, savestack=%"IVdf"\n",	\
 			     (IV)PL_savestack_ix)); cp = PL_savestack_ix
 
-#  define REGCP_UNWIND(cp)  DEBUG_r(cp != PL_savestack_ix ?		\
+#  define REGCP_UNWIND(cp)  DEBUG_EXECUTE_r(cp != PL_savestack_ix ?		\
 				PerlIO_printf(Perl_debug_log,		\
 				"  Clearing an EVAL scope, savestack=%"IVdf"..%"IVdf"\n", \
 				(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;
-    I32 tmps;
+
+    GET_RE_DEBUG_FLAGS_DECL;
 
     /* Pop REGCP_OTHER_ELEMS before the parentheses loop starts. */
     i = SSPOPINT;
@@ -236,13 +233,14 @@ S_regcppop(pTHX)
     /* Now restore the parentheses context. */
     for (i -= (REGCP_OTHER_ELEMS - REGCP_FRAME_ELEMS);
 	 i > 0; i -= REGCP_PAREN_ELEMS) {
-	paren = (U32)SSPOPINT;
+	I32 tmps;
+	U32 paren = (U32)SSPOPINT;
 	PL_reg_start_tmp[paren] = (char *) SSPOPPTR;
 	PL_regstartp[paren] = SSPOPINT;
 	tmps = SSPOPINT;
 	if (paren <= *PL_reglastparen)
 	    PL_regendp[paren] = tmps;
-	DEBUG_r(
+	DEBUG_EXECUTE_r(
 	    PerlIO_printf(Perl_debug_log,
 			  "     restoring \\%"UVuf" to %"IVdf"(%"IVdf")..%"IVdf"%s\n",
 			  (UV)paren, (IV)PL_regstartp[paren],
@@ -251,11 +249,11 @@ S_regcppop(pTHX)
 			  (paren > *PL_reglastparen ? "(no)" : ""));
 	);
     }
-    DEBUG_r(
-	if ((I32)(*PL_reglastparen + 1) <= PL_regnpar) {
+    DEBUG_EXECUTE_r(
+	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
@@ -269,38 +267,18 @@ 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;
 }
 
-STATIC char *
-S_regcp_set_to(pTHX_ I32 ss)
-{
-    I32 tmp = PL_savestack_ix;
-
-    PL_savestack_ix = ss;
-    regcppop();
-    PL_savestack_ix = tmp;
-    return Nullch;
-}
-
-typedef struct re_cc_state
-{
-    I32 ss;
-    regnode *node;
-    struct re_cc_state *prev;
-    CURCUR *cc;
-    regexp *re;
-} re_cc_state;
-
 #define regcpblow(cp) LEAVE_SCOPE(cp)	/* Ignores regcppush()ed data. */
 
-#define TRYPAREN(paren, n, input) {				\
+#define TRYPAREN(paren, n, input, where) {			\
     if (paren) {						\
 	if (n) {						\
 	    PL_regstartp[paren] = HOPc(input, -1) - PL_bostr;	\
@@ -309,7 +287,8 @@ typedef struct re_cc_state
 	else							\
 	    PL_regendp[paren] = -1;				\
     }								\
-    if (regmatch(next))						\
+    REGMATCH(next, where);					\
+    if (result)							\
 	sayYES;							\
     if (paren && n)						\
 	PL_regendp[paren] = -1;					\
@@ -336,17 +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)
-{
-    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:
@@ -364,7 +332,7 @@ S_cache_re(pTHX_ regexp *prog)
 
 /* Assumptions: if ANCH_GPOS, then strpos is anchored. XXXX Check GPOS logic */
 
-/* If SCREAM, then SvPVX(sv) should be compatible with strpos and strend.
+/* If SCREAM, then SvPVX_const(sv) should be compatible with strpos and strend.
    Otherwise, only SvCUR(sv) is used to get strbeg. */
 
 /* XXXX We assume that strpos is strbeg unless sv. */
@@ -398,6 +366,7 @@ char *
 Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		     char *strend, U32 flags, re_scream_pos_data *data)
 {
+    dVAR;
     register I32 start_shift = 0;
     /* Should be nonnegative! */
     register I32 end_shift   = 0;
@@ -405,37 +374,40 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
     register SV *check;
     char *strbeg;
     char *t;
-    int do_utf8 = sv ? SvUTF8(sv) : 0;	/* if no sv we have to assume bytes */
+    const int do_utf8 = sv ? SvUTF8(sv) : 0;	/* if no sv we have to assume bytes */
     I32 ml_anch;
-    register char *other_last = Nullch;	/* other substr checked before this */
-    char *check_at = Nullch;		/* check substr found at this pos */
-    I32 multiline = prog->reganch & PMf_MULTILINE;
+    register char *other_last = NULL;	/* other substr checked before this */
+    char *check_at = NULL;		/* check substr found at this pos */
+    const I32 multiline = prog->reganch & PMf_MULTILINE;
 #ifdef DEBUGGING
-    char *i_strpos = strpos;
-    SV *dsv = PERL_DEBUG_PAD_ZERO(0);
+    const char * const i_strpos = strpos;
+    SV * const dsv = PERL_DEBUG_PAD_ZERO(0);
 #endif
+
+    GET_RE_DEBUG_FLAGS_DECL;
+
     RX_MATCH_UTF8_set(prog,do_utf8);
 
     if (prog->reganch & ROPT_UTF8) {
-	DEBUG_r(PerlIO_printf(Perl_debug_log,
+	DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 			      "UTF-8 regex...\n"));
 	PL_reg_flags |= RF_utf8;
     }
 
-    DEBUG_r({
-	 char *s   = PL_reg_match_utf8 ?
+    DEBUG_EXECUTE_r({
+	 const char *s   = PL_reg_match_utf8 ?
 	                 sv_uni_display(dsv, sv, 60, UNI_DISPLAY_REGEX) :
 	                 strpos;
-	 int   len = PL_reg_match_utf8 ?
+	 const int   len = PL_reg_match_utf8 ?
 	                 strlen(s) : strend - strpos;
 	 if (!PL_colorset)
 	      reginitcolors();
 	 if (PL_reg_match_utf8)
-	     DEBUG_r(PerlIO_printf(Perl_debug_log,
+	     DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 				   "UTF-8 target...\n"));
 	 PerlIO_printf(Perl_debug_log,
-		       "%sGuessing start of match, REx%s `%s%.60s%s%s' against `%s%.*s%s%s'...\n",
-		       PL_colors[4],PL_colors[5],PL_colors[0],
+		       "%sGuessing start of match, REx%s \"%s%.60s%s%s\" against \"%s%.*s%s%s\"...\n",
+		       PL_colors[4], PL_colors[5], PL_colors[0],
 		       prog->precomp,
 		       PL_colors[1],
 		       (strlen(prog->precomp) > 60 ? "..." : ""),
@@ -448,7 +420,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 
     /* CHR_DIST() would be more correct here but it makes things slow. */
     if (prog->minlen > strend - strpos) {
-	DEBUG_r(PerlIO_printf(Perl_debug_log,
+	DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 			      "String too short... [re_intuit_start]\n"));
 	goto fail;
     }
@@ -464,7 +436,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	check = prog->check_substr;
     }
    if (check == &PL_sv_undef) {
-	DEBUG_r(PerlIO_printf(Perl_debug_log,
+	DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 		"Non-utf string cannot match utf check string\n"));
 	goto fail;
     }
@@ -476,10 +448,10 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	if (!ml_anch) {
 	  if ( !(prog->reganch & (ROPT_ANCH_GPOS /* Checked by the caller */
 				  | ROPT_IMPLICIT)) /* not a real BOL */
-	       /* SvCUR is not set on references: SvRV and SvPVX overlap */
+	       /* SvCUR is not set on references: SvRV and SvPVX_const overlap */
 	       && sv && !SvROK(sv)
 	       && (strpos != strbeg)) {
-	      DEBUG_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
+	      DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not at start...\n"));
 	      goto fail;
 	  }
 	  if (prog->check_offset_min == prog->check_offset_max &&
@@ -493,23 +465,24 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 
 		if ( strend - s > slen || strend - s < slen - 1
 		     || (strend - s == slen && strend[-1] != '\n')) {
-		    DEBUG_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
+		    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String too long...\n"));
 		    goto fail_finish;
 		}
 		/* Now should match s[0..slen-2] */
 		slen--;
-		if (slen && (*SvPVX(check) != *s
+		if (slen && (*SvPVX_const(check) != *s
 			     || (slen > 1
-				 && memNE(SvPVX(check), s, slen)))) {
+				 && memNE(SvPVX_const(check), s, slen)))) {
 		  report_neq:
-		    DEBUG_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
+		    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "String not equal...\n"));
 		    goto fail_finish;
 		}
 	    }
-	    else if (*SvPVX(check) != *s
+	    else if (*SvPVX_const(check) != *s
 		     || ((slen = SvCUR(check)) > 1
-			 && memNE(SvPVX(check), s, slen)))
+			 && memNE(SvPVX_const(check), s, slen)))
 		goto report_neq;
+	    check_at = s;
 	    goto success_at_start;
 	  }
 	}
@@ -519,9 +492,9 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	end_shift = prog->minlen - start_shift -
 	    CHR_SVLEN(check) + (SvTAIL(check) != 0);
 	if (!ml_anch) {
-	    I32 end = prog->check_offset_max + CHR_SVLEN(check)
+	    const I32 end = prog->check_offset_max + CHR_SVLEN(check)
 					 - (SvTAIL(check) != 0);
-	    I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
+	    const I32 eshift = CHR_DIST((U8*)strend, (U8*)s) - end;
 
 	    if (end_shift < eshift)
 		end_shift = eshift;
@@ -546,7 +519,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
        the "check" substring in the region corrected by start/end_shift. */
     if (flags & REXEC_SCREAM) {
 	I32 p = -1;			/* Internal iterator of scream. */
-	I32 *pp = data ? data->scream_pos : &p;
+	I32 * const pp = data ? data->scream_pos : &p;
 
 	if (PL_screamfirst[BmRARE(check)] >= 0
 	    || ( BmRARE(check) == '\n'
@@ -558,7 +531,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	    goto fail_finish;
 	/* we may be pointing at the wrong string */
 	if (s && RX_MATCH_COPIED(prog))
-	    s = strbeg + (s - SvPVX(sv));
+	    s = strbeg + (s - SvPVX_const(sv));
 	if (data)
 	    *data->scream_olds = s;
     }
@@ -574,12 +547,12 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
     /* Update the count-of-usability, remove useless subpatterns,
 	unshift s.  */
 
-    DEBUG_r(PerlIO_printf(Perl_debug_log, "%s %s substr `%s%.*s%s'%s%s",
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s %s substr \"%s%.*s%s\"%s%s",
 			  (s ? "Found" : "Did not find"),
 			  (check == (do_utf8 ? prog->anchored_utf8 : prog->anchored_substr) ? "anchored" : "floating"),
 			  PL_colors[0],
 			  (int)(SvCUR(check) - (SvTAIL(check)!=0)),
-			  SvPVX(check),
+			  SvPVX_const(check),
 			  PL_colors[1], (SvTAIL(check) ? "$" : ""),
 			  (s ? " at offset " : "...\n") ) );
 
@@ -589,12 +562,12 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
     check_at = s;
 
     /* Finish the diagnostic message */
-    DEBUG_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%ld...\n", (long)(s - i_strpos)) );
 
     /* Got a candidate.  Check MBOL anchoring, and the *other* substr.
        Start with the other substr.
        XXXX no SCREAM optimization yet - and a very coarse implementation
-       XXXX /ttx+/ results in anchored=`ttx', floating=`x'.  floating will
+       XXXX /ttx+/ results in anchored="ttx", floating="x".  floating will
 		*always* match.  Probably should be marked during compile...
        Probably it is right to do no SCREAM here...
      */
@@ -607,7 +580,8 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	if (check == (do_utf8 ? prog->float_utf8 : prog->float_substr)) {
 	  do_other_anchored:
 	    {
-		char *last = HOP3c(s, -start_shift, strbeg), *last1, *last2;
+		char * const last = HOP3c(s, -start_shift, strbeg);
+		char *last1, *last2;
 		char *s1 = s;
 		SV* must;
 
@@ -630,7 +604,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		must = do_utf8 ? prog->anchored_utf8 : prog->anchored_substr;
 		if (must == &PL_sv_undef) {
 		    s = (char*)NULL;
-		    DEBUG_r(must = prog->anchored_utf8);	/* for debug */
+		    DEBUG_EXECUTE_r(must = prog->anchored_utf8);	/* for debug */
 		}
 		else
 		    s = fbm_instr(
@@ -640,21 +614,21 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 			must,
 			multiline ? FBMrf_MULTILINE : 0
 		    );
-		DEBUG_r(PerlIO_printf(Perl_debug_log,
-			"%s anchored substr `%s%.*s%s'%s",
+		DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
+			"%s anchored substr \"%s%.*s%s\"%s",
 			(s ? "Found" : "Contradicts"),
 			PL_colors[0],
 			  (int)(SvCUR(must)
 			  - (SvTAIL(must)!=0)),
-			  SvPVX(must),
+			  SvPVX_const(must),
 			  PL_colors[1], (SvTAIL(must) ? "$" : "")));
 		if (!s) {
 		    if (last1 >= last2) {
-			DEBUG_r(PerlIO_printf(Perl_debug_log,
+			DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 						", giving up...\n"));
 			goto fail_finish;
 		    }
-		    DEBUG_r(PerlIO_printf(Perl_debug_log,
+		    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 			", trying floating at offset %ld...\n",
 			(long)(HOP3c(s1, 1, strend) - i_strpos)));
 		    other_last = HOP3c(last1, prog->anchored_offset+1, strend);
@@ -662,7 +636,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		    goto restart;
 		}
 		else {
-		    DEBUG_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
+		    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
 			  (long)(s - i_strpos)));
 		    t = HOP3c(s, -prog->anchored_offset, strbeg);
 		    other_last = HOP3c(s, 1, strend);
@@ -693,26 +667,26 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	       and end-of-str is not later than strend we are OK. */
 	    if (must == &PL_sv_undef) {
 		s = (char*)NULL;
-		DEBUG_r(must = prog->float_utf8);	/* for debug message */
+		DEBUG_EXECUTE_r(must = prog->float_utf8);	/* for debug message */
 	    }
 	    else
 		s = fbm_instr((unsigned char*)s,
 			      (unsigned char*)last + SvCUR(must)
 				  - (SvTAIL(must)!=0),
 			      must, multiline ? FBMrf_MULTILINE : 0);
-	    DEBUG_r(PerlIO_printf(Perl_debug_log, "%s floating substr `%s%.*s%s'%s",
+	    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s floating substr \"%s%.*s%s\"%s",
 		    (s ? "Found" : "Contradicts"),
 		    PL_colors[0],
 		      (int)(SvCUR(must) - (SvTAIL(must)!=0)),
-		      SvPVX(must),
+		      SvPVX_const(must),
 		      PL_colors[1], (SvTAIL(must) ? "$" : "")));
 	    if (!s) {
 		if (last1 == last) {
-		    DEBUG_r(PerlIO_printf(Perl_debug_log,
+		    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 					    ", giving up...\n"));
 		    goto fail_finish;
 		}
-		DEBUG_r(PerlIO_printf(Perl_debug_log,
+		DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 		    ", trying anchored starting at offset %ld...\n",
 		    (long)(s1 + 1 - i_strpos)));
 		other_last = last;
@@ -720,7 +694,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		goto restart;
 	    }
 	    else {
-		DEBUG_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
+		DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, " at offset %ld...\n",
 		      (long)(s - i_strpos)));
 		other_last = s; /* Fix this later. --Hugo */
 		s = s1;
@@ -759,34 +733,34 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 			       is float.  Redo checking for "other"=="fixed".
 			     */
 			    strpos = t + 1;			
-			    DEBUG_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
-				PL_colors[0],PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
+			    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld, rescanning for anchored from offset %ld...\n",
+				PL_colors[0], PL_colors[1], (long)(strpos - i_strpos), (long)(strpos - i_strpos + prog->anchored_offset)));
 			    goto do_other_anchored;
 			}
 			/* We don't contradict the found floating substring. */
 			/* XXXX Why not check for STCLASS? */
 			s = t + 1;
-			DEBUG_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
-			    PL_colors[0],PL_colors[1], (long)(s - i_strpos)));
+			DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m at offset %ld...\n",
+			    PL_colors[0], PL_colors[1], (long)(s - i_strpos)));
 			goto set_useful;
 		    }
 		    /* Position contradicts check-string */
 		    /* XXXX probably better to look for check-string
 		       than for "\n", so one should lower the limit for t? */
-		    DEBUG_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
-			PL_colors[0],PL_colors[1], (long)(t + 1 - i_strpos)));
+		    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Found /%s^%s/m, restarting lookup for check-string at offset %ld...\n",
+			PL_colors[0], PL_colors[1], (long)(t + 1 - i_strpos)));
 		    other_last = strpos = s = t + 1;
 		    goto restart;
 		}
 		t++;
 	    }
-	    DEBUG_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
-			PL_colors[0],PL_colors[1]));
+	    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Did not find /%s^%s/m...\n",
+			PL_colors[0], PL_colors[1]));
 	    goto fail_finish;
 	}
 	else {
-	    DEBUG_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
-			PL_colors[0],PL_colors[1]));
+	    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Starting position does not contradict /%s^%s/m...\n",
+			PL_colors[0], PL_colors[1]));
 	}
 	s = t;
       set_useful:
@@ -808,9 +782,9 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	    t = strpos;
 	    goto find_anchor;
 	}
-	DEBUG_r( if (ml_anch)
+	DEBUG_EXECUTE_r( if (ml_anch)
 	    PerlIO_printf(Perl_debug_log, "Position at offset %ld does not contradict /%s^%s/m...\n",
-			(long)(strpos - i_strpos), PL_colors[0],PL_colors[1]);
+			(long)(strpos - i_strpos), PL_colors[0], PL_colors[1]);
 	);
       success_at_start:
 	if (!(prog->reganch & ROPT_NAUGHTY)	/* XXXX If strpos moved? */
@@ -825,13 +799,13 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	    )))
 	{
 	    /* If flags & SOMETHING - do not do it many times on the same match */
-	    DEBUG_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
+	    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "... Disabling check substring...\n"));
 	    SvREFCNT_dec(do_utf8 ? prog->check_utf8 : prog->check_substr);
 	    if (do_utf8 ? prog->check_substr : prog->check_utf8)
 		SvREFCNT_dec(do_utf8 ? prog->check_substr : prog->check_utf8);
-	    prog->check_substr = prog->check_utf8 = Nullsv;	/* disable */
-	    prog->float_substr = prog->float_utf8 = Nullsv;	/* clear */
-	    check = Nullsv;			/* abort */
+	    prog->check_substr = prog->check_utf8 = NULL;	/* disable */
+	    prog->float_substr = prog->float_utf8 = NULL;	/* clear */
+	    check = NULL;			/* abort */
 	    s = strpos;
 	    /* XXXX This is a remnant of the old implementation.  It
 	            looks wasteful, since now INTUIT can use many
@@ -853,49 +827,47 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	   regstclass does not come from lookahead...  */
 	/* If regstclass takes bytelength more than 1: If charlength==1, OK.
 	   This leaves EXACTF only, which is dealt with in find_byclass().  */
-	U8* str = (U8*)STRING(prog->regstclass);
-	int cl_l = (PL_regkind[(U8)OP(prog->regstclass)] == EXACT
+        const U8* const str = (U8*)STRING(prog->regstclass);
+        const int cl_l = (PL_regkind[(U8)OP(prog->regstclass)] == EXACT
 		    ? CHR_DIST(str+STR_LEN(prog->regstclass), str)
 		    : 1);
-	char *endpos = (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
+	const char * const endpos = (prog->anchored_substr || prog->anchored_utf8 || ml_anch)
 		? HOP3c(s, (prog->minlen ? cl_l : 0), strend)
 		: (prog->float_substr || prog->float_utf8
 		   ? HOP3c(HOP3c(check_at, -start_shift, strbeg),
 			   cl_l, strend)
 		   : strend);
-	char *startpos = strbeg;
 
 	t = s;
-	cache_re(prog);
-	s = find_byclass(prog, prog->regstclass, s, endpos, startpos, 1);
+        s = find_byclass(prog, prog->regstclass, s, endpos, NULL);
 	if (!s) {
 #ifdef DEBUGGING
-	    char *what = 0;
+	    const char *what = NULL;
 #endif
 	    if (endpos == strend) {
-		DEBUG_r( PerlIO_printf(Perl_debug_log,
+		DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
 				"Could not match STCLASS...\n") );
 		goto fail;
 	    }
-	    DEBUG_r( PerlIO_printf(Perl_debug_log,
+	    DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
 				   "This position contradicts STCLASS...\n") );
 	    if ((prog->reganch & ROPT_ANCH) && !ml_anch)
 		goto fail;
 	    /* Contradict one of substrings */
 	    if (prog->anchored_substr || prog->anchored_utf8) {
 		if ((do_utf8 ? prog->anchored_utf8 : prog->anchored_substr) == check) {
-		    DEBUG_r( what = "anchored" );
+		    DEBUG_EXECUTE_r( what = "anchored" );
 		  hop_and_restart:
 		    s = HOP3c(t, 1, strend);
 		    if (s + start_shift + end_shift > strend) {
 			/* XXXX Should be taken into account earlier? */
-			DEBUG_r( PerlIO_printf(Perl_debug_log,
+			DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
 					       "Could not match STCLASS...\n") );
 			goto fail;
 		    }
 		    if (!check)
 			goto giveup;
-		    DEBUG_r( PerlIO_printf(Perl_debug_log,
+		    DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
 				"Looking for %s substr starting at offset %ld...\n",
 				 what, (long)(s + start_shift - i_strpos)) );
 		    goto restart;
@@ -907,7 +879,7 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		s = check_at;
 		if (!check)
 		    goto giveup;
-		DEBUG_r( PerlIO_printf(Perl_debug_log,
+		DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
 			  "Looking for anchored substr starting at offset %ld...\n",
 			  (long)(other_last - i_strpos)) );
 		goto do_other_anchored;
@@ -918,9 +890,9 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 		s = t = t + 1;
 		if (!check)
 		    goto giveup;
-		DEBUG_r( PerlIO_printf(Perl_debug_log,
+		DEBUG_EXECUTE_r( PerlIO_printf(Perl_debug_log,
 			  "Looking for /%s^%s/m starting at offset %ld...\n",
-			  PL_colors[0],PL_colors[1], (long)(t - i_strpos)) );
+			  PL_colors[0], PL_colors[1], (long)(t - i_strpos)) );
 		goto try_at_offset;
 	    }
 	    if (!(do_utf8 ? prog->float_utf8 : prog->float_substr))	/* Could have been deleted */
@@ -928,23 +900,23 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
 	    /* Check is floating subtring. */
 	  retry_floating_check:
 	    t = check_at - start_shift;
-	    DEBUG_r( what = "floating" );
+	    DEBUG_EXECUTE_r( what = "floating" );
 	    goto hop_and_restart;
 	}
 	if (t != s) {
-            DEBUG_r(PerlIO_printf(Perl_debug_log,
+            DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 			"By STCLASS: moving %ld --> %ld\n",
                                   (long)(t - i_strpos), (long)(s - i_strpos))
                    );
         }
         else {
-            DEBUG_r(PerlIO_printf(Perl_debug_log,
+            DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
                                   "Does not contradict STCLASS...\n"); 
                    );
         }
     }
   giveup:
-    DEBUG_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%s%s:%s match at offset %ld\n",
 			  PL_colors[4], (check ? "Guessed" : "Giving up"),
 			  PL_colors[5], (long)(s - i_strpos)) );
     return s;
@@ -953,16 +925,20 @@ Perl_re_intuit_start(pTHX_ regexp *prog, SV *sv, char *strpos,
     if (prog->check_substr || prog->check_utf8)		/* could be removed already */
 	BmUSEFUL(do_utf8 ? prog->check_utf8 : prog->check_substr) += 5; /* hooray */
   fail:
-    DEBUG_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
-			  PL_colors[4],PL_colors[5]));
-    return Nullch;
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch rejected by optimizer%s\n",
+			  PL_colors[4], PL_colors[5]));
+    return NULL;
 }
 
 /* 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, char *strend, char *startpos, I32 norun)
+S_find_byclass(pTHX_ regexp * prog, const regnode *c, char *s, const char
+*strend, const regmatch_info *reginfo)
 {
-	I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
+	dVAR;
+	const I32 doevery = (prog->reganch & ROPT_SKIP) == 0;
 	char *m;
 	STRLEN ln;
 	STRLEN lnc;
@@ -971,7 +947,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	unsigned int c2;
 	char *e;
 	register I32 tmp = 1;	/* Scratch variable? */
-	register bool do_utf8 = PL_reg_match_utf8;
+	register const bool do_utf8 = PL_reg_match_utf8;
 
 	/* We know what class it must start with. */
 	switch (OP(c)) {
@@ -980,9 +956,9 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		 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;
@@ -996,12 +972,12 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		 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;
@@ -1014,7 +990,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    break;
 	case CANY:
 	    while (s < strend) {
-	        if (tmp && (norun || regtry(prog, s)))
+	        if (tmp && (!reginfo || regtry(reginfo, s)))
 		    goto got_it;
 		else
 		    tmp = doevery;
@@ -1028,16 +1004,17 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    if (UTF) {
 	        STRLEN ulen1, ulen2;
 		U8 *sm = (U8 *) m;
-		U8 tmpbuf1[UTF8_MAXLEN_UCLC+1];
-		U8 tmpbuf2[UTF8_MAXLEN_UCLC+1];
+		U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
+		U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
+		const U32 uniflags = UTF8_ALLOW_DEFAULT;
 
 		to_utf8_lower((U8*)m, tmpbuf1, &ulen1);
 		to_utf8_upper((U8*)m, tmpbuf2, &ulen2);
 
-		c1 = utf8n_to_uvchr(tmpbuf1, UTF8_MAXLEN_UCLC, 
-				    0, ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY);
-		c2 = utf8n_to_uvchr(tmpbuf2, UTF8_MAXLEN_UCLC,
-				    0, ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY);
+		c1 = utf8n_to_uvchr(tmpbuf1, UTF8_MAXBYTES_CASE, 
+				    0, uniflags);
+		c2 = utf8n_to_uvchr(tmpbuf2, UTF8_MAXBYTES_CASE,
+				    0, uniflags);
 		lnc = 0;
 		while (sm < ((U8 *) m + ln)) {
 		    lnc++;
@@ -1058,7 +1035,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	  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
@@ -1074,24 +1051,23 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 
 	    if (do_utf8) {
 	        UV c, f;
-	        U8 tmpbuf [UTF8_MAXLEN+1];
-		U8 foldbuf[UTF8_MAXLEN_FOLD+1];
+	        U8 tmpbuf [UTF8_MAXBYTES+1];
 		STRLEN len, foldlen;
-		
+		const U32 uniflags = UTF8_ALLOW_DEFAULT;
 		if (c1 == c2) {
 		    /* Upper and lower of 1st char are equal -
 		     * probably not a "letter". */
 		    while (s <= e) {
-		        c = utf8n_to_uvchr((U8*)s, UTF8_MAXLEN, &len,
-					   ckWARN(WARN_UTF8) ?
-					   0 : UTF8_ALLOW_ANY);
+		        c = utf8n_to_uvchr((U8*)s, UTF8_MAXBYTES, &len,
+					   uniflags);
 			if ( c == c1
 			     && (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];
 			     uvchr_to_utf8(tmpbuf, c);
 			     f = to_utf8_fold(tmpbuf, foldbuf, &foldlen);
 			     if ( f != c
@@ -1101,7 +1077,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 						  (char **)0, foldlen, do_utf8,
 						  m,
 						  (char **)0, ln, (bool)UTF))
-				  && (norun || regtry(prog, s)) )
+				  && (!reginfo || regtry(reginfo, s)) )
 				  goto got_it;
 			}
 			s += len;
@@ -1109,9 +1085,8 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		}
 		else {
 		    while (s <= e) {
-		      c = utf8n_to_uvchr((U8*)s, UTF8_MAXLEN, &len,
-					   ckWARN(WARN_UTF8) ?
-					   0 : UTF8_ALLOW_ANY);
+		      c = utf8n_to_uvchr((U8*)s, UTF8_MAXBYTES, &len,
+					   uniflags);
 
 			/* Handle some of the three Greek sigmas cases.
 			 * Note that not all the possible combinations
@@ -1128,9 +1103,10 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 			     && (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];
 			     uvchr_to_utf8(tmpbuf, c);
 			     f = to_utf8_fold(tmpbuf, foldbuf, &foldlen);
 			     if ( f != c
@@ -1140,7 +1116,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 						  (char **)0, foldlen, do_utf8,
 						  m,
 						  (char **)0, ln, (bool)UTF))
-				  && (norun || regtry(prog, s)) )
+				  && (!reginfo || regtry(reginfo, s)) )
 				  goto got_it;
 			}
 			s += len;
@@ -1154,7 +1130,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 			     && (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++;
 		    }
@@ -1164,7 +1140,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 			     && (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++;
 		    }
@@ -1178,20 +1154,19 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		if (s == PL_bostr)
 		    tmp = '\n';
 		else {
-		    U8 *r = reghop3((U8*)s, -1, (U8*)PL_bostr);
-		
-		    tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
+		    U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);
+		    tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);
 		}
 		tmp = ((OP(c) == BOUND ?
 			isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
-		LOAD_UTF8_CHARCLASS(alnum,"a");
+		LOAD_UTF8_CHARCLASS_ALNUM();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (tmp == !(OP(c) == BOUND ?
 				 swash_fetch(PL_utf8_alnum, (U8*)s, do_utf8) :
 				 isALNUM_LC_utf8((U8*)s)))
 		    {
 			tmp = !tmp;
-			if ((norun || regtry(prog, s)))
+			if ((!reginfo || regtry(reginfo, s)))
 			    goto got_it;
 		    }
 		    s += uskip;
@@ -1204,13 +1179,13 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		    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:
@@ -1221,19 +1196,18 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		if (s == PL_bostr)
 		    tmp = '\n';
 		else {
-		    U8 *r = reghop3((U8*)s, -1, (U8*)PL_bostr);
-		
-		    tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
+		    U8 * const r = reghop3((U8*)s, -1, (U8*)PL_bostr);
+		    tmp = utf8n_to_uvchr(r, UTF8SKIP(r), 0, UTF8_ALLOW_DEFAULT);
 		}
 		tmp = ((OP(c) == NBOUND ?
 			isALNUM_uni(tmp) : isALNUM_LC_uvchr(UNI_TO_NATIVE(tmp))) != 0);
-		LOAD_UTF8_CHARCLASS(alnum,"a");
+		LOAD_UTF8_CHARCLASS_ALNUM();
 		while (s + (uskip = UTF8SKIP(s)) <= strend) {
 		    if (tmp == !(OP(c) == NBOUND ?
 				 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;
 		}
@@ -1246,20 +1220,20 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 		    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:
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(alnum,"a");
+		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;
@@ -1272,7 +1246,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1288,7 +1262,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1301,7 +1275,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1314,10 +1288,10 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    break;
 	case NALNUM:
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(alnum,"a");
+		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;
@@ -1330,7 +1304,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1346,7 +1320,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1359,7 +1333,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1372,10 +1346,10 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    break;
 	case SPACE:
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(space," ");
+		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;
@@ -1388,7 +1362,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1404,7 +1378,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1417,7 +1391,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1430,10 +1404,10 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    break;
 	case NSPACE:
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(space," ");
+		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;
@@ -1446,7 +1420,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1462,7 +1436,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1475,7 +1449,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1488,10 +1462,10 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    break;
 	case DIGIT:
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(digit,"0");
+		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;
@@ -1504,7 +1478,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1520,7 +1494,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1533,7 +1507,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1546,10 +1520,10 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    break;
 	case NDIGIT:
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(digit,"0");
+		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;
@@ -1562,7 +1536,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1578,7 +1552,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1591,7 +1565,7 @@ S_find_byclass(pTHX_ regexp * prog, regnode *c, char *s, char *strend, char *sta
 	    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;
@@ -1623,31 +1597,27 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 /* data: May be used for some additional optimizations. */
 /* nosave: For optimizations. */
 {
+    dVAR;
     register char *s;
     register regnode *c;
     register char *startpos = stringarg;
     I32 minlen;		/* must match at least this many chars */
     I32 dontbother = 0;	/* how many characters not to try at end */
-    /* I32 start_shift = 0; */		/* Offset of the start to find
-					 constant substr. */		/* CC */
     I32 end_shift = 0;			/* Same for the end. */		/* CC */
     I32 scream_pos = -1;		/* Internal iterator of scream. */
-    char *scream_olds;
+    char *scream_olds = NULL;
     SV* oreplsv = GvSV(PL_replgv);
-    bool do_utf8 = DO_UTF8(sv);
-    I32 multiline = prog->reganch & PMf_MULTILINE;
+    const bool do_utf8 = DO_UTF8(sv);
+    I32 multiline;
 #ifdef DEBUGGING
-    SV *dsv0 = PERL_DEBUG_PAD_ZERO(0);
-    SV *dsv1 = PERL_DEBUG_PAD_ZERO(1);
+    SV* dsv0;
+    SV* dsv1;
 #endif
-    RX_MATCH_UTF8_set(prog,do_utf8);
+    regmatch_info reginfo;  /* create some info to pass to regtry etc */
 
-    PL_regcc = 0;
+    GET_RE_DEBUG_FLAGS_DECL;
 
-    cache_re(prog);
-#ifdef DEBUGGING
-    PL_regnarrate = DEBUG_r_TEST;
-#endif
+    PERL_UNUSED_ARG(data);
 
     /* Be paranoid... */
     if (prog == NULL || startpos == NULL) {
@@ -1655,9 +1625,19 @@ 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_r(PerlIO_printf(Perl_debug_log,
+        DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 			      "String too short [regexec_flags]...\n"));
 	goto phooey;
     }
@@ -1675,68 +1655,65 @@ 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 != Nullsv || prog->check_utf8 != Nullsv)) {
+    if (!(flags & REXEC_CHECKED) && (prog->check_substr != NULL || prog->check_utf8 != NULL)) {
 	re_scream_pos_data d;
 
 	d.scream_olds = &scream_olds;
 	d.scream_pos = &scream_pos;
 	s = re_intuit_start(prog, sv, s, strend, flags, &d);
 	if (!s) {
-	    DEBUG_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
+	    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Not present...\n"));
 	    goto phooey;	/* not present */
 	}
     }
 
-    DEBUG_r({
-	 char *s0   = UTF ?
-	   pv_uni_display(dsv0, (U8*)prog->precomp, prog->prelen, 60,
-			  UNI_DISPLAY_REGEX) :
-	   prog->precomp;
-	 int   len0 = UTF ? SvCUR(dsv0) : prog->prelen;
-	 char *s1   = do_utf8 ? sv_uni_display(dsv1, sv, 60,
+    DEBUG_EXECUTE_r({
+	const char * const s0   = UTF
+	    ? pv_uni_display(dsv0, (U8*)prog->precomp, prog->prelen, 60,
+			  UNI_DISPLAY_REGEX)
+	    : prog->precomp;
+	const int len0 = UTF ? SvCUR(dsv0) : prog->prelen;
+	const char * const s1 = do_utf8 ? sv_uni_display(dsv1, sv, 60,
 					       UNI_DISPLAY_REGEX) : startpos;
-	 int   len1 = do_utf8 ? SvCUR(dsv1) : strend - startpos;
+	const int len1 = do_utf8 ? SvCUR(dsv1) : strend - startpos;
 	 if (!PL_colorset)
 	     reginitcolors();
 	 PerlIO_printf(Perl_debug_log,
-		       "%sMatching REx%s `%s%*.*s%s%s' against `%s%.*s%s%s'\n",
-		       PL_colors[4],PL_colors[5],PL_colors[0],
+		       "%sMatching REx%s \"%s%*.*s%s%s\" against \"%s%.*s%s%s\"\n",
+		       PL_colors[4], PL_colors[5], PL_colors[0],
 		       len0, len0, s0,
 		       PL_colors[1],
 		       len0 > 60 ? "..." : "",
@@ -1750,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? */
@@ -1765,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)
@@ -1783,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;
 		    }
 		}		
@@ -1791,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;
     }
@@ -1806,13 +1783,13 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 #endif
 	if (!(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr))
 	    do_utf8 ? to_utf8_substr(prog) : to_byte_substr(prog);
-	ch = SvPVX(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr)[0];
+	ch = SvPVX_const(do_utf8 ? prog->anchored_utf8 : prog->anchored_substr)[0];
 
 	if (do_utf8) {
 	    while (s < strend) {
 		if (*s == ch) {
-		    DEBUG_r( did_match = 1 );
-		    if (regtry(prog, s)) goto got_it;
+		    DEBUG_EXECUTE_r( did_match = 1 );
+		    if (regtry(&reginfo, s)) goto got_it;
 		    s += UTF8SKIP(s);
 		    while (s < strend && *s == ch)
 			s += UTF8SKIP(s);
@@ -1823,8 +1800,8 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	else {
 	    while (s < strend) {
 		if (*s == ch) {
-		    DEBUG_r( did_match = 1 );
-		    if (regtry(prog, s)) goto got_it;
+		    DEBUG_EXECUTE_r( did_match = 1 );
+		    if (regtry(&reginfo, s)) goto got_it;
 		    s++;
 		    while (s < strend && *s == ch)
 			s++;
@@ -1832,15 +1809,14 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 		s++;
 	    }
 	}
-	DEBUG_r(if (!did_match)
+	DEBUG_EXECUTE_r(if (!did_match)
 		PerlIO_printf(Perl_debug_log,
                                   "Did not find anchored character...\n")
                );
     }
-    /*SUPPRESS 560*/
-    else if (prog->anchored_substr != Nullsv
-	      || prog->anchored_utf8 != Nullsv
-	      || ((prog->float_substr != Nullsv || prog->float_utf8 != Nullsv)
+    else if (prog->anchored_substr != NULL
+	      || prog->anchored_utf8 != NULL
+	      || ((prog->float_substr != NULL || prog->float_utf8 != NULL)
 		  && prog->float_max_offset < strend - s)) {
 	SV *must;
 	I32 back_max;
@@ -1875,7 +1851,7 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	else
 	    last1 = s - 1;	/* bogus */
 
-	/* XXXX check_substr already used to find `s', can optimize if
+	/* XXXX check_substr already used to find "s", can optimize if
 	   check_substr==must. */
 	scream_pos = -1;
 	dontbother = end_shift;
@@ -1889,41 +1865,41 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 				  multiline ? FBMrf_MULTILINE : 0))) ) {
 	    /* we may be pointing at the wrong string */
 	    if ((flags & REXEC_SCREAM) && RX_MATCH_COPIED(prog))
-		s = strbeg + (s - SvPVX(sv));
-	    DEBUG_r( did_match = 1 );
+		s = strbeg + (s - SvPVX_const(sv));
+	    DEBUG_EXECUTE_r( did_match = 1 );
 	    if (HOPc(s, -back_max) > last1) {
 		last1 = HOPc(s, -back_min);
 		s = HOPc(s, -back_max);
 	    }
 	    else {
-		char *t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
+		char * const t = (last1 >= PL_bostr) ? HOPc(last1, 1) : last1 + 1;
 
 		last1 = HOPc(s, -back_min);
-		s = t;		
+		s = t;
 	    }
 	    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++;
 		}
 	    }
 	}
-	DEBUG_r(if (!did_match)
+	DEBUG_EXECUTE_r(if (!did_match)
                     PerlIO_printf(Perl_debug_log, 
-                                  "Did not find %s substr `%s%.*s%s'%s...\n",
+                                  "Did not find %s substr \"%s%.*s%s\"%s...\n",
 			      ((must == prog->anchored_substr || must == prog->anchored_utf8)
 			       ? "anchored" : "floating"),
 			      PL_colors[0],
 			      (int)(SvCUR(must) - (SvTAIL(must)!=0)),
-			      SvPVX(must),
+			      SvPVX_const(must),
                                   PL_colors[1], (SvTAIL(must) ? "$" : ""))
                );
 	goto phooey;
@@ -1935,34 +1911,34 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 	    if (PL_regkind[op] != EXACT && op != CANY)
 	        strend = HOPc(strend, -(minlen - 1));
 	}
-	DEBUG_r({
+	DEBUG_EXECUTE_r({
 	    SV *prop = sv_newmortal();
-	    char *s0;
-	    char *s1;
+	    const char *s0;
+	    const char *s1;
 	    int len0;
 	    int len1;
 
-	    regprop(prop, c);
+	    regprop(prog, prop, c);
 	    s0 = UTF ?
-	      pv_uni_display(dsv0, (U8*)SvPVX(prop), SvCUR(prop), 60,
+	      pv_uni_display(dsv0, (U8*)SvPVX_const(prop), SvCUR(prop), 60,
 			     UNI_DISPLAY_REGEX) :
-	      SvPVX(prop);
+	      SvPVX_const(prop);
 	    len0 = UTF ? SvCUR(dsv0) : SvCUR(prop);
 	    s1 = UTF ?
 	      sv_uni_display(dsv1, sv, 60, UNI_DISPLAY_REGEX) : s;
 	    len1 = UTF ? SvCUR(dsv1) : strend - s;
 	    PerlIO_printf(Perl_debug_log,
-			  "Matching stclass `%*.*s' against `%*.*s'\n",
+			  "Matching stclass \"%*.*s\" against \"%*.*s\"\n",
 			  len0, len0, s0,
 			  len1, len1, s1);
 	});
-  	if (find_byclass(prog, c, s, strend, startpos, 0))
+        if (find_byclass(prog, c, s, strend, &reginfo))
 	    goto got_it;
-	DEBUG_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass...\n"));
+	DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "Contradicts stclass...\n"));
     }
     else {
 	dontbother = 0;
-	if (prog->float_substr != Nullsv || prog->float_utf8 != Nullsv) {
+	if (prog->float_substr != NULL || prog->float_utf8 != NULL) {
 	    /* Trim the end. */
 	    char *last;
 	    SV* float_real;
@@ -1978,18 +1954,18 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 		    last = scream_olds; /* Only one occurrence. */
 		/* we may be pointing at the wrong string */
 		else if (RX_MATCH_COPIED(prog))
-		    s = strbeg + (s - SvPVX(sv));
+		    s = strbeg + (s - SvPVX_const(sv));
 	    }
 	    else {
 		STRLEN len;
-		char *little = SvPV(float_real, len);
+                const char * const little = SvPV_const(float_real, len);
 
 		if (SvTAIL(float_real)) {
 		    if (memEQ(strend - len + 1, little, len - 1))
 			last = strend - len + 1;
 		    else if (!multiline)
 			last = memEQ(strend - len, little, len)
-			    ? strend - len : Nullch;
+			    ? strend - len : NULL;
 		    else
 			goto find_last;
 		} else {
@@ -1997,13 +1973,13 @@ Perl_regexec_flags(pTHX_ register regexp *prog, char *stringarg, register char *
 		    if (len)
 			last = rninstr(s, strend, little, little + len);
 		    else
-			last = strend;	/* matching `$' */
+			last = strend;	/* matching "$" */
 		}
 	    }
 	    if (last == NULL) {
-		DEBUG_r(PerlIO_printf(Perl_debug_log,
+		DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log,
 				      "%sCan't trim the tail, match fails (should not happen)%s\n",
-				      PL_colors[4],PL_colors[5]));
+				      PL_colors[4], PL_colors[5]));
 		goto phooey; /* Should not happen! */
 	    }
 	    dontbother = strend - last + prog->float_min_offset;
@@ -2014,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;
@@ -2023,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);
 	}
@@ -2041,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 */
@@ -2049,7 +2025,7 @@ got_it:
 	RX_MATCH_COPY_FREE(prog);
 	if (flags & REXEC_COPY_STR) {
 	    I32 i = PL_regeol - startpos + (stringarg - strbeg);
-#ifdef PERL_COPY_ON_WRITE
+#ifdef PERL_OLD_COPY_ON_WRITE
 	    if ((SvIsCOW(sv)
 		 || (SvFLAGS(sv) & CAN_COW_MASK) == CAN_COW_FLAGS)) {
 		if (DEBUG_C_TEST) {
@@ -2058,7 +2034,7 @@ got_it:
 				  (int) SvTYPE(sv));
 		}
 		prog->saved_copy = sv_setsv_cow(prog->saved_copy, sv);
-		prog->subbeg = SvPVX(prog->saved_copy);
+		prog->subbeg = (char *)SvPVX_const(prog->saved_copy);
 		assert (SvPOKp(prog->saved_copy));
 	    } else
 #endif
@@ -2078,10 +2054,10 @@ got_it:
     return 1;
 
 phooey:
-    DEBUG_r(PerlIO_printf(Perl_debug_log, "%sMatch failed%s\n",
-			  PL_colors[4],PL_colors[5]));
+    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;
 }
 
@@ -2089,12 +2065,14 @@ 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)
 {
-    register I32 i;
+    dVAR;
     register I32 *sp;
     register I32 *ep;
     CHECKPOINT lastcp;
+    regexp *prog = reginfo->prog;
+    GET_RE_DEBUG_FLAGS_DECL;
 
 #ifdef DEBUGGING
     PL_regindent = 0;	/* XXXX Not good when matches are reenterable... */
@@ -2103,7 +2081,7 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
 	MAGIC *mg;
 
 	PL_reg_eval_set = RS_init;
-	DEBUG_r(DEBUG_s(
+	DEBUG_EXECUTE_r(DEBUG_s(
 	    PerlIO_printf(Perl_debug_log, "  setting stack tmpbase at %"IVdf"\n",
 			  (IV)(PL_stack_sp - PL_stack_base));
 	    ));
@@ -2115,27 +2093,30 @@ 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 */
-		sv_magic(PL_reg_sv, (SV*)0,
-			PERL_MAGIC_regex_global, Nullch, 0);
-		mg = mg_find(PL_reg_sv, PERL_MAGIC_regex_global);
+#ifdef PERL_OLD_COPY_ON_WRITE
+		if (SvIsCOW(sv))
+		    sv_force_normal_flags(sv, 0);
+#endif
+		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) {
-	    Newz(22,PL_reg_curpm, 1, PMOP);
+	    Newxz(PL_reg_curpm, 1, PMOP);
 #ifdef USE_ITHREADS
             {
                 SV* repointer = newSViv(0);
@@ -2156,13 +2137,13 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
 		$` inside (?{}) could fail... */
 	    PL_reg_oldsaved = prog->subbeg;
 	    PL_reg_oldsavedlen = prog->sublen;
-#ifdef PERL_COPY_ON_WRITE
+#ifdef PERL_OLD_COPY_ON_WRITE
 	    PL_nrs = prog->saved_copy;
 #endif
 	    RX_MATCH_COPIED_off(prog);
 	}
 	else
-	    PL_reg_oldsaved = Nullch;
+	    PL_reg_oldsaved = NULL;
 	prog->subbeg = PL_bostr;
 	prog->sublen = PL_regeol - PL_bostr; /* strend may have been modified */
     }
@@ -2175,13 +2156,13 @@ S_regtry(pTHX_ regexp *prog, char *startpos)
     prog->lastparen = 0;
     prog->lastcloseparen = 0;
     PL_regsize = 0;
-    DEBUG_r(PL_reg_starttry = startpos);
+    DEBUG_EXECUTE_r(PL_reg_starttry = startpos);
     if (PL_reg_start_tmpl <= prog->nparens) {
 	PL_reg_start_tmpl = prog->nparens*3/2 + 3;
         if(PL_reg_start_tmp)
             Renew(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
         else
-            New(22,PL_reg_start_tmp, PL_reg_start_tmpl, char*);
+            Newx(PL_reg_start_tmp, PL_reg_start_tmpl, char*);
     }
 
     /* XXXX What this code is doing here?!!!  There should be no need
@@ -2202,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;
@@ -2209,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;
     }
@@ -2236,6 +2218,7 @@ typedef struct {
     regnode *next;
     char *locinput;
     I32 nextchr;
+    int minmod;
 #ifdef DEBUGGING
     int regindent;
 #endif
@@ -2256,7 +2239,116 @@ typedef union re_unwind_t {
 #define sayNO_SILENT goto do_no
 #define saySAME(x) if (x) goto yes; else goto no
 
-#define REPORT_CODE_OFF 24
+#define POSCACHE_SUCCESS 0	/* caching success rather than failure */
+#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->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))) { \
+	    /* cache records failure, but this is success */ \
+	    DEBUG_r( \
+		PerlIO_printf(Perl_debug_log, \
+		    "%*s  (remove success from failure cache)\n", \
+		    REPORT_CODE_OFF+PL_regindent*2, "") \
+	    ); \
+	    PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
+	} \
+    } \
+    sayYES; \
+} STMT_END
+#define CACHEsayNO STMT_START { \
+    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))) { \
+	    /* cache records success, but this is failure */ \
+	    DEBUG_r( \
+		PerlIO_printf(Perl_debug_log, \
+		    "%*s  (remove failure from success cache)\n", \
+		    REPORT_CODE_OFF+PL_regindent*2, "") \
+	    ); \
+	    PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
+	} \
+    } \
+    sayNO; \
+} STMT_END
+
+/* this is used to determine how far from the left messages like
+   'failed...' are printed. Currently 29 makes these messages line
+   up with the opcode they refer to. Earlier perls used 25 which
+   left these messages outdented making reviewing a debug output
+   quite difficult.
+*/
+#define REPORT_CODE_OFF 29
+
+
+/* Make sure there is a test for this +1 options in re_tests */
+#define TRIE_INITAL_ACCEPT_BUFFLEN 4;
+
+/* grab a new slab and return the first slot in it */
+
+STATIC regmatch_state *
+S_push_slab(pTHX)
+{
+    regmatch_slab *s = PL_regmatch_slab->next;
+    if (!s) {
+	Newx(s, 1, regmatch_slab);
+	s->prev = PL_regmatch_slab;
+	s->next = NULL;
+	PL_regmatch_slab->next = s;
+    }
+    PL_regmatch_slab = s;
+    return &s->states[0];
+}
+
+/* simulate a recursive call to regmatch */
+
+#define REGMATCH(ns, where) \
+    st->scan = scan; \
+    scan = (ns); \
+    st->resume_state = resume_##where; \
+    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
@@ -2271,45 +2363,166 @@ typedef union re_unwind_t {
 /* [lwall] I've hoisted the register declarations to the outer block in order to
  * maybe save a little bit of pushing and popping on the stack.  It also takes
  * advantage of machines that use a register save mask on subroutine entry.
+ *
+ * This function used to be heavily recursive, but since this had the
+ * effect of blowing the CPU stack on complex regexes, it has been
+ * restructured to be iterative, and to save state onto the heap rather
+ * than the stack. Essentially whereever regmatch() used to be called, it
+ * pushes the current state, notes where to return, then jumps back into
+ * the main loop.
+ *
+ * Originally the structure of this function used to look something like
+
+    S_regmatch() {
+	int a = 1, b = 2;
+	...
+	while (scan != NULL) {
+	    a++; // do stuff with a and b
+	    ...
+    	    switch (OP(scan)) {
+		case FOO: {
+		    int local = 3;
+		    ...
+		    if (regmatch(...))  // recurse
+			goto yes;
+		}
+		...
+	    }
+	}
+	yes:
+	return 1;
+    }
+
+ * Now it looks something like this:
+
+    typedef struct {
+	int a, b, local;
+	int resume_state;
+    } regmatch_state;
+
+    S_regmatch() {
+	regmatch_state *st = new();
+	int depth=0;
+	st->a++; // do stuff with a and b
+	...
+	while (scan != NULL) {
+	    ...
+    	    switch (OP(scan)) {
+		case FOO: {
+		    st->local = 3;
+		    ...
+		    st->scan = scan;
+		    scan = ...;
+		    st->resume_state = resume_FOO;
+		    goto start_recurse; // recurse
+
+		    resume_point_FOO:
+		    if (result)
+			goto yes;
+		}
+		...
+	    }
+	  start_recurse:
+	    st = new(); push a new state
+	    st->a = 1; st->b = 2;
+	    depth++;
+	}
+      yes:
+	result = 1;
+	if (depth--) {
+	    st = pop();
+	    switch (resume_state) {
+	    case resume_FOO:
+		goto resume_point_FOO;
+	    ...
+	    }
+	}
+	return result
+    }
+	    
+ * WARNING: this means that any line in this function that contains a
+ * REGMATCH() or TRYPAREN() is actually simulating a recursive call to
+ * regmatch() using gotos instead. Thus the values of any local variables
+ * not saved in the regmatch_state structure will have been lost when
+ * execution resumes on the next line .
+ *
+ * States (ie the st pointer) are allocated in slabs of about 4K in size.
+ * PL_regmatch_state always points to the currently active state, and
+ * PL_regmatch_slab points to the slab currently containing PL_regmatch_state.
+ * The first time regmatch is called, the first slab is allocated, and is
+ * never freed until interpreter desctruction. When the slab is full,
+ * a new one is allocated chained to the end. At exit from regmatch, slabs
+ * allocated since entry are freed.
  */
+ 
+
 STATIC I32			/* 0 failure, 1 success */
-S_regmatch(pTHX_ regnode *prog)
+S_regmatch(pTHX_ const regmatch_info *reginfo, regnode *prog)
 {
-    register regnode *scan;	/* Current node. */
-    regnode *next;		/* Next node. */
-    regnode *inner;		/* Next node in internal branch. */
-    register I32 nextchr;	/* renamed nextchr - nextchar colides with
-				   function of same name */
-    register I32 n;		/* no or next */
-    register I32 ln = 0;	/* len or last */
-    register char *s = Nullch;	/* operand or save */
+    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;
+
+    /* the current state. This is a cached copy of PL_regmatch_state */
+    register regmatch_state *st;
+
+    /* cache heavy used fields of st in registers */
+    register regnode *scan;
+    register regnode *next;
+    register I32 n = 0;	/* initialize to shut up compiler warning */
     register char *locinput = PL_reginput;
-    register I32 c1 = 0, c2 = 0, paren;	/* case fold search, parenth */
-    int minmod = 0, sw = 0, logical = 0;
-    I32 unwind = 0;
-#if 0
-    I32 firstcp = PL_savestack_ix;
-#endif
-    register bool do_utf8 = PL_reg_match_utf8;
-#ifdef DEBUGGING
-    SV *dsv0 = PERL_DEBUG_PAD_ZERO(0);
-    SV *dsv1 = PERL_DEBUG_PAD_ZERO(1);
-    SV *dsv2 = PERL_DEBUG_PAD_ZERO(2);
-#endif
 
+    /* these variables are NOT saved during a recusive RFEGMATCH: */
+    register I32 nextchr;   /* is always set to UCHARAT(locinput) */
+    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;
+    GET_RE_DEBUG_FLAGS;
     PL_regindent++;
 #endif
 
+    /* on first ever call to regmatch, allocate first slab */
+    if (!PL_regmatch_slab) {
+	Newx(PL_regmatch_slab, 1, regmatch_slab);
+	PL_regmatch_slab->prev = NULL;
+	PL_regmatch_slab->next = NULL;
+	PL_regmatch_state = &PL_regmatch_slab->states[0] - 1;
+    }
+
+    /* remember current high-water mark for exit */
+    /* XXX this should be done with SAVE* instead */
+    orig_slab  = PL_regmatch_slab;
+    orig_state = PL_regmatch_state;
+
+    /* grab next free state slot */
+    st = ++PL_regmatch_state;
+    if (st >  &(PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1]))
+	st = PL_regmatch_state = S_push_slab(aTHX);
+
+    st->minmod = 0;
+    st->sw = 0;
+    st->logical = 0;
+    st->unwind = 0;
+    st->cc = NULL;
     /* Note that nextchr is a byte even in UTF */
     nextchr = UCHARAT(locinput);
     scan = prog;
     while (scan != NULL) {
 
-        DEBUG_r( {
-	    SV *prop = sv_newmortal();
-	    int docolor = *PL_colors[0];
-	    int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
+        DEBUG_EXECUTE_r( {
+	    SV * const prop = sv_newmortal();
+	    const int docolor = *PL_colors[0];
+	    const int taill = (docolor ? 10 : 7); /* 3 chars for "> <" */
 	    int l = (PL_regeol - locinput) > taill ? taill : (PL_regeol - locinput);
 	    /* The part of the string before starttry has one color
 	       (pref0_len chars), between starttry and current
@@ -2333,24 +2546,25 @@ S_regmatch(pTHX_ regnode *prog)
 		pref0_len = 0;
 	    if (pref0_len > pref_len)
 		pref0_len = pref_len;
-	    regprop(prop, scan);
+	    regprop(rex, prop, scan);
 	    {
-	      char *s0 =
+	      const char * const s0 =
 		do_utf8 && OP(scan) != CANY ?
-		pv_uni_display(dsv0, (U8*)(locinput - pref_len),
+		pv_uni_display(PERL_DEBUG_PAD(0), (U8*)(locinput - pref_len),
 			       pref0_len, 60, UNI_DISPLAY_REGEX) :
 		locinput - pref_len;
-	      int len0 = do_utf8 ? strlen(s0) : pref0_len;
-	      char *s1 = do_utf8 && OP(scan) != CANY ?
-		pv_uni_display(dsv1, (U8*)(locinput - pref_len + pref0_len),
+	      const int len0 = do_utf8 ? strlen(s0) : pref0_len;
+	      const char * const s1 = do_utf8 && OP(scan) != CANY ?
+		pv_uni_display(PERL_DEBUG_PAD(1),
+			       (U8*)(locinput - pref_len + pref0_len),
 			       pref_len - pref0_len, 60, UNI_DISPLAY_REGEX) :
 		locinput - pref_len + pref0_len;
-	      int len1 = do_utf8 ? strlen(s1) : pref_len - pref0_len;
-	      char *s2 = do_utf8 && OP(scan) != CANY ?
-		pv_uni_display(dsv2, (U8*)locinput,
+	      const int len1 = do_utf8 ? strlen(s1) : pref_len - pref0_len;
+	      const char * const s2 = do_utf8 && OP(scan) != CANY ?
+		pv_uni_display(PERL_DEBUG_PAD(2), (U8*)locinput,
 			       PL_regeol - locinput, 60, UNI_DISPLAY_REGEX) :
 		locinput;
-	      int len2 = do_utf8 ? strlen(s2) : l;
+	      const int len2 = do_utf8 ? strlen(s2) : l;
 	      PerlIO_printf(Perl_debug_log,
 			    "%4"IVdf" <%s%.*s%s%s%.*s%s%s%s%.*s%s>%*s|%3"IVdf":%*s%s\n",
 			    (IV)(locinput - PL_bostr),
@@ -2366,8 +2580,8 @@ S_regmatch(pTHX_ regnode *prog)
 			    PL_colors[1],
 			    15 - l - pref_len + 1,
 			    "",
-			    (IV)(scan - PL_regprogram), PL_regindent*2, "",
-			    SvPVX(prop));
+			    (IV)(scan - rex->program), PL_regindent*2, "",
+			    SvPVX_const(prop));
 	    }
 	});
 
@@ -2379,7 +2593,7 @@ S_regmatch(pTHX_ regnode *prog)
 	case BOL:
 	    if (locinput == PL_bostr)
 	    {
-		/* regtill = regbol; */
+		/* reginfo->till = reginfo->bol; */
 		break;
 	    }
 	    sayNO;
@@ -2395,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:
@@ -2444,24 +2658,255 @@ S_regmatch(pTHX_ regnode *prog)
 	    else
 		nextchr = UCHARAT(++locinput);
 	    break;
-	case EXACT:
-	    s = STRING(scan);
-	    ln = STR_LEN(scan);
+
+
+
+	/*
+	   traverse the TRIE keeping track of all accepting states
+	   we transition through until we get to a failing node.
+
+
+	*/
+	case TRIE:
+	case TRIEF:
+	case TRIEFL:
+	    {
+		U8 *uc = ( U8* )locinput;
+		U32 state = 1;
+		U16 charid = 0;
+		U32 base = 0;
+		UV uvc = 0;
+		STRLEN len = 0;
+		STRLEN foldlen = 0;
+		U8 *uscan = (U8*)NULL;
+		STRLEN bufflen=0;
+		SV *sv_accept_buff = NULL;
+		const enum { trie_plain, trie_utf8, trie_uft8_fold }
+		    trie_type = do_utf8 ?
+			  (OP(scan) == TRIE ? trie_utf8 : trie_uft8_fold)
+			: trie_plain;
+
+		/* what trie are we using right now */
+		reg_trie_data *trie
+		    = (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->u.trie.accepted ) {
+			    ENTER;
+			    SAVETMPS;
+			    bufflen = TRIE_INITAL_ACCEPT_BUFFLEN;
+			    sv_accept_buff=newSV(bufflen *
+					    sizeof(reg_trie_accepted) - 1);
+			    SvCUR_set(sv_accept_buff,
+						sizeof(reg_trie_accepted));
+			    SvPOK_on(sv_accept_buff);
+			    sv_2mortal(sv_accept_buff);
+			    st->u.trie.accept_buff =
+				(reg_trie_accepted*)SvPV_nolen(sv_accept_buff );
+			}
+			else {
+			    if (st->u.trie.accepted >= bufflen) {
+				bufflen *= 2;
+				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->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;
+
+		    DEBUG_TRIE_EXECUTE_r(
+			        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->u.trie.accepted );
+		    );
+
+		    if ( base ) {
+			switch (trie_type) {
+			case trie_uft8_fold:
+			    if ( foldlen>0 ) {
+				uvc = utf8n_to_uvuni( uscan, UTF8_MAXLEN, &len, uniflags );
+				foldlen -= len;
+				uscan += len;
+				len=0;
+			    } else {
+				U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
+				uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN, &len, uniflags );
+				uvc = to_uni_fold( uvc, foldbuf, &foldlen );
+				foldlen -= UNISKIP( uvc );
+				uscan = foldbuf + UNISKIP( uvc );
+			    }
+			    break;
+			case trie_utf8:
+			    uvc = utf8n_to_uvuni( (U8*)uc, UTF8_MAXLEN,
+							    &len, uniflags );
+			    break;
+			case trie_plain:
+			    uvc = (UV)*uc;
+			    len = 1;
+			}
+
+			if (uvc < 256) {
+			    charid = trie->charmap[ uvc ];
+			}
+			else {
+			    charid = 0;
+			    if (trie->widecharmap) {
+				SV** svpp = (SV**)NULL;
+				svpp = hv_fetch(trie->widecharmap,
+					    (char*)&uvc, sizeof(UV), 0);
+				if (svpp)
+				    charid = (U16)SvIV(*svpp);
+			    }
+			}
+
+			if (charid &&
+			     (base + charid > trie->uniquecharcount )
+			     && (base + charid - 1 - trie->uniquecharcount
+				    < trie->lasttrans)
+			     && trie->trans[base + charid - 1 -
+				    trie->uniquecharcount].check == state)
+			{
+			    state = trie->trans[base + charid - 1 -
+				trie->uniquecharcount ].next;
+			}
+			else {
+			    state = 0;
+			}
+			uc += len;
+
+		    }
+		    else {
+			state = 0;
+		    }
+		    DEBUG_TRIE_EXECUTE_r(
+		        PerlIO_printf( Perl_debug_log,
+		            "Charid:%3x CV:%4"UVxf" After State: %4"UVxf"%s\n",
+		            charid, uvc, (UV)state, PL_colors[5] );
+		    );
+		}
+		if (!st->u.trie.accepted )
+		   sayNO;
+
+	    /*
+	       There was at least one accepting state that we
+	       transitioned through. Presumably the number of accepting
+	       states is going to be low, typically one or two. So we
+	       simply scan through to find the one with lowest wordnum.
+	       Once we find it, we swap the last state into its place
+	       and decrement the size. We then try to match the rest of
+	       the pattern at the point where the word ends, if we
+	       succeed then we end the loop, otherwise the loop
+	       eventually terminates once all of the accepting states
+	       have been tried.
+	    */
+
+		if ( st->u.trie.accepted == 1 ) {
+		    DEBUG_EXECUTE_r({
+                        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->u.trie.accept_buff[ 0 ].wordnum,
+        		    tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",
+        		    PL_colors[5] );
+		    });
+		    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;
+		    LEAVE;
+		    REGMATCH(scan + NEXT_OFF(scan), TRIE1);
+		    /*** all unsaved local vars undefined at this point */
+		} 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->u.trie.accepted,
+                            PL_colors[5] );
+                    );
+		    while ( !result && st->u.trie.accepted-- ) {
+			U32 best = 0;
+			U32 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->u.trie.accept_buff[ best ].wordnum, (IV)cur,
+			            st->u.trie.accept_buff[ cur ].wordnum, PL_colors[5] );
+			    );
+
+			    if (st->u.trie.accept_buff[cur].wordnum <
+				    st->u.trie.accept_buff[best].wordnum)
+				best = cur;
+			}
+			DEBUG_EXECUTE_r({
+			    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->u.trie.accept_buff[best].wordnum,
+        		        tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",scan,
+        		        PL_colors[5] );
+			});
+			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->u.trie.accept_buff[ best ].endpos;
+
+                        /* 
+                           as far as I can tell we only need the SAVETMPS/FREETMPS 
+                           for re's with EVAL in them but I'm leaving them in for 
+                           all until I can be sure.
+                         */
+			SAVETMPS;
+			REGMATCH(scan + NEXT_OFF(scan), TRIE2);
+			/*** all unsaved local vars undefined at this point */
+			FREETMPS;
+		    }
+		    FREETMPS;
+		    LEAVE;
+		}
+		
+		if (result) {
+		    sayYES;
+		} else {
+		    sayNO;
+		}
+	    }
+	    /* unreached codepoint */
+	case EXACT: {
+	    char *s = STRING(scan);
+	    st->ln = STR_LEN(scan);
 	    if (do_utf8 != UTF) {
 		/* The target and the pattern have differing utf8ness. */
 		char *l = locinput;
-		char *e = s + ln;
-		STRLEN ulen;
+		const char *e = s + st->ln;
 
 		if (do_utf8) {
 		    /* The target is utf8, the pattern is not utf8. */
 		    while (s < e) {
+			STRLEN ulen;
 			if (l >= PL_regeol)
 			     sayNO;
 			if (NATIVE_TO_UNI(*(U8*)s) !=
-			    utf8n_to_uvuni((U8*)l, UTF8_MAXLEN, &ulen,
-					   ckWARN(WARN_UTF8) ?
-					   0 : UTF8_ALLOW_ANY))
+			    utf8n_to_uvuni((U8*)l, UTF8_MAXBYTES, &ulen,
+					    uniflags))
 			     sayNO;
 			l += ulen;
 			s ++;
@@ -2470,12 +2915,12 @@ S_regmatch(pTHX_ regnode *prog)
 		else {
 		    /* The target is not utf8, the pattern is utf8. */
 		    while (s < e) {
+			STRLEN ulen;
 			if (l >= PL_regeol)
 			    sayNO;
 			if (NATIVE_TO_UNI(*((U8*)l)) !=
-			    utf8n_to_uvuni((U8*)s, UTF8_MAXLEN, &ulen,
-					   ckWARN(WARN_UTF8) ?
-					   0 : UTF8_ALLOW_ANY))
+			    utf8n_to_uvuni((U8*)s, UTF8_MAXBYTES, &ulen,
+					   uniflags))
 			    sayNO;
 			s += ulen;
 			l ++;
@@ -2489,26 +2934,27 @@ S_regmatch(pTHX_ regnode *prog)
 	    /* Inline the first character, for speed. */
 	    if (UCHARAT(s) != nextchr)
 		sayNO;
-	    if (PL_regeol - locinput < ln)
+	    if (PL_regeol - locinput < st->ln)
 		sayNO;
-	    if (ln > 1 && memNE(s, locinput, ln))
+	    if (st->ln > 1 && memNE(s, locinput, st->ln))
 		sayNO;
-	    locinput += ln;
+	    locinput += st->ln;
 	    nextchr = UCHARAT(locinput);
 	    break;
+	    }
 	case EXACTFL:
 	    PL_reg_flags |= RF_tainted;
 	    /* FALL THROUGH */
-	case EXACTF:
-	    s = STRING(scan);
-	    ln = STR_LEN(scan);
+	case EXACTF: {
+	    char *s = STRING(scan);
+	    st->ln = STR_LEN(scan);
 
 	    if (do_utf8 || UTF) {
 	      /* Either target or the pattern are utf8. */
 		char *l = locinput;
 		char *e = PL_regeol;
 
-		if (ibcmp_utf8(s, 0,  ln, (bool)UTF,
+		if (ibcmp_utf8(s, 0,  st->ln, (bool)UTF,
 			       l, &e, 0,  do_utf8)) {
 		     /* One more case for the sharp s:
 		      * pack("U0U*", 0xDF) =~ /ss/i,
@@ -2516,7 +2962,7 @@ S_regmatch(pTHX_ regnode *prog)
 		      * byte sequence for the U+00DF. */
 		     if (!(do_utf8 &&
 			   toLOWER(s[0]) == 's' &&
-			   ln >= 2 &&
+			   st->ln >= 2 &&
 			   toLOWER(s[1]) == 's' &&
 			   (U8)l[0] == 0xC3 &&
 			   e - l >= 2 &&
@@ -2535,20 +2981,21 @@ S_regmatch(pTHX_ regnode *prog)
 		UCHARAT(s) != ((OP(scan) == EXACTF)
 			       ? PL_fold : PL_fold_locale)[nextchr])
 		sayNO;
-	    if (PL_regeol - locinput < ln)
+	    if (PL_regeol - locinput < st->ln)
 		sayNO;
-	    if (ln > 1 && (OP(scan) == EXACTF
-			   ? ibcmp(s, locinput, ln)
-			   : ibcmp_locale(s, locinput, ln)))
+	    if (st->ln > 1 && (OP(scan) == EXACTF
+			   ? ibcmp(s, locinput, st->ln)
+			   : ibcmp_locale(s, locinput, st->ln)))
 		sayNO;
-	    locinput += ln;
+	    locinput += st->ln;
 	    nextchr = UCHARAT(locinput);
 	    break;
+	    }
 	case ANYOF:
 	    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;
@@ -2559,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;
@@ -2584,7 +3031,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (!nextchr)
 		sayNO;
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(alnum,"a");
+		LOAD_UTF8_CHARCLASS_ALNUM();
 		if (!(OP(scan) == ALNUM
 		      ? swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
 		      : isALNUM_LC_utf8((U8*)locinput)))
@@ -2607,7 +3054,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (!nextchr && locinput >= PL_regeol)
 		sayNO;
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(alnum,"a");
+		LOAD_UTF8_CHARCLASS_ALNUM();
 		if (OP(scan) == NALNUM
 		    ? swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8)
 		    : isALNUM_LC_utf8((U8*)locinput))
@@ -2632,35 +3079,35 @@ S_regmatch(pTHX_ regnode *prog)
 	    /* was last char in word? */
 	    if (do_utf8) {
 		if (locinput == PL_bostr)
-		    ln = '\n';
+		    st->ln = '\n';
 		else {
-		    U8 *r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
+		    const U8 * const r = reghop3((U8*)locinput, -1, (U8*)PL_bostr);
 		
-		    ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, 0);
+		    st->ln = utf8n_to_uvchr(r, UTF8SKIP(r), 0, uniflags);
 		}
 		if (OP(scan) == BOUND || OP(scan) == NBOUND) {
-		    ln = isALNUM_uni(ln);
-		    LOAD_UTF8_CHARCLASS(alnum,"a");
+		    st->ln = isALNUM_uni(st->ln);
+		    LOAD_UTF8_CHARCLASS_ALNUM();
 		    n = swash_fetch(PL_utf8_alnum, (U8*)locinput, do_utf8);
 		}
 		else {
-		    ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(ln));
+		    st->ln = isALNUM_LC_uvchr(UNI_TO_NATIVE(st->ln));
 		    n = isALNUM_LC_utf8((U8*)locinput);
 		}
 	    }
 	    else {
-		ln = (locinput != PL_bostr) ?
+		st->ln = (locinput != PL_bostr) ?
 		    UCHARAT(locinput - 1) : '\n';
 		if (OP(scan) == BOUND || OP(scan) == NBOUND) {
-		    ln = isALNUM(ln);
+		    st->ln = isALNUM(st->ln);
 		    n = isALNUM(nextchr);
 		}
 		else {
-		    ln = isALNUM_LC(ln);
+		    st->ln = isALNUM_LC(st->ln);
 		    n = isALNUM_LC(nextchr);
 		}
 	    }
-	    if (((!ln) == (!n)) == (OP(scan) == BOUND ||
+	    if (((!st->ln) == (!n)) == (OP(scan) == BOUND ||
 				    OP(scan) == BOUNDL))
 		    sayNO;
 	    break;
@@ -2672,7 +3119,7 @@ S_regmatch(pTHX_ regnode *prog)
 		sayNO;
 	    if (do_utf8) {
 		if (UTF8_IS_CONTINUED(nextchr)) {
-		    LOAD_UTF8_CHARCLASS(space," ");
+		    LOAD_UTF8_CHARCLASS_SPACE();
 		    if (!(OP(scan) == SPACE
 			  ? swash_fetch(PL_utf8_space, (U8*)locinput, do_utf8)
 			  : isSPACE_LC_utf8((U8*)locinput)))
@@ -2702,7 +3149,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (!nextchr && locinput >= PL_regeol)
 		sayNO;
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(space," ");
+		LOAD_UTF8_CHARCLASS_SPACE();
 		if (OP(scan) == NSPACE
 		    ? swash_fetch(PL_utf8_space, (U8*)locinput, do_utf8)
 		    : isSPACE_LC_utf8((U8*)locinput))
@@ -2725,7 +3172,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (!nextchr)
 		sayNO;
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(digit,"0");
+		LOAD_UTF8_CHARCLASS_DIGIT();
 		if (!(OP(scan) == DIGIT
 		      ? swash_fetch(PL_utf8_digit, (U8*)locinput, do_utf8)
 		      : isDIGIT_LC_utf8((U8*)locinput)))
@@ -2748,7 +3195,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (!nextchr && locinput >= PL_regeol)
 		sayNO;
 	    if (do_utf8) {
-		LOAD_UTF8_CHARCLASS(digit,"0");
+		LOAD_UTF8_CHARCLASS_DIGIT();
 		if (OP(scan) == NDIGIT
 		    ? swash_fetch(PL_utf8_digit, (U8*)locinput, do_utf8)
 		    : isDIGIT_LC_utf8((U8*)locinput))
@@ -2768,7 +3215,7 @@ S_regmatch(pTHX_ regnode *prog)
 	    if (locinput >= PL_regeol)
 		sayNO;
 	    if  (do_utf8) {
-		LOAD_UTF8_CHARCLASS(mark,"~");
+		LOAD_UTF8_CHARCLASS_MARK();
 		if (swash_fetch(PL_utf8_mark,(U8*)locinput, do_utf8))
 		    sayNO;
 		locinput += PL_utf8skip[nextchr];
@@ -2786,29 +3233,31 @@ S_regmatch(pTHX_ regnode *prog)
 	    PL_reg_flags |= RF_tainted;
 	    /* FALL THROUGH */
         case REF:
-	case REFF:
+	case REFF: {
+	    char *s;
 	    n = ARG(scan);  /* which paren pair */
-	    ln = PL_regstartp[n];
+	    st->ln = PL_regstartp[n];
 	    PL_reg_leftiter = PL_reg_maxiter;		/* Void cache */
-	    if ((I32)*PL_reglastparen < n || ln == -1)
+	    if ((I32)*PL_reglastparen < n || st->ln == -1)
 		sayNO;			/* Do not match unless seen CLOSEn. */
-	    if (ln == PL_regendp[n])
+	    if (st->ln == PL_regendp[n])
 		break;
 
-	    s = PL_bostr + ln;
+	    s = PL_bostr + st->ln;
 	    if (do_utf8 && OP(scan) != REF) {	/* REF can do byte comparison */
 		char *l = locinput;
-		char *e = PL_bostr + PL_regendp[n];
+		const char *e = PL_bostr + PL_regendp[n];
 		/*
 		 * Note that we can't do the "other character" lookup trick as
 		 * in the 8-bit case (no pun intended) because in Unicode we
 		 * have to map both upper and title case to lower case.
 		 */
 		if (OP(scan) == REFF) {
-		    STRLEN ulen1, ulen2;
-		    U8 tmpbuf1[UTF8_MAXLEN_UCLC+1];
-		    U8 tmpbuf2[UTF8_MAXLEN_UCLC+1];
 		    while (s < e) {
+			STRLEN ulen1, ulen2;
+			U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
+			U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
+
 			if (l >= PL_regeol)
 			    sayNO;
 			toLOWER_utf8((U8*)s, tmpbuf1, &ulen1);
@@ -2830,18 +3279,19 @@ S_regmatch(pTHX_ regnode *prog)
 		 (UCHARAT(s) != ((OP(scan) == REFF
 				  ? PL_fold : PL_fold_locale)[nextchr]))))
 		sayNO;
-	    ln = PL_regendp[n] - ln;
-	    if (locinput + ln > PL_regeol)
+	    st->ln = PL_regendp[n] - st->ln;
+	    if (locinput + st->ln > PL_regeol)
 		sayNO;
-	    if (ln > 1 && (OP(scan) == REF
-			   ? memNE(s, locinput, ln)
+	    if (st->ln > 1 && (OP(scan) == REF
+			   ? memNE(s, locinput, st->ln)
 			   : (OP(scan) == REFF
-			      ? ibcmp(s, locinput, ln)
-			      : ibcmp_locale(s, locinput, ln))))
+			      ? ibcmp(s, locinput, st->ln)
+			      : ibcmp_locale(s, locinput, st->ln))))
 		sayNO;
-	    locinput += ln;
+	    locinput += st->ln;
 	    nextchr = UCHARAT(locinput);
 	    break;
+	    }
 
 	case NOTHING:
 	case TAIL:
@@ -2850,21 +3300,21 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	case EVAL:
 	{
-	    dSP;
-	    OP_4tree *oop = PL_op;
-	    COP *ocurcop = PL_curcop;
-	    PAD *old_comppad;
 	    SV *ret;
-	    struct regexp *oreg = PL_reg_re;
-	
-	    n = ARG(scan);
-	    PL_op = (OP_4tree*)PL_regdata->data[n];
-	    DEBUG_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;
-
 	    {
-		SV **before = SP;
+		/* 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)
@@ -2873,20 +3323,24 @@ S_regmatch(pTHX_ regnode *prog)
 		    ret = POPs;
 		    PUTBACK;
 		}
-	    }
 
-	    PL_op = oop;
-	    PAD_RESTORE_LOCAL(old_comppad);
-	    PL_curcop = ocurcop;
-	    if (logical) {
-		if (logical == 2) {	/* Postponed subexpression. */
-		    regexp *re;
-		    MAGIC *mg = Null(MAGIC*);
-		    re_cc_state state;
-		    CHECKPOINT cp, lastcp;
-                    int toggleutf;
-		    register SV *sv;
+		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 */
 
+		    MAGIC *mg = NULL;
+		    SV *sv;
 		    if(SvROK(ret) && SvSMAGICAL(sv = SvRV(ret)))
 			mg = mg_find(sv, PERL_MAGIC_qr);
 		    else if (SvSMAGICAL(ret)) {
@@ -2902,96 +3356,64 @@ S_regmatch(pTHX_ regnode *prog)
 		    }
 		    else {
 			STRLEN len;
-			char *t = SvPV(ret, len);
+			const char * const t = SvPV_const(ret, len);
 			PMOP pm;
-			char *oprecomp = PL_regprecomp;
-			I32 osize = PL_regsize;
-			I32 onpar = PL_regnpar;
+			const I32 osize = PL_regsize;
 
 			Zero(&pm, 1, PMOP);
-                        if (DO_UTF8(ret)) pm.op_pmdynflags |= PMdf_DYN_UTF8;
-			re = CALLREGCOMP(aTHX_ t, t + len, &pm);
+			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_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 = PL_regcc;
-		    state.re = PL_reg_re;
-
-		    PL_regcc = 0;
-		
-		    cp = regcppush(0);	/* Save *all* the positions. */
-		    REGCP_SET(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;
-
-		    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;
-			PL_regcc = 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(cp);
-			sayYES;
-		    }
-		    ReREFCNT_dec(re);
-		    REGCP_UNWIND(lastcp);
-		    regcppop();
-		    PL_reg_call_cc = state.prev;
-		    PL_regcc = 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;
-
-		    logical = 0;
-		    sayNO;
 		}
-		sw = SvTRUE(ret);
-		logical = 0;
-	    }
-	    else {
-		sv_setsv(save_scalar(PL_replgv), ret);
-		cache_re(oreg);
+
+		/* 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;
+		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 */
 	    }
+	    /* /(?(?{...})X|Y)/ */
+	    st->sw = SvTRUE(ret);
+	    st->logical = 0;
 	    break;
 	}
 	case OPEN:
@@ -3010,11 +3432,11 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	case GROUPP:
 	    n = ARG(scan);  /* which paren pair */
-	    sw = ((I32)*PL_reglastparen >= n && PL_regendp[n] != -1);
+	    st->sw = ((I32)*PL_reglastparen >= n && PL_regendp[n] != -1);
 	    break;
 	case IFTHEN:
 	    PL_reg_leftiter = PL_reg_maxiter;		/* Void cache */
-	    if (sw)
+	    if (st->sw)
 		next = NEXTOPER(NEXTOPER(scan));
 	    else {
 		next = scan + ARG(scan);
@@ -3023,38 +3445,39 @@ S_regmatch(pTHX_ regnode *prog)
 	    }
 	    break;
 	case LOGICAL:
-	    logical = scan->flags;
+	    st->logical = scan->flags;
 	    break;
 /*******************************************************************
- PL_regcc 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 X, regnode for CURLYX is processed;
+   1) After matching Y, regnode for CURLYX is processed;
 
-   2) This regnode creates infoblock on the stack, and calls
-      regmatch() recursively with the starting point at WHILEM node;
+   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.
 
-   5) Each time WHILEM is hit, PL_regcc is the infoblock created by CURLYX
+   5) Each time WHILEM is hit, cc is the infoblock created by CURLYX
       of the same pair.  Thus when WHILEM tries to match Z, it temporarily
-      resets PL_regcc, since this Y(A)*Z can be a part of some other loop:
+      resets cc, since this Y(A)*Z can be a part of some other loop:
       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.
 
- In the following picture infoblocks for outer loop of
+ In the following picture, infoblocks for outer loop of
  (Y(A)*?Z)*?T are denoted O, for inner I.  NULL starting block
  is denoted by x.  The matched string is YAAZYAZT.  Temporarily postponed
  infoblocks are drawn below the "reset" infoblock.
@@ -3100,35 +3523,40 @@ S_regmatch(pTHX_ regnode *prog)
 				O
 				I,I
  *******************************************************************/
+
 	case CURLYX: {
-		CURCUR cc;
-		CHECKPOINT cp = PL_savestack_ix;
 		/* No need to save/restore up to this paren */
 		I32 parenfloor = scan->flags;
 
-		if (OP(PREVOPER(next)) == NOTHING) /* LONGJMP */
+		if (next && (OP(PREVOPER(next)) == NOTHING)) /* LONGJMP */
 		    next += ARG(next);
-		cc.oldcc = PL_regcc;
-		PL_regcc = &cc;
 		/* XXXX Probably it is better to teach regpush to support
 		   parenfloor > PL_regsize... */
 		if (parenfloor > (I32)*PL_reglastparen)
 		    parenfloor = *PL_reglastparen; /* Pessimization... */
-		cc.parenfloor = parenfloor;
-		cc.cur = -1;
-		cc.min = ARG1(scan);
-		cc.max  = ARG2(scan);
-		cc.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
-		cc.next = next;
-		cc.minmod = minmod;
-		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;
-		n = regmatch(PREVOPER(next));	/* start on the WHILEM */
-		regcpblow(cp);
-		PL_regcc = cc.oldcc;
-		saySAME(n);
+		REGMATCH(PREVOPER(next), CURLYX); /* start on the WHILEM */
+		/*** all unsaved local vars undefined at this point */
+		regcpblow(st->u.curlyx.cp);
+		st->cc = st->u.curlyx.outercc;
+		saySAME(result);
 	    }
-	    /* NOT REACHED */
+	    /* NOTREACHED */
 	case WHILEM: {
 		/*
 		 * This is really hard to understand, because after we match
@@ -3139,49 +3567,54 @@ S_regmatch(pTHX_ regnode *prog)
 		 * that we can try again after backing off.
 		 */
 
-		CHECKPOINT cp, lastcp;
-		CURCUR* cc = PL_regcc;
-		char *lastloc = cc->lastloc; /* Detection of 0-len. */
+		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 = 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_r(
+		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)cc->min,
-				  (long)cc->max, PTR2UV(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 == cc->lastloc && n >= cc->min) {
-		    PL_regcc = cc->oldcc;
-		    if (PL_regcc)
-			ln = PL_regcc->cur;
-		    DEBUG_r(
+		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->u.curlyx.cur;
+		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 			   "%*s  empty match detected, try continuation...\n",
 			   REPORT_CODE_OFF+PL_regindent*2, "")
 			);
-		    if (regmatch(cc->next))
+		    REGMATCH(st->u.whilem.savecc->next, WHILEM1);
+		    /*** all unsaved local vars undefined at this point */
+		    st->cc = st->u.whilem.savecc;
+		    if (result)
 			sayYES;
-		    if (PL_regcc)
-			PL_regcc->cur = ln;
-		    PL_regcc = cc;
+		    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 < cc->min) {
-		    cc->cur = n;
-		    cc->lastloc = locinput;
-		    if (regmatch(cc->scan))
+		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;
-		    cc->cur = n - 1;
-		    cc->lastloc = lastloc;
+		    st->cc->u.curlyx.cur = n - 1;
+		    st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		    sayNO;
 		}
 
@@ -3194,7 +3627,7 @@ S_regmatch(pTHX_ regnode *prog)
 		    PL_reg_leftiter = PL_reg_maxiter;
 		}
 		if (PL_reg_leftiter-- == 0) {
-		    I32 size = (PL_reg_maxiter + 7)/8;
+		    const I32 size = (PL_reg_maxiter + 7 + POSCACHE_START)/8;
 		    if (PL_reg_poscache) {
 			if ((I32)PL_reg_poscache_size < size) {
 			    Renew(PL_reg_poscache, size, char);
@@ -3204,54 +3637,60 @@ S_regmatch(pTHX_ regnode *prog)
 		    }
 		    else {
 			PL_reg_poscache_size = size;
-			Newz(29, PL_reg_poscache, size, char);
+			Newxz(PL_reg_poscache, size, char);
 		    }
-		    DEBUG_r(
+		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 	      "%sDetected a super-linear match, switching on caching%s...\n",
 				      PL_colors[4], PL_colors[5])
 			);
 		}
 		if (PL_reg_leftiter < 0) {
-		    I32 o = locinput - PL_bostr, b;
-
-		    o = (scan->flags & 0xf) - 1 + o * (scan->flags>>4);
-		    b = o % 8;
-		    o /= 8;
-		    if (PL_reg_poscache[o] & (1<<b)) {
-		    DEBUG_r(
+		    st->u.whilem.cache_offset = locinput - PL_bostr;
+
+		    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",
 				      REPORT_CODE_OFF+PL_regindent*2, "")
 			);
-			if (PL_reg_flags & RF_false)
+			if (PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))
+			    /* cache records success */
 			    sayYES;
 			else
+			    /* cache records failure */
 			    sayNO_SILENT;
 		    }
-		    PL_reg_poscache[o] |= (1<<b);
+		    PL_reg_poscache[st->u.whilem.cache_offset] |= (1<<st->u.whilem.cache_bit);
 		}
 		}
 
 		/* Prefer next over scan for minimal matching. */
 
-		if (cc->minmod) {
-		    PL_regcc = cc->oldcc;
-		    if (PL_regcc)
-			ln = PL_regcc->cur;
-		    cp = regcppush(cc->parenfloor);
-		    REGCP_SET(lastcp);
-		    if (regmatch(cc->next)) {
-			regcpblow(cp);
-			sayYES;	/* All done. */
+		if (st->cc->minmod) {
+		    st->u.whilem.savecc = st->cc;
+		    st->cc = st->cc->u.curlyx.outercc;
+		    if (st->cc)
+			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->u.whilem.savecc;
+		    if (result) {
+			regcpblow(st->u.whilem.cp);
+			CACHEsayYES;	/* All done. */
 		    }
-		    REGCP_UNWIND(lastcp);
-		    regcppop();
-		    if (PL_regcc)
-			PL_regcc->cur = ln;
-		    PL_regcc = cc;
+		    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 >= 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;
@@ -3259,46 +3698,50 @@ S_regmatch(pTHX_ regnode *prog)
 				 "Complex regular subexpression recursion",
 				 REG_INFTY - 1);
 			}
-			sayNO;
+			CACHEsayNO;
 		    }
 
-		    DEBUG_r(
+		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 				      "%*s  trying longer...\n",
 				      REPORT_CODE_OFF+PL_regindent*2, "")
 			);
 		    /* Try scanning more and see if it helps. */
 		    PL_reginput = locinput;
-		    cc->cur = n;
-		    cc->lastloc = locinput;
-		    cp = regcppush(cc->parenfloor);
-		    REGCP_SET(lastcp);
-		    if (regmatch(cc->scan)) {
-			regcpblow(cp);
-			sayYES;
+		    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->u.whilem.cp);
+			CACHEsayYES;
 		    }
-		    REGCP_UNWIND(lastcp);
-		    regcppop();
-		    cc->cur = n - 1;
-		    cc->lastloc = lastloc;
-		    sayNO;
+		    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 < cc->max) {	/* More greed allowed? */
-		    cp = regcppush(cc->parenfloor);
-		    cc->cur = n;
-		    cc->lastloc = locinput;
-		    REGCP_SET(lastcp);
-		    if (regmatch(cc->scan)) {
-			regcpblow(cp);
-			sayYES;
+		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->u.whilem.cp);
+			CACHEsayYES;
 		    }
-		    REGCP_UNWIND(lastcp);
-		    regcppop();		/* Restore some previous $<digit>s? */
+		    REGCP_UNWIND(st->u.whilem.lastcp);
+		    regcppop(rex);	/* Restore some previous $<digit>s? */
 		    PL_reginput = locinput;
-		    DEBUG_r(
+		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 				      "%*s  failed, try continuation...\n",
 				      REPORT_CODE_OFF+PL_regindent*2, "")
@@ -3313,19 +3756,22 @@ S_regmatch(pTHX_ regnode *prog)
 		}
 
 		/* Failed deeper matches of scan, so see if this one works. */
-		PL_regcc = cc->oldcc;
-		if (PL_regcc)
-		    ln = PL_regcc->cur;
-		if (regmatch(cc->next))
-		    sayYES;
-		if (PL_regcc)
-		    PL_regcc->cur = ln;
-		PL_regcc = cc;
-		cc->cur = n - 1;
-		cc->lastloc = lastloc;
-		sayNO;
+		st->u.whilem.savecc = st->cc;
+		st->cc = st->cc->u.curlyx.outercc;
+		if (st->cc)
+		    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->u.whilem.savecc;
+		if (result)
+		    CACHEsayYES;
+		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;
 	    }
-	    /* NOT REACHED */
+	    /* NOTREACHED */
 	case BRANCHJ:
 	    next = scan + ARG(scan);
 	    if (next == scan)
@@ -3336,26 +3782,26 @@ S_regmatch(pTHX_ regnode *prog)
 	    inner = NEXTOPER(scan);
 	  do_branch:
 	    {
-		c1 = OP(scan);
-		if (OP(next) != c1)	/* No choice. */
+		I32 type;
+		type = OP(scan);
+		if (!next || OP(next) != type)	/* No choice. */
 		    next = inner;	/* Avoid recursion. */
 		else {
-		    I32 lastparen = *PL_reglastparen;
-		    I32 unwind1;
-		    re_unwind_branch_t *uw;
-
+		    const I32 lastparen = *PL_reglastparen;
 		    /* Put unwinding data on stack */
-		    unwind1 = SSNEWt(1,re_unwind_branch_t);
-		    uw = SSPTRt(unwind1,re_unwind_branch_t);
-		    uw->prev = unwind;
-		    unwind = unwind1;
-		    uw->type = ((c1 == BRANCH)
+		    const I32 unwind1 = SSNEWt(1,re_unwind_branch_t);
+		    re_unwind_branch_t * const uw = SSPTRt(unwind1,re_unwind_branch_t);
+
+		    uw->prev = st->unwind;
+		    st->unwind = unwind1;
+		    uw->type = ((type == BRANCH)
 				? RE_UNWIND_BRANCH
 				: RE_UNWIND_BRANCHJ);
 		    uw->lastparen = lastparen;
 		    uw->next = next;
 		    uw->locinput = locinput;
 		    uw->nextchr = nextchr;
+		    uw->minmod = st->minmod;
 #ifdef DEBUGGING
 		    uw->regindent = ++PL_regindent;
 #endif
@@ -3368,81 +3814,113 @@ S_regmatch(pTHX_ regnode *prog)
 	    }
 	    break;
 	case MINMOD:
-	    minmod = 1;
+	    st->minmod = 1;
 	    break;
 	case CURLYM:
 	{
-	    I32 l = 0;
-	    CHECKPOINT lastcp;
+	    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. */
-	    ln = ARG1(scan);  /* min to match */
+	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
-	    paren = scan->flags;
-	    if (paren) {
-		if (paren > PL_regsize)
-		    PL_regsize = paren;
-		if (paren > (I32)*PL_reglastparen)
-		    *PL_reglastparen = 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 (paren)
+	    if (st->u.curlym.paren)
 		scan += NEXT_OFF(scan); /* Skip former OPEN. */
 	    PL_reginput = locinput;
-	    if (minmod) {
-		minmod = 0;
-		if (ln && regrepeat_hard(scan, ln, &l) < ln)
+	    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, u.curlym.l */
+		    if (!st->u.curlym.matches++) {
+			if (PL_reg_match_utf8) {
+			    char *s = locinput;
+			    while (s < PL_reginput) {
+				st->u.curlym.l++;
+				s += UTF8SKIP(s);
+			    }
+			}
+			else {
+			    st->u.curlym.l = PL_reginput - locinput;
+			}
+			if (st->u.curlym.l == 0) {
+			    st->u.curlym.matches = st->u.curlym.maxwanted;
+			    break;
+			}
+		    }
+		    locinput = PL_reginput;
+		}
+	    }
+
+	    PL_reginput = locinput;
+
+	    if (st->minmod) {
+		st->minmod = 0;
+		if (st->ln && st->u.curlym.matches < st->ln)
 		    sayNO;
-		locinput = PL_reginput;
 		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)) c1 = 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) {
-			    c1 = c2 = -1000;
+			    st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 			    goto assume_ok_MM;
 			}
-			else { c1 = (U8)*STRING(text_node); }
+			else { st->u.curlym.c1 = (U8)*STRING(text_node); }
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-			    c2 = PL_fold[c1];
+			    st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
 			else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-			    c2 = PL_fold_locale[c1];
+			    st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
 			else
-			    c2 = c1;
+			    st->u.curlym.c2 = st->u.curlym.c1;
 		    }
 		}
 		else
-		    c1 = c2 = -1000;
+		    st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 	    assume_ok_MM:
-		REGCP_SET(lastcp);
-		while (n >= ln || (n == REG_INFTY && ln > 0)) { /* ln overflow ? */
+		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 (c1 == -1000 ||
-			UCHARAT(PL_reginput) == c1 ||
-			UCHARAT(PL_reginput) == c2)
+		    if (st->u.curlym.c1 == -1000 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c2)
 		    {
-			if (paren) {
-			    if (ln) {
-				PL_regstartp[paren] =
-				    HOPc(PL_reginput, -l) - PL_bostr;
-				PL_regendp[paren] = PL_reginput - PL_bostr;
+			if (st->u.curlym.paren) {
+			    if (st->ln) {
+				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[paren] = -1;
+				PL_regendp[st->u.curlym.paren] = -1;
 			}
-			if (regmatch(next))
+			REGMATCH(next, CURLYM2);
+			/*** all unsaved local vars undefined at this point */
+			if (result)
 			    sayYES;
-			REGCP_UNWIND(lastcp);
+			REGCP_UNWIND(st->u.curlym.lastcp);
 		    }
 		    /* Couldn't or didn't -- move forward. */
 		    PL_reginput = locinput;
-		    if (regrepeat_hard(scan, 1, &l)) {
-			ln++;
+		    REGMATCH(scan, CURLYM3);
+		    /*** all unsaved local vars undefined at this point */
+		    if (result) {
+			st->ln++;
 			locinput = PL_reginput;
 		    }
 		    else
@@ -3450,100 +3928,103 @@ S_regmatch(pTHX_ regnode *prog)
 		}
 	    }
 	    else {
-		n = regrepeat_hard(scan, n, &l);
-		locinput = PL_reginput;
-		DEBUG_r(
+		DEBUG_EXECUTE_r(
 		    PerlIO_printf(Perl_debug_log,
-				  "%*s  matched %"IVdf" times, len=%"IVdf"...\n",
-				  (int)(REPORT_CODE_OFF+PL_regindent*2), "",
-				  (IV) n, (IV)l)
+			      "%*s  matched %"IVdf" times, len=%"IVdf"...\n",
+			      (int)(REPORT_CODE_OFF+PL_regindent*2), "",
+			      (IV) st->u.curlym.matches, (IV)st->u.curlym.l)
 		    );
-		if (n >= 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)) c1 = 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) {
-				c1 = c2 = -1000;
+				st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 				goto assume_ok_REG;
 			    }
-			    else { c1 = (U8)*STRING(text_node); }
+			    else { st->u.curlym.c1 = (U8)*STRING(text_node); }
 
 			    if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-				c2 = PL_fold[c1];
+				st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
 			    else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-				c2 = PL_fold_locale[c1];
+				st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
 			    else
-				c2 = c1;
+				st->u.curlym.c2 = st->u.curlym.c1;
 			}
 		    }
 		    else
-			c1 = c2 = -1000;
+			st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 		}
 	    assume_ok_REG:
-		REGCP_SET(lastcp);
-		while (n >= ln) {
+		REGCP_SET(st->u.curlym.lastcp);
+		while (st->u.curlym.matches >= st->ln) {
 		    /* If it could work, try it. */
-		    if (c1 == -1000 ||
-			UCHARAT(PL_reginput) == c1 ||
-			UCHARAT(PL_reginput) == c2)
+		    if (st->u.curlym.c1 == -1000 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c2)
 		    {
-			DEBUG_r(
-				PerlIO_printf(Perl_debug_log,
-					      "%*s  trying tail with n=%"IVdf"...\n",
-					      (int)(REPORT_CODE_OFF+PL_regindent*2), "", (IV)n)
+			DEBUG_EXECUTE_r(
+			    PerlIO_printf(Perl_debug_log,
+				"%*s  trying tail with matches=%"IVdf"...\n",
+				(int)(REPORT_CODE_OFF+PL_regindent*2),
+				"", (IV)st->u.curlym.matches)
 			    );
-			if (paren) {
-			    if (n) {
-				PL_regstartp[paren] = HOPc(PL_reginput, -l) - PL_bostr;
-				PL_regendp[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[paren] = -1;
+				PL_regendp[st->u.curlym.paren] = -1;
 			}
-			if (regmatch(next))
+			REGMATCH(next, CURLYM4);
+			/*** all unsaved local vars undefined at this point */
+			if (result)
 			    sayYES;
-			REGCP_UNWIND(lastcp);
+			REGCP_UNWIND(st->u.curlym.lastcp);
 		    }
 		    /* Couldn't or didn't -- back up. */
-		    n--;
-		    locinput = HOPc(locinput, -l);
+		    st->u.curlym.matches--;
+		    locinput = HOPc(locinput, -st->u.curlym.l);
 		    PL_reginput = locinput;
 		}
 	    }
 	    sayNO;
+	    /* NOTREACHED */
 	    break;
 	}
 	case CURLYN:
-	    paren = scan->flags;	/* Which paren to set */
-	    if (paren > PL_regsize)
-		PL_regsize = paren;
-	    if (paren > (I32)*PL_reglastparen)
-		*PL_reglastparen = paren;
-	    ln = ARG1(scan);  /* min to match */
+	    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:
-	    paren = 0;
-	    ln = ARG1(scan);  /* min to match */
+	    st->u.plus.paren = 0;
+	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
 	    scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
 	    goto repeat;
 	case STAR:
-	    ln = 0;
+	    st->ln = 0;
 	    n = REG_INFTY;
 	    scan = NEXTOPER(scan);
-	    paren = 0;
+	    st->u.plus.paren = 0;
 	    goto repeat;
 	case PLUS:
-	    ln = 1;
+	    st->ln = 1;
 	    n = REG_INFTY;
 	    scan = NEXTOPER(scan);
-	    paren = 0;
+	    st->u.plus.paren = 0;
 	  repeat:
 	    /*
 	    * Lookahead to avoid useless match attempts
@@ -3562,170 +4043,166 @@ S_regmatch(pTHX_ regnode *prog)
 
 		if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-		if (! HAS_TEXT(text_node)) c1 = 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) {
-			c1 = c2 = -1000;
+			st->u.plus.c1 = st->u.plus.c2 = -1000;
 			goto assume_ok_easy;
 		    }
 		    else { s = (U8*)STRING(text_node); }
 
 		    if (!UTF) {
-			c2 = c1 = *s;
+			st->u.plus.c2 = st->u.plus.c1 = *s;
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-			    c2 = PL_fold[c1];
+			    st->u.plus.c2 = PL_fold[st->u.plus.c1];
 			else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-			    c2 = PL_fold_locale[c1];
+			    st->u.plus.c2 = PL_fold_locale[st->u.plus.c1];
 		    }
 		    else { /* UTF */
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF) {
 			     STRLEN ulen1, ulen2;
-			     U8 tmpbuf1[UTF8_MAXLEN_UCLC+1];
-			     U8 tmpbuf2[UTF8_MAXLEN_UCLC+1];
+			     U8 tmpbuf1[UTF8_MAXBYTES_CASE+1];
+			     U8 tmpbuf2[UTF8_MAXBYTES_CASE+1];
 
 			     to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
 			     to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
 
-			     c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXLEN, 0,
-						 ckWARN(WARN_UTF8) ?
-						 0 : UTF8_ALLOW_ANY);
-			     c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXLEN, 0,
-						 ckWARN(WARN_UTF8) ?
-						 0 : UTF8_ALLOW_ANY);
+			     st->u.plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
+						 uniflags);
+			     st->u.plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
+						 uniflags);
 			}
 			else {
-			    c2 = c1 = utf8n_to_uvchr(s, UTF8_MAXLEN, 0,
-						     ckWARN(WARN_UTF8) ?
-						     0 : UTF8_ALLOW_ANY);
+			    st->u.plus.c2 = st->u.plus.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
+						     uniflags);
 			}
 		    }
 		}
 	    }
 	    else
-		c1 = c2 = -1000;
+		st->u.plus.c1 = st->u.plus.c2 = -1000;
 	assume_ok_easy:
 	    PL_reginput = locinput;
-	    if (minmod) {
-		CHECKPOINT lastcp;
-		minmod = 0;
-		if (ln && regrepeat(scan, ln) < ln)
+	    if (st->minmod) {
+		st->minmod = 0;
+		if (st->ln && regrepeat(rex, scan, st->ln) < st->ln)
 		    sayNO;
 		locinput = PL_reginput;
-		REGCP_SET(lastcp);
-		if (c1 != -1000) {
-		    char *e; /* Should not check after this */
-		    char *old = locinput;
-		    int 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) {
-			e = PL_regeol - 1;
+			st->u.plus.e = PL_regeol - 1;
 			if (do_utf8)
-			    while (UTF8_IS_CONTINUATION(*(U8*)e))
-				e--;
+			    while (UTF8_IS_CONTINUATION(*(U8*)st->u.plus.e))
+				st->u.plus.e--;
 		    }
 		    else if (do_utf8) {
-			int m = n - ln;
-			for (e = locinput;
-			     m >0 && e + UTF8SKIP(e) <= PL_regeol; m--)
-			    e += UTF8SKIP(e);
+			int m = n - st->ln;
+			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 {
-			e = locinput + n - ln;
-			if (e >= PL_regeol)
-			    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 (c1 == c2) {
-				while (locinput <= e &&
-				       UCHARAT(locinput) != 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 <= e
-				       && UCHARAT(locinput) != c1
-				       && UCHARAT(locinput) != c2)
+				while (locinput <= st->u.plus.e
+				       && UCHARAT(locinput) != st->u.plus.c1
+				       && UCHARAT(locinput) != st->u.plus.c2)
 				    locinput++;
 			    }
-			    count = locinput - old;
+			    st->u.plus.count = locinput - st->u.plus.old;
 			}
 			else {
-			    STRLEN len;
-			    if (c1 == c2) {
+			    if (st->u.plus.c1 == st->u.plus.c2) {
+				STRLEN len;
 				/* count initialised to
 				 * utf8_distance(old, locinput) */
-				while (locinput <= e &&
+				while (locinput <= st->u.plus.e &&
 				       utf8n_to_uvchr((U8*)locinput,
-						      UTF8_MAXLEN, &len,
-						      ckWARN(WARN_UTF8) ?
-						      0 : UTF8_ALLOW_ANY) != (UV)c1) {
+						      UTF8_MAXBYTES, &len,
+						      uniflags) != (UV)st->u.plus.c1) {
 				    locinput += len;
-				    count++;
+				    st->u.plus.count++;
 				}
 			    } else {
+				STRLEN len;
 				/* count initialised to
 				 * utf8_distance(old, locinput) */
-				while (locinput <= e) {
+				while (locinput <= st->u.plus.e) {
 				    UV c = utf8n_to_uvchr((U8*)locinput,
-							  UTF8_MAXLEN, &len,
-							  ckWARN(WARN_UTF8) ?
-							  0 : UTF8_ALLOW_ANY);
-				    if (c == (UV)c1 || c == (UV)c2)
+							  UTF8_MAXBYTES, &len,
+							  uniflags);
+				    if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 					break;
 				    locinput += len;
-				    count++;
+				    st->u.plus.count++;
 				}
 			    }
 			}
-			if (locinput > e)
+			if (locinput > st->u.plus.e)
 			    sayNO;
 			/* PL_reginput == old now */
-			if (locinput != old) {
-			    ln = 1;	/* Did some */
-			    if (regrepeat(scan, count) < count)
+			if (locinput != st->u.plus.old) {
+			    st->ln = 1;	/* Did some */
+			    if (regrepeat(rex, scan, st->u.plus.count) < st->u.plus.count)
 				sayNO;
 			}
 			/* PL_reginput == locinput now */
-			TRYPAREN(paren, ln, locinput);
+			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(lastcp);
+			REGCP_UNWIND(st->u.plus.lastcp);
 			/* Couldn't or didn't -- move forward. */
-			old = locinput;
+			st->u.plus.old = locinput;
 			if (do_utf8)
 			    locinput += UTF8SKIP(locinput);
 			else
 			    locinput++;
-			count = 1;
+			st->u.plus.count = 1;
 		    }
 		}
 		else
-		while (n >= ln || (n == REG_INFTY && ln > 0)) { /* ln overflow ? */
+		while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
 		    UV c;
-		    if (c1 != -1000) {
+		    if (st->u.plus.c1 != -1000) {
 			if (do_utf8)
 			    c = utf8n_to_uvchr((U8*)PL_reginput,
-					       UTF8_MAXLEN, 0,
-					       ckWARN(WARN_UTF8) ?
-					       0 : UTF8_ALLOW_ANY);
+					       UTF8_MAXBYTES, 0,
+					       uniflags);
 			else
 			    c = UCHARAT(PL_reginput);
 			/* If it could work, try it. */
-		        if (c == (UV)c1 || c == (UV)c2)
+		        if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 		        {
-			    TRYPAREN(paren, ln, PL_reginput);
-			    REGCP_UNWIND(lastcp);
+			    TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS2);
+			    /*** all unsaved local vars undefined at this point */
+			    REGCP_UNWIND(st->u.plus.lastcp);
 		        }
 		    }
 		    /* If it could work, try it. */
-		    else if (c1 == -1000)
+		    else if (st->u.plus.c1 == -1000)
 		    {
-			TRYPAREN(paren, ln, PL_reginput);
-			REGCP_UNWIND(lastcp);
+			TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS3);
+			/*** all unsaved local vars undefined at this point */
+			REGCP_UNWIND(st->u.plus.lastcp);
 		    }
 		    /* Couldn't or didn't -- move forward. */
 		    PL_reginput = locinput;
-		    if (regrepeat(scan, 1)) {
-			ln++;
+		    if (regrepeat(rex, scan, 1)) {
+			st->ln++;
 			locinput = PL_reginput;
 		    }
 		    else
@@ -3733,61 +4210,37 @@ S_regmatch(pTHX_ regnode *prog)
 		}
 	    }
 	    else {
-		CHECKPOINT lastcp;
-		n = regrepeat(scan, n);
+		n = regrepeat(rex, scan, n);
 		locinput = PL_reginput;
-		if (ln < n && PL_regkind[(U8)OP(next)] == EOL &&
+		if (st->ln < n && PL_regkind[(U8)OP(next)] == EOL &&
 		    (OP(next) != MEOL ||
 			OP(next) == SEOL || OP(next) == EOS))
 		{
-		    ln = n;			/* why back off? */
+		    st->ln = n;			/* why back off? */
 		    /* ...because $ and \Z can match before *and* after
 		       newline at the end.  Consider "\n\n" =~ /\n+\Z\n/.
 		       We should back off by one in this case. */
 		    if (UCHARAT(PL_reginput - 1) == '\n' && OP(next) != EOS)
-			ln--;
-		}
-		REGCP_SET(lastcp);
-		if (paren) {
-		    UV c = 0;
-		    while (n >= ln) {
-			if (c1 != -1000) {
-			    if (do_utf8)
-				c = utf8n_to_uvchr((U8*)PL_reginput,
-						   UTF8_MAXLEN, 0,
-						   ckWARN(WARN_UTF8) ?
-						   0 : UTF8_ALLOW_ANY);
-			    else
-				c = UCHARAT(PL_reginput);
-			}
-			/* If it could work, try it. */
-			if (c1 == -1000 || c == (UV)c1 || c == (UV)c2)
-			    {
-				TRYPAREN(paren, n, PL_reginput);
-				REGCP_UNWIND(lastcp);
-			    }
-			/* Couldn't or didn't -- back up. */
-			n--;
-			PL_reginput = locinput = HOPc(locinput, -1);
-		    }
+			st->ln--;
 		}
-		else {
+		REGCP_SET(st->u.plus.lastcp);
+		{
 		    UV c = 0;
-		    while (n >= ln) {
-			if (c1 != -1000) {
+		    while (n >= st->ln) {
+			if (st->u.plus.c1 != -1000) {
 			    if (do_utf8)
 				c = utf8n_to_uvchr((U8*)PL_reginput,
-						   UTF8_MAXLEN, 0,
-						   ckWARN(WARN_UTF8) ?
-						   0 : UTF8_ALLOW_ANY);
+						   UTF8_MAXBYTES, 0,
+						   uniflags);
 			    else
 				c = UCHARAT(PL_reginput);
 			}
 			/* If it could work, try it. */
-			if (c1 == -1000 || c == (UV)c1 || c == (UV)c2)
+			if (st->u.plus.c1 == -1000 || c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 			    {
-				TRYPAREN(paren, n, PL_reginput);
-				REGCP_UNWIND(lastcp);
+				TRYPAREN(st->u.plus.paren, n, PL_reginput, PLUS4);
+				/*** all unsaved local vars undefined at this point */
+				REGCP_UNWIND(st->u.plus.lastcp);
 			    }
 			/* Couldn't or didn't -- back up. */
 			n--;
@@ -3798,46 +4251,54 @@ S_regmatch(pTHX_ regnode *prog)
 	    sayNO;
 	    break;
 	case END:
-	    if (PL_reg_call_cc) {
-		re_cc_state *cur_call_cc = PL_reg_call_cc;
-		CURCUR *cctmp = PL_regcc;
-		regexp *re = PL_reg_re;
-		CHECKPOINT cp, lastcp;
-		
-		cp = regcppush(0);	/* Save *all* the positions. */
-		REGCP_SET(lastcp);
-		regcp_set_to(PL_reg_call_cc->ss); /* Restore parens of
-						    the caller. */
-		PL_reginput = locinput;	/* Make position available to
-					   the callcc. */
-		cache_re(PL_reg_call_cc->re);
-		PL_regcc = PL_reg_call_cc->cc;
-		PL_reg_call_cc = PL_reg_call_cc->prev;
-		if (regmatch(cur_call_cc->node)) {
-		    PL_reg_call_cc = cur_call_cc;
-		    regcpblow(cp);
-		    sayYES;
+	    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;
+
+		PL_regmatch_state = st;
+		scan	= st->scan;
+		next	= st->next;
+		n		= st->n;
+
+		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 = st->u.eval.lastcp;
+		    regcppop(rex);
+		    PL_savestack_ix = tmp;
 		}
-		REGCP_UNWIND(lastcp);
-		regcppop();
-		PL_reg_call_cc = cur_call_cc;
-		PL_regcc = cctmp;
-		PL_reg_re = re;
-		cache_re(re);
-
-		DEBUG_r(
-		    PerlIO_printf(Perl_debug_log,
-				  "%*s  continuation failed...\n",
-				  REPORT_CODE_OFF+PL_regindent*2, "")
-		    );
-		sayNO_SILENT;
+
+
+		PL_reginput = locinput;
+		/* resume at node following the (??{...}) */
+		break;
+
 	    }
-	    if (locinput < PL_regtill) {
-		DEBUG_r(PerlIO_printf(Perl_debug_log,
+
+	    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. */
 	    }
@@ -3853,19 +4314,18 @@ S_regmatch(pTHX_ regnode *prog)
 	case UNLESSM:
 	    n = 0;
 	    if (scan->flags) {
-		s = HOPBACKc(locinput, scan->flags);
+		char * const s = HOPBACKc(locinput, scan->flags);
 		if (!s)
 		    goto say_yes;
 		PL_reginput = s;
 	    }
 	    else
 		PL_reginput = locinput;
-	    PL_reg_flags ^= RF_false;
 	    goto do_ifmatch;
 	case IFMATCH:
 	    n = 1;
 	    if (scan->flags) {
-		s = HOPBACKc(locinput, scan->flags);
+		char * const s = HOPBACKc(locinput, scan->flags);
 		if (!s)
 		    goto say_no;
 		PL_reginput = s;
@@ -3874,25 +4334,22 @@ S_regmatch(pTHX_ regnode *prog)
 		PL_reginput = locinput;
 
 	  do_ifmatch:
-	    inner = NEXTOPER(NEXTOPER(scan));
-	    if (regmatch(inner) != n) {
-		if (n == 0)
-		    PL_reg_flags ^= RF_false;
+	    REGMATCH(NEXTOPER(NEXTOPER(scan)), IFMATCH);
+	    /*** all unsaved local vars undefined at this point */
+	    if (result != n) {
 	      say_no:
-		if (logical) {
-		    logical = 0;
-		    sw = 0;
+		if (st->logical) {
+		    st->logical = 0;
+		    st->sw = 0;
 		    goto do_longjump;
 		}
 		else
 		    sayNO;
 	    }
-	    if (n == 0)
-		PL_reg_flags ^= RF_false;
 	  say_yes:
-	    if (logical) {
-		logical = 0;
-		sw = 1;
+	    if (st->logical) {
+		st->logical = 0;
+		st->sw = 1;
 	    }
 	    if (OP(scan) == SUSPEND) {
 		locinput = PL_reginput;
@@ -3910,10 +4367,49 @@ S_regmatch(pTHX_ regnode *prog)
 			  PTR2UV(scan), OP(scan));
 	    Perl_croak(aTHX_ "regexp memory corruption");
 	}
+
       reenter:
 	scan = next;
+	continue;
+	/* NOTREACHED */
+
+	/* simulate recursively calling regmatch(), but without actually
+	 * recursing - ie save the current state on the heap rather than on
+	 * the stack, then re-enter the loop. This avoids complex regexes
+	 * blowing the processor stack */
+
+      start_recurse:
+	{
+	    /* push new state */
+	    regmatch_state *oldst = st;
+
+	    depth++;
+
+	    /* grab the next free state slot */
+	    st++;
+	    if (st >  &(PL_regmatch_slab->states[PERL_REGMATCH_SLAB_SLOTS-1]))
+		st = S_push_slab(aTHX);
+	    PL_regmatch_state = st;
+
+	    oldst->next = next;
+	    oldst->n = n;
+	    oldst->locinput = locinput;
+
+	    st->cc = oldst->cc;
+	    locinput = PL_reginput;
+    	    nextchr = UCHARAT(locinput);
+	    st->minmod = 0;
+	    st->sw = 0;
+	    st->logical = 0;
+	    st->unwind = 0;
+#ifdef DEBUGGING
+	    PL_regindent++;
+#endif
+	}
     }
 
+
+
     /*
     * We get here only if there's trouble -- normally "case END" is
     * the terminating point.
@@ -3923,61 +4419,107 @@ S_regmatch(pTHX_ regnode *prog)
     sayNO;
 
 yes_loud:
-    DEBUG_r(
+    DEBUG_EXECUTE_r(
 	PerlIO_printf(Perl_debug_log,
 		      "%*s  %scould match...%s\n",
-		      REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],PL_colors[5])
+		      REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4], PL_colors[5])
 	);
     goto yes;
 yes_final:
-    DEBUG_r(PerlIO_printf(Perl_debug_log, "%sMatch successful!%s\n",
-			  PL_colors[4],PL_colors[5]));
+    DEBUG_EXECUTE_r(PerlIO_printf(Perl_debug_log, "%sMatch successful!%s\n",
+			  PL_colors[4], PL_colors[5]));
 yes:
 #ifdef DEBUGGING
     PL_regindent--;
 #endif
 
-#if 0					/* Breaks $^R */
-    if (unwind)
-	regcpblow(firstcp);
-#endif
-    return 1;
+    result = 1;
+    /* 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_r(
+    DEBUG_EXECUTE_r(
 	PerlIO_printf(Perl_debug_log,
 		      "%*s  %sfailed...%s\n",
-		      REPORT_CODE_OFF+PL_regindent*2, "",PL_colors[4],PL_colors[5])
+		      REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4], PL_colors[5])
 	);
     goto do_no;
 no_final:
 do_no:
-    if (unwind) {
-	re_unwind_t *uw = SSPTRt(unwind,re_unwind_t);
+    if (st->unwind) {
+	re_unwind_t * const uw = SSPTRt(st->unwind,re_unwind_t);
 
 	switch (uw->type) {
 	case RE_UNWIND_BRANCH:
 	case RE_UNWIND_BRANCHJ:
 	{
-	    re_unwind_branch_t *uwb = &(uw->branch);
-	    I32 lastparen = uwb->lastparen;
+	    re_unwind_branch_t * const uwb = &(uw->branch);
+	    const I32 lastparen = uwb->lastparen;
 	
 	    REGCP_UNWIND(uwb->lastcp);
 	    for (n = *PL_reglastparen; n > lastparen; n--)
 		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 */
-		unwind = uwb->prev;
+		st->unwind = uwb->prev;
 #ifdef DEBUGGING
 		PL_regindent--;
 #endif
 		goto do_no;
 	    }
 	    /* Have more choice yet.  Reuse the same uwb.  */
-	    /*SUPPRESS 560*/
 	    if ((n = (uwb->type == RE_UNWIND_BRANCH
 		      ? NEXT_OFF(next) : ARG(next))))
 		next += n;
@@ -3995,16 +4537,99 @@ do_no:
 
 	    goto reenter;
 	}
-	/* NOT REACHED */
+	/* NOTREACHED */
 	default:
 	    Perl_croak(aTHX_ "regexp unwind memory corruption");
 	}
-	/* NOT REACHED */
+	/* NOTREACHED */
     }
+
 #ifdef DEBUGGING
     PL_regindent--;
 #endif
-    return 0;
+    result = 0;
+
+    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:
+	    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");
+	}
+    }
+
+final_exit:
+
+    /* restore original high-water mark */
+    PL_regmatch_slab  = orig_slab;
+    PL_regmatch_state = orig_state;
+
+    /* free all slabs above current one */
+    if (orig_slab->next) {
+	regmatch_slab *osl, *sl = orig_slab->next;
+	orig_slab->next = NULL;
+	while (sl) {
+	    osl = sl;
+	    sl = sl->next;
+	    Safefree(osl);
+	}
+    }
+
+    return result;
+
 }
 
 /*
@@ -4016,8 +4641,9 @@ do_no:
  * rather than incrementing count on every character.  [Er, except utf8.]]
  */
 STATIC I32
-S_regrepeat(pTHX_ regnode *p, I32 max)
+S_regrepeat(pTHX_ const regexp *prog, const regnode *p, I32 max)
 {
+    dVAR;
     register char *scan;
     register I32 c;
     register char *loceol = PL_regeol;
@@ -4028,7 +4654,7 @@ S_regrepeat(pTHX_ 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) {
@@ -4078,19 +4704,19 @@ S_regrepeat(pTHX_ 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;
     case ALNUM:
 	if (do_utf8) {
 	    loceol = PL_regeol;
-	    LOAD_UTF8_CHARCLASS(alnum,"a");
+	    LOAD_UTF8_CHARCLASS_ALNUM();
 	    while (hardcount < max && scan < loceol &&
 		   swash_fetch(PL_utf8_alnum, (U8*)scan, do_utf8)) {
 		scan += UTF8SKIP(scan);
@@ -4118,7 +4744,7 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
     case NALNUM:
 	if (do_utf8) {
 	    loceol = PL_regeol;
-	    LOAD_UTF8_CHARCLASS(alnum,"a");
+	    LOAD_UTF8_CHARCLASS_ALNUM();
 	    while (hardcount < max && scan < loceol &&
 		   !swash_fetch(PL_utf8_alnum, (U8*)scan, do_utf8)) {
 		scan += UTF8SKIP(scan);
@@ -4146,7 +4772,7 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
     case SPACE:
 	if (do_utf8) {
 	    loceol = PL_regeol;
-	    LOAD_UTF8_CHARCLASS(space," ");
+	    LOAD_UTF8_CHARCLASS_SPACE();
 	    while (hardcount < max && scan < loceol &&
 		   (*scan == ' ' ||
 		    swash_fetch(PL_utf8_space,(U8*)scan, do_utf8))) {
@@ -4175,7 +4801,7 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
     case NSPACE:
 	if (do_utf8) {
 	    loceol = PL_regeol;
-	    LOAD_UTF8_CHARCLASS(space," ");
+	    LOAD_UTF8_CHARCLASS_SPACE();
 	    while (hardcount < max && scan < loceol &&
 		   !(*scan == ' ' ||
 		     swash_fetch(PL_utf8_space,(U8*)scan, do_utf8))) {
@@ -4204,7 +4830,7 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
     case DIGIT:
 	if (do_utf8) {
 	    loceol = PL_regeol;
-	    LOAD_UTF8_CHARCLASS(digit,"0");
+	    LOAD_UTF8_CHARCLASS_DIGIT();
 	    while (hardcount < max && scan < loceol &&
 		   swash_fetch(PL_utf8_digit, (U8*)scan, do_utf8)) {
 		scan += UTF8SKIP(scan);
@@ -4218,7 +4844,7 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
     case NDIGIT:
 	if (do_utf8) {
 	    loceol = PL_regeol;
-	    LOAD_UTF8_CHARCLASS(digit,"0");
+	    LOAD_UTF8_CHARCLASS_DIGIT();
 	    while (hardcount < max && scan < loceol &&
 		   !swash_fetch(PL_utf8_digit, (U8*)scan, do_utf8)) {
 		scan += UTF8SKIP(scan);
@@ -4239,96 +4865,49 @@ S_regrepeat(pTHX_ regnode *p, I32 max)
 	c = scan - PL_reginput;
     PL_reginput = scan;
 
-    DEBUG_r(
-	{
-		SV *prop = sv_newmortal();
-
-		regprop(prop, p);
+    DEBUG_r({
+	        SV *re_debug_flags = NULL;
+		SV * const prop = sv_newmortal();
+                GET_RE_DEBUG_FLAGS;
+                DEBUG_EXECUTE_r({
+		regprop(prog, prop, p);
 		PerlIO_printf(Perl_debug_log,
 			      "%*s  %s can match %"IVdf" times out of %"IVdf"...\n",
-			      REPORT_CODE_OFF+1, "", SvPVX(prop),(IV)c,(IV)max);
+			      REPORT_CODE_OFF+1, "", SvPVX_const(prop),(IV)c,(IV)max);
+	});
 	});
 
     return(c);
 }
 
-/*
- - regrepeat_hard - repeatedly match something, report total lenth and length
- *
- * The repeater is supposed to have constant non-zero length.
- */
-
-STATIC I32
-S_regrepeat_hard(pTHX_ regnode *p, I32 max, I32 *lp)
-{
-    register char *scan = Nullch;
-    register char *start;
-    register char *loceol = PL_regeol;
-    I32 l = 0;
-    I32 count = 0, res = 1;
-
-    if (!max)
-	return 0;
-
-    start = PL_reginput;
-    if (PL_reg_match_utf8) {
-	while (PL_reginput < loceol && (scan = PL_reginput, res = regmatch(p))) {
-	    if (!count++) {
-		l = 0;
-		while (start < PL_reginput) {
-		    l++;
-		    start += UTF8SKIP(start);
-		}
-		*lp = l;
-		if (l == 0)
-		    return max;
-	    }
-	    if (count == max)
-		return count;
-	}
-    }
-    else {
-	while (PL_reginput < loceol && (scan = PL_reginput, res = regmatch(p))) {
-	    if (!count++) {
-		*lp = l = PL_reginput - start;
-		if (max != REG_INFTY && l*max < loceol - scan)
-		    loceol = scan + l*max;
-		if (l == 0)
-		    return max;
-	    }
-	}
-    }
-    if (!res)
-	PL_reginput = scan;
-
-    return count;
-}
 
 /*
 - regclass_swash - prepare the utf8 swash
 */
 
 SV *
-Perl_regclass_swash(pTHX_ register 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) {
-	U32 n = ARG(node);
+    if (data && data->count) {
+	const U32 n = ARG(node);
 
-	if (PL_regdata->what[n] == 's') {
-	    SV *rv = (SV*)PL_regdata->data[n];
-	    AV *av = (AV*)SvRV((SV*)rv);
-	    SV **ary = AvARRAY(av);
+	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;
 	
-	    /* See the end of regcomp.c:S_reglass() for
+	    /* See the end of regcomp.c:S_regclass() for
 	     * documentation of these array elements. */
 
 	    si = *ary;
-	    a  = SvTYPE(ary[1]) == SVt_RV   ? &ary[1] : 0;
+	    a  = SvROK(ary[1]) ? &ary[1] : 0;
 	    b  = SvTYPE(ary[2]) == SVt_PVAV ? &ary[2] : 0;
 
 	    if (a)
@@ -4361,17 +4940,22 @@ Perl_regclass_swash(pTHX_ register regnode* node, bool doinit, SV** listsvp, SV
  */
 
 STATIC bool
-S_reginclass(pTHX_ register regnode *n, register 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)
 {
-    char flags = ANYOF_FLAGS(n);
+    dVAR;
+    const char flags = ANYOF_FLAGS(n);
     bool match = FALSE;
     UV c = *p;
     STRLEN len = 0;
     STRLEN plen;
 
-    if (do_utf8 && !UTF8_IS_INVARIANT(c))
-	 c = utf8n_to_uvchr(p, UTF8_MAXLEN, &len,
-			    ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY);
+    if (do_utf8 && !UTF8_IS_INVARIANT(c)) {
+	c = utf8n_to_uvchr(p, UTF8_MAXBYTES, &len,
+		(UTF8_ALLOW_DEFAULT & UTF8_ALLOW_ANYUV) | UTF8_CHECK_ONLY);
+		/* see [perl #37836] for UTF8_ALLOW_ANYUV */
+	if (len == (STRLEN)-1)
+	    Perl_croak(aTHX_ "Malformed UTF-8 character (fatal)");
+    }
 
     plen = lenp ? *lenp : UNISKIP(NATIVE_TO_UNI(c));
     if (do_utf8 || (flags & ANYOF_UNICODE)) {
@@ -4385,7 +4969,7 @@ S_reginclass(pTHX_ register regnode *n, register U8* p, STRLEN* lenp, register b
 	    match = TRUE;
 	if (!match) {
 	    AV *av;
-	    SV *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))
@@ -4393,11 +4977,10 @@ S_reginclass(pTHX_ register regnode *n, register U8* p, STRLEN* lenp, register b
 		else if (flags & ANYOF_FOLD) {
 		    if (!match && lenp && av) {
 		        I32 i;
-		      
 			for (i = 0; i <= av_len(av); i++) {
-			    SV* sv = *av_fetch(av, i, FALSE);
+			    SV* const sv = *av_fetch(av, i, FALSE);
 			    STRLEN len;
-			    char *s = SvPV(sv, len);
+			    const char * const s = SvPV_const(sv, len);
 			
 			    if (len <= plen && memEQ(s, (char*)p, len)) {
 			        *lenp = len;
@@ -4407,7 +4990,7 @@ S_reginclass(pTHX_ register regnode *n, register U8* p, STRLEN* lenp, register b
 			}
 		    }
 		    if (!match) {
-		        U8 tmpbuf[UTF8_MAXLEN_FOLD+1];
+		        U8 tmpbuf[UTF8_MAXBYTES_CASE+1];
 			STRLEN tmplen;
 
 		        to_utf8_fold(p, tmpbuf, &tmplen);
@@ -4480,14 +5063,9 @@ S_reginclass(pTHX_ register regnode *n, register U8* p, STRLEN* lenp, register b
 }
 
 STATIC U8 *
-S_reghop(pTHX_ U8 *s, I32 off)
-{
-    return S_reghop3(aTHX_ s, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr));
-}
-
-STATIC U8 *
-S_reghop3(pTHX_ U8 *s, I32 off, U8* lim)
+S_reghop3(U8 *s, I32 off, U8* lim)
 {
+    dVAR;
     if (off >= 0) {
 	while (off-- && s < lim) {
 	    /* XXX could check well-formedness here */
@@ -4510,14 +5088,9 @@ S_reghop3(pTHX_ U8 *s, I32 off, U8* lim)
 }
 
 STATIC U8 *
-S_reghopmaybe(pTHX_ U8 *s, I32 off)
-{
-    return S_reghopmaybe3(aTHX_ s, off, (U8*)(off >= 0 ? PL_regeol : PL_bostr));
-}
-
-STATIC U8 *
-S_reghopmaybe3(pTHX_ U8* s, I32 off, U8* lim)
+S_reghopmaybe3(U8* s, I32 off, U8* lim)
 {
+    dVAR;
     if (off >= 0) {
 	while (off-- && s < lim) {
 	    /* XXX could check well-formedness here */
@@ -4548,14 +5121,16 @@ S_reghopmaybe3(pTHX_ U8* s, I32 off, U8* lim)
 static void
 restore_pos(pTHX_ void *arg)
 {
+    dVAR;
+    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;
-#ifdef PERL_COPY_ON_WRITE
-	    PL_reg_re->saved_copy = PL_nrs;
+	    rex->subbeg = PL_reg_oldsaved;
+	    rex->sublen = PL_reg_oldsavedlen;
+#ifdef PERL_OLD_COPY_ON_WRITE
+	    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;
@@ -4566,10 +5141,9 @@ restore_pos(pTHX_ void *arg)
 STATIC void
 S_to_utf8_substr(pTHX_ register regexp *prog)
 {
-    SV* sv;
     if (prog->float_substr && !prog->float_utf8) {
-	prog->float_utf8 = sv = NEWSV(117, 0);
-	SvSetSV(sv, 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);
@@ -4577,8 +5151,8 @@ S_to_utf8_substr(pTHX_ register regexp *prog)
 	    prog->check_utf8 = sv;
     }
     if (prog->anchored_substr && !prog->anchored_utf8) {
-	prog->anchored_utf8 = sv = NEWSV(118, 0);
-	SvSetSV(sv, 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);
@@ -4590,10 +5164,10 @@ S_to_utf8_substr(pTHX_ register regexp *prog)
 STATIC void
 S_to_byte_substr(pTHX_ register regexp *prog)
 {
-    SV* sv;
+    dVAR;
     if (prog->float_utf8 && !prog->float_substr) {
-	prog->float_substr = sv = NEWSV(117, 0);
-	SvSetSV(sv, 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);
@@ -4605,8 +5179,8 @@ S_to_byte_substr(pTHX_ register regexp *prog)
 	    prog->check_substr = sv;
     }
     if (prog->anchored_utf8 && !prog->anchored_substr) {
-	prog->anchored_substr = sv = NEWSV(118, 0);
-	SvSetSV(sv, 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);
@@ -4618,3 +5192,13 @@ S_to_byte_substr(pTHX_ register regexp *prog)
 	    prog->check_substr = sv;
     }
 }
+
+/*
+ * Local variables:
+ * c-indentation-style: bsd
+ * c-basic-offset: 4
+ * indent-tabs-mode: t
+ * End:
+ *
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */