home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / perl560.zip / op.h < prev    next >
C/C++ Source or Header  |  2000-03-18  |  13KB  |  435 lines
  1. /*    op.h
  2.  *
  3.  *    Copyright (c) 1991-2000, Larry Wall
  4.  *
  5.  *    You may distribute under the terms of either the GNU General Public
  6.  *    License or the Artistic License, as specified in the README file.
  7.  *
  8.  */
  9.  
  10. /*
  11.  * The fields of BASEOP are:
  12.  *    op_next        Pointer to next ppcode to execute after this one.
  13.  *            (Top level pre-grafted op points to first op,
  14.  *            but this is replaced when op is grafted in, when
  15.  *            this op will point to the real next op, and the new
  16.  *            parent takes over role of remembering starting op.)
  17.  *    op_ppaddr    Pointer to current ppcode's function.
  18.  *    op_type        The type of the operation.
  19.  *    op_flags    Flags common to all operations.  See OPf_* below.
  20.  *    op_private    Flags peculiar to a particular operation (BUT,
  21.  *            by default, set to the number of children until
  22.  *            the operation is privatized by a check routine,
  23.  *            which may or may not check number of children).
  24.  */
  25.  
  26. typedef U32 PADOFFSET;
  27. #define NOT_IN_PAD ((PADOFFSET) -1)
  28.  
  29. #ifdef DEBUGGING_OPS
  30. #define OPCODE opcode
  31. #else
  32. #define OPCODE U16
  33. #endif
  34.  
  35. #ifdef BASEOP_DEFINITION
  36. #define BASEOP BASEOP_DEFINITION
  37. #else
  38. #define BASEOP                \
  39.     OP*        op_next;        \
  40.     OP*        op_sibling;        \
  41.     OP*        (CPERLscope(*op_ppaddr))(pTHX);        \
  42.     PADOFFSET    op_targ;        \
  43.     OPCODE    op_type;        \
  44.     U16        op_seq;            \
  45.     U8        op_flags;        \
  46.     U8        op_private;
  47. #endif
  48.  
  49. #define OP_GIMME(op,dfl) \
  50.     (((op)->op_flags & OPf_WANT) == OPf_WANT_VOID   ? G_VOID   : \
  51.      ((op)->op_flags & OPf_WANT) == OPf_WANT_SCALAR ? G_SCALAR : \
  52.      ((op)->op_flags & OPf_WANT) == OPf_WANT_LIST   ? G_ARRAY   : \
  53.      dfl)
  54.  
  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 array 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.  
  99. /* old names; don't use in new code, but don't break them, either */
  100. #define OPf_LIST    OPf_WANT_LIST
  101. #define OPf_KNOW    OPf_WANT
  102.  
  103. #define GIMME \
  104.       (PL_op->op_flags & OPf_WANT                    \
  105.        ? ((PL_op->op_flags & OPf_WANT) == OPf_WANT_LIST        \
  106.           ? G_ARRAY                            \
  107.           : G_SCALAR)                        \
  108.        : dowantarray())
  109.  
  110. /* NOTE: OP_NEXTSTATE, OP_DBSTATE, and OP_SETSTATE (i.e. COPs) carry lower
  111.  * bits of PL_hints in op_private */
  112.  
  113. /* Private for lvalues */
  114. #define OPpLVAL_INTRO    128    /* Lvalue must be localized or lvalue sub */
  115.  
  116. /* Private for OP_LEAVE, OP_LEAVESUB, OP_LEAVESUBLV and OP_LEAVEWRITE */
  117. #define OPpREFCOUNTED        64    /* op_targ carries a refcount */
  118.  
  119. /* Private for OP_AASSIGN */
  120. #define OPpASSIGN_COMMON    64    /* Left & right have syms in common. */
  121. #define OPpASSIGN_HASH        32    /* Assigning to possible pseudohash. */
  122.  
  123. /* Private for OP_SASSIGN */
  124. #define OPpASSIGN_BACKWARDS    64    /* Left & right switched. */
  125.  
  126. /* Private for OP_MATCH and OP_SUBST{,CONST} */
  127. #define OPpRUNTIME        64    /* Pattern coming in on the stack */
  128.  
  129. /* Private for OP_TRANS */
  130. #define OPpTRANS_FROM_UTF    1
  131. #define OPpTRANS_TO_UTF        2
  132. #define OPpTRANS_IDENTICAL    4
  133.     /* When CU or UC, means straight latin-1 to utf-8 or vice versa */
  134.     /* Otherwise, IDENTICAL means the right side is the same as the left */
  135. #define OPpTRANS_SQUASH        8
  136. #define OPpTRANS_DELETE        16
  137. #define OPpTRANS_COMPLEMENT    32
  138. #define OPpTRANS_GROWS        64
  139.  
  140. /* Private for OP_REPEAT */
  141. #define OPpREPEAT_DOLIST    64    /* List replication. */
  142.  
  143. /* Private for OP_LEAVELOOP */
  144. #define OPpLOOP_CONTINUE    64    /* a continue block is present */
  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.   /* OP_RV2CV only */
  155. #define OPpENTERSUB_AMPER    8    /* Used & form to call. */
  156. #define OPpENTERSUB_NOPAREN    128    /* bare sub call (without parens) */
  157. #define OPpENTERSUB_INARGS    4    /* Lval used as arg to a sub. */
  158.   /* OP_GV only */
  159. #define OPpEARLY_CV        32    /* foo() called before sub foo was parsed */
  160.   /* OP_?ELEM only */
  161. #define OPpLVAL_DEFER        16    /* Defer creation of array/hash elem */
  162.   /* OP_RV2?V, OP_GVSV only */
  163. #define OPpOUR_INTRO        16    /* Defer creation of array/hash elem */
  164.   /* for OP_RV2?V, lower bits carry hints (currently only HINT_STRICT_REFS) */
  165.  
  166. /* Private for OPs with TARGLEX */
  167.   /* (lower bits may carry MAXARG) */
  168. #define OPpTARGET_MY        16    /* Target is PADMY. */
  169.  
  170. /* Private for OP_CONST */
  171. #define    OPpCONST_STRICT        8    /* bearword subject to strict 'subs' */
  172. #define OPpCONST_ENTERED    16    /* Has been entered as symbol. */
  173. #define OPpCONST_ARYBASE    32    /* Was a $[ translated to constant. */
  174. #define OPpCONST_BARE        64    /* Was a bare word (filehandle?). */
  175. #define OPpCONST_WARNING    128    /* Was a $^W translated to constant. */
  176.  
  177. /* Private for OP_FLIP/FLOP */
  178. #define OPpFLIP_LINENUM        64    /* Range arg potentially a line num. */
  179.  
  180. /* Private for OP_LIST */
  181. #define OPpLIST_GUESSED        64    /* Guessed that pushmark was needed. */
  182.  
  183. /* Private for OP_DELETE */
  184. #define OPpSLICE        64    /* Operating on a list of keys */
  185.  
  186. /* Private for OP_EXISTS */
  187. #define OPpEXISTS_SUB        64    /* Checking for &sub, not {} or [].  */
  188.  
  189. /* Private for OP_SORT, OP_PRTF, OP_SPRINTF, OP_FTTEXT, OP_FTBINARY, */
  190. /*             string comparisons, and case changers. */
  191. #define OPpLOCALE        64    /* Use locale */
  192.  
  193. /* Private for OP_SORT */
  194. #define OPpSORT_NUMERIC        1    /* Optimized away { $a <=> $b } */
  195. #define OPpSORT_INTEGER        2    /* Ditto while under "use integer" */
  196. #define OPpSORT_REVERSE        4    /* Descending sort */
  197. /* Private for OP_THREADSV */
  198. #define OPpDONE_SVREF        64    /* Been through newSVREF once */
  199.  
  200. /* Private for OP_OPEN and OP_BACKTICK */
  201. #define OPpOPEN_IN_RAW        16    /* binmode(F,":raw") on input fh */
  202. #define OPpOPEN_IN_CRLF        32    /* binmode(F,":crlf") on input fh */
  203. #define OPpOPEN_OUT_RAW        64    /* binmode(F,":raw") on output fh */
  204. #define OPpOPEN_OUT_CRLF    128    /* binmode(F,":crlf") on output fh */
  205.  
  206. /* Private for OP_EXIT */
  207. #define OPpEXIT_VMSISH        128    /* exit(0) vs. exit(1) vmsish mode*/
  208.  
  209. struct op {
  210.     BASEOP
  211. };
  212.  
  213. struct unop {
  214.     BASEOP
  215.     OP *    op_first;
  216. };
  217.  
  218. struct binop {
  219.     BASEOP
  220.     OP *    op_first;
  221.     OP *    op_last;
  222. };
  223.  
  224. struct logop {
  225.     BASEOP
  226.     OP *    op_first;
  227.     OP *    op_other;
  228. };
  229.  
  230. struct listop {
  231.     BASEOP
  232.     OP *    op_first;
  233.     OP *    op_last;
  234.     U32        op_children;
  235. };
  236.  
  237. struct pmop {
  238.     BASEOP
  239.     OP *    op_first;
  240.     OP *    op_last;
  241.     U32        op_children;
  242.     OP *    op_pmreplroot;
  243.     OP *    op_pmreplstart;
  244.     PMOP *    op_pmnext;        /* list of all scanpats */
  245.     REGEXP *    op_pmregexp;        /* compiled expression */
  246.     U16        op_pmflags;
  247.     U16        op_pmpermflags;
  248.     U8        op_pmdynflags;
  249. };
  250.  
  251. #define PMdf_USED    0x01        /* pm has been used once already */
  252. #define PMdf_TAINTED    0x02        /* pm compiled from tainted pattern */
  253. #define PMdf_UTF8    0x04        /* pm compiled from utf8 data */
  254.  
  255. #define PMf_RETAINT    0x0001        /* taint $1 etc. if target tainted */
  256. #define PMf_ONCE    0x0002        /* use pattern only once per reset */
  257. #define PMf_REVERSED    0x0004        /* Should be matched right->left */
  258. #define PMf_MAYBE_CONST    0x0008        /* replacement contains variables */
  259. #define PMf_SKIPWHITE    0x0010        /* skip leading whitespace for split */
  260. #define PMf_WHITE    0x0020        /* pattern is \s+ */
  261. #define PMf_CONST    0x0040        /* subst replacement is constant */
  262. #define PMf_KEEP    0x0080        /* keep 1st runtime pattern forever */
  263. #define PMf_GLOBAL    0x0100        /* pattern had a g modifier */
  264. #define PMf_CONTINUE    0x0200        /* don't reset pos() if //g fails */
  265. #define PMf_EVAL    0x0400        /* evaluating replacement as expr */
  266. #define PMf_LOCALE    0x0800        /* use locale for character types */
  267. #define PMf_MULTILINE    0x1000        /* assume multiple lines */
  268. #define PMf_SINGLELINE    0x2000        /* assume single line */
  269. #define PMf_FOLD    0x4000        /* case insensitivity */
  270. #define PMf_EXTENDED    0x8000        /* chuck embedded whitespace */
  271.  
  272. /* mask of bits stored in regexp->reganch */
  273. #define PMf_COMPILETIME    (PMf_MULTILINE|PMf_SINGLELINE|PMf_LOCALE|PMf_FOLD|PMf_EXTENDED)
  274.  
  275. struct svop {
  276.     BASEOP
  277.     SV *    op_sv;
  278. };
  279.  
  280. struct padop {
  281.     BASEOP
  282.     PADOFFSET    op_padix;
  283. };
  284.  
  285. struct pvop {
  286.     BASEOP
  287.     char *    op_pv;
  288. };
  289.  
  290. struct loop {
  291.     BASEOP
  292.     OP *    op_first;
  293.     OP *    op_last;
  294.     U32        op_children;
  295.     OP *    op_redoop;
  296.     OP *    op_nextop;
  297.     OP *    op_lastop;
  298. };
  299.  
  300. #define cUNOPx(o)    ((UNOP*)o)
  301. #define cBINOPx(o)    ((BINOP*)o)
  302. #define cLISTOPx(o)    ((LISTOP*)o)
  303. #define cLOGOPx(o)    ((LOGOP*)o)
  304. #define cPMOPx(o)    ((PMOP*)o)
  305. #define cSVOPx(o)    ((SVOP*)o)
  306. #define cPADOPx(o)    ((PADOP*)o)
  307. #define cPVOPx(o)    ((PVOP*)o)
  308. #define cCOPx(o)    ((COP*)o)
  309. #define cLOOPx(o)    ((LOOP*)o)
  310.  
  311. #define cUNOP        cUNOPx(PL_op)
  312. #define cBINOP        cBINOPx(PL_op)
  313. #define cLISTOP        cLISTOPx(PL_op)
  314. #define cLOGOP        cLOGOPx(PL_op)
  315. #define cPMOP        cPMOPx(PL_op)
  316. #define cSVOP        cSVOPx(PL_op)
  317. #define cPADOP        cPADOPx(PL_op)
  318. #define cPVOP        cPVOPx(PL_op)
  319. #define cCOP        cCOPx(PL_op)
  320. #define cLOOP        cLOOPx(PL_op)
  321.  
  322. #define cUNOPo        cUNOPx(o)
  323. #define cBINOPo        cBINOPx(o)
  324. #define cLISTOPo    cLISTOPx(o)
  325. #define cLOGOPo        cLOGOPx(o)
  326. #define cPMOPo        cPMOPx(o)
  327. #define cSVOPo        cSVOPx(o)
  328. #define cPADOPo        cPADOPx(o)
  329. #define cPVOPo        cPVOPx(o)
  330. #define cCOPo        cCOPx(o)
  331. #define cLOOPo        cLOOPx(o)
  332.  
  333. #define kUNOP        cUNOPx(kid)
  334. #define kBINOP        cBINOPx(kid)
  335. #define kLISTOP        cLISTOPx(kid)
  336. #define kLOGOP        cLOGOPx(kid)
  337. #define kPMOP        cPMOPx(kid)
  338. #define kSVOP        cSVOPx(kid)
  339. #define kPADOP        cPADOPx(kid)
  340. #define kPVOP        cPVOPx(kid)
  341. #define kCOP        cCOPx(kid)
  342. #define kLOOP        cLOOPx(kid)
  343.  
  344.  
  345. #ifdef USE_ITHREADS
  346. #  define    cGVOPx_gv(o)    ((GV*)PL_curpad[cPADOPx(o)->op_padix])
  347. #  define    IS_PADGV(v)    (v && SvTYPE(v) == SVt_PVGV && GvIN_PAD(v))
  348. #  define    IS_PADCONST(v)    (v && SvREADONLY(v))
  349. #  define    cSVOPx_sv(v)    (cSVOPx(v)->op_sv \
  350.                  ? cSVOPx(v)->op_sv : PL_curpad[(v)->op_targ])
  351. #  define    cSVOPx_svp(v)    (cSVOPx(v)->op_sv \
  352.                  ? &cSVOPx(v)->op_sv : &PL_curpad[(v)->op_targ])
  353. #else
  354. #  define    cGVOPx_gv(o)    ((GV*)cSVOPx(o)->op_sv)
  355. #  define    IS_PADGV(v)    FALSE
  356. #  define    IS_PADCONST(v)    FALSE
  357. #  define    cSVOPx_sv(v)    (cSVOPx(v)->op_sv)
  358. #  define    cSVOPx_svp(v)    (&cSVOPx(v)->op_sv)
  359. #endif
  360.  
  361. #define    cGVOP_gv        cGVOPx_gv(PL_op)
  362. #define    cGVOPo_gv        cGVOPx_gv(o)
  363. #define    kGVOP_gv        cGVOPx_gv(kid)
  364. #define cSVOP_sv        cSVOPx_sv(PL_op)
  365. #define cSVOPo_sv        cSVOPx_sv(o)
  366. #define kSVOP_sv        cSVOPx_sv(kid)
  367.  
  368. #define Nullop Null(OP*)
  369.  
  370. /* Lowest byte of PL_opargs */
  371. #define OA_MARK 1
  372. #define OA_FOLDCONST 2
  373. #define OA_RETSCALAR 4
  374. #define OA_TARGET 8
  375. #define OA_RETINTEGER 16
  376. #define OA_OTHERINT 32
  377. #define OA_DANGEROUS 64
  378. #define OA_DEFGV 128
  379. #define OA_TARGLEX 256
  380.  
  381. /* The next 4 bits encode op class information */
  382. #define OCSHIFT 9
  383.  
  384. #define OA_CLASS_MASK (15 << OCSHIFT)
  385.  
  386. #define OA_BASEOP (0 << OCSHIFT)
  387. #define OA_UNOP (1 << OCSHIFT)
  388. #define OA_BINOP (2 << OCSHIFT)
  389. #define OA_LOGOP (3 << OCSHIFT)
  390. #define OA_LISTOP (4 << OCSHIFT)
  391. #define OA_PMOP (5 << OCSHIFT)
  392. #define OA_SVOP (6 << OCSHIFT)
  393. #define OA_PADOP (7 << OCSHIFT)
  394. #define OA_PVOP_OR_SVOP (8 << OCSHIFT)
  395. #define OA_LOOP (9 << OCSHIFT)
  396. #define OA_COP (10 << OCSHIFT)
  397. #define OA_BASEOP_OR_UNOP (11 << OCSHIFT)
  398. #define OA_FILESTATOP (12 << OCSHIFT)
  399. #define OA_LOOPEXOP (13 << OCSHIFT)
  400.  
  401. #define OASHIFT 13
  402.  
  403. /* Remaining nybbles of PL_opargs */
  404. #define OA_SCALAR 1
  405. #define OA_LIST 2
  406. #define OA_AVREF 3
  407. #define OA_HVREF 4
  408. #define OA_CVREF 5
  409. #define OA_FILEREF 6
  410. #define OA_SCALARREF 7
  411. #define OA_OPTIONAL 8
  412.  
  413. #ifdef USE_ITHREADS
  414. #  define OP_REFCNT_INIT        MUTEX_INIT(&PL_op_mutex)
  415. #  define OP_REFCNT_LOCK        MUTEX_LOCK(&PL_op_mutex)
  416. #  define OP_REFCNT_UNLOCK        MUTEX_UNLOCK(&PL_op_mutex)
  417. #  define OP_REFCNT_TERM        MUTEX_DESTROY(&PL_op_mutex)
  418. #  define OpREFCNT_set(o,n)        ((o)->op_targ = (n))
  419. #  define OpREFCNT_inc(o)        ((o) ? (++(o)->op_targ, (o)) : Nullop)
  420. #  define OpREFCNT_dec(o)        (--(o)->op_targ)
  421. #else
  422. #  define OP_REFCNT_INIT        NOOP
  423. #  define OP_REFCNT_LOCK        NOOP
  424. #  define OP_REFCNT_UNLOCK        NOOP
  425. #  define OP_REFCNT_TERM        NOOP
  426. #  define OpREFCNT_set(o,n)        NOOP
  427. #  define OpREFCNT_inc(o)        (o)
  428. #  define OpREFCNT_dec(o)        0
  429. #endif
  430.  
  431. /* flags used by Perl_load_module() */
  432. #define PERL_LOADMOD_DENY        0x1
  433. #define PERL_LOADMOD_NOIMPORT        0x2
  434. #define PERL_LOADMOD_IMPORT_OPS        0x4
  435.