[perl5.git] / pad.h

/*    pad.h
 *
 *    Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008,
 *    2009, 2010, 2011 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
*/


/* 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 expects the first members of these two structs to line up
   (xpadl_max with xpadnl_fill).
 */

struct padlist {
    SSize_t	xpadl_max;	/* max index for which array has space */
    PAD **	xpadl_alloc;	/* pointer to beginning of array of AVs */
    U32		xpadl_id;	/* Semi-unique ID, shared between clones */
    U32		xpadl_outid;	/* ID of outer pad */
};

struct padnamelist {
    SSize_t	xpadnl_fill;	/* max index in use */
    PADNAME **	xpadnl_alloc;	/* pointer to beginning of array */
    SSize_t	xpadnl_max;	/* max index for which array has space */
    PADOFFSET	xpadnl_max_named; /* highest index with len > 0 */
    U32		xpadnl_refcnt;
};

/* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
   PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
   define one or the other.  */
#if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
#  error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
#endif

#if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
#  define PERL_PADNAME_MINIMAL
#endif

#define _PADNAME_BASE \
    char *	xpadn_pv;		\
    HV *	xpadn_ourstash;		\
    union {				\
	HV *	xpadn_typestash;	\
	CV *	xpadn_protocv;		\
    } xpadn_type_u;			\
    U32		xpadn_low;		\
    U32		xpadn_high;		\
    U32		xpadn_refcnt;		\
    int		xpadn_gen;		\
    U8		xpadn_len;		\
    U8		xpadn_flags

struct padname {
    _PADNAME_BASE;
};

struct padname_with_str {
#ifdef PERL_PADNAME_MINIMAL
    _PADNAME_BASE;
#else
    struct padname	xpadn_padname;
#endif
    char		xpadn_str[1];
};

#undef _PADNAME_BASE

#define PADNAME_FROM_PV(s) \
    ((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))


/* 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
#define COP_SEQMAX_INC \
	(PL_cop_seqmax++, \
	 (void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))


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

#define COP_SEQ_RANGE_LOW(pn)		(pn)->xpadn_low
#define COP_SEQ_RANGE_HIGH(pn)		(pn)->xpadn_high
#define PARENT_PAD_INDEX(pn)		(pn)->xpadn_low
#define PARENT_FAKELEX_FLAGS(pn)	(pn)->xpadn_high

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

#define padadd_OUR		0x01	   /* our declaration. */
#define padadd_STATE		0x02	   /* state declaration. */
#define padadd_NO_DUP_CHECK	0x04	   /* skip warning on dups. */
#define padadd_STALEOK		0x08	   /* allow stale lexical in active
					    * sub, but only one level up */

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

#  define pad_peg(label)

#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 Amx|PAD **|PadlistARRAY|PADLIST padlist
The C array of a padlist, containing the pads.  Only subscript it with
numbers >= 1, as the 0th entry is not guaranteed to remain usable.

=for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist
The index of the last allocated space in the padlist.  Note that the last
pad may be in an earlier slot.  Any entries following it will be NULL in
that case.

=for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist
The names associated with pad entries.

=for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist
The C array of pad names.

=for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist
The index of the last pad name.

=for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist
The reference count of the padlist.  Currently this is always 1.

=for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl
The C array of pad names.

=for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl
The index of the last pad name.

=for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST pnl
The reference count of the pad name list.

=for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST pnl
Lowers the reference count of the pad name list.

=for apidoc Amx|SV **|PadARRAY|PAD pad
The C array of pad entries.

=for apidoc Amx|SSize_t|PadMAX|PAD pad
The index of the last pad entry.

=for apidoc Amx|char *|PadnamePV|PADNAME pn	
The name stored in the pad name struct.  This returns NULL for a target
slot.

=for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn	
The length of the name.

=for apidoc Amx|bool|PadnameUTF8|PADNAME pn
Whether PadnamePV is in UTF8.  Currently, this is always true.

=for apidoc Amx|SV *|PadnameSV|PADNAME pn
Returns the pad name as a mortal SV.

=for apidoc m|bool|PadnameIsOUR|PADNAME pn
Whether this is an "our" variable.

=for apidoc m|HV *|PadnameOURSTASH
The stash in which this "our" variable was declared.

=for apidoc m|bool|PadnameOUTER|PADNAME pn
Whether this entry belongs to an outer pad.  Entries for which this is true
are often referred to as 'fake'.

=for apidoc m|bool|PadnameIsSTATE|PADNAME pn
Whether this is a "state" variable.

=for apidoc m|HV *|PadnameTYPE|PADNAME pn
The stash associated with a typed lexical.  This returns the %Foo:: hash
for C<my Foo $bar>.

=for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME pn
The reference count of the pad name.

