X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=sv.c;h=ce85a4bb89a06059ad049c836897b7744d28bbbb;hb=e09f3e01ccd721309f0eb0aae224d84db2e8436a;hp=5adbe8a4b72df30dd18b99e2f2834779235b1d8e;hpb=2e3febc6b56a2d689b1b3f47d5fcfc7adade7965;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/sv.c b/sv.c
index 5adbe8a..ce85a4b 100644
--- a/sv.c
+++ b/sv.c
@@ -1,6 +1,6 @@
 /*    sv.c
  *
- *    Copyright (c) 1991-1994, Larry Wall
+ *    Copyright (c) 1991-1997, 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.
@@ -170,7 +170,7 @@ U32 flags;
 	--sv_count;			\
     } while (0)
 
-#define uproot_SV(p)		\
+#define uproot_SV(p)			\
     do {				\
 	(p) = sv_root;			\
 	sv_root = (SV*)SvANY(p);	\
@@ -885,28 +885,30 @@ char *
 sv_peek(sv)
 register SV *sv;
 {
-    char *t = tokenbuf;
+    SV *t = sv_newmortal();
+    STRLEN prevlen;
     int unref = 0;
 
+    sv_setpvn(t, "", 0);
   retry:
     if (!sv) {
-	strcpy(t, "VOID");
+	sv_catpv(t, "VOID");
 	goto finish;
     }
     else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
-	strcpy(t, "WILD");
+	sv_catpv(t, "WILD");
 	goto finish;
     }
     else if (sv == &sv_undef || sv == &sv_no || sv == &sv_yes) {
 	if (sv == &sv_undef) {
-	    strcpy(t, "SV_UNDEF");
+	    sv_catpv(t, "SV_UNDEF");
 	    if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
 				 SVs_GMG|SVs_SMG|SVs_RMG)) &&
 		SvREADONLY(sv))
 		goto finish;
 	}
 	else if (sv == &sv_no) {
-	    strcpy(t, "SV_NO");
+	    sv_catpv(t, "SV_NO");
 	    if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
 				 SVs_GMG|SVs_SMG|SVs_RMG)) &&
 		!(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
@@ -916,7 +918,7 @@ register SV *sv;
 		goto finish;
 	}
 	else {
-	    strcpy(t, "SV_YES");
+	    sv_catpv(t, "SV_YES");
 	    if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
 				 SVs_GMG|SVs_SMG|SVs_RMG)) &&
 		!(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
@@ -926,17 +928,18 @@ register SV *sv;
 		SvNVX(sv) == 1.0)
 		goto finish;
 	}
-	t += strlen(t);
-	*t++ = ':';
+	sv_catpv(t, ":");
     }
     else if (SvREFCNT(sv) == 0) {
-	*t++ = '(';
+	sv_catpv(t, "(");
 	unref++;
     }
     if (SvROK(sv)) {
-	*t++ = '\\';
-	if (t - tokenbuf + unref > 10) {
-	    strcpy(tokenbuf + unref + 3,"...");
+	sv_catpv(t, "\\");
+	if (SvCUR(t) + unref > 10) {
+	    SvCUR(t) = unref + 3;
+	    *SvEND(t) = '\0';
+	    sv_catpv(t, "...");
 	    goto finish;
 	}
 	sv = (SV*)SvRV(sv);
@@ -944,88 +947,85 @@ register SV *sv;
     }
     switch (SvTYPE(sv)) {
     default:
-	strcpy(t,"FREED");
+	sv_catpv(t, "FREED");
 	goto finish;
 
     case SVt_NULL:
-	strcpy(t,"UNDEF");
+	sv_catpv(t, "UNDEF");
 	return tokenbuf;
     case SVt_IV:
-	strcpy(t,"IV");
+	sv_catpv(t, "IV");
 	break;
     case SVt_NV:
-	strcpy(t,"NV");
+	sv_catpv(t, "NV");
 	break;
     case SVt_RV:
-	strcpy(t,"RV");
+	sv_catpv(t, "RV");
 	break;
     case SVt_PV:
-	strcpy(t,"PV");
+	sv_catpv(t, "PV");
 	break;
     case SVt_PVIV:
-	strcpy(t,"PVIV");
+	sv_catpv(t, "PVIV");
 	break;
     case SVt_PVNV:
-	strcpy(t,"PVNV");
+	sv_catpv(t, "PVNV");
 	break;
     case SVt_PVMG:
-	strcpy(t,"PVMG");
+	sv_catpv(t, "PVMG");
 	break;
     case SVt_PVLV:
-	strcpy(t,"PVLV");
+	sv_catpv(t, "PVLV");
 	break;
     case SVt_PVAV:
-	strcpy(t,"AV");
+	sv_catpv(t, "AV");
 	break;
     case SVt_PVHV:
-	strcpy(t,"HV");
+	sv_catpv(t, "HV");
 	break;
     case SVt_PVCV:
 	if (CvGV(sv))
-	    sprintf(t, "CV(%s)", GvNAME(CvGV(sv)));
+	    sv_catpvf(t, "CV(%s)", GvNAME(CvGV(sv)));
 	else
-	    strcpy(t, "CV()");
+	    sv_catpv(t, "CV()");
 	goto finish;
     case SVt_PVGV:
-	strcpy(t,"GV");
+	sv_catpv(t, "GV");
 	break;
     case SVt_PVBM:
-	strcpy(t,"BM");
+	sv_catpv(t, "BM");
 	break;
     case SVt_PVFM:
-	strcpy(t,"FM");
+	sv_catpv(t, "FM");
 	break;
     case SVt_PVIO:
-	strcpy(t,"IO");
+	sv_catpv(t, "IO");
 	break;
     }
-    t += strlen(t);
 
     if (SvPOKp(sv)) {
 	if (!SvPVX(sv))
-	    strcpy(t, "(null)");
+	    sv_catpv(t, "(null)");
 	if (SvOOK(sv))
-	    sprintf(t,"(%ld+\"%.127s\")",(long)SvIVX(sv),SvPVX(sv));
+	    sv_catpvf(t, "(%ld+\"%.127s\")",(long)SvIVX(sv),SvPVX(sv));
 	else
-	    sprintf(t,"(\"%.127s\")",SvPVX(sv));
+	    sv_catpvf(t, "(\"%.127s\")",SvPVX(sv));
     }
     else if (SvNOKp(sv)) {
 	SET_NUMERIC_STANDARD();
-	sprintf(t,"(%g)",SvNVX(sv));
+	sv_catpvf(t, "(%g)",SvNVX(sv));
     }
     else if (SvIOKp(sv))
-	sprintf(t,"(%ld)",(long)SvIVX(sv));
+	sv_catpvf(t, "(%ld)",(long)SvIVX(sv));
     else
-	strcpy(t,"()");
+	sv_catpv(t, "()");
     
   finish:
     if (unref) {
-	t += strlen(t);
 	while (unref--)
-	    *t++ = ')';
-	*t = '\0';
+	    sv_catpv(t, ")");
     }
-    return tokenbuf;
+    return SvPV(t, na);
 }
 #endif
 
@@ -1122,7 +1122,7 @@ IV i;
     case SVt_PVFM:
     case SVt_PVIO:
 	croak("Can't coerce %s to integer in %s", sv_reftype(sv,0),
-	    op_name[op->op_type]);
+	    op_desc[op->op_type]);
     }
     (void)SvIOK_only(sv);			/* validate number */
     SvIVX(sv) = i;
