perl 5.16.2, compiled without optimization for Windows (from siep)

git-svn-id: svn://tug.org/texlive/trunk@28315 c570f23f-e606-0410-a88d-b1316a301751

1 files changed, 170 insertions, 141 deletions

diff --git a/Master/tlpkg/tlperl/lib/CORE/sv.h b/Master/tlpkg/tlperl/lib/CORE/sv.h
index 7f466754142..7f79c016479 100644
--- a/Master/tlpkg/tlperl/lib/CORE/sv.h
+++ b/Master/tlpkg/tlperl/lib/CORE/sv.h
@@ -65,6 +65,11 @@ typedef enum {
 	SVt_LAST	/* keep last in enum. used to size arrays */
 } svtype;
 
+/* *** any alterations to the SV types above need to be reflected in
+ * SVt_MASK and the various PL_valid_types_* tables */
+
+#define SVt_MASK 0xf	/* smallest bitmask that covers all types */
+
 #ifndef PERL_CORE
 /* Although Fast Boyer Moore tables are now being stored in PVGVs, for most
    purposes eternal code wanting to consider PVBM probably needs to think of
@@ -304,10 +309,10 @@ perform the upgrade if necessary.  See C<svtype>.
 				       subroutine in another package. Set the
 				       CvIMPORTED_CV_ON() if it needs to be
 				       expanded to a real GV */
-
-#define SVs_PADSTALE	0x00010000  /* lexical has gone out of scope */
-#define SVpad_STATE	0x00010000  /* pad name is a "state" var */
-#define SVs_PADTMP	0x00020000  /* in use as tmp */
+/*                      0x00010000  *** FREE SLOT */
+#define SVs_PADTMP	0x00020000  /* in use as tmp; only if ! SVs_PADMY */
+#define SVs_PADSTALE	0x00020000  /* lexical has gone out of scope;
+					only valid for SVs_PADMY */
 #define SVpad_TYPED	0x00020000  /* pad name is a Typed Lexical */
 #define SVs_PADMY	0x00040000  /* in use a "my" variable */
 #define SVpad_OUR	0x00040000  /* pad name is "our" instead of "my" */
@@ -317,7 +322,7 @@ perform the upgrade if necessary.  See C<svtype>.
 #define SVs_SMG		0x00400000  /* has magical set method */
 #define SVs_RMG		0x00800000  /* has random magical methods */
 
-#define SVf_FAKE	0x01000000  /* 0: glob or lexical is just a copy
+#define SVf_FAKE	0x01000000  /* 0: glob is just a copy
 				       1: SV head arena wasn't malloc()ed
 				       2: in conjunction with SVf_READONLY
 					  marks a shared hash key scalar
@@ -367,8 +372,21 @@ perform the upgrade if necessary.  See C<svtype>.
 
 /* PVHV */
 #define SVphv_SHAREKEYS 0x20000000  /* PVHV keys live on shared string table */
-/* PVNV, PVMG, presumably only inside pads */
-#define SVpad_NAME	0x40000000  /* This SV is a name in the PAD, so
+
+/* PVNV, PVMG only, and only used in pads. Should be safe to test on any scalar
+   SV, as the core is careful to avoid setting both.
+
+   SVf_POK, SVp_POK also set:
+   0x00004400   Normal
+   0x0000C400   Studied (SvSCREAM)
+   0x40004400   FBM compiled (SvVALID)
+   0x4000C400   pad name.
+
+   0x00008000   GV with GP
+   0x00008800   RV with PCS imported
+*/
+#define SVpad_NAME	(SVp_SCREAM|SVpbm_VALID)
+				    /* This SV is a name in the PAD, so
 				       SVpad_TYPED, SVpad_OUR and SVpad_STATE
 				       apply */
 /* PVAV */
@@ -378,11 +396,10 @@ perform the upgrade if necessary.  See C<svtype>.
 /* This is only set true on a PVGV when it's playing "PVBM", but is tested for
    on any regular scalar (anything <= PVLV) */
 #define SVpbm_VALID	0x40000000
-/* ??? */
+/* Only used in toke.c on an SV stored in PL_lex_repl */
 #define SVrepl_EVAL	0x40000000  /* Replacement part of s///e */
 
 /* IV, PVIV, PVNV, PVMG, PVGV and (I assume) PVLV  */
-/* Presumably IVs aren't stored in pads */
 #define SVf_IVisUV	0x80000000  /* use XPVUV instead of XPVIV */
 /* PVAV */
 #define SVpav_REIFY 	0x80000000  /* can become real */
@@ -392,6 +409,8 @@ perform the upgrade if necessary.  See C<svtype>.
 #define SVpbm_TAIL	0x80000000
 /* RV upwards. However, SVf_ROK and SVp_IOK are exclusive  */
 #define SVprv_WEAKREF   0x80000000  /* Weak reference */
+/* pad name vars only */
+#define SVpad_STATE	0x80000000  /* pad name is a "state" var */
 
 #define _XPV_HEAD							\
     HV*		xmg_stash;	/* class package */			\
@@ -407,8 +426,7 @@ union _xnvu {
 	U32 xhigh;
     }	    xpad_cop_seq;	/* used by pad.c for cop_sequence */
     struct {
-	U32 xbm_previous;	/* how many characters in string before rare? */
-	U8  xbm_flags;
+	I32 xbm_useful;
 	U8  xbm_rare;		/* rarest character in string */
     }	    xbm_s;		/* fields from PVBM */
 };
@@ -416,13 +434,13 @@ union _xnvu {
 union _xivu {
     IV	    xivu_iv;		/* integer value */
     UV	    xivu_uv;
-    I32	    xivu_i32;		/* BmUSEFUL */
     HEK *   xivu_namehek;	/* xpvlv, xpvgv: GvNAME */
 };
 
 union _xmgu {
     MAGIC*  xmg_magic;		/* linked list of magicalness */
     HV*	    xmg_ourstash;	/* Stash for our (when SvPAD_OUR is true) */
+    STRLEN  xmg_hash_index;	/* used while freeing hash entries */
 };
 
 struct xpv {
@@ -465,6 +483,7 @@ struct xpvlv {
     SV*		xlv_targ;
     char	xlv_type;	/* k=keys .=pos x=substr v=vec /=join/re
 				 * y=alem/helem/iter t=tie T=tied HE */
+    char	xlv_flags;	/* 1 = negative offset  2 = negative len */
 };
 
 /* This structure works in 3 ways - regular scalar, GV with GP, or fast
@@ -654,20 +673,23 @@ Dereferences an RV to return the SV.
 
 =for apidoc Am|IV|SvIVX|SV* sv
 Returns the raw value in the SV's IV slot, without checks or conversions.
-Only use when you are sure SvIOK is true. See also C<SvIV()>.
+Only use when you are sure SvIOK is true.  See also C<SvIV()>.
 
 =for apidoc Am|UV|SvUVX|SV* sv
 Returns the raw value in the SV's UV slot, without checks or conversions.
-Only use when you are sure SvIOK is true. See also C<SvUV()>.
+Only use when you are sure SvIOK is true.  See also C<SvUV()>.
 
 =for apidoc Am|NV|SvNVX|SV* sv
 Returns the raw value in the SV's NV slot, without checks or conversions.
-Only use when you are sure SvNOK is true. See also C<SvNV()>.
+Only use when you are sure SvNOK is true.  See also C<SvNV()>.
 
 =for apidoc Am|char*|SvPVX|SV* sv
 Returns a pointer to the physical string in the SV.  The SV must contain a
 string.
 
+This is also used to store the name of an autoloaded subroutine in an XS
+AUTOLOAD routine.  See L<perlguts/Autoloading with XSUBs>.
+
 =for apidoc Am|STRLEN|SvCUR|SV* sv
 Returns the length of the string which is in the SV.  See C<SvLEN>.
 
@@ -676,9 +698,14 @@ Returns the size of the string buffer in the SV, not including any part
 attributable to C<SvOOK>.  See C<SvCUR>.
 
 =for apidoc Am|char*|SvEND|SV* sv
-Returns a pointer to the last character in the string which is in the SV.
+Returns a pointer to the spot just after the last character in
+the string which is in the SV, where there is usually a trailing
+null (even though Perl scalars do not strictly require it).
 See C<SvCUR>.  Access the character as *(SvEND(sv)).
 
+Warning: If C<SvCUR> is equal to C<SvLEN>, then C<SvEND> points to
+unallocated memory.
+
 =for apidoc Am|HV*|SvSTASH|SV* sv
 Returns the stash of the SV.
 
@@ -779,7 +806,8 @@ Set the actual length of the string which is in the SV.  See C<SvIV_set>.
 
 /*
 =for apidoc Am|U32|SvUTF8|SV* sv
-Returns a U32 value indicating whether the SV contains UTF-8 encoded data.
+Returns a U32 value indicating the UTF-8 status of an SV.  If things are set-up
+properly, this indicates whether or not the SV contains UTF-8 encoded data.
 Call this after SvPV() in case any call to string overloading updates the
 internal flag.
 
@@ -788,7 +816,8 @@ Turn on the UTF-8 status of an SV (the data is not changed, just the flag).
 Do not use frivolously.
 
 =for apidoc Am|void|SvUTF8_off|SV *sv
-Unsets the UTF-8 status of an SV.
+Unsets the UTF-8 status of an SV (the data is not changed, just the flag).
+Do not use frivolously.
 
 =for apidoc Am|void|SvPOK_only_UTF8|SV* sv
 Tells an SV that it is a string and disables all other OK bits,
@@ -823,7 +852,7 @@ in gv.h: */
 				 ? mg_find(sv,PERL_MAGIC_vstring) : NULL)
 
 #define SvOOK(sv)		(SvFLAGS(sv) & SVf_OOK)
-#define SvOOK_on(sv)		((void)SvIOK_off(sv), SvFLAGS(sv) |= SVf_OOK)
+#define SvOOK_on(sv)		(SvFLAGS(sv) |= SVf_OOK)
 #define SvOOK_off(sv)		((void)(SvOOK(sv) && sv_backoff(sv)))
 
 #define SvFAKE(sv)		(SvFLAGS(sv) & SVf_FAKE)
@@ -869,10 +898,12 @@ in gv.h: */
 /*
 =for apidoc Am|U32|SvGAMAGIC|SV* sv
 
-Returns true if the SV has get magic or overloading. If either is true then
+Returns true if the SV has get magic or
+overloading.  If either is true then
 the scalar is active data, and has the potential to return a new value every
-time it is accessed. Hence you must be careful to only read it once per user
-logical operation and work with that returned value. If neither is true then
+time it is accessed.  Hence you must be careful to
+only read it once per user logical operation and work
+with that returned value.  If neither is true then
 the scalar's value cannot change unless written to.
 
 =cut
@@ -894,17 +925,43 @@ the scalar's value cannot change unless written to.
 
 #define SvTHINKFIRST(sv)	(SvFLAGS(sv) & SVf_THINKFIRST)
 
-#define SvPADSTALE(sv)		(SvFLAGS(sv) & SVs_PADSTALE)
-#define SvPADSTALE_on(sv)	(SvFLAGS(sv) |= SVs_PADSTALE)
-#define SvPADSTALE_off(sv)	(SvFLAGS(sv) &= ~SVs_PADSTALE)
-
-#define SvPADTMP(sv)		(SvFLAGS(sv) & SVs_PADTMP)
-#define SvPADTMP_on(sv)		(SvFLAGS(sv) |= SVs_PADTMP)
-#define SvPADTMP_off(sv)	(SvFLAGS(sv) &= ~SVs_PADTMP)
-
 #define SvPADMY(sv)		(SvFLAGS(sv) & SVs_PADMY)
 #define SvPADMY_on(sv)		(SvFLAGS(sv) |= SVs_PADMY)
 
+/* SVs_PADTMP and SVs_PADSTALE share the same bit, mediated by SVs_PADMY */
+
+#define SvPADTMP(sv)	((SvFLAGS(sv) & (SVs_PADMY|SVs_PADTMP)) == SVs_PADTMP)
+#define SvPADSTALE(sv)	((SvFLAGS(sv) & (SVs_PADMY|SVs_PADSTALE)) \
+				    == (SVs_PADMY|SVs_PADSTALE))
+
+#if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
+#  define SvPADTMP_on(sv)	({			\
+	    SV *const _svpad = MUTABLE_SV(sv);		\
+	    assert(!(SvFLAGS(_svpad) & SVs_PADMY));	\
+	    SvFLAGS(_svpad) |= SVs_PADTMP;		\
+	})
+#  define SvPADTMP_off(sv)	({			\
+	    SV *const _svpad = MUTABLE_SV(sv);		\
+	    assert(!(SvFLAGS(_svpad) & SVs_PADMY));	\
+	    SvFLAGS(_svpad) &= ~SVs_PADTMP;		\
+	})
+#  define SvPADSTALE_on(sv)	({			\
+	    SV *const _svpad = MUTABLE_SV(sv);		\
+	    assert(SvFLAGS(_svpad) & SVs_PADMY);	\
+	    SvFLAGS(_svpad) |= SVs_PADSTALE;		\
+	})
+#  define SvPADSTALE_off(sv)	({			\
+	    SV *const _svpad = MUTABLE_SV(sv);		\
+	    assert(SvFLAGS(_svpad) & SVs_PADMY);	\
+	    SvFLAGS(_svpad) &= ~SVs_PADSTALE;		\
+	})
+#else
+#  define SvPADTMP_on(sv)	(SvFLAGS(sv) |= SVs_PADTMP)
+#  define SvPADTMP_off(sv)	(SvFLAGS(sv) &= ~SVs_PADTMP)
+#  define SvPADSTALE_on(sv)	(SvFLAGS(sv) |= SVs_PADSTALE)
+#  define SvPADSTALE_off(sv)	(SvFLAGS(sv) &= ~SVs_PADSTALE)
+#endif
+
 #define SvTEMP(sv)		(SvFLAGS(sv) & SVs_TEMP)
 #define SvTEMP_on(sv)		(SvFLAGS(sv) |= SVs_TEMP)
 #define SvTEMP_off(sv)		(SvFLAGS(sv) &= ~SVs_TEMP)
