home *** CD-ROM | disk | FTP | other *** search
/ Chip: Windows 2000 Professional Resource Kit / W2KPRK.iso / apps / perl / ActivePerl.exe / data.z / cop.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-14  |  11.3 KB  |  379 lines
  1. /*    cop.h
  2.  *
  3.  *    Copyright (c) 1991-1999, 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. struct cop {
  11.     BASEOP
  12.     char *    cop_label;    /* label for this construct */
  13.     HV *    cop_stash;    /* package line was compiled in */
  14.     GV *    cop_filegv;    /* file the following line # is from */
  15.     U32        cop_seq;    /* parse sequence number */
  16.     I32        cop_arybase;    /* array base this line was compiled with */
  17.     line_t      cop_line;       /* line # of this command */
  18. };
  19.  
  20. #define Nullcop Null(COP*)
  21.  
  22. /*
  23.  * Here we have some enormously heavy (or at least ponderous) wizardry.
  24.  */
  25.  
  26. /* subroutine context */
  27. struct block_sub {
  28.     CV *    cv;
  29.     GV *    gv;
  30.     GV *    dfoutgv;
  31. #ifndef USE_THREADS
  32.     AV *    savearray;
  33. #endif /* USE_THREADS */
  34.     AV *    argarray;
  35.     U16        olddepth;
  36.     U8        hasargs;
  37. };
  38.  
  39. #define PUSHSUB(cx)                            \
  40.     cx->blk_sub.cv = cv;                        \
  41.     cx->blk_sub.olddepth = CvDEPTH(cv);                \
  42.     cx->blk_sub.hasargs = hasargs;
  43.  
  44. #define PUSHFORMAT(cx)                            \
  45.     cx->blk_sub.cv = cv;                        \
  46.     cx->blk_sub.gv = gv;                        \
  47.     cx->blk_sub.hasargs = 0;                    \
  48.     cx->blk_sub.dfoutgv = PL_defoutgv;                \
  49.     (void)SvREFCNT_inc(cx->blk_sub.dfoutgv)
  50.  
  51. #define POPSUB(cx)                            \
  52.     { struct block_sub cxsub;                    \
  53.       POPSUB1(cx);                            \
  54.       POPSUB2(); }
  55.  
  56. #define POPSUB1(cx)                            \
  57.     cxsub = cx->blk_sub;    /* because DESTROY may clobber *cx */
  58.  
  59. #ifdef USE_THREADS
  60. #define POPSAVEARRAY() NOOP
  61. #else
  62. #define POPSAVEARRAY()                            \
  63.     STMT_START {                            \
  64.     SvREFCNT_dec(GvAV(PL_defgv));                    \
  65.     GvAV(PL_defgv) = cxsub.savearray;                    \
  66.     } STMT_END
  67. #endif /* USE_THREADS */
  68.  
  69. #define POPSUB2()                            \
  70.     if (cxsub.hasargs) {                        \
  71.         POPSAVEARRAY();                        \
  72.         /* destroy arg array */                    \
  73.         av_clear(cxsub.argarray);                    \
  74.         AvREAL_off(cxsub.argarray);                    \
  75.         AvREIFY_on(cxsub.argarray);                    \
  76.     }                                \
  77.     if (cxsub.cv) {                            \
  78.         if (!(CvDEPTH(cxsub.cv) = cxsub.olddepth))            \
  79.         SvREFCNT_dec(cxsub.cv);                    \
  80.     }
  81.  
  82. #define POPFORMAT(cx)                            \
  83.     setdefout(cx->blk_sub.dfoutgv);                    \
  84.     SvREFCNT_dec(cx->blk_sub.dfoutgv);
  85.  
  86. /* eval context */
  87. struct block_eval {
  88.     I32        old_in_eval;
  89.     I32        old_op_type;
  90.     char *    old_name;
  91.     OP *    old_eval_root;
  92.     SV *    cur_text;
  93. };
  94.  
  95. #define PUSHEVAL(cx,n,fgv)                        \
  96.     cx->blk_eval.old_in_eval = PL_in_eval;                \
  97.     cx->blk_eval.old_op_type = PL_op->op_type;                \
  98.     cx->blk_eval.old_name = n;                    \
  99.     cx->blk_eval.old_eval_root = PL_eval_root;                \
  100.     cx->blk_eval.cur_text = PL_linestr;
  101.  
  102. #define POPEVAL(cx)                            \
  103.     PL_in_eval = cx->blk_eval.old_in_eval;                \
  104.     optype = cx->blk_eval.old_op_type;                \
  105.     PL_eval_root = cx->blk_eval.old_eval_root;
  106.  
  107. /* loop context */
  108. struct block_loop {
  109.     char *    label;
  110.     I32        resetsp;
  111.     OP *    redo_op;
  112.     OP *    next_op;
  113.     OP *    last_op;
  114.     SV **    itervar;
  115.     SV *    itersave;
  116.     SV *    iterlval;
  117.     AV *    iterary;
  118.     IV        iterix;
  119.     IV        itermax;
  120. };
  121.  
  122. #define PUSHLOOP(cx, ivar, s)                        \
  123.     cx->blk_loop.label = PL_curcop->cop_label;                \
  124.     cx->blk_loop.resetsp = s - PL_stack_base;                \
  125.     cx->blk_loop.redo_op = cLOOP->op_redoop;            \
  126.     cx->blk_loop.next_op = cLOOP->op_nextop;            \
  127.     cx->blk_loop.last_op = cLOOP->op_lastop;            \
  128.     if (cx->blk_loop.itervar = (ivar))                \
  129.         cx->blk_loop.itersave = SvREFCNT_inc(*cx->blk_loop.itervar);\
  130.     cx->blk_loop.iterlval = Nullsv;                    \
  131.     cx->blk_loop.iterary = Nullav;                    \
  132.     cx->blk_loop.iterix = -1;
  133.  
  134. #define POPLOOP(cx)                            \
  135.     { struct block_loop cxloop;                    \
  136.       POPLOOP1(cx);                            \
  137.       POPLOOP2(); }
  138.  
  139. #define POPLOOP1(cx)                            \
  140.     cxloop = cx->blk_loop;    /* because DESTROY may clobber *cx */    \
  141.     newsp = PL_stack_base + cxloop.resetsp;
  142.  
  143. #define POPLOOP2()                            \
  144.     SvREFCNT_dec(cxloop.iterlval);                    \
  145.     if (cxloop.itervar) {                        \
  146.         sv_2mortal(*cxloop.itervar);                \
  147.         *cxloop.itervar = cxloop.itersave;                \
  148.     }                                \
  149.     if (cxloop.iterary && cxloop.iterary != PL_curstack)        \
  150.         SvREFCNT_dec(cxloop.iterary);
  151.  
  152. /* context common to subroutines, evals and loops */
  153. struct block {
  154.     I32        blku_oldsp;    /* stack pointer to copy stuff down to */
  155.     COP *    blku_oldcop;    /* old curcop pointer */
  156.     I32        blku_oldretsp;    /* return stack index */
  157.     I32        blku_oldmarksp;    /* mark stack index */
  158.     I32        blku_oldscopesp;    /* scope stack index */
  159.     PMOP *    blku_oldpm;    /* values of pattern match vars */
  160.     U8        blku_gimme;    /* is this block running in list context? */
  161.  
  162.     union {
  163.     struct block_sub    blku_sub;
  164.     struct block_eval    blku_eval;
  165.     struct block_loop    blku_loop;
  166.     } blk_u;
  167. };
  168. #define blk_oldsp    cx_u.cx_blk.blku_oldsp
  169. #define blk_oldcop    cx_u.cx_blk.blku_oldcop
  170. #define blk_oldretsp    cx_u.cx_blk.blku_oldretsp
  171. #define blk_oldmarksp    cx_u.cx_blk.blku_oldmarksp
  172. #define blk_oldscopesp    cx_u.cx_blk.blku_oldscopesp
  173. #define blk_oldpm    cx_u.cx_blk.blku_oldpm
  174. #define blk_gimme    cx_u.cx_blk.blku_gimme
  175. #define blk_sub        cx_u.cx_blk.blk_u.blku_sub
  176. #define blk_eval    cx_u.cx_blk.blk_u.blku_eval
  177. #define blk_loop    cx_u.cx_blk.blk_u.blku_loop
  178.  
  179. /* Enter a block. */
  180. #define PUSHBLOCK(cx,t,sp) CXINC, cx = &cxstack[cxstack_ix],        \
  181.     cx->cx_type        = t,                    \
  182.     cx->blk_oldsp        = sp - PL_stack_base,            \
  183.     cx->blk_oldcop        = PL_curcop,                \
  184.     cx->blk_oldmarksp    = PL_markstack_ptr - PL_markstack,    \
  185.     cx->blk_oldscopesp    = PL_scopestack_ix,            \
  186.     cx->blk_oldretsp    = PL_retstack_ix,            \
  187.     cx->blk_oldpm        = PL_curpm,                \
  188.     cx->blk_gimme        = gimme;                \
  189.     DEBUG_l( PerlIO_printf(PerlIO_stderr(), "Entering block %ld, type %s\n",    \
  190.             (long)cxstack_ix, block_type[CxTYPE(cx)]); )
  191.  
  192. /* Exit a block (RETURN and LAST). */
  193. #define POPBLOCK(cx,pm) cx = &cxstack[cxstack_ix--],            \
  194.     newsp         = PL_stack_base + cx->blk_oldsp,        \
  195.     PL_curcop     = cx->blk_oldcop,                \
  196.     PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp,        \
  197.     PL_scopestack_ix = cx->blk_oldscopesp,                \
  198.     PL_retstack_ix     = cx->blk_oldretsp,                \
  199.     pm         = cx->blk_oldpm,                \
  200.     gimme         = cx->blk_gimme;                \
  201.     DEBUG_l( PerlIO_printf(PerlIO_stderr(), "Leaving block %ld, type %s\n",        \
  202.             (long)cxstack_ix+1,block_type[CxTYPE(cx)]); )
  203.  
  204. /* Continue a block elsewhere (NEXT and REDO). */
  205. #define TOPBLOCK(cx) cx  = &cxstack[cxstack_ix],            \
  206.     PL_stack_sp     = PL_stack_base + cx->blk_oldsp,        \
  207.     PL_markstack_ptr = PL_markstack + cx->blk_oldmarksp,        \
  208.     PL_scopestack_ix = cx->blk_oldscopesp,                \
  209.     PL_retstack_ix     = cx->blk_oldretsp,                \
  210.     PL_curpm         = cx->blk_oldpm
  211.  
  212. /* substitution context */
  213. struct subst {
  214.     I32        sbu_iters;
  215.     I32        sbu_maxiters;
  216.     I32        sbu_safebase;
  217.     I32        sbu_oldsave;
  218.     bool    sbu_once;
  219.     bool    sbu_rxtainted;
  220.     char *    sbu_orig;
  221.     SV *    sbu_dstr;
  222.     SV *    sbu_targ;
  223.     char *    sbu_s;
  224.     char *    sbu_m;
  225.     char *    sbu_strend;
  226.     void *    sbu_rxres;
  227.     REGEXP *    sbu_rx;
  228. };
  229. #define sb_iters    cx_u.cx_subst.sbu_iters
  230. #define sb_maxiters    cx_u.cx_subst.sbu_maxiters
  231. #define sb_safebase    cx_u.cx_subst.sbu_safebase
  232. #define sb_oldsave    cx_u.cx_subst.sbu_oldsave
  233. #define sb_once        cx_u.cx_subst.sbu_once
  234. #define sb_rxtainted    cx_u.cx_subst.sbu_rxtainted
  235. #define sb_orig        cx_u.cx_subst.sbu_orig
  236. #define sb_dstr        cx_u.cx_subst.sbu_dstr
  237. #define sb_targ        cx_u.cx_subst.sbu_targ
  238. #define sb_s        cx_u.cx_subst.sbu_s
  239. #define sb_m        cx_u.cx_subst.sbu_m
  240. #define sb_strend    cx_u.cx_subst.sbu_strend
  241. #define sb_rxres    cx_u.cx_subst.sbu_rxres
  242. #define sb_rx        cx_u.cx_subst.sbu_rx
  243.  
  244. #define PUSHSUBST(cx) CXINC, cx = &cxstack[cxstack_ix],            \
  245.     cx->sb_iters        = iters,                \
  246.     cx->sb_maxiters        = maxiters,                \
  247.     cx->sb_safebase        = safebase,                \
  248.     cx->sb_oldsave        = oldsave,                \
  249.     cx->sb_once        = once,                    \
  250.     cx->sb_rxtainted    = rxtainted,                \
  251.     cx->sb_orig        = orig,                    \
  252.     cx->sb_dstr        = dstr,                    \
  253.     cx->sb_targ        = targ,                    \
  254.     cx->sb_s        = s,                    \
  255.     cx->sb_m        = m,                    \
  256.     cx->sb_strend        = strend,                \
  257.     cx->sb_rxres        = Null(void*),                \
  258.     cx->sb_rx        = rx,                    \
  259.     cx->cx_type        = CXt_SUBST;                \
  260.     rxres_save(&cx->sb_rxres, rx)
  261.  
  262. #define POPSUBST(cx) cx = &cxstack[cxstack_ix--];            \
  263.     rxres_free(&cx->sb_rxres)
  264.  
  265. struct context {
  266.     U32        cx_type;    /* what kind of context this is */
  267.     union {
  268.     struct block    cx_blk;
  269.     struct subst    cx_subst;
  270.     } cx_u;
  271. };
  272.  
  273. #define CXTYPEMASK    0xff
  274. #define CXt_NULL    0
  275. #define CXt_SUB        1
  276. #define CXt_EVAL    2
  277. #define CXt_LOOP    3
  278. #define CXt_SUBST    4
  279. #define CXt_BLOCK    5
  280.  
  281. /* private flags for CXt_EVAL */
  282. #define CXp_REAL    0x00000100    /* truly eval'', not a lookalike */
  283.  
  284. #define CxTYPE(c)    ((c)->cx_type & CXTYPEMASK)
  285. #define CxREALEVAL(c)    (((c)->cx_type & (CXt_EVAL|CXp_REAL)) == (CXt_EVAL|CXp_REAL))
  286.  
  287. #define CXINC (cxstack_ix < cxstack_max ? ++cxstack_ix : (cxstack_ix = cxinc()))
  288.  
  289. /* "gimme" values */
  290. #define G_SCALAR    0
  291. #define G_ARRAY        1
  292. #define G_VOID        128    /* skip this bit when adding flags below */
  293.  
  294. /* extra flags for perl_call_* routines */
  295. #define G_DISCARD    2    /* Call FREETMPS. */
  296. #define G_EVAL        4    /* Assume eval {} around subroutine call. */
  297. #define G_NOARGS    8    /* Don't construct a @_ array. */
  298. #define G_KEEPERR      16    /* Append errors to $@, don't overwrite it */
  299. #define G_NODEBUG      32    /* Disable debugging at toplevel.  */
  300.  
  301. /* Support for switching (stack and block) contexts.
  302.  * This ensures magic doesn't invalidate local stack and cx pointers.
  303.  */
  304.  
  305. #define PERLSI_UNKNOWN        -1
  306. #define PERLSI_UNDEF        0
  307. #define PERLSI_MAIN        1
  308. #define PERLSI_MAGIC        2
  309. #define PERLSI_SORT        3
  310. #define PERLSI_SIGNAL        4
  311. #define PERLSI_OVERLOAD        5
  312. #define PERLSI_DESTROY        6
  313. #define PERLSI_WARNHOOK        7
  314. #define PERLSI_DIEHOOK        8
  315. #define PERLSI_REQUIRE        9
  316.  
  317. struct stackinfo {
  318.     AV *        si_stack;    /* stack for current runlevel */
  319.     PERL_CONTEXT *    si_cxstack;    /* context stack for runlevel */
  320.     I32            si_cxix;    /* current context index */
  321.     I32            si_cxmax;    /* maximum allocated index */
  322.     I32            si_type;    /* type of runlevel */
  323.     struct stackinfo *    si_prev;
  324.     struct stackinfo *    si_next;
  325.     I32 *        si_markbase;    /* where markstack begins for us.
  326.                      * currently used only with DEBUGGING,
  327.                      * but not #ifdef-ed for bincompat */
  328. };
  329.  
  330. typedef struct stackinfo PERL_SI;
  331.  
  332. #define cxstack        (PL_curstackinfo->si_cxstack)
  333. #define cxstack_ix    (PL_curstackinfo->si_cxix)
  334. #define cxstack_max    (PL_curstackinfo->si_cxmax)
  335.  
  336. #ifdef DEBUGGING
  337. #  define    SET_MARKBASE PL_curstackinfo->si_markbase = PL_markstack_ptr
  338. #else
  339. #  define    SET_MARKBASE NOOP
  340. #endif
  341.  
  342. #define PUSHSTACKi(type) \
  343.     STMT_START {                            \
  344.     PERL_SI *next = PL_curstackinfo->si_next;            \
  345.     if (!next) {                            \
  346.         next = new_stackinfo(32, 2048/sizeof(PERL_CONTEXT) - 1);    \
  347.         next->si_prev = PL_curstackinfo;                \
  348.         PL_curstackinfo->si_next = next;                \
  349.     }                                \
  350.     next->si_type = type;                        \
  351.     next->si_cxix = -1;                        \
  352.     AvFILLp(next->si_stack) = 0;                    \
  353.     SWITCHSTACK(PL_curstack,next->si_stack);            \
  354.     PL_curstackinfo = next;                        \
  355.     SET_MARKBASE;                            \
  356.     } STMT_END
  357.  
  358. #define PUSHSTACK PUSHSTACKi(PERLSI_UNKNOWN)
  359.  
  360. #define POPSTACK \
  361.     STMT_START {                            \
  362.     PERL_SI *prev = PL_curstackinfo->si_prev;            \
  363.     if (!prev) {                            \
  364.         PerlIO_printf(PerlIO_stderr(), "panic: POPSTACK\n");    \
  365.         my_exit(1);                            \
  366.     }                                \
  367.     SWITCHSTACK(PL_curstack,prev->si_stack);            \
  368.     /* don't free prev here, free them all at the END{} */        \
  369.     PL_curstackinfo = prev;                        \
  370.     } STMT_END
  371.  
  372. #define POPSTACK_TO(s) \
  373.     STMT_START {                            \
  374.     while (PL_curstack != s) {                    \
  375.         dounwind(-1);                        \
  376.         POPSTACK;                            \
  377.     }                                \
  378.     } STMT_END
  379.