anonymous unions aren't legal ANSI c

p4raw-id: //depot/perl@27694

1 files changed, 247 insertions, 247 deletions

diff --git a/regexec.c b/regexec.c
index 5119f66aa2..ced5708dba 100644
--- a/regexec.c
+++ b/regexec.c
@@ -2250,7 +2250,7 @@ typedef union re_unwind_t {
 #define POSCACHE_SEEN 1		/* we know what we're caching */
 #define POSCACHE_START 2	/* the real cache: this bit maps to pos 0 */
 #define CACHEsayYES STMT_START { \
-    if (st->whilem.cache_offset | st->whilem.cache_bit) { \
+    if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
 	if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
 	    PL_reg_poscache[0] |= (1<<POSCACHE_SUCCESS) || (1<<POSCACHE_SEEN); \
         else if (!(PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
@@ -2260,13 +2260,13 @@ typedef union re_unwind_t {
 		    "%*s  (remove success from failure cache)\n", \
 		    REPORT_CODE_OFF+PL_regindent*2, "") \
 	    ); \
-	    PL_reg_poscache[st->whilem.cache_offset] &= ~(1<<st->whilem.cache_bit); \
+	    PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
 	} \
     } \
     sayYES; \
 } STMT_END
 #define CACHEsayNO STMT_START { \
-    if (st->whilem.cache_offset | st->whilem.cache_bit) { \
+    if (st->u.whilem.cache_offset | st->u.whilem.cache_bit) { \
 	if (!(PL_reg_poscache[0] & (1<<POSCACHE_SEEN))) \
 	    PL_reg_poscache[0] |= (1<<POSCACHE_SEEN); \
         else if ((PL_reg_poscache[0] & (1<<POSCACHE_SUCCESS))) { \
@@ -2276,7 +2276,7 @@ typedef union re_unwind_t {
 		    "%*s  (remove failure from success cache)\n", \
 		    REPORT_CODE_OFF+PL_regindent*2, "") \
 	    ); \
-	    PL_reg_poscache[st->whilem.cache_offset] &= ~(1<<st->whilem.cache_bit); \
+	    PL_reg_poscache[st->u.whilem.cache_offset] &= ~(1<<st->u.whilem.cache_bit); \
 	} \
     } \
     sayNO; \
@@ -2654,13 +2654,13 @@ S_regmatch(pTHX_ regnode *prog)
 		/* what trie are we using right now */
 		reg_trie_data *trie
 		    = (reg_trie_data*)PL_regdata->data[ ARG( scan ) ];
-	    	st->trie.accepted = 0; /* how many accepting states we have seen */
+	    	st->u.trie.accepted = 0; /* how many accepting states we have seen */
 		result = 0;
 
 		while ( state && uc <= (U8*)PL_regeol ) {
 
 		    if (trie->states[ state ].wordnum) {
-			if (!st->trie.accepted ) {
+			if (!st->u.trie.accepted ) {
 			    ENTER;
 			    SAVETMPS;
 			    bufflen = TRIE_INITAL_ACCEPT_BUFFLEN;
@@ -2670,22 +2670,22 @@ S_regmatch(pTHX_ regnode *prog)
 						sizeof(reg_trie_accepted));
 			    SvPOK_on(sv_accept_buff);
 			    sv_2mortal(sv_accept_buff);
-			    st->trie.accept_buff =
+			    st->u.trie.accept_buff =
 				(reg_trie_accepted*)SvPV_nolen(sv_accept_buff );
 			}
 			else {
-			    if (st->trie.accepted >= bufflen) {
+			    if (st->u.trie.accepted >= bufflen) {
 				bufflen *= 2;
-				st->trie.accept_buff =(reg_trie_accepted*)
+				st->u.trie.accept_buff =(reg_trie_accepted*)
 				    SvGROW(sv_accept_buff,
 				       	bufflen * sizeof(reg_trie_accepted));
 			    }
 			    SvCUR_set(sv_accept_buff,SvCUR(sv_accept_buff)
 				+ sizeof(reg_trie_accepted));
 			}
-			st->trie.accept_buff[st->trie.accepted].wordnum = trie->states[state].wordnum;
-			st->trie.accept_buff[st->trie.accepted].endpos = uc;
-			++st->trie.accepted;
+			st->u.trie.accept_buff[st->u.trie.accepted].wordnum = trie->states[state].wordnum;
+			st->u.trie.accept_buff[st->u.trie.accepted].endpos = uc;
+			++st->u.trie.accepted;
 		    }
 
 		    base = trie->states[ state ].trans.base;
@@ -2694,7 +2694,7 @@ S_regmatch(pTHX_ regnode *prog)
 			        PerlIO_printf( Perl_debug_log,
 			            "%*s  %sState: %4"UVxf", Base: %4"UVxf", Accepted: %4"UVxf" ",
 			            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
-			            (UV)state, (UV)base, (UV)st->trie.accepted );
+			            (UV)state, (UV)base, (UV)st->u.trie.accepted );
 		    );
 
 		    if ( base ) {
@@ -2761,7 +2761,7 @@ S_regmatch(pTHX_ regnode *prog)
 		            charid, uvc, (UV)state, PL_colors[5] );
 		    );
 		}
-		if (!st->trie.accepted )
+		if (!st->u.trie.accepted )
 		   sayNO;
 
 	    /*
@@ -2777,17 +2777,17 @@ S_regmatch(pTHX_ regnode *prog)
 	       have been tried.
 	    */
 
