X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=universal.c;h=52395cce691362d5abcdf3390436256c9e4b1018;hb=b5b5a8f0780c94d6973849925747efe92490a7da;hp=4d44aa7577c12f25dbf48093362f01c46064c6c6;hpb=4a818d86735b88cd762faade9872a9c2e89ab057;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/universal.c b/universal.c
index 4d44aa7..52395cc 100644
--- a/universal.c
+++ b/universal.c
@@ -1,7 +1,7 @@
 /*    universal.c
  *
  *    Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
- *    2005, by Larry Wall and others
+ *    2005, 2006, by Larry Wall and others
  *
  *    You may distribute under the terms of either the GNU General Public
  *    License or the Artistic License, as specified in the README file.
@@ -31,46 +31,50 @@
  * The main guts of traverse_isa was actually copied from gv_fetchmeth
  */
 
-STATIC SV *
-S_isa_lookup(pTHX_ HV *stash, const char *name, HV* name_stash,
+STATIC bool
+S_isa_lookup(pTHX_ HV *stash, const char *name, const HV* const name_stash,
              int len, int level)
 {
+    dVAR;
     AV* av;
     GV* gv;
     GV** gvp;
-    HV* hv = Nullhv;
-    SV* subgen = Nullsv;
+    HV* hv = NULL;
+    SV* subgen = NULL;
     const char *hvname;
 
     /* A stash/class can go by many names (ie. User == main::User), so 
        we compare the stash itself just in case */
-    if (name_stash && (stash == name_stash))
-        return &PL_sv_yes;
+    if (name_stash && ((const HV *)stash == name_stash))
+        return TRUE;
 
     hvname = HvNAME_get(stash);
 
     if (strEQ(hvname, name))
-	return &PL_sv_yes;
+	return TRUE;
 
     if (strEQ(name, "UNIVERSAL"))
-	return &PL_sv_yes;
+	return TRUE;
 
     if (level > 100)
 	Perl_croak(aTHX_ "Recursive inheritance detected in package '%s'",
 		   hvname);
 
-    gvp = (GV**)hv_fetch(stash, "::ISA::CACHE::", 14, FALSE);
+    gvp = (GV**)hv_fetchs(stash, "::ISA::CACHE::", FALSE);
 
     if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (subgen = GvSV(gv))
 	&& (hv = GvHV(gv)))
     {
 	if (SvIV(subgen) == (IV)PL_sub_generation) {
-	    SV* sv;
 	    SV** const svp = (SV**)hv_fetch(hv, name, len, FALSE);
-	    if (svp && (sv = *svp) != (SV*)&PL_sv_undef) {
-	        DEBUG_o( Perl_deb(aTHX_ "Using cached ISA %s for package %s\n",
-				  name, hvname) );
-		return sv;
+	    if (svp) {
+		SV * const sv = *svp;
+#ifdef DEBUGGING
+		if (sv != &PL_sv_undef)
+		    DEBUG_o( Perl_deb(aTHX_ "Using cached ISA %s for package %s\n",
+				    name, hvname) );
+#endif
+		return (sv == &PL_sv_yes);
 	    }
 	}
 	else {
@@ -81,11 +85,11 @@ S_isa_lookup(pTHX_ HV *stash, const char *name, HV* name_stash,
 	}
     }
 
-    gvp = (GV**)hv_fetch(stash,"ISA",3,FALSE);
+    gvp = (GV**)hv_fetchs(stash, "ISA", FALSE);
 
     if (gvp && (gv = *gvp) != (GV*)&PL_sv_undef && (av = GvAV(gv))) {
 	if (!hv || !subgen) {
-	    gvp = (GV**)hv_fetch(stash, "::ISA::CACHE::", 14, TRUE);
+	    gvp = (GV**)hv_fetchs(stash, "::ISA::CACHE::", TRUE);
 
 	    gv = *gvp;
 
@@ -110,19 +114,18 @@ S_isa_lookup(pTHX_ HV *stash, const char *name, HV* name_stash,
 		    if (ckWARN(WARN_MISC))
 			Perl_warner(aTHX_ packWARN(WARN_SYNTAX),
 				    "Can't locate package %"SVf" for @%s::ISA",
-				    sv, hvname);
+				    (void*)sv, hvname);
 		    continue;
 		}
-		if (&PL_sv_yes == isa_lookup(basestash, name, name_stash, 
-                                             len, level + 1)) {
+		if (isa_lookup(basestash, name, name_stash, len, level + 1)) {
 		    (void)hv_store(hv,name,len,&PL_sv_yes,0);
-		    return &PL_sv_yes;
+		    return TRUE;
 		}
 	    }
 	    (void)hv_store(hv,name,len,&PL_sv_no,0);
 	}
     }
-    return &PL_sv_no;
+    return FALSE;
 }
 
 /*
@@ -130,9 +133,9 @@ S_isa_lookup(pTHX_ HV *stash, const char *name, HV* name_stash,
 
 =for apidoc sv_derived_from
 
-Returns a boolean indicating whether the SV is derived from the specified
-class.  This is the function that implements C<UNIVERSAL::isa>.  It works
-for class names as well as for objects.
+Returns a boolean indicating whether the SV is derived from the specified class
+I<at the C level>.  To check derivation at the Perl level, call C<isa()> as a
+normal Perl method.
 
 =cut
 */
@@ -140,35 +143,86 @@ for class names as well as for objects.
 bool
 Perl_sv_derived_from(pTHX_ SV *sv, const char *name)
 {
-    const char *type = Nullch;
-    HV *stash = Nullhv;
-    HV *name_stash;
+    dVAR;
+    HV *stash;
 
     SvGETMAGIC(sv);
 
     if (SvROK(sv)) {
+	const char *type;
         sv = SvRV(sv);
         type = sv_reftype(sv,0);
-        if (SvOBJECT(sv))
-            stash = SvSTASH(sv);
+	if (type && strEQ(type,name))
+	    return TRUE;
+	stash = SvOBJECT(sv) ? SvSTASH(sv) : NULL;
     }
     else {
         stash = gv_stashsv(sv, FALSE);
     }
 
-    name_stash = gv_stashpv(name, FALSE);
+    if (stash) {
+	HV * const name_stash = gv_stashpv(name, FALSE);
+	return isa_lookup(stash, name, name_stash, strlen(name), 0);
+    }
+    else
+	return FALSE;
 
-    return (type && strEQ(type,name)) ||
-            (stash && isa_lookup(stash, name, name_stash, strlen(name), 0) 
-             == &PL_sv_yes)
-        ? TRUE
-        : FALSE ;
 }
 
+/*
+=for apidoc sv_does
+
+Returns a boolean indicating whether the SV performs a specific, named role.
+The SV can be a Perl object or the name of a Perl class.
+
+=cut
+*/
+
 #include "XSUB.h"
 
+bool
+Perl_sv_does(pTHX_ SV *sv, const char *name)
+{
+    const char *classname;
+    bool does_it;
+
+    dSP;
+    ENTER;
+    SAVETMPS;
+
+    SvGETMAGIC(sv);
+
+    if (!SvOK(sv) || !(SvROK(sv) || (SvPOK(sv) && SvCUR(sv))
+		|| (SvGMAGICAL(sv) && SvPOKp(sv) && SvCUR(sv))))
+	return FALSE;
+
+    if (sv_isobject(sv)) {
+	classname = sv_reftype(SvRV(sv),TRUE);
+    } else {
+	classname = SvPV(sv,PL_na);
+    }
+
+    if (strEQ(name,classname))
+	return TRUE;
+
+    PUSHMARK(SP);
+    XPUSHs(sv);
+    XPUSHs(sv_2mortal(newSVpv(name, 0)));
+    PUTBACK;
+
+    call_method("isa", G_SCALAR);
+    SPAGAIN;
+
+    does_it = SvTRUE( TOPs );
+    FREETMPS;
+    LEAVE;
+
+    return does_it;
+}
+
 PERL_XS_EXPORT_C void XS_UNIVERSAL_isa(pTHX_ CV *cv);
 PERL_XS_EXPORT_C void XS_UNIVERSAL_can(pTHX_ CV *cv);
+PERL_XS_EXPORT_C void XS_UNIVERSAL_DOES(pTHX_ CV *cv);
 PERL_XS_EXPORT_C void XS_UNIVERSAL_VERSION(pTHX_ CV *cv);
 XS(XS_version_new);
 XS(XS_version_stringify);
@@ -199,15 +253,17 @@ XS(XS_Regexp_DESTROY);
 XS(XS_Internals_hash_seed);
 XS(XS_Internals_rehash_seed);
 XS(XS_Internals_HvREHASH);
-XS(XS_utf8_SWASHGET_heavy);
+XS(XS_Internals_inc_sub_generation);
 
 void
 Perl_boot_core_UNIVERSAL(pTHX)
 {
-    const char file[] = __FILE__;
+    dVAR;
+    static const char file[] = __FILE__;
 
     newXS("UNIVERSAL::isa",             XS_UNIVERSAL_isa,         file);
     newXS("UNIVERSAL::can",             XS_UNIVERSAL_can,         file);
+    newXS("UNIVERSAL::DOES",            XS_UNIVERSAL_DOES,        file);
     newXS("UNIVERSAL::VERSION", 	XS_UNIVERSAL_VERSION, 	  file);
     {
 	/* register the overloading (type 'A') magic */
@@ -248,12 +304,14 @@ Perl_boot_core_UNIVERSAL(pTHX)
     newXSproto("Internals::hash_seed",XS_Internals_hash_seed, file, "");
     newXSproto("Internals::rehash_seed",XS_Internals_rehash_seed, file, "");
     newXSproto("Internals::HvREHASH", XS_Internals_HvREHASH, file, "\\%");
-    newXS("utf8::SWASHGET_heavy", XS_utf8_SWASHGET_heavy, file);
+    newXSproto("Internals::inc_sub_generation",XS_Internals_inc_sub_generation,
+	       file, "");
 }
 
 
 XS(XS_UNIVERSAL_isa)
 {
+    dVAR;
     dXSARGS;
 
     if (items != 2)
@@ -277,6 +335,7 @@ XS(XS_UNIVERSAL_isa)
 
 XS(XS_UNIVERSAL_can)
 {
+    dVAR;
     dXSARGS;
     SV   *sv;
     const char *name;
@@ -316,8 +375,28 @@ XS(XS_UNIVERSAL_can)
     XSRETURN(1);
 }
 
+XS(XS_UNIVERSAL_DOES)
+{
+    dVAR;
+    dXSARGS;
+
+    if (items != 2)
+	Perl_croak(aTHX_ "Usage: invocant->does(kind)");
+    else {
+	SV * const sv = ST(0);
+	const char *name;
+
+	name = SvPV_nolen_const(ST(1));
+	if (sv_does( sv, name ))
+	    XSRETURN_YES;
+
+	XSRETURN_NO;
+    }
+}
+
 XS(XS_UNIVERSAL_VERSION)
 {
+    dVAR;
     dXSARGS;
     HV *pkg;
     GV **gvp;
@@ -335,7 +414,7 @@ XS(XS_UNIVERSAL_VERSION)
         pkg = gv_stashsv(ST(0), FALSE);
     }
 
-    gvp = pkg ? (GV**)hv_fetch(pkg,"VERSION",7,FALSE) : Null(GV**);
+    gvp = pkg ? (GV**)hv_fetchs(pkg, "VERSION", FALSE) : NULL;
 
     if (gvp && isGV(gv = *gvp) && (sv = GvSV(gv)) && SvOK(sv)) {
         SV * const nsv = sv_newmortal();
@@ -343,7 +422,7 @@ XS(XS_UNIVERSAL_VERSION)
         sv = nsv;
 	if ( !sv_derived_from(sv, "version"))
 	    upg_version(sv);
-        undef = Nullch;
+        undef = NULL;
     }
     else {
         sv = (SV*)&PL_sv_undef;
@@ -376,8 +455,11 @@ XS(XS_UNIVERSAL_VERSION)
 
 	if ( vcmp( req, sv ) > 0 )
 	    Perl_croak(aTHX_ "%s version %"SVf" (%"SVf") required--"
-		    "this is only version %"SVf" (%"SVf")", HvNAME_get(pkg),
-		    vnumify(req),vnormal(req),vnumify(sv),vnormal(sv));
+		       "this is only version %"SVf" (%"SVf")", HvNAME_get(pkg),
+		       (void*)vnumify(req),
+		       (void*)vnormal(req),
+		       (void*)vnumify(sv),
+		       (void*)vnormal(sv));
     }
 
     if ( SvOK(sv) && sv_derived_from(sv, "version") ) {
@@ -391,6 +473,7 @@ XS(XS_UNIVERSAL_VERSION)
 
 XS(XS_version_new)
 {
+    dVAR;
     dXSARGS;
     if (items > 3)
 	Perl_croak(aTHX_ "Usage: version::new(class, version)");
@@ -403,17 +486,10 @@ XS(XS_version_new)
 		? HvNAME(SvSTASH(SvRV(ST(0))))
 		: (char *)SvPV_nolen(ST(0));
 
-	if ( items == 1 ) {
-	    /* no parameter provided */
-	    if ( sv_isobject(ST(0)) ) {
-		/* copy existing object */
-		vs = ST(0);
-	    }
-	    else {
-		/* create empty object */
-		vs = sv_newmortal();
-		sv_setpvn(vs,"",0);
-	    }
+	if ( items == 1 || vs == &PL_sv_undef ) { /* no param or explicit undef */
+	    /* create empty object */
+	    vs = sv_newmortal();
+	    sv_setpvn(vs,"",0);
 	}
 	else if ( items == 3 ) {
 	    vs = sv_newmortal();
@@ -432,6 +508,7 @@ XS(XS_version_new)
 
 XS(XS_version_stringify)
 {
+     dVAR;
      dXSARGS;
      if (items < 1)
 	  Perl_croak(aTHX_ "Usage: version::stringify(lobj, ...)");
@@ -454,6 +531,7 @@ XS(XS_version_stringify)
 
 XS(XS_version_numify)
 {
+     dVAR;
      dXSARGS;
      if (items < 1)
 	  Perl_croak(aTHX_ "Usage: version::numify(lobj, ...)");
@@ -476,6 +554,7 @@ XS(XS_version_numify)
 
 XS(XS_version_normal)
 {
+     dVAR;
      dXSARGS;
      if (items < 1)
 	  Perl_croak(aTHX_ "Usage: version::normal(lobj, ...)");
@@ -498,6 +577,7 @@ XS(XS_version_normal)
 
 XS(XS_version_vcmp)
 {
+     dVAR;
      dXSARGS;
      if (items < 1)
 	  Perl_croak(aTHX_ "Usage: version::vcmp(lobj, ...)");
@@ -542,13 +622,14 @@ XS(XS_version_vcmp)
 
 XS(XS_version_boolean)
 {
-     dXSARGS;
-     if (items < 1)
-	  Perl_croak(aTHX_ "Usage: version::boolean(lobj, ...)");
-     SP -= items;
+    dVAR;
+    dXSARGS;
+    if (items < 1)
+	Perl_croak(aTHX_ "Usage: version::boolean(lobj, ...)");
+    SP -= items;
     if (sv_derived_from(ST(0), "version")) {
 	SV * const lobj = SvRV(ST(0));
-	SV * const rs = newSViv( vcmp(lobj,new_version(newSVpvn("0",1))) );
+	SV * const rs = newSViv( vcmp(lobj,new_version(newSVpvs("0"))) );
 	PUSHs(sv_2mortal(rs));
 	PUTBACK;
 	return;
@@ -559,6 +640,7 @@ XS(XS_version_boolean)
 
 XS(XS_version_noop)
 {
+    dVAR;
     dXSARGS;
     if (items < 1)
 	Perl_croak(aTHX_ "Usage: version::noop(lobj, ...)");
@@ -573,6 +655,7 @@ XS(XS_version_noop)
 
 XS(XS_version_is_alpha)
 {
+    dVAR;
     dXSARGS;
     if (items != 1)
 	Perl_croak(aTHX_ "Usage: version::is_alpha(lobj)");
@@ -592,6 +675,7 @@ XS(XS_version_is_alpha)
 
 XS(XS_version_qv)
 {
+    dVAR;
     dXSARGS;
     if (items != 1)
 	Perl_croak(aTHX_ "Usage: version::qv(ver)");
@@ -604,7 +688,13 @@ XS(XS_version_qv)
 	    if ( SvNOK(ver) ) /* may get too much accuracy */
 	    {
 		char tbuf[64];
-		const STRLEN len = my_sprintf(tbuf,"%.9"NVgf, SvNVX(ver));
+#ifdef USE_LOCALE_NUMERIC
+		char *loc = setlocale(LC_NUMERIC, "C");
+#endif
+		const STRLEN len = my_snprintf(tbuf, sizeof(tbuf), "%.9"NVgf, SvNVX(ver));
+#ifdef USE_LOCALE_NUMERIC
+		setlocale(LC_NUMERIC, loc);
+#endif
 		version = savepvn(tbuf, len);
 	    }
 	    else
@@ -628,6 +718,7 @@ XS(XS_version_qv)
 
 XS(XS_utf8_is_utf8)
 {
+     dVAR;
      dXSARGS;
      if (items != 1)
 	  Perl_croak(aTHX_ "Usage: utf8::is_utf8(sv)");
@@ -643,6 +734,7 @@ XS(XS_utf8_is_utf8)
 
 XS(XS_utf8_valid)
 {
+     dVAR;
      dXSARGS;
      if (items != 1)
 	  Perl_croak(aTHX_ "Usage: utf8::valid(sv)");
@@ -660,6 +752,7 @@ XS(XS_utf8_valid)
 
 XS(XS_utf8_encode)
 {
+    dVAR;
     dXSARGS;
     if (items != 1)
 	Perl_croak(aTHX_ "Usage: utf8::encode(sv)");
@@ -669,6 +762,7 @@ XS(XS_utf8_encode)
 
 XS(XS_utf8_decode)
 {
+    dVAR;
     dXSARGS;
     if (items != 1)
 	Perl_croak(aTHX_ "Usage: utf8::decode(sv)");
@@ -683,6 +777,7 @@ XS(XS_utf8_decode)
 
 XS(XS_utf8_upgrade)
 {
+    dVAR;
     dXSARGS;
     if (items != 1)
 	Perl_croak(aTHX_ "Usage: utf8::upgrade(sv)");
@@ -699,6 +794,7 @@ XS(XS_utf8_upgrade)
 
 XS(XS_utf8_downgrade)
 {
+    dVAR;
     dXSARGS;
     if (items < 1 || items > 2)
 	Perl_croak(aTHX_ "Usage: utf8::downgrade(sv, failok=0)");
@@ -715,6 +811,7 @@ XS(XS_utf8_downgrade)
 
 XS(XS_utf8_native_to_unicode)
 {
+ dVAR;
  dXSARGS;
  const UV uv = SvUV(ST(0));
 
@@ -727,6 +824,7 @@ XS(XS_utf8_native_to_unicode)
 
 XS(XS_utf8_unicode_to_native)
 {
+ dVAR;
  dXSARGS;
  const UV uv = SvUV(ST(0));
 
@@ -739,6 +837,7 @@ XS(XS_utf8_unicode_to_native)
 
 XS(XS_Internals_SvREADONLY)	/* This is dangerous stuff. */
 {
+    dVAR;
     dXSARGS;
     SV * const sv = SvRV(ST(0));
 
@@ -764,6 +863,7 @@ XS(XS_Internals_SvREADONLY)	/* This is dangerous stuff. */
 
 XS(XS_Internals_SvREFCNT)	/* This is dangerous stuff. */
 {
+    dVAR;
     dXSARGS;
     SV * const sv = SvRV(ST(0));
 
@@ -779,6 +879,7 @@ XS(XS_Internals_SvREFCNT)	/* This is dangerous stuff. */
 
 XS(XS_Internals_hv_clear_placehold)
 {
+    dVAR;
     dXSARGS;
 
     if (items != 1)
@@ -792,11 +893,13 @@ XS(XS_Internals_hv_clear_placehold)
 
 XS(XS_Regexp_DESTROY)
 {
+    PERL_UNUSED_CONTEXT;
     PERL_UNUSED_ARG(cv);
 }
 
 XS(XS_PerlIO_get_layers)
 {
+    dVAR;
     dXSARGS;
     if (items < 1 || items % 2 == 0)
 	Perl_croak(aTHX_ "Usage: PerlIO_get_layers(filehandle[,args])");
@@ -853,7 +956,7 @@ XS(XS_PerlIO_get_layers)
 	     if (SvROK(sv) && isGV(SvRV(sv)))
 		  gv = (GV*)SvRV(sv);
 	     else if (SvPOKp(sv))
-		  gv = gv_fetchsv(sv, FALSE, SVt_PVIO);
+		  gv = gv_fetchsv(sv, 0, SVt_PVIO);
 	}
 
 	if (gv && (io = GvIO(gv))) {
@@ -889,9 +992,11 @@ XS(XS_PerlIO_get_layers)
 		  else {
 		       if (namok && argok)
 			    XPUSHs(Perl_newSVpvf(aTHX_ "%"SVf"(%"SVf")",
-					       *namsvp, *argsvp));
+						 (void*)*namsvp,
+						 (void*)*argsvp));
 		       else if (namok)
-			    XPUSHs(Perl_newSVpvf(aTHX_ "%"SVf, *namsvp));
+			    XPUSHs(Perl_newSVpvf(aTHX_ "%"SVf,
+						 (void*)*namsvp));
 		       else
 			    XPUSHs(&PL_sv_undef);
 		       nitem++;
@@ -899,7 +1004,7 @@ XS(XS_PerlIO_get_layers)
 			    const IV flags = SvIVX(*flgsvp);
 
 			    if (flags & PERLIO_F_UTF8) {
-				 XPUSHs(newSVpvn("utf8", 4));
+				 XPUSHs(newSVpvs("utf8"));
 				 nitem++;
 			    }
 		       }
@@ -918,6 +1023,7 @@ XS(XS_PerlIO_get_layers)
 
 XS(XS_Internals_hash_seed)
 {
+    dVAR;
     /* Using dXSARGS would also have dITEM and dSP,
      * which define 2 unused local variables.  */
     dAXMARK;
@@ -928,6 +1034,7 @@ XS(XS_Internals_hash_seed)
 
 XS(XS_Internals_rehash_seed)
 {
+    dVAR;
     /* Using dXSARGS would also have dITEM and dSP,
      * which define 2 unused local variables.  */
     dAXMARK;
@@ -938,6 +1045,7 @@ XS(XS_Internals_rehash_seed)
 
 XS(XS_Internals_HvREHASH)	/* Subject to change  */
 {
+    dVAR;
     dXSARGS;
     if (SvROK(ST(0))) {
 	const HV * const hv = (HV *) SvRV(ST(0));
@@ -951,417 +1059,18 @@ XS(XS_Internals_HvREHASH)	/* Subject to change  */
     Perl_croak(aTHX_ "Internals::HvREHASH $hashref");
 }
 
-XS(XS_utf8_SWASHGET_heavy)
+XS(XS_Internals_inc_sub_generation)
 {
-    dXSARGS;
-    if (items != 4) {
-	Perl_croak(aTHX_
-	    "Usage: utf8::SWASHGET_heavy($self, $start, $len, DEBUG)");
-    }
-    {
-	SV* self    = ST(0);
-	const I32 i_start = (I32)SvIV(ST(1));
-	const I32 i_len   = (I32)SvIV(ST(2));
-	const I32 debug   = (I32)SvIV(ST(3));
-	U32 start = (U32)i_start;
-	U32 len   = (U32)i_len;
-
-	HV *hv;
-	SV **listsvp, **typesvp, **bitssvp, **nonesvp, **extssvp, *swatch;
-	U8 *l, *lend, *x, *xend, *s, *nextline;
-	STRLEN lcur, xcur, scur;
-	U8* typestr;
-	int typeto;
-	U32 bits, none, end, octets;
-
-	if (SvROK(self) && SvTYPE(SvRV(self))==SVt_PVHV)
-	    hv = (HV*)SvRV(self);
-	else
-	    Perl_croak(aTHX_ "hv is not a hash reference");
-
-	if (i_start < 0)
-	    Perl_croak(aTHX_ "SWASHGET negative start");
-	if (i_len < 0)
-	    Perl_croak(aTHX_ "SWASHGET negative len");
-
-	listsvp = hv_fetch(hv, "LIST", 4, FALSE);
-	typesvp = hv_fetch(hv, "TYPE", 4, FALSE);
-	bitssvp = hv_fetch(hv, "BITS", 4, FALSE);
-	nonesvp = hv_fetch(hv, "NONE", 4, FALSE);
-	extssvp = hv_fetch(hv, "EXTRAS", 6, FALSE);
-	typestr = SvPV_nolen(*typesvp);
-	typeto  = typestr[0] == 'T' && typestr[1] == 'o';
-	bits    = (U32)SvUV(*bitssvp);
-	none    = (U32)SvUV(*nonesvp);
-	end     = start + len;
-	octets  = bits >> 3; /* if bits == 1, then octets == 0 */
-
-	if (bits != 1 && bits != 8 && bits != 16 && bits != 32) {
-	    Perl_croak(aTHX_ "SWASHGET unknown bits %"UVuf, (UV)bits);
-	}
-	if (debug) {
-	    char* selfstr = SvPV_nolen(self);
-	    PerlIO_printf(Perl_error_log, "SWASHGET ");
-	    PerlIO_printf(Perl_error_log, "%s %"UVuf" %"UVuf" ",
-					  selfstr, (UV)start, (UV)len);
-	    PerlIO_printf(Perl_error_log, "[%s/%"UVuf"/%"UVuf"]\n",
-					  typestr, (UV)bits, (UV)none);
-	}
-
-	/* initialize $swatch */
-	swatch = newSVpvn("",0);
-	scur   = octets ? (len * octets) : (len + 7) / 8;
-	SvGROW(swatch, scur + 1);
-	s = (U8*)SvPVX(swatch);
-	if (octets && none) {
-	    const U8* e = s + scur;
-	    while (s < e) {
-		if (bits == 8)
-		    *s++ = (U8)(none & 0xff);
-		else if (bits == 16) {
-		    *s++ = (U8)((none >>  8) & 0xff);
-		    *s++ = (U8)( none        & 0xff);
-		}
-		else if (bits == 32) {
-		    *s++ = (U8)((none >> 24) & 0xff);
-		    *s++ = (U8)((none >> 16) & 0xff);
-		    *s++ = (U8)((none >>  8) & 0xff);
-		    *s++ = (U8)( none        & 0xff);
-		}
-	    }
-	    *s = '\0';
-	}
-	else {
-	    (void)memzero((U8*)s, scur + 1);
-	}
-	SvCUR_set(swatch, scur);
-	s = (U8*)SvPVX(swatch);
-
-	/* read $self->{LIST} */
-	l = (U8*)SvPV(*listsvp, lcur);
-	lend = l + lcur;
-	while (l < lend) {
-	    U32 min, max, val, key;
-	    STRLEN numlen;
-	    I32 flags = PERL_SCAN_SILENT_ILLDIGIT | PERL_SCAN_DISALLOW_PREFIX;
-
-	    nextline = (U8*)memchr(l, '\n', lend - l);
-
-	    numlen = lend - l;
-	    min = (U32)grok_hex(l, &numlen, &flags, NULL);
-	    if (numlen)
-		l += numlen;
-	    else if (nextline) {
-		l = nextline + 1; /* 1 is length of "\n" */
-		continue;
-	    }
-	    else {
-		l = lend; /* to the end of LIST, at which no \n */
-		break;
-	    }
-
-	    if (isBLANK(*l)) {
-		++l;
-		flags = PERL_SCAN_SILENT_ILLDIGIT | PERL_SCAN_DISALLOW_PREFIX;
-		numlen = lend - l;
-		max = (U32)grok_hex(l, &numlen, &flags, NULL);
-		if (numlen)
-		    l += numlen;
-		else
-		    max = min;
-
-		if (octets) {
-		    if (isBLANK(*l)) {
-			++l;
-			flags = PERL_SCAN_SILENT_ILLDIGIT |
-				PERL_SCAN_DISALLOW_PREFIX;
-			numlen = lend - l;
-			val = (U32)grok_hex(l, &numlen, &flags, NULL);
-			if (numlen)
-			    l += numlen;
-			else
-			    val = 0;
-		    }
-		    else {
-			val = 0;
-			if (typeto) {
-			    Perl_croak(aTHX_ "%s: illegal mapping '%s'",
-					     typestr, l);
-			}
-		    }
-		}
-	    }
-	    else {
-		max = min;
-		if (octets) {
-		    val = 0;
-		    if (typeto) {
-			Perl_croak(aTHX_ "%s: illegal mapping '%s'",
-					 typestr, l);
-		    }
-		}
-	    }
-
-	    if (nextline)
-		l = nextline + 1;
-	    else
-		l = lend;
-
-	    if (max < start)
-		continue;
-
-	    if (octets) {
-		if (debug) {
-		    PerlIO_printf(Perl_error_log,
-			"%"UVuf" %"UVuf" %"UVuf"\n",
-			(UV)min, (UV)max, (UV)val);
-		}
-		if (min < start) {
-		    if (!none || val < none) {
-			val += start - min;
-		    }
-		    min = start;
-		}
-		for (key = min; key <= max; key++) {
-		    U32 offset;
-		    if (key >= end)
-			goto go_out_list;
-		    if (debug) {
-			PerlIO_printf(Perl_error_log,
-				"%"UVuf" => %"UVuf"\n",
-				(UV)key, (UV)val);
-		    }
-
-		/* offset must be non-negative (start <= min <= key < end) */
-		    offset = (key - start) * octets;
-		    if (bits == 8)
-			s[offset] = (U8)(val & 0xff);
-		    else if (bits == 16) {
-			s[offset    ] = (U8)((val >>  8) & 0xff);
-			s[offset + 1] = (U8)( val        & 0xff);
-		    }
-		    else if (bits == 32) {
-			s[offset    ] = (U8)((val >> 24) & 0xff);
-			s[offset + 1] = (U8)((val >> 16) & 0xff);
-			s[offset + 2] = (U8)((val >>  8) & 0xff);
-			s[offset + 3] = (U8)( val        & 0xff);
-		    }
-
-		    if (!none || val < none)
-			++val;
-		}
-	    }
-	    else {
-		if (min < start)
-		    min = start;
-		for (key = min; key <= max; key++) {
-		    U32 offset = key - start;
-		    if (key >= end)
-			goto go_out_list;
-		    if (debug) {
-			PerlIO_printf(Perl_error_log,
-				"%"UVuf" => 1\n", (UV)key);
-		    }
-		    s[offset >> 3] |= 1 << (offset & 7);
-		}
-	    }
-	}
-    go_out_list:
-
-	/* read $self->{EXTRAS} */
-	x = (U8*)SvPV(*extssvp, xcur);
-	xend = x + xcur;
-	while (x < xend) {
-	    STRLEN namelen;
-	    U8 *namestr;
-	    SV** othersvp;
-	    U32 otherbits;
-
-	    U8 opc = *x++;
-	    if (opc == '\n')
-		continue;
-
-	    nextline = (U8*)memchr(x, '\n', xend - x);
-
-	    if (opc != '-' && opc != '+' && opc != '!' && opc != '&') {
-		if (nextline) {
-		    x = nextline + 1;
-		    continue;
-		}
-		else {
-		    x = xend;
-		    break;
-		}
-	    }
-
-	    namestr = x;
-
-	    if (nextline) {
-		namelen = nextline - namestr;
-		x = nextline + 1;
-	    }
-	    else {
-		namelen = xend - namestr;
-		x = xend;
-	    }
-
-	    if (debug) {
-		U8* tmpstr;
-		Newx(tmpstr, namelen + 1, U8);
-		Move(namestr, tmpstr, namelen, U8);
-		tmpstr[namelen] = '\0';
-		PerlIO_printf(Perl_error_log,
-			"INDIRECT %c %s\n", opc, tmpstr);
-		Safefree(tmpstr);
-	    }
-
-	    {
-		HV* otherhv;
-		SV **otherbitssvp;
-
-		othersvp = hv_fetch(hv, namestr, namelen, FALSE);
-		if (*othersvp && SvROK(*othersvp) &&
-				 SvTYPE(SvRV(*othersvp))==SVt_PVHV)
-		    otherhv = (HV*)SvRV(*othersvp);
-		else
-		    Perl_croak(aTHX_ "otherhv is not a hash reference");
-
-		otherbitssvp = hv_fetch(otherhv, "BITS", 4, FALSE);
-		otherbits = (U32)SvUV(*otherbitssvp);
-		if (bits < otherbits)
-		    Perl_croak(aTHX_ "SWASHGET size mismatch");
-	    }
-
-	    {
-		dSP;
-		ENTER;
-		SAVETMPS;
-		PUSHMARK(SP);
-		EXTEND(SP,3);
-		PUSHs(*othersvp);
-		PUSHs(sv_2mortal(newSViv(start)));
-		PUSHs(sv_2mortal(newSViv(len)));
-		PUTBACK;
-		if (call_method("SWASHGET", G_SCALAR)) {
-		    U8 *s, *o;
-		    STRLEN slen, olen;
-		    SV* tmpsv = *PL_stack_sp--;
-		    o = (U8*)SvPV(tmpsv, olen);
-
-		    if (!olen)
-			Perl_croak(aTHX_ "SWASHGET didn't return valid swatch");
-		    s = SvPV(swatch, slen);
-		    if (bits == 1 && otherbits == 1) {
-			if (slen != olen)
-			    Perl_croak(aTHX_ "SWASHGET length mismatch");
-
-			switch (opc) {
-			case '+':
-			    while (slen--)
-				*s++ |= *o++;
-			    break;
-			case '!':
-			    while (slen--)
-				*s++ |= ~*o++;
-			    break;
-			case '-':
-			    while (slen--)
-				*s++ &= ~*o++;
-			    break;
-			case '&':
-			    while (slen--)
-				*s++ &= *o++;
-			    break;
-			default:
-			    break;
-			}
-		    }
-		    else {
-			U32 otheroctets = otherbits / 8;
-			U32 offset = 0;
-			U8* send = s + slen;
-
-			while (s < send) {
-			    U32 val = 0;
-
-			    if (otherbits == 1) {
-				val = (o[offset >> 3] >> (offset & 7)) & 1;
-				++offset;
-			    }
-			    else {
-				U32 vlen = otheroctets;
-				val = *o++;
-				while (--vlen) {
-				    val <<= 8;
-				    val |= *o++;
-				}
-			    }
-
-			    if      (opc == '+' && val)
-				val = 1;
-			    else if (opc == '!' && !val)
-				val = 1;
-			    else if (opc == '-' && val)
-				val = 0;
-			    else if (opc == '&' && !val)
-				val = 0;
-			    else {
-				s += octets;
-				continue;
-			    }
-
-			    if (bits == 8)
-				*s++ = (U8)( val & 0xff);
-			    else if (bits == 16) {
-				*s++ = (U8)((val >>  8) & 0xff);
-				*s++ = (U8)( val        & 0xff);
-			    }
-			    else if (bits == 32) {
-				*s++ = (U8)((val >> 24) & 0xff);
-				*s++ = (U8)((val >> 16) & 0xff);
-				*s++ = (U8)((val >>  8) & 0xff);
-				*s++ = (U8)( val        & 0xff);
-			    }
-			}
-		    }
-		}
-		FREETMPS;
-		LEAVE;
-	    }
-	}
-
-	if (debug) {
-	    U8* s = (U8*)SvPVX(swatch);
-	    PerlIO_printf(Perl_error_log, "CELLS ");
-	    if (bits == 1) {
-		U32 key;
-		for (key = 0; key < len; key++) {
-		    int val = (s[key >> 3] >> (key & 7)) & 1;
-		    PerlIO_printf(Perl_error_log, val ? "1 " : "0 ");
-		}
-	    }
-	    else {
-		U8* send = s + len * octets;
-		while (s < send) {
-		    U32 vlen = octets;
-		    U32 val = *s++;
-		    while (--vlen) {
-			val <<= 8;
-			val |= *s++;
-		    }
-		    PerlIO_printf(Perl_error_log, "%"UVuf" ", (UV)val);
-		}
-	    }
-	    PerlIO_printf(Perl_error_log, "\n");
-	}
-
-	ST(0) = swatch;
-	sv_2mortal(ST(0));
-    }
-    XSRETURN(1);
+    dVAR;
+    /* Using dXSARGS would also have dITEM and dSP,
+     * which define 2 unused local variables.  */
+    dAXMARK;
+    PERL_UNUSED_ARG(cv);
+    PERL_UNUSED_VAR(mark);
+    ++PL_sub_generation;
+    XSRETURN_EMPTY;
 }
 
-
 /*
  * Local variables:
  * c-indentation-style: bsd