3 * Copyright (c) 1991-1997, Larry Wall
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.
12 #define dARGS struct perl_thread *thr;
16 #endif /* USE_THREADS */
17 #define PP(s) OP * s(ARGSproto)
23 #define PUSHMARK(p) if (++markstack_ptr == markstack_max) \
25 *markstack_ptr = (p) - stack_base
27 #define TOPMARK (*markstack_ptr)
28 #define POPMARK (*markstack_ptr--)
30 #define djSP register SV **sp = stack_sp
31 #define dSP dTHR; djSP
32 #define dMARK register SV **mark = stack_base + POPMARK
33 #define dORIGMARK I32 origmark = mark - stack_base
34 #define SETORIGMARK origmark = mark - stack_base
35 #define ORIGMARK (stack_base + origmark)
37 #define SPAGAIN sp = stack_sp
38 #define MSPAGAIN sp = stack_sp; mark = ORIGMARK
40 #define GETTARGETSTACKED targ = (op->op_flags & OPf_STACKED ? POPs : PAD_SV(op->op_targ))
41 #define dTARGETSTACKED SV * GETTARGETSTACKED
43 #define GETTARGET targ = PAD_SV(op->op_targ)
44 #define dTARGET SV * GETTARGET
46 #define GETATARGET targ = (op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(op->op_targ))
47 #define dATARGET SV * GETATARGET
49 #define dTARG SV *targ
51 #define NORMAL op->op_next
52 #define DIE return die
54 #define PUTBACK stack_sp = sp
55 #define RETURN return PUTBACK, NORMAL
56 #define RETURNOP(o) return PUTBACK, o
57 #define RETURNX(x) return x, PUTBACK, NORMAL
60 #define POPp (SvPVx(POPs, na))
61 #define POPn (SvNVx(POPs))
62 #define POPi ((IV)SvIVx(POPs))
63 #define POPu ((UV)SvUVx(POPs))
64 #define POPl ((long)SvIVx(POPs))
67 #define TOPp (SvPV(TOPs, na))
68 #define TOPn (SvNV(TOPs))
69 #define TOPi ((IV)SvIV(TOPs))
70 #define TOPu ((UV)SvUV(TOPs))
71 #define TOPl ((long)SvIV(TOPs))
73 /* Go to some pains in the rare event that we must extend the stack. */
74 #define EXTEND(p,n) STMT_START { if (stack_max - p < (n)) { \
75 sp = stack_grow(sp,p, (int) (n)); \
78 /* Same thing, but update mark register too. */
79 #define MEXTEND(p,n) STMT_START {if (stack_max - p < (n)) { \
80 int markoff = mark - stack_base; \
81 sp = stack_grow(sp,p,(int) (n)); \
82 mark = stack_base + markoff; \
85 #define PUSHs(s) (*++sp = (s))
86 #define PUSHTARG STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END
87 #define PUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END
88 #define PUSHn(n) STMT_START { sv_setnv(TARG, (double)(n)); PUSHTARG; } STMT_END
89 #define PUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END
90 #define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END
92 #define XPUSHs(s) STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END
93 #define XPUSHTARG STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END
94 #define XPUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END
95 #define XPUSHn(n) STMT_START { sv_setnv(TARG, (double)(n)); XPUSHTARG; } STMT_END
96 #define XPUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END
97 #define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END
99 #define SETs(s) (*sp = s)
100 #define SETTARG STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END
101 #define SETp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END
102 #define SETn(n) STMT_START { sv_setnv(TARG, (double)(n)); SETTARG; } STMT_END
103 #define SETi(i) STMT_START { sv_setiv(TARG, (IV)(i)); SETTARG; } STMT_END
104 #define SETu(u) STMT_START { sv_setuv(TARG, (UV)(u)); SETTARG; } STMT_END
106 #define dTOPss SV *sv = TOPs
107 #define dPOPss SV *sv = POPs
108 #define dTOPnv double value = TOPn
109 #define dPOPnv double value = POPn
110 #define dTOPiv IV value = TOPi
111 #define dPOPiv IV value = POPi
112 #define dTOPuv UV value = TOPu
113 #define dPOPuv UV value = POPu
115 #define dPOPXssrl(X) SV *right = POPs; SV *left = CAT2(X,s)
116 #define dPOPXnnrl(X) double right = POPn; double left = CAT2(X,n)
117 #define dPOPXiirl(X) IV right = POPi; IV left = CAT2(X,i)
119 #define USE_LEFT(sv) \
120 (SvOK(sv) || SvGMAGICAL(sv) || !(op->op_flags & OPf_STACKED))
121 #define dPOPXnnrl_ul(X) \
122 double right = POPn; \
123 SV *leftsv = CAT2(X,s); \
124 double left = USE_LEFT(leftsv) ? SvNV(leftsv) : 0.0
125 #define dPOPXiirl_ul(X) \
127 SV *leftsv = CAT2(X,s); \
128 IV left = USE_LEFT(leftsv) ? SvIV(leftsv) : 0
130 #define dPOPPOPssrl dPOPXssrl(POP)
131 #define dPOPPOPnnrl dPOPXnnrl(POP)
132 #define dPOPPOPnnrl_ul dPOPXnnrl_ul(POP)
133 #define dPOPPOPiirl dPOPXiirl(POP)
134 #define dPOPPOPiirl_ul dPOPXiirl_ul(POP)
136 #define dPOPTOPssrl dPOPXssrl(TOP)
137 #define dPOPTOPnnrl dPOPXnnrl(TOP)
138 #define dPOPTOPnnrl_ul dPOPXnnrl_ul(TOP)
139 #define dPOPTOPiirl dPOPXiirl(TOP)
140 #define dPOPTOPiirl_ul dPOPXiirl_ul(TOP)
142 #define RETPUSHYES RETURNX(PUSHs(&sv_yes))
143 #define RETPUSHNO RETURNX(PUSHs(&sv_no))
144 #define RETPUSHUNDEF RETURNX(PUSHs(&sv_undef))
146 #define RETSETYES RETURNX(SETs(&sv_yes))
147 #define RETSETNO RETURNX(SETs(&sv_no))
148 #define RETSETUNDEF RETURNX(SETs(&sv_undef))
150 #define ARGTARG op->op_targ
151 #define MAXARG op->op_private
153 #define SWITCHSTACK(f,t) \
155 AvFILLp(f) = sp - stack_base; \
156 stack_base = AvARRAY(t); \
157 stack_max = stack_base + AvMAX(t); \
158 sp = stack_sp = stack_base + AvFILLp(t); \
162 #define EXTEND_MORTAL(n) \
164 if (tmps_ix + (n) >= tmps_max) \
165 Renew(tmps_stack, tmps_max = tmps_ix + (n) + 1, SV*); \
170 #define AMGf_noright 1
171 #define AMGf_noleft 2
172 #define AMGf_assign 4
175 #define tryAMAGICbinW(meth,assign,set) STMT_START { \
176 if (amagic_generation) { \
178 SV* right= *(sp); SV* left= *(sp-1);\
179 if ((SvAMAGIC(left)||SvAMAGIC(right))&&\
180 (tmpsv=amagic_call(left, \
183 (assign)? AMGf_assign: 0))) {\
185 (void)POPs; set(tmpsv); RETURN; } \
189 #define tryAMAGICbin(meth,assign) tryAMAGICbinW(meth,assign,SETsv)
190 #define tryAMAGICbinSET(meth,assign) tryAMAGICbinW(meth,assign,SETs)
192 #define AMG_CALLun(sv,meth) amagic_call(sv,&sv_undef, \
193 CAT2(meth,_amg),AMGf_noright | AMGf_unary)
194 #define AMG_CALLbinL(left,right,meth) \
195 amagic_call(left,right,CAT2(meth,_amg),AMGf_noright)
197 #define tryAMAGICunW(meth,set) STMT_START { \
198 if (amagic_generation) { \
201 if ((SvAMAGIC(arg))&&\
202 (tmpsv=AMG_CALLun(arg,meth))) {\
204 set(tmpsv); RETURN; } \
208 #define tryAMAGICun tryAMAGICunSET
209 #define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs)
211 #define opASSIGN (op->op_flags & OPf_STACKED)
212 #define SETsv(sv) STMT_START { \
213 if (opASSIGN) { sv_setsv(TARG, (sv)); SETTARG; } \
214 else SETs(sv); } STMT_END
216 /* newSVsv does not behave as advertised, so we copy missing
217 * information by hand */
220 #define RvDEEPCP(rv) STMT_START { SV* ref=SvRV(rv); \
221 if (SvREFCNT(ref)>1) { \
223 SvRV(rv)=AMG_CALLun(rv,copy); \
227 #define tryAMAGICbin(a,b)
228 #define tryAMAGICbinSET(a,b)
229 #define tryAMAGICun(a)
230 #define tryAMAGICunSET(a)
232 #endif /* OVERLOAD */