Fix my typo, as spotted by Steve Peters

[perl5.git] / cop.h

diff --git a/cop.h b/cop.h
index a630b64..e80f865 100644 (file)
--- a/cop.h
+++ b/cop.h
@@ -186,12 +186,18 @@ struct cop {
                                 ? gv_stashpv(CopSTASHPV(c),GV_ADD) : NULL)
 #  define CopSTASH_set(c,hv)   CopSTASHPV_set(c, (hv) ? HvNAME_get(hv) : NULL)
 #  define CopSTASH_eq(c,hv)    ((hv) && stashpv_hvname_match(c,hv))
+#  define CopLABEL(c)          ((c)->cop_label)
+#  define CopLABEL_set(c,pv)   (CopLABEL(c) = (pv))
 #  ifdef NETWARE
 #    define CopSTASH_free(c) SAVECOPSTASH_FREE(c)
 #    define CopFILE_free(c) SAVECOPFILE_FREE(c)
+#    define CopLABEL_free(c) SAVECOPLABEL_FREE(c)
+#    define CopLABEL_alloc(pv) ((pv)?savepv(pv):NULL)
 #  else
 #    define CopSTASH_free(c)   PerlMemShared_free(CopSTASHPV(c))
 #    define CopFILE_free(c)    (PerlMemShared_free(CopFILE(c)),(CopFILE(c) = NULL))
+#    define CopLABEL_free(c)   (PerlMemShared_free(CopLABEL(c)),(CopLABEL(c) = NULL))
+#    define CopLABEL_alloc(pv) ((pv)?savesharedpv(pv):NULL)
 #  endif
 #else
 #  define CopFILEGV(c)         ((c)->cop_filegv)
@@ -206,13 +212,17 @@ struct cop {
 # endif
 #  define CopFILE(c)           (CopFILESV(c) ? SvPVX(CopFILESV(c)) : NULL)
 #  define CopSTASH(c)          ((c)->cop_stash)
+#  define CopLABEL(c)          ((c)->cop_label)
 #  define CopSTASH_set(c,hv)   ((c)->cop_stash = (hv))
 #  define CopSTASHPV(c)                (CopSTASH(c) ? HvNAME_get(CopSTASH(c)) : NULL)
    /* cop_stash is not refcounted */
 #  define CopSTASHPV_set(c,pv) CopSTASH_set((c), gv_stashpv(pv,GV_ADD))
 #  define CopSTASH_eq(c,hv)    (CopSTASH(c) == (hv))
+#  define CopLABEL_alloc(pv)   ((pv)?savepv(pv):NULL)
+#  define CopLABEL_set(c,pv)   (CopLABEL(c) = (pv))
 #  define CopSTASH_free(c)     
 #  define CopFILE_free(c)      (SvREFCNT_dec(CopFILEGV(c)),(CopFILEGV(c) = NULL))
+#  define CopLABEL_free(c)     (Safefree(CopLABEL(c)),(CopLABEL(c) = NULL))
 
 #endif /* USE_ITHREADS */
 
@@ -320,7 +330,7 @@ struct block_sub {
 #define CLEAR_ARGARRAY(ary) \
     STMT_START {                                                       \
        AvMAX(ary) += AvARRAY(ary) - AvALLOC(ary);                      \
-       SvPV_set(ary, (char*)AvALLOC(ary));                             \
+       AvARRAY(ary) = AvALLOC(ary);                                    \
        AvFILLp(ary) = -1;                                              \
     } STMT_END
 
@@ -393,21 +403,39 @@ struct block_eval {
 struct block_loop {
     char *     label;
     I32                resetsp;
-    OP *       redo_op;
-    OP *       next_op;
-    OP *       last_op;
+    LOOP *     my_op;  /* My op, that contains redo, next and last ops.  */
+    /* (except for non_ithreads we need to modify next_op in pp_ctl.c, hence
+       why next_op is conditionally defined below.)  */
 #ifdef USE_ITHREADS
     void *     iterdata;
     PAD                *oldcomppad;
 #else
+    OP *       next_op;
     SV **      itervar;
 #endif
     SV *       itersave;
+    /* (from inspection of source code) for a .. range of strings this is the
+       current string.  */
     SV *       iterlval;
+    /* (from inspection of source code) for a foreach loop this is the array
+       being iterated over. For a .. range of numbers it's the current value.
+       A check is often made on the SvTYPE of iterary to determine whether
+       we are iterating over an array or a range. (numbers or strings)  */
     AV *       iterary;
     IV         iterix;
+    /* (from inspection of source code) for a .. range of numbers this is the
+       maximum value.  */
     IV         itermax;
 };
+/* It might be possible to squeeze this structure further. As best I can tell
+   itermax and iterlval are never used at the same time, so it might be possible
+   to make them into a union. However, I'm not confident that there are enough
+   flag bits/NULLable pointers in this structure alone to encode which is
+   active. There is, however, U8 of space free in struct block, which could be
+   used. Right now it may not be worth squeezing this structure further, as it's
+   the largest part of struct block, and currently struct block is 64 bytes on
+   an ILP32 system, which will give good cache alignment.
+*/
 
 #ifdef USE_ITHREADS
 #  define CxITERVAR(c)                                                 \
@@ -432,12 +460,19 @@ struct block_loop {
            cx->blk_loop.itersave = NULL;
 #endif
 
+#ifdef USE_ITHREADS
+#  define PUSHLOOP_OP_NEXT             /* No need to do anything.  */
+#  define CX_LOOP_NEXTOP_GET(cx)       ((cx)->blk_loop.my_op->op_nextop + 0)
+#else
+#  define PUSHLOOP_OP_NEXT             cx->blk_loop.next_op = cLOOP->op_nextop
+#  define CX_LOOP_NEXTOP_GET(cx)       ((cx)->blk_loop.next_op + 0)
+#endif
+
 #define PUSHLOOP(cx, dat, s)                                           \
        cx->blk_loop.label = PL_curcop->cop_label;                      \
        cx->blk_loop.resetsp = s - PL_stack_base;                       \
-       cx->blk_loop.redo_op = cLOOP->op_redoop;                        \
-       cx->blk_loop.next_op = cLOOP->op_nextop;                        \
-       cx->blk_loop.last_op = cLOOP->op_lastop;                        \
+       cx->blk_loop.my_op = cLOOP;                                     \
+       PUSHLOOP_OP_NEXT;                                               \
        cx->blk_loop.iterlval = NULL;                                   \
        cx->blk_loop.iterary = NULL;                                    \
        cx->blk_loop.iterix = -1;                                       \
@@ -472,6 +507,7 @@ struct block_givwhen {
 struct block {
     U16                blku_type;      /* what kind of context this is */
     U8         blku_gimme;     /* is this block running in list context? */
+    U8         blku_spare;     /* Padding to match with struct subst */
     I32                blku_oldsp;     /* stack pointer to copy stuff down to */
     COP *      blku_oldcop;    /* old curcop pointer */
     I32                blku_oldmarksp; /* mark stack index */
@@ -531,8 +567,8 @@ struct block {
 /* substitution context */
 struct subst {
     U16                sbu_type;       /* what kind of context this is */
-    bool       sbu_once;
-    bool       sbu_rxtainted;
+    U8         sbu_once;       /* Actually both booleans, but U8 to matches */
+    U8         sbu_rxtainted;  /* struct block */
     I32                sbu_iters;
     I32                sbu_maxiters;
     I32                sbu_rflags;