This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
make PadlistNAMES() lvalue again.
[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
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
34struct 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 */
38 U32 xpadl_outid; /* ID of outer pad */
7261499d
FC
39};
40
9b7476d7
FC
41struct 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 74struct padname {
66230865 75 _PADNAME_BASE;
0f94cb1f
FC
76};
77
78struct 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
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
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 */
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
124typedef 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
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
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
169Save a pad slot (used to restore after an iteration)
170
f3548bdc 171XXX DAPM it would make more sense to make the arg a PADOFFSET
dd2155a4 172=for apidoc m|void|SAVECLEARSV |SV **svp
154e47c8
FC
173Clear the pointed to pad value on scope exit. (i.e. the runtime action of
174'my')
dd2155a4
DM
175
176=for apidoc m|void|SAVECOMPPAD
9c47725a 177save PL_comppad and PL_curpad
dd2155a4 178
dd2155a4 179
86d2498c 180=for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist
35e035cc
FC
181The C array of a padlist, containing the pads. Only subscript it with
182numbers >= 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
185The index of the last allocated space in the padlist. Note that the last
186pad may be in an earlier slot. Any entries following it will be NULL in
187that case.
35e035cc 188
86d2498c 189=for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist
35e035cc
FC
190The names associated with pad entries.
191
86d2498c 192=for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist
35e035cc
FC
193The C array of pad names.
194
86d2498c 195=for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist
35e035cc
FC
196The index of the last pad name.
197
86d2498c 198=for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist
35e035cc
FC
199The reference count of the padlist. Currently this is always 1.
200
86d2498c 201=for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl
35e035cc
FC
202The C array of pad names.
203
86d2498c 204=for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl
35e035cc
FC
205The index of the last pad name.
206
9b7476d7
FC
207=for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST pnl
208The reference count of the pad name list.
209
210=for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST pnl
211Lowers the reference count of the pad name list.
212
86d2498c 213=for apidoc Amx|SV **|PadARRAY|PAD pad
35e035cc
FC
214The C array of pad entries.
215
86d2498c 216=for apidoc Amx|SSize_t|PadMAX|PAD pad
35e035cc
FC
217The index of the last pad entry.
218
86d2498c 219=for apidoc Amx|char *|PadnamePV|PADNAME pn
863f2221
FC
220The name stored in the pad name struct. This returns NULL for a target
221slot.
35e035cc 222
86d2498c 223=for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn
35e035cc
FC
224The length of the name.
225
86d2498c 226=for apidoc Amx|bool|PadnameUTF8|PADNAME pn
2502ffdf 227Whether PadnamePV is in UTF8. Currently, this is always true.
35e035cc 228
86d2498c 229=for apidoc Amx|SV *|PadnameSV|PADNAME pn
0f94cb1f 230Returns the pad name as a mortal SV.
97dad6bd 231
86d2498c 232=for apidoc m|bool|PadnameIsOUR|PADNAME pn
35e035cc
FC
233Whether this is an "our" variable.
234
86d2498c 235=for apidoc m|HV *|PadnameOURSTASH
35e035cc
FC
236The stash in which this "our" variable was declared.
237
86d2498c 238=for apidoc m|bool|PadnameOUTER|PADNAME pn
b19cb98d
FC
239Whether this entry belongs to an outer pad. Entries for which this is true
240are often referred to as 'fake'.
c44737a2 241
3f6a9d3a 242=for apidoc m|bool|PadnameIsSTATE|PADNAME pn
643fe368
FC
243Whether this is a "state" variable.
244
86d2498c 245=for apidoc m|HV *|PadnameTYPE|PADNAME pn
35e035cc
FC
246The stash associated with a typed lexical. This returns the %Foo:: hash
247for C<my Foo $bar>.
dd2155a4 248
0f94cb1f
FC
249=for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME pn
250The reference count of the pad name.
251
252=for apidoc Amx|void|PadnameREFCNT_dec|PADNAME pn
253Lowers the reference count of the pad name.
254
dd2155a4
DM
255
256=for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv
257Set 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
260Get the value at offset C<po> in the current pad
261
262=for apidoc m|SV *|PAD_SVl |PADOFFSET po
263Lightweight and lvalue version of C<PAD_SV>.
264Get or set the value at offset C<po> in the current pad.
265Unlike C<PAD_SV>, does not print diagnostics with -DX.
266For internal use only.
267
268=for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po
269Get 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
272Set the current pad to be pad C<n> in the padlist, saving
154e47c8 273the previous current pad. NB currently this macro expands to a string too
fd617465
DM
274long 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
281like PAD_SET_CUR, but without the save
282
dd2155a4
DM
283=for apidoc m|void|PAD_SAVE_SETNULLPAD
284Save the current pad then set it to null.
285
f3548bdc
DM
286=for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
287Save the current pad to the local variable opad, then make the
288current pad equal to npad
289
290=for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
291Restore 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
297#define PadlistMAX(pl) (pl)->xpadl_max
73949fca 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)
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]) \
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); \
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
375
de5e01c2 376#define PAD_SET_CUR(padlist,nth) \
4e380990 377 SAVECOMPPAD(); \
de5e01c2 378 PAD_SET_CUR_NOSAVE(padlist,nth);
4e380990
DM
379
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)); \
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
404Save 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
407Access the SV at offset po in the saved current pad in the given
408context 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
419Return the flags for the current compiling pad name
154e47c8 420at offset C<po>. Assumes a valid slot entry.
dd2155a4
DM
421
422=for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
423Return the name of the current compiling pad name
154e47c8 424at offset C<po>. Assumes a valid slot entry.
dd2155a4
DM
425
426=for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
427Return the type (stash) of the current compiling pad name at offset
154e47c8 428C<po>. Must be a valid name. Returns null if not typed.
dd2155a4
DM
429
430=for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
431Return the stash associated with an C<our> variable.
432Assumes the slot entry is a valid C<our> lexical.
433
434=for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
435The generation number of the name at offset C<po> in the current
154e47c8 436compiling 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
439Sets the generation number of the name at offset C<po> in the current
931b58fb 440ling 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*/
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
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
466Clone 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 = \
483 padnamelist_dup(proto_perl->Icomppad_name, param); \
dd2155a4
DM
484 PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \
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
493/*
cc76b5cc
Z
494=for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash
495
496Exactly like L</pad_add_name_pvn>, but takes a literal string instead
497of 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
508Exactly like L</pad_findmy_pvn>, but takes a literal string instead
509of 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/*
14d04a33 518 * ex: set ts=8 sts=4 sw=4 et:
e9a8c099 519 */