This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Remove some excess cleverness from the Bhk macros.
authorBen Morrow <ben@morrow.me.uk>
Sun, 10 Oct 2010 22:10:15 +0000 (23:10 +0100)
committerFather Chrysostomos <sprout@cpan.org>
Mon, 11 Oct 2010 00:25:15 +0000 (17:25 -0700)
Allowing BhkENTRY(bhk, start) to look up the bhk_start member defeats
much of the point of having a bhk_ prefix in the first place: if a
member is added later called (say) 'bhk_die', any invocation of
BhkENTRY(bhk, die) will expand to BhkENTRY(bhk, Perl_die) because of the
API macros. Requiring BhkENTRY(bhk, bhk_start), while tedious, is much
safer.

ext/XS-APItest/APItest.xs
op.c
op.h
pod/perlguts.pod
pp_ctl.c

index b0cbf6a..67420de 100644 (file)
@@ -1058,18 +1058,18 @@ BOOT:
     MY_CXT.bhkav = get_av("XS::APItest::bhkav", GV_ADDMULTI);
     MY_CXT.bhk_record = 0;
 
-    BhkENTRY_set(&bhk_test, start, blockhook_test_start);
-    BhkENTRY_set(&bhk_test, pre_end, blockhook_test_pre_end);
-    BhkENTRY_set(&bhk_test, post_end, blockhook_test_post_end);
-    BhkENTRY_set(&bhk_test, eval, blockhook_test_eval);
+    BhkENTRY_set(&bhk_test, bhk_start, blockhook_test_start);
+    BhkENTRY_set(&bhk_test, bhk_pre_end, blockhook_test_pre_end);
+    BhkENTRY_set(&bhk_test, bhk_post_end, blockhook_test_post_end);
+    BhkENTRY_set(&bhk_test, bhk_eval, blockhook_test_eval);
     Perl_blockhook_register(aTHX_ &bhk_test);
 
     MY_CXT.cscgv = gv_fetchpvs("XS::APItest::COMPILE_SCOPE_CONTAINER",
         GV_ADDMULTI, SVt_PVAV);
     MY_CXT.cscav = GvAV(MY_CXT.cscgv);
 
-    BhkENTRY_set(&bhk_csc, start, blockhook_csc_start);
-    BhkENTRY_set(&bhk_csc, pre_end, blockhook_csc_pre_end);
+    BhkENTRY_set(&bhk_csc, bhk_start, blockhook_csc_start);
+    BhkENTRY_set(&bhk_csc, bhk_pre_end, blockhook_csc_pre_end);
     Perl_blockhook_register(aTHX_ &bhk_csc);
 
     MY_CXT.peep_recorder = newAV();
diff --git a/op.c b/op.c
index 86b933f..e4ddfbc 100644 (file)
--- a/op.c
+++ b/op.c
@@ -2345,7 +2345,7 @@ Perl_block_start(pTHX_ int full)
     SAVECOMPILEWARNINGS();
     PL_compiling.cop_warnings = DUP_WARNINGS(PL_compiling.cop_warnings);
 
-    CALL_BLOCK_HOOKS(start, full);
+    CALL_BLOCK_HOOKS(bhk_start, full);
 
     return retval;
 }
@@ -2357,7 +2357,7 @@ Perl_block_end(pTHX_ I32 floor, OP *seq)
     const int needblockscope = PL_hints & HINT_BLOCK_SCOPE;
     OP* retval = scalarseq(seq);
 
-    CALL_BLOCK_HOOKS(pre_end, &retval);
+    CALL_BLOCK_HOOKS(bhk_pre_end, &retval);
 
     LEAVE_SCOPE(floor);
     CopHINTS_set(&PL_compiling, PL_hints);
@@ -2365,7 +2365,7 @@ Perl_block_end(pTHX_ I32 floor, OP *seq)
        PL_hints |= HINT_BLOCK_SCOPE; /* propagate out */
     pad_leavemy();
 
