X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=sv.c;h=2c598f7546025a277ae32cef73ff5ee01f99fa44;hb=605881df1187f0374622b9de459bb7d803f7d806;hp=73aed10c070cd6de28f707252cef28f5cf1ff494;hpb=c008732bfe878991e04a1364a130be250e4ea1db;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/sv.c b/sv.c
index 73aed10..2c598f7 100644
--- a/sv.c
+++ b/sv.c
@@ -49,7 +49,7 @@
 
 #ifdef PERL_COPY_ON_WRITE
 #define SV_COW_NEXT_SV(sv)	INT2PTR(SV *,SvUVX(sv))
-#define SV_COW_NEXT_SV_SET(current,next)	SvUVX(current) = PTR2UV(next)
+#define SV_COW_NEXT_SV_SET(current,next)	SvUV_set(current, PTR2UV(next))
 /* This is a pessimistic view. Scalar must be purely a read-write PV to copy-
    on-write.  */
 #endif
@@ -416,10 +416,10 @@ do_clean_objs(pTHX_ SV *sv)
 	if (SvWEAKREF(sv)) {
 	    sv_del_backref(sv);
 	    SvWEAKREF_off(sv);
-	    SvRV(sv) = 0;
+	    SvRV_set(sv, NULL);
 	} else {
 	    SvROK_off(sv);
-	    SvRV(sv) = 0;
+	    SvRV_set(sv, NULL);
 	    SvREFCNT_dec(rv);
 	}
     }
@@ -645,6 +645,7 @@ Perl_sv_free_arenas(pTHX)
 STATIC SV*
 S_find_hash_subscript(pTHX_ HV *hv, SV* val)
 {
+    dVAR;
     register HE **array;
     register HE *entry;
     I32 i;
@@ -790,6 +791,7 @@ PL_comppad/PL_curpad points to the currently executing pad.
 STATIC SV *
 S_find_uninit_var(pTHX_ OP* obase, SV* uninit_sv, bool match)
 {
+    dVAR;
     SV *sv;
     AV *av;
     SV **svp;
@@ -1777,13 +1779,13 @@ bool
 Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
 {
 
-    char*	pv = NULL;
-    U32		cur = 0;
-    U32		len = 0;
-    IV		iv = 0;
-    NV		nv = 0.0;
-    MAGIC*	magic = NULL;
-    HV*		stash = Nullhv;
+    char*	pv;
+    U32		cur;
+    U32		len;
+    IV		iv;
+    NV		nv;
+    MAGIC*	magic;
+    HV*		stash;
 
     if (mt != SVt_PV && SvIsCOW(sv)) {
 	sv_force_normal_flags(sv, 0);
@@ -1792,64 +1794,39 @@ Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
     if (SvTYPE(sv) == mt)
 	return TRUE;
 
-    if (mt < SVt_PVIV)
-	(void)SvOOK_off(sv);
+    pv = NULL;
+    cur = 0;
+    len = 0;
+    iv = 0;
+    nv = 0.0;
+    magic = NULL;
+    stash = Nullhv;
 
     switch (SvTYPE(sv)) {
     case SVt_NULL:
-	pv	= 0;
-	cur	= 0;
-	len	= 0;
-	iv	= 0;
-	nv	= 0.0;
-	magic	= 0;
-	stash	= 0;
 	break;
     case SVt_IV:
-	pv	= 0;
-	cur	= 0;
-	len	= 0;
 	iv	= SvIVX(sv);
-	nv	= (NV)SvIVX(sv);
 	del_XIV(SvANY(sv));
-	magic	= 0;
-	stash	= 0;
 	if (mt == SVt_NV)
 	    mt = SVt_PVNV;
 	else if (mt < SVt_PVIV)
 	    mt = SVt_PVIV;
 	break;
     case SVt_NV:
-	pv	= 0;
-	cur	= 0;
-	len	= 0;
 	nv	= SvNVX(sv);
-	iv	= I_V(nv);
-	magic	= 0;
-	stash	= 0;
 	del_XNV(SvANY(sv));
-	SvANY(sv) = 0;
 	if (mt < SVt_PVNV)
 	    mt = SVt_PVNV;
 	break;
     case SVt_RV:
 	pv	= (char*)SvRV(sv);
-	cur	= 0;
-	len	= 0;
-	iv	= PTR2IV(pv);
-	nv	= PTR2NV(pv);
 	del_XRV(SvANY(sv));
-	magic	= 0;
-	stash	= 0;
 	break;
     case SVt_PV:
 	pv	= SvPVX(sv);
 	cur	= SvCUR(sv);
 	len	= SvLEN(sv);
-	iv	= 0;
-	nv	= 0.0;
-	magic	= 0;
-	stash	= 0;
 	del_XPV(SvANY(sv));
 	if (mt <= SVt_IV)
 	    mt = SVt_PVIV;
@@ -1861,9 +1838,6 @@ Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
 	cur	= SvCUR(sv);
 	len	= SvLEN(sv);
 	iv	= SvIVX(sv);
-	nv	= 0.0;
-	magic	= 0;
-	stash	= 0;
 	del_XPVIV(SvANY(sv));
 	break;
     case SVt_PVNV:
@@ -1872,8 +1846,6 @@ Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
 	len	= SvLEN(sv);
 	iv	= SvIVX(sv);
 	nv	= SvNVX(sv);
-	magic	= 0;
-	stash	= 0;
 	del_XPVNV(SvANY(sv));
 	break;
     case SVt_PVMG:
@@ -1898,161 +1870,123 @@ Perl_sv_upgrade(pTHX_ register SV *sv, U32 mt)
 	Perl_croak(aTHX_ "Can't upgrade to undef");
     case SVt_IV:
 	SvANY(sv) = new_XIV();
-	SvIVX(sv)	= iv;
+	SvIV_set(sv, iv);
 	break;
     case SVt_NV:
 	SvANY(sv) = new_XNV();
-	SvNVX(sv)	= nv;
+	SvNV_set(sv, nv);
 	break;
     case SVt_RV:
 	SvANY(sv) = new_XRV();
-	SvRV(sv) = (SV*)pv;
-	break;
-    case SVt_PV:
-	SvANY(sv) = new_XPV();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	break;
-    case SVt_PVIV:
-	SvANY(sv) = new_XPVIV();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	if (SvNIOK(sv))
-	    (void)SvIOK_on(sv);
-	SvNOK_off(sv);
-	break;
-    case SVt_PVNV:
-	SvANY(sv) = new_XPVNV();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	break;
-    case SVt_PVMG:
-	SvANY(sv) = new_XPVMG();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	break;
-    case SVt_PVLV:
-	SvANY(sv) = new_XPVLV();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	LvTARGOFF(sv)	= 0;
-	LvTARGLEN(sv)	= 0;
-	LvTARG(sv)	= 0;
-	LvTYPE(sv)	= 0;
-	GvGP(sv)	= 0;
-	GvNAME(sv)	= 0;
-	GvNAMELEN(sv)	= 0;
-	GvSTASH(sv)	= 0;
-	GvFLAGS(sv)	= 0;
-	break;
-    case SVt_PVAV:
-	SvANY(sv) = new_XPVAV();
-	if (pv)
-	    Safefree(pv);
-	SvPVX(sv)	= 0;
-	AvMAX(sv)	= -1;
-	AvFILLp(sv)	= -1;
-	SvIVX(sv)	= 0;
-	SvNVX(sv)	= 0.0;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	AvALLOC(sv)	= 0;
-	AvARYLEN(sv)	= 0;
-	AvFLAGS(sv)	= AVf_REAL;
+	SvRV_set(sv, (SV*)pv);
 	break;
     case SVt_PVHV:
 	SvANY(sv) = new_XPVHV();
-	if (pv)
-	    Safefree(pv);
-	SvPVX(sv)	= 0;
-	HvFILL(sv)	= 0;
-	HvMAX(sv)	= 0;
-	HvTOTALKEYS(sv)	= 0;
-	HvPLACEHOLDERS(sv) = 0;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
 	HvRITER(sv)	= 0;
 	HvEITER(sv)	= 0;
 	HvPMROOT(sv)	= 0;
 	HvNAME(sv)	= 0;
+	HvFILL(sv)	= 0;
+	HvMAX(sv)	= 0;
+	HvTOTALKEYS(sv)	= 0;
+	HvPLACEHOLDERS(sv) = 0;
+
+	/* Fall through...  */
+	if (0) {
+	case SVt_PVAV:
+	    SvANY(sv) = new_XPVAV();
+	    AvMAX(sv)	= -1;
+	    AvFILLp(sv)	= -1;
+	    AvALLOC(sv)	= 0;
+	    AvARYLEN(sv)= 0;
+	    AvFLAGS(sv)	= AVf_REAL;
+	    SvIV_set(sv, 0);
+	    SvNV_set(sv, 0.0);
+	}
+	/* to here.  */
+	/* XXX? Only SVt_NULL is ever upgraded to AV or HV?  */
+	assert(!pv);
+	/* FIXME. Should be able to remove all this if()... if the above
+	   assertion is genuinely always true.  */
+	if(SvOOK(sv)) {
+	    pv -= iv;
+	    SvFLAGS(sv) &= ~SVf_OOK;
+	}
+	Safefree(pv);
+	SvPV_set(sv, (char*)0);
+	SvMAGIC_set(sv, magic);
+	SvSTASH_set(sv, stash);
 	break;
+
+    case SVt_PVIO:
+	SvANY(sv) = new_XPVIO();
+	Zero(SvANY(sv), 1, XPVIO);
+	IoPAGE_LEN(sv)	= 60;
+	goto set_magic_common;
+    case SVt_PVFM:
+	SvANY(sv) = new_XPVFM();
+	Zero(SvANY(sv), 1, XPVFM);
+	goto set_magic_common;
+    case SVt_PVBM:
+	SvANY(sv) = new_XPVBM();
+	BmRARE(sv)	= 0;
+	BmUSEFUL(sv)	= 0;
+	BmPREVIOUS(sv)	= 0;
+	goto set_magic_common;
+    case SVt_PVGV:
+	SvANY(sv) = new_XPVGV();
+	GvGP(sv)	= 0;
+	GvNAME(sv)	= 0;
+	GvNAMELEN(sv)	= 0;
+	GvSTASH(sv)	= 0;
+	GvFLAGS(sv)	= 0;
+	goto set_magic_common;
     case SVt_PVCV:
 	SvANY(sv) = new_XPVCV();
 	Zero(SvANY(sv), 1, XPVCV);
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	break;
-    case SVt_PVGV:
-	SvANY(sv) = new_XPVGV();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
+	goto set_magic_common;
+    case SVt_PVLV:
+	SvANY(sv) = new_XPVLV();
+	LvTARGOFF(sv)	= 0;
+	LvTARGLEN(sv)	= 0;
+	LvTARG(sv)	= 0;
+	LvTYPE(sv)	= 0;
 	GvGP(sv)	= 0;
 	GvNAME(sv)	= 0;
 	GvNAMELEN(sv)	= 0;
 	GvSTASH(sv)	= 0;
 	GvFLAGS(sv)	= 0;
-	break;
-    case SVt_PVBM:
-	SvANY(sv) = new_XPVBM();
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	BmRARE(sv)	= 0;
-	BmUSEFUL(sv)	= 0;
-	BmPREVIOUS(sv)	= 0;
-	break;
-    case SVt_PVFM:
-	SvANY(sv) = new_XPVFM();
-	Zero(SvANY(sv), 1, XPVFM);
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	break;
-    case SVt_PVIO:
-	SvANY(sv) = new_XPVIO();
-	Zero(SvANY(sv), 1, XPVIO);
-	SvPVX(sv)	= pv;
-	SvCUR(sv)	= cur;
-	SvLEN(sv)	= len;
-	SvIVX(sv)	= iv;
-	SvNVX(sv)	= nv;
-	SvMAGIC(sv)	= magic;
-	SvSTASH(sv)	= stash;
-	IoPAGE_LEN(sv)	= 60;
+	/* Fall through.  */
+	if (0) {
+	case SVt_PVMG:
+	    SvANY(sv) = new_XPVMG();
+	}
+    set_magic_common:
+	SvMAGIC_set(sv, magic);
+	SvSTASH_set(sv, stash);
+	/* Fall through.  */
+	if (0) {
+	case SVt_PVNV:
+	    SvANY(sv) = new_XPVNV();
+	}
+	SvNV_set(sv, nv);
+	/* Fall through.  */
+	if (0) {
+	case SVt_PVIV:
+	    SvANY(sv) = new_XPVIV();
+	    if (SvNIOK(sv))
+		(void)SvIOK_on(sv);
+	    SvNOK_off(sv);
+	}
+	SvIV_set(sv, iv);
+	/* Fall through.  */
+	if (0) {
+	case SVt_PV:
+	    SvANY(sv) = new_XPV();
+	}
+	SvPV_set(sv, pv);
+	SvCUR_set(sv, cur);
+	SvLEN_set(sv, len);
 	break;
     }
     return TRUE;
@@ -2073,8 +2007,8 @@ Perl_sv_backoff(pTHX_ register SV *sv)
     assert(SvOOK(sv));
     if (SvIVX(sv)) {
 	char *s = SvPVX(sv);
-	SvLEN(sv) += SvIVX(sv);
-	SvPVX(sv) -= SvIVX(sv);
+	SvLEN_set(sv, SvLEN(sv) + SvIVX(sv));
+	SvPV_set(sv, SvPVX(sv) - SvIVX(sv));
 	SvIV_set(sv, 0);
 	Move(s, SvPVX(sv), SvCUR(sv)+1, char);
     }
@@ -2181,7 +2115,7 @@ Perl_sv_setiv(pTHX_ register SV *sv, IV i)
 		   OP_DESC(PL_op));
     }
     (void)SvIOK_only(sv);			/* validate number */
-    SvIVX(sv) = i;
+    SvIV_set(sv, i);
     SvTAINT(sv);
 }
 
@@ -2226,7 +2160,7 @@ Perl_sv_setuv(pTHX_ register SV *sv, UV u)
     }
     sv_setiv(sv, 0);
     SvIsUV_on(sv);
