[perl5.git] / pad.h

/*    pad.h
 *
 *    Copyright (C) 2002, 2003, 2005, 2006, 2007 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.
 *
 * This file defines the types and macros associated with the API for
 * manipulating scratchpads, which are used by perl to store lexical
 * variables, op targets and constants.
 */


/* a padlist is currently just an AV; but that might change,
 * so hide the type. Ditto a pad.  */

typedef AV PADLIST;
typedef AV PAD;


/* offsets within a pad */

#if PTRSIZE == 4
typedef U32TYPE PADOFFSET;
#else
#   if PTRSIZE == 8
typedef U64TYPE PADOFFSET;
#   endif
#endif
#define NOT_IN_PAD ((PADOFFSET) -1)

/* B.xs needs these for the benefit of B::Deparse */ 
/* Low range end is exclusive (valid from the cop seq after this one) */
/* High range end is inclusive (valid up to this cop seq) */

#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
#  define COP_SEQ_RANGE_LOW(sv)						\
	(({ SV *const _svi = (SV *) (sv);				\
	  assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);	\
	  assert(SvTYPE(_svi) != SVt_PVAV);				\
	  assert(SvTYPE(_svi) != SVt_PVHV);				\
	  assert(SvTYPE(_svi) != SVt_PVCV);				\
	  assert(SvTYPE(_svi) != SVt_PVFM);				\
	  assert(!isGV_with_GP(_svi));					\
	  ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xlow;		\
	 }))
#  define COP_SEQ_RANGE_HIGH(sv)					\
	(({ SV *const _svi = (SV *) (sv);				\
	  assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);	\
	  assert(SvTYPE(_svi) != SVt_PVAV);				\
	  assert(SvTYPE(_svi) != SVt_PVHV);				\
	  assert(SvTYPE(_svi) != SVt_PVCV);				\
	  assert(SvTYPE(_svi) != SVt_PVFM);				\
	  assert(!isGV_with_GP(_svi));					\
	  ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xhigh;		\
	 }))
#  define PARENT_PAD_INDEX(sv)						\
	(({ SV *const _svi = (SV *) (sv);				\
	  assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);	\
	  assert(SvTYPE(_svi) != SVt_PVAV);				\
	  assert(SvTYPE(_svi) != SVt_PVHV);				\
	  assert(SvTYPE(_svi) != SVt_PVCV);				\
	  assert(SvTYPE(_svi) != SVt_PVFM);				\
	  assert(!isGV_with_GP(_svi));					\
	  ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xlow;		\
	 }))
#  define PARENT_FAKELEX_FLAGS(sv)					\
	(({ SV *const _svi = (SV *) (sv);				\
	  assert(SvTYPE(_svi) == SVt_NV || SvTYPE(_svi) >= SVt_PVNV);	\
	  assert(SvTYPE(_svi) != SVt_PVAV);				\
	  assert(SvTYPE(_svi) != SVt_PVHV);				\
	  assert(SvTYPE(_svi) != SVt_PVCV);				\
	  assert(SvTYPE(_svi) != SVt_PVFM);				\
	  assert(!isGV_with_GP(_svi));					\
	  ((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xhigh;		\
	 }))
#else
#  define COP_SEQ_RANGE_LOW(sv)		\
	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
#  define COP_SEQ_RANGE_HIGH(sv)	\
	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))


#  define PARENT_PAD_INDEX(sv)		\
	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
#  define PARENT_FAKELEX_FLAGS(sv)	\
	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))
#endif

/* Flags set in the SvIVX field of FAKE namesvs */
    
#define PAD_FAKELEX_ANON   1 /* the lex is declared in an ANON, or ... */
#define PAD_FAKELEX_MULTI  2 /* the lex can be instantiated multiple times */

/* flags for the pad_new() function */

#define padnew_CLONE	1	/* this pad is for a cloned CV */
#define padnew_SAVE	2	/* save old globals */
#define padnew_SAVESUB	4	/* also save extra stuff for start of sub */

/* values for the pad_tidy() function */

typedef enum {
	padtidy_SUB,		/* tidy up a pad for a sub, */
	padtidy_SUBCLONE,	/* a cloned sub, */
	padtidy_FORMAT		/* or a format */
} padtidy_type;

/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
 * whether PL_comppad and PL_curpad are consistent and whether they have
 * active values */

#ifndef PERL_MAD
#  define pad_peg(label)
#endif

