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