home *** CD-ROM | disk | FTP | other *** search
/ PC World 2005 December (Special) / PCWorld_2005-12_Special_cd.bin / Bezpecnost / lsti / lsti.exe / framework-2.5.exe / op.h < prev    next >
C/C++ Source or Header  |  2005-01-27  |  16KB  |  506 lines
  1. /*    op.h
  2.  *
  3.  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
  4.  *    2000, 2001, 2002, 2003, 2004, 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_flags    Flags common to all operations.  See OPf_* below.
  21.  *    op_private    Flags peculiar to a particular operation (BUT,
  22.  *            by default, set to the number of children until
  23.  *            the operation is privatized by a check routine,
  24.  *            which may or may not check number of children).
  25.  */
  26.  
  27. #ifdef DEBUGGING_OPS
  28. #define OPCODE opcode
  29. #else
  30. #define OPCODE U16
  31. #endif
  32.  
  33. #ifdef BASEOP_DEFINITION
  34. #define BASEOP BASEOP_DEFINITION
  35. #else
  36. #define BASEOP                \
  37.     OP*        op_next;        \
  38.     OP*        op_sibling;        \
  39.     OP*        (CPERLscope(*op_ppaddr))(pTHX);        \
  40.     PADOFFSET    op_targ;        \
  41.     OPCODE    op_type;        \
  42.     U16        op_seq;            \
  43.     U8        op_flags;        \
  44.     U8        op_private;
  45. #endif
  46.  
  47. #define OP_GIMME(op,dfl) \
  48.     (((op)->op_flags & OPf_WANT) == OPf_WANT_VOID   ? G_VOID   : \
  49.      ((op)->op_flags & OPf_WANT) == OPf_WANT_SCALAR ? G_SCALAR : \
  50.      ((op)->op_flags & OPf_WANT) == OPf_WANT_LIST   ? G_ARRAY   : \
  51.      dfl)
  52.  
  53. /*
  54. =head1 "Gimme" Values
  55.  
  56. =for apidoc Amn|U32|GIMME_V
  57. The XSUB-writer's equivalent to Perl's C<wantarray>.  Returns C<G_VOID>,
  58. C<G_SCALAR> or C<G_ARRAY> for void, scalar or list context,
  59. respectively.
  60.  
  61. =for apidoc Amn|U32|GIMME
  62. A backward-compatible version of C<GIMME_V> which can only return
  63. C<G_SCALAR> or C<G_ARRAY>; in a void context, it returns C<G_SCALAR>.
  64. Deprecated.  Use C<GIMME_V> instead.
  65.  
  66. =cut
  67. */
  68.  
  69. #define GIMME_V        OP_GIMME(PL_op, block_gimme())
  70.  
  71. /* Public flags */
  72.  
  73. #define OPf_WANT    3    /* Mask for "want" bits: */
  74. #define  OPf_WANT_VOID     1    /*   Want nothing */
  75. #define  OPf_WANT_SCALAR 2    /*   Want single value */
  76. #define  OPf_WANT_LIST     3    /*   Want list of any length */
  77. #define OPf_KIDS    4    /* There is a firstborn child. */
  78. #define OPf_PARENS    8    /* This operator was parenthesized. */
  79.                 /*  (Or block needs explicit scope entry.) */
  80. #define OPf_REF        16    /* Certified reference. */
  81.                 /*  (Return container, not containee). */
  82. #define OPf_MOD        32    /* Will modify (lvalue). */
  83. #define OPf_STACKED    64    /* Some arg is arriving on the stack. */
  84. #define OPf_SPECIAL    128    /* Do something weird for this op: */
  85.                 /*  On local LVAL, don't init local value. */
  86.                 /*  On OP_SORT, subroutine is inlined. */
  87.                 /*  On OP_NOT, inversion was implicit. */
  88.                 /*  On OP_LEAVE, don't restore curpm. */
  89.                 /*  On truncate, we truncate filehandle */
  90.                 /*  On control verbs, we saw no label */
  91.                 /*  On flipflop, we saw ... instead of .. */
  92.                 /*  On UNOPs, saw bare parens, e.g. eof(). */
  93.                 /*  On OP_ENTERSUB || OP_NULL, saw a "do". */
  94.                 /*  On OP_EXISTS, treat av as av, not avhv.  */
  95.                 /*  On OP_(ENTER|LEAVE)EVAL, don't clear $@ */
  96.                 /*  On OP_ENTERITER, loop var is per-thread */
  97.                 /*  On pushre, re is /\s+/ imp. by split " " */
  98.                 /*  On regcomp, "use re 'eval'" was in scope */
  99.                 /*  On OP_READLINE, was <$filehandle> */
  100.                 /*  On RV2[SG]V, don't create GV--in defined()*/
  101.                 /*  On OP_DBSTATE, indicates breakpoint
  102.                  *    (runtime property) */
  103.                 /*  On OP_AELEMFAST, indiciates pad var */
  104.  
  105. /* old names; don't use in new code, but don't break them, either */
  106. #define OPf_LIST    OPf_WANT_LIST
  107. #define OPf_KNOW    OPf_WANT
  108.  
  109. #define GIMME \
  110.       (PL_op->op_flags & OPf_WANT                    \
  111.        ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST        \
  112.           ? G_ARRAY                            \
  113.           : G_SCALAR)                        \
  114.        : dowantarray())
  115.  
  116. /* NOTE: OP_NEXTSTATE, OP_DBSTATE, and OP_SETSTATE (i.e. COPs) carry lower
  117.  * bits of PL_hints in op_private */
  118.  
  119. /* Private for lvalues */
  120. #define OPpLVAL_INTRO    128    /* Lvalue must be localized or lvalue sub */
  121.  
  122. /* Private for OP_LEAVE, OP_LEAVESUB, OP_LEAVESUBLV and OP_LEAVEWRITE */
  123. #define OPpREFCOUNTED        64    /* op_targ carries a refcount */
  124.  
  125. /* Private for OP_AASSIGN */
  126. #define OPpASSIGN_COMMON    64    /* Left & right have syms in common. */
  127. #define OPpASSIGN_HASH        32    /* Assigning to possible pseudohash. */
  128.  
  129. /* Private for OP_SASSIGN */
  130. #define OPpASSIGN_BACKWARDS    64    /* Left & right switched. */
  131.  
  132. /* Private for OP_MATCH and OP_SUBST{,CONST} */
  133. #define OPpRUNTIME        64    /* Pattern coming in on the stack */
  134.  
  135. /* Private for OP_TRANS */
  136. #define OPpTRANS_FROM_UTF    1
  137. #define OPpTRANS_TO_UTF        2
  138. #define OPpTRANS_IDENTICAL    4    /* right side is same as left */
  139. #define OPpTRANS_SQUASH        8
  140. #define OPpTRANS_DELETE        16
  141. #define OPpTRANS_COMPLEMENT    32
  142. #define OPpTRANS_GROWS        64
  143.  
  144. /* Private for OP_REPEAT */
  145. #define OPpREPEAT_DOLIST    64    /* List replication. */
  146.  
  147. /* Private for OP_RV2GV, OP_RV2SV, OP_AELEM, OP_HELEM, OP_PADSV */
  148. #define OPpDEREF        (32|64)    /* autovivify: Want ref to something: */
  149. #define OPpDEREF_AV        32    /*   Want ref to AV. */
  150. #define OPpDEREF_HV        64    /*   Want ref to HV. */
  151. #define OPpDEREF_SV        (32|64)    /*   Want ref to SV. */
  152.   /* OP_ENTERSUB only */
  153. #define OPpENTERSUB_DB        16    /* Debug subroutine. */
  154. #define OPpENTERSUB_HASTARG    32    /* Called from OP tree. */
  155. #define OPpENTERSUB_NOMOD    64    /* Immune to mod() for :attrlist. */
  156.   /* OP_RV2CV only */
  157. #define OPpENTERSUB_AMPER    8    /* Used & form to call. */
  158. #define OPpENTERSUB_NOPAREN    128    /* bare sub call (without parens) */
  159. #define OPpENTERSUB_INARGS    4    /* Lval used as arg to a sub. */
  160.   /* OP_GV only */
  161. #define OPpEARLY_CV        32    /* foo() called before sub foo was parsed */
  162.   /* OP_?ELEM only */
  163. #define OPpLVAL_DEFER        16    /* Defer creation of array/hash elem */
  164.   /* OP_RV2?V, OP_GVSV, OP_ENTERITER only */
  165. #define OPpOUR_INTRO        16    /* Variable was in an our() */
  166.   /* OP_RV2[AH]V, OP_PAD[AH]V, OP_[AH]ELEM */
  167. #define OPpMAYBE_LVSUB        8    /* We might be an lvalue to return */
  168.   /* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */
  169.  
  170. /* Private for OPs with TARGLEX */
  171.   /* (lower bits may carry MAXARG) */
  172. #define OPpTARGET_MY        16    /* Target is PADMY. */
  173.  
  174. /* Private for OP_ENTERITER and OP_ITER */
  175. #define OPpITER_REVERSED    4    /* for (reverse ...) */
  176.  
  177. /* Private for OP_CONST */
  178. #define    OPpCONST_SHORTCIRCUIT    4    /* eg the constant 5 in (5 || foo) */
  179. #define    OPpCONST_STRICT        8    /* bearword subject to strict 'subs' */
  180. #define OPpCONST_ENTERED    16    /* Has been entered as symbol. */
  181. #define OPpCONST_ARYBASE    32    /* Was a $[ translated to constant. */
  182. #define OPpCONST_BARE        64    /* Was a bare word (filehandle?). */
  183. #define OPpCONST_WARNING    128    /* Was a $^W translated to constant. */
  184.  
  185. /* Private for OP_FLIP/FLOP */
  186. #define OPpFLIP_LINENUM        64    /* Range arg potentially a line num. */
  187.  
  188. /* Private for OP_LIST */
  189. #define OPpLIST_GUESSED        64    /* Guessed that pushmark was needed. */
  190.  
  191. /* Private for OP_DELETE */
  192. #define OPpSLICE        64    /* Operating on a list of keys */
  193.  
  194. /* Private for OP_EXISTS */
  195. #define OPpEXISTS_SUB        64    /* Checking for &sub, not {} or [].  */
  196.  
  197. /* Private for OP_SORT */
  198. #define OPpSORT_NUMERIC        1    /* Optimized away { $a <=> $b } */
  199. #define OPpSORT_INTEGER        2    /* Ditto while under "use integer" */
  200. #define OPpSORT_REVERSE        4    /* Reversed sort */
  201. #define OPpSORT_INPLACE        8    /* sort in-place; eg @a = sort @a */
  202. #define OPpSORT_DESCEND        16    /* Descending sort */
  203. /* Private for OP_THREADSV */
  204. #define OPpDONE_SVREF        64    /* Been through newSVREF once */
  205.  
  206. /* Private for OP_OPEN and OP_BACKTICK */
  207. #define OPpOPEN_IN_RAW        16    /* binmode(F,":raw") on input fh */
  208. #define OPpOPEN_IN_CRLF        32    /* binmode(F,":crlf") on input fh */
  209. #define OPpOPEN_OUT_RAW        64    /* binmode(F,":raw") on output fh */
  210. #define OPpOPEN_OUT_CRLF    128    /* binmode(F,":crlf") on output fh */
  211.  
  212. /* Private for OP_EXIT, HUSH also for OP_DIE */
  213. #define OPpHUSH_VMSISH        64    /* hush DCL exit msg vmsish mode*/
  214. #define OPpEXIT_VMSISH        128    /* exit(0) vs. exit(1) vmsish mode*/
  215.  
  216. /* Private of OP_FTXXX */
  217. #define OPpFT_ACCESS        2    /* use filetest 'access' */
  218. #define OP_IS_FILETEST_ACCESS(op)         \
  219.     (((op)->op_type) == OP_FTRREAD  ||    \
  220.      ((op)->op_type) == OP_FTRWRITE ||    \
  221.      ((op)->op_type) == OP_FTREXEC  ||    \
  222.      ((op)->op_type) == OP_FTEREAD  ||    \
  223.      ((op)->op_type) == OP_FTEWRITE ||    \
  224.      ((op)->op_type) == OP_FTEEXEC)
  225.  
  226. struct op {
  227.     BASEOP
  228. };
  229.  
  230. struct unop {
  231.     BASEOP
  232.     OP *    op_first;
  233. };
  234.  
  235. struct binop {
  236.     BASEOP
  237.     OP *    op_first;
  238.     OP *    op_last;
  239. };
  240.  
  241. struct logop {
  242.     BASEOP
  243.     OP *    op_first;
  244.     OP *    op_other;
  245. };
  246.  
  247. struct listop {
  248.     BASEOP
  249.     OP *    op_first;
  250.     OP *    op_last;
  251. };
  252.  
  253. struct pmop {
  254.     BASEOP
  255.     OP *    op_first;
  256.     OP *    op_last;
  257.     OP *    op_pmreplroot;
  258.     OP *    op_pmreplstart;
  259.     PMOP *    op_pmnext;        /* list of all scanpats */
  260. #ifdef USE_ITHREADS
  261.     IV          op_pmoffset;
  262. #else
  263.     REGEXP *    op_pmregexp;            /* compiled expression */
  264. #endif
  265.     U32        op_pmflags;
  266.     U32        op_pmpermflags;
  267.     U8        op_pmdynflags;
  268. #ifdef USE_ITHREADS
  269.     char *    op_pmstashpv;
  270. #else
  271.     HV *    op_pmstash;
  272. #endif
  273. };
  274.  
  275. #ifdef USE_ITHREADS
  276. #define PM_GETRE(o)     (INT2PTR(REGEXP*,SvIVX(PL_regex_pad[(o)->op_pmoffset])))
  277. #define PM_SETRE(o,r)   STMT_START { SV* sv = PL_regex_pad[(o)->op_pmoffset]; sv_setiv(sv, PTR2IV(r)); } STMT_END
  278. #define PM_GETRE_SAFE(o) (PL_regex_pad ? PM_GETRE(o) : (REGEXP*)0)
  279. #define PM_SETRE_SAFE(o,r) if (PL_regex_pad) PM_SETRE(o,r)
  280. #else
  281. #define PM_GETRE(o)     ((o)->op_pmregexp)
  282. #define PM_SETRE(o,r)   ((o)->op_pmregexp = (r))
  283. #define PM_GETRE_SAFE PM_GETRE
  284. #define PM_SETRE_SAFE PM_SETRE
  285. #endif
  286.  
  287. #define PMdf_USED    0x01        /* pm has been used once already */
  288. #define PMdf_TAINTED    0x02        /* pm compiled from tainted pattern */
  289. #define PMdf_UTF8    0x04        /* pm compiled from utf8 data */
  290. #define PMdf_DYN_UTF8    0x08
  291.  
  292. #define PMdf_CMP_UTF8    (PMdf_UTF8|PMdf_DYN_UTF8)
  293.  
  294. #define PMf_RETAINT    0x0001        /* taint $1 etc. if target tainted */
  295. #define PMf_ONCE    0x0002        /* use pattern only once per reset */
  296. #define PMf_UNUSED    0x0004        /* free for use */
  297. #define PMf_MAYBE_CONST    0x0008        /* replacement contains variables */
  298. #define PMf_SKIPWHITE    0x0010        /* skip leading whitespace for split */
  299. #define PMf_WHITE    0x0020        /* pattern is \s+ */
  300. #define PMf_CONST    0x0040        /* subst replacement is constant */
  301. #define PMf_KEEP    0x0080        /* keep 1st runtime pattern forever */
  302. #define PMf_GLOBAL    0x0100        /* pattern had a g modifier */
  303. #define PMf_CONTINUE    0x0200        /* don't reset pos() if //g fails */
  304. #define PMf_EVAL    0x0400        /* evaluating replacement as expr */
  305. #define PMf_LOCALE    0x0800        /* use locale for character types */
  306. #define PMf_MULTILINE    0x1000        /* assume multiple lines */
  307. #define PMf_SINGLELINE    0x2000        /* assume single line */
  308. #define PMf_FOLD    0x4000        /* case insensitivity */
  309. #define PMf_EXTENDED    0x8000        /* chuck embedded whitespace */
  310.  
  311. /* mask of bits stored in regexp->reganch */
  312. #define PMf_COMPILETIME    (PMf_MULTILINE|PMf_SINGLELINE|PMf_LOCALE|PMf_FOLD|PMf_EXTENDED)
  313.  
  314. #ifdef USE_ITHREADS
  315.  
  316. #  define PmopSTASHPV(o)    ((o)->op_pmstashpv)
  317. #  define PmopSTASHPV_set(o,pv)    (PmopSTASHPV(o) = savesharedpv(pv))
  318. #  define PmopSTASH(o)        (PmopSTASHPV(o) \
  319.                  ? gv_stashpv(PmopSTASHPV(o),GV_ADD) : Nullhv)
  320. #  define PmopSTASH_set(o,hv)    PmopSTASHPV_set(o, ((hv) ? HvNAME(hv) : Nullch))
  321. #  define PmopSTASH_free(o)    PerlMemShared_free(PmopSTASHPV(o))
  322.  
  323. #else
  324. #  define PmopSTASH(o)        ((o)->op_pmstash)
  325. #  define PmopSTASH_set(o,hv)    ((o)->op_pmstash = (hv))
  326. #  define PmopSTASHPV(o)    (PmopSTASH(o) ? HvNAME(PmopSTASH(o)) : Nullch)
  327.    /* op_pmstash is not refcounted */
  328. #  define PmopSTASHPV_set(o,pv)    PmopSTASH_set((o), gv_stashpv(pv,GV_ADD))
  329. #  define PmopSTASH_free(o)    
  330. #endif
  331.  
  332. struct svop {
  333.     BASEOP
  334.     SV *    op_sv;
  335. };
  336.  
  337. struct padop {
  338.     BASEOP
  339.     PADOFFSET    op_padix;
  340. };
  341.  
  342. struct pvop {
  343.     BASEOP
  344.     char *    op_pv;
  345. };
  346.  
  347. struct loop {
  348.     BASEOP
  349.     OP *    op_first;
  350.     OP *    op_last;
  351.     OP *    op_redoop;
  352.     OP *    op_nextop;
  353.     OP *    op_lastop;
  354. };
  355.  
  356. #define cUNOPx(o)    ((UNOP*)o)
  357. #define cBINOPx(o)    ((BINOP*)o)
  358. #define cLISTOPx(o)    ((LISTOP*)o)
  359. #define cLOGOPx(o)    ((LOGOP*)o)
  360. #define cPMOPx(o)    ((PMOP*)o)
  361. #define cSVOPx(o)    ((SVOP*)o)
  362. #define cPADOPx(o)    ((PADOP*)o)
  363. #define cPVOPx(o)    ((PVOP*)o)
  364. #define cCOPx(o)    ((COP*)o)
  365. #define cLOOPx(o)    ((LOOP*)o)
  366.  
  367. #define cUNOP        cUNOPx(PL_op)
  368. #define cBINOP        cBINOPx(PL_op)
  369. #define cLISTOP        cLISTOPx(PL_op)
  370. #define cLOGOP        cLOGOPx(PL_op)
  371. #define cPMOP        cPMOPx(PL_op)
  372. #define cSVOP        cSVOPx(PL_op)
  373. #define cPADOP        cPADOPx(PL_op)
  374. #define cPVOP        cPVOPx(PL_op)
  375. #define cCOP        cCOPx(PL_op)
  376. #define cLOOP        cLOOPx(PL_op)
  377.  
  378. #define cUNOPo        cUNOPx(o)
  379. #define cBINOPo        cBINOPx(o)
  380. #define cLISTOPo    cLISTOPx(o)
  381. #define cLOGOPo        cLOGOPx(o)
  382. #define cPMOPo        cPMOPx(o)
  383. #define cSVOPo        cSVOPx(o)
  384. #define cPADOPo        cPADOPx(o)
  385. #define cPVOPo        cPVOPx(o)
  386. #define cCOPo        cCOPx(o)
  387. #define cLOOPo        cLOOPx(o)
  388.  
  389. #define kUNOP        cUNOPx(kid)
  390. #define kBINOP        cBINOPx(kid)
  391. #define kLISTOP        cLISTOPx(kid)
  392. #define kLOGOP        cLOGOPx(kid)
  393. #define kPMOP        cPMOPx(kid)
  394. #define kSVOP        cSVOPx(kid)
  395. #define kPADOP        cPADOPx(kid)
  396. #define kPVOP        cPVOPx(kid)
  397. #define kCOP        cCOPx(kid)
  398. #define kLOOP        cLOOPx(kid)
  399.  
  400.  
  401. #ifdef USE_ITHREADS
  402. #  define    cGVOPx_gv(o)    ((GV*)PAD_SVl(cPADOPx(o)->op_padix))
  403. #  define    IS_PADGV(v)    (v && SvTYPE(v) == SVt_PVGV && GvIN_PAD(v))
  404. #  define    IS_PADCONST(v)    (v && SvREADONLY(v))
  405. #  define    cSVOPx_sv(v)    (cSVOPx(v)->op_sv \
  406.                  ? cSVOPx(v)->op_sv : PAD_SVl((v)->op_targ))
  407. #  define    cSVOPx_svp(v)    (cSVOPx(v)->op_sv \
  408.                  ? &cSVOPx(v)->op_sv : &PAD_SVl((v)->op_targ))
  409. #else
  410. #  define    cGVOPx_gv(o)    ((GV*)cSVOPx(o)->op_sv)
  411. #  define    IS_PADGV(v)    FALSE
  412. #  define    IS_PADCONST(v)    FALSE
  413. #  define    cSVOPx_sv(v)    (cSVOPx(v)->op_sv)
  414. #  define    cSVOPx_svp(v)    (&cSVOPx(v)->op_sv)
  415. #endif
  416.  
  417. #define    cGVOP_gv        cGVOPx_gv(PL_op)
  418. #define    cGVOPo_gv        cGVOPx_gv(o)
  419. #define    kGVOP_gv        cGVOPx_gv(kid)
  420. #define cSVOP_sv        cSVOPx_sv(PL_op)
  421. #define cSVOPo_sv        cSVOPx_sv(o)
  422. #define kSVOP_sv        cSVOPx_sv(kid)
  423.  
  424. #define Nullop Null(OP*)
  425.  
  426. /* Lowest byte-and-a-bit of PL_opargs */
  427. #define OA_MARK 1
  428. #define OA_FOLDCONST 2
  429. #define OA_RETSCALAR 4
  430. #define OA_TARGET 8
  431. #define OA_RETINTEGER 16
  432. #define OA_OTHERINT 32
  433. #define OA_DANGEROUS 64
  434. #define OA_DEFGV 128
  435. #define OA_TARGLEX 256
  436.  
  437. /* The next 4 bits encode op class information */
  438. #define OCSHIFT 9
  439.  
  440. #define OA_CLASS_MASK (15 << OCSHIFT)
  441.  
  442. #define OA_BASEOP (0 << OCSHIFT)
  443. #define OA_UNOP (1 << OCSHIFT)
  444. #define OA_BINOP (2 << OCSHIFT)
  445. #define OA_LOGOP (3 << OCSHIFT)
  446. #define OA_LISTOP (4 << OCSHIFT)
  447. #define OA_PMOP (5 << OCSHIFT)
  448. #define OA_SVOP (6 << OCSHIFT)
  449. #define OA_PADOP (7 << OCSHIFT)
  450. #define OA_PVOP_OR_SVOP (8 << OCSHIFT)
  451. #define OA_LOOP (9 << OCSHIFT)
  452. #define OA_COP (10 << OCSHIFT)
  453. #define OA_BASEOP_OR_UNOP (11 << OCSHIFT)
  454. #define OA_FILESTATOP (12 << OCSHIFT)
  455. #define OA_LOOPEXOP (13 << OCSHIFT)
  456.  
  457. #define OASHIFT 13
  458.  
  459. /* Remaining nybbles of PL_opargs */
  460. #define OA_SCALAR 1
  461. #define OA_LIST 2
  462. #define OA_AVREF 3
  463. #define OA_HVREF 4
  464. #define OA_CVREF 5
  465. #define OA_FILEREF 6
  466. #define OA_SCALARREF 7
  467. #define OA_OPTIONAL 8
  468.  
  469. #ifdef USE_ITHREADS
  470. #  define OP_REFCNT_INIT        MUTEX_INIT(&PL_op_mutex)
  471. #  define OP_REFCNT_LOCK        MUTEX_LOCK(&PL_op_mutex)
  472. #  define OP_REFCNT_UNLOCK        MUTEX_UNLOCK(&PL_op_mutex)
  473. #  define OP_REFCNT_TERM        MUTEX_DESTROY(&PL_op_mutex)
  474. #else
  475. #  define OP_REFCNT_INIT        NOOP
  476. #  define OP_REFCNT_LOCK        NOOP
  477. #  define OP_REFCNT_UNLOCK        NOOP
  478. #  define OP_REFCNT_TERM        NOOP
  479. #endif
  480.  
  481. #define OpREFCNT_set(o,n)        ((o)->op_targ = (n))
  482. #define OpREFCNT_inc(o)            ((o) ? (++(o)->op_targ, (o)) : Nullop)
  483. #define OpREFCNT_dec(o)            (--(o)->op_targ)
  484.  
  485. /* flags used by Perl_load_module() */
  486. #define PERL_LOADMOD_DENY        0x1
  487. #define PERL_LOADMOD_NOIMPORT        0x2
  488. #define PERL_LOADMOD_IMPORT_OPS        0x4
  489.  
  490. #ifdef USE_REENTRANT_API
  491. #include "reentr.h"
  492. #endif
  493.  
  494. #if defined(PL_OP_SLAB_ALLOC)
  495. #define NewOp(m,var,c,type)    \
  496.     (var = (type *) Perl_Slab_Alloc(aTHX_ m,c*sizeof(type)))
  497. #define NewOpSz(m,var,size)    \
  498.     (var = (OP *) Perl_Slab_Alloc(aTHX_ m,size))
  499. #define FreeOp(p) Perl_Slab_Free(aTHX_ p)
  500. #else
  501. #define NewOp(m, var, c, type) Newz(m, var, c, type)
  502. #define NewOpSz(m, var, size)    \
  503.     (var = (OP*)safemalloc(size), memzero(var, size))
  504. #define FreeOp(p) Safefree(p)
  505. #endif
  506.