@@ -1003,9 +1060,6 @@ the scalar's value cannot change unless written to.
 	    ((XPVMG*) SvANY(sv))->xmg_u.xmg_ourstash = st;	\
 	} STMT_END
 
-#ifdef PERL_DEBUG_COW
-#else
-#endif
 #define SvRVx(sv) SvRV(sv)
 
 #ifdef PERL_DEBUG_COW
@@ -1041,9 +1095,7 @@ the scalar's value cannot change unless written to.
 /* These get expanded inside other macros that already use a variable _sv  */
 #    define SvPVX(sv)							\
 	(*({ SV *const _svpvx = MUTABLE_SV(sv);				\
-	    assert(SvTYPE(_svpvx) >= SVt_PV);				\
-	    assert(SvTYPE(_svpvx) != SVt_PVAV);				\
-	    assert(SvTYPE(_svpvx) != SVt_PVHV);				\
+	    assert(PL_valid_types_PVX[SvTYPE(_svpvx) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svpvx));				\
 	    assert(!(SvTYPE(_svpvx) == SVt_PVIO				\
 		     && !(IoFLAGS(_svpvx) & IOf_FAKE_DIRP)));		\
@@ -1051,9 +1103,7 @@ the scalar's value cannot change unless written to.
 	 }))
 #    define SvCUR(sv)							\
 	(*({ const SV *const _svcur = (const SV *)(sv);			\
-	    assert(SvTYPE(_svcur) >= SVt_PV);				\
-	    assert(SvTYPE(_svcur) != SVt_PVAV);				\
-	    assert(SvTYPE(_svcur) != SVt_PVHV);				\
+	    assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svcur));				\
 	    assert(!(SvTYPE(_svcur) == SVt_PVIO				\
 		     && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP)));		\
@@ -1061,47 +1111,25 @@ the scalar's value cannot change unless written to.
 	 }))
 #    define SvIVX(sv)							\
 	(*({ const SV *const _svivx = (const SV *)(sv);			\
-	    assert(SvTYPE(_svivx) == SVt_IV || SvTYPE(_svivx) >= SVt_PVIV); \
-	    assert(SvTYPE(_svivx) != SVt_PVAV);				\
-	    assert(SvTYPE(_svivx) != SVt_PVHV);				\
-	    assert(SvTYPE(_svivx) != SVt_PVCV);				\
-	    assert(SvTYPE(_svivx) != SVt_PVFM);				\
-	    assert(SvTYPE(_svivx) != SVt_PVIO);				\
-	    assert(SvTYPE(_svivx) != SVt_REGEXP);			\
+	    assert(PL_valid_types_IVX[SvTYPE(_svivx) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svivx));				\
 	    &(((XPVIV*) MUTABLE_PTR(SvANY(_svivx)))->xiv_iv);		\
 	 }))
 #    define SvUVX(sv)							\
 	(*({ const SV *const _svuvx = (const SV *)(sv);			\
-	    assert(SvTYPE(_svuvx) == SVt_IV || SvTYPE(_svuvx) >= SVt_PVIV); \
-	    assert(SvTYPE(_svuvx) != SVt_PVAV);				\
-	    assert(SvTYPE(_svuvx) != SVt_PVHV);				\
-	    assert(SvTYPE(_svuvx) != SVt_PVCV);				\
-	    assert(SvTYPE(_svuvx) != SVt_PVFM);				\
-	    assert(SvTYPE(_svuvx) != SVt_PVIO);				\
-	    assert(SvTYPE(_svuvx) != SVt_REGEXP);			\
+	    assert(PL_valid_types_IVX[SvTYPE(_svuvx) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svuvx));				\
 	    &(((XPVUV*) MUTABLE_PTR(SvANY(_svuvx)))->xuv_uv);		\
 	 }))
 #    define SvNVX(sv)							\
 	(*({ const SV *const _svnvx = (const SV *)(sv);			\
-	    assert(SvTYPE(_svnvx) == SVt_NV || SvTYPE(_svnvx) >= SVt_PVNV); \
-	    assert(SvTYPE(_svnvx) != SVt_PVAV);				\
-	    assert(SvTYPE(_svnvx) != SVt_PVHV);				\
-	    assert(SvTYPE(_svnvx) != SVt_PVCV);				\
-	    assert(SvTYPE(_svnvx) != SVt_PVFM);				\
-	    assert(SvTYPE(_svnvx) != SVt_PVIO);				\
-	    assert(SvTYPE(_svnvx) != SVt_REGEXP);			\
+	    assert(PL_valid_types_NVX[SvTYPE(_svnvx) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svnvx));				\
 	    &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv);	\
 	 }))
 #    define SvRV(sv)							\
 	(*({ SV *const _svrv = MUTABLE_SV(sv);				\
-	    assert(SvTYPE(_svrv) >= SVt_PV || SvTYPE(_svrv) == SVt_IV);	\
-	    assert(SvTYPE(_svrv) != SVt_PVAV);				\
-	    assert(SvTYPE(_svrv) != SVt_PVHV);				\
-	    assert(SvTYPE(_svrv) != SVt_PVCV);				\
-	    assert(SvTYPE(_svrv) != SVt_PVFM);				\
+	    assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svrv));				\
 	    assert(!(SvTYPE(_svrv) == SVt_PVIO				\
 		     && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP)));		\