-		if ( st->trie.accepted == 1 ) {
+		if ( st->u.trie.accepted == 1 ) {
 		    DEBUG_EXECUTE_r({
-                        SV **tmp = av_fetch( trie->words, st->trie.accept_buff[ 0 ].wordnum-1, 0 );
+                        SV **tmp = av_fetch( trie->words, st->u.trie.accept_buff[ 0 ].wordnum-1, 0 );
        	                PerlIO_printf( Perl_debug_log,
 			    "%*s  %sonly one match : #%d <%s>%s\n",
 			    REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],
-        		    st->trie.accept_buff[ 0 ].wordnum,
+        		    st->u.trie.accept_buff[ 0 ].wordnum,
         		    tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",
         		    PL_colors[5] );
 		    });
-		    PL_reginput = (char *)st->trie.accept_buff[ 0 ].endpos;
+		    PL_reginput = (char *)st->u.trie.accept_buff[ 0 ].endpos;
 		    /* in this case we free tmps/leave before we call regmatch
 		       as we wont be using accept_buff again. */
 		    FREETMPS;
@@ -2797,40 +2797,40 @@ S_regmatch(pTHX_ regnode *prog)
 		} else {
                     DEBUG_EXECUTE_r(
                         PerlIO_printf( Perl_debug_log,"%*s  %sgot %"IVdf" possible matches%s\n",
-                            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4], (IV)st->trie.accepted,
+                            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4], (IV)st->u.trie.accepted,
                             PL_colors[5] );
                     );
-		    while ( !result && st->trie.accepted-- ) {
+		    while ( !result && st->u.trie.accepted-- ) {
 			U32 best = 0;
 			U32 cur;
-			for( cur = 1 ; cur <= st->trie.accepted ; cur++ ) {
+			for( cur = 1 ; cur <= st->u.trie.accepted ; cur++ ) {
 			    DEBUG_TRIE_EXECUTE_r(
 			        PerlIO_printf( Perl_debug_log,
 			            "%*s  %sgot %"IVdf" (%d) as best, looking at %"IVdf" (%d)%s\n",
 			            REPORT_CODE_OFF + PL_regindent * 2, "", PL_colors[4],
-			            (IV)best, st->trie.accept_buff[ best ].wordnum, (IV)cur,
-			            st->trie.accept_buff[ cur ].wordnum, PL_colors[5] );
+			            (IV)best, st->u.trie.accept_buff[ best ].wordnum, (IV)cur,
+			            st->u.trie.accept_buff[ cur ].wordnum, PL_colors[5] );
 			    );
 
-			    if (st->trie.accept_buff[cur].wordnum <
-				    st->trie.accept_buff[best].wordnum)
+			    if (st->u.trie.accept_buff[cur].wordnum <
+				    st->u.trie.accept_buff[best].wordnum)
 				best = cur;
 			}
 			DEBUG_EXECUTE_r({
-			    SV ** const tmp = av_fetch( trie->words, st->trie.accept_buff[ best ].wordnum - 1, 0 );
+			    SV ** const tmp = av_fetch( trie->words, st->u.trie.accept_buff[ best ].wordnum - 1, 0 );
     			    PerlIO_printf( Perl_debug_log, "%*s  %strying alternation #%d <%s> at 0x%p%s\n",
     			        REPORT_CODE_OFF+PL_regindent*2, "", PL_colors[4],
-    			        st->trie.accept_buff[best].wordnum,
+    			        st->u.trie.accept_buff[best].wordnum,
         		        tmp ? SvPV_nolen_const( *tmp ) : "not compiled under -Dr",scan,
         		        PL_colors[5] );
 			});
-			if ( best<st->trie.accepted ) {
-			    reg_trie_accepted tmp = st->trie.accept_buff[ best ];
-			    st->trie.accept_buff[ best ] = st->trie.accept_buff[ st->trie.accepted ];
-			    st->trie.accept_buff[ st->trie.accepted ] = tmp;
-			    best = st->trie.accepted;
+			if ( best<st->u.trie.accepted ) {
+			    reg_trie_accepted tmp = st->u.trie.accept_buff[ best ];
+			    st->u.trie.accept_buff[ best ] = st->u.trie.accept_buff[ st->u.trie.accepted ];
+			    st->u.trie.accept_buff[ st->u.trie.accepted ] = tmp;
+			    best = st->u.trie.accepted;
 			}
-			PL_reginput = (char *)st->trie.accept_buff[ best ].endpos;
+			PL_reginput = (char *)st->u.trie.accept_buff[ best ].endpos;
 
                         /* 
                            as far as I can tell we only need the SAVETMPS/FREETMPS 
@@ -3347,8 +3347,8 @@ S_regmatch(pTHX_ regnode *prog)
 
 		    st->cc = 0;
 		
-		    st->eval.cp = regcppush(0);	/* Save *all* the positions. */
-		    REGCP_SET(st->eval.lastcp);
+		    st->u.eval.cp = regcppush(0);	/* Save *all* the positions. */
+		    REGCP_SET(st->u.eval.lastcp);
 		    cache_re(re);
 		    state.ss = PL_savestack_ix;
 		    *PL_reglastparen = 0;
@@ -3380,11 +3380,11 @@ S_regmatch(pTHX_ regnode *prog)
 
 			/* These are needed even if not SUSPEND. */
 			ReREFCNT_dec(re);
-			regcpblow(st->eval.cp);
+			regcpblow(st->u.eval.cp);
 			sayYES;
 		    }
 		    ReREFCNT_dec(re);
-		    REGCP_UNWIND(st->eval.lastcp);
+		    REGCP_UNWIND(st->u.eval.lastcp);
 		    regcppop();
 		    PL_reg_call_cc = state.prev;
 		    st->cc = state.cc;
@@ -3526,25 +3526,25 @@ S_regmatch(pTHX_ regnode *prog)
 		if (parenfloor > (I32)*PL_reglastparen)
 		    parenfloor = *PL_reglastparen; /* Pessimization... */
 
-		st->curlyx.cp = PL_savestack_ix;
-		st->curlyx.outercc = st->cc;
+		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->curlyx.parenfloor = parenfloor;
-		st->curlyx.cur = -1; /* this will be updated by WHILEM */
-		st->curlyx.min = ARG1(scan);
-		st->curlyx.max  = ARG2(scan);
-		st->curlyx.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
-		st->curlyx.lastloc = 0;
+		st->u.curlyx.parenfloor = parenfloor;
+		st->u.curlyx.cur = -1; /* this will be updated by WHILEM */
+		st->u.curlyx.min = ARG1(scan);
+		st->u.curlyx.max  = ARG2(scan);
+		st->u.curlyx.scan = NEXTOPER(scan) + EXTRA_STEP_2ARGS;
+		st->u.curlyx.lastloc = 0;
 		/* st->next and st->minmod are also read by WHILEM */
 
 		PL_reginput = locinput;
 		REGMATCH(PREVOPER(next), CURLYX); /* start on the WHILEM */
 		/*** all unsaved local vars undefined at this point */
-		regcpblow(st->curlyx.cp);
-		st->cc = st->curlyx.outercc;
+		regcpblow(st->u.curlyx.cp);
+		st->cc = st->u.curlyx.outercc;
 		saySAME(result);
 	    }
 	    /* NOTREACHED */
@@ -3558,54 +3558,54 @@ S_regmatch(pTHX_ regnode *prog)
 		 * that we can try again after backing off.
 		 */
 
-		st->whilem.lastloc = st->cc->curlyx.lastloc; /* Detection of 0-len. */
-		st->whilem.cache_offset = 0;
-		st->whilem.cache_bit = 0;
+		st->u.whilem.lastloc = st->cc->u.curlyx.lastloc; /* Detection of 0-len. */
+		st->u.whilem.cache_offset = 0;
+		st->u.whilem.cache_bit = 0;
 		
-		n = st->cc->curlyx.cur + 1; /* how many we know we matched */
+		n = st->cc->u.curlyx.cur + 1; /* how many we know we matched */
 		PL_reginput = locinput;
 
 		DEBUG_EXECUTE_r(
 		    PerlIO_printf(Perl_debug_log,
 				  "%*s  %ld out of %ld..%ld  cc=%"UVxf"\n",
 				  REPORT_CODE_OFF+PL_regindent*2, "",
-				  (long)n, (long)st->cc->curlyx.min,
-				  (long)st->cc->curlyx.max, PTR2UV(st->cc))
+				  (long)n, (long)st->cc->u.curlyx.min,
+				  (long)st->cc->u.curlyx.max, PTR2UV(st->cc))
 		    );
 
 		/* If degenerate scan matches "", assume scan done. */
 
