Integrate:

[ 24780]
Subject: [PATCH] regcomp.c and more
Message-ID: <20050609150556.GA30554@petdance.com>
p4raw-link: @24780 on //depot/perl: a28509cc00517ad2ad1f6e022f1be6ab8f1ad18e

p4raw-id: //depot/maint-5.8/perl@25535
p4raw-edited: from //depot/perl@24780 'edit in' regcomp.c (@24760..)
p4raw-integrated: from //depot/perl@24780 'edit in' sv.c (@24770..)
	'ignore' perly.c (@24666..) 'merge in' embed.fnc proto.h
	(@24760..) mg.c (@24778..)

diff --git a/embed.fnc b/embed.fnc
index d5a32bf..f82d09b 100644 (file)
--- a/embed.fnc
+++ b/embed.fnc
@@ -53,7 +53,7 @@ Anod  |void   |perl_free      |NN PerlInterpreter* interp
 Anod   |int    |perl_run       |NN PerlInterpreter* interp
 Anod   |int    |perl_parse     |PerlInterpreter* interp|XSINIT_t xsinit \
                                |int argc|char** argv|char** env
-Anp    |bool   |doing_taint    |int argc|char** argv|char** env
+AnpR   |bool   |doing_taint    |int argc|char** argv|char** env
 #if defined(USE_ITHREADS)
 Anod   |PerlInterpreter*|perl_clone|PerlInterpreter* interp|UV flags
 #  if defined(PERL_IMPLICIT_SYS)
@@ -260,8 +260,7 @@ Ap  |GP*    |gp_ref         |GP* gp
 Ap     |GV*    |gv_AVadd       |GV* gv
 Ap     |GV*    |gv_HVadd       |GV* gv
 Ap     |GV*    |gv_IOadd       |GV* gv
-Ap     |GV*    |gv_autoload4   |HV* stash|const char* name|STRLEN len \
-                               |I32 method
+ApR    |GV*    |gv_autoload4   |HV* stash|NN const char* name|STRLEN len|I32 method
 Ap     |void   |gv_check       |HV* stash
 Ap     |void   |gv_efullname   |SV* sv|GV* gv
 Amb    |void   |gv_efullname3  |SV* sv|GV* gv|const char* prefix
@@ -803,7 +802,7 @@ Apd |void   |sv_setpv       |SV* sv|const char* ptr
 Apd    |void   |sv_setpvn      |NN SV* sv|const char* ptr|STRLEN len
 Amdb   |void   |sv_setsv       |SV* dsv|SV* ssv
 Apd    |void   |sv_taint       |SV* sv
-Apd    |bool   |sv_tainted     |SV* sv
+ApdR   |bool   |sv_tainted     |SV* sv
 Apd    |int    |sv_unmagic     |NN SV* sv|int type
 Apd    |void   |sv_unref       |NN SV* sv
 Apd    |void   |sv_unref_flags |NN SV* sv|U32 flags
@@ -1131,9 +1130,9 @@ s |bool   |path_is_absolute|NN const char *name
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 s      |int    |do_maybe_phash |AV *ary|SV **lelem|SV **firstlelem \
                                |SV **relem|SV **lastrelem
-s      |void   |do_oddball     |HV *hash|SV **relem|SV **firstrelem
-s      |CV*    |get_db_sub     |SV **svp|CV *cv
-s      |SV*    |method_common  |SV* meth|U32* hashp
+s      |void   |do_oddball     |NN HV *hash|NN SV **relem|NN SV **firstrelem
+sR     |CV*    |get_db_sub     |NN SV **svp|NN CV *cv
+sR     |SV*    |method_common  |NN SV* meth|U32* hashp
 #endif
 
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
@@ -1145,34 +1144,34 @@ sR      |int    |dooneliner     |NN const char *cmd|NN const char *filename
 #endif
 
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_DECL_PROT)
-Es     |regnode*|reg           |struct RExC_state_t*|I32|I32 *
-Es     |regnode*|reganode      |struct RExC_state_t*|U8|U32
-Es     |regnode*|regatom       |struct RExC_state_t*|I32 *
-Es     |regnode*|regbranch     |struct RExC_state_t*|I32 *|I32
-Es     |void   |reguni         |struct RExC_state_t*|UV|char *|STRLEN*
-Es     |regnode*|regclass      |struct RExC_state_t*
+Es     |regnode*|reg           |NN struct RExC_state_t *state|I32 paren|NN I32 *flagp
+Es     |regnode*|reganode      |NN struct RExC_state_t *state|U8 op|U32 arg
+Es     |regnode*|regatom       |NN struct RExC_state_t *state|NN I32 *flagp
+Es     |regnode*|regbranch     |NN struct RExC_state_t *state|NN I32 *flagp|I32 first
+Es     |void   |reguni         |NN const struct RExC_state_t *state|UV uv|NN char *s|NN STRLEN *lenp
+Es     |regnode*|regclass      |NN struct RExC_state_t *state
 ERs    |I32    |regcurly       |NN const char *
