HV * cop_stash; /* package line was compiled in */
GV * cop_filegv; /* file the following line # is from */
#endif
+ U32 cop_hints; /* hints bits from pragmata */
U32 cop_seq; /* parse sequence number */
line_t cop_line; /* line # of this command */
/* Beware. mg.c and warnings.pl assume the type of this is STRLEN *: */
STRLEN * cop_warnings; /* lexical warnings bitmask */
- SV * cop_io; /* lexical IO defaults */
/* compile time state of %^H. See the comment in op.c for how this is
used to recreate a hash to return from caller. */
struct refcounted_he * cop_hints_hash;
"$[", 2, 0, 0)) \
: 0)
#define CopARYBASE_set(c, b) STMT_START { \
- if (b || ((c)->op_private & HINT_ARYBASE)) { \
- (c)->op_private |= HINT_ARYBASE; \
+ if (b || ((c)->cop_hints & HINT_ARYBASE)) { \
+ (c)->cop_hints |= HINT_ARYBASE; \
if ((c) == &PL_compiling) \
PL_hints |= HINT_LOCALIZE_HH | HINT_ARYBASE; \
(c)->cop_hints_hash \
} STMT_END
/* FIXME NATIVE_HINTS if this is changed from op_private (see perl.h) */
-#define CopHINTS_get(c) ((c)->op_private + 0)
+#define CopHINTS_get(c) ((c)->cop_hints + 0)
#define CopHINTS_set(c, h) STMT_START { \
- (c)->op_private \
- = (U8)((h) & HINT_PRIVATE_MASK); \
+ (c)->cop_hints = (h); \
} STMT_END
/*
POP_SAVEARRAY(); \
/* abandon @_ if it got reified */ \
if (AvREAL(cx->blk_sub.argarray)) { \
- SSize_t fill = AvFILLp(cx->blk_sub.argarray); \
+ const SSize_t fill = AvFILLp(cx->blk_sub.argarray); \
SvREFCNT_dec(cx->blk_sub.argarray); \
cx->blk_sub.argarray = newAV(); \
av_extend(cx->blk_sub.argarray, fill); \
/* 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;
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) \
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; \
/* 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? */
+ 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 */
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;
/* substitution context */
struct subst {
+ U16 sbu_type; /* what kind of context this is */
+ U8 sbu_once; /* Actually both booleans, but U8 to matches */
+ U8 sbu_rxtainted; /* struct block */
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;
cx->sb_rx = rx, \
cx->cx_type = CXt_SUBST; \
rxres_save(&cx->sb_rxres, rx); \
- ReREFCNT_inc(rx)
+ (void)ReREFCNT_inc(rx)
#define POPSUBST(cx) cx = &cxstack[cxstack_ix--]; \
rxres_free(&cx->sb_rxres); \
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
https://perl5.git.perl.org / perl5.git / blobdiff