/*    cop.h * *    Copyright (c) 1991-2001, 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. * */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))#  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 = ((pv) ? savepv(pv) : Nullch))#  define CopSTASH(c)		(CopSTASHPV(c) \				 ? gv_stashpv(CopSTASHPV(c),GV_ADD) : Nullhv)#  define CopSTASH_set(c,hv)	CopSTASHPV_set(c, (hv) ? HvNAME(hv) : Nullch)#  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*)SvREFCNT_inc(gv))#  define CopFILE_set(c,pv)	CopFILEGV_set((c), 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)   /* cop_stash is not refcounted */#  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. *//* subroutine context */struct block_sub {    CV *	cv;    GV *	gv;    GV *	dfoutgv;#ifndef USE_THREADS    AV *	savearray;#endif /* USE_THREADS */    AV *	argarray;    U16		olddepth;    U8		hasargs;    U8		lval;		/* XXX merge lval and hasargs? */    SV **	oldcurpad;};#define PUSHSUB(cx)							\	cx->blk_sub.cv = cv;						\	cx->blk_sub.olddepth = CvDEPTH(cv);				\	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;						\	cx->blk_sub.gv = gv;						\	cx->blk_sub.hasargs = 0;					\	cx->blk_sub.dfoutgv = PL_defoutgv;				\	(void)SvREFCNT_inc(cx->blk_sub.dfoutgv)#ifdef USE_THREADS#  define POP_SAVEARRAY() NOOP#else#  define POP_SAVEARRAY()						\    STMT_START {							\	SvREFCNT_dec(GvAV(PL_defgv));					\	GvAV(PL_defgv) = cx->blk_sub.savearray;				\    } STMT_END#endif /* USE_THREADS *//* junk in @_ spells trouble when cloning CVs and in pp_caller(), so don't * leave any (a fast av_clear(ary), basically) */#define CLEAR_ARGARRAY(ary) \    STMT_START {							\	AvMAX(ary) += AvARRAY(ary) - AvALLOC(ary);			\	SvPVX(ary) = (char*)AvALLOC(ary);				\	AvFILLp(ary) = -1;						\    } STMT_END#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;		\		cx->blk_sub.oldcurpad[0] = (SV*)cx->blk_sub.argarray;	\	    }								\	    else {							\		CLEAR_ARGARRAY(cx->blk_sub.argarray);			\	    }								\	}								\	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);					\	SvREFCNT_dec(cx->blk_sub.dfoutgv);/* eval context */struct block_eval {    I32		old_in_eval;    I32		old_op_type;    SV *	old_namesv;    OP *	old_eval_root;    SV *	cur_text;    CV *	cv;};#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_namesv = (n ? newSVpv(n,0) : Nullsv);		\	cx->blk_eval.old_eval_root = PL_eval_root;			\	cx->blk_eval.cur_text = PL_linestr;				\	cx->blk_eval.cv = Nullcv; /* set by doeval(), as applicable */	\    } 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;			\	if (cx->blk_eval.old_namesv)					\	    sv_2mortal(cx->blk_eval.old_namesv);			\    } STMT_END/* loop context */struct block_loop {    char *	label;    I32		resetsp;    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;    IV		iterix;    IV		itermax;};#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;			\	cx->blk_loop.iterlval = Nullsv;					\	cx->blk_loop.iterary = Nullav;					\	cx->blk_loop.iterix = -1;					\	CX_ITERDATA_SET(cx,dat);#define POPLOOP(cx)							\	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 (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 {    I32		blku_oldsp;	/* stack pointer to copy stuff down to */    COP *	blku_oldcop;	/* old curcop pointer */    I32		blku_oldretsp;	/* return stack index */    I32		blku_oldmarksp;	/* mark stack index */    I32		blku_oldscopesp;	/* scope stack index */    PMOP *	blku_oldpm;	/* values of pattern match vars */    U8		blku_gimme;	/* is this block running in list context? */    union {	struct block_sub	blku_sub;	struct block_eval	blku_eval;	struct block_loop	blku_loop;    } blk_u;};#define blk_oldsp	cx_u.cx_blk.blku_oldsp#define blk_oldcop	cx_u.cx_blk.blku_oldcop#define blk_oldretsp	cx_u.cx_blk.blku_oldretsp#define blk_oldmarksp	cx_u.cx_blk.blku_oldmarksp#define blk_oldscopesp	cx_u.cx_blk.blku_oldscopesp#define blk_oldpm	cx_u.cx_blk.blku_oldpm#define blk_gimme	cx_u.cx_blk.blku_gimme