-Es     |regnode*|reg_node      |struct RExC_state_t*|U8
-Es     |regnode*|regpiece      |struct RExC_state_t*|I32 *
-Es     |void   |reginsert      |struct RExC_state_t*|U8|regnode *
-Es     |void   |regoptail      |struct RExC_state_t*|regnode *|regnode *
-Es     |void   |regtail        |struct RExC_state_t*|regnode *|regnode *
-Es     |char*  |regwhite       |char *p|const char *e
-Es     |char*  |nextchar       |struct RExC_state_t*
+Es     |regnode*|reg_node      |NN struct RExC_state_t *state|U8 op
+Es     |regnode*|regpiece      |NN struct RExC_state_t *state|NN I32 *flagp
+Es     |void   |reginsert      |NN struct RExC_state_t *state|U8 op|NN regnode *opnd
+Es     |void   |regoptail      |NN struct RExC_state_t *state|NN regnode *p|NN regnode *val
+Es     |void   |regtail        |NN struct RExC_state_t *state|NN regnode *p|NN regnode *val
+Es     |char*  |regwhite       |NN char *p|NN const char *e
+Es     |char*  |nextchar       |NN struct RExC_state_t*
 #  ifdef DEBUGGING
 Es     |regnode*|dumpuntil     |regnode *start|regnode *node \
                                |regnode *last|SV* sv|I32 l
 Es     |void   |put_byte       |NN SV* sv|int c
 #  endif
 Es     |void   |scan_commit    |struct RExC_state_t*|struct scan_data_t *data
-Es     |void   |cl_anything    |struct RExC_state_t*|struct regnode_charclass_class *cl
-Es     |int    |cl_is_anything |struct regnode_charclass_class *cl
-Es     |void   |cl_init        |struct RExC_state_t*|struct regnode_charclass_class *cl
-Es     |void   |cl_init_zero   |struct RExC_state_t*|struct regnode_charclass_class *cl
-Es     |void   |cl_and         |struct regnode_charclass_class *cl \
-                               |struct regnode_charclass_class *and_with
-Es     |void   |cl_or          |struct RExC_state_t*|struct regnode_charclass_class *cl \
-                               |struct regnode_charclass_class *or_with
+Es     |void   |cl_anything    |NN struct RExC_state_t*|NN struct regnode_charclass_class *cl
+Es     |int    |cl_is_anything |NN const struct regnode_charclass_class *cl
+Es     |void   |cl_init        |NN struct RExC_state_t*|NN struct regnode_charclass_class *cl
+Es     |void   |cl_init_zero   |NN struct RExC_state_t*|NN struct regnode_charclass_class *cl
+Es     |void   |cl_and         |NN struct regnode_charclass_class *cl \
+                               |const struct regnode_charclass_class *and_with
+Es     |void   |cl_or          |NN struct RExC_state_t*|NN struct regnode_charclass_class *cl \
+                               |NN const struct regnode_charclass_class *or_with
 Es     |I32    |study_chunk    |struct RExC_state_t*|regnode **scanp|I32 *deltap \
                                |regnode *last|struct scan_data_t *data \
                                |U32 flags

