[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)


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


/* 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_STALEOK		0x08	   /* allow stale lexical in active
					    * sub, but only one level up */
#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 Amx|PAD **|PADLIST_ARRAY|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|PADLIST_MAX|PADLIST padlist
The index of the last pad in the padlist.

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

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

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

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

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

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

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

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

=for apidoc Amx|char *|PADNAME_PV|PADNAME pn	
The name stored in the pad name struct.

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

=for apidoc Amx|bool|PADNAME_UTF8|PADNAME pn
Whether PADNAME_PV is in UTF8.

=for apidoc Amx|SV *|PADNAME_SV|PADNAME pn
Returns the pad name as an SV.  This is currently just C<pn>.  It will
begin returning a new mortal SV if pad names ever stop being SVs.

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

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

=for apidoc m|bool|PADNAME_OUTER|PADNAME pn
Whether this entry belongs to an outer pad.

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


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

#define PADLIST_ARRAY(pl)	(pl)->xpadl_alloc
#define PADLIST_MAX(pl)		(pl)->xpadl_max
#define PADLIST_NAMES(pl)	(*PADLIST_ARRAY(pl))
#define PADLIST_NAMESARRAY(pl)	PADNAMELIST_ARRAY(PADLIST_NAMES(pl))
#define PADLIST_NAMESMAX(pl)	PADNAMELIST_MAX(PADLIST_NAMES(pl))
#define PADLIST_REFCNT(pl)	1	/* reserved for future use */

#define PADNAMELIST_ARRAY(pnl)	AvARRAY(pnl)
#define PADNAMELIST_MAX(pnl)	AvFILLp(pnl)

#define PAD_ARRAY(pad)		AvARRAY(pad)
#define PAD_MAX(pad)		AvFILLp(pad)

#define PADNAME_PV(pn)		SvPV_nolen(pn)
#define PADNAME_LEN(pn)		SvCUR(pn)
#define PADNAME_UTF8(pn)	!!SvUTF8(pn)
#define PADNAME_SV(pn)		pn
#define PADNAME_isOUR(pn)	!!SvPAD_OUR(pn)
#define PADNAME_OURSTASH(pn)	SvOURSTASH(pn)
#define PADNAME_OUTER(pn)	!!SvFAKE(pn)
#define PADNAME_TYPE(pn)	(SvPAD_TYPED(pn) ? SvSTASH(pn) : NULL)


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


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