X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/8a7fc0dc3015c8254ce4e866be71508e3379d45d..b162af07ec759e1b:/pp.h diff --git a/pp.h b/pp.h index ec701f3..221ea89 100644 --- a/pp.h +++ b/pp.h @@ -1,42 +1,79 @@ /* pp.h * - * Copyright (c) 1991-1999, Larry Wall + * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, + * 2000, 2001, 2002, 2003, 2004, 2005 by Larry Wall and others * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. * */ -#ifdef USE_THREADS -#define ARGS thr -#define dARGS struct perl_thread *thr; -#else -#define ARGS -#define dARGS -#endif /* USE_THREADS */ - #define PP(s) OP * Perl_##s(pTHX) +/* +=head1 Stack Manipulation Macros + +=for apidoc AmU||SP +Stack pointer. This is usually handled by C. See C and +C. + +=for apidoc AmU||MARK +Stack marker variable for the XSUB. See C. + +=for apidoc Am|void|PUSHMARK|SP +Opening bracket for arguments on a callback. See C and +L. + +=for apidoc Ams||dSP +Declares a local copy of perl's stack pointer for the XSUB, available via +the C macro. See C. + +=for apidoc ms||djSP + +Declare Just C. This is actually identical to C, and declares +a local copy of perl's stack pointer, available via the C macro. +See C. (Available for backward source code compatibility with the +old (Perl 5.005) thread model.) + +=for apidoc Ams||dMARK +Declare a stack marker variable, C, for the XSUB. See C and +C. + +=for apidoc Ams||dORIGMARK +Saves the original stack mark for the XSUB. See C. + +=for apidoc AmU||ORIGMARK +The original stack mark for the XSUB. See C. + +=for apidoc Ams||SPAGAIN +Refetch the stack pointer. Used after a callback. See L. + +=cut */ + +#undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */ #define SP sp #define MARK mark #define TARG targ -#define PUSHMARK(p) if (++PL_markstack_ptr == PL_markstack_max) \ - markstack_grow(); \ - *PL_markstack_ptr = (p) - PL_stack_base +#define PUSHMARK(p) \ + STMT_START { \ + if (++PL_markstack_ptr == PL_markstack_max) \ + markstack_grow(); \ + *PL_markstack_ptr = (p) - PL_stack_base; \ + } STMT_END #define TOPMARK (*PL_markstack_ptr) #define POPMARK (*PL_markstack_ptr--) -#define djSP register SV **sp = PL_stack_sp -#define dSP dTHR; djSP +#define dSP register SV **sp = PL_stack_sp +#define djSP dSP #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 = PL_stack_sp -#define MSPAGAIN sp = PL_stack_sp; mark = ORIGMARK +#define MSPAGAIN STMT_START { sp = PL_stack_sp; mark = ORIGMARK; } STMT_END #define GETTARGETSTACKED targ = (PL_op->op_flags & OPf_STACKED ? POPs : PAD_SV(PL_op->op_targ)) #define dTARGETSTACKED SV * GETTARGETSTACKED @@ -51,6 +88,39 @@ #define NORMAL PL_op->op_next #define DIE return Perl_die +#define DIE_NULL return DieNull + +/* +=for apidoc Ams||PUTBACK +Closing bracket for XSUB arguments. This is usually handled by C. +See C and L for other uses. + +=for apidoc Amn|SV*|POPs +Pops an SV off the stack. + +=for apidoc Amn|char*|POPp +Pops a string off the stack. Deprecated. New code should provide +a STRLEN n_a and use POPpx. + +=for apidoc Amn|char*|POPpx +Pops a string off the stack. +Requires a variable STRLEN n_a in scope. + +=for apidoc Amn|char*|POPpbytex +Pops a string off the stack which must consist of bytes i.e. characters < 256. +Requires a variable STRLEN n_a in scope. + +=for apidoc Amn|NV|POPn +Pops a double off the stack. + +=for apidoc Amn|IV|POPi +Pops an integer off the stack. + +=for apidoc Amn|long|POPl +Pops a long off the stack. + +=cut +*/ #define PUTBACK PL_stack_sp = sp #define RETURN return PUTBACK, NORMAL @@ -60,6 +130,7 @@ #define POPs (*sp--) #define POPp (SvPVx(POPs, PL_na)) /* deprecated */ #define POPpx (SvPVx(POPs, n_a)) +#define POPpbytex (SvPVbytex(POPs, n_a)) #define POPn (SvNVx(POPs)) #define POPi ((IV)SvIVx(POPs)) #define POPu ((UV)SvUVx(POPs)) @@ -71,6 +142,8 @@ #endif #define TOPs (*sp) +#define TOPm1s (*(sp-1)) +#define TOPp1s (*(sp+1)) #define TOPp (SvPV(TOPs, PL_na)) /* deprecated */ #define TOPpx (SvPV(TOPs, n_a)) #define TOPn (SvNV(TOPs)) @@ -84,12 +157,136 @@ #endif /* Go to some pains in the rare event that we must extend the stack. */ -#define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (n)) { \ + +/* +=for apidoc Am|void|EXTEND|SP|int nitems +Used to extend the argument stack for an XSUB's return values. Once +used, guarantees that there is room for at least C to be pushed +onto the stack. + +=for apidoc Am|void|PUSHs|SV* sv +Push an SV onto the stack. The stack must have room for this element. +Does not handle 'set' magic. Does not use C. See also C, +C and C. + +=for apidoc Am|void|PUSHp|char* str|STRLEN len +Push a string onto the stack. The stack must have room for this element. +The C indicates the length of the string. Handles 'set' magic. Uses +C, so C or C should be called to declare it. Do not +call multiple C-oriented macros to return lists from XSUB's - see +C instead. See also C and C. + +=for apidoc Am|void|PUSHn|NV nv +Push a double onto the stack. The stack must have room for this element. +Handles 'set' magic. Uses C, so C or C should be +called to declare it. Do not call multiple C-oriented macros to +return lists from XSUB's - see C instead. See also C and +C. + +=for apidoc Am|void|PUSHi|IV iv +Push an integer onto the stack. The stack must have room for this element. +Handles 'set' magic. Uses C, so C or C should be +called to declare it. Do not call multiple C-oriented macros to +return lists from XSUB's - see C instead. See also C and +C. + +=for apidoc Am|void|PUSHu|UV uv +Push an unsigned integer onto the stack. The stack must have room for this +element. Handles 'set' magic. Uses C, so C or C +should be called to declare it. Do not call multiple C-oriented +macros to return lists from XSUB's - see C instead. See also +C and C. + +=for apidoc Am|void|XPUSHs|SV* sv +Push an SV onto the stack, extending the stack if necessary. Does not +handle 'set' magic. Does not use C. See also C, +C and C. + +=for apidoc Am|void|XPUSHp|char* str|STRLEN len +Push a string onto the stack, extending the stack if necessary. The C +indicates the length of the string. Handles 'set' magic. Uses C, so +C or C should be called to declare it. Do not call +multiple C-oriented macros to return lists from XSUB's - see +C instead. See also C and C. + +=for apidoc Am|void|XPUSHn|NV nv +Push a double onto the stack, extending the stack if necessary. Handles +'set' magic. Uses C, so C or C should be called to +declare it. Do not call multiple C-oriented macros to return lists +from XSUB's - see C instead. See also C and C. + +=for apidoc Am|void|XPUSHi|IV iv +Push an integer onto the stack, extending the stack if necessary. Handles +'set' magic. Uses C, so C or C should be called to +declare it. Do not call multiple C-oriented macros to return lists +from XSUB's - see C instead. See also C and C. + +=for apidoc Am|void|XPUSHu|UV uv +Push an unsigned integer onto the stack, extending the stack if necessary. +Handles 'set' magic. Uses C, so C or C should be +called to declare it. Do not call multiple C-oriented macros to +return lists from XSUB's - see C instead. See also C and +C. + +=for apidoc Am|void|PUSHmortal +Push a new mortal SV onto the stack. The stack must have room for this +element. Does not handle 'set' magic. Does not use C. See also +C, C and C. + +=for apidoc Am|void|mPUSHp|char* str|STRLEN len +Push a string onto the stack. The stack must have room for this element. +The C indicates the length of the string. Handles 'set' magic. Does +not use C. See also C, C and C. + +=for apidoc Am|void|mPUSHn|NV nv +Push a double onto the stack. The stack must have room for this element. +Handles 'set' magic. Does not use C. See also C, C +and C. + +=for apidoc Am|void|mPUSHi|IV iv +Push an integer onto the stack. The stack must have room for this element. +Handles 'set' magic. Does not use C. See also C, C +and C. + +=for apidoc Am|void|mPUSHu|UV uv +Push an unsigned integer onto the stack. The stack must have room for this +element. Handles 'set' magic. Does not use C. See also C, +C and C. + +=for apidoc Am|void|XPUSHmortal +Push a new mortal SV onto the stack, extending the stack if necessary. Does +not handle 'set' magic. Does not use C. See also C, +C and C. + +=for apidoc Am|void|mXPUSHp|char* str|STRLEN len +Push a string onto the stack, extending the stack if necessary. The C +indicates the length of the string. Handles 'set' magic. Does not use +C. See also C, C and C. + +=for apidoc Am|void|mXPUSHn|NV nv +Push a double onto the stack, extending the stack if necessary. Handles +'set' magic. Does not use C. See also C, C and +C. + +=for apidoc Am|void|mXPUSHi|IV iv +Push an integer onto the stack, extending the stack if necessary. Handles +'set' magic. Does not use C. See also C, C and +C. + +=for apidoc Am|void|mXPUSHu|UV uv +Push an unsigned integer onto the stack, extending the stack if necessary. +Handles 'set' magic. Does not use C. See also C, C +and C. + +=cut +*/ + +#define EXTEND(p,n) STMT_START { if (PL_stack_max - p < (int)(n)) { \ sp = stack_grow(sp,p, (int) (n)); \ } } STMT_END /* Same thing, but update mark register too. */ -#define MEXTEND(p,n) STMT_START {if (PL_stack_max - p < (n)) { \ +#define MEXTEND(p,n) STMT_START {if (PL_stack_max - p < (int)(n)) { \ int markoff = mark - PL_stack_base; \ sp = stack_grow(sp,p,(int) (n)); \ mark = PL_stack_base + markoff; \ @@ -110,6 +307,18 @@ #define XPUSHu(u) STMT_START { sv_setuv(TARG, (UV)(u)); XPUSHTARG; } STMT_END #define XPUSHundef STMT_START { SvOK_off(TARG); XPUSHs(TARG); } STMT_END +#define PUSHmortal PUSHs(sv_newmortal()) +#define mPUSHp(p,l) sv_setpvn_mg(PUSHmortal, (p), (l)) +#define mPUSHn(n) sv_setnv_mg(PUSHmortal, (NV)(n)) +#define mPUSHi(i) sv_setiv_mg(PUSHmortal, (IV)(i)) +#define mPUSHu(u) sv_setuv_mg(PUSHmortal, (UV)(u)) + +#define XPUSHmortal XPUSHs(sv_newmortal()) +#define mXPUSHp(p,l) STMT_START { EXTEND(sp,1); sv_setpvn_mg(PUSHmortal, (p), (l)); } STMT_END +#define mXPUSHn(n) STMT_START { EXTEND(sp,1); sv_setnv_mg(PUSHmortal, (NV)(n)); } STMT_END +#define mXPUSHi(i) STMT_START { EXTEND(sp,1); sv_setiv_mg(PUSHmortal, (IV)(i)); } STMT_END +#define mXPUSHu(u) STMT_START { EXTEND(sp,1); sv_setuv_mg(PUSHmortal, (UV)(u)); } STMT_END + #define SETs(s) (*sp = s) #define SETTARG STMT_START { SvSETMAGIC(TARG); SETs(TARG); } STMT_END #define SETp(p,l) STMT_START { sv_setpvn(TARG, (p), (l)); SETTARG; } STMT_END @@ -218,6 +427,7 @@ if (PL_amagic_generation) { \ SV* tmpsv; \ SV* arg= sp[shift]; \ + if(0) goto am_again; /* shut up unused warning */ \ am_again: \ if ((SvAMAGIC(arg))&&\ (tmpsv=AMG_CALLun(arg,meth))) {\ @@ -231,14 +441,20 @@ #define tryAMAGICun(meth) tryAMAGICunW(meth,SETsvUN,0,RETURN) #define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs,0,RETURN) #define tryAMAGICunTARGET(meth, shift) \ - { dSP; sp--; /* get TARGET from below PL_stack_sp */ \ + STMT_START { 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)) \ - Perl_croak(aTHX_ "Overloaded dereference did not return a reference"); \ - goto am_again; + { dSP; tryAMAGICunW(meth,FORCE_SETs,shift,RETURN);}}} STMT_END + +#define setAGAIN(ref) \ + STMT_START { \ + sv = ref; \ + if (!SvROK(ref)) \ + Perl_croak(aTHX_ "Overloaded dereference did not return a reference"); \ + if (ref != arg && SvRV(ref) != SvRV(arg)) { \ + arg = ref; \ + goto am_again; \ + } \ + } STMT_END #define tryAMAGICunDEREF(meth) tryAMAGICunW(meth,setAGAIN,0,(void)0) @@ -260,6 +476,13 @@ changed SV* ref to SV* tmpRef */ #define RvDEEPCP(rv) STMT_START { SV* tmpRef=SvRV(rv); \ if (SvREFCNT(tmpRef)>1) { \ + SvRV_set(rv, AMG_CALLun(rv,copy)); \ SvREFCNT_dec(tmpRef); \ - SvRV(rv)=AMG_CALLun(rv,copy); \ } } STMT_END + +/* +=for apidoc mU||LVRET +True if this op will be the return value of an lvalue subroutine + +=cut */ +#define LVRET ((PL_op->op_private & OPpMAYBE_LVSUB) && is_lvalue_sub())