diff --git a/mg.c b/mg.c
index fdc17cb..6bb8796 100644 (file)
--- a/mg.c
+++ b/mg.c
@@ -497,7 +497,7 @@ Perl_magic_len(pTHX_ SV *sv, MAGIC *mg)
                i = t1 - s1;
              getlen:
                if (i > 0 && RX_MATCH_UTF8(rx)) {
-                   char *s    = rx->subbeg + s1;
+                   const char * const s = rx->subbeg + s1;
                    const U8 *ep;
                    STRLEN el;
 

diff --git a/proto.h b/proto.h
index 5009e70..0514853 100644 (file)
--- a/proto.h
+++ b/proto.h
@@ -35,7 +35,9 @@ PERL_CALLCONV int     perl_run(PerlInterpreter* interp)
                        __attribute__nonnull__(1);
 
 PERL_CALLCONV int      perl_parse(PerlInterpreter* interp, XSINIT_t xsinit, int argc, char** argv, char** env);
-PERL_CALLCONV bool     Perl_doing_taint(int argc, char** argv, char** env);
+PERL_CALLCONV bool     Perl_doing_taint(int argc, char** argv, char** env)
+                       __attribute__warn_unused_result__;
+
 #if defined(USE_ITHREADS)
 PERL_CALLCONV PerlInterpreter* perl_clone(PerlInterpreter* interp, UV flags);
 #  if defined(PERL_IMPLICIT_SYS)
@@ -374,7 +376,10 @@ PERL_CALLCONV GP*  Perl_gp_ref(pTHX_ GP* gp);
 PERL_CALLCONV GV*      Perl_gv_AVadd(pTHX_ GV* gv);
 PERL_CALLCONV GV*      Perl_gv_HVadd(pTHX_ GV* gv);
 PERL_CALLCONV GV*      Perl_gv_IOadd(pTHX_ GV* gv);
-PERL_CALLCONV GV*      Perl_gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method);
+PERL_CALLCONV GV*      Perl_gv_autoload4(pTHX_ HV* stash, const char* name, STRLEN len, I32 method)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_2);
+
 PERL_CALLCONV void     Perl_gv_check(pTHX_ HV* stash);
 PERL_CALLCONV void     Perl_gv_efullname(pTHX_ SV* sv, GV* gv);
 /* PERL_CALLCONV void  gv_efullname3(pTHX_ SV* sv, GV* gv, const char* prefix); */
@@ -1537,7 +1542,9 @@ PERL_CALLCONV void        Perl_sv_setpvn(pTHX_ SV* sv, const char* ptr, STRLEN len)
 
 /* PERL_CALLCONV void  sv_setsv(pTHX_ SV* dsv, SV* ssv); */
 PERL_CALLCONV void     Perl_sv_taint(pTHX_ SV* sv);
-PERL_CALLCONV bool     Perl_sv_tainted(pTHX_ SV* sv);
+PERL_CALLCONV bool     Perl_sv_tainted(pTHX_ SV* sv)
+                       __attribute__warn_unused_result__;
+
 PERL_CALLCONV int      Perl_sv_unmagic(pTHX_ SV* sv, int type)
                        __attribute__nonnull__(pTHX_1);
 
@@ -2051,9 +2058,20 @@ STATIC bool      S_path_is_absolute(pTHX_ const char *name)
 
 #if defined(PERL_IN_PP_HOT_C) || defined(PERL_DECL_PROT)
 STATIC int     S_do_maybe_phash(pTHX_ AV *ary, SV **lelem, SV **firstlelem, SV **relem, SV **lastrelem);
-STATIC void    S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem);
-STATIC CV*     S_get_db_sub(pTHX_ SV **svp, CV *cv);
-STATIC SV*     S_method_common(pTHX_ SV* meth, U32* hashp);
+STATIC void    S_do_oddball(pTHX_ HV *hash, SV **relem, SV **firstrelem)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+
+STATIC CV*     S_get_db_sub(pTHX_ SV **svp, CV *cv)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC SV*     S_method_common(pTHX_ SV* meth, U32* hashp)
+                       __attribute__warn_unused_result__
+                       __attribute__nonnull__(pTHX_1);
+
 #endif
 
 #if defined(PERL_IN_PP_SYS_C) || defined(PERL_DECL_PROT)
@@ -2076,23 +2094,61 @@ STATIC int      S_dooneliner(pTHX_ const char *cmd, const char *filename)
 #endif
 
 #if defined(PERL_IN_REGCOMP_C) || defined(PERL_DECL_PROT)
