3 * Copyright (c) 2002, Larry Wall
5 * You may distribute under the terms of either the GNU General Public
6 * License or the Artistic License, as specified in the README file.
8 * "Anyway: there was this Mr Frodo left an orphan and stranded, as you
9 * might say, among those queer Bucklanders, being brought up anyhow in
10 * Brandy Hall. A regular warren, by all accounts. Old Master Gorbadoc
11 * never had fewer than a couple of hundred relations in the place. Mr
12 * Bilbo never did a kinder deed than when he brought the lad back to
13 * live among decent folk." --the Gaffer
17 * As of Sept 2002, this file is new and may be in a state of flux for
18 * a while. I've marked things I intent to come back and look at further
19 * with an 'XXX DAPM' comment.
23 =head1 Pad Data Structures
25 =for apidoc m|AV *|CvPADLIST|CV *cv
26 CV's can have CvPADLIST(cv) set to point to an AV.
28 For these purposes "forms" are a kind-of CV, eval""s are too (except they're
29 not callable at will and are always thrown away after the eval"" is done
32 XSUBs don't have CvPADLIST set - dXSTARG fetches values from PL_curpad,
33 but that is really the callers pad (a slot of which is allocated by
36 The CvPADLIST AV has does not have AvREAL set, so REFCNT of component items
37 is managed "manual" (mostly in pad.c) rather than normal av.c rules.
38 The items in the AV are not SVs as for a normal AV, but other AVs:
40 0'th Entry of the CvPADLIST is an AV which represents the "names" or rather
41 the "static type information" for lexicals.
43 The CvDEPTH'th entry of CvPADLIST AV is an AV which is the stack frame at that
44 depth of recursion into the CV.
45 The 0'th slot of a frame AV is an AV which is @_.
46 other entries are storage for variables and op targets.
49 C<PL_comppad_name> is set the the the names AV.
50 C<PL_comppad> is set the the frame AV for the frame CvDEPTH == 1.
51 C<PL_curpad> is set the body of the frame AV (i.e. AvARRAY(PL_comppad)).
53 During execution, C<PL_comppad> and C<PL_curpad> refer to the live
54 frame of the currently executing sub.
56 Iterating over the names AV iterates over all possible pad
57 items. Pad slots that are SVs_PADTMP (targets/GVs/constants) end up having
58 &PL_sv_undef "names" (see pad_alloc()).
60 Only my/our variable (SVs_PADMY/SVs_PADOUR) slots get valid names.
61 The rest are op targets/GVs/constants which are statically allocated
62 or resolved at compile time. These don't have names by which they
63 can be looked up from Perl code at run time through eval"" like
64 my/our variables can be. Since they can't be looked up by "name"
65 but only by their index allocated at compile time (which is usually
66 in PL_op->op_targ), wasting a name SV for them doesn't make sense.
68 The SVs in the names AV have their PV being the name of the variable.
69 NV+1..IV inclusive is a range of cop_seq numbers for which the name is
70 valid. For typed lexicals name SV is SVt_PVMG and SvSTASH points at the
71 type. For C<our> lexicals, the type is SVt_PVGV, and GvSTASH points at the
72 stash of the associated global (so that duplicate C<our> delarations in the
73 same package can be detected). SvCUR is sometimes hijacked to
74 store the generation number during compilation.
76 If SvFAKE is set on the name SV then slot in the frame AVs are
77 a REFCNT'ed references to a lexical from "outside". In this case,
78 the name SV does not have a cop_seq range, since it is in scope
81 If the 'name' is '&' the the corresponding entry in frame AV
82 is a CV representing a possible closure.
83 (SvFAKE and name of '&' is not a meaningful combination currently but could
84 become so if C<my sub foo {}> is implemented.)
95 #define PAD_MAX 999999999
102 Create a new compiling padlist, saving and updating the various global
103 vars at the same time as creating the pad itself. The following flags
104 can be OR'ed together:
106 padnew_CLONE this pad is for a cloned CV
107 padnew_SAVE save old globals
108 padnew_SAVESUB also save extra stuff for start of sub
114 Perl_pad_new(pTHX_ int flags)
116 AV *padlist, *padname, *pad, *a0;
118 ASSERT_CURPAD_LEGAL("pad_new");
120 /* XXX DAPM really need a new SAVEt_PAD which restores all or most
121 * vars (based on flags) rather than storing vals + addresses for
122 * each individually. Also see pad_block_start.
123 * XXX DAPM Try to see whether all these conditionals are required
126 /* save existing state, ... */
128 if (flags & padnew_SAVE) {
130 SAVESPTR(PL_comppad_name);
131 if (! (flags & padnew_CLONE)) {
133 SAVEI32(PL_comppad_name_fill);
134 SAVEI32(PL_min_intro_pending);
135 SAVEI32(PL_max_intro_pending);
136 if (flags & padnew_SAVESUB) {
137 SAVEI32(PL_pad_reset_pending);
141 /* XXX DAPM interestingly, PL_comppad_name_floor never seems to be
142 * saved - check at some pt that this is okay */
144 /* ... create new pad ... */
150 if (flags & padnew_CLONE) {
151 /* XXX DAPM I dont know why cv_clone needs it
152 * doing differently yet - perhaps this separate branch can be
153 * dispensed with eventually ???
156 a0 = newAV(); /* will be @_ */
158 av_store(pad, 0, (SV*)a0);
159 AvFLAGS(a0) = AVf_REIFY;
162 av_store(pad, 0, Nullsv);
166 av_store(padlist, 0, (SV*)padname);
167 av_store(padlist, 1, (SV*)pad);
169 /* ... then update state variables */
171 PL_comppad_name = (AV*)(*av_fetch(padlist, 0, FALSE));
172 PL_comppad = (AV*)(*av_fetch(padlist, 1, FALSE));
173 PL_curpad = AvARRAY(PL_comppad);
175 if (! (flags & padnew_CLONE)) {
176 PL_comppad_name_fill = 0;
177 PL_min_intro_pending = 0;
181 DEBUG_X(PerlIO_printf(Perl_debug_log,
182 "Pad 0x%"UVxf"[0x%"UVxf"] new: padlist=0x%"UVxf
183 " name=0x%"UVxf" flags=0x%"UVxf"\n",
184 PTR2UV(PL_comppad), PTR2UV(PL_curpad), PTR2UV(padlist),
185 PTR2UV(padname), (UV)flags
189 return (PADLIST*)padlist;
193 =for apidoc pad_undef
195 Free the padlist associated with a CV.
196 If parts of it happen to be current, we null the relevant
197 PL_*pad* global vars so that we don't have any dangling references left.
198 We also repoint the CvOUTSIDE of any about-to-be-orphaned
199 inner subs to the outer of this cv.
201 (This function should really be called pad_free, but the name was already
208 Perl_pad_undef(pTHX_ CV* cv)
211 PADLIST *padlist = CvPADLIST(cv);
215 if (!SvREFCNT(CvPADLIST(cv))) /* may be during global destruction */
218 DEBUG_X(PerlIO_printf(Perl_debug_log,
219 "Pad undef: padlist=0x%"UVxf"\n" , PTR2UV(padlist))
222 /* detach any '&' anon children in the pad; if afterwards they
223 * are still live, fix up their CvOUTSIDEs to point to our outside,
225 /* XXX DAPM for efficiency, we should only do this if we know we have
226 * children, or integrate this loop with general cleanup */
228 if (!PL_dirty) { /* don't bother during global destruction */
229 CV *outercv = CvOUTSIDE(cv);
230 U32 seq = CvOUTSIDE_SEQ(cv);
231 AV *comppad_name = (AV*)AvARRAY(padlist)[0];
232 SV **namepad = AvARRAY(comppad_name);
233 AV *comppad = (AV*)AvARRAY(padlist)[1];
234 SV **curpad = AvARRAY(comppad);
235 for (ix = AvFILLp(comppad_name); ix > 0; ix--) {
236 SV *namesv = namepad[ix];
237 if (namesv && namesv != &PL_sv_undef
238 && *SvPVX(namesv) == '&')
240 CV *innercv = (CV*)curpad[ix];
241 namepad[ix] = Nullsv;
242 SvREFCNT_dec(namesv);
244 SvREFCNT_dec(innercv);
245 if (SvREFCNT(innercv) /* in use, not just a prototype */
246 && CvOUTSIDE(innercv) == cv)
248 assert(CvWEAKOUTSIDE(innercv));
249 CvWEAKOUTSIDE_off(innercv);
250 CvOUTSIDE(innercv) = outercv;
251 CvOUTSIDE_SEQ(innercv) = seq;
252 SvREFCNT_inc(outercv);
258 ix = AvFILLp(padlist);
260 SV* sv = AvARRAY(padlist)[ix--];
263 if (sv == (SV*)PL_comppad_name)
264 PL_comppad_name = Nullav;
265 else if (sv == (SV*)PL_comppad) {
266 PL_comppad = Null(PAD*);
267 PL_curpad = Null(SV**);
271 SvREFCNT_dec((SV*)CvPADLIST(cv));
272 CvPADLIST(cv) = Null(PADLIST*);
279 =for apidoc pad_add_name
281 Create a new name in the current pad at the specified offset.
282 If C<typestash> is valid, the name is for a typed lexical; set the
283 name's stash to that value.
284 If C<ourstash> is valid, it's an our lexical, set the name's
285 GvSTASH to that value
287 Also, if the name is @.. or %.., create a new array or hash for that slot
289 If fake, it means we're cloning an existing entry
295 * XXX DAPM this doesn't seem the right place to create a new array/hash.
296 * Whatever we do, we should be consistent - create scalars too, and
297 * create even if fake. Really need to integrate better the whole entry
298 * creation business - when + where does the name and value get created?
302 Perl_pad_add_name(pTHX_ char *name, HV* typestash, HV* ourstash, bool fake)
304 PADOFFSET offset = pad_alloc(OP_PADSV, SVs_PADMY);
305 SV* namesv = NEWSV(1102, 0);
307 ASSERT_CURPAD_ACTIVE("pad_add_name");
310 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
311 "Pad addname: %ld \"%s\"%s\n",
312 (long)offset, name, (fake ? " FAKE" : "")
316 sv_upgrade(namesv, ourstash ? SVt_PVGV : typestash ? SVt_PVMG : SVt_PVNV);
317 sv_setpv(namesv, name);
320 SvFLAGS(namesv) |= SVpad_TYPED;
321 SvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*) typestash);
324 SvFLAGS(namesv) |= SVpad_OUR;
325 GvSTASH(namesv) = (HV*)SvREFCNT_inc((SV*) ourstash);
328 av_store(PL_comppad_name, offset, namesv);
332 /* not yet introduced */
333 SvNVX(namesv) = (NV)PAD_MAX; /* min */
334 SvIVX(namesv) = 0; /* max */
336 if (!PL_min_intro_pending)
337 PL_min_intro_pending = offset;
338 PL_max_intro_pending = offset;
339 /* XXX DAPM since slot has been allocated, replace
340 * av_store with PL_curpad[offset] ? */
342 av_store(PL_comppad, offset, (SV*)newAV());
343 else if (*name == '%')
344 av_store(PL_comppad, offset, (SV*)newHV());
345 SvPADMY_on(PL_curpad[offset]);
355 =for apidoc pad_alloc
357 Allocate a new my or tmp pad entry. For a my, simply push a null SV onto
358 the end of PL_comppad, but for a tmp, scan the pad from PL_padix upwards
359 for a slot which has no name and and no active value.
364 /* XXX DAPM integrate alloc(), add_name() and add_anon(),
365 * or at least rationalise ??? */
369 Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
374 ASSERT_CURPAD_ACTIVE("pad_alloc");
376 if (AvARRAY(PL_comppad) != PL_curpad)
377 Perl_croak(aTHX_ "panic: pad_alloc");
378 if (PL_pad_reset_pending)
380 if (tmptype & SVs_PADMY) {
382 sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE);
383 } while (SvPADBUSY(sv)); /* need a fresh one */
384 retval = AvFILLp(PL_comppad);
387 SV **names = AvARRAY(PL_comppad_name);
388 SSize_t names_fill = AvFILLp(PL_comppad_name);
391 * "foreach" index vars temporarily become aliases to non-"my"
392 * values. Thus we must skip, not just pad values that are
393 * marked as current pad values, but also those with names.
395 /* HVDS why copy to sv here? we don't seem to use it */
396 if (++PL_padix <= names_fill &&
397 (sv = names[PL_padix]) && sv != &PL_sv_undef)
399 sv = *av_fetch(PL_comppad, PL_padix, TRUE);
400 if (!(SvFLAGS(sv) & (SVs_PADTMP | SVs_PADMY)) &&
401 !IS_PADGV(sv) && !IS_PADCONST(sv))
406 SvFLAGS(sv) |= tmptype;
407 PL_curpad = AvARRAY(PL_comppad);
409 DEBUG_X(PerlIO_printf(Perl_debug_log,
410 "Pad 0x%"UVxf"[0x%"UVxf"] alloc: %ld for %s\n",
411 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long) retval,
412 PL_op_name[optype]));
413 return (PADOFFSET)retval;
417 =for apidoc pad_add_anon
419 Add an anon code entry to the current compiling pad
425 Perl_pad_add_anon(pTHX_ SV* sv, OPCODE op_type)
430 name = NEWSV(1106, 0);
431 sv_upgrade(name, SVt_PVNV);
432 sv_setpvn(name, "&", 1);
435 ix = pad_alloc(op_type, SVs_PADMY);
436 av_store(PL_comppad_name, ix, name);
437 /* XXX DAPM use PL_curpad[] ? */
438 av_store(PL_comppad, ix, sv);
441 /* to avoid ref loops, we never have parent + child referencing each
442 * other simultaneously */
443 if (CvOUTSIDE((CV*)sv)) {
444 assert(!CvWEAKOUTSIDE((CV*)sv));
445 CvWEAKOUTSIDE_on((CV*)sv);
446 SvREFCNT_dec(CvOUTSIDE((CV*)sv));
454 =for apidoc pad_check_dup
456 Check for duplicate declarations: report any of:
457 * a my in the current scope with the same name;
458 * an our (anywhere in the pad) with the same name and the same stash
460 C<is_our> indicates that the name to check is an 'our' declaration
465 /* XXX DAPM integrate this into pad_add_name ??? */
468 Perl_pad_check_dup(pTHX_ char *name, bool is_our, HV *ourstash)
473 ASSERT_CURPAD_ACTIVE("pad_check_dup");
474 if (!ckWARN(WARN_MISC) || AvFILLp(PL_comppad_name) < 0)
475 return; /* nothing to check */
477 svp = AvARRAY(PL_comppad_name);
478 top = AvFILLp(PL_comppad_name);
479 /* check the current scope */
480 /* XXX DAPM - why the (I32) cast - shouldn't we ensure they're the same
482 for (off = top; (I32)off > PL_comppad_name_floor; off--) {
484 && sv != &PL_sv_undef
486 && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0)
488 || ((SvFLAGS(sv) & SVpad_OUR) && GvSTASH(sv) == ourstash))
489 && strEQ(name, SvPVX(sv)))
491 Perl_warner(aTHX_ packWARN(WARN_MISC),
492 "\"%s\" variable %s masks earlier declaration in same %s",
493 (is_our ? "our" : "my"),
495 (SvIVX(sv) == PAD_MAX ? "scope" : "statement"));
500 /* check the rest of the pad */
504 && sv != &PL_sv_undef
506 && (SvIVX(sv) == PAD_MAX || SvIVX(sv) == 0)
507 && ((SvFLAGS(sv) & SVpad_OUR) && GvSTASH(sv) == ourstash)
508 && strEQ(name, SvPVX(sv)))
510 Perl_warner(aTHX_ packWARN(WARN_MISC),
511 "\"our\" variable %s redeclared", name);
512 Perl_warner(aTHX_ packWARN(WARN_MISC),
513 "\t(Did you mean \"local\" instead of \"our\"?)\n");
516 } while ( off-- > 0 );
523 =for apidoc pad_findmy
525 Given a lexical name, try to find its offset, first in the current pad,
526 or failing that, in the pads of any lexically enclosing subs (including
527 the complications introduced by eval). If the name is found in an outer pad,
528 then a fake entry is added to the current pad.
529 Returns the offset in the current pad, or NOT_IN_PAD on failure.
535 Perl_pad_findmy(pTHX_ char *name)
540 SV **svp = AvARRAY(PL_comppad_name);
541 U32 seq = PL_cop_seqmax;
543 ASSERT_CURPAD_ACTIVE("pad_findmy");
544 DEBUG_Xv(PerlIO_printf(Perl_debug_log, "Pad findmy: \"%s\"\n", name));
546 /* The one we're looking for is probably just before comppad_name_fill. */
547 for (off = AvFILLp(PL_comppad_name); off > 0; off--) {
549 if (!sv || sv == &PL_sv_undef || !strEQ(SvPVX(sv), name))
552 /* we'll use this later if we don't find a real entry */
558 ( seq > (U32)I_32(SvNVX(sv)) /* min */
559 && seq <= (U32)SvIVX(sv)) /* max */
561 /* 'our' is visible before introduction */
562 (!SvIVX(sv) && (SvFLAGS(sv) & SVpad_OUR))
570 /* See if it's in a nested scope */
571 off = pad_findlex(name, 0, PL_compcv);
572 if (!off) /* pad_findlex returns 0 for failure...*/
573 return NOT_IN_PAD; /* ...but we return NOT_IN_PAD for failure */
581 =for apidoc pad_findlex
583 Find a named lexical anywhere in a chain of nested pads. Add fake entries
584 in the inner pads if it's found in an outer one. innercv is the CV *inside*
585 the chain of outer CVs to be searched. If newoff is non-null, this is a
586 run-time cloning: don't add fake entries, just find the lexical and add a
587 ref to it at newoff in the current pad.
593 S_pad_findlex(pTHX_ char *name, PADOFFSET newoff, CV* innercv)
605 ASSERT_CURPAD_ACTIVE("pad_findlex");
606 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
607 "Pad findlex: \"%s\" off=%ld startcv=0x%"UVxf"\n",
608 name, (long)newoff, PTR2UV(innercv))
611 seq = CvOUTSIDE_SEQ(innercv);
612 startcv = CvOUTSIDE(innercv);
614 for (cv = startcv; cv; seq = CvOUTSIDE_SEQ(cv), cv = CvOUTSIDE(cv)) {
619 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
620 " searching: cv=0x%"UVxf" seq=%d\n",
621 PTR2UV(cv), (int) seq )
624 curlist = CvPADLIST(cv);
626 continue; /* an undef CV */
627 svp = av_fetch(curlist, 0, FALSE);
628 if (!svp || *svp == &PL_sv_undef)
631 svp = AvARRAY(curname);
634 for (off = AvFILLp(curname); off > 0; off--) {
636 if (!sv || sv == &PL_sv_undef || !strEQ(SvPVX(sv), name))
639 /* we'll use this later if we don't find a real entry */
644 if ( seq > (U32)I_32(SvNVX(sv)) /* min */
645 && seq <= (U32)SvIVX(sv) /* max */
646 && !(newoff && !depth) /* ignore inactive when cloning */
652 /* no real entry - but did we find a fake one? */
654 if (newoff && !depth)
655 return 0; /* don't clone from inactive stack frame */
668 oldpad = (AV*)AvARRAY(curlist)[depth];
669 oldsv = *av_fetch(oldpad, off, TRUE);
673 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
674 " matched: offset %ld"
675 " FAKE, sv=0x%"UVxf"\n",
681 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
682 " matched: offset %ld"
683 " (%lu,%lu), sv=0x%"UVxf"\n",
685 (unsigned long)I_32(SvNVX(sv)),
686 (unsigned long)SvIVX(sv),
692 if (!newoff) { /* Not a mere clone operation. */
693 newoff = pad_add_name(
695 (SvFLAGS(sv) & SVpad_TYPED) ? SvSTASH(sv) : Nullhv,
696 (SvFLAGS(sv) & SVpad_OUR) ? GvSTASH(sv) : Nullhv,
700 if (CvANON(PL_compcv) || SvTYPE(PL_compcv) == SVt_PVFM) {
701 /* "It's closures all the way down." */
702 CvCLONE_on(PL_compcv);
704 if (CvANON(PL_compcv))
705 oldsv = Nullsv; /* no need to keep ref */
710 bcv && bcv != cv && !CvCLONE(bcv);
711 bcv = CvOUTSIDE(bcv))
714 /* install the missing pad entry in intervening
715 * nested subs and mark them cloneable. */
716 AV *ocomppad_name = PL_comppad_name;
717 PAD *ocomppad = PL_comppad;
718 AV *padlist = CvPADLIST(bcv);
719 PL_comppad_name = (AV*)AvARRAY(padlist)[0];
720 PL_comppad = (AV*)AvARRAY(padlist)[1];
721 PL_curpad = AvARRAY(PL_comppad);
724 (SvFLAGS(sv) & SVpad_TYPED)
725 ? SvSTASH(sv) : Nullhv,
726 (SvFLAGS(sv) & SVpad_OUR)
727 ? GvSTASH(sv) : Nullhv,
731 PL_comppad_name = ocomppad_name;
732 PL_comppad = ocomppad;
733 PL_curpad = ocomppad ?
734 AvARRAY(ocomppad) : Null(SV **);
738 if (ckWARN(WARN_CLOSURE)
739 && !CvUNIQUE(bcv) && !CvUNIQUE(cv))
741 Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
742 "Variable \"%s\" may be unavailable",
750 else if (!CvUNIQUE(PL_compcv)) {
751 if (ckWARN(WARN_CLOSURE) && !SvFAKE(sv) && !CvUNIQUE(cv)
752 && !(SvFLAGS(sv) & SVpad_OUR))
754 Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
755 "Variable \"%s\" will not stay shared", name);
759 av_store(PL_comppad, newoff, SvREFCNT_inc(oldsv));
760 ASSERT_CURPAD_ACTIVE("pad_findlex 2");
761 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
762 "Pad findlex: set offset %ld to sv 0x%"UVxf"\n",
763 (long)newoff, PTR2UV(oldsv)
773 Get the value at offset po in the current pad.
774 Use macro PAD_SV instead of calling this function directly.
781 Perl_pad_sv(pTHX_ PADOFFSET po)
783 ASSERT_CURPAD_ACTIVE("pad_sv");
786 Perl_croak(aTHX_ "panic: pad_sv po");
787 DEBUG_X(PerlIO_printf(Perl_debug_log,
788 "Pad 0x%"UVxf"[0x%"UVxf"] sv: %ld sv=0x%"UVxf"\n",
789 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po, PTR2UV(PL_curpad[po]))
791 return PL_curpad[po];
796 =for apidoc pad_setsv
798 Set the entry at offset po in the current pad to sv.
799 Use the macro PAD_SETSV() rather than calling this function directly.
806 Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv)
808 ASSERT_CURPAD_ACTIVE("pad_setsv");
810 DEBUG_X(PerlIO_printf(Perl_debug_log,
811 "Pad 0x%"UVxf"[0x%"UVxf"] setsv: %ld sv=0x%"UVxf"\n",
812 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po, PTR2UV(sv))
821 =for apidoc pad_block_start
823 Update the pad compilation state variables on entry to a new block
829 * - integrate this in general state-saving routine ???
830 * - combine with the state-saving going on in pad_new ???
831 * - introduce a new SAVE type that does all this in one go ?
835 Perl_pad_block_start(pTHX_ int full)
837 ASSERT_CURPAD_ACTIVE("pad_block_start");
838 SAVEI32(PL_comppad_name_floor);
839 PL_comppad_name_floor = AvFILLp(PL_comppad_name);
841 PL_comppad_name_fill = PL_comppad_name_floor;
842 if (PL_comppad_name_floor < 0)
843 PL_comppad_name_floor = 0;
844 SAVEI32(PL_min_intro_pending);
845 SAVEI32(PL_max_intro_pending);
846 PL_min_intro_pending = 0;
847 SAVEI32(PL_comppad_name_fill);
848 SAVEI32(PL_padix_floor);
849 PL_padix_floor = PL_padix;
850 PL_pad_reset_pending = FALSE;
857 "Introduce" my variables to visible status.
869 ASSERT_CURPAD_ACTIVE("intro_my");
870 if (! PL_min_intro_pending)
871 return PL_cop_seqmax;
873 svp = AvARRAY(PL_comppad_name);
874 for (i = PL_min_intro_pending; i <= PL_max_intro_pending; i++) {
875 if ((sv = svp[i]) && sv != &PL_sv_undef
876 && !SvFAKE(sv) && !SvIVX(sv))
878 SvIVX(sv) = PAD_MAX; /* Don't know scope end yet. */
879 SvNVX(sv) = (NV)PL_cop_seqmax;
880 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
881 "Pad intromy: %ld \"%s\", (%lu,%lu)\n",
883 (unsigned long)I_32(SvNVX(sv)), (unsigned long)SvIVX(sv))
887 PL_min_intro_pending = 0;
888 PL_comppad_name_fill = PL_max_intro_pending; /* Needn't search higher */
889 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
890 "Pad intromy: seq -> %ld\n", (long)(PL_cop_seqmax+1)));
892 return PL_cop_seqmax++;
896 =for apidoc pad_leavemy
898 Cleanup at end of scope during compilation: set the max seq number for
899 lexicals in this scope and warn of any lexicals that never got introduced.
905 Perl_pad_leavemy(pTHX)
908 SV **svp = AvARRAY(PL_comppad_name);
911 PL_pad_reset_pending = FALSE;
913 ASSERT_CURPAD_ACTIVE("pad_leavemy");
914 if (PL_min_intro_pending && PL_comppad_name_fill < PL_min_intro_pending) {
915 for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) {
916 if ((sv = svp[off]) && sv != &PL_sv_undef
917 && !SvFAKE(sv) && ckWARN_d(WARN_INTERNAL))
918 Perl_warner(aTHX_ packWARN(WARN_INTERNAL),
919 "%s never introduced", SvPVX(sv));
922 /* "Deintroduce" my variables that are leaving with this scope. */
923 for (off = AvFILLp(PL_comppad_name); off > PL_comppad_name_fill; off--) {
924 if ((sv = svp[off]) && sv != &PL_sv_undef
925 && !SvFAKE(sv) && SvIVX(sv) == PAD_MAX)
927 SvIVX(sv) = PL_cop_seqmax;
928 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
929 "Pad leavemy: %ld \"%s\", (%lu,%lu)\n",
930 (long)off, SvPVX(sv),
931 (unsigned long)I_32(SvNVX(sv)), (unsigned long)SvIVX(sv))
936 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
937 "Pad leavemy: seq = %ld\n", (long)PL_cop_seqmax));
942 =for apidoc pad_swipe
944 Abandon the tmp in the current pad at offset po and replace with a
951 Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust)
953 ASSERT_CURPAD_LEGAL("pad_swipe");
956 if (AvARRAY(PL_comppad) != PL_curpad)
957 Perl_croak(aTHX_ "panic: pad_swipe curpad");
959 Perl_croak(aTHX_ "panic: pad_swipe po");
961 DEBUG_X(PerlIO_printf(Perl_debug_log,
962 "Pad 0x%"UVxf"[0x%"UVxf"] swipe: %ld\n",
963 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po));
966 SvPADTMP_off(PL_curpad[po]);
968 SvREFCNT_dec(PL_curpad[po]);
970 PL_curpad[po] = NEWSV(1107,0);
971 SvPADTMP_on(PL_curpad[po]);
972 if ((I32)po < PL_padix)
978 =for apidoc pad_reset
980 Mark all the current temporaries for reuse
985 /* XXX pad_reset() is currently disabled because it results in serious bugs.
986 * It causes pad temp TARGs to be shared between OPs. Since TARGs are pushed
987 * on the stack by OPs that use them, there are several ways to get an alias
988 * to a shared TARG. Such an alias will change randomly and unpredictably.
989 * We avoid doing this until we can think of a Better Way.
994 #ifdef USE_BROKEN_PAD_RESET
997 if (AvARRAY(PL_comppad) != PL_curpad)
998 Perl_croak(aTHX_ "panic: pad_reset curpad");
1000 DEBUG_X(PerlIO_printf(Perl_debug_log,
1001 "Pad 0x%"UVxf"[0x%"UVxf"] reset: padix %ld -> %ld",
1002 PTR2UV(PL_comppad), PTR2UV(PL_curpad),
1003 (long)PL_padix, (long)PL_padix_floor
1007 if (!PL_tainting) { /* Can't mix tainted and non-tainted temporaries. */
1008 for (po = AvMAX(PL_comppad); po > PL_padix_floor; po--) {
1009 if (PL_curpad[po] && !SvIMMORTAL(PL_curpad[po]))
1010 SvPADTMP_off(PL_curpad[po]);
1012 PL_padix = PL_padix_floor;
1015 PL_pad_reset_pending = FALSE;
1020 =for apidoc pad_tidy
1022 Tidy up a pad after we've finished compiling it:
1023 * remove most stuff from the pads of anonsub prototypes;
1025 * mark tmps as such.
1030 /* XXX DAPM surely most of this stuff should be done properly
1031 * at the right time beforehand, rather than going around afterwards
1032 * cleaning up our mistakes ???
1036 Perl_pad_tidy(pTHX_ padtidy_type type)
1040 ASSERT_CURPAD_ACTIVE("pad_tidy");
1041 /* extend curpad to match namepad */
1042 if (AvFILLp(PL_comppad_name) < AvFILLp(PL_comppad))
1043 av_store(PL_comppad_name, AvFILLp(PL_comppad), Nullsv);
1045 if (type == padtidy_SUBCLONE) {
1046 SV **namep = AvARRAY(PL_comppad_name);
1047 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1050 if (SvIMMORTAL(PL_curpad[ix]) || IS_PADGV(PL_curpad[ix]) || IS_PADCONST(PL_curpad[ix]))
1053 * The only things that a clonable function needs in its
1054 * pad are references to outer lexicals and anonymous subs.
1055 * The rest are created anew during cloning.
1057 if (!((namesv = namep[ix]) != Nullsv &&
1058 namesv != &PL_sv_undef &&
1060 *SvPVX(namesv) == '&')))
1062 SvREFCNT_dec(PL_curpad[ix]);
1063 PL_curpad[ix] = Nullsv;
1067 else if (type == padtidy_SUB) {
1068 /* XXX DAPM this same bit of code keeps appearing !!! Rationalise? */
1069 AV *av = newAV(); /* Will be @_ */
1071 av_store(PL_comppad, 0, (SV*)av);
1072 AvFLAGS(av) = AVf_REIFY;
1075 /* XXX DAPM rationalise these two similar branches */
1077 if (type == padtidy_SUB) {
1078 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1079 if (SvIMMORTAL(PL_curpad[ix]) || IS_PADGV(PL_curpad[ix]) || IS_PADCONST(PL_curpad[ix]))
1081 if (!SvPADMY(PL_curpad[ix]))
1082 SvPADTMP_on(PL_curpad[ix]);
1085 else if (type == padtidy_FORMAT) {
1086 for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1087 if (!SvPADMY(PL_curpad[ix]) && !SvIMMORTAL(PL_curpad[ix]))
1088 SvPADTMP_on(PL_curpad[ix]);
1091 PL_curpad = AvARRAY(PL_comppad);
1096 =for apidoc pad_free
1098 Free the SV at offet po in the current pad.
1103 /* XXX DAPM integrate with pad_swipe ???? */
1105 Perl_pad_free(pTHX_ PADOFFSET po)
1107 ASSERT_CURPAD_LEGAL("pad_free");
1110 if (AvARRAY(PL_comppad) != PL_curpad)
1111 Perl_croak(aTHX_ "panic: pad_free curpad");
1113 Perl_croak(aTHX_ "panic: pad_free po");
1115 DEBUG_X(PerlIO_printf(Perl_debug_log,
1116 "Pad 0x%"UVxf"[0x%"UVxf"] free: %ld\n",
1117 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po)
1120 if (PL_curpad[po] && PL_curpad[po] != &PL_sv_undef) {
1121 SvPADTMP_off(PL_curpad[po]);
1123 /* SV could be a shared hash key (eg bugid #19022) */
1125 #ifdef PERL_COPY_ON_WRITE
1126 !SvIsCOW(PL_curpad[po])
1128 !SvFAKE(PL_curpad[po])
1131 SvREADONLY_off(PL_curpad[po]); /* could be a freed constant */
1134 if ((I32)po < PL_padix)
1141 =for apidoc do_dump_pad
1143 Dump the contents of a padlist
1149 Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full)
1161 pad_name = (AV*)*av_fetch((AV*)padlist, 0, FALSE);
1162 pad = (AV*)*av_fetch((AV*)padlist, 1, FALSE);
1163 pname = AvARRAY(pad_name);
1164 ppad = AvARRAY(pad);
1165 Perl_dump_indent(aTHX_ level, file,
1166 "PADNAME = 0x%"UVxf"(0x%"UVxf") PAD = 0x%"UVxf"(0x%"UVxf")\n",
1167 PTR2UV(pad_name), PTR2UV(pname), PTR2UV(pad), PTR2UV(ppad)
1170 for (ix = 1; ix <= AvFILLp(pad_name); ix++) {
1172 if (namesv && namesv == &PL_sv_undef) {
1177 Perl_dump_indent(aTHX_ level+1, file,
1178 "%2d. 0x%"UVxf"<%lu> FAKE \"%s\"\n",
1181 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0),
1185 Perl_dump_indent(aTHX_ level+1, file,
1186 "%2d. 0x%"UVxf"<%lu> (%lu,%lu) \"%s\"\n",
1189 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0),
1190 (unsigned long)I_32(SvNVX(namesv)),
1191 (unsigned long)SvIVX(namesv),
1196 Perl_dump_indent(aTHX_ level+1, file,
1197 "%2d. 0x%"UVxf"<%lu>\n",
1200 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0)
1211 dump the contents of a CV
1218 S_cv_dump(pTHX_ CV *cv, char *title)
1220 CV *outside = CvOUTSIDE(cv);
1221 AV* padlist = CvPADLIST(cv);
1223 PerlIO_printf(Perl_debug_log,
1224 " %s: CV=0x%"UVxf" (%s), OUTSIDE=0x%"UVxf" (%s)\n",
1227 (CvANON(cv) ? "ANON"
1228 : (cv == PL_main_cv) ? "MAIN"
1229 : CvUNIQUE(cv) ? "UNIQUE"
1230 : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"),
1233 : CvANON(outside) ? "ANON"
1234 : (outside == PL_main_cv) ? "MAIN"
1235 : CvUNIQUE(outside) ? "UNIQUE"
1236 : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
1238 PerlIO_printf(Perl_debug_log,
1239 " PADLIST = 0x%"UVxf"\n", PTR2UV(padlist));
1240 do_dump_pad(1, Perl_debug_log, padlist, 1);
1242 #endif /* DEBUGGING */
1249 =for apidoc cv_clone
1251 Clone a CV: make a new CV which points to the same code etc, but which
1252 has a newly-created pad built by copying the prototype pad and capturing
1259 Perl_cv_clone(pTHX_ CV *proto)
1263 LOCK_CRED_MUTEX; /* XXX create separate mutex */
1264 cv = cv_clone2(proto, CvOUTSIDE(proto));
1265 UNLOCK_CRED_MUTEX; /* XXX create separate mutex */
1270 /* XXX DAPM separate out cv and paddish bits ???
1271 * ideally the CV-related stuff shouldn't be in pad.c - how about
1275 S_cv_clone2(pTHX_ CV *proto, CV *outside)
1278 AV* protopadlist = CvPADLIST(proto);
1279 AV* protopad_name = (AV*)*av_fetch(protopadlist, 0, FALSE);
1280 AV* protopad = (AV*)*av_fetch(protopadlist, 1, FALSE);
1281 SV** pname = AvARRAY(protopad_name);
1282 SV** ppad = AvARRAY(protopad);
1283 I32 fname = AvFILLp(protopad_name);
1284 I32 fpad = AvFILLp(protopad);
1288 assert(!CvUNIQUE(proto));
1291 SAVESPTR(PL_compcv);
1293 cv = PL_compcv = (CV*)NEWSV(1104, 0);
1294 sv_upgrade((SV *)cv, SvTYPE(proto));
1295 CvFLAGS(cv) = CvFLAGS(proto) & ~(CVf_CLONE|CVf_WEAKOUTSIDE);
1299 CvFILE(cv) = CvXSUB(proto) ? CvFILE(proto)
1300 : savepv(CvFILE(proto));
1302 CvFILE(cv) = CvFILE(proto);
1304 CvGV(cv) = CvGV(proto);
1305 CvSTASH(cv) = CvSTASH(proto);
1306 CvROOT(cv) = OpREFCNT_inc(CvROOT(proto));
1307 CvSTART(cv) = CvSTART(proto);
1309 CvOUTSIDE(cv) = (CV*)SvREFCNT_inc(outside);
1310 CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto);
1314 sv_setpvn((SV*)cv, SvPVX(proto), SvCUR(proto));
1316 CvPADLIST(cv) = comppadlist = pad_new(padnew_CLONE|padnew_SAVE);
1318 for (ix = fname; ix >= 0; ix--)
1319 av_store(PL_comppad_name, ix, SvREFCNT_inc(pname[ix]));
1321 av_fill(PL_comppad, fpad);
1322 PL_curpad = AvARRAY(PL_comppad);
1324 for (ix = fpad; ix > 0; ix--) {
1325 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
1326 if (namesv && namesv != &PL_sv_undef) {
1327 char *name = SvPVX(namesv); /* XXX */
1328 if (SvFLAGS(namesv) & SVf_FAKE) { /* lexical from outside? */
1329 I32 off = pad_findlex(name, ix, cv);
1331 PL_curpad[ix] = SvREFCNT_inc(ppad[ix]);
1333 Perl_croak(aTHX_ "panic: cv_clone: %s", name);
1335 else { /* our own lexical */
1338 /* anon code -- we'll come back for it */
1339 sv = SvREFCNT_inc(ppad[ix]);
1341 else if (*name == '@')
1343 else if (*name == '%')
1352 else if (IS_PADGV(ppad[ix]) || IS_PADCONST(ppad[ix])) {
1353 PL_curpad[ix] = SvREFCNT_inc(ppad[ix]);
1356 SV* sv = NEWSV(0, 0);
1362 /* Now that vars are all in place, clone nested closures. */
1364 for (ix = fpad; ix > 0; ix--) {
1365 SV* namesv = (ix <= fname) ? pname[ix] : Nullsv;
1367 && namesv != &PL_sv_undef
1368 && !(SvFLAGS(namesv) & SVf_FAKE)
1369 && *SvPVX(namesv) == '&'
1370 && CvCLONE(ppad[ix]))
1372 CV *kid = cv_clone2((CV*)ppad[ix], cv);
1373 SvREFCNT_dec(ppad[ix]);
1376 PL_curpad[ix] = (SV*)kid;
1377 /* '&' entry points to child, so child mustn't refcnt parent */
1378 CvWEAKOUTSIDE_on(kid);
1384 PerlIO_printf(Perl_debug_log, "\nPad CV clone\n");
1385 cv_dump(outside, "Outside");
1386 cv_dump(proto, "Proto");
1393 SV* const_sv = op_const_sv(CvSTART(cv), cv);
1395 /* constant sub () { $x } closing over $x - see lib/constant.pm */
1397 cv = newCONSTSUB(CvSTASH(proto), 0, const_sv);
1405 =for apidoc pad_fixup_inner_anons
1407 For any anon CVs in the pad, change CvOUTSIDE of that CV from
1408 old_cv to new_cv if necessary. Needed when a newly-compiled CV has to be
1409 moved to a pre-existing CV struct.
1415 Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv)
1418 AV *comppad_name = (AV*)AvARRAY(padlist)[0];
1419 AV *comppad = (AV*)AvARRAY(padlist)[1];
1420 SV **namepad = AvARRAY(comppad_name);
1421 SV **curpad = AvARRAY(comppad);
1422 for (ix = AvFILLp(comppad_name); ix > 0; ix--) {
1423 SV *namesv = namepad[ix];
1424 if (namesv && namesv != &PL_sv_undef
1425 && *SvPVX(namesv) == '&')
1427 CV *innercv = (CV*)curpad[ix];
1428 assert(CvWEAKOUTSIDE(innercv));
1429 assert(CvOUTSIDE(innercv) == old_cv);
1430 CvOUTSIDE(innercv) = new_cv;
1437 =for apidoc pad_push
1439 Push a new pad frame onto the padlist, unless there's already a pad at
1440 this depth, in which case don't bother creating a new one.
1441 If has_args is true, give the new pad an @_ in slot zero.
1447 Perl_pad_push(pTHX_ PADLIST *padlist, int depth, int has_args)
1449 if (depth <= AvFILLp(padlist))
1453 SV** svp = AvARRAY(padlist);
1454 AV *newpad = newAV();
1455 SV **oldpad = AvARRAY(svp[depth-1]);
1456 I32 ix = AvFILLp((AV*)svp[1]);
1457 I32 names_fill = AvFILLp((AV*)svp[0]);
1458 SV** names = AvARRAY(svp[0]);
1460 for ( ;ix > 0; ix--) {
1461 if (names_fill >= ix && names[ix] != &PL_sv_undef) {
1462 char *name = SvPVX(names[ix]);
1463 if ((SvFLAGS(names[ix]) & SVf_FAKE) || *name == '&') {
1464 /* outer lexical or anon code */
1465 av_store(newpad, ix, SvREFCNT_inc(oldpad[ix]));
1467 else { /* our own lexical */
1469 av_store(newpad, ix, sv = (SV*)newAV());
1470 else if (*name == '%')
1471 av_store(newpad, ix, sv = (SV*)newHV());
1473 av_store(newpad, ix, sv = NEWSV(0, 0));
1477 else if (IS_PADGV(oldpad[ix]) || IS_PADCONST(oldpad[ix])) {
1478 av_store(newpad, ix, sv = SvREFCNT_inc(oldpad[ix]));
1481 /* save temporaries on recursion? */
1482 av_store(newpad, ix, sv = NEWSV(0, 0));
1489 av_store(newpad, 0, (SV*)av);
1490 AvFLAGS(av) = AVf_REIFY;
1492 av_store(padlist, depth, (SV*)newpad);
1493 AvFILLp(padlist) = depth;