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