X-Git-Url: https://perl5.git.perl.org/perl5.git/blobdiff_plain/161b7d1635bc830b9c733355ab423626eadf9ae9..bfc4de9ff33050d7c71e12b604bc53895468baad:/scope.c diff --git a/scope.c b/scope.c index 33569da..a1fdfd1 100644 --- a/scope.c +++ b/scope.c @@ -1,6 +1,6 @@ /* scope.c * - * Copyright (c) 1991-1997, Larry Wall + * Copyright (c) 1991-2002, Larry Wall * * You may distribute under the terms of either the GNU General Public * License or the Artistic License, as specified in the README file. @@ -13,117 +13,172 @@ */ #include "EXTERN.h" +#define PERL_IN_SCOPE_C #include "perl.h" +#if defined(PERL_FLEXIBLE_EXCEPTIONS) +void * +Perl_default_protect(pTHX_ volatile JMPENV *pcur_env, int *excpt, + protect_body_t body, ...) +{ + void *ret; + va_list args; + va_start(args, body); + ret = vdefault_protect(pcur_env, excpt, body, &args); + va_end(args); + return ret; +} + +void * +Perl_vdefault_protect(pTHX_ volatile JMPENV *pcur_env, int *excpt, + protect_body_t body, va_list *args) +{ + int ex; + void *ret; + + JMPENV_PUSH(ex); + if (ex) + ret = NULL; + else + ret = CALL_FPTR(body)(aTHX_ *args); + *excpt = ex; + JMPENV_POP; + return ret; +} +#endif + SV** -stack_grow(SV **sp, SV **p, int n) +Perl_stack_grow(pTHX_ SV **sp, SV **p, int n) { - dTHR; -#if defined(DEBUGGING) && !defined(USE_THREADS) - static int growing = 0; - if (growing++) - abort(); + PL_stack_sp = sp; +#ifndef STRESS_REALLOC + av_extend(PL_curstack, (p - PL_stack_base) + (n) + 128); +#else + av_extend(PL_curstack, (p - PL_stack_base) + (n) + 1); #endif - stack_sp = sp; - av_extend(curstack, (p - stack_base) + (n) + 128); -#if defined(DEBUGGING) && !defined(USE_THREADS) - growing--; + return PL_stack_sp; +} + +#ifndef STRESS_REALLOC +#define GROW(old) ((old) * 3 / 2) +#else +#define GROW(old) ((old) + 1) #endif - return stack_sp; + +PERL_SI * +Perl_new_stackinfo(pTHX_ I32 stitems, I32 cxitems) +{ + PERL_SI *si; + New(56, si, 1, PERL_SI); + si->si_stack = newAV(); + AvREAL_off(si->si_stack); + av_extend(si->si_stack, stitems > 0 ? stitems-1 : 0); + AvALLOC(si->si_stack)[0] = &PL_sv_undef; + AvFILLp(si->si_stack) = 0; + si->si_prev = 0; + si->si_next = 0; + si->si_cxmax = cxitems - 1; + si->si_cxix = -1; + si->si_type = PERLSI_UNDEF; + New(56, si->si_cxstack, cxitems, PERL_CONTEXT); + return si; } I32 -cxinc(void) +Perl_cxinc(pTHX) { - dTHR; - cxstack_max = cxstack_max * 3 / 2; + cxstack_max = GROW(cxstack_max); Renew(cxstack, cxstack_max + 1, PERL_CONTEXT); /* XXX should fix CXINC macro */ return cxstack_ix + 1; } void -push_return(OP *retop) +Perl_push_return(pTHX_ OP *retop) { - dTHR; - if (retstack_ix == retstack_max) { - retstack_max = retstack_max * 3 / 2; - Renew(retstack, retstack_max, OP*); + if (PL_retstack_ix == PL_retstack_max) { + PL_retstack_max = GROW(PL_retstack_max); + Renew(PL_retstack, PL_retstack_max, OP*); } - retstack[retstack_ix++] = retop; + PL_retstack[PL_retstack_ix++] = retop; } OP * -pop_return(void) +Perl_pop_return(pTHX) { - dTHR; - if (retstack_ix > 0) - return retstack[--retstack_ix]; + if (PL_retstack_ix > 0) + return PL_retstack[--PL_retstack_ix]; else return Nullop; } void -push_scope(void) +Perl_push_scope(pTHX) { - dTHR; - if (scopestack_ix == scopestack_max) { - scopestack_max = scopestack_max * 3 / 2; - Renew(scopestack, scopestack_max, I32); + if (PL_scopestack_ix == PL_scopestack_max) { + PL_scopestack_max = GROW(PL_scopestack_max); + Renew(PL_scopestack, PL_scopestack_max, I32); } - scopestack[scopestack_ix++] = savestack_ix; + PL_scopestack[PL_scopestack_ix++] = PL_savestack_ix; } void -pop_scope(void) +Perl_pop_scope(pTHX) { - dTHR; - I32 oldsave = scopestack[--scopestack_ix]; + I32 oldsave = PL_scopestack[--PL_scopestack_ix]; LEAVE_SCOPE(oldsave); } void -markstack_grow(void) +Perl_markstack_grow(pTHX) { - dTHR; - I32 oldmax = markstack_max - markstack; - I32 newmax = oldmax * 3 / 2; + I32 oldmax = PL_markstack_max - PL_markstack; + I32 newmax = GROW(oldmax); - Renew(markstack, newmax, I32); - markstack_ptr = markstack + oldmax; - markstack_max = markstack + newmax; + Renew(PL_markstack, newmax, I32); + PL_markstack_ptr = PL_markstack + oldmax; + PL_markstack_max = PL_markstack + newmax; } void -savestack_grow(void) +Perl_savestack_grow(pTHX) { - dTHR; - savestack_max = savestack_max * 3 / 2; - Renew(savestack, savestack_max, ANY); + PL_savestack_max = GROW(PL_savestack_max) + 4; + Renew(PL_savestack, PL_savestack_max, ANY); } +#undef GROW + void -free_tmps(void) +Perl_tmps_grow(pTHX_ I32 n) +{ +#ifndef STRESS_REALLOC + if (n < 128) + n = (PL_tmps_max < 512) ? 128 : 512; +#endif + PL_tmps_max = PL_tmps_ix + n + 1; + Renew(PL_tmps_stack, PL_tmps_max, SV*); +} + + +void +Perl_free_tmps(pTHX) { - dTHR; /* XXX should tmps_floor live in cxstack? */ - I32 myfloor = tmps_floor; - while (tmps_ix > myfloor) { /* clean up after last statement */ - SV* sv = tmps_stack[tmps_ix]; - tmps_stack[tmps_ix--] = Nullsv; - if (sv) { -#ifdef DEBUGGING + I32 myfloor = PL_tmps_floor; + while (PL_tmps_ix > myfloor) { /* clean up after last statement */ + SV* sv = PL_tmps_stack[PL_tmps_ix]; + PL_tmps_stack[PL_tmps_ix--] = Nullsv; + if (sv && sv != &PL_sv_undef) { SvTEMP_off(sv); -#endif SvREFCNT_dec(sv); /* note, can modify tmps_ix!!! */ } } } -static SV * -save_scalar_at(SV **sptr) +STATIC SV * +S_save_scalar_at(pTHX_ SV **sptr) { - dTHR; register SV *sv; SV *osv = *sptr; @@ -132,51 +187,88 @@ save_scalar_at(SV **sptr) sv_upgrade(sv, SvTYPE(osv)); if (SvGMAGICAL(osv)) { MAGIC* mg; - bool oldtainted = tainted; - mg_get(osv); - if (tainting && tainted && (mg = mg_find(osv, 't'))) { + bool oldtainted = PL_tainted; + mg_get(osv); /* note, can croak! */ + if (PL_tainting && PL_tainted && + (mg = mg_find(osv, PERL_MAGIC_taint))) { SAVESPTR(mg->mg_obj); mg->mg_obj = osv; } SvFLAGS(osv) |= (SvFLAGS(osv) & - (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; - tainted = oldtainted; + (SVp_NOK|SVp_POK)) >> PRIVSHIFT; + PL_tainted = oldtainted; } SvMAGIC(sv) = SvMAGIC(osv); SvFLAGS(sv) |= SvMAGICAL(osv); - localizing = 1; + /* XXX SvMAGIC() is *shared* between osv and sv. This can + * lead to coredumps when both SVs are destroyed without one + * of their SvMAGIC() slots being NULLed. */ + PL_localizing = 1; SvSETMAGIC(sv); - localizing = 0; + PL_localizing = 0; } return sv; } SV * -save_scalar(GV *gv) +Perl_save_scalar(pTHX_ GV *gv) { - dTHR; + SV **sptr = &GvSV(gv); SSCHECK(3); - SSPUSHPTR(gv); - SSPUSHPTR(GvSV(gv)); + SSPUSHPTR(SvREFCNT_inc(gv)); + SSPUSHPTR(SvREFCNT_inc(*sptr)); SSPUSHINT(SAVEt_SV); - return save_scalar_at(&GvSV(gv)); + return save_scalar_at(sptr); } SV* -save_svref(SV **sptr) +Perl_save_svref(pTHX_ SV **sptr) { - dTHR; SSCHECK(3); SSPUSHPTR(sptr); - SSPUSHPTR(*sptr); + SSPUSHPTR(SvREFCNT_inc(*sptr)); SSPUSHINT(SAVEt_SVREF); return save_scalar_at(sptr); } +/* Like save_sptr(), but also SvREFCNT_dec()s the new value. Can be used to + * restore a global SV to its prior contents, freeing new value. */ +void +Perl_save_generic_svref(pTHX_ SV **sptr) +{ + SSCHECK(3); + SSPUSHPTR(sptr); + SSPUSHPTR(SvREFCNT_inc(*sptr)); + SSPUSHINT(SAVEt_GENERIC_SVREF); +} + +/* Like save_pptr(), but also Safefree()s the new value if it is different + * from the old one. Can be used to restore a global char* to its prior + * contents, freeing new value. */ +void +Perl_save_generic_pvref(pTHX_ char **str) +{ + SSCHECK(3); + SSPUSHPTR(str); + SSPUSHPTR(*str); + SSPUSHINT(SAVEt_GENERIC_PVREF); +} + +/* Like save_generic_pvref(), but uses PerlMemShared_free() rather than Safefree(). + * Can be used to restore a shared global char* to its prior + * contents, freeing new value. */ void -save_gp(GV *gv, I32 empty) +Perl_save_shared_pvref(pTHX_ char **str) +{ + SSCHECK(3); + SSPUSHPTR(str); + SSPUSHPTR(*str); + SSPUSHINT(SAVEt_SHARED_PVREF); +} + +void +Perl_save_gp(pTHX_ GV *gv, I32 empty) { - dTHR; SSCHECK(6); SSPUSHIV((IV)SvLEN(gv)); SvLEN(gv) = 0; /* forget that anything was allocated here */ @@ -189,10 +281,19 @@ save_gp(GV *gv, I32 empty) if (empty) { register GP *gp; + Newz(602, gp, 1, GP); + + if (GvCVu(gv)) + PL_sub_generation++; /* taking a method out of circulation */ + if (GvIOp(gv) && (IoFLAGS(GvIOp(gv)) & IOf_ARGV)) { + gp->gp_io = newIO(); + IoFLAGS(gp->gp_io) |= IOf_ARGV|IOf_START; + } GvGP(gv) = gp_ref(gp); GvSV(gv) = NEWSV(72,0); - GvLINE(gv) = curcop->cop_line; + GvLINE(gv) = CopLINE(PL_curcop); + GvFILE(gv) = CopFILE(PL_curcop) ? CopFILE(PL_curcop) : ""; GvEGV(gv) = gv; } else { @@ -202,9 +303,8 @@ save_gp(GV *gv, I32 empty) } AV * -save_ary(GV *gv) +Perl_save_ary(pTHX_ GV *gv) { - dTHR; AV *oav = GvAVn(gv); AV *av; @@ -219,20 +319,19 @@ save_ary(GV *gv) av = GvAVn(gv); if (SvMAGIC(oav)) { SvMAGIC(av) = SvMAGIC(oav); - SvFLAGS(av) |= SvMAGICAL(oav); + SvFLAGS((SV*)av) |= SvMAGICAL(oav); SvMAGICAL_off(oav); SvMAGIC(oav) = 0; - localizing = 1; + PL_localizing = 1; SvSETMAGIC((SV*)av); - localizing = 0; + PL_localizing = 0; } return av; } HV * -save_hash(GV *gv) +Perl_save_hash(pTHX_ GV *gv) { - dTHR; HV *ohv, *hv; SSCHECK(3); @@ -244,20 +343,19 @@ save_hash(GV *gv) hv = GvHVn(gv); if (SvMAGIC(ohv)) { SvMAGIC(hv) = SvMAGIC(ohv); - SvFLAGS(hv) |= SvMAGICAL(ohv); + SvFLAGS((SV*)hv) |= SvMAGICAL(ohv); SvMAGICAL_off(ohv); SvMAGIC(ohv) = 0; - localizing = 1; + PL_localizing = 1; SvSETMAGIC((SV*)hv); - localizing = 0; + PL_localizing = 0; } return hv; } void -save_item(register SV *item) +Perl_save_item(pTHX_ register SV *item) { - dTHR; register SV *sv = NEWSV(0,0); sv_setsv(sv,item); @@ -268,9 +366,8 @@ save_item(register SV *item) } void -save_int(int *intp) +Perl_save_int(pTHX_ int *intp) { - dTHR; SSCHECK(3); SSPUSHINT(*intp); SSPUSHPTR(intp); @@ -278,9 +375,8 @@ save_int(int *intp) } void -save_long(long int *longp) +Perl_save_long(pTHX_ long int *longp) { - dTHR; SSCHECK(3); SSPUSHLONG(*longp); SSPUSHPTR(longp); @@ -288,9 +384,8 @@ save_long(long int *longp) } void -save_I32(I32 *intp) +Perl_save_I32(pTHX_ I32 *intp) { - dTHR; SSCHECK(3); SSPUSHINT(*intp); SSPUSHPTR(intp); @@ -298,9 +393,8 @@ save_I32(I32 *intp) } void -save_I16(I16 *intp) +Perl_save_I16(pTHX_ I16 *intp) { - dTHR; SSCHECK(3); SSPUSHINT(*intp); SSPUSHPTR(intp); @@ -308,9 +402,17 @@ save_I16(I16 *intp) } void -save_iv(IV *ivp) +Perl_save_I8(pTHX_ I8 *bytep) +{ + SSCHECK(3); + SSPUSHINT(*bytep); + SSPUSHPTR(bytep); + SSPUSHINT(SAVEt_I8); +} + +void +Perl_save_iv(pTHX_ IV *ivp) { - dTHR; SSCHECK(3); SSPUSHIV(*ivp); SSPUSHPTR(ivp); @@ -321,9 +423,8 @@ save_iv(IV *ivp) * force word-alignment and we'll miss the pointer. */ void -save_pptr(char **pptr) +Perl_save_pptr(pTHX_ char **pptr) { - dTHR; SSCHECK(3); SSPUSHPTR(*pptr); SSPUSHPTR(pptr); @@ -331,44 +432,59 @@ save_pptr(char **pptr) } void -save_sptr(SV **sptr) +Perl_save_vptr(pTHX_ void *ptr) +{ + SSCHECK(3); + SSPUSHPTR(*(char**)ptr); + SSPUSHPTR(ptr); + SSPUSHINT(SAVEt_VPTR); +} + +void +Perl_save_sptr(pTHX_ SV **sptr) { - dTHR; SSCHECK(3); SSPUSHPTR(*sptr); SSPUSHPTR(sptr); SSPUSHINT(SAVEt_SPTR); } +void +Perl_save_padsv(pTHX_ PADOFFSET off) +{ + SSCHECK(4); + SSPUSHPTR(PL_curpad[off]); + SSPUSHPTR(PL_curpad); + SSPUSHLONG((long)off); + SSPUSHINT(SAVEt_PADSV); +} + SV ** -save_threadsv(PADOFFSET i) +Perl_save_threadsv(pTHX_ PADOFFSET i) { -#ifdef USE_THREADS - dTHR; +#ifdef USE_5005THREADS SV **svp = &THREADSV(i); /* XXX Change to save by offset */ - DEBUG_L(PerlIO_printf(PerlIO_stderr(), "save_threadsv %u: %p %p:%s\n", - i, svp, *svp, SvPEEK(*svp))); + DEBUG_S(PerlIO_printf(Perl_debug_log, "save_threadsv %"UVuf": %p %p:%s\n", + (UV)i, svp, *svp, SvPEEK(*svp))); save_svref(svp); return svp; #else - croak("panic: save_threadsv called in non-threaded perl"); + Perl_croak(aTHX_ "panic: save_threadsv called in non-threaded perl"); return 0; -#endif /* USE_THREADS */ +#endif /* USE_5005THREADS */ } void -save_nogv(GV *gv) +Perl_save_nogv(pTHX_ GV *gv) { - dTHR; SSCHECK(2); SSPUSHPTR(gv); SSPUSHINT(SAVEt_NSTAB); } void -save_hptr(HV **hptr) +Perl_save_hptr(pTHX_ HV **hptr) { - dTHR; SSCHECK(3); SSPUSHPTR(*hptr); SSPUSHPTR(hptr); @@ -376,9 +492,8 @@ save_hptr(HV **hptr) } void -save_aptr(AV **aptr) +Perl_save_aptr(pTHX_ AV **aptr) { - dTHR; SSCHECK(3); SSPUSHPTR(*aptr); SSPUSHPTR(aptr); @@ -386,84 +501,58 @@ save_aptr(AV **aptr) } void -save_freesv(SV *sv) +Perl_save_freesv(pTHX_ SV *sv) { - dTHR; SSCHECK(2); SSPUSHPTR(sv); SSPUSHINT(SAVEt_FREESV); } void -save_freeop(OP *o) +Perl_save_mortalizesv(pTHX_ SV *sv) +{ + SSCHECK(2); + SSPUSHPTR(sv); + SSPUSHINT(SAVEt_MORTALIZESV); +} + +void +Perl_save_freeop(pTHX_ OP *o) { - dTHR; SSCHECK(2); SSPUSHPTR(o); SSPUSHINT(SAVEt_FREEOP); } void -save_freepv(char *pv) +Perl_save_freepv(pTHX_ char *pv) { - dTHR; SSCHECK(2); SSPUSHPTR(pv); SSPUSHINT(SAVEt_FREEPV); } void -save_clearsv(SV **svp) +Perl_save_clearsv(pTHX_ SV **svp) { - dTHR; SSCHECK(2); - SSPUSHLONG((long)(svp-curpad)); + SSPUSHLONG((long)(svp-PL_curpad)); SSPUSHINT(SAVEt_CLEARSV); } void -save_delete(HV *hv, char *key, I32 klen) +Perl_save_delete(pTHX_ HV *hv, char *key, I32 klen) { - dTHR; SSCHECK(4); SSPUSHINT(klen); SSPUSHPTR(key); - SSPUSHPTR(hv); + SSPUSHPTR(SvREFCNT_inc(hv)); SSPUSHINT(SAVEt_DELETE); } void -save_list(register SV **sarg, I32 maxsarg) -save_aelem(av,idx,sptr) -AV *av; -I32 idx; -SV **sptr; -{ - SSCHECK(4); - SSPUSHPTR(av); - SSPUSHINT(idx); - SSPUSHPTR(*sptr); - SSPUSHINT(SAVEt_AELEM); - save_scalar_at(sptr); -} - -void -save_helem(hv,key,sptr) -HV *hv; -SV *key; -SV **sptr; -{ - SSCHECK(4); - SSPUSHPTR(hv); - SSPUSHPTR(key); - SSPUSHPTR(*sptr); - SSPUSHINT(SAVEt_HELEM); - save_scalar_at(sptr); -} - -void +Perl_save_list(pTHX_ register SV **sarg, I32 maxsarg) { - dTHR; register SV *sv; register I32 i; @@ -478,9 +567,8 @@ void } void -save_destructor(void (*f) (void *), void *p) +Perl_save_destructor(pTHX_ DESTRUCTORFUNC_NOCONTEXT_t f, void* p) { - dTHR; SSCHECK(3); SSPUSHDPTR(f); SSPUSHPTR(p); @@ -488,51 +576,143 @@ save_destructor(void (*f) (void *), void *p) } void -save_op(void) +Perl_save_destructor_x(pTHX_ DESTRUCTORFUNC_t f, void* p) +{ + SSCHECK(3); + SSPUSHDXPTR(f); + SSPUSHPTR(p); + SSPUSHINT(SAVEt_DESTRUCTOR_X); +} + +void +Perl_save_aelem(pTHX_ AV *av, I32 idx, SV **sptr) +{ + SV *sv; + SSCHECK(4); + SSPUSHPTR(SvREFCNT_inc(av)); + SSPUSHINT(idx); + SSPUSHPTR(SvREFCNT_inc(*sptr)); + SSPUSHINT(SAVEt_AELEM); + save_scalar_at(sptr); + sv = *sptr; + /* If we're localizing a tied array element, this new sv + * won't actually be stored in the array - so it won't get + * reaped when the localize ends. Ensure it gets reaped by + * mortifying it instead. DAPM */ + if (SvTIED_mg(sv, PERL_MAGIC_tiedelem)) + sv_2mortal(sv); +} + +void +Perl_save_helem(pTHX_ HV *hv, SV *key, SV **sptr) +{ + SV *sv; + SSCHECK(4); + SSPUSHPTR(SvREFCNT_inc(hv)); + SSPUSHPTR(SvREFCNT_inc(key)); + SSPUSHPTR(SvREFCNT_inc(*sptr)); + SSPUSHINT(SAVEt_HELEM); + save_scalar_at(sptr); + sv = *sptr; + /* If we're localizing a tied hash element, this new sv + * won't actually be stored in the hash - so it won't get + * reaped when the localize ends. Ensure it gets reaped by + * mortifying it instead. DAPM */ + if (SvTIED_mg(sv, PERL_MAGIC_tiedelem)) + sv_2mortal(sv); +} + +void +Perl_save_op(pTHX) { - dTHR; SSCHECK(2); - SSPUSHPTR(op); + SSPUSHPTR(PL_op); SSPUSHINT(SAVEt_OP); } +I32 +Perl_save_alloc(pTHX_ I32 size, I32 pad) +{ + register I32 start = pad + ((char*)&PL_savestack[PL_savestack_ix] + - (char*)PL_savestack); + register I32 elems = 1 + ((size + pad - 1) / sizeof(*PL_savestack)); + + /* SSCHECK may not be good enough */ + while (PL_savestack_ix + elems + 2 > PL_savestack_max) + savestack_grow(); + + PL_savestack_ix += elems; + SSPUSHINT(elems); + SSPUSHINT(SAVEt_ALLOC); + return start; +} + void -leave_scope(I32 base) +Perl_leave_scope(pTHX_ I32 base) { - dTHR; register SV *sv; register SV *value; register GV *gv; register AV *av; register HV *hv; register void* ptr; + register char* str; I32 i; if (base < -1) - croak("panic: corrupt saved stack index"); - while (savestack_ix > base) { + Perl_croak(aTHX_ "panic: corrupt saved stack index"); + while (PL_savestack_ix > base) { switch (SSPOPINT) { case SAVEt_ITEM: /* normal string */ value = (SV*)SSPOPPTR; sv = (SV*)SSPOPPTR; sv_replace(sv,value); - localizing = 2; + PL_localizing = 2; SvSETMAGIC(sv); - localizing = 0; + PL_localizing = 0; break; - case SAVEt_SV: /* scalar reference */ + case SAVEt_SV: /* scalar reference */ value = (SV*)SSPOPPTR; gv = (GV*)SSPOPPTR; ptr = &GvSV(gv); + SvREFCNT_dec(gv); goto restore_sv; - case SAVEt_SVREF: /* scalar reference */ + case SAVEt_GENERIC_PVREF: /* generic pv */ + str = (char*)SSPOPPTR; + ptr = SSPOPPTR; + if (*(char**)ptr != str) { + Safefree(*(char**)ptr); + *(char**)ptr = str; + } + break; + case SAVEt_SHARED_PVREF: /* shared pv */ + str = (char*)SSPOPPTR; + ptr = SSPOPPTR; + if (*(char**)ptr != str) { +#ifdef NETWARE + PerlMem_free(*(char**)ptr); +#else + PerlMemShared_free(*(char**)ptr); +#endif + *(char**)ptr = str; + } + break; + case SAVEt_GENERIC_SVREF: /* generic sv */ + value = (SV*)SSPOPPTR; + ptr = SSPOPPTR; + sv = *(SV**)ptr; + *(SV**)ptr = value; + SvREFCNT_dec(sv); + SvREFCNT_dec(value); + break; + case SAVEt_SVREF: /* scalar reference */ value = (SV*)SSPOPPTR; ptr = SSPOPPTR; restore_sv: sv = *(SV**)ptr; - DEBUG_L(PerlIO_printf(PerlIO_stderr(), + DEBUG_S(PerlIO_printf(Perl_debug_log, "restore svref: %p %p:%s -> %p:%s\n", - ptr, sv, SvPEEK(sv), value, SvPEEK(value))); + ptr, sv, SvPEEK(sv), value, SvPEEK(value))); if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv) && SvTYPE(sv) != SVt_PVGV) { @@ -542,39 +722,47 @@ leave_scope(I32 base) SvMAGICAL_off(sv); SvMAGIC(sv) = 0; } + /* XXX This branch is pretty bogus. This code irretrievably + * clears(!) the magic on the SV (either to avoid further + * croaking that might ensue when the SvSETMAGIC() below is + * called, or to avoid two different SVs pointing at the same + * SvMAGIC()). This needs a total rethink. --GSAR */ else if (SvTYPE(value) >= SVt_PVMG && SvMAGIC(value) && SvTYPE(value) != SVt_PVGV) { SvFLAGS(value) |= (SvFLAGS(value) & - (SVp_IOK|SVp_NOK|SVp_POK)) >> PRIVSHIFT; + (SVp_NOK|SVp_POK)) >> PRIVSHIFT; SvMAGICAL_off(value); + /* XXX this is a leak when we get here because the + * mg_get() in save_scalar_at() croaked */ SvMAGIC(value) = 0; } - SvREFCNT_dec(sv); + SvREFCNT_dec(sv); *(SV**)ptr = value; - localizing = 2; + PL_localizing = 2; SvSETMAGIC(value); - localizing = 0; - break; - case SAVEt_AV: /* array reference */ + PL_localizing = 0; + SvREFCNT_dec(value); + break; + case SAVEt_AV: /* array reference */ av = (AV*)SSPOPPTR; gv = (GV*)SSPOPPTR; if (GvAV(gv)) { AV *goner = GvAV(gv); SvMAGIC(av) = SvMAGIC(goner); - SvFLAGS(av) |= SvMAGICAL(goner); + SvFLAGS((SV*)av) |= SvMAGICAL(goner); SvMAGICAL_off(goner); SvMAGIC(goner) = 0; SvREFCNT_dec(goner); } - GvAV(gv) = av; + GvAV(gv) = av; if (SvMAGICAL(av)) { - localizing = 2; + PL_localizing = 2; SvSETMAGIC((SV*)av); - localizing = 0; + PL_localizing = 0; } - break; - case SAVEt_HV: /* hash reference */ + break; + case SAVEt_HV: /* hash reference */ hv = (HV*)SSPOPPTR; gv = (GV*)SSPOPPTR; if (GvHV(gv)) { @@ -585,13 +773,13 @@ leave_scope(I32 base) SvMAGIC(goner) = 0; SvREFCNT_dec(goner); } - GvHV(gv) = hv; + GvHV(gv) = hv; if (SvMAGICAL(hv)) { - localizing = 2; + PL_localizing = 2; SvSETMAGIC((SV*)hv); - localizing = 0; + PL_localizing = 0; } - break; + break; case SAVEt_INT: /* int reference */ ptr = SSPOPPTR; *(int*)ptr = (int)SSPOPINT; @@ -608,6 +796,10 @@ leave_scope(I32 base) ptr = SSPOPPTR; *(I16*)ptr = (I16)SSPOPINT; break; + case SAVEt_I8: /* I8 reference */ + ptr = SSPOPPTR; + *(I8*)ptr = (I8)SSPOPINT; + break; case SAVEt_IV: /* IV reference */ ptr = SSPOPPTR; *(IV*)ptr = (IV)SSPOPIV; @@ -616,6 +808,7 @@ leave_scope(I32 base) ptr = SSPOPPTR; *(SV**)ptr = (SV*)SSPOPPTR; break; + case SAVEt_VPTR: /* random* reference */ case SAVEt_PPTR: /* char* reference */ ptr = SSPOPPTR; *(char**)ptr = (char*)SSPOPPTR; @@ -635,24 +828,30 @@ leave_scope(I32 base) case SAVEt_GP: /* scalar reference */ ptr = SSPOPPTR; gv = (GV*)SSPOPPTR; - if (SvPOK(gv) && SvLEN(gv) > 0) { - Safefree(SvPVX(gv)); - } - SvPVX(gv) = (char *)SSPOPPTR; - SvCUR(gv) = (STRLEN)SSPOPIV; - SvLEN(gv) = (STRLEN)SSPOPIV; - gp_free(gv); - GvGP(gv) = (GP*)ptr; + if (SvPVX(gv) && SvLEN(gv) > 0) { + Safefree(SvPVX(gv)); + } + SvPVX(gv) = (char *)SSPOPPTR; + SvCUR(gv) = (STRLEN)SSPOPIV; + SvLEN(gv) = (STRLEN)SSPOPIV; + gp_free(gv); + GvGP(gv) = (GP*)ptr; + if (GvCVu(gv)) + PL_sub_generation++; /* putting a method back into circulation */ SvREFCNT_dec(gv); - break; + break; case SAVEt_FREESV: ptr = SSPOPPTR; SvREFCNT_dec((SV*)ptr); break; + case SAVEt_MORTALIZESV: + ptr = SSPOPPTR; + sv_2mortal((SV*)ptr); + break; case SAVEt_FREEOP: ptr = SSPOPPTR; - if (comppad) - curpad = AvARRAY(comppad); + if (PL_comppad) + PL_curpad = AvARRAY(PL_comppad); op_free((OP*)ptr); break; case SAVEt_FREEPV: @@ -660,16 +859,20 @@ leave_scope(I32 base) Safefree((char*)ptr); break; case SAVEt_CLEARSV: - ptr = (void*)&curpad[SSPOPLONG]; + ptr = (void*)&PL_curpad[SSPOPLONG]; sv = *(SV**)ptr; /* Can clear pad variable in place? */ if (SvREFCNT(sv) <= 1 && !SvOBJECT(sv)) { - if (SvTHINKFIRST(sv)) { - if (SvREADONLY(sv)) - croak("panic: leave_scope clearsv"); - if (SvROK(sv)) - sv_unref(sv); - } + /* + * if a my variable that was made readonly is going out of + * scope, we want to remove the readonlyness so that it can + * go out of scope quietly + */ + if (SvPADMY(sv) && !SvFAKE(sv)) + SvREADONLY_off(sv); + + if (SvTHINKFIRST(sv)) + sv_force_normal_flags(sv, SV_IMMEDIATE_UNREF); if (SvMAGICAL(sv)) mg_free(sv); @@ -683,7 +886,7 @@ leave_scope(I32 base) hv_clear((HV*)sv); break; case SVt_PVCV: - croak("panic: leave_scope pad code"); + Perl_croak(aTHX_ "panic: leave_scope pad code"); case SVt_RV: case SVt_IV: case SVt_NV: @@ -711,84 +914,145 @@ leave_scope(I32 base) hv = (HV*)ptr; ptr = SSPOPPTR; (void)hv_delete(hv, (char*)ptr, (U32)SSPOPINT, G_DISCARD); + SvREFCNT_dec(hv); Safefree(ptr); break; case SAVEt_DESTRUCTOR: ptr = SSPOPPTR; (*SSPOPDPTR)(ptr); break; + case SAVEt_DESTRUCTOR_X: + ptr = SSPOPPTR; + (*SSPOPDXPTR)(aTHX_ ptr); + break; case SAVEt_REGCONTEXT: + case SAVEt_ALLOC: i = SSPOPINT; - savestack_ix -= i; /* regexp must have croaked */ + PL_savestack_ix -= i; /* regexp must have croaked */ break; case SAVEt_STACK_POS: /* Position on Perl stack */ i = SSPOPINT; - stack_sp = stack_base + i; + PL_stack_sp = PL_stack_base + i; break; case SAVEt_AELEM: /* array element */ value = (SV*)SSPOPPTR; i = SSPOPINT; av = (AV*)SSPOPPTR; ptr = av_fetch(av,i,1); - goto restore_sv; + if (ptr) { + sv = *(SV**)ptr; + if (sv && sv != &PL_sv_undef) { + if (SvTIED_mg((SV*)av, PERL_MAGIC_tied)) + (void)SvREFCNT_inc(sv); + SvREFCNT_dec(av); + goto restore_sv; + } + } + SvREFCNT_dec(av); + SvREFCNT_dec(value); + break; case SAVEt_HELEM: /* hash element */ value = (SV*)SSPOPPTR; - sv = (SV*)SSPOPINT; + sv = (SV*)SSPOPPTR; hv = (HV*)SSPOPPTR; ptr = hv_fetch_ent(hv, sv, 1, 0); - ptr = &HeVAL((HE*)ptr); - goto restore_sv; + if (ptr) { + SV *oval = HeVAL((HE*)ptr); + if (oval && oval != &PL_sv_undef) { + ptr = &HeVAL((HE*)ptr); + if (SvTIED_mg((SV*)hv, PERL_MAGIC_tied)) + (void)SvREFCNT_inc(*(SV**)ptr); + SvREFCNT_dec(hv); + SvREFCNT_dec(sv); + goto restore_sv; + } + } + SvREFCNT_dec(hv); + SvREFCNT_dec(sv); + SvREFCNT_dec(value); + break; case SAVEt_OP: - op = (OP*)SSPOPPTR; + PL_op = (OP*)SSPOPPTR; + break; + case SAVEt_HINTS: + if ((PL_hints & HINT_LOCALIZE_HH) && GvHV(PL_hintgv)) { + SvREFCNT_dec((SV*)GvHV(PL_hintgv)); + GvHV(PL_hintgv) = NULL; + } + *(I32*)&PL_hints = (I32)SSPOPINT; + break; + case SAVEt_COMPPAD: + PL_comppad = (AV*)SSPOPPTR; + if (PL_comppad) + PL_curpad = AvARRAY(PL_comppad); + else + PL_curpad = Null(SV**); + break; + case SAVEt_PADSV: + { + PADOFFSET off = (PADOFFSET)SSPOPLONG; + ptr = SSPOPPTR; + if (ptr) + ((SV**)ptr)[off] = (SV*)SSPOPPTR; + } break; default: - croak("panic: leave_scope inconsistency"); + Perl_croak(aTHX_ "panic: leave_scope inconsistency"); } } } -#ifdef DEBUGGING - void -cx_dump(PERL_CONTEXT *cx) +Perl_cx_dump(pTHX_ PERL_CONTEXT *cx) { - dTHR; - PerlIO_printf(Perl_debug_log, "CX %ld = %s\n", (long)(cx - cxstack), block_type[cx->cx_type]); - if (cx->cx_type != CXt_SUBST) { +#ifdef DEBUGGING + PerlIO_printf(Perl_debug_log, "CX %ld = %s\n", (long)(cx - cxstack), PL_block_type[CxTYPE(cx)]); + if (CxTYPE(cx) != CXt_SUBST) { PerlIO_printf(Perl_debug_log, "BLK_OLDSP = %ld\n", (long)cx->blk_oldsp); - PerlIO_printf(Perl_debug_log, "BLK_OLDCOP = 0x%lx\n", (long)cx->blk_oldcop); + PerlIO_printf(Perl_debug_log, "BLK_OLDCOP = 0x%"UVxf"\n", + PTR2UV(cx->blk_oldcop)); PerlIO_printf(Perl_debug_log, "BLK_OLDMARKSP = %ld\n", (long)cx->blk_oldmarksp); PerlIO_printf(Perl_debug_log, "BLK_OLDSCOPESP = %ld\n", (long)cx->blk_oldscopesp); PerlIO_printf(Perl_debug_log, "BLK_OLDRETSP = %ld\n", (long)cx->blk_oldretsp); - PerlIO_printf(Perl_debug_log, "BLK_OLDPM = 0x%lx\n", (long)cx->blk_oldpm); + PerlIO_printf(Perl_debug_log, "BLK_OLDPM = 0x%"UVxf"\n", + PTR2UV(cx->blk_oldpm)); PerlIO_printf(Perl_debug_log, "BLK_GIMME = %s\n", cx->blk_gimme ? "LIST" : "SCALAR"); } - switch (cx->cx_type) { + switch (CxTYPE(cx)) { case CXt_NULL: case CXt_BLOCK: break; + case CXt_FORMAT: + PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%"UVxf"\n", + PTR2UV(cx->blk_sub.cv)); + PerlIO_printf(Perl_debug_log, "BLK_SUB.GV = 0x%"UVxf"\n", + PTR2UV(cx->blk_sub.gv)); + PerlIO_printf(Perl_debug_log, "BLK_SUB.DFOUTGV = 0x%"UVxf"\n", + PTR2UV(cx->blk_sub.dfoutgv)); + PerlIO_printf(Perl_debug_log, "BLK_SUB.HASARGS = %d\n", + (int)cx->blk_sub.hasargs); + break; case CXt_SUB: - PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%lx\n", - (long)cx->blk_sub.cv); - PerlIO_printf(Perl_debug_log, "BLK_SUB.GV = 0x%lx\n", - (long)cx->blk_sub.gv); - PerlIO_printf(Perl_debug_log, "BLK_SUB.DFOUTGV = 0x%lx\n", - (long)cx->blk_sub.dfoutgv); + PerlIO_printf(Perl_debug_log, "BLK_SUB.CV = 0x%"UVxf"\n", + PTR2UV(cx->blk_sub.cv)); PerlIO_printf(Perl_debug_log, "BLK_SUB.OLDDEPTH = %ld\n", (long)cx->blk_sub.olddepth); PerlIO_printf(Perl_debug_log, "BLK_SUB.HASARGS = %d\n", (int)cx->blk_sub.hasargs); + PerlIO_printf(Perl_debug_log, "BLK_SUB.LVAL = %d\n", + (int)cx->blk_sub.lval); break; case CXt_EVAL: PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_IN_EVAL = %ld\n", (long)cx->blk_eval.old_in_eval); PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_OP_TYPE = %s (%s)\n", - op_name[cx->blk_eval.old_op_type], - op_desc[cx->blk_eval.old_op_type]); - PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_NAME = %s\n", - cx->blk_eval.old_name); - PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_EVAL_ROOT = 0x%lx\n", - (long)cx->blk_eval.old_eval_root); + PL_op_name[cx->blk_eval.old_op_type], + PL_op_desc[cx->blk_eval.old_op_type]); + if (cx->blk_eval.old_namesv) + PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_NAME = %s\n", + SvPVX(cx->blk_eval.old_namesv)); + PerlIO_printf(Perl_debug_log, "BLK_EVAL.OLD_EVAL_ROOT = 0x%"UVxf"\n", + PTR2UV(cx->blk_eval.old_eval_root)); break; case CXt_LOOP: @@ -796,23 +1060,23 @@ cx_dump(PERL_CONTEXT *cx) cx->blk_loop.label); PerlIO_printf(Perl_debug_log, "BLK_LOOP.RESETSP = %ld\n", (long)cx->blk_loop.resetsp); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.REDO_OP = 0x%lx\n", - (long)cx->blk_loop.redo_op); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.NEXT_OP = 0x%lx\n", - (long)cx->blk_loop.next_op); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.LAST_OP = 0x%lx\n", - (long)cx->blk_loop.last_op); + PerlIO_printf(Perl_debug_log, "BLK_LOOP.REDO_OP = 0x%"UVxf"\n", + PTR2UV(cx->blk_loop.redo_op)); + PerlIO_printf(Perl_debug_log, "BLK_LOOP.NEXT_OP = 0x%"UVxf"\n", + PTR2UV(cx->blk_loop.next_op)); + PerlIO_printf(Perl_debug_log, "BLK_LOOP.LAST_OP = 0x%"UVxf"\n", + PTR2UV(cx->blk_loop.last_op)); PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERIX = %ld\n", (long)cx->blk_loop.iterix); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERARY = 0x%lx\n", - (long)cx->blk_loop.iterary); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERVAR = 0x%lx\n", - (long)cx->blk_loop.itervar); - if (cx->blk_loop.itervar) - PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERSAVE = 0x%lx\n", - (long)cx->blk_loop.itersave); - PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERLVAL = 0x%lx\n", - (long)cx->blk_loop.iterlval); + PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERARY = 0x%"UVxf"\n", + PTR2UV(cx->blk_loop.iterary)); + PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERVAR = 0x%"UVxf"\n", + PTR2UV(CxITERVAR(cx))); + if (CxITERVAR(cx)) + PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERSAVE = 0x%"UVxf"\n", + PTR2UV(cx->blk_loop.itersave)); + PerlIO_printf(Perl_debug_log, "BLK_LOOP.ITERLVAL = 0x%"UVxf"\n", + PTR2UV(cx->blk_loop.iterlval)); break; case CXt_SUBST: @@ -820,25 +1084,25 @@ cx_dump(PERL_CONTEXT *cx) (long)cx->sb_iters); PerlIO_printf(Perl_debug_log, "SB_MAXITERS = %ld\n", (long)cx->sb_maxiters); - PerlIO_printf(Perl_debug_log, "SB_SAFEBASE = %ld\n", - (long)cx->sb_safebase); + PerlIO_printf(Perl_debug_log, "SB_RFLAGS = %ld\n", + (long)cx->sb_rflags); PerlIO_printf(Perl_debug_log, "SB_ONCE = %ld\n", (long)cx->sb_once); PerlIO_printf(Perl_debug_log, "SB_ORIG = %s\n", cx->sb_orig); - PerlIO_printf(Perl_debug_log, "SB_DSTR = 0x%lx\n", - (long)cx->sb_dstr); - PerlIO_printf(Perl_debug_log, "SB_TARG = 0x%lx\n", - (long)cx->sb_targ); - PerlIO_printf(Perl_debug_log, "SB_S = 0x%lx\n", - (long)cx->sb_s); - PerlIO_printf(Perl_debug_log, "SB_M = 0x%lx\n", - (long)cx->sb_m); - PerlIO_printf(Perl_debug_log, "SB_STREND = 0x%lx\n", - (long)cx->sb_strend); - PerlIO_printf(Perl_debug_log, "SB_RXRES = 0x%lx\n", - (long)cx->sb_rxres); + PerlIO_printf(Perl_debug_log, "SB_DSTR = 0x%"UVxf"\n", + PTR2UV(cx->sb_dstr)); + PerlIO_printf(Perl_debug_log, "SB_TARG = 0x%"UVxf"\n", + PTR2UV(cx->sb_targ)); + PerlIO_printf(Perl_debug_log, "SB_S = 0x%"UVxf"\n", + PTR2UV(cx->sb_s)); + PerlIO_printf(Perl_debug_log, "SB_M = 0x%"UVxf"\n", + PTR2UV(cx->sb_m)); + PerlIO_printf(Perl_debug_log, "SB_STREND = 0x%"UVxf"\n", + PTR2UV(cx->sb_strend)); + PerlIO_printf(Perl_debug_log, "SB_RXRES = 0x%"UVxf"\n", + PTR2UV(cx->sb_rxres)); break; } +#endif /* DEBUGGING */ } -#endif