3 * Copyright (C) 2002, 2003, 2005, 2006, 2007, 2008,
4 * 2009, 2010, 2011 by Larry Wall and others
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.
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.
15 =head1 Pad Data Structures
19 /* offsets within a pad */
22 typedef U32TYPE PADOFFSET;
25 typedef U64TYPE PADOFFSET;
28 #define NOT_IN_PAD ((PADOFFSET) -1)
30 /* B.xs expects the first members of these two structs to line up
31 (xpadl_max with xpadnl_fill).
35 SSize_t xpadl_max; /* max index for which array has space */
36 PAD ** xpadl_alloc; /* pointer to beginning of array of AVs */
37 U32 xpadl_id; /* Semi-unique ID, shared between clones */
38 U32 xpadl_outid; /* ID of outer pad */
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 */
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
56 #if !defined(PERL_PADNAME_MINIMAL) && !defined(PERL_PADNAME_ALIGNED)
57 # define PERL_PADNAME_MINIMAL
60 #define _PADNAME_BASE \
62 HV * xpadn_ourstash; \
64 HV * xpadn_typestash; \
78 struct padname_with_str {
79 #ifdef PERL_PADNAME_MINIMAL
82 struct padname xpadn_padname;
89 #define PADNAME_FROM_PV(s) \
90 ((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str)))
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
96 #define PERL_PADSEQ_INTRO U32_MAX
97 #define COP_SEQMAX_INC \
99 (void)(PL_cop_seqmax == PERL_PADSEQ_INTRO && PL_cop_seqmax++))
102 /* B.xs needs these for the benefit of B::Deparse */
103 /* Low range end is exclusive (valid from the cop seq after this one) */
104 /* High range end is inclusive (valid up to this cop seq) */
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
111 /* Flags set in the SvIVX field of FAKE namesvs */
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 */
116 /* flags for the pad_new() function */
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 */
122 /* values for the pad_tidy() function */
125 padtidy_SUB, /* tidy up a pad for a sub, */
126 padtidy_SUBCLONE, /* a cloned sub, */
127 padtidy_FORMAT /* or a format */
130 /* flags for pad_add_name_pvn. */
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. */
135 #define padadd_STALEOK 0x08 /* allow stale lexical in active
136 * sub, but only one level up */
138 /* ASSERT_CURPAD_LEGAL and ASSERT_CURPAD_ACTIVE respectively determine
139 * whether PL_comppad and PL_curpad are consistent and whether they have
142 # define pad_peg(label)
145 # define ASSERT_CURPAD_LEGAL(label) \
147 if (PL_comppad ? (AvARRAY(PL_comppad) != PL_curpad) : (PL_curpad != 0)) \
148 Perl_croak(aTHX_ "panic: illegal pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
149 label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
152 # define ASSERT_CURPAD_ACTIVE(label) \
154 if (!PL_comppad || (AvARRAY(PL_comppad) != PL_curpad)) \
155 Perl_croak(aTHX_ "panic: invalid pad in %s: 0x%" UVxf "[0x%" UVxf "]",\
156 label, PTR2UV(PL_comppad), PTR2UV(PL_curpad));
158 # define ASSERT_CURPAD_LEGAL(label)
159 # define ASSERT_CURPAD_ACTIVE(label)
164 /* Note: the following three macros are actually defined in scope.h, but
165 * they are documented here for completeness, since they directly or
166 * indirectly affect pads.
168 =for apidoc m|void|SAVEPADSV |PADOFFSET po
169 Save a pad slot (used to restore after an iteration)
171 XXX DAPM it would make more sense to make the arg a PADOFFSET
172 =for apidoc m|void|SAVECLEARSV |SV **svp
173 Clear the pointed to pad value on scope exit. (i.e. the runtime action of
176 =for apidoc m|void|SAVECOMPPAD
177 save PL_comppad and PL_curpad
180 =for apidoc Amx|PAD **|PadlistARRAY|PADLIST padlist
181 The C array of a padlist, containing the pads. Only subscript it with
182 numbers >= 1, as the 0th entry is not guaranteed to remain usable.
184 =for apidoc Amx|SSize_t|PadlistMAX|PADLIST padlist
185 The index of the last allocated space in the padlist. Note that the last
186 pad may be in an earlier slot. Any entries following it will be NULL in
189 =for apidoc Amx|PADNAMELIST *|PadlistNAMES|PADLIST padlist
190 The names associated with pad entries.
192 =for apidoc Amx|PADNAME **|PadlistNAMESARRAY|PADLIST padlist
193 The C array of pad names.
195 =for apidoc Amx|SSize_t|PadlistNAMESMAX|PADLIST padlist
196 The index of the last pad name.
198 =for apidoc Amx|U32|PadlistREFCNT|PADLIST padlist
199 The reference count of the padlist. Currently this is always 1.
201 =for apidoc Amx|PADNAME **|PadnamelistARRAY|PADNAMELIST pnl
202 The C array of pad names.
204 =for apidoc Amx|SSize_t|PadnamelistMAX|PADNAMELIST pnl
205 The index of the last pad name.
207 =for apidoc Amx|SSize_t|PadnamelistREFCNT|PADNAMELIST pnl
208 The reference count of the pad name list.
210 =for apidoc Amx|void|PadnamelistREFCNT_dec|PADNAMELIST pnl
211 Lowers the reference count of the pad name list.
213 =for apidoc Amx|SV **|PadARRAY|PAD pad
214 The C array of pad entries.
216 =for apidoc Amx|SSize_t|PadMAX|PAD pad
217 The index of the last pad entry.
219 =for apidoc Amx|char *|PadnamePV|PADNAME pn
220 The name stored in the pad name struct. This returns NULL for a target
223 =for apidoc Amx|STRLEN|PadnameLEN|PADNAME pn
224 The length of the name.
226 =for apidoc Amx|bool|PadnameUTF8|PADNAME pn
227 Whether PadnamePV is in UTF8. Currently, this is always true.
229 =for apidoc Amx|SV *|PadnameSV|PADNAME pn
230 Returns the pad name as a mortal SV.
232 =for apidoc m|bool|PadnameIsOUR|PADNAME pn
233 Whether this is an "our" variable.
235 =for apidoc m|HV *|PadnameOURSTASH
236 The stash in which this "our" variable was declared.
238 =for apidoc m|bool|PadnameOUTER|PADNAME pn
239 Whether this entry belongs to an outer pad. Entries for which this is true
240 are often referred to as 'fake'.
242 =for apidoc m|bool|PadnameIsSTATE|PADNAME pn
243 Whether this is a "state" variable.
245 =for apidoc m|HV *|PadnameTYPE|PADNAME pn
246 The stash associated with a typed lexical. This returns the %Foo:: hash
249 =for apidoc Amx|SSize_t|PadnameREFCNT|PADNAME pn
250 The reference count of the pad name.
252 =for apidoc Amx|void|PadnameREFCNT_dec|PADNAME pn
253 Lowers the reference count of the pad name.
256 =for apidoc m|SV *|PAD_SETSV |PADOFFSET po|SV* sv
257 Set the slot at offset C<po> in the current pad to C<sv>
259 =for apidoc m|SV *|PAD_SV |PADOFFSET po
260 Get the value at offset C<po> in the current pad
262 =for apidoc m|SV *|PAD_SVl |PADOFFSET po
263 Lightweight and lvalue version of C<PAD_SV>.
264 Get or set the value at offset C<po> in the current pad.
265 Unlike C<PAD_SV>, does not print diagnostics with -DX.
266 For internal use only.
268 =for apidoc m|SV *|PAD_BASE_SV |PADLIST padlist|PADOFFSET po
269 Get the value from slot C<po> in the base (DEPTH=1) pad of a padlist
271 =for apidoc m|void|PAD_SET_CUR |PADLIST padlist|I32 n
272 Set the current pad to be pad C<n> in the padlist, saving
273 the previous current pad. NB currently this macro expands to a string too
274 long for some compilers, so it's best to replace it with
277 PAD_SET_CUR_NOSAVE(padlist,n);
280 =for apidoc m|void|PAD_SET_CUR_NOSAVE |PADLIST padlist|I32 n
281 like PAD_SET_CUR, but without the save
283 =for apidoc m|void|PAD_SAVE_SETNULLPAD
284 Save the current pad then set it to null.
286 =for apidoc m|void|PAD_SAVE_LOCAL|PAD *opad|PAD *npad
287 Save the current pad to the local variable opad, then make the
288 current pad equal to npad
290 =for apidoc m|void|PAD_RESTORE_LOCAL|PAD *opad
291 Restore the old pad saved into the local variable opad by PAD_SAVE_LOCAL()
296 #define PadlistARRAY(pl) (pl)->xpadl_alloc
297 #define PadlistMAX(pl) (pl)->xpadl_max
298 #define PadlistNAMES(pl) ((PADNAMELIST *)*PadlistARRAY(pl))
299 #define PadlistNAMESARRAY(pl) PadnamelistARRAY(PadlistNAMES(pl))
300 #define PadlistNAMESMAX(pl) PadnamelistMAX(PadlistNAMES(pl))
301 #define PadlistREFCNT(pl) 1 /* reserved for future use */
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)
309 #define PadARRAY(pad) AvARRAY(pad)
310 #define PadMAX(pad) AvFILLp(pad)
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)
330 #define PadnameLVALUE_on(pn) (PadnameFLAGS(pn) |= PADNAMEt_LVALUE)
331 #define PadnameIsSTATE_on(pn) (PadnameFLAGS(pn) |= PADNAMEt_STATE)
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 */
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
353 # define PAD_SV(po) pad_sv(po)
354 # define PAD_SETSV(po,sv) pad_setsv(po,sv)
356 # define PAD_SV(po) (PL_curpad[po])
357 # define PAD_SETSV(po,sv) PL_curpad[po] = (sv)
360 #define PAD_SVl(po) (PL_curpad[po])
362 #define PAD_BASE_SV(padlist, po) \
363 (PadlistARRAY(padlist)[1]) \
364 ? AvARRAY(MUTABLE_AV((PadlistARRAY(padlist)[1])))[po] \
368 #define PAD_SET_CUR_NOSAVE(padlist,nth) \
369 PL_comppad = (PAD*) (PadlistARRAY(padlist)[nth]); \
370 PL_curpad = AvARRAY(PL_comppad); \
371 DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
372 "Pad 0x%" UVxf "[0x%" UVxf "] set_cur depth=%d\n", \
373 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (int)(nth)));
376 #define PAD_SET_CUR(padlist,nth) \
378 PAD_SET_CUR_NOSAVE(padlist,nth);
381 #define PAD_SAVE_SETNULLPAD() SAVECOMPPAD(); \
382 PL_comppad = NULL; PL_curpad = NULL; \
383 DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad set_null\n"));
385 #define PAD_SAVE_LOCAL(opad,npad) \
387 PL_comppad = (npad); \
388 PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
389 DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
390 "Pad 0x%" UVxf "[0x%" UVxf "] save_local\n", \
391 PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
393 #define PAD_RESTORE_LOCAL(opad) \
394 assert(!opad || !SvIS_FREED(opad)); \
396 PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
397 DEBUG_Xv(PerlIO_printf(Perl_debug_log, \
398 "Pad 0x%" UVxf "[0x%" UVxf "] restore_local\n", \
399 PTR2UV(PL_comppad), PTR2UV(PL_curpad)));
403 =for apidoc m|void|CX_CURPAD_SAVE|struct context
404 Save the current pad in the given context block structure.
406 =for apidoc m|SV *|CX_CURPAD_SV|struct context|PADOFFSET po
407 Access the SV at offset po in the saved current pad in the given
408 context block structure (can be used as an lvalue).
413 #define CX_CURPAD_SAVE(block) (block).oldcomppad = PL_comppad
414 #define CX_CURPAD_SV(block,po) (AvARRAY(MUTABLE_AV(((block).oldcomppad)))[po])
418 =for apidoc m|U32|PAD_COMPNAME_FLAGS|PADOFFSET po
419 Return the flags for the current compiling pad name
420 at offset C<po>. Assumes a valid slot entry.
422 =for apidoc m|char *|PAD_COMPNAME_PV|PADOFFSET po
423 Return the name of the current compiling pad name
424 at offset C<po>. Assumes a valid slot entry.
426 =for apidoc m|HV *|PAD_COMPNAME_TYPE|PADOFFSET po
427 Return the type (stash) of the current compiling pad name at offset
428 C<po>. Must be a valid name. Returns null if not typed.
430 =for apidoc m|HV *|PAD_COMPNAME_OURSTASH|PADOFFSET po
431 Return the stash associated with an C<our> variable.
432 Assumes the slot entry is a valid C<our> lexical.
434 =for apidoc m|STRLEN|PAD_COMPNAME_GEN|PADOFFSET po
435 The generation number of the name at offset C<po> in the current
436 compiling pad (lvalue). Note that C<SvUVX> is hijacked for this purpose.
438 =for apidoc m|STRLEN|PAD_COMPNAME_GEN_set|PADOFFSET po|int gen
439 Sets the generation number of the name at offset C<po> in the current
440 ling pad (lvalue) to C<gen>. Note that C<SvUV_set> is hijacked for this purpose.
446 #define PAD_COMPNAME(po) PAD_COMPNAME_SV(po)
447 #define PAD_COMPNAME_SV(po) (PadnamelistARRAY(PL_comppad_name)[(po)])
448 #define PAD_COMPNAME_FLAGS(po) PadnameFLAGS(PAD_COMPNAME(po))
449 #define PAD_COMPNAME_FLAGS_isOUR(po) SvPAD_OUR(PAD_COMPNAME_SV(po))
450 #define PAD_COMPNAME_PV(po) PadnamePV(PAD_COMPNAME(po))
452 #define PAD_COMPNAME_TYPE(po) PadnameTYPE(PAD_COMPNAME(po))
454 #define PAD_COMPNAME_OURSTASH(po) \
455 (SvOURSTASH(PAD_COMPNAME_SV(po)))
457 #define PAD_COMPNAME_GEN(po) \
458 ((STRLEN)PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen)
460 #define PAD_COMPNAME_GEN_set(po, gen) \
461 (PadnamelistARRAY(PL_comppad_name)[po]->xpadn_gen = (gen))
465 =for apidoc m|void|PAD_CLONE_VARS|PerlInterpreter *proto_perl|CLONE_PARAMS* param
466 Clone the state variables associated with running and compiling pads.
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
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. */
479 #define PAD_CLONE_VARS(proto_perl, param) \
480 PL_comppad = av_dup(proto_perl->Icomppad, param); \
481 PL_curpad = PL_comppad ? AvARRAY(PL_comppad) : NULL; \
483 padnamelist_dup(proto_perl->Icomppad_name, param); \
484 PL_comppad_name_fill = proto_perl->Icomppad_name_fill; \
485 PL_comppad_name_floor = proto_perl->Icomppad_name_floor; \
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;
494 =for apidoc Am|PADOFFSET|pad_add_name_pvs|const char *name|U32 flags|HV *typestash|HV *ourstash
496 Exactly like L</pad_add_name_pvn>, but takes a literal string instead
497 of a string/length pair.
502 #define pad_add_name_pvs(name,flags,typestash,ourstash) \
503 Perl_pad_add_name_pvn(aTHX_ STR_WITH_LEN(name), flags, typestash, ourstash)
506 =for apidoc Am|PADOFFSET|pad_findmy_pvs|const char *name|U32 flags
508 Exactly like L</pad_findmy_pvn>, but takes a literal string instead
509 of a string/length pair.
514 #define pad_findmy_pvs(name,flags) \
515 Perl_pad_findmy_pvn(aTHX_ STR_WITH_LEN(name), flags)
518 * ex: set ts=8 sts=4 sw=4 et: