Re: [PATCH] readable assertion names, now the rest

From: "Reini Urban" <rurban@x-ray.at>
Message-ID: <6910a60806080717h1aaaef1fh425a2ef21a62c9ed@mail.gmail.com>

p4raw-id: //depot/perl@34030

diff --git a/cv.h b/cv.h
index aca3748..53c4733 100644 (file)
--- a/cv.h
+++ b/cv.h
@@ -56,10 +56,10 @@ Returns the stash of the CV.
 #endif
 #define CvFILEGV(sv)   (gv_fetchfile(CvFILE(sv)))
 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
-#  define CvDEPTH(sv) (*({const CV *_cv = (CV *)sv; \
-                         assert(SvTYPE(_cv) == SVt_PVCV ||      \
-                                SvTYPE(_cv) == SVt_PVFM);       \
-                         &((XPVCV*)SvANY(_cv))->xiv_u.xivu_i32; \
+#  define CvDEPTH(sv) (*({const CV *_cvdepth = (CV *)sv;         \
+                         assert(SvTYPE(_cvdepth) == SVt_PVCV || \
+                                SvTYPE(_cvdepth) == SVt_PVFM);  \
+                         &((XPVCV*)SvANY(_cvdepth))->xiv_u.xivu_i32; \
                        }))
 #else
 #  define CvDEPTH(sv)  ((XPVCV*)SvANY(sv))->xiv_u.xivu_i32

diff --git a/op.h b/op.h
index a5cd625..e263a9c 100644 (file)
--- a/op.h
+++ b/op.h
@@ -340,9 +340,9 @@ struct pmop {
 /* BEWARE - something that calls this macro passes (r) which has a side
    effect.  */
 #define PM_SETRE(o,r)  STMT_START {                                    \
-                            const REGEXP *const whap = (r);            \
-                            assert(whap);                              \
-                           PL_regex_pad[(o)->op_pmoffset] = (SV*)whap; \
+                            const REGEXP *const _pm_setre = (r);       \
+                            assert(_pm_setre);                         \
+                           PL_regex_pad[(o)->op_pmoffset] = (SV*)_pm_setre; \
                         } STMT_END
 #else
 #define PM_GETRE(o)     ((o)->op_pmregexp)

diff --git a/pad.h b/pad.h
index 33717d3..f6c528c 100644 (file)
--- a/pad.h
+++ b/pad.h
@@ -31,50 +31,54 @@ typedef U64TYPE PADOFFSET;
 #endif
 #define NOT_IN_PAD ((PADOFFSET) -1)
 
-/* B.xs needs these for the benefit of B::Deparse */ 
+/* B.xs needs these for the benefit of B::Deparse */
 /* Low range end is exclusive (valid from the cop seq after this one) */
 /* High range end is inclusive (valid up to this cop seq) */
 
 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
 #  define COP_SEQ_RANGE_LOW(sv)                                                \
-       (({ SV *const _svi = (SV *) (sv);                               \
-         assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);   \
-         assert(SvTYPE(_svi) != SVt_PVAV);                             \
-         assert(SvTYPE(_svi) != SVt_PVHV);                             \
-         assert(SvTYPE(_svi) != SVt_PVCV);                             \
-         assert(SvTYPE(_svi) != SVt_PVFM);                             \
-         assert(!isGV_with_GP(_svi));                                  \
-         ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xlow;              \
+       (({ SV *const _sv_cop_seq_range_low = (SV *) (sv);              \
+         assert(SvTYPE(_sv_cop_seq_range_low) == SVt_NV                \
+                || SvTYPE(_sv_cop_seq_range_low) >= SVt_PVNV);         \
+         assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVAV);            \
+         assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVHV);            \
+         assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVCV);            \
+         assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVFM);            \
+         assert(!isGV_with_GP(_sv_cop_seq_range_low));                 \
+         ((XPVNV*) SvANY(_sv_cop_seq_range_low))->xnv_u.xpad_cop_seq.xlow; \
         }))
 #  define COP_SEQ_RANGE_HIGH(sv)                                       \
-       (({ SV *const _svi = (SV *) (sv);                               \
-         assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);   \
-         assert(SvTYPE(_svi) != SVt_PVAV);                             \
-         assert(SvTYPE(_svi) != SVt_PVHV);                             \
-         assert(SvTYPE(_svi) != SVt_PVCV);                             \
-         assert(SvTYPE(_svi) != SVt_PVFM);                             \
-         assert(!isGV_with_GP(_svi));                                  \
-         ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xhigh;             \
+       (({ SV *const _sv_cop_seq_range_high = (SV *) (sv);             \
+         assert(SvTYPE(_sv_cop_seq_range_high) == SVt_NV               \
+                 || SvTYPE(_sv_cop_seq_range_high) >= SVt_PVNV);       \
+         assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVAV);           \
+         assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVHV);           \
+         assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVCV);           \
+         assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVFM);           \
+         assert(!isGV_with_GP(_sv_cop_seq_range_high));                \
+         ((XPVNV*) SvANY(_sv_cop_seq_range_high))->xnv_u.xpad_cop_seq.xhigh; \
         }))
 #  define PARENT_PAD_INDEX(sv)                                         \
