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