-    SvUVX(sv) = u;
+    SvUV_set(sv, u);
 }
 
 /*
@@ -2291,7 +2225,7 @@ Perl_sv_setnv(pTHX_ register SV *sv, NV num)
 	Perl_croak(aTHX_ "Can't coerce %s to number in %s", sv_reftype(sv,0),
 		   OP_NAME(PL_op));
     }
-    SvNVX(sv) = num;
+    SvNV_set(sv, num);
     (void)SvNOK_only(sv);			/* validate number */
     SvTAINT(sv);
 }
@@ -2502,14 +2436,14 @@ S_sv_2iuv_non_preserve(pTHX_ register SV *sv, I32 numtype)
     if (SvNVX(sv) < (NV)IV_MIN) {
 	(void)SvIOKp_on(sv);
 	(void)SvNOK_on(sv);
-	SvIVX(sv) = IV_MIN;
+	SvIV_set(sv, IV_MIN);
 	return IS_NUMBER_UNDERFLOW_IV;
     }
     if (SvNVX(sv) > (NV)UV_MAX) {
 	(void)SvIOKp_on(sv);
 	(void)SvNOK_on(sv);
 	SvIsUV_on(sv);
-	SvUVX(sv) = UV_MAX;
+	SvUV_set(sv, UV_MAX);
 	return IS_NUMBER_OVERFLOW_UV;
     }
     (void)SvIOKp_on(sv);
@@ -2517,7 +2451,7 @@ S_sv_2iuv_non_preserve(pTHX_ register SV *sv, I32 numtype)
     /* Can't use strtol etc to convert this string.  (See truth table in
        sv_2iv  */
     if (SvNVX(sv) <= (UV)IV_MAX) {
-        SvIVX(sv) = I_V(SvNVX(sv));
+        SvIV_set(sv, I_V(SvNVX(sv)));
         if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
             SvIOK_on(sv); /* Integer is precise. NOK, IOK */
         } else {
@@ -2526,7 +2460,7 @@ S_sv_2iuv_non_preserve(pTHX_ register SV *sv, I32 numtype)
         return SvNVX(sv) < 0 ? IS_NUMBER_UNDERFLOW_UV : IS_NUMBER_IV_AND_UV;
     }
     SvIsUV_on(sv);
-    SvUVX(sv) = U_V(SvNVX(sv));
+    SvUV_set(sv, U_V(SvNVX(sv)));
     if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
         if (SvUVX(sv) == UV_MAX) {
             /* As we know that NVs don't preserve UVs, UV_MAX cannot
@@ -2625,7 +2559,7 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 	   answer is the UV IV_MAX +1. Hence < ensures that dodgy boundary
 	   cases go to UV */
 	if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
-	    SvIVX(sv) = I_V(SvNVX(sv));
+	    SvIV_set(sv, I_V(SvNVX(sv)));
 	    if (SvNVX(sv) == (NV) SvIVX(sv)
 #ifndef NV_PRESERVES_UV
 		&& (((UV)1 << NV_PRESERVES_UV_BITS) >
@@ -2663,7 +2597,7 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 	       0x8000000000000000 which will be exact. NWC */
 	}
 	else {
-	    SvUVX(sv) = U_V(SvNVX(sv));
+	    SvUV_set(sv, U_V(SvNVX(sv)));
 	    if (
 		(SvNVX(sv) == (NV) SvUVX(sv))
 #ifndef  NV_PRESERVES_UV
@@ -2726,15 +2660,15 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 	    if (!(numtype & IS_NUMBER_NEG)) {
 		/* positive */;
 		if (value <= (UV)IV_MAX) {
-		    SvIVX(sv) = (IV)value;
+		    SvIV_set(sv, (IV)value);
 		} else {
-		    SvUVX(sv) = value;
+		    SvUV_set(sv, value);
 		    SvIsUV_on(sv);
 		}
 	    } else {
 		/* 2s complement assumption  */
 		if (value <= (UV)IV_MIN) {
-		    SvIVX(sv) = -(IV)value;
+		    SvIV_set(sv, -(IV)value);
 		} else {
 		    /* Too negative for an IV.  This is a double upgrade, but
 		       I'm assuming it will be rare.  */
@@ -2743,8 +2677,8 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 		    SvNOK_on(sv);
 		    SvIOK_off(sv);
 		    SvIOKp_on(sv);
-		    SvNVX(sv) = -(NV)value;
-		    SvIVX(sv) = IV_MIN;
+		    SvNV_set(sv, -(NV)value);
+		    SvIV_set(sv, IV_MIN);
 		}
 	    }
 	}
@@ -2755,7 +2689,7 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 	if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
 	    != IS_NUMBER_IN_UV) {
 	    /* It wasn't an (integer that doesn't overflow the UV). */
-	    SvNVX(sv) = Atof(SvPVX(sv));
+	    SvNV_set(sv, Atof(SvPVX(sv)));
 
 	    if (! numtype && ckWARN(WARN_NUMERIC))
 		not_a_number(sv);
@@ -2773,7 +2707,7 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 	    (void)SvIOKp_on(sv);
 	    (void)SvNOK_on(sv);
 	    if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
-		SvIVX(sv) = I_V(SvNVX(sv));
+		SvIV_set(sv, I_V(SvNVX(sv)));
 		if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
 		    SvIOK_on(sv);
 		} else {
@@ -2784,10 +2718,10 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
 		if (SvNVX(sv) > (NV)UV_MAX) {
 		    SvIsUV_on(sv);
 		    /* Integer is inaccurate. NOK, IOKp, is UV */
-		    SvUVX(sv) = UV_MAX;
+		    SvUV_set(sv, UV_MAX);
 		    SvIsUV_on(sv);
 		} else {
-		    SvUVX(sv) = U_V(SvNVX(sv));
+		    SvUV_set(sv, U_V(SvNVX(sv)));
 		    /* 0xFFFFFFFFFFFFFFFF not an issue in here */
 		    if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
 			SvIOK_on(sv);
@@ -2813,7 +2747,7 @@ Perl_sv_2iv_flags(pTHX_ register SV *sv, I32 flags)
                     /* Small enough to preserve all bits. */
                     (void)SvIOKp_on(sv);
                     SvNOK_on(sv);
-                    SvIVX(sv) = I_V(SvNVX(sv));
+                    SvIV_set(sv, I_V(SvNVX(sv)));
                     if ((NV)(SvIVX(sv)) == SvNVX(sv))
                         SvIOK_on(sv);
                     /* Assumption: first non-preserved integer is < IV_MAX,
@@ -2930,7 +2864,7 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
 
 	(void)SvIOKp_on(sv);	/* Must do this first, to clear any SvOOK */
 	if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
-	    SvIVX(sv) = I_V(SvNVX(sv));
+	    SvIV_set(sv, I_V(SvNVX(sv)));
 	    if (SvNVX(sv) == (NV) SvIVX(sv)
 #ifndef NV_PRESERVES_UV
 		&& (((UV)1 << NV_PRESERVES_UV_BITS) >
@@ -2968,7 +2902,7 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
 	       0x8000000000000000 which will be exact. NWC */
 	}
 	else {
-	    SvUVX(sv) = U_V(SvNVX(sv));
+	    SvUV_set(sv, U_V(SvNVX(sv)));
 	    if (
 		(SvNVX(sv) == (NV) SvUVX(sv))
 #ifndef  NV_PRESERVES_UV
@@ -3027,16 +2961,16 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
 	    if (!(numtype & IS_NUMBER_NEG)) {
 		/* positive */;
 		if (value <= (UV)IV_MAX) {
-		    SvIVX(sv) = (IV)value;
+		    SvIV_set(sv, (IV)value);
 		} else {
 		    /* it didn't overflow, and it was positive. */
-		    SvUVX(sv) = value;
+		    SvUV_set(sv, value);
 		    SvIsUV_on(sv);
 		}
 	    } else {
 		/* 2s complement assumption  */
 		if (value <= (UV)IV_MIN) {
-		    SvIVX(sv) = -(IV)value;
+		    SvIV_set(sv, -(IV)value);
 		} else {
 		    /* Too negative for an IV.  This is a double upgrade, but
 		       I'm assuming it will be rare.  */
@@ -3045,8 +2979,8 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
 		    SvNOK_on(sv);
 		    SvIOK_off(sv);
 		    SvIOKp_on(sv);
-		    SvNVX(sv) = -(NV)value;
-		    SvIVX(sv) = IV_MIN;
+		    SvNV_set(sv, -(NV)value);
+		    SvIV_set(sv, IV_MIN);
 		}
 	    }
 	}
@@ -3054,7 +2988,7 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
 	if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
 	    != IS_NUMBER_IN_UV) {
 	    /* It wasn't an integer, or it overflowed the UV. */
-	    SvNVX(sv) = Atof(SvPVX(sv));
+	    SvNV_set(sv, Atof(SvPVX(sv)));
 
             if (! numtype && ckWARN(WARN_NUMERIC))
 		    not_a_number(sv);
@@ -3071,7 +3005,7 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
             (void)SvIOKp_on(sv);
             (void)SvNOK_on(sv);
             if (SvNVX(sv) < (NV)IV_MAX + 0.5) {
-                SvIVX(sv) = I_V(SvNVX(sv));
+                SvIV_set(sv, I_V(SvNVX(sv)));
                 if ((NV)(SvIVX(sv)) == SvNVX(sv)) {
                     SvIOK_on(sv);
                 } else {
@@ -3082,10 +3016,10 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
                 if (SvNVX(sv) > (NV)UV_MAX) {
                     SvIsUV_on(sv);
                     /* Integer is inaccurate. NOK, IOKp, is UV */
-                    SvUVX(sv) = UV_MAX;
+                    SvUV_set(sv, UV_MAX);
                     SvIsUV_on(sv);
                 } else {
-                    SvUVX(sv) = U_V(SvNVX(sv));
+                    SvUV_set(sv, U_V(SvNVX(sv)));
                     /* 0xFFFFFFFFFFFFFFFF not an issue in here, NVs
                        NV preservse UV so can do correct comparison.  */
                     if ((NV)(SvUVX(sv)) == SvNVX(sv)) {
@@ -3111,7 +3045,7 @@ Perl_sv_2uv_flags(pTHX_ register SV *sv, I32 flags)
                     /* Small enough to preserve all bits. */
                     (void)SvIOKp_on(sv);
                     SvNOK_on(sv);
-                    SvIVX(sv) = I_V(SvNVX(sv));
+                    SvIV_set(sv, I_V(SvNVX(sv)));
                     if ((NV)(SvIVX(sv)) == SvNVX(sv))
                         SvIOK_on(sv);
                     /* Assumption: first non-preserved integer is < IV_MAX,
@@ -3226,7 +3160,7 @@ Perl_sv_2nv(pTHX_ register SV *sv)
         return SvNVX(sv);
     }
     if (SvIOKp(sv)) {
-	SvNVX(sv) = SvIsUV(sv) ? (NV)SvUVX(sv) : (NV)SvIVX(sv);
+	SvNV_set(sv, SvIsUV(sv) ? (NV)SvUVX(sv) : (NV)SvIVX(sv));
 #ifdef NV_PRESERVES_UV
 	SvNOK_on(sv);
 #else
@@ -3248,12 +3182,12 @@ Perl_sv_2nv(pTHX_ register SV *sv)
 	if ((numtype & (IS_NUMBER_IN_UV | IS_NUMBER_NOT_INT))
 	    == IS_NUMBER_IN_UV) {
 	    /* It's definitely an integer */
-	    SvNVX(sv) = (numtype & IS_NUMBER_NEG) ? -(NV)value : (NV)value;
+	    SvNV_set(sv, (numtype & IS_NUMBER_NEG) ? -(NV)value : (NV)value);
 	} else
-	    SvNVX(sv) = Atof(SvPVX(sv));
+	    SvNV_set(sv, Atof(SvPVX(sv)));
 	SvNOK_on(sv);
 #else
-	SvNVX(sv) = Atof(SvPVX(sv));
+	SvNV_set(sv, Atof(SvPVX(sv)));
 	/* Only set the public NV OK flag if this NV preserves the value in
 	   the PV at least as well as an IV/UV would.
 	   Not sure how to do this 100% reliably. */
@@ -3277,11 +3211,11 @@ Perl_sv_2nv(pTHX_ register SV *sv)
                 SvIOKp_on(sv);
 
                 if (numtype & IS_NUMBER_NEG) {
-                    SvIVX(sv) = -(IV)value;
+                    SvIV_set(sv, -(IV)value);
                 } else if (value <= (UV)IV_MAX) {
-		    SvIVX(sv) = (IV)value;
+		    SvIV_set(sv, (IV)value);
 		} else {
-		    SvUVX(sv) = value;
+		    SvUV_set(sv, value);
 		    SvIsUV_on(sv);
 		}
 
@@ -3738,6 +3672,7 @@ Perl_sv_2pv_flags(pTHX_ register SV *sv, STRLEN *lp, I32 flags)
 	return SvPVX(tsv);
     }
     else {
+        dVAR;
 	STRLEN len;
         const char *t;
 
@@ -3951,9 +3886,6 @@ use the Encode extension for that.
 STRLEN
 Perl_sv_utf8_upgrade_flags(pTHX_ register SV *sv, I32 flags)
 {
-    U8 *s, *t, *e;
-    int  hibit = 0;
-
     if (sv == &PL_sv_undef)
 	return 0;
     if (!SvPOK(sv)) {
@@ -3978,31 +3910,32 @@ Perl_sv_utf8_upgrade_flags(pTHX_ register SV *sv, I32 flags)
     if (PL_encoding && !(flags & SV_UTF8_NO_ENCODING))
         sv_recode_to_utf8(sv, PL_encoding);
     else { /* Assume Latin-1/EBCDIC */
-	 /* This function could be much more efficient if we
-	  * had a FLAG in SVs to signal if there are any hibit
-	  * chars in the PV.  Given that there isn't such a flag
-	  * make the loop as fast as possible. */
-	 s = (U8 *) SvPVX(sv);
-	 e = (U8 *) SvEND(sv);
-	 t = s;
-	 while (t < e) {
-	      U8 ch = *t++;
-	      if ((hibit = !NATIVE_IS_INVARIANT(ch)))
-		   break;
-	 }
-	 if (hibit) {
-	      STRLEN len;
-	      (void)SvOOK_off(sv);
-	      s = (U8*)SvPVX(sv);
-	      len = SvCUR(sv) + 1; /* Plus the \0 */
-	      SvPVX(sv) = (char*)bytes_to_utf8((U8*)s, &len);
-	      SvCUR(sv) = len - 1;
-	      if (SvLEN(sv) != 0)
-		   Safefree(s); /* No longer using what was there before. */
-	      SvLEN(sv) = len; /* No longer know the real size. */
-	 }
-	 /* Mark as UTF-8 even if no hibit - saves scanning loop */
-	 SvUTF8_on(sv);
+	/* This function could be much more efficient if we
+	 * had a FLAG in SVs to signal if there are any hibit
+	 * chars in the PV.  Given that there isn't such a flag
+	 * make the loop as fast as possible. */
+	U8 *s = (U8 *) SvPVX(sv);
+	U8 *e = (U8 *) SvEND(sv);
+	U8 *t = s;
+	int hibit = 0;
+	
+	while (t < e) {
+	    U8 ch = *t++;
+	    if ((hibit = !NATIVE_IS_INVARIANT(ch)))
+		break;
+	}
+	if (hibit) {
+	    STRLEN len = SvCUR(sv) + 1; /* Plus the \0 */
+	    s = bytes_to_utf8((U8*)s, &len);
+
+	    SvPV_free(sv); /* No longer using what was there before. */
+
+	    SvPV_set(sv, (char*)s);
+	    SvCUR_set(sv, len - 1);
+	    SvLEN_set(sv, len); /* No longer know the real size. */
+	}
+	/* Mark as UTF-8 even if no hibit - saves scanning loop */
+	SvUTF8_on(sv);
     }
     return SvCUR(sv);
 }
@@ -4044,7 +3977,7 @@ Perl_sv_utf8_downgrade(pTHX_ register SV* sv, bool fail_ok)
 		        Perl_croak(aTHX_ "Wide character");
 		}
 	    }
-	    SvCUR(sv) = len;
+	    SvCUR_set(sv, len);
 	}
     }
     SvUTF8_off(sv);
@@ -4209,7 +4142,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 		break;
 	    }
 	    (void)SvIOK_only(dstr);
-	    SvIVX(dstr) = SvIVX(sstr);
+	    SvIV_set(dstr,  SvIVX(sstr));
 	    if (SvIsUV(sstr))
 		SvIsUV_on(dstr);
 	    if (SvTAINTED(sstr))
@@ -4231,7 +4164,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 		sv_upgrade(dstr, SVt_PVNV);
 		break;
 	    }
-	    SvNVX(dstr) = SvNVX(sstr);
+	    SvNV_set(dstr, SvNVX(sstr));
 	    (void)SvNOK_only(dstr);
 	    if (SvTAINTED(sstr))
 		SvTAINT(dstr);
@@ -4483,21 +4416,20 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 		return;
 	    }
 	    if (SvPVX(dstr)) {
-		(void)SvOOK_off(dstr);		/* backoff */
-		if (SvLEN(dstr))
-		    Safefree(SvPVX(dstr));
-		SvLEN(dstr)=SvCUR(dstr)=0;
+		SvPV_free(dstr);
+		SvLEN_set(dstr, 0);
+                SvCUR_set(dstr, 0);
 	    }
 	}
 	(void)SvOK_off(dstr);
-	SvRV(dstr) = SvREFCNT_inc(SvRV(sstr));
+	SvRV_set(dstr, SvREFCNT_inc(SvRV(sstr)));
 	SvROK_on(dstr);
 	if (sflags & SVp_NOK) {
 	    SvNOKp_on(dstr);
 	    /* Only set the public OK flag if the source has public OK.  */
 	    if (sflags & SVf_NOK)
 		SvFLAGS(dstr) |= SVf_NOK;
-	    SvNVX(dstr) = SvNVX(sstr);
+	    SvNV_set(dstr, SvNVX(sstr));
 	}
 	if (sflags & SVp_IOK) {
 	    (void)SvIOKp_on(dstr);
@@ -4505,7 +4437,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 		SvFLAGS(dstr) |= SVf_IOK;
 	    if (sflags & SVf_IVisUV)
 		SvIsUV_on(dstr);
-	    SvIVX(dstr) = SvIVX(sstr);
+	    SvIV_set(dstr, SvIVX(sstr));
 	}
 	if (SvAMAGIC(sstr)) {
 	    SvAMAGIC_on(dstr);
@@ -4610,10 +4542,10 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
                     SvPV_set(dstr,
                              sharepvn(SvPVX(sstr),
                                       (sflags & SVf_UTF8?-cur:cur), hash));
-                    SvUVX(dstr) = hash;
+                    SvUV_set(dstr, hash);
                 }
-                SvLEN(dstr) = len;
-                SvCUR(dstr) = cur;
+                SvLEN_set(dstr, len);
+                SvCUR_set(dstr, cur);
                 SvREADONLY_on(dstr);
                 SvFAKE_on(dstr);
                 /* Relesase a global SV mutex.  */
@@ -4640,7 +4572,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 	    SvNOKp_on(dstr);
 	    if (sflags & SVf_NOK)
 		SvFLAGS(dstr) |= SVf_NOK;
-	    SvNVX(dstr) = SvNVX(sstr);
+	    SvNV_set(dstr, SvNVX(sstr));
 	}
 	if (sflags & SVp_IOK) {
 	    (void)SvIOKp_on(dstr);
@@ -4648,7 +4580,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 		SvFLAGS(dstr) |= SVf_IOK;
 	    if (sflags & SVf_IVisUV)
 		SvIsUV_on(dstr);
-	    SvIVX(dstr) = SvIVX(sstr);
+	    SvIV_set(dstr, SvIVX(sstr));
 	}
 	if (SvVOK(sstr)) {
 	    MAGIC *smg = mg_find(sstr,PERL_MAGIC_vstring);
@@ -4667,13 +4599,13 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 	/* XXXX Do we want to set IsUV for IV(ROK)?  Be extra safe... */
 	if (sflags & SVf_IVisUV)
 	    SvIsUV_on(dstr);
-	SvIVX(dstr) = SvIVX(sstr);
+	SvIV_set(dstr, SvIVX(sstr));
 	if (sflags & SVp_NOK) {
 	    if (sflags & SVf_NOK)
 		(void)SvNOK_on(dstr);
 	    else
 		(void)SvNOKp_on(dstr);
-	    SvNVX(dstr) = SvNVX(sstr);
+	    SvNV_set(dstr, SvNVX(sstr));
 	}
     }
     else if (sflags & SVp_NOK) {
@@ -4683,7 +4615,7 @@ Perl_sv_setsv_flags(pTHX_ SV *dstr, register SV *sstr, I32 flags)
 	    (void)SvOK_off(dstr);
 	    SvNOKp_on(dstr);
 	}
-	SvNVX(dstr) = SvNVX(sstr);
+	SvNV_set(dstr, SvNVX(sstr));
     }
     else {
 	if (dtype == SVt_PVGV) {
@@ -4752,7 +4684,7 @@ Perl_sv_setsv_cow(pTHX_ SV *dstr, SV *sstr)
 	    UV hash = SvUVX(sstr);
 	    DEBUG_C(PerlIO_printf(Perl_debug_log,
 				  "Fast copy on write: Sharing hash\n"));
-	    SvUVX(dstr) = hash;
+	    SvUV_set(dstr, hash);
 	    new_pv = sharepvn(SvPVX(sstr), (SvUTF8(sstr)?-cur:cur), hash);
 	    goto common_exit;
 	}
@@ -4774,8 +4706,8 @@ Perl_sv_setsv_cow(pTHX_ SV *dstr, SV *sstr)
     SvFLAGS(dstr) = (SVt_PVIV|SVf_POK|SVp_POK|SVf_FAKE|SVf_READONLY);
     if (SvUTF8(sstr))
 	SvUTF8_on(dstr);
-    SvLEN(dstr) = len;
-    SvCUR(dstr) = cur;
+    SvLEN_set(dstr, len);
+    SvCUR_set(dstr, cur);
     if (DEBUG_C_TEST) {
 	sv_dump(dstr);
     }
@@ -4902,11 +4834,10 @@ Perl_sv_usepvn(pTHX_ register SV *sv, register char *ptr, register STRLEN len)
 	(void)SvOK_off(sv);
 	return;
     }
