[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.
 */

/*
=head1 Pad Data Structures
*/


/* 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)

/* a value that PL_cop_seqmax is guaranteed never to be,
 * flagging that a lexical is being introduced, or has not yet left scope
 */
#define PERL_PADSEQ_INTRO  U32_MAX


/* 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;

/* flags for pad_add_name_pvn. SVf_UTF8 will also be valid in the future.  */

#define padadd_OUR		0x01	/* our declaration. */
#define padadd_STATE		0x02	/* state declaration. */
#define padadd_NO_DUP_CHECK	0x04	/* skip warning on dups. */

/* 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) \
        assert(!opad || !SvIS_FREED(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(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) SvPAD_OUR(PAD_COMPNAME_SV(po))
#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;

/*
=for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash

Exactly like L</pad_add_name_pvn>, but takes a literal string instead
of a string/length pair.

=cut
*/

#define pad_add_name_pvs(name,flags,typestash,ourstash) \
    Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)

/*
=for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags

Exactly like L</pad_findmy_pvn>, but takes a literal string instead
of a string/length pair.

=cut
*/

#define pad_findmy_pvs(name,flags) \
    Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)

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