=for apidoc Amx|void|PadnameREFCNT_dec|PADNAME pn
Lowers the reference count of the pad name.


=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|SV *|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
*/

#define PadlistARRAY(pl)	(pl)->xpadl_alloc
#define PadlistMAX(pl)		(pl)->xpadl_max
#define PadlistNAMES(pl)	((PADNAMELIST *)*PadlistARRAY(pl))
#define PadlistNAMESARRAY(pl)	PadnamelistARRAY(PadlistNAMES(pl))
#define PadlistNAMESMAX(pl)	PadnamelistMAX(PadlistNAMES(pl))
#define PadlistREFCNT(pl)	1	/* reserved for future use */

#define PadnamelistARRAY(pnl)		(pnl)->xpadnl_alloc
#define PadnamelistMAX(pnl)		(pnl)->xpadnl_fill
#define PadnamelistMAXNAMED(pnl)	(pnl)->xpadnl_max_named
#define PadnamelistREFCNT(pnl)		(pnl)->xpadnl_refcnt
#define PadnamelistREFCNT_dec(pnl)	Perl_padnamelist_free(aTHX_ pnl)

#define PadARRAY(pad)		AvARRAY(pad)
#define PadMAX(pad)		AvFILLp(pad)

#define PadnamePV(pn)		(pn)->xpadn_pv
#define PadnameLEN(pn)		(pn)->xpadn_len
#define PadnameUTF8(pn)		1
#define PadnameSV(pn) \
	newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP|SVf_UTF8)
#define PadnameFLAGS(pn)	(pn)->xpadn_flags
#define PadnameIsOUR(pn)	(!!(pn)->xpadn_ourstash)
#define PadnameOURSTASH(pn)	(pn)->xpadn_ourstash
#define PadnameTYPE(pn)		(pn)->xpadn_type_u.xpadn_typestash
#define PadnamePROTOCV(pn)	(pn)->xpadn_type_u.xpadn_protocv
#define PadnameREFCNT(pn)	(pn)->xpadn_refcnt
#define PadnameREFCNT_dec(pn)	Perl_padname_free(aTHX_ pn)
#define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
#define PadnameTYPE_set(pn,s)	  (PadnameTYPE(pn) = (s))
#define PadnameOUTER(pn)	(PadnameFLAGS(pn) & PADNAMEt_OUTER)
#define PadnameIsSTATE(pn)	(PadnameFLAGS(pn) & PADNAMEt_STATE)
#define PadnameLVALUE(pn)	(PadnameFLAGS(pn) & PADNAMEt_LVALUE)

#define PadnameLVALUE_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_LVALUE)
#define PadnameIsSTATE_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_STATE)

#define PADNAMEt_OUTER	1	/* outer lexical var */
#define PADNAMEt_STATE	2	/* state var */
#define PADNAMEt_LVALUE	4	/* used as lvalue */
#define PADNAMEt_TYPED	8	/* for B; unused by core */
#define PADNAMEt_OUR	16	/* for B; unused by core */

/* backward compatibility */
#define SvPAD_STATE		PadnameIsSTATE
#define SvPAD_TYPED(pn)		(!!PadnameTYPE(pn))
#define SvPAD_OUR(pn)		(!!PadnameOURSTASH(pn))
#define SvPAD_STATE_on		PadnameIsSTATE_on
#define SvPAD_TYPED_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_TYPED)
#define SvPAD_OUR_on(pn)	(PadnameFLAGS(pn) |= PADNAMEt_OUR)
#define SvOURSTASH		PadnameOURSTASH
#define SvOURSTASH_set		PadnameOURSTASH_set
#define SVpad_STATE		PADNAMEt_STATE
#define SVpad_TYPED		PADNAMEt_TYPED
#define SVpad_OUR		PADNAMEt_OUR

#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) \
	(PadlistARRAY(padlist)[1])					\
	    ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
	    : NULL;


