perl-5.6.0 + local changes

1 files changed, 201 insertions, 64 deletions

diff --git a/gnu/usr.bin/perl/cop.h b/gnu/usr.bin/perl/cop.h
index 7d6730fb966..e588675012a 100644
--- a/gnu/usr.bin/perl/cop.h
+++ b/gnu/usr.bin/perl/cop.h
@@ -1,6 +1,6 @@
 /*    cop.h
  *
- *    Copyright (c) 1991-1999, Larry Wall
+ *    Copyright (c) 1991-2000, Larry Wall
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -10,15 +10,59 @@
 struct cop {
     BASEOP
     char *	cop_label;	/* label for this construct */
+#ifdef USE_ITHREADS
+    char *	cop_stashpv;	/* package line was compiled in */
+    char *	cop_file;	/* file name the following line # is from */
+#else
     HV *	cop_stash;	/* package line was compiled in */
     GV *	cop_filegv;	/* file the following line # is from */
+#endif
     U32		cop_seq;	/* parse sequence number */
     I32		cop_arybase;	/* array base this line was compiled with */
     line_t      cop_line;       /* line # of this command */
+    SV *	cop_warnings;	/* lexical warnings bitmask */
 };
 
 #define Nullcop Null(COP*)
 
+#ifdef USE_ITHREADS
+#  define CopFILE(c)		((c)->cop_file)
+#  define CopFILEGV(c)		(CopFILE(c) \
+				 ? gv_fetchfile(CopFILE(c)) : Nullgv)
+#  define CopFILE_set(c,pv)	((c)->cop_file = savepv(pv))	/* XXX */
+#  define CopFILESV(c)		(CopFILE(c) \
+				 ? GvSV(gv_fetchfile(CopFILE(c))) : Nullsv)
+#  define CopFILEAV(c)		(CopFILE(c) \
+				 ? GvAV(gv_fetchfile(CopFILE(c))) : Nullav)
+#  define CopSTASHPV(c)		((c)->cop_stashpv)
+#  define CopSTASHPV_set(c,pv)	((c)->cop_stashpv = savepv(pv))	/* XXX */
+#  define CopSTASH(c)		(CopSTASHPV(c) \
+				 ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)
+#  define CopSTASH_set(c,hv)	CopSTASHPV_set(c, HvNAME(hv))
+#  define CopSTASH_eq(c,hv)	(hv 					\
+				 && (CopSTASHPV(c) == HvNAME(hv)	\
+				     || (CopSTASHPV(c) && HvNAME(hv)	\
+					 && strEQ(CopSTASHPV(c), HvNAME(hv)))))
+#else
+#  define CopFILEGV(c)		((c)->cop_filegv)
+#  define CopFILEGV_set(c,gv)	((c)->cop_filegv = gv)
+#  define CopFILE_set(c,pv)	((c)->cop_filegv = gv_fetchfile(pv))
+#  define CopFILESV(c)		(CopFILEGV(c) ? GvSV(CopFILEGV(c)) : Nullsv)
+#  define CopFILEAV(c)		(CopFILEGV(c) ? GvAV(CopFILEGV(c)) : Nullav)
+#  define CopFILE(c)		(CopFILESV(c) ? SvPVX(CopFILESV(c)) : Nullch)
+#  define CopSTASH(c)		((c)->cop_stash)
+#  define CopSTASH_set(c,hv)	((c)->cop_stash = hv)
+#  define CopSTASHPV(c)		(CopSTASH(c) ? HvNAME(CopSTASH(c)) : Nullch)
+#  define CopSTASHPV_set(c,pv)	CopSTASH_set(c, gv_stashpv(pv,GV_ADD))
+#  define CopSTASH_eq(c,hv)	(CopSTASH(c) == hv)
+#endif /* USE_ITHREADS */
+
+#define CopSTASH_ne(c,hv)	(!CopSTASH_eq(c,hv))
+#define CopLINE(c)		((c)->cop_line)
+#define CopLINE_inc(c)		(++CopLINE(c))
+#define CopLINE_dec(c)		(--CopLINE(c))
+#define CopLINE_set(c,l)	(CopLINE(c) = (l))
+
 /*
  * Here we have some enormously heavy (or at least ponderous) wizardry.
  */
@@ -34,12 +78,15 @@ struct block_sub {
     AV *	argarray;
     U16		olddepth;
     U8		hasargs;
+    U8		lval;		/* XXX merge lval and hasargs? */
 };
 
 #define PUSHSUB(cx)							\
 	cx->blk_sub.cv = cv;						\
 	cx->blk_sub.olddepth = CvDEPTH(cv);				\
-	cx->blk_sub.hasargs = hasargs;
+	cx->blk_sub.hasargs = hasargs;					\
+	cx->blk_sub.lval = PL_op->op_private &                          \
+	                      (OPpLVAL_INTRO|OPpENTERSUB_INARGS);
 
 #define PUSHFORMAT(cx)							\
 	cx->blk_sub.cv = cv;						\
@@ -48,35 +95,51 @@ struct block_sub {
 	cx->blk_sub.dfoutgv = PL_defoutgv;				\
 	(void)SvREFCNT_inc(cx->blk_sub.dfoutgv)
 
-#define POPSUB(cx)							\
-	{ struct block_sub cxsub;					\
-	  POPSUB1(cx);							\
-	  POPSUB2(); }
-
-#define POPSUB1(cx)							\
-	cxsub = cx->blk_sub;	/* because DESTROY may clobber *cx */
-
 #ifdef USE_THREADS
-#define POPSAVEARRAY() NOOP
+#  define POP_SAVEARRAY() NOOP
 #else
-#define POPSAVEARRAY()							\
+#  define POP_SAVEARRAY()						\
     STMT_START {							\
 	SvREFCNT_dec(GvAV(PL_defgv));					\
-	GvAV(PL_defgv) = cxsub.savearray;					\
+	GvAV(PL_defgv) = cx->blk_sub.savearray;				\
     } STMT_END
 #endif /* USE_THREADS */
 
-#define POPSUB2()							\
-	if (cxsub.hasargs) {						\
-	    POPSAVEARRAY();						\
-	    /* destroy arg array */					\
-	    av_clear(cxsub.argarray);					\
-	    AvREAL_off(cxsub.argarray);					\
+#ifdef USE_ITHREADS
+   /* junk in @_ spells trouble when cloning CVs, so don't leave any */
+#  define CLEAR_ARGARRAY()	av_clear(cx->blk_sub.argarray)
+#else
+#  define CLEAR_ARGARRAY()	NOOP
+#endif /* USE_ITHREADS */
+
+
+#define POPSUB(cx,sv)							\
+    STMT_START {							\
+	if (cx->blk_sub.hasargs) {					\
+	    POP_SAVEARRAY();						\
+	    /* abandon @_ if it got reified */				\
+	    if (AvREAL(cx->blk_sub.argarray)) {				\
+		SSize_t fill = AvFILLp(cx->blk_sub.argarray);		\
+		SvREFCNT_dec(cx->blk_sub.argarray);			\
+		cx->blk_sub.argarray = newAV();				\
+		av_extend(cx->blk_sub.argarray, fill);			\
+		AvFLAGS(cx->blk_sub.argarray) = AVf_REIFY;		\
+		PL_curpad[0] = (SV*)cx->blk_sub.argarray;		\
+	    }								\
+	    else {							\
+		CLEAR_ARGARRAY();					\
+	    }								\
 	}								\
-	if (cxsub.cv) {							\
-	    if (!(CvDEPTH(cxsub.cv) = cxsub.olddepth))			\
-		SvREFCNT_dec(cxsub.cv);					\
-	}
+	sv = (SV*)cx->blk_sub.cv;					\
+	if (sv && (CvDEPTH((CV*)sv) = cx->blk_sub.olddepth))		\
+	    sv = Nullsv;						\
+    } STMT_END
+
+#define LEAVESUB(sv)							\
+    STMT_START {							\
+	if (sv)								\
+	    SvREFCNT_dec(sv);						\
+    } STMT_END
 
 #define POPFORMAT(cx)							\
 	setdefout(cx->blk_sub.dfoutgv);					\
@@ -86,22 +149,28 @@ struct block_sub {
 struct block_eval {
     I32		old_in_eval;
     I32		old_op_type;
-    char *	old_name;
+    SV *	old_namesv;
     OP *	old_eval_root;
     SV *	cur_text;
 };
 
 #define PUSHEVAL(cx,n,fgv)						\
+    STMT_START {							\
 	cx->blk_eval.old_in_eval = PL_in_eval;				\
-	cx->blk_eval.old_op_type = PL_op->op_type;				\
-	cx->blk_eval.old_name = n;					\
-	cx->blk_eval.old_eval_root = PL_eval_root;				\
-	cx->blk_eval.cur_text = PL_linestr;
+	cx->blk_eval.old_op_type = PL_op->op_type;			\
+	cx->blk_eval.old_namesv = (n ? newSVpv(n,0) : Nullsv);		\
+	cx->blk_eval.old_eval_root = PL_eval_root;			\
+	cx->blk_eval.cur_text = PL_linestr;				\
+    } STMT_END
 
 #define POPEVAL(cx)							\
+    STMT_START {							\
 	PL_in_eval = cx->blk_eval.old_in_eval;				\
 	optype = cx->blk_eval.old_op_type;				\
-	PL_eval_root = cx->blk_eval.old_eval_root;
+	PL_eval_root = cx->blk_eval.old_eval_root;			\
+	if (cx->blk_eval.old_namesv)					\
+	    sv_2mortal(cx->blk_eval.old_namesv);			\
+    } STMT_END
 
 /* loop context */
 struct block_loop {
@@ -110,7 +179,12 @@ struct block_loop {
     OP *	redo_op;
     OP *	next_op;
     OP *	last_op;
+#ifdef USE_ITHREADS
+    void *	iterdata;
+    SV **	oldcurpad;
+#else
     SV **	itervar;
+#endif
     SV *	itersave;
     SV *	iterlval;
     AV *	iterary;
@@ -118,35 +192,44 @@ struct block_loop {
     IV		itermax;
 };
 
-#define PUSHLOOP(cx, ivar, s)						\
-	cx->blk_loop.label = PL_curcop->cop_label;				\
-	cx->blk_loop.resetsp = s - PL_stack_base;				\
+#ifdef USE_ITHREADS
+#  define CxITERVAR(c)							\
+	((c)->blk_loop.iterdata						\
+	 ? (CxPADLOOP(cx) 						\
+	    ? &((c)->blk_loop.oldcurpad)[(PADOFFSET)(c)->blk_loop.iterdata]	\
+	    : &GvSV((GV*)(c)->blk_loop.iterdata))			\
+	 : (SV**)NULL)
+#  define CX_ITERDATA_SET(cx,idata)					\
+	cx->blk_loop.oldcurpad = PL_curpad;				\
+	if ((cx->blk_loop.iterdata = (idata)))				\
+	    cx->blk_loop.itersave = SvREFCNT_inc(*CxITERVAR(cx));
+#else
+#  define CxITERVAR(c)		((c)->blk_loop.itervar)
+#  define CX_ITERDATA_SET(cx,ivar)					\
+	if ((cx->blk_loop.itervar = (SV**)(ivar)))			\
+	    cx->blk_loop.itersave = SvREFCNT_inc(*CxITERVAR(cx));
+#endif
+
+#define PUSHLOOP(cx, dat, s)						\
+	cx->blk_loop.label = PL_curcop->cop_label;			\
+	cx->blk_loop.resetsp = s - PL_stack_base;			\
 	cx->blk_loop.redo_op = cLOOP->op_redoop;			\
 	cx->blk_loop.next_op = cLOOP->op_nextop;			\
 	cx->blk_loop.last_op = cLOOP->op_lastop;			\
-	if (cx->blk_loop.itervar = (ivar))				\
-	    cx->blk_loop.itersave = SvREFCNT_inc(*cx->blk_loop.itervar);\
 	cx->blk_loop.iterlval = Nullsv;					\
 	cx->blk_loop.iterary = Nullav;					\
-	cx->blk_loop.iterix = -1;
+	cx->blk_loop.iterix = -1;					\
+	CX_ITERDATA_SET(cx,dat);
 
 #define POPLOOP(cx)							\
-	{ struct block_loop cxloop;					\
-	  POPLOOP1(cx);							\
-	  POPLOOP2(); }
-
-#define POPLOOP1(cx)							\
-	cxloop = cx->blk_loop;	/* because DESTROY may clobber *cx */	\
-	newsp = PL_stack_base + cxloop.resetsp;
-
-#define POPLOOP2()							\
-	SvREFCNT_dec(cxloop.iterlval);					\
-	if (cxloop.itervar) {						\
-	    sv_2mortal(*cxloop.itervar);				\
-	    *cxloop.itervar = cxloop.itersave;				\
+	SvREFCNT_dec(cx->blk_loop.iterlval);				\
+	if (CxITERVAR(cx)) {						\
+	    SV **s_v_p = CxITERVAR(cx);					\
+	    sv_2mortal(*s_v_p);						\
+	    *s_v_p = cx->blk_loop.itersave;				\
 	}								\
-	if (cxloop.iterary && cxloop.iterary != PL_curstack)		\
-	    SvREFCNT_dec(cxloop.iterary);
+	if (cx->blk_loop.iterary && cx->blk_loop.iterary != PL_curstack)\
+	    SvREFCNT_dec(cx->blk_loop.iterary);
 
 /* context common to subroutines, evals and loops */
 struct block {
@@ -185,8 +268,8 @@ struct block {
 	cx->blk_oldretsp	= PL_retstack_ix,			\
 	cx->blk_oldpm		= PL_curpm,				\
 	cx->blk_gimme		= gimme;				\
-	DEBUG_l( PerlIO_printf(PerlIO_stderr(), "Entering block %ld, type %s\n",	\
-		    (long)cxstack_ix, block_type[CxTYPE(cx)]); )
+	DEBUG_l( PerlIO_printf(Perl_debug_log, "Entering block %ld, type %s\n",	\
+		    (long)cxstack_ix, PL_block_type[CxTYPE(cx)]); )
 
 /* Exit a block (RETURN and LAST). */
 #define POPBLOCK(cx,pm) cx = &cxstack[cxstack_ix--],			\
@@ -197,8 +280,8 @@ struct block {
 	PL_retstack_ix	 = cx->blk_oldretsp,				\
 	pm		 = cx->blk_oldpm,				\
 	gimme		 = cx->blk_gimme;				\
-	DEBUG_l( PerlIO_printf(PerlIO_stderr(), "Leaving block %ld, type %s\n",		\
-		    (long)cxstack_ix+1,block_type[CxTYPE(cx)]); )
+	DEBUG_l( PerlIO_printf(Perl_debug_log, "Leaving block %ld, type %s\n",		\
+		    (long)cxstack_ix+1,PL_block_type[CxTYPE(cx)]); )
 
 /* Continue a block elsewhere (NEXT and REDO). */
 #define TOPBLOCK(cx) cx  = &cxstack[cxstack_ix],			\
@@ -212,7 +295,7 @@ struct block {
 struct subst {
     I32		sbu_iters;
     I32		sbu_maxiters;
-    I32		sbu_safebase;
+    I32		sbu_rflags;
     I32		sbu_oldsave;
     bool	sbu_once;
     bool	sbu_rxtainted;
@@ -227,7 +310,7 @@ struct subst {
 };
 #define sb_iters	cx_u.cx_subst.sbu_iters
 #define sb_maxiters	cx_u.cx_subst.sbu_maxiters
-#define sb_safebase	cx_u.cx_subst.sbu_safebase
+#define sb_rflags	cx_u.cx_subst.sbu_rflags
 #define sb_oldsave	cx_u.cx_subst.sbu_oldsave
 #define sb_once		cx_u.cx_subst.sbu_once
 #define sb_rxtainted	cx_u.cx_subst.sbu_rxtainted
@@ -243,7 +326,7 @@ struct subst {
 #define PUSHSUBST(cx) CXINC, cx = &cxstack[cxstack_ix],			\
 	cx->sb_iters		= iters,				\
 	cx->sb_maxiters		= maxiters,				\
-	cx->sb_safebase		= safebase,				\
+	cx->sb_rflags		= r_flags,				\
 	cx->sb_oldsave		= oldsave,				\
 	cx->sb_once		= once,					\
 	cx->sb_rxtainted	= rxtainted,				\
@@ -276,27 +359,77 @@ struct context {
 #define CXt_LOOP	3
 #define CXt_SUBST	4
 #define CXt_BLOCK	5
+#define CXt_FORMAT	6
 
 /* private flags for CXt_EVAL */
 #define CXp_REAL	0x00000100	/* truly eval'', not a lookalike */
+#define CXp_TRYBLOCK	0x00000200	/* eval{}, not eval'' or similar */
+
+#ifdef USE_ITHREADS
+/* private flags for CXt_LOOP */
+#  define CXp_PADVAR	0x00000100	/* itervar lives on pad, iterdata
+					   has pad offset; if not set,
+					   iterdata holds GV* */
+#  define CxPADLOOP(c)	(((c)->cx_type & (CXt_LOOP|CXp_PADVAR))		\
+			 == (CXt_LOOP|CXp_PADVAR))
+#endif
 
 #define CxTYPE(c)	((c)->cx_type & CXTYPEMASK)
-#define CxREALEVAL(c)	(((c)->cx_type & (CXt_EVAL|CXp_REAL)) == (CXt_EVAL|CXp_REAL))
+#define CxREALEVAL(c)	(((c)->cx_type & (CXt_EVAL|CXp_REAL))		\
+			 == (CXt_EVAL|CXp_REAL))
+#define CxTRYBLOCK(c)	(((c)->cx_type & (CXt_EVAL|CXp_TRYBLOCK))	\
+			 == (CXt_EVAL|CXp_TRYBLOCK))
 
 #define CXINC (cxstack_ix < cxstack_max ? ++cxstack_ix : (cxstack_ix = cxinc()))
 
 /* "gimme" values */
+
+/*
+=for apidoc AmU||G_SCALAR
+Used to indicate scalar context.  See C<GIMME_V>, C<GIMME>, and
+L<perlcall>.
+
+=for apidoc AmU||G_ARRAY
+Used to indicate array context.  See C<GIMME_V>, C<GIMME> and
+L<perlcall>.
+
+=for apidoc AmU||G_VOID
+Used to indicate void context.  See C<GIMME_V> and L<perlcall>.
+
+=for apidoc AmU||G_DISCARD
+Indicates that arguments returned from a callback should be discarded.  See
+L<perlcall>.
+
+=for apidoc AmU||G_EVAL
+
+Used to force a Perl C<eval> wrapper around a callback.  See
+L<perlcall>.
+
+=for apidoc AmU||G_NOARGS
+
+Indicates that no arguments are being sent to a callback.  See
+L<perlcall>.
+
+=cut
+*/
+
 #define G_SCALAR	0
 #define G_ARRAY		1
 #define G_VOID		128	/* skip this bit when adding flags below */
 
-/* extra flags for perl_call_* routines */
+/* extra flags for Perl_call_* routines */
 #define G_DISCARD	2	/* Call FREETMPS. */
 #define G_EVAL		4	/* Assume eval {} around subroutine call. */
 #define G_NOARGS	8	/* Don't construct a @_ array. */
 #define G_KEEPERR      16	/* Append errors to $@, don't overwrite it */
 #define G_NODEBUG      32	/* Disable debugging at toplevel.  */
 
+/* flag bits for PL_in_eval */
+#define EVAL_NULL	0	/* not in an eval */
+#define EVAL_INEVAL	1	/* some enclosing scope is an eval */
+#define EVAL_WARNONLY	2	/* used by yywarn() when calling yyerror() */
+#define EVAL_KEEPERR	4	/* set by Perl_call_sv if G_KEEPERR */
+
 /* Support for switching (stack and block) contexts.
  * This ensures magic doesn't invalidate local stack and cx pointers.
  */
@@ -321,7 +454,7 @@ struct stackinfo {
     I32			si_type;	/* type of runlevel */
     struct stackinfo *	si_prev;
     struct stackinfo *	si_next;
-    I32 *		si_markbase;	/* where markstack begins for us.
+    I32			si_markoff;	/* offset where markstack begins for us.
 					 * currently used only with DEBUGGING,
 					 * but not #ifdef-ed for bincompat */
 };
@@ -333,9 +466,10 @@ typedef struct stackinfo PERL_SI;
 #define cxstack_max	(PL_curstackinfo->si_cxmax)
 
 #ifdef DEBUGGING
-#  define	SET_MARKBASE PL_curstackinfo->si_markbase = PL_markstack_ptr
+#  define	SET_MARK_OFFSET \
+    PL_curstackinfo->si_markoff = PL_markstack_ptr - PL_markstack
 #else
-#  define	SET_MARKBASE NOOP
+#  define	SET_MARK_OFFSET NOOP
 #endif
 
 #define PUSHSTACKi(type) \
@@ -351,16 +485,19 @@ typedef struct stackinfo PERL_SI;
 	AvFILLp(next->si_stack) = 0;					\
 	SWITCHSTACK(PL_curstack,next->si_stack);			\
 	PL_curstackinfo = next;						\
-	SET_MARKBASE;							\
+	SET_MARK_OFFSET;						\
     } STMT_END
 
 #define PUSHSTACK PUSHSTACKi(PERLSI_UNKNOWN)
 
+/* POPSTACK works with PL_stack_sp, so it may need to be bracketed by
+ * PUTBACK/SPAGAIN to flush/refresh any local SP that may be active */
 #define POPSTACK \
     STMT_START {							\
+	djSP;								\
 	PERL_SI *prev = PL_curstackinfo->si_prev;			\
 	if (!prev) {							\
-	    PerlIO_printf(PerlIO_stderr(), "panic: POPSTACK\n");	\
+	    PerlIO_printf(Perl_error_log, "panic: POPSTACK\n");		\
 	    my_exit(1);							\
 	}								\
 	SWITCHSTACK(PL_curstack,prev->si_stack);			\