@@ -1195,9 +1195,11 @@ SV *sv;
     char tmpbuf[64];
     char *d = tmpbuf;
     char *s;
-    int i;
+    char *limit = tmpbuf + sizeof(tmpbuf) - 8;
+                  /* each *s can expand to 4 chars + "...\0",
+                     i.e. need room for 8 chars */
 
-    for (s = SvPVX(sv), i = 50; *s && i; s++,i--) {
+    for (s = SvPVX(sv); *s && d < limit; s++) {
 	int ch = *s & 0xFF;
 	if (ch & 128 && !isPRINT_LC(ch)) {
 	    *d++ = 'M';
@@ -1259,8 +1261,11 @@ register SV *sv;
 	}
 	if (SvPOKp(sv) && SvLEN(sv))
 	    return asIV(sv);
-	if (!SvROK(sv))
+	if (!SvROK(sv)) {
+	    if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
+		warn(warn_uninit);
 	    return 0;
+	}
     }
     if (SvTHINKFIRST(sv)) {
 	if (SvROK(sv)) {
@@ -1331,8 +1336,11 @@ register SV *sv;
 	    return U_V(SvNVX(sv));
 	if (SvPOKp(sv) && SvLEN(sv))
 	    return asUV(sv);
-	if (!SvROK(sv))
+	if (!SvROK(sv)) {
+	    if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
+		warn(warn_uninit);
 	    return 0;
+	}
     }
     if (SvTHINKFIRST(sv)) {
 	if (SvROK(sv)) {
@@ -1402,6 +1410,8 @@ register SV *sv;
 	if (SvIOKp(sv))
 	    return (double)SvIVX(sv);
         if (!SvROK(sv)) {
+	    if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
+		warn(warn_uninit);
             return 0;
         }
     }
@@ -1502,7 +1512,7 @@ SV *sv;
     register char *s;
     register char *send;
     register char *sbegin;
-    I32 numtype = 1;
+    I32 numtype;
     STRLEN len;
 
     if (SvPOK(sv)) {
@@ -1518,31 +1528,53 @@ SV *sv;
     s = sbegin;
     while (isSPACE(*s))
 	s++;
-    if (s >= send)
-	return 0;
     if (*s == '+' || *s == '-')
 	s++;
-    while (isDIGIT(*s))
-	s++;
-    if (s == send)
-	return numtype;
-    if (*s == '.') {
-	numtype = 1;
-	s++;
+
+    /* next must be digit or '.' */
+    if (isDIGIT(*s)) {
+        do {
+	    s++;
+        } while (isDIGIT(*s));
+        if (*s == '.') {
+	    s++;
+            while (isDIGIT(*s))  /* optional digits after "." */
+                s++;
+        }
     }
-    else if (s == SvPVX(sv))
-	return 0;
-    while (isDIGIT(*s))
-	s++;
-    if (s == send)
-	return numtype;
+    else if (*s == '.') {
+        s++;
+        /* no digits before '.' means we need digits after it */
+        if (isDIGIT(*s)) {
+	    do {
+	        s++;
+            } while (isDIGIT(*s));
+        }
+        else
+	    return 0;
+    }
+    else
+        return 0;
+
+    /*
+     * we return 1 if the number can be converted to _integer_ with atol()
+     * and 2 if you need (int)atof().
+     */
+    numtype = 1;
+
+    /* we can have an optional exponent part */
     if (*s == 'e' || *s == 'E') {
 	numtype = 2;
 	s++;
 	if (*s == '+' || *s == '-')
 	    s++;
-	while (isDIGIT(*s))
-	    s++;
+        if (isDIGIT(*s)) {
+            do {
+                s++;
+            } while (isDIGIT(*s));
+        }
+        else
+            return 0;
     }
     while (isSPACE(*s))
 	s++;
@@ -1560,6 +1592,7 @@ STRLEN *lp;
 {
     register char *s;
     int olderrno;
+    SV *tsv;
 
     if (!sv) {
 	*lp = 0;
@@ -1573,14 +1606,18 @@ STRLEN *lp;
 	}
 	if (SvIOKp(sv)) {
 	    (void)sprintf(tokenbuf,"%ld",(long)SvIVX(sv));
+	    tsv = Nullsv;
 	    goto tokensave;
 	}
 	if (SvNOKp(sv)) {
 	    SET_NUMERIC_STANDARD();
 	    Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
+	    tsv = Nullsv;
 	    goto tokensave;
 	}
         if (!SvROK(sv)) {
+	    if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
+		warn(warn_uninit);
             *lp = 0;
             return "";
         }
@@ -1615,11 +1652,12 @@ STRLEN *lp;
 		case SVt_PVIO:	s = "IO";			break;
 		default:	s = "UNKNOWN";			break;
 		}
+		tsv = NEWSV(0,0);
 		if (SvOBJECT(sv))
-		    sprintf(tokenbuf, "%s=%s(0x%lx)",
-				HvNAME(SvSTASH(sv)), s, (unsigned long)sv);
+		    sv_setpvf(tsv, "%s=%s", HvNAME(SvSTASH(sv)), s);
 		else
-		    sprintf(tokenbuf, "%s(0x%lx)", s, (unsigned long)sv);
+		    sv_setpv(tsv, s);
+		sv_catpvf(tsv, "(0x%lx)", (unsigned long)sv);
 		goto tokensaveref;
 	    }
 	    *lp = strlen(s);
@@ -1629,10 +1667,12 @@ STRLEN *lp;
 	    if (SvNOKp(sv)) {
 		SET_NUMERIC_STANDARD();
 		Gconvert(SvNVX(sv), DBL_DIG, 0, tokenbuf);
+		tsv = Nullsv;
 		goto tokensave;
 	    }
 	    if (SvIOKp(sv)) {
 		(void)sprintf(tokenbuf,"%ld",(long)SvIVX(sv));
+		tsv = Nullsv;
 		goto tokensave;
 	    }
 	    if (dowarn)
@@ -1666,18 +1706,21 @@ STRLEN *lp;
 	while (*s) s++;
 #ifdef hcx
 	if (s[-1] == '.')
-	    s--;
+	    *--s = '\0';
 #endif
     }
     else if (SvIOKp(sv)) {
+	U32 oldIOK = SvIOK(sv);
 	if (SvTYPE(sv) < SVt_PVIV)
 	    sv_upgrade(sv, SVt_PVIV);
-	SvGROW(sv, 11);
-	s = SvPVX(sv);
 	olderrno = errno;	/* some Xenix systems wipe out errno here */
-	(void)sprintf(s,"%ld",(long)SvIVX(sv));
+	sv_setpvf(sv, "%Vd", SvIVX(sv));
 	errno = olderrno;
-	while (*s) s++;
+	s = SvEND(sv);
+	if (oldIOK)
+	    SvIOK_on(sv);
+	else
+	    SvIOKp_on(sv);
     }
     else {
 	if (dowarn && !localizing && !(SvFLAGS(sv) & SVs_PADTMP))
@@ -1685,7 +1728,6 @@ STRLEN *lp;
 	*lp = 0;
 	return "";
     }
-    *s = '\0';
     *lp = s - SvPVX(sv);
     SvCUR_set(sv, *lp);
     SvPOK_on(sv);
@@ -1697,23 +1739,36 @@ STRLEN *lp;
 	/* Sneaky stuff here */
 
       tokensaveref:
-	sv = sv_newmortal();
-	*lp = strlen(tokenbuf);
-	sv_setpvn(sv, tokenbuf, *lp);
-	return SvPVX(sv);
+	if (!tsv)
+	    tsv = newSVpv(tokenbuf, 0);
+	sv_2mortal(tsv);
+	*lp = SvCUR(tsv);
+	return SvPVX(tsv);
     }
     else {
 	STRLEN len;
-	
+	char *t;
+
+	if (tsv) {
+	    sv_2mortal(tsv);
+	    t = SvPVX(tsv);
+	    len = SvCUR(tsv);
+	}
+	else {
+	    t = tokenbuf;
+	    len = strlen(tokenbuf);
+	}
 #ifdef FIXNEGATIVEZERO
-	if (*tokenbuf == '-' && tokenbuf[1] == '0' && !tokenbuf[2])
-	    strcpy(tokenbuf,"0");
+	if (len == 2 && t[0] == '-' && t[1] == '0') {
+	    t = "0";
+	    len = 1;
+	}
 #endif
 	(void)SvUPGRADE(sv, SVt_PV);
-	len = *lp = strlen(tokenbuf);
+	*lp = len;
 	s = SvGROW(sv, len + 1);
 	SvCUR_set(sv, len);
-	(void)strcpy(s, tokenbuf);
+	(void)strcpy(s, t);
 	SvPOKp_on(sv);
 	return s;
     }
@@ -1838,6 +1893,7 @@ register SV *sstr;
 	}
 	break;
     case SVt_PV:
+    case SVt_PVFM:
 	if (dtype < SVt_PV)
 	    sv_upgrade(dstr, SVt_PV);
 	break;
@@ -1878,6 +1934,11 @@ register SV *sstr;
 		GvNAMELEN(dstr) = len;
 		SvFAKE_on(dstr);	/* can coerce to non-glob */
 	    }