#define PAD_SET_CUR_NOSAVE(padlist,nth) \
	PL_comppad = (PAD*) (PadlistARRAY(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(po)	PAD_COMPNAME_SV(po)
#define PAD_COMPNAME_SV(po)	(PadnamelistARRAY(PL_comppad_name)[(po)])
#define PAD_COMPNAME_FLAGS(po)	PadnameFLAGS(PAD_COMPNAME(po))
#define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
#define PAD_COMPNAME_PV(po)	PadnamePV(PAD_COMPNAME(po))

#define PAD_COMPNAME_TYPE(po)	PadnameTYPE(PAD_COMPNAME(po))

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

#define PAD_COMPNAME_GEN(po) \
    ((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)

#define PAD_COMPNAME_GEN_set(po, gen) \
    (PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))


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

=cut
*/

/* 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_dup(proto_perl->Icomppad, param);	\
    PL_curpad = PL_comppad ?  AvARRAY(PL_comppad) : NULL;		\
    PL_comppad_name		=					\
		  padnamelist_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: nil
 * End:
 *
 * ex: set ts=8 sts=4 sw=4 et:
 */
Commit	Line	Data
dd2155a4 DM	1	/* pad.h
dd2155a4 DM	2	*
2eee27d7 SS	3	* Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008,
2eee27d7 SS	4	* 2009, 2010, 2011 by Larry Wall and others
dd2155a4 DM	5	*
	6	* You may distribute under the terms of either the GNU General Public
	7	* License or the Artistic License, as specified in the README file.
	8	*
	9	* This file defines the types and macros associated with the API for
	10	* manipulating scratchpads, which are used by perl to store lexical
	11	* variables, op targets and constants.
	12	*/
	13
cc76b5cc Z	14	/*
	15	=head1 Pad Data Structures
	16	*/
dd2155a4 DM	17
dd2155a4 DM	18
dd2155a4 DM	19	/* offsets within a pad */
	20
	21	#if PTRSIZE == 4
	22	typedef U32TYPE PADOFFSET;
	23	#else
	24	# if PTRSIZE == 8
	25	typedef U64TYPE PADOFFSET;
	26	# endif
	27	#endif
	28	#define NOT_IN_PAD ((PADOFFSET) -1)
809abb02	29
9b7476d7 FC	30	/* B.xs expects the first members of these two structs to line up
	31	(xpadl_max with xpadnl_fill).
	32	*/
7261499d FC	33
	34	struct padlist {
	35	SSize_t xpadl_max; /* max index for which array has space */
	36	PAD ** xpadl_alloc; /* pointer to beginning of array of AVs */
b4db5868 FC	37	U32 xpadl_id; /* Semi-unique ID, shared between clones */
b4db5868 FC	38	U32 xpadl_outid; /* ID of outer pad */
7261499d FC	39	};
7261499d FC	40
9b7476d7 FC	41	struct padnamelist {
	42	SSize_t xpadnl_fill; /* max index in use */
	43	PADNAME ** xpadnl_alloc; /* pointer to beginning of array */
	44	SSize_t xpadnl_max; /* max index for which array has space */
	45	PADOFFSET xpadnl_max_named; /* highest index with len > 0 */
	46	U32 xpadnl_refcnt;
	47	};
	48
66230865 FC	49	/* PERL_PADNAME_MINIMAL uses less memory, but on some platforms
	50	PERL_PADNAME_ALIGNED may be faster, so platform-specific hints can
	51	define one or the other. */
	52	#if defined(PERL_PADNAME_MINIMAL) && defined (PERL_PADNAME_ALIGNED)
	53	# error PERL_PADNAME_MINIMAL and PERL_PADNAME_ALIGNED are exclusive
	54	#endif
	55
	56	#if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
3d6de2cd	57	# define PERL_PADNAME_MINIMAL
66230865 FC	58	#endif
	59
	60	#define _PADNAME_BASE \
	61	char * xpadn_pv; \
	62	HV * xpadn_ourstash; \
	63	union { \
	64	HV * xpadn_typestash; \
	65	CV * xpadn_protocv; \
	66	} xpadn_type_u; \
	67	U32 xpadn_low; \
	68	U32 xpadn_high; \
	69	U32 xpadn_refcnt; \
	70	int xpadn_gen; \
	71	U8 xpadn_len; \
	72	U8 xpadn_flags
	73
0f94cb1f	74	struct padname {
66230865	75	_PADNAME_BASE;
0f94cb1f FC	76	};
	77
	78	struct padname_with_str {
66230865 FC	79	#ifdef PERL_PADNAME_MINIMAL
	80	_PADNAME_BASE;
	81	#else
0f94cb1f	82	struct padname xpadn_padname;
66230865	83	#endif
0f94cb1f FC	84	char xpadn_str[1];
	85	};
	86
66230865 FC	87	#undef _PADNAME_BASE
66230865 FC	88
0f94cb1f FC	89	#define PADNAME_FROM_PV(s) \
	90	((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))
	91
7261499d	92
2df5bdd7 DM	93	/* a value that PL_cop_seqmax is guaranteed never to be,
	94	* flagging that a lexical is being introduced, or has not yet left scope
	95	*/
	96	#define PERL_PADSEQ_INTRO U32_MAX
953c8b80 FC	97	#define COP_SEQMAX_INC \
	98	(PL_cop_seqmax++, \
	99	(void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
2df5bdd7 DM	100
2df5bdd7 DM	101
7948fc08	102	/* B.xs needs these for the benefit of B::Deparse */
809abb02	103	/* Low range end is exclusive (valid from the cop seq after this one) */
809abb02	104	/* High range end is inclusive (valid up to this cop seq) */
809abb02	105
0f94cb1f FC	106	#define COP_SEQ_RANGE_LOW(pn) (pn)->xpadn_low
	107	#define COP_SEQ_RANGE_HIGH(pn) (pn)->xpadn_high
	108	#define PARENT_PAD_INDEX(pn) (pn)->xpadn_low
	109	#define PARENT_FAKELEX_FLAGS(pn) (pn)->xpadn_high
dd2155a4	110
6c5e080d	111	/* Flags set in the SvIVX field of FAKE namesvs */
7948fc08	112
6c5e080d NC	113	#define PAD_FAKELEX_ANON 1 /* the lex is declared in an ANON, or ... */
	114	#define PAD_FAKELEX_MULTI 2 /* the lex can be instantiated multiple times */
	115
dd2155a4 DM	116	/* flags for the pad_new() function */
dd2155a4 DM	117
c7c737cb DM	118	#define padnew_CLONE 1 /* this pad is for a cloned CV */
	119	#define padnew_SAVE 2 /* save old globals */
	120	#define padnew_SAVESUB 4 /* also save extra stuff for start of sub */
dd2155a4 DM	121
	122	/* values for the pad_tidy() function */
	123
	124	typedef enum {
	125	padtidy_SUB, /* tidy up a pad for a sub, */
	126	padtidy_SUBCLONE, /* a cloned sub, */
	127	padtidy_FORMAT /* or a format */
	128	} padtidy_type;
	129
9f6ec8dd	130	/* flags for pad_add_name_pvn. */
35f82371	131
9f6ec8dd BF	132	#define padadd_OUR 0x01 /* our declaration. */
	133	#define padadd_STATE 0x02 /* state declaration. */
	134	#define padadd_NO_DUP_CHECK 0x04 /* skip warning on dups. */
7ef30830 FC	135	#define padadd_STALEOK 0x08 /* allow stale lexical in active
7ef30830 FC	136	* sub, but only one level up */
35f82371	137
f3548bdc DM	138	/* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
	139	* whether PL_comppad and PL_curpad are consistent and whether they have
	140	* active values */
dd2155a4	141
1dba731d	142	# define pad_peg(label)
1dba731d	143
f3548bdc DM	144	#ifdef DEBUGGING
f3548bdc DM	145	# define ASSERT_CURPAD_LEGAL(label) \
1dba731d	146	pad_peg(label); \
f3548bdc	147	if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \
61608bb7	148	Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
f3548bdc DM	149	label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
	150
	151
	152	# define ASSERT_CURPAD_ACTIVE(label) \
1dba731d	153	pad_peg(label); \
f3548bdc	154	if (!PL_comppad \|\| (AvARRAY(PL_comppad) != PL_curpad)) \
61608bb7	155	Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
f3548bdc DM	156	label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
	157	#else
	158	# define ASSERT_CURPAD_LEGAL(label)
	159	# define ASSERT_CURPAD_ACTIVE(label)
	160	#endif
	161
	162
	163
	164	/* Note: the following three macros are actually defined in scope.h, but
dd2155a4 DM	165	* they are documented here for completeness, since they directly or
	166	* indirectly affect pads.
	167
	168	=for apidoc m\|void\|SAVEPADSV \|PADOFFSET po
	169	Save a pad slot (used to restore after an iteration)
	170
f3548bdc	171	XXX DAPM it would make more sense to make the arg a PADOFFSET
dd2155a4	172	=for apidoc m\|void\|SAVECLEARSV \|SV **svp
154e47c8 FC	173	Clear the pointed to pad value on scope exit. (i.e. the runtime action of
154e47c8 FC	174	'my')
dd2155a4 DM	175
dd2155a4 DM	176	=for apidoc m\|void\|SAVECOMPPAD
9c47725a	177	save PL_comppad and PL_curpad
dd2155a4	178
dd2155a4	179
86d2498c	180	=for apidoc Amx\|PAD **\|PadlistARRAY\|PADLIST padlist
35e035cc FC	181	The C array of a padlist, containing the pads. Only subscript it with
35e035cc FC	182	numbers >= 1, as the 0th entry is not guaranteed to remain usable.
dd2155a4	183
86d2498c	184	=for apidoc Amx\|SSize_t\|PadlistMAX\|PADLIST padlist
57ee99bb FC	185	The index of the last allocated space in the padlist. Note that the last
	186	pad may be in an earlier slot. Any entries following it will be NULL in
	187	that case.
35e035cc	188
86d2498c	189	=for apidoc Amx\|PADNAMELIST *\|PadlistNAMES\|PADLIST padlist
35e035cc FC	190	The names associated with pad entries.
35e035cc FC	191
86d2498c	192	=for apidoc Amx\|PADNAME **\|PadlistNAMESARRAY\|PADLIST padlist
35e035cc FC	193	The C array of pad names.
35e035cc FC	194
86d2498c	195	=for apidoc Amx\|SSize_t\|PadlistNAMESMAX\|PADLIST padlist
35e035cc FC	196	The index of the last pad name.
35e035cc FC	197
86d2498c	198	=for apidoc Amx\|U32\|PadlistREFCNT\|PADLIST padlist
35e035cc FC	199	The reference count of the padlist. Currently this is always 1.
35e035cc FC	200
86d2498c	201	=for apidoc Amx\|PADNAME **\|PadnamelistARRAY\|PADNAMELIST pnl
35e035cc FC	202	The C array of pad names.
35e035cc FC	203
86d2498c	204	=for apidoc Amx\|SSize_t\|PadnamelistMAX\|PADNAMELIST pnl
35e035cc FC	205	The index of the last pad name.
35e035cc FC	206
9b7476d7 FC	207	=for apidoc Amx\|SSize_t\|PadnamelistREFCNT\|PADNAMELIST pnl
	208	The reference count of the pad name list.
	209
	210	=for apidoc Amx\|void\|PadnamelistREFCNT_dec\|PADNAMELIST pnl
	211	Lowers the reference count of the pad name list.
	212
86d2498c	213	=for apidoc Amx\|SV **\|PadARRAY\|PAD pad
35e035cc FC	214	The C array of pad entries.
35e035cc FC	215
86d2498c	216	=for apidoc Amx\|SSize_t\|PadMAX\|PAD pad
35e035cc FC	217	The index of the last pad entry.
35e035cc FC	218
86d2498c	219	=for apidoc Amx\|char *\|PadnamePV\|PADNAME pn
863f2221 FC	220	The name stored in the pad name struct. This returns NULL for a target
863f2221 FC	221	slot.
35e035cc	222
86d2498c	223	=for apidoc Amx\|STRLEN\|PadnameLEN\|PADNAME pn
35e035cc FC	224	The length of the name.
35e035cc FC	225
86d2498c	226	=for apidoc Amx\|bool\|PadnameUTF8\|PADNAME pn
2502ffdf	227	Whether PadnamePV is in UTF8. Currently, this is always true.
35e035cc	228
86d2498c	229	=for apidoc Amx\|SV *\|PadnameSV\|PADNAME pn
0f94cb1f	230	Returns the pad name as a mortal SV.
97dad6bd	231
86d2498c	232	=for apidoc m\|bool\|PadnameIsOUR\|PADNAME pn
35e035cc FC	233	Whether this is an "our" variable.
35e035cc FC	234
86d2498c	235	=for apidoc m\|HV *\|PadnameOURSTASH
35e035cc FC	236	The stash in which this "our" variable was declared.
35e035cc FC	237
86d2498c	238	=for apidoc m\|bool\|PadnameOUTER\|PADNAME pn
b19cb98d FC	239	Whether this entry belongs to an outer pad. Entries for which this is true
b19cb98d FC	240	are often referred to as 'fake'.
c44737a2	241
3f6a9d3a	242	=for apidoc m\|bool\|PadnameIsSTATE\|PADNAME pn
643fe368 FC	243	Whether this is a "state" variable.
643fe368 FC	244
86d2498c	245	=for apidoc m\|HV *\|PadnameTYPE\|PADNAME pn
35e035cc FC	246	The stash associated with a typed lexical. This returns the %Foo:: hash
35e035cc FC	247	for C<my Foo $bar>.
dd2155a4	248
0f94cb1f FC	249	=for apidoc Amx\|SSize_t\|PadnameREFCNT\|PADNAME pn
	250	The reference count of the pad name.
	251
	252	=for apidoc Amx\|void\|PadnameREFCNT_dec\|PADNAME pn
	253	Lowers the reference count of the pad name.
	254
dd2155a4 DM	255
	256	=for apidoc m\|SV \|PAD_SETSV \|PADOFFSET po\|SV sv
	257	Set the slot at offset C<po> in the current pad to C<sv>
	258
9a0afbbc	259	=for apidoc m\|SV *\|PAD_SV \|PADOFFSET po
dd2155a4 DM	260	Get the value at offset C<po> in the current pad
	261
	262	=for apidoc m\|SV *\|PAD_SVl \|PADOFFSET po
	263	Lightweight and lvalue version of C<PAD_SV>.
	264	Get or set the value at offset C<po> in the current pad.
	265	Unlike C<PAD_SV>, does not print diagnostics with -DX.
	266	For internal use only.
	267
	268	=for apidoc m\|SV *\|PAD_BASE_SV \|PADLIST padlist\|PADOFFSET po
	269	Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
	270
	271	=for apidoc m\|void\|PAD_SET_CUR \|PADLIST padlist\|I32 n
	272	Set the current pad to be pad C<n> in the padlist, saving
154e47c8	273	the previous current pad. NB currently this macro expands to a string too
fd617465 DM	274	long for some compilers, so it's best to replace it with
	275
	276	SAVECOMPPAD();
	277	PAD_SET_CUR_NOSAVE(padlist,n);
	278
dd2155a4	279
4e380990 DM	280	=for apidoc m\|void\|PAD_SET_CUR_NOSAVE \|PADLIST padlist\|I32 n
	281	like PAD_SET_CUR, but without the save
	282
dd2155a4 DM	283	=for apidoc m\|void\|PAD_SAVE_SETNULLPAD
	284	Save the current pad then set it to null.
	285
f3548bdc DM	286	=for apidoc m\|void\|PAD_SAVE_LOCAL\|PAD opad\|PAD npad
	287	Save the current pad to the local variable opad, then make the
	288	current pad equal to npad
	289
	290	=for apidoc m\|void\|PAD_RESTORE_LOCAL\|PAD *opad
	291	Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
dd2155a4 DM	292
	293	=cut
	294	*/
	295
86d2498c FC	296	#define PadlistARRAY(pl) (pl)->xpadl_alloc
86d2498c FC	297	#define PadlistMAX(pl) (pl)->xpadl_max
9b7476d7	298	#define PadlistNAMES(pl) ((PADNAMELIST )PadlistARRAY(pl))
86d2498c FC	299	#define PadlistNAMESARRAY(pl) PadnamelistARRAY(PadlistNAMES(pl))
	300	#define PadlistNAMESMAX(pl) PadnamelistMAX(PadlistNAMES(pl))
	301	#define PadlistREFCNT(pl) 1 /* reserved for future use */
7261499d	302
9b7476d7 FC	303	#define PadnamelistARRAY(pnl) (pnl)->xpadnl_alloc
	304	#define PadnamelistMAX(pnl) (pnl)->xpadnl_fill
	305	#define PadnamelistMAXNAMED(pnl) (pnl)->xpadnl_max_named
	306	#define PadnamelistREFCNT(pnl) (pnl)->xpadnl_refcnt
	307	#define PadnamelistREFCNT_dec(pnl) Perl_padnamelist_free(aTHX_ pnl)
35e035cc	308
86d2498c FC	309	#define PadARRAY(pad) AvARRAY(pad)
86d2498c FC	310	#define PadMAX(pad) AvFILLp(pad)
35e035cc	311
0f94cb1f FC	312	#define PadnamePV(pn) (pn)->xpadn_pv
	313	#define PadnameLEN(pn) (pn)->xpadn_len
	314	#define PadnameUTF8(pn) 1
	315	#define PadnameSV(pn) \
	316	newSVpvn_flags(PadnamePV(pn), PadnameLEN(pn), SVs_TEMP\|SVf_UTF8)
	317	#define PadnameFLAGS(pn) (pn)->xpadn_flags
	318	#define PadnameIsOUR(pn) (!!(pn)->xpadn_ourstash)
	319	#define PadnameOURSTASH(pn) (pn)->xpadn_ourstash
	320	#define PadnameTYPE(pn) (pn)->xpadn_type_u.xpadn_typestash
	321	#define PadnamePROTOCV(pn) (pn)->xpadn_type_u.xpadn_protocv
	322	#define PadnameREFCNT(pn) (pn)->xpadn_refcnt
	323	#define PadnameREFCNT_dec(pn) Perl_padname_free(aTHX_ pn)
	324	#define PadnameOURSTASH_set(pn,s) (PadnameOURSTASH(pn) = (s))
	325	#define PadnameTYPE_set(pn,s) (PadnameTYPE(pn) = (s))
	326	#define PadnameOUTER(pn) (PadnameFLAGS(pn) & PADNAMEt_OUTER)
	327	#define PadnameIsSTATE(pn) (PadnameFLAGS(pn) & PADNAMEt_STATE)
	328	#define PadnameLVALUE(pn) (PadnameFLAGS(pn) & PADNAMEt_LVALUE)
	329
	330	#define PadnameLVALUE_on(pn) (PadnameFLAGS(pn) \|= PADNAMEt_LVALUE)
	331	#define PadnameIsSTATE_on(pn) (PadnameFLAGS(pn) \|= PADNAMEt_STATE)
	332
	333	#define PADNAMEt_OUTER 1 /* outer lexical var */
	334	#define PADNAMEt_STATE 2 /* state var */
	335	#define PADNAMEt_LVALUE 4 /* used as lvalue */
	336	#define PADNAMEt_TYPED 8 /* for B; unused by core */
	337	#define PADNAMEt_OUR 16 /* for B; unused by core */
	338
	339	/* backward compatibility */
	340	#define SvPAD_STATE PadnameIsSTATE
	341	#define SvPAD_TYPED(pn) (!!PadnameTYPE(pn))
	342	#define SvPAD_OUR(pn) (!!PadnameOURSTASH(pn))
	343	#define SvPAD_STATE_on PadnameIsSTATE_on
	344	#define SvPAD_TYPED_on(pn) (PadnameFLAGS(pn) \|= PADNAMEt_TYPED)
	345	#define SvPAD_OUR_on(pn) (PadnameFLAGS(pn) \|= PADNAMEt_OUR)
	346	#define SvOURSTASH PadnameOURSTASH
	347	#define SvOURSTASH_set PadnameOURSTASH_set
	348	#define SVpad_STATE PADNAMEt_STATE
	349	#define SVpad_TYPED PADNAMEt_TYPED
	350	#define SVpad_OUR PADNAMEt_OUR
35e035cc	351
dd2155a4 DM	352	#ifdef DEBUGGING
	353	# define PAD_SV(po) pad_sv(po)
	354	# define PAD_SETSV(po,sv) pad_setsv(po,sv)
	355	#else
	356	# define PAD_SV(po) (PL_curpad[po])
	357	# define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
	358	#endif
	359
	360	#define PAD_SVl(po) (PL_curpad[po])
	361
	362	#define PAD_BASE_SV(padlist, po) \
86d2498c FC	363	(PadlistARRAY(padlist)[1]) \
86d2498c FC	364	? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
7261499d	365	: NULL;
7948fc08	366
dd2155a4	367
de5e01c2	368	#define PAD_SET_CUR_NOSAVE(padlist,nth) \
86d2498c	369	PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]); \
f3548bdc DM	370	PL_curpad = AvARRAY(PL_comppad); \
f3548bdc DM	371	DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
61608bb7	372	"Pad 0x%" UVxf "[0x%" UVxf "] set_cur depth=%d\n", \
de5e01c2	373	PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
f3548bdc DM	374
f3548bdc DM	375
de5e01c2	376	#define PAD_SET_CUR(padlist,nth) \
4e380990	377	SAVECOMPPAD(); \
de5e01c2	378	PAD_SET_CUR_NOSAVE(padlist,nth);
4e380990 DM	379
4e380990 DM	380
f3548bdc	381	#define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \
4608196e	382	PL_comppad = NULL; PL_curpad = NULL; \
f3548bdc DM	383	DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
	384
	385	#define PAD_SAVE_LOCAL(opad,npad) \
	386	opad = PL_comppad; \
	387	PL_comppad = (npad); \
4608196e	388	PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
f3548bdc	389	DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
61608bb7	390	"Pad 0x%" UVxf "[0x%" UVxf "] save_local\n", \
f3548bdc DM	391	PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
	392
	393	#define PAD_RESTORE_LOCAL(opad) \
8c63ea58 GG	394	assert(!opad \|\| !SvIS_FREED(opad)); \
8c63ea58 GG	395	PL_comppad = opad; \
4608196e	396	PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
f3548bdc	397	DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
61608bb7	398	"Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n", \
f3548bdc	399	PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
dd2155a4 DM	400
	401
	402	/*
	403	=for apidoc m\|void\|CX_CURPAD_SAVE\|struct context
	404	Save the current pad in the given context block structure.
	405
f3548bdc	406	=for apidoc m\|SV *\|CX_CURPAD_SV\|struct context\|PADOFFSET po
dd2155a4 DM	407	Access the SV at offset po in the saved current pad in the given
	408	context block structure (can be used as an lvalue).
	409
	410	=cut
	411	*/
	412
f3548bdc	413	#define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad
a062e10d	414	#define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
dd2155a4 DM	415
	416
	417	/*
	418	=for apidoc m\|U32\|PAD_COMPNAME_FLAGS\|PADOFFSET po
	419	Return the flags for the current compiling pad name
154e47c8	420	at offset C<po>. Assumes a valid slot entry.
dd2155a4 DM	421
	422	=for apidoc m\|char *\|PAD_COMPNAME_PV\|PADOFFSET po
	423	Return the name of the current compiling pad name
154e47c8	424	at offset C<po>. Assumes a valid slot entry.
dd2155a4 DM	425
	426	=for apidoc m\|HV *\|PAD_COMPNAME_TYPE\|PADOFFSET po
	427	Return the type (stash) of the current compiling pad name at offset
154e47c8	428	C<po>. Must be a valid name. Returns null if not typed.
dd2155a4 DM	429
	430	=for apidoc m\|HV *\|PAD_COMPNAME_OURSTASH\|PADOFFSET po
	431	Return the stash associated with an C<our> variable.
	432	Assumes the slot entry is a valid C<our> lexical.
	433
	434	=for apidoc m\|STRLEN\|PAD_COMPNAME_GEN\|PADOFFSET po
	435	The generation number of the name at offset C<po> in the current
154e47c8	436	compiling pad (lvalue). Note that C<SvUVX> is hijacked for this purpose.
dd2155a4	437
b162af07 SP	438	=for apidoc m\|STRLEN\|PAD_COMPNAME_GEN_set\|PADOFFSET po\|int gen
b162af07 SP	439	Sets the generation number of the name at offset C<po> in the current
931b58fb	440	ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose.
b162af07	441
dd2155a4	442	=cut
b162af07	443
dd2155a4 DM	444	*/
dd2155a4 DM	445
35e035cc	446	#define PAD_COMPNAME(po) PAD_COMPNAME_SV(po)
9b7476d7	447	#define PAD_COMPNAME_SV(po) (PadnamelistARRAY(PL_comppad_name)[(po)])
0f94cb1f	448	#define PAD_COMPNAME_FLAGS(po) PadnameFLAGS(PAD_COMPNAME(po))
1979170b	449	#define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
e1c02f84	450	#define PAD_COMPNAME_PV(po) PadnamePV(PAD_COMPNAME(po))
dd2155a4	451
afb6e3f5	452	#define PAD_COMPNAME_TYPE(po) PadnameTYPE(PAD_COMPNAME(po))
dd2155a4 DM	453
dd2155a4 DM	454	#define PAD_COMPNAME_OURSTASH(po) \
73d95100	455	(SvOURSTASH(PAD_COMPNAME_SV(po)))
dd2155a4	456
9b7476d7	457	#define PAD_COMPNAME_GEN(po) \
0f94cb1f	458	((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)
dd2155a4	459
9b7476d7	460	#define PAD_COMPNAME_GEN_set(po, gen) \
0f94cb1f	461	(PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))
dd2155a4 DM	462
	463
	464	/*
d77cdebf	465	=for apidoc m\|void\|PAD_CLONE_VARS\|PerlInterpreter proto_perl\|CLONE_PARAMS param
dd2155a4 DM	466	Clone the state variables associated with running and compiling pads.
	467
	468	=cut
	469	*/
	470
c5ab0850 DM	471	/* NB - we set PL_comppad to null unless it points at a value that
	472	* has already been dup'ed, ie it points to part of an active padlist.
	473	* Otherwise PL_comppad ends up being a leaked scalar in code like
	474	* the following:
	475	* threads->create(sub { threads->create(sub {...} ) } );
	476	* where the second thread dups the outer sub's comppad but not the
	477	* sub's CV or padlist. */
f3548bdc	478
dd2155a4	479	#define PAD_CLONE_VARS(proto_perl, param) \
253649d9	480	PL_comppad = av_dup(proto_perl->Icomppad, param); \
4608196e	481	PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
9b7476d7 FC	482	PL_comppad_name = \
9b7476d7 FC	483	padnamelist_dup(proto_perl->Icomppad_name, param); \
dd2155a4 DM	484	PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \
dd2155a4 DM	485	PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \
dd2155a4 DM	486	PL_min_intro_pending = proto_perl->Imin_intro_pending; \
	487	PL_max_intro_pending = proto_perl->Imax_intro_pending; \
	488	PL_padix = proto_perl->Ipadix; \
	489	PL_padix_floor = proto_perl->Ipadix_floor; \
	490	PL_pad_reset_pending = proto_perl->Ipad_reset_pending; \
	491	PL_cop_seqmax = proto_perl->Icop_seqmax;
e9a8c099 MHM	492
e9a8c099 MHM	493	/*
cc76b5cc Z	494	=for apidoc Am\|PADOFFSET\|pad_add_name_pvs\|const char name\|U32 flags\|HV typestash\|HV *ourstash
	495
	496	Exactly like L</pad_add_name_pvn>, but takes a literal string instead
	497	of a string/length pair.
	498
	499	=cut
	500	*/
	501
	502	#define pad_add_name_pvs(name,flags,typestash,ourstash) \
	503	Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
	504
	505	/*
	506	=for apidoc Am\|PADOFFSET\|pad_findmy_pvs\|const char *name\|U32 flags
	507
	508	Exactly like L</pad_findmy_pvn>, but takes a literal string instead
	509	of a string/length pair.
	510
	511	=cut
	512	*/
	513
	514	#define pad_findmy_pvs(name,flags) \
	515	Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
	516
	517	/*
e9a8c099 MHM	518	* Local variables:
	519	* c-indentation-style: bsd
	520	* c-basic-offset: 4
14d04a33	521	* indent-tabs-mode: nil
e9a8c099 MHM	522	* End:
e9a8c099 MHM	523	*
14d04a33	524	* ex: set ts=8 sts=4 sw=4 et:
e9a8c099	525	*/