-    (void)SvOOK_off(sv);
-    if (SvPVX(sv) && SvLEN(sv))
-	Safefree(SvPVX(sv));
+    if (SvPVX(sv))
+	SvPV_free(sv);
     Renew(ptr, len+1, char);
-    SvPVX(sv) = ptr;
+    SvPV_set(sv, ptr);
     SvCUR_set(sv, len);
     SvLEN_set(sv, len+1);
     *SvEND(sv) = '\0';
@@ -5014,15 +4945,15 @@ Perl_sv_force_normal_flags(pTHX_ register SV *sv, U32 flags)
             SvFAKE_off(sv);
             SvREADONLY_off(sv);
             /* This SV doesn't own the buffer, so need to New() a new one:  */
-            SvPVX(sv) = 0;
-            SvLEN(sv) = 0;
+            SvPV_set(sv, (char*)0);
+            SvLEN_set(sv, 0);
             if (flags & SV_COW_DROP_PV) {
                 /* OK, so we don't need to copy our buffer.  */
                 SvPOK_off(sv);
             } else {
                 SvGROW(sv, cur + 1);
                 Move(pvx,SvPVX(sv),cur,char);
-                SvCUR(sv) = cur;
+                SvCUR_set(sv, cur);
                 *SvEND(sv) = '\0';
             }
             sv_release_COW(sv, pvx, cur, len, hash, next);