+	    /* ahem, death to those who redefine active sort subs */
+	    else if (curstack == sortstack
+		     && GvCV(dstr) && sortcop == CvSTART(GvCV(dstr)))
+		croak("Can't redefine active sort subroutine %s",
+		      GvNAME(dstr));
 	    (void)SvOK_off(dstr);
 	    GvINTRO_off(dstr);		/* one-shot flag */
 	    gp_free((GV*)dstr);
@@ -1891,10 +1952,16 @@ register SV *sstr;
 	/* FALL THROUGH */
 
     default:
+	if (SvGMAGICAL(sstr)) {
+	    mg_get(sstr);
+	    if (SvTYPE(sstr) != stype) {
+		stype = SvTYPE(sstr);
+		if (stype == SVt_PVGV && dtype <= SVt_PVGV)
+		    goto glob_assign;
+	    }
+	}
 	if (dtype < stype)
 	    sv_upgrade(dstr, stype);
-	if (SvGMAGICAL(sstr))
-	    mg_get(sstr);
     }
 
     sflags = SvFLAGS(sstr);
@@ -1941,22 +2008,36 @@ register SV *sstr;
 			if (GvCVGEN(dstr) && GvCV(dstr) != (CV*)sref) {
 			    SvREFCNT_dec(GvCV(dstr));
 			    GvCV(dstr) = Nullcv;
-			    GvCVGEN(dstr) = 0;
+			    GvCVGEN(dstr) = 0; /* Switch off cacheness. */
+			    sub_generation++;
 			}
 			SAVESPTR(GvCV(dstr));
 		    }
-		    else {
+		    else
+			dref = (SV*)GvCV(dstr);
+		    if (GvCV(dstr) != (CV*)sref) {
 			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));
+			    if (!GvCVGEN((GV*)dstr) &&
+				(CvROOT(cv) || CvXSUB(cv)))
+			    {
+				/* ahem, death to those who redefine
+				 * active sort subs */
+				if (curstack == sortstack &&
+				      sortcop == CvSTART(cv))
+				    croak(
+				    "Can't redefine active sort subroutine %s",
+					  GvENAME((GV*)dstr));
+				if (cv_const_sv(cv))
+				    warn("Constant subroutine %s redefined",
+					 GvENAME((GV*)dstr));
+				else if (dowarn)
+				    warn("Subroutine %s redefined",
+					 GvENAME((GV*)dstr));
+			    }
+			    cv_ckproto(cv, (GV*)dstr,
+				       SvPOK(sref) ? SvPVX(sref) : Nullch);
 			}
