Fix nit in possessive quantifier descriptions.

[p5sagit/p5-mst-13.2.git] / cop.h

diff --git a/cop.h b/cop.h
index bfaea57..effdbf3 100644 (file)
--- a/cop.h
+++ b/cop.h
@@ -358,8 +358,8 @@ struct block_sub {
 
 /* eval context */
 struct block_eval {
-    I32                old_in_eval;
-    I32                old_op_type;
+    U8         old_in_eval;
+    U16                old_op_type;
     SV *       old_namesv;
     OP *       old_eval_root;
     SV *       cur_text;
@@ -393,21 +393,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 +450,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;                                       \
@@ -470,12 +495,13 @@ struct block_givwhen {
 
 /* context common to subroutines, evals and loops */
 struct block {
+    U16                blku_type;      /* what kind of context this is */
+    U8         blku_gimme;     /* is this block running in list context? */
     I32                blku_oldsp;     /* stack pointer to copy stuff down to */
     COP *      blku_oldcop;    /* old curcop pointer */
     I32                blku_oldmarksp; /* mark stack index */
     I32                blku_oldscopesp;        /* scope stack index */
     PMOP *     blku_oldpm;     /* values of pattern match vars */
-    U8         blku_gimme;     /* is this block running in list context? */
 
     union {
        struct block_sub        blku_sub;
@@ -529,12 +555,13 @@ struct block {
 
 /* substitution context */
 struct subst {
+    U16                sbu_type;       /* what kind of context this is */
+    bool       sbu_once;
+    bool       sbu_rxtainted;
     I32                sbu_iters;
     I32                sbu_maxiters;
     I32                sbu_rflags;
     I32                sbu_oldsave;
-    bool       sbu_once;
-    bool       sbu_rxtainted;
     char *     sbu_orig;
     SV *       sbu_dstr;
     SV *       sbu_targ;
@@ -583,12 +610,12 @@ struct subst {
        ReREFCNT_dec(cx->sb_rx)
 
 struct context {
-    U32                cx_type;        /* what kind of context this is */
     union {
        struct block    cx_blk;
        struct subst    cx_subst;
     } cx_u;
 };
+#define cx_type cx_u.cx_subst.sbu_type
 
 #define CXTYPEMASK     0xff
 #define CXt_NULL       0