@@ -1109,11 +1137,7 @@ the scalar's value cannot change unless written to.
 	 }))
 #    define SvRV_const(sv)						\
 	({ const SV *const _svrv = (const SV *)(sv);			\
-	    assert(SvTYPE(_svrv) >= SVt_PV || SvTYPE(_svrv) == SVt_IV);	\
-	    assert(SvTYPE(_svrv) != SVt_PVAV);				\
-	    assert(SvTYPE(_svrv) != SVt_PVHV);				\
-	    assert(SvTYPE(_svrv) != SVt_PVCV);				\
-	    assert(SvTYPE(_svrv) != SVt_PVFM);				\
+	    assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]);	\
 	    assert(!isGV_with_GP(_svrv));				\
 	    assert(!(SvTYPE(_svrv) == SVt_PVIO				\
 		     && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP)));		\
@@ -1174,40 +1198,30 @@ the scalar's value cannot change unless written to.
 	STMT_START {if (!SvIOKp(sv) && (SvNOK(sv) || SvPOK(sv))) \
 		(void) SvIV_nomg(sv); } STMT_END
 #define SvIV_set(sv, val) \
-	STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
-		assert(SvTYPE(sv) != SVt_PVAV);		\
-		assert(SvTYPE(sv) != SVt_PVHV);		\
-		assert(SvTYPE(sv) != SVt_PVCV);		\
+	STMT_START { \
+		assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));		\
 		(((XPVIV*)  SvANY(sv))->xiv_iv = (val)); } STMT_END
 #define SvNV_set(sv, val) \
