X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pp.h;h=40b16e6bf28ed15f95b8eeab23e063889b301fd7;hb=7ada78df9739acac44e6c9a8f1e08c978571e2a0;hp=9fd3365361c58dfdb1718f1516f2759362b138d8;hpb=cad2e5aadfceb1a406f657488ea1c699f44a1487;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/pp.h b/pp.h
index 9fd3365..40b16e6 100644
--- a/pp.h
+++ b/pp.h
@@ -1,22 +1,56 @@
 /*    pp.h
  *
- *    Copyright (c) 1991-1999, Larry Wall
+ *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
+ *    2000, 2001, 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<xsubpp>.  See C<dSP> and
+C<SPAGAIN>.
+
+=for apidoc AmU||MARK
+Stack marker variable for the XSUB.  See C<dMARK>.
+
+=for apidoc Am|void|PUSHMARK|SP
+Opening bracket for arguments on a callback.  See C<PUTBACK> and
+L<perlcall>.
+
+=for apidoc Ams||dSP
+Declares a local copy of perl's stack pointer for the XSUB, available via
+the C<SP> macro.  See C<SP>.
+
+=for apidoc ms||djSP
+
+Declare Just C<SP>. This is actually identical to C<dSP>, and declares
+a local copy of perl's stack pointer, available via the C<SP> macro.
+See C<SP>.  (Available for backward source code compatibility with the
+old (Perl 5.005) thread model.)
+
+=for apidoc Ams||dMARK
+Declare a stack marker variable, C<mark>, for the XSUB.  See C<MARK> and
+C<dORIGMARK>.
+
+=for apidoc Ams||dORIGMARK
+Saves the original stack mark for the XSUB.  See C<ORIGMARK>.
+
+=for apidoc AmU||ORIGMARK
+The original stack mark for the XSUB.  See C<dORIGMARK>.
+
+=for apidoc Ams||SPAGAIN
+Refetch the stack pointer.  Used after a callback.  See L<perlcall>.
+
+=cut */
+
+#undef SP /* Solaris 2.7 i386 has this in /usr/include/sys/reg.h */
 #define SP sp
 #define MARK mark
 #define TARG targ
@@ -28,8 +62,8 @@
 #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
@@ -52,6 +86,38 @@
 #define NORMAL PL_op->op_next
 #define DIE return Perl_die
 
