3 * Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
4 * 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.
11 * 'Anyway: there was this Mr. Frodo left an orphan and stranded, as you
12 * might say, among those queer Bucklanders, being brought up anyhow in
13 * Brandy Hall. A regular warren, by all accounts. Old Master Gorbadoc
14 * never had fewer than a couple of hundred relations in the place.
15 * Mr. Bilbo never did a kinder deed than when he brought the lad back
16 * to live among decent folk.' --the Gaffer
18 * [p.23 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
22 * As of Sept 2002, this file is new and may be in a state of flux for
23 * a while. I've marked things I intent to come back and look at further
24 * with an 'XXX DAPM' comment.
28 =head1 Pad Data Structures
30 =for apidoc Amx|PADLIST *|CvPADLIST|CV *cv
32 CV's can have CvPADLIST(cv) set to point to a PADLIST. This is the CV's
33 scratchpad, which stores lexical variables and opcode temporary and
36 For these purposes "formats" are a kind-of CV; eval""s are too (except they're
37 not callable at will and are always thrown away after the eval"" is done
38 executing). Require'd files are simply evals without any outer lexical
41 XSUBs do not have a C<CvPADLIST>. C<dXSTARG> fetches values from C<PL_curpad>,
42 but that is really the callers pad (a slot of which is allocated by
43 every entersub). Do not get or set C<CvPADLIST> if a CV is an XSUB (as
44 determined by C<CvISXSUB()>), C<CvPADLIST> slot is reused for a different
45 internal purpose in XSUBs.
47 The PADLIST has a C array where pads are stored.
49 The 0th entry of the PADLIST is a PADNAMELIST
50 which represents the "names" or rather
51 the "static type information" for lexicals. The individual elements of a
52 PADNAMELIST are PADNAMEs. Future
53 refactorings might stop the PADNAMELIST from being stored in the PADLIST's
54 array, so don't rely on it. See L</PadlistNAMES>.
56 The CvDEPTH'th entry of a PADLIST is a PAD (an AV) which is the stack frame
57 at that depth of recursion into the CV. The 0th slot of a frame AV is an
58 AV which is C<@_>. Other entries are storage for variables and op targets.
60 Iterating over the PADNAMELIST iterates over all possible pad
61 items. Pad slots for targets (C<SVs_PADTMP>)
62 and GVs end up having &PL_padname_undef "names", while slots for constants
63 have C<&PL_padname_const> "names" (see C<L</pad_alloc>>). That
65 and C<&PL_padname_const> are used is an implementation detail subject to
66 change. To test for them, use C<!PadnamePV(name)> and
67 S<C<PadnamePV(name) && !PadnameLEN(name)>>, respectively.
69 Only C<my>/C<our> variable slots get valid names.
70 The rest are op targets/GVs/constants which are statically allocated
71 or resolved at compile time. These don't have names by which they
72 can be looked up from Perl code at run time through eval"" the way
73 C<my>/C<our> variables can be. Since they can't be looked up by "name"
74 but only by their index allocated at compile time (which is usually
75 in C<PL_op->op_targ>), wasting a name SV for them doesn't make sense.
77 The pad names in the PADNAMELIST have their PV holding the name of
78 the variable. The C<COP_SEQ_RANGE_LOW> and C<_HIGH> fields form a range
79 (low+1..high inclusive) of cop_seq numbers for which the name is
80 valid. During compilation, these fields may hold the special value
81 PERL_PADSEQ_INTRO to indicate various stages:
83 COP_SEQ_RANGE_LOW _HIGH
84 ----------------- -----
85 PERL_PADSEQ_INTRO 0 variable not yet introduced:
87 valid-seq# PERL_PADSEQ_INTRO variable in scope:
89 valid-seq# valid-seq# compilation of scope complete:
92 For typed lexicals C<PadnameTYPE> points at the type stash. For C<our>
93 lexicals, C<PadnameOURSTASH> points at the stash of the associated global (so
94 that duplicate C<our> declarations in the same package can be detected).
95 C<PadnameGEN> is sometimes used to store the generation number during
98 If C<PadnameOUTER> is set on the pad name, then that slot in the frame AV
99 is a REFCNT'ed reference to a lexical from "outside". Such entries
100 are sometimes referred to as 'fake'. In this case, the name does not
101 use 'low' and 'high' to store a cop_seq range, since it is in scope
102 throughout. Instead 'high' stores some flags containing info about
103 the real lexical (is it declared in an anon, and is it capable of being
104 instantiated multiple times?), and for fake ANONs, 'low' contains the index
105 within the parent's pad where the lexical's value is stored, to make
108 If the 'name' is C<&> the corresponding entry in the PAD
109 is a CV representing a possible closure.
111 Note that formats are treated as anon subs, and are cloned each time
112 write is called (if necessary).
114 The flag C<SVs_PADSTALE> is cleared on lexicals each time the C<my()> is executed,
115 and set on scope exit. This allows the
116 C<"Variable $x is not available"> warning
117 to be generated in evals, such as
119 { my $x = 1; sub f { eval '$x'} } f();
121 For state vars, C<SVs_PADSTALE> is overloaded to mean 'not yet initialised',
122 but this internal state is stored in a separate pad entry.
124 =for apidoc AmxU|PADNAMELIST *|PL_comppad_name
126 During compilation, this points to the array containing the names part
127 of the pad for the currently-compiling code.
129 =for apidoc AmxU|PAD *|PL_comppad
131 During compilation, this points to the array containing the values
132 part of the pad for the currently-compiling code. (At runtime a CV may
133 have many such value arrays; at compile time just one is constructed.)
134 At runtime, this points to the array containing the currently-relevant
135 values for the pad for the currently-executing code.
137 =for apidoc AmxU|SV **|PL_curpad
139 Points directly to the body of the L</PL_comppad> array.
140 (I.e., this is C<PAD_ARRAY(PL_comppad)>.)
147 #define PERL_IN_PAD_C
149 #include "keywords.h"
151 #define COP_SEQ_RANGE_LOW_set(sv,val) \
152 STMT_START { (sv)->xpadn_low = (val); } STMT_END
153 #define COP_SEQ_RANGE_HIGH_set(sv,val) \
154 STMT_START { (sv)->xpadn_high = (val); } STMT_END
156 #define PARENT_PAD_INDEX_set COP_SEQ_RANGE_LOW_set
157 #define PARENT_FAKELEX_FLAGS_set COP_SEQ_RANGE_HIGH_set
161 Perl_set_padlist(CV * cv, PADLIST *padlist){
162 PERL_ARGS_ASSERT_SET_PADLIST;
164 assert((Size_t)padlist != UINT64_C(0xEFEFEFEFEFEFEFEF));
166 assert((Size_t)padlist != 0xEFEFEFEF);
168 # error unknown pointer size
170 assert(!CvISXSUB(cv));
171 ((XPVCV*)MUTABLE_PTR(SvANY(cv)))->xcv_padlist_u.xcv_padlist = padlist;
176 =for apidoc Am|PADLIST *|pad_new|int flags
178 Create a new padlist, updating the global variables for the
179 currently-compiling padlist to point to the new padlist. The following
180 flags can be OR'ed together:
182 padnew_CLONE this pad is for a cloned CV
183 padnew_SAVE save old globals on the save stack
184 padnew_SAVESUB also save extra stuff for start of sub
190 Perl_pad_new(pTHX_ int flags)
193 PADNAMELIST *padname;
197 ASSERT_CURPAD_LEGAL("pad_new");
199 /* XXX DAPM really need a new SAVEt_PAD which restores all or most
200 * vars (based on flags) rather than storing vals + addresses for
201 * each individually. Also see pad_block_start.
202 * XXX DAPM Try to see whether all these conditionals are required
205 /* save existing state, ... */
207 if (flags & padnew_SAVE) {
209 if (! (flags & padnew_CLONE)) {
210 SAVESPTR(PL_comppad_name);
212 SAVEI32(PL_constpadix);
213 SAVEI32(PL_comppad_name_fill);
214 SAVEI32(PL_min_intro_pending);
215 SAVEI32(PL_max_intro_pending);
216 SAVEBOOL(PL_cv_has_eval);
217 if (flags & padnew_SAVESUB) {
218 SAVEBOOL(PL_pad_reset_pending);
222 /* XXX DAPM interestingly, PL_comppad_name_floor never seems to be
223 * saved - check at some pt that this is okay */
225 /* ... create new pad ... */
227 Newxz(padlist, 1, PADLIST);
230 if (flags & padnew_CLONE) {
231 /* XXX DAPM I dont know why cv_clone needs it
232 * doing differently yet - perhaps this separate branch can be
233 * dispensed with eventually ???
236 AV * const a0 = newAV(); /* will be @_ */
237 av_store(pad, 0, MUTABLE_SV(a0));
240 PadnamelistREFCNT(padname = PL_comppad_name)++;
243 padlist->xpadl_id = PL_padlist_generation++;
244 av_store(pad, 0, NULL);
245 padname = newPADNAMELIST(0);
246 padnamelist_store(padname, 0, &PL_padname_undef);
249 /* Most subroutines never recurse, hence only need 2 entries in the padlist
250 array - names, and depth=1. The default for av_store() is to allocate
251 0..3, and even an explicit call to av_extend() with <3 will be rounded
252 up, so we inline the allocation of the array here. */
254 PadlistMAX(padlist) = 1;
255 PadlistARRAY(padlist) = ary;
256 ary[0] = (PAD *)padname;
259 /* ... then update state variables */
262 PL_curpad = AvARRAY(pad);
264 if (! (flags & padnew_CLONE)) {
265 PL_comppad_name = padname;
266 PL_comppad_name_fill = 0;
267 PL_min_intro_pending = 0;
273 DEBUG_X(PerlIO_printf(Perl_debug_log,
274 "Pad 0x%"UVxf"[0x%"UVxf"] new: compcv=0x%"UVxf
275 " name=0x%"UVxf" flags=0x%"UVxf"\n",
276 PTR2UV(PL_comppad), PTR2UV(PL_curpad), PTR2UV(PL_compcv),
277 PTR2UV(padname), (UV)flags
281 return (PADLIST*)padlist;
286 =head1 Embedding Functions
290 Clear out all the active components of a CV. This can happen either
291 by an explicit C<undef &foo>, or by the reference count going to zero.
292 In the former case, we keep the C<CvOUTSIDE> pointer, so that any anonymous
293 children can still follow the full lexical scope chain.
299 Perl_cv_undef(pTHX_ CV *cv)
301 PERL_ARGS_ASSERT_CV_UNDEF;
302 cv_undef_flags(cv, 0);
306 Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags)
308 CV cvbody;/*CV body will never be realloced inside this func,
309 so dont read it more than once, use fake CV so existing macros
310 will work, the indirection and CV head struct optimized away*/
311 SvANY(&cvbody) = SvANY(cv);
313 PERL_ARGS_ASSERT_CV_UNDEF_FLAGS;
315 DEBUG_X(PerlIO_printf(Perl_debug_log,
316 "CV undef: cv=0x%"UVxf" comppad=0x%"UVxf"\n",
317 PTR2UV(cv), PTR2UV(PL_comppad))
320 if (CvFILE(&cvbody)) {
321 char * file = CvFILE(&cvbody);
322 CvFILE(&cvbody) = NULL;
323 if(CvDYNFILE(&cvbody))
327 /* CvSLABBED_off(&cvbody); *//* turned off below */
328 /* release the sub's body */
329 if (!CvISXSUB(&cvbody)) {
330 if(CvROOT(&cvbody)) {
331 assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); /*unsafe is safe */
332 if (CvDEPTHunsafe(&cvbody)) {
333 assert(SvTYPE(cv) == SVt_PVCV);
334 Perl_croak_nocontext("Can't undef active subroutine");
338 PAD_SAVE_SETNULLPAD();
340 if (CvSLABBED(&cvbody)) OpslabREFCNT_dec_padok(OpSLAB(CvROOT(&cvbody)));
341 op_free(CvROOT(&cvbody));
342 CvROOT(&cvbody) = NULL;
343 CvSTART(&cvbody) = NULL;
346 else if (CvSLABBED(&cvbody)) {
347 if( CvSTART(&cvbody)) {
349 PAD_SAVE_SETNULLPAD();
351 /* discard any leaked ops */
353 parser_free_nexttoke_ops(PL_parser, (OPSLAB *)CvSTART(&cvbody));
354 opslab_force_free((OPSLAB *)CvSTART(&cvbody));
355 CvSTART(&cvbody) = NULL;
360 else Perl_warn(aTHX_ "Slab leaked from cv %p", (void*)cv);
364 else { /* dont bother checking if CvXSUB(cv) is true, less branching */
365 CvXSUB(&cvbody) = NULL;
367 SvPOK_off(MUTABLE_SV(cv)); /* forget prototype */
368 sv_unmagic((SV *)cv, PERL_MAGIC_checkcall);
369 if (!(flags & CV_UNDEF_KEEP_NAME)) {
370 if (CvNAMED(&cvbody)) {
371 CvNAME_HEK_set(&cvbody, NULL);
372 CvNAMED_off(&cvbody);
374 else CvGV_set(cv, NULL);
377 /* This statement and the subsequence if block was pad_undef(). */
378 pad_peg("pad_undef");
380 if (!CvISXSUB(&cvbody) && CvPADLIST(&cvbody)) {
382 const PADLIST *padlist = CvPADLIST(&cvbody);
384 /* Free the padlist associated with a CV.
385 If parts of it happen to be current, we null the relevant PL_*pad*
386 global vars so that we don't have any dangling references left.
387 We also repoint the CvOUTSIDE of any about-to-be-orphaned inner
388 subs to the outer of this cv. */
390 DEBUG_X(PerlIO_printf(Perl_debug_log,
391 "Pad undef: cv=0x%"UVxf" padlist=0x%"UVxf" comppad=0x%"UVxf"\n",
392 PTR2UV(cv), PTR2UV(padlist), PTR2UV(PL_comppad))
395 /* detach any '&' anon children in the pad; if afterwards they
396 * are still live, fix up their CvOUTSIDEs to point to our outside,
398 /* XXX DAPM for efficiency, we should only do this if we know we have
399 * children, or integrate this loop with general cleanup */
401 if (PL_phase != PERL_PHASE_DESTRUCT) { /* don't bother during global destruction */
402 CV * const outercv = CvOUTSIDE(&cvbody);
403 const U32 seq = CvOUTSIDE_SEQ(&cvbody);
404 PADNAMELIST * const comppad_name = PadlistNAMES(padlist);
405 PADNAME ** const namepad = PadnamelistARRAY(comppad_name);
406 PAD * const comppad = PadlistARRAY(padlist)[1];
407 SV ** const curpad = AvARRAY(comppad);
408 for (ix = PadnamelistMAX(comppad_name); ix > 0; ix--) {
409 PADNAME * const name = namepad[ix];
410 if (name && PadnamePV(name) && *PadnamePV(name) == '&')
412 CV * const innercv = MUTABLE_CV(curpad[ix]);
413 U32 inner_rc = SvREFCNT(innercv);
415 assert(SvTYPE(innercv) != SVt_PVFM);
417 if (SvREFCNT(comppad) < 2) { /* allow for /(?{ sub{} })/ */
419 SvREFCNT_dec_NN(innercv);
423 /* in use, not just a prototype */
424 if (inner_rc && SvTYPE(innercv) == SVt_PVCV
425 && (CvOUTSIDE(innercv) == cv))
427 assert(CvWEAKOUTSIDE(innercv));
428 /* don't relink to grandfather if he's being freed */
429 if (outercv && SvREFCNT(outercv)) {
430 CvWEAKOUTSIDE_off(innercv);
431 CvOUTSIDE(innercv) = outercv;
432 CvOUTSIDE_SEQ(innercv) = seq;
433 SvREFCNT_inc_simple_void_NN(outercv);
436 CvOUTSIDE(innercv) = NULL;
443 ix = PadlistMAX(padlist);
445 PAD * const sv = PadlistARRAY(padlist)[ix--];
447 if (sv == PL_comppad) {
455 PADNAMELIST * const names = PadlistNAMES(padlist);
456 if (names == PL_comppad_name && PadnamelistREFCNT(names) == 1)
457 PL_comppad_name = NULL;
458 PadnamelistREFCNT_dec(names);
460 if (PadlistARRAY(padlist)) Safefree(PadlistARRAY(padlist));
462 CvPADLIST_set(&cvbody, NULL);
464 else if (CvISXSUB(&cvbody))
465 CvHSCXT(&cvbody) = NULL;
466 /* else is (!CvISXSUB(&cvbody) && !CvPADLIST(&cvbody)) {do nothing;} */
469 /* remove CvOUTSIDE unless this is an undef rather than a free */
471 CV * outside = CvOUTSIDE(&cvbody);
473 CvOUTSIDE(&cvbody) = NULL;
474 if (!CvWEAKOUTSIDE(&cvbody))
475 SvREFCNT_dec_NN(outside);
478 if (CvCONST(&cvbody)) {
479 SvREFCNT_dec(MUTABLE_SV(CvXSUBANY(&cvbody).any_ptr));
480 /* CvCONST_off(cv); *//* turned off below */
482 /* delete all flags except WEAKOUTSIDE and CVGV_RC, which indicate the
483 * ref status of CvOUTSIDE and CvGV, and ANON, NAMED and
484 * LEXICAL, which are used to determine the sub's name. */
485 CvFLAGS(&cvbody) &= (CVf_WEAKOUTSIDE|CVf_CVGV_RC|CVf_ANON|CVf_LEXICAL
490 =for apidoc cv_forget_slab
492 When a CV has a reference count on its slab (C<CvSLABBED>), it is responsible
493 for making sure it is freed. (Hence, no two CVs should ever have a
494 reference count on the same slab.) The CV only needs to reference the slab
495 during compilation. Once it is compiled and C<CvROOT> attached, it has
496 finished its job, so it can forget the slab.
502 Perl_cv_forget_slab(pTHX_ CV *cv)
509 slabbed = cBOOL(CvSLABBED(cv));
510 if (!slabbed) return;
514 if (CvROOT(cv)) slab = OpSLAB(CvROOT(cv));
515 else if (CvSTART(cv)) slab = (OPSLAB *)CvSTART(cv);
517 else if (slabbed) Perl_warn(aTHX_ "Slab leaked from cv %p", (void*)cv);
521 #ifdef PERL_DEBUG_READONLY_OPS
522 const size_t refcnt = slab->opslab_refcnt;
524 OpslabREFCNT_dec(slab);
525 #ifdef PERL_DEBUG_READONLY_OPS
526 if (refcnt > 1) Slab_to_ro(slab);
532 =for apidoc m|PADOFFSET|pad_alloc_name|PADNAME *name|U32 flags|HV *typestash|HV *ourstash
534 Allocates a place in the currently-compiling
535 pad (via L<perlapi/pad_alloc>) and
536 then stores a name for that entry. C<name> is adopted and
537 becomes the name entry; it must already contain the name
538 string. C<typestash> and C<ourstash> and the C<padadd_STATE>
539 flag get added to C<name>. None of the other
540 processing of L<perlapi/pad_add_name_pvn>
541 is done. Returns the offset of the allocated pad slot.
547 S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash,
550 const PADOFFSET offset = pad_alloc(OP_PADSV, SVs_PADMY);
552 PERL_ARGS_ASSERT_PAD_ALLOC_NAME;
554 ASSERT_CURPAD_ACTIVE("pad_alloc_name");
557 SvPAD_TYPED_on(name);
559 MUTABLE_HV(SvREFCNT_inc_simple_NN(MUTABLE_SV(typestash)));
563 SvOURSTASH_set(name, ourstash);
564 SvREFCNT_inc_simple_void_NN(ourstash);
566 else if (flags & padadd_STATE) {
567 SvPAD_STATE_on(name);
570 padnamelist_store(PL_comppad_name, offset, name);
571 if (PadnameLEN(name) > 1)
572 PadnamelistMAXNAMED(PL_comppad_name) = offset;
577 =for apidoc Am|PADOFFSET|pad_add_name_pvn|const char *namepv|STRLEN namelen|U32 flags|HV *typestash|HV *ourstash
579 Allocates a place in the currently-compiling pad for a named lexical
580 variable. Stores the name and other metadata in the name part of the
581 pad, and makes preparations to manage the variable's lexical scoping.
582 Returns the offset of the allocated pad slot.
584 C<namepv>/C<namelen> specify the variable's name, including leading sigil.
585 If C<typestash> is non-null, the name is for a typed lexical, and this
586 identifies the type. If C<ourstash> is non-null, it's a lexical reference
587 to a package variable, and this identifies the package. The following
588 flags can be OR'ed together:
590 padadd_OUR redundantly specifies if it's a package var
591 padadd_STATE variable will retain value persistently
592 padadd_NO_DUP_CHECK skip check for lexical shadowing
598 Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen,
599 U32 flags, HV *typestash, HV *ourstash)
604 PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN;
606 if (flags & ~(padadd_OUR|padadd_STATE|padadd_NO_DUP_CHECK))
607 Perl_croak(aTHX_ "panic: pad_add_name_pvn illegal flag bits 0x%" UVxf,
610 name = newPADNAMEpvn(namepv, namelen);
612 if ((flags & padadd_NO_DUP_CHECK) == 0) {
614 SAVEFREEPADNAME(name); /* in case of fatal warnings */
615 /* check for duplicate declaration */
616 pad_check_dup(name, flags & padadd_OUR, ourstash);
617 PadnameREFCNT(name)++;
621 offset = pad_alloc_name(name, flags, typestash, ourstash);
623 /* not yet introduced */
624 COP_SEQ_RANGE_LOW_set(name, PERL_PADSEQ_INTRO);
625 COP_SEQ_RANGE_HIGH_set(name, 0);
627 if (!PL_min_intro_pending)
628 PL_min_intro_pending = offset;
629 PL_max_intro_pending = offset;
630 /* if it's not a simple scalar, replace with an AV or HV */
631 assert(SvTYPE(PL_curpad[offset]) == SVt_NULL);
632 assert(SvREFCNT(PL_curpad[offset]) == 1);
633 if (namelen != 0 && *namepv == '@')
634 sv_upgrade(PL_curpad[offset], SVt_PVAV);
635 else if (namelen != 0 && *namepv == '%')
636 sv_upgrade(PL_curpad[offset], SVt_PVHV);
637 else if (namelen != 0 && *namepv == '&')
638 sv_upgrade(PL_curpad[offset], SVt_PVCV);
639 assert(SvPADMY(PL_curpad[offset]));
640 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
641 "Pad addname: %ld \"%s\" new lex=0x%"UVxf"\n",
642 (long)offset, PadnamePV(name),
643 PTR2UV(PL_curpad[offset])));
649 =for apidoc Am|PADOFFSET|pad_add_name_pv|const char *name|U32 flags|HV *typestash|HV *ourstash
651 Exactly like L</pad_add_name_pvn>, but takes a nul-terminated string
652 instead of a string/length pair.
658 Perl_pad_add_name_pv(pTHX_ const char *name,
659 const U32 flags, HV *typestash, HV *ourstash)
661 PERL_ARGS_ASSERT_PAD_ADD_NAME_PV;
662 return pad_add_name_pvn(name, strlen(name), flags, typestash, ourstash);
666 =for apidoc Am|PADOFFSET|pad_add_name_sv|SV *name|U32 flags|HV *typestash|HV *ourstash
668 Exactly like L</pad_add_name_pvn>, but takes the name string in the form
669 of an SV instead of a string/length pair.
675 Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash)
679 PERL_ARGS_ASSERT_PAD_ADD_NAME_SV;
680 namepv = SvPVutf8(name, namelen);
681 return pad_add_name_pvn(namepv, namelen, flags, typestash, ourstash);
685 =for apidoc Amx|PADOFFSET|pad_alloc|I32 optype|U32 tmptype
687 Allocates a place in the currently-compiling pad,
688 returning the offset of the allocated pad slot.
689 No name is initially attached to the pad slot.
690 C<tmptype> is a set of flags indicating the kind of pad entry required,
691 which will be set in the value SV for the allocated pad entry:
693 SVs_PADMY named lexical variable ("my", "our", "state")
694 SVs_PADTMP unnamed temporary store
695 SVf_READONLY constant shared between recursion levels
697 C<SVf_READONLY> has been supported here only since perl 5.20. To work with
698 earlier versions as well, use C<SVf_READONLY|SVs_PADTMP>. C<SVf_READONLY>
699 does not cause the SV in the pad slot to be marked read-only, but simply
700 tells C<pad_alloc> that it I<will> be made read-only (by the caller), or at
701 least should be treated as such.
703 C<optype> should be an opcode indicating the type of operation that the
704 pad entry is to support. This doesn't affect operational semantics,
705 but is used for debugging.
710 /* XXX DAPM integrate alloc(), add_name() and add_anon(),
711 * or at least rationalise ??? */
714 Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
719 PERL_UNUSED_ARG(optype);
720 ASSERT_CURPAD_ACTIVE("pad_alloc");
722 if (AvARRAY(PL_comppad) != PL_curpad)
723 Perl_croak(aTHX_ "panic: pad_alloc, %p!=%p",
724 AvARRAY(PL_comppad), PL_curpad);
725 if (PL_pad_reset_pending)
727 if (tmptype == SVs_PADMY) { /* Not & because this ‘flag’ is 0. */
728 /* For a my, simply push a null SV onto the end of PL_comppad. */
729 sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE);
730 retval = AvFILLp(PL_comppad);
733 /* For a tmp, scan the pad from PL_padix upwards
734 * for a slot which has no name and no active value.
735 * For a constant, likewise, but use PL_constpadix.
737 PADNAME * const * const names = PadnamelistARRAY(PL_comppad_name);
738 const SSize_t names_fill = PadnamelistMAX(PL_comppad_name);
739 const bool konst = cBOOL(tmptype & SVf_READONLY);
740 retval = konst ? PL_constpadix : PL_padix;
743 * Entries that close over unavailable variables
744 * in outer subs contain values not marked PADMY.
745 * Thus we must skip, not just pad values that are
746 * marked as current pad values, but also those with names.
747 * If pad_reset is enabled, ‘current’ means different
748 * things depending on whether we are allocating a con-
749 * stant or a target. For a target, things marked PADTMP
750 * can be reused; not so for constants.
753 if (++retval <= names_fill &&
754 (pn = names[retval]) && PadnamePV(pn))
756 sv = *av_fetch(PL_comppad, retval, TRUE);
759 (konst ? SVs_PADTMP : 0))
767 padnamelist_store(PL_comppad_name, retval, &PL_padname_const);
768 tmptype &= ~SVf_READONLY;
769 tmptype |= SVs_PADTMP;
771 *(konst ? &PL_constpadix : &PL_padix) = retval;
773 SvFLAGS(sv) |= tmptype;
774 PL_curpad = AvARRAY(PL_comppad);
776 DEBUG_X(PerlIO_printf(Perl_debug_log,
777 "Pad 0x%"UVxf"[0x%"UVxf"] alloc: %ld for %s\n",
778 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long) retval,
779 PL_op_name[optype]));
780 #ifdef DEBUG_LEAKING_SCALARS
781 sv->sv_debug_optype = optype;
782 sv->sv_debug_inpad = 1;
784 return (PADOFFSET)retval;
788 =for apidoc Am|PADOFFSET|pad_add_anon|CV *func|I32 optype
790 Allocates a place in the currently-compiling pad (via L</pad_alloc>)
791 for an anonymous function that is lexically scoped inside the
792 currently-compiling function.
793 The function C<func> is linked into the pad, and its C<CvOUTSIDE> link
794 to the outer scope is weakened to avoid a reference loop.
796 One reference count is stolen, so you may need to do C<SvREFCNT_inc(func)>.
798 C<optype> should be an opcode indicating the type of operation that the
799 pad entry is to support. This doesn't affect operational semantics,
800 but is used for debugging.
806 Perl_pad_add_anon(pTHX_ CV* func, I32 optype)
809 PADNAME * const name = newPADNAMEpvn("&", 1);
811 PERL_ARGS_ASSERT_PAD_ADD_ANON;
812 assert (SvTYPE(func) == SVt_PVCV);
815 /* These two aren't used; just make sure they're not equal to
816 * PERL_PADSEQ_INTRO. They should be 0 by default. */
817 assert(COP_SEQ_RANGE_LOW (name) != PERL_PADSEQ_INTRO);
818 assert(COP_SEQ_RANGE_HIGH(name) != PERL_PADSEQ_INTRO);
819 ix = pad_alloc(optype, SVs_PADMY);
820 padnamelist_store(PL_comppad_name, ix, name);
821 /* XXX DAPM use PL_curpad[] ? */
822 av_store(PL_comppad, ix, (SV*)func);
824 /* to avoid ref loops, we never have parent + child referencing each
825 * other simultaneously */
826 if (CvOUTSIDE(func)) {
827 assert(!CvWEAKOUTSIDE(func));
828 CvWEAKOUTSIDE_on(func);
829 SvREFCNT_dec_NN(CvOUTSIDE(func));
835 Perl_pad_add_weakref(pTHX_ CV* func)
837 const PADOFFSET ix = pad_alloc(OP_NULL, SVs_PADMY);
838 PADNAME * const name = newPADNAMEpvn("&", 1);
839 SV * const rv = newRV_inc((SV *)func);
841 PERL_ARGS_ASSERT_PAD_ADD_WEAKREF;
843 /* These two aren't used; just make sure they're not equal to
844 * PERL_PADSEQ_INTRO. They should be 0 by default. */
845 assert(COP_SEQ_RANGE_LOW (name) != PERL_PADSEQ_INTRO);
846 assert(COP_SEQ_RANGE_HIGH(name) != PERL_PADSEQ_INTRO);
847 padnamelist_store(PL_comppad_name, ix, name);
849 av_store(PL_comppad, ix, rv);
853 =for apidoc pad_check_dup
855 Check for duplicate declarations: report any of:
857 * a 'my' in the current scope with the same name;
858 * an 'our' (anywhere in the pad) with the same name and the
859 same stash as 'ourstash'
861 C<is_our> indicates that the name to check is an C<"our"> declaration.
867 S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash)
871 const U32 is_our = flags & padadd_OUR;
873 PERL_ARGS_ASSERT_PAD_CHECK_DUP;
875 ASSERT_CURPAD_ACTIVE("pad_check_dup");
877 assert((flags & ~padadd_OUR) == 0);
879 if (PadnamelistMAX(PL_comppad_name) < 0 || !ckWARN(WARN_MISC))
880 return; /* nothing to check */
882 svp = PadnamelistARRAY(PL_comppad_name);
883 top = PadnamelistMAX(PL_comppad_name);
884 /* check the current scope */
885 /* XXX DAPM - why the (I32) cast - shouldn't we ensure they're the same
887 for (off = top; (I32)off > PL_comppad_name_floor; off--) {
888 PADNAME * const sv = svp[off];
890 && PadnameLEN(sv) == PadnameLEN(name)
892 && ( COP_SEQ_RANGE_LOW(sv) == PERL_PADSEQ_INTRO
893 || COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO)
894 && memEQ(PadnamePV(sv), PadnamePV(name), PadnameLEN(name)))
896 if (is_our && (SvPAD_OUR(sv)))
897 break; /* "our" masking "our" */
898 /* diag_listed_as: "%s" variable %s masks earlier declaration in same %s */
899 Perl_warner(aTHX_ packWARN(WARN_MISC),
900 "\"%s\" %s %"PNf" masks earlier declaration in same %s",
901 (is_our ? "our" : PL_parser->in_my == KEY_my ? "my" : "state"),
902 *PadnamePV(sv) == '&' ? "subroutine" : "variable",
904 (COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO
905 ? "scope" : "statement"));
910 /* check the rest of the pad */
913 PADNAME * const sv = svp[off];
915 && PadnameLEN(sv) == PadnameLEN(name)
917 && ( COP_SEQ_RANGE_LOW(sv) == PERL_PADSEQ_INTRO
918 || COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO)
919 && SvOURSTASH(sv) == ourstash
920 && memEQ(PadnamePV(sv), PadnamePV(name), PadnameLEN(name)))
922 Perl_warner(aTHX_ packWARN(WARN_MISC),
923 "\"our\" variable %"PNf" redeclared", PNfARG(sv));
924 if ((I32)off <= PL_comppad_name_floor)
925 Perl_warner(aTHX_ packWARN(WARN_MISC),
926 "\t(Did you mean \"local\" instead of \"our\"?)\n");
936 =for apidoc Am|PADOFFSET|pad_findmy_pvn|const char *namepv|STRLEN namelen|U32 flags
938 Given the name of a lexical variable, find its position in the
939 currently-compiling pad.
940 C<namepv>/C<namelen> specify the variable's name, including leading sigil.
941 C<flags> is reserved and must be zero.
942 If it is not in the current pad but appears in the pad of any lexically
943 enclosing scope, then a pseudo-entry for it is added in the current pad.
944 Returns the offset in the current pad,
945 or C<NOT_IN_PAD> if no such lexical is in scope.
951 Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags)
956 const PADNAMELIST *namelist;
959 PERL_ARGS_ASSERT_PAD_FINDMY_PVN;
961 pad_peg("pad_findmy_pvn");
964 Perl_croak(aTHX_ "panic: pad_findmy_pvn illegal flag bits 0x%" UVxf,
967 /* compilation errors can zero PL_compcv */
971 offset = pad_findlex(namepv, namelen, flags,
972 PL_compcv, PL_cop_seqmax, 1, NULL, &out_pn, &out_flags);
973 if ((PADOFFSET)offset != NOT_IN_PAD)
976 /* Skip the ‘our’ hack for subroutines, as the warning does not apply.
978 if (*namepv == '&') return NOT_IN_PAD;
980 /* look for an our that's being introduced; this allows
981 * our $foo = 0 unless defined $foo;
982 * to not give a warning. (Yes, this is a hack) */
984 namelist = PadlistNAMES(CvPADLIST(PL_compcv));
985 name_p = PadnamelistARRAY(namelist);
986 for (offset = PadnamelistMAXNAMED(namelist); offset > 0; offset--) {
987 const PADNAME * const name = name_p[offset];
988 if (name && PadnameLEN(name) == namelen
989 && !PadnameOUTER(name)
990 && (PadnameIsOUR(name))
991 && ( PadnamePV(name) == namepv
992 || memEQ(PadnamePV(name), namepv, namelen) )
993 && COP_SEQ_RANGE_LOW(name) == PERL_PADSEQ_INTRO
1001 =for apidoc Am|PADOFFSET|pad_findmy_pv|const char *name|U32 flags
1003 Exactly like L</pad_findmy_pvn>, but takes a nul-terminated string
1004 instead of a string/length pair.
1010 Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags)
1012 PERL_ARGS_ASSERT_PAD_FINDMY_PV;
1013 return pad_findmy_pvn(name, strlen(name), flags);
1017 =for apidoc Am|PADOFFSET|pad_findmy_sv|SV *name|U32 flags
1019 Exactly like L</pad_findmy_pvn>, but takes the name string in the form
1020 of an SV instead of a string/length pair.
1026 Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags)
1030 PERL_ARGS_ASSERT_PAD_FINDMY_SV;
1031 namepv = SvPVutf8(name, namelen);
1032 return pad_findmy_pvn(namepv, namelen, flags);
1036 =for apidoc Amp|PADOFFSET|find_rundefsvoffset
1038 Find the position of the lexical C<$_> in the pad of the
1039 currently-executing function. Returns the offset in the current pad,
1040 or C<NOT_IN_PAD> if there is no lexical C<$_> in scope (in which case
1041 the global one should be used instead).
1042 L</find_rundefsv> is likely to be more convenient.
1048 Perl_find_rundefsvoffset(pTHX)
1052 return pad_findlex("$_", 2, 0, find_runcv(NULL), PL_curcop->cop_seq, 1,
1053 NULL, &out_pn, &out_flags);
1057 =for apidoc Am|SV *|find_rundefsv
1059 Find and return the variable that is named C<$_> in the lexical scope
1060 of the currently-executing function. This may be a lexical C<$_>,
1061 or will otherwise be the global one.
1067 Perl_find_rundefsv(pTHX)
1073 po = pad_findlex("$_", 2, 0, find_runcv(NULL), PL_curcop->cop_seq, 1,
1074 NULL, &name, &flags);
1076 if (po == NOT_IN_PAD || PadnameIsOUR(name))
1083 Perl_find_rundefsv2(pTHX_ CV *cv, U32 seq)
1089 PERL_ARGS_ASSERT_FIND_RUNDEFSV2;
1091 po = pad_findlex("$_", 2, 0, cv, seq, 1,
1092 NULL, &name, &flags);
1094 if (po == NOT_IN_PAD || PadnameIsOUR(name))
1097 return AvARRAY(PadlistARRAY(CvPADLIST(cv))[CvDEPTH(cv)])[po];
1101 =for apidoc m|PADOFFSET|pad_findlex|const char *namepv|STRLEN namelen|U32 flags|const CV* cv|U32 seq|int warn|SV** out_capture|PADNAME** out_name|int *out_flags
1103 Find a named lexical anywhere in a chain of nested pads. Add fake entries
1104 in the inner pads if it's found in an outer one.
1106 Returns the offset in the bottom pad of the lex or the fake lex.
1107 C<cv> is the CV in which to start the search, and seq is the current C<cop_seq>
1108 to match against. If C<warn> is true, print appropriate warnings. The C<out_>*
1109 vars return values, and so are pointers to where the returned values
1110 should be stored. C<out_capture>, if non-null, requests that the innermost
1111 instance of the lexical is captured; C<out_name> is set to the innermost
1112 matched pad name or fake pad name; C<out_flags> returns the flags normally
1113 associated with the C<PARENT_FAKELEX_FLAGS> field of a fake pad name.
1115 Note that C<pad_findlex()> is recursive; it recurses up the chain of CVs,
1116 then comes back down, adding fake entries
1117 as it goes. It has to be this way
1118 because fake names in anon protoypes have to store in C<xlow> the index into
1124 /* the CV has finished being compiled. This is not a sufficient test for
1125 * all CVs (eg XSUBs), but suffices for the CVs found in a lexical chain */
1126 #define CvCOMPILED(cv) CvROOT(cv)
1128 /* the CV does late binding of its lexicals */
1129 #define CvLATE(cv) (CvANON(cv) || CvCLONE(cv) || SvTYPE(cv) == SVt_PVFM)
1132 S_unavailable(pTHX_ PADNAME *name)
1134 /* diag_listed_as: Variable "%s" is not available */
1135 Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE),
1136 "%se \"%"PNf"\" is not available",
1137 *PadnamePV(name) == '&'
1144 S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq,
1145 int warn, SV** out_capture, PADNAME** out_name, int *out_flags)
1147 I32 offset, new_offset;
1150 const PADLIST * const padlist = CvPADLIST(cv);
1151 const bool staleok = !!(flags & padadd_STALEOK);
1153 PERL_ARGS_ASSERT_PAD_FINDLEX;
1155 flags &= ~ padadd_STALEOK; /* one-shot flag */
1157 Perl_croak(aTHX_ "panic: pad_findlex illegal flag bits 0x%" UVxf,
1162 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1163 "Pad findlex cv=0x%"UVxf" searching \"%.*s\" seq=%d%s\n",
1164 PTR2UV(cv), (int)namelen, namepv, (int)seq,
1165 out_capture ? " capturing" : "" ));
1167 /* first, search this pad */
1169 if (padlist) { /* not an undef CV */
1170 I32 fake_offset = 0;
1171 const PADNAMELIST * const names = PadlistNAMES(padlist);
1172 PADNAME * const * const name_p = PadnamelistARRAY(names);
1174 for (offset = PadnamelistMAXNAMED(names); offset > 0; offset--) {
1175 const PADNAME * const name = name_p[offset];
1176 if (name && PadnameLEN(name) == namelen
1177 && ( PadnamePV(name) == namepv
1178 || memEQ(PadnamePV(name), namepv, namelen) ))
1180 if (PadnameOUTER(name)) {
1181 fake_offset = offset; /* in case we don't find a real one */
1184 if (PadnameIN_SCOPE(name, seq))
1189 if (offset > 0 || fake_offset > 0 ) { /* a match! */
1190 if (offset > 0) { /* not fake */
1192 *out_name = name_p[offset]; /* return the name */
1194 /* set PAD_FAKELEX_MULTI if this lex can have multiple
1195 * instances. For now, we just test !CvUNIQUE(cv), but
1196 * ideally, we should detect my's declared within loops
1197 * etc - this would allow a wider range of 'not stayed
1198 * shared' warnings. We also treated already-compiled
1199 * lexes as not multi as viewed from evals. */
1201 *out_flags = CvANON(cv) ?
1203 (!CvUNIQUE(cv) && ! CvCOMPILED(cv))
1204 ? PAD_FAKELEX_MULTI : 0;
1206 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1207 "Pad findlex cv=0x%"UVxf" matched: offset=%ld (%lu,%lu)\n",
1208 PTR2UV(cv), (long)offset,
1209 (unsigned long)COP_SEQ_RANGE_LOW(*out_name),
1210 (unsigned long)COP_SEQ_RANGE_HIGH(*out_name)));
1212 else { /* fake match */
1213 offset = fake_offset;
1214 *out_name = name_p[offset]; /* return the name */
1215 *out_flags = PARENT_FAKELEX_FLAGS(*out_name);
1216 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1217 "Pad findlex cv=0x%"UVxf" matched: offset=%ld flags=0x%lx index=%lu\n",
1218 PTR2UV(cv), (long)offset, (unsigned long)*out_flags,
1219 (unsigned long) PARENT_PAD_INDEX(*out_name)
1223 /* return the lex? */
1228 if (PadnameIsOUR(*out_name)) {
1229 *out_capture = NULL;
1233 /* trying to capture from an anon prototype? */
1235 ? CvANON(cv) && CvCLONE(cv) && !CvCLONED(cv)
1236 : *out_flags & PAD_FAKELEX_ANON)
1242 *out_capture = NULL;
1248 if (!CvCOMPILED(cv) && (*out_flags & PAD_FAKELEX_MULTI)
1249 && !PadnameIsSTATE(name_p[offset])
1250 && warn && ckWARN(WARN_CLOSURE)) {
1252 /* diag_listed_as: Variable "%s" will not stay
1254 Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
1255 "%se \"%"UTF8f"\" will not stay shared",
1256 *namepv == '&' ? "Subroutin" : "Variabl",
1257 UTF8fARG(1, namelen, namepv));
1260 if (fake_offset && CvANON(cv)
1261 && CvCLONE(cv) &&!CvCLONED(cv))
1264 /* not yet caught - look further up */
1265 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1266 "Pad findlex cv=0x%"UVxf" chasing lex in outer pad\n",
1269 (void) pad_findlex(namepv, namelen, flags, CvOUTSIDE(cv),
1271 newwarn, out_capture, out_name, out_flags);
1276 *out_capture = AvARRAY(PadlistARRAY(padlist)[
1277 CvDEPTH(cv) ? CvDEPTH(cv) : 1])[offset];
1278 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1279 "Pad findlex cv=0x%"UVxf" found lex=0x%"UVxf"\n",
1280 PTR2UV(cv), PTR2UV(*out_capture)));
1282 if (SvPADSTALE(*out_capture)
1283 && (!CvDEPTH(cv) || !staleok)
1284 && !PadnameIsSTATE(name_p[offset]))
1288 *out_capture = NULL;
1291 if (!*out_capture) {
1292 if (namelen != 0 && *namepv == '@')
1293 *out_capture = sv_2mortal(MUTABLE_SV(newAV()));
1294 else if (namelen != 0 && *namepv == '%')
1295 *out_capture = sv_2mortal(MUTABLE_SV(newHV()));
1296 else if (namelen != 0 && *namepv == '&')
1297 *out_capture = sv_2mortal(newSV_type(SVt_PVCV));
1299 *out_capture = sv_newmortal();
1307 /* it's not in this pad - try above */
1312 /* out_capture non-null means caller wants us to capture lex; in
1313 * addition we capture ourselves unless it's an ANON/format */
1314 new_capturep = out_capture ? out_capture :
1315 CvLATE(cv) ? NULL : &new_capture;
1317 offset = pad_findlex(namepv, namelen,
1318 flags | padadd_STALEOK*(new_capturep == &new_capture),
1319 CvOUTSIDE(cv), CvOUTSIDE_SEQ(cv), 1,
1320 new_capturep, out_name, out_flags);
1321 if ((PADOFFSET)offset == NOT_IN_PAD)
1324 /* found in an outer CV. Add appropriate fake entry to this pad */
1326 /* don't add new fake entries (via eval) to CVs that we have already
1327 * finished compiling, or to undef CVs */
1328 if (CvCOMPILED(cv) || !padlist)
1329 return 0; /* this dummy (and invalid) value isnt used by the caller */
1332 PADNAME *new_name = newPADNAMEouter(*out_name);
1333 PADNAMELIST * const ocomppad_name = PL_comppad_name;
1334 PAD * const ocomppad = PL_comppad;
1335 PL_comppad_name = PadlistNAMES(padlist);
1336 PL_comppad = PadlistARRAY(padlist)[1];
1337 PL_curpad = AvARRAY(PL_comppad);
1340 = pad_alloc_name(new_name,
1341 PadnameIsSTATE(*out_name) ? padadd_STATE : 0,
1342 PadnameTYPE(*out_name),
1343 PadnameOURSTASH(*out_name)
1346 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1347 "Pad addname: %ld \"%.*s\" FAKE\n",
1349 (int) PadnameLEN(new_name),
1350 PadnamePV(new_name)));
1351 PARENT_FAKELEX_FLAGS_set(new_name, *out_flags);
1353 PARENT_PAD_INDEX_set(new_name, 0);
1354 if (PadnameIsOUR(new_name)) {
1355 NOOP; /* do nothing */
1357 else if (CvLATE(cv)) {
1358 /* delayed creation - just note the offset within parent pad */
1359 PARENT_PAD_INDEX_set(new_name, offset);
1363 /* immediate creation - capture outer value right now */
1364 av_store(PL_comppad, new_offset, SvREFCNT_inc(*new_capturep));
1365 /* But also note the offset, as newMYSUB needs it */
1366 PARENT_PAD_INDEX_set(new_name, offset);
1367 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1368 "Pad findlex cv=0x%"UVxf" saved captured sv 0x%"UVxf" at offset %ld\n",
1369 PTR2UV(cv), PTR2UV(*new_capturep), (long)new_offset));
1371 *out_name = new_name;
1372 *out_flags = PARENT_FAKELEX_FLAGS(new_name);
1374 PL_comppad_name = ocomppad_name;
1375 PL_comppad = ocomppad;
1376 PL_curpad = ocomppad ? AvARRAY(ocomppad) : NULL;
1384 =for apidoc Am|SV *|pad_sv|PADOFFSET po
1386 Get the value at offset C<po> in the current (compiling or executing) pad.
1387 Use macro C<PAD_SV> instead of calling this function directly.
1393 Perl_pad_sv(pTHX_ PADOFFSET po)
1395 ASSERT_CURPAD_ACTIVE("pad_sv");
1398 Perl_croak(aTHX_ "panic: pad_sv po");
1399 DEBUG_X(PerlIO_printf(Perl_debug_log,
1400 "Pad 0x%"UVxf"[0x%"UVxf"] sv: %ld sv=0x%"UVxf"\n",
1401 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po, PTR2UV(PL_curpad[po]))
1403 return PL_curpad[po];
1407 =for apidoc Am|void|pad_setsv|PADOFFSET po|SV *sv
1409 Set the value at offset C<po> in the current (compiling or executing) pad.
1410 Use the macro C<PAD_SETSV()> rather than calling this function directly.
1416 Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv)
1418 PERL_ARGS_ASSERT_PAD_SETSV;
1420 ASSERT_CURPAD_ACTIVE("pad_setsv");
1422 DEBUG_X(PerlIO_printf(Perl_debug_log,
1423 "Pad 0x%"UVxf"[0x%"UVxf"] setsv: %ld sv=0x%"UVxf"\n",
1424 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po, PTR2UV(sv))
1429 #endif /* DEBUGGING */
1432 =for apidoc m|void|pad_block_start|int full
1434 Update the pad compilation state variables on entry to a new block.
1439 /* XXX DAPM perhaps:
1440 * - integrate this in general state-saving routine ???
1441 * - combine with the state-saving going on in pad_new ???
1442 * - introduce a new SAVE type that does all this in one go ?
1446 Perl_pad_block_start(pTHX_ int full)
1448 ASSERT_CURPAD_ACTIVE("pad_block_start");
1449 SAVEI32(PL_comppad_name_floor);
1450 PL_comppad_name_floor = PadnamelistMAX(PL_comppad_name);
1452 PL_comppad_name_fill = PL_comppad_name_floor;
1453 if (PL_comppad_name_floor < 0)
1454 PL_comppad_name_floor = 0;
1455 SAVEI32(PL_min_intro_pending);
1456 SAVEI32(PL_max_intro_pending);
1457 PL_min_intro_pending = 0;
1458 SAVEI32(PL_comppad_name_fill);
1459 SAVEI32(PL_padix_floor);
1460 /* PL_padix_floor is what PL_padix is reset to at the start of each
1461 statement, by pad_reset(). We set it when entering a new scope
1462 to keep things like this working:
1463 print "$foo$bar", do { this(); that() . "foo" };
1464 We must not let "$foo$bar" and the later concatenation share the
1466 PL_padix_floor = PL_padix;
1467 PL_pad_reset_pending = FALSE;
1471 =for apidoc Am|U32|intro_my
1473 "Introduce" C<my> variables to visible status. This is called during parsing
1474 at the end of each statement to make lexical variables visible to subsequent
1487 ASSERT_CURPAD_ACTIVE("intro_my");
1488 if (PL_compiling.cop_seq) {
1489 seq = PL_compiling.cop_seq;
1490 PL_compiling.cop_seq = 0;
1493 seq = PL_cop_seqmax;
1494 if (! PL_min_intro_pending)
1497 svp = PadnamelistARRAY(PL_comppad_name);
1498 for (i = PL_min_intro_pending; i <= PL_max_intro_pending; i++) {
1499 PADNAME * const sv = svp[i];
1501 if (sv && PadnameLEN(sv) && !PadnameOUTER(sv)
1502 && COP_SEQ_RANGE_LOW(sv) == PERL_PADSEQ_INTRO)
1504 COP_SEQ_RANGE_HIGH_set(sv, PERL_PADSEQ_INTRO); /* Don't know scope end yet. */
1505 COP_SEQ_RANGE_LOW_set(sv, PL_cop_seqmax);
1506 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1507 "Pad intromy: %ld \"%s\", (%lu,%lu)\n",
1508 (long)i, PadnamePV(sv),
1509 (unsigned long)COP_SEQ_RANGE_LOW(sv),
1510 (unsigned long)COP_SEQ_RANGE_HIGH(sv))
1515 PL_min_intro_pending = 0;
1516 PL_comppad_name_fill = PL_max_intro_pending; /* Needn't search higher */
1517 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1518 "Pad intromy: seq -> %ld\n", (long)(PL_cop_seqmax)));
1524 =for apidoc m|void|pad_leavemy
1526 Cleanup at end of scope during compilation: set the max seq number for
1527 lexicals in this scope and warn of any lexicals that never got introduced.
1533 Perl_pad_leavemy(pTHX)
1537 PADNAME * const * const svp = PadnamelistARRAY(PL_comppad_name);
1539 PL_pad_reset_pending = FALSE;
1541 ASSERT_CURPAD_ACTIVE("pad_leavemy");
1542 if (PL_min_intro_pending && PL_comppad_name_fill < PL_min_intro_pending) {
1543 for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) {
1544 const PADNAME * const name = svp[off];
1545 if (name && PadnameLEN(name) && !PadnameOUTER(name))
1546 Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL),
1547 "%"PNf" never introduced",
1551 /* "Deintroduce" my variables that are leaving with this scope. */
1552 for (off = PadnamelistMAX(PL_comppad_name);
1553 off > PL_comppad_name_fill; off--) {
1554 PADNAME * const sv = svp[off];
1555 if (sv && PadnameLEN(sv) && !PadnameOUTER(sv)
1556 && COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO)
1558 COP_SEQ_RANGE_HIGH_set(sv, PL_cop_seqmax);
1559 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1560 "Pad leavemy: %ld \"%s\", (%lu,%lu)\n",
1561 (long)off, PadnamePV(sv),
1562 (unsigned long)COP_SEQ_RANGE_LOW(sv),
1563 (unsigned long)COP_SEQ_RANGE_HIGH(sv))
1565 if (!PadnameIsSTATE(sv) && !PadnameIsOUR(sv)
1566 && *PadnamePV(sv) == '&' && PadnameLEN(sv) > 1) {
1567 OP *kid = newOP(OP_INTROCV, 0);
1569 o = op_prepend_elem(OP_LINESEQ, kid, o);
1574 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1575 "Pad leavemy: seq = %ld\n", (long)PL_cop_seqmax));
1580 =for apidoc m|void|pad_swipe|PADOFFSET po|bool refadjust
1582 Abandon the tmp in the current pad at offset C<po> and replace with a
1589 Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust)
1591 ASSERT_CURPAD_LEGAL("pad_swipe");
1594 if (AvARRAY(PL_comppad) != PL_curpad)
1595 Perl_croak(aTHX_ "panic: pad_swipe curpad, %p!=%p",
1596 AvARRAY(PL_comppad), PL_curpad);
1597 if (!po || ((SSize_t)po) > AvFILLp(PL_comppad))
1598 Perl_croak(aTHX_ "panic: pad_swipe po=%ld, fill=%ld",
1599 (long)po, (long)AvFILLp(PL_comppad));
1601 DEBUG_X(PerlIO_printf(Perl_debug_log,
1602 "Pad 0x%"UVxf"[0x%"UVxf"] swipe: %ld\n",
1603 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po));
1606 SvREFCNT_dec(PL_curpad[po]);
1609 /* if pad tmps aren't shared between ops, then there's no need to
1610 * create a new tmp when an existing op is freed */
1611 #ifdef USE_PAD_RESET
1612 PL_curpad[po] = newSV(0);
1613 SvPADTMP_on(PL_curpad[po]);
1615 PL_curpad[po] = NULL;
1617 if (PadnamelistMAX(PL_comppad_name) != -1
1618 && (PADOFFSET)PadnamelistMAX(PL_comppad_name) >= po) {
1619 if (PadnamelistARRAY(PL_comppad_name)[po]) {
1620 assert(!PadnameLEN(PadnamelistARRAY(PL_comppad_name)[po]));
1622 PadnamelistARRAY(PL_comppad_name)[po] = &PL_padname_undef;
1624 /* Use PL_constpadix here, not PL_padix. The latter may have been
1625 reset by pad_reset. We don’t want pad_alloc to have to scan the
1626 whole pad when allocating a constant. */
1627 if ((I32)po < PL_constpadix)
1628 PL_constpadix = po - 1;
1632 =for apidoc m|void|pad_reset
1634 Mark all the current temporaries for reuse
1639 /* pad_reset() causes pad temp TARGs (operator targets) to be shared
1640 * between OPs from different statements. During compilation, at the start
1641 * of each statement pad_reset resets PL_padix back to its previous value.
1642 * When allocating a target, pad_alloc begins its scan through the pad at
1647 #ifdef USE_PAD_RESET
1648 if (AvARRAY(PL_comppad) != PL_curpad)
1649 Perl_croak(aTHX_ "panic: pad_reset curpad, %p!=%p",
1650 AvARRAY(PL_comppad), PL_curpad);
1652 DEBUG_X(PerlIO_printf(Perl_debug_log,
1653 "Pad 0x%"UVxf"[0x%"UVxf"] reset: padix %ld -> %ld",
1654 PTR2UV(PL_comppad), PTR2UV(PL_curpad),
1655 (long)PL_padix, (long)PL_padix_floor
1659 if (!TAINTING_get) { /* Can't mix tainted and non-tainted temporaries. */
1660 PL_padix = PL_padix_floor;
1663 PL_pad_reset_pending = FALSE;
1667 =for apidoc Amx|void|pad_tidy|padtidy_type type
1669 Tidy up a pad at the end of compilation of the code to which it belongs.
1670 Jobs performed here are: remove most stuff from the pads of anonsub
1671 prototypes; give it a C<@_>; mark temporaries as such. C<type> indicates
1672 the kind of subroutine:
1674 padtidy_SUB ordinary subroutine
1675 padtidy_SUBCLONE prototype for lexical closure
1676 padtidy_FORMAT format
1681 /* XXX DAPM surely most of this stuff should be done properly
1682 * at the right time beforehand, rather than going around afterwards
1683 * cleaning up our mistakes ???
1687 Perl_pad_tidy(pTHX_ padtidy_type type)
1691 ASSERT_CURPAD_ACTIVE("pad_tidy");
1693 /* If this CV has had any 'eval-capable' ops planted in it:
1694 * i.e. it contains any of:
1698 * * use re 'eval'; /$var/
1701 * Then any anon prototypes in the chain of CVs should be marked as
1702 * cloneable, so that for example the eval's CV in
1706 * gets the right CvOUTSIDE. If running with -d, *any* sub may
1707 * potentially have an eval executed within it.
1710 if (PL_cv_has_eval || PL_perldb) {
1712 for (cv = PL_compcv ;cv; cv = CvOUTSIDE(cv)) {
1713 if (cv != PL_compcv && CvCOMPILED(cv))
1714 break; /* no need to mark already-compiled code */
1716 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1717 "Pad clone on cv=0x%"UVxf"\n", PTR2UV(cv)));
1724 /* extend namepad to match curpad */
1725 if (PadnamelistMAX(PL_comppad_name) < AvFILLp(PL_comppad))
1726 padnamelist_store(PL_comppad_name, AvFILLp(PL_comppad), NULL);
1728 if (type == padtidy_SUBCLONE) {
1729 PADNAME ** const namep = PadnamelistARRAY(PL_comppad_name);
1732 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1734 if (!namep[ix]) namep[ix] = &PL_padname_undef;
1737 * The only things that a clonable function needs in its
1738 * pad are anonymous subs, constants and GVs.
1739 * The rest are created anew during cloning.
1741 if (!PL_curpad[ix] || SvIMMORTAL(PL_curpad[ix]))
1744 if (!(PadnamePV(namesv) &&
1745 (!PadnameLEN(namesv) || *PadnamePV(namesv) == '&')))
1747 SvREFCNT_dec(PL_curpad[ix]);
1748 PL_curpad[ix] = NULL;
1752 else if (type == padtidy_SUB) {
1753 /* XXX DAPM this same bit of code keeps appearing !!! Rationalise? */
1754 AV * const av = newAV(); /* Will be @_ */
1755 av_store(PL_comppad, 0, MUTABLE_SV(av));
1759 if (type == padtidy_SUB || type == padtidy_FORMAT) {
1760 PADNAME ** const namep = PadnamelistARRAY(PL_comppad_name);
1762 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1763 if (!namep[ix]) namep[ix] = &PL_padname_undef;
1764 if (!PL_curpad[ix] || SvIMMORTAL(PL_curpad[ix]))
1766 if (SvPADMY(PL_curpad[ix]) && !PadnameOUTER(namep[ix])) {
1767 /* This is a work around for how the current implementation of
1768 ?{ } blocks in regexps interacts with lexicals.
1770 One of our lexicals.
1771 Can't do this on all lexicals, otherwise sub baz() won't
1780 because completion of compiling &bar calling pad_tidy()
1781 would cause (top level) $foo to be marked as stale, and
1782 "no longer available". */
1783 SvPADSTALE_on(PL_curpad[ix]);
1787 PL_curpad = AvARRAY(PL_comppad);
1791 =for apidoc m|void|pad_free|PADOFFSET po
1793 Free the SV at offset po in the current pad.
1798 /* XXX DAPM integrate with pad_swipe ???? */
1800 Perl_pad_free(pTHX_ PADOFFSET po)
1802 #ifndef USE_PAD_RESET
1805 ASSERT_CURPAD_LEGAL("pad_free");
1808 if (AvARRAY(PL_comppad) != PL_curpad)
1809 Perl_croak(aTHX_ "panic: pad_free curpad, %p!=%p",
1810 AvARRAY(PL_comppad), PL_curpad);
1812 Perl_croak(aTHX_ "panic: pad_free po");
1814 DEBUG_X(PerlIO_printf(Perl_debug_log,
1815 "Pad 0x%"UVxf"[0x%"UVxf"] free: %ld\n",
1816 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po)
1819 #ifndef USE_PAD_RESET
1821 if (sv && sv != &PL_sv_undef && !SvPADMY(sv))
1822 SvFLAGS(sv) &= ~SVs_PADTMP;
1824 if ((I32)po < PL_padix)
1830 =for apidoc m|void|do_dump_pad|I32 level|PerlIO *file|PADLIST *padlist|int full
1832 Dump the contents of a padlist
1838 Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full)
1840 const PADNAMELIST *pad_name;
1846 PERL_ARGS_ASSERT_DO_DUMP_PAD;
1851 pad_name = PadlistNAMES(padlist);
1852 pad = PadlistARRAY(padlist)[1];
1853 pname = PadnamelistARRAY(pad_name);
1854 ppad = AvARRAY(pad);
1855 Perl_dump_indent(aTHX_ level, file,
1856 "PADNAME = 0x%"UVxf"(0x%"UVxf") PAD = 0x%"UVxf"(0x%"UVxf")\n",
1857 PTR2UV(pad_name), PTR2UV(pname), PTR2UV(pad), PTR2UV(ppad)
1860 for (ix = 1; ix <= PadnamelistMAX(pad_name); ix++) {
1861 const PADNAME *namesv = pname[ix];
1862 if (namesv && !PadnameLEN(namesv)) {
1866 if (PadnameOUTER(namesv))
1867 Perl_dump_indent(aTHX_ level+1, file,
1868 "%2d. 0x%"UVxf"<%lu> FAKE \"%s\" flags=0x%lx index=%lu\n",
1871 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0),
1873 (unsigned long)PARENT_FAKELEX_FLAGS(namesv),
1874 (unsigned long)PARENT_PAD_INDEX(namesv)
1878 Perl_dump_indent(aTHX_ level+1, file,
1879 "%2d. 0x%"UVxf"<%lu> (%lu,%lu) \"%s\"\n",
1882 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0),
1883 (unsigned long)COP_SEQ_RANGE_LOW(namesv),
1884 (unsigned long)COP_SEQ_RANGE_HIGH(namesv),
1889 Perl_dump_indent(aTHX_ level+1, file,
1890 "%2d. 0x%"UVxf"<%lu>\n",
1893 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0)
1902 =for apidoc m|void|cv_dump|CV *cv|const char *title
1904 dump the contents of a CV
1910 S_cv_dump(pTHX_ const CV *cv, const char *title)
1912 const CV * const outside = CvOUTSIDE(cv);
1913 PADLIST* const padlist = CvPADLIST(cv);
1915 PERL_ARGS_ASSERT_CV_DUMP;
1917 PerlIO_printf(Perl_debug_log,
1918 " %s: CV=0x%"UVxf" (%s), OUTSIDE=0x%"UVxf" (%s)\n",
1921 (CvANON(cv) ? "ANON"
1922 : (SvTYPE(cv) == SVt_PVFM) ? "FORMAT"
1923 : (cv == PL_main_cv) ? "MAIN"
1924 : CvUNIQUE(cv) ? "UNIQUE"
1925 : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"),
1928 : CvANON(outside) ? "ANON"
1929 : (outside == PL_main_cv) ? "MAIN"
1930 : CvUNIQUE(outside) ? "UNIQUE"
1931 : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
1933 PerlIO_printf(Perl_debug_log,
1934 " PADLIST = 0x%"UVxf"\n", PTR2UV(padlist));
1935 do_dump_pad(1, Perl_debug_log, padlist, 1);
1938 #endif /* DEBUGGING */
1941 =for apidoc Am|CV *|cv_clone|CV *proto
1943 Clone a CV, making a lexical closure. C<proto> supplies the prototype
1944 of the function: its code, pad structure, and other attributes.
1945 The prototype is combined with a capture of outer lexicals to which the
1946 code refers, which are taken from the currently-executing instance of
1947 the immediately surrounding code.
1952 static CV *S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned);
1955 S_cv_clone_pad(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned,
1959 PADLIST* const protopadlist = CvPADLIST(proto);
1960 PADNAMELIST *const protopad_name = PadlistNAMES(protopadlist);
1961 const PAD *const protopad = PadlistARRAY(protopadlist)[1];
1962 PADNAME** const pname = PadnamelistARRAY(protopad_name);
1963 SV** const ppad = AvARRAY(protopad);
1964 const I32 fname = PadnamelistMAX(protopad_name);
1965 const I32 fpad = AvFILLp(protopad);
1969 bool trouble = FALSE;
1971 assert(!CvUNIQUE(proto));
1973 /* Anonymous subs have a weak CvOUTSIDE pointer, so its value is not
1974 * reliable. The currently-running sub is always the one we need to
1976 * For my subs, the currently-running sub may not be the one we want.
1977 * We have to check whether it is a clone of CvOUTSIDE.
1978 * Note that in general for formats, CvOUTSIDE != find_runcv.
1979 * Since formats may be nested inside closures, CvOUTSIDE may point
1980 * to a prototype; we instead want the cloned parent who called us.
1984 if (CvWEAKOUTSIDE(proto))
1985 outside = find_runcv(NULL);
1987 outside = CvOUTSIDE(proto);
1988 if ((CvCLONE(outside) && ! CvCLONED(outside))
1989 || !CvPADLIST(outside)
1990 || CvPADLIST(outside)->xpadl_id != protopadlist->xpadl_outid) {
1991 outside = find_runcv_where(
1992 FIND_RUNCV_padid_eq, PTR2IV(protopadlist->xpadl_outid), NULL
1994 /* outside could be null */
1998 depth = outside ? CvDEPTH(outside) : 0;
2003 SAVESPTR(PL_compcv);
2005 if (newcv) SAVEFREESV(cv); /* in case of fatal warnings */
2008 CvOUTSIDE(cv) = MUTABLE_CV(SvREFCNT_inc_simple(outside));
2010 SAVESPTR(PL_comppad_name);
2011 PL_comppad_name = protopad_name;
2012 CvPADLIST_set(cv, pad_new(padnew_CLONE|padnew_SAVE));
2013 CvPADLIST(cv)->xpadl_id = protopadlist->xpadl_id;
2015 av_fill(PL_comppad, fpad);
2017 PL_curpad = AvARRAY(PL_comppad);
2019 outpad = outside && CvPADLIST(outside)
2020 ? AvARRAY(PadlistARRAY(CvPADLIST(outside))[depth])
2022 if (outpad) CvPADLIST(cv)->xpadl_outid = CvPADLIST(outside)->xpadl_id;
2024 for (ix = fpad; ix > 0; ix--) {
2025 PADNAME* const namesv = (ix <= fname) ? pname[ix] : NULL;
2027 if (namesv && PadnameLEN(namesv)) { /* lexical */
2028 if (PadnameIsOUR(namesv)) { /* or maybe not so lexical */
2032 if (PadnameOUTER(namesv)) { /* lexical from outside? */
2033 /* formats may have an inactive, or even undefined, parent;
2034 but state vars are always available. */
2035 if (!outpad || !(sv = outpad[PARENT_PAD_INDEX(namesv)])
2036 || ( SvPADSTALE(sv) && !SvPAD_STATE(namesv)
2037 && (!outside || !CvDEPTH(outside))) ) {
2038 S_unavailable(aTHX_ namesv);
2042 SvREFCNT_inc_simple_void_NN(sv);
2045 const char sigil = PadnamePV(namesv)[0];
2047 /* If there are state subs, we need to clone them, too.
2048 But they may need to close over variables we have
2049 not cloned yet. So we will have to do a second
2050 pass. Furthermore, there may be state subs clos-
2051 ing over other state subs’ entries, so we have
2052 to put a stub here and then clone into it on the
2054 if (SvPAD_STATE(namesv) && !CvCLONED(ppad[ix])) {
2055 assert(SvTYPE(ppad[ix]) == SVt_PVCV);
2057 if (CvOUTSIDE(ppad[ix]) != proto)
2059 sv = newSV_type(SVt_PVCV);
2062 else if (PadnameLEN(namesv)>1 && !PadnameIsOUR(namesv))
2065 /* Just provide a stub, but name it. It will be
2066 upgrade to the real thing on scope entry. */
2069 PERL_HASH(hash, PadnamePV(namesv)+1,
2070 PadnameLEN(namesv) - 1);
2071 sv = newSV_type(SVt_PVCV);
2074 share_hek(PadnamePV(namesv)+1,
2075 1 - PadnameLEN(namesv),
2080 else sv = SvREFCNT_inc(ppad[ix]);
2081 else if (sigil == '@')
2082 sv = MUTABLE_SV(newAV());
2083 else if (sigil == '%')
2084 sv = MUTABLE_SV(newHV());
2087 /* reset the 'assign only once' flag on each state var */
2088 if (sigil != '&' && SvPAD_STATE(namesv))
2093 else if (namesv && PadnamePV(namesv)) {
2094 sv = SvREFCNT_inc_NN(ppad[ix]);
2105 if (trouble || cloned) {
2106 /* Uh-oh, we have trouble! At least one of the state subs here
2107 has its CvOUTSIDE pointer pointing somewhere unexpected. It
2108 could be pointing to another state protosub that we are
2109 about to clone. So we have to track which sub clones come
2110 from which protosubs. If the CvOUTSIDE pointer for a parti-
2111 cular sub points to something we have not cloned yet, we
2112 delay cloning it. We must loop through the pad entries,
2113 until we get a full pass with no cloning. If any uncloned
2114 subs remain (probably nested inside anonymous or ‘my’ subs),
2115 then they get cloned in a final pass.
2117 bool cloned_in_this_pass;
2119 cloned = (HV *)sv_2mortal((SV *)newHV());
2121 cloned_in_this_pass = FALSE;
2122 for (ix = fpad; ix > 0; ix--) {
2123 PADNAME * const name =
2124 (ix <= fname) ? pname[ix] : NULL;
2125 if (name && name != &PL_padname_undef
2126 && !PadnameOUTER(name) && PadnamePV(name)[0] == '&'
2127 && PadnameIsSTATE(name) && !CvCLONED(PL_curpad[ix]))
2129 CV * const protokey = CvOUTSIDE(ppad[ix]);
2130 CV ** const cvp = protokey == proto
2132 : (CV **)hv_fetch(cloned, (char *)&protokey,
2135 S_cv_clone(aTHX_ (CV *)ppad[ix],
2136 (CV *)PL_curpad[ix],
2138 (void)hv_store(cloned, (char *)&ppad[ix],
2140 SvREFCNT_inc_simple_NN(PL_curpad[ix]),
2143 cloned_in_this_pass = TRUE;
2147 } while (cloned_in_this_pass);
2149 for (ix = fpad; ix > 0; ix--) {
2150 PADNAME * const name =
2151 (ix <= fname) ? pname[ix] : NULL;
2152 if (name && name != &PL_padname_undef
2153 && !PadnameOUTER(name) && PadnamePV(name)[0] == '&'
2154 && PadnameIsSTATE(name) && !CvCLONED(PL_curpad[ix]))
2155 S_cv_clone(aTHX_ (CV *)ppad[ix],
2156 (CV *)PL_curpad[ix],
2157 CvOUTSIDE(ppad[ix]), cloned);
2160 else for (ix = fpad; ix > 0; ix--) {
2161 PADNAME * const name = (ix <= fname) ? pname[ix] : NULL;
2162 if (name && name != &PL_padname_undef && !PadnameOUTER(name)
2163 && PadnamePV(name)[0] == '&' && PadnameIsSTATE(name))
2164 S_cv_clone(aTHX_ (CV *)ppad[ix], (CV *)PL_curpad[ix], cv,
2169 if (newcv) SvREFCNT_inc_simple_void_NN(cv);
2173 /* Constant sub () { $x } closing over $x:
2174 * The prototype was marked as a candiate for const-ization,
2175 * so try to grab the current const value, and if successful,
2176 * turn into a const sub:
2179 OP *o = CvSTART(cv);
2181 for (; o; o = o->op_next)
2182 if (o->op_type == OP_PADSV)
2184 ASSUME(o->op_type == OP_PADSV);
2185 const_sv = PAD_BASE_SV(CvPADLIST(cv), o->op_targ);
2186 /* the candidate should have 1 ref from this pad and 1 ref
2187 * from the parent */
2188 if (const_sv && SvREFCNT(const_sv) == 2) {
2189 const bool was_method = cBOOL(CvMETHOD(cv));
2190 bool copied = FALSE;
2192 PADNAME * const pn =
2193 PadlistNAMESARRAY(CvPADLIST(outside))
2194 [PARENT_PAD_INDEX(PadlistNAMESARRAY(
2195 CvPADLIST(cv))[o->op_targ])];
2196 assert(PadnameOUTER(PadlistNAMESARRAY(CvPADLIST(cv))
2198 if (PadnameLVALUE(pn)) {
2199 /* We have a lexical that is potentially modifiable
2200 elsewhere, so making a constant will break clo-
2201 sure behaviour. If this is a ‘simple lexical
2202 op tree’, i.e., sub(){$x}, emit a deprecation
2203 warning, but continue to exhibit the old behav-
2204 iour of making it a constant based on the ref-
2205 count of the candidate variable.
2207 A simple lexical op tree looks like this:
2215 cUNOPx(cUNOPx(CvROOT(cv))->op_first)->op_first
2219 Perl_ck_warner_d(aTHX_
2220 packWARN(WARN_DEPRECATED),
2221 "Constants from lexical "
2222 "variables potentially "
2223 "modified elsewhere are "
2225 /* We *copy* the lexical variable, and donate the
2226 copy to newCONSTSUB. Yes, this is ugly, and
2227 should be killed. We need to do this for the
2228 time being, however, because turning on SvPADTMP
2229 on a lexical will have observable effects
2231 const_sv = newSVsv(const_sv);
2239 SvREFCNT_inc_simple_void_NN(const_sv);
2240 /* If the lexical is not used elsewhere, it is safe to turn on
2241 SvPADTMP, since it is only when it is used in lvalue con-
2242 text that the difference is observable. */
2243 SvREADONLY_on(const_sv);
2244 SvPADTMP_on(const_sv);
2245 SvREFCNT_dec_NN(cv);
2246 cv = newCONSTSUB(CvSTASH(proto), NULL, const_sv);
2260 S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned)
2265 const bool newcv = !cv;
2267 assert(!CvUNIQUE(proto));
2269 if (!cv) cv = MUTABLE_CV(newSV_type(SvTYPE(proto)));
2270 CvFLAGS(cv) = CvFLAGS(proto) & ~(CVf_CLONE|CVf_WEAKOUTSIDE|CVf_CVGV_RC
2274 CvFILE(cv) = CvDYNFILE(proto) ? savepv(CvFILE(proto))
2277 CvNAME_HEK_set(cv, share_hek_hek(CvNAME_HEK(proto)));
2278 else CvGV_set(cv,CvGV(proto));
2279 CvSTASH_set(cv, CvSTASH(proto));
2281 CvROOT(cv) = OpREFCNT_inc(CvROOT(proto));
2283 CvSTART(cv) = CvSTART(proto);
2284 CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto);
2287 sv_setpvn(MUTABLE_SV(cv), SvPVX_const(proto), SvCUR(proto));
2289 SvUTF8_on(MUTABLE_SV(cv));
2292 mg_copy((SV *)proto, (SV *)cv, 0, 0);
2294 if (CvPADLIST(proto))
2295 cv = S_cv_clone_pad(aTHX_ proto, cv, outside, cloned, newcv);
2298 PerlIO_printf(Perl_debug_log, "\nPad CV clone\n");
2299 if (CvOUTSIDE(cv)) cv_dump(CvOUTSIDE(cv), "Outside");
2300 cv_dump(proto, "Proto");
2308 Perl_cv_clone(pTHX_ CV *proto)
2310 PERL_ARGS_ASSERT_CV_CLONE;
2312 if (!CvPADLIST(proto)) Perl_croak(aTHX_ "panic: no pad in cv_clone");
2313 return S_cv_clone(aTHX_ proto, NULL, NULL, NULL);
2316 /* Called only by pp_clonecv */
2318 Perl_cv_clone_into(pTHX_ CV *proto, CV *target)
2320 PERL_ARGS_ASSERT_CV_CLONE_INTO;
2322 return S_cv_clone(aTHX_ proto, target, NULL, NULL);
2328 Returns an SV containing the name of the CV, mainly for use in error
2329 reporting. The CV may actually be a GV instead, in which case the returned
2330 SV holds the GV's name. Anything other than a GV or CV is treated as a
2331 string already holding the sub name, but this could change in the future.
2333 An SV may be passed as a second argument. If so, the name will be assigned
2334 to it and it will be returned. Otherwise the returned SV will be a new
2337 If C<flags> has the C<CV_NAME_NOTQUAL> bit set, then the package name will not be
2338 included. If the first argument is neither a CV nor a GV, this flag is
2339 ignored (subject to change).
2345 Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags)
2347 PERL_ARGS_ASSERT_CV_NAME;
2348 if (!isGV_with_GP(cv) && SvTYPE(cv) != SVt_PVCV) {
2349 if (sv) sv_setsv(sv,(SV *)cv);
2350 return sv ? (sv) : (SV *)cv;
2353 SV * const retsv = sv ? (sv) : sv_newmortal();
2354 if (SvTYPE(cv) == SVt_PVCV) {
2356 if (CvLEXICAL(cv) || flags & CV_NAME_NOTQUAL)
2357 sv_sethek(retsv, CvNAME_HEK(cv));
2359 sv_sethek(retsv, HvNAME_HEK(CvSTASH(cv)));
2360 sv_catpvs(retsv, "::");
2361 sv_cathek(retsv, CvNAME_HEK(cv));
2364 else if (CvLEXICAL(cv) || flags & CV_NAME_NOTQUAL)
2365 sv_sethek(retsv, GvNAME_HEK(GvEGV(CvGV(cv))));
2366 else gv_efullname3(retsv, CvGV(cv), NULL);
2368 else if (flags & CV_NAME_NOTQUAL) sv_sethek(retsv, GvNAME_HEK(cv));
2369 else gv_efullname3(retsv,(GV *)cv,NULL);
2375 =for apidoc m|void|pad_fixup_inner_anons|PADLIST *padlist|CV *old_cv|CV *new_cv
2377 For any anon CVs in the pad, change C<CvOUTSIDE> of that CV from
2378 C<old_cv> to C<new_cv> if necessary. Needed when a newly-compiled CV has to be
2379 moved to a pre-existing CV struct.
2385 Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv)
2388 PADNAMELIST * const comppad_name = PadlistNAMES(padlist);
2389 AV * const comppad = PadlistARRAY(padlist)[1];
2390 PADNAME ** const namepad = PadnamelistARRAY(comppad_name);
2391 SV ** const curpad = AvARRAY(comppad);
2393 PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS;
2394 PERL_UNUSED_ARG(old_cv);
2396 for (ix = PadnamelistMAX(comppad_name); ix > 0; ix--) {
2397 const PADNAME *name = namepad[ix];
2398 if (name && name != &PL_padname_undef && !PadnameIsOUR(name)
2399 && *PadnamePV(name) == '&')
2401 CV *innercv = MUTABLE_CV(curpad[ix]);
2402 if (UNLIKELY(PadnameOUTER(name))) {
2404 PADNAME **names = namepad;
2406 while (PadnameOUTER(name)) {
2408 names = PadlistNAMESARRAY(CvPADLIST(cv));
2409 i = PARENT_PAD_INDEX(name);
2412 innercv = (CV *)PadARRAY(PadlistARRAY(CvPADLIST(cv))[1])[i];
2414 if (SvTYPE(innercv) == SVt_PVCV) {
2415 /* XXX 0afba48f added code here to check for a proto CV
2416 attached to the pad entry by magic. But shortly there-
2417 after 81df9f6f95 moved the magic to the pad name. The
2418 code here was never updated, so it wasn’t doing anything
2419 and got deleted when PADNAME became a distinct type. Is
2420 there any bug as a result? */
2421 if (CvOUTSIDE(innercv) == old_cv) {
2422 if (!CvWEAKOUTSIDE(innercv)) {
2423 SvREFCNT_dec(old_cv);
2424 SvREFCNT_inc_simple_void_NN(new_cv);
2426 CvOUTSIDE(innercv) = new_cv;
2429 else { /* format reference */
2430 SV * const rv = curpad[ix];
2432 if (!SvOK(rv)) continue;
2434 assert(SvWEAKREF(rv));
2435 innercv = (CV *)SvRV(rv);
2436 assert(!CvWEAKOUTSIDE(innercv));
2437 SvREFCNT_dec(CvOUTSIDE(innercv));
2438 CvOUTSIDE(innercv) = (CV *)SvREFCNT_inc_simple_NN(new_cv);
2445 =for apidoc m|void|pad_push|PADLIST *padlist|int depth
2447 Push a new pad frame onto the padlist, unless there's already a pad at
2448 this depth, in which case don't bother creating a new one. Then give
2449 the new pad an C<@_> in slot zero.
2455 Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
2457 PERL_ARGS_ASSERT_PAD_PUSH;
2459 if (depth > PadlistMAX(padlist) || !PadlistARRAY(padlist)[depth]) {
2460 PAD** const svp = PadlistARRAY(padlist);
2461 AV* const newpad = newAV();
2462 SV** const oldpad = AvARRAY(svp[depth-1]);
2463 I32 ix = AvFILLp((const AV *)svp[1]);
2464 const I32 names_fill = PadnamelistMAX((PADNAMELIST *)svp[0]);
2465 PADNAME ** const names = PadnamelistARRAY((PADNAMELIST *)svp[0]);
2468 for ( ;ix > 0; ix--) {
2469 if (names_fill >= ix && PadnameLEN(names[ix])) {
2470 const char sigil = PadnamePV(names[ix])[0];
2471 if (PadnameOUTER(names[ix])
2472 || PadnameIsSTATE(names[ix])
2475 /* outer lexical or anon code */
2476 av_store(newpad, ix, SvREFCNT_inc(oldpad[ix]));
2478 else { /* our own lexical */
2481 sv = MUTABLE_SV(newAV());
2482 else if (sigil == '%')
2483 sv = MUTABLE_SV(newHV());
2486 av_store(newpad, ix, sv);
2489 else if (PadnamePV(names[ix])) {
2490 av_store(newpad, ix, SvREFCNT_inc_NN(oldpad[ix]));
2493 /* save temporaries on recursion? */
2494 SV * const sv = newSV(0);
2495 av_store(newpad, ix, sv);
2500 av_store(newpad, 0, MUTABLE_SV(av));
2503 padlist_store(padlist, depth, newpad);
2507 #if defined(USE_ITHREADS)
2509 # define av_dup_inc(s,t) MUTABLE_AV(sv_dup_inc((const SV *)s,t))
2512 =for apidoc padlist_dup
2520 Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
2526 PERL_ARGS_ASSERT_PADLIST_DUP;
2528 cloneall = cBOOL(param->flags & CLONEf_COPY_STACKS);
2529 assert (SvREFCNT(PadlistARRAY(srcpad)[1]) == 1);
2531 max = cloneall ? PadlistMAX(srcpad) : 1;
2533 Newx(dstpad, 1, PADLIST);
2534 ptr_table_store(PL_ptr_table, srcpad, dstpad);
2535 PadlistMAX(dstpad) = max;
2536 Newx(PadlistARRAY(dstpad), max + 1, PAD *);
2538 PadlistARRAY(dstpad)[0] = (PAD *)
2539 padnamelist_dup(PadlistNAMES(srcpad), param);
2540 PadnamelistREFCNT(PadlistNAMES(dstpad))++;
2543 for (depth = 1; depth <= max; ++depth)
2544 PadlistARRAY(dstpad)[depth] =
2545 av_dup_inc(PadlistARRAY(srcpad)[depth], param);
2547 /* CvDEPTH() on our subroutine will be set to 0, so there's no need
2548 to build anything other than the first level of pads. */
2549 I32 ix = AvFILLp(PadlistARRAY(srcpad)[1]);
2551 const I32 names_fill = PadnamelistMAX(PadlistNAMES(srcpad));
2552 const PAD *const srcpad1 = PadlistARRAY(srcpad)[1];
2553 SV **oldpad = AvARRAY(srcpad1);
2554 PADNAME ** const names = PadnamelistARRAY(PadlistNAMES(dstpad));
2560 av_extend(pad1, ix);
2561 PadlistARRAY(dstpad)[1] = pad1;
2562 pad1a = AvARRAY(pad1);
2567 for ( ;ix > 0; ix--) {
2570 } else if (names_fill >= ix && names[ix] &&
2571 PadnameLEN(names[ix])) {
2572 const char sigil = PadnamePV(names[ix])[0];
2573 if (PadnameOUTER(names[ix])
2574 || PadnameIsSTATE(names[ix])
2577 /* outer lexical or anon code */
2578 pad1a[ix] = sv_dup_inc(oldpad[ix], param);
2580 else { /* our own lexical */
2581 if(SvPADSTALE(oldpad[ix]) && SvREFCNT(oldpad[ix]) > 1) {
2582 /* This is a work around for how the current
2583 implementation of ?{ } blocks in regexps
2584 interacts with lexicals. */
2585 pad1a[ix] = sv_dup_inc(oldpad[ix], param);
2590 sv = MUTABLE_SV(newAV());
2591 else if (sigil == '%')
2592 sv = MUTABLE_SV(newHV());
2599 else if (( names_fill >= ix && names[ix]
2600 && PadnamePV(names[ix]) )) {
2601 pad1a[ix] = sv_dup_inc(oldpad[ix], param);
2604 /* save temporaries on recursion? */
2605 SV * const sv = newSV(0);
2608 /* SvREFCNT(oldpad[ix]) != 1 for some code in threads.xs
2609 FIXTHAT before merging this branch.
2610 (And I know how to) */
2611 if (SvPADTMP(oldpad[ix]))
2617 args = newAV(); /* Will be @_ */
2619 pad1a[0] = (SV *)args;
2627 #endif /* USE_ITHREADS */
2630 Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val)
2633 SSize_t const oldmax = PadlistMAX(padlist);
2635 PERL_ARGS_ASSERT_PADLIST_STORE;
2639 if (key > PadlistMAX(padlist)) {
2640 av_extend_guts(NULL,key,&PadlistMAX(padlist),
2641 (SV ***)&PadlistARRAY(padlist),
2642 (SV ***)&PadlistARRAY(padlist));
2643 Zero(PadlistARRAY(padlist)+oldmax+1, PadlistMAX(padlist)-oldmax,
2646 ary = PadlistARRAY(padlist);
2647 SvREFCNT_dec(ary[key]);
2653 =for apidoc newPADNAMELIST
2655 Creates a new pad name list. C<max> is the highest index for which space
2662 Perl_newPADNAMELIST(size_t max)
2665 Newx(pnl, 1, PADNAMELIST);
2666 Newxz(PadnamelistARRAY(pnl), max+1, PADNAME *);
2667 PadnamelistMAX(pnl) = -1;
2668 PadnamelistREFCNT(pnl) = 1;
2669 PadnamelistMAXNAMED(pnl) = 0;
2670 pnl->xpadnl_max = max;
2675 =for apidoc padnamelist_store
2677 Stores the pad name (which may be null) at the given index, freeing any
2678 existing pad name in that slot.
2684 Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val)
2688 PERL_ARGS_ASSERT_PADNAMELIST_STORE;
2692 if (key > pnl->xpadnl_max)
2693 av_extend_guts(NULL,key,&pnl->xpadnl_max,
2694 (SV ***)&PadnamelistARRAY(pnl),
2695 (SV ***)&PadnamelistARRAY(pnl));
2696 if (PadnamelistMAX(pnl) < key) {
2697 Zero(PadnamelistARRAY(pnl)+PadnamelistMAX(pnl)+1,
2698 key-PadnamelistMAX(pnl), PADNAME *);
2699 PadnamelistMAX(pnl) = key;
2701 ary = PadnamelistARRAY(pnl);
2703 PadnameREFCNT_dec(ary[key]);
2709 =for apidoc padnamelist_fetch
2711 Fetches the pad name from the given index.
2717 Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key)
2719 PERL_ARGS_ASSERT_PADNAMELIST_FETCH;
2722 return key > PadnamelistMAX(pnl) ? NULL : PadnamelistARRAY(pnl)[key];
2726 Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl)
2728 PERL_ARGS_ASSERT_PADNAMELIST_FREE;
2729 if (!--PadnamelistREFCNT(pnl)) {
2730 while(PadnamelistMAX(pnl) >= 0)
2732 PADNAME * const pn =
2733 PadnamelistARRAY(pnl)[PadnamelistMAX(pnl)--];
2735 PadnameREFCNT_dec(pn);
2737 Safefree(PadnamelistARRAY(pnl));
2742 #if defined(USE_ITHREADS)
2745 =for apidoc padnamelist_dup
2747 Duplicates a pad name list.
2753 Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param)
2755 PADNAMELIST *dstpad;
2756 SSize_t max = PadnamelistMAX(srcpad);
2758 PERL_ARGS_ASSERT_PADNAMELIST_DUP;
2760 /* look for it in the table first */
2761 dstpad = (PADNAMELIST *)ptr_table_fetch(PL_ptr_table, srcpad);
2765 dstpad = newPADNAMELIST(max);
2766 PadnamelistREFCNT(dstpad) = 0; /* The caller will increment it. */
2767 PadnamelistMAXNAMED(dstpad) = PadnamelistMAXNAMED(srcpad);
2768 PadnamelistMAX(dstpad) = max;
2770 ptr_table_store(PL_ptr_table, srcpad, dstpad);
2771 for (; max >= 0; max--)
2772 if (PadnamelistARRAY(srcpad)[max]) {
2773 PadnamelistARRAY(dstpad)[max] =
2774 padname_dup(PadnamelistARRAY(srcpad)[max], param);
2775 PadnameREFCNT(PadnamelistARRAY(dstpad)[max])++;
2781 #endif /* USE_ITHREADS */
2784 =for apidoc newPADNAMEpvn
2786 Constructs and returns a new pad name. C<s> must be a UTF-8 string. Do not
2787 use this for pad names that point to outer lexicals. See
2788 C<L</newPADNAMEouter>>.
2794 Perl_newPADNAMEpvn(const char *s, STRLEN len)
2796 struct padname_with_str *alloc;
2797 char *alloc2; /* for Newxz */
2799 PERL_ARGS_ASSERT_NEWPADNAMEPVN;
2801 STRUCT_OFFSET(struct padname_with_str, xpadn_str[0]) + len + 1,
2803 alloc = (struct padname_with_str *)alloc2;
2804 pn = (PADNAME *)alloc;
2805 PadnameREFCNT(pn) = 1;
2806 PadnamePV(pn) = alloc->xpadn_str;
2807 Copy(s, PadnamePV(pn), len, char);
2808 *(PadnamePV(pn) + len) = '\0';
2809 PadnameLEN(pn) = len;
2814 =for apidoc newPADNAMEouter
2816 Constructs and returns a new pad name. Only use this function for names
2817 that refer to outer lexicals. (See also L</newPADNAMEpvn>.) C<outer> is
2818 the outer pad name that this one mirrors. The returned pad name has the
2819 C<PADNAMEt_OUTER> flag already set.
2825 Perl_newPADNAMEouter(PADNAME *outer)
2828 PERL_ARGS_ASSERT_NEWPADNAMEOUTER;
2829 Newxz(pn, 1, PADNAME);
2830 PadnameREFCNT(pn) = 1;
2831 PadnamePV(pn) = PadnamePV(outer);
2832 /* Not PadnameREFCNT(outer), because ‘outer’ may itself close over
2833 another entry. The original pad name owns the buffer. */
2834 PadnameREFCNT(PADNAME_FROM_PV(PadnamePV(outer)))++;
2835 PadnameFLAGS(pn) = PADNAMEt_OUTER;
2836 PadnameLEN(pn) = PadnameLEN(outer);
2841 Perl_padname_free(pTHX_ PADNAME *pn)
2843 PERL_ARGS_ASSERT_PADNAME_FREE;
2844 if (!--PadnameREFCNT(pn)) {
2845 if (UNLIKELY(pn == &PL_padname_undef || pn == &PL_padname_const)) {
2846 PadnameREFCNT(pn) = SvREFCNT_IMMORTAL;
2849 SvREFCNT_dec(PadnameTYPE(pn)); /* Takes care of protocv, too. */
2850 SvREFCNT_dec(PadnameOURSTASH(pn));
2851 if (PadnameOUTER(pn))
2852 PadnameREFCNT_dec(PADNAME_FROM_PV(PadnamePV(pn)));
2857 #if defined(USE_ITHREADS)
2860 =for apidoc padname_dup
2862 Duplicates a pad name.
2868 Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param)
2872 PERL_ARGS_ASSERT_PADNAME_DUP;
2874 /* look for it in the table first */
2875 dst = (PADNAME *)ptr_table_fetch(PL_ptr_table, src);
2879 if (!PadnamePV(src)) {
2880 dst = &PL_padname_undef;
2881 ptr_table_store(PL_ptr_table, src, dst);
2885 dst = PadnameOUTER(src)
2886 ? newPADNAMEouter(padname_dup(PADNAME_FROM_PV(PadnamePV(src)), param))
2887 : newPADNAMEpvn(PadnamePV(src), PadnameLEN(src));
2888 ptr_table_store(PL_ptr_table, src, dst);
2889 PadnameLEN(dst) = PadnameLEN(src);
2890 PadnameFLAGS(dst) = PadnameFLAGS(src);
2891 PadnameREFCNT(dst) = 0; /* The caller will increment it. */
2892 PadnameTYPE (dst) = (HV *)sv_dup_inc((SV *)PadnameTYPE(src), param);
2893 PadnameOURSTASH(dst) = (HV *)sv_dup_inc((SV *)PadnameOURSTASH(src),
2895 dst->xpadn_low = src->xpadn_low;
2896 dst->xpadn_high = src->xpadn_high;
2897 dst->xpadn_gen = src->xpadn_gen;
2901 #endif /* USE_ITHREADS */
2904 * ex: set ts=8 sts=4 sw=4 et: