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


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

#define padadd_OUR		0x01	   /* our declaration. */
#define padadd_STATE		0x02	   /* state declaration. */
#define padadd_NO_DUP_CHECK	0x04	   /* skip warning on dups. */
#define padadd_UTF8_NAME	SVf_UTF8   /* name is UTF-8 encoded. */

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