1 /* op.h 2 * 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 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_opt Whether or not the op has been optimised by the 21 * peephole optimiser. 22 * op_slabbed allocated via opslab 23 * op_static tell op_free() to skip PerlMemShared_free(), when 24 * !op_slabbed. 25 * op_savefree on savestack via SAVEFREEOP 26 * op_folded Result/remainder of a constant fold operation. 27 * op_spare Two spare bits 28 * op_flags Flags common to all operations. See OPf_* below. 29 * op_private Flags peculiar to a particular operation (BUT, 30 * by default, set to the number of children until 31 * the operation is privatized by a check routine, 32 * which may or may not check number of children). 33 */ 34 #include "op_reg_common.h" 35 36 #define OPCODE U16 37 38 #ifdef PERL_MAD 39 # define MADPROP_IN_BASEOP MADPROP* op_madprop; 40 #else 41 # define MADPROP_IN_BASEOP 42 #endif 43 44 typedef PERL_BITFIELD16 Optype; 45 46 #ifdef BASEOP_DEFINITION 47 #define BASEOP BASEOP_DEFINITION 48 #else 49 #define BASEOP \ 50 OP* op_next; \ 51 OP* op_sibling; \ 52 OP* (*op_ppaddr)(pTHX); \ 53 MADPROP_IN_BASEOP \ 54 PADOFFSET op_targ; \ 55 PERL_BITFIELD16 op_type:9; \ 56 PERL_BITFIELD16 op_opt:1; \ 57 PERL_BITFIELD16 op_slabbed:1; \ 58 PERL_BITFIELD16 op_savefree:1; \ 59 PERL_BITFIELD16 op_static:1; \ 60 PERL_BITFIELD16 op_folded:1; \ 61 PERL_BITFIELD16 op_spare:2; \ 62 U8 op_flags; \ 63 U8 op_private; 64 #endif 65 66 /* If op_type:9 is changed to :10, also change PUSHEVAL in cop.h. 67 Also, if the type of op_type is ever changed (e.g. to PERL_BITFIELD32) 68 then all the other bit-fields before/after it should change their 69 types too to let VC pack them into the same 4 byte integer.*/ 70 71 /* for efficiency, requires OPf_WANT_VOID == G_VOID etc */ 72 #define OP_GIMME(op,dfl) \ 73 (((op)->op_flags & OPf_WANT) ? ((op)->op_flags & OPf_WANT) : dfl) 74 75 #define OP_GIMME_REVERSE(flags) ((flags) & G_WANT) 76 77 /* 78 =head1 "Gimme" Values 79 80 =for apidoc Amn|U32|GIMME_V 81 The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>, 82 C<G_SCALAR> or C<G_ARRAY> for void, scalar or list context, 83 respectively. See L<perlcall> for a usage example. 84 85 =for apidoc Amn|U32|GIMME 86 A backward-compatible version of C<GIMME_V> which can only return 87 C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>. 88 Deprecated. Use C<GIMME_V> instead. 89 90 =cut 91 */ 92 93 #define GIMME_V OP_GIMME(PL_op, block_gimme()) 94 95 /* Public flags */ 96 97 #define OPf_WANT 3 /* Mask for "want" bits: */ 98 #define OPf_WANT_VOID 1 /* Want nothing */ 99 #define OPf_WANT_SCALAR 2 /* Want single value */ 100 #define OPf_WANT_LIST 3 /* Want list of any length */ 101 #define OPf_KIDS 4 /* There is a firstborn child. */ 102 #define OPf_PARENS 8 /* This operator was parenthesized. */ 103 /* (Or block needs explicit scope entry.) */ 104 #define OPf_REF 16 /* Certified reference. */ 105 /* (Return container, not containee). */ 106 #define OPf_MOD 32 /* Will modify (lvalue). */ 107 #define OPf_STACKED 64 /* Some arg is arriving on the stack. */ 108 #define OPf_SPECIAL 128 /* Do something weird for this op: */ 109 /* On local LVAL, don't init local value. */ 110 /* On OP_SORT, subroutine is inlined. */ 111 /* On OP_NOT, inversion was implicit. */ 112 /* On OP_LEAVE, don't restore curpm. */ 113 /* On truncate, we truncate filehandle */ 114 /* On control verbs, we saw no label */ 115 /* On flipflop, we saw ... instead of .. */ 116 /* On UNOPs, saw bare parens, e.g. eof(). */ 117 /* On OP_ENTERSUB || OP_NULL, saw a "do". */ 118 /* On OP_EXISTS, treat av as av, not avhv. */ 119 /* On OP_(ENTER|LEAVE)EVAL, don't clear $@ */ 120 /* On pushre, rx is used as part of split, e.g. split " " */ 121 /* On regcomp, "use re 'eval'" was in scope */ 122 /* On OP_READLINE, was <$filehandle> */ 123 /* On RV2[ACGHS]V, don't create GV--in 124 defined()*/ 125 /* On OP_DBSTATE, indicates breakpoint 126 * (runtime property) */ 127 /* On OP_REQUIRE, was seen as CORE::require */ 128 /* On OP_(ENTER|LEAVE)WHEN, there's 129 no condition */ 130 /* On OP_SMARTMATCH, an implicit smartmatch */ 131 /* On OP_ANONHASH and OP_ANONLIST, create a 132 reference to the new anon hash or array */ 133 /* On OP_HELEM and OP_HSLICE, localization will be followed 134 by assignment, so do not wipe the target if it is special 135 (e.g. a glob or a magic SV) */ 136 /* On OP_MATCH, OP_SUBST & OP_TRANS, the 137 operand of a logical or conditional 138 that was optimised away, so it should 139 not be bound via =~ */ 140 /* On OP_CONST, from a constant CV */ 141 /* On OP_GLOB, two meanings: 142 - Before ck_glob, called as CORE::glob 143 - After ck_glob, use Perl glob function 144 */ 145 /* On OP_PADRANGE, push @_ */ 146 /* On OP_DUMP, has no label */ 147 148 /* old names; don't use in new code, but don't break them, either */ 149 #define OPf_LIST OPf_WANT_LIST 150 #define OPf_KNOW OPf_WANT 151 152 #define GIMME \ 153 (PL_op->op_flags & OPf_WANT \ 154 ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST \ 155 ? G_ARRAY \ 156 : G_SCALAR) \ 157 : dowantarray()) 158 159 /* Lower bits of op_private often carry the number of arguments, as 160 * set by newBINOP, newUNOP and ck_fun */ 161 162 /* NOTE: OP_NEXTSTATE and OP_DBSTATE (i.e. COPs) carry NATIVE_HINTS 163 * in op_private */ 164 165 /* Private for lvalues */ 166 #define OPpLVAL_INTRO 128 /* Lvalue must be localized or lvalue sub */ 167 168 /* Private for OPs with TARGLEX */ 169 /* (lower bits may carry MAXARG) */ 170 #define OPpTARGET_MY 16 /* Target is PADMY. */ 171 172 /* Private for OP_LEAVE, OP_LEAVESUB, OP_LEAVESUBLV and OP_LEAVEWRITE */ 173 #define OPpREFCOUNTED 64 /* op_targ carries a refcount */ 174 175 /* Private for OP_LEAVE and OP_LEAVELOOP */ 176 #define OPpLVALUE 128 /* Do not copy return value */ 177 178 /* Private for OP_AASSIGN */ 179 #define OPpASSIGN_COMMON 64 /* Left & right have syms in common. */ 180 181 /* Private for OP_SASSIGN */ 182 #define OPpASSIGN_BACKWARDS 64 /* Left & right switched. */ 183 #define OPpASSIGN_CV_TO_GV 128 /* Possible optimisation for constants. */ 184 185 /* Private for OP_MATCH and OP_SUBST{,CONT} */ 186 #define OPpRUNTIME 64 /* Pattern coming in on the stack */ 187 188 /* Private for OP_TRANS */ 189 #define OPpTRANS_FROM_UTF 1 190 #define OPpTRANS_TO_UTF 2 191 #define OPpTRANS_IDENTICAL 4 /* right side is same as left */ 192 #define OPpTRANS_SQUASH 8 193 /* 16 is used for OPpTARGET_MY */ 194 #define OPpTRANS_COMPLEMENT 32 195 #define OPpTRANS_GROWS 64 196 #define OPpTRANS_DELETE 128 197 #define OPpTRANS_ALL (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE) 198 199 /* Private for OP_REPEAT */ 200 #define OPpREPEAT_DOLIST 64 /* List replication. */ 201 202 /* Private for OP_RV2GV, OP_RV2SV, OP_AELEM, OP_HELEM, OP_PADSV */ 203 #define OPpDEREF (32|64) /* autovivify: Want ref to something: */ 204 #define OPpDEREF_AV 32 /* Want ref to AV. */ 205 #define OPpDEREF_HV 64 /* Want ref to HV. */ 206 #define OPpDEREF_SV (32|64) /* Want ref to SV. */ 207 208 /* OP_ENTERSUB and OP_RV2CV flags 209 210 Flags are set on entersub and rv2cv in three phases: 211 parser - the parser passes the flag to the op constructor 212 check - the check routine called by the op constructor sets the flag 213 context - application of scalar/ref/lvalue context applies the flag 214 215 In the third stage, an entersub op might turn into an rv2cv op (undef &foo, 216 \&foo, lock &foo, exists &foo, defined &foo). The two places where that 217 happens (op_lvalue_flags and doref in op.c) need to make sure the flags do 218 not conflict. Flags applied in the context phase are only set when there 219 is no conversion of op type. 220 221 bit entersub flag phase rv2cv flag phase 222 --- ------------- ----- ---------- ----- 223 1 OPpENTERSUB_INARGS context OPpMAY_RETURN_CONSTANT context 224 2 HINT_STRICT_REFS check HINT_STRICT_REFS check 225 4 OPpENTERSUB_HASTARG check 226 8 OPpENTERSUB_AMPER parser 227 16 OPpENTERSUB_DB check 228 32 OPpDEREF_AV context 229 64 OPpDEREF_HV context 230 128 OPpLVAL_INTRO context OPpENTERSUB_NOPAREN parser 231 232 */ 233 234 /* OP_ENTERSUB only */ 235 #define OPpENTERSUB_DB 16 /* Debug subroutine. */ 236 #define OPpENTERSUB_HASTARG 4 /* Called from OP tree. */ 237 #define OPpENTERSUB_INARGS 1 /* Lval used as arg to a sub. */ 238 /* used by OPpDEREF (32|64) */ 239 /* used by HINT_STRICT_REFS 2 */ 240 /* Mask for OP_ENTERSUB flags, the absence of which must be propagated 241 in dynamic context */ 242 #define OPpENTERSUB_LVAL_MASK (OPpLVAL_INTRO|OPpENTERSUB_INARGS) 243 244 /* OP_RV2CV only */ 245 #define OPpENTERSUB_AMPER 8 /* Used & form to call. */ 246 #define OPpENTERSUB_NOPAREN 128 /* bare sub call (without parens) */ 247 #define OPpMAY_RETURN_CONSTANT 1 /* If a constant sub, return the constant */ 248 249 /* OP_GV only */ 250 #define OPpEARLY_CV 32 /* foo() called before sub foo was parsed */ 251 /* OP_?ELEM only */ 252 #define OPpLVAL_DEFER 16 /* Defer creation of array/hash elem */ 253 /* OP_RV2[AH]V OP_[AH]SLICE */ 254 #define OPpSLICEWARNING 4 /* warn about @hash{$scalar} */ 255 /* OP_RV2[SAH]V, OP_GVSV, OP_ENTERITER only */ 256 #define OPpOUR_INTRO 16 /* Variable was in an our() */ 257 /* OP_RV2[AGH]V, OP_PAD[AH]V, OP_[AH]ELEM, OP_[AH]SLICE OP_AV2ARYLEN, 258 OP_R?KEYS, OP_SUBSTR, OP_POS, OP_VEC */ 259 #define OPpMAYBE_LVSUB 8 /* We might be an lvalue to return */ 260 /* OP_RV2HV and OP_PADHV */ 261 #define OPpTRUEBOOL 32 /* %hash in (%hash || $foo) in 262 void context */ 263 #define OPpMAYBE_TRUEBOOL 64 /* %hash in (%hash || $foo) where 264 cx is not known till run time */ 265 266 /* OP_SUBSTR only */ 267 #define OPpSUBSTR_REPL_FIRST 16 /* 1st arg is replacement string */ 268 269 /* OP_PADSV only */ 270 #define OPpPAD_STATE 16 /* is a "state" pad */ 271 /* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */ 272 273 /* OP_PADRANGE only */ 274 /* bit 7 is OPpLVAL_INTRO */ 275 #define OPpPADRANGE_COUNTMASK 127 /* bits 6..0 hold target range, */ 276 #define OPpPADRANGE_COUNTSHIFT 7 /* 7 bits in total */ 277 278 /* OP_RV2GV only */ 279 #define OPpDONT_INIT_GV 4 /* Call gv_fetchpv with GV_NOINIT */ 280 /* (Therefore will return whatever is currently in the symbol table, not 281 guaranteed to be a PVGV) */ 282 #define OPpALLOW_FAKE 16 /* OK to return fake glob */ 283 284 /* Private for OP_ENTERITER and OP_ITER */ 285 #define OPpITER_REVERSED 4 /* for (reverse ...) */ 286 #define OPpITER_DEF 8 /* for $_ or for my $_ */ 287 288 /* Private for OP_CONST */ 289 #define OPpCONST_NOVER 2 /* no 6; */ 290 #define OPpCONST_SHORTCIRCUIT 4 /* eg the constant 5 in (5 || foo) */ 291 #define OPpCONST_STRICT 8 /* bareword subject to strict 'subs' */ 292 #define OPpCONST_ENTERED 16 /* Has been entered as symbol. */ 293 #define OPpCONST_BARE 64 /* Was a bare word (filehandle?). */ 294 295 /* Private for OP_FLIP/FLOP */ 296 #define OPpFLIP_LINENUM 64 /* Range arg potentially a line num. */ 297 298 /* Private for OP_LIST */ 299 #define OPpLIST_GUESSED 64 /* Guessed that pushmark was needed. */ 300 301 /* Private for OP_DELETE */ 302 #define OPpSLICE 64 /* Operating on a list of keys */ 303 /* Also OPpLVAL_INTRO (128) */ 304 305 /* Private for OP_EXISTS */ 306 #define OPpEXISTS_SUB 64 /* Checking for &sub, not {} or []. */ 307 308 /* Private for OP_SORT */ 309 #define OPpSORT_NUMERIC 1 /* Optimized away { $a <=> $b } */ 310 #define OPpSORT_INTEGER 2 /* Ditto while under "use integer" */ 311 #define OPpSORT_REVERSE 4 /* Reversed sort */ 312 #define OPpSORT_INPLACE 8 /* sort in-place; eg @a = sort @a */ 313 #define OPpSORT_DESCEND 16 /* Descending sort */ 314 #define OPpSORT_QSORT 32 /* Use quicksort (not mergesort) */ 315 #define OPpSORT_STABLE 64 /* Use a stable algorithm */ 316 317 /* Private for OP_REVERSE */ 318 #define OPpREVERSE_INPLACE 8 /* reverse in-place (@a = reverse @a) */ 319 320 /* Private for OP_OPEN and OP_BACKTICK */ 321 #define OPpOPEN_IN_RAW 16 /* binmode(F,":raw") on input fh */ 322 #define OPpOPEN_IN_CRLF 32 /* binmode(F,":crlf") on input fh */ 323 #define OPpOPEN_OUT_RAW 64 /* binmode(F,":raw") on output fh */ 324 #define OPpOPEN_OUT_CRLF 128 /* binmode(F,":crlf") on output fh */ 325 326 /* Private for COPs */ 327 #define OPpHUSH_VMSISH 32 /* hush DCL exit msg vmsish mode*/ 328 /* Note: Used for NATIVE_HINTS (shifted from the values in PL_hints), 329 currently defined by vms/vmsish.h: 330 64 331 128 332 */ 333 334 /* Private for OP_FTXXX */ 335 #define OPpFT_ACCESS 2 /* use filetest 'access' */ 336 #define OPpFT_STACKED 4 /* stacked filetest, as "-f" in "-f -x $f" */ 337 #define OPpFT_STACKING 8 /* stacking filetest, as "-x" in "-f -x $f" */ 338 #define OPpFT_AFTER_t 16 /* previous op was -t */ 339 340 /* Private for OP_(MAP|GREP)(WHILE|START) */ 341 #define OPpGREP_LEX 2 /* iterate over lexical $_ */ 342 343 /* Private for OP_ENTEREVAL */ 344 #define OPpEVAL_HAS_HH 2 /* Does it have a copy of %^H */ 345 #define OPpEVAL_UNICODE 4 346 #define OPpEVAL_BYTES 8 347 #define OPpEVAL_COPHH 16 /* Construct %^H from cop hints */ 348 #define OPpEVAL_RE_REPARSING 32 /* eval_sv(..., G_RE_REPARSING) */ 349 350 /* Private for OP_CALLER, OP_WANTARRAY and OP_RUNCV */ 351 #define OPpOFFBYONE 128 /* Treat caller(1) as caller(2) */ 352 353 /* Private for OP_COREARGS */ 354 /* These must not conflict with OPpDONT_INIT_GV or OPpALLOW_FAKE. 355 See pp.c:S_rv2gv. */ 356 #define OPpCOREARGS_DEREF1 1 /* Arg 1 is a handle constructor */ 357 #define OPpCOREARGS_DEREF2 2 /* Arg 2 is a handle constructor */ 358 #define OPpCOREARGS_SCALARMOD 64 /* \$ rather than \[$@%*] */ 359 #define OPpCOREARGS_PUSHMARK 128 /* Call pp_pushmark */ 360 361 /* Private for OP_(LAST|REDO|NEXT|GOTO|DUMP) */ 362 #define OPpPV_IS_UTF8 128 /* label is in UTF8 */ 363 364 /* Private for OP_SPLIT */ 365 #define OPpSPLIT_IMPLIM 128 /* implicit limit */ 366 367 struct op { 368 BASEOP 369 }; 370 371 struct unop { 372 BASEOP 373 OP * op_first; 374 }; 375 376 struct binop { 377 BASEOP 378 OP * op_first; 379 OP * op_last; 380 }; 381 382 struct logop { 383 BASEOP 384 OP * op_first; 385 OP * op_other; 386 }; 387 388 struct listop { 389 BASEOP 390 OP * op_first; 391 OP * op_last; 392 }; 393 394 struct pmop { 395 BASEOP 396 OP * op_first; 397 OP * op_last; 398 #ifdef USE_ITHREADS 399 PADOFFSET op_pmoffset; 400 #else 401 REGEXP * op_pmregexp; /* compiled expression */ 402 #endif 403 U32 op_pmflags; 404 union { 405 OP * op_pmreplroot; /* For OP_SUBST */ 406 #ifdef USE_ITHREADS 407 PADOFFSET op_pmtargetoff; /* For OP_PUSHRE */ 408 #else 409 GV * op_pmtargetgv; 410 #endif 411 } op_pmreplrootu; 412 union { 413 OP * op_pmreplstart; /* Only used in OP_SUBST */ 414 #ifdef USE_ITHREADS 415 PADOFFSET op_pmstashoff; /* Only used in OP_MATCH, with PMf_ONCE set */ 416 #else 417 HV * op_pmstash; 418 #endif 419 } op_pmstashstartu; 420 OP * op_code_list; /* list of (?{}) code blocks */ 421 }; 422 423 #ifdef USE_ITHREADS 424 #define PM_GETRE(o) (SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \ 425 ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL) 426 /* The assignment is just to enforce type safety (or at least get a warning). 427 */ 428 /* With first class regexps not via a reference one needs to assign 429 &PL_sv_undef under ithreads. (This would probably work unthreaded, but NULL 430 is cheaper. I guess we could allow NULL, but the check above would get 431 more complex, and we'd have an AV with (SV*)NULL in it, which feels bad */ 432 /* BEWARE - something that calls this macro passes (r) which has a side 433 effect. */ 434 #define PM_SETRE(o,r) STMT_START { \ 435 REGEXP *const _pm_setre = (r); \ 436 assert(_pm_setre); \ 437 PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \ 438 } STMT_END 439 #else 440 #define PM_GETRE(o) ((o)->op_pmregexp) 441 #define PM_SETRE(o,r) ((o)->op_pmregexp = (r)) 442 #endif 443 444 /* Leave some space, so future bit allocations can go either in the shared or 445 * unshared area without affecting binary compatibility */ 446 #define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+6) 447 448 /* 'use re "taint"' in scope: taint $1 etc. if target tainted */ 449 #define PMf_RETAINT (1<<(PMf_BASE_SHIFT+0)) 450 451 /* match successfully only once per reset, with related flag RXf_USED in 452 * re->extflags holding state. This is used only for ?? matches, and only on 453 * OP_MATCH and OP_QR */ 454 #define PMf_ONCE (1<<(PMf_BASE_SHIFT+1)) 455 456 /* PMf_ONCE, i.e. ?pat?, has matched successfully. Not used under threading. */ 457 #define PMf_USED (1<<(PMf_BASE_SHIFT+3)) 458 459 /* subst replacement is constant */ 460 #define PMf_CONST (1<<(PMf_BASE_SHIFT+4)) 461 462 /* keep 1st runtime pattern forever */ 463 #define PMf_KEEP (1<<(PMf_BASE_SHIFT+5)) 464 465 #define PMf_GLOBAL (1<<(PMf_BASE_SHIFT+6)) /* pattern had a g modifier */ 466 467 /* don't reset pos() if //g fails */ 468 #define PMf_CONTINUE (1<<(PMf_BASE_SHIFT+7)) 469 470 /* evaluating replacement as expr */ 471 #define PMf_EVAL (1<<(PMf_BASE_SHIFT+8)) 472 473 /* Return substituted string instead of modifying it. */ 474 #define PMf_NONDESTRUCT (1<<(PMf_BASE_SHIFT+9)) 475 476 /* the pattern has a CV attached (currently only under qr/...(?{}).../) */ 477 #define PMf_HAS_CV (1<<(PMf_BASE_SHIFT+10)) 478 479 /* op_code_list is private; don't free it etc. It may well point to 480 * code within another sub, with different pad etc */ 481 #define PMf_CODELIST_PRIVATE (1<<(PMf_BASE_SHIFT+11)) 482 483 /* the PMOP is a QR (we should be able to detect that from the op type, 484 * but the regex compilation API passes just the pm flags, not the op 485 * itself */ 486 #define PMf_IS_QR (1<<(PMf_BASE_SHIFT+12)) 487 #define PMf_USE_RE_EVAL (1<<(PMf_BASE_SHIFT+13)) /* use re'eval' in scope */ 488 489 #if PMf_BASE_SHIFT+13 > 31 490 # error Too many PMf_ bits used. See above and regnodes.h for any spare in middle 491 #endif 492 493 #ifdef USE_ITHREADS 494 495 # define PmopSTASH(o) ((o)->op_pmflags & PMf_ONCE \ 496 ? PL_stashpad[(o)->op_pmstashstartu.op_pmstashoff] \ 497 : NULL) 498 # define PmopSTASH_set(o,hv) \ 499 (assert_((o)->op_pmflags & PMf_ONCE) \ 500 (o)->op_pmstashstartu.op_pmstashoff = \ 501 (hv) ? alloccopstash(hv) : 0) 502 #else 503 # define PmopSTASH(o) \ 504 (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL) 505 # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 506 # define PmopSTASH_set(o,hv) ({ \ 507 assert((o)->op_pmflags & PMf_ONCE); \ 508 ((o)->op_pmstashstartu.op_pmstash = (hv)); \ 509 }) 510 # else 511 # define PmopSTASH_set(o,hv) ((o)->op_pmstashstartu.op_pmstash = (hv)) 512 # endif 513 #endif 514 #define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL) 515 /* op_pmstashstartu.op_pmstash is not refcounted */ 516 #define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD)) 517 518 struct svop { 519 BASEOP 520 SV * op_sv; 521 }; 522 523 struct padop { 524 BASEOP 525 PADOFFSET op_padix; 526 }; 527 528 struct pvop { 529 BASEOP 530 char * op_pv; 531 }; 532 533 struct loop { 534 BASEOP 535 OP * op_first; 536 OP * op_last; 537 OP * op_redoop; 538 OP * op_nextop; 539 OP * op_lastop; 540 }; 541 542 #define cUNOPx(o) ((UNOP*)o) 543 #define cBINOPx(o) ((BINOP*)o) 544 #define cLISTOPx(o) ((LISTOP*)o) 545 #define cLOGOPx(o) ((LOGOP*)o) 546 #define cPMOPx(o) ((PMOP*)o) 547 #define cSVOPx(o) ((SVOP*)o) 548 #define cPADOPx(o) ((PADOP*)o) 549 #define cPVOPx(o) ((PVOP*)o) 550 #define cCOPx(o) ((COP*)o) 551 #define cLOOPx(o) ((LOOP*)o) 552 553 #define cUNOP cUNOPx(PL_op) 554 #define cBINOP cBINOPx(PL_op) 555 #define cLISTOP cLISTOPx(PL_op) 556 #define cLOGOP cLOGOPx(PL_op) 557 #define cPMOP cPMOPx(PL_op) 558 #define cSVOP cSVOPx(PL_op) 559 #define cPADOP cPADOPx(PL_op) 560 #define cPVOP cPVOPx(PL_op) 561 #define cCOP cCOPx(PL_op) 562 #define cLOOP cLOOPx(PL_op) 563 564 #define cUNOPo cUNOPx(o) 565 #define cBINOPo cBINOPx(o) 566 #define cLISTOPo cLISTOPx(o) 567 #define cLOGOPo cLOGOPx(o) 568 #define cPMOPo cPMOPx(o) 569 #define cSVOPo cSVOPx(o) 570 #define cPADOPo cPADOPx(o) 571 #define cPVOPo cPVOPx(o) 572 #define cCOPo cCOPx(o) 573 #define cLOOPo cLOOPx(o) 574 575 #define kUNOP cUNOPx(kid) 576 #define kBINOP cBINOPx(kid) 577 #define kLISTOP cLISTOPx(kid) 578 #define kLOGOP cLOGOPx(kid) 579 #define kPMOP cPMOPx(kid) 580 #define kSVOP cSVOPx(kid) 581 #define kPADOP cPADOPx(kid) 582 #define kPVOP cPVOPx(kid) 583 #define kCOP cCOPx(kid) 584 #define kLOOP cLOOPx(kid) 585 586 587 #ifdef USE_ITHREADS 588 # define cGVOPx_gv(o) ((GV*)PAD_SVl(cPADOPx(o)->op_padix)) 589 # define IS_PADGV(v) (v && SvTYPE(v) == SVt_PVGV && isGV_with_GP(v) \ 590 && GvIN_PAD(v)) 591 # define IS_PADCONST(v) \ 592 (v && (SvREADONLY(v) || (SvIsCOW(v) && !SvLEN(v)))) 593 # define cSVOPx_sv(v) (cSVOPx(v)->op_sv \ 594 ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ)) 595 # define cSVOPx_svp(v) (cSVOPx(v)->op_sv \ 596 ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ)) 597 #else 598 # define cGVOPx_gv(o) ((GV*)cSVOPx(o)->op_sv) 599 # define IS_PADGV(v) FALSE 600 # define IS_PADCONST(v) FALSE 601 # define cSVOPx_sv(v) (cSVOPx(v)->op_sv) 602 # define cSVOPx_svp(v) (&cSVOPx(v)->op_sv) 603 #endif 604 605 #define cGVOP_gv cGVOPx_gv(PL_op) 606 #define cGVOPo_gv cGVOPx_gv(o) 607 #define kGVOP_gv cGVOPx_gv(kid) 608 #define cSVOP_sv cSVOPx_sv(PL_op) 609 #define cSVOPo_sv cSVOPx_sv(o) 610 #define kSVOP_sv cSVOPx_sv(kid) 611 612 #ifndef PERL_CORE 613 # define Nullop ((OP*)NULL) 614 #endif 615 616 /* Lowest byte of PL_opargs */ 617 #define OA_MARK 1 618 #define OA_FOLDCONST 2 619 #define OA_RETSCALAR 4 620 #define OA_TARGET 8 621 #define OA_TARGLEX 16 622 #define OA_OTHERINT 32 623 #define OA_DANGEROUS 64 624 #define OA_DEFGV 128 625 626 /* The next 4 bits encode op class information */ 627 #define OCSHIFT 8 628 629 #define OA_CLASS_MASK (15 << OCSHIFT) 630 631 #define OA_BASEOP (0 << OCSHIFT) 632 #define OA_UNOP (1 << OCSHIFT) 633 #define OA_BINOP (2 << OCSHIFT) 634 #define OA_LOGOP (3 << OCSHIFT) 635 #define OA_LISTOP (4 << OCSHIFT) 636 #define OA_PMOP (5 << OCSHIFT) 637 #define OA_SVOP (6 << OCSHIFT) 638 #define OA_PADOP (7 << OCSHIFT) 639 #define OA_PVOP_OR_SVOP (8 << OCSHIFT) 640 #define OA_LOOP (9 << OCSHIFT) 641 #define OA_COP (10 << OCSHIFT) 642 #define OA_BASEOP_OR_UNOP (11 << OCSHIFT) 643 #define OA_FILESTATOP (12 << OCSHIFT) 644 #define OA_LOOPEXOP (13 << OCSHIFT) 645 646 #define OASHIFT 12 647 648 /* Remaining nybbles of PL_opargs */ 649 #define OA_SCALAR 1 650 #define OA_LIST 2 651 #define OA_AVREF 3 652 #define OA_HVREF 4 653 #define OA_CVREF 5 654 #define OA_FILEREF 6 655 #define OA_SCALARREF 7 656 #define OA_OPTIONAL 8 657 658 /* Op_REFCNT is a reference count at the head of each op tree: needed 659 * since the tree is shared between threads, and between cloned closure 660 * copies in the same thread. OP_REFCNT_LOCK/UNLOCK is used when modifying 661 * this count. 662 * The same mutex is used to protect the refcounts of the reg_trie_data 663 * and reg_ac_data structures, which are shared between duplicated 664 * regexes. 665 */ 666 667 #ifdef USE_ITHREADS 668 # define OP_REFCNT_INIT MUTEX_INIT(&PL_op_mutex) 669 # ifdef PERL_CORE 670 # define OP_REFCNT_LOCK MUTEX_LOCK(&PL_op_mutex) 671 # define OP_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_op_mutex) 672 # else 673 # define OP_REFCNT_LOCK op_refcnt_lock() 674 # define OP_REFCNT_UNLOCK op_refcnt_unlock() 675 # endif 676 # define OP_REFCNT_TERM MUTEX_DESTROY(&PL_op_mutex) 677 #else 678 # define OP_REFCNT_INIT NOOP 679 # define OP_REFCNT_LOCK NOOP 680 # define OP_REFCNT_UNLOCK NOOP 681 # define OP_REFCNT_TERM NOOP 682 #endif 683 684 #define OpREFCNT_set(o,n) ((o)->op_targ = (n)) 685 #ifdef PERL_DEBUG_READONLY_OPS 686 # define OpREFCNT_inc(o) Perl_op_refcnt_inc(aTHX_ o) 687 # define OpREFCNT_dec(o) Perl_op_refcnt_dec(aTHX_ o) 688 #else 689 # define OpREFCNT_inc(o) ((o) ? (++(o)->op_targ, (o)) : NULL) 690 # define OpREFCNT_dec(o) (--(o)->op_targ) 691 #endif 692 693 /* flags used by Perl_load_module() */ 694 #define PERL_LOADMOD_DENY 0x1 /* no Module */ 695 #define PERL_LOADMOD_NOIMPORT 0x2 /* use Module () */ 696 #define PERL_LOADMOD_IMPORT_OPS 0x4 /* use Module (...) */ 697 698 #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) || defined(PERL_IN_TOKE_C) 699 #define ref(o, type) doref(o, type, TRUE) 700 #endif 701 702 /* 703 =head1 Optree Manipulation Functions 704 705 =for apidoc Am|OP*|LINKLIST|OP *o 706 Given the root of an optree, link the tree in execution order using the 707 C<op_next> pointers and return the first op executed. If this has 708 already been done, it will not be redone, and C<< o->op_next >> will be 709 returned. If C<< o->op_next >> is not already set, I<o> should be at 710 least an C<UNOP>. 711 712 =cut 713 */ 714 715 #define LINKLIST(o) ((o)->op_next ? (o)->op_next : op_linklist((OP*)o)) 716 717 /* no longer used anywhere in core */ 718 #ifndef PERL_CORE 719 #define cv_ckproto(cv, gv, p) \ 720 cv_ckproto_len_flags((cv), (gv), (p), (p) ? strlen(p) : 0, 0) 721 #endif 722 723 #ifdef PERL_CORE 724 # define my(o) my_attrs((o), NULL) 725 #endif 726 727 #ifdef USE_REENTRANT_API 728 #include "reentr.h" 729 #endif 730 731 #define NewOp(m,var,c,type) \ 732 (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type))) 733 #define NewOpSz(m,var,size) \ 734 (var = (OP *) Perl_Slab_Alloc(aTHX_ size)) 735 #define FreeOp(p) Perl_Slab_Free(aTHX_ p) 736 737 /* 738 * The per-CV op slabs consist of a header (the opslab struct) and a bunch 739 * of space for allocating op slots, each of which consists of two pointers 740 * followed by an op. The first pointer points to the next op slot. The 741 * second points to the slab. At the end of the slab is a null pointer, 742 * so that slot->opslot_next - slot can be used to determine the size 743 * of the op. 744 * 745 * Each CV can have multiple slabs; opslab_next points to the next slab, to 746 * form a chain. All bookkeeping is done on the first slab, which is where 747 * all the op slots point. 748 * 749 * Freed ops are marked as freed and attached to the freed chain 750 * via op_next pointers. 751 * 752 * When there is more than one slab, the second slab in the slab chain is 753 * assumed to be the one with free space available. It is used when allo- 754 * cating an op if there are no freed ops available or big enough. 755 */ 756 757 #ifdef PERL_CORE 758 struct opslot { 759 /* keep opslot_next first */ 760 OPSLOT * opslot_next; /* next slot */ 761 OPSLAB * opslot_slab; /* owner */ 762 OP opslot_op; /* the op itself */ 763 }; 764 765 struct opslab { 766 OPSLOT * opslab_first; /* first op in this slab */ 767 OPSLAB * opslab_next; /* next slab */ 768 OP * opslab_freed; /* chain of freed ops */ 769 size_t opslab_refcnt; /* number of ops */ 770 # ifdef PERL_DEBUG_READONLY_OPS 771 U16 opslab_size; /* size of slab in pointers */ 772 bool opslab_readonly; 773 # endif 774 OPSLOT opslab_slots; /* slots begin here */ 775 }; 776 777 # define OPSLOT_HEADER STRUCT_OFFSET(OPSLOT, opslot_op) 778 # define OPSLOT_HEADER_P (OPSLOT_HEADER/sizeof(I32 *)) 779 # define OpSLOT(o) (assert_(o->op_slabbed) \ 780 (OPSLOT *)(((char *)o)-OPSLOT_HEADER)) 781 # define OpSLAB(o) OpSLOT(o)->opslot_slab 782 # define OpslabREFCNT_dec(slab) \ 783 (((slab)->opslab_refcnt == 1) \ 784 ? opslab_free_nopad(slab) \ 785 : (void)--(slab)->opslab_refcnt) 786 /* Variant that does not null out the pads */ 787 # define OpslabREFCNT_dec_padok(slab) \ 788 (((slab)->opslab_refcnt == 1) \ 789 ? opslab_free(slab) \ 790 : (void)--(slab)->opslab_refcnt) 791 #endif 792 793 struct block_hooks { 794 U32 bhk_flags; 795 void (*bhk_start) (pTHX_ int full); 796 void (*bhk_pre_end) (pTHX_ OP **seq); 797 void (*bhk_post_end) (pTHX_ OP **seq); 798 void (*bhk_eval) (pTHX_ OP *const saveop); 799 }; 800 801 /* 802 =head1 Compile-time scope hooks 803 804 =for apidoc mx|U32|BhkFLAGS|BHK *hk 805 Return the BHK's flags. 806 807 =for apidoc mx|void *|BhkENTRY|BHK *hk|which 808 Return an entry from the BHK structure. I<which> is a preprocessor token 809 indicating which entry to return. If the appropriate flag is not set 810 this will return NULL. The type of the return value depends on which 811 entry you ask for. 812 813 =for apidoc Amx|void|BhkENTRY_set|BHK *hk|which|void *ptr 814 Set an entry in the BHK structure, and set the flags to indicate it is 815 valid. I<which> is a preprocessing token indicating which entry to set. 816 The type of I<ptr> depends on the entry. 817 818 =for apidoc Amx|void|BhkDISABLE|BHK *hk|which 819 Temporarily disable an entry in this BHK structure, by clearing the 820 appropriate flag. I<which> is a preprocessor token indicating which 821 entry to disable. 822 823 =for apidoc Amx|void|BhkENABLE|BHK *hk|which 824 Re-enable an entry in this BHK structure, by setting the appropriate 825 flag. I<which> is a preprocessor token indicating which entry to enable. 826 This will assert (under -DDEBUGGING) if the entry doesn't contain a valid 827 pointer. 828 829 =for apidoc mx|void|CALL_BLOCK_HOOKS|which|arg 830 Call all the registered block hooks for type I<which>. I<which> is a 831 preprocessing token; the type of I<arg> depends on I<which>. 832 833 =cut 834 */ 835 836 #define BhkFLAGS(hk) ((hk)->bhk_flags) 837 838 #define BHKf_bhk_start 0x01 839 #define BHKf_bhk_pre_end 0x02 840 #define BHKf_bhk_post_end 0x04 841 #define BHKf_bhk_eval 0x08 842 843 #define BhkENTRY(hk, which) \ 844 ((BhkFLAGS(hk) & BHKf_ ## which) ? ((hk)->which) : NULL) 845 846 #define BhkENABLE(hk, which) \ 847 STMT_START { \ 848 BhkFLAGS(hk) |= BHKf_ ## which; \ 849 assert(BhkENTRY(hk, which)); \ 850 } STMT_END 851 852 #define BhkDISABLE(hk, which) \ 853 STMT_START { \ 854 BhkFLAGS(hk) &= ~(BHKf_ ## which); \ 855 } STMT_END 856 857 #define BhkENTRY_set(hk, which, ptr) \ 858 STMT_START { \ 859 (hk)->which = ptr; \ 860 BhkENABLE(hk, which); \ 861 } STMT_END 862 863 #define CALL_BLOCK_HOOKS(which, arg) \ 864 STMT_START { \ 865 if (PL_blockhooks) { \ 866 SSize_t i; \ 867 for (i = av_tindex(PL_blockhooks); i >= 0; i--) { \ 868 SV *sv = AvARRAY(PL_blockhooks)[i]; \ 869 BHK *hk; \ 870 \ 871 assert(SvIOK(sv)); \ 872 if (SvUOK(sv)) \ 873 hk = INT2PTR(BHK *, SvUVX(sv)); \ 874 else \ 875 hk = INT2PTR(BHK *, SvIVX(sv)); \ 876 \ 877 if (BhkENTRY(hk, which)) \ 878 BhkENTRY(hk, which)(aTHX_ arg); \ 879 } \ 880 } \ 881 } STMT_END 882 883 /* flags for rv2cv_op_cv */ 884 885 #define RV2CVOPCV_MARK_EARLY 0x00000001 886 #define RV2CVOPCV_RETURN_NAME_GV 0x00000002 887 888 #define op_lvalue(op,t) Perl_op_lvalue_flags(aTHX_ op,t,0) 889 890 /* flags for op_lvalue_flags */ 891 892 #define OP_LVALUE_NO_CROAK 1 893 894 /* 895 =head1 Custom Operators 896 897 =for apidoc Am|U32|XopFLAGS|XOP *xop 898 Return the XOP's flags. 899 900 =for apidoc Am||XopENTRY|XOP *xop|which 901 Return a member of the XOP structure. I<which> is a cpp token 902 indicating which entry to return. If the member is not set 903 this will return a default value. The return type depends 904 on I<which>. This macro evaluates its arguments more than 905 once. If you are using C<Perl_custom_op_xop> to retreive a 906 C<XOP *> from a C<OP *>, use the more efficient L</XopENTRYCUSTOM> instead. 907 908 =for apidoc Am||XopENTRYCUSTOM|const OP *o|which 909 Exactly like C<XopENTRY(XopENTRY(Perl_custom_op_xop(aTHX_ o), which)> but more 910 efficient. The I<which> parameter is identical to L</XopENTRY>. 911 912 =for apidoc Am|void|XopENTRY_set|XOP *xop|which|value 913 Set a member of the XOP structure. I<which> is a cpp token 914 indicating which entry to set. See L<perlguts/"Custom Operators"> 915 for details about the available members and how 916 they are used. This macro evaluates its argument 917 more than once. 918 919 =for apidoc Am|void|XopDISABLE|XOP *xop|which 920 Temporarily disable a member of the XOP, by clearing the appropriate flag. 921 922 =for apidoc Am|void|XopENABLE|XOP *xop|which 923 Reenable a member of the XOP which has been disabled. 924 925 =cut 926 */ 927 928 struct custom_op { 929 U32 xop_flags; 930 const char *xop_name; 931 const char *xop_desc; 932 U32 xop_class; 933 void (*xop_peep)(pTHX_ OP *o, OP *oldop); 934 }; 935 936 /* return value of Perl_custom_op_get_field, similar to void * then casting but 937 the U32 doesn't need truncation on 64 bit platforms in the caller, also 938 for easier macro writing */ 939 typedef union { 940 const char *xop_name; 941 const char *xop_desc; 942 U32 xop_class; 943 void (*xop_peep)(pTHX_ OP *o, OP *oldop); 944 XOP *xop_ptr; 945 } XOPRETANY; 946 947 #define XopFLAGS(xop) ((xop)->xop_flags) 948 949 #define XOPf_xop_name 0x01 950 #define XOPf_xop_desc 0x02 951 #define XOPf_xop_class 0x04 952 #define XOPf_xop_peep 0x08 953 954 /* used by Perl_custom_op_get_field for option checking */ 955 typedef enum { 956 XOPe_xop_ptr = 0, /* just get the XOP *, don't look inside it */ 957 XOPe_xop_name = XOPf_xop_name, 958 XOPe_xop_desc = XOPf_xop_desc, 959 XOPe_xop_class = XOPf_xop_class, 960 XOPe_xop_peep = XOPf_xop_peep 961 } xop_flags_enum; 962 963 #define XOPd_xop_name PL_op_name[OP_CUSTOM] 964 #define XOPd_xop_desc PL_op_desc[OP_CUSTOM] 965 #define XOPd_xop_class OA_BASEOP 966 #define XOPd_xop_peep ((Perl_cpeep_t)0) 967 968 #define XopENTRY_set(xop, which, to) \ 969 STMT_START { \ 970 (xop)->which = (to); \ 971 (xop)->xop_flags |= XOPf_ ## which; \ 972 } STMT_END 973 974 #define XopENTRY(xop, which) \ 975 ((XopFLAGS(xop) & XOPf_ ## which) ? (xop)->which : XOPd_ ## which) 976 977 #define XopENTRYCUSTOM(o, which) \ 978 (Perl_custom_op_get_field(aTHX_ o, XOPe_ ## which).which) 979 980 #define XopDISABLE(xop, which) ((xop)->xop_flags &= ~XOPf_ ## which) 981 #define XopENABLE(xop, which) \ 982 STMT_START { \ 983 (xop)->xop_flags |= XOPf_ ## which; \ 984 assert(XopENTRY(xop, which)); \ 985 } STMT_END 986 987 #define Perl_custom_op_xop(x) \ 988 (Perl_custom_op_get_field(x, XOPe_xop_ptr).xop_ptr) 989 990 /* 991 =head1 Optree Manipulation Functions 992 993 =for apidoc Am|const char *|OP_NAME|OP *o 994 Return the name of the provided OP. For core ops this looks up the name 995 from the op_type; for custom ops from the op_ppaddr. 996 997 =for apidoc Am|const char *|OP_DESC|OP *o 998 Return a short description of the provided OP. 999 1000 =for apidoc Am|U32|OP_CLASS|OP *o 1001 Return the class of the provided OP: that is, which of the *OP 1002 structures it uses. For core ops this currently gets the information out 1003 of PL_opargs, which does not always accurately reflect the type used. 1004 For custom ops the type is returned from the registration, and it is up 1005 to the registree to ensure it is accurate. The value returned will be 1006 one of the OA_* constants from op.h. 1007 1008 =for apidoc Am|bool|OP_TYPE_IS|OP *o|Optype type 1009 Returns true if the given OP is not a NULL pointer 1010 and if it is of the given type. 1011 1012 The negation of this macro, C<OP_TYPE_ISNT> is also available 1013 as well as C<OP_TYPE_IS_NN> and C<OP_TYPE_ISNT_NN> which elide 1014 the NULL pointer check. 1015 1016 =for apidoc Am|bool|OP_TYPE_IS_OR_WAS|OP *o|Optype type 1017 Returns true if the given OP is not a NULL pointer and 1018 if it is of the given type or used to be before being 1019 replaced by an OP of type OP_NULL. 1020 1021 The negation of this macro, C<OP_TYPE_ISNT_AND_WASNT> 1022 is also available as well as C<OP_TYPE_IS_OR_WAS_NN> 1023 and C<OP_TYPE_ISNT_AND_WASNT_NN> which elide 1024 the NULL pointer check. 1025 1026 =cut 1027 */ 1028 1029 #define OP_NAME(o) ((o)->op_type == OP_CUSTOM \ 1030 ? XopENTRYCUSTOM(o, xop_name) \ 1031 : PL_op_name[(o)->op_type]) 1032 #define OP_DESC(o) ((o)->op_type == OP_CUSTOM \ 1033 ? XopENTRYCUSTOM(o, xop_desc) \ 1034 : PL_op_desc[(o)->op_type]) 1035 #define OP_CLASS(o) ((o)->op_type == OP_CUSTOM \ 1036 ? XopENTRYCUSTOM(o, xop_class) \ 1037 : (PL_opargs[(o)->op_type] & OA_CLASS_MASK)) 1038 1039 #define OP_TYPE_IS(o, type) ((o) && (o)->op_type == (type)) 1040 #define OP_TYPE_IS_NN(o, type) ((o)->op_type == (type)) 1041 #define OP_TYPE_ISNT(o, type) ((o) && (o)->op_type != (type)) 1042 #define OP_TYPE_ISNT_NN(o, type) ((o)->op_type != (type)) 1043 1044 #define OP_TYPE_IS_OR_WAS_NN(o, type) \ 1045 ( ((o)->op_type == OP_NULL \ 1046 ? (o)->op_targ \ 1047 : (o)->op_type) \ 1048 == (type) ) 1049 1050 #define OP_TYPE_IS_OR_WAS(o, type) \ 1051 ( (o) && OP_TYPE_IS_OR_WAS_NN(o, type) ) 1052 1053 #define OP_TYPE_ISNT_AND_WASNT_NN(o, type) \ 1054 ( ((o)->op_type == OP_NULL \ 1055 ? (o)->op_targ \ 1056 : (o)->op_type) \ 1057 != (type) ) 1058 1059 #define OP_TYPE_ISNT_AND_WASNT(o, type) \ 1060 ( (o) && OP_TYPE_ISNT_AND_WASNT_NN(o, type) ) 1061 1062 #define newATTRSUB(f, o, p, a, b) Perl_newATTRSUB_x(aTHX_ f, o, p, a, b, FALSE) 1063 #define newSUB(f, o, p, b) newATTRSUB((f), (o), (p), NULL, (b)) 1064 1065 #ifdef PERL_MAD 1066 # define MAD_NULL 1 1067 # define MAD_PV 2 1068 # define MAD_OP 3 1069 # define MAD_SV 4 1070 1071 struct madprop { 1072 MADPROP* mad_next; 1073 void *mad_val; 1074 U32 mad_vlen; 1075 /* short mad_count; */ 1076 char mad_key; 1077 char mad_type; 1078 }; 1079 1080 struct token { 1081 I32 tk_type; 1082 YYSTYPE tk_lval; 1083 MADPROP* tk_mad; 1084 }; 1085 #endif 1086 1087 /* 1088 * Values that can be held by mad_key : 1089 * ^ unfilled head spot 1090 * , literal , 1091 * ; literal ; (blank if implicit ; at end of block) 1092 * : literal : from ?: or attr list 1093 * + unary + 1094 * ? literal ? from ?: 1095 * ( literal ( 1096 * ) literal ) 1097 * [ literal [ 1098 * ] literal ] 1099 * { literal { 1100 * } literal } 1101 * @ literal @ sigil 1102 * $ literal $ sigil 1103 * * literal * sigil 1104 * ! use is source filtered 1105 * & & or sub 1106 * # whitespace/comment following ; or } 1107 * # $# sigil 1108 * 1 1st ; from for(;;) 1109 * 1 retired protasis 1110 * 2 2nd ; from for(;;) 1111 * 2 retired apodosis 1112 * 3 C-style for list 1113 * a sub or var attributes 1114 * a non-method arrow operator 1115 * A method arrow operator 1116 * A use import args 1117 * b format block 1118 * B retired stub block 1119 * C constant conditional op 1120 * d declarator 1121 * D do block 1122 * e unreached "else" (see C) 1123 * e expression producing E 1124 * E tr/E/R/, /E/ 1125 * f folded constant op 1126 * F peg op for format 1127 * g op was forced to be a word 1128 * i if/unless modifier 1129 * I if/elsif/unless statement 1130 * k local declarator 1131 * K retired kid op 1132 * l last index of array ($#foo) 1133 * L label 1134 * m modifier on regex 1135 * n sub or format name 1136 * o current operator/declarator name 1137 * o else/continue 1138 * O generic optimized op 1139 * p peg to hold extra whitespace at statement level 1140 * P peg op for package declaration 1141 * q opening quote 1142 * = quoted material 1143 * Q closing quote 1144 * Q optimized qw// 1145 * r expression producing R 1146 * R tr/E/R/ s/E/R/ 1147 * s sub signature 1148 * S use import stub (no import) 1149 * S retired sort block 1150 * t unreached "then" (see C) 1151 * U use import op 1152 * v private sv of for loop 1153 * V use version 1154 * w while/until modifier 1155 * W while/for statement 1156 * x optimized qw 1157 * X random thing 1158 * _ whitespace/comments preceding anything else 1159 * ~ =~ operator 1160 */ 1161 1162 /* 1163 =head1 Hook manipulation 1164 */ 1165 1166 #ifdef USE_ITHREADS 1167 # define OP_CHECK_MUTEX_INIT MUTEX_INIT(&PL_check_mutex) 1168 # define OP_CHECK_MUTEX_LOCK MUTEX_LOCK(&PL_check_mutex) 1169 # define OP_CHECK_MUTEX_UNLOCK MUTEX_UNLOCK(&PL_check_mutex) 1170 # define OP_CHECK_MUTEX_TERM MUTEX_DESTROY(&PL_check_mutex) 1171 #else 1172 # define OP_CHECK_MUTEX_INIT NOOP 1173 # define OP_CHECK_MUTEX_LOCK NOOP 1174 # define OP_CHECK_MUTEX_UNLOCK NOOP 1175 # define OP_CHECK_MUTEX_TERM NOOP 1176 #endif 1177 1178 /* 1179 * Local variables: 1180 * c-indentation-style: bsd 1181 * c-basic-offset: 4 1182 * indent-tabs-mode: nil 1183 * End: 1184 * 1185 * ex: set ts=8 sts=4 sw=4 et: 1186 */ 1187