| 1 |
root |
1.1 |
/* op.h |
| 2 |
|
|
* |
| 3 |
|
|
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, |
| 4 |
|
|
* 2000, 2001, 2002, 2003, 2004, 2005 by Larry Wall and others |
| 5 |
|
|
* |
| 6 |
|
|
* You may distribute under the terms of either the GNU General Public |
| 7 |
|
|
* License or the Artistic License, as specified in the README file. |
| 8 |
|
|
* |
| 9 |
|
|
*/ |
| 10 |
|
|
|
| 11 |
|
|
/* |
| 12 |
|
|
* The fields of BASEOP are: |
| 13 |
|
|
* op_next Pointer to next ppcode to execute after this one. |
| 14 |
|
|
* (Top level pre-grafted op points to first op, |
| 15 |
|
|
* but this is replaced when op is grafted in, when |
| 16 |
|
|
* this op will point to the real next op, and the new |
| 17 |
|
|
* parent takes over role of remembering starting op.) |
| 18 |
|
|
* op_ppaddr Pointer to current ppcode's function. |
| 19 |
|
|
* op_type The type of the operation. |
| 20 |
|
|
* op_flags Flags common to all operations. See OPf_* below. |
| 21 |
|
|
* op_private Flags peculiar to a particular operation (BUT, |
| 22 |
|
|
* by default, set to the number of children until |
| 23 |
|
|
* the operation is privatized by a check routine, |
| 24 |
|
|
* which may or may not check number of children). |
| 25 |
|
|
*/ |
| 26 |
|
|
|
| 27 |
|
|
#ifdef DEBUGGING_OPS |
| 28 |
|
|
#define OPCODE opcode |
| 29 |
|
|
#else |
| 30 |
|
|
#define OPCODE U16 |
| 31 |
|
|
#endif |
| 32 |
|
|
|
| 33 |
|
|
#ifdef BASEOP_DEFINITION |
| 34 |
|
|
#define BASEOP BASEOP_DEFINITION |
| 35 |
|
|
#else |
| 36 |
|
|
#define BASEOP \ |
| 37 |
|
|
OP* op_next; \ |
| 38 |
|
|
OP* op_sibling; \ |
| 39 |
|
|
OP* (CPERLscope(*op_ppaddr))(pTHX); \ |
| 40 |
|
|
PADOFFSET op_targ; \ |
| 41 |
|
|
OPCODE op_type; \ |
| 42 |
|
|
U16 op_seq; \ |
| 43 |
|
|
U8 op_flags; \ |
| 44 |
|
|
U8 op_private; |
| 45 |
|
|
#endif |
| 46 |
|
|
|
| 47 |
|
|
#define OP_GIMME(op,dfl) \ |
| 48 |
|
|
(((op)->op_flags & OPf_WANT) == OPf_WANT_VOID ? G_VOID : \ |
| 49 |
|
|
((op)->op_flags & OPf_WANT) == OPf_WANT_SCALAR ? G_SCALAR : \ |
| 50 |
|
|
((op)->op_flags & OPf_WANT) == OPf_WANT_LIST ? G_ARRAY : \ |
| 51 |
|
|
dfl) |
| 52 |
|
|
|
| 53 |
|
|
/* |
| 54 |
|
|
=head1 "Gimme" Values |
| 55 |
|
|
|
| 56 |
|
|
=for apidoc Amn|U32|GIMME_V |
| 57 |
|
|
The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>, |
| 58 |
|
|
C<G_SCALAR> or C<G_ARRAY> for void, scalar or list context, |
| 59 |
|
|
respectively. |
| 60 |
|
|
|
| 61 |
|
|
=for apidoc Amn|U32|GIMME |
| 62 |
|
|
A backward-compatible version of C<GIMME_V> which can only return |
| 63 |
|
|
C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>. |
| 64 |
|
|
Deprecated. Use C<GIMME_V> instead. |
| 65 |
|
|
|
| 66 |
|
|
=cut |
| 67 |
|
|
*/ |
| 68 |
|
|
|
| 69 |
|
|
#define GIMME_V OP_GIMME(PL_op, block_gimme()) |
| 70 |
|
|
|
| 71 |
|
|
/* Public flags */ |
| 72 |
|
|
|
| 73 |
|
|
#define OPf_WANT 3 /* Mask for "want" bits: */ |
| 74 |
|
|
#define OPf_WANT_VOID 1 /* Want nothing */ |
| 75 |
|
|
#define OPf_WANT_SCALAR 2 /* Want single value */ |
| 76 |
|
|
#define OPf_WANT_LIST 3 /* Want list of any length */ |
| 77 |
|
|
#define OPf_KIDS 4 /* There is a firstborn child. */ |
| 78 |
|
|
#define OPf_PARENS 8 /* This operator was parenthesized. */ |
| 79 |
|
|
/* (Or block needs explicit scope entry.) */ |
| 80 |
|
|
#define OPf_REF 16 /* Certified reference. */ |
| 81 |
|
|
/* (Return container, not containee). */ |
| 82 |
|
|
#define OPf_MOD 32 /* Will modify (lvalue). */ |
| 83 |
|
|
#define OPf_STACKED 64 /* Some arg is arriving on the stack. */ |
| 84 |
|
|
#define OPf_SPECIAL 128 /* Do something weird for this op: */ |
| 85 |
|
|
/* On local LVAL, don't init local value. */ |
| 86 |
|
|
/* On OP_SORT, subroutine is inlined. */ |
| 87 |
|
|
/* On OP_NOT, inversion was implicit. */ |
| 88 |
|
|
/* On OP_LEAVE, don't restore curpm. */ |
| 89 |
|
|
/* On truncate, we truncate filehandle */ |
| 90 |
|
|
/* On control verbs, we saw no label */ |
| 91 |
|
|
/* On flipflop, we saw ... instead of .. */ |
| 92 |
|
|
/* On UNOPs, saw bare parens, e.g. eof(). */ |
| 93 |
|
|
/* On OP_ENTERSUB || OP_NULL, saw a "do". */ |
| 94 |
|
|
/* On OP_EXISTS, treat av as av, not avhv. */ |
| 95 |
|
|
/* On OP_(ENTER|LEAVE)EVAL, don't clear $@ */ |
| 96 |
|
|
/* On OP_ENTERITER, loop var is per-thread */ |
| 97 |
|
|
/* On pushre, re is /\s+/ imp. by split " " */ |
| 98 |
|
|
/* On regcomp, "use re 'eval'" was in scope */ |
| 99 |
|
|
/* On OP_READLINE, was <$filehandle> */ |
| 100 |
|
|
/* On RV2[SG]V, don't create GV--in defined()*/ |
| 101 |
|
|
/* On OP_DBSTATE, indicates breakpoint |
| 102 |
|
|
* (runtime property) */ |
| 103 |
|
|
/* On OP_AELEMFAST, indiciates pad var */ |
| 104 |
|
|
|
| 105 |
|
|
/* old names; don't use in new code, but don't break them, either */ |
| 106 |
|
|
#define OPf_LIST OPf_WANT_LIST |
| 107 |
|
|
#define OPf_KNOW OPf_WANT |
| 108 |
|
|
|
| 109 |
|
|
#define GIMME \ |
| 110 |
|
|
(PL_op->op_flags & OPf_WANT \ |
| 111 |
|
|
? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST \ |
| 112 |
|
|
? G_ARRAY \ |
| 113 |
|
|
: G_SCALAR) \ |
| 114 |
|
|
: dowantarray()) |
| 115 |
|
|
|
| 116 |
|
|
/* NOTE: OP_NEXTSTATE, OP_DBSTATE, and OP_SETSTATE (i.e. COPs) carry lower |
| 117 |
|
|
* bits of PL_hints in op_private */ |
| 118 |
|
|
|
| 119 |
|
|
/* Private for lvalues */ |
| 120 |
|
|
#define OPpLVAL_INTRO 128 /* Lvalue must be localized or lvalue sub */ |
| 121 |
|
|
|
| 122 |
|
|
/* Private for OP_LEAVE, OP_LEAVESUB, OP_LEAVESUBLV and OP_LEAVEWRITE */ |
| 123 |
|
|
#define OPpREFCOUNTED 64 /* op_targ carries a refcount */ |
| 124 |
|
|
|
| 125 |
|
|
/* Private for OP_AASSIGN */ |
| 126 |
|
|
#define OPpASSIGN_COMMON 64 /* Left & right have syms in common. */ |
| 127 |
|
|
#define OPpASSIGN_HASH 32 /* Assigning to possible pseudohash. */ |
| 128 |
|
|
|
| 129 |
|
|
/* Private for OP_SASSIGN */ |
| 130 |
|
|
#define OPpASSIGN_BACKWARDS 64 /* Left & right switched. */ |
| 131 |
|
|
|
| 132 |
|
|
/* Private for OP_MATCH and OP_SUBST{,CONST} */ |
| 133 |
|
|
#define OPpRUNTIME 64 /* Pattern coming in on the stack */ |
| 134 |
|
|
|
| 135 |
|
|
/* Private for OP_TRANS */ |
| 136 |
|
|
#define OPpTRANS_FROM_UTF 1 |
| 137 |
|
|
#define OPpTRANS_TO_UTF 2 |
| 138 |
|
|
#define OPpTRANS_IDENTICAL 4 /* right side is same as left */ |
| 139 |
|
|
#define OPpTRANS_SQUASH 8 |
| 140 |
|
|
#define OPpTRANS_DELETE 16 |
| 141 |
|
|
#define OPpTRANS_COMPLEMENT 32 |
| 142 |
|
|
#define OPpTRANS_GROWS 64 |
| 143 |
|
|
|
| 144 |
|
|
/* Private for OP_REPEAT */ |
| 145 |
|
|
#define OPpREPEAT_DOLIST 64 /* List replication. */ |
| 146 |
|
|
|
| 147 |
|
|
/* Private for OP_RV2GV, OP_RV2SV, OP_AELEM, OP_HELEM, OP_PADSV */ |
| 148 |
|
|
#define OPpDEREF (32|64) /* autovivify: Want ref to something: */ |
| 149 |
|
|
#define OPpDEREF_AV 32 /* Want ref to AV. */ |
| 150 |
|
|
#define OPpDEREF_HV 64 /* Want ref to HV. */ |
| 151 |
|
|
#define OPpDEREF_SV (32|64) /* Want ref to SV. */ |
| 152 |
|
|
/* OP_ENTERSUB only */ |
| 153 |
|
|
#define OPpENTERSUB_DB 16 /* Debug subroutine. */ |
| 154 |
|
|
#define OPpENTERSUB_HASTARG 32 /* Called from OP tree. */ |
| 155 |
|
|
#define OPpENTERSUB_NOMOD 64 /* Immune to mod() for :attrlist. */ |
| 156 |
|
|
/* OP_RV2CV only */ |
| 157 |
|
|
#define OPpENTERSUB_AMPER 8 /* Used & form to call. */ |
| 158 |
|
|
#define OPpENTERSUB_NOPAREN 128 /* bare sub call (without parens) */ |
| 159 |
|
|
#define OPpENTERSUB_INARGS 4 /* Lval used as arg to a sub. */ |
| 160 |
|
|
/* OP_GV only */ |
| 161 |
|
|
#define OPpEARLY_CV 32 /* foo() called before sub foo was parsed */ |
| 162 |
|
|
/* OP_?ELEM only */ |
| 163 |
|
|
#define OPpLVAL_DEFER 16 /* Defer creation of array/hash elem */ |
| 164 |
|
|
/* OP_RV2?V, OP_GVSV, OP_ENTERITER only */ |
| 165 |
|
|
#define OPpOUR_INTRO 16 /* Variable was in an our() */ |
| 166 |
|
|
/* OP_RV2[AH]V, OP_PAD[AH]V, OP_[AH]ELEM */ |
| 167 |
|
|
#define OPpMAYBE_LVSUB 8 /* We might be an lvalue to return */ |
| 168 |
|
|
/* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */ |
| 169 |
|
|
|
| 170 |
|
|
/* Private for OPs with TARGLEX */ |
| 171 |
|
|
/* (lower bits may carry MAXARG) */ |
| 172 |
|
|
#define OPpTARGET_MY 16 /* Target is PADMY. */ |
| 173 |
|
|
|
| 174 |
|
|
/* Private for OP_ENTERITER and OP_ITER */ |
| 175 |
|
|
#define OPpITER_REVERSED 4 /* for (reverse ...) */ |
| 176 |
|
|
|
| 177 |
|
|
/* Private for OP_CONST */ |
| 178 |
|
|
#define OPpCONST_SHORTCIRCUIT 4 /* eg the constant 5 in (5 || foo) */ |
| 179 |
|
|
#define OPpCONST_STRICT 8 /* bearword subject to strict 'subs' */ |
| 180 |
|
|
#define OPpCONST_ENTERED 16 /* Has been entered as symbol. */ |
| 181 |
|
|
#define OPpCONST_ARYBASE 32 /* Was a $[ translated to constant. */ |
| 182 |
|
|
#define OPpCONST_BARE 64 /* Was a bare word (filehandle?). */ |
| 183 |
|
|
#define OPpCONST_WARNING 128 /* Was a $^W translated to constant. */ |
| 184 |
|
|
|
| 185 |
|
|
/* Private for OP_FLIP/FLOP */ |
| 186 |
|
|
#define OPpFLIP_LINENUM 64 /* Range arg potentially a line num. */ |
| 187 |
|
|
|
| 188 |
|
|
/* Private for OP_LIST */ |
| 189 |
|
|
#define OPpLIST_GUESSED 64 /* Guessed that pushmark was needed. */ |
| 190 |
|
|
|
| 191 |
|
|
/* Private for OP_DELETE */ |
| 192 |
|
|
#define OPpSLICE 64 /* Operating on a list of keys */ |
| 193 |
|
|
|
| 194 |
|
|
/* Private for OP_EXISTS */ |
| 195 |
|
|
#define OPpEXISTS_SUB 64 /* Checking for &sub, not {} or []. */ |
| 196 |
|
|
|
| 197 |
|
|
/* Private for OP_SORT */ |
| 198 |
|
|
#define OPpSORT_NUMERIC 1 /* Optimized away { $a <=> $b } */ |
| 199 |
|
|
#define OPpSORT_INTEGER 2 /* Ditto while under "use integer" */ |
| 200 |
|
|
#define OPpSORT_REVERSE 4 /* Reversed sort */ |
| 201 |
|
|
#define OPpSORT_INPLACE 8 /* sort in-place; eg @a = sort @a */ |
| 202 |
|
|
#define OPpSORT_DESCEND 16 /* Descending sort */ |
| 203 |
|
|
/* Private for OP_THREADSV */ |
| 204 |
|
|
#define OPpDONE_SVREF 64 /* Been through newSVREF once */ |
| 205 |
|
|
|
| 206 |
|
|
/* Private for OP_OPEN and OP_BACKTICK */ |
| 207 |
|
|
#define OPpOPEN_IN_RAW 16 /* binmode(F,":raw") on input fh */ |
| 208 |
|
|
#define OPpOPEN_IN_CRLF 32 /* binmode(F,":crlf") on input fh */ |
| 209 |
|
|
#define OPpOPEN_OUT_RAW 64 /* binmode(F,":raw") on output fh */ |
| 210 |
|
|
#define OPpOPEN_OUT_CRLF 128 /* binmode(F,":crlf") on output fh */ |
| 211 |
|
|
|
| 212 |
|
|
/* Private for OP_EXIT, HUSH also for OP_DIE */ |
| 213 |
|
|
#define OPpHUSH_VMSISH 64 /* hush DCL exit msg vmsish mode*/ |
| 214 |
|
|
#define OPpEXIT_VMSISH 128 /* exit(0) vs. exit(1) vmsish mode*/ |
| 215 |
|
|
|
| 216 |
|
|
/* Private of OP_FTXXX */ |
| 217 |
|
|
#define OPpFT_ACCESS 2 /* use filetest 'access' */ |
| 218 |
|
|
#define OP_IS_FILETEST_ACCESS(op) \ |
| 219 |
|
|
(((op)->op_type) == OP_FTRREAD || \ |
| 220 |
|
|
((op)->op_type) == OP_FTRWRITE || \ |
| 221 |
|
|
((op)->op_type) == OP_FTREXEC || \ |
| 222 |
|
|
((op)->op_type) == OP_FTEREAD || \ |
| 223 |
|
|
((op)->op_type) == OP_FTEWRITE || \ |
| 224 |
|
|
((op)->op_type) == OP_FTEEXEC) |
| 225 |
|
|
|
| 226 |
|
|
struct op { |
| 227 |
|
|
BASEOP |
| 228 |
|
|
}; |
| 229 |
|
|
|
| 230 |
|
|
struct unop { |
| 231 |
|
|
BASEOP |
| 232 |
|
|
OP * op_first; |
| 233 |
|
|
}; |
| 234 |
|
|
|
| 235 |
|
|
struct binop { |
| 236 |
|
|
BASEOP |
| 237 |
|
|
OP * op_first; |
| 238 |
|
|
OP * op_last; |
| 239 |
|
|
}; |
| 240 |
|
|
|
| 241 |
|
|
struct logop { |
| 242 |
|
|
BASEOP |
| 243 |
|
|
OP * op_first; |
| 244 |
|
|
OP * op_other; |
| 245 |
|
|
}; |
| 246 |
|
|
|
| 247 |
|
|
struct listop { |
| 248 |
|
|
BASEOP |
| 249 |
|
|
OP * op_first; |
| 250 |
|
|
OP * op_last; |
| 251 |
|
|
}; |
| 252 |
|
|
|
| 253 |
|
|
struct pmop { |
| 254 |
|
|
BASEOP |
| 255 |
|
|
OP * op_first; |
| 256 |
|
|
OP * op_last; |
| 257 |
|
|
OP * op_pmreplroot; /* (type is really union {OP*,GV*,PADOFFSET}) */ |
| 258 |
|
|
OP * op_pmreplstart; |
| 259 |
|
|
PMOP * op_pmnext; /* list of all scanpats */ |
| 260 |
|
|
#ifdef USE_ITHREADS |
| 261 |
|
|
IV op_pmoffset; |
| 262 |
|
|
#else |
| 263 |
|
|
REGEXP * op_pmregexp; /* compiled expression */ |
| 264 |
|
|
#endif |
| 265 |
|
|
U32 op_pmflags; |
| 266 |
|
|
U32 op_pmpermflags; |
| 267 |
|
|
U8 op_pmdynflags; |
| 268 |
|
|
#ifdef USE_ITHREADS |
| 269 |
|
|
char * op_pmstashpv; |
| 270 |
|
|
#else |
| 271 |
|
|
HV * op_pmstash; |
| 272 |
|
|
#endif |
| 273 |
|
|
}; |
| 274 |
|
|
|
| 275 |
|
|
#ifdef USE_ITHREADS |
| 276 |
|
|
#define PM_GETRE(o) (INT2PTR(REGEXP*,SvIVX(PL_regex_pad[(o)->op_pmoffset]))) |
| 277 |
|
|
#define PM_SETRE(o,r) STMT_START { SV* sv = PL_regex_pad[(o)->op_pmoffset]; sv_setiv(sv, PTR2IV(r)); } STMT_END |
| 278 |
|
|
#define PM_GETRE_SAFE(o) (PL_regex_pad ? PM_GETRE(o) : (REGEXP*)0) |
| 279 |
|
|
#define PM_SETRE_SAFE(o,r) if (PL_regex_pad) PM_SETRE(o,r) |
| 280 |
|
|
#else |
| 281 |
|
|
#define PM_GETRE(o) ((o)->op_pmregexp) |
| 282 |
|
|
#define PM_SETRE(o,r) ((o)->op_pmregexp = (r)) |
| 283 |
|
|
#define PM_GETRE_SAFE PM_GETRE |
| 284 |
|
|
#define PM_SETRE_SAFE PM_SETRE |
| 285 |
|
|
#endif |
| 286 |
|
|
|
| 287 |
|
|
#define PMdf_USED 0x01 /* pm has been used once already */ |
| 288 |
|
|
#define PMdf_TAINTED 0x02 /* pm compiled from tainted pattern */ |
| 289 |
|
|
#define PMdf_UTF8 0x04 /* pm compiled from utf8 data */ |
| 290 |
|
|
#define PMdf_DYN_UTF8 0x08 |
| 291 |
|
|
|
| 292 |
|
|
#define PMdf_CMP_UTF8 (PMdf_UTF8|PMdf_DYN_UTF8) |
| 293 |
|
|
|
| 294 |
|
|
#define PMf_RETAINT 0x0001 /* taint $1 etc. if target tainted */ |
| 295 |
|
|
#define PMf_ONCE 0x0002 /* use pattern only once per reset */ |
| 296 |
|
|
#define PMf_UNUSED 0x0004 /* free for use */ |
| 297 |
|
|
#define PMf_MAYBE_CONST 0x0008 /* replacement contains variables */ |
| 298 |
|
|
#define PMf_SKIPWHITE 0x0010 /* skip leading whitespace for split */ |
| 299 |
|
|
#define PMf_WHITE 0x0020 /* pattern is \s+ */ |
| 300 |
|
|
#define PMf_CONST 0x0040 /* subst replacement is constant */ |
| 301 |
|
|
#define PMf_KEEP 0x0080 /* keep 1st runtime pattern forever */ |
| 302 |
|
|
#define PMf_GLOBAL 0x0100 /* pattern had a g modifier */ |
| 303 |
|
|
#define PMf_CONTINUE 0x0200 /* don't reset pos() if //g fails */ |
| 304 |
|
|
#define PMf_EVAL 0x0400 /* evaluating replacement as expr */ |
| 305 |
|
|
#define PMf_LOCALE 0x0800 /* use locale for character types */ |
| 306 |
|
|
#define PMf_MULTILINE 0x1000 /* assume multiple lines */ |
| 307 |
|
|
#define PMf_SINGLELINE 0x2000 /* assume single line */ |
| 308 |
|
|
#define PMf_FOLD 0x4000 /* case insensitivity */ |
| 309 |
|
|
#define PMf_EXTENDED 0x8000 /* chuck embedded whitespace */ |
| 310 |
|
|
|
| 311 |
|
|
/* mask of bits stored in regexp->reganch */ |
| 312 |
|
|
#define PMf_COMPILETIME (PMf_MULTILINE|PMf_SINGLELINE|PMf_LOCALE|PMf_FOLD|PMf_EXTENDED) |
| 313 |
|
|
|
| 314 |
|
|
#ifdef USE_ITHREADS |
| 315 |
|
|
|
| 316 |
|
|
# define PmopSTASHPV(o) ((o)->op_pmstashpv) |
| 317 |
|
|
# define PmopSTASHPV_set(o,pv) (PmopSTASHPV(o) = savesharedpv(pv)) |
| 318 |
|
|
# define PmopSTASH(o) (PmopSTASHPV(o) \ |
| 319 |
|
|
? gv_stashpv(PmopSTASHPV(o),GV_ADD) : Nullhv) |
| 320 |
|
|
# define PmopSTASH_set(o,hv) PmopSTASHPV_set(o, ((hv) ? HvNAME(hv) : Nullch)) |
| 321 |
|
|
# define PmopSTASH_free(o) PerlMemShared_free(PmopSTASHPV(o)) |
| 322 |
|
|
|
| 323 |
|
|
#else |
| 324 |
|
|
# define PmopSTASH(o) ((o)->op_pmstash) |
| 325 |
|
|
# define PmopSTASH_set(o,hv) ((o)->op_pmstash = (hv)) |
| 326 |
|
|
# define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME(PmopSTASH(o)) : Nullch) |
| 327 |
|
|
/* op_pmstash is not refcounted */ |
| 328 |
|
|
# define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD)) |
| 329 |
|
|
# define PmopSTASH_free(o) |
| 330 |
|
|
#endif |
| 331 |
|
|
|
| 332 |
|
|
struct svop { |
| 333 |
|
|
BASEOP |
| 334 |
|
|
SV * op_sv; |
| 335 |
|
|
}; |
| 336 |
|
|
|
| 337 |
|
|
struct padop { |
| 338 |
|
|
BASEOP |
| 339 |
|
|
PADOFFSET op_padix; |
| 340 |
|
|
}; |
| 341 |
|
|
|
| 342 |
|
|
struct pvop { |
| 343 |
|
|
BASEOP |
| 344 |
|
|
char * op_pv; |
| 345 |
|
|
}; |
| 346 |
|
|
|
| 347 |
|
|
struct loop { |
| 348 |
|
|
BASEOP |
| 349 |
|
|
OP * op_first; |
| 350 |
|
|
OP * op_last; |
| 351 |
|
|
OP * op_redoop; |
| 352 |
|
|
OP * op_nextop; |
| 353 |
|
|
OP * op_lastop; |
| 354 |
|
|
}; |
| 355 |
|
|
|
| 356 |
|
|
#define cUNOPx(o) ((UNOP*)o) |
| 357 |
|
|
#define cBINOPx(o) ((BINOP*)o) |
| 358 |
|
|
#define cLISTOPx(o) ((LISTOP*)o) |
| 359 |
|
|
#define cLOGOPx(o) ((LOGOP*)o) |
| 360 |
|
|
#define cPMOPx(o) ((PMOP*)o) |
| 361 |
|
|
#define cSVOPx(o) ((SVOP*)o) |
| 362 |
|
|
#define cPADOPx(o) ((PADOP*)o) |
| 363 |
|
|
#define cPVOPx(o) ((PVOP*)o) |
| 364 |
|
|
#define cCOPx(o) ((COP*)o) |
| 365 |
|
|
#define cLOOPx(o) ((LOOP*)o) |
| 366 |
|
|
|
| 367 |
|
|
#define cUNOP cUNOPx(PL_op) |
| 368 |
|
|
#define cBINOP cBINOPx(PL_op) |
| 369 |
|
|
#define cLISTOP cLISTOPx(PL_op) |
| 370 |
|
|
#define cLOGOP cLOGOPx(PL_op) |
| 371 |
|
|
#define cPMOP cPMOPx(PL_op) |
| 372 |
|
|
#define cSVOP cSVOPx(PL_op) |
| 373 |
|
|
#define cPADOP cPADOPx(PL_op) |
| 374 |
|
|
#define cPVOP cPVOPx(PL_op) |
| 375 |
|
|
#define cCOP cCOPx(PL_op) |
| 376 |
|
|
#define cLOOP cLOOPx(PL_op) |
| 377 |
|
|
|
| 378 |
|
|
#define cUNOPo cUNOPx(o) |
| 379 |
|
|
#define cBINOPo cBINOPx(o) |
| 380 |
|
|
#define cLISTOPo cLISTOPx(o) |
| 381 |
|
|
#define cLOGOPo cLOGOPx(o) |
| 382 |
|
|
#define cPMOPo cPMOPx(o) |
| 383 |
|
|
#define cSVOPo cSVOPx(o) |
| 384 |
|
|
#define cPADOPo cPADOPx(o) |
| 385 |
|
|
#define cPVOPo cPVOPx(o) |
| 386 |
|
|
#define cCOPo cCOPx(o) |
| 387 |
|
|
#define cLOOPo cLOOPx(o) |
| 388 |
|
|
|
| 389 |
|
|
#define kUNOP cUNOPx(kid) |
| 390 |
|
|
#define kBINOP cBINOPx(kid) |
| 391 |
|
|
#define kLISTOP cLISTOPx(kid) |
| 392 |
|
|
#define kLOGOP cLOGOPx(kid) |
| 393 |
|
|
#define kPMOP cPMOPx(kid) |
| 394 |
|
|
#define kSVOP cSVOPx(kid) |
| 395 |
|
|
#define kPADOP cPADOPx(kid) |
| 396 |
|
|
#define kPVOP cPVOPx(kid) |
| 397 |
|
|
#define kCOP cCOPx(kid) |
| 398 |
|
|
#define kLOOP cLOOPx(kid) |
| 399 |
|
|
|
| 400 |
|
|
|
| 401 |
|
|
#ifdef USE_ITHREADS |
| 402 |
|
|
# define cGVOPx_gv(o) ((GV*)PAD_SVl(cPADOPx(o)->op_padix)) |
| 403 |
|
|
# define IS_PADGV(v) (v && SvTYPE(v) == SVt_PVGV && GvIN_PAD(v)) |
| 404 |
|
|
# define IS_PADCONST(v) (v && SvREADONLY(v)) |
| 405 |
|
|
# define cSVOPx_sv(v) (cSVOPx(v)->op_sv \ |
| 406 |
|
|
? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ)) |
| 407 |
|
|
# define cSVOPx_svp(v) (cSVOPx(v)->op_sv \ |
| 408 |
|
|
? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ)) |
| 409 |
|
|
#else |
| 410 |
|
|
# define cGVOPx_gv(o) ((GV*)cSVOPx(o)->op_sv) |
| 411 |
|
|
# define IS_PADGV(v) FALSE |
| 412 |
|
|
# define IS_PADCONST(v) FALSE |
| 413 |
|
|
# define cSVOPx_sv(v) (cSVOPx(v)->op_sv) |
| 414 |
|
|
# define cSVOPx_svp(v) (&cSVOPx(v)->op_sv) |
| 415 |
|
|
#endif |
| 416 |
|
|
|
| 417 |
|
|
#define cGVOP_gv cGVOPx_gv(PL_op) |
| 418 |
|
|
#define cGVOPo_gv cGVOPx_gv(o) |
| 419 |
|
|
#define kGVOP_gv cGVOPx_gv(kid) |
| 420 |
|
|
#define cSVOP_sv cSVOPx_sv(PL_op) |
| 421 |
|
|
#define cSVOPo_sv cSVOPx_sv(o) |
| 422 |
|
|
#define kSVOP_sv cSVOPx_sv(kid) |
| 423 |
|
|
|
| 424 |
|
|
#define Nullop Null(OP*) |
| 425 |
|
|
|
| 426 |
|
|
/* Lowest byte-and-a-bit of PL_opargs */ |
| 427 |
|
|
#define OA_MARK 1 |
| 428 |
|
|
#define OA_FOLDCONST 2 |
| 429 |
|
|
#define OA_RETSCALAR 4 |
| 430 |
|
|
#define OA_TARGET 8 |
| 431 |
|
|
#define OA_RETINTEGER 16 |
| 432 |
|
|
#define OA_OTHERINT 32 |
| 433 |
|
|
#define OA_DANGEROUS 64 |
| 434 |
|
|
#define OA_DEFGV 128 |
| 435 |
|
|
#define OA_TARGLEX 256 |
| 436 |
|
|
|
| 437 |
|
|
/* The next 4 bits encode op class information */ |
| 438 |
|
|
#define OCSHIFT 9 |
| 439 |
|
|
|
| 440 |
|
|
#define OA_CLASS_MASK (15 << OCSHIFT) |
| 441 |
|
|
|
| 442 |
|
|
#define OA_BASEOP (0 << OCSHIFT) |
| 443 |
|
|
#define OA_UNOP (1 << OCSHIFT) |
| 444 |
|
|
#define OA_BINOP (2 << OCSHIFT) |
| 445 |
|
|
#define OA_LOGOP (3 << OCSHIFT) |
| 446 |
|
|
#define OA_LISTOP (4 << OCSHIFT) |
| 447 |
|
|
#define OA_PMOP (5 << OCSHIFT) |
| 448 |
|
|
#define OA_SVOP (6 << OCSHIFT) |
| 449 |
|
|
#define OA_PADOP (7 << OCSHIFT) |
| 450 |
|
|
#define OA_PVOP_OR_SVOP (8 << OCSHIFT) |
| 451 |
|
|
#define OA_LOOP (9 << OCSHIFT) |
| 452 |
|
|
#define OA_COP (10 << OCSHIFT) |
| 453 |
|
|
#define OA_BASEOP_OR_UNOP (11 << OCSHIFT) |
| 454 |
|
|
#define OA_FILESTATOP (12 << OCSHIFT) |
| 455 |
|
|
#define OA_LOOPEXOP (13 << OCSHIFT) |
| 456 |
|
|
|
| 457 |
|
|
#define OASHIFT 13 |
| 458 |
|
|
|
| 459 |
|
|
/* Remaining nybbles of PL_opargs */ |
| 460 |
|
|
#define OA_SCALAR 1 |
| 461 |
|
|
#define OA_LIST 2 |
| 462 |
|
|
#define OA_AVREF 3 |
| 463 |
|
|
#define OA_HVREF 4 |
| 464 |
|
|
#define OA_CVREF 5 |
| 465 |
|
|
#define OA_FILEREF 6 |
| 466 |
|
|
#define OA_SCALARREF 7 |
| 467 |
|
|
#define OA_OPTIONAL 8 |
| 468 |
|
|
|
| 469 |
|
|
#ifdef USE_ITHREADS |
| 470 |
|
|
# define OP_REFCNT_INIT MUTEX_INIT(&PL_op_mutex) |
| 471 |
|
|
# ifdef PERL_CORE |
| 472 |
|
|
# define OP_REFCNT_LOCK MUTEX_LOCK(&PL_op_mutex) |
| 473 |
|
|
# define OP_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_op_mutex) |
| 474 |
|
|
# else |
| 475 |
|
|
# define OP_REFCNT_LOCK op_refcnt_lock() |
| 476 |
|
|
# define OP_REFCNT_UNLOCK op_refcnt_unlock() |
| 477 |
|
|
# endif |
| 478 |
|
|
# define OP_REFCNT_TERM MUTEX_DESTROY(&PL_op_mutex) |
| 479 |
|
|
#else |
| 480 |
|
|
# define OP_REFCNT_INIT NOOP |
| 481 |
|
|
# define OP_REFCNT_LOCK NOOP |
| 482 |
|
|
# define OP_REFCNT_UNLOCK NOOP |
| 483 |
|
|
# define OP_REFCNT_TERM NOOP |
| 484 |
|
|
#endif |
| 485 |
|
|
|
| 486 |
|
|
#define OpREFCNT_set(o,n) ((o)->op_targ = (n)) |
| 487 |
|
|
#define OpREFCNT_inc(o) ((o) ? (++(o)->op_targ, (o)) : Nullop) |
| 488 |
|
|
#define OpREFCNT_dec(o) (--(o)->op_targ) |
| 489 |
|
|
|
| 490 |
|
|
/* flags used by Perl_load_module() */ |
| 491 |
|
|
#define PERL_LOADMOD_DENY 0x1 |
| 492 |
|
|
#define PERL_LOADMOD_NOIMPORT 0x2 |
| 493 |
|
|
#define PERL_LOADMOD_IMPORT_OPS 0x4 |
| 494 |
|
|
|
| 495 |
|
|
#ifdef USE_REENTRANT_API |
| 496 |
|
|
#include "reentr.h" |
| 497 |
|
|
#endif |
| 498 |
|
|
|
| 499 |
|
|
#if defined(PL_OP_SLAB_ALLOC) |
| 500 |
|
|
#define NewOp(m,var,c,type) \ |
| 501 |
|
|
(var = (type *) Perl_Slab_Alloc(aTHX_ m,c*sizeof(type))) |
| 502 |
|
|
#define NewOpSz(m,var,size) \ |
| 503 |
|
|
(var = (OP *) Perl_Slab_Alloc(aTHX_ m,size)) |
| 504 |
|
|
#define FreeOp(p) Perl_Slab_Free(aTHX_ p) |
| 505 |
|
|
#else |
| 506 |
|
|
#define NewOp(m, var, c, type) Newz(m, var, c, type) |
| 507 |
|
|
#define NewOpSz(m, var, size) \ |
| 508 |
|
|
(var = (OP*)safemalloc(size), memzero(var, size)) |
| 509 |
|
|
#define FreeOp(p) Safefree(p) |
| 510 |
|
|
#endif |
