[perl5.git] / pad.h

/*    pad.h
 *
 *    Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008 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)						\
	(({ const SV *const _sv_cop_seq_range_low = (const SV *) (sv);	\
	  assert(SvTYPE(_sv_cop_seq_range_low) == SVt_NV		\
		 || SvTYPE(_sv_cop_seq_range_low) >= SVt_PVNV);		\
	  assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVAV);		\
	  assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVHV);		\
	  assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVCV);		\
	  assert(SvTYPE(_sv_cop_seq_range_low) != SVt_PVFM);		\
	  assert(!isGV_with_GP(_sv_cop_seq_range_low));			\
	  ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_low)))->xnv_u.xpad_cop_seq.xlow; \
	 }))
#  define COP_SEQ_RANGE_HIGH(sv)					\
	(({ const SV *const _sv_cop_seq_range_high = (const SV *) (sv);	\
	  assert(SvTYPE(_sv_cop_seq_range_high) == SVt_NV 		\
                 || SvTYPE(_sv_cop_seq_range_high) >= SVt_PVNV);	\
	  assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVAV);		\
	  assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVHV);		\
	  assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVCV);		\
	  assert(SvTYPE(_sv_cop_seq_range_high) != SVt_PVFM);		\
	  assert(!isGV_with_GP(_sv_cop_seq_range_high));		\
	  ((XPVNV*) MUTABLE_PTR(SvANY(_sv_cop_seq_range_high)))->xnv_u.xpad_cop_seq.xhigh; \
	 }))
#  define PARENT_PAD_INDEX(sv)						\
	(({ const SV *const _sv_parent_pad_index = (const SV *) (sv);	\
	  assert(SvTYPE(_sv_parent_pad_index) == SVt_NV			\
		 || SvTYPE(_sv_parent_pad_index) >= SVt_PVNV);		\
	  assert(SvTYPE(_sv_parent_pad_index) != SVt_PVAV);		\
	  assert(SvTYPE(_sv_parent_pad_index) != SVt_PVHV);		\
	  assert(SvTYPE(_sv_parent_pad_index) != SVt_PVCV);		\
	  assert(SvTYPE(_sv_parent_pad_index) != SVt_PVFM);		\
	  assert(!isGV_with_GP(_sv_parent_pad_index));			\
	  ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_pad_index)))->xnv_u.xpad_cop_seq.xlow; \
	 }))
#  define PARENT_FAKELEX_FLAGS(sv)					\
	(({ const SV *const _sv_parent_fakelex_flags = (const SV *) (sv); \
	  assert(SvTYPE(_sv_parent_fakelex_flags) == SVt_NV  		\
		 || SvTYPE(_sv_parent_fakelex_flags) >= SVt_PVNV);	\
	  assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVAV);		\
	  assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVHV);		\
	  assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVCV);		\
	  assert(SvTYPE(_sv_parent_fakelex_flags) != SVt_PVFM);		\
	  assert(!isGV_with_GP(_sv_parent_fakelex_flags));		\
	  ((XPVNV*) MUTABLE_PTR(SvANY(_sv_parent_fakelex_flags)))->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(MUTABLE_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 && SvIS_FREED(opad) ? NULL : 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(MUTABLE_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 = MUTABLE_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;

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