home *** CD-ROM | disk | FTP | other *** search
/ Chip: Windows 2000 Professional Resource Kit / W2KPRK.iso / apps / perl / ActivePerl.exe / data.z / pp.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-10-14  |  7.8 KB  |  240 lines
  1. /*    pp.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. #ifdef USE_THREADS
  11. #define ARGS thr
  12. #define dARGS struct perl_thread *thr;
  13. #else
  14. #define ARGS
  15. #define dARGS
  16. #endif /* USE_THREADS */
  17. #ifdef PERL_OBJECT
  18. #define PP(s) OP * CPerlObj::s(ARGSproto)
  19. #else
  20. #define PP(s) OP * s(ARGSproto)
  21. #endif
  22.  
  23. #define SP sp
  24. #define MARK mark
  25. #define TARG targ
  26.  
  27. #define PUSHMARK(p) if (++PL_markstack_ptr == PL_markstack_max)    \
  28.             markstack_grow();            \
  29.             *PL_markstack_ptr = (p) - PL_stack_base
  30.  
  31. #define TOPMARK        (*PL_markstack_ptr)
  32. #define POPMARK        (*PL_markstack_ptr--)
  33.  
  34. #define djSP        register SV **sp = PL_stack_sp
  35. #define dSP        dTHR; djSP
  36. #define dMARK        register SV **mark = PL_stack_base + POPMARK
  37. #define dORIGMARK    I32 origmark = mark - PL_stack_base
  38. #define SETORIGMARK    origmark = mark - PL_stack_base
  39. #define ORIGMARK    (PL_stack_base + origmark)
  40.  
  41. #define SPAGAIN        sp = PL_stack_sp
  42. #define MSPAGAIN    sp = PL_stack_sp; mark = ORIGMARK
  43.  
  44. #define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ))
  45. #define dTARGETSTACKED SV * GETTARGETSTACKED
  46.  
  47. #define GETTARGET targ = PAD_SV(PL_op->op_targ)
  48. #define dTARGET SV * GETTARGET
  49.  
  50. #define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ))
  51. #define dATARGET SV * GETATARGET
  52.  
  53. #define dTARG SV *targ
  54.  
  55. #define NORMAL PL_op->op_next
  56. #define DIE return die
  57.  
  58. #define PUTBACK        PL_stack_sp = sp
  59. #define RETURN        return PUTBACK, NORMAL
  60. #define RETURNOP(o)    return PUTBACK, o
  61. #define RETURNX(x)    return x, PUTBACK, NORMAL
  62.  
  63. #define POPs        (*sp--)
  64. #define POPp        (SvPVx(POPs, PL_na))        /* deprecated */
  65. #define POPpx        (SvPVx(POPs, n_a))
  66. #define POPn        (SvNVx(POPs))
  67. #define POPi        ((IV)SvIVx(POPs))
  68. #define POPu        ((UV)SvUVx(POPs))
  69. #define POPl        ((long)SvIVx(POPs))
  70.  
  71. #define TOPs        (*sp)
  72. #define TOPp        (SvPV(TOPs, PL_na))        /* deprecated */
  73. #define TOPpx        (SvPV(TOPs, n_a))
  74. #define TOPn        (SvNV(TOPs))
  75. #define TOPi        ((IV)SvIV(TOPs))
  76. #define TOPu        ((UV)SvUV(TOPs))
  77. #define TOPl        ((long)SvIV(TOPs))
  78.  
  79. /* Go to some pains in the rare event that we must extend the stack. */
  80. #define EXTEND(p,n)    STMT_START { if (PL_stack_max - p < (n)) {        \
  81.                 sp = stack_grow(sp,p, (int) (n));        \
  82.             } } STMT_END
  83.  
  84. /* Same thing, but update mark register too. */
  85. #define MEXTEND(p,n)    STMT_START {if (PL_stack_max - p < (n)) {        \
  86.                 int markoff = mark - PL_stack_base;        \
  87.                 sp = stack_grow(sp,p,(int) (n));        \
  88.                 mark = PL_stack_base + markoff;        \
  89.             } } STMT_END
  90.  
  91. #define PUSHs(s)    (*++sp = (s))
  92. #define PUSHTARG    STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END
  93. #define PUSHp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END
  94. #define PUSHn(n)    STMT_START { sv_setnv(TARG, (double)(n)); PUSHTARG; } STMT_END
  95. #define PUSHi(i)    STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END
  96. #define PUSHu(u)    STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
  97.  
  98. #define XPUSHs(s)    STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END
  99. #define XPUSHTARG    STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END
  100. #define XPUSHp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END
  101. #define XPUSHn(n)    STMT_START { sv_setnv(TARG, (double)(n)); XPUSHTARG; } STMT_END
  102. #define XPUSHi(i)    STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END
  103. #define XPUSHu(u)    STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
  104.  
  105. #define SETs(s)        (*sp = s)
  106. #define SETTARG        STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END
  107. #define SETp(p,l)    STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END
  108. #define SETn(n)        STMT_START { sv_setnv(TARG, (double)(n)); SETTARG; } STMT_END
  109. #define SETi(i)        STMT_START { sv_setiv(TARG, (IV)(i)); SETTARG; } STMT_END
  110. #define SETu(u)        STMT_START { sv_setuv(TARG, (UV)(u)); SETTARG; } STMT_END
  111.  
  112. #define dTOPss        SV *sv = TOPs
  113. #define dPOPss        SV *sv = POPs
  114. #define dTOPnv        double value = TOPn
  115. #define dPOPnv        double value = POPn
  116. #define dTOPiv        IV value = TOPi
  117. #define dPOPiv        IV value = POPi
  118. #define dTOPuv        UV value = TOPu
  119. #define dPOPuv        UV value = POPu
  120.  
  121. #define dPOPXssrl(X)    SV *right = POPs; SV *left = CAT2(X,s)
  122. #define dPOPXnnrl(X)    double right = POPn; double left = CAT2(X,n)
  123. #define dPOPXiirl(X)    IV right = POPi; IV left = CAT2(X,i)
  124.  
  125. #define USE_LEFT(sv) \
  126.     (SvOK(sv) || SvGMAGICAL(sv) || !(PL_op->op_flags & OPf_STACKED))
  127. #define dPOPXnnrl_ul(X)    \
  128.     double right = POPn;                \
  129.     SV *leftsv = CAT2(X,s);                \
  130.     double left = USE_LEFT(leftsv) ? SvNV(leftsv) : 0.0
  131. #define dPOPXiirl_ul(X) \
  132.     IV right = POPi;                    \
  133.     SV *leftsv = CAT2(X,s);                \
  134.     IV left = USE_LEFT(leftsv) ? SvIV(leftsv) : 0
  135.  
  136. #define dPOPPOPssrl    dPOPXssrl(POP)
  137. #define dPOPPOPnnrl    dPOPXnnrl(POP)
  138. #define dPOPPOPnnrl_ul    dPOPXnnrl_ul(POP)
  139. #define dPOPPOPiirl    dPOPXiirl(POP)
  140. #define dPOPPOPiirl_ul    dPOPXiirl_ul(POP)
  141.  
  142. #define dPOPTOPssrl    dPOPXssrl(TOP)
  143. #define dPOPTOPnnrl    dPOPXnnrl(TOP)
  144. #define dPOPTOPnnrl_ul    dPOPXnnrl_ul(TOP)
  145. #define dPOPTOPiirl    dPOPXiirl(TOP)
  146. #define dPOPTOPiirl_ul    dPOPXiirl_ul(TOP)
  147.  
  148. #define RETPUSHYES    RETURNX(PUSHs(&PL_sv_yes))
  149. #define RETPUSHNO    RETURNX(PUSHs(&PL_sv_no))
  150. #define RETPUSHUNDEF    RETURNX(PUSHs(&PL_sv_undef))
  151.  
  152. #define RETSETYES    RETURNX(SETs(&PL_sv_yes))
  153. #define RETSETNO    RETURNX(SETs(&PL_sv_no))
  154. #define RETSETUNDEF    RETURNX(SETs(&PL_sv_undef))
  155.  
  156. #define ARGTARG        PL_op->op_targ
  157. #define MAXARG        PL_op->op_private
  158.  
  159. #define SWITCHSTACK(f,t) \
  160.     STMT_START {                            \
  161.     AvFILLp(f) = sp - PL_stack_base;                    \
  162.     PL_stack_base = AvARRAY(t);                    \
  163.     PL_stack_max = PL_stack_base + AvMAX(t);                \
  164.     sp = PL_stack_sp = PL_stack_base + AvFILLp(t);            \
  165.     PL_curstack = t;                            \
  166.     } STMT_END
  167.  
  168. #define EXTEND_MORTAL(n) \
  169.     STMT_START { \
  170.         if (PL_tmps_ix + (n) >= PL_tmps_max) \
  171.         Renew(PL_tmps_stack, PL_tmps_max = PL_tmps_ix + (n) + 1, SV*); \
  172.     } STMT_END
  173.  
  174. #ifdef OVERLOAD
  175.  
  176. #define AMGf_noright    1
  177. #define AMGf_noleft    2
  178. #define AMGf_assign    4
  179. #define AMGf_unary    8
  180.  
  181. #define tryAMAGICbinW(meth,assign,set) STMT_START { \
  182.           if (PL_amagic_generation) { \
  183.         SV* tmpsv; \
  184.         SV* right= *(sp); SV* left= *(sp-1);\
  185.         if ((SvAMAGIC(left)||SvAMAGIC(right))&&\
  186.         (tmpsv=amagic_call(left, \
  187.                    right, \
  188.                    CAT2(meth,_amg), \
  189.                    (assign)? AMGf_assign: 0))) {\
  190.            SPAGAIN;    \
  191.            (void)POPs; set(tmpsv); RETURN; } \
  192.       } \
  193.     } STMT_END
  194.  
  195. #define tryAMAGICbin(meth,assign) tryAMAGICbinW(meth,assign,SETsv)
  196. #define tryAMAGICbinSET(meth,assign) tryAMAGICbinW(meth,assign,SETs)
  197.  
  198. #define AMG_CALLun(sv,meth) amagic_call(sv,&PL_sv_undef,  \
  199.                     CAT2(meth,_amg),AMGf_noright | AMGf_unary)
  200. #define AMG_CALLbinL(left,right,meth) \
  201.             amagic_call(left,right,CAT2(meth,_amg),AMGf_noright)
  202.  
  203. #define tryAMAGICunW(meth,set) STMT_START { \
  204.           if (PL_amagic_generation) { \
  205.         SV* tmpsv; \
  206.         SV* arg= *(sp); \
  207.         if ((SvAMAGIC(arg))&&\
  208.         (tmpsv=AMG_CALLun(arg,meth))) {\
  209.            SPAGAIN;    \
  210.            set(tmpsv); RETURN; } \
  211.       } \
  212.     } STMT_END
  213.  
  214. #define tryAMAGICun    tryAMAGICunSET
  215. #define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs)
  216.  
  217. #define opASSIGN (PL_op->op_flags & OPf_STACKED)
  218. #define SETsv(sv)    STMT_START {                    \
  219.         if (opASSIGN) { sv_setsv(TARG, (sv)); SETTARG; }    \
  220.         else SETs(sv); } STMT_END
  221.  
  222. /* newSVsv does not behave as advertised, so we copy missing
  223.  * information by hand */
  224.  
  225. /* SV* ref causes confusion with the member variable
  226.    changed SV* ref to SV* tmpRef */
  227. #define RvDEEPCP(rv) STMT_START { SV* tmpRef=SvRV(rv);      \
  228.   if (SvREFCNT(tmpRef)>1) {                 \
  229.     SvREFCNT_dec(tmpRef);                   \
  230.     SvRV(rv)=AMG_CALLun(rv,copy);        \
  231.   } } STMT_END
  232. #else
  233.  
  234. #define tryAMAGICbin(a,b)
  235. #define tryAMAGICbinSET(a,b)
  236. #define tryAMAGICun(a)
  237. #define tryAMAGICunSET(a)
  238.  
  239. #endif /* OVERLOAD */
  240.