X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=sv.c;h=a1f1d60715725f2058061b1ef57cfbaf0faeff1d;hb=cf8a192df3df82f50274b83f7996aab39275728a;hp=ed8dc5228cd638c20c438d98101579dd33866f67;hpb=adbc6bb137ce1026e8a7cba251bb82b41f398aae;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/sv.c b/sv.c
index ed8dc52..a1f1d60 100644
--- a/sv.c
+++ b/sv.c
@@ -14,6 +14,13 @@
 #include "EXTERN.h"
 #include "perl.h"
 
+#ifdef OVR_DBL_DIG
+/* Use an overridden DBL_DIG */
+# ifdef DBL_DIG
+#  undef DBL_DIG
+# endif
+# define DBL_DIG OVR_DBL_DIG
+#else
 /* The following is all to get DBL_DIG, in order to pick a nice
    default value for printing floating point numbers in Gconvert.
    (see config.h)
@@ -27,6 +34,11 @@
 #ifndef HAS_DBL_DIG
 #define DBL_DIG	15   /* A guess that works lots of places */
 #endif
+#endif
+
+#if defined(USE_STDIO_PTR) && defined(STDIO_PTR_LVALUE) && defined(STDIO_CNT_LVALUE)
+#  define FAST_SV_GETS
+#endif
 
 static SV *more_sv _((void));
 static XPVIV *more_xiv _((void));
@@ -51,6 +63,16 @@ static void sv_unglob _((SV* sv));
 #define new_SV() sv = (SV*)safemalloc(sizeof(SV))
 #define del_SV(p) free((char*)p)
 
+void
+sv_add_arena(ptr, size, flags)
+char* ptr;
+U32 size;
+U32 flags;
+{
+    if (!(flags & SVf_FAKE))
+	free(ptr);
+}
+
 #else
 
 #define new_SV()			\
@@ -61,7 +83,6 @@ static void sv_unglob _((SV* sv));
     }					\
     else				\
 	sv = more_sv();
-#endif
 
 static SV*
 new_sv()
