[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original]

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



>> With this patch the type of failed variable is obvious without
>> grepping the code.

And now for the rest.

PS: I'm fully aware that I mix up macroname with parameter name.
However the assertion parameter is just a funky name for the context
in this case. (the "caller")

assertion "isGV_with_GP(_gvstash)" failed: file "B.c", line 4990
says GvSTASH fails with the isGV_with_GP assertion.
-- 
Reini Urban
difforig op.h pad.h regexp.h

diff -u op.h.orig op.h
--- op.h.orig	2008-04-14 17:58:34.000000000 +0200
+++ op.h	2008-06-08 15:41:13.328125000 +0200
@@ -340,9 +340,9 @@
 /* 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 -u pad.h.orig pad.h
--- pad.h.orig	2008-01-16 13:16:51.000000000 +0100
+++ pad.h	2008-06-08 15:43:22.687500000 +0200
@@ -31,50 +31,54 @@
 #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 @@
 #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 @@
 #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 -u regexp.h.orig regexp.h
--- regexp.h.orig	2008-02-12 16:03:13.000000000 +0100
+++ regexp.h	2008-06-08 15:44:32.000000000 +0200
@@ -187,7 +187,7 @@
 /* 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 @@
 #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 @@
  * 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 @@
 
 /*
  * 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 @@
 
 /*
  * 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 @@
 #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 @@
 
 /* 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 @@
 #  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)
@@ -512,7 +512,7 @@
     char *ganch;
     char *cutpoint;
 } regmatch_info;
- 
+
 
 /* structures for holding and saving the state maintained by regmatch() */
 
@@ -543,15 +543,15 @@
 	    struct regmatch_state *prev_yes_state;
 	    U32 lastparen;
 	    CHECKPOINT cp;
-	    
+	
         } branchlike;
-        	    
+        	
 	struct {
 	    /* the first elements must match u.branchlike */
 	    struct regmatch_state *prev_yes_state;
 	    U32 lastparen;
 	    CHECKPOINT cp;
-	    
+	
 	    regnode *next_branch; /* next branch node */
 	} branch;
 
@@ -663,7 +663,7 @@
 /* how many regmatch_state structs to allocate as a single slab.
  * We do it in 4K blocks for efficiency. The "3" is 2 for the next/prev
  * pointers, plus 1 for any mythical malloc overhead. */
- 
+
 #define PERL_REGMATCH_SLAB_SLOTS \
     ((4096 - 3 * sizeof (void*)) / sizeof(regmatch_state))
 

Follow-Ups from:
"Reini Urban" <rurban@x-ray.at>

[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index][Thread Index][Top&Search][Original]