@@ -5043,8 +4974,8 @@ Perl_sv_force_normal_flags(pTHX_ register SV *sv, U32 flags)
             U32 hash   = SvUVX(sv);
 	    SvFAKE_off(sv);
 	    SvREADONLY_off(sv);
-            SvPVX(sv) = 0;
-            SvLEN(sv) = 0;
+            SvPV_set(sv, (char*)0);
+            SvLEN_set(sv, 0);
 	    SvGROW(sv, len + 1);
 	    Move(pvx,SvPVX(sv),len,char);
 	    *SvEND(sv) = '\0';
@@ -5108,17 +5039,17 @@ Perl_sv_chop(pTHX_ register SV *sv, register char *ptr)
 	    Move(pvx,SvPVX(sv),len,char);
 	    *SvEND(sv) = '\0';
 	}
-	SvIVX(sv) = 0;
+	SvIV_set(sv, 0);
 	/* Same SvOOK_on but SvOOK_on does a SvIOK_off
 	   and we do that anyway inside the SvNIOK_off
 	*/
 	SvFLAGS(sv) |= SVf_OOK;
     }
     SvNIOK_off(sv);
-    SvLEN(sv) -= delta;
-    SvCUR(sv) -= delta;
-    SvPVX(sv) += delta;
-    SvIVX(sv) += delta;
+    SvLEN_set(sv, SvLEN(sv) - delta);
+    SvCUR_set(sv, SvCUR(sv) - delta);
+    SvPV_set(sv, SvPVX(sv) + delta);
+    SvIV_set(sv, SvIVX(sv) + delta);
 }
 
 /* sv_catpvn() is now a macro using Perl_sv_catpvn_flags();
@@ -5162,7 +5093,7 @@ Perl_sv_catpvn_flags(pTHX_ register SV *dsv, register const char *sstr, register
     if (sstr == dstr)
 	sstr = SvPVX(dsv);
     Move(sstr, SvPVX(dsv) + dlen, slen, char);
-    SvCUR(dsv) += slen;
+    SvCUR_set(dsv, SvCUR(dsv) + slen);
     *SvEND(dsv) = '\0';
     (void)SvPOK_only_UTF8(dsv);		/* validate pointer */
     SvTAINT(dsv);
@@ -5285,7 +5216,7 @@ Perl_sv_catpv(pTHX_ register SV *sv, register const char *ptr)
     if (ptr == junk)
 	ptr = SvPVX(sv);
     Move(ptr,SvPVX(sv)+tlen,len+1,char);
-    SvCUR(sv) += len;
+    SvCUR_set(sv, SvCUR(sv) + len);
     (void)SvPOK_only_UTF8(sv);		/* validate pointer */
     SvTAINT(sv);
 }
@@ -5357,7 +5288,7 @@ Perl_sv_magicext(pTHX_ SV* sv, SV* obj, int how, const MGVTBL *vtable,
     }
     Newz(702,mg, 1, MAGIC);
     mg->mg_moremagic = SvMAGIC(sv);
-    SvMAGIC(sv) = mg;
+    SvMAGIC_set(sv, mg);
 
     /* Sometimes a magic contains a reference loop, where the sv and
        object refer to each other.  To prevent a reference loop that
@@ -5577,7 +5508,7 @@ Perl_sv_magic(pTHX_ register SV *sv, SV *obj, int how, const char *name, I32 nam
     }
 
     /* Rest of work is done else where */
-    mg = sv_magicext(sv,obj,how,vtable,name,namlen);
+    mg = sv_magicext(sv,obj,how,(MGVTBL*)vtable,name,namlen);
 
     switch (how) {
     case PERL_MAGIC_taint:
@@ -5758,7 +5689,7 @@ Perl_sv_insert(pTHX_ SV *bigstr, STRLEN offset, STRLEN len, const char *little,
 	while (midend > mid)		/* shove everything down */
 	    *--bigend = *--midend;
 	Move(little,big+offset,littlelen,char);
-	SvCUR(bigstr) += i;
+	SvCUR_set(bigstr, SvCUR(bigstr) + i);
 	SvSETMAGIC(bigstr);
 	return;
     }
@@ -5836,10 +5767,10 @@ Perl_sv_replace(pTHX_ register SV *sv, register SV *nsv)
 	    mg_free(nsv);
 	else
 	    sv_upgrade(nsv, SVt_PVMG);
-	SvMAGIC(nsv) = SvMAGIC(sv);
+	SvMAGIC_set(nsv, SvMAGIC(sv));
 	SvFLAGS(nsv) |= SvMAGICAL(sv);
 	SvMAGICAL_off(sv);
-	SvMAGIC(sv) = 0;
+	SvMAGIC_set(sv, NULL);
     }
     SvREFCNT(sv) = 0;
     sv_clear(sv);
