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