1 /* pp.h 2 * 3 * Copyright (c) 1991-2001, 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 18 #define PP(s) OP * Perl_##s(pTHX) 19 20 /* 21 =for apidoc AmU||SP 22 Stack pointer. This is usually handled by C<xsubpp>. See C<dSP> and 23 C<SPAGAIN>. 24 25 =for apidoc AmU||MARK 26 Stack marker variable for the XSUB. See C<dMARK>. 27 28 =for apidoc Ams||PUSHMARK 29 Opening bracket for arguments on a callback. See C<PUTBACK> and 30 L<perlcall>. 31 32 =for apidoc Ams||dSP 33 Declares a local copy of perl's stack pointer for the XSUB, available via 34 the C<SP> macro. See C<SP>. 35 36 =for apidoc Ams||dMARK 37 Declare a stack marker variable, C<mark>, for the XSUB. See C<MARK> and 38 C<dORIGMARK>. 39 40 =for apidoc Ams||dORIGMARK 41 Saves the original stack mark for the XSUB. See C<ORIGMARK>. 42 43 =for apidoc AmU||ORIGMARK 44 The original stack mark for the XSUB. See C<dORIGMARK>. 45 46 =for apidoc Ams||SPAGAIN 47 Refetch the stack pointer. Used after a callback. See L<perlcall>. 48 49 =cut 50 */ 51 52 #undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */ 53 #define SP sp 54 #define MARK mark 55 #define TARG targ 56 57 #define PUSHMARK(p) if (++PL_markstack_ptr == PL_markstack_max) \ 58 markstack_grow(); \ 59 *PL_markstack_ptr = (p) - PL_stack_base 60 61 #define TOPMARK (*PL_markstack_ptr) 62 #define POPMARK (*PL_markstack_ptr--) 63 64 #define dSP register SV **sp = PL_stack_sp 65 #define djSP dSP 66 #define dMARK register SV **mark = PL_stack_base + POPMARK 67 #define dORIGMARK I32 origmark = mark - PL_stack_base 68 #define SETORIGMARK origmark = mark - PL_stack_base 69 #define ORIGMARK (PL_stack_base + origmark) 70 71 #define SPAGAIN sp = PL_stack_sp 72 #define MSPAGAIN sp = PL_stack_sp; mark = ORIGMARK 73 74 #define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ)) 75 #define dTARGETSTACKED SV * GETTARGETSTACKED 76 77 #define GETTARGET targ = PAD_SV(PL_op->op_targ) 78 #define dTARGET SV * GETTARGET 79 80 #define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ)) 81 #define dATARGET SV * GETATARGET 82 83 #define dTARG SV *targ 84 85 #define NORMAL PL_op->op_next 86 #define DIE return Perl_die 87 88 /* 89 =for apidoc Ams||PUTBACK 90 Closing bracket for XSUB arguments. This is usually handled by C<xsubpp>. 91 See C<PUSHMARK> and L<perlcall> for other uses. 92 93 =for apidoc Amn|SV*|POPs 94 Pops an SV off the stack. 95 96 =for apidoc Amn|char*|POPp 97 Pops a string off the stack. 98 99 =for apidoc Amn|NV|POPn 100 Pops a double off the stack. 101 102 =for apidoc Amn|IV|POPi 103 Pops an integer off the stack. 104 105 =for apidoc Amn|long|POPl 106 Pops a long off the stack. 107 108 =cut 109 */ 110 111 #define PUTBACK PL_stack_sp = sp 112 #define RETURN return PUTBACK, NORMAL 113 #define RETURNOP(o) return PUTBACK, o 114 #define RETURNX(x) return x, PUTBACK, NORMAL 115 116 #define POPs (*sp--) 117 #define POPp (SvPVx(POPs, PL_na)) /* deprecated */ 118 #define POPpx (SvPVx(POPs, n_a)) 119 #define POPn (SvNVx(POPs)) 120 #define POPi ((IV)SvIVx(POPs)) 121 #define POPu ((UV)SvUVx(POPs)) 122 #define POPl ((long)SvIVx(POPs)) 123 #define POPul ((unsigned long)SvIVx(POPs)) 124 #ifdef HAS_QUAD 125 #define POPq ((Quad_t)SvIVx(POPs)) 126 #define POPuq ((Uquad_t)SvUVx(POPs)) 127 #endif 128 129 #define TOPs (*sp) 130 #define TOPp (SvPV(TOPs, PL_na)) /* deprecated */ 131 #define TOPpx (SvPV(TOPs, n_a)) 132 #define TOPn (SvNV(TOPs)) 133 #define TOPi ((IV)SvIV(TOPs)) 134 #define TOPu ((UV)SvUV(TOPs)) 135 #define TOPl ((long)SvIV(TOPs)) 136 #define TOPul ((unsigned long)SvUV(TOPs)) 137 #ifdef HAS_QUAD 138 #define TOPq ((Quad_t)SvIV(TOPs)) 139 #define TOPuq ((Uquad_t)SvUV(TOPs)) 140 #endif 141 142 /* Go to some pains in the rare event that we must extend the stack. */ 143 144 /* 145 =for apidoc Am|void|EXTEND|SP|int nitems 146 Used to extend the argument stack for an XSUB's return values. Once 147 used, guarantees that there is room for at least C<nitems> to be pushed 148 onto the stack. 149 150 =for apidoc Am|void|PUSHs|SV* sv 151 Push an SV onto the stack. The stack must have room for this element. 152 Does not handle 'set' magic. See C<XPUSHs>. 153 154 =for apidoc Am|void|PUSHp|char* str|STRLEN len 155 Push a string onto the stack. The stack must have room for this element. 156 The C<len> indicates the length of the string. Handles 'set' magic. See 157 C<XPUSHp>. 158 159 =for apidoc Am|void|PUSHn|NV nv 160 Push a double onto the stack. The stack must have room for this element. 161 Handles 'set' magic. See C<XPUSHn>. 162 163 =for apidoc Am|void|PUSHi|IV iv 164 Push an integer onto the stack. The stack must have room for this element. 165 Handles 'set' magic. See C<XPUSHi>. 166 167 =for apidoc Am|void|PUSHu|UV uv 168 Push an unsigned integer onto the stack. The stack must have room for this 169 element. See C<XPUSHu>. 170 171 =for apidoc Am|void|XPUSHs|SV* sv 172 Push an SV onto the stack, extending the stack if necessary. Does not 173 handle 'set' magic. See C<PUSHs>. 174 175 =for apidoc Am|void|XPUSHp|char* str|STRLEN len 176 Push a string onto the stack, extending the stack if necessary. The C<len> 177 indicates the length of the string. Handles 'set' magic. See 178 C<PUSHp>. 179 180 =for apidoc Am|void|XPUSHn|NV nv 181 Push a double onto the stack, extending the stack if necessary. Handles 182 'set' magic. See C<PUSHn>. 183 184 =for apidoc Am|void|XPUSHi|IV iv 185 Push an integer onto the stack, extending the stack if necessary. Handles 186 'set' magic. See C<PUSHi>. 187 188 =for apidoc Am|void|XPUSHu|UV uv 189 Push an unsigned integer onto the stack, extending the stack if necessary. 190 See C<PUSHu>. 191 192 =cut 193 */ 194 195 #define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (n)) { \ 196 sp = stack_grow(sp,p, (int) (n)); \ 197 } } STMT_END 198 199 /* Same thing, but update mark register too. */ 200 #define MEXTEND(p,n) STMT_START {if (PL_stack_max - p < (n)) { \ 201 int markoff = mark - PL_stack_base; \ 202 sp = stack_grow(sp,p,(int) (n)); \ 203 mark = PL_stack_base + markoff; \ 204 } } STMT_END 205 206 #define PUSHs(s) (*++sp = (s)) 207 #define PUSHTARG STMT_START { SvSETMAGIC(TARG); PUSHs(TARG); } STMT_END 208 #define PUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); PUSHTARG; } STMT_END 209 #define PUSHn(n) STMT_START { sv_setnv(TARG, (NV)(n)); PUSHTARG; } STMT_END 210 #define PUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); PUSHTARG; } STMT_END 211 #define PUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); PUSHTARG; } STMT_END 212 213 #define XPUSHs(s) STMT_START { EXTEND(sp,1); (*++sp = (s)); } STMT_END 214 #define XPUSHTARG STMT_START { SvSETMAGIC(TARG); XPUSHs(TARG); } STMT_END 215 #define XPUSHp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); XPUSHTARG; } STMT_END 216 #define XPUSHn(n) STMT_START { sv_setnv(TARG, (NV)(n)); XPUSHTARG; } STMT_END 217 #define XPUSHi(i) STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END 218 #define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END 219 #define XPUSHundef STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END 220 221 #define SETs(s) (*sp = s) 222 #define SETTARG STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END 223 #define SETp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END 224 #define SETn(n) STMT_START { sv_setnv(TARG, (NV)(n)); SETTARG; } STMT_END 225 #define SETi(i) STMT_START { sv_setiv(TARG, (IV)(i)); SETTARG; } STMT_END 226 #define SETu(u) STMT_START { sv_setuv(TARG, (UV)(u)); SETTARG; } STMT_END 227 228 #define dTOPss SV *sv = TOPs 229 #define dPOPss SV *sv = POPs 230 #define dTOPnv NV value = TOPn 231 #define dPOPnv NV value = POPn 232 #define dTOPiv IV value = TOPi 233 #define dPOPiv IV value = POPi 234 #define dTOPuv UV value = TOPu 235 #define dPOPuv UV value = POPu 236 #ifdef HAS_QUAD 237 #define dTOPqv Quad_t value = TOPu 238 #define dPOPqv Quad_t value = POPu 239 #define dTOPuqv Uquad_t value = TOPuq 240 #define dPOPuqv Uquad_t value = POPuq 241 #endif 242 243 #define dPOPXssrl(X) SV *right = POPs; SV *left = CAT2(X,s) 244 #define dPOPXnnrl(X) NV right = POPn; NV left = CAT2(X,n) 245 #define dPOPXiirl(X) IV right = POPi; IV left = CAT2(X,i) 246 247 #define USE_LEFT(sv) \ 248 (SvOK(sv) || SvGMAGICAL(sv) || !(PL_op->op_flags & OPf_STACKED)) 249 #define dPOPXnnrl_ul(X) \ 250 NV right = POPn; \ 251 SV *leftsv = CAT2(X,s); \ 252 NV left = USE_LEFT(leftsv) ? SvNV(leftsv) : 0.0 253 #define dPOPXiirl_ul(X) \ 254 IV right = POPi; \ 255 SV *leftsv = CAT2(X,s); \ 256 IV left = USE_LEFT(leftsv) ? SvIV(leftsv) : 0 257 258 #define dPOPPOPssrl dPOPXssrl(POP) 259 #define dPOPPOPnnrl dPOPXnnrl(POP) 260 #define dPOPPOPnnrl_ul dPOPXnnrl_ul(POP) 261 #define dPOPPOPiirl dPOPXiirl(POP) 262 #define dPOPPOPiirl_ul dPOPXiirl_ul(POP) 263 264 #define dPOPTOPssrl dPOPXssrl(TOP) 265 #define dPOPTOPnnrl dPOPXnnrl(TOP) 266 #define dPOPTOPnnrl_ul dPOPXnnrl_ul(TOP) 267 #define dPOPTOPiirl dPOPXiirl(TOP) 268 #define dPOPTOPiirl_ul dPOPXiirl_ul(TOP) 269 270 #define RETPUSHYES RETURNX(PUSHs(&PL_sv_yes)) 271 #define RETPUSHNO RETURNX(PUSHs(&PL_sv_no)) 272 #define RETPUSHUNDEF RETURNX(PUSHs(&PL_sv_undef)) 273 274 #define RETSETYES RETURNX(SETs(&PL_sv_yes)) 275 #define RETSETNO RETURNX(SETs(&PL_sv_no)) 276 #define RETSETUNDEF RETURNX(SETs(&PL_sv_undef)) 277 278 #define ARGTARG PL_op->op_targ 279 280 /* See OPpTARGET_MY: */ 281 #define MAXARG (PL_op->op_private & 15) 282 283 #define SWITCHSTACK(f,t) \ 284 STMT_START { \ 285 AvFILLp(f) = sp - PL_stack_base; \ 286 PL_stack_base = AvARRAY(t); \ 287 PL_stack_max = PL_stack_base + AvMAX(t); \ 288 sp = PL_stack_sp = PL_stack_base + AvFILLp(t); \ 289 PL_curstack = t; \ 290 } STMT_END 291 292 #define EXTEND_MORTAL(n) \ 293 STMT_START { \ 294 if (PL_tmps_ix + (n) >= PL_tmps_max) \ 295 tmps_grow(n); \ 296 } STMT_END 297 298 #define AMGf_noright 1 299 #define AMGf_noleft 2 300 #define AMGf_assign 4 301 #define AMGf_unary 8 302 303 #define tryAMAGICbinW(meth,assign,set) STMT_START { \ 304 if (PL_amagic_generation) { \ 305 SV* tmpsv; \ 306 SV* right= *(sp); SV* left= *(sp-1);\ 307 if ((SvAMAGIC(left)||SvAMAGIC(right))&&\ 308 (tmpsv=amagic_call(left, \ 309 right, \ 310 CAT2(meth,_amg), \ 311 (assign)? AMGf_assign: 0))) {\ 312 SPAGAIN; \ 313 (void)POPs; set(tmpsv); RETURN; } \ 314 } \ 315 } STMT_END 316 317 #define tryAMAGICbin(meth,assign) tryAMAGICbinW(meth,assign,SETsv) 318 #define tryAMAGICbinSET(meth,assign) tryAMAGICbinW(meth,assign,SETs) 319 320 #define AMG_CALLun(sv,meth) amagic_call(sv,&PL_sv_undef, \ 321 CAT2(meth,_amg),AMGf_noright | AMGf_unary) 322 #define AMG_CALLbinL(left,right,meth) \ 323 amagic_call(left,right,CAT2(meth,_amg),AMGf_noright) 324 325 #define tryAMAGICunW(meth,set,shift,ret) STMT_START { \ 326 if (PL_amagic_generation) { \ 327 SV* tmpsv; \ 328 SV* arg= sp[shift]; \ 329 am_again: \ 330 if ((SvAMAGIC(arg))&&\ 331 (tmpsv=AMG_CALLun(arg,meth))) {\ 332 SPAGAIN; if (shift) sp += shift; \ 333 set(tmpsv); ret; } \ 334 } \ 335 } STMT_END 336 337 #define FORCE_SETs(sv) STMT_START { sv_setsv(TARG, (sv)); SETTARG; } STMT_END 338 339 #define tryAMAGICun(meth) tryAMAGICunW(meth,SETsvUN,0,RETURN) 340 #define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs,0,RETURN) 341 #define tryAMAGICunTARGET(meth, shift) \ 342 { dSP; sp--; /* get TARGET from below PL_stack_sp */ \ 343 { dTARGETSTACKED; \ 344 { dSP; tryAMAGICunW(meth,FORCE_SETs,shift,RETURN);}}} 345 346 #define setAGAIN(ref) sv = ref; \ 347 if (!SvROK(ref)) \ 348 Perl_croak(aTHX_ "Overloaded dereference did not return a reference"); \ 349 if (ref != arg && SvRV(ref) != SvRV(arg)) { \ 350 arg = ref; \ 351 goto am_again; \ 352 } 353 354 #define tryAMAGICunDEREF(meth) tryAMAGICunW(meth,setAGAIN,0,(void)0) 355 356 #define opASSIGN (PL_op->op_flags & OPf_STACKED) 357 #define SETsv(sv) STMT_START { \ 358 if (opASSIGN || (SvFLAGS(TARG) & SVs_PADMY)) \ 359 { sv_setsv(TARG, (sv)); SETTARG; } \ 360 else SETs(sv); } STMT_END 361 362 #define SETsvUN(sv) STMT_START { \ 363 if (SvFLAGS(TARG) & SVs_PADMY) \ 364 { sv_setsv(TARG, (sv)); SETTARG; } \ 365 else SETs(sv); } STMT_END 366 367 /* newSVsv does not behave as advertised, so we copy missing 368 * information by hand */ 369 370 /* SV* ref causes confusion with the member variable 371 changed SV* ref to SV* tmpRef */ 372 #define RvDEEPCP(rv) STMT_START { SV* tmpRef=SvRV(rv); \ 373 if (SvREFCNT(tmpRef)>1) { \ 374 SvREFCNT_dec(tmpRef); \ 375 SvRV(rv)=AMG_CALLun(rv,copy); \ 376 } } STMT_END 377 378 /* 379 =for apidoc mU||LVRET 380 True if this op will be the return value of an lvalue subroutine 381 382 =cut */ 383 #define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub()) 384