-		    }
-		    if (GvCV(dstr) != (CV*)sref) {
 			GvCV(dstr) = (CV*)sref;
 			GvCVGEN(dstr) = 0; /* Switch off cacheness. */
 			GvASSUMECV_on(dstr);
@@ -2400,7 +2481,7 @@ I32 namlen;
 	mg->mg_virtual = &vtbl_substr;
 	break;
     case 'y':
-	mg->mg_virtual = &vtbl_itervar;
+	mg->mg_virtual = &vtbl_defelem;
 	break;
     case '*':
 	mg->mg_virtual = &vtbl_glob;
@@ -2600,6 +2681,9 @@ register SV *sv;
 		sv_upgrade(&ref, SVt_RV);
 		SvRV(&ref) = SvREFCNT_inc(sv);
 		SvROK_on(&ref);
+		SvREFCNT(&ref) = 1;	/* Fake, but otherwise
+					   creating+destructing a ref
+					   leads to disaster. */
 
 		EXTEND(SP, 2);
 		PUSHMARK(SP);
@@ -2927,6 +3011,11 @@ sv_collxfrm(sv, nxp)
 	    Safefree(mg->mg_ptr);
 	s = SvPV(sv, len);
 	if ((xf = mem_collxfrm(s, len, &xlen))) {
+	    if (SvREADONLY(sv)) {
+		SAVEFREEPV(xf);
+		*nxp = xlen;
+		return xf;
+	    }
 	    if (! mg) {
 		sv_magic(sv, 0, 'o', 0, 0);
 		mg = mg_find(sv, 'o');
@@ -2936,8 +3025,10 @@ sv_collxfrm(sv, nxp)
 	    mg->mg_len = xlen;
 	}
 	else {
-	    mg->mg_ptr = NULL;
-	    mg->mg_len = -1;
+	    if (mg) {
+		mg->mg_ptr = NULL;
+		mg->mg_len = -1;
+	    }
 	}
     }
     if (mg && mg->mg_ptr) {
@@ -3049,11 +3140,11 @@ I32 append;
     bp = (STDCHAR*)SvPVX(sv) + append;  /* move these two too to registers */
     ptr = (STDCHAR*)PerlIO_get_ptr(fp);
     DEBUG_P(PerlIO_printf(Perl_debug_log,
-	"Screamer: entering, ptr=%d, cnt=%d\n",ptr,cnt));
+	"Screamer: entering, ptr=%ld, cnt=%ld\n",(long)ptr,(long)cnt));
     DEBUG_P(PerlIO_printf(Perl_debug_log,
-	"Screamer: entering: FILE * thinks ptr=%d, cnt=%d, base=%d\n",
-	       PerlIO_get_ptr(fp), PerlIO_get_cnt(fp), 
-	       PerlIO_has_base(fp) ? PerlIO_get_base(fp) : 0));
+	"Screamer: entering: FILE * thinks ptr=%ld, cnt=%ld, base=%ld\n",
+	       (long)PerlIO_get_ptr(fp), (long)PerlIO_get_cnt(fp), 
+	       (long)(PerlIO_has_base(fp) ? PerlIO_get_base(fp) : 0)));
     for (;;) {
       screamer:
 	if (cnt > 0) {
@@ -3083,24 +3174,24 @@ I32 append;
 	}
 
 	DEBUG_P(PerlIO_printf(Perl_debug_log,
-	    "Screamer: going to getc, ptr=%d, cnt=%d\n",ptr,cnt));
+	    "Screamer: going to getc, ptr=%ld, cnt=%ld\n",(long)ptr,(long)cnt));
 	PerlIO_set_ptrcnt(fp, ptr, cnt); /* deregisterize cnt and ptr */
 	DEBUG_P(PerlIO_printf(Perl_debug_log,
-	    "Screamer: pre: FILE * thinks ptr=%d, cnt=%d, base=%d\n",
-	    PerlIO_get_ptr(fp), PerlIO_get_cnt(fp), 
-	    PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0));
+	    "Screamer: pre: FILE * thinks ptr=%ld, cnt=%ld, base=%ld\n",
+	    (long)PerlIO_get_ptr(fp), (long)PerlIO_get_cnt(fp), 
+	    (long)(PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0)));
 	/* This used to call 'filbuf' in stdio form, but as that behaves like 
 	   getc when cnt <= 0 we use PerlIO_getc here to avoid introducing
 	   another abstraction.  */
 	i   = PerlIO_getc(fp);		/* get more characters */
 	DEBUG_P(PerlIO_printf(Perl_debug_log,
-	    "Screamer: post: FILE * thinks ptr=%d, cnt=%d, base=%d\n",
-	    PerlIO_get_ptr(fp), PerlIO_get_cnt(fp), 
-	    PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0));
+	    "Screamer: post: FILE * thinks ptr=%ld, cnt=%ld, base=%ld\n",
+	    (long)PerlIO_get_ptr(fp), (long)PerlIO_get_cnt(fp), 
+	    (long)(PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0)));
 	cnt = PerlIO_get_cnt(fp);
 	ptr = (STDCHAR*)PerlIO_get_ptr(fp);	/* reregisterize cnt and ptr */
 	DEBUG_P(PerlIO_printf(Perl_debug_log,
-	    "Screamer: after getc, ptr=%d, cnt=%d\n",ptr,cnt));
+	    "Screamer: after getc, ptr=%ld, cnt=%ld\n",(long)ptr,(long)cnt));
 
 	if (i == EOF)			/* all done for ever? */
 	    goto thats_really_all_folks;
@@ -3124,17 +3215,17 @@ thats_really_all_folks:
     if (shortbuffered)
 	cnt += shortbuffered;
 	DEBUG_P(PerlIO_printf(Perl_debug_log,
-	    "Screamer: quitting, ptr=%d, cnt=%d\n",ptr,cnt));
+	    "Screamer: quitting, ptr=%ld, cnt=%ld\n",(long)ptr,(long)cnt));
     PerlIO_set_ptrcnt(fp, ptr, cnt);	/* put these back or we're in trouble */
     DEBUG_P(PerlIO_printf(Perl_debug_log,
-	"Screamer: end: FILE * thinks ptr=%d, cnt=%d, base=%d\n",
-	PerlIO_get_ptr(fp), PerlIO_get_cnt(fp), 
-	PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0));
+	"Screamer: end: FILE * thinks ptr=%ld, cnt=%ld, base=%ld\n",
+	(long)PerlIO_get_ptr(fp), (long)PerlIO_get_cnt(fp), 
+	(long)(PerlIO_has_base (fp) ? PerlIO_get_base(fp) : 0)));
     *bp = '\0';
     SvCUR_set(sv, bp - (STDCHAR*)SvPVX(sv));	/* set length */
     DEBUG_P(PerlIO_printf(Perl_debug_log,
 	"Screamer: done, len=%d, string=|%.*s|\n",
-	SvCUR(sv),SvCUR(sv),SvPVX(sv)));
+	SvCUR(sv),(int)SvCUR(sv),SvPVX(sv)));
     }
    else
     {
@@ -3168,7 +3259,19 @@ screamer2:
 	     memNE(SvPVX(sv) + SvCUR(sv) - rslen, rsptr, rslen)))
 	{
 	    append = -1;
-	    goto screamer2;
+	    /*
+	     * If we're reading from a TTY and we get a short read,
+	     * indicating that the user hit his EOF character, we need
+	     * to notice it now, because if we try to read from the TTY
+	     * again, the EOF condition will disappear.
+	     *
+	     * The comparison of cnt to sizeof(buf) is an optimization
+	     * that prevents unnecessary calls to feof().
+	     *
+	     * - jik 9/25/96
+	     */
+	    if (!(cnt < sizeof(buf) && PerlIO_eof(fp)))
+		goto screamer2;
 	}
     }
 
@@ -3387,6 +3490,35 @@ STRLEN len;
     return sv;
 }
 
+#ifdef I_STDARG
+SV *
+newSVpvf(const char* pat, ...)
+#else
+/*VARARGS0*/
+SV *
+newSVpvf(pat, va_alist)
+const char *pat;
+va_dcl
+#endif
+{
+    register SV *sv;
+    va_list args;
+
+    new_SV(sv);
+    SvANY(sv) = 0;
+    SvREFCNT(sv) = 1;
+    SvFLAGS(sv) = 0;
+#ifdef I_STDARG
+    va_start(args, pat);
+#else
+    va_start(args);
+#endif
+    sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+    va_end(args);
+    return sv;
+}
+
+
 SV *
 newSVnv(n)
 double n;
@@ -3538,6 +3670,40 @@ HV *stash;
     }
 }
 
+IO*
+sv_2io(sv)
+SV *sv;
+{
+    IO* io;
+    GV* gv;
+
+    switch (SvTYPE(sv)) {
+    case SVt_PVIO:
+	io = (IO*)sv;
+	break;
+    case SVt_PVGV:
+	gv = (GV*)sv;
+	io = GvIO(gv);
+	if (!io)
+	    croak("Bad filehandle: %s", GvNAME(gv));
+	break;
+    default:
+	if (!SvOK(sv))
+	    croak(no_usym, "filehandle");
+	if (SvROK(sv))
+	    return sv_2io(SvRV(sv));
+	gv = gv_fetchpv(SvPV(sv,na), FALSE, SVt_PVIO);
+	if (gv)
+	    io = GvIO(gv);
+	else
+	    io = 0;
+	if (!io)
+	    croak("Bad filehandle: %s", SvPV(sv,na));
+	break;
+    }
+    return io;
+}
+
 CV *
 sv_2cv(sv, st, gvp, lref)
 SV *sv;
