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