-STATIC regnode*        S_reg(pTHX_ struct RExC_state_t*, I32, I32 *);
-STATIC regnode*        S_reganode(pTHX_ struct RExC_state_t*, U8, U32);
-STATIC regnode*        S_regatom(pTHX_ struct RExC_state_t*, I32 *);
-STATIC regnode*        S_regbranch(pTHX_ struct RExC_state_t*, I32 *, I32);
-STATIC void    S_reguni(pTHX_ struct RExC_state_t*, UV, char *, STRLEN*);
-STATIC regnode*        S_regclass(pTHX_ struct RExC_state_t*);
+STATIC regnode*        S_reg(pTHX_ struct RExC_state_t *state, I32 paren, I32 *flagp)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3);
+
+STATIC regnode*        S_reganode(pTHX_ struct RExC_state_t *state, U8 op, U32 arg)
+                       __attribute__nonnull__(pTHX_1);
+
+STATIC regnode*        S_regatom(pTHX_ struct RExC_state_t *state, I32 *flagp)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC regnode*        S_regbranch(pTHX_ struct RExC_state_t *state, I32 *flagp, I32 first)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC void    S_reguni(pTHX_ const struct RExC_state_t *state, UV uv, char *s, STRLEN *lenp)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3)
+                       __attribute__nonnull__(pTHX_4);
+
+STATIC regnode*        S_regclass(pTHX_ struct RExC_state_t *state)
+                       __attribute__nonnull__(pTHX_1);
+
 STATIC I32     S_regcurly(pTHX_ const char *)
                        __attribute__warn_unused_result__
                        __attribute__nonnull__(pTHX_1);
 
-STATIC regnode*        S_reg_node(pTHX_ struct RExC_state_t*, U8);
-STATIC regnode*        S_regpiece(pTHX_ struct RExC_state_t*, I32 *);
-STATIC void    S_reginsert(pTHX_ struct RExC_state_t*, U8, regnode *);
-STATIC void    S_regoptail(pTHX_ struct RExC_state_t*, regnode *, regnode *);
-STATIC void    S_regtail(pTHX_ struct RExC_state_t*, regnode *, regnode *);
-STATIC char*   S_regwhite(pTHX_ char *p, const char *e);
-STATIC char*   S_nextchar(pTHX_ struct RExC_state_t*);
+STATIC regnode*        S_reg_node(pTHX_ struct RExC_state_t *state, U8 op)
+                       __attribute__nonnull__(pTHX_1);
+
+STATIC regnode*        S_regpiece(pTHX_ struct RExC_state_t *state, I32 *flagp)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC void    S_reginsert(pTHX_ struct RExC_state_t *state, U8 op, regnode *opnd)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_3);
+
+STATIC void    S_regoptail(pTHX_ struct RExC_state_t *state, regnode *p, regnode *val)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+
+STATIC void    S_regtail(pTHX_ struct RExC_state_t *state, regnode *p, regnode *val)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+
+STATIC char*   S_regwhite(pTHX_ char *p, const char *e)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC char*   S_nextchar(pTHX_ struct RExC_state_t*)
+                       __attribute__nonnull__(pTHX_1);
+
 #  ifdef DEBUGGING
 STATIC regnode*        S_dumpuntil(pTHX_ regnode *start, regnode *node, regnode *last, SV* sv, I32 l);
 STATIC void    S_put_byte(pTHX_ SV* sv, int c)
@@ -2100,12 +2156,29 @@ STATIC void     S_put_byte(pTHX_ SV* sv, int c)
 
 #  endif
 STATIC void    S_scan_commit(pTHX_ struct RExC_state_t*, struct scan_data_t *data);
-STATIC void    S_cl_anything(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl);
-STATIC int     S_cl_is_anything(pTHX_ struct regnode_charclass_class *cl);
-STATIC void    S_cl_init(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl);
-STATIC void    S_cl_init_zero(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl);
-STATIC void    S_cl_and(pTHX_ struct regnode_charclass_class *cl, struct regnode_charclass_class *and_with);
-STATIC void    S_cl_or(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl, struct regnode_charclass_class *or_with);
+STATIC void    S_cl_anything(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC int     S_cl_is_anything(pTHX_ const struct regnode_charclass_class *cl)
+                       __attribute__nonnull__(pTHX_1);
+
+STATIC void    S_cl_init(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC void    S_cl_init_zero(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2);
+
+STATIC void    S_cl_and(pTHX_ struct regnode_charclass_class *cl, const struct regnode_charclass_class *and_with)
+                       __attribute__nonnull__(pTHX_1);
+
+STATIC void    S_cl_or(pTHX_ struct RExC_state_t*, struct regnode_charclass_class *cl, const struct regnode_charclass_class *or_with)
+                       __attribute__nonnull__(pTHX_1)
+                       __attribute__nonnull__(pTHX_2)
+                       __attribute__nonnull__(pTHX_3);
+
 STATIC I32     S_study_chunk(pTHX_ struct RExC_state_t*, regnode **scanp, I32 *deltap, regnode *last, struct scan_data_t *data, U32 flags);
 STATIC I32     S_add_data(pTHX_ struct RExC_state_t*, I32 n, const char *s);
 STATIC void    S_re_croak2(pTHX_ const char* pat1, const char* pat2, ...)

diff --git a/regcomp.c b/regcomp.c
index b41f0d0..9151af9 100644 (file)
--- a/regcomp.c
+++ b/regcomp.c
@@ -307,7 +307,7 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  * 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 +325,7 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  * 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 +344,7 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  * 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 +362,19 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  * 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 +382,25 @@ static scan_data_t zero_scan_data = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 
 
 #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
@@ -507,8 +497,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 +520,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 +557,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 +593,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
@@ -770,8 +760,8 @@ S_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, I32 *deltap, reg
 */
                 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;
+                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));
@@ -936,7 +926,7 @@ 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) ?
+                   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),
@@ -1623,7 +1613,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)
@@ -2159,7 +2149,7 @@ S_reg(pTHX_ RExC_state_t *pRExC_state, I32 paren, I32 *flagp)
         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. */
