1			/*
     2			 * This file was generated automatically by ExtUtils::ParseXS version 2.10 from the
     3			 * contents of Dumper.xs. Do not edit this file, edit Dumper.xs instead.
     4			 *
     5			 *	ANY CHANGES MADE HERE WILL BE LOST! 
     6			 *
     7			 */
     8			
     9			#line 1 "Dumper.xs"
    10			#define PERL_NO_GET_CONTEXT
    11			#include "EXTERN.h"
    12			#include "perl.h"
    13			#include "XSUB.h"
    14			
    15			static I32 num_q (char *s, STRLEN slen);
    16			static I32 esc_q (char *dest, char *src, STRLEN slen);
    17			static I32 esc_q_utf8 (pTHX_ SV *sv, char *src, STRLEN slen);
    18			static SV *sv_x (pTHX_ SV *sv, const char *str, STRLEN len, I32 n);
    19			static I32 DD_dump (pTHX_ SV *val, const char *name, STRLEN namelen, SV *retval,
    20					    HV *seenhv, AV *postav, I32 *levelp, I32 indent,
    21					    SV *pad, SV *xpad, SV *apad, SV *sep, SV *pair,
    22					    SV *freezer, SV *toaster,
    23					    I32 purity, I32 deepcopy, I32 quotekeys, SV *bless,
    24					    I32 maxdepth, SV *sortkeys);
    25			
    26			#ifndef HvNAME_get
    27			#define HvNAME_get HvNAME
    28			#endif
    29			
    30			#if PERL_VERSION <= 6 /* Perl 5.6 and earlier */
    31			
    32			# ifdef EBCDIC
    33			#  define UNI_TO_NATIVE(ch) (((ch) > 255) ? (ch) : ASCII_TO_NATIVE(ch))
    34			# else
    35			#  define UNI_TO_NATIVE(ch) (ch)
    36			# endif
    37			
    38			UV
    39			Perl_utf8_to_uvchr(pTHX_ U8 *s, STRLEN *retlen)
    40			{
    41			    UV uv = utf8_to_uv(s, UTF8_MAXLEN, retlen,
    42			                    ckWARN(WARN_UTF8) ? 0 : UTF8_ALLOW_ANY);
    43			    return UNI_TO_NATIVE(uv);
    44			}
    45			
    46			# if !defined(PERL_IMPLICIT_CONTEXT)
    47			#  define utf8_to_uvchr	     Perl_utf8_to_uvchr
    48			# else
    49			#  define utf8_to_uvchr(a,b) Perl_utf8_to_uvchr(aTHX_ a,b)
    50			# endif
    51			
    52			#endif /* PERL_VERSION <= 6 */
    53			
    54			/* Changes in 5.7 series mean that now IOK is only set if scalar is
    55			   precisely integer but in 5.6 and earlier we need to do a more
    56			   complex test  */
    57			#if PERL_VERSION <= 6
    58			#define DD_is_integer(sv) (SvIOK(sv) && (SvIsUV(val) ? SvUV(sv) == SvNV(sv) : SvIV(sv) == SvNV(sv)))
    59			#else
    60			#define DD_is_integer(sv) SvIOK(sv)
    61			#endif
    62			
    63			/* does a string need to be protected? */
    64			static I32
    65			needs_quote(register char *s)
    66			{
    67			TOP:
    68			    if (s[0] == ':') {
    69				if (*++s) {
    70				    if (*s++ != ':')
    71					return 1;
    72				}
    73				else
    74				    return 1;
    75			    }
    76			    if (isIDFIRST(*s)) {
    77				while (*++s)
    78				    if (!isALNUM(*s)) {
    79					if (*s == ':')
    80					    goto TOP;
    81					else
    82					    return 1;
    83				    }
    84			    }
    85			    else
    86				return 1;
    87			    return 0;
    88			}
    89			
    90			/* count the number of "'"s and "\"s in string */
    91			static I32
    92			num_q(register char *s, register STRLEN slen)
    93			{
    94			    register I32 ret = 0;
    95			
    96			    while (slen > 0) {
    97				if (*s == '\'' || *s == '\\')
    98				    ++ret;
    99				++s;
   100				--slen;
   101			    }
   102			    return ret;
   103			}
   104			
   105			
   106			/* returns number of chars added to escape "'"s and "\"s in s */
   107			/* slen number of characters in s will be escaped */
   108			/* destination must be long enough for additional chars */
   109			static I32
   110			esc_q(register char *d, register char *s, register STRLEN slen)
   111			{
   112			    register I32 ret = 0;
   113			
   114			    while (slen > 0) {
   115				switch (*s) {
   116				case '\'':
   117				case '\\':
   118				    *d = '\\';
   119				    ++d; ++ret;
   120				default:
   121				    *d = *s;
   122				    ++d; ++s; --slen;
   123				    break;
   124				}
   125			    }
   126			    return ret;
   127			}
   128			
   129			static I32
   130			esc_q_utf8(pTHX_ SV* sv, register char *src, register STRLEN slen)
   131			{
   132			    char *s, *send, *r, *rstart;
   133			    STRLEN j, cur = SvCUR(sv);
   134			    /* Could count 128-255 and 256+ in two variables, if we want to
   135			       be like &qquote and make a distinction.  */
   136			    STRLEN grow = 0;	/* bytes needed to represent chars 128+ */
   137			    /* STRLEN topbit_grow = 0;	bytes needed to represent chars 128-255 */
   138			    STRLEN backslashes = 0;
   139			    STRLEN single_quotes = 0;
   140			    STRLEN qq_escapables = 0;	/* " $ @ will need a \ in "" strings.  */
   141			    STRLEN normal = 0;
   142			
   143			    /* this will need EBCDICification */
   144			    for (s = src, send = src + slen; s < send; s += UTF8SKIP(s)) {
   145			        UV k = utf8_to_uvchr((U8*)s, NULL);
   146			
   147			        if (k > 127) {
   148			            /* 4: \x{} then count the number of hex digits.  */
   149			            grow += 4 + (k <= 0xFF ? 2 : k <= 0xFFF ? 3 : k <= 0xFFFF ? 4 :
   150			#if UVSIZE == 4
   151			                8 /* We may allocate a bit more than the minimum here.  */
   152			#else
   153			                k <= 0xFFFFFFFF ? 8 : UVSIZE * 4
   154			#endif
   155			                );
   156			        } else if (k == '\\') {
   157			            backslashes++;
   158			        } else if (k == '\'') {
   159			            single_quotes++;
   160			        } else if (k == '"' || k == '$' || k == '@') {
   161			            qq_escapables++;
   162			        } else {
   163			            normal++;
   164			        }
   165			    }
   166			    if (grow) {
   167			        /* We have something needing hex. 3 is ""\0 */
   168			        sv_grow(sv, cur + 3 + grow + 2*backslashes + single_quotes
   169					+ 2*qq_escapables + normal);
   170			        rstart = r = SvPVX(sv) + cur;
   171			
   172			        *r++ = '"';
   173			
   174			        for (s = src; s < send; s += UTF8SKIP(s)) {
   175			            UV k = utf8_to_uvchr((U8*)s, NULL);
   176			
   177			            if (k == '"' || k == '\\' || k == '$' || k == '@') {
   178			                *r++ = '\\';
   179			                *r++ = (char)k;
   180			            }
   181			            else if (k < 0x80)
   182			                *r++ = (char)k;
   183			            else {
   184				      /* The return value of sprintf() is unportable.
   185				       * In modern systems it returns (int) the number of characters,
   186				       * but in older systems it might return (char*) the original
   187				       * buffer, or it might even be (void).  The easiest portable
   188				       * thing to do is probably use sprintf() in void context and
   189				       * then strlen(buffer) for the length.  The more proper way
   190				       * would of course be to figure out the prototype of sprintf.
   191				       * --jhi */
   192				        sprintf(r, "\\x{%"UVxf"}", k);
   193			                r += strlen(r);
   194			            }
   195			        }
   196			        *r++ = '"';
   197			    } else {
   198			        /* Single quotes.  */
   199			        sv_grow(sv, cur + 3 + 2*backslashes + 2*single_quotes
   200					+ qq_escapables + normal);
   201			        rstart = r = SvPVX(sv) + cur;
   202			        *r++ = '\'';
   203			        for (s = src; s < send; s ++) {
   204			            char k = *s;
   205			            if (k == '\'' || k == '\\')
   206			                *r++ = '\\';
   207			            *r++ = k;
   208			        }
   209			        *r++ = '\'';
   210			    }
   211			    *r = '\0';
   212			    j = r - rstart;
   213			    SvCUR_set(sv, cur + j);
   214			
   215			    return j;
   216			}
   217			
   218			/* append a repeated string to an SV */
   219			static SV *
   220			sv_x(pTHX_ SV *sv, const char *str, STRLEN len, I32 n)
   221			{
   222			    if (sv == Nullsv)
   223				sv = newSVpvn("", 0);
   224			    else
   225				assert(SvTYPE(sv) >= SVt_PV);
   226			
   227			    if (n > 0) {
   228				SvGROW(sv, len*n + SvCUR(sv) + 1);
   229				if (len == 1) {
   230				    char *start = SvPVX(sv) + SvCUR(sv);
   231				    SvCUR_set(sv, SvCUR(sv) + n);
   232				    start[n] = '\0';
   233				    while (n > 0)
   234					start[--n] = str[0];
   235				}
   236				else
   237				    while (n > 0) {
   238					sv_catpvn(sv, str, len);
   239					--n;
   240				    }
   241			    }
   242			    return sv;
   243			}
   244			
   245			/*
   246			 * This ought to be split into smaller functions. (it is one long function since
   247			 * it exactly parallels the perl version, which was one long thing for
   248			 * efficiency raisins.)  Ugggh!
   249			 */
   250			static I32
   251			DD_dump(pTHX_ SV *val, const char *name, STRLEN namelen, SV *retval, HV *seenhv,
   252				AV *postav, I32 *levelp, I32 indent, SV *pad, SV *xpad,
   253				SV *apad, SV *sep, SV *pair, SV *freezer, SV *toaster, I32 purity,
   254				I32 deepcopy, I32 quotekeys, SV *bless, I32 maxdepth, SV *sortkeys)
   255			{
   256			    char tmpbuf[128];
   257			    U32 i;
   258			    char *c, *r, *realpack, id[128];
   259			    SV **svp;
   260			    SV *sv, *ipad, *ival;
   261			    SV *blesspad = Nullsv;
   262			    AV *seenentry = Nullav;
   263			    char *iname;
   264			    STRLEN inamelen, idlen = 0;
   265			    U32 realtype;
   266			
   267			    if (!val)
   268				return 0;
   269			
   270			    realtype = SvTYPE(val);
   271			
   272			    if (SvGMAGICAL(val))
   273			        mg_get(val);
   274			    if (SvROK(val)) {
   275			
   276			        /* If a freeze method is provided and the object has it, call
   277			           it.  Warn on errors. */
   278				if (SvOBJECT(SvRV(val)) && freezer &&
   279				    SvPOK(freezer) && SvCUR(freezer) &&
   280			            gv_fetchmeth(SvSTASH(SvRV(val)), SvPVX_const(freezer), 
   281			                         SvCUR(freezer), -1) != NULL)
   282				{
   283				    dSP; ENTER; SAVETMPS; PUSHMARK(sp);
   284				    XPUSHs(val); PUTBACK;
   285				    i = perl_call_method(SvPVX_const(freezer), G_EVAL|G_VOID);
   286				    SPAGAIN;
   287				    if (SvTRUE(ERRSV))
   288					warn("WARNING(Freezer method call failed): %"SVf"", ERRSV);
   289				    PUTBACK; FREETMPS; LEAVE;
   290				}
   291				
   292				ival = SvRV(val);
   293				realtype = SvTYPE(ival);
   294			        (void) sprintf(id, "0x%"UVxf, PTR2UV(ival));
   295				idlen = strlen(id);
   296				if (SvOBJECT(ival))
   297				    realpack = HvNAME_get(SvSTASH(ival));
   298				else
   299				    realpack = Nullch;
   300			
   301				/* if it has a name, we need to either look it up, or keep a tab
   302				 * on it so we know when we hit it later
   303				 */
   304				if (namelen) {
   305				    if ((svp = hv_fetch(seenhv, id, idlen, FALSE))
   306					&& (sv = *svp) && SvROK(sv) && (seenentry = (AV*)SvRV(sv)))
   307				    {
   308					SV *othername;
   309					if ((svp = av_fetch(seenentry, 0, FALSE))
   310					    && (othername = *svp))
   311					{
   312					    if (purity && *levelp > 0) {
   313						SV *postentry;
   314						
   315						if (realtype == SVt_PVHV)
   316						    sv_catpvn(retval, "{}", 2);
   317						else if (realtype == SVt_PVAV)
   318						    sv_catpvn(retval, "[]", 2);
   319						else
   320						    sv_catpvn(retval, "do{my $o}", 9);
   321						postentry = newSVpvn(name, namelen);
   322						sv_catpvn(postentry, " = ", 3);
   323						sv_catsv(postentry, othername);
   324						av_push(postav, postentry);
   325					    }
   326					    else {
   327						if (name[0] == '@' || name[0] == '%') {
   328						    if ((SvPVX_const(othername))[0] == '\\' &&
   329							(SvPVX_const(othername))[1] == name[0]) {
   330							sv_catpvn(retval, SvPVX_const(othername)+1,
   331								  SvCUR(othername)-1);
   332						    }
   333						    else {
   334							sv_catpvn(retval, name, 1);
   335							sv_catpvn(retval, "{", 1);
   336							sv_catsv(retval, othername);
   337							sv_catpvn(retval, "}", 1);
   338						    }
   339						}
   340						else
   341						    sv_catsv(retval, othername);
   342					    }
   343					    return 1;
   344					}
   345					else {
   346					    warn("ref name not found for %s", id);
   347					    return 0;
   348					}
   349				    }
   350				    else {   /* store our name and continue */
   351					SV *namesv;
   352					if (name[0] == '@' || name[0] == '%') {
   353					    namesv = newSVpvn("\\", 1);
   354					    sv_catpvn(namesv, name, namelen);
   355					}
   356					else if (realtype == SVt_PVCV && name[0] == '*') {
   357					    namesv = newSVpvn("\\", 2);
   358					    sv_catpvn(namesv, name, namelen);
   359					    (SvPVX(namesv))[1] = '&';
   360					}
   361					else
   362					    namesv = newSVpvn(name, namelen);
   363					seenentry = newAV();
   364					av_push(seenentry, namesv);
   365					(void)SvREFCNT_inc(val);
   366					av_push(seenentry, val);
   367					(void)hv_store(seenhv, id, strlen(id),
   368						       newRV_inc((SV*)seenentry), 0);
   369					SvREFCNT_dec(seenentry);
   370				    }
   371				}
   372			
   373				if (realpack && *realpack == 'R' && strEQ(realpack, "Regexp")) {
   374				    STRLEN rlen;
   375				    char *rval = SvPV(val, rlen);
   376				    char *slash = strchr(rval, '/');
   377				    sv_catpvn(retval, "qr/", 3);
   378				    while (slash) {
   379					sv_catpvn(retval, rval, slash-rval);
   380					sv_catpvn(retval, "\\/", 2);
   381					rlen -= slash-rval+1;
   382					rval = slash+1;
   383					slash = strchr(rval, '/');
   384				    }
   385				    sv_catpvn(retval, rval, rlen);
   386				    sv_catpvn(retval, "/", 1);
   387				    return 1;
   388				}
   389			
   390				/* If purity is not set and maxdepth is set, then check depth:
   391				 * if we have reached maximum depth, return the string
   392				 * representation of the thing we are currently examining
   393				 * at this depth (i.e., 'Foo=ARRAY(0xdeadbeef)').
   394				 */
   395				if (!purity && maxdepth > 0 && *levelp >= maxdepth) {
   396				    STRLEN vallen;
   397				    char *valstr = SvPV(val,vallen);
   398				    sv_catpvn(retval, "'", 1);
   399				    sv_catpvn(retval, valstr, vallen);
   400				    sv_catpvn(retval, "'", 1);
   401				    return 1;
   402				}
   403			
   404				if (realpack) {				/* we have a blessed ref */
   405				    STRLEN blesslen;
   406				    char *blessstr = SvPV(bless, blesslen);
   407				    sv_catpvn(retval, blessstr, blesslen);
   408				    sv_catpvn(retval, "( ", 2);
   409				    if (indent >= 2) {
   410					blesspad = apad;
   411					apad = newSVsv(apad);
   412					sv_x(aTHX_ apad, " ", 1, blesslen+2);
   413				    }
   414				}
   415			
   416				(*levelp)++;
   417				ipad = sv_x(aTHX_ Nullsv, SvPVX_const(xpad), SvCUR(xpad), *levelp);
   418			
   419				if (realtype <= SVt_PVBM) {			     /* scalar ref */
   420				    SV *namesv = newSVpvn("${", 2);
   421				    sv_catpvn(namesv, name, namelen);
   422				    sv_catpvn(namesv, "}", 1);
   423				    if (realpack) {				     /* blessed */
   424					sv_catpvn(retval, "do{\\(my $o = ", 13);
   425					DD_dump(aTHX_ ival, SvPVX_const(namesv), SvCUR(namesv), retval, seenhv,
   426						postav, levelp,	indent, pad, xpad, apad, sep, pair,
   427						freezer, toaster, purity, deepcopy, quotekeys, bless,
   428						maxdepth, sortkeys);
   429					sv_catpvn(retval, ")}", 2);
   430				    }						     /* plain */
   431				    else {
   432					sv_catpvn(retval, "\\", 1);
   433					DD_dump(aTHX_ ival, SvPVX_const(namesv), SvCUR(namesv), retval, seenhv,
   434						postav, levelp,	indent, pad, xpad, apad, sep, pair,
   435						freezer, toaster, purity, deepcopy, quotekeys, bless,
   436						maxdepth, sortkeys);
   437				    }
   438				    SvREFCNT_dec(namesv);
   439				}
   440				else if (realtype == SVt_PVGV) {		     /* glob ref */
   441				    SV *namesv = newSVpvn("*{", 2);
   442				    sv_catpvn(namesv, name, namelen);
   443				    sv_catpvn(namesv, "}", 1);
   444				    sv_catpvn(retval, "\\", 1);
   445				    DD_dump(aTHX_ ival, SvPVX_const(namesv), SvCUR(namesv), retval, seenhv,
   446					    postav, levelp,	indent, pad, xpad, apad, sep, pair,
   447					    freezer, toaster, purity, deepcopy, quotekeys, bless,
   448					    maxdepth, sortkeys);
   449				    SvREFCNT_dec(namesv);
   450				}
   451				else if (realtype == SVt_PVAV) {
   452				    SV *totpad;
   453				    I32 ix = 0;
   454				    I32 ixmax = av_len((AV *)ival);
   455				
   456				    SV *ixsv = newSViv(0);
   457				    /* allowing for a 24 char wide array index */
   458				    New(0, iname, namelen+28, char);
   459				    (void)strcpy(iname, name);
   460				    inamelen = namelen;
   461				    if (name[0] == '@') {
   462					sv_catpvn(retval, "(", 1);
   463					iname[0] = '$';
   464				    }
   465				    else {
   466					sv_catpvn(retval, "[", 1);
   467					/* omit "->" in $foo{bar}->[0], but not in ${$foo}->[0] */
   468					/*if (namelen > 0
   469					    && name[namelen-1] != ']' && name[namelen-1] != '}'
   470					    && (namelen < 4 || (name[1] != '{' && name[2] != '{')))*/
   471					if ((namelen > 0
   472					     && name[namelen-1] != ']' && name[namelen-1] != '}')
   473					    || (namelen > 4
   474					        && (name[1] == '{'
   475						    || (name[0] == '\\' && name[2] == '{'))))
   476					{
   477					    iname[inamelen++] = '-'; iname[inamelen++] = '>';
   478					    iname[inamelen] = '\0';
   479					}
   480				    }
   481				    if (iname[0] == '*' && iname[inamelen-1] == '}' && inamelen >= 8 &&
   482					(instr(iname+inamelen-8, "{SCALAR}") ||
   483					 instr(iname+inamelen-7, "{ARRAY}") ||
   484					 instr(iname+inamelen-6, "{HASH}"))) {
   485					iname[inamelen++] = '-'; iname[inamelen++] = '>';
   486				    }
   487				    iname[inamelen++] = '['; iname[inamelen] = '\0';
   488				    totpad = newSVsv(sep);
   489				    sv_catsv(totpad, pad);
   490				    sv_catsv(totpad, apad);
   491			
   492				    for (ix = 0; ix <= ixmax; ++ix) {
   493					STRLEN ilen;
   494					SV *elem;
   495					svp = av_fetch((AV*)ival, ix, FALSE);
   496					if (svp)
   497					    elem = *svp;
   498					else
   499					    elem = &PL_sv_undef;
   500					
   501					ilen = inamelen;
   502					sv_setiv(ixsv, ix);
   503			                (void) sprintf(iname+ilen, "%"IVdf, (IV)ix);
   504					ilen = strlen(iname);
   505					iname[ilen++] = ']'; iname[ilen] = '\0';
   506					if (indent >= 3) {
   507					    sv_catsv(retval, totpad);
   508					    sv_catsv(retval, ipad);
   509					    sv_catpvn(retval, "#", 1);
   510					    sv_catsv(retval, ixsv);
   511					}
   512					sv_catsv(retval, totpad);
   513					sv_catsv(retval, ipad);
   514					DD_dump(aTHX_ elem, iname, ilen, retval, seenhv, postav,
   515						levelp,	indent, pad, xpad, apad, sep, pair,
   516						freezer, toaster, purity, deepcopy, quotekeys, bless,
   517						maxdepth, sortkeys);
   518					if (ix < ixmax)
   519					    sv_catpvn(retval, ",", 1);
   520				    }
   521				    if (ixmax >= 0) {
   522					SV *opad = sv_x(aTHX_ Nullsv, SvPVX_const(xpad), SvCUR(xpad), (*levelp)-1);
   523					sv_catsv(retval, totpad);
   524					sv_catsv(retval, opad);
   525					SvREFCNT_dec(opad);
   526				    }
   527				    if (name[0] == '@')
   528					sv_catpvn(retval, ")", 1);
   529				    else
   530					sv_catpvn(retval, "]", 1);
   531				    SvREFCNT_dec(ixsv);
   532				    SvREFCNT_dec(totpad);
   533				    Safefree(iname);
   534				}
   535				else if (realtype == SVt_PVHV) {
   536				    SV *totpad, *newapad;
   537				    SV *iname, *sname;
   538				    HE *entry;
   539				    char *key;
   540				    I32 klen;
   541				    SV *hval;
   542				    AV *keys = Nullav;
   543				
   544				    iname = newSVpvn(name, namelen);
   545				    if (name[0] == '%') {
   546					sv_catpvn(retval, "(", 1);
   547					(SvPVX(iname))[0] = '$';
   548				    }
   549				    else {
   550					sv_catpvn(retval, "{", 1);
   551					/* omit "->" in $foo[0]->{bar}, but not in ${$foo}->{bar} */
   552					if ((namelen > 0
   553					     && name[namelen-1] != ']' && name[namelen-1] != '}')
   554					    || (namelen > 4
   555					        && (name[1] == '{'
   556						    || (name[0] == '\\' && name[2] == '{'))))
   557					{
   558					    sv_catpvn(iname, "->", 2);
   559					}
   560				    }
   561				    if (name[0] == '*' && name[namelen-1] == '}' && namelen >= 8 &&
   562					(instr(name+namelen-8, "{SCALAR}") ||
   563					 instr(name+namelen-7, "{ARRAY}") ||
   564					 instr(name+namelen-6, "{HASH}"))) {
   565					sv_catpvn(iname, "->", 2);
   566				    }
   567				    sv_catpvn(iname, "{", 1);
   568				    totpad = newSVsv(sep);
   569				    sv_catsv(totpad, pad);
   570				    sv_catsv(totpad, apad);
   571				
   572				    /* If requested, get a sorted/filtered array of hash keys */
   573				    if (sortkeys) {
   574					if (sortkeys == &PL_sv_yes) {
   575			#if PERL_VERSION < 8
   576			                    sortkeys = sv_2mortal(newSVpvn("Data::Dumper::_sortkeys", 23));
   577			#else
   578					    keys = newAV();
   579					    (void)hv_iterinit((HV*)ival);
   580					    while ((entry = hv_iternext((HV*)ival))) {
   581						sv = hv_iterkeysv(entry);
   582						SvREFCNT_inc(sv);
   583						av_push(keys, sv);
   584					    }
   585			# ifdef USE_LOCALE_NUMERIC
   586					    sortsv(AvARRAY(keys), 
   587						   av_len(keys)+1, 
   588						   IN_LOCALE ? Perl_sv_cmp_locale : Perl_sv_cmp);
   589			# else
   590					    sortsv(AvARRAY(keys), 
   591						   av_len(keys)+1, 
   592						   Perl_sv_cmp);
   593			# endif
   594			#endif
   595					}
   596					if (sortkeys != &PL_sv_yes) {
   597					    dSP; ENTER; SAVETMPS; PUSHMARK(sp);
   598					    XPUSHs(sv_2mortal(newRV_inc(ival))); PUTBACK;
   599					    i = perl_call_sv(sortkeys, G_SCALAR | G_EVAL);
   600					    SPAGAIN;
   601					    if (i) {
   602						sv = POPs;
   603						if (SvROK(sv) && (SvTYPE(SvRV(sv)) == SVt_PVAV))
   604						    keys = (AV*)SvREFCNT_inc(SvRV(sv));
   605					    }
   606					    if (! keys)
   607						warn("Sortkeys subroutine did not return ARRAYREF\n");
   608					    PUTBACK; FREETMPS; LEAVE;
   609					}
   610					if (keys)
   611					    sv_2mortal((SV*)keys);
   612				    }
   613				    else
   614					(void)hv_iterinit((HV*)ival);
   615			
   616			            /* foreach (keys %hash) */
   617			            for (i = 0; 1; i++) {
   618					char *nkey;
   619			                char *nkey_buffer = NULL;
   620					I32 nticks = 0;
   621					SV* keysv;
   622					STRLEN keylen;
   623			                I32 nlen;
   624					bool do_utf8 = FALSE;
   625			
   626			                if ((sortkeys && !(keys && (I32)i <= av_len(keys))) ||
   627			                    !(entry = hv_iternext((HV *)ival)))
   628			                    break;
   629			
   630					if (i)
   631					    sv_catpvn(retval, ",", 1);
   632			
   633					if (sortkeys) {
   634					    char *key;
   635					    svp = av_fetch(keys, i, FALSE);
   636					    keysv = svp ? *svp : sv_mortalcopy(&PL_sv_undef);
   637					    key = SvPV(keysv, keylen);
   638					    svp = hv_fetch((HV*)ival, key,
   639			                                   SvUTF8(keysv) ? -(I32)keylen : keylen, 0);
   640					    hval = svp ? *svp : sv_mortalcopy(&PL_sv_undef);
   641					}
   642					else {
   643					    keysv = hv_iterkeysv(entry);
   644					    hval = hv_iterval((HV*)ival, entry);
   645					}
   646			
   647					do_utf8 = DO_UTF8(keysv);
   648					key = SvPV(keysv, keylen);
   649					klen = keylen;
   650			
   651			                sv_catsv(retval, totpad);
   652			                sv_catsv(retval, ipad);
   653			                /* old logic was first to check utf8 flag, and if utf8 always
   654			                   call esc_q_utf8.  This caused test to break under -Mutf8,
   655			                   because there even strings like 'c' have utf8 flag on.
   656			                   Hence with quotekeys == 0 the XS code would still '' quote
   657			                   them based on flags, whereas the perl code would not,
   658			                   based on regexps.
   659			                   The perl code is correct.
   660			                   needs_quote() decides that anything that isn't a valid
   661			                   perl identifier needs to be quoted, hence only correctly
   662			                   formed strings with no characters outside [A-Za-z0-9_:]
   663			                   won't need quoting.  None of those characters are used in
   664			                   the byte encoding of utf8, so anything with utf8
   665			                   encoded characters in will need quoting. Hence strings
   666			                   with utf8 encoded characters in will end up inside do_utf8
   667			                   just like before, but now strings with utf8 flag set but
   668			                   only ascii characters will end up in the unquoted section.
   669			
   670			                   There should also be less tests for the (probably currently)
   671			                   more common doesn't need quoting case.
   672			                   The code is also smaller (22044 vs 22260) because I've been
   673			                   able to pull the common logic out to both sides.  */
   674			                if (quotekeys || needs_quote(key)) {
   675			                    if (do_utf8) {
   676			                        STRLEN ocur = SvCUR(retval);
   677			                        nlen = esc_q_utf8(aTHX_ retval, key, klen);
   678			                        nkey = SvPVX(retval) + ocur;
   679			                    }
   680			                    else {
   681					        nticks = num_q(key, klen);
   682						New(0, nkey_buffer, klen+nticks+3, char);
   683			                        nkey = nkey_buffer;
   684						nkey[0] = '\'';
   685						if (nticks)
   686						    klen += esc_q(nkey+1, key, klen);
   687						else
   688						    (void)Copy(key, nkey+1, klen, char);
   689						nkey[++klen] = '\'';
   690						nkey[++klen] = '\0';
   691			                        nlen = klen;
   692			                        sv_catpvn(retval, nkey, klen);
   693					    }
   694			                }
   695			                else {
   696			                    nkey = key;
   697			                    nlen = klen;
   698			                    sv_catpvn(retval, nkey, klen);
   699					}
   700			                sname = newSVsv(iname);
   701			                sv_catpvn(sname, nkey, nlen);
   702			                sv_catpvn(sname, "}", 1);
   703			
   704					sv_catsv(retval, pair);
   705					if (indent >= 2) {
   706					    char *extra;
   707					    I32 elen = 0;
   708					    newapad = newSVsv(apad);
   709					    New(0, extra, klen+4+1, char);
   710					    while (elen < (klen+4))
   711						extra[elen++] = ' ';
   712					    extra[elen] = '\0';
   713					    sv_catpvn(newapad, extra, elen);
   714					    Safefree(extra);
   715					}
   716					else
   717					    newapad = apad;
   718			
   719					DD_dump(aTHX_ hval, SvPVX_const(sname), SvCUR(sname), retval, seenhv,
   720						postav, levelp,	indent, pad, xpad, newapad, sep, pair,
   721						freezer, toaster, purity, deepcopy, quotekeys, bless,
   722						maxdepth, sortkeys);
   723					SvREFCNT_dec(sname);
   724					Safefree(nkey_buffer);
   725					if (indent >= 2)
   726					    SvREFCNT_dec(newapad);
   727				    }
   728				    if (i) {
   729					SV *opad = sv_x(aTHX_ Nullsv, SvPVX_const(xpad), SvCUR(xpad), *levelp-1);
   730					sv_catsv(retval, totpad);
   731					sv_catsv(retval, opad);
   732					SvREFCNT_dec(opad);
   733				    }
   734				    if (name[0] == '%')
   735					sv_catpvn(retval, ")", 1);
   736				    else
   737					sv_catpvn(retval, "}", 1);
   738				    SvREFCNT_dec(iname);
   739				    SvREFCNT_dec(totpad);
   740				}
   741				else if (realtype == SVt_PVCV) {
   742				    sv_catpvn(retval, "sub { \"DUMMY\" }", 15);
   743				    if (purity)
   744					warn("Encountered CODE ref, using dummy placeholder");
   745				}
   746				else {
   747				    warn("cannot handle ref type %ld", realtype);
   748				}
   749			
   750				if (realpack) {  /* free blessed allocs */
   751				    if (indent >= 2) {
   752					SvREFCNT_dec(apad);
   753					apad = blesspad;
   754				    }
   755				    sv_catpvn(retval, ", '", 3);
   756				    sv_catpvn(retval, realpack, strlen(realpack));
   757				    sv_catpvn(retval, "' )", 3);
   758				    if (toaster && SvPOK(toaster) && SvCUR(toaster)) {
   759					sv_catpvn(retval, "->", 2);
   760					sv_catsv(retval, toaster);
   761					sv_catpvn(retval, "()", 2);
   762				    }
   763				}
   764				SvREFCNT_dec(ipad);
   765				(*levelp)--;
   766			    }
   767			    else {
   768				STRLEN i;
   769				
   770				if (namelen) {
   771				    (void) sprintf(id, "0x%"UVxf, PTR2UV(val));
   772				    if ((svp = hv_fetch(seenhv, id, (idlen = strlen(id)), FALSE)) &&
   773					(sv = *svp) && SvROK(sv) &&
   774					(seenentry = (AV*)SvRV(sv)))
   775				    {
   776					SV *othername;
   777					if ((svp = av_fetch(seenentry, 0, FALSE)) && (othername = *svp)
   778					    && (svp = av_fetch(seenentry, 2, FALSE)) && *svp && SvIV(*svp) > 0)
   779					{
   780					    sv_catpvn(retval, "${", 2);
   781					    sv_catsv(retval, othername);
   782					    sv_catpvn(retval, "}", 1);
   783					    return 1;
   784					}
   785				    }
   786				    else if (val != &PL_sv_undef) {
   787					SV *namesv;
   788					namesv = newSVpvn("\\", 1);
   789					sv_catpvn(namesv, name, namelen);
   790					seenentry = newAV();
   791					av_push(seenentry, namesv);
   792					av_push(seenentry, newRV_inc(val));
   793					(void)hv_store(seenhv, id, strlen(id), newRV_inc((SV*)seenentry), 0);
   794					SvREFCNT_dec(seenentry);
   795				    }
   796				}
   797			
   798			        if (DD_is_integer(val)) {
   799			            STRLEN len;
   800				    if (SvIsUV(val))
   801				      (void) sprintf(tmpbuf, "%"UVuf, SvUV(val));
   802				    else
   803				      (void) sprintf(tmpbuf, "%"IVdf, SvIV(val));
   804			            len = strlen(tmpbuf);
   805			            if (SvPOK(val)) {
   806			              /* Need to check to see if this is a string such as " 0".
   807			                 I'm assuming from sprintf isn't going to clash with utf8.
   808			                 Is this valid on EBCDIC?  */
   809			              STRLEN pvlen;
   810			              const char *pv = SvPV(val, pvlen);
   811			              if (pvlen != len || memNE(pv, tmpbuf, len))
   812			                goto integer_came_from_string;
   813			            }
   814			            if (len > 10) {
   815			              /* Looks like we're on a 64 bit system.  Make it a string so that
   816			                 if a 32 bit system reads the number it will cope better.  */
   817			              sv_catpvf(retval, "'%s'", tmpbuf);
   818			            } else
   819			              sv_catpvn(retval, tmpbuf, len);
   820				}
   821				else if (realtype == SVt_PVGV) {/* GLOBs can end up with scribbly names */
   822				    c = SvPV(val, i);
   823				    ++c; --i;			/* just get the name */
   824				    if (i >= 6 && strncmp(c, "main::", 6) == 0) {
   825					c += 4;
   826					i -= 4;
   827				    }
   828				    if (needs_quote(c)) {
   829					sv_grow(retval, SvCUR(retval)+6+2*i);
   830					r = SvPVX(retval)+SvCUR(retval);
   831					r[0] = '*'; r[1] = '{';	r[2] = '\'';
   832					i += esc_q(r+3, c, i);
   833					i += 3;
   834					r[i++] = '\''; r[i++] = '}';
   835					r[i] = '\0';
   836				    }
   837				    else {
   838					sv_grow(retval, SvCUR(retval)+i+2);
   839					r = SvPVX(retval)+SvCUR(retval);
   840					r[0] = '*'; strcpy(r+1, c);
   841					i++;
   842				    }
   843				    SvCUR_set(retval, SvCUR(retval)+i);
   844			
   845				    if (purity) {
   846					static const char* const entries[] = { "{SCALAR}", "{ARRAY}", "{HASH}" };
   847					static const STRLEN sizes[] = { 8, 7, 6 };
   848					SV *e;
   849					SV *nname = newSVpvn("", 0);
   850					SV *newapad = newSVpvn("", 0);
   851					GV *gv = (GV*)val;
   852					I32 j;
   853					
   854					for (j=0; j<3; j++) {
   855					    e = ((j == 0) ? GvSV(gv) : (j == 1) ? (SV*)GvAV(gv) : (SV*)GvHV(gv));
   856					    if (!e)
   857						continue;
   858					    if (j == 0 && !SvOK(e))
   859						continue;
   860			
   861					    {
   862						I32 nlevel = 0;
   863						SV *postentry = newSVpvn(r,i);
   864						
   865						sv_setsv(nname, postentry);
   866						sv_catpvn(nname, entries[j], sizes[j]);
   867						sv_catpvn(postentry, " = ", 3);
   868						av_push(postav, postentry);
   869						e = newRV_inc(e);
   870						
   871						SvCUR_set(newapad, 0);
   872						if (indent >= 2)
   873						    (void)sv_x(aTHX_ newapad, " ", 1, SvCUR(postentry));
   874						
   875						DD_dump(aTHX_ e, SvPVX_const(nname), SvCUR(nname), postentry,
   876							seenhv, postav, &nlevel, indent, pad, xpad,
   877							newapad, sep, pair, freezer, toaster, purity,
   878							deepcopy, quotekeys, bless, maxdepth, 
   879							sortkeys);
   880						SvREFCNT_dec(e);
   881					    }
   882					}
   883					
   884					SvREFCNT_dec(newapad);
   885					SvREFCNT_dec(nname);
   886				    }
   887				}
   888				else if (val == &PL_sv_undef || !SvOK(val)) {
   889				    sv_catpvn(retval, "undef", 5);
   890				}
   891				else {
   892			        integer_came_from_string:
   893				    c = SvPV(val, i);
   894				    if (DO_UTF8(val))
   895				        i += esc_q_utf8(aTHX_ retval, c, i);
   896				    else {
   897					sv_grow(retval, SvCUR(retval)+3+2*i); /* 3: ""\0 */
   898					r = SvPVX(retval) + SvCUR(retval);
   899					r[0] = '\'';
   900					i += esc_q(r+1, c, i);
   901					++i;
   902					r[i++] = '\'';
   903					r[i] = '\0';
   904					SvCUR_set(retval, SvCUR(retval)+i);
   905				    }
   906				}
   907			    }
   908			
   909			    if (idlen) {
   910				if (deepcopy)
   911				    (void)hv_delete(seenhv, id, idlen, G_DISCARD);
   912				else if (namelen && seenentry) {
   913				    SV *mark = *av_fetch(seenentry, 2, TRUE);
   914				    sv_setiv(mark,1);
   915				}
   916			    }
   917			    return 1;
   918			}
   919			
   920			
   921			#ifndef PERL_UNUSED_VAR
   922			#  define PERL_UNUSED_VAR(var) if (0) var = var
   923			#endif
   924			
   925			#line 926 "Dumper.c"
   926			
   927			XS(XS_Data__Dumper_Dumpxs); /* prototype to pass -Wmissing-prototypes */
   928			XS(XS_Data__Dumper_Dumpxs)
   929	         998    {
   930	         998        dXSARGS;
   931	         998        if (items < 1)
   932	      ######    	Perl_croak(aTHX_ "Usage: Data::Dumper::Dumpxs(href, ...)");
   933	         998        PERL_UNUSED_VAR(cv); /* -W */
   934	         998        PERL_UNUSED_VAR(ax); /* -Wall */
   935	         998        SP -= items;
   936			    {
   937	         998    	SV *	href = ST(0);
   938			#line 925 "Dumper.xs"
   939				{
   940				    HV *hv;
   941				    SV *retval, *valstr;
   942				    HV *seenhv = Nullhv;
   943				    AV *postav, *todumpav, *namesav;
   944				    I32 level = 0;
   945				    I32 indent, terse, i, imax, postlen;
   946				    SV **svp;
   947				    SV *val, *name, *pad, *xpad, *apad, *sep, *pair, *varname;
   948				    SV *freezer, *toaster, *bless, *sortkeys;
   949				    I32 purity, deepcopy, quotekeys, maxdepth = 0;
   950				    char tmpbuf[1024];
   951				    I32 gimme = GIMME;
   952			
   953				    if (!SvROK(href)) {		/* call new to get an object first */
   954					if (items < 2)
   955					    croak("Usage: Data::Dumper::Dumpxs(PACKAGE, VAL_ARY_REF, [NAME_ARY_REF])");
   956			
   957					ENTER;
   958					SAVETMPS;
   959			
   960					PUSHMARK(sp);
   961					XPUSHs(href);
   962					XPUSHs(sv_2mortal(newSVsv(ST(1))));
   963					if (items >= 3)
   964					    XPUSHs(sv_2mortal(newSVsv(ST(2))));
   965					PUTBACK;
   966					i = perl_call_method("new", G_SCALAR);
   967					SPAGAIN;
   968					if (i)
   969					    href = newSVsv(POPs);
   970			
   971					PUTBACK;
   972					FREETMPS;
   973					LEAVE;
   974					if (i)
   975					    (void)sv_2mortal(href);
   976				    }
   977			
   978				    todumpav = namesav = Nullav;
   979				    seenhv = Nullhv;
   980				    val = pad = xpad = apad = sep = pair = varname
   981					= freezer = toaster = bless = &PL_sv_undef;
   982				    name = sv_newmortal();
   983				    indent = 2;
   984				    terse = purity = deepcopy = 0;
   985				    quotekeys = 1;
   986			
   987				    retval = newSVpvn("", 0);
   988				    if (SvROK(href)
   989					&& (hv = (HV*)SvRV((SV*)href))
   990					&& SvTYPE(hv) == SVt_PVHV)		{
   991			
   992					if ((svp = hv_fetch(hv, "seen", 4, FALSE)) && SvROK(*svp))
   993					    seenhv = (HV*)SvRV(*svp);
   994					if ((svp = hv_fetch(hv, "todump", 6, FALSE)) && SvROK(*svp))
   995					    todumpav = (AV*)SvRV(*svp);
   996					if ((svp = hv_fetch(hv, "names", 5, FALSE)) && SvROK(*svp))
   997					    namesav = (AV*)SvRV(*svp);
   998					if ((svp = hv_fetch(hv, "indent", 6, FALSE)))
   999					    indent = SvIV(*svp);
  1000					if ((svp = hv_fetch(hv, "purity", 6, FALSE)))
  1001					    purity = SvIV(*svp);
  1002					if ((svp = hv_fetch(hv, "terse", 5, FALSE)))
  1003					    terse = SvTRUE(*svp);
  1004			#if 0 /* useqq currently unused */
  1005					if ((svp = hv_fetch(hv, "useqq", 5, FALSE)))
  1006					    useqq = SvTRUE(*svp);
  1007			#endif
  1008					if ((svp = hv_fetch(hv, "pad", 3, FALSE)))
  1009					    pad = *svp;
  1010					if ((svp = hv_fetch(hv, "xpad", 4, FALSE)))
  1011					    xpad = *svp;
  1012					if ((svp = hv_fetch(hv, "apad", 4, FALSE)))
  1013					    apad = *svp;
  1014					if ((svp = hv_fetch(hv, "sep", 3, FALSE)))
  1015					    sep = *svp;
  1016					if ((svp = hv_fetch(hv, "pair", 4, FALSE)))
  1017					    pair = *svp;
  1018					if ((svp = hv_fetch(hv, "varname", 7, FALSE)))
  1019					    varname = *svp;
  1020					if ((svp = hv_fetch(hv, "freezer", 7, FALSE)))
  1021					    freezer = *svp;
  1022					if ((svp = hv_fetch(hv, "toaster", 7, FALSE)))
  1023					    toaster = *svp;
  1024					if ((svp = hv_fetch(hv, "deepcopy", 8, FALSE)))
  1025					    deepcopy = SvTRUE(*svp);
  1026					if ((svp = hv_fetch(hv, "quotekeys", 9, FALSE)))
  1027					    quotekeys = SvTRUE(*svp);
  1028					if ((svp = hv_fetch(hv, "bless", 5, FALSE)))
  1029					    bless = *svp;
  1030					if ((svp = hv_fetch(hv, "maxdepth", 8, FALSE)))
  1031					    maxdepth = SvIV(*svp);
  1032					if ((svp = hv_fetch(hv, "sortkeys", 8, FALSE))) {
  1033					    sortkeys = *svp;
  1034					    if (! SvTRUE(sortkeys))
  1035						sortkeys = NULL;
  1036					    else if (! (SvROK(sortkeys) &&
  1037							SvTYPE(SvRV(sortkeys)) == SVt_PVCV) )
  1038					    {
  1039						/* flag to use qsortsv() for sorting hash keys */	
  1040						sortkeys = &PL_sv_yes; 
  1041					    }
  1042					}
  1043					postav = newAV();
  1044			
  1045					if (todumpav)
  1046					    imax = av_len(todumpav);
  1047					else
  1048					    imax = -1;
  1049					valstr = newSVpvn("",0);
  1050					for (i = 0; i <= imax; ++i) {
  1051					    SV *newapad;
  1052			
  1053					    av_clear(postav);
  1054					    if ((svp = av_fetch(todumpav, i, FALSE)))
  1055						val = *svp;
  1056					    else
  1057						val = &PL_sv_undef;
  1058					    if ((svp = av_fetch(namesav, i, TRUE))) {
  1059						sv_setsv(name, *svp);
  1060						if (SvOK(*svp) && !SvPOK(*svp))
  1061						    (void)SvPV_nolen_const(name);
  1062					    }
  1063					    else
  1064						(void)SvOK_off(name);
  1065			
  1066					    if (SvPOK(name)) {
  1067						if ((SvPVX_const(name))[0] == '*') {
  1068						    if (SvROK(val)) {
  1069							switch (SvTYPE(SvRV(val))) {
  1070							case SVt_PVAV:
  1071							    (SvPVX(name))[0] = '@';
  1072							    break;
  1073							case SVt_PVHV:
  1074							    (SvPVX(name))[0] = '%';
  1075							    break;
  1076							case SVt_PVCV:
  1077							    (SvPVX(name))[0] = '*';
  1078							    break;
  1079							default:
  1080							    (SvPVX(name))[0] = '$';
  1081							    break;
  1082							}
  1083						    }
  1084						    else
  1085							(SvPVX(name))[0] = '$';
  1086						}
  1087						else if ((SvPVX_const(name))[0] != '$')
  1088						    sv_insert(name, 0, 0, "$", 1);
  1089					    }
  1090					    else {
  1091						STRLEN nchars = 0;
  1092						sv_setpvn(name, "$", 1);
  1093						sv_catsv(name, varname);
  1094						(void) sprintf(tmpbuf, "%"IVdf, (IV)(i+1));
  1095						nchars = strlen(tmpbuf);
  1096						sv_catpvn(name, tmpbuf, nchars);
  1097					    }
  1098			
  1099					    if (indent >= 2) {
  1100						SV *tmpsv = sv_x(aTHX_ Nullsv, " ", 1, SvCUR(name)+3);
  1101						newapad = newSVsv(apad);
  1102						sv_catsv(newapad, tmpsv);
  1103						SvREFCNT_dec(tmpsv);
  1104					    }
  1105					    else
  1106						newapad = apad;
  1107			
  1108					    DD_dump(aTHX_ val, SvPVX_const(name), SvCUR(name), valstr, seenhv,
  1109						    postav, &level, indent, pad, xpad, newapad, sep, pair,
  1110						    freezer, toaster, purity, deepcopy, quotekeys,
  1111						    bless, maxdepth, sortkeys);
  1112			
  1113					    if (indent >= 2)
  1114						SvREFCNT_dec(newapad);
  1115			
  1116					    postlen = av_len(postav);
  1117					    if (postlen >= 0 || !terse) {
  1118						sv_insert(valstr, 0, 0, " = ", 3);
  1119						sv_insert(valstr, 0, 0, SvPVX_const(name), SvCUR(name));
  1120						sv_catpvn(valstr, ";", 1);
  1121					    }
  1122					    sv_catsv(retval, pad);
  1123					    sv_catsv(retval, valstr);
  1124					    sv_catsv(retval, sep);
  1125					    if (postlen >= 0) {
  1126						I32 i;
  1127						sv_catsv(retval, pad);
  1128						for (i = 0; i <= postlen; ++i) {
  1129						    SV *elem;
  1130						    svp = av_fetch(postav, i, FALSE);
  1131						    if (svp && (elem = *svp)) {
  1132							sv_catsv(retval, elem);
  1133							if (i < postlen) {
  1134							    sv_catpvn(retval, ";", 1);
  1135							    sv_catsv(retval, sep);
  1136							    sv_catsv(retval, pad);
  1137							}
  1138						    }
  1139						}
  1140						sv_catpvn(retval, ";", 1);
  1141						    sv_catsv(retval, sep);
  1142					    }
  1143					    sv_setpvn(valstr, "", 0);
  1144					    if (gimme == G_ARRAY) {
  1145						XPUSHs(sv_2mortal(retval));
  1146						if (i < imax)	/* not the last time thro ? */
  1147						    retval = newSVpvn("",0);
  1148					    }
  1149					}
  1150					SvREFCNT_dec(postav);
  1151					SvREFCNT_dec(valstr);
  1152				    }
  1153				    else
  1154					croak("Call to new() method failed to return HASH ref");
  1155				    if (gimme == G_SCALAR)
  1156					XPUSHs(sv_2mortal(retval));
  1157				}
  1158			#line 1159 "Dumper.c"
  1159	         998    	PUTBACK;
  1160				return;
  1161			    }
  1162			}
  1163			
  1164			#ifdef __cplusplus
  1165			extern "C"
  1166			#endif
  1167			XS(boot_Data__Dumper); /* prototype to pass -Wmissing-prototypes */
  1168			XS(boot_Data__Dumper)
  1169	           9    {
  1170	           9        dXSARGS;
  1171	           9        char* file = __FILE__;
  1172			
  1173	           9        PERL_UNUSED_VAR(cv); /* -W */
  1174	           9        PERL_UNUSED_VAR(items); /* -W */
  1175	           9        XS_VERSION_BOOTCHECK ;
  1176			
  1177	           9            newXSproto("Data::Dumper::Dumpxs", XS_Data__Dumper_Dumpxs, file, "$;$$");
  1178	           9        XSRETURN_YES;
  1179			}
  1180