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