#ifdef DEBUGGING
#  define ASSERT_CURPAD_LEGAL(label) \
    pad_peg(label); \
    if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0))  \
	Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%"UVxf"[0x%"UVxf"]",\
	    label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));


#  define ASSERT_CURPAD_ACTIVE(label) \
    pad_peg(label); \
    if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad))		  \
	Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%"UVxf"[0x%"UVxf"]",\
	    label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
#else
#  define ASSERT_CURPAD_LEGAL(label)
#  define ASSERT_CURPAD_ACTIVE(label)
#endif


/* Note: the following three macros are actually defined in scope.h, but
 * they are documented here for completeness, since they directly or
 * indirectly affect pads.

=for apidoc m|void|SAVEPADSV	|PADOFFSET po
Save a pad slot (used to restore after an iteration)

XXX DAPM it would make more sense to make the arg a PADOFFSET
=for apidoc m|void|SAVECLEARSV	|SV **svp
Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my')

=for apidoc m|void|SAVECOMPPAD
save PL_comppad and PL_curpad


=for apidoc m|SV *|PAD_SETSV	|PADOFFSET po|SV* sv
Set the slot at offset C<po> in the current pad to C<sv>

=for apidoc m|void|PAD_SV	|PADOFFSET po
Get the value at offset C<po> in the current pad

=for apidoc m|SV *|PAD_SVl	|PADOFFSET po
Lightweight and lvalue version of C<PAD_SV>.
Get or set the value at offset C<po> in the current pad.
Unlike C<PAD_SV>, does not print diagnostics with -DX.
For internal use only.

=for apidoc m|SV *|PAD_BASE_SV	|PADLIST padlist|PADOFFSET po
Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist

=for apidoc m|void|PAD_SET_CUR	|PADLIST padlist|I32 n
Set the current pad to be pad C<n> in the padlist, saving
the previous current pad. NB currently this macro expands to a string too
long for some compilers, so it's best to replace it with

    SAVECOMPPAD();
    PAD_SET_CUR_NOSAVE(padlist,n);


=for apidoc m|void|PAD_SET_CUR_NOSAVE	|PADLIST padlist|I32 n
like PAD_SET_CUR, but without the save

=for apidoc m|void|PAD_SAVE_SETNULLPAD
Save the current pad then set it to null.

=for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
Save the current pad to the local variable opad, then make the
current pad equal to npad

=for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()

=cut
*/

#ifdef DEBUGGING
#  define PAD_SV(po)	   pad_sv(po)
#  define PAD_SETSV(po,sv) pad_setsv(po,sv)
#else
#  define PAD_SV(po)       (PL_curpad[po])
#  define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
#endif

#define PAD_SVl(po)       (PL_curpad[po])

#define PAD_BASE_SV(padlist, po) \
	(AvARRAY(padlist)[1]) 	\
	    ? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : NULL;
    

#define PAD_SET_CUR_NOSAVE(padlist,nth) \
	PL_comppad = (PAD*) (AvARRAY(padlist)[nth]);		\
	PL_curpad = AvARRAY(PL_comppad);			\
	DEBUG_Xv(PerlIO_printf(Perl_debug_log,			\
	      "Pad 0x%"UVxf"[0x%"UVxf"] set_cur    depth=%d\n",	\
	      PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));


#define PAD_SET_CUR(padlist,nth) \
	SAVECOMPPAD();						\
	PAD_SET_CUR_NOSAVE(padlist,nth);


#define PAD_SAVE_SETNULLPAD()	SAVECOMPPAD(); \
	PL_comppad = NULL; PL_curpad = NULL;	\
	DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));

#define PAD_SAVE_LOCAL(opad,npad) \
	opad = PL_comppad;					\
	PL_comppad = (npad);					\
	PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;	\
	DEBUG_Xv(PerlIO_printf(Perl_debug_log,			\
	      "Pad 0x%"UVxf"[0x%"UVxf"] save_local\n",		\
	      PTR2UV(PL_comppad), PTR2UV(PL_curpad)));

#define PAD_RESTORE_LOCAL(opad) \
	PL_comppad = opad;					\
	PL_curpad =  PL_comppad ? AvARRAY(PL_comppad) : NULL;	\
	DEBUG_Xv(PerlIO_printf(Perl_debug_log,			\
	      "Pad 0x%"UVxf"[0x%"UVxf"] restore_local\n",	\
	      PTR2UV(PL_comppad), PTR2UV(PL_curpad)));