-       (({ SV *const _svi = (SV *) (sv);                               \
-         assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);   \
-         assert(SvTYPE(_svi) != SVt_PVAV);                             \
-         assert(SvTYPE(_svi) != SVt_PVHV);                             \
-         assert(SvTYPE(_svi) != SVt_PVCV);                             \
-         assert(SvTYPE(_svi) != SVt_PVFM);                             \
-         assert(!isGV_with_GP(_svi));                                  \
-         ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xlow;              \
+       (({ SV *const _sv_parent_pad_index = (SV *) (sv);               \
+         assert(SvTYPE(_sv_parent_pad_index) == SVt_NV                 \
+                || SvTYPE(_sv_parent_pad_index) >= SVt_PVNV);          \
+         assert(SvTYPE(_sv_parent_pad_index) != SVt_PVAV);             \
+         assert(SvTYPE(_sv_parent_pad_index) != SVt_PVHV);             \
+         assert(SvTYPE(_sv_parent_pad_index) != SVt_PVCV);             \
+         assert(SvTYPE(_sv_parent_pad_index) != SVt_PVFM);             \
+         assert(!isGV_with_GP(_sv_parent_pad_index));                  \
+         ((XPVNV*) SvANY(_sv_parent_pad_index))->xnv_u.xpad_cop_seq.xlow; \
         }))
 #  define PARENT_FAKELEX_FLAGS(sv)                                     \
-       (({ SV *const _svi = (SV *) (sv);                               \
-         assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);   \
-         assert(SvTYPE(_svi) != SVt_PVAV);                             \
-         assert(SvTYPE(_svi) != SVt_PVHV);                             \
-         assert(SvTYPE(_svi) != SVt_PVCV);                             \
-         assert(SvTYPE(_svi) != SVt_PVFM);                             \
-         assert(!isGV_with_GP(_svi));                                  \
-         ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xhigh;             \
+       (({ SV *const _sv_parent_fakelex_flags = (SV *) (sv);           \
+         assert(SvTYPE(_sv_parent_fakelex_flags) == SVt_NV             \
+                || SvTYPE(_sv_parent_fakelex_flags) >= SVt_PVNV);      \
+         assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVAV);         \
+         assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVHV);         \
+         assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVCV);         \
+         assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVFM);         \
+         assert(!isGV_with_GP(_sv_parent_fakelex_flags));              \
+         ((XPVNV*) SvANY(_sv_parent_fakelex_flags))->xnv_u.xpad_cop_seq.xhigh; \
         }))
 #else
 #  define COP_SEQ_RANGE_LOW(sv)                \
@@ -90,7 +94,7 @@ typedef U64TYPE PADOFFSET;
 #endif
 
 /* Flags set in the SvIVX field of FAKE namesvs */
-    
+
 #define PAD_FAKELEX_ANON   1 /* the lex is declared in an ANON, or ... */
 #define PAD_FAKELEX_MULTI  2 /* the lex can be instantiated multiple times */
 
@@ -207,7 +211,7 @@ Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
 #define PAD_BASE_SV(padlist, po) \
        (AvARRAY(padlist)[1])   \
            ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : NULL;
-    
+
 
 #define PAD_SET_CUR_NOSAVE(padlist,nth) \
        PL_comppad = (PAD*) (AvARRAY(padlist)[nth]);            \