-	STMT_START { assert(SvTYPE(sv) == SVt_NV || SvTYPE(sv) >= SVt_PVNV); \
-	    assert(SvTYPE(sv) != SVt_PVAV); assert(SvTYPE(sv) != SVt_PVHV); \
-	    assert(SvTYPE(sv) != SVt_PVCV); assert(SvTYPE(sv) != SVt_PVFM); \
-		assert(SvTYPE(sv) != SVt_PVIO);		\
+	STMT_START { \
+		assert(PL_valid_types_NV_set[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));		\
 		(((XPVNV*)SvANY(sv))->xnv_u.xnv_nv = (val)); } STMT_END
 #define SvPV_set(sv, val) \
-	STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
-		assert(SvTYPE(sv) != SVt_PVAV);		\
-		assert(SvTYPE(sv) != SVt_PVHV);		\
+	STMT_START { \
+		assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));		\
 		assert(!(SvTYPE(sv) == SVt_PVIO		\
 		     && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
 		((sv)->sv_u.svu_pv = (val)); } STMT_END
 #define SvUV_set(sv, val) \
-	STMT_START { assert(SvTYPE(sv) == SVt_IV || SvTYPE(sv) >= SVt_PVIV); \
-		assert(SvTYPE(sv) != SVt_PVAV);		\
-		assert(SvTYPE(sv) != SVt_PVHV);		\
-		assert(SvTYPE(sv) != SVt_PVCV);		\
+	STMT_START { \
+		assert(PL_valid_types_IV_set[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));		\
 		(((XPVUV*)SvANY(sv))->xuv_uv = (val)); } STMT_END
 #define SvRV_set(sv, val) \
-        STMT_START { assert(SvTYPE(sv) >=  SVt_PV || SvTYPE(sv) ==  SVt_IV); \
-		assert(SvTYPE(sv) != SVt_PVAV);		\
-		assert(SvTYPE(sv) != SVt_PVHV);		\
-		assert(SvTYPE(sv) != SVt_PVCV);		\
-		assert(SvTYPE(sv) != SVt_PVFM);		\
+        STMT_START { \
+		assert(PL_valid_types_RV[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));		\
 		assert(!(SvTYPE(sv) == SVt_PVIO		\
 		     && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
@@ -1219,17 +1233,15 @@ the scalar's value cannot change unless written to.
         STMT_START { assert(SvTYPE(sv) >= SVt_PVMG); \
                 (((XPVMG*)  SvANY(sv))->xmg_stash = (val)); } STMT_END
 #define SvCUR_set(sv, val) \
-	STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
-		assert(SvTYPE(sv) != SVt_PVAV);		\
-		assert(SvTYPE(sv) != SVt_PVHV);		\
+	STMT_START { \
+		assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));		\
 		assert(!(SvTYPE(sv) == SVt_PVIO		\
 		     && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
 		(((XPV*)  SvANY(sv))->xpv_cur = (val)); } STMT_END
 #define SvLEN_set(sv, val) \
-	STMT_START { assert(SvTYPE(sv) >= SVt_PV); \
-		assert(SvTYPE(sv) != SVt_PVAV);	\
-		assert(SvTYPE(sv) != SVt_PVHV);	\
+	STMT_START { \
+		assert(PL_valid_types_PVX[SvTYPE(sv) & SVt_MASK]);	\
 		assert(!isGV_with_GP(sv));	\
 		assert(!(SvTYPE(sv) == SVt_PVIO		\
 		     && !(IoFLAGS(sv) & IOf_FAKE_DIRP))); \
@@ -1280,42 +1292,34 @@ the scalar's value cannot change unless written to.
 		 } STMT_END
 #endif
 
-#define PERL_FBM_TABLE_OFFSET 1	/* Number of bytes between EOS and table */
+#ifndef PERL_CORE
+#  define BmFLAGS(sv)		(SvTAIL(sv) ? FBMcf_TAIL : 0)
+#endif
 
-/* SvPOKp not SvPOK in the assertion because the string can be tainted! eg
-   perl -T -e '/$^X/'
-*/
 #if defined (DEBUGGING) && defined(__GNUC__) && !defined(PERL_GCC_BRACE_GROUPS_FORBIDDEN)
-#  define BmFLAGS(sv)							\
-	(*({ SV *const _bmflags = MUTABLE_SV(sv);			\
-		assert(SvTYPE(_bmflags) == SVt_PVGV);			\
-		assert(SvVALID(_bmflags));				\
-	    &(((XPVGV*) SvANY(_bmflags))->xnv_u.xbm_s.xbm_flags);	\
-	 }))
 #  define BmRARE(sv)							\
 	(*({ SV *const _bmrare = MUTABLE_SV(sv);			\
-		assert(SvTYPE(_bmrare) == SVt_PVGV);			\
+		assert(SvTYPE(_bmrare) == SVt_PVMG);			\
 		assert(SvVALID(_bmrare));				\
-	    &(((XPVGV*) SvANY(_bmrare))->xnv_u.xbm_s.xbm_rare);		\
+	    &(((XPVMG*) SvANY(_bmrare))->xnv_u.xbm_s.xbm_rare);		\
 	 }))
 #  define BmUSEFUL(sv)							\
 	(*({ SV *const _bmuseful = MUTABLE_SV(sv);			\
-	    assert(SvTYPE(_bmuseful) == SVt_PVGV);			\
+	    assert(SvTYPE(_bmuseful) == SVt_PVMG);			\
 	    assert(SvVALID(_bmuseful));					\
 	    assert(!SvIOK(_bmuseful));					\
-	    &(((XPVGV*) SvANY(_bmuseful))->xiv_u.xivu_i32);		\
+	    &(((XPVMG*) SvANY(_bmuseful))->xnv_u.xbm_s.xbm_useful);	\
 	 }))
 #  define BmPREVIOUS(sv)						\
     (*({ SV *const _bmprevious = MUTABLE_SV(sv);			\
-		assert(SvTYPE(_bmprevious) == SVt_PVGV);		\
+		assert(SvTYPE(_bmprevious) == SVt_PVMG);		\
 		assert(SvVALID(_bmprevious));				\
-	    &(((XPVGV*) SvANY(_bmprevious))->xnv_u.xbm_s.xbm_previous);	\
+	    &(((XPVMG*) SvANY(_bmprevious))->xiv_u.xivu_uv);		\
 	 }))
 #else
-#  define BmFLAGS(sv)		((XPVGV*) SvANY(sv))->xnv_u.xbm_s.xbm_flags
-#  define BmRARE(sv)		((XPVGV*) SvANY(sv))->xnv_u.xbm_s.xbm_rare
-#  define BmUSEFUL(sv)		((XPVGV*) SvANY(sv))->xiv_u.xivu_i32
-#  define BmPREVIOUS(sv)	((XPVGV*) SvANY(sv))->xnv_u.xbm_s.xbm_previous
+#  define BmRARE(sv)		((XPVMG*) SvANY(sv))->xnv_u.xbm_s.xbm_rare
+#  define BmUSEFUL(sv)		((XPVMG*) SvANY(sv))->xnv_u.xbm_s.xbm_useful
+#  define BmPREVIOUS(sv)	((XPVMG*) SvANY(sv))->xiv_u.xivu_uv
 
 #endif
 
@@ -1325,6 +1329,7 @@ the scalar's value cannot change unless written to.
 #define LvTARG(sv)	((XPVLV*)  SvANY(sv))->xlv_targ
 #define LvTARGOFF(sv)	((XPVLV*)  SvANY(sv))->xlv_targoff
 #define LvTARGLEN(sv)	((XPVLV*)  SvANY(sv))->xlv_targlen
+#define LvFLAGS(sv)	((XPVLV*)  SvANY(sv))->xlv_flags
 
 #define IoIFP(sv)	(sv)->sv_u.svu_fp
 #define IoOFP(sv)	((XPVIO*)  SvANY(sv))->xio_ofp
@@ -1357,22 +1362,26 @@ the scalar's value cannot change unless written to.
 
 /*
 =for apidoc Am|bool|SvTAINTED|SV* sv
-Checks to see if an SV is tainted. Returns TRUE if it is, FALSE if
+Checks to see if an SV is tainted.  Returns TRUE if it is, FALSE if
 not.
 
 =for apidoc Am|void|SvTAINTED_on|SV* sv
 Marks an SV as tainted if tainting is enabled.
 
 =for apidoc Am|void|SvTAINTED_off|SV* sv
-Untaints an SV. Be I<very> careful with this routine, as it short-circuits
-some of Perl's fundamental security features. XS module authors should not
+Untaints an SV.  Be I<very> careful with this routine, as it short-circuits
+some of Perl's fundamental security features.  XS module authors should not
 use this function unless they fully understand all the implications of
 unconditionally untainting the value. Untainting should be done in the
 standard perl fashion, via a carefully crafted regexp, rather than directly
 untainting variables.
 
 =for apidoc Am|void|SvTAINT|SV* sv
-Taints an SV if tainting is enabled.
+Taints an SV if tainting is enabled, and if some input to the current
+expression is tainted--usually a variable, but possibly also implicit
+inputs such as locale settings.  C<SvTAINT> propagates that taintedness to
+the outputs of an expression in a pessimistic fashion; i.e., without paying
+attention to precisely which outputs are influenced by which inputs.
 
 =cut
 */
@@ -1400,18 +1409,18 @@ directly.
 =for apidoc Am|char*|SvPV_force_nomg|SV* sv|STRLEN len
 Like C<SvPV> but will force the SV into containing just a string
 (C<SvPOK_only>).  You want force if you are going to update the C<SvPVX>
-directly. Doesn't process magic.
+directly.  Doesn't process magic.
 
 =for apidoc Am|char*|SvPV|SV* sv|STRLEN len
 Returns a pointer to the string in the SV, or a stringified form of
 the SV if the SV does not contain a string.  The SV may cache the
-stringified version becoming C<SvPOK>.  Handles 'get' magic. See also
+stringified version becoming C<SvPOK>.  Handles 'get' magic.  See also
 C<SvPVx> for a version which guarantees to evaluate sv only once.
 
 =for apidoc Am|char*|SvPVx|SV* sv|STRLEN len
 A version of C<SvPV> which guarantees to evaluate C<sv> only once.
 Only use this if C<sv> is an expression with side effects, otherwise use the
-more efficient C<SvPVX>.
+more efficient C<SvPV>.
 
 =for apidoc Am|char*|SvPV_nomg|SV* sv|STRLEN len
 Like C<SvPV> but doesn't process magic.
@@ -1425,27 +1434,29 @@ stringified form becoming C<SvPOK>.  Handles 'get' magic.
 Like C<SvPV_nolen> but doesn't process magic.
 
 =for apidoc Am|IV|SvIV|SV* sv
-Coerces the given SV to an integer and returns it. See C<SvIVx> for a
+Coerces the given SV to an integer and returns it.  See C<SvIVx> for a
 version which guarantees to evaluate sv only once.
 
 =for apidoc Am|IV|SvIV_nomg|SV* sv
 Like C<SvIV> but doesn't process magic.
 
 =for apidoc Am|IV|SvIVx|SV* sv
-Coerces the given SV to an integer and returns it. Guarantees to evaluate
-C<sv> only once. Only use this if C<sv> is an expression with side effects,
+Coerces the given SV to an integer and returns it.
+Guarantees to evaluate C<sv> only once.  Only use
+this if C<sv> is an expression with side effects,
 otherwise use the more efficient C<SvIV>.
 
 =for apidoc Am|NV|SvNV|SV* sv
-Coerce the given SV to a double and return it. See C<SvNVx> for a version
+Coerce the given SV to a double and return it.  See C<SvNVx> for a version
 which guarantees to evaluate sv only once.
 
 =for apidoc Am|NV|SvNV_nomg|SV* sv
 Like C<SvNV> but doesn't process magic.
 
 =for apidoc Am|NV|SvNVx|SV* sv
-Coerces the given SV to a double and returns it. Guarantees to evaluate
-C<sv> only once. Only use this if C<sv> is an expression with side effects,
+Coerces the given SV to a double and returns it.
+Guarantees to evaluate C<sv> only once.  Only use
+this if C<sv> is an expression with side effects,
 otherwise use the more efficient C<SvNV>.
 
 =for apidoc Am|UV|SvUV|SV* sv
@@ -1456,8 +1467,9 @@ for a version which guarantees to evaluate sv only once.
 Like C<SvUV> but doesn't process magic.
 
 =for apidoc Am|UV|SvUVx|SV* sv
-Coerces the given SV to an unsigned integer and returns it. Guarantees to
-C<sv> only once. Only use this if C<sv> is an expression with side effects,
+Coerces the given SV to an unsigned integer and
+returns it.  Guarantees to C<sv> only once.  Only
+use this if C<sv> is an expression with side effects,
 otherwise use the more efficient C<SvUV>.
 
 =for apidoc Am|bool|SvTRUE|SV* sv
@@ -1509,9 +1521,9 @@ Guarantees to evaluate sv only once; use the more efficient C<SvPVbyte>
 otherwise.
 
 =for apidoc Am|bool|SvIsCOW|SV* sv
-Returns a boolean indicating whether the SV is Copy-On-Write. (either shared
+Returns a boolean indicating whether the SV is Copy-On-Write (either shared
 hash key scalars, or full Copy On Write scalars if 5.9.0 is configured for
-COW)
+COW).
 
 =for apidoc Am|bool|SvIsCOW_shared_hash|SV* sv
 Returns a boolean indicating whether the SV is Copy-On-Write shared hash key
@@ -1531,7 +1543,7 @@ Like C<sv_catsv> but doesn't process magic.
 
 =for apidoc Amdb|STRLEN|sv_utf8_upgrade_nomg|NN SV *sv
 
-Like sv_utf8_upgrade, but doesn't do magic on C<sv>
+Like sv_utf8_upgrade, but doesn't do magic on C<sv>.
 
 =cut
 */
@@ -1735,8 +1747,9 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>
 #  define SvTRUEx(sv) ((PL_Sv = (sv)), SvTRUE(PL_Sv))
 #endif /* __GNU__ */
 
-#define SvIsCOW(sv)		((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \
-				    (SVf_FAKE | SVf_READONLY))
+#define SvIsCOW(sv)	((SvFLAGS(sv) & (SVf_FAKE | SVf_READONLY)) == \
+			   (SVf_FAKE | SVf_READONLY) && !isGV_with_GP(sv) \
+			   && SvTYPE(sv) != SVt_REGEXP)
 #define SvIsCOW_shared_hash(sv)	(SvIsCOW(sv) && SvLEN(sv) == 0)
 
 #define SvSHARED_HEK_FROM_PV(pvx) \
@@ -1765,6 +1778,12 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>
 /* if (after resolving magic etc), the SV is found to be overloaded,
  * don't call the overload magic, just return as-is */
 #define SV_SKIP_OVERLOAD	8192
+/* It is not yet clear whether we want this as an API, or what the
+ * constants should be named. */
+#ifdef PERL_CORE
+# define SV_CATBYTES		16384
+# define SV_CATUTF8		32768
+#endif
 
 /* The core is safe for this COW optimisation. XS code on CPAN may not be.
    So only default to doing the COW setup if we're in the core.
@@ -1802,7 +1821,7 @@ Like sv_utf8_upgrade, but doesn't do magic on C<sv>
 #else
 #  define SvRELEASE_IVX(sv)   0
 /* This little game brought to you by the need to shut this warning up:
-mg.c: In function `Perl_magic_get':
+mg.c: In function 'Perl_magic_get':
 mg.c:1024: warning: left-hand operand of comma expression has no effect
 */
 #  define SvRELEASE_IVX_(sv)  /**/
@@ -1898,7 +1917,7 @@ more than once.
 
 =for apidoc Am|void|SvSetSV_nosteal|SV* dsv|SV* ssv
 Calls a non-destructive version of C<sv_setsv> if dsv is not the same as
-ssv. May evaluate arguments more than once.
+ssv.  May evaluate arguments more than once.
 
 =for apidoc Am|void|SvSetMagicSV|SV* dsb|SV* ssv
 Like C<SvSetSV>, but does any set magic required afterwards.
@@ -1934,7 +1953,7 @@ Returns a pointer to the character buffer.
 #define SvUNLOCK(sv) PL_unlockhook(aTHX_ sv)
 #define SvDESTROYABLE(sv) PL_destroyhook(aTHX_ sv)
 
-#define SvGETMAGIC(x) STMT_START { if (SvGMAGICAL(x)) mg_get(x); } STMT_END
+#define SvGETMAGIC(x) ((void)(SvGMAGICAL(x) && mg_get(x)))
 #define SvSETMAGIC(x) STMT_START { if (SvSMAGICAL(x)) mg_set(x); } STMT_END
 
 #define SvSetSV_and(dst,src,finally) \
@@ -1971,6 +1990,16 @@ Returns a pointer to the character buffer.
 
 #define SvIMMORTAL(sv) ((sv)==&PL_sv_undef || (sv)==&PL_sv_yes || (sv)==&PL_sv_no || (sv)==&PL_sv_placeholder)
 
+/*
+=for apidoc Am|SV *|boolSV|bool b
+
+Returns a true SV if C<b> is a true value, or a false SV if C<b> is 0.
+
+See also C<PL_sv_yes> and C<PL_sv_no>.
+
+=cut
+*/
+
 #define boolSV(b) ((b) ? &PL_sv_yes : &PL_sv_no)
 
 #define isGV(sv) (SvTYPE(sv) == SVt_PVGV)
@@ -2027,9 +2056,9 @@ C<SvUTF8_on> on the new SV.  Implemented as a wrapper around C<newSVpvn_flags>.
 
 Reads into I<len> the offset from SvPVX back to the true start of the
 allocated buffer, which will be non-zero if C<sv_chop> has been used to
-efficiently remove characters from start of the buffer. Implemented as a
+efficiently remove characters from start of the buffer.  Implemented as a
 macro, which takes the address of I<len>, which must be of type C<STRLEN>.
-Evaluates I<sv> more than once. Sets I<len> to 0 if C<SvOOK(sv)> is false.
+Evaluates I<sv> more than once.  Sets I<len> to 0 if C<SvOOK(sv)> is false.
 
 =cut
 */