This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Refactoring to Sv*_set() macros - patch #5
[perl5.git] / scope.c
1 /*    scope.c
2  *
3  *    Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4  *    2000, 2001, 2002, 2003, 2004, 2005, 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 /*
12  * "For the fashion of Minas Tirith was such that it was built on seven
13  * levels..."
14  */
15
16 /* This file contains functions to manipulate several of Perl's stacks;
17  * in particular it contains code to push various types of things onto
18  * the savestack, then to pop them off and perform the correct restorative
19  * action for each one. This corresponds to the cleanup Perl does at
20  * each scope exit.
21  */
22
23 #include "EXTERN.h"
24 #define PERL_IN_SCOPE_C
25 #include "perl.h"
26
27 SV**
28 Perl_stack_grow(pTHX_ SV **sp, SV **p, int n)
29 {
30     PL_stack_sp = sp;
31 #ifndef STRESS_REALLOC
32     av_extend(PL_curstack, (p - PL_stack_base) + (n) + 128);
33 #else
34     av_extend(PL_curstack, (p - PL_stack_base) + (n) + 1);
35 #endif
36     return PL_stack_sp;
37 }
38
39 #ifndef STRESS_REALLOC
40 #define GROW(old) ((old) * 3 / 2)
41 #else
42 #define GROW(old) ((old) + 1)
43 #endif
44
45 PERL_SI *
46 Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems)
47 {
48     PERL_SI *si;
49     New(56, si, 1, PERL_SI);
50     si->si_stack = newAV();
51     AvREAL_off(si->si_stack);
52     av_extend(si->si_stack, stitems > 0 ? stitems-1 : 0);
53     AvALLOC(si->si_stack)[0] = &PL_sv_undef;
54     AvFILLp(si->si_stack) = 0;
55     si->si_prev = 0;
56     si->si_next = 0;
57     si->si_cxmax = cxitems - 1;
58     si->si_cxix = -1;
59     si->si_type = PERLSI_UNDEF;
60     New(56, si->si_cxstack, cxitems, PERL_CONTEXT);
61     /* Without any kind of initialising PUSHSUBST()
62      * in pp_subst() will read uninitialised heap. */
63     Poison(si->si_cxstack, cxitems, PERL_CONTEXT);
64     return si;
65 }
66
67 I32
68 Perl_cxinc(pTHX)
69 {
70     IV old_max = cxstack_max;
71     cxstack_max = GROW(cxstack_max);
72     Renew(cxstack, cxstack_max + 1, PERL_CONTEXT);      /* XXX should fix CXINC macro */
73     /* Without any kind of initialising deep enough recursion
74      * will end up reading uninitialised PERL_CONTEXTs. */
75     Poison(cxstack + old_max + 1, cxstack_max - old_max, PERL_CONTEXT);
76     return cxstack_ix + 1;
77 }
78
79 void
80 Perl_push_scope(pTHX)
81 {
82     if (PL_scopestack_ix == PL_scopestack_max) {
83         PL_scopestack_max = GROW(PL_scopestack_max);
84         Renew(PL_scopestack, PL_scopestack_max, I32);
85     }
86     PL_scopestack[PL_scopestack_ix++] = PL_savestack_ix;
87
88 }
89
90 void
91 Perl_pop_scope(pTHX)
92 {
93     const I32 oldsave = PL_scopestack[--PL_scopestack_ix];
94     LEAVE_SCOPE(oldsave);
95 }
96
97 void
98 Perl_markstack_grow(pTHX)
99 {
100     const I32 oldmax = PL_markstack_max - PL_markstack;
101     const I32 newmax = GROW(oldmax);
102
103     Renew(PL_markstack, newmax, I32);
104     PL_markstack_ptr = PL_markstack + oldmax;
105     PL_markstack_max = PL_markstack + newmax;
106 }
107
108 void
109 Perl_savestack_grow(pTHX)
110 {
111     PL_savestack_max = GROW(PL_savestack_max) + 4;
112     Renew(PL_savestack, PL_savestack_max, ANY);
113 }
114
115 void
116 Perl_savestack_grow_cnt(pTHX_ I32 need)
117 {
118     PL_savestack_max = PL_savestack_ix + need;
119     Renew(PL_savestack, PL_savestack_max, ANY);
120 }
121
122 #undef GROW
123
124 void
125 Perl_tmps_grow(pTHX_ I32 n)
126 {
127 #ifndef STRESS_REALLOC
128     if (n < 128)
129         n = (PL_tmps_max < 512) ? 128 : 512;
130 #endif
131     PL_tmps_max = PL_tmps_ix + n + 1;
132     Renew(PL_tmps_stack, PL_tmps_max, SV*);
133 }
134
135
136 void
137 Perl_free_tmps(pTHX)
138 {
139     /* XXX should tmps_floor live in cxstack? */
140     const I32 myfloor = PL_tmps_floor;
141     while (PL_tmps_ix > myfloor) {      /* clean up after last statement */
142         SV* sv = PL_tmps_stack[PL_tmps_ix];
143         PL_tmps_stack[PL_tmps_ix--] = Nullsv;
144         if (sv && sv != &PL_sv_undef) {
145             SvTEMP_off(sv);
146             SvREFCNT_dec(sv);           /* note, can modify tmps_ix!!! */
147         }
148     }
149 }
150
151 STATIC SV *
152 S_save_scalar_at(pTHX_ SV **sptr)
153 {
154     register SV *sv;
155     SV *osv = *sptr;
156
157     sv = *sptr = NEWSV(0,0);
158     if (SvTYPE(osv) >= SVt_PVMG && SvMAGIC(osv) && SvTYPE(osv) != SVt_PVGV) {
159         MAGIC *mg;
160         sv_upgrade(sv, SvTYPE(osv));
161         if (SvGMAGICAL(osv)) {
162             const bool oldtainted = PL_tainted;
163             mg_get(osv);                /* note, can croak! */
164             if (PL_tainting && PL_tainted &&
165                         (mg = mg_find(osv, PERL_MAGIC_taint))) {
166                 SAVESPTR(mg->mg_obj);
167                 mg->mg_obj = osv;
168             }
169             SvFLAGS(osv) |= (SvFLAGS(osv) &
170                (SVp_NOK|SVp_POK)) >> PRIVSHIFT;
171             PL_tainted = oldtainted;
172         }
173         SvMAGIC_set(sv, SvMAGIC(osv));
174         /* if it's a special scalar or if it has no 'set' magic,
175          * propagate the SvREADONLY flag. --rgs 20030922 */
176         for (mg = SvMAGIC(sv); mg; mg = mg->mg_moremagic) {
177             if (mg->mg_type == '\0'
178                     || !(mg->mg_virtual && mg->mg_virtual->svt_set))
179             {
180                 SvFLAGS(sv) |= SvREADONLY(osv);
181                 break;
182             }
183         }
184         SvFLAGS(sv) |= SvMAGICAL(osv);
185         /* XXX SvMAGIC() is *shared* between osv and sv.  This can
186          * lead to coredumps when both SVs are destroyed without one
187          * of their SvMAGIC() slots being NULLed. */
188         PL_localizing = 1;
189         SvSETMAGIC(sv);
190         PL_localizing = 0;
191     }
192     return sv;
193 }
194
195 SV *
196 Perl_save_scalar(pTHX_ GV *gv)
197 {
198     SV **sptr = &GvSV(gv);
199     SSCHECK(3);
200     SSPUSHPTR(SvREFCNT_inc(gv));
201     SSPUSHPTR(SvREFCNT_inc(*sptr));
202     SSPUSHINT(SAVEt_SV);
203     return save_scalar_at(sptr);
204 }
205
206 SV*
207 Perl_save_svref(pTHX_ SV **sptr)
208 {
209     SSCHECK(3);
210     SSPUSHPTR(sptr);
211     SSPUSHPTR(SvREFCNT_inc(*sptr));
212     SSPUSHINT(SAVEt_SVREF);
213     return save_scalar_at(sptr);
214 }
215
216 /* Like save_sptr(), but also SvREFCNT_dec()s the new value.  Can be used to
217  * restore a global SV to its prior contents, freeing new value. */
218 void
219 Perl_save_generic_svref(pTHX_ SV **sptr)
220 {
221     SSCHECK(3);
222     SSPUSHPTR(sptr);
223     SSPUSHPTR(SvREFCNT_inc(*sptr));
224     SSPUSHINT(SAVEt_GENERIC_SVREF);
225 }
226
227 /* Like save_pptr(), but also Safefree()s the new value if it is different
228  * from the old one.  Can be used to restore a global char* to its prior
229  * contents, freeing new value. */
230 void
231 Perl_save_generic_pvref(pTHX_ char **str)
232 {
233     SSCHECK(3);
234     SSPUSHPTR(str);
235     SSPUSHPTR(*str);
236     SSPUSHINT(SAVEt_GENERIC_PVREF);
237 }
238
239 /* Like save_generic_pvref(), but uses PerlMemShared_free() rather than Safefree().
240  * Can be used to restore a shared global char* to its prior
241  * contents, freeing new value. */
242 void
243 Perl_save_shared_pvref(pTHX_ char **str)
244 {
245     SSCHECK(3);
246     SSPUSHPTR(str);
247     SSPUSHPTR(*str);
248     SSPUSHINT(SAVEt_SHARED_PVREF);
249 }
250
251 /* set the SvFLAGS specified by mask to the values in val */
252
253 void
254 Perl_save_set_svflags(pTHX_ SV* sv, U32 mask, U32 val)
255 {
256     SSCHECK(4);
257     SSPUSHPTR(sv);
258     SSPUSHINT(mask);
259     SSPUSHINT(val);
260     SSPUSHINT(SAVEt_SET_SVFLAGS);
261 }
262
263 void
264 Perl_save_gp(pTHX_ GV *gv, I32 empty)
265 {
266     SSGROW(6);
267     SSPUSHIV((IV)SvLEN(gv));
268     SvLEN_set(gv, 0); /* forget that anything was allocated here */
269     SSPUSHIV((IV)SvCUR(gv));
270     SSPUSHPTR(SvPVX(gv));
271     SvPOK_off(gv);
272     SSPUSHPTR(SvREFCNT_inc(gv));
273     SSPUSHPTR(GvGP(gv));
274     SSPUSHINT(SAVEt_GP);
275
276     if (empty) {
277         register GP *gp;
278
279         Newz(602, gp, 1, GP);
280
281         if (GvCVu(gv))
282             PL_sub_generation++;        /* taking a method out of circulation */
283         if (GvIOp(gv) && (IoFLAGS(GvIOp(gv)) & IOf_ARGV)) {
284             gp->gp_io = newIO();
285             IoFLAGS(gp->gp_io) |= IOf_ARGV|IOf_START;
286         }
287         GvGP(gv) = gp_ref(gp);
288         GvSV(gv) = NEWSV(72,0);
289         GvLINE(gv) = CopLINE(PL_curcop);
290         /* XXX Ideally this cast would be replaced with a change to const char*
291            in the struct.  */
292         GvFILE(gv) = CopFILE(PL_curcop) ? CopFILE(PL_curcop) : (char *) "";
293         GvEGV(gv) = gv;
294     }
295     else {
296         gp_ref(GvGP(gv));
297         GvINTRO_on(gv);
298     }
299 }
300
301 AV *
302 Perl_save_ary(pTHX_ GV *gv)
303 {
304     AV *oav = GvAVn(gv);
305     AV *av;
306
307     if (!AvREAL(oav) && AvREIFY(oav))
308         av_reify(oav);
309     SSCHECK(3);
310     SSPUSHPTR(gv);
311     SSPUSHPTR(oav);
312     SSPUSHINT(SAVEt_AV);
313
314     GvAV(gv) = Null(AV*);
315     av = GvAVn(gv);
316     if (SvMAGIC(oav)) {
317         SvMAGIC_set(av, SvMAGIC(oav));
318         SvFLAGS((SV*)av) |= SvMAGICAL(oav);
319         SvMAGICAL_off(oav);
320         SvMAGIC_set(oav, NULL);
321         PL_localizing = 1;
322         SvSETMAGIC((SV*)av);
323         PL_localizing = 0;
324     }
325     return av;
326 }
327
328 HV *
329 Perl_save_hash(pTHX_ GV *gv)
330 {
331     HV *ohv, *hv;
332
333     SSCHECK(3);
334     SSPUSHPTR(gv);
335     SSPUSHPTR(ohv = GvHVn(gv));
336     SSPUSHINT(SAVEt_HV);
337
338     GvHV(gv) = Null(HV*);
339     hv = GvHVn(gv);
340     if (SvMAGIC(ohv)) {
341         SvMAGIC_set(hv, SvMAGIC(ohv));
342         SvFLAGS((SV*)hv) |= SvMAGICAL(ohv);
343         SvMAGICAL_off(ohv);
344         SvMAGIC_set(ohv, NULL);
345         PL_localizing = 1;
346         SvSETMAGIC((SV*)hv);
347         PL_localizing = 0;
348     }
349     return hv;
350 }
351
352 void
353 Perl_save_item(pTHX_ register SV *item)
354 {
355     register SV *sv = newSVsv(item);
356
357     SSCHECK(3);
358     SSPUSHPTR(item);            /* remember the pointer */
359     SSPUSHPTR(sv);              /* remember the value */
360     SSPUSHINT(SAVEt_ITEM);
361 }
362
363 void
364 Perl_save_int(pTHX_ int *intp)
365 {
366     SSCHECK(3);
367     SSPUSHINT(*intp);
368     SSPUSHPTR(intp);
369     SSPUSHINT(SAVEt_INT);
370 }
371
372 void
373 Perl_save_long(pTHX_ long int *longp)
374 {
375     SSCHECK(3);
376     SSPUSHLONG(*longp);
377     SSPUSHPTR(longp);
378     SSPUSHINT(SAVEt_LONG);
379 }
380
381 void
382 Perl_save_bool(pTHX_ bool *boolp)
383 {
384     SSCHECK(3);
385     SSPUSHBOOL(*boolp);
386     SSPUSHPTR(boolp);
387     SSPUSHINT(SAVEt_BOOL);
388 }
389
390 void
391 Perl_save_I32(pTHX_ I32 *intp)
392 {
393     SSCHECK(3);
394     SSPUSHINT(*intp);
395     SSPUSHPTR(intp);
396     SSPUSHINT(SAVEt_I32);
397 }
398
399 void
400 Perl_save_I16(pTHX_ I16 *intp)
401 {
402     SSCHECK(3);
403     SSPUSHINT(*intp);
404     SSPUSHPTR(intp);
405     SSPUSHINT(SAVEt_I16);
406 }
407
408 void
409 Perl_save_I8(pTHX_ I8 *bytep)
410 {
411     SSCHECK(3);
412     SSPUSHINT(*bytep);
413     SSPUSHPTR(bytep);
414     SSPUSHINT(SAVEt_I8);
415 }
416
417 void
418 Perl_save_iv(pTHX_ IV *ivp)
419 {
420     SSCHECK(3);
421     SSPUSHIV(*ivp);
422     SSPUSHPTR(ivp);
423     SSPUSHINT(SAVEt_IV);
424 }
425
426 /* Cannot use save_sptr() to store a char* since the SV** cast will
427  * force word-alignment and we'll miss the pointer.
428  */
429 void
430 Perl_save_pptr(pTHX_ char **pptr)
431 {
432     SSCHECK(3);
433     SSPUSHPTR(*pptr);
434     SSPUSHPTR(pptr);
435     SSPUSHINT(SAVEt_PPTR);
436 }
437
438 void
439 Perl_save_vptr(pTHX_ void *ptr)
440 {
441     SSCHECK(3);
442     SSPUSHPTR(*(char**)ptr);
443     SSPUSHPTR(ptr);
444     SSPUSHINT(SAVEt_VPTR);
445 }
446
447 void
448 Perl_save_sptr(pTHX_ SV **sptr)
449 {
450     SSCHECK(3);
451     SSPUSHPTR(*sptr);
452     SSPUSHPTR(sptr);
453     SSPUSHINT(SAVEt_SPTR);
454 }
455
456 void
457 Perl_save_padsv(pTHX_ PADOFFSET off)
458 {
459     SSCHECK(4);
460     ASSERT_CURPAD_ACTIVE("save_padsv");
461     SSPUSHPTR(PL_curpad[off]);
462     SSPUSHPTR(PL_comppad);
463     SSPUSHLONG((long)off);
464     SSPUSHINT(SAVEt_PADSV);
465 }
466
467 SV **
468 Perl_save_threadsv(pTHX_ PADOFFSET i)
469 {
470     Perl_croak(aTHX_ "panic: save_threadsv called in non-threaded perl");
471     (void)i;
472 #ifndef HASATTRIBUTE
473     /* No __attribute__, so the compiler doesn't know that croak never returns
474      */
475     return 0;
476 #endif
477 }
478
479 void
480 Perl_save_nogv(pTHX_ GV *gv)
481 {
482     SSCHECK(2);
483     SSPUSHPTR(gv);
484     SSPUSHINT(SAVEt_NSTAB);
485 }
486
487 void
488 Perl_save_hptr(pTHX_ HV **hptr)
489 {
490     SSCHECK(3);
491     SSPUSHPTR(*hptr);
492     SSPUSHPTR(hptr);
493     SSPUSHINT(SAVEt_HPTR);
494 }
495
496 void
497 Perl_save_aptr(pTHX_ AV **aptr)
498 {
499     SSCHECK(3);
500     SSPUSHPTR(*aptr);
501     SSPUSHPTR(aptr);
502     SSPUSHINT(SAVEt_APTR);
503 }
504
505 void
506 Perl_save_freesv(pTHX_ SV *sv)
507 {
508     SSCHECK(2);
509     SSPUSHPTR(sv);
510     SSPUSHINT(SAVEt_FREESV);
511 }
512
513 void
514 Perl_save_mortalizesv(pTHX_ SV *sv)
515 {
516     SSCHECK(2);
517     SSPUSHPTR(sv);
518     SSPUSHINT(SAVEt_MORTALIZESV);
519 }
520
521 void
522 Perl_save_freeop(pTHX_ OP *o)
523 {
524     SSCHECK(2);
525     SSPUSHPTR(o);
526     SSPUSHINT(SAVEt_FREEOP);
527 }
528
529 void
530 Perl_save_freepv(pTHX_ char *pv)
531 {
532     SSCHECK(2);
533     SSPUSHPTR(pv);
534     SSPUSHINT(SAVEt_FREEPV);
535 }
536
537 void
538 Perl_save_clearsv(pTHX_ SV **svp)
539 {
540     ASSERT_CURPAD_ACTIVE("save_clearsv");
541     SSCHECK(2);
542     SSPUSHLONG((long)(svp-PL_curpad));
543     SSPUSHINT(SAVEt_CLEARSV);
544     SvPADSTALE_off(*svp); /* mark lexical as active */
545 }
546
547 void
548 Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen)
549 {
550     SSCHECK(4);
551     SSPUSHINT(klen);
552     SSPUSHPTR(key);
553     SSPUSHPTR(SvREFCNT_inc(hv));
554     SSPUSHINT(SAVEt_DELETE);
555 }
556
557 void
558 Perl_save_list(pTHX_ register SV **sarg, I32 maxsarg)
559 {
560     register SV *sv;
561     register I32 i;
562
563     for (i = 1; i <= maxsarg; i++) {
564         sv = NEWSV(0,0);
565         sv_setsv(sv,sarg[i]);
566         SSCHECK(3);
567         SSPUSHPTR(sarg[i]);             /* remember the pointer */
568         SSPUSHPTR(sv);                  /* remember the value */
569         SSPUSHINT(SAVEt_ITEM);
570     }
571 }
572
573 void
574 Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p)
575 {
576     SSCHECK(3);
577     SSPUSHDPTR(f);
578     SSPUSHPTR(p);
579     SSPUSHINT(SAVEt_DESTRUCTOR);
580 }
581
582 void
583 Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p)
584 {
585     SSCHECK(3);
586     SSPUSHDXPTR(f);
587     SSPUSHPTR(p);
588     SSPUSHINT(SAVEt_DESTRUCTOR_X);
589 }
590
591 void
592 Perl_save_aelem(pTHX_ const AV *av, I32 idx, SV **sptr)
593 {
594     SV *sv;
595     SSCHECK(4);
596     SSPUSHPTR(SvREFCNT_inc(av));
597     SSPUSHINT(idx);
598     SSPUSHPTR(SvREFCNT_inc(*sptr));
599     SSPUSHINT(SAVEt_AELEM);
600     /* if it gets reified later, the restore will have the wrong refcnt */
601     if (!AvREAL(av) && AvREIFY(av))
602         (void)SvREFCNT_inc(*sptr);
603     save_scalar_at(sptr);
604     sv = *sptr;
605     /* If we're localizing a tied array element, this new sv
606      * won't actually be stored in the array - so it won't get
607      * reaped when the localize ends. Ensure it gets reaped by
608      * mortifying it instead. DAPM */
609     if (SvTIED_mg(sv, PERL_MAGIC_tiedelem))
610         sv_2mortal(sv);
611 }
612
613 void
614 Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr)
615 {
616     SV *sv;
617     SSCHECK(4);
618     SSPUSHPTR(SvREFCNT_inc(hv));
619     SSPUSHPTR(SvREFCNT_inc(key));
620     SSPUSHPTR(SvREFCNT_inc(*sptr));
621     SSPUSHINT(SAVEt_HELEM);
622     save_scalar_at(sptr);
623     sv = *sptr;
624     /* If we're localizing a tied hash element, this new sv
625      * won't actually be stored in the hash - so it won't get
626      * reaped when the localize ends. Ensure it gets reaped by
627      * mortifying it instead. DAPM */
628     if (SvTIED_mg(sv, PERL_MAGIC_tiedelem))
629         sv_2mortal(sv);
630 }
631
632 void
633 Perl_save_op(pTHX)
634 {
635     SSCHECK(2);
636     SSPUSHPTR(PL_op);
637     SSPUSHINT(SAVEt_OP);
638 }
639
640 I32
641 Perl_save_alloc(pTHX_ I32 size, I32 pad)
642 {
643     register const I32 start = pad + ((char*)&PL_savestack[PL_savestack_ix]
644                                 - (char*)PL_savestack);
645     register const I32 elems = 1 + ((size + pad - 1) / sizeof(*PL_savestack));
646
647     /* SSCHECK may not be good enough */
648     while (PL_savestack_ix + elems + 2 > PL_savestack_max)
649         savestack_grow();
650
651     PL_savestack_ix += elems;
652     SSPUSHINT(elems);
653     SSPUSHINT(SAVEt_ALLOC);
654     return start;
655 }
656
657 void
658 Perl_leave_scope(pTHX_ I32 base)
659 {
660     register SV *sv;
661     register SV *value;
662     register GV *gv;
663     register AV *av;
664     register HV *hv;
665     register void* ptr;
666     register char* str;
667     I32 i;
668
669     if (base < -1)
670         Perl_croak(aTHX_ "panic: corrupt saved stack index");
671     while (PL_savestack_ix > base) {
672         switch (SSPOPINT) {
673         case SAVEt_ITEM:                        /* normal string */
674             value = (SV*)SSPOPPTR;
675             sv = (SV*)SSPOPPTR;
676             sv_replace(sv,value);
677             PL_localizing = 2;
678             SvSETMAGIC(sv);
679             PL_localizing = 0;
680             break;
681         case SAVEt_SV:                          /* scalar reference */
682             value = (SV*)SSPOPPTR;
683             gv = (GV*)SSPOPPTR;
684             ptr = &GvSV(gv);
685             av = (AV*)gv; /* what to refcnt_dec */
686             goto restore_sv;
687         case SAVEt_GENERIC_PVREF:               /* generic pv */
688             str = (char*)SSPOPPTR;
689             ptr = SSPOPPTR;
690             if (*(char**)ptr != str) {
691                 Safefree(*(char**)ptr);
692                 *(char**)ptr = str;
693             }
694             break;
695         case SAVEt_SHARED_PVREF:                /* shared pv */
696             str = (char*)SSPOPPTR;
697             ptr = SSPOPPTR;
698             if (*(char**)ptr != str) {
699 #ifdef NETWARE
700                 PerlMem_free(*(char**)ptr);
701 #else
702                 PerlMemShared_free(*(char**)ptr);
703 #endif
704                 *(char**)ptr = str;
705             }
706             break;
707         case SAVEt_GENERIC_SVREF:               /* generic sv */
708             value = (SV*)SSPOPPTR;
709             ptr = SSPOPPTR;
710             sv = *(SV**)ptr;
711             *(SV**)ptr = value;
712             SvREFCNT_dec(sv);
713             SvREFCNT_dec(value);
714             break;
715         case SAVEt_SVREF:                       /* scalar reference */
716             value = (SV*)SSPOPPTR;
717             ptr = SSPOPPTR;
718             av = Nullav; /* what to refcnt_dec */
719         restore_sv:
720             sv = *(SV**)ptr;
721             DEBUG_S(PerlIO_printf(Perl_debug_log,
722                                   "restore svref: %p %p:%s -> %p:%s\n",
723                                   ptr, sv, SvPEEK(sv), value, SvPEEK(value)));
724             if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv) &&
725                 SvTYPE(sv) != SVt_PVGV)
726             {
727                 (void)SvUPGRADE(value, SvTYPE(sv));
728                 SvMAGIC_set(value, SvMAGIC(sv));
729                 SvFLAGS(value) |= SvMAGICAL(sv);
730                 SvMAGICAL_off(sv);
731                 SvMAGIC_set(sv, 0);
732             }
733             /* XXX This branch is pretty bogus.  This code irretrievably
734              * clears(!) the magic on the SV (either to avoid further
735              * croaking that might ensue when the SvSETMAGIC() below is
736              * called, or to avoid two different SVs pointing at the same
737              * SvMAGIC()).  This needs a total rethink.  --GSAR */
738             else if (SvTYPE(value) >= SVt_PVMG && SvMAGIC(value) &&
739                      SvTYPE(value) != SVt_PVGV)
740             {
741                 SvFLAGS(value) |= (SvFLAGS(value) &
742                                   (SVp_NOK|SVp_POK)) >> PRIVSHIFT;
743                 SvMAGICAL_off(value);
744                 /* XXX this is a leak when we get here because the
745                  * mg_get() in save_scalar_at() croaked */
746                 SvMAGIC_set(value, NULL);
747             }
748             *(SV**)ptr = value;
749             SvREFCNT_dec(sv);
750             PL_localizing = 2;
751             SvSETMAGIC(value);
752             PL_localizing = 0;
753             SvREFCNT_dec(value);
754             if (av) /* actually an av, hv or gv */
755                 SvREFCNT_dec(av);
756             break;
757         case SAVEt_AV:                          /* array reference */
758             av = (AV*)SSPOPPTR;
759             gv = (GV*)SSPOPPTR;
760             if (GvAV(gv)) {
761                 AV * const goner = GvAV(gv);
762                 SvMAGIC_set(av, SvMAGIC(goner));
763                 SvFLAGS((SV*)av) |= SvMAGICAL(goner);
764                 SvMAGICAL_off(goner);
765                 SvMAGIC_set(goner, NULL);
766                 SvREFCNT_dec(goner);
767             }
768             GvAV(gv) = av;
769             if (SvMAGICAL(av)) {
770                 PL_localizing = 2;
771                 SvSETMAGIC((SV*)av);
772                 PL_localizing = 0;
773             }
774             break;
775         case SAVEt_HV:                          /* hash reference */
776             hv = (HV*)SSPOPPTR;
777             gv = (GV*)SSPOPPTR;
778             if (GvHV(gv)) {
779                 HV * const goner = GvHV(gv);
780                 SvMAGIC_set(hv, SvMAGIC(goner));
781                 SvFLAGS(hv) |= SvMAGICAL(goner);
782                 SvMAGICAL_off(goner);
783                 SvMAGIC_set(goner, NULL);
784                 SvREFCNT_dec(goner);
785             }
786             GvHV(gv) = hv;
787             if (SvMAGICAL(hv)) {
788                 PL_localizing = 2;
789                 SvSETMAGIC((SV*)hv);
790                 PL_localizing = 0;
791             }
792             break;
793         case SAVEt_INT:                         /* int reference */
794             ptr = SSPOPPTR;
795             *(int*)ptr = (int)SSPOPINT;
796             break;
797         case SAVEt_LONG:                        /* long reference */
798             ptr = SSPOPPTR;
799             *(long*)ptr = (long)SSPOPLONG;
800             break;
801         case SAVEt_BOOL:                        /* bool reference */
802             ptr = SSPOPPTR;
803             *(bool*)ptr = (bool)SSPOPBOOL;
804             break;
805         case SAVEt_I32:                         /* I32 reference */
806             ptr = SSPOPPTR;
807             *(I32*)ptr = (I32)SSPOPINT;
808             break;
809         case SAVEt_I16:                         /* I16 reference */
810             ptr = SSPOPPTR;
811             *(I16*)ptr = (I16)SSPOPINT;
812             break;
813         case SAVEt_I8:                          /* I8 reference */
814             ptr = SSPOPPTR;
815             *(I8*)ptr = (I8)SSPOPINT;
816             break;
817         case SAVEt_IV:                          /* IV reference */
818             ptr = SSPOPPTR;
819             *(IV*)ptr = (IV)SSPOPIV;
820             break;
821         case SAVEt_SPTR:                        /* SV* reference */
822             ptr = SSPOPPTR;
823             *(SV**)ptr = (SV*)SSPOPPTR;
824             break;
825         case SAVEt_VPTR:                        /* random* reference */
826         case SAVEt_PPTR:                        /* char* reference */
827             ptr = SSPOPPTR;
828             *(char**)ptr = (char*)SSPOPPTR;
829             break;
830         case SAVEt_HPTR:                        /* HV* reference */
831             ptr = SSPOPPTR;
832             *(HV**)ptr = (HV*)SSPOPPTR;
833             break;
834         case SAVEt_APTR:                        /* AV* reference */
835             ptr = SSPOPPTR;
836             *(AV**)ptr = (AV*)SSPOPPTR;
837             break;
838         case SAVEt_NSTAB:
839             gv = (GV*)SSPOPPTR;
840             (void)sv_clear((SV*)gv);
841             break;
842         case SAVEt_GP:                          /* scalar reference */
843             ptr = SSPOPPTR;
844             gv = (GV*)SSPOPPTR;
845             if (SvPVX(gv) && SvLEN(gv) > 0) {
846                 Safefree(SvPVX(gv));
847             }
848             SvPV_set(gv, (char *)SSPOPPTR);
849             SvCUR_set(gv, (STRLEN)SSPOPIV);
850             SvLEN_set(gv, (STRLEN)SSPOPIV);
851             gp_free(gv);
852             GvGP(gv) = (GP*)ptr;
853             if (GvCVu(gv))
854                 PL_sub_generation++;  /* putting a method back into circulation */
855             SvREFCNT_dec(gv);
856             break;
857         case SAVEt_FREESV:
858             ptr = SSPOPPTR;
859             SvREFCNT_dec((SV*)ptr);
860             break;
861         case SAVEt_MORTALIZESV:
862             ptr = SSPOPPTR;
863             sv_2mortal((SV*)ptr);
864             break;
865         case SAVEt_FREEOP:
866             ptr = SSPOPPTR;
867             ASSERT_CURPAD_LEGAL("SAVEt_FREEOP"); /* XXX DAPM tmp */
868             op_free((OP*)ptr);
869             break;
870         case SAVEt_FREEPV:
871             ptr = SSPOPPTR;
872             Safefree((char*)ptr);
873             break;
874         case SAVEt_CLEARSV:
875             ptr = (void*)&PL_curpad[SSPOPLONG];
876             sv = *(SV**)ptr;
877
878             DEBUG_Xv(PerlIO_printf(Perl_debug_log,
879              "Pad 0x%"UVxf"[0x%"UVxf"] clearsv: %ld sv=0x%"UVxf"<%"IVdf"> %s\n",
880                 PTR2UV(PL_comppad), PTR2UV(PL_curpad),
881                 (long)((SV **)ptr-PL_curpad), PTR2UV(sv), (IV)SvREFCNT(sv),
882                 (SvREFCNT(sv) <= 1 && !SvOBJECT(sv)) ? "clear" : "abandon"
883             ));
884
885             /* Can clear pad variable in place? */
886             if (SvREFCNT(sv) <= 1 && !SvOBJECT(sv)) {
887                 /*
888                  * if a my variable that was made readonly is going out of
889                  * scope, we want to remove the readonlyness so that it can
890                  * go out of scope quietly
891                  */
892                 if (SvPADMY(sv) && !SvFAKE(sv))
893                     SvREADONLY_off(sv);
894
895                 if (SvTHINKFIRST(sv))
896                     sv_force_normal_flags(sv, SV_IMMEDIATE_UNREF);
897                 if (SvMAGICAL(sv))
898                     mg_free(sv);
899
900                 switch (SvTYPE(sv)) {
901                 case SVt_NULL:
902                     break;
903                 case SVt_PVAV:
904                     av_clear((AV*)sv);
905                     break;
906                 case SVt_PVHV:
907                     hv_clear((HV*)sv);
908                     break;
909                 case SVt_PVCV:
910                     Perl_croak(aTHX_ "panic: leave_scope pad code");
911                 default:
912                     SvOK_off(sv);
913                     break;
914                 }
915                 SvPADSTALE_on(sv); /* mark as no longer live */
916             }
917             else {      /* Someone has a claim on this, so abandon it. */
918                 const U32 padflags = SvFLAGS(sv) & (SVs_PADMY|SVs_PADTMP);
919                 switch (SvTYPE(sv)) {   /* Console ourselves with a new value */
920                 case SVt_PVAV:  *(SV**)ptr = (SV*)newAV();      break;
921                 case SVt_PVHV:  *(SV**)ptr = (SV*)newHV();      break;
922                 default:        *(SV**)ptr = NEWSV(0,0);        break;
923                 }
924                 SvREFCNT_dec(sv);       /* Cast current value to the winds. */
925                 /* preserve pad nature, but also mark as not live
926                  * for any closure capturing */
927                 SvFLAGS(*(SV**)ptr) |= padflags | SVs_PADSTALE;
928             }
929             break;
930         case SAVEt_DELETE:
931             ptr = SSPOPPTR;
932             hv = (HV*)ptr;
933             ptr = SSPOPPTR;
934             (void)hv_delete(hv, (char*)ptr, (U32)SSPOPINT, G_DISCARD);
935             SvREFCNT_dec(hv);
936             Safefree(ptr);
937             break;
938         case SAVEt_DESTRUCTOR:
939             ptr = SSPOPPTR;
940             (*SSPOPDPTR)(ptr);
941             break;
942         case SAVEt_DESTRUCTOR_X:
943             ptr = SSPOPPTR;
944             (*SSPOPDXPTR)(aTHX_ ptr);
945             break;
946         case SAVEt_REGCONTEXT:
947         case SAVEt_ALLOC:
948             i = SSPOPINT;
949             PL_savestack_ix -= i;       /* regexp must have croaked */
950             break;
951         case SAVEt_STACK_POS:           /* Position on Perl stack */
952             i = SSPOPINT;
953             PL_stack_sp = PL_stack_base + i;
954             break;
955         case SAVEt_AELEM:               /* array element */
956             value = (SV*)SSPOPPTR;
957             i = SSPOPINT;
958             av = (AV*)SSPOPPTR;
959             if (!AvREAL(av) && AvREIFY(av)) /* undo reify guard */
960                 SvREFCNT_dec(value);
961             ptr = av_fetch(av,i,1);
962             if (ptr) {
963                 sv = *(SV**)ptr;
964                 if (sv && sv != &PL_sv_undef) {
965                     if (SvTIED_mg((SV*)av, PERL_MAGIC_tied))
966                         (void)SvREFCNT_inc(sv);
967                     goto restore_sv;
968                 }
969             }
970             SvREFCNT_dec(av);
971             SvREFCNT_dec(value);
972             break;
973         case SAVEt_HELEM:               /* hash element */
974             value = (SV*)SSPOPPTR;
975             sv = (SV*)SSPOPPTR;
976             hv = (HV*)SSPOPPTR;
977             ptr = hv_fetch_ent(hv, sv, 1, 0);
978             if (ptr) {
979                 const SV * const oval = HeVAL((HE*)ptr);
980                 if (oval && oval != &PL_sv_undef) {
981                     ptr = &HeVAL((HE*)ptr);
982                     if (SvTIED_mg((SV*)hv, PERL_MAGIC_tied))
983                         (void)SvREFCNT_inc(*(SV**)ptr);
984                     SvREFCNT_dec(sv);
985                     av = (AV*)hv; /* what to refcnt_dec */
986                     goto restore_sv;
987                 }
988             }
989             SvREFCNT_dec(hv);
990             SvREFCNT_dec(sv);
991             SvREFCNT_dec(value);
992             break;
993         case SAVEt_OP:
994             PL_op = (OP*)SSPOPPTR;
995             break;
996         case SAVEt_HINTS:
997             if ((PL_hints & HINT_LOCALIZE_HH) && GvHV(PL_hintgv)) {
998                 SvREFCNT_dec((SV*)GvHV(PL_hintgv));
999                 GvHV(PL_hintgv) = NULL;
1000             }
1001             *(I32*)&PL_hints = (I32)SSPOPINT;
1002             if (PL_hints & HINT_LOCALIZE_HH) {
1003                 SvREFCNT_dec((SV*)GvHV(PL_hintgv));
1004                 GvHV(PL_hintgv) = (HV*)SSPOPPTR;
1005             }
1006                     
1007             break;
1008         case SAVEt_COMPPAD:
1009             PL_comppad = (PAD*)SSPOPPTR;
1010             if (PL_comppad)
1011                 PL_curpad = AvARRAY(PL_comppad);
1012             else
1013                 PL_curpad = Null(SV**);
1014             break;
1015         case SAVEt_PADSV:
1016             {
1017                 const PADOFFSET off = (PADOFFSET)SSPOPLONG;
1018                 ptr = SSPOPPTR;
1019                 if (ptr)
1020                     AvARRAY((PAD*)ptr)[off] = (SV*)SSPOPPTR;
1021             }
1022             break;
1023         case SAVEt_SAVESWITCHSTACK:
1024             {
1025                 dSP;
1026                 AV* t = (AV*)SSPOPPTR;
1027                 AV* f = (AV*)SSPOPPTR;
1028                 SWITCHSTACK(t,f);
1029                 PL_curstackinfo->si_stack = f;
1030             }
1031             break;
1032         case SAVEt_SET_SVFLAGS:
1033             {
1034                 const U32 val  = (U32)SSPOPINT;
1035                 const U32 mask = (U32)SSPOPINT;
1036                 sv = (SV*)SSPOPPTR;
1037                 SvFLAGS(sv) &= ~mask;
1038                 SvFLAGS(sv) |= val;
1039             }
1040             break;
1041         default:
1042             Perl_croak(aTHX_ "panic: leave_scope inconsistency");
1043         }
1044     }
1045 }
1046
1047 void
1048 Perl_cx_dump(pTHX_ PERL_CONTEXT *cx)
1049 {
1050 #ifdef DEBUGGING
1051     PerlIO_printf(Perl_debug_log, "CX %ld = %s\n", (long)(cx - cxstack), PL_block_type[CxTYPE(cx)]);
1052     if (CxTYPE(cx) != CXt_SUBST) {
1053         PerlIO_printf(Perl_debug_log, "BLK_OLDSP = %ld\n", (long)cx->blk_oldsp);
1054         PerlIO_printf(Perl_debug_log, "BLK_OLDCOP = 0x%"UVxf"\n",
1055                       PTR2UV(cx->blk_oldcop));
1056         PerlIO_printf(Perl_debug_log, "BLK_OLDMARKSP = %ld\n", (long)cx->blk_oldmarksp);
1057         PerlIO_printf(Perl_debug_log, "BLK_OLDSCOPESP = %ld\n", (long)cx->blk_oldscopesp);
1058         PerlIO_printf(Perl_debug_log, "BLK_OLDPM = 0x%"UVxf"\n",
1059                       PTR2UV(cx->blk_oldpm));
1060         PerlIO_printf(Perl_debug_log, "BLK_GIMME = %s\n", cx->blk_gimme ? "LIST" : "SCALAR");
1061     }
1062     switch (CxTYPE(cx)) {
1063     case CXt_NULL:
1064     case CXt_BLOCK:
1065         break;
1066     case CXt_FORMAT:
1067         PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%"UVxf"\n",
1068                 PTR2UV(cx->blk_sub.cv));
1069         PerlIO_printf(Perl_debug_log, "BLK_SUB.GV = 0x%"UVxf"\n",
1070                 PTR2UV(cx->blk_sub.gv));
1071         PerlIO_printf(Perl_debug_log, "BLK_SUB.DFOUTGV = 0x%"UVxf"\n",
1072                 PTR2UV(cx->blk_sub.dfoutgv));
1073         PerlIO_printf(Perl_debug_log, "BLK_SUB.HASARGS = %d\n",
1074                 (int)cx->blk_sub.hasargs);
1075         PerlIO_printf(Perl_debug_log, "BLK_SUB.RETOP = 0x%"UVxf"\n",
1076                 PTR2UV(cx->blk_sub.retop));
1077         break;
1078     case CXt_SUB:
1079         PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%"UVxf"\n",
1080                 PTR2UV(cx->blk_sub.cv));
1081         PerlIO_printf(Perl_debug_log, "BLK_SUB.OLDDEPTH = %ld\n",
1082                 (long)cx->blk_sub.olddepth);
1083         PerlIO_printf(Perl_debug_log, "BLK_SUB.HASARGS = %d\n",
1084                 (int)cx->blk_sub.hasargs);
1085         PerlIO_printf(Perl_debug_log, "BLK_SUB.LVAL = %d\n",
1086                 (int)cx->blk_sub.lval);
1087         PerlIO_printf(Perl_debug_log, "BLK_SUB.RETOP = 0x%"UVxf"\n",
1088                 PTR2UV(cx->blk_sub.retop));
1089         break;
1090     case CXt_EVAL:
1091         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_IN_EVAL = %ld\n",
1092                 (long)cx->blk_eval.old_in_eval);
1093         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_OP_TYPE = %s (%s)\n",
1094                 PL_op_name[cx->blk_eval.old_op_type],
1095                 PL_op_desc[cx->blk_eval.old_op_type]);
1096         if (cx->blk_eval.old_namesv)
1097             PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_NAME = %s\n",
1098                           SvPVX(cx->blk_eval.old_namesv));
1099         PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_EVAL_ROOT = 0x%"UVxf"\n",
1100                 PTR2UV(cx->blk_eval.old_eval_root));
1101         PerlIO_printf(Perl_debug_log, "BLK_EVAL.RETOP = 0x%"UVxf"\n",
1102                 PTR2UV(cx->blk_eval.retop));
1103         break;
1104
1105     case CXt_LOOP:
1106         PerlIO_printf(Perl_debug_log, "BLK_LOOP.LABEL = %s\n",
1107                 cx->blk_loop.label);
1108         PerlIO_printf(Perl_debug_log, "BLK_LOOP.RESETSP = %ld\n",
1109                 (long)cx->blk_loop.resetsp);
1110         PerlIO_printf(Perl_debug_log, "BLK_LOOP.REDO_OP = 0x%"UVxf"\n",
1111                 PTR2UV(cx->blk_loop.redo_op));
1112         PerlIO_printf(Perl_debug_log, "BLK_LOOP.NEXT_OP = 0x%"UVxf"\n",
1113                 PTR2UV(cx->blk_loop.next_op));
1114         PerlIO_printf(Perl_debug_log, "BLK_LOOP.LAST_OP = 0x%"UVxf"\n",
1115                 PTR2UV(cx->blk_loop.last_op));
1116         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERIX = %ld\n",
1117                 (long)cx->blk_loop.iterix);
1118         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERARY = 0x%"UVxf"\n",
1119                 PTR2UV(cx->blk_loop.iterary));
1120         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERVAR = 0x%"UVxf"\n",
1121                 PTR2UV(CxITERVAR(cx)));
1122         if (CxITERVAR(cx))
1123             PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERSAVE = 0x%"UVxf"\n",
1124                 PTR2UV(cx->blk_loop.itersave));
1125         PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERLVAL = 0x%"UVxf"\n",
1126                 PTR2UV(cx->blk_loop.iterlval));
1127         break;
1128
1129     case CXt_SUBST:
1130         PerlIO_printf(Perl_debug_log, "SB_ITERS = %ld\n",
1131                 (long)cx->sb_iters);
1132         PerlIO_printf(Perl_debug_log, "SB_MAXITERS = %ld\n",
1133                 (long)cx->sb_maxiters);
1134         PerlIO_printf(Perl_debug_log, "SB_RFLAGS = %ld\n",
1135                 (long)cx->sb_rflags);
1136         PerlIO_printf(Perl_debug_log, "SB_ONCE = %ld\n",
1137                 (long)cx->sb_once);
1138         PerlIO_printf(Perl_debug_log, "SB_ORIG = %s\n",
1139                 cx->sb_orig);
1140         PerlIO_printf(Perl_debug_log, "SB_DSTR = 0x%"UVxf"\n",
1141                 PTR2UV(cx->sb_dstr));
1142         PerlIO_printf(Perl_debug_log, "SB_TARG = 0x%"UVxf"\n",
1143                 PTR2UV(cx->sb_targ));
1144         PerlIO_printf(Perl_debug_log, "SB_S = 0x%"UVxf"\n",
1145                 PTR2UV(cx->sb_s));
1146         PerlIO_printf(Perl_debug_log, "SB_M = 0x%"UVxf"\n",
1147                 PTR2UV(cx->sb_m));
1148         PerlIO_printf(Perl_debug_log, "SB_STREND = 0x%"UVxf"\n",
1149                 PTR2UV(cx->sb_strend));
1150         PerlIO_printf(Perl_debug_log, "SB_RXRES = 0x%"UVxf"\n",
1151                 PTR2UV(cx->sb_rxres));
1152         break;
1153     }
1154 #endif  /* DEBUGGING */
1155 }
1156
1157 /*
1158  * Local variables:
1159  * c-indentation-style: bsd
1160  * c-basic-offset: 4
1161  * indent-tabs-mode: t
1162  * End:
1163  *
1164  * vim: shiftwidth=4:
1165 */