@@ -5897,6 +5828,7 @@ instead.
 void
 Perl_sv_clear(pTHX_ register SV *sv)
 {
+    dVAR;
     HV* stash;
     assert(sv);
     assert(SvREFCNT(sv) == 0);
@@ -5929,7 +5861,7 @@ Perl_sv_clear(pTHX_ register SV *sv)
 		    if(SvREFCNT(tmpref) < 2) {
 		        /* tmpref is not kept alive! */
 		        SvREFCNT(sv)--;
-			SvRV(tmpref) = 0;
+			SvRV_set(tmpref, NULL);
 			SvROK_off(tmpref);
 		    }
 		    SvREFCNT_dec(tmpref);
@@ -6010,7 +5942,11 @@ Perl_sv_clear(pTHX_ register SV *sv)
     case SVt_PVNV:
     case SVt_PVIV:
       freescalar:
-	SvOOK_off(sv);
+	/* Don't bother with SvOOK_off(sv); as we're only going to free it.  */
+	if (SvOOK(sv)) {
+	    SvPV_set(sv, SvPVX(sv) - SvIVX(sv));
+	    /* Don't even bother with turning off the OOK flag.  */
+	}
 	/* FALL THROUGH */
     case SVt_PV:
     case SVt_RV:
@@ -6146,6 +6082,7 @@ Normally called via a wrapper macro C<SvREFCNT_dec>.
 void
 Perl_sv_free(pTHX_ SV *sv)
 {
+    dVAR;
     if (!sv)
 	return;
     if (SvREFCNT(sv) == 0) {
@@ -6174,6 +6111,7 @@ Perl_sv_free(pTHX_ SV *sv)
 void
 Perl_sv_free2(pTHX_ SV *sv)
 {
+    dVAR;
 #ifdef DEBUGGING
     if (SvTEMP(sv)) {
 	if (ckWARN_d(WARN_DEBUGGING))
@@ -6284,7 +6222,7 @@ S_utf8_mg_pos_init(pTHX_ SV *sv, MAGIC **mgp, STRLEN **cachep, I32 i, I32 *offse
 
     if (SvMAGICAL(sv) && !SvREADONLY(sv)) {
 	if (!*mgp)
-	    *mgp = sv_magicext(sv, 0, PERL_MAGIC_utf8, &PL_vtbl_utf8, 0, 0);
+	    *mgp = sv_magicext(sv, 0, PERL_MAGIC_utf8, (MGVTBL*)&PL_vtbl_utf8, 0, 0);
 	assert(*mgp);
 
 	if ((*mgp)->mg_ptr)
@@ -6473,7 +6411,7 @@ Perl_sv_pos_u2b(pTHX_ register SV *sv, I32* offsetp, I32* lenp)
 	 if (lenp) {
 	      found = FALSE;
 	      start = s;
-              if (utf8_mg_pos(sv, &mg, &cache, 2, lenp, *lenp + *offsetp, &s, start, send)) {
+              if (utf8_mg_pos(sv, &mg, &cache, 2, lenp, *lenp, &s, start, send)) {
                   *lenp -= boffset;
                   found = TRUE;
               }
@@ -7208,17 +7146,7 @@ thats_really_all_folks:
    else
     {
        /*The big, slow, and stupid way. */
-
-      /* Any stack-challenged places. */
-#if defined(EPOC)
-      /* EPOC: need to work around SDK features.         *
-       * On WINS: MS VC5 generates calls to _chkstk,     *
-       * if a "large" stack frame is allocated.          *
-       * gcc on MARM does not generate calls like these. */
-#   define USEHEAPINSTEADOFSTACK
-#endif
-
-#ifdef USEHEAPINSTEADOFSTACK
+#ifdef USE_HEAP_INSTEAD_OF_STACK	/* Even slower way. */
 	STDCHAR *buf = 0;
 	New(0, buf, 8192, STDCHAR);
 	assert(buf);
@@ -7228,7 +7156,7 @@ thats_really_all_folks:
 
 screamer2:
 	if (rslen) {
-	    register STDCHAR *bpe = buf + sizeof(buf);
+            const register STDCHAR *bpe = buf + sizeof(buf);
 	    bp = buf;
 	    while ((i = PerlIO_getc(fp)) != EOF && (*bp++ = (STDCHAR)i) != rslast && bp < bpe)
 		; /* keep reading */
@@ -7273,7 +7201,7 @@ screamer2:
 		goto screamer2;
 	}
 
-#ifdef USEHEAPINSTEADOFSTACK
+#ifdef USE_HEAP_INSTEAD_OF_STACK
 	Safefree(buf);
 #endif
     }
@@ -7344,20 +7272,20 @@ Perl_sv_inc(pTHX_ register SV *sv)
 		sv_setnv(sv, UV_MAX_P1);
 	    else
 		(void)SvIOK_only_UV(sv);
-		++SvUVX(sv);
+		SvUV_set(sv, SvUVX(sv) + 1);
 	} else {
 	    if (SvIVX(sv) == IV_MAX)
 		sv_setuv(sv, (UV)IV_MAX + 1);
 	    else {
 		(void)SvIOK_only(sv);
-		++SvIVX(sv);
+		SvIV_set(sv, SvIVX(sv) + 1);
 	    }	
 	}
 	return;
     }
     if (flags & SVp_NOK) {
 	(void)SvNOK_only(sv);
-	SvNVX(sv) += 1.0;
+        SvNV_set(sv, SvNVX(sv) + 1.0);
 	return;
     }
 
@@ -7365,7 +7293,7 @@ Perl_sv_inc(pTHX_ register SV *sv)
 	if ((flags & SVTYPEMASK) < SVt_PVIV)
 	    sv_upgrade(sv, SVt_IV);
 	(void)SvIOK_only(sv);
-	SvIVX(sv) = 1;
+	SvIV_set(sv, 1);
 	return;
     }
     d = SvPVX(sv);
@@ -7392,7 +7320,7 @@ Perl_sv_inc(pTHX_ register SV *sv)
 	    /* sv_2iv *should* have made this an NV */
 	    if (flags & SVp_NOK) {
 		(void)SvNOK_only(sv);
-		SvNVX(sv) += 1.0;
+                SvNV_set(sv, SvNVX(sv) + 1.0);
 		return;
 	    }
 	    /* I don't think we can get here. Maybe I should assert this
@@ -7440,7 +7368,7 @@ Perl_sv_inc(pTHX_ register SV *sv)
     }
     /* oh,oh, the number grew */
     SvGROW(sv, SvCUR(sv) + 2);
-    SvCUR(sv)++;
+    SvCUR_set(sv, SvCUR(sv) + 1);
     for (d = SvPVX(sv) + SvCUR(sv); d > SvPVX(sv); d--)
 	*d = d[-1];
     if (isDIGIT(d[1]))
@@ -7494,31 +7422,31 @@ Perl_sv_dec(pTHX_ register SV *sv)
 	if (SvIsUV(sv)) {
 	    if (SvUVX(sv) == 0) {
 		(void)SvIOK_only(sv);
-		SvIVX(sv) = -1;
+		SvIV_set(sv, -1);
 	    }
 	    else {
 		(void)SvIOK_only_UV(sv);
-		--SvUVX(sv);
+		SvUV_set(sv, SvUVX(sv) + 1);
 	    }	
 	} else {
 	    if (SvIVX(sv) == IV_MIN)
 		sv_setnv(sv, (NV)IV_MIN - 1.0);
 	    else {
 		(void)SvIOK_only(sv);
-		--SvIVX(sv);
+		SvIV_set(sv, SvIVX(sv) - 1);
 	    }	
 	}
 	return;
     }
     if (flags & SVp_NOK) {
-	SvNVX(sv) -= 1.0;
+        SvNV_set(sv, SvNVX(sv) - 1.0);
 	(void)SvNOK_only(sv);
 	return;
     }
     if (!(flags & SVp_POK)) {
 	if ((flags & SVTYPEMASK) < SVt_PVNV)
 	    sv_upgrade(sv, SVt_NV);
-	SvNVX(sv) = -1.0;
+	SvNV_set(sv, 1.0);
 	(void)SvNOK_only(sv);
 	return;
     }
@@ -7540,7 +7468,7 @@ Perl_sv_dec(pTHX_ register SV *sv)
 	    /* sv_2iv *should* have made this an NV */
 	    if (flags & SVp_NOK) {
 		(void)SvNOK_only(sv);
-		SvNVX(sv) -= 1.0;
+                SvNV_set(sv, SvNVX(sv) - 1.0);
 		return;
 	    }
 	    /* I don't think we can get here. Maybe I should assert this
@@ -7626,6 +7554,7 @@ and C<sv_mortalcopy>.
 SV *
 Perl_sv_2mortal(pTHX_ register SV *sv)
 {
+    dVAR;
     if (!sv)
 	return sv;
     if (SvREADONLY(sv) && SvIMMORTAL(sv))
@@ -7709,10 +7638,10 @@ Perl_newSVpvn_share(pTHX_ const char *src, I32 len, U32 hash)
 	PERL_HASH(hash, src, len);
     new_SV(sv);
     sv_upgrade(sv, SVt_PVIV);
-    SvPVX(sv) = sharepvn(src, is_utf8?-len:len, hash);
-    SvCUR(sv) = len;
-    SvUVX(sv) = hash;
-    SvLEN(sv) = 0;
+    SvPV_set(sv, sharepvn(src, is_utf8?-len:len, hash));
+    SvCUR_set(sv, len);
+    SvUV_set(sv, hash);
+    SvLEN_set(sv, 0);
     SvREADONLY_on(sv);
     SvFAKE_on(sv);
     SvPOK_on(sv);
@@ -7847,7 +7776,7 @@ Perl_newRV_noinc(pTHX_ SV *tmpRef)
     new_SV(sv);
     sv_upgrade(sv, SVt_RV);
     SvTEMP_off(tmpRef);
-    SvRV(sv) = tmpRef;
+    SvRV_set(sv, tmpRef);
     SvROK_on(sv);
     return sv;
 }
@@ -7903,6 +7832,7 @@ Note that the perl-level function is vaguely deprecated.
 void
 Perl_sv_reset(pTHX_ register const char *s, HV *stash)
 {
+    dVAR;
     register HE *entry;
     register GV *gv;
     register SV *sv;
@@ -8035,6 +7965,7 @@ possible to set C<*st> and C<*gvp> to the stash and GV associated with it.
 CV *
 Perl_sv_2cv(pTHX_ SV *sv, HV **st, GV **gvp, I32 lref)
 {
+    dVAR;
     GV *gv = Nullgv;
     CV *cv = Nullcv;
 
@@ -8427,9 +8358,11 @@ Returns a string describing what the SV is a reference to.
 char *
 Perl_sv_reftype(pTHX_ const SV *sv, int ob)
 {
+    /* The fact that I don't need to downcast to char * everywhere, only in ?:
+       inside return suggests a const propagation bug in g++.  */
     if (ob && SvOBJECT(sv)) {
 	char *name = HvNAME(SvSTASH(sv));
-	return name ? name : "__ANON__";
+	return name ? name : (char *) "__ANON__";
     }
     else {
 	switch (SvTYPE(sv)) {
@@ -8449,11 +8382,11 @@ Perl_sv_reftype(pTHX_ const SV *sv, int ob)
 				else
 				    return "SCALAR";
 
-	case SVt_PVLV:		return SvROK(sv) ? "REF"
+	case SVt_PVLV:		return (char *)  (SvROK(sv) ? "REF"
 				/* tied lvalues should appear to be
 				 * scalars for backwards compatitbility */
 				: (LvTYPE(sv) == 't' || LvTYPE(sv) == 'T')
-				    ? "SCALAR" : "LVALUE";
+				    ? "SCALAR" : "LVALUE");
 	case SVt_PVAV:		return "ARRAY";
 	case SVt_PVHV:		return "HASH";
 	case SVt_PVCV:		return "CODE";
@@ -8550,15 +8483,13 @@ Perl_newSVrv(pTHX_ SV *rv, const char *classname)
     if (SvTYPE(rv) < SVt_RV)
 	sv_upgrade(rv, SVt_RV);
     else if (SvTYPE(rv) > SVt_RV) {
-	SvOOK_off(rv);
-	if (SvPVX(rv) && SvLEN(rv))
-	    Safefree(SvPVX(rv));
+	SvPV_free(rv);
 	SvCUR_set(rv, 0);
 	SvLEN_set(rv, 0);
     }
 
     SvOK_off(rv);
-    SvRV(rv) = sv;
+    SvRV_set(rv, sv);
     SvROK_on(rv);
 
     if (classname) {
@@ -8707,7 +8638,7 @@ Perl_sv_bless(pTHX_ SV *sv, HV *stash)
     if (SvTYPE(tmpRef) != SVt_PVIO)
 	++PL_sv_objcount;
     (void)SvUPGRADE(tmpRef, SVt_PVMG);
-    SvSTASH(tmpRef) = (HV*)SvREFCNT_inc(stash);
+    SvSTASH_set(tmpRef, (HV*)SvREFCNT_inc(stash));
 
     if (Gv_AMG(stash))
 	SvAMAGIC_on(sv);
@@ -8775,10 +8706,10 @@ Perl_sv_unref_flags(pTHX_ SV *sv, U32 flags)
     if (SvWEAKREF(sv)) {
     	sv_del_backref(sv);
 	SvWEAKREF_off(sv);
-	SvRV(sv) = 0;
+	SvRV_set(sv, NULL);
 	return;
     }
-    SvRV(sv) = 0;
+    SvRV_set(sv, NULL);
     SvROK_off(sv);
     /* You can't have a || SvREADONLY(rv) here, as $a = $$a, where $a was
        assigned to as BEGIN {$a = \"Foo"} will fail.  */
@@ -9185,7 +9116,7 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
     char *patend;
     STRLEN origlen;
     I32 svix = 0;
-    static char nullstr[] = "(null)";
+    static const char nullstr[] = "(null)";
     SV *argsv = Nullsv;
     bool has_utf8; /* has the result utf8? */
     bool pat_utf8; /* the pattern is in utf8? */
@@ -9588,7 +9519,7 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
 #endif
 		    elen = strlen(eptr);
 		else {
-		    eptr = nullstr;
+		    eptr = (char *)nullstr;
 		    elen = sizeof nullstr - 1;
 		}
 	    }
@@ -9820,19 +9751,6 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
 		}
 		break;
 	    default:		/* it had better be ten or less */
-#if defined(PERL_Y2KWARN)
-		if (ckWARN(WARN_Y2K)) {
-		    STRLEN n;
-		    char *s = SvPV(sv,n);
-		    if (n >= 2 && s[n-2] == '1' && s[n-1] == '9'
-			&& (n == 2 || !isDIGIT(s[n-3])))
-		    {
-			Perl_warner(aTHX_ packWARN(WARN_Y2K),
-				    "Possible Y2K bug: %%%c %s",
-				    c, "format string following '19'");
-		    }
-		}
-#endif
 		do {
 		    dig = uv % base;
 		    *--eptr = '0' + dig;
@@ -10105,7 +10023,7 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
 	    Copy(eptr, p, elen, char);
 	    p += elen;
 	    *p = '\0';
-	    SvCUR(sv) = p - SvPVX(sv);
+	    SvCUR_set(sv, p - SvPVX(sv));
 	    svix = osvix;
 	    continue;	/* not "break" */
 	}
@@ -10171,7 +10089,7 @@ Perl_sv_vcatpvfn(pTHX_ SV *sv, const char *pat, STRLEN patlen, va_list *args, SV
 	if (has_utf8)
 	    SvUTF8_on(sv);
 	*p = '\0';
-	SvCUR(sv) = p - SvPVX(sv);
+	SvCUR_set(sv, p - SvPVX(sv));
 	if (vectorize) {
 	    esignlen = 0;
 	    goto vector;
@@ -10224,6 +10142,7 @@ ptr_table_* functions.
 REGEXP *
 Perl_re_dup(pTHX_ REGEXP *r, CLONE_PARAMS *param)
 {
+    dVAR;
     REGEXP *ret;
     int i, len, npar;
     struct reg_substr_datum *s;
@@ -10616,10 +10535,6 @@ Perl_ptr_table_free(pTHX_ PTR_TBL_t *tbl)
     Safefree(tbl);
 }
 
-#ifdef DEBUGGING
-char *PL_watch_pvx;
-#endif
-
 /* attempt to make everything in the typeglob readonly */
 
 STATIC SV *
@@ -10683,15 +10598,16 @@ void
 Perl_rvpv_dup(pTHX_ SV *dstr, SV *sstr, CLONE_PARAMS* param)
 {
     if (SvROK(sstr)) {
-	SvRV(dstr) = SvWEAKREF(sstr)
-		     ? sv_dup(SvRV(sstr), param)
-		     : sv_dup_inc(SvRV(sstr), param);
+	SvRV_set(dstr, SvWEAKREF(sstr)
+		       ? sv_dup(SvRV(sstr), param)
+		       : sv_dup_inc(SvRV(sstr), param));
+
     }
     else if (SvPVX(sstr)) {
 	/* Has something there */
 	if (SvLEN(sstr)) {
 	    /* Normal PV - clone whole allocated space */
-	    SvPVX(dstr) = SAVEPVN(SvPVX(sstr), SvLEN(sstr)-1);
+	    SvPV_set(dstr, SAVEPVN(SvPVX(sstr), SvLEN(sstr)-1));
 	    if (SvREADONLY(sstr) && SvFAKE(sstr)) {
 		/* Not that normal - actually sstr is copy on write.
 		   But we are a true, independant SV, so:  */
@@ -10708,31 +10624,35 @@ Perl_rvpv_dup(pTHX_ SV *dstr, SV *sstr, CLONE_PARAMS* param)
                        and they should not have these flags
                        turned off */
 
-                    SvPVX(dstr) = sharepvn(SvPVX(sstr), SvCUR(sstr),
-                                           SvUVX(sstr));
-                    SvUVX(dstr) = SvUVX(sstr);
+                    SvPV_set(dstr, sharepvn(SvPVX(sstr), SvCUR(sstr),
+                                           SvUVX(sstr)));
+                    SvUV_set(dstr, SvUVX(sstr));
                 } else {
 
-                    SvPVX(dstr) = SAVEPVN(SvPVX(sstr), SvCUR(sstr));
+                    SvPV_set(dstr, SAVEPVN(SvPVX(sstr), SvCUR(sstr)));
                     SvFAKE_off(dstr);
                     SvREADONLY_off(dstr);
                 }
 	    }
 	    else {
 		/* Some other special case - random pointer */
-		SvPVX(dstr) = SvPVX(sstr);		
+		SvPV_set(dstr, SvPVX(sstr));		
 	    }
 	}
     }
     else {
 	/* Copy the Null */
-	SvPVX(dstr) = SvPVX(sstr);
+	if (SvTYPE(dstr) == SVt_RV)
+	    SvRV_set(dstr, NULL);
+	else
+	    SvPV_set(dstr, 0);
     }
 }
 
 SV *
 Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 {
+    dVAR;
     SV *dstr;
 
     if (!sstr || SvTYPE(sstr) == SVTYPEMASK)
@@ -10782,17 +10702,24 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 		      PL_watch_pvx, SvPVX(sstr));
 #endif
 
+    /* don't clone objects whose class has asked us not to */
+    if (SvOBJECT(sstr) && ! (SvFLAGS(SvSTASH(sstr)) & SVphv_CLONEABLE)) {
+	SvFLAGS(dstr) &= ~SVTYPEMASK;
+	SvOBJECT_off(dstr);
+	return dstr;
+    }
+
     switch (SvTYPE(sstr)) {
     case SVt_NULL:
 	SvANY(dstr)	= NULL;
 	break;
     case SVt_IV:
 	SvANY(dstr)	= new_XIV();
-	SvIVX(dstr)	= SvIVX(sstr);
+	SvIV_set(dstr, SvIVX(sstr));
 	break;
     case SVt_NV:
 	SvANY(dstr)	= new_XNV();
-	SvNVX(dstr)	= SvNVX(sstr);
+	SvNV_set(dstr, SvNVX(sstr));
 	break;
     case SVt_RV:
 	SvANY(dstr)	= new_XRV();
@@ -10800,43 +10727,43 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	break;
     case SVt_PV:
 	SvANY(dstr)	= new_XPV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	break;
     case SVt_PVIV:
 	SvANY(dstr)	= new_XPVIV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	break;
     case SVt_PVNV:
 	SvANY(dstr)	= new_XPVNV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	break;
     case SVt_PVMG:
 	SvANY(dstr)	= new_XPVMG();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	break;
     case SVt_PVBM:
 	SvANY(dstr)	= new_XPVBM();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	BmRARE(dstr)	= BmRARE(sstr);
 	BmUSEFUL(dstr)	= BmUSEFUL(sstr);
@@ -10844,12 +10771,12 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	break;
     case SVt_PVLV:
 	SvANY(dstr)	= new_XPVLV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	LvTARGOFF(dstr)	= LvTARGOFF(sstr);	/* XXX sometimes holds PMOP* when DEBUGGING */
 	LvTARGLEN(dstr)	= LvTARGLEN(sstr);
@@ -10876,12 +10803,12 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
             }
 	}
 	SvANY(dstr)	= new_XPVGV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	GvNAMELEN(dstr)	= GvNAMELEN(sstr);
 	GvNAME(dstr)	= SAVEPVN(GvNAME(sstr), GvNAMELEN(sstr));
@@ -10892,12 +10819,12 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	break;
     case SVt_PVIO:
 	SvANY(dstr)	= new_XPVIO();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	IoIFP(dstr)	= fp_dup(IoIFP(sstr), IoTYPE(sstr), param);
 	if (IoOFP(sstr) == IoIFP(sstr))
@@ -10934,12 +10861,12 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	break;
     case SVt_PVAV:
 	SvANY(dstr)	= new_XPVAV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	AvARYLEN((AV*)dstr) = sv_dup_inc(AvARYLEN((AV*)sstr), param);
 	AvFLAGS((AV*)dstr) = AvFLAGS((AV*)sstr);
 	if (AvARRAY((AV*)sstr)) {
@@ -10949,7 +10876,7 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	    src_ary = AvARRAY((AV*)sstr);
 	    Newz(0, dst_ary, AvMAX((AV*)sstr)+1, SV*);
 	    ptr_table_store(PL_ptr_table, src_ary, dst_ary);
-	    SvPVX(dstr)	= (char*)dst_ary;
+	    SvPV_set(dstr, (char*)dst_ary);
 	    AvALLOC((AV*)dstr) = dst_ary;
 	    if (AvREAL((AV*)sstr)) {
 		while (items-- > 0)
@@ -10965,18 +10892,18 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	    }
 	}
 	else {
-	    SvPVX(dstr)		= Nullch;
+	    SvPV_set(dstr, Nullch);
 	    AvALLOC((AV*)dstr)	= (SV**)NULL;
 	}
 	break;
     case SVt_PVHV:
 	SvANY(dstr)	= new_XPVHV();
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	HvRITER((HV*)dstr)	= HvRITER((HV*)sstr);
 	if (HvARRAY((HV*)sstr)) {
 	    STRLEN i = 0;
@@ -10994,7 +10921,7 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 				     (bool)!!HvSHAREKEYS(sstr), param);
 	}
 	else {
-	    SvPVX(dstr)		= Nullch;
+	    SvPV_set(dstr, Nullch);
 	    HvEITER((HV*)dstr)	= (HE*)NULL;
 	}
 	HvPMROOT((HV*)dstr)	= HvPMROOT((HV*)sstr);		/* XXX */
@@ -11011,12 +10938,12 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
     case SVt_PVCV:
 	SvANY(dstr)	= new_XPVCV();
         dup_pvcv:
-	SvCUR(dstr)	= SvCUR(sstr);
-	SvLEN(dstr)	= SvLEN(sstr);
-	SvIVX(dstr)	= SvIVX(sstr);
-	SvNVX(dstr)	= SvNVX(sstr);
-	SvMAGIC(dstr)	= mg_dup(SvMAGIC(sstr), param);
-	SvSTASH(dstr)	= hv_dup_inc(SvSTASH(sstr), param);
+	SvCUR_set(dstr, SvCUR(sstr));
+	SvLEN_set(dstr, SvLEN(sstr));
+	SvIV_set(dstr, SvIVX(sstr));
+	SvNV_set(dstr, SvNVX(sstr));
+	SvMAGIC_set(dstr, mg_dup(SvMAGIC(sstr), param));
+	SvSTASH_set(dstr, hv_dup_inc(SvSTASH(sstr), param));
 	Perl_rvpv_dup(aTHX_ dstr, sstr, param);
 	CvSTASH(dstr)	= hv_dup(CvSTASH(sstr), param); /* NOTE: not refcounted */
 	CvSTART(dstr)	= CvSTART(sstr);
@@ -11028,7 +10955,7 @@ Perl_sv_dup(pTHX_ SV *sstr, CLONE_PARAMS* param)
 	if (CvCONST(sstr)) {
 	    CvXSUBANY(dstr).any_ptr = GvUNIQUE(CvGV(sstr)) ?
                 SvREFCNT_inc(CvXSUBANY(sstr).any_ptr) :
-                sv_dup_inc(CvXSUBANY(sstr).any_ptr, param);
+                sv_dup_inc((SV *)CvXSUBANY(sstr).any_ptr, param);
 	}
 	/* don't dup if copying back - CvGV isn't refcounted, so the
 	 * duped GV may never be freed. A bit of a hack! DAPM */
@@ -11497,6 +11424,40 @@ Perl_ss_dup(pTHX_ PerlInterpreter *proto_perl, CLONE_PARAMS* param)
     return nss;
 }
 
+
+/* if sv is a stash, call $class->CLONE_SKIP(), and set the SVphv_CLONEABLE
+ * flag to the result. This is done for each stash before cloning starts,
+ * so we know which stashes want their objects cloned */
+
+static void
+do_mark_cloneable_stash(pTHX_ SV *sv)
+{
+    if (HvNAME((HV*)sv)) {
+	GV* cloner = gv_fetchmethod_autoload((HV*)sv, "CLONE_SKIP", 0);
+	SvFLAGS(sv) |= SVphv_CLONEABLE; /* clone objects by default */
+	if (cloner && GvCV(cloner)) {
+	    dSP;
+	    UV status;
+
+	    ENTER;
+	    SAVETMPS;
+	    PUSHMARK(SP);
+	    XPUSHs(sv_2mortal(newSVpv(HvNAME((HV*)sv), 0)));
+	    PUTBACK;
+	    call_sv((SV*)GvCV(cloner), G_SCALAR);
+	    SPAGAIN;
+	    status = POPu;
+	    PUTBACK;
+	    FREETMPS;
+	    LEAVE;
+	    if (status)
+		SvFLAGS(sv) &= ~SVphv_CLONEABLE;
+	}
+    }
+}
+
+
+
 /*
 =for apidoc perl_clone
 
@@ -11541,6 +11502,7 @@ perl_clone_host(PerlInterpreter* proto_perl, UV flags);
 PerlInterpreter *
 perl_clone(PerlInterpreter *proto_perl, UV flags)
 {
+   dVAR;
 #ifdef PERL_IMPLICIT_SYS
 
    /* perlhost.h so we need to call into it
@@ -11578,6 +11540,8 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     CLONE_PARAMS* param = &clone_params;
 
     PerlInterpreter *my_perl = (PerlInterpreter*)(*ipM->pMalloc)(ipM, sizeof(PerlInterpreter));
+    /* for each stash, determine whether its objects should be cloned */
+    S_visit(proto_perl, do_mark_cloneable_stash, SVt_PVHV, SVTYPEMASK);
     PERL_SET_THX(my_perl);
 
 #  ifdef DEBUGGING
@@ -11610,10 +11574,10 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     CLONE_PARAMS clone_params;
     CLONE_PARAMS* param = &clone_params;
     PerlInterpreter *my_perl = (PerlInterpreter*)PerlMem_malloc(sizeof(PerlInterpreter));
+    /* for each stash, determine whether its objects should be cloned */
+    S_visit(proto_perl, do_mark_cloneable_stash, SVt_PVHV, SVTYPEMASK);
     PERL_SET_THX(my_perl);
 
-
-
 #    ifdef DEBUGGING
     Poison(my_perl, 1, PerlInterpreter);
     PL_op = Nullop;
@@ -11689,22 +11653,22 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
     SvREFCNT(&PL_sv_no)		= (~(U32)0)/2;
     SvFLAGS(&PL_sv_no)		= SVp_IOK|SVf_IOK|SVp_NOK|SVf_NOK
 				  |SVp_POK|SVf_POK|SVf_READONLY|SVt_PVNV;
-    SvPVX(&PL_sv_no)		= SAVEPVN(PL_No, 0);
-    SvCUR(&PL_sv_no)		= 0;
-    SvLEN(&PL_sv_no)		= 1;
-    SvIVX(&PL_sv_no)		= 0;
-    SvNVX(&PL_sv_no)		= 0;
+    SvPV_set(&PL_sv_no, SAVEPVN(PL_No, 0));
+    SvCUR_set(&PL_sv_no, 0);
+    SvLEN_set(&PL_sv_no, 1);
+    SvIV_set(&PL_sv_no, 0);
+    SvNV_set(&PL_sv_no, 0);
     ptr_table_store(PL_ptr_table, &proto_perl->Isv_no, &PL_sv_no);
 
     SvANY(&PL_sv_yes)		= new_XPVNV();
     SvREFCNT(&PL_sv_yes)	= (~(U32)0)/2;
     SvFLAGS(&PL_sv_yes)		= SVp_IOK|SVf_IOK|SVp_NOK|SVf_NOK
 				  |SVp_POK|SVf_POK|SVf_READONLY|SVt_PVNV;
-    SvPVX(&PL_sv_yes)		= SAVEPVN(PL_Yes, 1);
-    SvCUR(&PL_sv_yes)		= 1;
-    SvLEN(&PL_sv_yes)		= 2;
-    SvIVX(&PL_sv_yes)		= 1;
-    SvNVX(&PL_sv_yes)		= 1;
+    SvPV_set(&PL_sv_yes, SAVEPVN(PL_Yes, 1));
+    SvCUR_set(&PL_sv_yes, 1);
+    SvLEN_set(&PL_sv_yes, 2);
+    SvIV_set(&PL_sv_yes, 1);
+    SvNV_set(&PL_sv_yes, 1);
     ptr_table_store(PL_ptr_table, &proto_perl->Isv_yes, &PL_sv_yes);
 
     /* create (a non-shared!) shared string table */
@@ -12321,7 +12285,7 @@ perl_clone_using(PerlInterpreter *proto_perl, UV flags,
 	    ENTER;
 	    SAVETMPS;
 	    PUSHMARK(SP);
-           XPUSHs(sv_2mortal(newSVpv(HvNAME(stash), 0)));
+	    XPUSHs(sv_2mortal(newSVpv(HvNAME(stash), 0)));
 	    PUTBACK;
 	    call_sv((SV*)GvCV(cloner), G_DISCARD);
 	    FREETMPS;
@@ -12357,6 +12321,7 @@ The PV of the sv is returned.
 char *
 Perl_sv_recode_to_utf8(pTHX_ SV *sv, SV *encoding)
 {
+    dVAR;
     if (SvPOK(sv) && !SvUTF8(sv) && !IN_BYTES && SvROK(encoding)) {
 	SV *uni;
 	STRLEN len;
@@ -12418,6 +12383,7 @@ bool
 Perl_sv_cat_decode(pTHX_ SV *dsv, SV *encoding,
 		   SV *ssv, int *offset, char *tstr, int tlen)
 {
+    dVAR;
     bool ret = FALSE;
     if (SvPOK(ssv) && SvPOK(dsv) && SvROK(encoding) && offset) {
 	SV *offsv;