diff --git a/regexp.h b/regexp.h
index 156e60b..0e5f072 100644 (file)
--- a/regexp.h
+++ b/regexp.h
@@ -187,7 +187,7 @@ typedef struct regexp_engine {
 /* Whether this is being called from a re:: function */
 #define RXapif_REGNAME         0x0400
 #define RXapif_REGNAMES        0x0800
-#define RXapif_REGNAMES_COUNT  0x1000 
+#define RXapif_REGNAMES_COUNT  0x1000
 
 /*
 =head1 REGEXP Functions
@@ -224,7 +224,7 @@ and check for NULL.
 #define SvRXOK(sv) (Perl_get_re_arg(aTHX_ sv) ? TRUE : FALSE)
 
 
-/* Flags stored in regexp->extflags 
+/* Flags stored in regexp->extflags
  * These are used by code external to the regexp engine
  *
  * Note that flags starting with RXf_PMf_ have exact equivalents
@@ -232,7 +232,7 @@ and check for NULL.
  * numerically here only for clarity.
  *
  * NOTE: if you modify any RXf flags you should run regen.pl or regcomp.pl
- * so that regnodes.h is updated with the changes. 
+ * so that regnodes.h is updated with the changes.
  *
  */
 
@@ -289,7 +289,7 @@ and check for NULL.
 
 /*
  * NOTE: if you modify any RXf flags you should run regen.pl or regcomp.pl
- * so that regnodes.h is updated with the changes. 
+ * so that regnodes.h is updated with the changes.
  *
  */
 
@@ -344,7 +344,7 @@ and check for NULL.
 
 /*
  * NOTE: if you modify any RXf flags you should run regen.pl or regcomp.pl
- * so that regnodes.h is updated with the changes. 
+ * so that regnodes.h is updated with the changes.
  *
  */
 
@@ -382,33 +382,33 @@ and check for NULL.
 #if defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
 #  define RX_EXTFLAGS(prog)                                            \
     (*({                                                               \
-       const REGEXP *const thwape = (prog);                            \
-       assert(SvTYPE(thwape) == SVt_REGEXP);                           \
-       &RXp_EXTFLAGS(SvANY(thwape));                                   \
+       const REGEXP *const _rx_extflags = (prog);                      \
+       assert(SvTYPE(_rx_extflags) == SVt_REGEXP);                     \
+       &RXp_EXTFLAGS(SvANY(_rx_extflags));                             \
     }))
 #  define RX_ENGINE(prog)                                              \
     (*({                                                               \
-       const REGEXP *const thwape = (prog);                            \
-       assert(SvTYPE(thwape) == SVt_REGEXP);                           \
-       &SvANY(thwape)->engine;                                         \
+       const REGEXP *const _rx_engine = (prog);                        \
+       assert(SvTYPE(_rx_engine) == SVt_REGEXP);                       \
+       &SvANY(_rx_engine)->engine;                                     \
     }))
 #  define RX_SUBBEG(prog)                                              \
     (*({                                                               \
-       const REGEXP *const thwape = (prog);                            \
-       assert(SvTYPE(thwape) == SVt_REGEXP);                           \
-       &SvANY(thwape)->subbeg;                                         \
+       const REGEXP *const _rx_subbeg = (prog);                        \
+       assert(SvTYPE(_rx_subbeg) == SVt_REGEXP);                       \
+       &SvANY(_rx_subbeg)->subbeg;                                     \
     }))
 #  define RX_OFFS(prog)                                                        \
     (*({                                                               \
-       const REGEXP *const thwape = (prog);                            \
-       assert(SvTYPE(thwape) == SVt_REGEXP);                           \
-       &SvANY(thwape)->offs;                                           \
+       const REGEXP *const _rx_offs = (prog);                          \
+       assert(SvTYPE(_rx_offs) == SVt_REGEXP);                         \
+       &SvANY(_rx_offs)->offs;                                         \
     }))
 #  define RX_NPARENS(prog)                                             \
     (*({                                                               \
-       const REGEXP *const thwape = (prog);                            \
-       assert(SvTYPE(thwape) == SVt_REGEXP);                           \
-       &SvANY(thwape)->nparens;                                        \
+       const REGEXP *const _rx_nparens = (prog);                       \
+       assert(SvTYPE(_rx_nparens) == SVt_REGEXP);                      \
+       &SvANY(_rx_nparens)->nparens;                                   \
     }))
 #else
 #  define RX_EXTFLAGS(prog)    RXp_EXTFLAGS((struct regexp *)SvANY(prog))
@@ -457,7 +457,7 @@ and check for NULL.
 
 /* Whether the pattern stored at RX_WRAPPED is in UTF-8  */
 #define RX_UTF8(prog)                  SvUTF8(prog)
-    
+
 #define REXEC_COPY_STR 0x01            /* Need to copy the string. */
 #define REXEC_CHECKED  0x02            /* check_substr already checked. */
 #define REXEC_SCREAM   0x04            /* use scream table. */
@@ -468,16 +468,16 @@ and check for NULL.
 #  define ReREFCNT_inc(re)                                             \
     ({                                                                 \
        /* This is here to generate a casting warning if incorrect.  */ \
-       REGEXP *const zwapp = (re);                                     \
-       assert(SvTYPE(zwapp) == SVt_REGEXP);                            \
-       SvREFCNT_inc(zwapp);                                            \
-       zwapp;                                                          \
+       REGEXP *const _rerefcnt_inc = (re);                             \
+       assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP);                    \
+       SvREFCNT_inc(_rerefcnt_inc);                                    \
+       _rerefcnt_inc;                                                  \
     })
 #  define ReREFCNT_dec(re)                                             \
     ({                                                                 \
        /* This is here to generate a casting warning if incorrect.  */ \
-       REGEXP *const boff = (re);                                      \
-       SvREFCNT_dec(boff);                                             \
+       REGEXP *const _rerefcnt_dec = (re);                             \
+       SvREFCNT_dec(_rerefcnt_dec);                                    \
     })
 #else
 #  define ReREFCNT_dec(re)     SvREFCNT_dec(re)