@@ -2171,7 +2161,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++;
@@ -3384,7 +3374,6 @@ S_regwhite(pTHX_ char *p, const char *e)
 STATIC I32
 S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
 {
-    char *posixcc = 0;
     I32 namedclass = OOB_NAMEDCLASS;
 
     if (value == '[' && RExC_parse + 1 < RExC_end &&
@@ -3400,6 +3389,7 @@ S_regpposixcc(pTHX_ RExC_state_t *pRExC_state, I32 value)
            RExC_parse = s;
        else {
            const char* t = RExC_parse++; /* skip over the c */
+           const char *posixcc;
 
            assert(*t == c);
 
@@ -4449,7 +4439,7 @@ 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)
 {
     *lenp = SIZE_ONLY ? UNISKIP(uv) : (uvchr_to_utf8((U8*)s, uv) - (U8*)s);
 }
@@ -4582,82 +4572,6 @@ S_regcurly(pTHX_ register const char *s)
     return TRUE;
 }
 
-
-#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_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 ( 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
  */
@@ -4757,21 +4671,6 @@ Perl_regdump(pTHX_ regexp *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
 */
@@ -4964,9 +4863,9 @@ SV *
 Perl_re_intuit_string(pTHX_ regexp *prog)
 {                              /* Assume that RE_INTUIT is set */
     DEBUG_r(
-       {
-           const char *s = SvPV_nolen_const(prog->check_substr
-                     ? prog->check_substr : prog->check_utf8);
+       {   STRLEN n_a;
+           const char *s = SvPV(prog->check_substr
+                     ? prog->check_substr : prog->check_utf8, n_a);
 
            if (!PL_colorset) reginitcolors();
            PerlIO_printf(Perl_debug_log,
@@ -5206,6 +5105,93 @@ clear_re(pTHX_ void *r)
     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)
+{
+    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 ( 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

diff --git a/sv.c b/sv.c
index f1bd88d..ecd8238 100644 (file)
--- a/sv.c
+++ b/sv.c
@@ -4352,7 +4352,7 @@ Perl_sv_force_normal_flags(pTHX_ register SV *sv, U32 flags)
        if (SvFAKE(sv)) {
            const char *pvx = SvPVX_const(sv);
            const STRLEN len = SvCUR(sv);
-           const U32 hash   = SvSHARED_HASH(sv);
+           const U32 hash = SvSHARED_HASH(sv);
            SvFAKE_off(sv);
            SvREADONLY_off(sv);
            SvGROW(sv, len + 1);
@@ -4412,7 +4412,7 @@ Perl_sv_chop(pTHX_ register SV *sv, register char *ptr)
     if (!SvOOK(sv)) {
        if (!SvLEN(sv)) { /* make copy of shared string */
            const char *pvx = SvPVX_const(sv);
-           STRLEN len = SvCUR(sv);
+           const STRLEN len = SvCUR(sv);
            SvGROW(sv, len + 1);
            Move(pvx,SvPVX_const(sv),len,char);
            *SvEND(sv) = '\0';
@@ -8180,7 +8180,7 @@ bool
 Perl_sv_tainted(pTHX_ SV *sv)
 {
     if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv)) {
-       MAGIC *mg = mg_find(sv, PERL_MAGIC_taint);
+       MAGIC * const mg = mg_find(sv, PERL_MAGIC_taint);
        if (mg && ((mg->mg_len & 1) || ((mg->mg_len & 2) && mg->mg_obj == sv)))
            return TRUE;
     }