-    CALL_BLOCK_HOOKS(post_end, &retval);
+    CALL_BLOCK_HOOKS(bhk_post_end, &retval);
 
     return retval;
 }
diff --git a/op.h b/op.h
index e03468f..71bab3e 100644 (file)
--- a/op.h
+++ b/op.h
@@ -696,13 +696,13 @@ preprocessing token; the type of I<arg> depends on I<which>.
 
 #define BhkFLAGS(hk)           ((hk)->bhk_flags)
 
-#define BHKf_start         0x01
-#define BHKf_pre_end       0x02
-#define BHKf_post_end      0x04
-#define BHKf_eval          0x08
+#define BHKf_bhk_start     0x01
+#define BHKf_bhk_pre_end    0x02
+#define BHKf_bhk_post_end   0x04
+#define BHKf_bhk_eval      0x08
 
 #define BhkENTRY(hk, which) \
-    ((BhkFLAGS(hk) & BHKf_ ## which) ? ((hk)->bhk_ ## which) : NULL)
+    ((BhkFLAGS(hk) & BHKf_ ## which) ? ((hk)->which) : NULL)
 
 #define BhkENABLE(hk, which) \
     STMT_START { \
@@ -717,7 +717,7 @@ preprocessing token; the type of I<arg> depends on I<which>.
 
 #define BhkENTRY_set(hk, which, ptr) \
     STMT_START { \
-       (hk)->bhk_ ## which = ptr; \
+       (hk)->which = ptr; \
        BhkENABLE(hk, which); \
     } STMT_END
 
index 5113e51..104f27b 100644 (file)
@@ -1884,7 +1884,7 @@ this:
     STATIC BHK my_hooks;
 
     BOOT:
-        BhkENTRY_set(&my_hooks, start, my_start_hook);
+        BhkENTRY_set(&my_hooks, bhk_start, my_start_hook);
         Perl_blockhook_register(aTHX_ &my_hooks);
 
 This will arrange to have C<my_start_hook> called at the start of
@@ -1892,7 +1892,7 @@ compiling every lexical scope. The available hooks are:
 
 =over 4
 
-=item C<void start(pTHX_ int full)>
+=item C<void bhk_start(pTHX_ int full)>
 
 This is called just after starting a new lexical scope. Note that Perl
 code like
@@ -1905,20 +1905,20 @@ C<}>, so calls to C<start> and C<pre/post_end> will match. Anything
 pushed onto the save stack by this hook will be popped just before the
 scope ends (between the C<pre_> and C<post_end> hooks, in fact).
 
-=item C<void pre_end(pTHX_ OP **o)>
+=item C<void bhk_pre_end(pTHX_ OP **o)>
 
 This is called at the end of a lexical scope, just before unwinding the
 stack. I<o> is the root of the optree representing the scope; it is a
 double pointer so you can replace the OP if you need to.
 
-=item C<void post_end(pTHX_ OP **o)>
+=item C<void bhk_post_end(pTHX_ OP **o)>
 
 This is called at the end of a lexical scope, just after unwinding the
 stack. I<o> is as above. Note that it is possible for calls to C<pre_>
 and C<post_end> to nest, if there is something on the save stack that
 calls string eval.
 
-=item C<void eval(pTHX_ OP *const o)>
+=item C<void bhk_eval(pTHX_ OP *const o)>
 
 This is called just before starting to compile an C<eval STRING>, C<do
 FILE>, C<require> or C<use>, after the eval has been set up. I<o> is the
index 20a0701..a9d92f1 100644 (file)
--- a/pp_ctl.c
+++ b/pp_ctl.c
@@ -3209,7 +3209,7 @@ S_doeval(pTHX_ int gimme, OP** startop, CV* outside, U32 seq)
     else
        CLEAR_ERRSV();
 
-    CALL_BLOCK_HOOKS(eval, saveop);
+    CALL_BLOCK_HOOKS(bhk_eval, saveop);
 
     /* note that yyparse() may raise an exception, e.g. C<BEGIN{die}>,
      * so honour CATCH_GET and trap it here if necessary */