X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/2af232bd5d3f6bd1ea08b47ef83cc57f75149871..54ca4ee7252684545d9524460bab88037e5f584b:/regcomp.c

diff --git a/regcomp.c b/regcomp.c
index bc324ed..86b9140 100644
--- a/regcomp.c
+++ b/regcomp.c
@@ -55,7 +55,6 @@
 #  define PERL_NO_GET_CONTEXT
 #endif
 
-/*SUPPRESS 112*/
 /*
  * pregcomp and pregexec -- regsub and regerror are not used in perl
  *
@@ -80,7 +79,7 @@
  ****    Alterations to Henry's code are...
  ****
  ****    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- ****    2000, 2001, 2002, 2003, 2004, 2005, 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.
@@ -307,7 +306,7 @@ static const scan_data_t zero_scan_data =
  * Simple_vFAIL -- like FAIL, but marks the current location in the scan
  */
 #define	Simple_vFAIL(m) STMT_START {					\
-    IV offset = RExC_parse - RExC_precomp;				\
+    const IV offset = RExC_parse - RExC_precomp;			\
     Perl_croak(aTHX_ "%s" REPORT_LOCATION,				\
 	    m, (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
@@ -325,7 +324,7 @@ static const scan_data_t zero_scan_data =
  * Like Simple_vFAIL(), but accepts two arguments.
  */
 #define	Simple_vFAIL2(m,a1) STMT_START {			\
-    IV offset = RExC_parse - RExC_precomp;			\
+    const IV offset = RExC_parse - RExC_precomp;			\
     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1,			\
 	    (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
@@ -344,7 +343,7 @@ static const scan_data_t zero_scan_data =
  * Like Simple_vFAIL(), but accepts three arguments.
  */
 #define	Simple_vFAIL3(m, a1, a2) STMT_START {			\
-    IV offset = RExC_parse - RExC_precomp;			\
+    const IV offset = RExC_parse - RExC_precomp;		\
     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2,		\
 	    (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
@@ -362,29 +361,19 @@ static const scan_data_t zero_scan_data =
  * Like Simple_vFAIL(), but accepts four arguments.
  */
 #define	Simple_vFAIL4(m, a1, a2, a3) STMT_START {		\
-    IV offset = RExC_parse - RExC_precomp;			\
+    const IV offset = RExC_parse - RExC_precomp;		\
     S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2, a3,		\
 	    (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
 
-/*
- * Like Simple_vFAIL(), but accepts five arguments.
- */
-#define	Simple_vFAIL5(m, a1, a2, a3, a4) STMT_START {		\
-    IV offset = RExC_parse - RExC_precomp;			\
-    S_re_croak2(aTHX_ m, REPORT_LOCATION, a1, a2, a3, a4,	\
-	    (int)offset, RExC_precomp, RExC_precomp + offset);	\
-} STMT_END
-
-
 #define	vWARN(loc,m) STMT_START {					\
-    IV offset = loc - RExC_precomp;					\
+    const IV offset = loc - RExC_precomp;				\
     Perl_warner(aTHX_ packWARN(WARN_REGEXP), "%s" REPORT_LOCATION,	\
 	    m, (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
 
 #define	vWARNdep(loc,m) STMT_START {					\
-    IV offset = loc - RExC_precomp;					\
+    const IV offset = loc - RExC_precomp;				\
     Perl_warner(aTHX_ packWARN2(WARN_DEPRECATED, WARN_REGEXP),		\
 	    "%s" REPORT_LOCATION,					\
 	    m, (int)offset, RExC_precomp, RExC_precomp + offset);	\
@@ -392,25 +381,25 @@ static const scan_data_t zero_scan_data =
 
 
 #define	vWARN2(loc, m, a1) STMT_START {					\
-    IV offset = loc - RExC_precomp;					\
+    const IV offset = loc - RExC_precomp;				\
     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,		\
 	    a1, (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
 
 #define	vWARN3(loc, m, a1, a2) STMT_START {				\
-    IV offset = loc - RExC_precomp;					\
+    const IV offset = loc - RExC_precomp;				\
     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,		\
 	    a1, a2, (int)offset, RExC_precomp, RExC_precomp + offset);	\
 } STMT_END
 
 #define	vWARN4(loc, m, a1, a2, a3) STMT_START {				\
-    IV offset = loc - RExC_precomp;					\
+    const IV offset = loc - RExC_precomp;				\
     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,		\
 	    a1, a2, a3, (int)offset, RExC_precomp, RExC_precomp + offset); \
 } STMT_END
 
 #define	vWARN5(loc, m, a1, a2, a3, a4) STMT_START {			\
-    IV offset = loc - RExC_precomp;					\
+    const IV offset = loc - RExC_precomp;				\
     Perl_warner(aTHX_ packWARN(WARN_REGEXP), m REPORT_LOCATION,		\
 	    a1, a2, a3, a4, (int)offset, RExC_precomp, RExC_precomp + offset); \
 } STMT_END
@@ -436,7 +425,7 @@ static const scan_data_t zero_scan_data =
 	MJD_OFFSET_DEBUG(("** (%d) offset of node %d is %d.\n",		\
 		__LINE__, (node), (byte)));				\
 	if((node) < 0) {						\
-	    Perl_croak(aTHX_ "value of node is %d in Offset macro", node); \
+	    Perl_croak(aTHX_ "value of node is %d in Offset macro", (int)(node)); \
 	} else {							\
 	    RExC_offsets[2*(node)-1] = (byte);				\
 	}								\
@@ -450,9 +439,9 @@ static const scan_data_t zero_scan_data =
 #define Set_Node_Length_To_R(node,len) STMT_START {			\
     if (! SIZE_ONLY) {							\
 	MJD_OFFSET_DEBUG(("** (%d) size of node %d is %d.\n",		\
-		__LINE__, (node), (len)));				\
+		__LINE__, (int)(node), (int)(len)));			\
 	if((node) < 0) {						\
-	    Perl_croak(aTHX_ "value of node is %d in Length macro", node); \
+	    Perl_croak(aTHX_ "value of node is %d in Length macro", (int)(node)); \
 	} else {							\
 	    RExC_offsets[2*(node)] = (len);				\
 	}								\
@@ -507,8 +496,8 @@ S_scan_commit(pTHX_ RExC_state_t *pRExC_state, scan_data_t *data)
     }
     SvCUR_set(data->last_found, 0);
     {
-	SV * sv = data->last_found;
-	MAGIC *mg =
+	SV * const sv = data->last_found;
+	MAGIC * const mg =
 	    SvUTF8(sv) && SvMAGICAL(sv) ? mg_find(sv, PERL_MAGIC_utf8) : NULL;
 	if (mg && mg->mg_len > 0)
 	    mg->mg_len = 0;
@@ -530,7 +519,7 @@ S_cl_anything(pTHX_ RExC_state_t *pRExC_state, struct regnode_charclass_class *c
 
 /* Can match anything (initialization) */
 STATIC int
-S_cl_is_anything(pTHX_ struct regnode_charclass_class *cl)
+S_cl_is_anything(pTHX_ const struct regnode_charclass_class *cl)
 {
     int value;
 
@@ -567,7 +556,7 @@ S_cl_init_zero(pTHX_ RExC_state_t *pRExC_state, struct regnode_charclass_class *
 /* We assume that cl is not inverted */
 STATIC void
 S_cl_and(pTHX_ struct regnode_charclass_class *cl,
-	 struct regnode_charclass_class *and_with)
+	const struct regnode_charclass_class *and_with)
 {
     if (!(and_with->flags & ANYOF_CLASS)
 	&& !(cl->flags & ANYOF_CLASS)
@@ -603,7 +592,7 @@ S_cl_and(pTHX_ struct regnode_charclass_class *cl,
 /* 'OR' a given class with another one.  Can create false positives */
 /* We assume that cl is not inverted */
 STATIC void
-S_cl_or(pTHX_ RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, struct regnode_charclass_class *or_with)
+S_cl_or(pTHX_ RExC_state_t *pRExC_state, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with)
 {
     if (or_with->flags & ANYOF_INVERT) {
 	/* We do not use
@@ -776,7 +765,7 @@ and would end up looking like:
     DEBUG_TRIE_COMPILE_r({                                                 \
 	SV *tmp;                                                           \
 	if ( UTF ) {                                                       \
-	    tmp = newSVpv( "", 0 );                                        \
+	    tmp = newSVpvn( "", 0 );                                       \
 	    pv_uni_display( tmp, uc, len, 60, UNI_DISPLAY_REGEX );         \
 	} else {                                                           \
 	    tmp = Perl_newSVpvf_nocontext( "%c", (int)uvc );               \
@@ -825,7 +814,7 @@ and would end up looking like:
 } STMT_END
 
 #define TRIE_LIST_NEW(state) STMT_START {                       \
-    Newz( 1023, trie->states[ state ].trans.list,               \
+    Newxz( trie->states[ state ].trans.list,               \
 	4, reg_trie_trans_le );                                 \
      TRIE_LIST_CUR( state ) = 1;                                \
      TRIE_LIST_LEN( state ) = 4;                                \
@@ -857,10 +846,10 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 
     GET_RE_DEBUG_FLAGS_DECL;
 
-    Newz( 848200, trie, 1, reg_trie_data );
+    Newxz( trie, 1, reg_trie_data );
     trie->refcount = 1;
     RExC_rx->data->data[ data_slot ] = (void*)trie;
-    Newz( 848201, trie->charmap, 256, U16 );
+    Newxz( trie->charmap, 256, U16 );
     DEBUG_r({
         trie->words = newAV();
         trie->revcharmap = newAV();
@@ -897,9 +886,9 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 
 
     for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
-        regnode *noper = NEXTOPER( cur );
+        regnode * const noper = NEXTOPER( cur );
         const U8 *uc = (U8*)STRING( noper );
-        const U8 *e  = uc + STR_LEN( noper );
+        const U8 * const e  = uc + STR_LEN( noper );
         STRLEN foldlen = 0;
         U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
         const U8 *scan = (U8*)NULL;
@@ -935,7 +924,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
     DEBUG_TRIE_COMPILE_r(
         PerlIO_printf( Perl_debug_log, "TRIE(%s): W:%d C:%d Uq:%d \n",
                 ( trie->widecharmap ? "UTF8" : "NATIVE" ), trie->wordcount,
-                trie->charcount, trie->uniquecharcount )
+                (int)trie->charcount, trie->uniquecharcount )
     );
 
 
@@ -979,79 +968,76 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 
         STRLEN transcount = 1;
 
-        Newz( 848204, trie->states, trie->charcount + 2, reg_trie_state );
+        Newxz( trie->states, trie->charcount + 2, reg_trie_state );
         TRIE_LIST_NEW(1);
         next_alloc = 2;
 
         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
 
-        regnode *noper   = NEXTOPER( cur );
-        U8 *uc           = (U8*)STRING( noper );
-        U8 *e            = uc + STR_LEN( noper );
-        U32 state        = 1;         /* required init */
-        U16 charid       = 0;         /* sanity init */
-        U8 *scan         = (U8*)NULL; /* sanity init */
-        STRLEN foldlen   = 0;         /* required init */
-        U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
-
-
-        for ( ; uc < e ; uc += len ) {
-
-            TRIE_READ_CHAR;
-
-            if ( uvc < 256 ) {
-                charid = trie->charmap[ uvc ];
-            } else {
-                SV** svpp=(SV**)NULL;
-                svpp = hv_fetch( trie->widecharmap, (char*)&uvc, sizeof( UV ), 0);
-                if ( !svpp ) {
-                    charid = 0;
-                } else {
-                    charid=(U16)SvIV( *svpp );
-                }
-            }
-            if ( charid ) {
-
-                U16 check;
-                U32 newstate = 0;
+	    regnode * const noper = NEXTOPER( cur );
+	    U8 *uc           = (U8*)STRING( noper );
+	    const U8 * const e = uc + STR_LEN( noper );
+	    U32 state        = 1;         /* required init */
+	    U16 charid       = 0;         /* sanity init */
+	    U8 *scan         = (U8*)NULL; /* sanity init */
+	    STRLEN foldlen   = 0;         /* required init */
+	    U8 foldbuf[ UTF8_MAXBYTES_CASE + 1 ];
+
+	    for ( ; uc < e ; uc += len ) {
+
+		TRIE_READ_CHAR;
+
+		if ( uvc < 256 ) {
+		    charid = trie->charmap[ uvc ];
+		} else {
+		    SV** const svpp = hv_fetch( trie->widecharmap, (char*)&uvc, sizeof( UV ), 0);
+		    if ( !svpp ) {
+			charid = 0;
+		    } else {
+			charid=(U16)SvIV( *svpp );
+		    }
+		}
+		if ( charid ) {
 
-                charid--;
-                if ( !trie->states[ state ].trans.list ) {
-                    TRIE_LIST_NEW( state );
-                }
-                for ( check = 1; check <= TRIE_LIST_USED( state ); check++ ) {
-                    if ( TRIE_LIST_ITEM( state, check ).forid == charid ) {
-                        newstate = TRIE_LIST_ITEM( state, check ).newstate;
-                        break;
-                    }
-                    }
-                    if ( ! newstate ) {
-                        newstate = next_alloc++;
-                        TRIE_LIST_PUSH( state, charid, newstate );
-                        transcount++;
-                    }
-                    state = newstate;
+		    U16 check;
+		    U32 newstate = 0;
 
-            } else {
-                Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
-            }
-            /* charid is now 0 if we dont know the char read, or nonzero if we do */
-        }
+		    charid--;
+		    if ( !trie->states[ state ].trans.list ) {
+			TRIE_LIST_NEW( state );
+		    }
+		    for ( check = 1; check <= TRIE_LIST_USED( state ); check++ ) {
+			if ( TRIE_LIST_ITEM( state, check ).forid == charid ) {
+			    newstate = TRIE_LIST_ITEM( state, check ).newstate;
+			    break;
+			}
+		    }
+		    if ( ! newstate ) {
+			newstate = next_alloc++;
+			TRIE_LIST_PUSH( state, charid, newstate );
+			transcount++;
+		    }
+		    state = newstate;
+		} else {
+		    Perl_croak( aTHX_ "panic! In trie construction, no char mapping for %"IVdf, uvc );
+		}
+		/* charid is now 0 if we dont know the char read, or nonzero if we do */
+	    }
 
-        if ( !trie->states[ state ].wordnum ) {
-            /* we havent inserted this word into the structure yet. */
-            trie->states[ state ].wordnum = ++curword;
+	    if ( !trie->states[ state ].wordnum ) {
+		/* we havent inserted this word into the structure yet. */
+		trie->states[ state ].wordnum = ++curword;
 
-            DEBUG_r({
-                /* store the word for dumping */
-                SV* tmp = newSVpvn( STRING( noper ), STR_LEN( noper ) );
-                if ( UTF ) SvUTF8_on( tmp );
-                av_push( trie->words, tmp );
-            });
+		DEBUG_r({
+		    /* store the word for dumping */
+		    SV* tmp = newSVpvn( STRING( noper ), STR_LEN( noper ) );
+		    if ( UTF ) SvUTF8_on( tmp );
+		    av_push( trie->words, tmp );
+		});
 
-        } else {
-            /* Its a dupe. So ignore it. */
-        }
+	    } else {
+		/* Its a dupe. So ignore it. */
+	    }
 
         } /* end second pass */
 
@@ -1060,16 +1046,14 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 
         DEBUG_TRIE_COMPILE_MORE_r({
             U32 state;
-            U16 charid;
 
-            /*
-               print out the table precompression.
-             */
+            /* print out the table precompression.  */
 
             PerlIO_printf( Perl_debug_log, "\nState :Word | Transition Data\n" );
             PerlIO_printf( Perl_debug_log,   "------:-----+-----------------" );
 
             for( state=1 ; state < next_alloc ; state ++ ) {
+		U16 charid;
 
                 PerlIO_printf( Perl_debug_log, "\n %04"UVXf" :", (UV)state  );
                 if ( ! trie->states[ state ].wordnum ) {
@@ -1082,7 +1066,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
                 for( charid = 1 ; charid <= TRIE_LIST_USED( state ) ; charid++ ) {
                     SV **tmp = av_fetch( trie->revcharmap, TRIE_LIST_ITEM(state,charid).forid, 0);
                     PerlIO_printf( Perl_debug_log, "%s:%3X=%04"UVXf" | ",
-                        SvPV_nolen( *tmp ),
+                        SvPV_nolen_const( *tmp ),
                         TRIE_LIST_ITEM(state,charid).forid,
                         (UV)TRIE_LIST_ITEM(state,charid).newstate
                     );
@@ -1092,10 +1076,9 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
             PerlIO_printf( Perl_debug_log, "\n\n" );
         });
 
-        Newz( 848203, trie->trans, transcount ,reg_trie_trans );
+        Newxz( trie->trans, transcount ,reg_trie_trans );
         {
             U32 state;
-            U16 idx;
             U32 tp = 0;
             U32 zp = 0;
 
@@ -1112,14 +1095,15 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
                 if (trie->states[state].trans.list) {
                     U16 minid=TRIE_LIST_ITEM( state, 1).forid;
                     U16 maxid=minid;
-
+		    U16 idx;
 
                     for( idx = 2 ; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
-                        if ( TRIE_LIST_ITEM( state, idx).forid < minid ) {
-                            minid=TRIE_LIST_ITEM( state, idx).forid;
-                        } else if ( TRIE_LIST_ITEM( state, idx).forid > maxid ) {
-                            maxid=TRIE_LIST_ITEM( state, idx).forid;
-                        }
+			const U16 forid = TRIE_LIST_ITEM( state, idx).forid;
+			if ( forid < minid ) {
+			    minid=forid;
+			} else if ( forid > maxid ) {
+			    maxid=forid;
+			}
                     }
                     if ( transcount < tp + maxid - minid + 1) {
                         transcount *= 2;
@@ -1146,7 +1130,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
                         }
                     } else {
                         for ( idx=1; idx <= TRIE_LIST_USED( state ) ; idx++ ) {
-                            U32 tid = base -  trie->uniquecharcount + TRIE_LIST_ITEM( state, idx ).forid;
+                            const U32 tid = base -  trie->uniquecharcount + TRIE_LIST_ITEM( state, idx ).forid;
                             trie->trans[ tid ].next = TRIE_LIST_ITEM( state, idx ).newstate;
                             trie->trans[ tid ].check = state;
                         }
@@ -1200,16 +1184,16 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 
         */
 
-        Newz( 848203, trie->trans, ( trie->charcount + 1 ) * trie->uniquecharcount + 1,
+        Newxz( trie->trans, ( trie->charcount + 1 ) * trie->uniquecharcount + 1,
               reg_trie_trans );
-        Newz( 848204, trie->states, trie->charcount + 2, reg_trie_state );
+        Newxz( trie->states, trie->charcount + 2, reg_trie_state );
         next_alloc = trie->uniquecharcount + 1;
 
         for ( cur = first ; cur < last ; cur = regnext( cur ) ) {
 
-            regnode *noper   = NEXTOPER( cur );
-            U8 *uc           = (U8*)STRING( noper );
-            U8 *e            = uc + STR_LEN( noper );
+	    regnode * const noper   = NEXTOPER( cur );
+	    const U8 *uc     = (U8*)STRING( noper );
+	    const U8 * const e = uc + STR_LEN( noper );
 
             U32 state        = 1;         /* required init */
 
@@ -1228,13 +1212,8 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
                 if ( uvc < 256 ) {
                     charid = trie->charmap[ uvc ];
                 } else {
-                    SV** svpp=(SV**)NULL;
-                    svpp = hv_fetch( trie->widecharmap, (char*)&uvc, sizeof( UV ), 0);
-                    if ( !svpp ) {
-                        charid = 0;
-                    } else {
-                        charid=(U16)SvIV( *svpp );
-                    }
+		    SV* const * const svpp = hv_fetch( trie->widecharmap, (char*)&uvc, sizeof( UV ), 0);
+		    charid = svpp ? (U16)SvIV(*svpp) : 0;
                 }
                 if ( charid ) {
                     charid--;
@@ -1280,7 +1259,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
             for( charid = 0 ; charid < trie->uniquecharcount ; charid++ ) {
                 SV **tmp = av_fetch( trie->revcharmap, charid, 0);
                 if ( tmp ) {
-                  PerlIO_printf( Perl_debug_log, "%4.4s ", SvPV_nolen( *tmp ) );
+                  PerlIO_printf( Perl_debug_log, "%4.4s ", SvPV_nolen_const( *tmp ) );
                 }
             }
 
@@ -1370,16 +1349,16 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 
            demq
         */
-        U32 laststate = TRIE_NODENUM( next_alloc );
-        U32 used , state, charid;
+        const U32 laststate = TRIE_NODENUM( next_alloc );
+	U32 state, charid;
         U32 pos = 0, zp=0;
         trie->laststate = laststate;
 
         for ( state = 1 ; state < laststate ; state++ ) {
             U8 flag = 0;
-            U32 stateidx = TRIE_NODEIDX( state );
-            U32 o_used=trie->trans[ stateidx ].check;
-            used = trie->trans[ stateidx ].check;
+	    const U32 stateidx = TRIE_NODEIDX( state );
+	    const U32 o_used = trie->trans[ stateidx ].check;
+	    U32 used = trie->trans[ stateidx ].check;
             trie->trans[ stateidx ].check = 0;
 
             for ( charid = 0 ; used && charid < trie->uniquecharcount ; charid++ ) {
@@ -1414,7 +1393,9 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
         DEBUG_TRIE_COMPILE_MORE_r(
                 PerlIO_printf( Perl_debug_log,
 		    " Alloc: %d Orig: %"IVdf" elements, Final:%"IVdf". Savings of %%%5.2f\n",
-                    ( ( trie->charcount + 1 ) * trie->uniquecharcount + 1 ), (IV)next_alloc, (IV)pos,
+		    (int)( ( trie->charcount + 1 ) * trie->uniquecharcount + 1 ),
+		    (IV)next_alloc,
+		    (IV)pos,
                     ( ( next_alloc - pos ) * 100 ) / (double)next_alloc );
             );
 
@@ -1435,7 +1416,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
         for( state = 0 ; state < trie->uniquecharcount ; state++ ) {
             SV **tmp = av_fetch( trie->revcharmap, state, 0);
             if ( tmp ) {
-              PerlIO_printf( Perl_debug_log, "%4.4s ", SvPV_nolen( *tmp ) );
+              PerlIO_printf( Perl_debug_log, "%4.4s ", SvPV_nolen_const( *tmp ) );
             }
         }
         PerlIO_printf( Perl_debug_log, "\n-----:-----------------------");
@@ -1445,7 +1426,7 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
         PerlIO_printf( Perl_debug_log, "\n");
 
         for( state = 1 ; state < trie->laststate ; state++ ) {
-            U32 base = trie->states[ state ].trans.base;
+	    const U32 base = trie->states[ state ].trans.base;
 
             PerlIO_printf( Perl_debug_log, "#%04"UVXf" ", (UV)state);
 
@@ -1548,16 +1529,18 @@ S_make_trie(pTHX_ RExC_state_t *pRExC_state, regnode *startbranch, regnode *firs
 /* REx optimizer.  Converts nodes into quickier variants "in place".
    Finds fixed substrings.  */
 
-/* Stops at toplevel WHILEM as well as at `last'. At end *scanp is set
+/* Stops at toplevel WHILEM as well as at "last". At end *scanp is set
    to the position after last scanned or to NULL. */
 
 
 STATIC I32
-S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, regnode *last, scan_data_t *data, U32 flags, U32 depth)
+S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap,
+			regnode *last, scan_data_t *data, U32 flags, U32 depth)
 			/* scanp: Start here (read-write). */
 			/* deltap: Write maxlen-minlen here. */
 			/* last: Stop before this one. */
 {
+    dVAR;
     I32 min = 0, pars = 0, code;
     regnode *scan = *scanp, *next;
     I32 delta = 0;
@@ -1573,10 +1556,10 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
     while (scan && OP(scan) != END && scan < last) {
 	/* Peephole optimizer: */
 	DEBUG_OPTIMISE_r({
-	  SV *mysv=sv_newmortal();
+	  SV * const mysv=sv_newmortal();
 	  regprop( mysv, scan);
 	  PerlIO_printf(Perl_debug_log, "%*speep: %s (0x%08"UVXf")\n",
-	    (int)depth*2, "", SvPV_nolen(mysv), PTR2UV(scan));
+	    (int)depth*2, "", SvPV_nolen_const(mysv), PTR2UV(scan));
 	});
 
 	if (PL_regkind[(U8)OP(scan)] == EXACT) {
@@ -1606,8 +1589,8 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 		    n = regnext(n);
 		}
 		else if (stringok) {
-		    int oldl = STR_LEN(scan);
-		    regnode *nnext = regnext(n);
+		    const int oldl = STR_LEN(scan);
+		    regnode * const nnext = regnext(n);
 
 		    if (oldl + STR_LEN(n) > U8_MAX)
 			break;
@@ -1652,10 +1635,11 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
    another valid sequence of UTF-8 bytes.
 
 */
-		 char *s0 = STRING(scan), *s, *t;
-		 char *s1 = s0 + STR_LEN(scan) - 1, *s2 = s1 - 4;
-                 const char *t0 = "\xcc\x88\xcc\x81";
-                 const char *t1 = t0 + 3;
+		 char * const s0 = STRING(scan), *s, *t;
+		 char * const s1 = s0 + STR_LEN(scan) - 1;
+		 char * const s2 = s1 - 4;
+		 const char * const t0 = "\xcc\x88\xcc\x81";
+		 const char * const t1 = t0 + 3;
 
 		 for (s = s0 + 2;
 		      s < s2 && (t = ninstr(s, s1, t0, t1));
@@ -1684,7 +1668,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 	/* Follow the next-chain of the current node and optimize
 	   away all the NOTHINGs from it.  */
 	if (OP(scan) != CURLYX) {
-	    int max = (reg_off_by_arg[OP(scan)]
+	    const int max = (reg_off_by_arg[OP(scan)]
 		       ? I32_MAX
 		       /* I32 may be smaller than U16 on CRAYs! */
 		       : (I32_MAX < U16_MAX ? I32_MAX : U16_MAX));
@@ -1852,7 +1836,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
                         U32 count=0;
 
 #ifdef DEBUGGING
-                        SV *mysv = sv_newmortal();       /* for dumping */
+                        SV * const mysv = sv_newmortal();       /* for dumping */
 #endif
                         /* var tail is used because there may be a TAIL
                            regop in the way. Ie, the exacts will point to the
@@ -1870,7 +1854,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
                         DEBUG_OPTIMISE_r({
                             regprop( mysv, tail );
                             PerlIO_printf( Perl_debug_log, "%*s%s%s%s\n",
-                                (int)depth * 2 + 2, "", "Tail node is:", SvPV_nolen( mysv ),
+                                (int)depth * 2 + 2, "", "Tail node is:", SvPV_nolen_const( mysv ),
                                 (RExC_seen_evals) ? "[EVAL]" : ""
                             );
                         });
@@ -1901,22 +1885,22 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 
                         /* dont use tail as the end marker for this traverse */
                         for ( cur = startbranch ; cur != scan ; cur = regnext( cur ) ) {
-                            regnode *noper = NEXTOPER( cur );
-                            regnode *noper_next = regnext( noper );
+                            regnode * const noper = NEXTOPER( cur );
+                            regnode * const noper_next = regnext( noper );
 
                             DEBUG_OPTIMISE_r({
                                 regprop( mysv, cur);
                                 PerlIO_printf( Perl_debug_log, "%*s%s",
-                                   (int)depth * 2 + 2,"  ", SvPV_nolen( mysv ) );
+                                   (int)depth * 2 + 2,"  ", SvPV_nolen_const( mysv ) );
 
                                 regprop( mysv, noper);
                                 PerlIO_printf( Perl_debug_log, " -> %s",
-                                    SvPV_nolen(mysv));
+                                    SvPV_nolen_const(mysv));
 
                                 if ( noper_next ) {
                                   regprop( mysv, noper_next );
                                   PerlIO_printf( Perl_debug_log,"\t=> %s\t",
-                                    SvPV_nolen(mysv));
+                                    SvPV_nolen_const(mysv));
                                 }
                                 PerlIO_printf( Perl_debug_log, "0x%p,0x%p,0x%p)\n",
                                    first, last, cur );
@@ -1934,20 +1918,20 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
                                         if (!last ) {
                                             regprop( mysv, first);
                                             PerlIO_printf( Perl_debug_log, "%*s%s",
-                                              (int)depth * 2 + 2, "F:", SvPV_nolen( mysv ) );
+                                              (int)depth * 2 + 2, "F:", SvPV_nolen_const( mysv ) );
                                             regprop( mysv, NEXTOPER(first) );
                                             PerlIO_printf( Perl_debug_log, " -> %s\n",
-                                              SvPV_nolen( mysv ) );
+                                              SvPV_nolen_const( mysv ) );
                                         }
                                     );
                                     last = cur;
                                     DEBUG_OPTIMISE_r({
                                         regprop( mysv, cur);
                                         PerlIO_printf( Perl_debug_log, "%*s%s",
-                                          (int)depth * 2 + 2, "N:", SvPV_nolen( mysv ) );
+                                          (int)depth * 2 + 2, "N:", SvPV_nolen_const( mysv ) );
                                         regprop( mysv, noper );
                                         PerlIO_printf( Perl_debug_log, " -> %s\n",
-                                          SvPV_nolen( mysv ) );
+                                          SvPV_nolen_const( mysv ) );
                                     });
                                 }
                             } else {
@@ -1976,7 +1960,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
                             regprop( mysv, cur);
                             PerlIO_printf( Perl_debug_log,
                               "%*s%s\t(0x%p,0x%p,0x%p)\n", (int)depth * 2 + 2,
-                              "  ", SvPV_nolen( mysv ), first, last, cur);
+                              "  ", SvPV_nolen_const( mysv ), first, last, cur);
 
                         });
                         if ( last ) {
@@ -1997,11 +1981,13 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 	}
 	else if (OP(scan) == EXACT) {
 	    I32 l = STR_LEN(scan);
-	    UV uc = *((U8*)STRING(scan));
+	    UV uc;
 	    if (UTF) {
-		U8 *s = (U8*)STRING(scan);
+		const U8 * const s = (U8*)STRING(scan);
 		l = utf8_length(s, s + l);
 		uc = utf8_to_uvchr(s, NULL);
+	    } else {
+		uc = *((U8*)STRING(scan));
 	    }
 	    min += l;
 	    if (flags & SCF_DO_SUBSTR) { /* Update longest substr. */
@@ -2014,8 +2000,8 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 		}
 		sv_catpvn(data->last_found, STRING(scan), STR_LEN(scan));
 		{
-		    SV * sv = data->last_found;
-		    MAGIC *mg = SvUTF8(sv) && SvMAGICAL(sv) ?
+		    SV * const sv = data->last_found;
+		    MAGIC * const mg = SvUTF8(sv) && SvMAGICAL(sv) ?
 			mg_find(sv, PERL_MAGIC_utf8) : NULL;
 		    if (mg && mg->mg_len >= 0)
 			mg->mg_len += utf8_length((U8*)STRING(scan),
@@ -2215,12 +2201,12 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 		}
 		if (!scan) 		/* It was not CURLYX, but CURLY. */
 		    scan = next;
-		if (ckWARN(WARN_REGEXP)
-		       /* ? quantifier ok, except for (?{ ... }) */
-		    && (next_is_eval || !(mincount == 0 && maxcount == 1))
+		if ( /* ? quantifier ok, except for (?{ ... }) */
+		    (next_is_eval || !(mincount == 0 && maxcount == 1))
 		    && (minnext == 0) && (deltanext == 0)
 		    && data && !(data->flags & (SF_HAS_PAR|SF_IN_PAR))
-		    && maxcount <= REG_INFTY/3) /* Complement check for big count */
+		    && maxcount <= REG_INFTY/3 /* Complement check for big count */
+		    && ckWARN(WARN_REGEXP))
 		{
 		    vWARN(RExC_parse,
 			  "Quantifier unexpected on zero-length expression");
@@ -2346,14 +2332,14 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 		if (data && fl & (SF_HAS_PAR|SF_IN_PAR))
 		    pars++;
 		if (flags & SCF_DO_SUBSTR) {
-		    SV *last_str = Nullsv;
+		    SV *last_str = NULL;
 		    int counted = mincount != 0;
 
 		    if (data->last_end > 0 && mincount != 0) { /* Ends with a string. */
 #if defined(SPARC64_GCC_WORKAROUND)
 			I32 b = 0;
 			STRLEN l = 0;
-			char *s = NULL;
+			const char *s = NULL;
 			I32 old = 0;
 
 			if (pos_before >= data->last_start_min)
@@ -2362,14 +2348,14 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 			    b = data->last_start_min;
 
 			l = 0;
-			s = SvPV(data->last_found, l);
+			s = SvPV_const(data->last_found, l);
 			old = b - data->last_start_min;
 
 #else
 			I32 b = pos_before >= data->last_start_min
 			    ? pos_before : data->last_start_min;
 			STRLEN l;
-			char *s = SvPV(data->last_found, l);
+			const char *s = SvPV_const(data->last_found, l);
 			I32 old = b - data->last_start_min;
 #endif
 
@@ -2386,7 +2372,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 			    if (mincount > 1) {
 				SvGROW(last_str, (mincount * l) + 1);
 				repeatcpy(SvPVX(last_str) + l,
-					  SvPVX(last_str), l, mincount - 1);
+					  SvPVX_const(last_str), l, mincount - 1);
 				SvCUR_set(last_str, SvCUR(last_str) * mincount);
 				/* Add additional parts. */
 				SvCUR_set(data->last_found,
@@ -2701,7 +2687,7 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 	    if (data)
 		data->whilem_c = data_fake.whilem_c;
 	    if (f & SCF_DO_STCLASS_AND) {
-		int was = (data->start_class->flags & ANYOF_EOS);
+		const int was = (data->start_class->flags & ANYOF_EOS);
 
 		cl_and(data->start_class, &intrnl);
 		if (was)
@@ -2770,9 +2756,9 @@ S_add_data(pTHX_ RExC_state_t *pRExC_state, I32 n, const char *s)
 	RExC_rx->data->count += n;
     }
     else {
-	Newc(1207, RExC_rx->data, sizeof(*RExC_rx->data) + sizeof(void*) * (n - 1),
+	Newxc(RExC_rx->data, sizeof(*RExC_rx->data) + sizeof(void*) * (n - 1),
 	     char, struct reg_data);
-	New(1208, RExC_rx->data->what, n, U8);
+	Newx(RExC_rx->data->what, n, U8);
 	RExC_rx->data->count = n;
     }
     Copy(s, RExC_rx->data->what + RExC_rx->data->count - n, n, U8);
@@ -2782,21 +2768,23 @@ S_add_data(pTHX_ RExC_state_t *pRExC_state, I32 n, const char *s)
 void
 Perl_reginitcolors(pTHX)
 {
-    int i = 0;
-    char *s = PerlEnv_getenv("PERL_RE_COLORS");
-	
+    dVAR;
+    const char * const s = PerlEnv_getenv("PERL_RE_COLORS");
     if (s) {
-	PL_colors[0] = s = savepv(s);
+	char *t = savepv(s);
+	int i = 0;
+	PL_colors[0] = t;
 	while (++i < 6) {
-	    s = strchr(s, '\t');
-	    if (s) {
-		*s = '\0';
-		PL_colors[i] = ++s;
+	    t = strchr(t, '\t');
+	    if (t) {
+		*t = '\0';
+		PL_colors[i] = ++t;
 	    }
 	    else
-		PL_colors[i] = s = (char *)"";
+		PL_colors[i] = t = (char *)"";
 	}
     } else {
+	int i = 0;
 	while (i < 6)
 	    PL_colors[i++] = (char *)"";
     }
@@ -2822,6 +2810,7 @@ Perl_reginitcolors(pTHX)
 regexp *
 Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 {
+    dVAR;
     register regexp *r;
     regnode *scan;
     regnode *first;
@@ -2869,7 +2858,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
     REGC((U8)REG_MAGIC, (char*)RExC_emit);
 #endif
     if (reg(pRExC_state, 0, &flags) == NULL) {
-	RExC_precomp = Nullch;
+	RExC_precomp = NULL;
 	return(NULL);
     }
     DEBUG_COMPILE_r(PerlIO_printf(Perl_debug_log, "size %"IVdf" ", (IV)RExC_size));
@@ -2884,7 +2873,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	RExC_whilem_seen = 15;
 
     /* Allocate space and initialize. */
-    Newc(1001, r, sizeof(regexp) + (unsigned)RExC_size * sizeof(regnode),
+    Newxc(r, sizeof(regexp) + (unsigned)RExC_size * sizeof(regnode),
 	 char, regexp);
     if (r == NULL)
 	FAIL("Regexp out of space");
@@ -2897,8 +2886,8 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
     r->prelen = xend - exp;
     r->precomp = savepvn(RExC_precomp, r->prelen);
     r->subbeg = NULL;
-#ifdef PERL_COPY_ON_WRITE
-    r->saved_copy = Nullsv;
+#ifdef PERL_OLD_COPY_ON_WRITE
+    r->saved_copy = NULL;
 #endif
     r->reganch = pm->op_pmflags & PMf_COMPILETIME;
     r->nparens = RExC_npar - 1;	/* set early to validate backrefs */
@@ -2907,7 +2896,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
     r->startp = 0;			/* Useful during FAIL. */
     r->endp = 0;			/* Useful during FAIL. */
 
-    Newz(1304, r->offsets, 2*RExC_size+1, U32); /* MJD 20001228 */
+    Newxz(r->offsets, 2*RExC_size+1, U32); /* MJD 20001228 */
     if (r->offsets) {
 	r->offsets[0] = RExC_size;
     }
@@ -2946,7 +2935,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 
     /* XXXX To minimize changes to RE engine we always allocate
        3-units-long substrs field. */
-    Newz(1004, r->substrs, 1, struct reg_substr_data);
+    Newxz(r->substrs, 1, struct reg_substr_data);
 
     StructCopy(&zero_scan_data, &data, scan_data_t);
     /* XXXX Should not we check for something else?  Usually it is OPEN1... */
@@ -3005,13 +2994,10 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	    !(r->reganch & ROPT_ANCH) )
 	{
 	    /* turn .* into ^.* with an implied $*=1 */
-	    int type = OP(NEXTOPER(first));
-
-	    if (type == REG_ANY)
-		type = ROPT_ANCH_MBOL;
-	    else
-		type = ROPT_ANCH_SBOL;
-
+	    const int type =
+		(OP(NEXTOPER(first)) == REG_ANY)
+		    ? ROPT_ANCH_MBOL
+		    : ROPT_ANCH_SBOL;
 	    r->reganch |= type | ROPT_IMPLICIT;
 	    first = NEXTOPER(first);
 	    goto again;
@@ -3037,9 +3023,9 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	*/
 	minlen = 0;
 
-	data.longest_fixed = newSVpvn("",0);
-	data.longest_float = newSVpvn("",0);
-	data.last_found = newSVpvn("",0);
+	data.longest_fixed = newSVpvs("");
+	data.longest_float = newSVpvs("");
+	data.last_found = newSVpvs("");
 	data.longest = &(data.longest_fixed);
 	first = scan;
 	if (!r->regstclass) {
@@ -3074,10 +3060,10 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 
 	    if (SvUTF8(data.longest_float)) {
 		r->float_utf8 = data.longest_float;
-		r->float_substr = Nullsv;
+		r->float_substr = NULL;
 	    } else {
 		r->float_substr = data.longest_float;
-		r->float_utf8 = Nullsv;
+		r->float_utf8 = NULL;
 	    }
 	    r->float_min_offset = data.offset_float_min;
 	    r->float_max_offset = data.offset_float_max;
@@ -3088,7 +3074,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	}
 	else {
 	  remove_float:
-	    r->float_substr = r->float_utf8 = Nullsv;
+	    r->float_substr = r->float_utf8 = NULL;
 	    SvREFCNT_dec(data.longest_float);
 	    longest_float_length = 0;
 	}
@@ -3102,10 +3088,10 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 
 	    if (SvUTF8(data.longest_fixed)) {
 		r->anchored_utf8 = data.longest_fixed;
-		r->anchored_substr = Nullsv;
+		r->anchored_substr = NULL;
 	    } else {
 		r->anchored_substr = data.longest_fixed;
-		r->anchored_utf8 = Nullsv;
+		r->anchored_utf8 = NULL;
 	    }
 	    r->anchored_offset = data.offset_fixed;
 	    t = (data.flags & SF_FIX_BEFORE_EOL /* Can't have SEOL and MULTI */
@@ -3114,7 +3100,7 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	    fbm_compile(data.longest_fixed, t ? FBMcf_TAIL : 0);
 	}
 	else {
-	    r->anchored_substr = r->anchored_utf8 = Nullsv;
+	    r->anchored_substr = r->anchored_utf8 = NULL;
 	    SvREFCNT_dec(data.longest_fixed);
 	    longest_fixed_length = 0;
 	}
@@ -3126,9 +3112,9 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	    && !(data.start_class->flags & ANYOF_EOS)
 	    && !cl_is_anything(data.start_class))
 	{
-	    I32 n = add_data(pRExC_state, 1, "f");
+	    const I32 n = add_data(pRExC_state, 1, "f");
 
-	    New(1006, RExC_rx->data->data[n], 1,
+	    Newx(RExC_rx->data->data[n], 1,
 		struct regnode_charclass_class);
 	    StructCopy(data.start_class,
 		       (struct regnode_charclass_class*)RExC_rx->data->data[n],
@@ -3139,8 +3125,8 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	    DEBUG_COMPILE_r({ SV *sv = sv_newmortal();
 	              regprop(sv, (regnode*)data.start_class);
 		      PerlIO_printf(Perl_debug_log,
-				    "synthetic stclass `%s'.\n",
-				    SvPVX(sv));});
+				    "synthetic stclass \"%s\".\n",
+				    SvPVX_const(sv));});
 	}
 
 	/* A temporary algorithm prefers floated substr to fixed one to dig more info. */
@@ -3178,13 +3164,13 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	data.last_closep = &last_close;
 	minlen = study_chunk(pRExC_state, &scan, &fake, scan + RExC_size, &data, SCF_DO_STCLASS_AND|SCF_WHILEM_VISITED_POS,0);
 	r->check_substr = r->check_utf8 = r->anchored_substr = r->anchored_utf8
-		= r->float_substr = r->float_utf8 = Nullsv;
+		= r->float_substr = r->float_utf8 = NULL;
 	if (!(data.start_class->flags & ANYOF_EOS)
 	    && !cl_is_anything(data.start_class))
 	{
-	    I32 n = add_data(pRExC_state, 1, "f");
+	    const I32 n = add_data(pRExC_state, 1, "f");
 
-	    New(1006, RExC_rx->data->data[n], 1,
+	    Newx(RExC_rx->data->data[n], 1,
 		struct regnode_charclass_class);
 	    StructCopy(data.start_class,
 		       (struct regnode_charclass_class*)RExC_rx->data->data[n],
@@ -3194,8 +3180,8 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	    DEBUG_COMPILE_r({ SV* sv = sv_newmortal();
 	              regprop(sv, (regnode*)data.start_class);
 		      PerlIO_printf(Perl_debug_log,
-				    "synthetic stclass `%s'.\n",
-				    SvPVX(sv));});
+				    "synthetic stclass \"%s\".\n",
+				    SvPVX_const(sv));});
 	}
     }
 
@@ -3208,8 +3194,8 @@ Perl_pregcomp(pTHX_ char *exp, char *xend, PMOP *pm)
 	r->reganch |= ROPT_EVAL_SEEN;
     if (RExC_seen & REG_SEEN_CANY)
 	r->reganch |= ROPT_CANY_SEEN;
-    Newz(1002, r->startp, RExC_npar, I32);
-    Newz(1002, r->endp, RExC_npar, I32);
+    Newxz(r->startp, RExC_npar, I32);
+    Newxz(r->endp, RExC_npar, I32);
     PL_regdata = r->data; /* for regprop() */
     DEBUG_COMPILE_r(regdump(r));
     return(r);
@@ -3232,21 +3218,24 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp)
     register regnode *ret;		/* Will be the head of the group. */
     register regnode *br;
     register regnode *lastbr;
-    register regnode *ender = 0;
+    register regnode *ender = NULL;
     register I32 parno = 0;
-    I32 flags, oregflags = RExC_flags, have_branch = 0, open = 0;
+    I32 flags;
+    const I32 oregflags = RExC_flags;
+    I32 have_branch = 0;
+    I32 open = 0;
 
     /* for (?g), (?gc), and (?o) warnings; warning
        about (?c) will warn about (?g) -- japhy    */
 
-    I32 wastedflags = 0x00,
-        wasted_o    = 0x01,
-        wasted_g    = 0x02,
-        wasted_gc   = 0x02 | 0x04,
-        wasted_c    = 0x04;
+    I32 wastedflags = 0x00;
+    const I32 wasted_o  = 0x01;
+    const I32 wasted_g  = 0x02;
+    const I32 wasted_gc = 0x02 | 0x04;
+    const I32 wasted_c  = 0x04;
 
     char * parse_start = RExC_parse; /* MJD */
-    char *oregcomp_parse = RExC_parse;
+    char * const oregcomp_parse = RExC_parse;
     char c;
 
     *flagp = 0;				/* Tentatively. */
@@ -3258,7 +3247,7 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp)
 	    U32 posflags = 0, negflags = 0;
 	    U32 *flagsp = &posflags;
 	    int logical = 0;
-	    char *seqstart = RExC_parse;
+	    const char * const seqstart = RExC_parse;
 
 	    RExC_parse++;
 	    paren = *RExC_parse++;
@@ -3329,7 +3318,7 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp)
 		    if (RExC_parse - 1 - s)
 			sv = newSVpvn(s, RExC_parse - 1 - s);
 		    else
-			sv = newSVpvn("", 0);
+			sv = newSVpvs("");
 
 		    ENTER;
 		    Perl_save_re_context(aTHX);
@@ -3641,6 +3630,7 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp)
 STATIC regnode *
 S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first)
 {
+    dVAR;
     register regnode *ret;
     register regnode *chain = NULL;
     register regnode *latest;
@@ -3708,11 +3698,12 @@ S_regbranch(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, I32 first)
 STATIC regnode *
 S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp)
 {
+    dVAR;
     register regnode *ret;
     register char op;
     register char *next;
     I32 flags;
-    char *origparse = RExC_parse;
+    const char * const origparse = RExC_parse;
     char *maxpos;
     I32 min;
     I32 max = REG_INFTY;
@@ -3730,7 +3721,7 @@ S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp)
     if (op == '{' && regcurly(RExC_parse)) {
         parse_start = RExC_parse; /* MJD */
 	next = RExC_parse + 1;
-	maxpos = Nullch;
+	maxpos = NULL;
 	while (isDIGIT(*next) || *next == ',') {
 	    if (*next == ',') {
 		if (maxpos)
@@ -3853,10 +3844,10 @@ S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp)
 	goto do_curly;
     }
   nest_check:
-    if (ckWARN(WARN_REGEXP) && !SIZE_ONLY && !(flags&HASWIDTH) && max > REG_INFTY/3) {
+    if (!SIZE_ONLY && !(flags&HASWIDTH) && max > REG_INFTY/3 && ckWARN(WARN_REGEXP)) {
 	vWARN3(RExC_parse,
 	       "%.*s matches null string many times",
-	       RExC_parse - origparse,
+	       (int)(RExC_parse >= origparse ? RExC_parse - origparse : 0),
 	       origparse);
     }
 
@@ -3885,7 +3876,8 @@ S_regpiece(pTHX_ RExC_state_t *pRExC_state, I32 *flagp)
 STATIC regnode *
 S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp)
 {
-    register regnode *ret = 0;
+    dVAR;
+    register regnode *ret = NULL;
     I32 flags;
     char *parse_start = RExC_parse;
 
@@ -4118,7 +4110,7 @@ tryagain:
 	case '1': case '2': case '3': case '4':
 	case '5': case '6': case '7': case '8': case '9':
 	    {
-		I32 num = atoi(RExC_parse);
+		const I32 num = atoi(RExC_parse);
 
 		if (num > 9 && num >= RExC_npar)
 		    goto defchar;
@@ -4148,7 +4140,7 @@ tryagain:
 		FAIL("Trailing \\");
 	    /* FALL THROUGH */
 	default:
-	    /* Do not generate `unrecognized' warnings here, we fall
+	    /* Do not generate "unrecognized" warnings here, we fall
 	       back into the quick-grab loop below */
 	    parse_start--;
 	    goto defchar;
@@ -4168,7 +4160,6 @@ tryagain:
 	    register UV ender;
 	    register char *p;
 	    char *oldp, *s;
-	    STRLEN numlen;
 	    STRLEN foldlen;
 	    U8 tmpbuf[UTF8_MAXBYTES_CASE+1], *foldbuf;
 
@@ -4244,7 +4235,7 @@ tryagain:
 			break;
 		    case 'x':
 			if (*++p == '{') {
-			    char* e = strchr(p, '}');
+			    char* const e = strchr(p, '}');
 	
 			    if (!e) {
 				RExC_parse = p + 1;
@@ -4253,7 +4244,7 @@ tryagain:
 			    else {
                                 I32 flags = PERL_SCAN_ALLOW_UNDERSCORES
                                     | PERL_SCAN_DISALLOW_PREFIX;
-                                numlen = e - p - 1;
+                                STRLEN numlen = e - p - 1;
 				ender = grok_hex(p + 1, &numlen, &flags, NULL);
 				if (ender > 0xff)
 				    RExC_utf8 = 1;
@@ -4262,7 +4253,7 @@ tryagain:
 			}
 			else {
                             I32 flags = PERL_SCAN_DISALLOW_PREFIX;
-			    numlen = 2;
+			    STRLEN numlen = 2;
 			    ender = grok_hex(p, &numlen, &flags, NULL);
 			    p += numlen;
 			}
@@ -4277,7 +4268,7 @@ tryagain:
 			if (*p == '0' ||
 			  (isDIGIT(p[1]) && atoi(p) >= RExC_npar) ) {
                             I32 flags = 0;
-			    numlen = 3;
+			    STRLEN numlen = 3;
 			    ender = grok_oct(p, &numlen, &flags, NULL);
 			    p += numlen;
 			}
@@ -4291,7 +4282,7 @@ tryagain:
 			    FAIL("Trailing \\");
 			/* FALL THROUGH */
 		    default:
-			if (!SIZE_ONLY && ckWARN(WARN_REGEXP) && isALPHA(*p))
+			if (!SIZE_ONLY&& isALPHA(*p) && ckWARN(WARN_REGEXP))
 			    vWARN2(p + 1, "Unrecognized escape \\%c passed through", UCHARAT(p));
 			goto normal_default;
 		    }
@@ -4299,6 +4290,7 @@ tryagain:
 		default:
 		  normal_default:
 		    if (UTF8_IS_START(*p) && UTF) {
+			STRLEN numlen;
 			ender = utf8n_to_uvchr((U8*)p, RExC_end - p,
 					       &numlen, 0);
 			p += numlen;
@@ -4321,6 +4313,7 @@ tryagain:
 
 			 if (FOLD) {
 			      /* Emit all the Unicode characters. */
+			      STRLEN numlen;
 			      for (foldbuf = tmpbuf;
 				   foldlen;
 				   foldlen -= numlen) {
@@ -4358,6 +4351,7 @@ tryagain:
 
 		     if (FOLD) {
 		          /* Emit all the Unicode characters. */
+			  STRLEN numlen;
 			  for (foldbuf = tmpbuf;
 			       foldlen;
 			       foldlen -= numlen) {
@@ -4421,8 +4415,8 @@ tryagain:
 	if (RExC_utf8)
 	    SvUTF8_on(sv);
 	if (sv_utf8_downgrade(sv, TRUE)) {
-	    char *s       = sv_recode_to_utf8(sv, PL_encoding);
-	    STRLEN newlen = SvCUR(sv);
+	    const char * const s = sv_recode_to_utf8(sv, PL_encoding);
+	    const STRLEN newlen = SvCUR(sv);
 
 	    if (SvUTF8(sv))
 		RExC_utf8 = 1;
@@ -4443,7 +4437,7 @@ tryagain:
 }
 
 STATIC char *
-S_regwhite(pTHX_ char *p, char *e)
+S_regwhite(pTHX_ char *p, const char *e)
 {
     while (p < e) {
 	if (isSPACE(*p))
@@ -4472,13 +4466,13 @@ S_regwhite(pTHX_ char *p, char *e)
 STATIC I32
 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
 {
-    char *posixcc = 0;
+    dVAR;
     I32 namedclass = OOB_NAMEDCLASS;
 
     if (value == '[' && RExC_parse + 1 < RExC_end &&
 	/* I smell either [: or [= or [. -- POSIX has been here, right? */
 	POSIXCC(UCHARAT(RExC_parse))) {
-	char  c = UCHARAT(RExC_parse);
+	const char c = UCHARAT(RExC_parse);
 	char* s = RExC_parse++;
 	
 	while (RExC_parse < RExC_end && UCHARAT(RExC_parse) != c)
@@ -4487,7 +4481,8 @@ S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
 	    /* Grandfather lone [:, [=, [. */
 	    RExC_parse = s;
 	else {
-	    char* t = RExC_parse++; /* skip over the c */
+	    const char* t = RExC_parse++; /* skip over the c */
+	    const char *posixcc;
 
 	    assert(*t == c);
 
@@ -4495,8 +4490,8 @@ S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
   		RExC_parse++; /* skip over the ending ] */
   		posixcc = s + 1;
 		if (*s == ':') {
-		    I32 complement = *posixcc == '^' ? *posixcc++ : 0;
-		    I32 skip = t - posixcc;
+		    const I32 complement = *posixcc == '^' ? *posixcc++ : 0;
+		    const I32 skip = t - posixcc;
 
 		    /* Initially switch on the length of the name.  */
 		    switch (skip) {
@@ -4631,9 +4626,10 @@ S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
 STATIC void
 S_checkposixcc(pTHX_ RExC_state_t *pRExC_state)
 {
+    dVAR;
     if (!SIZE_ONLY && POSIXCC(UCHARAT(RExC_parse))) {
-	char *s = RExC_parse;
- 	char  c = *s++;
+	const char *s = RExC_parse;
+	const char  c = *s++;
 
 	while(*s && isALNUM(*s))
 	    s++;
@@ -4658,6 +4654,7 @@ S_checkposixcc(pTHX_ RExC_state_t *pRExC_state)
 STATIC regnode *
 S_regclass(pTHX_ RExC_state_t *pRExC_state)
 {
+    dVAR;
     register UV value;
     register UV nextvalue;
     register IV prevvalue = OOB_UNICODE;
@@ -4665,13 +4662,13 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
     register regnode *ret;
     STRLEN numlen;
     IV namedclass;
-    char *rangebegin = 0;
+    char *rangebegin = NULL;
     bool need_class = 0;
-    SV *listsv = Nullsv;
+    SV *listsv = NULL;
     register char *e;
     UV n;
     bool optimize_invert   = TRUE;
-    AV* unicode_alternate  = 0;
+    AV* unicode_alternate  = NULL;
 #ifdef EBCDIC
     UV literal_endpoint = 0;
 #endif
@@ -4697,7 +4694,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 	if (LOC)
 	    ANYOF_FLAGS(ret) |= ANYOF_LOCALE;
 	ANYOF_BITMAP_ZERO(ret);
-	listsv = newSVpvn("# comment\n", 10);
+	listsv = newSVpvs("# comment\n");
     }
 
     nextvalue = RExC_parse < RExC_end ? UCHARAT(RExC_parse) : 0;
@@ -4754,7 +4751,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 		if (RExC_parse >= RExC_end)
 		    vFAIL2("Empty \\%c{}", (U8)value);
 		if (*RExC_parse == '{') {
-		    U8 c = (U8)value;
+		    const U8 c = (U8)value;
 		    e = strchr(RExC_parse++, '}');
                     if (!e)
                         vFAIL2("Missing right brace on \\%c{}", c);
@@ -4831,7 +4828,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 		break;
             }
 	    default:
-		if (!SIZE_ONLY && ckWARN(WARN_REGEXP) && isALPHA(value))
+		if (!SIZE_ONLY && isALPHA(value) && ckWARN(WARN_REGEXP))
 		    vWARN2(RExC_parse,
 			   "Unrecognized escape \\%c in character class passed through",
 			   (int)value);
@@ -4853,12 +4850,16 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 	    /* a bad range like a-\d, a-[:digit:] ? */
 	    if (range) {
 		if (!SIZE_ONLY) {
-		    if (ckWARN(WARN_REGEXP))
+		    if (ckWARN(WARN_REGEXP)) {
+			int w =
+			    RExC_parse >= rangebegin ?
+			    RExC_parse - rangebegin : 0;
 			vWARN4(RExC_parse,
 			       "False [] range \"%*.*s\"",
-			       RExC_parse - rangebegin,
-			       RExC_parse - rangebegin,
+			       w,
+			       w,
 			       rangebegin);
+		    }
 		    if (prevvalue < 256) {
 			ANYOF_BITMAP_SET(ret, prevvalue);
 			ANYOF_BITMAP_SET(ret, '-');
@@ -5262,12 +5263,16 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 
 		/* a bad range like \w-, [:word:]- ? */
 		if (namedclass > OOB_NAMEDCLASS) {
-		    if (ckWARN(WARN_REGEXP))
+		    if (ckWARN(WARN_REGEXP)) {
+			int w =
+			    RExC_parse >= rangebegin ?
+			    RExC_parse - rangebegin : 0;
 			vWARN4(RExC_parse,
 			       "False [] range \"%*.*s\"",
-			       RExC_parse - rangebegin,
-			       RExC_parse - rangebegin,
+			       w,
+			       w,
 			       rangebegin);
+		    }
 		    if (!SIZE_ONLY)
 			ANYOF_BITMAP_SET(ret, '-');
 		} else
@@ -5281,7 +5286,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 	    IV i;
 
 	    if (prevvalue < 256) {
-	        IV ceilvalue = value < 256 ? value : 255;
+	        const IV ceilvalue = value < 256 ? value : 255;
 
 #ifdef EBCDIC
 		/* In EBCDIC [\x89-\x91] should include
@@ -5306,8 +5311,8 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 			  ANYOF_BITMAP_SET(ret, i);
 	  }
 	  if (value > 255 || UTF) {
-	        UV prevnatvalue  = NATIVE_TO_UNI(prevvalue);
-		UV natvalue      = NATIVE_TO_UNI(value);
+	        const UV prevnatvalue  = NATIVE_TO_UNI(prevvalue);
+		const UV natvalue      = NATIVE_TO_UNI(value);
 
 		ANYOF_FLAGS(ret) |= ANYOF_UNICODE;
 		if (prevnatvalue < natvalue) { /* what about > ? */
@@ -5319,7 +5324,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 		    if (FOLD) {
 			 U8 foldbuf[UTF8_MAXBYTES_CASE+1];
 			 STRLEN foldlen;
-			 UV f = to_uni_fold(natvalue, foldbuf, &foldlen);
+			 const UV f = to_uni_fold(natvalue, foldbuf, &foldlen);
 
 			 /* If folding and foldable and a single
 			  * character, insert also the folded version
@@ -5434,6 +5439,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state)
 STATIC char*
 S_nextchar(pTHX_ RExC_state_t *pRExC_state)
 {
+    dVAR;
     char* retval = RExC_parse++;
 
     for (;;) {
@@ -5468,10 +5474,10 @@ S_nextchar(pTHX_ RExC_state_t *pRExC_state)
 STATIC regnode *			/* Location. */
 S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
 {
-    register regnode *ret;
+    dVAR;
     register regnode *ptr;
+    regnode * const ret = RExC_emit;
 
-    ret = RExC_emit;
     if (SIZE_ONLY) {
 	SIZE_ALIGN(RExC_size);
 	RExC_size += 1;
@@ -5504,10 +5510,10 @@ S_reg_node(pTHX_ RExC_state_t *pRExC_state, U8 op)
 STATIC regnode *			/* Location. */
 S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
 {
-    register regnode *ret;
+    dVAR;
     register regnode *ptr;
+    regnode * const ret = RExC_emit;
 
-    ret = RExC_emit;
     if (SIZE_ONLY) {
 	SIZE_ALIGN(RExC_size);
 	RExC_size += 2;
@@ -5539,8 +5545,9 @@ S_reganode(pTHX_ RExC_state_t *pRExC_state, U8 op, U32 arg)
 - reguni - emit (if appropriate) a Unicode character
 */
 STATIC void
-S_reguni(pTHX_ RExC_state_t *pRExC_state, UV uv, char* s, STRLEN* lenp)
+S_reguni(pTHX_ const RExC_state_t *pRExC_state, UV uv, char* s, STRLEN* lenp)
 {
+    dVAR;
     *lenp = SIZE_ONLY ? UNISKIP(uv) : (uvchr_to_utf8((U8*)s, uv) - (U8*)s);
 }
 
@@ -5552,10 +5559,11 @@ S_reguni(pTHX_ RExC_state_t *pRExC_state, UV uv, char* s, STRLEN* lenp)
 STATIC void
 S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd)
 {
+    dVAR;
     register regnode *src;
     register regnode *dst;
     register regnode *place;
-    register int offset = regarglen[(U8)op];
+    const int offset = regarglen[(U8)op];
 
 /* (PL_regkind[(U8)op] == CURLY ? EXTRA_STEP_2ARGS : 0); */
 
@@ -5610,8 +5618,8 @@ S_reginsert(pTHX_ RExC_state_t *pRExC_state, U8 op, regnode *opnd)
 STATIC void
 S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, regnode *val)
 {
+    dVAR;
     register regnode *scan;
-    register regnode *temp;
 
     if (SIZE_ONLY)
 	return;
@@ -5619,7 +5627,7 @@ S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, regnode *val)
     /* Find last node. */
     scan = p;
     for (;;) {
-	temp = regnext(scan);
+	regnode * const temp = regnext(scan);
 	if (temp == NULL)
 	    break;
 	scan = temp;
@@ -5639,6 +5647,7 @@ S_regtail(pTHX_ RExC_state_t *pRExC_state, regnode *p, regnode *val)
 STATIC void
 S_regoptail(pTHX_ RExC_state_t *pRExC_state, regnode *p, regnode *val)
 {
+    dVAR;
     /* "Operandless" and "op != BRANCH" are synonymous in practice. */
     if (p == NULL || SIZE_ONLY)
 	return;
@@ -5656,7 +5665,7 @@ S_regoptail(pTHX_ RExC_state_t *pRExC_state, regnode *p, regnode *val)
  - regcurly - a little FSA that accepts {\d+,?\d*}
  */
 STATIC I32
-S_regcurly(pTHX_ register char *s)
+S_regcurly(pTHX_ register const char *s)
 {
     if (*s++ != '{')
 	return FALSE;
@@ -5674,118 +5683,6 @@ S_regcurly(pTHX_ register char *s)
 }
 
 
-#ifdef DEBUGGING
-
-STATIC regnode *
-S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l)
-{
-    register U8 op = EXACT;	/* Arbitrary non-END op. */
-    register regnode *next;
-
-    while (op != END && (!last || node < last)) {
-	/* While that wasn't END last time... */
-
-	NODE_ALIGN(node);
-	op = OP(node);
-	if (op == CLOSE)
-	    l--;	
-	next = regnext(node);
-	/* Where, what. */
-	if (OP(node) == OPTIMIZED)
-	    goto after_print;
-	regprop(sv, node);
-	PerlIO_printf(Perl_debug_log, "%4"IVdf":%*s%s", (IV)(node - start),
-		      (int)(2*l + 1), "", SvPVX(sv));
-	if (next == NULL)		/* Next ptr. */
-	    PerlIO_printf(Perl_debug_log, "(0)");
-	else
-	    PerlIO_printf(Perl_debug_log, "(%"IVdf")", (IV)(next - start));
-	(void)PerlIO_putc(Perl_debug_log, '\n');
-      after_print:
-	if (PL_regkind[(U8)op] == BRANCHJ) {
-	    register regnode *nnode = (OP(next) == LONGJMP
-				       ? regnext(next)
-				       : next);
-	    if (last && nnode > last)
-		nnode = last;
-	    node = dumpuntil(start, NEXTOPER(NEXTOPER(node)), nnode, sv, l + 1);
-	}
-	else if (PL_regkind[(U8)op] == BRANCH) {
-	    node = dumpuntil(start, NEXTOPER(node), next, sv, l + 1);
-	}
-	else if ( PL_regkind[(U8)op]  == TRIE ) {
-            const I32 n = ARG(node);
-            const reg_trie_data *trie = (reg_trie_data*)PL_regdata->data[n];
-            const I32 arry_len = av_len(trie->words)+1;
-	    I32 word_idx;
-	    PerlIO_printf(Perl_debug_log,
-		       "%*s[Words:%d Chars Stored:%d Unique Chars:%d States:%"IVdf"%s]\n",
-		       (int)(2*(l+3)), "",
-		       trie->wordcount,
-		       trie->charcount,
-		       trie->uniquecharcount,
-		       (IV)trie->laststate-1,
-		       node->flags ? " EVAL mode" : "");
-
-	    for (word_idx=0; word_idx < arry_len; word_idx++) {
-		SV **elem_ptr=av_fetch(trie->words,word_idx,0);
-		if (elem_ptr) {
-		    PerlIO_printf(Perl_debug_log, "%*s<%s%s%s>\n",
-		       (int)(2*(l+4)), "",
-		       PL_colors[0],
-		       SvPV_nolen(*elem_ptr),
-		       PL_colors[1]
-		    );
-		    /*
-		    if (next == NULL)
-			PerlIO_printf(Perl_debug_log, "(0)\n");
-		    else
-			PerlIO_printf(Perl_debug_log, "(%"IVdf")\n", (IV)(next - start));
-		    */
-		}
-
-	    }
-
-	    node = NEXTOPER(node);
-	    node += regarglen[(U8)op];
-
-	}
-	else if ( op == CURLY) {   /* `next' might be very big: optimizer */
-	    node = dumpuntil(start, NEXTOPER(node) + EXTRA_STEP_2ARGS,
-			     NEXTOPER(node) + EXTRA_STEP_2ARGS + 1, sv, l + 1);
-	}
-	else if (PL_regkind[(U8)op] == CURLY && op != CURLYX) {
-	    node = dumpuntil(start, NEXTOPER(node) + EXTRA_STEP_2ARGS,
-			     next, sv, l + 1);
-	}
-	else if ( op == PLUS || op == STAR) {
-	    node = dumpuntil(start, NEXTOPER(node), NEXTOPER(node) + 1, sv, l + 1);
-	}
-	else if (op == ANYOF) {
-	    /* arglen 1 + class block */
-	    node += 1 + ((ANYOF_FLAGS(node) & ANYOF_LARGE)
-		    ? ANYOF_CLASS_SKIP : ANYOF_SKIP);
-	    node = NEXTOPER(node);
-	}
-	else if (PL_regkind[(U8)op] == EXACT) {
-            /* Literal string, where present. */
-	    node += NODE_SZ_STR(node) - 1;
-	    node = NEXTOPER(node);
-	}
-	else {
-	    node = NEXTOPER(node);
-	    node += regarglen[(U8)op];
-	}
-	if (op == CURLYX || op == OPEN)
-	    l++;
-	else if (op == WHILEM)
-	    l--;
-    }
-    return node;
-}
-
-#endif	/* DEBUGGING */
-
 /*
  - regdump - dump a regexp onto Perl_debug_log in vaguely comprehensible form
  */
@@ -5793,44 +5690,45 @@ void
 Perl_regdump(pTHX_ regexp *r)
 {
 #ifdef DEBUGGING
-    SV *sv = sv_newmortal();
+    dVAR;
+    SV * const sv = sv_newmortal();
 
     (void)dumpuntil(r->program, r->program + 1, NULL, sv, 0);
 
     /* Header fields of interest. */
     if (r->anchored_substr)
 	PerlIO_printf(Perl_debug_log,
-		      "anchored `%s%.*s%s'%s at %"IVdf" ",
+		      "anchored \"%s%.*s%s\"%s at %"IVdf" ",
 		      PL_colors[0],
 		      (int)(SvCUR(r->anchored_substr) - (SvTAIL(r->anchored_substr)!=0)),
-		      SvPVX(r->anchored_substr),
+		      SvPVX_const(r->anchored_substr),
 		      PL_colors[1],
 		      SvTAIL(r->anchored_substr) ? "$" : "",
 		      (IV)r->anchored_offset);
     else if (r->anchored_utf8)
 	PerlIO_printf(Perl_debug_log,
-		      "anchored utf8 `%s%.*s%s'%s at %"IVdf" ",
+		      "anchored utf8 \"%s%.*s%s\"%s at %"IVdf" ",
 		      PL_colors[0],
 		      (int)(SvCUR(r->anchored_utf8) - (SvTAIL(r->anchored_utf8)!=0)),
-		      SvPVX(r->anchored_utf8),
+		      SvPVX_const(r->anchored_utf8),
 		      PL_colors[1],
 		      SvTAIL(r->anchored_utf8) ? "$" : "",
 		      (IV)r->anchored_offset);
     if (r->float_substr)
 	PerlIO_printf(Perl_debug_log,
-		      "floating `%s%.*s%s'%s at %"IVdf"..%"UVuf" ",
+		      "floating \"%s%.*s%s\"%s at %"IVdf"..%"UVuf" ",
 		      PL_colors[0],
 		      (int)(SvCUR(r->float_substr) - (SvTAIL(r->float_substr)!=0)),
-		      SvPVX(r->float_substr),
+		      SvPVX_const(r->float_substr),
 		      PL_colors[1],
 		      SvTAIL(r->float_substr) ? "$" : "",
 		      (IV)r->float_min_offset, (UV)r->float_max_offset);
     else if (r->float_utf8)
 	PerlIO_printf(Perl_debug_log,
-		      "floating utf8 `%s%.*s%s'%s at %"IVdf"..%"UVuf" ",
+		      "floating utf8 \"%s%.*s%s\"%s at %"IVdf"..%"UVuf" ",
 		      PL_colors[0],
 		      (int)(SvCUR(r->float_utf8) - (SvTAIL(r->float_utf8)!=0)),
-		      SvPVX(r->float_utf8),
+		      SvPVX_const(r->float_utf8),
 		      PL_colors[1],
 		      SvTAIL(r->float_utf8) ? "$" : "",
 		      (IV)r->float_min_offset, (UV)r->float_max_offset);
@@ -5848,7 +5746,7 @@ Perl_regdump(pTHX_ regexp *r)
 
     if (r->regstclass) {
 	regprop(sv, r->regstclass);
-	PerlIO_printf(Perl_debug_log, "stclass `%s' ", SvPVX(sv));
+	PerlIO_printf(Perl_debug_log, "stclass \"%s\" ", SvPVX_const(sv));
     }
     if (r->reganch & ROPT_ANCH) {
 	PerlIO_printf(Perl_debug_log, "anchored");
@@ -5873,10 +5771,10 @@ Perl_regdump(pTHX_ regexp *r)
 	PerlIO_printf(Perl_debug_log, "with eval ");
     PerlIO_printf(Perl_debug_log, "\n");
     if (r->offsets) {
-        U32 i;
         const U32 len = r->offsets[0];
         GET_RE_DEBUG_FLAGS_DECL;
         DEBUG_OFFSETS_r({
+	    U32 i;
 	    PerlIO_printf(Perl_debug_log, "Offsets: [%"UVuf"]\n\t", (UV)r->offsets[0]);
 	    for (i = 1; i <= len; i++)
 	        PerlIO_printf(Perl_debug_log, "%"UVuf"[%"UVuf"] ", 
@@ -5884,32 +5782,19 @@ Perl_regdump(pTHX_ regexp *r)
 	    PerlIO_printf(Perl_debug_log, "\n");
         });
     }
+#else
+    PERL_UNUSED_ARG(r);
 #endif	/* DEBUGGING */
 }
 
-#ifdef DEBUGGING
-
-STATIC void
-S_put_byte(pTHX_ SV *sv, int c)
-{
-    if (isCNTRL(c) || c == 255 || !isPRINT(c))
-	Perl_sv_catpvf(aTHX_ sv, "\\%o", c);
-    else if (c == '-' || c == ']' || c == '\\' || c == '^')
-	Perl_sv_catpvf(aTHX_ sv, "\\%c", c);
-    else
-	Perl_sv_catpvf(aTHX_ sv, "%c", c);
-}
-
-#endif	/* DEBUGGING */
-
-
 /*
 - regprop - printable representation of opcode
 */
 void
-Perl_regprop(pTHX_ SV *sv, regnode *o)
+Perl_regprop(pTHX_ SV *sv, const regnode *o)
 {
 #ifdef DEBUGGING
+    dVAR;
     register int k;
 
     sv_setpvn(sv, "", 0);
@@ -5922,12 +5807,12 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
     k = PL_regkind[(U8)OP(o)];
 
     if (k == EXACT) {
-        SV *dsv = sv_2mortal(newSVpvn("", 0));
+	SV * const dsv = sv_2mortal(newSVpvs(""));
 	/* Using is_utf8_string() is a crude hack but it may
 	 * be the best for now since we have no flag "this EXACTish
 	 * node was UTF-8" --jhi */
-	bool do_utf8 = is_utf8_string((U8*)STRING(o), STR_LEN(o));
-	char *s    = do_utf8 ?
+	const bool do_utf8 = is_utf8_string((U8*)STRING(o), STR_LEN(o));
+	const char * const s = do_utf8 ?
 	  pv_uni_display(dsv, (U8*)STRING(o), STR_LEN(o), 60,
 			 UNI_DISPLAY_REGEX) :
 	  STRING(o);
@@ -5962,9 +5847,10 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
 	Perl_sv_catpvf(aTHX_ sv, "[%d]", o->flags);	/* 2: embedded, otherwise 1 */
     else if (k == ANYOF) {
 	int i, rangestart = -1;
-	U8 flags = ANYOF_FLAGS(o);
-	const char * const anyofs[] = {	/* Should be synchronized with
-					 * ANYOF_ #xdefines in regcomp.h */
+	const U8 flags = ANYOF_FLAGS(o);
+
+	/* Should be synchronized with * ANYOF_ #xdefines in regcomp.h */
+	static const char * const anyofs[] = {
 	    "\\w",
 	    "\\W",
 	    "\\s",
@@ -5998,12 +5884,12 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
 	};
 
 	if (flags & ANYOF_LOCALE)
-	    sv_catpv(sv, "{loc}");
+	    sv_catpvs(sv, "{loc}");
 	if (flags & ANYOF_FOLD)
-	    sv_catpv(sv, "{i}");
+	    sv_catpvs(sv, "{i}");
 	Perl_sv_catpvf(aTHX_ sv, "[%s", PL_colors[0]);
 	if (flags & ANYOF_INVERT)
-	    sv_catpv(sv, "^");
+	    sv_catpvs(sv, "^");
 	for (i = 0; i <= 256; i++) {
 	    if (i < 256 && ANYOF_BITMAP_TEST(o,i)) {
 		if (rangestart == -1)
@@ -6014,7 +5900,7 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
 			put_byte(sv, rangestart);
 		else {
 		    put_byte(sv, rangestart);
-		    sv_catpv(sv, "-");
+		    sv_catpvs(sv, "-");
 		    put_byte(sv, i - 1);
 		}
 		rangestart = -1;
@@ -6027,54 +5913,57 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
 		    sv_catpv(sv, anyofs[i]);
 
 	if (flags & ANYOF_UNICODE)
-	    sv_catpv(sv, "{unicode}");
+	    sv_catpvs(sv, "{unicode}");
 	else if (flags & ANYOF_UNICODE_ALL)
-	    sv_catpv(sv, "{unicode_all}");
+	    sv_catpvs(sv, "{unicode_all}");
 
 	{
 	    SV *lv;
-	    SV *sw = regclass_swash(o, FALSE, &lv, 0);
+	    SV * const sw = regclass_swash(o, FALSE, &lv, 0);
 	
 	    if (lv) {
 		if (sw) {
 		    U8 s[UTF8_MAXBYTES_CASE+1];
 		
 		    for (i = 0; i <= 256; i++) { /* just the first 256 */
-			U8 *e = uvchr_to_utf8(s, i);
+			uvchr_to_utf8(s, i);
 			
 			if (i < 256 && swash_fetch(sw, s, TRUE)) {
 			    if (rangestart == -1)
 				rangestart = i;
 			} else if (rangestart != -1) {
-			    U8 *p;
-			
 			    if (i <= rangestart + 3)
 				for (; rangestart < i; rangestart++) {
-				    for(e = uvchr_to_utf8(s, rangestart), p = s; p < e; p++)
+				    const U8 * const e = uvchr_to_utf8(s,rangestart);
+				    U8 *p;
+				    for(p = s; p < e; p++)
 					put_byte(sv, *p);
 				}
 			    else {
-				for (e = uvchr_to_utf8(s, rangestart), p = s; p < e; p++)
+				const U8 *e = uvchr_to_utf8(s,rangestart);
+				U8 *p;
+				for (p = s; p < e; p++)
+				    put_byte(sv, *p);
+				sv_catpvs(sv, "-");
+				e = uvchr_to_utf8(s, i-1);
+				for (p = s; p < e; p++)
 				    put_byte(sv, *p);
-				sv_catpv(sv, "-");
-				    for (e = uvchr_to_utf8(s, i - 1), p = s; p < e; p++)
-					put_byte(sv, *p);
 				}
 				rangestart = -1;
 			    }
 			}
 			
-		    sv_catpv(sv, "..."); /* et cetera */
+		    sv_catpvs(sv, "..."); /* et cetera */
 		}
 
 		{
 		    char *s = savesvpv(lv);
-		    char *origs = s;
+		    char * const origs = s;
 		
 		    while(*s && *s != '\n') s++;
 		
 		    if (*s == '\n') {
-			char *t = ++s;
+			const char * const t = ++s;
 			
 			while (*s) {
 			    if (*s == '\n')
@@ -6096,21 +5985,25 @@ Perl_regprop(pTHX_ SV *sv, regnode *o)
     }
     else if (k == BRANCHJ && (OP(o) == UNLESSM || OP(o) == IFMATCH))
 	Perl_sv_catpvf(aTHX_ sv, "[-%d]", o->flags);
+#else
+    PERL_UNUSED_ARG(sv);
+    PERL_UNUSED_ARG(o);
 #endif	/* DEBUGGING */
 }
 
 SV *
 Perl_re_intuit_string(pTHX_ regexp *prog)
 {				/* Assume that RE_INTUIT is set */
+    dVAR;
     GET_RE_DEBUG_FLAGS_DECL;
     DEBUG_COMPILE_r(
-	{   STRLEN n_a;
-	    char *s = SvPV(prog->check_substr
-		      ? prog->check_substr : prog->check_utf8, n_a);
+	{
+	    const char * const s = SvPV_nolen_const(prog->check_substr
+		      ? prog->check_substr : prog->check_utf8);
 
 	    if (!PL_colorset) reginitcolors();
 	    PerlIO_printf(Perl_debug_log,
-		      "%sUsing REx %ssubstr:%s `%s%.60s%s%s'\n",
+		      "%sUsing REx %ssubstr:%s \"%s%.60s%s%s\"\n",
 		      PL_colors[4],
 		      prog->check_substr ? "" : "utf8 ",
 		      PL_colors[5],PL_colors[0],
@@ -6127,15 +6020,15 @@ Perl_pregfree(pTHX_ struct regexp *r)
 {
     dVAR;
 #ifdef DEBUGGING
-    SV *dsv = PERL_DEBUG_PAD_ZERO(0);
-    SV *re_debug_flags=get_sv(RE_DEBUG_FLAGS,0);
+    SV * const dsv = PERL_DEBUG_PAD_ZERO(0);
+    SV * const re_debug_flags=get_sv(RE_DEBUG_FLAGS,0);
 #endif
 
 
     if (!r || (--r->refcnt > 0))
 	return;
     DEBUG_r(if (re_debug_flags && (SvIV(re_debug_flags) & RE_DEBUG_COMPILE)) {
-        const char *s = (r->reganch & ROPT_UTF8)
+        const char * const s = (r->reganch & ROPT_UTF8)
             ? pv_uni_display(dsv, (U8*)r->precomp, r->prelen, 60, UNI_DISPLAY_REGEX)
             : pv_display(dsv, r->precomp, r->prelen, 0, 60);
         const int len = SvCUR(dsv);
@@ -6149,12 +6042,12 @@ Perl_pregfree(pTHX_ struct regexp *r)
 		       len > 60 ? "..." : "");
     });
 
-    if (r->precomp)
-	Safefree(r->precomp);
-    if (r->offsets)             /* 20010421 MJD */
-	Safefree(r->offsets);
+    /* gcov results gave these as non-null 100% of the time, so there's no
+       optimisation in checking them before calling Safefree  */
+    Safefree(r->precomp);
+    Safefree(r->offsets);             /* 20010421 MJD */
     RX_MATCH_COPY_FREE(r);
-#ifdef PERL_COPY_ON_WRITE
+#ifdef PERL_OLD_COPY_ON_WRITE
     if (r->saved_copy)
 	SvREFCNT_dec(r->saved_copy);
 #endif
@@ -6192,8 +6085,7 @@ Perl_pregfree(pTHX_ struct regexp *r)
 		    Perl_croak(aTHX_ "panic: pregfree comppad");
 		PAD_SAVE_LOCAL(old_comppad,
 		    /* Watch out for global destruction's random ordering. */
-		    (SvTYPE(new_comppad) == SVt_PVAV) ?
-		    		new_comppad : Null(PAD *)
+		    (SvTYPE(new_comppad) == SVt_PVAV) ? new_comppad : NULL
 		);
 		OP_REFCNT_LOCK;
 		refcnt = OpREFCNT_dec((OP_4tree*)r->data->data[n]);
@@ -6209,20 +6101,17 @@ Perl_pregfree(pTHX_ struct regexp *r)
 	        break;
 	    case 't':
 		    {
-			reg_trie_data *trie=(reg_trie_data*)r->data->data[n];
+			reg_trie_data * const trie=(reg_trie_data*)r->data->data[n];
 			U32 refcount;
 			OP_REFCNT_LOCK;
-			refcount = trie->refcount--;
+			refcount = --trie->refcount;
 			OP_REFCNT_UNLOCK;
 			if ( !refcount ) {
-			    if (trie->charmap)
-			        Safefree(trie->charmap);
+			    Safefree(trie->charmap);
 			    if (trie->widecharmap)
 			        SvREFCNT_dec((SV*)trie->widecharmap);
-			    if (trie->states)
-			        Safefree(trie->states);
-			    if (trie->trans)
-			        Safefree(trie->trans);
+			    Safefree(trie->states);
+			    Safefree(trie->trans);
 #ifdef DEBUGGING
 			    if (trie->words)
 			        SvREFCNT_dec((SV*)trie->words);
@@ -6251,6 +6140,7 @@ Perl_pregfree(pTHX_ struct regexp *r)
 regnode *
 Perl_regnext(pTHX_ register regnode *p)
 {
+    dVAR;
     register I32 offset;
 
     if (p == &PL_regdummy)
@@ -6289,7 +6179,7 @@ S_re_croak2(pTHX_ const char* pat1,const char* pat2,...)
 #endif
     msv = vmess(buf, &args);
     va_end(args);
-    message = SvPV(msv,l1);
+    message = SvPV_const(msv,l1);
     if (l1 > 512)
 	l1 = 512;
     Copy(message, buf, l1 , char);
@@ -6302,6 +6192,7 @@ S_re_croak2(pTHX_ const char* pat1,const char* pat2,...)
 void
 Perl_save_re_context(pTHX)
 {
+    dVAR;
     SAVEI32(PL_reg_flags);		/* from regexec.c */
     SAVEPPTR(PL_bostr);
     SAVEPPTR(PL_reginput);		/* String-input pointer. */
@@ -6333,36 +6224,35 @@ Perl_save_re_context(pTHX)
     SAVEVPTR(PL_reg_oldcurpm);		/* from regexec.c */
     SAVEVPTR(PL_reg_curpm);		/* from regexec.c */
     SAVEPPTR(PL_reg_oldsaved);		/* old saved substr during match */
-    PL_reg_oldsaved = Nullch;
+    PL_reg_oldsaved = NULL;
     SAVEI32(PL_reg_oldsavedlen);	/* old length of saved substr during match */
     PL_reg_oldsavedlen = 0;
-#ifdef PERL_COPY_ON_WRITE
+#ifdef PERL_OLD_COPY_ON_WRITE
     SAVESPTR(PL_nrs);
-    PL_nrs = Nullsv;
+    PL_nrs = NULL;
 #endif
     SAVEI32(PL_reg_maxiter);		/* max wait until caching pos */
     PL_reg_maxiter = 0;
     SAVEI32(PL_reg_leftiter);		/* wait until caching pos */
     PL_reg_leftiter = 0;
     SAVEGENERICPV(PL_reg_poscache);	/* cache of pos of WHILEM */
-    PL_reg_poscache = Nullch;
+    PL_reg_poscache = NULL;
     SAVEI32(PL_reg_poscache_size);	/* size of pos cache of WHILEM */
     PL_reg_poscache_size = 0;
     SAVEPPTR(PL_regprecomp);		/* uncompiled string. */
     SAVEI32(PL_regnpar);		/* () count. */
     SAVEI32(PL_regsize);		/* from regexec.c */
 
-    {
-	/* Save $1..$n (#18107: UTF-8 s/(\w+)/uc($1)/e); AMS 20021106. */
-	U32 i;
-	GV *mgv;
-	REGEXP *rx;
-	char digits[TYPE_CHARS(long)];
-
-	if (PL_curpm && (rx = PM_GETRE(PL_curpm))) {
+    /* Save $1..$n (#18107: UTF-8 s/(\w+)/uc($1)/e); AMS 20021106. */
+    if (PL_curpm) {
+	const REGEXP * const rx = PM_GETRE(PL_curpm);
+	if (rx) {
+	    U32 i;
 	    for (i = 1; i <= rx->nparens; i++) {
-		sprintf(digits, "%lu", (long)i);
-		if ((mgv = gv_fetchpv(digits, FALSE, SVt_PV)))
+		char digits[TYPE_CHARS(long)];
+		const STRLEN len = my_sprintf(digits, "%lu", (long)i);
+		GV * const mgv = gv_fetchpvn_flags(digits, len, 0, SVt_PV);
+		if (mgv)
 		    save_scalar(mgv);
 	    }
 	}
@@ -6376,9 +6266,136 @@ Perl_save_re_context(pTHX)
 static void
 clear_re(pTHX_ void *r)
 {
+    dVAR;
     ReREFCNT_dec((regexp *)r);
 }
 
+#ifdef DEBUGGING
+
+STATIC void
+S_put_byte(pTHX_ SV *sv, int c)
+{
+    if (isCNTRL(c) || c == 255 || !isPRINT(c))
+	Perl_sv_catpvf(aTHX_ sv, "\\%o", c);
+    else if (c == '-' || c == ']' || c == '\\' || c == '^')
+	Perl_sv_catpvf(aTHX_ sv, "\\%c", c);
+    else
+	Perl_sv_catpvf(aTHX_ sv, "%c", c);
+}
+
+
+STATIC regnode *
+S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l)
+{
+    dVAR;
+    register U8 op = EXACT;	/* Arbitrary non-END op. */
+    register regnode *next;
+
+    while (op != END && (!last || node < last)) {
+	/* While that wasn't END last time... */
+
+	NODE_ALIGN(node);
+	op = OP(node);
+	if (op == CLOSE)
+	    l--;	
+	next = regnext(node);
+	/* Where, what. */
+	if (OP(node) == OPTIMIZED)
+	    goto after_print;
+	regprop(sv, node);
+	PerlIO_printf(Perl_debug_log, "%4"IVdf":%*s%s", (IV)(node - start),
+		      (int)(2*l + 1), "", SvPVX_const(sv));
+	if (next == NULL)		/* Next ptr. */
+	    PerlIO_printf(Perl_debug_log, "(0)");
+	else
+	    PerlIO_printf(Perl_debug_log, "(%"IVdf")", (IV)(next - start));
+	(void)PerlIO_putc(Perl_debug_log, '\n');
+      after_print:
+	if (PL_regkind[(U8)op] == BRANCHJ) {
+	    register regnode *nnode = (OP(next) == LONGJMP
+				       ? regnext(next)
+				       : next);
+	    if (last && nnode > last)
+		nnode = last;
+	    node = dumpuntil(start, NEXTOPER(NEXTOPER(node)), nnode, sv, l + 1);
+	}
+	else if (PL_regkind[(U8)op] == BRANCH) {
+	    node = dumpuntil(start, NEXTOPER(node), next, sv, l + 1);
+	}
+	else if ( PL_regkind[(U8)op]  == TRIE ) {
+            const I32 n = ARG(node);
+	    const reg_trie_data * const trie = (reg_trie_data*)PL_regdata->data[n];
+            const I32 arry_len = av_len(trie->words)+1;
+	    I32 word_idx;
+	    PerlIO_printf(Perl_debug_log,
+		       "%*s[Words:%d Chars Stored:%d Unique Chars:%d States:%"IVdf"%s]\n",
+		       (int)(2*(l+3)),
+		       "",
+		       trie->wordcount,
+		       (int)trie->charcount,
+		       trie->uniquecharcount,
+		       (IV)trie->laststate-1,
+		       node->flags ? " EVAL mode" : "");
+
+	    for (word_idx=0; word_idx < arry_len; word_idx++) {
+		SV **elem_ptr=av_fetch(trie->words,word_idx,0);
+		if (elem_ptr) {
+		    PerlIO_printf(Perl_debug_log, "%*s<%s%s%s>\n",
+		       (int)(2*(l+4)), "",
+		       PL_colors[0],
+		       SvPV_nolen_const(*elem_ptr),
+		       PL_colors[1]
+		    );
+		    /*
+		    if (next == NULL)
+			PerlIO_printf(Perl_debug_log, "(0)\n");
+		    else
+			PerlIO_printf(Perl_debug_log, "(%"IVdf")\n", (IV)(next - start));
+		    */
+		}
+
+	    }
+
+	    node = NEXTOPER(node);
+	    node += regarglen[(U8)op];
+
+	}
+	else if ( op == CURLY) {   /* "next" might be very big: optimizer */
+	    node = dumpuntil(start, NEXTOPER(node) + EXTRA_STEP_2ARGS,
+			     NEXTOPER(node) + EXTRA_STEP_2ARGS + 1, sv, l + 1);
+	}
+	else if (PL_regkind[(U8)op] == CURLY && op != CURLYX) {
+	    node = dumpuntil(start, NEXTOPER(node) + EXTRA_STEP_2ARGS,
+			     next, sv, l + 1);
+	}
+	else if ( op == PLUS || op == STAR) {
+	    node = dumpuntil(start, NEXTOPER(node), NEXTOPER(node) + 1, sv, l + 1);
+	}
+	else if (op == ANYOF) {
+	    /* arglen 1 + class block */
+	    node += 1 + ((ANYOF_FLAGS(node) & ANYOF_LARGE)
+		    ? ANYOF_CLASS_SKIP : ANYOF_SKIP);
+	    node = NEXTOPER(node);
+	}
+	else if (PL_regkind[(U8)op] == EXACT) {
+            /* Literal string, where present. */
+	    node += NODE_SZ_STR(node) - 1;
+	    node = NEXTOPER(node);
+	}
+	else {
+	    node = NEXTOPER(node);
+	    node += regarglen[(U8)op];
+	}
+	if (op == CURLYX || op == OPEN)
+	    l++;
+	else if (op == WHILEM)
+	    l--;
+    }
+    return node;
+}
+
+#endif	/* DEBUGGING */
+
 /*
  * Local variables:
  * c-indentation-style: bsd
@@ -6386,5 +6403,5 @@ clear_re(pTHX_ void *r)
  * indent-tabs-mode: t
  * End:
  *
- * vim: shiftwidth=4:
-*/
+ * ex: set ts=8 sts=4 sw=4 noet:
+ */