-		if (locinput == st->cc->curlyx.lastloc && n >= st->cc->curlyx.min) {
-		    st->whilem.savecc = st->cc;
-		    st->cc = st->cc->curlyx.outercc;
+		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->curlyx.cur;
+			st->ln = st->cc->u.curlyx.cur;
 		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 			   "%*s  empty match detected, try continuation...\n",
 			   REPORT_CODE_OFF+PL_regindent*2, "")
 			);
-		    REGMATCH(st->whilem.savecc->next, WHILEM1);
+		    REGMATCH(st->u.whilem.savecc->next, WHILEM1);
 		    /*** all unsaved local vars undefined at this point */
-		    st->cc = st->whilem.savecc;
+		    st->cc = st->u.whilem.savecc;
 		    if (result)
 			sayYES;
-		    if (st->cc->curlyx.outercc)
-			st->cc->curlyx.outercc->curlyx.cur = st->ln;
+		    if (st->cc->u.curlyx.outercc)
+			st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
 		    sayNO;
 		}
 
 		/* First just match a string of min scans. */
 
-		if (n < st->cc->curlyx.min) {
-		    st->cc->curlyx.cur = n;
-		    st->cc->curlyx.lastloc = locinput;
-		    REGMATCH(st->cc->curlyx.scan, WHILEM2);
+		if (n < st->cc->u.curlyx.min) {
+		    st->cc->u.curlyx.cur = n;
+		    st->cc->u.curlyx.lastloc = locinput;
+		    REGMATCH(st->cc->u.curlyx.scan, WHILEM2);
 		    /*** all unsaved local vars undefined at this point */
 		    if (result)
 			sayYES;
-		    st->cc->curlyx.cur = n - 1;
-		    st->cc->curlyx.lastloc = st->whilem.lastloc;
+		    st->cc->u.curlyx.cur = n - 1;
+		    st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		    sayNO;
 		}
 
@@ -3637,13 +3637,13 @@ S_regmatch(pTHX_ regnode *prog)
 			);
 		}
 		if (PL_reg_leftiter < 0) {
-		    st->whilem.cache_offset = locinput - PL_bostr;
+		    st->u.whilem.cache_offset = locinput - PL_bostr;
 
-		    st->whilem.cache_offset = (scan->flags & 0xf) - 1 + POSCACHE_START
-			    + st->whilem.cache_offset * (scan->flags>>4);
-		    st->whilem.cache_bit = st->whilem.cache_offset % 8;
-		    st->whilem.cache_offset /= 8;
-		    if (PL_reg_poscache[st->whilem.cache_offset] & (1<<st->whilem.cache_bit)) {
+		    st->u.whilem.cache_offset = (scan->flags & 0xf) - 1 + POSCACHE_START
+			    + st->u.whilem.cache_offset * (scan->flags>>4);
+		    st->u.whilem.cache_bit = st->u.whilem.cache_offset % 8;
+		    st->u.whilem.cache_offset /= 8;
+		    if (PL_reg_poscache[st->u.whilem.cache_offset] & (1<<st->u.whilem.cache_bit)) {
 		    DEBUG_EXECUTE_r(
 			PerlIO_printf(Perl_debug_log,
 				      "%*s  already tried at this position...\n",
@@ -3656,32 +3656,32 @@ S_regmatch(pTHX_ regnode *prog)
 			    /* cache records failure */
 			    sayNO_SILENT;
 		    }
-		    PL_reg_poscache[st->whilem.cache_offset] |= (1<<st->whilem.cache_bit);
+		    PL_reg_poscache[st->u.whilem.cache_offset] |= (1<<st->u.whilem.cache_bit);
 		}
 		}
 
 		/* Prefer next over scan for minimal matching. */
 
 		if (st->cc->minmod) {
-		    st->whilem.savecc = st->cc;
-		    st->cc = st->cc->curlyx.outercc;
+		    st->u.whilem.savecc = st->cc;
+		    st->cc = st->cc->u.curlyx.outercc;
 		    if (st->cc)
-			st->ln = st->cc->curlyx.cur;
-		    st->whilem.cp = regcppush(st->whilem.savecc->curlyx.parenfloor);
-		    REGCP_SET(st->whilem.lastcp);
-		    REGMATCH(st->whilem.savecc->next, WHILEM3);
+			st->ln = st->cc->u.curlyx.cur;
+		    st->u.whilem.cp = regcppush(st->u.whilem.savecc->u.curlyx.parenfloor);
+		    REGCP_SET(st->u.whilem.lastcp);
+		    REGMATCH(st->u.whilem.savecc->next, WHILEM3);
 		    /*** all unsaved local vars undefined at this point */
-		    st->cc = st->whilem.savecc;
+		    st->cc = st->u.whilem.savecc;
 		    if (result) {
-			regcpblow(st->whilem.cp);
+			regcpblow(st->u.whilem.cp);
 			CACHEsayYES;	/* All done. */
 		    }
-		    REGCP_UNWIND(st->whilem.lastcp);
+		    REGCP_UNWIND(st->u.whilem.lastcp);
 		    regcppop();
-		    if (st->cc->curlyx.outercc)
-			st->cc->curlyx.outercc->curlyx.cur = st->ln;
+		    if (st->cc->u.curlyx.outercc)
+			st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
 
-		    if (n >= st->cc->curlyx.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;
@@ -3699,37 +3699,37 @@ S_regmatch(pTHX_ regnode *prog)
 			);
 		    /* Try scanning more and see if it helps. */
 		    PL_reginput = locinput;
-		    st->cc->curlyx.cur = n;
-		    st->cc->curlyx.lastloc = locinput;
-		    st->whilem.cp = regcppush(st->cc->curlyx.parenfloor);
-		    REGCP_SET(st->whilem.lastcp);
-		    REGMATCH(st->cc->curlyx.scan, WHILEM4);
+		    st->cc->u.curlyx.cur = n;
+		    st->cc->u.curlyx.lastloc = locinput;
+		    st->u.whilem.cp = regcppush(st->cc->u.curlyx.parenfloor);
+		    REGCP_SET(st->u.whilem.lastcp);
+		    REGMATCH(st->cc->u.curlyx.scan, WHILEM4);
 		    /*** all unsaved local vars undefined at this point */
 		    if (result) {
-			regcpblow(st->whilem.cp);
+			regcpblow(st->u.whilem.cp);
 			CACHEsayYES;
 		    }
-		    REGCP_UNWIND(st->whilem.lastcp);
+		    REGCP_UNWIND(st->u.whilem.lastcp);
 		    regcppop();
-		    st->cc->curlyx.cur = n - 1;
-		    st->cc->curlyx.lastloc = st->whilem.lastloc;
+		    st->cc->u.curlyx.cur = n - 1;
+		    st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		    CACHEsayNO;
 		}
 
 		/* Prefer scan over next for maximal matching. */
 
-		if (n < st->cc->curlyx.max) {	/* More greed allowed? */
-		    st->whilem.cp = regcppush(st->cc->curlyx.parenfloor);
-		    st->cc->curlyx.cur = n;
-		    st->cc->curlyx.lastloc = locinput;
-		    REGCP_SET(st->whilem.lastcp);
-		    REGMATCH(st->cc->curlyx.scan, WHILEM5);
+		if (n < st->cc->u.curlyx.max) {	/* More greed allowed? */
+		    st->u.whilem.cp = regcppush(st->cc->u.curlyx.parenfloor);
+		    st->cc->u.curlyx.cur = n;
+		    st->cc->u.curlyx.lastloc = locinput;
+		    REGCP_SET(st->u.whilem.lastcp);
+		    REGMATCH(st->cc->u.curlyx.scan, WHILEM5);
 		    /*** all unsaved local vars undefined at this point */
 		    if (result) {
-			regcpblow(st->whilem.cp);
+			regcpblow(st->u.whilem.cp);
 			CACHEsayYES;
 		    }
-		    REGCP_UNWIND(st->whilem.lastcp);
+		    REGCP_UNWIND(st->u.whilem.lastcp);
 		    regcppop();		/* Restore some previous $<digit>s? */
 		    PL_reginput = locinput;
 		    DEBUG_EXECUTE_r(
@@ -3747,19 +3747,19 @@ S_regmatch(pTHX_ regnode *prog)
 		}
 
 		/* Failed deeper matches of scan, so see if this one works. */
-		st->whilem.savecc = st->cc;
-		st->cc = st->cc->curlyx.outercc;
+		st->u.whilem.savecc = st->cc;
+		st->cc = st->cc->u.curlyx.outercc;
 		if (st->cc)
-		    st->ln = st->cc->curlyx.cur;
-		REGMATCH(st->whilem.savecc->next, WHILEM6);
+		    st->ln = st->cc->u.curlyx.cur;
+		REGMATCH(st->u.whilem.savecc->next, WHILEM6);
 		/*** all unsaved local vars undefined at this point */
-		st->cc = st->whilem.savecc;
+		st->cc = st->u.whilem.savecc;
 		if (result)
 		    CACHEsayYES;
-		if (st->cc->curlyx.outercc)
-		    st->cc->curlyx.outercc->curlyx.cur = st->ln;
-		st->cc->curlyx.cur = n - 1;
-		st->cc->curlyx.lastloc = st->whilem.lastloc;
+		if (st->cc->u.curlyx.outercc)
+		    st->cc->u.curlyx.outercc->u.curlyx.cur = st->ln;
+		st->cc->u.curlyx.cur = n - 1;
+		st->cc->u.curlyx.lastloc = st->u.whilem.lastloc;
 		CACHEsayNO;
 	    }
 	    /* NOTREACHED */
@@ -3808,45 +3808,45 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	case CURLYM:
 	{
-	    st->curlym.l = st->curlym.matches = 0;
+	    st->u.curlym.l = st->u.curlym.matches = 0;
 	
 	    /* We suppose that the next guy does not need
 	       backtracking: in particular, it is of constant non-zero length,
 	       and has no parenths to influence future backrefs. */
 	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
-	    st->curlym.paren = scan->flags;
-	    if (st->curlym.paren) {
-		if (st->curlym.paren > PL_regsize)
-		    PL_regsize = st->curlym.paren;
-		if (st->curlym.paren > (I32)*PL_reglastparen)
-		    *PL_reglastparen = st->curlym.paren;
+	    st->u.curlym.paren = scan->flags;
+	    if (st->u.curlym.paren) {
+		if (st->u.curlym.paren > PL_regsize)
+		    PL_regsize = st->u.curlym.paren;
+		if (st->u.curlym.paren > (I32)*PL_reglastparen)
+		    *PL_reglastparen = st->u.curlym.paren;
 	    }
 	    scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
-	    if (st->curlym.paren)
+	    if (st->u.curlym.paren)
 		scan += NEXT_OFF(scan); /* Skip former OPEN. */
 	    PL_reginput = locinput;
-	    st->curlym.maxwanted = st->minmod ? st->ln : n;
-	    if (st->curlym.maxwanted) {
-		while (PL_reginput < PL_regeol && st->curlym.matches < st->curlym.maxwanted) {
+	    st->u.curlym.maxwanted = st->minmod ? st->ln : n;
+	    if (st->u.curlym.maxwanted) {
+		while (PL_reginput < PL_regeol && st->u.curlym.matches < st->u.curlym.maxwanted) {
 		    REGMATCH(scan, CURLYM1);
 		    /*** all unsaved local vars undefined at this point */
 		    if (!result)
 			break;
-		    /* on first match, determine length, curlym.l */
-		    if (!st->curlym.matches++) {
+		    /* on first match, determine length, u.curlym.l */
+		    if (!st->u.curlym.matches++) {
 			if (PL_reg_match_utf8) {
 			    char *s = locinput;
 			    while (s < PL_reginput) {
-				st->curlym.l++;
+				st->u.curlym.l++;
 				s += UTF8SKIP(s);
 			    }
 			}
 			else {
-			    st->curlym.l = PL_reginput - locinput;
+			    st->u.curlym.l = PL_reginput - locinput;
 			}
-			if (st->curlym.l == 0) {
-			    st->curlym.matches = st->curlym.maxwanted;
+			if (st->u.curlym.l == 0) {
+			    st->u.curlym.matches = st->u.curlym.maxwanted;
 			    break;
 			}
 		    }
@@ -3858,52 +3858,52 @@ S_regmatch(pTHX_ regnode *prog)
 
 	    if (st->minmod) {
 		st->minmod = 0;
-		if (st->ln && st->curlym.matches < st->ln)
+		if (st->ln && st->u.curlym.matches < st->ln)
 		    sayNO;
 		if (HAS_TEXT(next) || JUMPABLE(next)) {
 		    regnode *text_node = next;
 
 		    if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-		    if (! HAS_TEXT(text_node)) st->curlym.c1 = st->curlym.c2 = -1000;
+		    if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 		    else {
 			if (PL_regkind[(U8)OP(text_node)] == REF) {
-			    st->curlym.c1 = st->curlym.c2 = -1000;
+			    st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 			    goto assume_ok_MM;
 			}
-			else { st->curlym.c1 = (U8)*STRING(text_node); }
+			else { st->u.curlym.c1 = (U8)*STRING(text_node); }
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-			    st->curlym.c2 = PL_fold[st->curlym.c1];
+			    st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
 			else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-			    st->curlym.c2 = PL_fold_locale[st->curlym.c1];
+			    st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
 			else
-			    st->curlym.c2 = st->curlym.c1;
+			    st->u.curlym.c2 = st->u.curlym.c1;
 		    }
 		}
 		else
-		    st->curlym.c1 = st->curlym.c2 = -1000;
+		    st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 	    assume_ok_MM:
-		REGCP_SET(st->curlym.lastcp);
+		REGCP_SET(st->u.curlym.lastcp);
 		while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
 		    /* If it could work, try it. */
-		    if (st->curlym.c1 == -1000 ||
-			UCHARAT(PL_reginput) == st->curlym.c1 ||
-			UCHARAT(PL_reginput) == st->curlym.c2)
+		    if (st->u.curlym.c1 == -1000 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c2)
 		    {
-			if (st->curlym.paren) {
+			if (st->u.curlym.paren) {
 			    if (st->ln) {
-				PL_regstartp[st->curlym.paren] =
-				    HOPc(PL_reginput, -st->curlym.l) - PL_bostr;
-				PL_regendp[st->curlym.paren] = PL_reginput - PL_bostr;
+				PL_regstartp[st->u.curlym.paren] =
+				    HOPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+				PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
 			    }
 			    else
-				PL_regendp[st->curlym.paren] = -1;
+				PL_regendp[st->u.curlym.paren] = -1;
 			}
 			REGMATCH(next, CURLYM2);
 			/*** all unsaved local vars undefined at this point */
 			if (result)
 			    sayYES;
-			REGCP_UNWIND(st->curlym.lastcp);
+			REGCP_UNWIND(st->u.curlym.lastcp);
 		    }
 		    /* Couldn't or didn't -- move forward. */
 		    PL_reginput = locinput;
@@ -3922,65 +3922,65 @@ S_regmatch(pTHX_ regnode *prog)
 		    PerlIO_printf(Perl_debug_log,
 			      "%*s  matched %"IVdf" times, len=%"IVdf"...\n",
 			      (int)(REPORT_CODE_OFF+PL_regindent*2), "",
-			      (IV) st->curlym.matches, (IV)st->curlym.l)
+			      (IV) st->u.curlym.matches, (IV)st->u.curlym.l)
 		    );
-		if (st->curlym.matches >= st->ln) {
+		if (st->u.curlym.matches >= st->ln) {
 		    if (HAS_TEXT(next) || JUMPABLE(next)) {
 			regnode *text_node = next;
 
 			if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-			if (! HAS_TEXT(text_node)) st->curlym.c1 = st->curlym.c2 = -1000;
+			if (! HAS_TEXT(text_node)) st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 			else {
 			    if (PL_regkind[(U8)OP(text_node)] == REF) {
-				st->curlym.c1 = st->curlym.c2 = -1000;
+				st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 				goto assume_ok_REG;
 			    }
-			    else { st->curlym.c1 = (U8)*STRING(text_node); }
+			    else { st->u.curlym.c1 = (U8)*STRING(text_node); }
 
 			    if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-				st->curlym.c2 = PL_fold[st->curlym.c1];
+				st->u.curlym.c2 = PL_fold[st->u.curlym.c1];
 			    else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-				st->curlym.c2 = PL_fold_locale[st->curlym.c1];
+				st->u.curlym.c2 = PL_fold_locale[st->u.curlym.c1];
 			    else
-				st->curlym.c2 = st->curlym.c1;
+				st->u.curlym.c2 = st->u.curlym.c1;
 			}
 		    }
 		    else
-			st->curlym.c1 = st->curlym.c2 = -1000;
+			st->u.curlym.c1 = st->u.curlym.c2 = -1000;
 		}
 	    assume_ok_REG:
-		REGCP_SET(st->curlym.lastcp);
-		while (st->curlym.matches >= st->ln) {
+		REGCP_SET(st->u.curlym.lastcp);
+		while (st->u.curlym.matches >= st->ln) {
 		    /* If it could work, try it. */
-		    if (st->curlym.c1 == -1000 ||
-			UCHARAT(PL_reginput) == st->curlym.c1 ||
-			UCHARAT(PL_reginput) == st->curlym.c2)
+		    if (st->u.curlym.c1 == -1000 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c1 ||
+			UCHARAT(PL_reginput) == st->u.curlym.c2)
 		    {
 			DEBUG_EXECUTE_r(
 			    PerlIO_printf(Perl_debug_log,
 				"%*s  trying tail with matches=%"IVdf"...\n",
 				(int)(REPORT_CODE_OFF+PL_regindent*2),
-				"", (IV)st->curlym.matches)
+				"", (IV)st->u.curlym.matches)
 			    );
-			if (st->curlym.paren) {
-			    if (st->curlym.matches) {
-				PL_regstartp[st->curlym.paren]
-				    = HOPc(PL_reginput, -st->curlym.l) - PL_bostr;
-				PL_regendp[st->curlym.paren] = PL_reginput - PL_bostr;
+			if (st->u.curlym.paren) {
+			    if (st->u.curlym.matches) {
+				PL_regstartp[st->u.curlym.paren]
+				    = HOPc(PL_reginput, -st->u.curlym.l) - PL_bostr;
+				PL_regendp[st->u.curlym.paren] = PL_reginput - PL_bostr;
 			    }
 			    else
-				PL_regendp[st->curlym.paren] = -1;
+				PL_regendp[st->u.curlym.paren] = -1;
 			}
 			REGMATCH(next, CURLYM4);
 			/*** all unsaved local vars undefined at this point */
 			if (result)
 			    sayYES;
-			REGCP_UNWIND(st->curlym.lastcp);
+			REGCP_UNWIND(st->u.curlym.lastcp);
 		    }
 		    /* Couldn't or didn't -- back up. */
-		    st->curlym.matches--;
-		    locinput = HOPc(locinput, -st->curlym.l);
+		    st->u.curlym.matches--;
+		    locinput = HOPc(locinput, -st->u.curlym.l);
 		    PL_reginput = locinput;
 		}
 	    }
@@ -3989,17 +3989,17 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	}
 	case CURLYN:
-	    st->plus.paren = scan->flags;	/* Which paren to set */
-	    if (st->plus.paren > PL_regsize)
-		PL_regsize = st->plus.paren;
-	    if (st->plus.paren > (I32)*PL_reglastparen)
-		*PL_reglastparen = st->plus.paren;
+	    st->u.plus.paren = scan->flags;	/* Which paren to set */
+	    if (st->u.plus.paren > PL_regsize)
+		PL_regsize = st->u.plus.paren;
+	    if (st->u.plus.paren > (I32)*PL_reglastparen)
+		*PL_reglastparen = st->u.plus.paren;
 	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
             scan = regnext(NEXTOPER(scan) + NODE_STEP_REGNODE);
 	    goto repeat;
 	case CURLY:
-	    st->plus.paren = 0;
+	    st->u.plus.paren = 0;
 	    st->ln = ARG1(scan);  /* min to match */
 	    n  = ARG2(scan);  /* max to match */
 	    scan = NEXTOPER(scan) + NODE_STEP_REGNODE;
@@ -4008,13 +4008,13 @@ S_regmatch(pTHX_ regnode *prog)
 	    st->ln = 0;
 	    n = REG_INFTY;
 	    scan = NEXTOPER(scan);
-	    st->plus.paren = 0;
+	    st->u.plus.paren = 0;
 	    goto repeat;
 	case PLUS:
 	    st->ln = 1;
 	    n = REG_INFTY;
 	    scan = NEXTOPER(scan);
-	    st->plus.paren = 0;
+	    st->u.plus.paren = 0;
 	  repeat:
 	    /*
 	    * Lookahead to avoid useless match attempts
@@ -4033,20 +4033,20 @@ S_regmatch(pTHX_ regnode *prog)
 
 		if (! HAS_TEXT(text_node)) FIND_NEXT_IMPT(text_node);
 
-		if (! HAS_TEXT(text_node)) st->plus.c1 = st->plus.c2 = -1000;
+		if (! HAS_TEXT(text_node)) st->u.plus.c1 = st->u.plus.c2 = -1000;
 		else {
 		    if (PL_regkind[(U8)OP(text_node)] == REF) {
-			st->plus.c1 = st->plus.c2 = -1000;
+			st->u.plus.c1 = st->u.plus.c2 = -1000;
 			goto assume_ok_easy;
 		    }
 		    else { s = (U8*)STRING(text_node); }
 
 		    if (!UTF) {
-			st->plus.c2 = st->plus.c1 = *s;
+			st->u.plus.c2 = st->u.plus.c1 = *s;
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF)
-			    st->plus.c2 = PL_fold[st->plus.c1];
+			    st->u.plus.c2 = PL_fold[st->u.plus.c1];
 			else if (OP(text_node) == EXACTFL || OP(text_node) == REFFL)
-			    st->plus.c2 = PL_fold_locale[st->plus.c1];
+			    st->u.plus.c2 = PL_fold_locale[st->u.plus.c1];
 		    }
 		    else { /* UTF */
 			if (OP(text_node) == EXACTF || OP(text_node) == REFF) {
@@ -4057,20 +4057,20 @@ S_regmatch(pTHX_ regnode *prog)
 			     to_utf8_lower((U8*)s, tmpbuf1, &ulen1);
 			     to_utf8_upper((U8*)s, tmpbuf2, &ulen2);
 
-			     st->plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
+			     st->u.plus.c1 = utf8n_to_uvuni(tmpbuf1, UTF8_MAXBYTES, 0,
 						 uniflags);
-			     st->plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
+			     st->u.plus.c2 = utf8n_to_uvuni(tmpbuf2, UTF8_MAXBYTES, 0,
 						 uniflags);
 			}
 			else {
-			    st->plus.c2 = st->plus.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
+			    st->u.plus.c2 = st->u.plus.c1 = utf8n_to_uvchr(s, UTF8_MAXBYTES, 0,
 						     uniflags);
 			}
 		    }
 		}
 	    }
 	    else
-		st->plus.c1 = st->plus.c2 = -1000;
+		st->u.plus.c1 = st->u.plus.c2 = -1000;
 	assume_ok_easy:
 	    PL_reginput = locinput;
 	    if (st->minmod) {
@@ -4078,96 +4078,96 @@ S_regmatch(pTHX_ regnode *prog)
 		if (st->ln && regrepeat(scan, st->ln) < st->ln)
 		    sayNO;
 		locinput = PL_reginput;
-		REGCP_SET(st->plus.lastcp);
-		if (st->plus.c1 != -1000) {
-		    st->plus.old = locinput;
-		    st->plus.count = 0;
+		REGCP_SET(st->u.plus.lastcp);
+		if (st->u.plus.c1 != -1000) {
+		    st->u.plus.old = locinput;
+		    st->u.plus.count = 0;
 
 		    if  (n == REG_INFTY) {
-			st->plus.e = PL_regeol - 1;
+			st->u.plus.e = PL_regeol - 1;
 			if (do_utf8)
-			    while (UTF8_IS_CONTINUATION(*(U8*)st->plus.e))
-				st->plus.e--;
+			    while (UTF8_IS_CONTINUATION(*(U8*)st->u.plus.e))
+				st->u.plus.e--;
 		    }
 		    else if (do_utf8) {
 			int m = n - st->ln;
-			for (st->plus.e = locinput;
-			     m >0 && st->plus.e + UTF8SKIP(st->plus.e) <= PL_regeol; m--)
-			    st->plus.e += UTF8SKIP(st->plus.e);
+			for (st->u.plus.e = locinput;
+			     m >0 && st->u.plus.e + UTF8SKIP(st->u.plus.e) <= PL_regeol; m--)
+			    st->u.plus.e += UTF8SKIP(st->u.plus.e);
 		    }
 		    else {
-			st->plus.e = locinput + n - st->ln;
-			if (st->plus.e >= PL_regeol)
-			    st->plus.e = PL_regeol - 1;
+			st->u.plus.e = locinput + n - st->ln;
+			if (st->u.plus.e >= PL_regeol)
+			    st->u.plus.e = PL_regeol - 1;
 		    }
 		    while (1) {
 			/* Find place 'next' could work */
 			if (!do_utf8) {
-			    if (st->plus.c1 == st->plus.c2) {
-				while (locinput <= st->plus.e &&
-				       UCHARAT(locinput) != st->plus.c1)
+			    if (st->u.plus.c1 == st->u.plus.c2) {
+				while (locinput <= st->u.plus.e &&
+				       UCHARAT(locinput) != st->u.plus.c1)
 				    locinput++;
 			    } else {
-				while (locinput <= st->plus.e
-				       && UCHARAT(locinput) != st->plus.c1
-				       && UCHARAT(locinput) != st->plus.c2)
+				while (locinput <= st->u.plus.e
+				       && UCHARAT(locinput) != st->u.plus.c1
+				       && UCHARAT(locinput) != st->u.plus.c2)
 				    locinput++;
 			    }
-			    st->plus.count = locinput - st->plus.old;
+			    st->u.plus.count = locinput - st->u.plus.old;
 			}
 			else {
-			    if (st->plus.c1 == st->plus.c2) {
+			    if (st->u.plus.c1 == st->u.plus.c2) {
 				STRLEN len;
 				/* count initialised to
 				 * utf8_distance(old, locinput) */
-				while (locinput <= st->plus.e &&
+				while (locinput <= st->u.plus.e &&
 				       utf8n_to_uvchr((U8*)locinput,
 						      UTF8_MAXBYTES, &len,
-						      uniflags) != (UV)st->plus.c1) {
+						      uniflags) != (UV)st->u.plus.c1) {
 				    locinput += len;
-				    st->plus.count++;
+				    st->u.plus.count++;
 				}
 			    } else {
 				STRLEN len;
 				/* count initialised to
 				 * utf8_distance(old, locinput) */
-				while (locinput <= st->plus.e) {
+				while (locinput <= st->u.plus.e) {
 				    UV c = utf8n_to_uvchr((U8*)locinput,
 							  UTF8_MAXBYTES, &len,
 							  uniflags);
-				    if (c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+				    if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 					break;
 				    locinput += len;
-				    st->plus.count++;
+				    st->u.plus.count++;
 				}
 			    }
 			}
-			if (locinput > st->plus.e)
+			if (locinput > st->u.plus.e)
 			    sayNO;
 			/* PL_reginput == old now */
-			if (locinput != st->plus.old) {
+			if (locinput != st->u.plus.old) {
 			    st->ln = 1;	/* Did some */
-			    if (regrepeat(scan, st->plus.count) < st->plus.count)
+			    if (regrepeat(scan, st->u.plus.count) < st->u.plus.count)
 				sayNO;
 			}
 			/* PL_reginput == locinput now */
-			TRYPAREN(st->plus.paren, st->ln, locinput, PLUS1);
+			TRYPAREN(st->u.plus.paren, st->ln, locinput, PLUS1);
 			/*** all unsaved local vars undefined at this point */
 			PL_reginput = locinput;	/* Could be reset... */
-			REGCP_UNWIND(st->plus.lastcp);
+			REGCP_UNWIND(st->u.plus.lastcp);
 			/* Couldn't or didn't -- move forward. */
-			st->plus.old = locinput;
+			st->u.plus.old = locinput;
 			if (do_utf8)
 			    locinput += UTF8SKIP(locinput);
 			else
 			    locinput++;
-			st->plus.count = 1;
+			st->u.plus.count = 1;
 		    }
 		}
 		else
 		while (n >= st->ln || (n == REG_INFTY && st->ln > 0)) { /* ln overflow ? */
 		    UV c;
-		    if (st->plus.c1 != -1000) {
+		    if (st->u.plus.c1 != -1000) {
 			if (do_utf8)
 			    c = utf8n_to_uvchr((U8*)PL_reginput,
 					       UTF8_MAXBYTES, 0,
@@ -4175,19 +4175,19 @@ S_regmatch(pTHX_ regnode *prog)
 			else
 			    c = UCHARAT(PL_reginput);
 			/* If it could work, try it. */
-		        if (c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+		        if (c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 		        {
-			    TRYPAREN(st->plus.paren, st->ln, PL_reginput, PLUS2);
+			    TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS2);
 			    /*** all unsaved local vars undefined at this point */
-			    REGCP_UNWIND(st->plus.lastcp);
+			    REGCP_UNWIND(st->u.plus.lastcp);
 		        }
 		    }
 		    /* If it could work, try it. */
-		    else if (st->plus.c1 == -1000)
+		    else if (st->u.plus.c1 == -1000)
 		    {
-			TRYPAREN(st->plus.paren, st->ln, PL_reginput, PLUS3);
+			TRYPAREN(st->u.plus.paren, st->ln, PL_reginput, PLUS3);
 			/*** all unsaved local vars undefined at this point */
-			REGCP_UNWIND(st->plus.lastcp);
+			REGCP_UNWIND(st->u.plus.lastcp);
 		    }
 		    /* Couldn't or didn't -- move forward. */
 		    PL_reginput = locinput;
@@ -4213,11 +4213,11 @@ S_regmatch(pTHX_ regnode *prog)
 		    if (UCHARAT(PL_reginput - 1) == '\n' && OP(next) != EOS)
 			st->ln--;
 		}
-		REGCP_SET(st->plus.lastcp);
+		REGCP_SET(st->u.plus.lastcp);
 		{
 		    UV c = 0;
 		    while (n >= st->ln) {
-			if (st->plus.c1 != -1000) {
+			if (st->u.plus.c1 != -1000) {
 			    if (do_utf8)
 				c = utf8n_to_uvchr((U8*)PL_reginput,
 						   UTF8_MAXBYTES, 0,
@@ -4226,11 +4226,11 @@ S_regmatch(pTHX_ regnode *prog)
 				c = UCHARAT(PL_reginput);
 			}
 			/* If it could work, try it. */
-			if (st->plus.c1 == -1000 || c == (UV)st->plus.c1 || c == (UV)st->plus.c2)
+			if (st->u.plus.c1 == -1000 || c == (UV)st->u.plus.c1 || c == (UV)st->u.plus.c2)
 			    {
-				TRYPAREN(st->plus.paren, n, PL_reginput, PLUS4);
+				TRYPAREN(st->u.plus.paren, n, PL_reginput, PLUS4);
 				/*** all unsaved local vars undefined at this point */
-				REGCP_UNWIND(st->plus.lastcp);
+				REGCP_UNWIND(st->u.plus.lastcp);
 			    }
 			/* Couldn't or didn't -- back up. */
 			n--;
@@ -4242,12 +4242,12 @@ S_regmatch(pTHX_ regnode *prog)
 	    break;
 	case END:
 	    if (PL_reg_call_cc) {
-		st->end.cur_call_cc = PL_reg_call_cc;
-		st->end.end_re = PL_reg_re;
+		st->u.end.cur_call_cc = PL_reg_call_cc;
+		st->u.end.end_re = PL_reg_re;
 
 		/* Save *all* the positions. */
-		st->end.cp = regcppush(0);
-		REGCP_SET(st->end.lastcp);
+		st->u.end.cp = regcppush(0);
+		REGCP_SET(st->u.end.lastcp);
 
 		/* Restore parens of the caller. */
 		{
@@ -4261,22 +4261,22 @@ S_regmatch(pTHX_ regnode *prog)
 		PL_reginput = locinput;
 
 		cache_re(PL_reg_call_cc->re);
-		st->end.savecc = st->cc;
+		st->u.end.savecc = st->cc;
 		st->cc = PL_reg_call_cc->cc;
 		PL_reg_call_cc = PL_reg_call_cc->prev;
-		REGMATCH(st->end.cur_call_cc->node, END);
+		REGMATCH(st->u.end.cur_call_cc->node, END);
 		/*** all unsaved local vars undefined at this point */
 		if (result) {
-		    PL_reg_call_cc = st->end.cur_call_cc;
-		    regcpblow(st->end.cp);
+		    PL_reg_call_cc = st->u.end.cur_call_cc;
+		    regcpblow(st->u.end.cp);
 		    sayYES;
 		}
-		REGCP_UNWIND(st->end.lastcp);
+		REGCP_UNWIND(st->u.end.lastcp);
 		regcppop();
-		PL_reg_call_cc = st->end.cur_call_cc;
-		st->cc = st->end.savecc;
-		PL_reg_re = st->end.end_re;
-		cache_re(st->end.end_re);
+		PL_reg_call_cc = st->u.end.cur_call_cc;
+		st->cc = st->u.end.savecc;
+		PL_reg_re = st->u.end.end_re;
+		cache_re(st->u.end.end_re);
 
 		DEBUG_EXECUTE_r(
 		    PerlIO_printf(Perl_debug_log,