@@ -3765,6 +3931,10 @@ int
 sv_isobject(sv)
 SV *sv;
 {
+    if (!sv)
+	return 0;
+    if (SvGMAGICAL(sv))
+	mg_get(sv);
     if (!SvROK(sv))
 	return 0;
     sv = (SV*)SvRV(sv);
@@ -3778,6 +3948,10 @@ sv_isa(sv, name)
 SV *sv;
 char *name;
 {
+    if (!sv)
+	return 0;
+    if (SvGMAGICAL(sv))
+	mg_get(sv);
     if (!SvROK(sv))
 	return 0;
     sv = (SV*)SvRV(sv);
@@ -3916,40 +4090,6 @@ SV* sv;
 	sv_2mortal(rv);		/* Schedule for freeing later */
 }
 
-IO*
-sv_2io(sv)
-SV *sv;
-{
-    IO* io;
-    GV* gv;
-
-    switch (SvTYPE(sv)) {
-    case SVt_PVIO:
-	io = (IO*)sv;
-	break;
-    case SVt_PVGV:
-	gv = (GV*)sv;
-	io = GvIO(gv);
-	if (!io)
-	    croak("Bad filehandle: %s", GvNAME(gv));
-	break;
-    default:
-	if (!SvOK(sv))
-	    croak(no_usym, "filehandle");
-	if (SvROK(sv))
-	    return sv_2io(SvRV(sv));
-	gv = gv_fetchpv(SvPV(sv,na), FALSE, SVt_PVIO);
-	if (gv)
-	    io = GvIO(gv);
-	else
-	    io = 0;
-	if (!io)
-	    croak("Bad filehandle: %s", SvPV(sv,na));
-	break;
-    }
-    return io;
-}
-
 void
 sv_taint(sv)
 SV *sv;
@@ -3980,13 +4120,554 @@ SV *sv;
     return FALSE;
 }
 
