/* dump.c
*
* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
- * 2000, 2001, 2002, 2003, 2004, 2005, 2006, by Larry Wall and others
+ * 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 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.
#include "proto.h"
+static const char* const svtypenames[SVt_LAST] = {
+ "NULL",
+ "BIND",
+ "IV",
+ "NV",
+ "RV",
+ "PV",
+ "PVIV",
+ "PVNV",
+ "PVMG",
+ "PVGV",
+ "PVLV",
+ "PVAV",
+ "PVHV",
+ "PVCV",
+ "PVFM",
+ "PVIO"
+};
+
+
+static const char* const svshorttypenames[SVt_LAST] = {
+ "UNDEF",
+ "BIND",
+ "IV",
+ "NV",
+ "RV",
+ "PV",
+ "PVIV",
+ "PVNV",
+ "PVMG",
+ "GV",
+ "PVLV",
+ "AV",
+ "HV",
+ "CV",
+ "FM",
+ "IO"
+};
+
#define Sequence PL_op_sequence
void
op_dump(PL_eval_root);
}
+
+/*
+=for apidoc Apd|char*|pv_escape|NN SV *dsv|NN const char const *str\
+ |const STRLEN count|const STRLEN max
+ |STRLEN const *escaped, const U32 flags
+
+Escapes at most the first "count" chars of pv and puts the results into
+dsv such that the size of the escaped string will not exceed "max" chars
+and will not contain any incomplete escape sequences.
+
+If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string
+will also be escaped.
+
+Normally the SV will be cleared before the escaped string is prepared,
+but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur.
+
+If PERL_PV_ESCAPE_UNI is set then the input string is treated as unicode,
+if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned
+using C<is_utf8_string()> to determine if it is unicode.
+
+If PERL_PV_ESCAPE_ALL is set then all input chars will be output
+using C<\x01F1> style escapes, otherwise only chars above 255 will be
+escaped using this style, other non printable chars will use octal or
+common escaped patterns like C<\n>. If PERL_PV_ESCAPE_NOBACKSLASH
+then all chars below 255 will be treated as printable and
+will be output as literals.
+
+If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the
+string will be escaped, regardles of max. If the string is utf8 and
+the chars value is >255 then it will be returned as a plain hex
+sequence. Thus the output will either be a single char,
+an octal escape sequence, a special escape like C<\n> or a 3 or
+more digit hex value.
+
+If PERL_PV_ESCAPE_RE is set then the escape char used will be a '%' and
+not a '\\'. This is because regexes very often contain backslashed
+sequences, whereas '%' is not a particularly common character in patterns.
+
+Returns a pointer to the escaped text as held by dsv.
+
+=cut
+*/
+#define PV_ESCAPE_OCTBUFSIZE 32
+
char *
-Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
+Perl_pv_escape( pTHX_ SV *dsv, char const * const str,
+ const STRLEN count, const STRLEN max,
+ STRLEN * const escaped, const U32 flags )
{
- const bool nul_terminated = len > cur && pv[cur] == '\0';
- bool truncated = 0;
-
- sv_setpvn(dsv, "\"", 1);
- for (; cur--; pv++) {
- if (pvlim && SvCUR(dsv) >= pvlim) {
- truncated = 1;
+ char esc = (flags & PERL_PV_ESCAPE_RE) ? '%' : '\\';
+ char dq = (flags & PERL_PV_ESCAPE_QUOTE) ? '"' : esc;
+ char octbuf[PV_ESCAPE_OCTBUFSIZE] = "%123456789ABCDF";
+ STRLEN wrote = 0; /* chars written so far */
+ STRLEN chsize = 0; /* size of data to be written */
+ STRLEN readsize = 1; /* size of data just read */
+ bool isuni= flags & PERL_PV_ESCAPE_UNI ? 1 : 0; /* is this unicode */
+ const char *pv = str;
+ const char *end = pv + count; /* end of string */
+ octbuf[0] = esc;
+
+ if (!flags & PERL_PV_ESCAPE_NOCLEAR)
+ sv_setpvn(dsv, "", 0);
+
+ if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
+ isuni = 1;
+
+ for ( ; (pv < end && (!max || (wrote < max))) ; pv += readsize ) {
+ const UV u= (isuni) ? utf8_to_uvchr((U8*)pv, &readsize) : (U8)*pv;
+ const U8 c = (U8)u & 0xFF;
+
+ if ( ( u > 255 ) || (flags & PERL_PV_ESCAPE_ALL)) {
+ if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
+ chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
+ "%"UVxf, u);
+ else
+ chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
+ "%cx{%"UVxf"}", esc, u);
+ } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {
+ chsize = 1;
+ } else {
+ if ( (c == dq) || (c == esc) || !isPRINT(c) ) {
+ chsize = 2;
+ switch (c) {
+
+ case '\\' : /* fallthrough */
+ case '%' : if ( c == esc ) {
+ octbuf[1] = esc;
+ } else {
+ chsize = 1;
+ }
+ break;
+ case '\v' : octbuf[1] = 'v'; break;
+ case '\t' : octbuf[1] = 't'; break;
+ case '\r' : octbuf[1] = 'r'; break;
+ case '\n' : octbuf[1] = 'n'; break;
+ case '\f' : octbuf[1] = 'f'; break;
+ case '"' :
+ if ( dq == '"' )
+ octbuf[1] = '"';
+ else
+ chsize = 1;
+ break;
+ default:
+ if ( (pv < end) && isDIGIT((U8)*(pv+readsize)) )
+ chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
+ "%c%03o", esc, c);
+ else
+ chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
+ "%c%o", esc, c);
+ }
+ } else {
+ chsize = 1;
+ }
+ }
+ if ( max && (wrote + chsize > max) ) {
break;
- }
- switch (*pv) {
- case '\t': sv_catpvs(dsv, "\\t"); break;
- case '\n': sv_catpvs(dsv, "\\n"); break;
- case '\r': sv_catpvs(dsv, "\\r"); break;
- case '\f': sv_catpvs(dsv, "\\f"); break;
- case '"': sv_catpvs(dsv, "\\\""); break;
- case '\\': sv_catpvs(dsv, "\\\\"); break;
- default:
- if (isPRINT(*pv))
- sv_catpvn(dsv, pv, 1);
- else if (cur && isDIGIT(*(pv+1)))
- Perl_sv_catpvf(aTHX_ dsv, "\\%03o", (U8)*pv);
- else
- Perl_sv_catpvf(aTHX_ dsv, "\\%o", (U8)*pv);
- }
+ } else if (chsize > 1) {
+ sv_catpvn(dsv, octbuf, chsize);
+ wrote += chsize;
+ } else {
+ Perl_sv_catpvf( aTHX_ dsv, "%c", c);
+ wrote++;
+ }
+ if ( flags & PERL_PV_ESCAPE_FIRSTCHAR )
+ break;
}
- sv_catpvs(dsv, "\"");
- if (truncated)
- sv_catpvs(dsv, "...");
- if (nul_terminated)
- sv_catpvs(dsv, "\\0");
+ if (escaped != NULL)
+ *escaped= pv - str;
+ return SvPVX(dsv);
+}
+/*
+=for apidoc Apd|char *|pv_pretty|NN SV *dsv|NN const char const *str\
+ |const STRLEN count|const STRLEN max\
+ |const char const *start_color| const char const *end_color\
+ |const U32 flags
+
+Converts a string into something presentable, handling escaping via
+pv_escape() and supporting quoting and elipses.
+
+If the PERL_PV_PRETTY_QUOTE flag is set then the result will be
+double quoted with any double quotes in the string escaped. Otherwise
+if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in
+angle brackets.
+
+If the PERL_PV_PRETTY_ELIPSES flag is set and not all characters in
+string were output then an elipses C<...> will be appended to the
+string. Note that this happens AFTER it has been quoted.
+
+If start_color is non-null then it will be inserted after the opening
+quote (if there is one) but before the escaped text. If end_color
+is non-null then it will be inserted after the escaped text but before
+any quotes or elipses.
+
+Returns a pointer to the prettified text as held by dsv.
+
+=cut
+*/
+
+char *
+Perl_pv_pretty( pTHX_ SV *dsv, char const * const str, const STRLEN count,
+ const STRLEN max, char const * const start_color, char const * const end_color,
+ const U32 flags )
+{
+ U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
+ STRLEN escaped;
+
+ if ( dq == '"' )
+ sv_setpvn(dsv, "\"", 1);
+ else if ( flags & PERL_PV_PRETTY_LTGT )
+ sv_setpvn(dsv, "<", 1);
+ else
+ sv_setpvn(dsv, "", 0);
+
+ if ( start_color != NULL )
+ Perl_sv_catpv( aTHX_ dsv, start_color);
+
+ pv_escape( dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR );
+
+ if ( end_color != NULL )
+ Perl_sv_catpv( aTHX_ dsv, end_color);
+
+ if ( dq == '"' )
+ sv_catpvn( dsv, "\"", 1 );
+ else if ( flags & PERL_PV_PRETTY_LTGT )
+ sv_catpvn( dsv, ">", 1);
+
+ if ( (flags & PERL_PV_PRETTY_ELIPSES) && ( escaped < count ) )
+ sv_catpvn( dsv, "...", 3 );
+
+ return SvPVX(dsv);
+}
+
+/*
+=for apidoc pv_display
+
+ char *pv_display(SV *dsv, const char *pv, STRLEN cur, STRLEN len,
+ STRLEN pvlim, U32 flags)
+
+Similar to
+
+ pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE);
+
+except that an additional "\0" will be appended to the string when
+len > cur and pv[cur] is "\0".
+Note that the final string may be up to 7 chars longer than pvlim.
+
+=cut
+*/
+
+char *
+Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
+{
+ pv_pretty( dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
+ if (len > cur && pv[cur] == '\0')
+ sv_catpvn( dsv, "\\0", 2 );
return SvPVX(dsv);
}
dVAR;
SV * const t = sv_newmortal();
int unref = 0;
+ U32 type;
sv_setpvn(t, "", 0);
retry:
sv = (SV*)SvRV(sv);
goto retry;
}
- switch (SvTYPE(sv)) {
- default:
- sv_catpv(t, "FREED");
+ type = SvTYPE(sv);
+ if (type == SVt_PVCV) {
+ Perl_sv_catpvf(aTHX_ t, "CV(%s)", CvGV(sv) ? GvNAME(CvGV(sv)) : "");
goto finish;
+ } else if (type < SVt_LAST) {
+ sv_catpv(t, svshorttypenames[type]);
- case SVt_NULL:
- sv_catpv(t, "UNDEF");
- goto finish;
- case SVt_IV:
- sv_catpv(t, "IV");
- break;
- case SVt_NV:
- sv_catpv(t, "NV");
- break;
- case SVt_RV:
- sv_catpv(t, "RV");
- break;
- case SVt_PV:
- sv_catpv(t, "PV");
- break;
- case SVt_PVIV:
- sv_catpv(t, "PVIV");
- break;
- case SVt_PVNV:
- sv_catpv(t, "PVNV");
- break;
- case SVt_PVMG:
- sv_catpv(t, "PVMG");
- break;
- case SVt_PVLV:
- sv_catpv(t, "PVLV");
- break;
- case SVt_PVAV:
- sv_catpv(t, "AV");
- break;
- case SVt_PVHV:
- sv_catpv(t, "HV");
- break;
- case SVt_PVCV:
- if (CvGV(sv))
- Perl_sv_catpvf(aTHX_ t, "CV(%s)", GvNAME(CvGV(sv)));
- else
- sv_catpv(t, "CV()");
+ if (type == SVt_NULL)
+ goto finish;
+ } else {
+ sv_catpv(t, "FREED");
goto finish;
- case SVt_PVGV:
- sv_catpv(t, "GV");
- break;
- case SVt_PVBM:
- sv_catpv(t, "BM");
- break;
- case SVt_PVFM:
- sv_catpv(t, "FM");
- break;
- case SVt_PVIO:
- sv_catpv(t, "IO");
- break;
}
if (SvPOKp(sv)) {
if (!SvPVX_const(sv))
sv_catpv(t, "(null)");
else {
- SV *tmp = newSVpvs("");
+ SV * const tmp = newSVpvs("");
sv_catpv(t, "(");
if (SvOOK(sv))
Perl_sv_catpvf(aTHX_ t, "[%s]", pv_display(tmp, SvPVX_const(sv)-SvIVX(sv), SvIVX(sv), 0, 127));
(pm->op_private & OPpRUNTIME) ? " (RUNTIME)" : "");
else
Perl_dump_indent(aTHX_ level, file, "PMf_PRE (RUNTIME)\n");
- if (pm->op_type != OP_PUSHRE && pm->op_pmreplroot) {
+ if (pm->op_type != OP_PUSHRE && pm->op_pmreplrootu.op_pmreplroot) {
Perl_dump_indent(aTHX_ level, file, "PMf_REPL = ");
- op_dump(pm->op_pmreplroot);
+ op_dump(pm->op_pmreplrootu.op_pmreplroot);
}
if (pm->op_pmflags || (PM_GETRE(pm) && PM_GETRE(pm)->check_substr)) {
- SV *tmpsv = newSVpvs("");
- if (pm->op_pmdynflags & PMdf_USED)
- sv_catpv(tmpsv, ",USED");
- if (pm->op_pmdynflags & PMdf_TAINTED)
- sv_catpv(tmpsv, ",TAINTED");
- if (pm->op_pmflags & PMf_ONCE)
- sv_catpv(tmpsv, ",ONCE");
- if (PM_GETRE(pm) && PM_GETRE(pm)->check_substr
- && !(PM_GETRE(pm)->reganch & ROPT_NOSCAN))
- sv_catpv(tmpsv, ",SCANFIRST");
- if (PM_GETRE(pm) && PM_GETRE(pm)->check_substr
- && PM_GETRE(pm)->reganch & ROPT_CHECK_ALL)
- sv_catpv(tmpsv, ",ALL");
- if (pm->op_pmflags & PMf_SKIPWHITE)
- sv_catpv(tmpsv, ",SKIPWHITE");
- if (pm->op_pmflags & PMf_CONST)
- sv_catpv(tmpsv, ",CONST");
- if (pm->op_pmflags & PMf_KEEP)
- sv_catpv(tmpsv, ",KEEP");
- if (pm->op_pmflags & PMf_GLOBAL)
- sv_catpv(tmpsv, ",GLOBAL");
- if (pm->op_pmflags & PMf_CONTINUE)
- sv_catpv(tmpsv, ",CONTINUE");
- if (pm->op_pmflags & PMf_RETAINT)
- sv_catpv(tmpsv, ",RETAINT");
- if (pm->op_pmflags & PMf_EVAL)
- sv_catpv(tmpsv, ",EVAL");
+ SV * const tmpsv = pm_description(pm);
Perl_dump_indent(aTHX_ level, file, "PMFLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
SvREFCNT_dec(tmpsv);
}
Perl_dump_indent(aTHX_ level-1, file, "}\n");
}
+static SV *
+S_pm_description(pTHX_ const PMOP *pm)
+{
+ SV * const desc = newSVpvs("");
+ const REGEXP * regex = PM_GETRE(pm);
+ const U32 pmflags = pm->op_pmflags;
+
+ if (pmflags & PMf_ONCE)
+ sv_catpv(desc, ",ONCE");
+#ifdef USE_ITHREADS
+ if (SvREADONLY(PL_regex_pad[pm->op_pmoffset]))
+ sv_catpv(desc, ":USED");
+#else
+ if (pmflags & PMf_USED)
+ sv_catpv(desc, ":USED");
+#endif
+
+ if (regex) {
+ if (regex->extflags & RXf_TAINTED)
+ sv_catpv(desc, ",TAINTED");
+ if (regex->check_substr) {
+ if (!(regex->extflags & RXf_NOSCAN))
+ sv_catpv(desc, ",SCANFIRST");
+ if (regex->extflags & RXf_CHECK_ALL)
+ sv_catpv(desc, ",ALL");
+ }
+ if (regex->extflags & RXf_SKIPWHITE)
+ sv_catpv(desc, ",SKIPWHITE");
+ }
+
+ if (pmflags & PMf_CONST)
+ sv_catpv(desc, ",CONST");
+ if (pmflags & PMf_KEEP)
+ sv_catpv(desc, ",KEEP");
+ if (pmflags & PMf_GLOBAL)
+ sv_catpv(desc, ",GLOBAL");
+ if (pmflags & PMf_CONTINUE)
+ sv_catpv(desc, ",CONTINUE");
+ if (pmflags & PMf_RETAINT)
+ sv_catpv(desc, ",RETAINT");
+ if (pmflags & PMf_EVAL)
+ sv_catpv(desc, ",EVAL");
+ return desc;
+}
+
void
Perl_pmop_dump(pTHX_ PMOP *pm)
{
S_sequence(pTHX_ register const OP *o)
{
dVAR;
- SV *op;
- const char *key;
- STRLEN len;
const OP *oldop = NULL;
- OP *l;
if (!o)
return;
+#ifdef PERL_MAD
+ if (o->op_next == 0)
+ return;
+#endif
+
if (!Sequence)
Sequence = newHV();
for (; o; o = o->op_next) {
- op = newSVuv(PTR2UV(o));
- key = SvPV_const(op, len);
+ STRLEN len;
+ SV * const op = newSVuv(PTR2UV(o));
+ const char * const key = SvPV_const(op, len);
+
if (hv_exists(Sequence, key, len))
break;
}
goto nothin;
case OP_NULL:
+#ifdef PERL_MAD
+ if (o == o->op_next)
+ return;
+#endif
if (oldop && o->op_next)
continue;
break;
case OP_COND_EXPR:
case OP_RANGE:
hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
- for (l = cLOGOPo->op_other; l && l->op_type == OP_NULL; l = l->op_next)
- ;
- sequence(l);
+ sequence_tail(cLOGOPo->op_other);
break;
case OP_ENTERLOOP:
case OP_ENTERITER:
hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
- for (l = cLOOPo->op_redoop; l && l->op_type == OP_NULL; l = l->op_next)
- ;
- sequence(l);
- for (l = cLOOPo->op_nextop; l && l->op_type == OP_NULL; l = l->op_next)
- ;
- sequence(l);
- for (l = cLOOPo->op_lastop; l && l->op_type == OP_NULL; l = l->op_next)
- ;
- sequence(l);
+ sequence_tail(cLOOPo->op_redoop);
+ sequence_tail(cLOOPo->op_nextop);
+ sequence_tail(cLOOPo->op_lastop);
break;
- case OP_QR:
- case OP_MATCH:
case OP_SUBST:
hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
- for (l = cPMOPo->op_pmreplstart; l && l->op_type == OP_NULL; l = l->op_next)
- ;
- sequence(l);
+ sequence_tail(cPMOPo->op_pmstashstartu.op_pmreplstart);
break;
+ case OP_QR:
+ case OP_MATCH:
case OP_HELEM:
break;
}
}
+static void
+S_sequence_tail(pTHX_ const OP *o)
+{
+ while (o && (o->op_type == OP_NULL))
+ o = o->op_next;
+ sequence(o);
+}
+
STATIC UV
S_sequence_num(pTHX_ const OP *o)
{
{
dVAR;
UV seq;
+ const OPCODE optype = o->op_type;
+
sequence(o);
Perl_dump_indent(aTHX_ level, file, "{\n");
level++;
seq = sequence_num(o);
if (seq)
- PerlIO_printf(file, "%-4"UVf, seq);
+ PerlIO_printf(file, "%-4"UVuf, seq);
else
PerlIO_printf(file, " ");
PerlIO_printf(file,
"%*sTYPE = %s ===> ",
(int)(PL_dumpindent*level-4), "", OP_NAME(o));
if (o->op_next)
- PerlIO_printf(file, seq ? "%"UVf"\n" : "(%"UVf")\n",
+ PerlIO_printf(file, seq ? "%"UVuf"\n" : "(%"UVuf")\n",
sequence_num(o->op_next));
else
PerlIO_printf(file, "DONE\n");
if (o->op_targ) {
- if (o->op_type == OP_NULL)
- {
+ if (optype == OP_NULL) {
Perl_dump_indent(aTHX_ level, file, " (was %s)\n", PL_op_name[o->op_targ]);
- if (o->op_targ == OP_NEXTSTATE)
- {
+ if (o->op_targ == OP_NEXTSTATE) {
if (CopLINE(cCOPo))
- Perl_dump_indent(aTHX_ level, file, "LINE = %"UVf"\n",
+ Perl_dump_indent(aTHX_ level, file, "LINE = %"UVuf"\n",
(UV)CopLINE(cCOPo));
if (CopSTASHPV(cCOPo))
Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
#ifdef DUMPADDR
Perl_dump_indent(aTHX_ level, file, "ADDR = 0x%"UVxf" => 0x%"UVxf"\n", (UV)o, (UV)o->op_next);
#endif
- if (o->op_flags) {
- SV *tmpsv = newSVpvs("");
+ if (o->op_flags || o->op_latefree || o->op_latefreed || o->op_attached) {
+ SV * const tmpsv = newSVpvs("");
switch (o->op_flags & OPf_WANT) {
case OPf_WANT_VOID:
sv_catpv(tmpsv, ",VOID");
sv_catpv(tmpsv, ",MOD");
if (o->op_flags & OPf_SPECIAL)
sv_catpv(tmpsv, ",SPECIAL");
+ if (o->op_latefree)
+ sv_catpv(tmpsv, ",LATEFREE");
+ if (o->op_latefreed)
+ sv_catpv(tmpsv, ",LATEFREED");
+ if (o->op_attached)
+ sv_catpv(tmpsv, ",ATTACHED");
Perl_dump_indent(aTHX_ level, file, "FLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
SvREFCNT_dec(tmpsv);
}
if (o->op_private) {
- SV *tmpsv = newSVpvs("");
- if (PL_opargs[o->op_type] & OA_TARGLEX) {
+ SV * const tmpsv = newSVpvs("");
+ if (PL_opargs[optype] & OA_TARGLEX) {
if (o->op_private & OPpTARGET_MY)
sv_catpv(tmpsv, ",TARGET_MY");
}
- else if (o->op_type == OP_LEAVESUB ||
- o->op_type == OP_LEAVE ||
- o->op_type == OP_LEAVESUBLV ||
- o->op_type == OP_LEAVEWRITE) {
+ else if (optype == OP_LEAVESUB ||
+ optype == OP_LEAVE ||
+ optype == OP_LEAVESUBLV ||
+ optype == OP_LEAVEWRITE) {
if (o->op_private & OPpREFCOUNTED)
sv_catpv(tmpsv, ",REFCOUNTED");
}
- else if (o->op_type == OP_AASSIGN) {
+ else if (optype == OP_AASSIGN) {
if (o->op_private & OPpASSIGN_COMMON)
sv_catpv(tmpsv, ",COMMON");
}
- else if (o->op_type == OP_SASSIGN) {
+ else if (optype == OP_SASSIGN) {
if (o->op_private & OPpASSIGN_BACKWARDS)
sv_catpv(tmpsv, ",BACKWARDS");
}
- else if (o->op_type == OP_TRANS) {
+ else if (optype == OP_TRANS) {
if (o->op_private & OPpTRANS_SQUASH)
sv_catpv(tmpsv, ",SQUASH");
if (o->op_private & OPpTRANS_DELETE)
if (o->op_private & OPpTRANS_GROWS)
sv_catpv(tmpsv, ",GROWS");
}
- else if (o->op_type == OP_REPEAT) {
+ else if (optype == OP_REPEAT) {
if (o->op_private & OPpREPEAT_DOLIST)
sv_catpv(tmpsv, ",DOLIST");
}
- else if (o->op_type == OP_ENTERSUB ||
- o->op_type == OP_RV2SV ||
- o->op_type == OP_GVSV ||
- o->op_type == OP_RV2AV ||
- o->op_type == OP_RV2HV ||
- o->op_type == OP_RV2GV ||
- o->op_type == OP_AELEM ||
- o->op_type == OP_HELEM )
+ else if (optype == OP_ENTERSUB ||
+ optype == OP_RV2SV ||
+ optype == OP_GVSV ||
+ optype == OP_RV2AV ||
+ optype == OP_RV2HV ||
+ optype == OP_RV2GV ||
+ optype == OP_AELEM ||
+ optype == OP_HELEM )
{
- if (o->op_type == OP_ENTERSUB) {
+ if (optype == OP_ENTERSUB) {
if (o->op_private & OPpENTERSUB_AMPER)
sv_catpv(tmpsv, ",AMPER");
if (o->op_private & OPpENTERSUB_DB)
}
else {
switch (o->op_private & OPpDEREF) {
- case OPpDEREF_SV:
- sv_catpv(tmpsv, ",SV");
- break;
- case OPpDEREF_AV:
- sv_catpv(tmpsv, ",AV");
- break;
- case OPpDEREF_HV:
- sv_catpv(tmpsv, ",HV");
- break;
- }
+ case OPpDEREF_SV:
+ sv_catpv(tmpsv, ",SV");
+ break;
+ case OPpDEREF_AV:
+ sv_catpv(tmpsv, ",AV");
+ break;
+ case OPpDEREF_HV:
+ sv_catpv(tmpsv, ",HV");
+ break;
+ }
if (o->op_private & OPpMAYBE_LVSUB)
sv_catpv(tmpsv, ",MAYBE_LVSUB");
}
- if (o->op_type == OP_AELEM || o->op_type == OP_HELEM) {
+ if (optype == OP_AELEM || optype == OP_HELEM) {
if (o->op_private & OPpLVAL_DEFER)
sv_catpv(tmpsv, ",LVAL_DEFER");
}
sv_catpv(tmpsv, ",OUR_INTRO");
}
}
- else if (o->op_type == OP_CONST) {
+ else if (optype == OP_CONST) {
if (o->op_private & OPpCONST_BARE)
sv_catpv(tmpsv, ",BARE");
if (o->op_private & OPpCONST_STRICT)
if (o->op_private & OPpCONST_ENTERED)
sv_catpv(tmpsv, ",ENTERED");
}
- else if (o->op_type == OP_FLIP) {
+ else if (optype == OP_FLIP) {
if (o->op_private & OPpFLIP_LINENUM)
sv_catpv(tmpsv, ",LINENUM");
}
- else if (o->op_type == OP_FLOP) {
+ else if (optype == OP_FLOP) {
if (o->op_private & OPpFLIP_LINENUM)
sv_catpv(tmpsv, ",LINENUM");
}
- else if (o->op_type == OP_RV2CV) {
+ else if (optype == OP_RV2CV) {
if (o->op_private & OPpLVAL_INTRO)
sv_catpv(tmpsv, ",INTRO");
}
- else if (o->op_type == OP_GV) {
+ else if (optype == OP_GV) {
if (o->op_private & OPpEARLY_CV)
sv_catpv(tmpsv, ",EARLY_CV");
}
- else if (o->op_type == OP_LIST) {
+ else if (optype == OP_LIST) {
if (o->op_private & OPpLIST_GUESSED)
sv_catpv(tmpsv, ",GUESSED");
}
- else if (o->op_type == OP_DELETE) {
+ else if (optype == OP_DELETE) {
if (o->op_private & OPpSLICE)
sv_catpv(tmpsv, ",SLICE");
}
- else if (o->op_type == OP_EXISTS) {
+ else if (optype == OP_EXISTS) {
if (o->op_private & OPpEXISTS_SUB)
sv_catpv(tmpsv, ",EXISTS_SUB");
}
- else if (o->op_type == OP_SORT) {
+ else if (optype == OP_SORT) {
if (o->op_private & OPpSORT_NUMERIC)
sv_catpv(tmpsv, ",NUMERIC");
if (o->op_private & OPpSORT_INTEGER)
if (o->op_private & OPpSORT_REVERSE)
sv_catpv(tmpsv, ",REVERSE");
}
- else if (o->op_type == OP_THREADSV) {
- if (o->op_private & OPpDONE_SVREF)
- sv_catpv(tmpsv, ",SVREF");
- }
- else if (o->op_type == OP_OPEN || o->op_type == OP_BACKTICK) {
+ else if (optype == OP_OPEN || optype == OP_BACKTICK) {
if (o->op_private & OPpOPEN_IN_RAW)
sv_catpv(tmpsv, ",IN_RAW");
if (o->op_private & OPpOPEN_IN_CRLF)
if (o->op_private & OPpOPEN_OUT_CRLF)
sv_catpv(tmpsv, ",OUT_CRLF");
}
- else if (o->op_type == OP_EXIT) {
+ else if (optype == OP_EXIT) {
if (o->op_private & OPpEXIT_VMSISH)
sv_catpv(tmpsv, ",EXIT_VMSISH");
if (o->op_private & OPpHUSH_VMSISH)
sv_catpv(tmpsv, ",HUSH_VMSISH");
}
- else if (o->op_type == OP_DIE) {
+ else if (optype == OP_DIE) {
if (o->op_private & OPpHUSH_VMSISH)
sv_catpv(tmpsv, ",HUSH_VMSISH");
}
- else if (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
+ else if (PL_check[optype] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
if (OP_IS_FILETEST_ACCESS(o) && o->op_private & OPpFT_ACCESS)
sv_catpv(tmpsv, ",FT_ACCESS");
if (o->op_private & OPpFT_STACKED)
SvREFCNT_dec(tmpsv);
}
- switch (o->op_type) {
+#ifdef PERL_MAD
+ if (PL_madskills && o->op_madprop) {
+ SV * const tmpsv = newSVpvn("", 0);
+ MADPROP* mp = o->op_madprop;
+ Perl_dump_indent(aTHX_ level, file, "MADPROPS = {\n");
+ level++;
+ while (mp) {
+ char tmp = mp->mad_key;
+ sv_setpvn(tmpsv,"'",1);
+ if (tmp)
+ sv_catpvn(tmpsv, &tmp, 1);
+ sv_catpv(tmpsv, "'=");
+ switch (mp->mad_type) {
+ case MAD_NULL:
+ sv_catpv(tmpsv, "NULL");
+ Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
+ break;
+ case MAD_PV:
+ sv_catpv(tmpsv, "<");
+ sv_catpvn(tmpsv, (char*)mp->mad_val, mp->mad_vlen);
+ sv_catpv(tmpsv, ">");
+ Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
+ break;
+ case MAD_OP:
+ if ((OP*)mp->mad_val) {
+ Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
+ do_op_dump(level, file, (OP*)mp->mad_val);
+ }
+ break;
+ default:
+ sv_catpv(tmpsv, "(UNK)");
+ Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
+ break;
+ }
+ mp = mp->mad_next;
+ }
+ level--;
+ Perl_dump_indent(aTHX_ level, file, "}\n");
+
+ SvREFCNT_dec(tmpsv);
+ }
+#endif
+
+ switch (optype) {
case OP_AELEMFAST:
case OP_GVSV:
case OP_GV:
#else
if ( ! PL_op->op_flags & OPf_SPECIAL) { /* not lexical */
if (cSVOPo->op_sv) {
- SV *tmpsv = newSV(0);
+ SV * const tmpsv = newSV(0);
ENTER;
SAVEFREESV(tmpsv);
+#ifdef PERL_MAD
+ /* FIXME - is this making unwarranted assumptions about the
+ UTF-8 cleanliness of the dump file handle? */
+ SvUTF8_on(tmpsv);
+#endif
gv_fullname3(tmpsv, (GV*)cSVOPo->op_sv, NULL);
Perl_dump_indent(aTHX_ level, file, "GV = %s\n",
SvPV_nolen_const(tmpsv));
case OP_NEXTSTATE:
case OP_DBSTATE:
if (CopLINE(cCOPo))
- Perl_dump_indent(aTHX_ level, file, "LINE = %"UVf"\n",
+ Perl_dump_indent(aTHX_ level, file, "LINE = %"UVuf"\n",
(UV)CopLINE(cCOPo));
if (CopSTASHPV(cCOPo))
Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
case OP_ENTERLOOP:
Perl_dump_indent(aTHX_ level, file, "REDO ===> ");
if (cLOOPo->op_redoop)
- PerlIO_printf(file, "%"UVf"\n", sequence_num(cLOOPo->op_redoop));
+ PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOOPo->op_redoop));
else
PerlIO_printf(file, "DONE\n");
Perl_dump_indent(aTHX_ level, file, "NEXT ===> ");
if (cLOOPo->op_nextop)
- PerlIO_printf(file, "%"UVf"\n", sequence_num(cLOOPo->op_nextop));
+ PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOOPo->op_nextop));
else
PerlIO_printf(file, "DONE\n");
Perl_dump_indent(aTHX_ level, file, "LAST ===> ");
if (cLOOPo->op_lastop)
- PerlIO_printf(file, "%"UVf"\n", sequence_num(cLOOPo->op_lastop));
+ PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOOPo->op_lastop));
else
PerlIO_printf(file, "DONE\n");
break;
case OP_AND:
Perl_dump_indent(aTHX_ level, file, "OTHER ===> ");
if (cLOGOPo->op_other)
- PerlIO_printf(file, "%"UVf"\n", sequence_num(cLOGOPo->op_other));
+ PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOGOPo->op_other));
else
PerlIO_printf(file, "DONE\n");
break;
{ PERL_MAGIC_sv, "sv(\\0)" },
{ PERL_MAGIC_arylen, "arylen(#)" },
{ PERL_MAGIC_rhash, "rhash(%)" },
- { PERL_MAGIC_glob, "glob(*)" },
{ PERL_MAGIC_pos, "pos(.)" },
{ PERL_MAGIC_symtab, "symtab(:)" },
{ PERL_MAGIC_backref, "backref(<)" },
{ PERL_MAGIC_bm, "bm(B)" },
{ PERL_MAGIC_regdata, "regdata(D)" },
{ PERL_MAGIC_env, "env(E)" },
+ { PERL_MAGIC_hints, "hints(H)" },
{ PERL_MAGIC_isa, "isa(I)" },
{ PERL_MAGIC_dbfile, "dbfile(L)" },
{ PERL_MAGIC_shared, "shared(N)" },
{ PERL_MAGIC_envelem, "envelem(e)" },
{ PERL_MAGIC_fm, "fm(f)" },
{ PERL_MAGIC_regex_global, "regex_global(g)" },
+ { PERL_MAGIC_hintselem, "hintselem(h)" },
{ PERL_MAGIC_isaelem, "isaelem(i)" },
{ PERL_MAGIC_nkeys, "nkeys(k)" },
{ PERL_MAGIC_dbline, "dbline(l)" },
{ PERL_MAGIC_defelem, "defelem(y)" },
{ PERL_MAGIC_ext, "ext(~)" },
/* this null string terminates the list */
- { 0, 0 },
+ { 0, NULL },
};
void
" MAGIC = 0x%"UVxf"\n", PTR2UV(mg));
if (mg->mg_virtual) {
const MGVTBL * const v = mg->mg_virtual;
- const char *s = NULL;
+ const char *s;
if (v == &PL_vtbl_sv) s = "sv";
else if (v == &PL_vtbl_env) s = "env";
else if (v == &PL_vtbl_envelem) s = "envelem";
else if (v == &PL_vtbl_dbline) s = "dbline";
else if (v == &PL_vtbl_isa) s = "isa";
else if (v == &PL_vtbl_arylen) s = "arylen";
- else if (v == &PL_vtbl_glob) s = "glob";
else if (v == &PL_vtbl_mglob) s = "mglob";
else if (v == &PL_vtbl_nkeys) s = "nkeys";
else if (v == &PL_vtbl_taint) s = "taint";
else if (v == &PL_vtbl_backref) s = "backref";
else if (v == &PL_vtbl_utf8) s = "utf8";
else if (v == &PL_vtbl_arylen_p) s = "arylen_p";
+ else if (v == &PL_vtbl_hintselem) s = "hintselem";
+ else s = NULL;
if (s)
Perl_dump_indent(aTHX_ level, file, " MG_VIRTUAL = &PL_vtbl_%s\n", s);
else
Perl_dump_indent(aTHX_ level, file, " MINMATCH\n");
}
if (mg->mg_obj) {
- Perl_dump_indent(aTHX_ level, file, " MG_OBJ = 0x%"UVxf"\n", PTR2UV(mg->mg_obj));
- if (mg->mg_flags & MGf_REFCOUNTED)
+ Perl_dump_indent(aTHX_ level, file, " MG_OBJ = 0x%"UVxf"\n",
+ PTR2UV(mg->mg_obj));
+ if (mg->mg_type == PERL_MAGIC_qr) {
+ regexp *re=(regexp *)mg->mg_obj;
+ SV *dsv= sv_newmortal();
+ const char * const s = pv_pretty(dsv, re->wrapped, re->wraplen,
+ 60, NULL, NULL,
+ ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_PRETTY_ELIPSES |
+ ((re->extflags & RXf_UTF8) ? PERL_PV_ESCAPE_UNI : 0))
+ );
+ Perl_dump_indent(aTHX_ level+1, file, " PAT = %s\n", s);
+ Perl_dump_indent(aTHX_ level+1, file, " REFCNT = %"IVdf"\n",
+ (IV)re->refcnt);
+ }
+ if (mg->mg_flags & MGf_REFCOUNTED)
do_sv_dump(level+2, file, mg->mg_obj, nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
}
if (mg->mg_len)
void
Perl_magic_dump(pTHX_ const MAGIC *mg)
{
- do_magic_dump(0, Perl_debug_log, mg, 0, 0, 0, 0);
+ do_magic_dump(0, Perl_debug_log, mg, 0, 0, FALSE, 0);
}
void
(int)(PL_dumpindent*level), "", (IV)SvREFCNT(sv),
(int)(PL_dumpindent*level), "");
- if (flags & SVs_PADSTALE) sv_catpv(d, "PADSTALE,");
- if (flags & SVs_PADTMP) sv_catpv(d, "PADTMP,");
- if (flags & SVs_PADMY) sv_catpv(d, "PADMY,");
+ if (!(flags & SVpad_NAME && (type == SVt_PVMG || type == SVt_PVNV))) {
+ if (flags & SVs_PADSTALE) sv_catpv(d, "PADSTALE,");
+ }
+ if (!(flags & SVpad_NAME && type == SVt_PVMG)) {
+ if (flags & SVs_PADTMP) sv_catpv(d, "PADTMP,");
+ if (flags & SVs_PADMY) sv_catpv(d, "PADMY,");
+ }
if (flags & SVs_TEMP) sv_catpv(d, "TEMP,");
if (flags & SVs_OBJECT) sv_catpv(d, "OBJECT,");
if (flags & SVs_GMG) sv_catpv(d, "GMG,");
if (flags & SVf_OOK) sv_catpv(d, "OOK,");
if (flags & SVf_FAKE) sv_catpv(d, "FAKE,");
if (flags & SVf_READONLY) sv_catpv(d, "READONLY,");
+ if (flags & SVf_BREAK) sv_catpv(d, "BREAK,");
- if (flags & SVf_AMAGIC && type != SVt_PVHV)
- sv_catpv(d, "OVERLOAD,");
+ if (flags & SVf_AMAGIC) sv_catpv(d, "OVERLOAD,");
if (flags & SVp_IOK) sv_catpv(d, "pIOK,");
if (flags & SVp_NOK) sv_catpv(d, "pNOK,");
if (flags & SVp_POK) sv_catpv(d, "pPOK,");
- if (flags & SVp_SCREAM && type != SVt_PVHV)
+ if (flags & SVp_SCREAM && type != SVt_PVHV && !isGV_with_GP(sv)) {
+ if (SvPCS_IMPORTED(sv))
+ sv_catpv(d, "PCS_IMPORTED,");
+ else
sv_catpv(d, "SCREAM,");
+ }
switch (type) {
case SVt_PVCV:
if (HvREHASH(sv)) sv_catpv(d, "REHASH,");
if (flags & SVphv_CLONEABLE) sv_catpv(d, "CLONEABLE,");
break;
- case SVt_PVGV: case SVt_PVLV:
- if (GvINTRO(sv)) sv_catpv(d, "INTRO,");
- if (GvMULTI(sv)) sv_catpv(d, "MULTI,");
- if (GvUNIQUE(sv)) sv_catpv(d, "UNIQUE,");
- if (GvASSUMECV(sv)) sv_catpv(d, "ASSUMECV,");
- if (GvIN_PAD(sv)) sv_catpv(d, "IN_PAD,");
- if (flags & SVpad_OUR) sv_catpv(d, "OUR,");
- if (GvIMPORTED(sv)) {
+ case SVt_PVGV:
+ case SVt_PVLV:
+ if (isGV_with_GP(sv)) {
+ if (GvINTRO(sv)) sv_catpv(d, "INTRO,");
+ if (GvMULTI(sv)) sv_catpv(d, "MULTI,");
+ if (GvUNIQUE(sv)) sv_catpv(d, "UNIQUE,");
+ if (GvASSUMECV(sv)) sv_catpv(d, "ASSUMECV,");
+ if (GvIN_PAD(sv)) sv_catpv(d, "IN_PAD,");
+ }
+ if (isGV_with_GP(sv) && GvIMPORTED(sv)) {
sv_catpv(d, "IMPORT");
if (GvIMPORTED(sv) == GVf_IMPORTED)
sv_catpv(d, "ALL,");
sv_catpv(d, " ),");
}
}
+ if (SvTAIL(sv)) sv_catpv(d, "TAIL,");
+ if (SvVALID(sv)) sv_catpv(d, "VALID,");
/* FALL THROUGH */
default:
+ evaled_or_uv:
if (SvEVALED(sv)) sv_catpv(d, "EVALED,");
if (SvIsUV(sv) && !(flags & SVf_ROK)) sv_catpv(d, "IsUV,");
break;
- case SVt_PVBM:
- if (SvTAIL(sv)) sv_catpv(d, "TAIL,");
- if (SvVALID(sv)) sv_catpv(d, "VALID,");
- break;
case SVt_PVMG:
- if (flags & SVpad_TYPED)
- sv_catpv(d, "TYPED,");
- break;
+ if (SvPAD_TYPED(sv)) sv_catpv(d, "TYPED,");
+ if (SvPAD_OUR(sv)) sv_catpv(d, "OUR,");
+ /* FALL THROUGH */
+ case SVt_PVNV:
+ if (SvPAD_STATE(sv)) sv_catpv(d, "STATE,");
+ goto evaled_or_uv;
case SVt_PVAV:
break;
}
sv->sv_debug_cloned ? " (cloned)" : "");
#endif
Perl_dump_indent(aTHX_ level, file, "SV = ");
- switch (type) {
- case SVt_NULL:
- PerlIO_printf(file, "NULL%s\n", s);
- SvREFCNT_dec(d);
- return;
- case SVt_IV:
- PerlIO_printf(file, "IV%s\n", s);
- break;
- case SVt_NV:
- PerlIO_printf(file, "NV%s\n", s);
- break;
- case SVt_RV:
- PerlIO_printf(file, "RV%s\n", s);
- break;
- case SVt_PV:
- PerlIO_printf(file, "PV%s\n", s);
- break;
- case SVt_PVIV:
- PerlIO_printf(file, "PVIV%s\n", s);
- break;
- case SVt_PVNV:
- PerlIO_printf(file, "PVNV%s\n", s);
- break;
- case SVt_PVBM:
- PerlIO_printf(file, "PVBM%s\n", s);
- break;
- case SVt_PVMG:
- PerlIO_printf(file, "PVMG%s\n", s);
- break;
- case SVt_PVLV:
- PerlIO_printf(file, "PVLV%s\n", s);
- break;
- case SVt_PVAV:
- PerlIO_printf(file, "PVAV%s\n", s);
- break;
- case SVt_PVHV:
- PerlIO_printf(file, "PVHV%s\n", s);
- break;
- case SVt_PVCV:
- PerlIO_printf(file, "PVCV%s\n", s);
- break;
- case SVt_PVGV:
- PerlIO_printf(file, "PVGV%s\n", s);
- break;
- case SVt_PVFM:
- PerlIO_printf(file, "PVFM%s\n", s);
- break;
- case SVt_PVIO:
- PerlIO_printf(file, "PVIO%s\n", s);
- break;
- default:
+ if (type < SVt_LAST) {
+ PerlIO_printf(file, "%s%s\n", svtypenames[type], s);
+
+ if (type == SVt_NULL) {
+ SvREFCNT_dec(d);
+ return;
+ }
+ } else {
PerlIO_printf(file, "UNKNOWN(0x%"UVxf") %s\n", (UV)type, s);
SvREFCNT_dec(d);
return;
}
- if ((type >= SVt_PVIV && type != SVt_PVAV && type != SVt_PVHV)
+ if ((type >= SVt_PVIV && type != SVt_PVAV && type != SVt_PVHV
+ && type != SVt_PVCV && !isGV_with_GP(sv))
|| type == SVt_IV) {
if (SvIsUV(sv)
#ifdef PERL_OLD_COPY_ON_WRITE
#endif
PerlIO_putc(file, '\n');
}
- if ((type >= SVt_PVNV && type != SVt_PVAV && type != SVt_PVHV)
- || type == SVt_NV) {
+ if ((type == SVt_PVNV || type == SVt_PVMG) && SvFLAGS(sv) & SVpad_NAME) {
+ Perl_dump_indent(aTHX_ level, file, " COP_LOW = %"UVuf"\n",
+ (UV) COP_SEQ_RANGE_LOW(sv));
+ Perl_dump_indent(aTHX_ level, file, " COP_HIGH = %"UVuf"\n",
+ (UV) COP_SEQ_RANGE_HIGH(sv));
+ } else if ((type >= SVt_PVNV && type != SVt_PVAV && type != SVt_PVHV
+ && type != SVt_PVCV && type != SVt_PVFM && !isGV_with_GP(sv)
+ && !SvVALID(sv))
+ || type == SVt_NV) {
STORE_NUMERIC_LOCAL_SET_STANDARD();
/* %Vg doesn't work? --jhi */
#ifdef USE_LONG_DOUBLE
SvREFCNT_dec(d);
return;
}
- if (type <= SVt_PVLV && type != SVt_PVGV) {
+ if (type <= SVt_PVLV && !isGV_with_GP(sv)) {
if (SvPVX_const(sv)) {
Perl_dump_indent(aTHX_ level, file," PV = 0x%"UVxf" ", PTR2UV(SvPVX_const(sv)));
if (SvOOK(sv))
Perl_dump_indent(aTHX_ level, file, " PV = 0\n");
}
if (type >= SVt_PVMG) {
- if (SvMAGIC(sv))
- do_magic_dump(level, file, SvMAGIC(sv), nest, maxnest, dumpops, pvlim);
+ if (type == SVt_PVMG && SvPAD_OUR(sv)) {
+ HV *ost = SvOURSTASH(sv);
+ if (ost)
+ do_hv_dump(level, file, " OURSTASH", ost);
+ } else {
+ if (SvMAGIC(sv))
+ do_magic_dump(level, file, SvMAGIC(sv), nest, maxnest, dumpops, pvlim);
+ }
if (SvSTASH(sv))
do_hv_dump(level, file, " STASH", SvSTASH(sv));
}
if (HvARRAY(sv) && HvKEYS(sv)) {
/* Show distribution of HEs in the ARRAY */
int freq[200];
-#define FREQ_MAX (sizeof freq / sizeof freq[0] - 1)
+#define FREQ_MAX ((int)(sizeof freq / sizeof freq[0] - 1))
int i;
int max = 0;
U32 pow2 = 2, keys = HvKEYS(sv);
Perl_dump_indent(aTHX_ level, file, " RITER = %"IVdf"\n", (IV)HvRITER_get(sv));
Perl_dump_indent(aTHX_ level, file, " EITER = 0x%"UVxf"\n", PTR2UV(HvEITER_get(sv)));
{
- MAGIC *mg = mg_find(sv, PERL_MAGIC_symtab);
+ MAGIC * const mg = mg_find(sv, PERL_MAGIC_symtab);
if (mg && mg->mg_obj) {
Perl_dump_indent(aTHX_ level, file, " PMROOT = 0x%"UVxf"\n", PTR2UV(mg->mg_obj));
}
}
{
- const char *hvname = HvNAME_get(sv);
+ const char * const hvname = HvNAME_get(sv);
if (hvname)
Perl_dump_indent(aTHX_ level, file, " NAME = \"%s\"\n", hvname);
}
if (SvOOK(sv)) {
- AV *backrefs = *Perl_hv_backreferences_p(aTHX_ (HV*)sv);
+ const AV * const backrefs = *Perl_hv_backreferences_p(aTHX_ (HV*)sv);
if (backrefs) {
Perl_dump_indent(aTHX_ level, file, " BACKREFS = 0x%"UVxf"\n",
PTR2UV(backrefs));
}
break;
case SVt_PVCV:
- if (SvPOK(sv))
- Perl_dump_indent(aTHX_ level, file, " PROTOTYPE = \"%s\"\n", SvPV_nolen_const(sv));
+ if (SvPOK(sv)) {
+ STRLEN len;
+ const char *const proto = SvPV_const(sv, len);
+ Perl_dump_indent(aTHX_ level, file, " PROTOTYPE = \"%.*s\"\n",
+ (int) len, proto);
+ }
/* FALL THROUGH */
case SVt_PVFM:
do_hv_dump(level, file, " COMP_STASH", CvSTASH(sv));
- if (!CvISXSUB(sv) && CvSTART(sv))
- Perl_dump_indent(aTHX_ level, file, " START = 0x%"UVxf" ===> %"IVdf"\n", PTR2UV(CvSTART(sv)), (IV)sequence_num(CvSTART(sv)));
- Perl_dump_indent(aTHX_ level, file, " ROOT = 0x%"UVxf"\n", PTR2UV(CvROOT(sv)));
- if (CvROOT(sv) && dumpops)
- do_op_dump(level+1, file, CvROOT(sv));
- Perl_dump_indent(aTHX_ level, file, " XSUB = 0x%"UVxf"\n", PTR2UV(CvXSUB(sv)));
- if (CvISXSUB(sv)) {
+ if (!CvISXSUB(sv)) {
+ if (CvSTART(sv)) {
+ Perl_dump_indent(aTHX_ level, file,
+ " START = 0x%"UVxf" ===> %"IVdf"\n",
+ PTR2UV(CvSTART(sv)),
+ (IV)sequence_num(CvSTART(sv)));
+ }
+ Perl_dump_indent(aTHX_ level, file, " ROOT = 0x%"UVxf"\n",
+ PTR2UV(CvROOT(sv)));
+ if (CvROOT(sv) && dumpops) {
+ do_op_dump(level+1, file, CvROOT(sv));
+ }
+ } else {
SV *constant = cv_const_sv((CV *)sv);
+ Perl_dump_indent(aTHX_ level, file, " XSUB = 0x%"UVxf"\n", PTR2UV(CvXSUB(sv)));
if (constant) {
Perl_dump_indent(aTHX_ level, file, " XSUBANY = 0x%"UVxf
do_dump_pad(level+1, file, CvPADLIST(sv), 0);
}
{
- const CV *outside = CvOUTSIDE(sv);
+ const CV * const outside = CvOUTSIDE(sv);
Perl_dump_indent(aTHX_ level, file, " OUTSIDE = 0x%"UVxf" (%s)\n",
PTR2UV(outside),
(!outside ? "null"
if (nest < maxnest && (CvCLONE(sv) || CvCLONED(sv)))
do_sv_dump(level+1, file, (SV*)CvOUTSIDE(sv), nest+1, maxnest, dumpops, pvlim);
break;
- case SVt_PVGV: case SVt_PVLV:
- if (type == SVt_PVLV) {
- Perl_dump_indent(aTHX_ level, file, " TYPE = %c\n", LvTYPE(sv));
- Perl_dump_indent(aTHX_ level, file, " TARGOFF = %"IVdf"\n", (IV)LvTARGOFF(sv));
- Perl_dump_indent(aTHX_ level, file, " TARGLEN = %"IVdf"\n", (IV)LvTARGLEN(sv));
- Perl_dump_indent(aTHX_ level, file, " TARG = 0x%"UVxf"\n", PTR2UV(LvTARG(sv)));
- if (LvTYPE(sv) != 't' && LvTYPE(sv) != 'T')
- do_sv_dump(level+1, file, LvTARG(sv), nest+1, maxnest,
- dumpops, pvlim);
- }
+ case SVt_PVGV:
+ case SVt_PVLV:
+ if (type == SVt_PVLV) {
+ Perl_dump_indent(aTHX_ level, file, " TYPE = %c\n", LvTYPE(sv));
+ Perl_dump_indent(aTHX_ level, file, " TARGOFF = %"IVdf"\n", (IV)LvTARGOFF(sv));
+ Perl_dump_indent(aTHX_ level, file, " TARGLEN = %"IVdf"\n", (IV)LvTARGLEN(sv));
+ Perl_dump_indent(aTHX_ level, file, " TARG = 0x%"UVxf"\n", PTR2UV(LvTARG(sv)));
+ if (LvTYPE(sv) != 't' && LvTYPE(sv) != 'T')
+ do_sv_dump(level+1, file, LvTARG(sv), nest+1, maxnest,
+ dumpops, pvlim);
+ }
+ if (SvVALID(sv)) {
+ Perl_dump_indent(aTHX_ level, file, " FLAGS = %u\n", (U8)BmFLAGS(sv));
+ Perl_dump_indent(aTHX_ level, file, " RARE = %u\n", (U8)BmRARE(sv));
+ Perl_dump_indent(aTHX_ level, file, " PREVIOUS = %"UVuf"\n", (UV)BmPREVIOUS(sv));
+ Perl_dump_indent(aTHX_ level, file, " USEFUL = %"IVdf"\n", (IV)BmUSEFUL(sv));
+ }
+ if (!isGV_with_GP(sv))
+ break;
Perl_dump_indent(aTHX_ level, file, " NAME = \"%s\"\n", GvNAME(sv));
Perl_dump_indent(aTHX_ level, file, " NAMELEN = %"IVdf"\n", (IV)GvNAMELEN(sv));
do_hv_dump (level, file, " GvSTASH", GvSTASH(sv));
Perl_dump_indent(aTHX_ level, file, " LINES_LEFT = %"IVdf"\n", (IV)IoLINES_LEFT(sv));
if (IoTOP_NAME(sv))
Perl_dump_indent(aTHX_ level, file, " TOP_NAME = \"%s\"\n", IoTOP_NAME(sv));
- do_gv_dump (level, file, " TOP_GV", IoTOP_GV(sv));
+ if (!IoTOP_GV(sv) || SvTYPE(IoTOP_GV(sv)) == SVt_PVGV)
+ do_gv_dump (level, file, " TOP_GV", IoTOP_GV(sv));
+ else {
+ Perl_dump_indent(aTHX_ level, file, " TOP_GV = 0x%"UVxf"\n",
+ PTR2UV(IoTOP_GV(sv)));
+ do_sv_dump (level+1, file, (SV *) IoTOP_GV(sv), nest+1, maxnest,
+ dumpops, pvlim);
+ }
+ /* Source filters hide things that are not GVs in these three, so let's
+ be careful out there. */
if (IoFMT_NAME(sv))
Perl_dump_indent(aTHX_ level, file, " FMT_NAME = \"%s\"\n", IoFMT_NAME(sv));
- do_gv_dump (level, file, " FMT_GV", IoFMT_GV(sv));
+ if (!IoFMT_GV(sv) || SvTYPE(IoFMT_GV(sv)) == SVt_PVGV)
+ do_gv_dump (level, file, " FMT_GV", IoFMT_GV(sv));
+ else {
+ Perl_dump_indent(aTHX_ level, file, " FMT_GV = 0x%"UVxf"\n",
+ PTR2UV(IoFMT_GV(sv)));
+ do_sv_dump (level+1, file, (SV *) IoFMT_GV(sv), nest+1, maxnest,
+ dumpops, pvlim);
+ }
if (IoBOTTOM_NAME(sv))
Perl_dump_indent(aTHX_ level, file, " BOTTOM_NAME = \"%s\"\n", IoBOTTOM_NAME(sv));
- do_gv_dump (level, file, " BOTTOM_GV", IoBOTTOM_GV(sv));
+ if (!IoBOTTOM_GV(sv) || SvTYPE(IoBOTTOM_GV(sv)) == SVt_PVGV)
+ do_gv_dump (level, file, " BOTTOM_GV", IoBOTTOM_GV(sv));
+ else {
+ Perl_dump_indent(aTHX_ level, file, " BOTTOM_GV = 0x%"UVxf"\n",
+ PTR2UV(IoBOTTOM_GV(sv)));
+ do_sv_dump (level+1, file, (SV *) IoBOTTOM_GV(sv), nest+1, maxnest,
+ dumpops, pvlim);
+ }
Perl_dump_indent(aTHX_ level, file, " SUBPROCESS = %"IVdf"\n", (IV)IoSUBPROCESS(sv));
if (isPRINT(IoTYPE(sv)))
Perl_dump_indent(aTHX_ level, file, " TYPE = '%c'\n", IoTYPE(sv));
do {
PERL_ASYNC_CHECK();
if (PL_debug) {
- if (PL_watchaddr != 0 && *PL_watchaddr != PL_watchok)
+ if (PL_watchaddr && (*PL_watchaddr != PL_watchok))
PerlIO_printf(Perl_debug_log,
"WARNING: %"UVxf" changed from %"UVxf" to %"UVxf"\n",
PTR2UV(PL_watchaddr), PTR2UV(PL_watchok),
case OP_GVSV:
case OP_GV:
if (cGVOPo_gv) {
- SV *sv = newSV(0);
+ SV * const sv = newSV(0);
+#ifdef PERL_MAD
+ /* FIXME - is this making unwarranted assumptions about the
+ UTF-8 cleanliness of the dump file handle? */
+ SvUTF8_on(sv);
+#endif
gv_fullname3(sv, cGVOPo_gv, NULL);
PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
SvREFCNT_dec(sv);
case OP_PADHV:
{
/* print the lexical's name */
- CV *cv = deb_curcv(cxstack_ix);
+ CV * const cv = deb_curcv(cxstack_ix);
SV *sv;
if (cv) {
- AV * const padlist = CvPADLIST(cv);
+ AV * const padlist = CvPADLIST(cv);
AV * const comppad = (AV*)(*av_fetch(padlist, 0, FALSE));
sv = *av_fetch(comppad, o->op_targ, FALSE);
} else
sv = NULL;
if (sv)
- PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
+ PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
else
- PerlIO_printf(Perl_debug_log, "[%"UVuf"]", (UV)o->op_targ);
+ PerlIO_printf(Perl_debug_log, "[%"UVuf"]", (UV)o->op_targ);
}
break;
default:
S_deb_curcv(pTHX_ I32 ix)
{
dVAR;
- const PERL_CONTEXT *cx = &cxstack[ix];
+ const PERL_CONTEXT * const cx = &cxstack[ix];
if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT)
return cx->blk_sub.cv;
else if (CxTYPE(cx) == CXt_EVAL && !CxTRYBLOCK(cx))
}
}
+#ifdef PERL_MAD
+/*
+ * XML variants of most of the above routines
+ */
+
+STATIC void
+S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
+{
+ va_list args;
+ PerlIO_printf(file, "\n ");
+ va_start(args, pat);
+ xmldump_vindent(level, file, pat, &args);
+ va_end(args);
+}
+
+
+void
+Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
+{
+ va_list args;
+ va_start(args, pat);
+ xmldump_vindent(level, file, pat, &args);
+ va_end(args);
+}
+
+void
+Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
+{
+ PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
+ PerlIO_vprintf(file, pat, *args);
+}
+
+void
+Perl_xmldump_all(pTHX)
+{
+ PerlIO_setlinebuf(PL_xmlfp);
+ if (PL_main_root)
+ op_xmldump(PL_main_root);
+ if (PL_xmlfp != (PerlIO*)PerlIO_stdout())
+ PerlIO_close(PL_xmlfp);
+ PL_xmlfp = 0;
+}
+
+void
+Perl_xmldump_packsubs(pTHX_ const HV *stash)
+{
+ I32 i;
+ HE *entry;
+
+ if (!HvARRAY(stash))
+ return;
+ for (i = 0; i <= (I32) HvMAX(stash); i++) {
+ for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
+ GV *gv = (GV*)HeVAL(entry);
+ HV *hv;
+ if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
+ continue;
+ if (GvCVu(gv))
+ xmldump_sub(gv);
+ if (GvFORM(gv))
+ xmldump_form(gv);
+ if (HeKEY(entry)[HeKLEN(entry)-1] == ':'
+ && (hv = GvHV(gv)) && hv != PL_defstash)
+ xmldump_packsubs(hv); /* nested package */
+ }
+ }
+}
+
+void
+Perl_xmldump_sub(pTHX_ const GV *gv)
+{
+ SV *sv = sv_newmortal();
+
+ gv_fullname3(sv, gv, Nullch);
+ Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nSUB %s = ", SvPVX(sv));
+ if (CvXSUB(GvCV(gv)))
+ Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "(xsub 0x%"UVxf" %d)\n",
+ PTR2UV(CvXSUB(GvCV(gv))),
+ (int)CvXSUBANY(GvCV(gv)).any_i32);
+ else if (CvROOT(GvCV(gv)))
+ op_xmldump(CvROOT(GvCV(gv)));
+ else
+ Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "<undef>\n");
+}
+
+void
+Perl_xmldump_form(pTHX_ const GV *gv)
+{
+ SV *sv = sv_newmortal();
+
+ gv_fullname3(sv, gv, Nullch);
+ Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nFORMAT %s = ", SvPVX(sv));
+ if (CvROOT(GvFORM(gv)))
+ op_xmldump(CvROOT(GvFORM(gv)));
+ else
+ Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "<undef>\n");
+}
+
+void
+Perl_xmldump_eval(pTHX)
+{
+ op_xmldump(PL_eval_root);
+}
+
+char *
+Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv)
+{
+ return sv_catxmlpvn(dsv, SvPVX(ssv), SvCUR(ssv), SvUTF8(ssv));
+}
+
+char *
+Perl_sv_catxmlpvn(pTHX_ SV *dsv, char* pv, STRLEN len, int utf8)
+{
+ unsigned int c;
+ char *e = pv + len;
+ char *start = pv;
+ STRLEN dsvcur;
+ STRLEN cl;
+
+ sv_catpvn(dsv,"",0);
+ dsvcur = SvCUR(dsv); /* in case we have to restart */
+
+ retry:
+ while (pv < e) {
+ if (utf8) {
+ c = utf8_to_uvchr((U8*)pv, &cl);
+ if (cl == 0) {
+ SvCUR(dsv) = dsvcur;
+ pv = start;
+ utf8 = 0;
+ goto retry;
+ }
+ }
+ else
+ c = (*pv & 255);
+
+ switch (c) {
+ case 0x00:
+ case 0x01:
+ case 0x02:
+ case 0x03:
+ case 0x04:
+ case 0x05:
+ case 0x06:
+ case 0x07:
+ case 0x08:
+ case 0x0b:
+ case 0x0c:
+ case 0x0e:
+ case 0x0f:
+ case 0x10:
+ case 0x11:
+ case 0x12:
+ case 0x13:
+ case 0x14:
+ case 0x15:
+ case 0x16:
+ case 0x17:
+ case 0x18:
+ case 0x19:
+ case 0x1a:
+ case 0x1b:
+ case 0x1c:
+ case 0x1d:
+ case 0x1e:
+ case 0x1f:
+ case 0x7f:
+ case 0x80:
+ case 0x81:
+ case 0x82:
+ case 0x83:
+ case 0x84:
+ case 0x86:
+ case 0x87:
+ case 0x88:
+ case 0x89:
+ case 0x90:
+ case 0x91:
+ case 0x92:
+ case 0x93:
+ case 0x94:
+ case 0x95:
+ case 0x96:
+ case 0x97:
+ case 0x98:
+ case 0x99:
+ case 0x9a:
+ case 0x9b:
+ case 0x9c:
+ case 0x9d:
+ case 0x9e:
+ case 0x9f:
+ Perl_sv_catpvf(aTHX_ dsv, "STUPIDXML(#x%X)", c);
+ break;
+ case '<':
+ Perl_sv_catpvf(aTHX_ dsv, "<");
+ break;
+ case '>':
+ Perl_sv_catpvf(aTHX_ dsv, ">");
+ break;
+ case '&':
+ Perl_sv_catpvf(aTHX_ dsv, "&");
+ break;
+ case '"':
+ Perl_sv_catpvf(aTHX_ dsv, """);
+ break;
+ default:
+ if (c < 0xD800) {
+ if (c < 32 || c > 127) {
+ Perl_sv_catpvf(aTHX_ dsv, "&#x%X;", c);
+ }
+ else {
+ Perl_sv_catpvf(aTHX_ dsv, "%c", c);
+ }
+ break;
+ }
+ if ((c >= 0xD800 && c <= 0xDB7F) ||
+ (c >= 0xDC00 && c <= 0xDFFF) ||
+ (c >= 0xFFF0 && c <= 0xFFFF) ||
+ c > 0x10ffff)
+ Perl_sv_catpvf(aTHX_ dsv, "STUPIDXML(#x%X)", c);
+ else
+ Perl_sv_catpvf(aTHX_ dsv, "&#x%X;", c);
+ }
+
+ if (utf8)
+ pv += UTF8SKIP(pv);
+ else
+ pv++;
+ }
+
+ return SvPVX(dsv);
+}
+
+char *
+Perl_sv_xmlpeek(pTHX_ SV *sv)
+{
+ SV *t = sv_newmortal();
+ STRLEN n_a;
+ int unref = 0;
+
+ sv_utf8_upgrade(t);
+ sv_setpvn(t, "", 0);
+ /* retry: */
+ if (!sv) {
+ sv_catpv(t, "VOID=\"\"");
+ goto finish;
+ }
+ else if (sv == (SV*)0x55555555 || SvTYPE(sv) == 'U') {
+ sv_catpv(t, "WILD=\"\"");
+ goto finish;
+ }
+ else if (sv == &PL_sv_undef || sv == &PL_sv_no || sv == &PL_sv_yes || sv == &PL_sv_placeholder) {
+ if (sv == &PL_sv_undef) {
+ sv_catpv(t, "SV_UNDEF=\"1\"");
+ if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
+ SVs_GMG|SVs_SMG|SVs_RMG)) &&
+ SvREADONLY(sv))
+ goto finish;
+ }
+ else if (sv == &PL_sv_no) {
+ sv_catpv(t, "SV_NO=\"1\"");
+ if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
+ SVs_GMG|SVs_SMG|SVs_RMG)) &&
+ !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
+ SVp_POK|SVp_NOK)) &&
+ SvCUR(sv) == 0 &&
+ SvNVX(sv) == 0.0)
+ goto finish;
+ }
+ else if (sv == &PL_sv_yes) {
+ sv_catpv(t, "SV_YES=\"1\"");
+ if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
+ SVs_GMG|SVs_SMG|SVs_RMG)) &&
+ !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
+ SVp_POK|SVp_NOK)) &&
+ SvCUR(sv) == 1 &&
+ SvPVX(sv) && *SvPVX(sv) == '1' &&
+ SvNVX(sv) == 1.0)
+ goto finish;
+ }
+ else {
+ sv_catpv(t, "SV_PLACEHOLDER=\"1\"");
+ if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
+ SVs_GMG|SVs_SMG|SVs_RMG)) &&
+ SvREADONLY(sv))
+ goto finish;
+ }
+ sv_catpv(t, " XXX=\"\" ");
+ }
+ else if (SvREFCNT(sv) == 0) {
+ sv_catpv(t, " refcnt=\"0\"");
+ unref++;
+ }
+ else if (DEBUG_R_TEST_) {
+ int is_tmp = 0;
+ I32 ix;
+ /* is this SV on the tmps stack? */
+ for (ix=PL_tmps_ix; ix>=0; ix--) {
+ if (PL_tmps_stack[ix] == sv) {
+ is_tmp = 1;
+ break;
+ }
+ }
+ if (SvREFCNT(sv) > 1)
+ Perl_sv_catpvf(aTHX_ t, " DRT=\"<%"UVuf"%s>\"", (UV)SvREFCNT(sv),
+ is_tmp ? "T" : "");
+ else if (is_tmp)
+ sv_catpv(t, " DRT=\"<T>\"");
+ }
+
+ if (SvROK(sv)) {
+ sv_catpv(t, " ROK=\"\"");
+ }
+ switch (SvTYPE(sv)) {
+ default:
+ sv_catpv(t, " FREED=\"1\"");
+ goto finish;
+
+ case SVt_NULL:
+ sv_catpv(t, " UNDEF=\"1\"");
+ goto finish;
+ case SVt_IV:
+ sv_catpv(t, " IV=\"");
+ break;
+ case SVt_NV:
+ sv_catpv(t, " NV=\"");
+ break;
+ case SVt_RV:
+ sv_catpv(t, " RV=\"");
+ break;
+ case SVt_PV:
+ sv_catpv(t, " PV=\"");
+ break;
+ case SVt_PVIV:
+ sv_catpv(t, " PVIV=\"");
+ break;
+ case SVt_PVNV:
+ sv_catpv(t, " PVNV=\"");
+ break;
+ case SVt_PVMG:
+ sv_catpv(t, " PVMG=\"");
+ break;
+ case SVt_PVLV:
+ sv_catpv(t, " PVLV=\"");
+ break;
+ case SVt_PVAV:
+ sv_catpv(t, " AV=\"");
+ break;
+ case SVt_PVHV:
+ sv_catpv(t, " HV=\"");
+ break;
+ case SVt_PVCV:
+ if (CvGV(sv))
+ Perl_sv_catpvf(aTHX_ t, " CV=\"(%s)\"", GvNAME(CvGV(sv)));
+ else
+ sv_catpv(t, " CV=\"()\"");
+ goto finish;
+ case SVt_PVGV:
+ sv_catpv(t, " GV=\"");
+ break;
+ case SVt_BIND:
+ sv_catpv(t, " BIND=\"");
+ break;
+ case SVt_PVFM:
+ sv_catpv(t, " FM=\"");
+ break;
+ case SVt_PVIO:
+ sv_catpv(t, " IO=\"");
+ break;
+ }
+
+ if (SvPOKp(sv)) {
+ if (SvPVX(sv)) {
+ sv_catxmlsv(t, sv);
+ }
+ }
+ else if (SvNOKp(sv)) {
+ STORE_NUMERIC_LOCAL_SET_STANDARD();
+ Perl_sv_catpvf(aTHX_ t, "%"NVgf"",SvNVX(sv));
+ RESTORE_NUMERIC_LOCAL();
+ }
+ else if (SvIOKp(sv)) {
+ if (SvIsUV(sv))
+ Perl_sv_catpvf(aTHX_ t, "%"UVuf"", (UV)SvUVX(sv));
+ else
+ Perl_sv_catpvf(aTHX_ t, "%"IVdf"", (IV)SvIVX(sv));
+ }
+ else
+ sv_catpv(t, "");
+ sv_catpv(t, "\"");
+
+ finish:
+ if (unref) {
+ while (unref--)
+ sv_catpv(t, ")");
+ }
+ return SvPV(t, n_a);
+}
+
+void
+Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
+{
+ if (!pm) {
+ Perl_xmldump_indent(aTHX_ level, file, "<pmop/>\n");
+ return;
+ }
+ Perl_xmldump_indent(aTHX_ level, file, "<pmop \n");
+ level++;
+ if (PM_GETRE(pm)) {
+ char *s = PM_GETRE(pm)->precomp;
+ SV *tmpsv = newSVpvn("",0);
+ SvUTF8_on(tmpsv);
+ sv_catxmlpvn(tmpsv, s, strlen(s), 1);
+ Perl_xmldump_indent(aTHX_ level, file, "pre=\"%s\"\n",
+ SvPVX(tmpsv));
+ SvREFCNT_dec(tmpsv);
+ Perl_xmldump_indent(aTHX_ level, file, "when=\"%s\"\n",
+ (pm->op_private & OPpRUNTIME) ? "RUN" : "COMP");
+ }
+ else
+ Perl_xmldump_indent(aTHX_ level, file, "pre=\"\" when=\"RUN\"\n");
+ if (pm->op_pmflags || (PM_GETRE(pm) && PM_GETRE(pm)->check_substr)) {
+ SV * const tmpsv = pm_description(pm);
+ Perl_xmldump_indent(aTHX_ level, file, "pmflags=\"%s\"\n", SvCUR(tmpsv) ? SvPVX(tmpsv) + 1 : "");
+ SvREFCNT_dec(tmpsv);
+ }
+
+ level--;
+ if (pm->op_type != OP_PUSHRE && pm->op_pmreplrootu.op_pmreplroot) {
+ Perl_xmldump_indent(aTHX_ level, file, ">\n");
+ Perl_xmldump_indent(aTHX_ level+1, file, "<pm_repl>\n");
+ do_op_xmldump(level+2, file, pm->op_pmreplrootu.op_pmreplroot);
+ Perl_xmldump_indent(aTHX_ level+1, file, "</pm_repl>\n");
+ Perl_xmldump_indent(aTHX_ level, file, "</pmop>\n");
+ }
+ else
+ Perl_xmldump_indent(aTHX_ level, file, "/>\n");
+}
+
+void
+Perl_pmop_xmldump(pTHX_ const PMOP *pm)
+{
+ do_pmop_xmldump(0, PL_xmlfp, pm);
+}
+
+void
+Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
+{
+ UV seq;
+ int contents = 0;
+ if (!o)
+ return;
+ sequence(o);
+ seq = sequence_num(o);
+ Perl_xmldump_indent(aTHX_ level, file,
+ "<op_%s seq=\"%"UVuf" -> ",
+ OP_NAME(o),
+ seq);
+ level++;
+ if (o->op_next)
+ PerlIO_printf(file, seq ? "%"UVuf"\"" : "(%"UVuf")\"",
+ sequence_num(o->op_next));
+ else
+ PerlIO_printf(file, "DONE\"");
+
+ if (o->op_targ) {
+ if (o->op_type == OP_NULL)
+ {
+ PerlIO_printf(file, " was=\"%s\"", PL_op_name[o->op_targ]);
+ if (o->op_targ == OP_NEXTSTATE)
+ {
+ if (CopLINE(cCOPo))
+ PerlIO_printf(file, " line=\"%"UVuf"\"",
+ (UV)CopLINE(cCOPo));
+ if (CopSTASHPV(cCOPo))
+ PerlIO_printf(file, " package=\"%s\"",
+ CopSTASHPV(cCOPo));
+ if (cCOPo->cop_label)
+ PerlIO_printf(file, " label=\"%s\"",
+ cCOPo->cop_label);
+ }
+ }
+ else
+ PerlIO_printf(file, " targ=\"%ld\"", (long)o->op_targ);
+ }
+#ifdef DUMPADDR
+ PerlIO_printf(file, " addr=\"0x%"UVxf" => 0x%"UVxf"\"", (UV)o, (UV)o->op_next);
+#endif
+ if (o->op_flags) {
+ SV *tmpsv = newSVpvn("", 0);
+ switch (o->op_flags & OPf_WANT) {
+ case OPf_WANT_VOID:
+ sv_catpv(tmpsv, ",VOID");
+ break;
+ case OPf_WANT_SCALAR:
+ sv_catpv(tmpsv, ",SCALAR");
+ break;
+ case OPf_WANT_LIST:
+ sv_catpv(tmpsv, ",LIST");
+ break;
+ default:
+ sv_catpv(tmpsv, ",UNKNOWN");
+ break;
+ }
+ if (o->op_flags & OPf_KIDS)
+ sv_catpv(tmpsv, ",KIDS");
+ if (o->op_flags & OPf_PARENS)
+ sv_catpv(tmpsv, ",PARENS");
+ if (o->op_flags & OPf_STACKED)
+ sv_catpv(tmpsv, ",STACKED");
+ if (o->op_flags & OPf_REF)
+ sv_catpv(tmpsv, ",REF");
+ if (o->op_flags & OPf_MOD)
+ sv_catpv(tmpsv, ",MOD");
+ if (o->op_flags & OPf_SPECIAL)
+ sv_catpv(tmpsv, ",SPECIAL");
+ PerlIO_printf(file, " flags=\"%s\"", SvCUR(tmpsv) ? SvPVX(tmpsv) + 1 : "");
+ SvREFCNT_dec(tmpsv);
+ }
+ if (o->op_private) {
+ SV *tmpsv = newSVpvn("", 0);
+ if (PL_opargs[o->op_type] & OA_TARGLEX) {
+ if (o->op_private & OPpTARGET_MY)
+ sv_catpv(tmpsv, ",TARGET_MY");
+ }
+ else if (o->op_type == OP_LEAVESUB ||
+ o->op_type == OP_LEAVE ||
+ o->op_type == OP_LEAVESUBLV ||
+ o->op_type == OP_LEAVEWRITE) {
+ if (o->op_private & OPpREFCOUNTED)
+ sv_catpv(tmpsv, ",REFCOUNTED");
+ }
+ else if (o->op_type == OP_AASSIGN) {
+ if (o->op_private & OPpASSIGN_COMMON)
+ sv_catpv(tmpsv, ",COMMON");
+ }
+ else if (o->op_type == OP_SASSIGN) {
+ if (o->op_private & OPpASSIGN_BACKWARDS)
+ sv_catpv(tmpsv, ",BACKWARDS");
+ }
+ else if (o->op_type == OP_TRANS) {
+ if (o->op_private & OPpTRANS_SQUASH)
+ sv_catpv(tmpsv, ",SQUASH");
+ if (o->op_private & OPpTRANS_DELETE)
+ sv_catpv(tmpsv, ",DELETE");
+ if (o->op_private & OPpTRANS_COMPLEMENT)
+ sv_catpv(tmpsv, ",COMPLEMENT");
+ if (o->op_private & OPpTRANS_IDENTICAL)
+ sv_catpv(tmpsv, ",IDENTICAL");
+ if (o->op_private & OPpTRANS_GROWS)
+ sv_catpv(tmpsv, ",GROWS");
+ }
+ else if (o->op_type == OP_REPEAT) {
+ if (o->op_private & OPpREPEAT_DOLIST)
+ sv_catpv(tmpsv, ",DOLIST");
+ }
+ else if (o->op_type == OP_ENTERSUB ||
+ o->op_type == OP_RV2SV ||
+ o->op_type == OP_GVSV ||
+ o->op_type == OP_RV2AV ||
+ o->op_type == OP_RV2HV ||
+ o->op_type == OP_RV2GV ||
+ o->op_type == OP_AELEM ||
+ o->op_type == OP_HELEM )
+ {
+ if (o->op_type == OP_ENTERSUB) {
+ if (o->op_private & OPpENTERSUB_AMPER)
+ sv_catpv(tmpsv, ",AMPER");
+ if (o->op_private & OPpENTERSUB_DB)
+ sv_catpv(tmpsv, ",DB");
+ if (o->op_private & OPpENTERSUB_HASTARG)
+ sv_catpv(tmpsv, ",HASTARG");
+ if (o->op_private & OPpENTERSUB_NOPAREN)
+ sv_catpv(tmpsv, ",NOPAREN");
+ if (o->op_private & OPpENTERSUB_INARGS)
+ sv_catpv(tmpsv, ",INARGS");
+ if (o->op_private & OPpENTERSUB_NOMOD)
+ sv_catpv(tmpsv, ",NOMOD");
+ }
+ else {
+ switch (o->op_private & OPpDEREF) {
+ case OPpDEREF_SV:
+ sv_catpv(tmpsv, ",SV");
+ break;
+ case OPpDEREF_AV:
+ sv_catpv(tmpsv, ",AV");
+ break;
+ case OPpDEREF_HV:
+ sv_catpv(tmpsv, ",HV");
+ break;
+ }
+ if (o->op_private & OPpMAYBE_LVSUB)
+ sv_catpv(tmpsv, ",MAYBE_LVSUB");
+ }
+ if (o->op_type == OP_AELEM || o->op_type == OP_HELEM) {
+ if (o->op_private & OPpLVAL_DEFER)
+ sv_catpv(tmpsv, ",LVAL_DEFER");
+ }
+ else {
+ if (o->op_private & HINT_STRICT_REFS)
+ sv_catpv(tmpsv, ",STRICT_REFS");
+ if (o->op_private & OPpOUR_INTRO)
+ sv_catpv(tmpsv, ",OUR_INTRO");
+ }
+ }
+ else if (o->op_type == OP_CONST) {
+ if (o->op_private & OPpCONST_BARE)
+ sv_catpv(tmpsv, ",BARE");
+ if (o->op_private & OPpCONST_STRICT)
+ sv_catpv(tmpsv, ",STRICT");
+ if (o->op_private & OPpCONST_ARYBASE)
+ sv_catpv(tmpsv, ",ARYBASE");
+ if (o->op_private & OPpCONST_WARNING)
+ sv_catpv(tmpsv, ",WARNING");
+ if (o->op_private & OPpCONST_ENTERED)
+ sv_catpv(tmpsv, ",ENTERED");
+ }
+ else if (o->op_type == OP_FLIP) {
+ if (o->op_private & OPpFLIP_LINENUM)
+ sv_catpv(tmpsv, ",LINENUM");
+ }
+ else if (o->op_type == OP_FLOP) {
+ if (o->op_private & OPpFLIP_LINENUM)
+ sv_catpv(tmpsv, ",LINENUM");
+ }
+ else if (o->op_type == OP_RV2CV) {
+ if (o->op_private & OPpLVAL_INTRO)
+ sv_catpv(tmpsv, ",INTRO");
+ }
+ else if (o->op_type == OP_GV) {
+ if (o->op_private & OPpEARLY_CV)
+ sv_catpv(tmpsv, ",EARLY_CV");
+ }
+ else if (o->op_type == OP_LIST) {
+ if (o->op_private & OPpLIST_GUESSED)
+ sv_catpv(tmpsv, ",GUESSED");
+ }
+ else if (o->op_type == OP_DELETE) {
+ if (o->op_private & OPpSLICE)
+ sv_catpv(tmpsv, ",SLICE");
+ }
+ else if (o->op_type == OP_EXISTS) {
+ if (o->op_private & OPpEXISTS_SUB)
+ sv_catpv(tmpsv, ",EXISTS_SUB");
+ }
+ else if (o->op_type == OP_SORT) {
+ if (o->op_private & OPpSORT_NUMERIC)
+ sv_catpv(tmpsv, ",NUMERIC");
+ if (o->op_private & OPpSORT_INTEGER)
+ sv_catpv(tmpsv, ",INTEGER");
+ if (o->op_private & OPpSORT_REVERSE)
+ sv_catpv(tmpsv, ",REVERSE");
+ }
+ else if (o->op_type == OP_OPEN || o->op_type == OP_BACKTICK) {
+ if (o->op_private & OPpOPEN_IN_RAW)
+ sv_catpv(tmpsv, ",IN_RAW");
+ if (o->op_private & OPpOPEN_IN_CRLF)
+ sv_catpv(tmpsv, ",IN_CRLF");
+ if (o->op_private & OPpOPEN_OUT_RAW)
+ sv_catpv(tmpsv, ",OUT_RAW");
+ if (o->op_private & OPpOPEN_OUT_CRLF)
+ sv_catpv(tmpsv, ",OUT_CRLF");
+ }
+ else if (o->op_type == OP_EXIT) {
+ if (o->op_private & OPpEXIT_VMSISH)
+ sv_catpv(tmpsv, ",EXIT_VMSISH");
+ if (o->op_private & OPpHUSH_VMSISH)
+ sv_catpv(tmpsv, ",HUSH_VMSISH");
+ }
+ else if (o->op_type == OP_DIE) {
+ if (o->op_private & OPpHUSH_VMSISH)
+ sv_catpv(tmpsv, ",HUSH_VMSISH");
+ }
+ else if (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
+ if (OP_IS_FILETEST_ACCESS(o) && o->op_private & OPpFT_ACCESS)
+ sv_catpv(tmpsv, ",FT_ACCESS");
+ if (o->op_private & OPpFT_STACKED)
+ sv_catpv(tmpsv, ",FT_STACKED");
+ }
+ if (o->op_flags & OPf_MOD && o->op_private & OPpLVAL_INTRO)
+ sv_catpv(tmpsv, ",INTRO");
+ if (SvCUR(tmpsv))
+ S_xmldump_attr(aTHX_ level, file, "private=\"%s\"", SvPVX(tmpsv) + 1);
+ SvREFCNT_dec(tmpsv);
+ }
+
+ switch (o->op_type) {
+ case OP_AELEMFAST:
+ if (o->op_flags & OPf_SPECIAL) {
+ break;
+ }
+ case OP_GVSV:
+ case OP_GV:
+#ifdef USE_ITHREADS
+ S_xmldump_attr(aTHX_ level, file, "padix=\"%" IVdf "\"", (IV)cPADOPo->op_padix);
+#else
+ if (cSVOPo->op_sv) {
+ SV *tmpsv1 = newSV(0);
+ SV *tmpsv2 = newSVpvn("",0);
+ char *s;
+ STRLEN len;
+ SvUTF8_on(tmpsv1);
+ SvUTF8_on(tmpsv2);
+ ENTER;
+ SAVEFREESV(tmpsv1);
+ SAVEFREESV(tmpsv2);
+ gv_fullname3(tmpsv1, (GV*)cSVOPo->op_sv, Nullch);
+ s = SvPV(tmpsv1,len);
+ sv_catxmlpvn(tmpsv2, s, len, 1);
+ S_xmldump_attr(aTHX_ level, file, "gv=\"%s\"", SvPV(tmpsv2, len));
+ LEAVE;
+ }
+ else
+ S_xmldump_attr(aTHX_ level, file, "gv=\"NULL\"");
+#endif
+ break;
+ case OP_CONST:
+ case OP_METHOD_NAMED:
+#ifndef USE_ITHREADS
+ /* with ITHREADS, consts are stored in the pad, and the right pad
+ * may not be active here, so skip */
+ S_xmldump_attr(aTHX_ level, file, "%s", sv_xmlpeek(cSVOPo_sv));
+#endif
+ break;
+ case OP_ANONCODE:
+ if (!contents) {
+ contents = 1;
+ PerlIO_printf(file, ">\n");
+ }
+ do_op_xmldump(level+1, file, CvROOT(cSVOPo_sv));
+ break;
+ case OP_SETSTATE:
+ case OP_NEXTSTATE:
+ case OP_DBSTATE:
+ if (CopLINE(cCOPo))
+ S_xmldump_attr(aTHX_ level, file, "line=\"%"UVuf"\"",
+ (UV)CopLINE(cCOPo));
+ if (CopSTASHPV(cCOPo))
+ S_xmldump_attr(aTHX_ level, file, "package=\"%s\"",
+ CopSTASHPV(cCOPo));
+ if (cCOPo->cop_label)
+ S_xmldump_attr(aTHX_ level, file, "label=\"%s\"",
+ cCOPo->cop_label);
+ break;
+ case OP_ENTERLOOP:
+ S_xmldump_attr(aTHX_ level, file, "redo=\"");
+ if (cLOOPo->op_redoop)
+ PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOOPo->op_redoop));
+ else
+ PerlIO_printf(file, "DONE\"");
+ S_xmldump_attr(aTHX_ level, file, "next=\"");
+ if (cLOOPo->op_nextop)
+ PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOOPo->op_nextop));
+ else
+ PerlIO_printf(file, "DONE\"");
+ S_xmldump_attr(aTHX_ level, file, "last=\"");
+ if (cLOOPo->op_lastop)
+ PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOOPo->op_lastop));
+ else
+ PerlIO_printf(file, "DONE\"");
+ break;
+ case OP_COND_EXPR:
+ case OP_RANGE:
+ case OP_MAPWHILE:
+ case OP_GREPWHILE:
+ case OP_OR:
+ case OP_AND:
+ S_xmldump_attr(aTHX_ level, file, "other=\"");
+ if (cLOGOPo->op_other)
+ PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOGOPo->op_other));
+ else
+ PerlIO_printf(file, "DONE\"");
+ break;
+ case OP_LEAVE:
+ case OP_LEAVEEVAL:
+ case OP_LEAVESUB:
+ case OP_LEAVESUBLV:
+ case OP_LEAVEWRITE:
+ case OP_SCOPE:
+ if (o->op_private & OPpREFCOUNTED)
+ S_xmldump_attr(aTHX_ level, file, "refcnt=\"%"UVuf"\"", (UV)o->op_targ);
+ break;
+ default:
+ break;
+ }
+
+ if (PL_madskills && o->op_madprop) {
+ SV *tmpsv = newSVpvn("", 0);
+ MADPROP* mp = o->op_madprop;
+ sv_utf8_upgrade(tmpsv);
+ if (!contents) {
+ contents = 1;
+ PerlIO_printf(file, ">\n");
+ }
+ Perl_xmldump_indent(aTHX_ level, file, "<madprops>\n");
+ level++;
+ while (mp) {
+ char tmp = mp->mad_key;
+ sv_setpvn(tmpsv,"\"",1);
+ if (tmp)
+ sv_catxmlpvn(tmpsv, &tmp, 1, 0);
+ sv_catpv(tmpsv, "\"");
+ switch (mp->mad_type) {
+ case MAD_NULL:
+ sv_catpv(tmpsv, "NULL");
+ Perl_xmldump_indent(aTHX_ level, file, "<mad_null key=%s/>\n", SvPVX(tmpsv));
+ break;
+ case MAD_PV:
+ sv_catpv(tmpsv, " val=\"");
+ sv_catxmlpvn(tmpsv, (char*)mp->mad_val, mp->mad_vlen,1);
+ sv_catpv(tmpsv, "\"");
+ Perl_xmldump_indent(aTHX_ level, file, "<mad_pv key=%s/>\n", SvPVX(tmpsv));
+ break;
+ case MAD_SV:
+ sv_catpv(tmpsv, " val=\"");
+ sv_catxmlsv(tmpsv, (SV*)mp->mad_val);
+ sv_catpv(tmpsv, "\"");
+ Perl_xmldump_indent(aTHX_ level, file, "<mad_sv key=%s/>\n", SvPVX(tmpsv));
+ break;
+ case MAD_OP:
+ if ((OP*)mp->mad_val) {
+ Perl_xmldump_indent(aTHX_ level, file, "<mad_op key=%s>\n", SvPVX(tmpsv));
+ do_op_xmldump(level+1, file, (OP*)mp->mad_val);
+ Perl_xmldump_indent(aTHX_ level, file, "</mad_op>\n");
+ }
+ break;
+ default:
+ Perl_xmldump_indent(aTHX_ level, file, "<mad_unk key=%s/>\n", SvPVX(tmpsv));
+ break;
+ }
+ mp = mp->mad_next;
+ }
+ level--;
+ Perl_xmldump_indent(aTHX_ level, file, "</madprops>\n");
+
+ SvREFCNT_dec(tmpsv);
+ }
+
+ switch (o->op_type) {
+ case OP_PUSHRE:
+ case OP_MATCH:
+ case OP_QR:
+ case OP_SUBST:
+ if (!contents) {
+ contents = 1;
+ PerlIO_printf(file, ">\n");
+ }
+ do_pmop_xmldump(level, file, cPMOPo);
+ break;
+ default:
+ break;
+ }
+
+ if (o->op_flags & OPf_KIDS) {
+ OP *kid;
+ if (!contents) {
+ contents = 1;
+ PerlIO_printf(file, ">\n");
+ }
+ for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
+ do_op_xmldump(level, file, kid);
+ }
+
+ if (contents)
+ Perl_xmldump_indent(aTHX_ level-1, file, "</op_%s>\n", OP_NAME(o));
+ else
+ PerlIO_printf(file, " />\n");
+}
+
+void
+Perl_op_xmldump(pTHX_ const OP *o)
+{
+ do_op_xmldump(0, PL_xmlfp, o);
+}
+#endif
+
/*
* Local variables:
* c-indentation-style: bsd
https://perl5.git.perl.org / perl5.git / blobdiff