/*
=for apidoc m|void|CX_CURPAD_SAVE|struct context
Save the current pad in the given context block structure.

=for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
Access the SV at offset po in the saved current pad in the given
context block structure (can be used as an lvalue).

=cut
*/

#define CX_CURPAD_SAVE(block)  (block).oldcomppad = PL_comppad
#define CX_CURPAD_SV(block,po) (AvARRAY((AV*)((block).oldcomppad))[po])


/*
=for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
Return the flags for the current compiling pad name
at offset C<po>. Assumes a valid slot entry.

=for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
Return the name of the current compiling pad name
at offset C<po>. Assumes a valid slot entry.

=for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
Return the type (stash) of the current compiling pad name at offset
C<po>. Must be a valid name. Returns null if not typed.

=for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
Return the stash associated with an C<our> variable.
Assumes the slot entry is a valid C<our> lexical.

=for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
The generation number of the name at offset C<po> in the current
compiling pad (lvalue). Note that C<SvUVX> is hijacked for this purpose.

=for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
Sets the generation number of the name at offset C<po> in the current
ling pad (lvalue) to C<gen>.  Note that C<SvUV_set> is hijacked for this purpose.

=cut

*/

#define PAD_COMPNAME_SV(po) (*av_fetch(PL_comppad_name, (po), FALSE))
#define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po))
#define PAD_COMPNAME_FLAGS_isOUR(po) \
  ((PAD_COMPNAME_FLAGS(po) & (SVpad_NAME|SVpad_OUR)) == (SVpad_NAME|SVpad_OUR))
#define PAD_COMPNAME_PV(po) SvPV_nolen(PAD_COMPNAME_SV(po))

#define PAD_COMPNAME_TYPE(po) pad_compname_type(po)

#define PAD_COMPNAME_OURSTASH(po) \
    (SvOURSTASH(PAD_COMPNAME_SV(po)))

#define PAD_COMPNAME_GEN(po) ((STRLEN)SvUVX(AvARRAY(PL_comppad_name)[po]))

#define PAD_COMPNAME_GEN_set(po, gen) SvUV_set(AvARRAY(PL_comppad_name)[po], (UV)(gen))


/*
=for apidoc m|void|PAD_DUP|PADLIST dstpad|PADLIST srcpad|CLONE_PARAMS* param
Clone a padlist.

=for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl \
|CLONE_PARAMS* param
Clone the state variables associated with running and compiling pads.

=cut
*/


#define PAD_DUP(dstpad, srcpad, param)				\
    if ((srcpad) && !AvREAL(srcpad)) {				\
	/* XXX padlists are real, but pretend to be not */ 	\
	AvREAL_on(srcpad);					\
	(dstpad) = av_dup_inc((srcpad), param);			\
	AvREAL_off(srcpad);					\
	AvREAL_off(dstpad);					\
    }								\
    else							\
	(dstpad) = av_dup_inc((srcpad), param);			

/* NB - we set PL_comppad to null unless it points at a value that
 * has already been dup'ed, ie it points to part of an active padlist.
 * Otherwise PL_comppad ends up being a leaked scalar in code like
 * the following:
 *     threads->create(sub { threads->create(sub {...} ) } );
 * where the second thread dups the outer sub's comppad but not the
 * sub's CV or padlist. */

#define PAD_CLONE_VARS(proto_perl, param)				\
    PL_comppad = (AV *) ptr_table_fetch(PL_ptr_table, proto_perl->Icomppad); \
    PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;		\
    PL_comppad_name		= av_dup(proto_perl->Icomppad_name, param); \
    PL_comppad_name_fill	= proto_perl->Icomppad_name_fill;	\
    PL_comppad_name_floor	= proto_perl->Icomppad_name_floor;	\
    PL_min_intro_pending	= proto_perl->Imin_intro_pending;	\
    PL_max_intro_pending	= proto_perl->Imax_intro_pending;	\
    PL_padix			= proto_perl->Ipadix;			\
    PL_padix_floor		= proto_perl->Ipadix_floor;		\
    PL_pad_reset_pending	= proto_perl->Ipad_reset_pending;	\
    PL_cop_seqmax		= proto_perl->Icop_seqmax;
