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 * 23 * See the comments in S_clear_yystack() for more 24 * details on the following three flags: 25 * 26 * op_latefree tell op_free() to clear this op (and free any kids) 27 * but not yet deallocate the struct. This means that 28 * the op may be safely op_free()d multiple times 29 * op_latefreed an op_latefree op has been op_free()d 30 * op_attached this op (sub)tree has been attached to a CV 31 * 32 * op_spare three spare bits! 33 * op_flags Flags common to all operations. See OPf_* below. 34 * op_private Flags peculiar to a particular operation (BUT, 35 * by default, set to the number of children until 36 * the operation is privatized by a check routine, 37 * which may or may not check number of children). 38 */ 39 40 #define OPCODE U16 41 42 #ifdef PERL_MAD 43 # define MADPROP_IN_BASEOP MADPROP* op_madprop; 44 #else 45 # define MADPROP_IN_BASEOP 46 #endif 47 48 typedef PERL_BITFIELD16 Optype; 49 50 #ifdef BASEOP_DEFINITION 51 #define BASEOP BASEOP_DEFINITION 52 #else 53 #define BASEOP \ 54 OP* op_next; \ 55 OP* op_sibling; \ 56 OP* (CPERLscope(*op_ppaddr))(pTHX); \ 57 MADPROP_IN_BASEOP \ 58 PADOFFSET op_targ; \ 59 PERL_BITFIELD16 op_type:9; \ 60 PERL_BITFIELD16 op_opt:1; \ 61 PERL_BITFIELD16 op_latefree:1; \ 62 PERL_BITFIELD16 op_latefreed:1; \ 63 PERL_BITFIELD16 op_attached:1; \ 64 PERL_BITFIELD16 op_spare:3; \ 65 U8 op_flags; \ 66 U8 op_private; 67 #endif 68 69 /* If op_type:9 is changed to :10, also change PUSHEVAL in cop.h. 70 Also, if the type of op_type is ever changed (e.g. to PERL_BITFIELD32) 71 then all the other bit-fields before/after it should change their 72 types too to let VC pack them into the same 4 byte integer.*/ 73 74 #define OP_GIMME(op,dfl) \ 75 (((op)->op_flags & OPf_WANT) == OPf_WANT_VOID ? G_VOID : \ 76 ((op)->op_flags & OPf_WANT) == OPf_WANT_SCALAR ? G_SCALAR : \ 77 ((op)->op_flags & OPf_WANT) == OPf_WANT_LIST ? G_ARRAY : \ 78 dfl) 79 80 #define OP_GIMME_REVERSE(flags) ((flags) & G_WANT) 81 82 /* 83 =head1 "Gimme" Values 84 85 =for apidoc Amn|U32|GIMME_V 86 The XSUB-writer's equivalent to Perl's C<wantarray>. Returns C<G_VOID>, 87 C<G_SCALAR> or C<G_ARRAY> for void, scalar or list context, 88 respectively. 89 90 =for apidoc Amn|U32|GIMME 91 A backward-compatible version of C<GIMME_V> which can only return 92 C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>. 93 Deprecated. Use C<GIMME_V> instead. 94 95 =cut 96 */ 97 98 #define GIMME_V OP_GIMME(PL_op, block_gimme()) 99 100 /* Public flags */ 101 102 #define OPf_WANT 3 /* Mask for "want" bits: */ 103 #define OPf_WANT_VOID 1 /* Want nothing */ 104 #define OPf_WANT_SCALAR 2 /* Want single value */ 105 #define OPf_WANT_LIST 3 /* Want list of any length */ 106 #define OPf_KIDS 4 /* There is a firstborn child. */ 107 #define OPf_PARENS 8 /* This operator was parenthesized. */ 108 /* (Or block needs explicit scope entry.) */ 109 #define OPf_REF 16 /* Certified reference. */ 110 /* (Return container, not containee). */ 111 #define OPf_MOD 32 /* Will modify (lvalue). */ 112 #define OPf_STACKED 64 /* Some arg is arriving on the stack. */ 113 #define OPf_SPECIAL 128 /* Do something weird for this op: */ 114 /* On local LVAL, don't init local value. */ 115 /* On OP_SORT, subroutine is inlined. */ 116 /* On OP_NOT, inversion was implicit. */ 117 /* On OP_LEAVE, don't restore curpm. */ 118 /* On truncate, we truncate filehandle */ 119 /* On control verbs, we saw no label */ 120 /* On flipflop, we saw ... instead of .. */ 121 /* On UNOPs, saw bare parens, e.g. eof(). */ 122 /* On OP_ENTERSUB || OP_NULL, saw a "do". */ 123 /* On OP_EXISTS, treat av as av, not avhv. */ 124 /* On OP_(ENTER|LEAVE)EVAL, don't clear $@ */ 125 /* On OP_ENTERITER, loop var is per-thread */ 126 /* On pushre, rx is used as part of split, e.g. split " " */ 127 /* On regcomp, "use re 'eval'" was in scope */ 128 /* On OP_READLINE, was <$filehandle> */ 129 /* On RV2[ACGHS]V, don't create GV--in 130 defined()*/ 131 /* On OP_DBSTATE, indicates breakpoint 132 * (runtime property) */ 133 /* On OP_AELEMFAST, indiciates pad var */ 134 /* On OP_REQUIRE, was seen as CORE::require */ 135 /* On OP_ENTERWHEN, there's no condition */ 136 /* On OP_BREAK, an implicit break */ 137 /* On OP_SMARTMATCH, an implicit smartmatch */ 138 /* On OP_ANONHASH and OP_ANONLIST, create a 139 reference to the new anon hash or array */ 140 /* On OP_ENTER, store caller context */ 141 /* On OP_HELEM and OP_HSLICE, localization will be followed 142 by assignment, so do not wipe the target if it is special 143 (e.g. a glob or a magic SV) */ 144 145 /* old names; don't use in new code, but don't break them, either */ 146 #define OPf_LIST OPf_WANT_LIST 147 #define OPf_KNOW OPf_WANT 148 149 #define GIMME \ 150 (PL_op->op_flags & OPf_WANT \ 151 ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST \ 152 ? G_ARRAY \ 153 : G_SCALAR) \ 154 : dowantarray()) 155 156 /* NOTE: OP_NEXTSTATE, OP_DBSTATE, and OP_SETSTATE (i.e. COPs) carry lower 157 * bits of PL_hints in op_private */ 158 159 /* Private for lvalues */ 160 #define OPpLVAL_INTRO 128 /* Lvalue must be localized or lvalue sub */ 161 162 /* Private for OP_LEAVE, OP_LEAVESUB, OP_LEAVESUBLV and OP_LEAVEWRITE */ 163 #define OPpREFCOUNTED 64 /* op_targ carries a refcount */ 164 165 /* Private for OP_AASSIGN */ 166 #define OPpASSIGN_COMMON 64 /* Left & right have syms in common. */ 167 168 /* Private for OP_SASSIGN */ 169 #define OPpASSIGN_BACKWARDS 64 /* Left & right switched. */ 170 #define OPpASSIGN_CV_TO_GV 128 /* Possible optimisation for constants. */ 171 172 /* Private for OP_MATCH and OP_SUBST{,CONST} */ 173 #define OPpRUNTIME 64 /* Pattern coming in on the stack */ 174 175 /* Private for OP_TRANS */ 176 #define OPpTRANS_FROM_UTF 1 177 #define OPpTRANS_TO_UTF 2 178 #define OPpTRANS_IDENTICAL 4 /* right side is same as left */ 179 #define OPpTRANS_SQUASH 8 180 /* 16 is used for OPpTARGET_MY */ 181 #define OPpTRANS_COMPLEMENT 32 182 #define OPpTRANS_GROWS 64 183 #define OPpTRANS_DELETE 128 184 #define OPpTRANS_ALL (OPpTRANS_FROM_UTF|OPpTRANS_TO_UTF|OPpTRANS_IDENTICAL|OPpTRANS_SQUASH|OPpTRANS_COMPLEMENT|OPpTRANS_GROWS|OPpTRANS_DELETE) 185 186 /* Private for OP_REPEAT */ 187 #define OPpREPEAT_DOLIST 64 /* List replication. */ 188 189 /* Private for OP_RV2GV, OP_RV2SV, OP_AELEM, OP_HELEM, OP_PADSV */ 190 #define OPpDEREF (32|64) /* autovivify: Want ref to something: */ 191 #define OPpDEREF_AV 32 /* Want ref to AV. */ 192 #define OPpDEREF_HV 64 /* Want ref to HV. */ 193 #define OPpDEREF_SV (32|64) /* Want ref to SV. */ 194 /* OP_ENTERSUB only */ 195 #define OPpENTERSUB_DB 16 /* Debug subroutine. */ 196 #define OPpENTERSUB_HASTARG 32 /* Called from OP tree. */ 197 #define OPpENTERSUB_NOMOD 64 /* Immune to mod() for :attrlist. */ 198 /* OP_ENTERSUB and OP_RV2CV only */ 199 #define OPpENTERSUB_AMPER 8 /* Used & form to call. */ 200 #define OPpENTERSUB_NOPAREN 128 /* bare sub call (without parens) */ 201 #define OPpENTERSUB_INARGS 4 /* Lval used as arg to a sub. */ 202 /* OP_GV only */ 203 #define OPpEARLY_CV 32 /* foo() called before sub foo was parsed */ 204 /* OP_?ELEM only */ 205 #define OPpLVAL_DEFER 16 /* Defer creation of array/hash elem */ 206 /* OP_RV2?V, OP_GVSV, OP_ENTERITER only */ 207 #define OPpOUR_INTRO 16 /* Variable was in an our() */ 208 /* OP_RV2[AGH]V, OP_PAD[AH]V, OP_[AH]ELEM */ 209 #define OPpMAYBE_LVSUB 8 /* We might be an lvalue to return */ 210 /* OP_PADSV only */ 211 #define OPpPAD_STATE 16 /* is a "state" pad */ 212 /* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */ 213 214 /* OP_RV2GV only */ 215 #define OPpDONT_INIT_GV 4 /* Call gv_fetchpv with GV_NOINIT */ 216 /* (Therefore will return whatever is currently in the symbol table, not 217 guaranteed to be a PVGV) */ 218 219 /* OP_RV2CV only */ 220 #define OPpMAY_RETURN_CONSTANT 1 /* If a constant sub, return the constant */ 221 222 /* Private for OPs with TARGLEX */ 223 /* (lower bits may carry MAXARG) */ 224 #define OPpTARGET_MY 16 /* Target is PADMY. */ 225 226 /* Private for OP_ENTERITER and OP_ITER */ 227 #define OPpITER_REVERSED 4 /* for (reverse ...) */ 228 #define OPpITER_DEF 8 /* for $_ or for my $_ */ 229 230 /* Private for OP_CONST */ 231 #define OPpCONST_NOVER 2 /* no 6; */ 232 #define OPpCONST_SHORTCIRCUIT 4 /* eg the constant 5 in (5 || foo) */ 233 #define OPpCONST_STRICT 8 /* bearword subject to strict 'subs' */ 234 #define OPpCONST_ENTERED 16 /* Has been entered as symbol. */ 235 #define OPpCONST_ARYBASE 32 /* Was a $[ translated to constant. */ 236 #define OPpCONST_BARE 64 /* Was a bare word (filehandle?). */ 237 #define OPpCONST_WARNING 128 /* Was a $^W translated to constant. */ 238 239 /* Private for OP_FLIP/FLOP */ 240 #define OPpFLIP_LINENUM 64 /* Range arg potentially a line num. */ 241 242 /* Private for OP_LIST */ 243 #define OPpLIST_GUESSED 64 /* Guessed that pushmark was needed. */ 244 245 /* Private for OP_DELETE */ 246 #define OPpSLICE 64 /* Operating on a list of keys */ 247 /* Also OPpLVAL_INTRO (128) */ 248 249 /* Private for OP_EXISTS */ 250 #define OPpEXISTS_SUB 64 /* Checking for &sub, not {} or []. */ 251 252 /* Private for OP_SORT */ 253 #define OPpSORT_NUMERIC 1 /* Optimized away { $a <=> $b } */ 254 #define OPpSORT_INTEGER 2 /* Ditto while under "use integer" */ 255 #define OPpSORT_REVERSE 4 /* Reversed sort */ 256 #define OPpSORT_INPLACE 8 /* sort in-place; eg @a = sort @a */ 257 #define OPpSORT_DESCEND 16 /* Descending sort */ 258 #define OPpSORT_QSORT 32 /* Use quicksort (not mergesort) */ 259 #define OPpSORT_STABLE 64 /* Use a stable algorithm */ 260 261 /* Private for OP_REVERSE */ 262 #define OPpREVERSE_INPLACE 8 /* reverse in-place (@a = reverse @a) */ 263 264 /* Private for OP_OPEN and OP_BACKTICK */ 265 #define OPpOPEN_IN_RAW 16 /* binmode(F,":raw") on input fh */ 266 #define OPpOPEN_IN_CRLF 32 /* binmode(F,":crlf") on input fh */ 267 #define OPpOPEN_OUT_RAW 64 /* binmode(F,":raw") on output fh */ 268 #define OPpOPEN_OUT_CRLF 128 /* binmode(F,":crlf") on output fh */ 269 270 /* Private for OP_EXIT, HUSH also for OP_DIE */ 271 #define OPpHUSH_VMSISH 64 /* hush DCL exit msg vmsish mode*/ 272 #define OPpEXIT_VMSISH 128 /* exit(0) vs. exit(1) vmsish mode*/ 273 274 /* Private for OP_FTXXX */ 275 #define OPpFT_ACCESS 2 /* use filetest 'access' */ 276 #define OPpFT_STACKED 4 /* stacked filetest, as in "-f -x $f" */ 277 278 /* Private for OP_(MAP|GREP)(WHILE|START) */ 279 #define OPpGREP_LEX 2 /* iterate over lexical $_ */ 280 281 /* Private for OP_ENTEREVAL */ 282 #define OPpEVAL_HAS_HH 2 /* Does it have a copy of %^H */ 283 284 struct op { 285 BASEOP 286 }; 287 288 struct unop { 289 BASEOP 290 OP * op_first; 291 }; 292 293 struct binop { 294 BASEOP 295 OP * op_first; 296 OP * op_last; 297 }; 298 299 struct logop { 300 BASEOP 301 OP * op_first; 302 OP * op_other; 303 }; 304 305 struct listop { 306 BASEOP 307 OP * op_first; 308 OP * op_last; 309 }; 310 311 struct pmop { 312 BASEOP 313 OP * op_first; 314 OP * op_last; 315 #ifdef USE_ITHREADS 316 IV op_pmoffset; 317 #else 318 REGEXP * op_pmregexp; /* compiled expression */ 319 #endif 320 U32 op_pmflags; 321 union { 322 OP * op_pmreplroot; /* For OP_SUBST */ 323 #ifdef USE_ITHREADS 324 PADOFFSET op_pmtargetoff; /* For OP_PUSHRE */ 325 #else 326 GV * op_pmtargetgv; 327 #endif 328 } op_pmreplrootu; 329 union { 330 OP * op_pmreplstart; /* Only used in OP_SUBST */ 331 #ifdef USE_ITHREADS 332 char * op_pmstashpv; /* Only used in OP_MATCH, with PMf_ONCE set */ 333 #else 334 HV * op_pmstash; 335 #endif 336 } op_pmstashstartu; 337 }; 338 339 #ifdef USE_ITHREADS 340 #define PM_GETRE(o) (SvTYPE(PL_regex_pad[(o)->op_pmoffset]) == SVt_REGEXP \ 341 ? (REGEXP*)(PL_regex_pad[(o)->op_pmoffset]) : NULL) 342 /* The assignment is just to enforce type safety (or at least get a warning). 343 */ 344 /* With first class regexps not via a reference one needs to assign 345 &PL_sv_undef under ithreads. (This would probably work unthreaded, but NULL 346 is cheaper. I guess we could allow NULL, but the check above would get 347 more complex, and we'd have an AV with (SV*)NULL in it, which feels bad */ 348 /* BEWARE - something that calls this macro passes (r) which has a side 349 effect. */ 350 #define PM_SETRE(o,r) STMT_START { \ 351 REGEXP *const _pm_setre = (r); \ 352 assert(_pm_setre); \ 353 PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \ 354 } STMT_END 355 #else 356 #define PM_GETRE(o) ((o)->op_pmregexp) 357 #define PM_SETRE(o,r) ((o)->op_pmregexp = (r)) 358 #endif 359 360 361 #define PMf_RETAINT 0x00000040 /* taint $1 etc. if target tainted */ 362 #define PMf_ONCE 0x00000080 /* match successfully only once per 363 reset, with related flag RXf_USED 364 in re->extflags holding state. 365 This is used only for ?? matches, 366 and only on OP_MATCH and OP_QR */ 367 368 #define PMf_UNUSED 0x00000100 /* free for use */ 369 #define PMf_MAYBE_CONST 0x00000200 /* replacement contains variables */ 370 371 #define PMf_USED 0x00000400 /* PMf_ONCE has matched successfully. 372 Not used under threading. */ 373 374 #define PMf_CONST 0x00000800 /* subst replacement is constant */ 375 #define PMf_KEEP 0x00001000 /* keep 1st runtime pattern forever */ 376 #define PMf_GLOBAL 0x00002000 /* pattern had a g modifier */ 377 #define PMf_CONTINUE 0x00004000 /* don't reset pos() if //g fails */ 378 #define PMf_EVAL 0x00008000 /* evaluating replacement as expr */ 379 380 /* The following flags have exact equivalents in regcomp.h with the prefix RXf_ 381 * which are stored in the regexp->extflags member. If you change them here, 382 * you have to change them there, and vice versa. 383 */ 384 #define PMf_MULTILINE 0x00000001 /* assume multiple lines */ 385 #define PMf_SINGLELINE 0x00000002 /* assume single line */ 386 #define PMf_FOLD 0x00000004 /* case insensitivity */ 387 #define PMf_EXTENDED 0x00000008 /* chuck embedded whitespace */ 388 #define PMf_KEEPCOPY 0x00000010 /* copy the string when matching */ 389 #define PMf_LOCALE 0x00000020 /* use locale for character types */ 390 391 /* mask of bits that need to be transfered to re->extflags */ 392 #define PMf_COMPILETIME (PMf_MULTILINE|PMf_SINGLELINE|PMf_LOCALE|PMf_FOLD|PMf_EXTENDED|PMf_KEEPCOPY) 393 394 #ifdef USE_ITHREADS 395 396 # define PmopSTASHPV(o) \ 397 (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstashpv : NULL) 398 # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 399 # define PmopSTASHPV_set(o,pv) ({ \ 400 assert((o)->op_pmflags & PMf_ONCE); \ 401 ((o)->op_pmstashstartu.op_pmstashpv = savesharedpv(pv)); \ 402 }) 403 # else 404 # define PmopSTASHPV_set(o,pv) \ 405 ((o)->op_pmstashstartu.op_pmstashpv = savesharedpv(pv)) 406 # endif 407 # define PmopSTASH(o) (PmopSTASHPV(o) \ 408 ? gv_stashpv((o)->op_pmstashstartu.op_pmstashpv,GV_ADD) : NULL) 409 # define PmopSTASH_set(o,hv) PmopSTASHPV_set(o, ((hv) ? HvNAME_get(hv) : NULL)) 410 # define PmopSTASH_free(o) PerlMemShared_free(PmopSTASHPV(o)) 411 412 #else 413 # define PmopSTASH(o) \ 414 (((o)->op_pmflags & PMf_ONCE) ? (o)->op_pmstashstartu.op_pmstash : NULL) 415 # if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN) 416 # define PmopSTASH_set(o,hv) ({ \ 417 assert((o)->op_pmflags & PMf_ONCE); \ 418 ((o)->op_pmstashstartu.op_pmstash = (hv)); \ 419 }) 420 # else 421 # define PmopSTASH_set(o,hv) ((o)->op_pmstashstartu.op_pmstash = (hv)) 422 # endif 423 # define PmopSTASHPV(o) (PmopSTASH(o) ? HvNAME_get(PmopSTASH(o)) : NULL) 424 /* op_pmstashstartu.op_pmstash is not refcounted */ 425 # define PmopSTASHPV_set(o,pv) PmopSTASH_set((o), gv_stashpv(pv,GV_ADD)) 426 /* Note that if this becomes non-empty, then S_forget_pmop in op.c will need 427 changing */ 428 # define PmopSTASH_free(o) 429 #endif 430 431 struct svop { 432 BASEOP 433 SV * op_sv; 434 }; 435 436 struct padop { 437 BASEOP 438 PADOFFSET op_padix; 439 }; 440 441 struct pvop { 442 BASEOP 443 char * op_pv; 444 }; 445 446 struct loop { 447 BASEOP 448 OP * op_first; 449 OP * op_last; 450 OP * op_redoop; 451 OP * op_nextop; 452 OP * op_lastop; 453 }; 454 455 #define cUNOPx(o) ((UNOP*)o) 456 #define cBINOPx(o) ((BINOP*)o) 457 #define cLISTOPx(o) ((LISTOP*)o) 458 #define cLOGOPx(o) ((LOGOP*)o) 459 #define cPMOPx(o) ((PMOP*)o) 460 #define cSVOPx(o) ((SVOP*)o) 461 #define cPADOPx(o) ((PADOP*)o) 462 #define cPVOPx(o) ((PVOP*)o) 463 #define cCOPx(o) ((COP*)o) 464 #define cLOOPx(o) ((LOOP*)o) 465 466 #define cUNOP cUNOPx(PL_op) 467 #define cBINOP cBINOPx(PL_op) 468 #define cLISTOP cLISTOPx(PL_op) 469 #define cLOGOP cLOGOPx(PL_op) 470 #define cPMOP cPMOPx(PL_op) 471 #define cSVOP cSVOPx(PL_op) 472 #define cPADOP cPADOPx(PL_op) 473 #define cPVOP cPVOPx(PL_op) 474 #define cCOP cCOPx(PL_op) 475 #define cLOOP cLOOPx(PL_op) 476 477 #define cUNOPo cUNOPx(o) 478 #define cBINOPo cBINOPx(o) 479 #define cLISTOPo cLISTOPx(o) 480 #define cLOGOPo cLOGOPx(o) 481 #define cPMOPo cPMOPx(o) 482 #define cSVOPo cSVOPx(o) 483 #define cPADOPo cPADOPx(o) 484 #define cPVOPo cPVOPx(o) 485 #define cCOPo cCOPx(o) 486 #define cLOOPo cLOOPx(o) 487 488 #define kUNOP cUNOPx(kid) 489 #define kBINOP cBINOPx(kid) 490 #define kLISTOP cLISTOPx(kid) 491 #define kLOGOP cLOGOPx(kid) 492 #define kPMOP cPMOPx(kid) 493 #define kSVOP cSVOPx(kid) 494 #define kPADOP cPADOPx(kid) 495 #define kPVOP cPVOPx(kid) 496 #define kCOP cCOPx(kid) 497 #define kLOOP cLOOPx(kid) 498 499 500 #ifdef USE_ITHREADS 501 # define cGVOPx_gv(o) ((GV*)PAD_SVl(cPADOPx(o)->op_padix)) 502 # define IS_PADGV(v) (v && SvTYPE(v) == SVt_PVGV && isGV_with_GP(v) \ 503 && GvIN_PAD(v)) 504 # define IS_PADCONST(v) (v && SvREADONLY(v)) 505 # define cSVOPx_sv(v) (cSVOPx(v)->op_sv \ 506 ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ)) 507 # define cSVOPx_svp(v) (cSVOPx(v)->op_sv \ 508 ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ)) 509 #else 510 # define cGVOPx_gv(o) ((GV*)cSVOPx(o)->op_sv) 511 # define IS_PADGV(v) FALSE 512 # define IS_PADCONST(v) FALSE 513 # define cSVOPx_sv(v) (cSVOPx(v)->op_sv) 514 # define cSVOPx_svp(v) (&cSVOPx(v)->op_sv) 515 #endif 516 517 #define cGVOP_gv cGVOPx_gv(PL_op) 518 #define cGVOPo_gv cGVOPx_gv(o) 519 #define kGVOP_gv cGVOPx_gv(kid) 520 #define cSVOP_sv cSVOPx_sv(PL_op) 521 #define cSVOPo_sv cSVOPx_sv(o) 522 #define kSVOP_sv cSVOPx_sv(kid) 523 524 #ifndef PERL_CORE 525 # define Nullop ((OP*)NULL) 526 #endif 527 528 /* Lowest byte-and-a-bit of PL_opargs */ 529 #define OA_MARK 1 530 #define OA_FOLDCONST 2 531 #define OA_RETSCALAR 4 532 #define OA_TARGET 8 533 #define OA_RETINTEGER 16 534 #define OA_OTHERINT 32 535 #define OA_DANGEROUS 64 536 #define OA_DEFGV 128 537 #define OA_TARGLEX 256 538 539 /* The next 4 bits encode op class information */ 540 #define OCSHIFT 9 541 542 #define OA_CLASS_MASK (15 << OCSHIFT) 543 544 #define OA_BASEOP (0 << OCSHIFT) 545 #define OA_UNOP (1 << OCSHIFT) 546 #define OA_BINOP (2 << OCSHIFT) 547 #define OA_LOGOP (3 << OCSHIFT) 548 #define OA_LISTOP (4 << OCSHIFT) 549 #define OA_PMOP (5 << OCSHIFT) 550 #define OA_SVOP (6 << OCSHIFT) 551 #define OA_PADOP (7 << OCSHIFT) 552 #define OA_PVOP_OR_SVOP (8 << OCSHIFT) 553 #define OA_LOOP (9 << OCSHIFT) 554 #define OA_COP (10 << OCSHIFT) 555 #define OA_BASEOP_OR_UNOP (11 << OCSHIFT) 556 #define OA_FILESTATOP (12 << OCSHIFT) 557 #define OA_LOOPEXOP (13 << OCSHIFT) 558 559 #define OASHIFT 13 560 561 /* Remaining nybbles of PL_opargs */ 562 #define OA_SCALAR 1 563 #define OA_LIST 2 564 #define OA_AVREF 3 565 #define OA_HVREF 4 566 #define OA_CVREF 5 567 #define OA_FILEREF 6 568 #define OA_SCALARREF 7 569 #define OA_OPTIONAL 8 570 571 /* Op_REFCNT is a reference count at the head of each op tree: needed 572 * since the tree is shared between threads, and between cloned closure 573 * copies in the same thread. OP_REFCNT_LOCK/UNLOCK is used when modifying 574 * this count. 575 * The same mutex is used to protect the refcounts of the reg_trie_data 576 * and reg_ac_data structures, which are shared between duplicated 577 * regexes. 578 */ 579 580 #ifdef USE_ITHREADS 581 # define OP_REFCNT_INIT MUTEX_INIT(&PL_op_mutex) 582 # ifdef PERL_CORE 583 # define OP_REFCNT_LOCK MUTEX_LOCK(&PL_op_mutex) 584 # define OP_REFCNT_UNLOCK MUTEX_UNLOCK(&PL_op_mutex) 585 # else 586 # define OP_REFCNT_LOCK op_refcnt_lock() 587 # define OP_REFCNT_UNLOCK op_refcnt_unlock() 588 # endif 589 # define OP_REFCNT_TERM MUTEX_DESTROY(&PL_op_mutex) 590 #else 591 # define OP_REFCNT_INIT NOOP 592 # define OP_REFCNT_LOCK NOOP 593 # define OP_REFCNT_UNLOCK NOOP 594 # define OP_REFCNT_TERM NOOP 595 #endif 596 597 #define OpREFCNT_set(o,n) ((o)->op_targ = (n)) 598 #ifdef PERL_DEBUG_READONLY_OPS 599 # define OpREFCNT_inc(o) Perl_op_refcnt_inc(aTHX_ o) 600 # define OpREFCNT_dec(o) Perl_op_refcnt_dec(aTHX_ o) 601 #else 602 # define OpREFCNT_inc(o) ((o) ? (++(o)->op_targ, (o)) : NULL) 603 # define OpREFCNT_dec(o) (--(o)->op_targ) 604 #endif 605 606 /* flags used by Perl_load_module() */ 607 #define PERL_LOADMOD_DENY 0x1 /* no Module */ 608 #define PERL_LOADMOD_NOIMPORT 0x2 /* use Module () */ 609 #define PERL_LOADMOD_IMPORT_OPS 0x4 /* use Module (...) */ 610 611 #if defined(PERL_IN_PERLY_C) || defined(PERL_IN_OP_C) 612 #define ref(o, type) doref(o, type, TRUE) 613 #endif 614 615 /* no longer used anywhere in core */ 616 #ifndef PERL_CORE 617 #define cv_ckproto(cv, gv, p) \ 618 cv_ckproto_len((cv), (gv), (p), (p) ? strlen(p) : 0) 619 #endif 620 621 #ifdef PERL_CORE 622 # define my(o) my_attrs((o), NULL) 623 #endif 624 625 #ifdef USE_REENTRANT_API 626 #include "reentr.h" 627 #endif 628 629 #if defined(PL_OP_SLAB_ALLOC) 630 #define NewOp(m,var,c,type) \ 631 (var = (type *) Perl_Slab_Alloc(aTHX_ c*sizeof(type))) 632 #define NewOpSz(m,var,size) \ 633 (var = (OP *) Perl_Slab_Alloc(aTHX_ size)) 634 #define FreeOp(p) Perl_Slab_Free(aTHX_ p) 635 #else 636 #define NewOp(m, var, c, type) \ 637 (var = (MEM_WRAP_CHECK_(c,type) \ 638 (type*)PerlMemShared_calloc(c, sizeof(type)))) 639 #define NewOpSz(m, var, size) \ 640 (var = (OP*)PerlMemShared_calloc(1, size)) 641 #define FreeOp(p) PerlMemShared_free(p) 642 #endif 643 644 #ifdef PERL_MAD 645 # define MAD_NULL 1 646 # define MAD_PV 2 647 # define MAD_OP 3 648 # define MAD_SV 4 649 650 struct madprop { 651 MADPROP* mad_next; 652 void *mad_val; 653 U32 mad_vlen; 654 /* short mad_count; */ 655 char mad_key; 656 char mad_type; 657 }; 658 659 struct token { 660 I32 tk_type; 661 YYSTYPE tk_lval; 662 MADPROP* tk_mad; 663 }; 664 #endif 665 666 /* 667 * Values that can be held by mad_key : 668 * ^ unfilled head spot 669 * , literal , 670 * ; literal ; (blank if implicit ; at end of block) 671 * : literal : from ?: or attr list 672 * + unary + 673 * ? literal ? from ?: 674 * ( literal ( 675 * ) literal ) 676 * [ literal [ 677 * ] literal ] 678 * { literal { 679 * } literal } 680 * @ literal @ sigil 681 * $ literal $ sigil 682 * * literal * sigil 683 * ! use is source filtered 684 * & & or sub 685 * # whitespace/comment following ; or } 686 * # $# sigil 687 * 1 1st ; from for(;;) 688 * 1 retired protasis 689 * 2 2nd ; from for(;;) 690 * 2 retired apodosis 691 * 3 C-style for list 692 * a sub or var attributes 693 * a non-method arrow operator 694 * A method arrow operator 695 * A use import args 696 * b format block 697 * B retired stub block 698 * C constant conditional op 699 * d declarator 700 * D do block 701 * e unreached "else" (see C) 702 * e expression producing E 703 * E tr/E/R/, /E/ 704 * f folded constant op 705 * F peg op for format 706 * g op was forced to be a word 707 * i if/unless modifier 708 * I if/elsif/unless statement 709 * k local declarator 710 * K retired kid op 711 * l last index of array ($#foo) 712 * L label 713 * m modifier on regex 714 * n sub or format name 715 * o current operator/declarator name 716 * o else/continue 717 * O generic optimized op 718 * p peg to hold extra whitespace at statement level 719 * P peg op for package declaration 720 * q opening quote 721 * = quoted material 722 * Q closing quote 723 * Q optimized qw// 724 * r expression producing R 725 * R tr/E/R/ s/E/R/ 726 * s sub signature 727 * S use import stub (no import) 728 * S retired sort block 729 * t unreached "then" (see C) 730 * U use import op 731 * v private sv of for loop 732 * V use version 733 * w while/until modifier 734 * W while/for statement 735 * x optimized qw 736 * X random thing 737 * _ whitespace/comments preceding anything else 738 * ~ =~ operator 739 */ 740 741 /* 742 * Local variables: 743 * c-indentation-style: bsd 744 * c-basic-offset: 4 745 * indent-tabs-mode: t 746 * End: 747 * 748 * ex: set ts=8 sts=4 sw=4 noet: 749 */ 750