+#ifdef I_STDARG
+void
+sv_setpvf(SV *sv, const char* pat, ...)
+#else
+/*VARARGS0*/
+void
+sv_setpvf(sv, pat, va_alist)
+    SV *sv;
+    const char *pat;
+    va_dcl
+#endif
+{
+    va_list args;
+#ifdef I_STDARG
+    va_start(args, pat);
+#else
+    va_start(args);
+#endif
+    sv_vsetpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+    va_end(args);
+}
+
+#ifdef I_STDARG
+void
+sv_catpvf(SV *sv, const char* pat, ...)
+#else
+/*VARARGS0*/
+void
+sv_catpvf(sv, pat, va_alist)
+    SV *sv;
+    const char *pat;
+    va_dcl
+#endif
+{
+    va_list args;
+#ifdef I_STDARG
+    va_start(args, pat);
+#else
+    va_start(args);
+#endif
+    sv_vcatpvfn(sv, pat, strlen(pat), &args, Null(SV**), 0, Null(bool*));
+    va_end(args);
+}
+
+void
+sv_vsetpvfn(sv, pat, patlen, args, svargs, svmax, used_locale)
+    SV *sv;
+    const char *pat;
+    STRLEN patlen;
+    va_list *args;
+    SV **svargs;
+    I32 svmax;
+    bool *used_locale;
+{
+    sv_setpvn(sv, "", 0);
+    sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, used_locale);
+}
+
+void
+sv_vcatpvfn(sv, pat, patlen, args, svargs, svmax, used_locale)
+    SV *sv;
+    const char *pat;
+    STRLEN patlen;
+    va_list *args;
+    SV **svargs;
+    I32 svmax;
+    bool *used_locale;
+{
+    char *p;
+    char *q;
+    char *patend;
+    STRLEN origlen;
+    I32 svix = 0;
+    static char nullstr[] = "(null)";
+
+    /* no matter what, this is a string now */
+    (void)SvPV_force(sv, origlen);
+
+    /* special-case "", "%s", and "%_" */
+    if (patlen == 0)
+	return;
+    if (patlen == 2 && pat[0] == '%') {
+	switch (pat[1]) {
+	case 's':
+	    if (args) {
+		char *s = va_arg(*args, char*);
+		sv_catpv(sv, s ? s : nullstr);
+	    }
+	    else if (svix < svmax)
+		sv_catsv(sv, *svargs);
+	    return;
+	case '_':
+	    if (args) {
+		sv_catsv(sv, va_arg(*args, SV*));
+		return;
+	    }
+	    /* See comment on '_' below */
+	    break;
+	}
+    }
+
+    patend = (char*)pat + patlen;
+    for (p = (char*)pat; p < patend; p = q) {
+	bool alt = FALSE;
+	bool left = FALSE;
+	char fill = ' ';
+	char plus = 0;
+	char intsize = 0;
+	STRLEN width = 0;
+	STRLEN zeros = 0;
+	bool has_precis = FALSE;
+	STRLEN precis = 0;
+
+	char esignbuf[4];
+	STRLEN esignlen = 0;
+
+	char *eptr = Nullch;
+	STRLEN elen = 0;
+	char ebuf[TYPE_DIGITS(int) * 2 + 16]; /* large enough for "%#.#f" */
+
+	static char *efloatbuf = Nullch;
+	static STRLEN efloatsize = 0;
+
+	char c;
+	int i;
+	unsigned base;
+	IV iv;
+	UV uv;
+	double nv;
+	STRLEN have;
+	STRLEN need;
+	STRLEN gap;
+
+	for (q = p; q < patend && *q != '%'; ++q) ;
+	if (q > p) {
+	    sv_catpvn(sv, p, q - p);
+	    p = q;
+	}
+	if (q++ >= patend)
+	    break;
+
+	/* FLAGS */
+
+	while (*q) {
+	    switch (*q) {
+	    case ' ':
+	    case '+':
+		plus = *q++;
+		continue;
+
+	    case '-':
+		left = TRUE;
+		q++;
+		continue;
+
+	    case '0':
+		fill = *q++;
+		continue;
+
+	    case '#':
+		alt = TRUE;
+		q++;
+		continue;
+
+	    default:
+		break;
+	    }
+	    break;
+	}
+
+	/* WIDTH */
+
+	switch (*q) {
+	case '1': case '2': case '3':
+	case '4': case '5': case '6':
+	case '7': case '8': case '9':
+	    width = 0;
+	    while (isDIGIT(*q))
+		width = width * 10 + (*q++ - '0');
+	    break;
+
+	case '*':
+	    if (args)
+		i = va_arg(*args, int);
+	    else
+		i = (svix < svmax) ? SvIVx(svargs[svix++]) : 0;
+	    left |= (i < 0);
+	    width = (i < 0) ? -i : i;
+	    q++;
+	    break;
+	}
+
+	/* PRECISION */
+
+	if (*q == '.') {
+	    q++;
+	    if (*q == '*') {
+		if (args)
+		    i = va_arg(*args, int);
+		else
+		    i = (svix < svmax) ? SvIVx(svargs[svix++]) : 0;
+		precis = (i < 0) ? 0 : i;
+		q++;
+	    }
+	    else {
+		precis = 0;
+		while (isDIGIT(*q))
+		    precis = precis * 10 + (*q++ - '0');
+	    }
+	    has_precis = TRUE;
+	}
+
+	/* SIZE */
+
+	switch (*q) {
+	case 'l':
+#if 0  /* when quads have better support within Perl */
+	    if (*(q + 1) == 'l') {
+		intsize = 'q';
+		q += 2;
+		break;
+	    }
+#endif
+	    /* FALL THROUGH */
+	case 'h':
+	case 'V':
+	    intsize = *q++;
+	    break;
+	}
+
+	/* CONVERSION */
+
+	switch (c = *q++) {
+
+	    /* STRINGS */
+
+	case '%':
+	    eptr = q - 1;
+	    elen = 1;
+	    goto string;
+
+	case 'c':
+	    if (args)
+		c = va_arg(*args, int);
+	    else
+		c = (svix < svmax) ? SvIVx(svargs[svix++]) : 0;
+	    eptr = &c;
+	    elen = 1;
+	    goto string;
+
+	case 's':
+	    if (args) {
+		eptr = va_arg(*args, char*);
+		if (eptr)
+		    elen = strlen(eptr);
+		else {
+		    eptr = nullstr;
+		    elen = sizeof nullstr - 1;
+		}
+	    }
+	    else if (svix < svmax)
+		eptr = SvPVx(svargs[svix++], elen);
+	    goto string;
+
+	case '_':
+	    /*
+	     * The "%_" hack might have to be changed someday,
+	     * if ISO or ANSI decide to use '_' for something.
+	     * So we keep it hidden from users' code.
+	     */
+	    if (!args)
+		goto unknown;
+	    eptr = SvPVx(va_arg(*args, SV*), elen);
+
+	string:
+	    if (has_precis && elen > precis)
+		elen = precis;
+	    break;
+
+	    /* INTEGERS */
+
+	case 'p':
+	    if (args)
+		uv = (UV)va_arg(*args, void*);
+	    else
+		uv = (svix < svmax) ? (UV)svargs[svix++] : 0;
+	    base = 16;
+	    goto integer;
+
+	case 'D':
+	    intsize = 'l';
+	    /* FALL THROUGH */
+	case 'd':
+	case 'i':
+	    if (args) {
+		switch (intsize) {
+		case 'h':	iv = (short)va_arg(*args, int); break;
+		default:	iv = va_arg(*args, int); break;
+		case 'l':	iv = va_arg(*args, long); break;
+		case 'V':	iv = va_arg(*args, IV); break;
+		}
+	    }
+	    else {
+		iv = (svix < svmax) ? SvIVx(svargs[svix++]) : 0;
+		switch (intsize) {
+		case 'h':	iv = (short)iv; break;
+		default:	iv = (int)iv; break;
+		case 'l':	iv = (long)iv; break;
+		case 'V':	break;
+		}
+	    }
+	    if (iv >= 0) {
+		uv = iv;
+		if (plus)
+		    esignbuf[esignlen++] = plus;
+	    }
+	    else {
+		uv = -iv;
+		esignbuf[esignlen++] = '-';
+	    }
+	    base = 10;
+	    goto integer;
+
+	case 'U':
+	    intsize = 'l';
+	    /* FALL THROUGH */
+	case 'u':
+	    base = 10;
+	    goto uns_integer;
+
+	case 'O':
+	    intsize = 'l';
+	    /* FALL THROUGH */
+	case 'o':
+	    base = 8;
+	    goto uns_integer;
+
+	case 'X':
+	case 'x':
+	    base = 16;
+
+	uns_integer:
+	    if (args) {
+		switch (intsize) {
+		case 'h':  uv = (unsigned short)va_arg(*args, unsigned); break;
+		default:   uv = va_arg(*args, unsigned); break;
+		case 'l':  uv = va_arg(*args, unsigned long); break;
+		case 'V':  uv = va_arg(*args, UV); break;
+		}
+	    }
+	    else {
+		uv = (svix < svmax) ? SvUVx(svargs[svix++]) : 0;
+		switch (intsize) {
+		case 'h':	uv = (unsigned short)uv; break;
+		default:	uv = (unsigned)uv; break;
+		case 'l':	uv = (unsigned long)uv; break;
+		case 'V':	break;
+		}
+	    }
+
+	integer:
+	    eptr = ebuf + sizeof ebuf;
+	    switch (base) {
+		unsigned dig;
+	    case 16:
+		p = (c == 'X') ? "0123456789ABCDEF" : "0123456789abcdef";
+		do {
+		    dig = uv & 15;
+		    *--eptr = p[dig];
+		} while (uv >>= 4);
+		if (alt) {
+		    esignbuf[esignlen++] = '0';
+		    esignbuf[esignlen++] = c;  /* 'x' or 'X' */
+		}
+		break;
+	    case 8:
+		do {
+		    dig = uv & 7;
+		    *--eptr = '0' + dig;
+		} while (uv >>= 3);
+		if (alt && *eptr != '0')
+		    *--eptr = '0';
+		break;
+	    default:		/* it had better be ten or less */
+		do {
+		    dig = uv % base;
+		    *--eptr = '0' + dig;
+		} while (uv /= base);
+		break;
+	    }
+	    elen = (ebuf + sizeof ebuf) - eptr;
+	    if (has_precis && precis > elen)
+		zeros = precis - elen;
+	    break;
+
+	    /* FLOATING POINT */
+
+	case 'F':
+	    c = 'f';		/* maybe %F isn't supported here */
+	    /* FALL THROUGH */
+	case 'e': case 'E':
+	case 'f':
+	case 'g': case 'G':
+
+	    /* This is evil, but floating point is even more evil */
+
+	    if (args)
+		nv = va_arg(*args, double);
+	    else
+		nv = (svix < svmax) ? SvNVx(svargs[svix++]) : 0.0;
+
+	    need = 0;
+	    if (c != 'e' && c != 'E') {
+		i = PERL_INT_MIN;
+		(void)frexp(nv, &i);
+		if (i == PERL_INT_MIN)
+		    die("panic: frexp");
+		if (i > 0)
+		    need = BIT_DIGITS(i);
+	    }
+	    need += has_precis ? precis : 6; /* known default */
+	    if (need < width)
+		need = width;
+
+	    need += 20; /* fudge factor */
+	    if (efloatsize < need) {
+		Safefree(efloatbuf);
+		efloatsize = need + 20; /* more fudge */
+		New(906, efloatbuf, efloatsize, char);
+	    }
+
+	    eptr = ebuf + sizeof ebuf;
+	    *--eptr = '\0';
+	    *--eptr = c;
+	    if (has_precis) {
+		base = precis;
+		do { *--eptr = '0' + (base % 10); } while (base /= 10);
+		*--eptr = '.';
+	    }
+	    if (width) {
+		base = width;
+		do { *--eptr = '0' + (base % 10); } while (base /= 10);
+	    }
+	    if (fill == '0')
+		*--eptr = fill;
+	    if (plus)
+		*--eptr = plus;
+	    if (alt)
+		*--eptr = '#';
+	    *--eptr = '%';
+
+	    (void)sprintf(efloatbuf, eptr, nv);
+
+	    eptr = efloatbuf;
+	    elen = strlen(efloatbuf);
+
+#ifdef LC_NUMERIC
+	    /*
+	     * User-defined locales may include arbitrary characters.
+	     * And, unfortunately, some system may alloc the "C" locale
+	     * to be overridden by a malicious user.
+	     */
+	    if (used_locale)
+		*used_locale = TRUE;
+#endif /* LC_NUMERIC */
+
+	    break;
+
+	    /* SPECIAL */
+
+	case 'n':
+	    i = SvCUR(sv) - origlen;
+	    if (args) {
+		switch (intsize) {
+		case 'h':	*(va_arg(*args, short*)) = i; break;
+		default:	*(va_arg(*args, int*)) = i; break;
+		case 'l':	*(va_arg(*args, long*)) = i; break;
+		case 'V':	*(va_arg(*args, IV*)) = i; break;
+		}
+	    }
+	    else if (svix < svmax)
+		sv_setuv(svargs[svix++], (UV)i);
+	    continue;	/* not "break" */
+
+	    /* UNKNOWN */
+
+	default:
+      unknown:
+	    if (!args && dowarn &&
+		  (op->op_type == OP_PRTF || op->op_type == OP_SPRINTF)) {
+		SV *msg = sv_newmortal();
+		sv_setpvf(msg, "Invalid conversion in %s: ",
+			  (op->op_type == OP_PRTF) ? "printf" : "sprintf");
+		if (c)
+		    sv_catpvf(msg, isPRINT(c) ? "\"%%%c\"" : "\"%%\\%03o\"",
+			      c & 0xFF);
+		else
+		    sv_catpv(msg, "end of string");
+		warn("%_", msg); /* yes, this is reentrant */
+	    }
+	    /* output mangled stuff */
+	    eptr = p;
+	    elen = q - p;
+	    break;
+	}
+
+	have = esignlen + zeros + elen;
+	need = (have > width ? have : width);
+	gap = need - have;
+
+	SvGROW(sv, SvLEN(sv) + need);
+	p = SvEND(sv);
+	if (esignlen && fill == '0') {
+	    for (i = 0; i < esignlen; i++)
+		*p++ = esignbuf[i];
+	}
+	if (gap && !left) {
+	    memset(p, fill, gap);
+	    p += gap;
+	}
+	if (esignlen && fill != '0') {
+	    for (i = 0; i < esignlen; i++)
+		*p++ = esignbuf[i];
+	}
+	if (zeros) {
+	    for (i = zeros; i; i--)
+		*p++ = '0';
+	}
+	if (elen) {
+	    memcpy(p, eptr, elen);
+	    p += elen;
+	}
+	if (gap && left) {
+	    memset(p, ' ', gap);
+	    p += gap;
+	}
+	*p = '\0';
+	SvCUR(sv) = p - SvPVX(sv);
+    }
+}
+
 #ifdef DEBUGGING
 void
 sv_dump(sv)
 SV* sv;
 {
-    char tmpbuf[1024];
-    char *d = tmpbuf;
+    SV *d = sv_newmortal();
+    char *s;
     U32 flags;
     U32 type;
 
@@ -3998,126 +4679,122 @@ SV* sv;
     flags = SvFLAGS(sv);
     type = SvTYPE(sv);
 
-    sprintf(d, "(0x%lx)\n  REFCNT = %ld\n  FLAGS = (",
-	(unsigned long)SvANY(sv), (long)SvREFCNT(sv));
-    d += strlen(d);
-    if (flags & SVs_PADBUSY)	strcat(d, "PADBUSY,");
-    if (flags & SVs_PADTMP)	strcat(d, "PADTMP,");
-    if (flags & SVs_PADMY)	strcat(d, "PADMY,");
-    if (flags & SVs_TEMP)	strcat(d, "TEMP,");
-    if (flags & SVs_OBJECT)	strcat(d, "OBJECT,");
-    if (flags & SVs_GMG)	strcat(d, "GMG,");
-    if (flags & SVs_SMG)	strcat(d, "SMG,");
-    if (flags & SVs_RMG)	strcat(d, "RMG,");
-    d += strlen(d);
-
-    if (flags & SVf_IOK)	strcat(d, "IOK,");
-    if (flags & SVf_NOK)	strcat(d, "NOK,");
-    if (flags & SVf_POK)	strcat(d, "POK,");
-    if (flags & SVf_ROK)	strcat(d, "ROK,");
-    if (flags & SVf_OOK)	strcat(d, "OOK,");
-    if (flags & SVf_FAKE)	strcat(d, "FAKE,");
-    if (flags & SVf_READONLY)	strcat(d, "READONLY,");
-    d += strlen(d);
+    sv_setpvf(d, "(0x%lx)\n  REFCNT = %ld\n  FLAGS = (",
+	      (unsigned long)SvANY(sv), (long)SvREFCNT(sv));
+    if (flags & SVs_PADBUSY)	sv_catpv(d, "PADBUSY,");
+    if (flags & SVs_PADTMP)	sv_catpv(d, "PADTMP,");
+    if (flags & SVs_PADMY)	sv_catpv(d, "PADMY,");
+    if (flags & SVs_TEMP)	sv_catpv(d, "TEMP,");
+    if (flags & SVs_OBJECT)	sv_catpv(d, "OBJECT,");
+    if (flags & SVs_GMG)	sv_catpv(d, "GMG,");
+    if (flags & SVs_SMG)	sv_catpv(d, "SMG,");
+    if (flags & SVs_RMG)	sv_catpv(d, "RMG,");
+
+    if (flags & SVf_IOK)	sv_catpv(d, "IOK,");
+    if (flags & SVf_NOK)	sv_catpv(d, "NOK,");
+    if (flags & SVf_POK)	sv_catpv(d, "POK,");
+    if (flags & SVf_ROK)	sv_catpv(d, "ROK,");
+    if (flags & SVf_OOK)	sv_catpv(d, "OOK,");
+    if (flags & SVf_FAKE)	sv_catpv(d, "FAKE,");
+    if (flags & SVf_READONLY)	sv_catpv(d, "READONLY,");
 
 #ifdef OVERLOAD
-    if (flags & SVf_AMAGIC)	strcat(d, "OVERLOAD,");
+    if (flags & SVf_AMAGIC)	sv_catpv(d, "OVERLOAD,");
 #endif /* OVERLOAD */
-    if (flags & SVp_IOK)	strcat(d, "pIOK,");
-    if (flags & SVp_NOK)	strcat(d, "pNOK,");
-    if (flags & SVp_POK)	strcat(d, "pPOK,");
-    if (flags & SVp_SCREAM)	strcat(d, "SCREAM,");
+    if (flags & SVp_IOK)	sv_catpv(d, "pIOK,");
+    if (flags & SVp_NOK)	sv_catpv(d, "pNOK,");
+    if (flags & SVp_POK)	sv_catpv(d, "pPOK,");
+    if (flags & SVp_SCREAM)	sv_catpv(d, "SCREAM,");
 
     switch (type) {
     case SVt_PVCV:
     case SVt_PVFM:
-      if (CvANON(sv))		strcat(d, "ANON,");
-      if (CvUNIQUE(sv))		strcat(d, "UNIQUE,");
-      if (CvCLONE(sv))		strcat(d, "CLONE,");
-      if (CvCLONED(sv))		strcat(d, "CLONED,");
-      if (CvNODEBUG(sv))	strcat(d, "NODEBUG,");
-      break;
+	if (CvANON(sv))		sv_catpv(d, "ANON,");
+	if (CvUNIQUE(sv))	sv_catpv(d, "UNIQUE,");
+	if (CvCLONE(sv))	sv_catpv(d, "CLONE,");
+	if (CvCLONED(sv))	sv_catpv(d, "CLONED,");
+	if (CvNODEBUG(sv))	sv_catpv(d, "NODEBUG,");
+	break;
     case SVt_PVHV:
-      if (HvSHAREKEYS(sv))	strcat(d, "SHAREKEYS,");
-      if (HvLAZYDEL(sv))	strcat(d, "LAZYDEL,");
-      break;
+	if (HvSHAREKEYS(sv))	sv_catpv(d, "SHAREKEYS,");
+	if (HvLAZYDEL(sv))	sv_catpv(d, "LAZYDEL,");
+	break;
     case SVt_PVGV:
-      if (GvINTRO(sv))		strcat(d, "INTRO,");
-      if (GvMULTI(sv))		strcat(d, "MULTI,");
-      if (GvASSUMECV(sv))	strcat(d, "ASSUMECV,");
-      if (GvIMPORTED(sv)) {
-	  strcat(d, "IMPORT");
-	  if (GvIMPORTED(sv) == GVf_IMPORTED)
-	      strcat(d, "ALL,");
-	  else {
-	      strcat(d, "(");
-	      if (GvIMPORTED_SV(sv))	strcat(d, " SV");
-	      if (GvIMPORTED_AV(sv))	strcat(d, " AV");
-	      if (GvIMPORTED_HV(sv))	strcat(d, " HV");
-	      if (GvIMPORTED_CV(sv))	strcat(d, " CV");
-	      strcat(d, " ),");
-	  }
-      }
+	if (GvINTRO(sv))	sv_catpv(d, "INTRO,");
+	if (GvMULTI(sv))	sv_catpv(d, "MULTI,");
+	if (GvASSUMECV(sv))	sv_catpv(d, "ASSUMECV,");
+	if (GvIMPORTED(sv)) {
+	    sv_catpv(d, "IMPORT");
+	    if (GvIMPORTED(sv) == GVf_IMPORTED)
+		sv_catpv(d, "ALL,");
+	    else {
+		sv_catpv(d, "(");
+		if (GvIMPORTED_SV(sv))	sv_catpv(d, " SV");
+		if (GvIMPORTED_AV(sv))	sv_catpv(d, " AV");
+		if (GvIMPORTED_HV(sv))	sv_catpv(d, " HV");
+		if (GvIMPORTED_CV(sv))	sv_catpv(d, " CV");
+		sv_catpv(d, " ),");
+	    }
+	}
     }
 
-    d += strlen(d);
-    if (d[-1] == ',')
-	d--;
-    *d++ = ')';
-    *d = '\0';
+    if (*(SvEND(d) - 1) == ',')
+	SvPVX(d)[--SvCUR(d)] = '\0';
+    sv_catpv(d, ")");
+    s = SvPVX(d);
 
     PerlIO_printf(Perl_debug_log, "SV = ");
     switch (type) {
     case SVt_NULL:
-	PerlIO_printf(Perl_debug_log, "NULL%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "NULL%s\n", s);
 	return;
     case SVt_IV:
-	PerlIO_printf(Perl_debug_log, "IV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "IV%s\n", s);
 	break;
     case SVt_NV:
-	PerlIO_printf(Perl_debug_log, "NV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "NV%s\n", s);
 	break;
     case SVt_RV:
-	PerlIO_printf(Perl_debug_log, "RV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "RV%s\n", s);
 	break;
     case SVt_PV:
-	PerlIO_printf(Perl_debug_log, "PV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PV%s\n", s);
 	break;
     case SVt_PVIV:
-	PerlIO_printf(Perl_debug_log, "PVIV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVIV%s\n", s);
 	break;
     case SVt_PVNV:
-	PerlIO_printf(Perl_debug_log, "PVNV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVNV%s\n", s);
 	break;
     case SVt_PVBM:
-	PerlIO_printf(Perl_debug_log, "PVBM%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVBM%s\n", s);
 	break;
     case SVt_PVMG:
-	PerlIO_printf(Perl_debug_log, "PVMG%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVMG%s\n", s);
 	break;
     case SVt_PVLV:
-	PerlIO_printf(Perl_debug_log, "PVLV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVLV%s\n", s);
 	break;
     case SVt_PVAV:
-	PerlIO_printf(Perl_debug_log, "PVAV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVAV%s\n", s);
 	break;
     case SVt_PVHV:
-	PerlIO_printf(Perl_debug_log, "PVHV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVHV%s\n", s);
 	break;
     case SVt_PVCV:
-	PerlIO_printf(Perl_debug_log, "PVCV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVCV%s\n", s);
 	break;
     case SVt_PVGV:
-	PerlIO_printf(Perl_debug_log, "PVGV%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVGV%s\n", s);
 	break;
     case SVt_PVFM:
-	PerlIO_printf(Perl_debug_log, "PVFM%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVFM%s\n", s);
 	break;
     case SVt_PVIO:
-	PerlIO_printf(Perl_debug_log, "PVIO%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "PVIO%s\n", s);
 	break;
     default:
-	PerlIO_printf(Perl_debug_log, "UNKNOWN%s\n", tmpbuf);
+	PerlIO_printf(Perl_debug_log, "UNKNOWN%s\n", s);
 	return;
     }
     if (type >= SVt_PVIV || type == SVt_IV)
@@ -4162,14 +4839,12 @@ SV* sv;
 	PerlIO_printf(Perl_debug_log, "  MAX = %ld\n", (long)AvMAX(sv));
 	PerlIO_printf(Perl_debug_log, "  ARYLEN = 0x%lx\n", (long)AvARYLEN(sv));
 	flags = AvFLAGS(sv);
-	d = tmpbuf;
-	*d = '\0';
-	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';
-	PerlIO_printf(Perl_debug_log, "  FLAGS = (%s)\n", d);
+	sv_setpv(d, "");
+	if (flags & AVf_REAL)	sv_catpv(d, ",REAL");
+	if (flags & AVf_REIFY)	sv_catpv(d, ",REIFY");
+	if (flags & AVf_REUSED)	sv_catpv(d, ",REUSED");
+	PerlIO_printf(Perl_debug_log, "  FLAGS = (%s)\n",
+		      SvCUR(d) ? SvPVX(d) + 1 : "");
 	break;
     case SVt_PVHV:
 	PerlIO_printf(Perl_debug_log, "  ARRAY = 0x%lx\n",(long)HvARRAY(sv));