Commit	Line	Data
dd2155a4 DM	1	/* pad.h
dd2155a4 DM	2	*
699a97de	3	* Copyright (C) 2002, 2003, 2005, 2006, 2007 by Larry Wall and others
dd2155a4 DM	4	*
	5	* You may distribute under the terms of either the GNU General Public
	6	* License or the Artistic License, as specified in the README file.
	7	*
	8	* This file defines the types and macros associated with the API for
	9	* manipulating scratchpads, which are used by perl to store lexical
	10	* variables, op targets and constants.
	11	*/
	12
	13
	14
	15
	16	/* a padlist is currently just an AV; but that might change,
	17	* so hide the type. Ditto a pad. */
	18
	19	typedef AV PADLIST;
f3548bdc	20	typedef AV PAD;
dd2155a4 DM	21
	22
	23	/* offsets within a pad */
	24
	25	#if PTRSIZE == 4
	26	typedef U32TYPE PADOFFSET;
	27	#else
	28	# if PTRSIZE == 8
	29	typedef U64TYPE PADOFFSET;
	30	# endif
	31	#endif
	32	#define NOT_IN_PAD ((PADOFFSET) -1)
809abb02 NC	33
	34	/* B.xs needs these for the benefit of B::Deparse */
	35	/* Low range end is exclusive (valid from the cop seq after this one) */
