[MERGE] t/TEST -deparse fixups
[perl.git] / pad.c
1 /*    pad.c
2  *
3  *    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
4  *    by Larry Wall and others
5  *
6  *    You may distribute under the terms of either the GNU General Public
7  *    License or the Artistic License, as specified in the README file.
8  */
9
10 /*
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
17  *
18  *     [p.23 of _The Lord of the Rings_, I/i: "A Long-Expected Party"]
19  */
20
21 /*
22 =head1 Pad Data Structures
23
24 =for apidoc Amx|PADLIST *|CvPADLIST|CV *cv
25
26 CV's can have CvPADLIST(cv) set to point to a PADLIST.  This is the CV's
27 scratchpad, which stores lexical variables and opcode temporary and
28 per-thread values.
29
30 For these purposes "formats" are a kind-of CV; eval""s are too (except they're
31 not callable at will and are always thrown away after the eval"" is done
32 executing).  Require'd files are simply evals without any outer lexical
33 scope.
34
35 XSUBs do not have a C<CvPADLIST>.  C<dXSTARG> fetches values from C<PL_curpad>,
36 but that is really the callers pad (a slot of which is allocated by
37 every entersub). Do not get or set C<CvPADLIST> if a CV is an XSUB (as
38 determined by C<CvISXSUB()>), C<CvPADLIST> slot is reused for a different
39 internal purpose in XSUBs.
40
41 The PADLIST has a C array where pads are stored.
42
43 The 0th entry of the PADLIST is a PADNAMELIST
44 which represents the "names" or rather
45 the "static type information" for lexicals.  The individual elements of a
46 PADNAMELIST are PADNAMEs.  Future
47 refactorings might stop the PADNAMELIST from being stored in the PADLIST's
48 array, so don't rely on it.  See L</PadlistNAMES>.
49
50 The CvDEPTH'th entry of a PADLIST is a PAD (an AV) which is the stack frame
51 at that depth of recursion into the CV.  The 0th slot of a frame AV is an
52 AV which is C<@_>.  Other entries are storage for variables and op targets.
53
54 Iterating over the PADNAMELIST iterates over all possible pad
55 items.  Pad slots for targets (C<SVs_PADTMP>)
56 and GVs end up having &PL_padname_undef "names", while slots for constants 
57 have C<&PL_padname_const> "names" (see C<L</pad_alloc>>).  That
58 C<&PL_padname_undef>
59 and C<&PL_padname_const> are used is an implementation detail subject to
60 change.  To test for them, use C<!PadnamePV(name)> and
61 S<C<PadnamePV(name) && !PadnameLEN(name)>>, respectively.
62
63 Only C<my>/C<our> variable slots get valid names.
64 The rest are op targets/GVs/constants which are statically allocated
65 or resolved at compile time.  These don't have names by which they
66 can be looked up from Perl code at run time through eval"" the way
67 C<my>/C<our> variables can be.  Since they can't be looked up by "name"
68 but only by their index allocated at compile time (which is usually
69 in C<PL_op->op_targ>), wasting a name SV for them doesn't make sense.
70
71 The pad names in the PADNAMELIST have their PV holding the name of
72 the variable.  The C<COP_SEQ_RANGE_LOW> and C<_HIGH> fields form a range
73 (low+1..high inclusive) of cop_seq numbers for which the name is
74 valid.  During compilation, these fields may hold the special value
75 PERL_PADSEQ_INTRO to indicate various stages:
76
77  COP_SEQ_RANGE_LOW        _HIGH
78  -----------------        -----
79  PERL_PADSEQ_INTRO            0   variable not yet introduced:
80                                   { my ($x
81  valid-seq#   PERL_PADSEQ_INTRO   variable in scope:
82                                   { my ($x);
83  valid-seq#          valid-seq#   compilation of scope complete:
84                                   { my ($x); .... }
85
86 When a lexical var hasn't yet been introduced, it already exists from the
87 perspective of duplicate declarations, but not for variable lookups, e.g.
88
89     my ($x, $x); # '"my" variable $x masks earlier declaration'
90     my $x = $x;  # equal to my $x = $::x;
91
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
96 compilation.
97
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
106 cloning quicker.
107
108 If the 'name' is C<&> the corresponding entry in the PAD
109 is a CV representing a possible closure.
110
111 Note that formats are treated as anon subs, and are cloned each time
112 write is called (if necessary).
113
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 
118
119     { my $x = 1; sub f { eval '$x'} } f();
120
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.
123
124 =for apidoc AmxU|PADNAMELIST *|PL_comppad_name
125
126 During compilation, this points to the array containing the names part
127 of the pad for the currently-compiling code.
128
129 =for apidoc AmxU|PAD *|PL_comppad
130
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.
136
137 =for apidoc AmxU|SV **|PL_curpad
138
139 Points directly to the body of the L</PL_comppad> array.
140 (I.e., this is C<PAD_ARRAY(PL_comppad)>.)
141
142 =cut
143 */
144
145
146 #include "EXTERN.h"
147 #define PERL_IN_PAD_C
148 #include "perl.h"
149 #include "keywords.h"
150
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
155
156 #define PARENT_PAD_INDEX_set            COP_SEQ_RANGE_LOW_set
157 #define PARENT_FAKELEX_FLAGS_set        COP_SEQ_RANGE_HIGH_set
158
159 #ifdef DEBUGGING
160 void
161 Perl_set_padlist(CV * cv, PADLIST *padlist){
162     PERL_ARGS_ASSERT_SET_PADLIST;
163 #  if PTRSIZE == 8
164     assert((Size_t)padlist != UINT64_C(0xEFEFEFEFEFEFEFEF));
165 #  elif PTRSIZE == 4
166     assert((Size_t)padlist != 0xEFEFEFEF);
167 #  else
168 #    error unknown pointer size
169 #  endif
170     assert(!CvISXSUB(cv));
171     ((XPVCV*)MUTABLE_PTR(SvANY(cv)))->xcv_padlist_u.xcv_padlist = padlist;
172 }
173 #endif
174
175 /*
176 =for apidoc Am|PADLIST *|pad_new|int flags
177
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:
181
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
185
186 =cut
187 */
188
189 PADLIST *
190 Perl_pad_new(pTHX_ int flags)
191 {
192     PADLIST *padlist;
193     PADNAMELIST *padname;
194     PAD *pad;
195     PAD **ary;
196
197     ASSERT_CURPAD_LEGAL("pad_new");
198
199     /* save existing state, ... */
200
201     if (flags & padnew_SAVE) {
202         SAVECOMPPAD();
203         if (! (flags & padnew_CLONE)) {
204             SAVESPTR(PL_comppad_name);
205             save_strlen((STRLEN *)&PL_padix);
206             save_strlen((STRLEN *)&PL_constpadix);
207             save_strlen((STRLEN *)&PL_comppad_name_fill);
208             save_strlen((STRLEN *)&PL_min_intro_pending);
209             save_strlen((STRLEN *)&PL_max_intro_pending);
210             SAVEBOOL(PL_cv_has_eval);
211             if (flags & padnew_SAVESUB) {
212                 SAVEBOOL(PL_pad_reset_pending);
213             }
214         }
215     }
216
217     /* ... create new pad ... */
218
219     Newxz(padlist, 1, PADLIST);
220     pad         = newAV();
221
222     if (flags & padnew_CLONE) {
223         AV * const a0 = newAV();                        /* will be @_ */
224         av_store(pad, 0, MUTABLE_SV(a0));
225         AvREIFY_only(a0);
226
227         PadnamelistREFCNT(padname = PL_comppad_name)++;
228     }
229     else {
230         padlist->xpadl_id = PL_padlist_generation++;
231         av_store(pad, 0, NULL);
232         padname = newPADNAMELIST(0);
233         padnamelist_store(padname, 0, &PL_padname_undef);
234     }
235
236     /* Most subroutines never recurse, hence only need 2 entries in the padlist
237        array - names, and depth=1.  The default for av_store() is to allocate
238        0..3, and even an explicit call to av_extend() with <3 will be rounded
239        up, so we inline the allocation of the array here.  */
240     Newx(ary, 2, PAD *);
241     PadlistMAX(padlist) = 1;
242     PadlistARRAY(padlist) = ary;
243     ary[0] = (PAD *)padname;
244     ary[1] = pad;
245
246     /* ... then update state variables */
247
248     PL_comppad          = pad;
249     PL_curpad           = AvARRAY(pad);
250
251     if (! (flags & padnew_CLONE)) {
252         PL_comppad_name      = padname;
253         PL_comppad_name_fill = 0;
254         PL_min_intro_pending = 0;
255         PL_padix             = 0;
256         PL_constpadix        = 0;
257         PL_cv_has_eval       = 0;
258     }
259
260     DEBUG_X(PerlIO_printf(Perl_debug_log,
261           "Pad 0x%" UVxf "[0x%" UVxf "] new:       compcv=0x%" UVxf
262               " name=0x%" UVxf " flags=0x%" UVxf "\n",
263           PTR2UV(PL_comppad), PTR2UV(PL_curpad), PTR2UV(PL_compcv),
264               PTR2UV(padname), (UV)flags
265         )
266     );
267
268     return (PADLIST*)padlist;
269 }
270
271
272 /*
273 =head1 Embedding Functions
274
275 =for apidoc cv_undef
276
277 Clear out all the active components of a CV.  This can happen either
278 by an explicit C<undef &foo>, or by the reference count going to zero.
279 In the former case, we keep the C<CvOUTSIDE> pointer, so that any anonymous
280 children can still follow the full lexical scope chain.
281
282 =cut
283 */
284
285 void
286 Perl_cv_undef(pTHX_ CV *cv)
287 {
288     PERL_ARGS_ASSERT_CV_UNDEF;
289     cv_undef_flags(cv, 0);
290 }
291
292 void
293 Perl_cv_undef_flags(pTHX_ CV *cv, U32 flags)
294 {
295     CV cvbody;/*CV body will never be realloced inside this func,
296                so dont read it more than once, use fake CV so existing macros
297                will work, the indirection and CV head struct optimized away*/
298     SvANY(&cvbody) = SvANY(cv);
299
300     PERL_ARGS_ASSERT_CV_UNDEF_FLAGS;
301
302     DEBUG_X(PerlIO_printf(Perl_debug_log,
303           "CV undef: cv=0x%" UVxf " comppad=0x%" UVxf "\n",
304             PTR2UV(cv), PTR2UV(PL_comppad))
305     );
306
307     if (CvFILE(&cvbody)) {
308         char * file = CvFILE(&cvbody);
309         CvFILE(&cvbody) = NULL;
310         if(CvDYNFILE(&cvbody))
311             Safefree(file);
312     }
313
314     /* CvSLABBED_off(&cvbody); *//* turned off below */
315     /* release the sub's body */
316     if (!CvISXSUB(&cvbody)) {
317         if(CvROOT(&cvbody)) {
318             assert(SvTYPE(cv) == SVt_PVCV || SvTYPE(cv) == SVt_PVFM); /*unsafe is safe */
319             if (CvDEPTHunsafe(&cvbody)) {
320                 assert(SvTYPE(cv) == SVt_PVCV);
321                 Perl_croak_nocontext("Can't undef active subroutine");
322             }
323             ENTER;
324
325             PAD_SAVE_SETNULLPAD();
326
327             if (CvSLABBED(&cvbody)) OpslabREFCNT_dec_padok(OpSLAB(CvROOT(&cvbody)));
328             op_free(CvROOT(&cvbody));
329             CvROOT(&cvbody) = NULL;
330             CvSTART(&cvbody) = NULL;
331             LEAVE;
332         }
333         else if (CvSLABBED(&cvbody)) {
334             if( CvSTART(&cvbody)) {
335                 ENTER;
336                 PAD_SAVE_SETNULLPAD();
337
338                 /* discard any leaked ops */
339                 if (PL_parser)
340                     parser_free_nexttoke_ops(PL_parser, (OPSLAB *)CvSTART(&cvbody));
341                 opslab_force_free((OPSLAB *)CvSTART(&cvbody));
342                 CvSTART(&cvbody) = NULL;
343
344                 LEAVE;
345             }
346 #ifdef DEBUGGING
347             else Perl_warn(aTHX_ "Slab leaked from cv %p", (void*)cv);
348 #endif
349         }
350     }
351     else { /* dont bother checking if CvXSUB(cv) is true, less branching */
352         CvXSUB(&cvbody) = NULL;
353     }
354     SvPOK_off(MUTABLE_SV(cv));          /* forget prototype */
355     sv_unmagic((SV *)cv, PERL_MAGIC_checkcall);
356     if (!(flags & CV_UNDEF_KEEP_NAME)) {
357         if (CvNAMED(&cvbody)) {
358             CvNAME_HEK_set(&cvbody, NULL);
359             CvNAMED_off(&cvbody);
360         }
361         else CvGV_set(cv, NULL);
362     }
363
364     /* This statement and the subsequence if block was pad_undef().  */
365     pad_peg("pad_undef");
366
367     if (!CvISXSUB(&cvbody) && CvPADLIST(&cvbody)) {
368         PADOFFSET ix;
369         const PADLIST *padlist = CvPADLIST(&cvbody);
370
371         /* Free the padlist associated with a CV.
372            If parts of it happen to be current, we null the relevant PL_*pad*
373            global vars so that we don't have any dangling references left.
374            We also repoint the CvOUTSIDE of any about-to-be-orphaned inner
375            subs to the outer of this cv.  */
376
377         DEBUG_X(PerlIO_printf(Perl_debug_log,
378                               "Pad undef: cv=0x%" UVxf " padlist=0x%" UVxf " comppad=0x%" UVxf "\n",
379                               PTR2UV(cv), PTR2UV(padlist), PTR2UV(PL_comppad))
380                 );
381
382         /* detach any '&' anon children in the pad; if afterwards they
383          * are still live, fix up their CvOUTSIDEs to point to our outside,
384          * bypassing us. */
385
386         if (PL_phase != PERL_PHASE_DESTRUCT) { /* don't bother during global destruction */
387             CV * const outercv = CvOUTSIDE(&cvbody);
388             const U32 seq = CvOUTSIDE_SEQ(&cvbody);
389             PADNAMELIST * const comppad_name = PadlistNAMES(padlist);
390             PADNAME ** const namepad = PadnamelistARRAY(comppad_name);
391             PAD * const comppad = PadlistARRAY(padlist)[1];
392             SV ** const curpad = AvARRAY(comppad);
393             for (ix = PadnamelistMAX(comppad_name); ix > 0; ix--) {
394                 PADNAME * const name = namepad[ix];
395                 if (name && PadnamePV(name) && *PadnamePV(name) == '&')
396                     {
397                         CV * const innercv = MUTABLE_CV(curpad[ix]);
398                         U32 inner_rc = SvREFCNT(innercv);
399                         assert(inner_rc);
400                         assert(SvTYPE(innercv) != SVt_PVFM);
401
402                         if (SvREFCNT(comppad) < 2) { /* allow for /(?{ sub{} })/  */
403                             curpad[ix] = NULL;
404                             SvREFCNT_dec_NN(innercv);
405                             inner_rc--;
406                         }
407
408                         /* in use, not just a prototype */
409                         if (inner_rc && SvTYPE(innercv) == SVt_PVCV
410                          && (CvOUTSIDE(innercv) == cv))
411                         {
412                             assert(CvWEAKOUTSIDE(innercv));
413                             /* don't relink to grandfather if he's being freed */
414                             if (outercv && SvREFCNT(outercv)) {
415                                 CvWEAKOUTSIDE_off(innercv);
416                                 CvOUTSIDE(innercv) = outercv;
417                                 CvOUTSIDE_SEQ(innercv) = seq;
418                                 SvREFCNT_inc_simple_void_NN(outercv);
419                             }
420                             else {
421                                 CvOUTSIDE(innercv) = NULL;
422                             }
423                         }
424                     }
425             }
426         }
427
428         ix = PadlistMAX(padlist);
429         while (ix > 0) {
430             PAD * const sv = PadlistARRAY(padlist)[ix--];
431             if (sv) {
432                 if (sv == PL_comppad) {
433                     PL_comppad = NULL;
434                     PL_curpad = NULL;
435                 }
436                 SvREFCNT_dec_NN(sv);
437             }
438         }
439         {
440             PADNAMELIST * const names = PadlistNAMES(padlist);
441             if (names == PL_comppad_name && PadnamelistREFCNT(names) == 1)
442                 PL_comppad_name = NULL;
443             PadnamelistREFCNT_dec(names);
444         }
445         if (PadlistARRAY(padlist)) Safefree(PadlistARRAY(padlist));
446         Safefree(padlist);
447         CvPADLIST_set(&cvbody, NULL);
448     }
449     else if (CvISXSUB(&cvbody))
450         CvHSCXT(&cvbody) = NULL;
451     /* else is (!CvISXSUB(&cvbody) && !CvPADLIST(&cvbody)) {do nothing;} */
452
453
454     /* remove CvOUTSIDE unless this is an undef rather than a free */
455     if (!SvREFCNT(cv)) {
456         CV * outside = CvOUTSIDE(&cvbody);
457         if(outside) {
458             CvOUTSIDE(&cvbody) = NULL;
459             if (!CvWEAKOUTSIDE(&cvbody))
460                 SvREFCNT_dec_NN(outside);
461         }
462     }
463     if (CvCONST(&cvbody)) {
464         SvREFCNT_dec(MUTABLE_SV(CvXSUBANY(&cvbody).any_ptr));
465         /* CvCONST_off(cv); *//* turned off below */
466     }
467     /* delete all flags except WEAKOUTSIDE and CVGV_RC, which indicate the
468      * ref status of CvOUTSIDE and CvGV, and ANON, NAMED and
469      * LEXICAL, which are used to determine the sub's name.  */
470     CvFLAGS(&cvbody) &= (CVf_WEAKOUTSIDE|CVf_CVGV_RC|CVf_ANON|CVf_LEXICAL
471                    |CVf_NAMED);
472 }
473
474 /*
475 =for apidoc cv_forget_slab
476
477 When a CV has a reference count on its slab (C<CvSLABBED>), it is responsible
478 for making sure it is freed.  (Hence, no two CVs should ever have a
479 reference count on the same slab.)  The CV only needs to reference the slab
480 during compilation.  Once it is compiled and C<CvROOT> attached, it has
481 finished its job, so it can forget the slab.
482
483 =cut
484 */
485
486 void
487 Perl_cv_forget_slab(pTHX_ CV *cv)
488 {
489     bool slabbed;
490     OPSLAB *slab = NULL;
491
492     if (!cv)
493         return;
494     slabbed = cBOOL(CvSLABBED(cv));
495     if (!slabbed) return;
496
497     CvSLABBED_off(cv);
498
499     if      (CvROOT(cv))  slab = OpSLAB(CvROOT(cv));
500     else if (CvSTART(cv)) slab = (OPSLAB *)CvSTART(cv);
501 #ifdef DEBUGGING
502     else if (slabbed)     Perl_warn(aTHX_ "Slab leaked from cv %p", (void*)cv);
503 #endif
504
505     if (slab) {
506 #ifdef PERL_DEBUG_READONLY_OPS
507         const size_t refcnt = slab->opslab_refcnt;
508 #endif
509         OpslabREFCNT_dec(slab);
510 #ifdef PERL_DEBUG_READONLY_OPS
511         if (refcnt > 1) Slab_to_ro(slab);
512 #endif
513     }
514 }
515
516 /*
517 =for apidoc m|PADOFFSET|pad_alloc_name|PADNAME *name|U32 flags|HV *typestash|HV *ourstash
518
519 Allocates a place in the currently-compiling
520 pad (via L<perlapi/pad_alloc>) and
521 then stores a name for that entry.  C<name> is adopted and
522 becomes the name entry; it must already contain the name
523 string.  C<typestash> and C<ourstash> and the C<padadd_STATE>
524 flag get added to C<name>.  None of the other
525 processing of L<perlapi/pad_add_name_pvn>
526 is done.  Returns the offset of the allocated pad slot.
527
528 =cut
529 */
530
531 static PADOFFSET
532 S_pad_alloc_name(pTHX_ PADNAME *name, U32 flags, HV *typestash,
533                        HV *ourstash)
534 {
535     const PADOFFSET offset = pad_alloc(OP_PADSV, SVs_PADMY);
536
537     PERL_ARGS_ASSERT_PAD_ALLOC_NAME;
538
539     ASSERT_CURPAD_ACTIVE("pad_alloc_name");
540
541     if (typestash) {
542         SvPAD_TYPED_on(name);
543         PadnameTYPE(name) =
544             MUTABLE_HV(SvREFCNT_inc_simple_NN(MUTABLE_SV(typestash)));
545     }
546     if (ourstash) {
547         SvPAD_OUR_on(name);
548         SvOURSTASH_set(name, ourstash);
549         SvREFCNT_inc_simple_void_NN(ourstash);
550     }
551     else if (flags & padadd_STATE) {
552         SvPAD_STATE_on(name);
553     }
554
555     padnamelist_store(PL_comppad_name, offset, name);
556     if (PadnameLEN(name) > 1)
557         PadnamelistMAXNAMED(PL_comppad_name) = offset;
558     return offset;
559 }
560
561 /*
562 =for apidoc Am|PADOFFSET|pad_add_name_pvn|const char *namepv|STRLEN namelen|U32 flags|HV *typestash|HV *ourstash
563
564 Allocates a place in the currently-compiling pad for a named lexical
565 variable.  Stores the name and other metadata in the name part of the
566 pad, and makes preparations to manage the variable's lexical scoping.
567 Returns the offset of the allocated pad slot.
568
569 C<namepv>/C<namelen> specify the variable's name, including leading sigil.
570 If C<typestash> is non-null, the name is for a typed lexical, and this
571 identifies the type.  If C<ourstash> is non-null, it's a lexical reference
572 to a package variable, and this identifies the package.  The following
573 flags can be OR'ed together:
574
575  padadd_OUR          redundantly specifies if it's a package var
576  padadd_STATE        variable will retain value persistently
577  padadd_NO_DUP_CHECK skip check for lexical shadowing
578
579 =cut
580 */
581
582 PADOFFSET
583 Perl_pad_add_name_pvn(pTHX_ const char *namepv, STRLEN namelen,
584                 U32 flags, HV *typestash, HV *ourstash)
585 {
586     PADOFFSET offset;
587     PADNAME *name;
588
589     PERL_ARGS_ASSERT_PAD_ADD_NAME_PVN;
590
591     if (flags & ~(padadd_OUR|padadd_STATE|padadd_NO_DUP_CHECK))
592         Perl_croak(aTHX_ "panic: pad_add_name_pvn illegal flag bits 0x%" UVxf,
593                    (UV)flags);
594
595     name = newPADNAMEpvn(namepv, namelen);
596
597     if ((flags & padadd_NO_DUP_CHECK) == 0) {
598         ENTER;
599         SAVEFREEPADNAME(name); /* in case of fatal warnings */
600         /* check for duplicate declaration */
601         pad_check_dup(name, flags & padadd_OUR, ourstash);
602         PadnameREFCNT(name)++;
603         LEAVE;
604     }
605
606     offset = pad_alloc_name(name, flags, typestash, ourstash);
607
608     /* not yet introduced */
609     COP_SEQ_RANGE_LOW_set(name, PERL_PADSEQ_INTRO);
610     COP_SEQ_RANGE_HIGH_set(name, 0);
611
612     if (!PL_min_intro_pending)
613         PL_min_intro_pending = offset;
614     PL_max_intro_pending = offset;
615     /* if it's not a simple scalar, replace with an AV or HV */
616     assert(SvTYPE(PL_curpad[offset]) == SVt_NULL);
617     assert(SvREFCNT(PL_curpad[offset]) == 1);
618     if (namelen != 0 && *namepv == '@')
619         sv_upgrade(PL_curpad[offset], SVt_PVAV);
620     else if (namelen != 0 && *namepv == '%')
621         sv_upgrade(PL_curpad[offset], SVt_PVHV);
622     else if (namelen != 0 && *namepv == '&')
623         sv_upgrade(PL_curpad[offset], SVt_PVCV);
624     assert(SvPADMY(PL_curpad[offset]));
625     DEBUG_Xv(PerlIO_printf(Perl_debug_log,
626                            "Pad addname: %ld \"%s\" new lex=0x%" UVxf "\n",
627                            (long)offset, PadnamePV(name),
628                            PTR2UV(PL_curpad[offset])));
629
630     return offset;
631 }
632
633 /*
634 =for apidoc Am|PADOFFSET|pad_add_name_pv|const char *name|U32 flags|HV *typestash|HV *ourstash
635
636 Exactly like L</pad_add_name_pvn>, but takes a nul-terminated string
637 instead of a string/length pair.
638
639 =cut
640 */
641
642 PADOFFSET
643 Perl_pad_add_name_pv(pTHX_ const char *name,
644                      const U32 flags, HV *typestash, HV *ourstash)
645 {
646     PERL_ARGS_ASSERT_PAD_ADD_NAME_PV;
647     return pad_add_name_pvn(name, strlen(name), flags, typestash, ourstash);
648 }
649
650 /*
651 =for apidoc Am|PADOFFSET|pad_add_name_sv|SV *name|U32 flags|HV *typestash|HV *ourstash
652
653 Exactly like L</pad_add_name_pvn>, but takes the name string in the form
654 of an SV instead of a string/length pair.
655
656 =cut
657 */
658
659 PADOFFSET
660 Perl_pad_add_name_sv(pTHX_ SV *name, U32 flags, HV *typestash, HV *ourstash)
661 {
662     char *namepv;
663     STRLEN namelen;
664     PERL_ARGS_ASSERT_PAD_ADD_NAME_SV;
665     namepv = SvPVutf8(name, namelen);
666     return pad_add_name_pvn(namepv, namelen, flags, typestash, ourstash);
667 }
668
669 /*
670 =for apidoc Amx|PADOFFSET|pad_alloc|I32 optype|U32 tmptype
671
672 Allocates a place in the currently-compiling pad,
673 returning the offset of the allocated pad slot.
674 No name is initially attached to the pad slot.
675 C<tmptype> is a set of flags indicating the kind of pad entry required,
676 which will be set in the value SV for the allocated pad entry:
677
678     SVs_PADMY    named lexical variable ("my", "our", "state")
679     SVs_PADTMP   unnamed temporary store
680     SVf_READONLY constant shared between recursion levels
681
682 C<SVf_READONLY> has been supported here only since perl 5.20.  To work with
683 earlier versions as well, use C<SVf_READONLY|SVs_PADTMP>.  C<SVf_READONLY>
684 does not cause the SV in the pad slot to be marked read-only, but simply
685 tells C<pad_alloc> that it I<will> be made read-only (by the caller), or at
686 least should be treated as such.
687
688 C<optype> should be an opcode indicating the type of operation that the
689 pad entry is to support.  This doesn't affect operational semantics,
690 but is used for debugging.
691
692 =cut
693 */
694
695 PADOFFSET
696 Perl_pad_alloc(pTHX_ I32 optype, U32 tmptype)
697 {
698     SV *sv;
699     PADOFFSET retval;
700
701     PERL_UNUSED_ARG(optype);
702     ASSERT_CURPAD_ACTIVE("pad_alloc");
703
704     if (AvARRAY(PL_comppad) != PL_curpad)
705         Perl_croak(aTHX_ "panic: pad_alloc, %p!=%p",
706                    AvARRAY(PL_comppad), PL_curpad);
707     if (PL_pad_reset_pending)
708         pad_reset();
709     if (tmptype == SVs_PADMY) { /* Not & because this ‘flag’ is 0.  */
710         /* For a my, simply push a null SV onto the end of PL_comppad. */
711         sv = *av_fetch(PL_comppad, AvFILLp(PL_comppad) + 1, TRUE);
712         retval = (PADOFFSET)AvFILLp(PL_comppad);
713     }
714     else {
715         /* For a tmp, scan the pad from PL_padix upwards
716          * for a slot which has no name and no active value.
717          * For a constant, likewise, but use PL_constpadix.
718          */
719         PADNAME * const * const names = PadnamelistARRAY(PL_comppad_name);
720         const SSize_t names_fill = PadnamelistMAX(PL_comppad_name);
721         const bool konst = cBOOL(tmptype & SVf_READONLY);
722         retval = konst ? PL_constpadix : PL_padix;
723         for (;;) {
724             /*
725              * Entries that close over unavailable variables
726              * in outer subs contain values not marked PADMY.
727              * Thus we must skip, not just pad values that are
728              * marked as current pad values, but also those with names.
729              * If pad_reset is enabled, ‘current’ means different
730              * things depending on whether we are allocating a con-
731              * stant or a target.  For a target, things marked PADTMP
732              * can be reused; not so for constants.
733              */
734             PADNAME *pn;
735             if (++retval <= names_fill &&
736                    (pn = names[retval]) && PadnamePV(pn))
737                 continue;
738             sv = *av_fetch(PL_comppad, retval, TRUE);
739             if (!(SvFLAGS(sv) &
740 #ifdef USE_PAD_RESET
741                     (konst ? SVs_PADTMP : 0)
742 #else
743                     SVs_PADTMP
744 #endif
745                  ))
746                 break;
747         }
748         if (konst) {
749             padnamelist_store(PL_comppad_name, retval, &PL_padname_const);
750             tmptype &= ~SVf_READONLY;
751             tmptype |= SVs_PADTMP;
752         }
753         *(konst ? &PL_constpadix : &PL_padix) = retval;
754     }
755     SvFLAGS(sv) |= tmptype;
756     PL_curpad = AvARRAY(PL_comppad);
757
758     DEBUG_X(PerlIO_printf(Perl_debug_log,
759           "Pad 0x%" UVxf "[0x%" UVxf "] alloc:   %ld for %s\n",
760           PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long) retval,
761           PL_op_name[optype]));
762 #ifdef DEBUG_LEAKING_SCALARS
763     sv->sv_debug_optype = optype;
764     sv->sv_debug_inpad = 1;
765 #endif
766     return retval;
767 }
768
769 /*
770 =for apidoc Am|PADOFFSET|pad_add_anon|CV *func|I32 optype
771
772 Allocates a place in the currently-compiling pad (via L</pad_alloc>)
773 for an anonymous function that is lexically scoped inside the
774 currently-compiling function.
775 The function C<func> is linked into the pad, and its C<CvOUTSIDE> link
776 to the outer scope is weakened to avoid a reference loop.
777
778 One reference count is stolen, so you may need to do C<SvREFCNT_inc(func)>.
779
780 C<optype> should be an opcode indicating the type of operation that the
781 pad entry is to support.  This doesn't affect operational semantics,
782 but is used for debugging.
783
784 =cut
785 */
786
787 PADOFFSET
788 Perl_pad_add_anon(pTHX_ CV* func, I32 optype)
789 {
790     PADOFFSET ix;
791     PADNAME * const name = newPADNAMEpvn("&", 1);
792
793     PERL_ARGS_ASSERT_PAD_ADD_ANON;
794     assert (SvTYPE(func) == SVt_PVCV);
795
796     pad_peg("add_anon");
797     /* These two aren't used; just make sure they're not equal to
798      * PERL_PADSEQ_INTRO.  They should be 0 by default.  */
799     assert(COP_SEQ_RANGE_LOW (name) != PERL_PADSEQ_INTRO);
800     assert(COP_SEQ_RANGE_HIGH(name) != PERL_PADSEQ_INTRO);
801     ix = pad_alloc(optype, SVs_PADMY);
802     padnamelist_store(PL_comppad_name, ix, name);
803     av_store(PL_comppad, ix, (SV*)func);
804
805     /* to avoid ref loops, we never have parent + child referencing each
806      * other simultaneously */
807     if (CvOUTSIDE(func)) {
808         assert(!CvWEAKOUTSIDE(func));
809         CvWEAKOUTSIDE_on(func);
810         SvREFCNT_dec_NN(CvOUTSIDE(func));
811     }
812     return ix;
813 }
814
815 void
816 Perl_pad_add_weakref(pTHX_ CV* func)
817 {
818     const PADOFFSET ix = pad_alloc(OP_NULL, SVs_PADMY);
819     PADNAME * const name = newPADNAMEpvn("&", 1);
820     SV * const rv = newRV_inc((SV *)func);
821
822     PERL_ARGS_ASSERT_PAD_ADD_WEAKREF;
823
824     /* These two aren't used; just make sure they're not equal to
825      * PERL_PADSEQ_INTRO.  They should be 0 by default.  */
826     assert(COP_SEQ_RANGE_LOW (name) != PERL_PADSEQ_INTRO);
827     assert(COP_SEQ_RANGE_HIGH(name) != PERL_PADSEQ_INTRO);
828     padnamelist_store(PL_comppad_name, ix, name);
829     sv_rvweaken(rv);
830     av_store(PL_comppad, ix, rv);
831 }
832
833 /*
834 =for apidoc pad_check_dup
835
836 Check for duplicate declarations: report any of:
837
838      * a 'my' in the current scope with the same name;
839      * an 'our' (anywhere in the pad) with the same name and the
840        same stash as 'ourstash'
841
842 C<is_our> indicates that the name to check is an C<"our"> declaration.
843
844 =cut
845 */
846
847 STATIC void
848 S_pad_check_dup(pTHX_ PADNAME *name, U32 flags, const HV *ourstash)
849 {
850     PADNAME     **svp;
851     PADOFFSET   top, off;
852     const U32   is_our = flags & padadd_OUR;
853
854     PERL_ARGS_ASSERT_PAD_CHECK_DUP;
855
856     ASSERT_CURPAD_ACTIVE("pad_check_dup");
857
858     assert((flags & ~padadd_OUR) == 0);
859
860     if (PadnamelistMAX(PL_comppad_name) < 0 || !ckWARN(WARN_MISC))
861         return; /* nothing to check */
862
863     svp = PadnamelistARRAY(PL_comppad_name);
864     top = PadnamelistMAX(PL_comppad_name);
865     /* check the current scope */
866     for (off = top; off > PL_comppad_name_floor; off--) {
867         PADNAME * const sv = svp[off];
868         if (sv
869             && PadnameLEN(sv) == PadnameLEN(name)
870             && !PadnameOUTER(sv)
871             && (   COP_SEQ_RANGE_LOW(sv)  == PERL_PADSEQ_INTRO
872                 || COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO)
873             && memEQ(PadnamePV(sv), PadnamePV(name), PadnameLEN(name)))
874         {
875             if (is_our && (SvPAD_OUR(sv)))
876                 break; /* "our" masking "our" */
877             /* diag_listed_as: "%s" variable %s masks earlier declaration in same %s */
878             Perl_warner(aTHX_ packWARN(WARN_MISC),
879                 "\"%s\" %s %" PNf " masks earlier declaration in same %s",
880                 (   is_our                         ? "our"   :
881                     PL_parser->in_my == KEY_my     ? "my"    :
882                     PL_parser->in_my == KEY_sigvar ? "my"    :
883                                                      "state" ),
884                 *PadnamePV(sv) == '&' ? "subroutine" : "variable",
885                 PNfARG(sv),
886                 (COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO
887                     ? "scope" : "statement"));
888             --off;
889             break;
890         }
891     }
892     /* check the rest of the pad */
893     if (is_our) {
894         while (off > 0) {
895             PADNAME * const sv = svp[off];
896             if (sv
897                 && PadnameLEN(sv) == PadnameLEN(name)
898                 && !PadnameOUTER(sv)
899                 && (   COP_SEQ_RANGE_LOW(sv)  == PERL_PADSEQ_INTRO
900                     || COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO)
901                 && SvOURSTASH(sv) == ourstash
902                 && memEQ(PadnamePV(sv), PadnamePV(name), PadnameLEN(name)))
903             {
904                 Perl_warner(aTHX_ packWARN(WARN_MISC),
905                     "\"our\" variable %" PNf " redeclared", PNfARG(sv));
906                 if (off <= PL_comppad_name_floor)
907                     Perl_warner(aTHX_ packWARN(WARN_MISC),
908                         "\t(Did you mean \"local\" instead of \"our\"?)\n");
909                 break;
910             }
911             --off;
912         }
913     }
914 }
915
916
917 /*
918 =for apidoc Am|PADOFFSET|pad_findmy_pvn|const char *namepv|STRLEN namelen|U32 flags
919
920 Given the name of a lexical variable, find its position in the
921 currently-compiling pad.
922 C<namepv>/C<namelen> specify the variable's name, including leading sigil.
923 C<flags> is reserved and must be zero.
924 If it is not in the current pad but appears in the pad of any lexically
925 enclosing scope, then a pseudo-entry for it is added in the current pad.
926 Returns the offset in the current pad,
927 or C<NOT_IN_PAD> if no such lexical is in scope.
928
929 =cut
930 */
931
932 PADOFFSET
933 Perl_pad_findmy_pvn(pTHX_ const char *namepv, STRLEN namelen, U32 flags)
934 {
935     PADNAME *out_pn;
936     int out_flags;
937     PADOFFSET offset;
938     const PADNAMELIST *namelist;
939     PADNAME **name_p;
940
941     PERL_ARGS_ASSERT_PAD_FINDMY_PVN;
942
943     pad_peg("pad_findmy_pvn");
944
945     if (flags)
946         Perl_croak(aTHX_ "panic: pad_findmy_pvn illegal flag bits 0x%" UVxf,
947                    (UV)flags);
948
949     /* compilation errors can zero PL_compcv */
950     if (!PL_compcv)
951         return NOT_IN_PAD;
952
953     offset = pad_findlex(namepv, namelen, flags,
954                 PL_compcv, PL_cop_seqmax, 1, NULL, &out_pn, &out_flags);
955     if (offset != NOT_IN_PAD)
956         return offset;
957
958     /* Skip the ‘our’ hack for subroutines, as the warning does not apply.
959      */
960     if (*namepv == '&') return NOT_IN_PAD;
961
962     /* look for an our that's being introduced; this allows
963      *    our $foo = 0 unless defined $foo;
964      * to not give a warning. (Yes, this is a hack) */
965
966     namelist = PadlistNAMES(CvPADLIST(PL_compcv));
967     name_p = PadnamelistARRAY(namelist);
968     for (offset = PadnamelistMAXNAMED(namelist); offset > 0; offset--) {
969         const PADNAME * const name = name_p[offset];
970         if (name && PadnameLEN(name) == namelen
971             && !PadnameOUTER(name)
972             && (PadnameIsOUR(name))
973             && (  PadnamePV(name) == namepv
974                || memEQ(PadnamePV(name), namepv, namelen)  )
975             && COP_SEQ_RANGE_LOW(name) == PERL_PADSEQ_INTRO
976         )
977             return offset;
978     }
979     return NOT_IN_PAD;
980 }
981
982 /*
983 =for apidoc Am|PADOFFSET|pad_findmy_pv|const char *name|U32 flags
984
985 Exactly like L</pad_findmy_pvn>, but takes a nul-terminated string
986 instead of a string/length pair.
987
988 =cut
989 */
990
991 PADOFFSET
992 Perl_pad_findmy_pv(pTHX_ const char *name, U32 flags)
993 {
994     PERL_ARGS_ASSERT_PAD_FINDMY_PV;
995     return pad_findmy_pvn(name, strlen(name), flags);
996 }
997
998 /*
999 =for apidoc Am|PADOFFSET|pad_findmy_sv|SV *name|U32 flags
1000
1001 Exactly like L</pad_findmy_pvn>, but takes the name string in the form
1002 of an SV instead of a string/length pair.
1003
1004 =cut
1005 */
1006
1007 PADOFFSET
1008 Perl_pad_findmy_sv(pTHX_ SV *name, U32 flags)
1009 {
1010     char *namepv;
1011     STRLEN namelen;
1012     PERL_ARGS_ASSERT_PAD_FINDMY_SV;
1013     namepv = SvPVutf8(name, namelen);
1014     return pad_findmy_pvn(namepv, namelen, flags);
1015 }
1016
1017 /*
1018 =for apidoc Amp|PADOFFSET|find_rundefsvoffset
1019
1020 Until the lexical C<$_> feature was removed, this function would
1021 find the position of the lexical C<$_> in the pad of the
1022 currently-executing function and return the offset in the current pad,
1023 or C<NOT_IN_PAD>.
1024
1025 Now it always returns C<NOT_IN_PAD>.
1026
1027 =cut
1028 */
1029
1030 PADOFFSET
1031 Perl_find_rundefsvoffset(pTHX)
1032 {
1033     PERL_UNUSED_CONTEXT; /* Can we just remove the pTHX from the sig? */
1034     return NOT_IN_PAD;
1035 }
1036
1037 /*
1038 =for apidoc Am|SV *|find_rundefsv
1039
1040 Returns the global variable C<$_>.
1041
1042 =cut
1043 */
1044
1045 SV *
1046 Perl_find_rundefsv(pTHX)
1047 {
1048     return DEFSV;
1049 }
1050
1051 /*
1052 =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
1053
1054 Find a named lexical anywhere in a chain of nested pads.  Add fake entries
1055 in the inner pads if it's found in an outer one.
1056
1057 Returns the offset in the bottom pad of the lex or the fake lex.
1058 C<cv> is the CV in which to start the search, and seq is the current C<cop_seq>
1059 to match against.  If C<warn> is true, print appropriate warnings.  The C<out_>*
1060 vars return values, and so are pointers to where the returned values
1061 should be stored.  C<out_capture>, if non-null, requests that the innermost
1062 instance of the lexical is captured; C<out_name> is set to the innermost
1063 matched pad name or fake pad name; C<out_flags> returns the flags normally
1064 associated with the C<PARENT_FAKELEX_FLAGS> field of a fake pad name.
1065
1066 Note that C<pad_findlex()> is recursive; it recurses up the chain of CVs,
1067 then comes back down, adding fake entries
1068 as it goes.  It has to be this way
1069 because fake names in anon protoypes have to store in C<xpadn_low> the
1070 index into the parent pad.
1071
1072 =cut
1073 */
1074
1075 /* the CV has finished being compiled. This is not a sufficient test for
1076  * all CVs (eg XSUBs), but suffices for the CVs found in a lexical chain */
1077 #define CvCOMPILED(cv)  CvROOT(cv)
1078
1079 /* the CV does late binding of its lexicals */
1080 #define CvLATE(cv) (CvANON(cv) || CvCLONE(cv) || SvTYPE(cv) == SVt_PVFM)
1081
1082 static void
1083 S_unavailable(pTHX_ PADNAME *name)
1084 {
1085     /* diag_listed_as: Variable "%s" is not available */
1086     Perl_ck_warner(aTHX_ packWARN(WARN_CLOSURE),
1087                         "%se \"%" PNf "\" is not available",
1088                          *PadnamePV(name) == '&'
1089                                          ? "Subroutin"
1090                                          : "Variabl",
1091                          PNfARG(name));
1092 }
1093
1094 STATIC PADOFFSET
1095 S_pad_findlex(pTHX_ const char *namepv, STRLEN namelen, U32 flags, const CV* cv, U32 seq,
1096         int warn, SV** out_capture, PADNAME** out_name, int *out_flags)
1097 {
1098     PADOFFSET offset, new_offset;
1099     SV *new_capture;
1100     SV **new_capturep;
1101     const PADLIST * const padlist = CvPADLIST(cv);
1102     const bool staleok = !!(flags & padadd_STALEOK);
1103
1104     PERL_ARGS_ASSERT_PAD_FINDLEX;
1105
1106     flags &= ~ padadd_STALEOK; /* one-shot flag */
1107     if (flags)
1108         Perl_croak(aTHX_ "panic: pad_findlex illegal flag bits 0x%" UVxf,
1109                    (UV)flags);
1110
1111     *out_flags = 0;
1112
1113     DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1114         "Pad findlex cv=0x%" UVxf " searching \"%.*s\" seq=%d%s\n",
1115                            PTR2UV(cv), (int)namelen, namepv, (int)seq,
1116         out_capture ? " capturing" : "" ));
1117
1118     /* first, search this pad */
1119
1120     if (padlist) { /* not an undef CV */
1121         PADOFFSET fake_offset = 0;
1122         const PADNAMELIST * const names = PadlistNAMES(padlist);
1123         PADNAME * const * const name_p = PadnamelistARRAY(names);
1124
1125         for (offset = PadnamelistMAXNAMED(names); offset > 0; offset--) {
1126             const PADNAME * const name = name_p[offset];
1127             if (name && PadnameLEN(name) == namelen
1128                      && (  PadnamePV(name) == namepv
1129                         || memEQ(PadnamePV(name), namepv, namelen)  ))
1130             {
1131                 if (PadnameOUTER(name)) {
1132                     fake_offset = offset; /* in case we don't find a real one */
1133                     continue;
1134                 }
1135                 if (PadnameIN_SCOPE(name, seq))
1136                     break;
1137             }
1138         }
1139
1140         if (offset > 0 || fake_offset > 0 ) { /* a match! */
1141             if (offset > 0) { /* not fake */
1142                 fake_offset = 0;
1143                 *out_name = name_p[offset]; /* return the name */
1144
1145                 /* set PAD_FAKELEX_MULTI if this lex can have multiple
1146                  * instances. For now, we just test !CvUNIQUE(cv), but
1147                  * ideally, we should detect my's declared within loops
1148                  * etc - this would allow a wider range of 'not stayed
1149                  * shared' warnings. We also treated already-compiled
1150                  * lexes as not multi as viewed from evals. */
1151
1152                 *out_flags = CvANON(cv) ?
1153                         PAD_FAKELEX_ANON :
1154                             (!CvUNIQUE(cv) && ! CvCOMPILED(cv))
1155                                 ? PAD_FAKELEX_MULTI : 0;
1156
1157                 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1158                     "Pad findlex cv=0x%" UVxf " matched: offset=%ld (%lu,%lu)\n",
1159                     PTR2UV(cv), (long)offset,
1160                     (unsigned long)COP_SEQ_RANGE_LOW(*out_name),
1161                     (unsigned long)COP_SEQ_RANGE_HIGH(*out_name)));
1162             }
1163             else { /* fake match */
1164                 offset = fake_offset;
1165                 *out_name = name_p[offset]; /* return the name */
1166                 *out_flags = PARENT_FAKELEX_FLAGS(*out_name);
1167                 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1168                     "Pad findlex cv=0x%" UVxf " matched: offset=%ld flags=0x%lx index=%lu\n",
1169                     PTR2UV(cv), (long)offset, (unsigned long)*out_flags,
1170                     (unsigned long) PARENT_PAD_INDEX(*out_name) 
1171                 ));
1172             }
1173
1174             /* return the lex? */
1175
1176             if (out_capture) {
1177
1178                 /* our ? */
1179                 if (PadnameIsOUR(*out_name)) {
1180                     *out_capture = NULL;
1181                     return offset;
1182                 }
1183
1184                 /* trying to capture from an anon prototype? */
1185                 if (CvCOMPILED(cv)
1186                         ? CvANON(cv) && CvCLONE(cv) && !CvCLONED(cv)
1187                         : *out_flags & PAD_FAKELEX_ANON)
1188                 {
1189                     if (warn)
1190                         S_unavailable(aTHX_
1191                                       *out_name);
1192
1193                     *out_capture = NULL;
1194                 }
1195
1196                 /* real value */
1197                 else {
1198                     int newwarn = warn;
1199                     if (!CvCOMPILED(cv) && (*out_flags & PAD_FAKELEX_MULTI)
1200                          && !PadnameIsSTATE(name_p[offset])
1201                          && warn && ckWARN(WARN_CLOSURE)) {
1202                         newwarn = 0;
1203                         /* diag_listed_as: Variable "%s" will not stay
1204                                            shared */
1205                         Perl_warner(aTHX_ packWARN(WARN_CLOSURE),
1206                             "%se \"%" UTF8f "\" will not stay shared",
1207                              *namepv == '&' ? "Subroutin" : "Variabl",
1208                              UTF8fARG(1, namelen, namepv));
1209                     }
1210
1211                     if (fake_offset && CvANON(cv)
1212                             && CvCLONE(cv) &&!CvCLONED(cv))
1213                     {
1214                         PADNAME *n;
1215                         /* not yet caught - look further up */
1216                         DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1217                             "Pad findlex cv=0x%" UVxf " chasing lex in outer pad\n",
1218                             PTR2UV(cv)));
1219                         n = *out_name;
1220                         (void) pad_findlex(namepv, namelen, flags, CvOUTSIDE(cv),
1221                             CvOUTSIDE_SEQ(cv),
1222                             newwarn, out_capture, out_name, out_flags);
1223                         *out_name = n;
1224                         return offset;
1225                     }
1226
1227                     *out_capture = AvARRAY(PadlistARRAY(padlist)[
1228                                     CvDEPTH(cv) ? CvDEPTH(cv) : 1])[offset];
1229                     DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1230                         "Pad findlex cv=0x%" UVxf " found lex=0x%" UVxf "\n",
1231                         PTR2UV(cv), PTR2UV(*out_capture)));
1232
1233                     if (SvPADSTALE(*out_capture)
1234                         && (!CvDEPTH(cv) || !staleok)
1235                         && !PadnameIsSTATE(name_p[offset]))
1236                     {
1237                         S_unavailable(aTHX_
1238                                       name_p[offset]);
1239                         *out_capture = NULL;
1240                     }
1241                 }
1242                 if (!*out_capture) {
1243                     if (namelen != 0 && *namepv == '@')
1244                         *out_capture = sv_2mortal(MUTABLE_SV(newAV()));
1245                     else if (namelen != 0 && *namepv == '%')
1246                         *out_capture = sv_2mortal(MUTABLE_SV(newHV()));
1247                     else if (namelen != 0 && *namepv == '&')
1248                         *out_capture = sv_2mortal(newSV_type(SVt_PVCV));
1249                     else
1250                         *out_capture = sv_newmortal();
1251                 }
1252             }
1253
1254             return offset;
1255         }
1256     }
1257
1258     /* it's not in this pad - try above */
1259
1260     if (!CvOUTSIDE(cv))
1261         return NOT_IN_PAD;
1262
1263     /* out_capture non-null means caller wants us to capture lex; in
1264      * addition we capture ourselves unless it's an ANON/format */
1265     new_capturep = out_capture ? out_capture :
1266                 CvLATE(cv) ? NULL : &new_capture;
1267
1268     offset = pad_findlex(namepv, namelen,
1269                 flags | padadd_STALEOK*(new_capturep == &new_capture),
1270                 CvOUTSIDE(cv), CvOUTSIDE_SEQ(cv), 1,
1271                 new_capturep, out_name, out_flags);
1272     if (offset == NOT_IN_PAD)
1273         return NOT_IN_PAD;
1274
1275     /* found in an outer CV. Add appropriate fake entry to this pad */
1276
1277     /* don't add new fake entries (via eval) to CVs that we have already
1278      * finished compiling, or to undef CVs */
1279     if (CvCOMPILED(cv) || !padlist)
1280         return 0; /* this dummy (and invalid) value isnt used by the caller */
1281
1282     {
1283         PADNAME *new_name = newPADNAMEouter(*out_name);
1284         PADNAMELIST * const ocomppad_name = PL_comppad_name;
1285         PAD * const ocomppad = PL_comppad;
1286         PL_comppad_name = PadlistNAMES(padlist);
1287         PL_comppad = PadlistARRAY(padlist)[1];
1288         PL_curpad = AvARRAY(PL_comppad);
1289
1290         new_offset
1291             = pad_alloc_name(new_name,
1292                               PadnameIsSTATE(*out_name) ? padadd_STATE : 0,
1293                               PadnameTYPE(*out_name),
1294                               PadnameOURSTASH(*out_name)
1295                               );
1296
1297         DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1298                                "Pad addname: %ld \"%.*s\" FAKE\n",
1299                                (long)new_offset,
1300                                (int) PadnameLEN(new_name),
1301                                PadnamePV(new_name)));
1302         PARENT_FAKELEX_FLAGS_set(new_name, *out_flags);
1303
1304         PARENT_PAD_INDEX_set(new_name, 0);
1305         if (PadnameIsOUR(new_name)) {
1306             NOOP;   /* do nothing */
1307         }
1308         else if (CvLATE(cv)) {
1309             /* delayed creation - just note the offset within parent pad */
1310             PARENT_PAD_INDEX_set(new_name, offset);
1311             CvCLONE_on(cv);
1312         }
1313         else {
1314             /* immediate creation - capture outer value right now */
1315             av_store(PL_comppad, new_offset, SvREFCNT_inc(*new_capturep));
1316             /* But also note the offset, as newMYSUB needs it */
1317             PARENT_PAD_INDEX_set(new_name, offset);
1318             DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1319                 "Pad findlex cv=0x%" UVxf " saved captured sv 0x%" UVxf " at offset %ld\n",
1320                 PTR2UV(cv), PTR2UV(*new_capturep), (long)new_offset));
1321         }
1322         *out_name = new_name;
1323         *out_flags = PARENT_FAKELEX_FLAGS(new_name);
1324
1325         PL_comppad_name = ocomppad_name;
1326         PL_comppad = ocomppad;
1327         PL_curpad = ocomppad ? AvARRAY(ocomppad) : NULL;
1328     }
1329     return new_offset;
1330 }
1331
1332 #ifdef DEBUGGING
1333
1334 /*
1335 =for apidoc Am|SV *|pad_sv|PADOFFSET po
1336
1337 Get the value at offset C<po> in the current (compiling or executing) pad.
1338 Use macro C<PAD_SV> instead of calling this function directly.
1339
1340 =cut
1341 */
1342
1343 SV *
1344 Perl_pad_sv(pTHX_ PADOFFSET po)
1345 {
1346     ASSERT_CURPAD_ACTIVE("pad_sv");
1347
1348     if (!po)
1349         Perl_croak(aTHX_ "panic: pad_sv po");
1350     DEBUG_X(PerlIO_printf(Perl_debug_log,
1351         "Pad 0x%" UVxf "[0x%" UVxf "] sv:      %ld sv=0x%" UVxf "\n",
1352         PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po, PTR2UV(PL_curpad[po]))
1353     );
1354     return PL_curpad[po];
1355 }
1356
1357 /*
1358 =for apidoc Am|void|pad_setsv|PADOFFSET po|SV *sv
1359
1360 Set the value at offset C<po> in the current (compiling or executing) pad.
1361 Use the macro C<PAD_SETSV()> rather than calling this function directly.
1362
1363 =cut
1364 */
1365
1366 void
1367 Perl_pad_setsv(pTHX_ PADOFFSET po, SV* sv)
1368 {
1369     PERL_ARGS_ASSERT_PAD_SETSV;
1370
1371     ASSERT_CURPAD_ACTIVE("pad_setsv");
1372
1373     DEBUG_X(PerlIO_printf(Perl_debug_log,
1374         "Pad 0x%" UVxf "[0x%" UVxf "] setsv:   %ld sv=0x%" UVxf "\n",
1375         PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po, PTR2UV(sv))
1376     );
1377     PL_curpad[po] = sv;
1378 }
1379
1380 #endif /* DEBUGGING */
1381
1382 /*
1383 =for apidoc m|void|pad_block_start|int full
1384
1385 Update the pad compilation state variables on entry to a new block.
1386
1387 =cut
1388 */
1389
1390 void
1391 Perl_pad_block_start(pTHX_ int full)
1392 {
1393     ASSERT_CURPAD_ACTIVE("pad_block_start");
1394     save_strlen((STRLEN *)&PL_comppad_name_floor);
1395     PL_comppad_name_floor = PadnamelistMAX(PL_comppad_name);
1396     if (full)
1397         PL_comppad_name_fill = PL_comppad_name_floor;
1398     if (PL_comppad_name_floor < 0)
1399         PL_comppad_name_floor = 0;
1400     save_strlen((STRLEN *)&PL_min_intro_pending);
1401     save_strlen((STRLEN *)&PL_max_intro_pending);
1402     PL_min_intro_pending = 0;
1403     save_strlen((STRLEN *)&PL_comppad_name_fill);
1404     save_strlen((STRLEN *)&PL_padix_floor);
1405     /* PL_padix_floor is what PL_padix is reset to at the start of each
1406        statement, by pad_reset().  We set it when entering a new scope
1407        to keep things like this working:
1408             print "$foo$bar", do { this(); that() . "foo" };
1409        We must not let "$foo$bar" and the later concatenation share the
1410        same target.  */
1411     PL_padix_floor = PL_padix;
1412     PL_pad_reset_pending = FALSE;
1413 }
1414
1415 /*
1416 =for apidoc Am|U32|intro_my
1417
1418 "Introduce" C<my> variables to visible status.  This is called during parsing
1419 at the end of each statement to make lexical variables visible to subsequent
1420 statements.
1421
1422 =cut
1423 */
1424
1425 U32
1426 Perl_intro_my(pTHX)
1427 {
1428     PADNAME **svp;
1429     PADOFFSET i;
1430     U32 seq;
1431
1432     ASSERT_CURPAD_ACTIVE("intro_my");
1433     if (PL_compiling.cop_seq) {
1434         seq = PL_compiling.cop_seq;
1435         PL_compiling.cop_seq = 0;
1436     }
1437     else
1438         seq = PL_cop_seqmax;
1439     if (! PL_min_intro_pending)
1440         return seq;
1441
1442     svp = PadnamelistARRAY(PL_comppad_name);
1443     for (i = PL_min_intro_pending; i <= PL_max_intro_pending; i++) {
1444         PADNAME * const sv = svp[i];
1445
1446         if (sv && PadnameLEN(sv) && !PadnameOUTER(sv)
1447             && COP_SEQ_RANGE_LOW(sv) == PERL_PADSEQ_INTRO)
1448         {
1449             COP_SEQ_RANGE_HIGH_set(sv, PERL_PADSEQ_INTRO); /* Don't know scope end yet. */
1450             COP_SEQ_RANGE_LOW_set(sv, PL_cop_seqmax);
1451             DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1452                 "Pad intromy: %ld \"%s\", (%lu,%lu)\n",
1453                 (long)i, PadnamePV(sv),
1454                 (unsigned long)COP_SEQ_RANGE_LOW(sv),
1455                 (unsigned long)COP_SEQ_RANGE_HIGH(sv))
1456             );
1457         }
1458     }
1459     COP_SEQMAX_INC;
1460     PL_min_intro_pending = 0;
1461     PL_comppad_name_fill = PL_max_intro_pending; /* Needn't search higher */
1462     DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1463                 "Pad intromy: seq -> %ld\n", (long)(PL_cop_seqmax)));
1464
1465     return seq;
1466 }
1467
1468 /*
1469 =for apidoc m|void|pad_leavemy
1470
1471 Cleanup at end of scope during compilation: set the max seq number for
1472 lexicals in this scope and warn of any lexicals that never got introduced.
1473
1474 =cut
1475 */
1476
1477 OP *
1478 Perl_pad_leavemy(pTHX)
1479 {
1480     PADOFFSET off;
1481     OP *o = NULL;
1482     PADNAME * const * const svp = PadnamelistARRAY(PL_comppad_name);
1483
1484     PL_pad_reset_pending = FALSE;
1485
1486     ASSERT_CURPAD_ACTIVE("pad_leavemy");
1487     if (PL_min_intro_pending && PL_comppad_name_fill < PL_min_intro_pending) {
1488         for (off = PL_max_intro_pending; off >= PL_min_intro_pending; off--) {
1489             const PADNAME * const name = svp[off];
1490             if (name && PadnameLEN(name) && !PadnameOUTER(name))
1491                 Perl_ck_warner_d(aTHX_ packWARN(WARN_INTERNAL),
1492                                       "%" PNf " never introduced",
1493                                        PNfARG(name));
1494         }
1495     }
1496     /* "Deintroduce" my variables that are leaving with this scope. */
1497     for (off = PadnamelistMAX(PL_comppad_name);
1498          off > PL_comppad_name_fill; off--) {
1499         PADNAME * const sv = svp[off];
1500         if (sv && PadnameLEN(sv) && !PadnameOUTER(sv)
1501             && COP_SEQ_RANGE_HIGH(sv) == PERL_PADSEQ_INTRO)
1502         {
1503             COP_SEQ_RANGE_HIGH_set(sv, PL_cop_seqmax);
1504             DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1505                 "Pad leavemy: %ld \"%s\", (%lu,%lu)\n",
1506                 (long)off, PadnamePV(sv),
1507                 (unsigned long)COP_SEQ_RANGE_LOW(sv),
1508                 (unsigned long)COP_SEQ_RANGE_HIGH(sv))
1509             );
1510             if (!PadnameIsSTATE(sv) && !PadnameIsOUR(sv)
1511              && *PadnamePV(sv) == '&' && PadnameLEN(sv) > 1) {
1512                 OP *kid = newOP(OP_INTROCV, 0);
1513                 kid->op_targ = off;
1514                 o = op_prepend_elem(OP_LINESEQ, kid, o);
1515             }
1516         }
1517     }
1518     COP_SEQMAX_INC;
1519     DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1520             "Pad leavemy: seq = %ld\n", (long)PL_cop_seqmax));
1521     return o;
1522 }
1523
1524 /*
1525 =for apidoc m|void|pad_swipe|PADOFFSET po|bool refadjust
1526
1527 Abandon the tmp in the current pad at offset C<po> and replace with a
1528 new one.
1529
1530 =cut
1531 */
1532
1533 void
1534 Perl_pad_swipe(pTHX_ PADOFFSET po, bool refadjust)
1535 {
1536     ASSERT_CURPAD_LEGAL("pad_swipe");
1537     if (!PL_curpad)
1538         return;
1539     if (AvARRAY(PL_comppad) != PL_curpad)
1540         Perl_croak(aTHX_ "panic: pad_swipe curpad, %p!=%p",
1541                    AvARRAY(PL_comppad), PL_curpad);
1542     if (!po || ((SSize_t)po) > AvFILLp(PL_comppad))
1543         Perl_croak(aTHX_ "panic: pad_swipe po=%ld, fill=%ld",
1544                    (long)po, (long)AvFILLp(PL_comppad));
1545
1546     DEBUG_X(PerlIO_printf(Perl_debug_log,
1547                 "Pad 0x%" UVxf "[0x%" UVxf "] swipe:   %ld\n",
1548                 PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po));
1549
1550     if (refadjust)
1551         SvREFCNT_dec(PL_curpad[po]);
1552
1553
1554     /* if pad tmps aren't shared between ops, then there's no need to
1555      * create a new tmp when an existing op is freed */
1556 #ifdef USE_PAD_RESET
1557     PL_curpad[po] = newSV(0);
1558     SvPADTMP_on(PL_curpad[po]);
1559 #else
1560     PL_curpad[po] = NULL;
1561 #endif
1562     if (PadnamelistMAX(PL_comppad_name) != -1
1563      && (PADOFFSET)PadnamelistMAX(PL_comppad_name) >= po) {
1564         if (PadnamelistARRAY(PL_comppad_name)[po]) {
1565             assert(!PadnameLEN(PadnamelistARRAY(PL_comppad_name)[po]));
1566         }
1567         PadnamelistARRAY(PL_comppad_name)[po] = &PL_padname_undef;
1568     }
1569     /* Use PL_constpadix here, not PL_padix.  The latter may have been
1570        reset by pad_reset.  We don’t want pad_alloc to have to scan the
1571        whole pad when allocating a constant. */
1572     if (po < PL_constpadix)
1573         PL_constpadix = po - 1;
1574 }
1575
1576 /*
1577 =for apidoc m|void|pad_reset
1578
1579 Mark all the current temporaries for reuse
1580
1581 =cut
1582 */
1583
1584 /* pad_reset() causes pad temp TARGs (operator targets) to be shared
1585  * between OPs from different statements.  During compilation, at the start
1586  * of each statement pad_reset resets PL_padix back to its previous value.
1587  * When allocating a target, pad_alloc begins its scan through the pad at
1588  * PL_padix+1.  */
1589 static void
1590 S_pad_reset(pTHX)
1591 {
1592 #ifdef USE_PAD_RESET
1593     if (AvARRAY(PL_comppad) != PL_curpad)
1594         Perl_croak(aTHX_ "panic: pad_reset curpad, %p!=%p",
1595                    AvARRAY(PL_comppad), PL_curpad);
1596
1597     DEBUG_X(PerlIO_printf(Perl_debug_log,
1598             "Pad 0x%" UVxf "[0x%" UVxf "] reset:     padix %ld -> %ld",
1599             PTR2UV(PL_comppad), PTR2UV(PL_curpad),
1600                 (long)PL_padix, (long)PL_padix_floor
1601             )
1602     );
1603
1604     if (!TAINTING_get) {        /* Can't mix tainted and non-tainted temporaries. */
1605         PL_padix = PL_padix_floor;
1606     }
1607 #endif
1608     PL_pad_reset_pending = FALSE;
1609 }
1610
1611 /*
1612 =for apidoc Amx|void|pad_tidy|padtidy_type type
1613
1614 Tidy up a pad at the end of compilation of the code to which it belongs.
1615 Jobs performed here are: remove most stuff from the pads of anonsub
1616 prototypes; give it a C<@_>; mark temporaries as such.  C<type> indicates
1617 the kind of subroutine:
1618
1619     padtidy_SUB        ordinary subroutine
1620     padtidy_SUBCLONE   prototype for lexical closure
1621     padtidy_FORMAT     format
1622
1623 =cut
1624 */
1625
1626 void
1627 Perl_pad_tidy(pTHX_ padtidy_type type)
1628 {
1629     dVAR;
1630
1631     ASSERT_CURPAD_ACTIVE("pad_tidy");
1632
1633     /* If this CV has had any 'eval-capable' ops planted in it:
1634      * i.e. it contains any of:
1635      *
1636      *     * eval '...',
1637      *     * //ee,
1638      *     * use re 'eval'; /$var/
1639      *     * /(?{..})/),
1640      *
1641      * Then any anon prototypes in the chain of CVs should be marked as
1642      * cloneable, so that for example the eval's CV in
1643      *
1644      *    sub { eval '$x' }
1645      *
1646      * gets the right CvOUTSIDE.  If running with -d, *any* sub may
1647      * potentially have an eval executed within it.
1648      */
1649
1650     if (PL_cv_has_eval || PL_perldb) {
1651         const CV *cv;
1652         for (cv = PL_compcv ;cv; cv = CvOUTSIDE(cv)) {
1653             if (cv != PL_compcv && CvCOMPILED(cv))
1654                 break; /* no need to mark already-compiled code */
1655             if (CvANON(cv)) {
1656                 DEBUG_Xv(PerlIO_printf(Perl_debug_log,
1657                     "Pad clone on cv=0x%" UVxf "\n", PTR2UV(cv)));
1658                 CvCLONE_on(cv);
1659             }
1660             CvHASEVAL_on(cv);
1661         }
1662     }
1663
1664     /* extend namepad to match curpad */
1665     if (PadnamelistMAX(PL_comppad_name) < AvFILLp(PL_comppad))
1666         padnamelist_store(PL_comppad_name, AvFILLp(PL_comppad), NULL);
1667
1668     if (type == padtidy_SUBCLONE) {
1669         PADNAME ** const namep = PadnamelistARRAY(PL_comppad_name);
1670         PADOFFSET ix;
1671
1672         for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1673             PADNAME *namesv;
1674             if (!namep[ix]) namep[ix] = &PL_padname_undef;
1675
1676             /*
1677              * The only things that a clonable function needs in its
1678              * pad are anonymous subs, constants and GVs.
1679              * The rest are created anew during cloning.
1680              */
1681             if (!PL_curpad[ix] || SvIMMORTAL(PL_curpad[ix]))
1682                 continue;
1683             namesv = namep[ix];
1684             if (!(PadnamePV(namesv) &&
1685                    (!PadnameLEN(namesv) || *PadnamePV(namesv) == '&')))
1686             {
1687                 SvREFCNT_dec(PL_curpad[ix]);
1688                 PL_curpad[ix] = NULL;
1689             }
1690         }
1691     }
1692     else if (type == padtidy_SUB) {
1693         AV * const av = newAV();                        /* Will be @_ */
1694         av_store(PL_comppad, 0, MUTABLE_SV(av));
1695         AvREIFY_only(av);
1696     }
1697
1698     if (type == padtidy_SUB || type == padtidy_FORMAT) {
1699         PADNAME ** const namep = PadnamelistARRAY(PL_comppad_name);
1700         PADOFFSET ix;
1701         for (ix = AvFILLp(PL_comppad); ix > 0; ix--) {
1702             if (!namep[ix]) namep[ix] = &PL_padname_undef;
1703             if (!PL_curpad[ix] || SvIMMORTAL(PL_curpad[ix]))
1704                 continue;
1705             if (SvPADMY(PL_curpad[ix]) && !PadnameOUTER(namep[ix])) {
1706                 /* This is a work around for how the current implementation of
1707                    ?{ } blocks in regexps interacts with lexicals.
1708
1709                    One of our lexicals.
1710                    Can't do this on all lexicals, otherwise sub baz() won't
1711                    compile in
1712
1713                    my $foo;
1714
1715                    sub bar { ++$foo; }
1716
1717                    sub baz { ++$foo; }
1718
1719                    because completion of compiling &bar calling pad_tidy()
1720                    would cause (top level) $foo to be marked as stale, and
1721                    "no longer available".  */
1722                 SvPADSTALE_on(PL_curpad[ix]);
1723             }
1724         }
1725     }
1726     PL_curpad = AvARRAY(PL_comppad);
1727 }
1728
1729 /*
1730 =for apidoc m|void|pad_free|PADOFFSET po
1731
1732 Free the SV at offset po in the current pad.
1733
1734 =cut
1735 */
1736
1737 void
1738 Perl_pad_free(pTHX_ PADOFFSET po)
1739 {
1740 #ifndef USE_PAD_RESET
1741     SV *sv;
1742 #endif
1743     ASSERT_CURPAD_LEGAL("pad_free");
1744     if (!PL_curpad)
1745         return;
1746     if (AvARRAY(PL_comppad) != PL_curpad)
1747         Perl_croak(aTHX_ "panic: pad_free curpad, %p!=%p",
1748                    AvARRAY(PL_comppad), PL_curpad);
1749     if (!po)
1750         Perl_croak(aTHX_ "panic: pad_free po");
1751
1752     DEBUG_X(PerlIO_printf(Perl_debug_log,
1753             "Pad 0x%" UVxf "[0x%" UVxf "] free:    %ld\n",
1754             PTR2UV(PL_comppad), PTR2UV(PL_curpad), (long)po)
1755     );
1756
1757 #ifndef USE_PAD_RESET
1758     sv = PL_curpad[po];
1759     if (sv && sv != &PL_sv_undef && !SvPADMY(sv))
1760         SvFLAGS(sv) &= ~SVs_PADTMP;
1761
1762     if (po < PL_padix)
1763         PL_padix = po - 1;
1764 #endif
1765 }
1766
1767 /*
1768 =for apidoc m|void|do_dump_pad|I32 level|PerlIO *file|PADLIST *padlist|int full
1769
1770 Dump the contents of a padlist
1771
1772 =cut
1773 */
1774
1775 void
1776 Perl_do_dump_pad(pTHX_ I32 level, PerlIO *file, PADLIST *padlist, int full)
1777 {
1778     const PADNAMELIST *pad_name;
1779     const AV *pad;
1780     PADNAME **pname;
1781     SV **ppad;
1782     PADOFFSET ix;
1783
1784     PERL_ARGS_ASSERT_DO_DUMP_PAD;
1785
1786     if (!padlist) {
1787         return;
1788     }
1789     pad_name = PadlistNAMES(padlist);
1790     pad = PadlistARRAY(padlist)[1];
1791     pname = PadnamelistARRAY(pad_name);
1792     ppad = AvARRAY(pad);
1793     Perl_dump_indent(aTHX_ level, file,
1794             "PADNAME = 0x%" UVxf "(0x%" UVxf ") PAD = 0x%" UVxf "(0x%" UVxf ")\n",
1795             PTR2UV(pad_name), PTR2UV(pname), PTR2UV(pad), PTR2UV(ppad)
1796     );
1797
1798     for (ix = 1; ix <= PadnamelistMAX(pad_name); ix++) {
1799         const PADNAME *namesv = pname[ix];
1800         if (namesv && !PadnameLEN(namesv)) {
1801             namesv = NULL;
1802         }
1803         if (namesv) {
1804             if (PadnameOUTER(namesv))
1805                 Perl_dump_indent(aTHX_ level+1, file,
1806                     "%2d. 0x%" UVxf "<%lu> FAKE \"%s\" flags=0x%lx index=%lu\n",
1807                     (int) ix,
1808                     PTR2UV(ppad[ix]),
1809                     (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0),
1810                     PadnamePV(namesv),
1811                     (unsigned long)PARENT_FAKELEX_FLAGS(namesv),
1812                     (unsigned long)PARENT_PAD_INDEX(namesv)
1813
1814                 );
1815             else
1816                 Perl_dump_indent(aTHX_ level+1, file,
1817                     "%2d. 0x%" UVxf "<%lu> (%lu,%lu) \"%s\"\n",
1818                     (int) ix,
1819                     PTR2UV(ppad[ix]),
1820                     (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0),
1821                     (unsigned long)COP_SEQ_RANGE_LOW(namesv),
1822                     (unsigned long)COP_SEQ_RANGE_HIGH(namesv),
1823                     PadnamePV(namesv)
1824                 );
1825         }
1826         else if (full) {
1827             Perl_dump_indent(aTHX_ level+1, file,
1828                 "%2d. 0x%" UVxf "<%lu>\n",
1829                 (int) ix,
1830                 PTR2UV(ppad[ix]),
1831                 (unsigned long) (ppad[ix] ? SvREFCNT(ppad[ix]) : 0)
1832             );
1833         }
1834     }
1835 }
1836
1837 #ifdef DEBUGGING
1838
1839 /*
1840 =for apidoc m|void|cv_dump|CV *cv|const char *title
1841
1842 dump the contents of a CV
1843
1844 =cut
1845 */
1846
1847 STATIC void
1848 S_cv_dump(pTHX_ const CV *cv, const char *title)
1849 {
1850     const CV * const outside = CvOUTSIDE(cv);
1851     PADLIST* const padlist = CvPADLIST(cv);
1852
1853     PERL_ARGS_ASSERT_CV_DUMP;
1854
1855     PerlIO_printf(Perl_debug_log,
1856                   "  %s: CV=0x%" UVxf " (%s), OUTSIDE=0x%" UVxf " (%s)\n",
1857                   title,
1858                   PTR2UV(cv),
1859                   (CvANON(cv) ? "ANON"
1860                    : (SvTYPE(cv) == SVt_PVFM) ? "FORMAT"
1861                    : (cv == PL_main_cv) ? "MAIN"
1862                    : CvUNIQUE(cv) ? "UNIQUE"
1863                    : CvGV(cv) ? GvNAME(CvGV(cv)) : "UNDEFINED"),
1864                   PTR2UV(outside),
1865                   (!outside ? "null"
1866                    : CvANON(outside) ? "ANON"
1867                    : (outside == PL_main_cv) ? "MAIN"
1868                    : CvUNIQUE(outside) ? "UNIQUE"
1869                    : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
1870
1871     PerlIO_printf(Perl_debug_log,
1872                     "    PADLIST = 0x%" UVxf "\n", PTR2UV(padlist));
1873     do_dump_pad(1, Perl_debug_log, padlist, 1);
1874 }
1875
1876 #endif /* DEBUGGING */
1877
1878 /*
1879 =for apidoc Am|CV *|cv_clone|CV *proto
1880
1881 Clone a CV, making a lexical closure.  C<proto> supplies the prototype
1882 of the function: its code, pad structure, and other attributes.
1883 The prototype is combined with a capture of outer lexicals to which the
1884 code refers, which are taken from the currently-executing instance of
1885 the immediately surrounding code.
1886
1887 =cut
1888 */
1889
1890 static CV *S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned);
1891
1892 static CV *
1893 S_cv_clone_pad(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned,
1894                      bool newcv)
1895 {
1896     PADOFFSET ix;
1897     PADLIST* const protopadlist = CvPADLIST(proto);
1898     PADNAMELIST *const protopad_name = PadlistNAMES(protopadlist);
1899     const PAD *const protopad = PadlistARRAY(protopadlist)[1];
1900     PADNAME** const pname = PadnamelistARRAY(protopad_name);
1901     SV** const ppad = AvARRAY(protopad);
1902     const PADOFFSET fname = PadnamelistMAX(protopad_name);
1903     const PADOFFSET fpad = AvFILLp(protopad);
1904     SV** outpad;
1905     long depth;
1906     U32 subclones = 0;
1907     bool trouble = FALSE;
1908
1909     assert(!CvUNIQUE(proto));
1910
1911     /* Anonymous subs have a weak CvOUTSIDE pointer, so its value is not
1912      * reliable.  The currently-running sub is always the one we need to
1913      * close over.
1914      * For my subs, the currently-running sub may not be the one we want.
1915      * We have to check whether it is a clone of CvOUTSIDE.
1916      * Note that in general for formats, CvOUTSIDE != find_runcv.
1917      * Since formats may be nested inside closures, CvOUTSIDE may point
1918      * to a prototype; we instead want the cloned parent who called us.
1919      */
1920
1921     if (!outside) {
1922       if (CvWEAKOUTSIDE(proto))
1923         outside = find_runcv(NULL);
1924       else {
1925         outside = CvOUTSIDE(proto);
1926         if ((CvCLONE(outside) && ! CvCLONED(outside))
1927             || !CvPADLIST(outside)
1928             || CvPADLIST(outside)->xpadl_id != protopadlist->xpadl_outid) {
1929             outside = find_runcv_where(
1930                 FIND_RUNCV_padid_eq, PTR2IV(protopadlist->xpadl_outid), NULL
1931             );
1932             /* outside could be null */
1933         }
1934       }
1935     }
1936     depth = outside ? CvDEPTH(outside) : 0;
1937     if (!depth)
1938         depth = 1;
1939
1940     ENTER;
1941     SAVESPTR(PL_compcv);
1942     PL_compcv = cv;
1943     if (newcv) SAVEFREESV(cv); /* in case of fatal warnings */
1944
1945     if (CvHASEVAL(cv))
1946         CvOUTSIDE(cv)   = MUTABLE_CV(SvREFCNT_inc_simple(outside));
1947
1948     SAVESPTR(PL_comppad_name);
1949     PL_comppad_name = protopad_name;
1950     CvPADLIST_set(cv, pad_new(padnew_CLONE|padnew_SAVE));
1951     CvPADLIST(cv)->xpadl_id = protopadlist->xpadl_id;
1952
1953     av_fill(PL_comppad, fpad);
1954
1955     PL_curpad = AvARRAY(PL_comppad);
1956
1957     outpad = outside && CvPADLIST(outside)
1958         ? AvARRAY(PadlistARRAY(CvPADLIST(outside))[depth])
1959         : NULL;
1960     if (outpad) CvPADLIST(cv)->xpadl_outid = CvPADLIST(outside)->xpadl_id;
1961
1962     for (ix = fpad; ix > 0; ix--) {
1963         PADNAME* const namesv = (ix <= fname) ? pname[ix] : NULL;
1964         SV *sv = NULL;
1965         if (namesv && PadnameLEN(namesv)) { /* lexical */
1966           if (PadnameIsOUR(namesv)) { /* or maybe not so lexical */
1967                 NOOP;
1968           }
1969           else {
1970             if (PadnameOUTER(namesv)) {   /* lexical from outside? */
1971                 /* formats may have an inactive, or even undefined, parent;
1972                    but state vars are always available. */
1973                 if (!outpad || !(sv = outpad[PARENT_PAD_INDEX(namesv)])
1974                  || (  SvPADSTALE(sv) && !SvPAD_STATE(namesv)
1975                     && (!outside || !CvDEPTH(outside)))  ) {
1976                     S_unavailable(aTHX_ namesv);
1977                     sv = NULL;
1978                 }
1979                 else 
1980                     SvREFCNT_inc_simple_void_NN(sv);
1981             }
1982             if (!sv) {
1983                 const char sigil = PadnamePV(namesv)[0];
1984                 if (sigil == '&')
1985                     /* If there are state subs, we need to clone them, too.
1986                        But they may need to close over variables we have
1987                        not cloned yet.  So we will have to do a second
1988                        pass.  Furthermore, there may be state subs clos-
1989                        ing over other state subs’ entries, so we have
1990                        to put a stub here and then clone into it on the
1991                        second pass. */
1992                     if (SvPAD_STATE(namesv) && !CvCLONED(ppad[ix])) {
1993                         assert(SvTYPE(ppad[ix]) == SVt_PVCV);
1994                         subclones ++;
1995                         if (CvOUTSIDE(ppad[ix]) != proto)
1996                              trouble = TRUE;
1997                         sv = newSV_type(SVt_PVCV);
1998                         CvLEXICAL_on(sv);
1999                     }
2000                     else if (PadnameLEN(namesv)>1 && !PadnameIsOUR(namesv))
2001                     {
2002                         /* my sub */
2003                         /* Just provide a stub, but name it.  It will be
2004                            upgraded to the real thing on scope entry. */
2005                         dVAR;
2006                         U32 hash;
2007                         PERL_HASH(hash, PadnamePV(namesv)+1,
2008                                   PadnameLEN(namesv) - 1);
2009                         sv = newSV_type(SVt_PVCV);
2010                         CvNAME_HEK_set(
2011                             sv,
2012                             share_hek(PadnamePV(namesv)+1,
2013                                       1 - PadnameLEN(namesv),
2014                                       hash)
2015                         );
2016                         CvLEXICAL_on(sv);
2017                     }
2018                     else sv = SvREFCNT_inc(ppad[ix]);
2019                 else if (sigil == '@')
2020                     sv = MUTABLE_SV(newAV());
2021                 else if (sigil == '%')
2022                     sv = MUTABLE_SV(newHV());
2023                 else
2024                     sv = newSV(0);
2025                 /* reset the 'assign only once' flag on each state var */
2026                 if (sigil != '&' && SvPAD_STATE(namesv))
2027                     SvPADSTALE_on(sv);
2028             }
2029           }
2030         }
2031         else if (namesv && PadnamePV(namesv)) {
2032             sv = SvREFCNT_inc_NN(ppad[ix]);
2033         }
2034         else {
2035             sv = newSV(0);
2036             SvPADTMP_on(sv);
2037         }
2038         PL_curpad[ix] = sv;
2039     }
2040
2041     if (subclones)
2042     {
2043         if (trouble || cloned) {
2044             /* Uh-oh, we have trouble!  At least one of the state subs here
2045                has its CvOUTSIDE pointer pointing somewhere unexpected.  It
2046                could be pointing to another state protosub that we are
2047                about to clone.  So we have to track which sub clones come
2048                from which protosubs.  If the CvOUTSIDE pointer for a parti-
2049                cular sub points to something we have not cloned yet, we
2050                delay cloning it.  We must loop through the pad entries,
2051                until we get a full pass with no cloning.  If any uncloned
2052                subs remain (probably nested inside anonymous or ‘my’ subs),
2053                then they get cloned in a final pass.
2054              */
2055             bool cloned_in_this_pass;
2056             if (!cloned)
2057                 cloned = (HV *)sv_2mortal((SV *)newHV());
2058             do {
2059                 cloned_in_this_pass = FALSE;
2060                 for (ix = fpad; ix > 0; ix--) {
2061                     PADNAME * const name =
2062                         (ix <= fname) ? pname[ix] : NULL;
2063                     if (name && name != &PL_padname_undef
2064                      && !PadnameOUTER(name) && PadnamePV(name)[0] == '&'
2065                      && PadnameIsSTATE(name) && !CvCLONED(PL_curpad[ix]))
2066                     {
2067                         CV * const protokey = CvOUTSIDE(ppad[ix]);
2068                         CV ** const cvp = protokey == proto
2069                             ? &cv
2070                             : (CV **)hv_fetch(cloned, (char *)&protokey,
2071                                               sizeof(CV *), 0);
2072                         if (cvp && *cvp) {
2073                             S_cv_clone(aTHX_ (CV *)ppad[ix],
2074                                              (CV *)PL_curpad[ix],
2075                                              *cvp, cloned);
2076                             (void)hv_store(cloned, (char *)&ppad[ix],
2077                                      sizeof(CV *),
2078                                      SvREFCNT_inc_simple_NN(PL_curpad[ix]),
2079                                      0);
2080                             subclones--;
2081                             cloned_in_this_pass = TRUE;
2082                         }
2083                     }
2084                 }
2085             } while (cloned_in_this_pass);
2086             if (subclones)
2087                 for (ix = fpad; ix > 0; ix--) {
2088                     PADNAME * const name =
2089                         (ix <= fname) ? pname[ix] : NULL;
2090                     if (name && name != &PL_padname_undef
2091                      && !PadnameOUTER(name) && PadnamePV(name)[0] == '&'
2092                      && PadnameIsSTATE(name) && !CvCLONED(PL_curpad[ix]))
2093                         S_cv_clone(aTHX_ (CV *)ppad[ix],
2094                                          (CV *)PL_curpad[ix],
2095                                          CvOUTSIDE(ppad[ix]), cloned);
2096                 }
2097         }
2098         else for (ix = fpad; ix > 0; ix--) {
2099             PADNAME * const name = (ix <= fname) ? pname[ix] : NULL;
2100             if (name && name != &PL_padname_undef && !PadnameOUTER(name)
2101              && PadnamePV(name)[0] == '&' && PadnameIsSTATE(name))
2102                 S_cv_clone(aTHX_ (CV *)ppad[ix], (CV *)PL_curpad[ix], cv,
2103                                  NULL);
2104         }
2105     }
2106
2107     if (newcv) SvREFCNT_inc_simple_void_NN(cv);
2108     LEAVE;
2109
2110     if (CvCONST(cv)) {
2111         /* Constant sub () { $x } closing over $x:
2112          * The prototype was marked as a candiate for const-ization,
2113          * so try to grab the current const value, and if successful,
2114          * turn into a const sub:
2115          */
2116         SV* const_sv;
2117         OP *o = CvSTART(cv);
2118         assert(newcv);
2119         for (; o; o = o->op_next)
2120             if (o->op_type == OP_PADSV)
2121                 break;
2122         ASSUME(o->op_type == OP_PADSV);
2123         const_sv = PAD_BASE_SV(CvPADLIST(cv), o->op_targ);
2124         /* the candidate should have 1 ref from this pad and 1 ref
2125          * from the parent */
2126         if (const_sv && SvREFCNT(const_sv) == 2) {
2127             const bool was_method = cBOOL(CvMETHOD(cv));
2128             bool copied = FALSE;
2129             if (outside) {
2130                 PADNAME * const pn =
2131                     PadlistNAMESARRAY(CvPADLIST(outside))
2132                         [PARENT_PAD_INDEX(PadlistNAMESARRAY(
2133                             CvPADLIST(cv))[o->op_targ])];
2134                 assert(PadnameOUTER(PadlistNAMESARRAY(CvPADLIST(cv))
2135                                         [o->op_targ]));
2136                 if (PadnameLVALUE(pn)) {
2137                     /* We have a lexical that is potentially modifiable
2138                        elsewhere, so making a constant will break clo-
2139                        sure behaviour.  If this is a ‘simple lexical
2140                        op tree’, i.e., sub(){$x}, emit a deprecation
2141                        warning, but continue to exhibit the old behav-
2142                        iour of making it a constant based on the ref-
2143                        count of the candidate variable.
2144
2145                        A simple lexical op tree looks like this:
2146
2147                          leavesub
2148                            lineseq
2149                              nextstate
2150                              padsv
2151                      */
2152                     if (OpSIBLING(
2153                          cUNOPx(cUNOPx(CvROOT(cv))->op_first)->op_first
2154                         ) == o
2155                      && !OpSIBLING(o))
2156                     {
2157                         Perl_ck_warner_d(aTHX_
2158                                           packWARN(WARN_DEPRECATED),
2159                                          "Constants from lexical "
2160                                          "variables potentially "
2161                                          "modified elsewhere are "
2162                                          "deprecated. This will not "
2163                                          "be allowed in Perl 5.32");
2164                         /* We *copy* the lexical variable, and donate the
2165                            copy to newCONSTSUB.  Yes, this is ugly, and
2166                            should be killed.  We need to do this for the
2167                            time being, however, because turning on SvPADTMP
2168                            on a lexical will have observable effects
2169                            elsewhere.  */
2170                         const_sv = newSVsv(const_sv);
2171                         copied = TRUE;
2172                     }
2173                     else
2174                         goto constoff;
2175                 }
2176             }
2177             if (!copied)
2178                 SvREFCNT_inc_simple_void_NN(const_sv);
2179             /* If the lexical is not used elsewhere, it is safe to turn on
2180                SvPADTMP, since it is only when it is used in lvalue con-
2181                text that the difference is observable.  */
2182             SvREADONLY_on(const_sv);
2183             SvPADTMP_on(const_sv);
2184             SvREFCNT_dec_NN(cv);
2185             cv = newCONSTSUB(CvSTASH(proto), NULL, const_sv);
2186             if (was_method)
2187                 CvMETHOD_on(cv);
2188         }
2189         else {
2190           constoff:
2191             CvCONST_off(cv);
2192         }
2193     }
2194
2195     return cv;
2196 }
2197
2198 static CV *
2199 S_cv_clone(pTHX_ CV *proto, CV *cv, CV *outside, HV *cloned)
2200 {
2201 #ifdef USE_ITHREADS
2202     dVAR;
2203 #endif
2204     const bool newcv = !cv;
2205
2206     assert(!CvUNIQUE(proto));
2207
2208     if (!cv) cv = MUTABLE_CV(newSV_type(SvTYPE(proto)));
2209     CvFLAGS(cv) = CvFLAGS(proto) & ~(CVf_CLONE|CVf_WEAKOUTSIDE|CVf_CVGV_RC
2210                                     |CVf_SLABBED);
2211     CvCLONED_on(cv);
2212
2213     CvFILE(cv)          = CvDYNFILE(proto) ? savepv(CvFILE(proto))
2214                                            : CvFILE(proto);
2215     if (CvNAMED(proto))
2216          CvNAME_HEK_set(cv, share_hek_hek(CvNAME_HEK(proto)));
2217     else CvGV_set(cv,CvGV(proto));
2218     CvSTASH_set(cv, CvSTASH(proto));
2219     OP_REFCNT_LOCK;
2220     CvROOT(cv)          = OpREFCNT_inc(CvROOT(proto));
2221     OP_REFCNT_UNLOCK;
2222     CvSTART(cv)         = CvSTART(proto);
2223     CvOUTSIDE_SEQ(cv) = CvOUTSIDE_SEQ(proto);
2224
2225     if (SvPOK(proto)) {
2226         sv_setpvn(MUTABLE_SV(cv), SvPVX_const(proto), SvCUR(proto));
2227         if (SvUTF8(proto))
2228            SvUTF8_on(MUTABLE_SV(cv));
2229     }
2230     if (SvMAGIC(proto))
2231         mg_copy((SV *)proto, (SV *)cv, 0, 0);
2232
2233     if (CvPADLIST(proto))
2234         cv = S_cv_clone_pad(aTHX_ proto, cv, outside, cloned, newcv);
2235
2236     DEBUG_Xv(
2237         PerlIO_printf(Perl_debug_log, "\nPad CV clone\n");
2238         if (CvOUTSIDE(cv)) cv_dump(CvOUTSIDE(cv), "Outside");
2239         cv_dump(proto,   "Proto");
2240         cv_dump(cv,      "To");
2241     );
2242
2243     return cv;
2244 }
2245
2246 CV *
2247 Perl_cv_clone(pTHX_ CV *proto)
2248 {
2249     PERL_ARGS_ASSERT_CV_CLONE;
2250
2251     if (!CvPADLIST(proto)) Perl_croak(aTHX_ "panic: no pad in cv_clone");
2252     return S_cv_clone(aTHX_ proto, NULL, NULL, NULL);
2253 }
2254
2255 /* Called only by pp_clonecv */
2256 CV *
2257 Perl_cv_clone_into(pTHX_ CV *proto, CV *target)
2258 {
2259     PERL_ARGS_ASSERT_CV_CLONE_INTO;
2260     cv_undef(target);
2261     return S_cv_clone(aTHX_ proto, target, NULL, NULL);
2262 }
2263
2264 /*
2265 =for apidoc cv_name
2266
2267 Returns an SV containing the name of the CV, mainly for use in error
2268 reporting.  The CV may actually be a GV instead, in which case the returned
2269 SV holds the GV's name.  Anything other than a GV or CV is treated as a
2270 string already holding the sub name, but this could change in the future.
2271
2272 An SV may be passed as a second argument.  If so, the name will be assigned
2273 to it and it will be returned.  Otherwise the returned SV will be a new
2274 mortal.
2275
2276 If C<flags> has the C<CV_NAME_NOTQUAL> bit set, then the package name will not be
2277 included.  If the first argument is neither a CV nor a GV, this flag is
2278 ignored (subject to change).
2279
2280 =cut
2281 */
2282
2283 SV *
2284 Perl_cv_name(pTHX_ CV *cv, SV *sv, U32 flags)
2285 {
2286     PERL_ARGS_ASSERT_CV_NAME;
2287     if (!isGV_with_GP(cv) && SvTYPE(cv) != SVt_PVCV) {
2288         if (sv) sv_setsv(sv,(SV *)cv);
2289         return sv ? (sv) : (SV *)cv;
2290     }
2291     {
2292         SV * const retsv = sv ? (sv) : sv_newmortal();
2293         if (SvTYPE(cv) == SVt_PVCV) {
2294             if (CvNAMED(cv)) {
2295                 if (CvLEXICAL(cv) || flags & CV_NAME_NOTQUAL)
2296                     sv_sethek(retsv, CvNAME_HEK(cv));
2297                 else {
2298                     if (CvSTASH(cv) && HvNAME_HEK(CvSTASH(cv)))
2299                         sv_sethek(retsv, HvNAME_HEK(CvSTASH(cv)));
2300                     else
2301                         sv_setpvs(retsv, "__ANON__");
2302                     sv_catpvs(retsv, "::");
2303                     sv_cathek(retsv, CvNAME_HEK(cv));
2304                 }
2305             }
2306             else if (CvLEXICAL(cv) || flags & CV_NAME_NOTQUAL)
2307                 sv_sethek(retsv, GvNAME_HEK(GvEGV(CvGV(cv))));
2308             else gv_efullname3(retsv, CvGV(cv), NULL);
2309         }
2310         else if (flags & CV_NAME_NOTQUAL) sv_sethek(retsv, GvNAME_HEK(cv));
2311         else gv_efullname3(retsv,(GV *)cv,NULL);
2312         return retsv;
2313     }
2314 }
2315
2316 /*
2317 =for apidoc m|void|pad_fixup_inner_anons|PADLIST *padlist|CV *old_cv|CV *new_cv
2318
2319 For any anon CVs in the pad, change C<CvOUTSIDE> of that CV from
2320 C<old_cv> to C<new_cv> if necessary.  Needed when a newly-compiled CV has to be
2321 moved to a pre-existing CV struct.
2322
2323 =cut
2324 */
2325
2326 void
2327 Perl_pad_fixup_inner_anons(pTHX_ PADLIST *padlist, CV *old_cv, CV *new_cv)
2328 {
2329     PADOFFSET ix;
2330     PADNAMELIST * const comppad_name = PadlistNAMES(padlist);
2331     AV * const comppad = PadlistARRAY(padlist)[1];
2332     PADNAME ** const namepad = PadnamelistARRAY(comppad_name);
2333     SV ** const curpad = AvARRAY(comppad);
2334
2335     PERL_ARGS_ASSERT_PAD_FIXUP_INNER_ANONS;
2336     PERL_UNUSED_ARG(old_cv);
2337
2338     for (ix = PadnamelistMAX(comppad_name); ix > 0; ix--) {
2339         const PADNAME *name = namepad[ix];
2340         if (name && name != &PL_padname_undef && !PadnameIsOUR(name)
2341             && *PadnamePV(name) == '&')
2342         {
2343           CV *innercv = MUTABLE_CV(curpad[ix]);
2344           if (UNLIKELY(PadnameOUTER(name))) {
2345             CV *cv = new_cv;
2346             PADNAME **names = namepad;
2347             PADOFFSET i = ix;
2348             while (PadnameOUTER(name)) {
2349                 assert(SvTYPE(cv) == SVt_PVCV);
2350                 cv = CvOUTSIDE(cv);
2351                 names = PadlistNAMESARRAY(CvPADLIST(cv));
2352                 i = PARENT_PAD_INDEX(name);
2353                 name = names[i];
2354             }
2355             innercv = (CV *)PadARRAY(PadlistARRAY(CvPADLIST(cv))[1])[i];
2356           }
2357           if (SvTYPE(innercv) == SVt_PVCV) {
2358             /* XXX 0afba48f added code here to check for a proto CV
2359                    attached to the pad entry by magic.  But shortly there-
2360                    after 81df9f6f95 moved the magic to the pad name.  The
2361                    code here was never updated, so it wasn’t doing anything
2362                    and got deleted when PADNAME became a distinct type.  Is
2363                    there any bug as a result?  */
2364             if (CvOUTSIDE(innercv) == old_cv) {
2365                 if (!CvWEAKOUTSIDE(innercv)) {
2366                     SvREFCNT_dec(old_cv);
2367                     SvREFCNT_inc_simple_void_NN(new_cv);
2368                 }
2369                 CvOUTSIDE(innercv) = new_cv;
2370             }
2371           }
2372           else { /* format reference */
2373             SV * const rv = curpad[ix];
2374             CV *innercv;
2375             if (!SvOK(rv)) continue;
2376             assert(SvROK(rv));
2377             assert(SvWEAKREF(rv));
2378             innercv = (CV *)SvRV(rv);
2379             assert(!CvWEAKOUTSIDE(innercv));
2380             assert(CvOUTSIDE(innercv) == old_cv);
2381             SvREFCNT_dec(CvOUTSIDE(innercv));
2382             CvOUTSIDE(innercv) = (CV *)SvREFCNT_inc_simple_NN(new_cv);
2383           }
2384         }
2385     }
2386 }
2387
2388 /*
2389 =for apidoc m|void|pad_push|PADLIST *padlist|int depth
2390
2391 Push a new pad frame onto the padlist, unless there's already a pad at
2392 this depth, in which case don't bother creating a new one.  Then give
2393 the new pad an C<@_> in slot zero.
2394
2395 =cut
2396 */
2397
2398 void
2399 Perl_pad_push(pTHX_ PADLIST *padlist, int depth)
2400 {
2401     PERL_ARGS_ASSERT_PAD_PUSH;
2402
2403     if (depth > PadlistMAX(padlist) || !PadlistARRAY(padlist)[depth]) {
2404         PAD** const svp = PadlistARRAY(padlist);
2405         AV* const newpad = newAV();
2406         SV** const oldpad = AvARRAY(svp[depth-1]);
2407         PADOFFSET ix = AvFILLp((const AV *)svp[1]);
2408         const PADOFFSET names_fill = PadnamelistMAX((PADNAMELIST *)svp[0]);
2409         PADNAME ** const names = PadnamelistARRAY((PADNAMELIST *)svp[0]);
2410         AV *av;
2411
2412         for ( ;ix > 0; ix--) {
2413             if (names_fill >= ix && PadnameLEN(names[ix])) {
2414                 const char sigil = PadnamePV(names[ix])[0];
2415                 if (PadnameOUTER(names[ix])
2416                         || PadnameIsSTATE(names[ix])
2417                         || sigil == '&')
2418                 {
2419                     /* outer lexical or anon code */
2420                     av_store(newpad, ix, SvREFCNT_inc(oldpad[ix]));
2421                 }
2422                 else {          /* our own lexical */
2423                     SV *sv; 
2424                     if (sigil == '@')
2425                         sv = MUTABLE_SV(newAV());
2426                     else if (sigil == '%')
2427                         sv = MUTABLE_SV(newHV());
2428                     else
2429                         sv = newSV(0);
2430                     av_store(newpad, ix, sv);
2431                 }
2432             }
2433             else if (PadnamePV(names[ix])) {
2434                 av_store(newpad, ix, SvREFCNT_inc_NN(oldpad[ix]));
2435             }
2436             else {
2437                 /* save temporaries on recursion? */
2438                 SV * const sv = newSV(0);
2439                 av_store(newpad, ix, sv);
2440                 SvPADTMP_on(sv);
2441             }
2442         }
2443         av = newAV();
2444         av_store(newpad, 0, MUTABLE_SV(av));
2445         AvREIFY_only(av);
2446
2447         padlist_store(padlist, depth, newpad);
2448     }
2449 }
2450
2451 #if defined(USE_ITHREADS)
2452
2453 #  define av_dup_inc(s,t)       MUTABLE_AV(sv_dup_inc((const SV *)s,t))
2454
2455 /*
2456 =for apidoc padlist_dup
2457
2458 Duplicates a pad.
2459
2460 =cut
2461 */
2462
2463 PADLIST *
2464 Perl_padlist_dup(pTHX_ PADLIST *srcpad, CLONE_PARAMS *param)
2465 {
2466     PADLIST *dstpad;
2467     bool cloneall;
2468     PADOFFSET max;
2469
2470     PERL_ARGS_ASSERT_PADLIST_DUP;
2471
2472     cloneall = cBOOL(param->flags & CLONEf_COPY_STACKS);
2473     assert (SvREFCNT(PadlistARRAY(srcpad)[1]) == 1);
2474
2475     max = cloneall ? PadlistMAX(srcpad) : 1;
2476
2477     Newx(dstpad, 1, PADLIST);
2478     ptr_table_store(PL_ptr_table, srcpad, dstpad);
2479     PadlistMAX(dstpad) = max;
2480     Newx(PadlistARRAY(dstpad), max + 1, PAD *);
2481
2482     PadlistARRAY(dstpad)[0] = (PAD *)
2483             padnamelist_dup(PadlistNAMES(srcpad), param);
2484     PadnamelistREFCNT(PadlistNAMES(dstpad))++;
2485     if (cloneall) {
2486         PADOFFSET depth;
2487         for (depth = 1; depth <= max; ++depth)
2488             PadlistARRAY(dstpad)[depth] =
2489                 av_dup_inc(PadlistARRAY(srcpad)[depth], param);
2490     } else {
2491         /* CvDEPTH() on our subroutine will be set to 0, so there's no need
2492            to build anything other than the first level of pads.  */
2493         PADOFFSET ix = AvFILLp(PadlistARRAY(srcpad)[1]);
2494         AV *pad1;
2495         const PADOFFSET names_fill = PadnamelistMAX(PadlistNAMES(srcpad));
2496         const PAD *const srcpad1 = PadlistARRAY(srcpad)[1];
2497         SV **oldpad = AvARRAY(srcpad1);
2498         PADNAME ** const names = PadnamelistARRAY(PadlistNAMES(dstpad));
2499         SV **pad1a;
2500         AV *args;
2501
2502         pad1 = newAV();
2503
2504         av_extend(pad1, ix);
2505         PadlistARRAY(dstpad)[1] = pad1;
2506         pad1a = AvARRAY(pad1);
2507
2508         if (ix > -1) {
2509             AvFILLp(pad1) = ix;
2510
2511             for ( ;ix > 0; ix--) {
2512                 if (!oldpad[ix]) {
2513                     pad1a[ix] = NULL;
2514                 } else if (names_fill >= ix && names[ix] &&
2515                            PadnameLEN(names[ix])) {
2516                     const char sigil = PadnamePV(names[ix])[0];
2517                     if (PadnameOUTER(names[ix])
2518                         || PadnameIsSTATE(names[ix])
2519                         || sigil == '&')
2520                         {
2521                             /* outer lexical or anon code */
2522                             pad1a[ix] = sv_dup_inc(oldpad[ix], param);
2523                         }
2524                     else {              /* our own lexical */
2525                         if(SvPADSTALE(oldpad[ix]) && SvREFCNT(oldpad[ix]) > 1) {
2526                             /* This is a work around for how the current
2527                                implementation of ?{ } blocks in regexps
2528                                interacts with lexicals.  */
2529                             pad1a[ix] = sv_dup_inc(oldpad[ix], param);
2530                         } else {
2531                             SV *sv; 
2532                             
2533                             if (sigil == '@')
2534                                 sv = MUTABLE_SV(newAV());
2535                             else if (sigil == '%')
2536                                 sv = MUTABLE_SV(newHV());
2537                             else
2538                                 sv = newSV(0);
2539                             pad1a[ix] = sv;
2540                         }
2541                     }
2542                 }
2543                 else if ((  names_fill >= ix && names[ix]
2544                          && PadnamePV(names[ix])  )) {
2545                     pad1a[ix] = sv_dup_inc(oldpad[ix], param);
2546                 }
2547                 else {
2548                     /* save temporaries on recursion? */
2549                     SV * const sv = newSV(0);
2550                     pad1a[ix] = sv;
2551
2552                     /* SvREFCNT(oldpad[ix]) != 1 for some code in threads.xs
2553                        FIXTHAT before merging this branch.
2554                        (And I know how to) */
2555                     if (SvPADTMP(oldpad[ix]))
2556                         SvPADTMP_on(sv);
2557                 }
2558             }
2559
2560             if (oldpad[0]) {
2561                 args = newAV();                 /* Will be @_ */
2562                 AvREIFY_only(args);
2563                 pad1a[0] = (SV *)args;
2564             }
2565         }
2566     }
2567
2568     return dstpad;
2569 }
2570
2571 #endif /* USE_ITHREADS */
2572
2573 PAD **
2574 Perl_padlist_store(pTHX_ PADLIST *padlist, I32 key, PAD *val)
2575 {
2576     PAD **ary;
2577     SSize_t const oldmax = PadlistMAX(padlist);
2578
2579     PERL_ARGS_ASSERT_PADLIST_STORE;
2580
2581     assert(key >= 0);
2582
2583     if (key > PadlistMAX(padlist)) {
2584         av_extend_guts(NULL,key,&PadlistMAX(padlist),
2585                        (SV ***)&PadlistARRAY(padlist),
2586                        (SV ***)&PadlistARRAY(padlist));
2587         Zero(PadlistARRAY(padlist)+oldmax+1, PadlistMAX(padlist)-oldmax,
2588              PAD *);
2589     }
2590     ary = PadlistARRAY(padlist);
2591     SvREFCNT_dec(ary[key]);
2592     ary[key] = val;
2593     return &ary[key];
2594 }
2595
2596 /*
2597 =for apidoc newPADNAMELIST
2598
2599 Creates a new pad name list.  C<max> is the highest index for which space
2600 is allocated.
2601
2602 =cut
2603 */
2604
2605 PADNAMELIST *
2606 Perl_newPADNAMELIST(size_t max)
2607 {
2608     PADNAMELIST *pnl;
2609     Newx(pnl, 1, PADNAMELIST);
2610     Newxz(PadnamelistARRAY(pnl), max+1, PADNAME *);
2611     PadnamelistMAX(pnl) = -1;
2612     PadnamelistREFCNT(pnl) = 1;
2613     PadnamelistMAXNAMED(pnl) = 0;
2614     pnl->xpadnl_max = max;
2615     return pnl;
2616 }
2617
2618 /*
2619 =for apidoc padnamelist_store
2620
2621 Stores the pad name (which may be null) at the given index, freeing any
2622 existing pad name in that slot.
2623
2624 =cut
2625 */
2626
2627 PADNAME **
2628 Perl_padnamelist_store(pTHX_ PADNAMELIST *pnl, SSize_t key, PADNAME *val)
2629 {
2630     PADNAME **ary;
2631
2632     PERL_ARGS_ASSERT_PADNAMELIST_STORE;
2633
2634     assert(key >= 0);
2635
2636     if (key > pnl->xpadnl_max)
2637         av_extend_guts(NULL,key,&pnl->xpadnl_max,
2638                        (SV ***)&PadnamelistARRAY(pnl),
2639                        (SV ***)&PadnamelistARRAY(pnl));
2640     if (PadnamelistMAX(pnl) < key) {
2641         Zero(PadnamelistARRAY(pnl)+PadnamelistMAX(pnl)+1,
2642              key-PadnamelistMAX(pnl), PADNAME *);
2643         PadnamelistMAX(pnl) = key;
2644     }
2645     ary = PadnamelistARRAY(pnl);
2646     if (ary[key])
2647         PadnameREFCNT_dec(ary[key]);
2648     ary[key] = val;
2649     return &ary[key];
2650 }
2651
2652 /*
2653 =for apidoc padnamelist_fetch
2654
2655 Fetches the pad name from the given index.
2656
2657 =cut
2658 */
2659
2660 PADNAME *
2661 Perl_padnamelist_fetch(PADNAMELIST *pnl, SSize_t key)
2662 {
2663     PERL_ARGS_ASSERT_PADNAMELIST_FETCH;
2664     ASSUME(key >= 0);
2665
2666     return key > PadnamelistMAX(pnl) ? NULL : PadnamelistARRAY(pnl)[key];
2667 }
2668
2669 void
2670 Perl_padnamelist_free(pTHX_ PADNAMELIST *pnl)
2671 {
2672     PERL_ARGS_ASSERT_PADNAMELIST_FREE;
2673     if (!--PadnamelistREFCNT(pnl)) {
2674         while(PadnamelistMAX(pnl) >= 0)
2675         {
2676             PADNAME * const pn =
2677                 PadnamelistARRAY(pnl)[PadnamelistMAX(pnl)--];
2678             if (pn)
2679                 PadnameREFCNT_dec(pn);
2680         }
2681         Safefree(PadnamelistARRAY(pnl));
2682         Safefree(pnl);
2683     }
2684 }
2685
2686 #if defined(USE_ITHREADS)
2687
2688 /*
2689 =for apidoc padnamelist_dup
2690
2691 Duplicates a pad name list.
2692
2693 =cut
2694 */
2695
2696 PADNAMELIST *
2697 Perl_padnamelist_dup(pTHX_ PADNAMELIST *srcpad, CLONE_PARAMS *param)
2698 {
2699     PADNAMELIST *dstpad;
2700     SSize_t max = PadnamelistMAX(srcpad);
2701
2702     PERL_ARGS_ASSERT_PADNAMELIST_DUP;
2703
2704     /* look for it in the table first */
2705     dstpad = (PADNAMELIST *)ptr_table_fetch(PL_ptr_table, srcpad);
2706     if (dstpad)
2707         return dstpad;
2708
2709     dstpad = newPADNAMELIST(max);
2710     PadnamelistREFCNT(dstpad) = 0; /* The caller will increment it.  */
2711     PadnamelistMAXNAMED(dstpad) = PadnamelistMAXNAMED(srcpad);
2712     PadnamelistMAX(dstpad) = max;
2713
2714     ptr_table_store(PL_ptr_table, srcpad, dstpad);
2715     for (; max >= 0; max--)
2716       if (PadnamelistARRAY(srcpad)[max]) {
2717         PadnamelistARRAY(dstpad)[max] =
2718             padname_dup(PadnamelistARRAY(srcpad)[max], param);
2719         PadnameREFCNT(PadnamelistARRAY(dstpad)[max])++;
2720       }
2721
2722     return dstpad;
2723 }
2724
2725 #endif /* USE_ITHREADS */
2726
2727 /*
2728 =for apidoc newPADNAMEpvn
2729
2730 Constructs and returns a new pad name.  C<s> must be a UTF-8 string.  Do not
2731 use this for pad names that point to outer lexicals.  See
2732 C<L</newPADNAMEouter>>.
2733
2734 =cut
2735 */
2736
2737 PADNAME *
2738 Perl_newPADNAMEpvn(const char *s, STRLEN len)
2739 {
2740     struct padname_with_str *alloc;
2741     char *alloc2; /* for Newxz */
2742     PADNAME *pn;
2743     PERL_ARGS_ASSERT_NEWPADNAMEPVN;
2744     Newxz(alloc2,
2745           STRUCT_OFFSET(struct padname_with_str, xpadn_str[0]) + len + 1,
2746           char);
2747     alloc = (struct padname_with_str *)alloc2;
2748     pn = (PADNAME *)alloc;
2749     PadnameREFCNT(pn) = 1;
2750     PadnamePV(pn) = alloc->xpadn_str;
2751     Copy(s, PadnamePV(pn), len, char);
2752     *(PadnamePV(pn) + len) = '\0';
2753     PadnameLEN(pn) = len;
2754     return pn;
2755 }
2756
2757 /*
2758 =for apidoc newPADNAMEouter
2759
2760 Constructs and returns a new pad name.  Only use this function for names
2761 that refer to outer lexicals.  (See also L</newPADNAMEpvn>.)  C<outer> is
2762 the outer pad name that this one mirrors.  The returned pad name has the
2763 C<PADNAMEt_OUTER> flag already set.
2764
2765 =cut
2766 */
2767
2768 PADNAME *
2769 Perl_newPADNAMEouter(PADNAME *outer)
2770 {
2771     PADNAME *pn;
2772     PERL_ARGS_ASSERT_NEWPADNAMEOUTER;
2773     Newxz(pn, 1, PADNAME);
2774     PadnameREFCNT(pn) = 1;
2775     PadnamePV(pn) = PadnamePV(outer);
2776     /* Not PadnameREFCNT(outer), because ‘outer’ may itself close over
2777        another entry.  The original pad name owns the buffer.  */
2778     PadnameREFCNT(PADNAME_FROM_PV(PadnamePV(outer)))++;
2779     PadnameFLAGS(pn) = PADNAMEt_OUTER;
2780     PadnameLEN(pn) = PadnameLEN(outer);
2781     return pn;
2782 }
2783
2784 void
2785 Perl_padname_free(pTHX_ PADNAME *pn)
2786 {
2787     PERL_ARGS_ASSERT_PADNAME_FREE;
2788     if (!--PadnameREFCNT(pn)) {
2789         if (UNLIKELY(pn == &PL_padname_undef || pn == &PL_padname_const)) {
2790             PadnameREFCNT(pn) = SvREFCNT_IMMORTAL;
2791             return;
2792         }
2793         SvREFCNT_dec(PadnameTYPE(pn)); /* Takes care of protocv, too.  */
2794         SvREFCNT_dec(PadnameOURSTASH(pn));
2795         if (PadnameOUTER(pn))
2796             PadnameREFCNT_dec(PADNAME_FROM_PV(PadnamePV(pn)));
2797         Safefree(pn);
2798     }
2799 }
2800
2801 #if defined(USE_ITHREADS)
2802
2803 /*
2804 =for apidoc padname_dup
2805
2806 Duplicates a pad name.
2807
2808 =cut
2809 */
2810
2811 PADNAME *
2812 Perl_padname_dup(pTHX_ PADNAME *src, CLONE_PARAMS *param)
2813 {
2814     PADNAME *dst;
2815
2816     PERL_ARGS_ASSERT_PADNAME_DUP;
2817
2818     /* look for it in the table first */
2819     dst = (PADNAME *)ptr_table_fetch(PL_ptr_table, src);
2820     if (dst)
2821         return dst;
2822
2823     if (!PadnamePV(src)) {
2824         dst = &PL_padname_undef;
2825         ptr_table_store(PL_ptr_table, src, dst);
2826         return dst;
2827     }
2828
2829     dst = PadnameOUTER(src)
2830      ? newPADNAMEouter(padname_dup(PADNAME_FROM_PV(PadnamePV(src)), param))
2831      : newPADNAMEpvn(PadnamePV(src), PadnameLEN(src));
2832     ptr_table_store(PL_ptr_table, src, dst);
2833     PadnameLEN(dst) = PadnameLEN(src);
2834     PadnameFLAGS(dst) = PadnameFLAGS(src);
2835     PadnameREFCNT(dst) = 0; /* The caller will increment it.  */
2836     PadnameTYPE   (dst) = (HV *)sv_dup_inc((SV *)PadnameTYPE(src), param);
2837     PadnameOURSTASH(dst) = (HV *)sv_dup_inc((SV *)PadnameOURSTASH(src),
2838                                             param);
2839     dst->xpadn_low  = src->xpadn_low;
2840     dst->xpadn_high = src->xpadn_high;
2841     dst->xpadn_gen  = src->xpadn_gen;
2842     return dst;
2843 }
2844
2845 #endif /* USE_ITHREADS */
2846
2847 /*
2848  * ex: set ts=8 sts=4 sw=4 et:
2849  */