+/*
+=for apidoc Ams||PUTBACK
+Closing bracket for XSUB arguments.  This is usually handled by C<xsubpp>.
+See C<PUSHMARK> and L<perlcall> 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
 #define RETURNOP(o)	return PUTBACK, o
@@ -60,26 +126,163 @@
 #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))
 #define POPl		((long)SvIVx(POPs))
+#define POPul		((unsigned long)SvIVx(POPs))
+#ifdef HAS_QUAD
+#define POPq		((Quad_t)SvIVx(POPs))
+#define POPuq		((Uquad_t)SvUVx(POPs))
+#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))
 #define TOPi		((IV)SvIV(TOPs))
 #define TOPu		((UV)SvUV(TOPs))
 #define TOPl		((long)SvIV(TOPs))
+#define TOPul		((unsigned long)SvUV(TOPs))
+#ifdef HAS_QUAD
+#define TOPq		((Quad_t)SvIV(TOPs))
+#define TOPuq		((Uquad_t)SvUV(TOPs))
+#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<nitems> 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<TARG>.  See also C<PUSHmortal>,
+C<XPUSHs> and C<XPUSHmortal>.
+
+=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<len> indicates the length of the string.  Handles 'set' magic.  Uses
+C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not
+call multiple C<TARG>-oriented macros to return lists from XSUB's - see
+C<mPUSHp> instead.  See also C<XPUSHp> and C<mXPUSHp>.
+
+=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<TARG>, so C<dTARGET> or C<dXSTARG> should be
+called to declare it.  Do not call multiple C<TARG>-oriented macros to
+return lists from XSUB's - see C<mPUSHn> instead.  See also C<XPUSHn> and
+C<mXPUSHn>.
+
+=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<TARG>, so C<dTARGET> or C<dXSTARG> should be
+called to declare it.  Do not call multiple C<TARG>-oriented macros to 
+return lists from XSUB's - see C<mPUSHi> instead.  See also C<XPUSHi> and
+C<mXPUSHi>.
+
+=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<TARG>, so C<dTARGET> or C<dXSTARG>
+should be called to declare it.  Do not call multiple C<TARG>-oriented
+macros to return lists from XSUB's - see C<mPUSHu> instead.  See also
+C<XPUSHu> and C<mXPUSHu>.
+
+=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<TARG>.  See also C<XPUSHmortal>,
+C<PUSHs> and C<PUSHmortal>.
+
+=for apidoc Am|void|XPUSHp|char* str|STRLEN len
+Push a string onto the stack, extending the stack if necessary.  The C<len>
+indicates the length of the string.  Handles 'set' magic.  Uses C<TARG>, so
+C<dTARGET> or C<dXSTARG> should be called to declare it.  Do not call
+multiple C<TARG>-oriented macros to return lists from XSUB's - see
+C<mXPUSHp> instead.  See also C<PUSHp> and C<mPUSHp>.
+
+=for apidoc Am|void|XPUSHn|NV nv
+Push a double onto the stack, extending the stack if necessary.  Handles
+'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
+declare it.  Do not call multiple C<TARG>-oriented macros to return lists
+from XSUB's - see C<mXPUSHn> instead.  See also C<PUSHn> and C<mPUSHn>.
+
+=for apidoc Am|void|XPUSHi|IV iv
+Push an integer onto the stack, extending the stack if necessary.  Handles
+'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be called to
+declare it.  Do not call multiple C<TARG>-oriented macros to return lists
+from XSUB's - see C<mXPUSHi> instead.  See also C<PUSHi> and C<mPUSHi>.
+
+=for apidoc Am|void|XPUSHu|UV uv
+Push an unsigned integer onto the stack, extending the stack if necessary.
+Handles 'set' magic.  Uses C<TARG>, so C<dTARGET> or C<dXSTARG> should be
+called to declare it.  Do not call multiple C<TARG>-oriented macros to
+return lists from XSUB's - see C<mXPUSHu> instead.  See also C<PUSHu> and
+C<mPUSHu>.
+
+=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<TARG>.  See also
+C<PUSHs>, C<XPUSHmortal> and C<XPUSHs>.
+
+=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<len> indicates the length of the string.  Handles 'set' magic.  Does
+not use C<TARG>.  See also C<PUSHp>, C<mXPUSHp> and C<XPUSHp>.
+
+=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<TARG>.  See also C<PUSHn>, C<mXPUSHn>
+and C<XPUSHn>.
+
+=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<TARG>.  See also C<PUSHi>, C<mXPUSHi>
+and C<XPUSHi>.
+
+=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<TARG>.  See also C<PUSHu>,
+C<mXPUSHu> and C<XPUSHu>.
+
+=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<TARG>.  See also C<XPUSHs>,
+C<PUSHmortal> and C<PUSHs>.
+
+=for apidoc Am|void|mXPUSHp|char* str|STRLEN len
+Push a string onto the stack, extending the stack if necessary.  The C<len>
+indicates the length of the string.  Handles 'set' magic.  Does not use
+C<TARG>.  See also C<XPUSHp>, C<mPUSHp> and C<PUSHp>.
+
+=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<TARG>.  See also C<XPUSHn>, C<mPUSHn> and
+C<PUSHn>.
+
+=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<TARG>.  See also C<XPUSHi>, C<mPUSHi> and
+C<PUSHi>.
+
+=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<TARG>.  See also C<XPUSHu>, C<mPUSHu>
+and C<PUSHu>.
+
+=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;		\
@@ -98,6 +301,19 @@
 #define XPUSHn(n)	STMT_START { sv_setnv(TARG, (NV)(n)); XPUSHTARG; } STMT_END
 #define XPUSHi(i)	STMT_START { sv_setiv(TARG, (IV)(i)); XPUSHTARG; } STMT_END
 #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
@@ -114,6 +330,12 @@
 #define dPOPiv		IV value = POPi
 #define dTOPuv		UV value = TOPu
 #define dPOPuv		UV value = POPu
+#ifdef HAS_QUAD
+#define dTOPqv		Quad_t value = TOPu
+#define dPOPqv		Quad_t value = POPu
+#define dTOPuqv		Uquad_t value = TOPuq
+#define dPOPuqv		Uquad_t value = POPuq
+#endif
 
 #define dPOPXssrl(X)	SV *right = POPs; SV *left = CAT2(X,s)
 #define dPOPXnnrl(X)	NV right = POPn; NV left = CAT2(X,n)
@@ -151,7 +373,9 @@
 #define RETSETUNDEF	RETURNX(SETs(&PL_sv_undef))
 
 #define ARGTARG		PL_op->op_targ
-#define MAXARG		PL_op->op_private
+
+    /* See OPpTARGET_MY: */
+#define MAXARG		(PL_op->op_private & 15)
 
 #define SWITCHSTACK(f,t) \
     STMT_START {							\
@@ -199,6 +423,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))) {\
@@ -209,23 +434,32 @@
 
 #define FORCE_SETs(sv) STMT_START { sv_setsv(TARG, (sv)); SETTARG; } STMT_END
 
-#define tryAMAGICun	tryAMAGICunSET
-#define tryAMAGICunSET(meth) tryAMAGICunW(meth,SETs,0,RETURN)
+#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 */		\
 	    { dTARGETSTACKED; 						\
 		{ dSP; tryAMAGICunW(meth,FORCE_SETs,shift,RETURN);}}}
 
-#define setAGAIN(ref) sv = arg = ref;					\
-  if (!SvROK(ref))							\
+#define setAGAIN(ref) sv = ref;							\
+  if (!SvROK(ref))								\
       Perl_croak(aTHX_ "Overloaded dereference did not return a reference");	\
-  goto am_again;
+  if (ref != arg && SvRV(ref) != SvRV(arg)) {					\
+      arg = ref;								\
+      goto am_again;								\
+  }
 
 #define tryAMAGICunDEREF(meth) tryAMAGICunW(meth,setAGAIN,0,(void)0)
 
 #define opASSIGN (PL_op->op_flags & OPf_STACKED)
 #define SETsv(sv)	STMT_START {					\
-		if (opASSIGN) { sv_setsv(TARG, (sv)); SETTARG; }	\
+		if (opASSIGN || (SvFLAGS(TARG) & SVs_PADMY))		\
+		   { sv_setsv(TARG, (sv)); SETTARG; }			\
+		else SETs(sv); } STMT_END
+
+#define SETsvUN(sv)	STMT_START {					\
+		if (SvFLAGS(TARG) & SVs_PADMY)		\
+		   { sv_setsv(TARG, (sv)); SETTARG; }			\
 		else SETs(sv); } STMT_END
 
 /* newSVsv does not behave as advertised, so we copy missing
@@ -235,6 +469,13 @@
    changed SV* ref to SV* tmpRef */
 #define RvDEEPCP(rv) STMT_START { SV* tmpRef=SvRV(rv);      \
   if (SvREFCNT(tmpRef)>1) {                 \
+    SvRV(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())