home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / perl-5.003-bin.lha / lib / perl5 / m68k-amigaos / 5.003 / CORE / cop.h < prev    next >
C/C++ Source or Header  |  1996-10-09  |  7KB  |  242 lines
  1. /*    cop.h
  2.  *
  3.  *    Copyright (c) 1991-1994, 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.     short       cop_pad;
  19. };
  20.  
  21. #define Nullcop Null(COP*)
  22.  
  23. /*
  24.  * Here we have some enormously heavy (or at least ponderous) wizardry.
  25.  */
  26.  
  27. /* subroutine context */
  28. struct block_sub {
  29.     CV *    cv;
  30.     GV *    gv;
  31.     GV *    dfoutgv;
  32.     AV *    savearray;
  33.     AV *    argarray;
  34.     U16        olddepth;
  35.     U8        hasargs;
  36. };
  37.  
  38. #define PUSHSUB(cx)                            \
  39.     cx->blk_sub.cv = cv;                        \
  40.     cx->blk_sub.olddepth = CvDEPTH(cv);                \
  41.     cx->blk_sub.hasargs = hasargs;
  42.  
  43. #define PUSHFORMAT(cx)                            \
  44.     cx->blk_sub.cv = cv;                        \
  45.     cx->blk_sub.gv = gv;                        \
  46.     cx->blk_sub.hasargs = 0;                    \
  47.     cx->blk_sub.dfoutgv = defoutgv;                    \
  48.     (void)SvREFCNT_inc(cx->blk_sub.dfoutgv)
  49.  
  50. #define POPSUB(cx)                            \
  51.     if (cx->blk_sub.hasargs) {   /* put back old @_ */        \
  52.         GvAV(defgv) = cx->blk_sub.savearray;            \
  53.     }                                \
  54.     if (cx->blk_sub.cv) {                        \
  55.         if (!(CvDEPTH(cx->blk_sub.cv) = cx->blk_sub.olddepth)) {    \
  56.         SvREFCNT_dec((SV*)cx->blk_sub.cv);            \
  57.         }                                \
  58.     }
  59.  
  60. #define POPFORMAT(cx)                            \
  61.     setdefout(cx->blk_sub.dfoutgv);                    \
  62.     SvREFCNT_dec(cx->blk_sub.dfoutgv);
  63.  
  64. /* eval context */
  65. struct block_eval {
  66.     I32        old_in_eval;
  67.     I32        old_op_type;
  68.     char *    old_name;
  69.     OP *    old_eval_root;
  70.     SV *    cur_text;
  71. };
  72.  
  73. #define PUSHEVAL(cx,n,fgv)                        \
  74.     cx->blk_eval.old_in_eval = in_eval;                \
  75.     cx->blk_eval.old_op_type = op->op_type;                \
  76.     cx->blk_eval.old_name = n;                    \
  77.     cx->blk_eval.old_eval_root = eval_root;                \
  78.     cx->blk_eval.cur_text = linestr;
  79.  
  80. #define POPEVAL(cx)                            \
  81.     in_eval = cx->blk_eval.old_in_eval;                \
  82.     optype = cx->blk_eval.old_op_type;                \
  83.     eval_root = cx->blk_eval.old_eval_root;
  84.  
  85. /* loop context */
  86. struct block_loop {
  87.     char *    label;
  88.     I32        resetsp;
  89.     OP *    redo_op;
  90.     OP *    next_op;
  91.     OP *    last_op;
  92.     SV **    itervar;
  93.     SV *    itersave;
  94.     AV *    iterary;
  95.     I32        iterix;
  96. };
  97.  
  98. #define PUSHLOOP(cx, ivar, s)                        \
  99.     cx->blk_loop.label = curcop->cop_label;                \
  100.     cx->blk_loop.resetsp = s - stack_base;                \
  101.     cx->blk_loop.redo_op = cLOOP->op_redoop;            \
  102.     cx->blk_loop.next_op = cLOOP->op_nextop;            \
  103.     cx->blk_loop.last_op = cLOOP->op_lastop;            \
  104.     cx->blk_loop.itervar = ivar;                    \
  105.     if (ivar)                            \
  106.         cx->blk_loop.itersave = *cx->blk_loop.itervar;
  107.  
  108. #define POPLOOP(cx)                            \
  109.     newsp        = stack_base + cx->blk_loop.resetsp;
  110.  
  111. /* context common to subroutines, evals and loops */
  112. struct block {
  113.     I32        blku_oldsp;    /* stack pointer to copy stuff down to */
  114.     COP *    blku_oldcop;    /* old curcop pointer */
  115.     I32        blku_oldretsp;    /* return stack index */
  116.     I32        blku_oldmarksp;    /* mark stack index */
  117.     I32        blku_oldscopesp;    /* scope stack index */
  118.     PMOP *    blku_oldpm;    /* values of pattern match vars */
  119.     U8        blku_gimme;    /* is this block running in list context? */
  120.  
  121.     union {
  122.     struct block_sub    blku_sub;
  123.     struct block_eval    blku_eval;
  124.     struct block_loop    blku_loop;
  125.     } blk_u;
  126. };
  127. #define blk_oldsp    cx_u.cx_blk.blku_oldsp
  128. #define blk_oldcop    cx_u.cx_blk.blku_oldcop
  129. #define blk_oldretsp    cx_u.cx_blk.blku_oldretsp
  130. #define blk_oldmarksp    cx_u.cx_blk.blku_oldmarksp
  131. #define blk_oldscopesp    cx_u.cx_blk.blku_oldscopesp
  132. #define blk_oldpm    cx_u.cx_blk.blku_oldpm
  133. #define blk_gimme    cx_u.cx_blk.blku_gimme
  134. #define blk_sub        cx_u.cx_blk.blk_u.blku_sub
  135. #define blk_eval    cx_u.cx_blk.blk_u.blku_eval
  136. #define blk_loop    cx_u.cx_blk.blk_u.blku_loop
  137.  
  138. /* Enter a block. */
  139. #define PUSHBLOCK(cx,t,sp) CXINC, cx = &cxstack[cxstack_ix],        \
  140.     cx->cx_type        = t,                    \
  141.     cx->blk_oldsp        = sp - stack_base,            \
  142.     cx->blk_oldcop        = curcop,                \
  143.     cx->blk_oldmarksp    = markstack_ptr - markstack,        \
  144.     cx->blk_oldscopesp    = scopestack_ix,            \
  145.     cx->blk_oldretsp    = retstack_ix,                \
  146.     cx->blk_oldpm        = curpm,                \
  147.     cx->blk_gimme        = gimme;                \
  148.     DEBUG_l( fprintf(stderr,"Entering block %ld, type %s\n",    \
  149.             (long)cxstack_ix, block_type[t]); )
  150.  
  151. /* Exit a block (RETURN and LAST). */
  152. #define POPBLOCK(cx,pm) cx = &cxstack[cxstack_ix--],            \
  153.     newsp        = stack_base + cx->blk_oldsp,            \
  154.     curcop        = cx->blk_oldcop,                \
  155.     markstack_ptr    = markstack + cx->blk_oldmarksp,        \
  156.     scopestack_ix    = cx->blk_oldscopesp,                \
  157.     retstack_ix    = cx->blk_oldretsp,                \
  158.     pm        = cx->blk_oldpm,                \
  159.     gimme        = cx->blk_gimme;                \
  160.     DEBUG_l( fprintf(stderr,"Leaving block %ld, type %s\n",        \
  161.             (long)cxstack_ix+1,block_type[cx->cx_type]); )
  162.  
  163. /* Continue a block elsewhere (NEXT and REDO). */
  164. #define TOPBLOCK(cx) cx = &cxstack[cxstack_ix],                \
  165.     stack_sp    = stack_base + cx->blk_oldsp,            \
  166.     markstack_ptr    = markstack + cx->blk_oldmarksp,        \
  167.     scopestack_ix    = cx->blk_oldscopesp,                \
  168.     retstack_ix    = cx->blk_oldretsp
  169.  
  170. /* substitution context */
  171. struct subst {
  172.     I32        sbu_iters;
  173.     I32        sbu_maxiters;
  174.     I32        sbu_safebase;
  175.     I32        sbu_once;
  176.     I32        sbu_oldsave;
  177.     char *    sbu_orig;
  178.     SV *    sbu_dstr;
  179.     SV *    sbu_targ;
  180.     char *    sbu_s;
  181.     char *    sbu_m;
  182.     char *    sbu_strend;
  183.     char *    sbu_subbase;
  184.     REGEXP *    sbu_rx;
  185. };
  186. #define sb_iters    cx_u.cx_subst.sbu_iters
  187. #define sb_maxiters    cx_u.cx_subst.sbu_maxiters
  188. #define sb_safebase    cx_u.cx_subst.sbu_safebase
  189. #define sb_once        cx_u.cx_subst.sbu_once
  190. #define sb_oldsave    cx_u.cx_subst.sbu_oldsave
  191. #define sb_orig        cx_u.cx_subst.sbu_orig
  192. #define sb_dstr        cx_u.cx_subst.sbu_dstr
  193. #define sb_targ        cx_u.cx_subst.sbu_targ
  194. #define sb_s        cx_u.cx_subst.sbu_s
  195. #define sb_m        cx_u.cx_subst.sbu_m
  196. #define sb_strend    cx_u.cx_subst.sbu_strend
  197. #define sb_subbase    cx_u.cx_subst.sbu_subbase
  198. #define sb_rx        cx_u.cx_subst.sbu_rx
  199.  
  200. #define PUSHSUBST(cx) CXINC, cx = &cxstack[cxstack_ix],            \
  201.     cx->sb_iters        = iters,                \
  202.     cx->sb_maxiters        = maxiters,                \
  203.     cx->sb_safebase        = safebase,                \
  204.     cx->sb_once        = once,                    \
  205.     cx->sb_oldsave        = oldsave,                \
  206.     cx->sb_orig        = orig,                    \
  207.     cx->sb_dstr        = dstr,                    \
  208.     cx->sb_targ        = targ,                    \
  209.     cx->sb_s        = s,                    \
  210.     cx->sb_m        = m,                    \
  211.     cx->sb_strend        = strend,                \
  212.     cx->sb_rx        = rx,                    \
  213.     cx->cx_type        = CXt_SUBST
  214.  
  215. #define POPSUBST(cx) cxstack_ix--
  216.  
  217. struct context {
  218.     I32        cx_type;    /* what kind of context this is */
  219.     union {
  220.     struct block    cx_blk;
  221.     struct subst    cx_subst;
  222.     } cx_u;
  223. };
  224. #define CXt_NULL    0
  225. #define CXt_SUB        1
  226. #define CXt_EVAL    2
  227. #define CXt_LOOP    3
  228. #define CXt_SUBST    4
  229. #define CXt_BLOCK    5
  230.  
  231. #define CXINC (cxstack_ix < cxstack_max ? ++cxstack_ix : (cxstack_ix = cxinc()))
  232.  
  233. /* "gimme" values */
  234. #define G_SCALAR    0
  235. #define G_ARRAY        1
  236.  
  237. /* extra flags for perl_call_* routines */
  238. #define G_DISCARD    2    /* Call FREETMPS. */
  239. #define G_EVAL        4    /* Assume eval {} around subroutine call. */
  240. #define G_NOARGS    8    /* Don't construct a @_ array. */
  241. #define G_KEEPERR      16    /* Append errors to $@ rather than overwriting it */
  242.