op.h

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