X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pp.h;h=64020020c8f33be7773c8d1c45f718b1645b4d69;hb=619ffc2be66f166b301c5b0d14a8bbba728675bc;hp=de405f6c8fc0838a91c06ea8c5a9468ee224a8ea;hpb=ba3eb2af450c2577c20a691fb686a5e02955c48b;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pp.h b/pp.h index de405f6..6402002 100644 --- a/pp.h +++ b/pp.h @@ -14,76 +14,75 @@ #define ARGS #define dARGS #endif /* USE_THREADS */ -#ifdef PERL_OBJECT -#define PP(s) OP * CPerlObj::s(ARGSproto) -#else + #define PP(s) OP * s(ARGSproto) -#endif #define SP sp #define MARK mark #define TARG targ -#define PUSHMARK(p) if (++markstack_ptr == markstack_max) \ +#define PUSHMARK(p) if (++PL_markstack_ptr == PL_markstack_max) \ markstack_grow(); \ - *markstack_ptr = (p) - stack_base + *PL_markstack_ptr = (p) - PL_stack_base -#define TOPMARK (*markstack_ptr) -#define POPMARK (*markstack_ptr--) +#define TOPMARK (*PL_markstack_ptr) +#define POPMARK (*PL_markstack_ptr--) -#define djSP register SV **sp = stack_sp +#define djSP register SV **sp = PL_stack_sp #define dSP dTHR; djSP -#define dMARK register SV **mark = stack_base + POPMARK -#define dORIGMARK I32 origmark = mark - stack_base -#define SETORIGMARK origmark = mark - stack_base -#define ORIGMARK (stack_base + origmark) +#define dMARK register SV **mark = PL_stack_base + POPMARK +#define dORIGMARK I32 origmark = mark - PL_stack_base +#define SETORIGMARK origmark = mark - PL_stack_base +#define ORIGMARK (PL_stack_base + origmark) -#define SPAGAIN sp = stack_sp -#define MSPAGAIN sp = stack_sp; mark = ORIGMARK +#define SPAGAIN sp = PL_stack_sp +#define MSPAGAIN sp = PL_stack_sp; mark = ORIGMARK -#define GETTARGETSTACKED targ = (op->op_flags & OPf_STACKED ? POPs : PAD_SV(op->op_targ)) +#define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ)) #define dTARGETSTACKED SV * GETTARGETSTACKED -#define GETTARGET targ = PAD_SV(op->op_targ) +#define GETTARGET targ = PAD_SV(PL_op->op_targ) #define dTARGET SV * GETTARGET -#define GETATARGET targ = (op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(op->op_targ)) +#define GETATARGET targ = (PL_op->op_flags & OPf_STACKED ? sp[-1] : PAD_SV(PL_op->op_targ)) #define dATARGET SV * GETATARGET #define dTARG SV *targ -#define NORMAL op->op_next +#define NORMAL PL_op->op_next #define DIE return die -#define PUTBACK stack_sp = sp +#define PUTBACK PL_stack_sp = sp #define RETURN return PUTBACK, NORMAL #define RETURNOP(o) return PUTBACK, o #define RETURNX(x) return x, PUTBACK, NORMAL #define POPs (*sp--) -#define POPp (SvPVx(POPs, na)) +#define POPp (SvPVx(POPs, PL_na)) /* deprecated */ +#define POPpx (SvPVx(POPs, n_a)) #define POPn (SvNVx(POPs)) #define POPi ((IV)SvIVx(POPs)) #define POPu ((UV)SvUVx(POPs)) #define POPl ((long)SvIVx(POPs)) #define TOPs (*sp) -#define TOPp (SvPV(TOPs, na)) +#define TOPp (SvPV(TOPs, PL_na)) /* deprecated */ +#define TOPpx (SvPV(TOPs, n_a)) #define TOPn (SvNV(TOPs)) #define TOPi ((IV)SvIV(TOPs)) #define TOPu ((UV)SvUV(TOPs)) #define TOPl ((long)SvIV(TOPs)) /* Go to some pains in the rare event that we must extend the stack. */ -#define EXTEND(p,n) STMT_START { if (stack_max - p < (n)) { \ +#define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (n)) { \ sp = stack_grow(sp,p, (int) (n)); \ } } STMT_END /* Same thing, but update mark register too. */ -#define MEXTEND(p,n) STMT_START {if (stack_max - p < (n)) { \ - int markoff = mark - stack_base; \ +#define MEXTEND(p,n) STMT_START {if (PL_stack_max - p < (n)) { \ + int markoff = mark - PL_stack_base; \ sp = stack_grow(sp,p,(int) (n)); \ - mark = stack_base + markoff; \ + mark = PL_stack_base + markoff; \ } } STMT_END #define PUSHs(s) (*++sp = (s)) @@ -121,7 +120,7 @@ #define dPOPXiirl(X) IV right = POPi; IV left = CAT2(X,i) #define USE_LEFT(sv) \ - (SvOK(sv) || SvGMAGICAL(sv) || !(op->op_flags & OPf_STACKED)) + (SvOK(sv) || SvGMAGICAL(sv) || !(PL_op->op_flags & OPf_STACKED)) #define dPOPXnnrl_ul(X) \ double right = POPn; \ SV *leftsv = CAT2(X,s); \ @@ -143,30 +142,30 @@ #define dPOPTOPiirl dPOPXiirl(TOP) #define dPOPTOPiirl_ul dPOPXiirl_ul(TOP) -#define RETPUSHYES RETURNX(PUSHs(&sv_yes)) -#define RETPUSHNO RETURNX(PUSHs(&sv_no)) -#define RETPUSHUNDEF RETURNX(PUSHs(&sv_undef)) +#define RETPUSHYES RETURNX(PUSHs(&PL_sv_yes)) +#define RETPUSHNO RETURNX(PUSHs(&PL_sv_no)) +#define RETPUSHUNDEF RETURNX(PUSHs(&PL_sv_undef)) -#define RETSETYES RETURNX(SETs(&sv_yes)) -#define RETSETNO RETURNX(SETs(&sv_no)) -#define RETSETUNDEF RETURNX(SETs(&sv_undef)) +#define RETSETYES RETURNX(SETs(&PL_sv_yes)) +#define RETSETNO RETURNX(SETs(&PL_sv_no)) +#define RETSETUNDEF RETURNX(SETs(&PL_sv_undef)) -#define ARGTARG op->op_targ -#define MAXARG op->op_private +#define ARGTARG PL_op->op_targ +#define MAXARG PL_op->op_private #define SWITCHSTACK(f,t) \ STMT_START { \ - AvFILLp(f) = sp - stack_base; \ - stack_base = AvARRAY(t); \ - stack_max = stack_base + AvMAX(t); \ - sp = stack_sp = stack_base + AvFILLp(t); \ - curstack = t; \ + AvFILLp(f) = sp - PL_stack_base; \ + PL_stack_base = AvARRAY(t); \ + PL_stack_max = PL_stack_base + AvMAX(t); \ + sp = PL_stack_sp = PL_stack_base + AvFILLp(t); \ + PL_curstack = t; \ } STMT_END #define EXTEND_MORTAL(n) \ STMT_START { \ - if (tmps_ix + (n) >= tmps_max) \ - Renew(tmps_stack, tmps_max = tmps_ix + (n) + 1, SV*); \ + if (PL_tmps_ix + (n) >= PL_tmps_max) \ + Renew(PL_tmps_stack, PL_tmps_max = PL_tmps_ix + (n) + 1, SV*); \ } STMT_END #ifdef OVERLOAD @@ -177,7 +176,7 @@ #define AMGf_unary 8 #define tryAMAGICbinW(meth,assign,set) STMT_START { \ - if (amagic_generation) { \ + if (PL_amagic_generation) { \ SV* tmpsv; \ SV* right= *(sp); SV* left= *(sp-1);\ if ((SvAMAGIC(left)||SvAMAGIC(right))&&\ @@ -193,26 +192,40 @@ #define tryAMAGICbin(meth,assign) tryAMAGICbinW(meth,assign,SETsv) #define tryAMAGICbinSET(meth,assign) tryAMAGICbinW(meth,assign,SETs) -#define AMG_CALLun(sv,meth) amagic_call(sv,&sv_undef, \ +#define AMG_CALLun(sv,meth) amagic_call(sv,&PL_sv_undef, \ CAT2(meth,_amg),AMGf_noright | AMGf_unary) #define AMG_CALLbinL(left,right,meth) \ amagic_call(left,right,CAT2(meth,_amg),AMGf_noright) -#define tryAMAGICunW(meth,set) STMT_START { \ - if (amagic_generation) { \ +#define tryAMAGICunW(meth,set,shift,ret) STMT_START { \ + if (PL_amagic_generation) { \ SV* tmpsv; \ - SV* arg= *(sp); \ + SV* arg= sp[shift]; \ + am_again: \ if ((SvAMAGIC(arg))&&\ (tmpsv=AMG_CALLun(arg,meth))) {\ - SPAGAIN; \ - set(tmpsv); RETURN; } \ + SPAGAIN; if (shift) sp += shift; \ + set(tmpsv); ret; } \ } \ } STMT_END +#define FORCE_SETs(sv) STMT_START { sv_setsv(TARG, (sv)); SETTARG; } STMT_END + #define tryAMAGICun tryAMAGICunSET -#define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs) +#define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs,0,RETURN) +#define tryAMAGICunTARGET(meth, shift) \ + { dSP; sp--; /* get TARGET from below PL_stack_sp */ \ + { dTARGETSTACKED; \ + { dSP; tryAMAGICunW(meth,FORCE_SETs,shift,RETURN);}}} + +#define setAGAIN(ref) sv = arg = ref; \ + if (!SvROK(ref)) \ + croak("Overloaded dereference did not return a reference"); \ + goto am_again; + +#define tryAMAGICunDEREF(meth) tryAMAGICunW(meth,setAGAIN,0,(void)0) -#define opASSIGN (op->op_flags & OPf_STACKED) +#define opASSIGN (PL_op->op_flags & OPf_STACKED) #define SETsv(sv) STMT_START { \ if (opASSIGN) { sv_setsv(TARG, (sv)); SETTARG; } \ else SETs(sv); } STMT_END