@@ -91,11 +112,13 @@ del_sv(p)
 SV* p;
 {
     if (debug & 32768) {
+	SV* sva;
 	SV* sv;
 	SV* svend;
 	int ok = 0;
-	for (sv = sv_arenaroot; sv; sv = (SV *) SvANY(svend)) {
-	    svend = &sv[1008 / sizeof(SV)];
+	for (sva = sv_arenaroot; sva; sva = (SV *) SvANY(sva)) {
+	    sv = sva + 1;
+	    svend = &sva[SvREFCNT(sva)];
 	    if (p >= sv && p < svend)
 		ok = 1;
 	}
@@ -116,35 +139,59 @@ SV* p;
 
 #endif
 
-static SV*
-more_sv()
+void
+sv_add_arena(ptr, size, flags)
+char* ptr;
+U32 size;
+U32 flags;
 {
+    SV* sva = (SV*)ptr;
     register SV* sv;
     register SV* svend;
-    sv_root = (SV*)safemalloc(1012);
-    sv = sv_root;
-    Zero(sv, 1012, char);
-    svend = &sv[1008 / sizeof(SV) - 1];
+    Zero(sva, size, char);
+
+    /* The first SV in an arena isn't an SV. */
+    SvANY(sva) = (void *) sv_arenaroot;		/* ptr to next arena */
+    SvREFCNT(sva) = size / sizeof(SV);		/* number of SV slots */
+    SvFLAGS(sva) = flags;			/* FAKE if not to be freed */
+
+    sv_arenaroot = sva;
+    sv_root = sva + 1;
+
+    svend = &sva[SvREFCNT(sva) - 1];
+    sv = sva + 1;
     while (sv < svend) {
 	SvANY(sv) = (void *)(SV*)(sv + 1);
 	SvFLAGS(sv) = SVTYPEMASK;
 	sv++;
     }
     SvANY(sv) = 0;
-    sv++;
-    SvANY(sv) = (void *) sv_arenaroot;
-    sv_arenaroot = sv_root;
+    SvFLAGS(sv) = SVTYPEMASK;
+}
+
+static SV*
+more_sv()
+{
+    if (nice_chunk) {
+	sv_add_arena(nice_chunk, nice_chunk_size, 0);
+	nice_chunk = Nullch;
+    }
+    else
+	sv_add_arena(safemalloc(1008), 1008, 0);
     return new_sv();
 }
+#endif
 
 void
 sv_report_used()
 {
+    SV* sva;
     SV* sv;
     register SV* svend;
 
-    for (sv = sv_arenaroot; sv; sv = (SV *) SvANY(sv)) {
-	svend = &sv[1008 / sizeof(SV)];
+    for (sva = sv_arenaroot; sva; sva = (SV *) SvANY(sva)) {
+	sv = sva + 1;
+	svend = &sva[SvREFCNT(sva)];
 	while (sv < svend) {
 	    if (SvTYPE(sv) != SVTYPEMASK) {
 		fprintf(stderr, "****\n");
@@ -158,12 +205,35 @@ sv_report_used()
 void
 sv_clean_objs()
 {
+    SV* sva;
     register SV* sv;
     register SV* svend;
     SV* rv;
 
-    for (sv = sv_arenaroot; sv; sv = (SV *) SvANY(sv)) {
-	svend = &sv[1008 / sizeof(SV)];
+#ifndef DISABLE_DESTRUCTOR_KLUDGE
+    register GV* gv;
+    for (sva = sv_arenaroot; sva; sva = (SV *) SvANY(sva)) {
+	gv = sva + 1;
+	svend = &sva[SvREFCNT(sva)];
+	while (gv < svend) {
+	    if (SvTYPE(gv) == SVt_PVGV && (sv = GvSV(gv)) &&
+		SvROK(sv) && SvOBJECT(rv = SvRV(sv)))
+	    {
+		DEBUG_D((fprintf(stderr, "Cleaning object ref:\n "),
+			 sv_dump(sv));)
+		SvROK_off(sv);
+		SvRV(sv) = 0;
+		SvREFCNT_dec(rv);
+	    }
+	    ++gv;
+	}
+    }
+    if (!sv_objcount)
+	return;
+#endif
+    for (sva = sv_arenaroot; sva; sva = (SV *) SvANY(sva)) {
+	sv = sva + 1;
+	svend = &sva[SvREFCNT(sva)];
 	while (sv < svend) {
 	    if (SvROK(sv) && SvOBJECT(rv = SvRV(sv))) {
 		DEBUG_D((fprintf(stderr, "Cleaning object ref:\n "),
@@ -181,11 +251,13 @@ sv_clean_objs()
 void
 sv_clean_all()
 {
+    SV* sva;
     register SV* sv;
     register SV* svend;
 
-    for (sv = sv_arenaroot; sv; sv = (SV *) SvANY(sv)) {
-	svend = &sv[1008 / sizeof(SV)];
+    for (sva = sv_arenaroot; sva; sva = (SV*) SvANY(sva)) {
+	sv = sva + 1;
+	svend = &sva[SvREFCNT(sva)];
 	while (sv < svend) {
 	    if (SvTYPE(sv) != SVTYPEMASK) {
 		DEBUG_D((fprintf(stderr, "Cleaning loops:\n "), sv_dump(sv));)
@@ -197,6 +269,25 @@ sv_clean_all()
     }
 }
 
+void
+sv_free_arenas()
+{
+    SV* sva;
+    SV* svanext;
+
+    /* Free arenas here, but be careful about fake ones.  (We assume
+       contiguity of the fake ones with the corresponding real ones.) */
+
+    for (sva = sv_arenaroot; sva; sva = svanext) {
+	svanext = (SV*) SvANY(sva);
+	while (svanext && SvFAKE(svanext))
+	    svanext = (SV*) SvANY(svanext);
+
+	if (!SvFAKE(sva))
+	    Safefree(sva);
+    }
+}
+
 static XPVIV*
 new_xiv()
 {
@@ -433,6 +524,9 @@ U32 mt;
     if (SvTYPE(sv) == mt)
 	return TRUE;
 
+    if (mt < SVt_PVIV)
+	(void)SvOOK_off(sv);
+
     switch (SvTYPE(sv)) {
     case SVt_NULL:
 	pv	= 0;
@@ -490,6 +584,10 @@ U32 mt;
 	magic	= 0;
 	stash	= 0;
 	del_XPV(SvANY(sv));
+	if (mt <= SVt_IV)
+	    mt = SVt_PVIV;
+	else if (mt == SVt_NV)
+	    mt = SVt_PVNV;
 	break;
     case SVt_PVIV:
 	nv = 0.0;
@@ -623,6 +721,7 @@ U32 mt;
 	break;
     case SVt_PVCV:
 	SvANY(sv) = new_XPVCV();
+	Zero(SvANY(sv), 1, XPVCV);
 	SvPVX(sv)	= pv;
 	SvCUR(sv)	= cur;
 	SvLEN(sv)	= len;
@@ -630,15 +729,6 @@ U32 mt;
 	SvNVX(sv)	= nv;
 	SvMAGIC(sv)	= magic;
 	SvSTASH(sv)	= stash;
-	CvSTASH(sv)	= 0;
-	CvSTART(sv)	= 0;
-	CvROOT(sv)	= 0;
-	CvXSUB(sv)	= 0;
-	CvXSUBANY(sv).any_ptr	= 0;
-	CvFILEGV(sv)	= 0;
-	CvDEPTH(sv)	= 0;
-	CvPADLIST(sv)	= 0;
-	CvOLDSTYLE(sv)	= 0;
 	break;
     case SVt_PVGV:
 	SvANY(sv) = new_XPVGV();
@@ -653,6 +743,7 @@ U32 mt;
 	GvNAME(sv)	= 0;
 	GvNAMELEN(sv)	= 0;
 	GvSTASH(sv)	= 0;
+	GvFLAGS(sv)	= 0;
 	break;
     case SVt_PVBM:
 	SvANY(sv) = new_XPVBM();
@@ -669,6 +760,7 @@ U32 mt;
 	break;
     case SVt_PVFM:
 	SvANY(sv) = new_XPVFM();
+	Zero(SvANY(sv), 1, XPVFM);
 	SvPVX(sv)	= pv;
 	SvCUR(sv)	= cur;
 	SvLEN(sv)	= len;
@@ -676,10 +768,10 @@ U32 mt;
 	SvNVX(sv)	= nv;
 	SvMAGIC(sv)	= magic;
 	SvSTASH(sv)	= stash;
-	FmLINES(sv)	= 0;
 	break;
     case SVt_PVIO:
 	SvANY(sv) = new_XPVIO();
+	Zero(SvANY(sv), 1, XPVIO);
 	SvPVX(sv)	= pv;
 	SvCUR(sv)	= cur;
 	SvLEN(sv)	= len;
@@ -687,22 +779,7 @@ U32 mt;
 	SvNVX(sv)	= nv;
 	SvMAGIC(sv)	= magic;
 	SvSTASH(sv)	= stash;
-	IoIFP(sv)	= 0;
-	IoOFP(sv)	= 0;
-	IoDIRP(sv)	= 0;
-	IoLINES(sv)	= 0;
-	IoPAGE(sv)	= 0;
 	IoPAGE_LEN(sv)	= 60;
-	IoLINES_LEFT(sv)= 0;
-	IoTOP_NAME(sv)	= 0;
-	IoTOP_GV(sv)	= 0;
-	IoFMT_NAME(sv)	= 0;
-	IoFMT_GV(sv)	= 0;
-	IoBOTTOM_NAME(sv)= 0;
-	IoBOTTOM_GV(sv)	= 0;
-	IoSUBPROCESS(sv)= 0;
-	IoTYPE(sv)	= 0;
-	IoFLAGS(sv)	= 0;
 	break;
     }
     SvFLAGS(sv) &= ~SVTYPEMASK;
@@ -952,8 +1029,8 @@ IV i;
 	croak("Can't coerce %s to integer in %s", sv_reftype(sv,0),
 	    op_name[op->op_type]);
     }
-    SvIVX(sv) = i;
     (void)SvIOK_only(sv);			/* validate number */
+    SvIVX(sv) = i;
     SvTAINT(sv);
 }
 
@@ -1036,7 +1113,7 @@ SV *sv;
     *d = '\0';
 
     if (op)
-	warn("Argument \"%s\" isn't numeric for %s", tmpbuf,
+	warn("Argument \"%s\" isn't numeric in %s", tmpbuf,
 		op_name[op->op_type]);
     else
 	warn("Argument \"%s\" isn't numeric", tmpbuf);
@@ -1052,14 +1129,20 @@ register SV *sv;
 	mg_get(sv);
 	if (SvIOKp(sv))
 	    return SvIVX(sv);
-	if (SvNOKp(sv))
-	    return I_V(SvNVX(sv));
+	if (SvNOKp(sv)) {
+	    if (SvNVX(sv) < 0.0)
+		return I_V(SvNVX(sv));
+	    else
+		return (IV) U_V(SvNVX(sv));
+	}
 	if (SvPOKp(sv) && SvLEN(sv)) {
 	    if (dowarn && !looks_like_number(sv))
 		not_a_number(sv);
 	    return (IV)atol(SvPVX(sv));
 	}
-	return 0;
+        if (!SvROK(sv)) {
+            return 0;
+        }
     }
     if (SvTHINKFIRST(sv)) {
 	if (SvROK(sv)) {
@@ -1071,9 +1154,13 @@ register SV *sv;
 	  return (IV)SvRV(sv);
 	}
 	if (SvREADONLY(sv)) {
-	    if (SvNOK(sv))
-		return I_V(SvNVX(sv));
-	    if (SvPOK(sv) && SvLEN(sv)) {
+	    if (SvNOKp(sv)) {
+		if (SvNVX(sv) < 0.0)
+		    return I_V(SvNVX(sv));
+		else
+		    return (IV) U_V(SvNVX(sv));
+	    }
+	    if (SvPOKp(sv) && SvLEN(sv)) {
 		if (dowarn && !looks_like_number(sv))
 		    not_a_number(sv);
 		return (IV)atol(SvPVX(sv));
@@ -1094,19 +1181,24 @@ register SV *sv;
 	sv_upgrade(sv, SVt_PVNV);
 	break;
     }
-    if (SvNOK(sv))
-	SvIVX(sv) = I_V(SvNVX(sv));
-    else if (SvPOK(sv) && SvLEN(sv)) {
+    if (SvNOKp(sv)) {
+	(void)SvIOK_on(sv);
+	if (SvNVX(sv) < 0.0)
+	    SvIVX(sv) = I_V(SvNVX(sv));
+	else
+	    SvIVX(sv) = (IV) U_V(SvNVX(sv));
+    }
+    else if (SvPOKp(sv) && SvLEN(sv)) {
 	if (dowarn && !looks_like_number(sv))
 	    not_a_number(sv);
+	(void)SvIOK_on(sv);
 	SvIVX(sv) = (IV)atol(SvPVX(sv));
     }
     else  {
-	if (dowarn && !localizing)
+	if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
 	    warn(warn_uninit);
 	return 0;
     }
-    (void)SvIOK_on(sv);
     DEBUG_c(fprintf(stderr,"0x%lx 2iv(%ld)\n",
 	(unsigned long)sv,(long)SvIVX(sv)));
     return SvIVX(sv);
@@ -1123,13 +1215,15 @@ register SV *sv;
 	if (SvNOKp(sv))
 	    return SvNVX(sv);
 	if (SvPOKp(sv) && SvLEN(sv)) {
-	    if (dowarn && !SvIOK(sv) && !looks_like_number(sv))
+	    if (dowarn && !SvIOKp(sv) && !looks_like_number(sv))
 		not_a_number(sv);
 	    return atof(SvPVX(sv));
 	}
 	if (SvIOKp(sv))
 	    return (double)SvIVX(sv);
-	return 0;
+        if (!SvROK(sv)) {
+            return 0;
+        }
     }
     if (SvTHINKFIRST(sv)) {
 	if (SvROK(sv)) {
@@ -1141,12 +1235,12 @@ register SV *sv;
 	  return (double)(unsigned long)SvRV(sv);
 	}
 	if (SvREADONLY(sv)) {
-	    if (SvPOK(sv) && SvLEN(sv)) {
-		if (dowarn && !SvIOK(sv) && !looks_like_number(sv))
+	    if (SvPOKp(sv) && SvLEN(sv)) {
+		if (dowarn && !SvIOKp(sv) && !looks_like_number(sv))
 		    not_a_number(sv);
 		return atof(SvPVX(sv));
 	    }
-	    if (SvIOK(sv))
+	    if (SvIOKp(sv))
 		return (double)SvIVX(sv);
 	    if (dowarn)
 		warn(warn_uninit);
@@ -1162,18 +1256,18 @@ register SV *sv;
     }
     else if (SvTYPE(sv) < SVt_PVNV)
 	sv_upgrade(sv, SVt_PVNV);
-    if (SvIOK(sv) &&
-	    (!SvPOK(sv) || !strchr(SvPVX(sv),'.') || !looks_like_number(sv)))
+    if (SvIOKp(sv) &&
+	    (!SvPOKp(sv) || !strchr(SvPVX(sv),'.') || !looks_like_number(sv)))
     {
 	SvNVX(sv) = (double)SvIVX(sv);
     }
-    else if (SvPOK(sv) && SvLEN(sv)) {
-	if (dowarn && !SvIOK(sv) && !looks_like_number(sv))
+    else if (SvPOKp(sv) && SvLEN(sv)) {
+	if (dowarn && !SvIOKp(sv) && !looks_like_number(sv))
 	    not_a_number(sv);
 	SvNVX(sv) = atof(SvPVX(sv));
     }
     else  {
-	if (dowarn && !localizing)
+	if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
 	    warn(warn_uninit);
 	return 0.0;
     }
@@ -1208,8 +1302,10 @@ STRLEN *lp;
 	    Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
 	    goto tokensave;
 	}
-	*lp = 0;
-	return "";
+        if (!SvROK(sv)) {
+            *lp = 0;
+            return "";
+        }
     }
     if (SvTHINKFIRST(sv)) {
 	if (SvROK(sv)) {
@@ -1252,12 +1348,12 @@ STRLEN *lp;
 	    return s;
 	}
 	if (SvREADONLY(sv)) {
-	    if (SvIOK(sv)) {
-		(void)sprintf(tokenbuf,"%ld",(long)SvIVX(sv));
+	    if (SvNOKp(sv)) {
+		Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
 		goto tokensave;
 	    }
-	    if (SvNOK(sv)) {
-		Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
+	    if (SvIOKp(sv)) {
+		(void)sprintf(tokenbuf,"%ld",(long)SvIVX(sv));
 		goto tokensave;
 	    }
 	    if (dowarn)
@@ -1268,7 +1364,7 @@ STRLEN *lp;
     }
     if (!SvUPGRADE(sv, SVt_PV))
 	return 0;
-    if (SvNOK(sv)) {
+    if (SvNOKp(sv)) {
 	if (SvTYPE(sv) < SVt_PVNV)
 	    sv_upgrade(sv, SVt_PVNV);
 	SvGROW(sv, 28);
@@ -1291,7 +1387,7 @@ STRLEN *lp;
 	    s--;
 #endif
     }
-    else if (SvIOK(sv)) {
+    else if (SvIOKp(sv)) {
 	if (SvTYPE(sv) < SVt_PVIV)
 	    sv_upgrade(sv, SVt_PVIV);
 	SvGROW(sv, 11);
@@ -1302,7 +1398,7 @@ STRLEN *lp;
 	while (*s) s++;
     }
     else {
-	if (dowarn && !localizing)
+	if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
 	    warn(warn_uninit);
 	*lp = 0;
 	return "";
@@ -1410,6 +1506,13 @@ register SV *sstr;
     stype = SvTYPE(sstr);
     dtype = SvTYPE(dstr);
 
+    if (dtype == SVt_PVGV && (SvFLAGS(dstr) & SVf_FAKE)) {
+        sv_unglob(dstr);     /* so fake GLOB won't perpetuate */
+	sv_setpvn(dstr, "", 0);
+        (void)SvPOK_only(dstr);
+        dtype = SvTYPE(dstr);
+    }
+
 #ifdef OVERLOAD
     SvAMAGIC_off(dstr);
 #endif /* OVERLOAD */
@@ -1442,6 +1545,17 @@ register SV *sstr;
     case SVt_RV:
 	if (dtype < SVt_RV)
 	    sv_upgrade(dstr, SVt_RV);
+	else if (dtype == SVt_PVGV &&
+		 SvTYPE(SvRV(sstr)) == SVt_PVGV) {
+	    sstr = SvRV(sstr);
+	    if (sstr == dstr) {
+		if (curcop->cop_stash != GvSTASH(dstr))
+		    GvIMPORTED_on(dstr);
+		GvMULTI_on(dstr);
+		return;
+	    }
+	    goto glob_assign;
+	}
 	break;
     case SVt_PV:
 	if (dtype < SVt_PV)
@@ -1455,9 +1569,26 @@ register SV *sstr;
 	if (dtype < SVt_PVNV)
 	    sv_upgrade(dstr, SVt_PVNV);
 	break;
+
+    case SVt_PVLV:
+	sv_upgrade(dstr, SVt_PVNV);
+	break;
+
+    case SVt_PVAV:
+    case SVt_PVHV:
+    case SVt_PVCV:
+    case SVt_PVIO:
+	if (op)
+	    croak("Bizarre copy of %s in %s", sv_reftype(sstr, 0),
+		op_name[op->op_type]);
+	else
+	    croak("Bizarre copy of %s", sv_reftype(sstr, 0));
+	break;
+
     case SVt_PVGV:
 	if (dtype <= SVt_PVGV) {
-	    if (dtype < SVt_PVGV) {
+  glob_assign:
+	    if (dtype != SVt_PVGV) {
 		char *name = GvNAME(sstr);
 		STRLEN len = GvNAMELEN(sstr);
 		sv_upgrade(dstr, SVt_PVGV);
@@ -1468,17 +1599,13 @@ register SV *sstr;
 		SvFAKE_on(dstr);	/* can coerce to non-glob */
 	    }
 	    (void)SvOK_off(dstr);
-	    if (!GvAV(sstr))
-		gv_AVadd(sstr);
-	    if (!GvHV(sstr))
-		gv_HVadd(sstr);
-	    if (!GvIO(sstr))
-		gv_IOadd(sstr);
-	    if (GvGP(dstr))
-		gp_free(dstr);
+	    GvINTRO_off(dstr);		/* one-shot flag */
+	    gp_free(dstr);
 	    GvGP(dstr) = gp_ref(GvGP(sstr));
 	    SvTAINT(dstr);
-	    GvFLAGS(dstr) &= ~GVf_INTRO;	/* one-shot flag */
+	    if (curcop->cop_stash != GvSTASH(dstr))
+		GvIMPORTED_on(dstr);
+	    GvMULTI_on(dstr);
 	    return;
 	}
 	/* FALL THROUGH */
@@ -1497,20 +1624,20 @@ register SV *sstr;
 	    if (dtype == SVt_PVGV) {
 		SV *sref = SvREFCNT_inc(SvRV(sstr));
 		SV *dref = 0;
-		int intro = GvFLAGS(dstr) & GVf_INTRO;
+		int intro = GvINTRO(dstr);
 
 		if (intro) {
 		    GP *gp;
 		    GvGP(dstr)->gp_refcnt--;
+		    GvINTRO_off(dstr);	/* one-shot flag */
 		    Newz(602,gp, 1, GP);
 		    GvGP(dstr) = gp;
 		    GvREFCNT(dstr) = 1;
 		    GvSV(dstr) = NEWSV(72,0);
 		    GvLINE(dstr) = curcop->cop_line;
 		    GvEGV(dstr) = dstr;
-		    GvFLAGS(dstr) &= ~GVf_INTRO;	/* one-shot flag */
 		}
-		SvMULTI_on(dstr);
+		GvMULTI_on(dstr);
 		switch (SvTYPE(sref)) {
 		case SVt_PVAV:
 		    if (intro)
@@ -1518,6 +1645,8 @@ register SV *sstr;
 		    else
 			dref = (SV*)GvAV(dstr);
 		    GvAV(dstr) = (AV*)sref;
+		    if (curcop->cop_stash != GvSTASH(dstr))
+			GvIMPORTED_AV_on(dstr);
 		    break;
 		case SVt_PVHV:
 		    if (intro)
@@ -1525,14 +1654,37 @@ register SV *sstr;
 		    else
 			dref = (SV*)GvHV(dstr);
 		    GvHV(dstr) = (HV*)sref;
+		    if (curcop->cop_stash != GvSTASH(dstr))
+			GvIMPORTED_HV_on(dstr);
 		    break;
 		case SVt_PVCV:
 		    if (intro)
 			SAVESPTR(GvCV(dstr));
+		    else {
+			CV* cv = GvCV(dstr);
+			if (cv) {
+			    dref = (SV*)cv;
+			    if (dowarn && sref != dref &&
+				    !GvCVGEN((GV*)dstr) &&
+				    (CvROOT(cv) || CvXSUB(cv)) )
+				warn("Subroutine %s redefined",
+				    GvENAME((GV*)dstr));
+			    SvFAKE_on(cv);
+			}
+		    }
+		    if (GvCV(dstr) != (CV*)sref) {
+			GvCV(dstr) = (CV*)sref;
+			GvASSUMECV_on(dstr);
+		    }
+		    if (curcop->cop_stash != GvSTASH(dstr))
+			GvIMPORTED_CV_on(dstr);
+		    break;
+		case SVt_PVIO:
+		    if (intro)
+			SAVESPTR(GvIOp(dstr));
 		    else
-			dref = (SV*)GvCV(dstr);
-		    GvFLAGS(dstr) |= GVf_IMPORTED;
-		    GvCV(dstr) = (CV*)sref;
+			dref = (SV*)GvIOp(dstr);
+		    GvIOp(dstr) = (IO*)sref;
 		    break;
 		default:
 		    if (intro)
@@ -1540,6 +1692,8 @@ register SV *sstr;
 		    else
 			dref = (SV*)GvSV(dstr);
 		    GvSV(dstr) = sref;
+		    if (curcop->cop_stash != GvSTASH(dstr))
+			GvIMPORTED_SV_on(dstr);
 		    break;
 		}
 		if (dref)
@@ -1580,20 +1734,27 @@ register SV *sstr;
 	 * has to be allocated and SvPVX(sstr) has to be freed.
 	 */
 
-	if (SvTEMP(sstr)) {		/* slated for free anyway? */
+	if (SvTEMP(sstr) &&		/* slated for free anyway? */
+	    !(sflags & SVf_OOK)) 	/* and not involved in OOK hack? */
+	{
 	    if (SvPVX(dstr)) {		/* we know that dtype >= SVt_PV */
-		(void)SvOOK_off(dstr);
-		Safefree(SvPVX(dstr));
+		if (SvOOK(dstr)) {
+		    SvFLAGS(dstr) &= ~SVf_OOK;
+		    Safefree(SvPVX(dstr) - SvIVX(dstr));
+		}
+		else
+		    Safefree(SvPVX(dstr));
 	    }
+	    (void)SvPOK_only(dstr);
 	    SvPV_set(dstr, SvPVX(sstr));
 	    SvLEN_set(dstr, SvLEN(sstr));
 	    SvCUR_set(dstr, SvCUR(sstr));
-	    (void)SvPOK_only(dstr);
 	    SvTEMP_off(dstr);
+	    (void)SvOK_off(sstr);
 	    SvPV_set(sstr, Nullch);
 	    SvLEN_set(sstr, 0);
-	    SvPOK_off(sstr);			/* wipe out any weird flags */
-	    SvPVX(sstr) = 0;			/* so sstr frees uneventfully */
+	    SvCUR_set(sstr, 0);
+	    SvTEMP_off(sstr);
 	}
 	else {					/* have to copy actual string */
 	    STRLEN len = SvCUR(sstr);
@@ -1638,6 +1799,7 @@ register SV *sv;
 register char *ptr;
 register STRLEN len;
 {
+    assert(len >= 0);
     if (SvTHINKFIRST(sv)) {
 	if (SvREADONLY(sv) && curcop != &compiling)
 	    croak(no_modify);
@@ -1648,7 +1810,11 @@ register STRLEN len;
 	(void)SvOK_off(sv);
 	return;
     }
-    if (!SvUPGRADE(sv, SVt_PV))
+    if (SvTYPE(sv) >= SVt_PV) {
+	if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
+	    sv_unglob(sv);
+    }
+    else if (!sv_upgrade(sv, SVt_PV))
 	return;
     SvGROW(sv, len + 1);
     Move(ptr,SvPVX(sv),len,char);
@@ -1676,7 +1842,11 @@ register char *ptr;
 	return;
     }
     len = strlen(ptr);
-    if (!SvUPGRADE(sv, SVt_PV))
+    if (SvTYPE(sv) >= SVt_PV) {
+	if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV)
+	    sv_unglob(sv);
+    }
+    else if (!sv_upgrade(sv, SVt_PV))
 	return;
     SvGROW(sv, len + 1);
     Move(ptr,SvPVX(sv),len+1,char);
@@ -1751,10 +1921,12 @@ register char *ptr;
 register STRLEN len;
 {
     STRLEN tlen;
-    char *s;
+    char *junk;
 
-    s = SvPV_force(sv, tlen);
+    junk = SvPV_force(sv, tlen);
     SvGROW(sv, tlen + len + 1);
+    if (ptr == junk)
+	ptr = SvPVX(sv);
     Move(ptr,SvPVX(sv)+tlen,len,char);
     SvCUR(sv) += len;
     *SvEND(sv) = '\0';
@@ -1782,13 +1954,15 @@ register char *ptr;
 {
     register STRLEN len;
     STRLEN tlen;
-    char *s;
+    char *junk;
 
     if (!ptr)
 	return;
-    s = SvPV_force(sv, tlen);
+    junk = SvPV_force(sv, tlen);
     len = strlen(ptr);
     SvGROW(sv, tlen + len + 1);
+    if (ptr == junk)
+	ptr = SvPVX(sv);
     Move(ptr,SvPVX(sv)+tlen,len+1,char);
     SvCUR(sv) += len;
     (void)SvPOK_only(sv);		/* validate pointer */
@@ -1829,9 +2003,12 @@ I32 namlen;
     
     if (SvREADONLY(sv) && curcop != &compiling && !strchr("gB", how))
 	croak(no_modify);
-    if (SvMAGICAL(sv)) {
-	if (SvMAGIC(sv) && mg_find(sv, how))
+    if (SvMAGICAL(sv) || (how == 't' && SvTYPE(sv) >= SVt_PVMG)) {
+	if (SvMAGIC(sv) && (mg = mg_find(sv, how))) {
+	    if (how == 't')
+		mg->mg_len |= 1;
 	    return;
+	}
     }
     else {
 	if (!SvUPGRADE(sv, SVt_PVMG))
@@ -1841,7 +2018,7 @@ I32 namlen;
     mg->mg_moremagic = SvMAGIC(sv);
 
     SvMAGIC(sv) = mg;
-    if (obj == sv || how == '#')
+    if (!obj || obj == sv || how == '#')
 	mg->mg_obj = obj;
     else {
 	mg->mg_obj = SvREFCNT_inc(obj);
@@ -1906,6 +2083,7 @@ I32 namlen;
 	break;
     case 't':
 	mg->mg_virtual = &vtbl_taint;
+	mg->mg_len = 1;
 	break;
     case 'U':
 	mg->mg_virtual = &vtbl_uvar;
@@ -1925,7 +2103,11 @@ I32 namlen;
     case '.':
 	mg->mg_virtual = &vtbl_pos;
 	break;
-    case '~':	/* reserved for extensions but multiple extensions may clash */
+    case '~':	/* Reserved for use by extensions not perl internals.	*/
+	/* Useful for attaching extension internal data to perl vars.	*/
+	/* Note that multiple extensions may clash if magical scalars	*/
+	/* etc holding private data from one are passed to another.	*/
+	SvRMAGICAL_on(sv);
 	break;
     default:
 	croak("Don't know how to handle magic of type '%c'", how);
@@ -1942,7 +2124,7 @@ int type;
 {
     MAGIC* mg;
     MAGIC** mgp;
-    if (!SvMAGICAL(sv))
+    if (SvTYPE(sv) < SVt_PVMG || !SvMAGIC(sv))
 	return 0;
     mgp = &SvMAGIC(sv);
     for (mg = *mgp; mg; mg = *mgp) {
@@ -2111,28 +2293,32 @@ register SV *sv;
 		PUSHMARK(SP);
 		PUSHs(&ref);
 		PUTBACK;
-		perl_call_sv((SV*)destructor, G_DISCARD|G_EVAL);
+		perl_call_sv((SV*)destructor, G_DISCARD|G_EVAL|G_KEEPERR);
+		del_XRV(SvANY(&ref));
 	    }
 	    LEAVE;
 	}
+	else
+	    SvREFCNT_dec(SvSTASH(sv));
 	if (SvOBJECT(sv)) {
 	    SvOBJECT_off(sv);	/* Curse the object. */
 	    if (SvTYPE(sv) != SVt_PVIO)
 		--sv_objcount;	/* XXX Might want something more general */
 	}
     }
-    if (SvMAGICAL(sv))
+    if (SvTYPE(sv) >= SVt_PVMG && SvMAGIC(sv))
 	mg_free(sv);
     switch (SvTYPE(sv)) {
     case SVt_PVIO:
+	io_close((IO*)sv);
 	Safefree(IoTOP_NAME(sv));
 	Safefree(IoFMT_NAME(sv));
 	Safefree(IoBOTTOM_NAME(sv));
 	/* FALL THROUGH */
-    case SVt_PVFM:
     case SVt_PVBM:
 	goto freescalar;
     case SVt_PVCV:
+    case SVt_PVFM:
 	cv_undef((CV*)sv);
 	goto freescalar;
     case SVt_PVHV:
@@ -2261,7 +2447,7 @@ STRLEN
 sv_len(sv)
 register SV *sv;
 {
-    char *s;
+    char *junk;
     STRLEN len;
 
     if (!sv)
@@ -2270,7 +2456,7 @@ register SV *sv;
     if (SvGMAGICAL(sv))
 	len = mg_len(sv);
     else
-	s = SvPV(sv, len);
+	junk = SvPV(sv, len);
     return len;
 }
 
@@ -2354,13 +2540,22 @@ register SV *sv;
 register FILE *fp;
 I32 append;
 {
-    register char *bp;		/* we're going to steal some values */
-    register I32 cnt;		/*  from the stdio struct and put EVERYTHING */
-    register STDCHAR *ptr;	/*   in the innermost loop into registers */
-    register I32 newline = rschar;/* (assuming >= 6 registers) */
+    char *rsptr;
+    STRLEN rslen;
+    register STDCHAR rslast;
+    register STDCHAR *bp;
+    register I32 cnt;
     I32 i;
+
+#ifdef FAST_SV_GETS
+    /*
+     * We're going to steal some values from the stdio struct
+     * and put EVERYTHING in the innermost loop into registers.
+     */
+    register STDCHAR *ptr;
     STRLEN bpx;
     I32 shortbuffered;
+#endif
 
     if (SvTHINKFIRST(sv)) {
 	if (SvREADONLY(sv) && curcop != &compiling)
@@ -2370,7 +2565,20 @@ I32 append;
     }
     if (!SvUPGRADE(sv, SVt_PV))
 	return 0;
-    if (rspara) {		/* have to do this both before and after */
+
+    if (RsSNARF(rs)) {
+	rsptr = NULL;
+	rslen = 0;
+    }
+    else if (RsPARA(rs)) {
+	rsptr = "\n\n";
+	rslen = 2;
+    }
+    else
+	rsptr = SvPV(rs, rslen);
+    rslast = rslen ? rsptr[rslen - 1] : '\0';
+
+    if (RsPARA(rs)) {		/* have to do this both before and after */
 	do {			/* to make sure file boundaries work right */
 	    if (feof(fp))
 		return 0;
@@ -2383,8 +2591,12 @@ I32 append;
 	    }
 	} while (i != EOF);
     }
-#ifdef USE_STD_STDIO		/* Here is some breathtakingly efficient cheating */
-    cnt = fp->_cnt;			/* get count into register */
+
+#ifdef FAST_SV_GETS
+
+    /* Here is some breathtakingly efficient cheating */
+
+    cnt = FILE_cnt(fp);			/* get count into register */
     (void)SvPOK_only(sv);		/* validate pointer */
     if (SvLEN(sv) - append <= cnt + 1) { /* make sure we have the room */
 	if (cnt > 80 && SvLEN(sv) > append) {
@@ -2398,95 +2610,106 @@ I32 append;
     }
     else
 	shortbuffered = 0;
-    bp = SvPVX(sv) + append;		/* move these two too to registers */
-    ptr = fp->_ptr;
+    bp = (STDCHAR*)SvPVX(sv) + append;  /* move these two too to registers */
+    ptr = FILE_ptr(fp);
     for (;;) {
       screamer:
 	if (cnt > 0) {
-	    while (--cnt >= 0) {		 /* this */	/* eat */
-		if ((*bp++ = *ptr++) == newline) /* really */	/* dust */
-		    goto thats_all_folks;	 /* screams */	/* sed :-) */ 
+	    if (rslen) {
+		while (--cnt >= 0) {		     /* this     |  eat */
+		    if ((*bp++ = *ptr++) == rslast)  /* really   |  dust */
+			goto thats_all_folks;	     /* screams  |  sed :-) */
+		}
+	    }
+	    else {
+	        memcpy((char*)bp, (char*)ptr, cnt);  /* this     |  eat */    
+		bp += cnt;			     /* screams  |  dust */   
+		ptr += cnt;			     /* louder   |  sed :-) */
+		cnt = 0;
 	    }
 	}
 	
-	if (shortbuffered) {			/* oh well, must extend */
+	if (shortbuffered) {		/* oh well, must extend */
 	    cnt = shortbuffered;
 	    shortbuffered = 0;
-	    bpx = bp - SvPVX(sv);	/* prepare for possible relocation */
+	    bpx = bp - (STDCHAR*)SvPVX(sv); /* box up before relocation */
 	    SvCUR_set(sv, bpx);
 	    SvGROW(sv, SvLEN(sv) + append + cnt + 2);
-	    bp = SvPVX(sv) + bpx;	/* reconstitute our pointer */
+	    bp = (STDCHAR*)SvPVX(sv) + bpx; /* unbox after relocation */
 	    continue;
 	}
 
-	fp->_cnt = cnt;			/* deregisterize cnt and ptr */
-	fp->_ptr = ptr;
+	FILE_cnt(fp) = cnt;		/* deregisterize cnt and ptr */
+	FILE_ptr(fp) = ptr;
 	i = _filbuf(fp);		/* get more characters */
-	cnt = fp->_cnt;
-	ptr = fp->_ptr;			/* reregisterize cnt and ptr */
+	cnt = FILE_cnt(fp);
+	ptr = FILE_ptr(fp);		/* reregisterize cnt and ptr */
 
-	bpx = bp - SvPVX(sv);	/* prepare for possible relocation */
+	if (i == EOF)			/* all done for ever? */
+	    goto thats_really_all_folks;
+
+	bpx = bp - (STDCHAR*)SvPVX(sv);	/* box up before relocation */
 	SvCUR_set(sv, bpx);
 	SvGROW(sv, bpx + cnt + 2);
-	bp = SvPVX(sv) + bpx;	/* reconstitute our pointer */
+	bp = (STDCHAR*)SvPVX(sv) + bpx;	/* unbox after relocation */
+
+	*bp++ = i;			/* store character from _filbuf */
 
-	if (i == newline) {		/* all done for now? */
-	    *bp++ = i;
+	if (rslen && (STDCHAR)i == rslast)  /* all done for now? */
 	    goto thats_all_folks;
-	}
-	else if (i == EOF)		/* all done for ever? */
-	    goto thats_really_all_folks;
-	*bp++ = i;			/* now go back to screaming loop */
     }
 
 thats_all_folks:
-    if (rslen > 1 && (bp - SvPVX(sv) < rslen || bcmp(bp - rslen, rs, rslen)))
-	goto screamer;	/* go back to the fray */
+    if ((rslen > 1 && (bp - (STDCHAR*)SvPVX(sv) < rslen)) ||
+	  bcmp((char*)bp - rslen, rsptr, rslen))
+	goto screamer;			/* go back to the fray */
 thats_really_all_folks:
     if (shortbuffered)
 	cnt += shortbuffered;
-    fp->_cnt = cnt;			/* put these back or we're in trouble */
-    fp->_ptr = ptr;
+    FILE_cnt(fp) = cnt;			/* put these back or we're in trouble */
+    FILE_ptr(fp) = ptr;
     *bp = '\0';
-    SvCUR_set(sv, bp - SvPVX(sv));	/* set length */
+    SvCUR_set(sv, bp - (STDCHAR*)SvPVX(sv));  /* set length */
 
-#else /* !USE_STD_STDIO */	/* The big, slow, and stupid way */
+#else /* SV_FAST_GETS */
+
+    /*The big, slow, and stupid way */
 
     {
-	char buf[8192];
-	register char * bpe = buf + sizeof(buf) - 3;
+	STDCHAR buf[8192];
 
 screamer:
-	bp = buf;
-	while ((i = getc(fp)) != EOF && (*bp++ = i) != newline && bp < bpe) ;
+	if (rslen) {
+	    register STDCHAR *bpe = buf + sizeof(buf);
+	    bp = buf;
+	    while ((i = getc(fp)) != EOF && (*bp++ = i) != rslast && bp < bpe)
+		; /* keep reading */
+	    cnt = bp - buf;
+	}
+	else {
+	    cnt = fread((char*)buf, 1, sizeof(buf), fp);
+	    i = cnt ? (U8)buf[cnt - 1] : EOF;
+	}
 
 	if (append)
-	    sv_catpvn(sv, buf, bp - buf);
+	    sv_catpvn(sv, buf, cnt);
 	else
-	    sv_setpvn(sv, buf, bp - buf);
-	if (i != EOF			/* joy */
-	    &&
-	    (i != newline
-	     ||
-	     (rslen > 1
-	      &&
-	      (SvCUR(sv) < rslen
-	       ||
-	       bcmp(SvPVX(sv) + SvCUR(sv) - rslen, rs, rslen)
-	      )
-	     )
-	    )
-	   )
+	    sv_setpvn(sv, buf, cnt);
+
+	if (i != EOF &&			/* joy */
+	    (!rslen ||
+	     SvCUR(sv) < rslen ||
+	     bcmp(SvPVX(sv) + SvCUR(sv) - rslen, rsptr, rslen)))
 	{
 	    append = -1;
 	    goto screamer;
 	}
     }
 
-#endif /* USE_STD_STDIO */
+#endif /* SV_FAST_GETS */
 
-    if (rspara) {
-        while (i != EOF) {
+    if (RsPARA(rs)) {		/* have to do this both before and after */  
+        while (i != EOF) {	/* to make sure file boundaries work right */
 	    i = getc(fp);
 	    if (i != '\n') {
 		ungetc(i,fp);
@@ -2494,7 +2717,8 @@ screamer:
 	    }
 	}
     }
-    return SvCUR(sv) - append ? SvPVX(sv) : Nullch;
+
+    return (SvCUR(sv) - append) ? SvPVX(sv) : Nullch;
 }
 
 void
@@ -2520,8 +2744,8 @@ register SV *sv;
 	mg_get(sv);
     flags = SvFLAGS(sv);
     if (flags & SVp_IOK) {
-	++SvIVX(sv);
 	(void)SvIOK_only(sv);
+	++SvIVX(sv);
 	return;
     }
     if (flags & SVp_NOK) {
@@ -2530,8 +2754,8 @@ register SV *sv;
 	return;
     }
     if (!(flags & SVp_POK) || !*SvPVX(sv)) {
-	if (!SvUPGRADE(sv, SVt_NV))
-	    return;
+	if ((flags & SVTYPEMASK) < SVt_PVNV)
+	    sv_upgrade(sv, SVt_NV);
 	SvNVX(sv) = 1.0;
 	(void)SvNOK_only(sv);
 	return;
@@ -2590,8 +2814,8 @@ register SV *sv;
 	mg_get(sv);
     flags = SvFLAGS(sv);
     if (flags & SVp_IOK) {
-	--SvIVX(sv);
 	(void)SvIOK_only(sv);
+	--SvIVX(sv);
 	return;
     }
     if (flags & SVp_NOK) {
@@ -2600,8 +2824,8 @@ register SV *sv;
 	return;
     }
     if (!(flags & SVp_POK)) {
-	if (!SvUPGRADE(sv, SVt_NV))
-	    return;
+	if ((flags & SVTYPEMASK) < SVt_PVNV)
+	    sv_upgrade(sv, SVt_NV);
 	SvNVX(sv) = -1.0;
 	(void)SvNOK_only(sv);
 	return;
@@ -2876,11 +3100,17 @@ I32 lref;
 	*st = GvESTASH(gv);
     fix_gv:
 	if (lref && !GvCV(gv)) {
-	    sv = NEWSV(704,0);
-	    gv_efullname(sv, gv);
-	    newSUB(savestack_ix,
-		   newSVOP(OP_CONST, 0, sv),
+	    SV *tmpsv;
+	    ENTER;
+	    tmpsv = NEWSV(704,0);
+	    gv_efullname(tmpsv, gv);
+	    newSUB(start_subparse(),
+		   newSVOP(OP_CONST, 0, tmpsv),
+		   Nullop,
 		   Nullop);
+	    LEAVE;
+	    if (!GvCV(gv))
+		croak("Unable to create sub named \"%s\"", SvPV(sv,na));
 	}
 	return GvCV(gv);
     }
@@ -2969,14 +3199,18 @@ STRLEN *lp;
 	*lp = SvCUR(sv);
     }
     else {
-	if (SvTYPE(sv) > SVt_PVLV) {
-	    if (SvFAKE(sv))
+	if (SvTYPE(sv) > SVt_PVLV && SvTYPE(sv) != SVt_PVFM) {
+	    if (SvFAKE(sv) && SvTYPE(sv) == SVt_PVGV) {
 		sv_unglob(sv);
+		s = SvPVX(sv);
+		*lp = SvCUR(sv);
+	    }
 	    else
 		croak("Can't coerce %s to string in %s", sv_reftype(sv,0),
 		    op_name[op->op_type]);
 	}
-	s = sv_2pv(sv, lp);
+	else
+	    s = sv_2pv(sv, lp);
 	if (s != SvPVX(sv)) {	/* Almost, but not quite, sv_setpvn() */
 	    STRLEN len = *lp;
 	    
@@ -3144,6 +3378,7 @@ HV* stash;
     SvSTASH(ref) = (HV*)SvREFCNT_inc(stash);
 
 #ifdef OVERLOAD
+    SvAMAGIC_off(sv);
     if (Gv_AMG(stash)) {
       SvAMAGIC_on(sv);
     }
@@ -3162,6 +3397,7 @@ SV* sv;
 	gp_free(sv);
     sv_unmagic(sv, '*');
     Safefree(GvNAME(sv));
+    GvMULTI_off(sv);
     SvFLAGS(sv) &= ~SVTYPEMASK;
     SvFLAGS(sv) |= SVt_PVMG;
 }
@@ -3174,7 +3410,10 @@ SV* sv;
     
     SvRV(sv) = 0;
     SvROK_off(sv);
-    SvREFCNT_dec(rv);
+    if (SvREFCNT(rv) != 1 || SvREADONLY(rv))
+	SvREFCNT_dec(rv);
+    else
+	sv_2mortal(rv);		/* Schedule for freeing later */
 }
 
 #ifdef DEBUGGING
@@ -3320,10 +3559,14 @@ SV* sv;
 	fprintf(stderr, "  FILL = %ld\n", (long)AvFILL(sv));
 	fprintf(stderr, "  MAX = %ld\n", (long)AvMAX(sv));
 	fprintf(stderr, "  ARYLEN = 0x%lx\n", (long)AvARYLEN(sv));
-	if (AvREAL(sv))
-	    fprintf(stderr, "  FLAGS = (REAL)\n");
-	else
-	    fprintf(stderr, "  FLAGS = ()\n");
+	flags = AvFLAGS(sv);
+	d = tmpbuf;
+	if (flags & AVf_REAL)	strcat(d, "REAL,");
+	if (flags & AVf_REIFY)	strcat(d, "REIFY,");
+	if (flags & AVf_REUSED)	strcat(d, "REUSED,");
+	if (*d)
+	    d[strlen(d)-1] = '\0';
+	fprintf(stderr, "  FLAGS = (%s)\n", d);
 	break;
     case SVt_PVHV:
 	fprintf(stderr, "  ARRAY = 0x%lx\n",(long)HvARRAY(sv));
@@ -3347,6 +3590,7 @@ SV* sv;
 	fprintf(stderr, "  FILEGV = 0x%lx\n", (long)CvFILEGV(sv));
 	fprintf(stderr, "  DEPTH = %ld\n", (long)CvDEPTH(sv));
 	fprintf(stderr, "  PADLIST = 0x%lx\n", (long)CvPADLIST(sv));
+	fprintf(stderr, "  OUTSIDE = 0x%lx\n", (long)CvOUTSIDE(sv));
 	if (type == SVt_PVFM)
 	    fprintf(stderr, "  LINES = %ld\n", (long)FmLINES(sv));
 	break;