809abb02	36	/* High range end is inclusive (valid up to this cop seq) */
809abb02	37
3441fb63 NC	38	#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
	39	# define COP_SEQ_RANGE_LOW(sv) \
	40	(({ SV const _svi = (SV ) (sv); \
	41	assert(SvTYPE(_svi) == SVt_NV \|\| SvTYPE(_svi) >= SVt_PVNV); \
	42	assert(SvTYPE(_svi) != SVt_PVAV); \
	43	assert(SvTYPE(_svi) != SVt_PVHV); \
	44	assert(SvTYPE(_svi) != SVt_PVCV); \
	45	assert(SvTYPE(_svi) != SVt_PVFM); \
	46	assert(!isGV_with_GP(_svi)); \
	47	((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xlow; \
	48	}))
	49	# define COP_SEQ_RANGE_HIGH(sv) \
	50	(({ SV const _svi = (SV ) (sv); \
	51	assert(SvTYPE(_svi) == SVt_NV \|\| SvTYPE(_svi) >= SVt_PVNV); \
	52	assert(SvTYPE(_svi) != SVt_PVAV); \
	53	assert(SvTYPE(_svi) != SVt_PVHV); \
	54	assert(SvTYPE(_svi) != SVt_PVCV); \
	55	assert(SvTYPE(_svi) != SVt_PVFM); \
	56	assert(!isGV_with_GP(_svi)); \
	57	((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xhigh; \
	58	}))
	59	# define PARENT_PAD_INDEX(sv) \
	60	(({ SV const _svi = (SV ) (sv); \
	61	assert(SvTYPE(_svi) == SVt_NV \|\| SvTYPE(_svi) >= SVt_PVNV); \
	62	assert(SvTYPE(_svi) != SVt_PVAV); \
	63	assert(SvTYPE(_svi) != SVt_PVHV); \
	64	assert(SvTYPE(_svi) != SVt_PVCV); \
	65	assert(SvTYPE(_svi) != SVt_PVFM); \
	66	assert(!isGV_with_GP(_svi)); \
	67	((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xlow; \
	68	}))
	69	# define PARENT_FAKELEX_FLAGS(sv) \
	70	(({ SV const _svi = (SV ) (sv); \
	71	assert(SvTYPE(_svi) == SVt_NV \|\| SvTYPE(_svi) >= SVt_PVNV); \
	72	assert(SvTYPE(_svi) != SVt_PVAV); \
	73	assert(SvTYPE(_svi) != SVt_PVHV); \
	74	assert(SvTYPE(_svi) != SVt_PVCV); \
	75	assert(SvTYPE(_svi) != SVt_PVFM); \
	76	assert(!isGV_with_GP(_svi)); \
	77	((XPVNV*) SvANY(_svi))->xnv_u.xpad_cop_seq.xhigh; \
	78	}))
	79	#else
	80	# define COP_SEQ_RANGE_LOW(sv) \
	81	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
	82	# define COP_SEQ_RANGE_HIGH(sv) \
	83	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))
	84
	85
	86	# define PARENT_PAD_INDEX(sv) \
	87	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xlow))
	88	# define PARENT_FAKELEX_FLAGS(sv) \
	89	(0 + (((XPVNV*) SvANY(sv))->xnv_u.xpad_cop_seq.xhigh))
	90	#endif
dd2155a4	91
6c5e080d NC	92	/* Flags set in the SvIVX field of FAKE namesvs */
	93
	94	#define PAD_FAKELEX_ANON 1 /* the lex is declared in an ANON, or ... */
	95	#define PAD_FAKELEX_MULTI 2 /* the lex can be instantiated multiple times */
	96
dd2155a4 DM	97	/* flags for the pad_new() function */
dd2155a4 DM	98
c7c737cb DM	99	#define padnew_CLONE 1 /* this pad is for a cloned CV */
	100	#define padnew_SAVE 2 /* save old globals */
	101	#define padnew_SAVESUB 4 /* also save extra stuff for start of sub */
dd2155a4 DM	102
	103	/* values for the pad_tidy() function */
	104
	105	typedef enum {
	106	padtidy_SUB, /* tidy up a pad for a sub, */
	107	padtidy_SUBCLONE, /* a cloned sub, */
	108	padtidy_FORMAT /* or a format */
	109	} padtidy_type;
	110
f3548bdc DM	111	/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
	112	* whether PL_comppad and PL_curpad are consistent and whether they have
	113	* active values */
dd2155a4	114
1dba731d NC	115	#ifndef PERL_MAD
	116	# define pad_peg(label)
	117	#endif
	118
f3548bdc DM	119	#ifdef DEBUGGING
f3548bdc DM	120	# define ASSERT_CURPAD_LEGAL(label) \
1dba731d	121	pad_peg(label); \
f3548bdc DM	122	if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \
	123	Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%"UVxf"[0x%"UVxf"]",\
	124	label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
	125
	126
	127	# define ASSERT_CURPAD_ACTIVE(label) \
1dba731d	128	pad_peg(label); \
f3548bdc DM	129	if (!PL_comppad \|\| (AvARRAY(PL_comppad) != PL_curpad)) \
	130	Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%"UVxf"[0x%"UVxf"]",\
	131	label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
	132	#else
	133	# define ASSERT_CURPAD_LEGAL(label)
	134	# define ASSERT_CURPAD_ACTIVE(label)
	135	#endif
	136
	137
	138
	139	/* Note: the following three macros are actually defined in scope.h, but
dd2155a4 DM	140	* they are documented here for completeness, since they directly or
	141	* indirectly affect pads.
	142
	143	=for apidoc m\|void\|SAVEPADSV \|PADOFFSET po
	144	Save a pad slot (used to restore after an iteration)
	145
f3548bdc	146	XXX DAPM it would make more sense to make the arg a PADOFFSET
dd2155a4	147	=for apidoc m\|void\|SAVECLEARSV \|SV **svp
eeb8d49e	148	Clear the pointed to pad value on scope exit. (i.e. the runtime action of 'my')
dd2155a4 DM	149
	150	=for apidoc m\|void\|SAVECOMPPAD
	151	save PL_comppad and PL_curpad
	152
dd2155a4 DM	153
	154
	155
	156
	157	=for apidoc m\|SV \|PAD_SETSV \|PADOFFSET po\|SV sv
	158	Set the slot at offset C<po> in the current pad to C<sv>
	159
	160	=for apidoc m\|void\|PAD_SV \|PADOFFSET po
	161	Get the value at offset C<po> in the current pad
	162
	163	=for apidoc m\|SV *\|PAD_SVl \|PADOFFSET po
	164	Lightweight and lvalue version of C<PAD_SV>.
	165	Get or set the value at offset C<po> in the current pad.
	166	Unlike C<PAD_SV>, does not print diagnostics with -DX.
	167	For internal use only.
	168
	169	=for apidoc m\|SV *\|PAD_BASE_SV \|PADLIST padlist\|PADOFFSET po
	170	Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
	171
	172	=for apidoc m\|void\|PAD_SET_CUR \|PADLIST padlist\|I32 n
	173	Set the current pad to be pad C<n> in the padlist, saving
fd617465 DM	174	the previous current pad. NB currently this macro expands to a string too
	175	long for some compilers, so it's best to replace it with
	176
	177	SAVECOMPPAD();
	178	PAD_SET_CUR_NOSAVE(padlist,n);
	179
dd2155a4	180
4e380990 DM	181	=for apidoc m\|void\|PAD_SET_CUR_NOSAVE \|PADLIST padlist\|I32 n
	182	like PAD_SET_CUR, but without the save
	183
dd2155a4 DM	184	=for apidoc m\|void\|PAD_SAVE_SETNULLPAD
	185	Save the current pad then set it to null.
	186
f3548bdc DM	187	=for apidoc m\|void\|PAD_SAVE_LOCAL\|PAD opad\|PAD npad
	188	Save the current pad to the local variable opad, then make the
	189	current pad equal to npad
	190
	191	=for apidoc m\|void\|PAD_RESTORE_LOCAL\|PAD *opad
	192	Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
dd2155a4 DM	193
	194	=cut
	195	*/
	196
	197	#ifdef DEBUGGING
	198	# define PAD_SV(po) pad_sv(po)
	199	# define PAD_SETSV(po,sv) pad_setsv(po,sv)
	200	#else
	201	# define PAD_SV(po) (PL_curpad[po])
	202	# define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
	203	#endif
	204
	205	#define PAD_SVl(po) (PL_curpad[po])
	206
	207	#define PAD_BASE_SV(padlist, po) \
	208	(AvARRAY(padlist)[1]) \
a0714e2c	209	? AvARRAY((AV*)(AvARRAY(padlist)[1]))[po] : NULL;
dd2155a4 DM	210
dd2155a4 DM	211
de5e01c2 JH	212	#define PAD_SET_CUR_NOSAVE(padlist,nth) \
de5e01c2 JH	213	PL_comppad = (PAD*) (AvARRAY(padlist)[nth]); \
f3548bdc DM	214	PL_curpad = AvARRAY(PL_comppad); \
	215	DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
	216	"Pad 0x%"UVxf"[0x%"UVxf"] set_cur depth=%d\n", \
de5e01c2	217	PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
f3548bdc DM	218
f3548bdc DM	219
de5e01c2	220	#define PAD_SET_CUR(padlist,nth) \
4e380990	221	SAVECOMPPAD(); \
de5e01c2	222	PAD_SET_CUR_NOSAVE(padlist,nth);
4e380990 DM	223
4e380990 DM	224
f3548bdc	225	#define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \
4608196e	226	PL_comppad = NULL; PL_curpad = NULL; \
f3548bdc DM	227	DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
	228
	229	#define PAD_SAVE_LOCAL(opad,npad) \
	230	opad = PL_comppad; \
	231	PL_comppad = (npad); \
4608196e	232	PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
f3548bdc DM	233	DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
	234	"Pad 0x%"UVxf"[0x%"UVxf"] save_local\n", \
	235	PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
	236
	237	#define PAD_RESTORE_LOCAL(opad) \
	238	PL_comppad = opad; \
4608196e	239	PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
f3548bdc DM	240	DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
	241	"Pad 0x%"UVxf"[0x%"UVxf"] restore_local\n", \
	242	PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
dd2155a4 DM	243
	244
	245	/*
	246	=for apidoc m\|void\|CX_CURPAD_SAVE\|struct context
	247	Save the current pad in the given context block structure.
	248
f3548bdc	249	=for apidoc m\|SV *\|CX_CURPAD_SV\|struct context\|PADOFFSET po
dd2155a4 DM	250	Access the SV at offset po in the saved current pad in the given
	251	context block structure (can be used as an lvalue).
	252
	253	=cut
	254	*/
	255
f3548bdc DM	256	#define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad
f3548bdc DM	257	#define CX_CURPAD_SV(block,po) (AvARRAY((AV*)((block).oldcomppad))[po])
dd2155a4 DM	258
	259
	260	/*
	261	=for apidoc m\|U32\|PAD_COMPNAME_FLAGS\|PADOFFSET po
	262	Return the flags for the current compiling pad name
	263	at offset C<po>. Assumes a valid slot entry.
	264
	265	=for apidoc m\|char *\|PAD_COMPNAME_PV\|PADOFFSET po
	266	Return the name of the current compiling pad name
	267	at offset C<po>. Assumes a valid slot entry.
	268
	269	=for apidoc m\|HV *\|PAD_COMPNAME_TYPE\|PADOFFSET po
	270	Return the type (stash) of the current compiling pad name at offset
	271	C<po>. Must be a valid name. Returns null if not typed.
	272
	273	=for apidoc m\|HV *\|PAD_COMPNAME_OURSTASH\|PADOFFSET po
	274	Return the stash associated with an C<our> variable.
	275	Assumes the slot entry is a valid C<our> lexical.
	276
	277	=for apidoc m\|STRLEN\|PAD_COMPNAME_GEN\|PADOFFSET po
	278	The generation number of the name at offset C<po> in the current
931b58fb	279	compiling pad (lvalue). Note that C<SvUVX> is hijacked for this purpose.
dd2155a4	280
b162af07 SP	281	=for apidoc m\|STRLEN\|PAD_COMPNAME_GEN_set\|PADOFFSET po\|int gen
b162af07 SP	282	Sets the generation number of the name at offset C<po> in the current
931b58fb	283	ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose.
b162af07	284
dd2155a4	285	=cut
b162af07	286
dd2155a4 DM	287	*/
dd2155a4 DM	288
f8503592 NC	289	#define PAD_COMPNAME_SV(po) (*av_fetch(PL_comppad_name, (po), FALSE))
f8503592 NC	290	#define PAD_COMPNAME_FLAGS(po) SvFLAGS(PAD_COMPNAME_SV(po))
1e7f542f NC	291	#define PAD_COMPNAME_FLAGS_isOUR(po) \
1e7f542f NC	292	((PAD_COMPNAME_FLAGS(po) & (SVpad_NAME\|SVpad_OUR)) == (SVpad_NAME\|SVpad_OUR))
f8503592	293	#define PAD_COMPNAME_PV(po) SvPV_nolen(PAD_COMPNAME_SV(po))
dd2155a4	294
b21dc031	295	#define PAD_COMPNAME_TYPE(po) pad_compname_type(po)
dd2155a4 DM	296
dd2155a4 DM	297	#define PAD_COMPNAME_OURSTASH(po) \
73d95100	298	(SvOURSTASH(PAD_COMPNAME_SV(po)))
dd2155a4	299
931b58fb	300	#define PAD_COMPNAME_GEN(po) ((STRLEN)SvUVX(AvARRAY(PL_comppad_name)[po]))
dd2155a4	301
931b58fb	302	#define PAD_COMPNAME_GEN_set(po, gen) SvUV_set(AvARRAY(PL_comppad_name)[po], (UV)(gen))
dd2155a4 DM	303
	304
	305	/*
	306	=for apidoc m\|void\|PAD_DUP\|PADLIST dstpad\|PADLIST srcpad\|CLONE_PARAMS* param
	307	Clone a padlist.
	308
	309	=for apidoc m\|void\|PAD_CLONE_VARS\|PerlInterpreter *proto_perl \
	310	\|CLONE_PARAMS* param
	311	Clone the state variables associated with running and compiling pads.
	312
	313	=cut
	314	*/
	315
	316
	317	#define PAD_DUP(dstpad, srcpad, param) \
	318	if ((srcpad) && !AvREAL(srcpad)) { \
	319	/* XXX padlists are real, but pretend to be not */ \
	320	AvREAL_on(srcpad); \
	321	(dstpad) = av_dup_inc((srcpad), param); \
	322	AvREAL_off(srcpad); \
	323	AvREAL_off(dstpad); \
	324	} \
	325	else \
	326	(dstpad) = av_dup_inc((srcpad), param);
	327
c5ab0850 DM	328	/* NB - we set PL_comppad to null unless it points at a value that
	329	* has already been dup'ed, ie it points to part of an active padlist.
	330	* Otherwise PL_comppad ends up being a leaked scalar in code like
	331	* the following:
	332	* threads->create(sub { threads->create(sub {...} ) } );
	333	* where the second thread dups the outer sub's comppad but not the
	334	* sub's CV or padlist. */
f3548bdc	335
dd2155a4	336	#define PAD_CLONE_VARS(proto_perl, param) \
8f77bfdb	337	PL_comppad = (AV *) ptr_table_fetch(PL_ptr_table, proto_perl->Icomppad); \
4608196e	338	PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
dd2155a4 DM	339	PL_comppad_name = av_dup(proto_perl->Icomppad_name, param); \
	340	PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \
	341	PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \
dd2155a4 DM	342	PL_min_intro_pending = proto_perl->Imin_intro_pending; \
	343	PL_max_intro_pending = proto_perl->Imax_intro_pending; \
	344	PL_padix = proto_perl->Ipadix; \
	345	PL_padix_floor = proto_perl->Ipadix_floor; \
	346	PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \
	347	PL_cop_seqmax = proto_perl->Icop_seqmax;