This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
https://perl5.git.perl.org / perl5.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
use more efficient sv_reftype_len() interface
[perl5.git] / dump.c
CommitLineData
a0d0e21e 1/* dump.c
a687059c 2 *
1129b882
NC		 3 * Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 * 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 by Larry Wall and others
a687059c 5 *
6e21c824
LW		 6 * You may distribute under the terms of either the GNU General Public
7 * License or the Artistic License, as specified in the README file.
8d063cd8 8 *
a0d0e21e
LW		 9 */
10
11/*
4ac71550
TC		 12 * 'You have talked long in your sleep, Frodo,' said Gandalf gently, 'and
13 * it has not been hard for me to read your mind and memory.'
14 *
15 * [p.220 of _The Lord of the Rings_, II/i: "Many Meetings"]
8d063cd8
LW		 16 */
17
166f8a29 18/* This file contains utility routines to dump the contents of SV and OP
61296642 19 * structures, as used by command-line options like -Dt and -Dx, and
166f8a29
DM		 20 * by Devel::Peek.
21 *
22 * It also holds the debugging version of the runops function.
23 */
24
8d063cd8 25#include "EXTERN.h"
864dbfa3 26#define PERL_IN_DUMP_C
8d063cd8 27#include "perl.h"
f722798b 28#include "regcomp.h"
0bd48802
AL		 29#include "proto.h"
30
8d063cd8 31
5357ca29
NC		 32static const char* const svtypenames[SVt_LAST] = {
33 "NULL",
1cb9cd50 34 "BIND",
5357ca29 35 "IV",
b53eecb4 36 "NV",
5357ca29
NC		 37 "PV",
38 "PVIV",
39 "PVNV",
40 "PVMG",
5c35adbb 41 "REGEXP",
5357ca29
NC		 42 "PVGV",
43 "PVLV",
44 "PVAV",
45 "PVHV",
46 "PVCV",
47 "PVFM",
48 "PVIO"
49};
50
51
52static const char* const svshorttypenames[SVt_LAST] = {
53 "UNDEF",
1cb9cd50 54 "BIND",
5357ca29 55 "IV",
b53eecb4 56 "NV",
5357ca29
NC		 57 "PV",
58 "PVIV",
59 "PVNV",
60 "PVMG",
5c35adbb 61 "REGEXP",
5357ca29
NC		 62 "GV",
63 "PVLV",
64 "AV",
65 "HV",
66 "CV",
67 "FM",
68 "IO"
69};
70
a0c2f4dd
NC		 71struct flag_to_name {
72 U32 flag;
73 const char *name;
74};
75
76static void
77S_append_flags(pTHX_ SV *sv, U32 flags, const struct flag_to_name *start,
78 const struct flag_to_name *const end)
79{
80 do {
81 if (flags & start->flag)
82 sv_catpv(sv, start->name);
83 } while (++start < end);
84}
85
86#define append_flags(sv, f, flags) \
cd431fde 87 S_append_flags(aTHX_ (sv), (f), (flags), C_ARRAY_END(flags))
a0c2f4dd
NC		 88
89
27da23d5 90#define Sequence PL_op_sequence
2814eb74 91
3967c732 92void
864dbfa3 93Perl_dump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
3967c732 94{
3967c732 95 va_list args;
7918f24d 96 PERL_ARGS_ASSERT_DUMP_INDENT;
3967c732 97 va_start(args, pat);
c5be433b 98 dump_vindent(level, file, pat, &args);
3967c732
JD		 99 va_end(args);
100}
8adcabd8
LW		 101
102void
c5be433b
GS		 103Perl_dump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
104{
97aff369 105 dVAR;
7918f24d 106 PERL_ARGS_ASSERT_DUMP_VINDENT;
c8db6e60 107 PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
c5be433b
GS		 108 PerlIO_vprintf(file, pat, *args);
109}
110
111void
864dbfa3 112Perl_dump_all(pTHX)
79072805 113{
712a6fe4 114 dump_all_perl(FALSE);
f0e3f042
CS		 115}
116
117void
118Perl_dump_all_perl(pTHX_ bool justperl)
119{
120
97aff369 121 dVAR;
760ac839 122 PerlIO_setlinebuf(Perl_debug_log);
3280af22 123 if (PL_main_root)
3967c732 124 op_dump(PL_main_root);
f0e3f042 125 dump_packsubs_perl(PL_defstash, justperl);
463ee0b2
LW		 126}
127
128void
e1ec3a88 129Perl_dump_packsubs(pTHX_ const HV *stash)
463ee0b2 130{
28eb953d 131 PERL_ARGS_ASSERT_DUMP_PACKSUBS;
f0e3f042
CS		 132 dump_packsubs_perl(stash, FALSE);
133}
134
135void
136Perl_dump_packsubs_perl(pTHX_ const HV *stash, bool justperl)
137{
97aff369 138 dVAR;
a0d0e21e 139 I32 i;
463ee0b2 140
28eb953d 141 PERL_ARGS_ASSERT_DUMP_PACKSUBS_PERL;
7918f24d 142
8990e307
LW		 143 if (!HvARRAY(stash))
144 return;
a0d0e21e 145 for (i = 0; i <= (I32) HvMAX(stash); i++) {
e1ec3a88 146 const HE *entry;
4db58590 147 for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
159b6efe 148 const GV * const gv = (const GV *)HeVAL(entry);
e29cdcb3
GS		 149 if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
150 continue;
8ebc5c01 151 if (GvCVu(gv))
f0e3f042 152 dump_sub_perl(gv, justperl);
85e6fe83
LW		 153 if (GvFORM(gv))
154 dump_form(gv);
61f9802b
AL		 155 if (HeKEY(entry)[HeKLEN(entry)-1] == ':') {
156 const HV * const hv = GvHV(gv);
157 if (hv && (hv != PL_defstash))
f0e3f042 158 dump_packsubs_perl(hv, justperl); /* nested package */
61f9802b 159 }
463ee0b2 160 }
79072805
LW		 161 }
162}
163
164void
e1ec3a88 165Perl_dump_sub(pTHX_ const GV *gv)
a687059c 166{
28eb953d 167 PERL_ARGS_ASSERT_DUMP_SUB;
f0e3f042
CS		 168 dump_sub_perl(gv, FALSE);
169}
170
171void
172Perl_dump_sub_perl(pTHX_ const GV *gv, bool justperl)
173{
174 SV * sv;
85e6fe83 175
28eb953d 176 PERL_ARGS_ASSERT_DUMP_SUB_PERL;
7918f24d 177
f0e3f042
CS		 178 if (justperl && (CvISXSUB(GvCV(gv)) || !CvROOT(GvCV(gv))))
179 return;
180
181 sv = sv_newmortal();
bd61b366 182 gv_fullname3(sv, gv, NULL);
b15aece3 183 Perl_dump_indent(aTHX_ 0, Perl_debug_log, "\nSUB %s = ", SvPVX_const(sv));
aed2304a 184 if (CvISXSUB(GvCV(gv)))
91f3b821
GS		 185 Perl_dump_indent(aTHX_ 0, Perl_debug_log, "(xsub 0x%"UVxf" %d)\n",
186 PTR2UV(CvXSUB(GvCV(gv))),
894356b3 187 (int)CvXSUBANY(GvCV(gv)).any_i32);
85e6fe83 188 else if (CvROOT(GvCV(gv)))
3967c732 189 op_dump(CvROOT(GvCV(gv)));
85e6fe83 190 else
cea2e8a9 191 Perl_dump_indent(aTHX_ 0, Perl_debug_log, "<undef>\n");
85e6fe83
LW		 192}
193
194void
e1ec3a88 195Perl_dump_form(pTHX_ const GV *gv)
85e6fe83 196{
b464bac0 197 SV * const sv = sv_newmortal();
85e6fe83 198
7918f24d
NC		 199 PERL_ARGS_ASSERT_DUMP_FORM;
200
bd61b366 201 gv_fullname3(sv, gv, NULL);
b15aece3 202 Perl_dump_indent(aTHX_ 0, Perl_debug_log, "\nFORMAT %s = ", SvPVX_const(sv));
85e6fe83 203 if (CvROOT(GvFORM(gv)))
3967c732 204 op_dump(CvROOT(GvFORM(gv)));
85e6fe83 205 else
cea2e8a9 206 Perl_dump_indent(aTHX_ 0, Perl_debug_log, "<undef>\n");
a687059c
LW		 207}
208
8adcabd8 209void
864dbfa3 210Perl_dump_eval(pTHX)
8d063cd8 211{
97aff369 212 dVAR;
3967c732
JD		 213 op_dump(PL_eval_root);
214}
215
3df15adc
YO		 216
217/*
87cea99e 218=for apidoc pv_escape
3df15adc
YO		 219
220Escapes at most the first "count" chars of pv and puts the results into
ab3bbdeb 221dsv such that the size of the escaped string will not exceed "max" chars
3df15adc
YO		 222and will not contain any incomplete escape sequences.
223
ab3bbdeb
YO		 224If flags contains PERL_PV_ESCAPE_QUOTE then any double quotes in the string
225will also be escaped.
3df15adc
YO		 226
227Normally the SV will be cleared before the escaped string is prepared,
ab3bbdeb
YO		 228but when PERL_PV_ESCAPE_NOCLEAR is set this will not occur.
229
38a44b82 230If PERL_PV_ESCAPE_UNI is set then the input string is treated as Unicode,
ab3bbdeb 231if PERL_PV_ESCAPE_UNI_DETECT is set then the input string is scanned
38a44b82 232using C<is_utf8_string()> to determine if it is Unicode.
ab3bbdeb
YO		 233
234If PERL_PV_ESCAPE_ALL is set then all input chars will be output
235using C<\x01F1> style escapes, otherwise only chars above 255 will be
236escaped using this style, other non printable chars will use octal or
237common escaped patterns like C<\n>. If PERL_PV_ESCAPE_NOBACKSLASH
238then all chars below 255 will be treated as printable and
239will be output as literals.
240
241If PERL_PV_ESCAPE_FIRSTCHAR is set then only the first char of the
242string will be escaped, regardles of max. If the string is utf8 and
243the chars value is >255 then it will be returned as a plain hex
244sequence. Thus the output will either be a single char,
245an octal escape sequence, a special escape like C<\n> or a 3 or
246more digit hex value.
3df15adc 247
44a2ac75
YO		 248If PERL_PV_ESCAPE_RE is set then the escape char used will be a '%' and
249not a '\\'. This is because regexes very often contain backslashed
250sequences, whereas '%' is not a particularly common character in patterns.
251
ab3bbdeb 252Returns a pointer to the escaped text as held by dsv.
3df15adc
YO		 253
254=cut
255*/
ab3bbdeb 256#define PV_ESCAPE_OCTBUFSIZE 32
ddc5bc0f 257
3967c732 258char *
ddc5bc0f 259Perl_pv_escape( pTHX_ SV *dsv, char const * const str,
ab3bbdeb
YO		 260 const STRLEN count, const STRLEN max,
261 STRLEN * const escaped, const U32 flags )
262{
61f9802b
AL		 263 const char esc = (flags & PERL_PV_ESCAPE_RE) ? '%' : '\\';
264 const char dq = (flags & PERL_PV_ESCAPE_QUOTE) ? '"' : esc;
44a2ac75 265 char octbuf[PV_ESCAPE_OCTBUFSIZE] = "%123456789ABCDF";
ab3bbdeb
YO		 266 STRLEN wrote = 0; /* chars written so far */
267 STRLEN chsize = 0; /* size of data to be written */
268 STRLEN readsize = 1; /* size of data just read */
38a44b82 269 bool isuni= flags & PERL_PV_ESCAPE_UNI ? 1 : 0; /* is this Unicode */
ddc5bc0f 270 const char *pv = str;
61f9802b 271 const char * const end = pv + count; /* end of string */
44a2ac75 272 octbuf[0] = esc;
ab3bbdeb 273
7918f24d
NC		 274 PERL_ARGS_ASSERT_PV_ESCAPE;
275
9ed8b5e5 276 if (!(flags & PERL_PV_ESCAPE_NOCLEAR)) {
7fddd944 277 /* This won't alter the UTF-8 flag */
76f68e9b 278 sv_setpvs(dsv, "");
7fddd944 279 }
ab3bbdeb 280
ddc5bc0f 281 if ((flags & PERL_PV_ESCAPE_UNI_DETECT) && is_utf8_string((U8*)pv, count))
ab3bbdeb
YO		 282 isuni = 1;
283
284 for ( ; (pv < end && (!max || (wrote < max))) ; pv += readsize ) {
ddc5bc0f 285 const UV u= (isuni) ? utf8_to_uvchr((U8*)pv, &readsize) : (U8)*pv;
ab3bbdeb
YO		 286 const U8 c = (U8)u & 0xFF;
287
288 if ( ( u > 255 ) || (flags & PERL_PV_ESCAPE_ALL)) {
289 if (flags & PERL_PV_ESCAPE_FIRSTCHAR)
290 chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
291 "%"UVxf, u);
292 else
293 chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
44a2ac75 294 "%cx{%"UVxf"}", esc, u);
ab3bbdeb
YO		 295 } else if (flags & PERL_PV_ESCAPE_NOBACKSLASH) {
296 chsize = 1;
297 } else {
44a2ac75
YO		 298 if ( (c == dq) || (c == esc) || !isPRINT(c) ) {
299 chsize = 2;
ab3bbdeb 300 switch (c) {
44a2ac75
YO		 301
302 case '\\' : /* fallthrough */
303 case '%' : if ( c == esc ) {
304 octbuf[1] = esc;
305 } else {
306 chsize = 1;
307 }
308 break;
3df15adc
YO		 309 case '\v' : octbuf[1] = 'v'; break;
310 case '\t' : octbuf[1] = 't'; break;
311 case '\r' : octbuf[1] = 'r'; break;
312 case '\n' : octbuf[1] = 'n'; break;
313 case '\f' : octbuf[1] = 'f'; break;
44a2ac75 314 case '"' :
ab3bbdeb 315 if ( dq == '"' )
3df15adc 316 octbuf[1] = '"';
ab3bbdeb
YO		 317 else
318 chsize = 1;
44a2ac75 319 break;
3df15adc 320 default:
ddc5bc0f 321 if ( (pv < end) && isDIGIT((U8)*(pv+readsize)) )
ab3bbdeb 322 chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
44a2ac75
YO		 323 "%c%03o", esc, c);
324 else
ab3bbdeb 325 chsize = my_snprintf( octbuf, PV_ESCAPE_OCTBUFSIZE,
44a2ac75 326 "%c%o", esc, c);
ab3bbdeb
YO		 327 }
328 } else {
44a2ac75 329 chsize = 1;
ab3bbdeb 330 }
44a2ac75
YO		 331 }
332 if ( max && (wrote + chsize > max) ) {
333 break;
ab3bbdeb 334 } else if (chsize > 1) {
44a2ac75
YO		 335 sv_catpvn(dsv, octbuf, chsize);
336 wrote += chsize;
3df15adc 337 } else {
7fddd944
NC		 338 /* If PERL_PV_ESCAPE_NOBACKSLASH is set then bytes in the range
339 128-255 can be appended raw to the dsv. If dsv happens to be
340 UTF-8 then we need catpvf to upgrade them for us.
341 Or add a new API call sv_catpvc(). Think about that name, and
342 how to keep it clear that it's unlike the s of catpvs, which is
343 really an array octets, not a string. */
344 Perl_sv_catpvf( aTHX_ dsv, "%c", c);
3df15adc
YO		 345 wrote++;
346 }
ab3bbdeb
YO		 347 if ( flags & PERL_PV_ESCAPE_FIRSTCHAR )
348 break;
3967c732 349 }
ab3bbdeb
YO		 350 if (escaped != NULL)
351 *escaped= pv - str;
352 return SvPVX(dsv);
353}
354/*
87cea99e 355=for apidoc pv_pretty
ab3bbdeb
YO		 356
357Converts a string into something presentable, handling escaping via
95b611b0 358pv_escape() and supporting quoting and ellipses.
ab3bbdeb
YO		 359
360If the PERL_PV_PRETTY_QUOTE flag is set then the result will be
361double quoted with any double quotes in the string escaped. Otherwise
362if the PERL_PV_PRETTY_LTGT flag is set then the result be wrapped in
363angle brackets.
364
95b611b0
RGS		 365If the PERL_PV_PRETTY_ELLIPSES flag is set and not all characters in
366string were output then an ellipsis C<...> will be appended to the
ab3bbdeb
YO		 367string. Note that this happens AFTER it has been quoted.
368
369If start_color is non-null then it will be inserted after the opening
370quote (if there is one) but before the escaped text. If end_color
371is non-null then it will be inserted after the escaped text but before
95b611b0 372any quotes or ellipses.
ab3bbdeb
YO		 373
374Returns a pointer to the prettified text as held by dsv.
375
376=cut
377*/
378
379char *
ddc5bc0f
YO		 380Perl_pv_pretty( pTHX_ SV *dsv, char const * const str, const STRLEN count,
381 const STRLEN max, char const * const start_color, char const * const end_color,
ab3bbdeb
YO		 382 const U32 flags )
383{
61f9802b 384 const U8 dq = (flags & PERL_PV_PRETTY_QUOTE) ? '"' : '%';
ab3bbdeb 385 STRLEN escaped;
7918f24d
NC		 386
387 PERL_ARGS_ASSERT_PV_PRETTY;
388
881a015e
NC		 389 if (!(flags & PERL_PV_PRETTY_NOCLEAR)) {
390 /* This won't alter the UTF-8 flag */
76f68e9b 391 sv_setpvs(dsv, "");
881a015e
NC		 392 }
393
ab3bbdeb 394 if ( dq == '"' )
76f68e9b 395 sv_catpvs(dsv, "\"");
ab3bbdeb 396 else if ( flags & PERL_PV_PRETTY_LTGT )
76f68e9b 397 sv_catpvs(dsv, "<");
ab3bbdeb
YO		 398
399 if ( start_color != NULL )
76f68e9b 400 sv_catpv(dsv, start_color);
ab3bbdeb
YO		 401
402 pv_escape( dsv, str, count, max, &escaped, flags | PERL_PV_ESCAPE_NOCLEAR );
403
404 if ( end_color != NULL )
76f68e9b 405 sv_catpv(dsv, end_color);
ab3bbdeb
YO		 406
407 if ( dq == '"' )
76f68e9b 408 sv_catpvs( dsv, "\"");
ab3bbdeb 409 else if ( flags & PERL_PV_PRETTY_LTGT )
76f68e9b 410 sv_catpvs(dsv, ">");
ab3bbdeb 411
95b611b0 412 if ( (flags & PERL_PV_PRETTY_ELLIPSES) && ( escaped < count ) )
76f68e9b 413 sv_catpvs(dsv, "...");
ab3bbdeb 414
3df15adc
YO		 415 return SvPVX(dsv);
416}
417
418/*
419=for apidoc pv_display
420
3df15adc 421Similar to
3967c732 422
3df15adc
YO		 423 pv_escape(dsv,pv,cur,pvlim,PERL_PV_ESCAPE_QUOTE);
424
425except that an additional "\0" will be appended to the string when
426len > cur and pv[cur] is "\0".
427
428Note that the final string may be up to 7 chars longer than pvlim.
429
430=cut
431*/
432
433char *
434Perl_pv_display(pTHX_ SV *dsv, const char *pv, STRLEN cur, STRLEN len, STRLEN pvlim)
435{
7918f24d
NC		 436 PERL_ARGS_ASSERT_PV_DISPLAY;
437
ddc5bc0f 438 pv_pretty( dsv, pv, cur, pvlim, NULL, NULL, PERL_PV_PRETTY_DUMP);
3df15adc 439 if (len > cur && pv[cur] == '\0')
76f68e9b 440 sv_catpvs( dsv, "\\0");
e6abe6d8
JH		 441 return SvPVX(dsv);
442}
443
444char *
864dbfa3 445Perl_sv_peek(pTHX_ SV *sv)
3967c732 446{
27da23d5 447 dVAR;
aec46f14 448 SV * const t = sv_newmortal();
3967c732 449 int unref = 0;
5357ca29 450 U32 type;
3967c732 451
76f68e9b 452 sv_setpvs(t, "");
3967c732
JD		 453 retry:
454 if (!sv) {
455 sv_catpv(t, "VOID");
456 goto finish;
457 }
ad64d0ec 458 else if (sv == (const SV *)0x55555555 || SvTYPE(sv) == 'U') {
3967c732
JD		 459 sv_catpv(t, "WILD");
460 goto finish;
461 }
7996736c 462 else if (sv == &PL_sv_undef || sv == &PL_sv_no || sv == &PL_sv_yes || sv == &PL_sv_placeholder) {
3967c732
JD		 463 if (sv == &PL_sv_undef) {
464 sv_catpv(t, "SV_UNDEF");
465 if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
466 SVs_GMG|SVs_SMG|SVs_RMG)) &&
467 SvREADONLY(sv))
468 goto finish;
469 }
470 else if (sv == &PL_sv_no) {
471 sv_catpv(t, "SV_NO");
472 if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
473 SVs_GMG|SVs_SMG|SVs_RMG)) &&
474 !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
475 SVp_POK|SVp_NOK)) &&
476 SvCUR(sv) == 0 &&
477 SvNVX(sv) == 0.0)
478 goto finish;
479 }
7996736c 480 else if (sv == &PL_sv_yes) {
3967c732
JD		 481 sv_catpv(t, "SV_YES");
482 if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
483 SVs_GMG|SVs_SMG|SVs_RMG)) &&
484 !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
485 SVp_POK|SVp_NOK)) &&
486 SvCUR(sv) == 1 &&
b15aece3 487 SvPVX_const(sv) && *SvPVX_const(sv) == '1' &&
3967c732
JD		 488 SvNVX(sv) == 1.0)
489 goto finish;
7996736c
MHM		 490 }
491 else {
492 sv_catpv(t, "SV_PLACEHOLDER");
493 if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
494 SVs_GMG|SVs_SMG|SVs_RMG)) &&
495 SvREADONLY(sv))
496 goto finish;
3967c732
JD		 497 }
498 sv_catpv(t, ":");
499 }
500 else if (SvREFCNT(sv) == 0) {
501 sv_catpv(t, "(");
502 unref++;
503 }
a3b4c9c6
DM		 504 else if (DEBUG_R_TEST_) {
505 int is_tmp = 0;
506 I32 ix;
507 /* is this SV on the tmps stack? */
508 for (ix=PL_tmps_ix; ix>=0; ix--) {
509 if (PL_tmps_stack[ix] == sv) {
510 is_tmp = 1;
511 break;
512 }
513 }
514 if (SvREFCNT(sv) > 1)
515 Perl_sv_catpvf(aTHX_ t, "<%"UVuf"%s>", (UV)SvREFCNT(sv),
516 is_tmp ? "T" : "");
517 else if (is_tmp)
518 sv_catpv(t, "<T>");
04932ac8
DM		 519 }
520
3967c732
JD		 521 if (SvROK(sv)) {
522 sv_catpv(t, "\\");
523 if (SvCUR(t) + unref > 10) {
b162af07 524 SvCUR_set(t, unref + 3);
3967c732
JD		 525 *SvEND(t) = '\0';
526 sv_catpv(t, "...");
527 goto finish;
528 }
ad64d0ec 529 sv = SvRV(sv);
3967c732
JD		 530 goto retry;
531 }
5357ca29
NC		 532 type = SvTYPE(sv);
533 if (type == SVt_PVCV) {
534 Perl_sv_catpvf(aTHX_ t, "CV(%s)", CvGV(sv) ? GvNAME(CvGV(sv)) : "");
3967c732 535 goto finish;
5357ca29
NC		 536 } else if (type < SVt_LAST) {
537 sv_catpv(t, svshorttypenames[type]);
3967c732 538
5357ca29
NC		 539 if (type == SVt_NULL)
540 goto finish;
541 } else {
542 sv_catpv(t, "FREED");
3967c732 543 goto finish;
3967c732
JD		 544 }
545
546 if (SvPOKp(sv)) {
b15aece3 547 if (!SvPVX_const(sv))
3967c732
JD		 548 sv_catpv(t, "(null)");
549 else {
b9ac451d 550 SV * const tmp = newSVpvs("");
3967c732 551 sv_catpv(t, "(");
5115136b
DM		 552 if (SvOOK(sv)) {
553 STRLEN delta;
554 SvOOK_offset(sv, delta);
555 Perl_sv_catpvf(aTHX_ t, "[%s]", pv_display(tmp, SvPVX_const(sv)-delta, delta, 0, 127));
556 }
b15aece3 557 Perl_sv_catpvf(aTHX_ t, "%s)", pv_display(tmp, SvPVX_const(sv), SvCUR(sv), SvLEN(sv), 127));
32639b87 558 if (SvUTF8(sv))
b2ff9928 559 Perl_sv_catpvf(aTHX_ t, " [UTF8 \"%s\"]",
e9569a7a 560 sv_uni_display(tmp, sv, 6 * SvCUR(sv),
c728cb41 561 UNI_DISPLAY_QQ));
3967c732
JD		 562 SvREFCNT_dec(tmp);
563 }
564 }
565 else if (SvNOKp(sv)) {
e54dc35b 566 STORE_NUMERIC_LOCAL_SET_STANDARD();
1779d84d 567 Perl_sv_catpvf(aTHX_ t, "(%"NVgf")",SvNVX(sv));
e54dc35b 568 RESTORE_NUMERIC_LOCAL();
3967c732 569 }
57def98f 570 else if (SvIOKp(sv)) {
cf2093f6 571 if (SvIsUV(sv))
57def98f 572 Perl_sv_catpvf(aTHX_ t, "(%"UVuf")", (UV)SvUVX(sv));
cf2093f6 573 else
57def98f 574 Perl_sv_catpvf(aTHX_ t, "(%"IVdf")", (IV)SvIVX(sv));
25da4f38 575 }
3967c732
JD		 576 else
577 sv_catpv(t, "()");
2ef28da1 578
3967c732 579 finish:
61f9802b
AL		 580 while (unref--)
581 sv_catpv(t, ")");
59b714e2
RGS		 582 if (PL_tainting && SvTAINTED(sv))
583 sv_catpv(t, " [tainted]");
8b6b16e7 584 return SvPV_nolen(t);
3967c732
JD		 585}
586
587void
6867be6d 588Perl_do_pmop_dump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
3967c732
JD		 589{
590 char ch;
591
7918f24d
NC		 592 PERL_ARGS_ASSERT_DO_PMOP_DUMP;
593
3967c732 594 if (!pm) {
cea2e8a9 595 Perl_dump_indent(aTHX_ level, file, "{}\n");
3967c732
JD		 596 return;
597 }
cea2e8a9 598 Perl_dump_indent(aTHX_ level, file, "{\n");
3967c732
JD		 599 level++;
600 if (pm->op_pmflags & PMf_ONCE)
601 ch = '?';
602 else
603 ch = '/';
aaa362c4 604 if (PM_GETRE(pm))
cea2e8a9 605 Perl_dump_indent(aTHX_ level, file, "PMf_PRE %c%s%c%s\n",
220fc49f 606 ch, RX_PRECOMP(PM_GETRE(pm)), ch,
3967c732
JD		 607 (pm->op_private & OPpRUNTIME) ? " (RUNTIME)" : "");
608 else
cea2e8a9 609 Perl_dump_indent(aTHX_ level, file, "PMf_PRE (RUNTIME)\n");
20e98b0f 610 if (pm->op_type != OP_PUSHRE && pm->op_pmreplrootu.op_pmreplroot) {
cea2e8a9 611 Perl_dump_indent(aTHX_ level, file, "PMf_REPL = ");
20e98b0f 612 op_dump(pm->op_pmreplrootu.op_pmreplroot);
3967c732 613 }
07bc277f 614 if (pm->op_pmflags || (PM_GETRE(pm) && RX_CHECK_SUBSTR(PM_GETRE(pm)))) {
4199688e 615 SV * const tmpsv = pm_description(pm);
b15aece3 616 Perl_dump_indent(aTHX_ level, file, "PMFLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
3967c732
JD		 617 SvREFCNT_dec(tmpsv);
618 }
619
cea2e8a9 620 Perl_dump_indent(aTHX_ level-1, file, "}\n");
3967c732
JD		 621}
622
a0c2f4dd
NC		 623const struct flag_to_name pmflags_flags_names[] = {
624 {PMf_CONST, ",CONST"},
625 {PMf_KEEP, ",KEEP"},
626 {PMf_GLOBAL, ",GLOBAL"},
627 {PMf_CONTINUE, ",CONTINUE"},
628 {PMf_RETAINT, ",RETAINT"},
629 {PMf_EVAL, ",EVAL"},
630 {PMf_NONDESTRUCT, ",NONDESTRUCT"},
631};
632
b9ac451d 633static SV *
4199688e
AL		 634S_pm_description(pTHX_ const PMOP *pm)
635{
636 SV * const desc = newSVpvs("");
61f9802b 637 const REGEXP * const regex = PM_GETRE(pm);
4199688e
AL		 638 const U32 pmflags = pm->op_pmflags;
639
7918f24d
NC		 640 PERL_ARGS_ASSERT_PM_DESCRIPTION;
641
4199688e
AL		 642 if (pmflags & PMf_ONCE)
643 sv_catpv(desc, ",ONCE");
c737faaf
YO		 644#ifdef USE_ITHREADS
645 if (SvREADONLY(PL_regex_pad[pm->op_pmoffset]))
646 sv_catpv(desc, ":USED");
647#else
648 if (pmflags & PMf_USED)
649 sv_catpv(desc, ":USED");
650#endif
c737faaf 651
68d4833d 652 if (regex) {
07bc277f 653 if (RX_EXTFLAGS(regex) & RXf_TAINTED)
68d4833d 654 sv_catpv(desc, ",TAINTED");
07bc277f
NC		 655 if (RX_CHECK_SUBSTR(regex)) {
656 if (!(RX_EXTFLAGS(regex) & RXf_NOSCAN))
68d4833d 657 sv_catpv(desc, ",SCANFIRST");
07bc277f 658 if (RX_EXTFLAGS(regex) & RXf_CHECK_ALL)
68d4833d
AB		 659 sv_catpv(desc, ",ALL");
660 }
07bc277f 661 if (RX_EXTFLAGS(regex) & RXf_SKIPWHITE)
68d4833d 662 sv_catpv(desc, ",SKIPWHITE");
4199688e 663 }
68d4833d 664
a0c2f4dd 665 append_flags(desc, pmflags, pmflags_flags_names);
4199688e
AL		 666 return desc;
667}
668
3967c732 669void
864dbfa3 670Perl_pmop_dump(pTHX_ PMOP *pm)
3967c732
JD		 671{
672 do_pmop_dump(0, Perl_debug_log, pm);
79072805
LW		 673}
674
2814eb74
PJ		 675/* An op sequencer. We visit the ops in the order they're to execute. */
676
677STATIC void
0bd48802 678S_sequence(pTHX_ register const OP *o)
2814eb74 679{
27da23d5 680 dVAR;
c445ea15 681 const OP *oldop = NULL;
2814eb74 682
2814eb74
PJ		 683 if (!o)
684 return;
685
3b721df9
NC		 686#ifdef PERL_MAD
687 if (o->op_next == 0)
688 return;
689#endif
690
724e67cb
RGS		 691 if (!Sequence)
692 Sequence = newHV();
2814eb74
PJ		 693
694 for (; o; o = o->op_next) {
294b3b39
AL		 695 STRLEN len;
696 SV * const op = newSVuv(PTR2UV(o));
697 const char * const key = SvPV_const(op, len);
698
2814eb74
PJ		 699 if (hv_exists(Sequence, key, len))
700 break;
701
702 switch (o->op_type) {
703 case OP_STUB:
704 if ((o->op_flags & OPf_WANT) != OPf_WANT_LIST) {
04fe65b0 705 (void)hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
2814eb74
PJ		 706 break;
707 }
708 goto nothin;
709 case OP_NULL:
3b721df9
NC		 710#ifdef PERL_MAD
711 if (o == o->op_next)
712 return;
713#endif
2814eb74
PJ		 714 if (oldop && o->op_next)
715 continue;
716 break;
717 case OP_SCALAR:
718 case OP_LINESEQ:
719 case OP_SCOPE:
720 nothin:
721 if (oldop && o->op_next)
722 continue;
04fe65b0 723 (void)hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
2814eb74
PJ		 724 break;
725
726 case OP_MAPWHILE:
727 case OP_GREPWHILE:
728 case OP_AND:
729 case OP_OR:
730 case OP_DOR:
731 case OP_ANDASSIGN:
732 case OP_ORASSIGN:
733 case OP_DORASSIGN:
734 case OP_COND_EXPR:
735 case OP_RANGE:
04fe65b0 736 (void)hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
294b3b39 737 sequence_tail(cLOGOPo->op_other);
2814eb74
PJ		 738 break;
739
740 case OP_ENTERLOOP:
741 case OP_ENTERITER:
04fe65b0 742 (void)hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
294b3b39
AL		 743 sequence_tail(cLOOPo->op_redoop);
744 sequence_tail(cLOOPo->op_nextop);
745 sequence_tail(cLOOPo->op_lastop);
2814eb74
PJ		 746 break;
747
2814eb74 748 case OP_SUBST:
04fe65b0 749 (void)hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
29f2e912 750 sequence_tail(cPMOPo->op_pmstashstartu.op_pmreplstart);
2814eb74
PJ		 751 break;
752
29f2e912
NC		 753 case OP_QR:
754 case OP_MATCH:
2814eb74
PJ		 755 case OP_HELEM:
756 break;
757
758 default:
04fe65b0 759 (void)hv_store(Sequence, key, len, newSVuv(++PL_op_seq), 0);
2814eb74
PJ		 760 break;
761 }
762 oldop = o;
763 }
764}
765
294b3b39
AL		 766static void
767S_sequence_tail(pTHX_ const OP *o)
768{
769 while (o && (o->op_type == OP_NULL))
770 o = o->op_next;
771 sequence(o);
772}
773
2814eb74 774STATIC UV
0bd48802 775S_sequence_num(pTHX_ const OP *o)
2814eb74 776{
27da23d5 777 dVAR;
2814eb74
PJ		 778 SV *op,
779 **seq;
93524f2b 780 const char *key;
2814eb74
PJ		 781 STRLEN len;
782 if (!o) return 0;
c0fd1b42 783 op = newSVuv(PTR2UV(o));
93524f2b 784 key = SvPV_const(op, len);
2814eb74
PJ		 785 seq = hv_fetch(Sequence, key, len, 0);
786 return seq ? SvUV(*seq): 0;
787}
788
a0c2f4dd
NC		 789const struct flag_to_name op_flags_names[] = {
790 {OPf_KIDS, ",KIDS"},
791 {OPf_PARENS, ",PARENS"},
a0c2f4dd
NC		 792 {OPf_REF, ",REF"},
793 {OPf_MOD, ",MOD"},
65cccc5e 794 {OPf_STACKED, ",STACKED"},
a0c2f4dd
NC		 795 {OPf_SPECIAL, ",SPECIAL"}
796};
797
ea9ad1f2 798const struct flag_to_name op_trans_names[] = {
65cccc5e
VP		 799 {OPpTRANS_FROM_UTF, ",FROM_UTF"},
800 {OPpTRANS_TO_UTF, ",TO_UTF"},
801 {OPpTRANS_IDENTICAL, ",IDENTICAL"},
ea9ad1f2 802 {OPpTRANS_SQUASH, ",SQUASH"},
ea9ad1f2 803 {OPpTRANS_COMPLEMENT, ",COMPLEMENT"},
65cccc5e
VP		 804 {OPpTRANS_GROWS, ",GROWS"},
805 {OPpTRANS_DELETE, ",DELETE"}
ea9ad1f2
NC		 806};
807
808const struct flag_to_name op_entersub_names[] = {
ea9ad1f2
NC		 809 {OPpENTERSUB_DB, ",DB"},
810 {OPpENTERSUB_HASTARG, ",HASTARG"},
65cccc5e
VP		 811 {OPpENTERSUB_NOMOD, ",NOMOD"},
812 {OPpENTERSUB_AMPER, ",AMPER"},
ea9ad1f2 813 {OPpENTERSUB_NOPAREN, ",NOPAREN"},
65cccc5e 814 {OPpENTERSUB_INARGS, ",INARGS"}
ea9ad1f2
NC		 815};
816
817const struct flag_to_name op_const_names[] = {
65cccc5e
VP		 818 {OPpCONST_NOVER, ",NOVER"},
819 {OPpCONST_SHORTCIRCUIT, ",SHORTCIRCUIT"},
ea9ad1f2 820 {OPpCONST_STRICT, ",STRICT"},
65cccc5e 821 {OPpCONST_ENTERED, ",ENTERED"},
ea9ad1f2 822 {OPpCONST_ARYBASE, ",ARYBASE"},
65cccc5e
VP		 823 {OPpCONST_BARE, ",BARE"},
824 {OPpCONST_WARNING, ",WARNING"}
ea9ad1f2
NC		 825};
826
827const struct flag_to_name op_sort_names[] = {
828 {OPpSORT_NUMERIC, ",NUMERIC"},
829 {OPpSORT_INTEGER, ",INTEGER"},
65cccc5e
VP		 830 {OPpSORT_REVERSE, ",REVERSE"},
831 {OPpSORT_INPLACE, ",INPLACE"},
832 {OPpSORT_DESCEND, ",DESCEND"},
833 {OPpSORT_QSORT, ",QSORT"},
834 {OPpSORT_STABLE, ",STABLE"}
ea9ad1f2
NC		 835};
836
837const struct flag_to_name op_open_names[] = {
838 {OPpOPEN_IN_RAW, ",IN_RAW"},
839 {OPpOPEN_IN_CRLF, ",IN_CRLF"},
840 {OPpOPEN_OUT_RAW, ",OUT_RAW"},
841 {OPpOPEN_OUT_CRLF, ",OUT_CRLF"}
842};
843
261c990e
NC		 844const struct flag_to_name op_exit_names[] = {
845 {OPpEXIT_VMSISH, ",EXIT_VMSISH"},
846 {OPpHUSH_VMSISH, ",HUSH_VMSISH"}
847};
848
849#define OP_PRIVATE_ONCE(op, flag, name) \
850 const struct flag_to_name CAT2(op, _names)[] = { \
851 {(flag), (name)} \
f58883a1 852 }
261c990e
NC		 853
854OP_PRIVATE_ONCE(op_aassign, OPpASSIGN_COMMON, ",COMMON");
855OP_PRIVATE_ONCE(op_leavesub, OPpREFCOUNTED, ",REFCOUNTED");
856OP_PRIVATE_ONCE(op_sassign, OPpASSIGN_BACKWARDS, ",BACKWARDS");
857OP_PRIVATE_ONCE(op_repeat, OPpREPEAT_DOLIST, ",DOLIST");
65cccc5e 858OP_PRIVATE_ONCE(op_reverse, OPpREVERSE_INPLACE, ",INPLACE");
261c990e
NC		 859OP_PRIVATE_ONCE(op_rv2cv, OPpLVAL_INTRO, ",INTRO");
860OP_PRIVATE_ONCE(op_flip, OPpFLIP_LINENUM, ",LINENUM");
861OP_PRIVATE_ONCE(op_gv, OPpEARLY_CV, ",EARLY_CV");
862OP_PRIVATE_ONCE(op_list, OPpLIST_GUESSED, ",GUESSED");
863OP_PRIVATE_ONCE(op_delete, OPpSLICE, ",SLICE");
864OP_PRIVATE_ONCE(op_exists, OPpEXISTS_SUB, ",EXISTS_SUB");
865OP_PRIVATE_ONCE(op_die, OPpHUSH_VMSISH, ",HUSH_VMSISH");
866
1fe3abee
NC		 867struct op_private_by_op {
868 U16 op_type;
869 U16 len;
870 const struct flag_to_name *start;
871};
872
873const struct op_private_by_op op_private_names[] = {
261c990e
NC		 874 {OP_LEAVESUB, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
875 {OP_LEAVE, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
876 {OP_LEAVESUBLV, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
877 {OP_LEAVEWRITE, C_ARRAY_LENGTH(op_leavesub_names), op_leavesub_names },
878 {OP_AASSIGN, C_ARRAY_LENGTH(op_aassign_names), op_aassign_names },
879 {OP_DIE, C_ARRAY_LENGTH(op_die_names), op_die_names },
880 {OP_DELETE, C_ARRAY_LENGTH(op_delete_names), op_delete_names },
881 {OP_EXISTS, C_ARRAY_LENGTH(op_exists_names), op_exists_names },
882 {OP_EXIT, C_ARRAY_LENGTH(op_exit_names), op_exit_names },
883 {OP_FLIP, C_ARRAY_LENGTH(op_flip_names), op_flip_names },
884 {OP_FLOP, C_ARRAY_LENGTH(op_flip_names), op_flip_names },
885 {OP_GV, C_ARRAY_LENGTH(op_gv_names), op_gv_names },
886 {OP_LIST, C_ARRAY_LENGTH(op_list_names), op_list_names },
887 {OP_SASSIGN, C_ARRAY_LENGTH(op_sassign_names), op_sassign_names },
888 {OP_REPEAT, C_ARRAY_LENGTH(op_repeat_names), op_repeat_names },
889 {OP_RV2CV, C_ARRAY_LENGTH(op_rv2cv_names), op_rv2cv_names },
1fe3abee
NC		 890 {OP_TRANS, C_ARRAY_LENGTH(op_trans_names), op_trans_names },
891 {OP_CONST, C_ARRAY_LENGTH(op_const_names), op_const_names },
892 {OP_SORT, C_ARRAY_LENGTH(op_sort_names), op_sort_names },
893 {OP_OPEN, C_ARRAY_LENGTH(op_open_names), op_open_names },
894 {OP_BACKTICK, C_ARRAY_LENGTH(op_open_names), op_open_names }
895};
896
897static bool
898S_op_private_to_names(pTHX_ SV *tmpsv, U32 optype, U32 op_private) {
899 const struct op_private_by_op *start = op_private_names;
900 const struct op_private_by_op *const end
901 = op_private_names + C_ARRAY_LENGTH(op_private_names);
902
903 /* This is a linear search, but no worse than the code that it replaced.
904 It's debugging code - size is more important than speed. */
905 do {
906 if (optype == start->op_type) {
907 S_append_flags(aTHX_ tmpsv, op_private, start->start,
908 start->start + start->len);
909 return TRUE;
910 }
911 } while (++start < end);
912 return FALSE;
913}
914
79072805 915void
6867be6d 916Perl_do_op_dump(pTHX_ I32 level, PerlIO *file, const OP *o)
79072805 917{
27da23d5 918 dVAR;
2814eb74 919 UV seq;
e15d5972
AL		 920 const OPCODE optype = o->op_type;
921
7918f24d
NC		 922 PERL_ARGS_ASSERT_DO_OP_DUMP;
923
0bd48802 924 sequence(o);
cea2e8a9 925 Perl_dump_indent(aTHX_ level, file, "{\n");
3967c732 926 level++;
0bd48802 927 seq = sequence_num(o);
2814eb74 928 if (seq)
f5992bc4 929 PerlIO_printf(file, "%-4"UVuf, seq);
93a17b20 930 else
3967c732 931 PerlIO_printf(file, " ");
c8db6e60
JH		 932 PerlIO_printf(file,
933 "%*sTYPE = %s ===> ",
53e06cf0 934 (int)(PL_dumpindent*level-4), "", OP_NAME(o));
2814eb74 935 if (o->op_next)
f5992bc4 936 PerlIO_printf(file, seq ? "%"UVuf"\n" : "(%"UVuf")\n",
666ea192 937 sequence_num(o->op_next));
79072805 938 else
3967c732 939 PerlIO_printf(file, "DONE\n");
11343788 940 if (o->op_targ) {
e15d5972 941 if (optype == OP_NULL) {
cea2e8a9 942 Perl_dump_indent(aTHX_ level, file, " (was %s)\n", PL_op_name[o->op_targ]);
e15d5972 943 if (o->op_targ == OP_NEXTSTATE) {
ae7d165c 944 if (CopLINE(cCOPo))
f5992bc4 945 Perl_dump_indent(aTHX_ level, file, "LINE = %"UVuf"\n",
9d98dee5 946 (UV)CopLINE(cCOPo));
ae7d165c
PJ		 947 if (CopSTASHPV(cCOPo))
948 Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
949 CopSTASHPV(cCOPo));
4b65a919 950 if (CopLABEL(cCOPo))
ae7d165c 951 Perl_dump_indent(aTHX_ level, file, "LABEL = \"%s\"\n",
4b65a919 952 CopLABEL(cCOPo));
ae7d165c
PJ		 953 }
954 }
8990e307 955 else
894356b3 956 Perl_dump_indent(aTHX_ level, file, "TARG = %ld\n", (long)o->op_targ);
8990e307 957 }
748a9306 958#ifdef DUMPADDR
57def98f 959 Perl_dump_indent(aTHX_ level, file, "ADDR = 0x%"UVxf" => 0x%"UVxf"\n", (UV)o, (UV)o->op_next);
79072805 960#endif
7e5d8ed2 961 if (o->op_flags || o->op_latefree || o->op_latefreed || o->op_attached) {
e15d5972 962 SV * const tmpsv = newSVpvs("");
5dc0d613 963 switch (o->op_flags & OPf_WANT) {
54310121 964 case OPf_WANT_VOID:
46fc3d4c 965 sv_catpv(tmpsv, ",VOID");
54310121 966 break;
967 case OPf_WANT_SCALAR:
46fc3d4c 968 sv_catpv(tmpsv, ",SCALAR");
54310121 969 break;
970 case OPf_WANT_LIST:
46fc3d4c 971 sv_catpv(tmpsv, ",LIST");
54310121 972 break;
973 default:
46fc3d4c 974 sv_catpv(tmpsv, ",UNKNOWN");
54310121 975 break;
976 }
a0c2f4dd 977 append_flags(tmpsv, o->op_flags, op_flags_names);
29522234
DM		 978 if (o->op_latefree)
979 sv_catpv(tmpsv, ",LATEFREE");
980 if (o->op_latefreed)
981 sv_catpv(tmpsv, ",LATEFREED");
7e5d8ed2
DM		 982 if (o->op_attached)
983 sv_catpv(tmpsv, ",ATTACHED");
b15aece3 984 Perl_dump_indent(aTHX_ level, file, "FLAGS = (%s)\n", SvCUR(tmpsv) ? SvPVX_const(tmpsv) + 1 : "");
46fc3d4c 985 SvREFCNT_dec(tmpsv);
79072805 986 }
11343788 987 if (o->op_private) {
e15d5972
AL		 988 SV * const tmpsv = newSVpvs("");
989 if (PL_opargs[optype] & OA_TARGLEX) {
07447971
GS		 990 if (o->op_private & OPpTARGET_MY)
991 sv_catpv(tmpsv, ",TARGET_MY");
992 }
e15d5972 993 else if (optype == OP_ENTERSUB ||
5c135d48
NC		 994 optype == OP_RV2SV ||
995 optype == OP_GVSV ||
996 optype == OP_RV2AV ||
997 optype == OP_RV2HV ||
998 optype == OP_RV2GV ||
999 optype == OP_AELEM ||
1000 optype == OP_HELEM )
85e6fe83 1001 {
e15d5972 1002 if (optype == OP_ENTERSUB) {
ea9ad1f2 1003 append_flags(tmpsv, o->op_private, op_entersub_names);
68dc0745 1004 }
bf91b999 1005 else {
d3011074 1006 switch (o->op_private & OPpDEREF) {
b9ac451d
AL		 1007 case OPpDEREF_SV:
1008 sv_catpv(tmpsv, ",SV");
1009 break;
1010 case OPpDEREF_AV:
1011 sv_catpv(tmpsv, ",AV");
1012 break;
1013 case OPpDEREF_HV:
1014 sv_catpv(tmpsv, ",HV");
1015 break;
1016 }
bf91b999
SC		 1017 if (o->op_private & OPpMAYBE_LVSUB)
1018 sv_catpv(tmpsv, ",MAYBE_LVSUB");
1019 }
0824d667
DM		 1020
1021 if ((optype==OP_RV2SV || optype==OP_RV2AV || optype==OP_RV2HV)
1022 && (o->op_private & OPpDEREFed))
1023 sv_catpv(tmpsv, ",DEREFed");
1024
e15d5972 1025 if (optype == OP_AELEM || optype == OP_HELEM) {
5dc0d613 1026 if (o->op_private & OPpLVAL_DEFER)
46fc3d4c 1027 sv_catpv(tmpsv, ",LVAL_DEFER");
68dc0745 1028 }
1029 else {
5dc0d613 1030 if (o->op_private & HINT_STRICT_REFS)
46fc3d4c 1031 sv_catpv(tmpsv, ",STRICT_REFS");
192587c2
GS		 1032 if (o->op_private & OPpOUR_INTRO)
1033 sv_catpv(tmpsv, ",OUR_INTRO");
68dc0745 1034 }
8d063cd8 1035 }
1fe3abee
NC		 1036 else if (S_op_private_to_names(aTHX_ tmpsv, optype, o->op_private)) {
1037 }
e15d5972 1038 else if (PL_check[optype] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
6ecf81d6 1039 if (OP_IS_FILETEST_ACCESS(o->op_type) && o->op_private & OPpFT_ACCESS)
fbb0b3b3
RGS		 1040 sv_catpv(tmpsv, ",FT_ACCESS");
1041 if (o->op_private & OPpFT_STACKED)
1042 sv_catpv(tmpsv, ",FT_STACKED");
1af34c76 1043 }
11343788 1044 if (o->op_flags & OPf_MOD && o->op_private & OPpLVAL_INTRO)
46fc3d4c 1045 sv_catpv(tmpsv, ",INTRO");
1046 if (SvCUR(tmpsv))
b15aece3 1047 Perl_dump_indent(aTHX_ level, file, "PRIVATE = (%s)\n", SvPVX_const(tmpsv) + 1);
46fc3d4c 1048 SvREFCNT_dec(tmpsv);
8d063cd8 1049 }
8d063cd8 1050
3b721df9
NC		 1051#ifdef PERL_MAD
1052 if (PL_madskills && o->op_madprop) {
76f68e9b 1053 SV * const tmpsv = newSVpvs("");
3b721df9
NC		 1054 MADPROP* mp = o->op_madprop;
1055 Perl_dump_indent(aTHX_ level, file, "MADPROPS = {\n");
1056 level++;
1057 while (mp) {
61f9802b 1058 const char tmp = mp->mad_key;
76f68e9b 1059 sv_setpvs(tmpsv,"'");
3b721df9
NC		 1060 if (tmp)
1061 sv_catpvn(tmpsv, &tmp, 1);
1062 sv_catpv(tmpsv, "'=");
1063 switch (mp->mad_type) {
1064 case MAD_NULL:
1065 sv_catpv(tmpsv, "NULL");
1066 Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
1067 break;
1068 case MAD_PV:
1069 sv_catpv(tmpsv, "<");
1070 sv_catpvn(tmpsv, (char*)mp->mad_val, mp->mad_vlen);
1071 sv_catpv(tmpsv, ">");
1072 Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
1073 break;
1074 case MAD_OP:
1075 if ((OP*)mp->mad_val) {
1076 Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
1077 do_op_dump(level, file, (OP*)mp->mad_val);
1078 }
1079 break;
1080 default:
1081 sv_catpv(tmpsv, "(UNK)");
1082 Perl_dump_indent(aTHX_ level, file, "%s\n", SvPVX(tmpsv));
1083 break;
1084 }
1085 mp = mp->mad_next;
1086 }
1087 level--;
1088 Perl_dump_indent(aTHX_ level, file, "}\n");
1089
1090 SvREFCNT_dec(tmpsv);
1091 }
1092#endif
1093
e15d5972 1094 switch (optype) {
971a9dd3 1095 case OP_AELEMFAST:
93a17b20 1096 case OP_GVSV:
79072805 1097 case OP_GV:
971a9dd3 1098#ifdef USE_ITHREADS
c803eecc 1099 Perl_dump_indent(aTHX_ level, file, "PADIX = %" IVdf "\n", (IV)cPADOPo->op_padix);
971a9dd3 1100#else
1640e9f0 1101 if ( ! (o->op_flags & OPf_SPECIAL)) { /* not lexical */
38c076c7 1102 if (cSVOPo->op_sv) {
d4c19fe8 1103 SV * const tmpsv = newSV(0);
38c076c7
DM		 1104 ENTER;
1105 SAVEFREESV(tmpsv);
3b721df9 1106#ifdef PERL_MAD
84021b46 1107 /* FIXME - is this making unwarranted assumptions about the
3b721df9
NC		 1108 UTF-8 cleanliness of the dump file handle? */
1109 SvUTF8_on(tmpsv);
1110#endif
159b6efe 1111 gv_fullname3(tmpsv, MUTABLE_GV(cSVOPo->op_sv), NULL);
8b6b16e7 1112 Perl_dump_indent(aTHX_ level, file, "GV = %s\n",
d5263905 1113 SvPV_nolen_const(tmpsv));
38c076c7
DM		 1114 LEAVE;
1115 }
1116 else
1117 Perl_dump_indent(aTHX_ level, file, "GV = NULL\n");
378cc40b 1118 }
971a9dd3 1119#endif
79072805
LW		 1120 break;
1121 case OP_CONST:
996c9baa 1122 case OP_HINTSEVAL:
f5d5a27c 1123 case OP_METHOD_NAMED:
b6a15bc5
DM		 1124#ifndef USE_ITHREADS
1125 /* with ITHREADS, consts are stored in the pad, and the right pad
1126 * may not be active here, so skip */
3848b962 1127 Perl_dump_indent(aTHX_ level, file, "SV = %s\n", SvPEEK(cSVOPo_sv));
b6a15bc5 1128#endif
79072805 1129 break;
93a17b20
LW		 1130 case OP_NEXTSTATE:
1131 case OP_DBSTATE:
57843af0 1132 if (CopLINE(cCOPo))
f5992bc4 1133 Perl_dump_indent(aTHX_ level, file, "LINE = %"UVuf"\n",
9d98dee5 1134 (UV)CopLINE(cCOPo));
ed094faf
GS		 1135 if (CopSTASHPV(cCOPo))
1136 Perl_dump_indent(aTHX_ level, file, "PACKAGE = \"%s\"\n",
1137 CopSTASHPV(cCOPo));
4b65a919 1138 if (CopLABEL(cCOPo))
ed094faf 1139 Perl_dump_indent(aTHX_ level, file, "LABEL = \"%s\"\n",
4b65a919 1140 CopLABEL(cCOPo));
79072805
LW		 1141 break;
1142 case OP_ENTERLOOP:
cea2e8a9 1143 Perl_dump_indent(aTHX_ level, file, "REDO ===> ");
11343788 1144 if (cLOOPo->op_redoop)
f5992bc4 1145 PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOOPo->op_redoop));
79072805 1146 else
3967c732 1147 PerlIO_printf(file, "DONE\n");
cea2e8a9 1148 Perl_dump_indent(aTHX_ level, file, "NEXT ===> ");
11343788 1149 if (cLOOPo->op_nextop)
f5992bc4 1150 PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOOPo->op_nextop));
79072805 1151 else
3967c732 1152 PerlIO_printf(file, "DONE\n");
cea2e8a9 1153 Perl_dump_indent(aTHX_ level, file, "LAST ===> ");
11343788 1154 if (cLOOPo->op_lastop)
f5992bc4 1155 PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOOPo->op_lastop));
79072805 1156 else
3967c732 1157 PerlIO_printf(file, "DONE\n");
79072805
LW		 1158 break;
1159 case OP_COND_EXPR:
1a67a97c 1160 case OP_RANGE:
a0d0e21e 1161 case OP_MAPWHILE:
79072805
LW		 1162 case OP_GREPWHILE:
1163 case OP_OR:
1164 case OP_AND:
cea2e8a9 1165 Perl_dump_indent(aTHX_ level, file, "OTHER ===> ");
11343788 1166 if (cLOGOPo->op_other)
f5992bc4 1167 PerlIO_printf(file, "%"UVuf"\n", sequence_num(cLOGOPo->op_other));
79072805 1168 else
3967c732 1169 PerlIO_printf(file, "DONE\n");
79072805
LW		 1170 break;
1171 case OP_PUSHRE:
1172 case OP_MATCH:
8782bef2 1173 case OP_QR:
79072805 1174 case OP_SUBST:
3967c732 1175 do_pmop_dump(level, file, cPMOPo);
79072805 1176 break;
7934575e
GS		 1177 case OP_LEAVE:
1178 case OP_LEAVEEVAL:
1179 case OP_LEAVESUB:
1180 case OP_LEAVESUBLV:
1181 case OP_LEAVEWRITE:
1182 case OP_SCOPE:
1183 if (o->op_private & OPpREFCOUNTED)
1184 Perl_dump_indent(aTHX_ level, file, "REFCNT = %"UVuf"\n", (UV)o->op_targ);
1185 break;
a0d0e21e
LW		 1186 default:
1187 break;
79072805 1188 }
11343788 1189 if (o->op_flags & OPf_KIDS) {
79072805 1190 OP *kid;
11343788 1191 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
3967c732 1192 do_op_dump(level, file, kid);
8d063cd8 1193 }
cea2e8a9 1194 Perl_dump_indent(aTHX_ level-1, file, "}\n");
3967c732
JD		 1195}
1196
1197void
6867be6d 1198Perl_op_dump(pTHX_ const OP *o)
3967c732 1199{
7918f24d 1200 PERL_ARGS_ASSERT_OP_DUMP;
3967c732 1201 do_op_dump(0, Perl_debug_log, o);
8d063cd8
LW		 1202}
1203
8adcabd8 1204void
864dbfa3 1205Perl_gv_dump(pTHX_ GV *gv)
378cc40b 1206{
79072805 1207 SV *sv;
378cc40b 1208
7918f24d
NC		 1209 PERL_ARGS_ASSERT_GV_DUMP;
1210
79072805 1211 if (!gv) {
760ac839 1212 PerlIO_printf(Perl_debug_log, "{}\n");
378cc40b
LW		 1213 return;
1214 }
8990e307 1215 sv = sv_newmortal();
760ac839 1216 PerlIO_printf(Perl_debug_log, "{\n");
bd61b366 1217 gv_fullname3(sv, gv, NULL);
b15aece3 1218 Perl_dump_indent(aTHX_ 1, Perl_debug_log, "GV_NAME = %s", SvPVX_const(sv));
79072805 1219 if (gv != GvEGV(gv)) {
bd61b366 1220 gv_efullname3(sv, GvEGV(gv), NULL);
b15aece3 1221 Perl_dump_indent(aTHX_ 1, Perl_debug_log, "-> %s", SvPVX_const(sv));
8adcabd8 1222 }
3967c732 1223 PerlIO_putc(Perl_debug_log, '\n');
cea2e8a9 1224 Perl_dump_indent(aTHX_ 0, Perl_debug_log, "}\n");
8d063cd8
LW		 1225}
1226
14befaf4 1227
afe38520 1228/* map magic types to the symbolic names
14befaf4
DM		 1229 * (with the PERL_MAGIC_ prefixed stripped)
1230 */
1231
27da23d5 1232static const struct { const char type; const char *name; } magic_names[] = {
516a5887
JH		 1233 { PERL_MAGIC_sv, "sv(\\0)" },
1234 { PERL_MAGIC_arylen, "arylen(#)" },
ca732855 1235 { PERL_MAGIC_rhash, "rhash(%)" },
516a5887 1236 { PERL_MAGIC_pos, "pos(.)" },
8d2f4536 1237 { PERL_MAGIC_symtab, "symtab(:)" },
516a5887 1238 { PERL_MAGIC_backref, "backref(<)" },
a3874608 1239 { PERL_MAGIC_arylen_p, "arylen_p(@)" },
516a5887
JH		 1240 { PERL_MAGIC_overload, "overload(A)" },
1241 { PERL_MAGIC_bm, "bm(B)" },
1242 { PERL_MAGIC_regdata, "regdata(D)" },
1243 { PERL_MAGIC_env, "env(E)" },
b3ca2e83 1244 { PERL_MAGIC_hints, "hints(H)" },
516a5887
JH		 1245 { PERL_MAGIC_isa, "isa(I)" },
1246 { PERL_MAGIC_dbfile, "dbfile(L)" },
afe38520 1247 { PERL_MAGIC_shared, "shared(N)" },
516a5887
JH		 1248 { PERL_MAGIC_tied, "tied(P)" },
1249 { PERL_MAGIC_sig, "sig(S)" },
1250 { PERL_MAGIC_uvar, "uvar(U)" },
1251 { PERL_MAGIC_overload_elem, "overload_elem(a)" },
1252 { PERL_MAGIC_overload_table, "overload_table(c)" },
1253 { PERL_MAGIC_regdatum, "regdatum(d)" },
1254 { PERL_MAGIC_envelem, "envelem(e)" },
1255 { PERL_MAGIC_fm, "fm(f)" },
1256 { PERL_MAGIC_regex_global, "regex_global(g)" },
b3ca2e83 1257 { PERL_MAGIC_hintselem, "hintselem(h)" },
516a5887
JH		 1258 { PERL_MAGIC_isaelem, "isaelem(i)" },
1259 { PERL_MAGIC_nkeys, "nkeys(k)" },
1260 { PERL_MAGIC_dbline, "dbline(l)" },
afe38520 1261 { PERL_MAGIC_shared_scalar, "shared_scalar(n)" },
516a5887
JH		 1262 { PERL_MAGIC_collxfrm, "collxfrm(o)" },
1263 { PERL_MAGIC_tiedelem, "tiedelem(p)" },
1264 { PERL_MAGIC_tiedscalar, "tiedscalar(q)" },
1265 { PERL_MAGIC_qr, "qr(r)" },
1266 { PERL_MAGIC_sigelem, "sigelem(s)" },
1267 { PERL_MAGIC_taint, "taint(t)" },
cae86ea8 1268 { PERL_MAGIC_uvar_elem, "uvar_elem(u)" },
516a5887 1269 { PERL_MAGIC_vec, "vec(v)" },
cb50f42d 1270 { PERL_MAGIC_vstring, "vstring(V)" },
7e8c5dac 1271 { PERL_MAGIC_utf8, "utf8(w)" },
516a5887
JH		 1272 { PERL_MAGIC_substr, "substr(x)" },
1273 { PERL_MAGIC_defelem, "defelem(y)" },
1274 { PERL_MAGIC_ext, "ext(~)" },
1275 /* this null string terminates the list */
b9ac451d 1276 { 0, NULL },
14befaf4
DM		 1277};
1278
8adcabd8 1279void
6867be6d 1280Perl_do_magic_dump(pTHX_ I32 level, PerlIO *file, const MAGIC *mg, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
8d063cd8 1281{
7918f24d
NC		 1282 PERL_ARGS_ASSERT_DO_MAGIC_DUMP;
1283
3967c732 1284 for (; mg; mg = mg->mg_moremagic) {
b900a521
JH		 1285 Perl_dump_indent(aTHX_ level, file,
1286 " MAGIC = 0x%"UVxf"\n", PTR2UV(mg));
3967c732 1287 if (mg->mg_virtual) {
bfed75c6 1288 const MGVTBL * const v = mg->mg_virtual;
b9ac451d 1289 const char *s;
3967c732
JD		 1290 if (v == &PL_vtbl_sv) s = "sv";
1291 else if (v == &PL_vtbl_env) s = "env";
1292 else if (v == &PL_vtbl_envelem) s = "envelem";
1293 else if (v == &PL_vtbl_sig) s = "sig";
1294 else if (v == &PL_vtbl_sigelem) s = "sigelem";
1295 else if (v == &PL_vtbl_pack) s = "pack";
1296 else if (v == &PL_vtbl_packelem) s = "packelem";
1297 else if (v == &PL_vtbl_dbline) s = "dbline";
1298 else if (v == &PL_vtbl_isa) s = "isa";
1299 else if (v == &PL_vtbl_arylen) s = "arylen";
3967c732
JD		 1300 else if (v == &PL_vtbl_mglob) s = "mglob";
1301 else if (v == &PL_vtbl_nkeys) s = "nkeys";
1302 else if (v == &PL_vtbl_taint) s = "taint";
1303 else if (v == &PL_vtbl_substr) s = "substr";
1304 else if (v == &PL_vtbl_vec) s = "vec";
1305 else if (v == &PL_vtbl_pos) s = "pos";
1306 else if (v == &PL_vtbl_bm) s = "bm";
1307 else if (v == &PL_vtbl_fm) s = "fm";
1308 else if (v == &PL_vtbl_uvar) s = "uvar";
1309 else if (v == &PL_vtbl_defelem) s = "defelem";
1310#ifdef USE_LOCALE_COLLATE
1311 else if (v == &PL_vtbl_collxfrm) s = "collxfrm";
1312#endif
3967c732
JD		 1313 else if (v == &PL_vtbl_amagic) s = "amagic";
1314 else if (v == &PL_vtbl_amagicelem) s = "amagicelem";
810b8aa5 1315 else if (v == &PL_vtbl_backref) s = "backref";
7e8c5dac 1316 else if (v == &PL_vtbl_utf8) s = "utf8";
83bf042f 1317 else if (v == &PL_vtbl_arylen_p) s = "arylen_p";
b3ca2e83 1318 else if (v == &PL_vtbl_hintselem) s = "hintselem";
f747ebd6 1319 else if (v == &PL_vtbl_hints) s = "hints";
b9ac451d 1320 else s = NULL;
3967c732 1321 if (s)
cea2e8a9 1322 Perl_dump_indent(aTHX_ level, file, " MG_VIRTUAL = &PL_vtbl_%s\n", s);
3967c732 1323 else
b900a521 1324 Perl_dump_indent(aTHX_ level, file, " MG_VIRTUAL = 0x%"UVxf"\n", PTR2UV(v));
3967c732
JD		 1325 }
1326 else
cea2e8a9 1327 Perl_dump_indent(aTHX_ level, file, " MG_VIRTUAL = 0\n");
8d063cd8 1328
3967c732 1329 if (mg->mg_private)
cea2e8a9 1330 Perl_dump_indent(aTHX_ level, file, " MG_PRIVATE = %d\n", mg->mg_private);
3967c732 1331
14befaf4
DM		 1332 {
1333 int n;
c445ea15 1334 const char *name = NULL;
27da23d5 1335 for (n = 0; magic_names[n].name; n++) {
14befaf4
DM		 1336 if (mg->mg_type == magic_names[n].type) {
1337 name = magic_names[n].name;
1338 break;
1339 }
1340 }
1341 if (name)
1342 Perl_dump_indent(aTHX_ level, file,
1343 " MG_TYPE = PERL_MAGIC_%s\n", name);
1344 else
1345 Perl_dump_indent(aTHX_ level, file,
1346 " MG_TYPE = UNKNOWN(\\%o)\n", mg->mg_type);
1347 }
3967c732
JD		 1348
1349 if (mg->mg_flags) {
cea2e8a9 1350 Perl_dump_indent(aTHX_ level, file, " MG_FLAGS = 0x%02X\n", mg->mg_flags);
cb50f42d
YST		 1351 if (mg->mg_type == PERL_MAGIC_envelem &&
1352 mg->mg_flags & MGf_TAINTEDDIR)
cea2e8a9 1353 Perl_dump_indent(aTHX_ level, file, " TAINTEDDIR\n");
3967c732 1354 if (mg->mg_flags & MGf_REFCOUNTED)
cea2e8a9 1355 Perl_dump_indent(aTHX_ level, file, " REFCOUNTED\n");
3967c732 1356 if (mg->mg_flags & MGf_GSKIP)
cea2e8a9 1357 Perl_dump_indent(aTHX_ level, file, " GSKIP\n");
cb50f42d
YST		 1358 if (mg->mg_type == PERL_MAGIC_regex_global &&
1359 mg->mg_flags & MGf_MINMATCH)
cea2e8a9 1360 Perl_dump_indent(aTHX_ level, file, " MINMATCH\n");
3967c732
JD		 1361 }
1362 if (mg->mg_obj) {
28d8d7f4
YO		 1363 Perl_dump_indent(aTHX_ level, file, " MG_OBJ = 0x%"UVxf"\n",
1364 PTR2UV(mg->mg_obj));
1365 if (mg->mg_type == PERL_MAGIC_qr) {
07bc277f 1366 REGEXP* const re = (REGEXP *)mg->mg_obj;
61f9802b 1367 SV * const dsv = sv_newmortal();
866c78d1
NC		 1368 const char * const s
1369 = pv_pretty(dsv, RX_WRAPPED(re), RX_WRAPLEN(re),
28d8d7f4 1370 60, NULL, NULL,
95b611b0 1371 ( PERL_PV_PRETTY_QUOTE | PERL_PV_ESCAPE_RE | PERL_PV_PRETTY_ELLIPSES |
3c8556c3 1372 (RX_UTF8(re) ? PERL_PV_ESCAPE_UNI : 0))
28d8d7f4 1373 );
6483fb35
RGS		 1374 Perl_dump_indent(aTHX_ level+1, file, " PAT = %s\n", s);
1375 Perl_dump_indent(aTHX_ level+1, file, " REFCNT = %"IVdf"\n",
07bc277f 1376 (IV)RX_REFCNT(re));
28d8d7f4
YO		 1377 }
1378 if (mg->mg_flags & MGf_REFCOUNTED)
3967c732
JD		 1379 do_sv_dump(level+2, file, mg->mg_obj, nest+1, maxnest, dumpops, pvlim); /* MG is already +1 */
1380 }
1381 if (mg->mg_len)
894356b3 1382 Perl_dump_indent(aTHX_ level, file, " MG_LEN = %ld\n", (long)mg->mg_len);
3967c732 1383 if (mg->mg_ptr) {
b900a521 1384 Perl_dump_indent(aTHX_ level, file, " MG_PTR = 0x%"UVxf, PTR2UV(mg->mg_ptr));
3967c732 1385 if (mg->mg_len >= 0) {
7e8c5dac 1386 if (mg->mg_type != PERL_MAGIC_utf8) {
61f9802b 1387 SV * const sv = newSVpvs("");
7e8c5dac
HS		 1388 PerlIO_printf(file, " %s", pv_display(sv, mg->mg_ptr, mg->mg_len, 0, pvlim));
1389 SvREFCNT_dec(sv);
1390 }
3967c732
JD		 1391 }
1392 else if (mg->mg_len == HEf_SVKEY) {
1393 PerlIO_puts(file, " => HEf_SVKEY\n");
ad64d0ec
NC		 1394 do_sv_dump(level+2, file, MUTABLE_SV(((mg)->mg_ptr)), nest+1,
1395 maxnest, dumpops, pvlim); /* MG is already +1 */
3967c732
JD		 1396 continue;
1397 }
866f9d6c 1398 else if (mg->mg_len == -1 && mg->mg_type == PERL_MAGIC_utf8);
3967c732 1399 else
866f9d6c
FC		 1400 PerlIO_puts(
1401 file,
1402 " ???? - " __FILE__
1403 " does not know how to handle this MG_LEN"
1404 );
3967c732
JD		 1405 PerlIO_putc(file, '\n');
1406 }
7e8c5dac 1407 if (mg->mg_type == PERL_MAGIC_utf8) {
61f9802b 1408 const STRLEN * const cache = (STRLEN *) mg->mg_ptr;
7e8c5dac
HS		 1409 if (cache) {
1410 IV i;
1411 for (i = 0; i < PERL_MAGIC_UTF8_CACHESIZE; i++)
1412 Perl_dump_indent(aTHX_ level, file,
1413 " %2"IVdf": %"UVuf" -> %"UVuf"\n",
1414 i,
1415 (UV)cache[i * 2],
1416 (UV)cache[i * 2 + 1]);
1417 }
1418 }
378cc40b 1419 }
3967c732
JD		 1420}
1421
1422void
6867be6d 1423Perl_magic_dump(pTHX_ const MAGIC *mg)
3967c732 1424{
b9ac451d 1425 do_magic_dump(0, Perl_debug_log, mg, 0, 0, FALSE, 0);
3967c732
JD		 1426}
1427
1428void
e1ec3a88 1429Perl_do_hv_dump(pTHX_ I32 level, PerlIO *file, const char *name, HV *sv)
3967c732 1430{
bfcb3514 1431 const char *hvname;
7918f24d
NC		 1432
1433 PERL_ARGS_ASSERT_DO_HV_DUMP;
1434
b900a521 1435 Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
bfcb3514 1436 if (sv && (hvname = HvNAME_get(sv)))
d7d51f4b
YO		 1437 {
1438 /* we have to use pv_display and HvNAMELEN_get() so that we display the real package
1439 name which quite legally could contain insane things like tabs, newlines, nulls or
1440 other scary crap - this should produce sane results - except maybe for unicode package
1441 names - but we will wait for someone to file a bug on that - demerphq */
1442 SV * const tmpsv = newSVpvs("");
1443 PerlIO_printf(file, "\t%s\n", pv_display(tmpsv, hvname, HvNAMELEN_get(sv), 0, 1024));
1444 }
79072805 1445 else
3967c732
JD		 1446 PerlIO_putc(file, '\n');
1447}
1448
1449void
e1ec3a88 1450Perl_do_gv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
3967c732 1451{
7918f24d
NC		 1452 PERL_ARGS_ASSERT_DO_GV_DUMP;
1453
b900a521 1454 Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
3967c732
JD		 1455 if (sv && GvNAME(sv))
1456 PerlIO_printf(file, "\t\"%s\"\n", GvNAME(sv));
c90c0ff4 1457 else
3967c732
JD		 1458 PerlIO_putc(file, '\n');
1459}
1460
1461void
e1ec3a88 1462Perl_do_gvgv_dump(pTHX_ I32 level, PerlIO *file, const char *name, GV *sv)
3967c732 1463{
7918f24d
NC		 1464 PERL_ARGS_ASSERT_DO_GVGV_DUMP;
1465
b900a521 1466 Perl_dump_indent(aTHX_ level, file, "%s = 0x%"UVxf, name, PTR2UV(sv));
3967c732 1467 if (sv && GvNAME(sv)) {
bfcb3514 1468 const char *hvname;
3967c732 1469 PerlIO_printf(file, "\t\"");
bfcb3514
NC		 1470 if (GvSTASH(sv) && (hvname = HvNAME_get(GvSTASH(sv))))
1471 PerlIO_printf(file, "%s\" :: \"", hvname);
3967c732 1472 PerlIO_printf(file, "%s\"\n", GvNAME(sv));
8d063cd8 1473 }
3967c732
JD		 1474 else
1475 PerlIO_putc(file, '\n');
1476}
1477
a0c2f4dd
NC		 1478const struct flag_to_name first_sv_flags_names[] = {
1479 {SVs_TEMP, "TEMP,"},
1480 {SVs_OBJECT, "OBJECT,"},
1481 {SVs_GMG, "GMG,"},
1482 {SVs_SMG, "SMG,"},
1483 {SVs_RMG, "RMG,"},
1484 {SVf_IOK, "IOK,"},
1485 {SVf_NOK, "NOK,"},
1486 {SVf_POK, "POK,"}
1487};
1488
1489const struct flag_to_name second_sv_flags_names[] = {
1490 {SVf_OOK, "OOK,"},
1491 {SVf_FAKE, "FAKE,"},
1492 {SVf_READONLY, "READONLY,"},
1493 {SVf_BREAK, "BREAK,"},
1494 {SVf_AMAGIC, "OVERLOAD,"},
1495 {SVp_IOK, "pIOK,"},
1496 {SVp_NOK, "pNOK,"},
1497 {SVp_POK, "pPOK,"}
1498};
1499
ae1f06a1
NC		 1500const struct flag_to_name cv_flags_names[] = {
1501 {CVf_ANON, "ANON,"},
1502 {CVf_UNIQUE, "UNIQUE,"},
1503 {CVf_CLONE, "CLONE,"},
1504 {CVf_CLONED, "CLONED,"},
1505 {CVf_CONST, "CONST,"},
1506 {CVf_NODEBUG, "NODEBUG,"},
1507 {CVf_LVALUE, "LVALUE,"},
1508 {CVf_METHOD, "METHOD,"},
cfc1e951 1509 {CVf_WEAKOUTSIDE, "WEAKOUTSIDE,"},
31d45e0c
DM		 1510 {CVf_CVGV_RC, "CVGV_RC,"},
1511 {CVf_ISXSUB, "ISXSUB,"}
ae1f06a1
NC		 1512};
1513
1514const struct flag_to_name hv_flags_names[] = {
1515 {SVphv_SHAREKEYS, "SHAREKEYS,"},
1516 {SVphv_LAZYDEL, "LAZYDEL,"},
1517 {SVphv_HASKFLAGS, "HASKFLAGS,"},
1518 {SVphv_REHASH, "REHASH,"},
1519 {SVphv_CLONEABLE, "CLONEABLE,"}
1520};
1521
1522const struct flag_to_name gp_flags_names[] = {
1523 {GVf_INTRO, "INTRO,"},
1524 {GVf_MULTI, "MULTI,"},
1525 {GVf_ASSUMECV, "ASSUMECV,"},
1526 {GVf_IN_PAD, "IN_PAD,"}
1527};
1528
1529const struct flag_to_name gp_flags_imported_names[] = {
1530 {GVf_IMPORTED_SV, " SV"},
1531 {GVf_IMPORTED_AV, " AV"},
1532 {GVf_IMPORTED_HV, " HV"},
1533 {GVf_IMPORTED_CV, " CV"},
1534};
1535
3967c732 1536void
864dbfa3 1537Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bool dumpops, STRLEN pvlim)
3967c732 1538{
97aff369 1539 dVAR;
cea89e20 1540 SV *d;
e1ec3a88 1541 const char *s;
3967c732
JD		 1542 U32 flags;
1543 U32 type;
1544
7918f24d
NC		 1545 PERL_ARGS_ASSERT_DO_SV_DUMP;
1546
3967c732 1547 if (!sv) {
cea2e8a9 1548 Perl_dump_indent(aTHX_ level, file, "SV = 0\n");
3967c732 1549 return;
378cc40b 1550 }
2ef28da1 1551
3967c732
JD		 1552 flags = SvFLAGS(sv);
1553 type = SvTYPE(sv);
79072805 1554
cea89e20 1555 d = Perl_newSVpvf(aTHX_
57def98f 1556 "(0x%"UVxf") at 0x%"UVxf"\n%*s REFCNT = %"IVdf"\n%*s FLAGS = (",
56431972 1557 PTR2UV(SvANY(sv)), PTR2UV(sv),
894356b3
GS		 1558 (int)(PL_dumpindent*level), "", (IV)SvREFCNT(sv),
1559 (int)(PL_dumpindent*level), "");
8d063cd8 1560
e604303a
NC		 1561 if (!(flags & SVpad_NAME && (type == SVt_PVMG || type == SVt_PVNV))) {
1562 if (flags & SVs_PADSTALE) sv_catpv(d, "PADSTALE,");
1563 }
1564 if (!(flags & SVpad_NAME && type == SVt_PVMG)) {
1565 if (flags & SVs_PADTMP) sv_catpv(d, "PADTMP,");
1566 if (flags & SVs_PADMY) sv_catpv(d, "PADMY,");
1567 }
a0c2f4dd 1568 append_flags(d, flags, first_sv_flags_names);
810b8aa5
GS		 1569 if (flags & SVf_ROK) {
1570 sv_catpv(d, "ROK,");
1571 if (SvWEAKREF(sv)) sv_catpv(d, "WEAKREF,");
1572 }
a0c2f4dd 1573 append_flags(d, flags, second_sv_flags_names);
1ccdb730
NC		 1574 if (flags & SVp_SCREAM && type != SVt_PVHV && !isGV_with_GP(sv)) {
1575 if (SvPCS_IMPORTED(sv))
1576 sv_catpv(d, "PCS_IMPORTED,");
1577 else
9660f481 1578 sv_catpv(d, "SCREAM,");
1ccdb730 1579 }
3967c732
JD		 1580
1581 switch (type) {
1582 case SVt_PVCV:
1583 case SVt_PVFM:
ae1f06a1 1584 append_flags(d, CvFLAGS(sv), cv_flags_names);
16cf2f8d 1585 if (SvCOMPILED(sv)) sv_catpv(d, "COMPILED,");
3967c732
JD		 1586 break;
1587 case SVt_PVHV:
ae1f06a1 1588 append_flags(d, flags, hv_flags_names);
3967c732 1589 break;
926fc7b6
DM		 1590 case SVt_PVGV:
1591 case SVt_PVLV:
1592 if (isGV_with_GP(sv)) {
ae1f06a1 1593 append_flags(d, GvFLAGS(sv), gp_flags_names);
926fc7b6 1594 }
926fc7b6 1595 if (isGV_with_GP(sv) && GvIMPORTED(sv)) {
3967c732
JD		 1596 sv_catpv(d, "IMPORT");
1597 if (GvIMPORTED(sv) == GVf_IMPORTED)
1598 sv_catpv(d, "ALL,");
1599 else {
1600 sv_catpv(d, "(");
ae1f06a1 1601 append_flags(d, GvFLAGS(sv), gp_flags_imported_names);
3967c732
JD		 1602 sv_catpv(d, " ),");
1603 }
1604 }
cecf5685
NC		 1605 if (SvTAIL(sv)) sv_catpv(d, "TAIL,");
1606 if (SvVALID(sv)) sv_catpv(d, "VALID,");
addd1794 1607 /* FALL THROUGH */
25da4f38 1608 default:
e604303a 1609 evaled_or_uv:
25da4f38 1610 if (SvEVALED(sv)) sv_catpv(d, "EVALED,");
69c678eb 1611 if (SvIsUV(sv) && !(flags & SVf_ROK)) sv_catpv(d, "IsUV,");
25da4f38 1612 break;
addd1794 1613 case SVt_PVMG:
00b1698f 1614 if (SvPAD_TYPED(sv)) sv_catpv(d, "TYPED,");
e604303a 1615 if (SvPAD_OUR(sv)) sv_catpv(d, "OUR,");
2e94196c 1616 /* FALL THROUGH */
e604303a
NC		 1617 case SVt_PVNV:
1618 if (SvPAD_STATE(sv)) sv_catpv(d, "STATE,");
1619 goto evaled_or_uv;
11ca45c0
NC		 1620 case SVt_PVAV:
1621 break;
3967c732 1622 }
86f0d186
NC		 1623 /* SVphv_SHAREKEYS is also 0x20000000 */
1624 if ((type != SVt_PVHV) && SvUTF8(sv))
9fe74ede 1625 sv_catpv(d, "UTF8");
3967c732 1626
b162af07
SP		 1627 if (*(SvEND(d) - 1) == ',') {
1628 SvCUR_set(d, SvCUR(d) - 1);
1629 SvPVX(d)[SvCUR(d)] = '\0';
1630 }
3967c732 1631 sv_catpv(d, ")");
b15aece3 1632 s = SvPVX_const(d);
3967c732 1633
fd0854ff 1634#ifdef DEBUG_LEAKING_SCALARS
cbe56f1d 1635 Perl_dump_indent(aTHX_ level, file,
cd676548 1636 "ALLOCATED at %s:%d %s %s (parent 0x%"UVxf"); serial %"UVuf"\n",
fd0854ff
DM		 1637 sv->sv_debug_file ? sv->sv_debug_file : "(unknown)",
1638 sv->sv_debug_line,
1639 sv->sv_debug_inpad ? "for" : "by",
1640 sv->sv_debug_optype ? PL_op_name[sv->sv_debug_optype]: "(none)",
cd676548 1641 PTR2UV(sv->sv_debug_parent),
cbe56f1d
DM		 1642 sv->sv_debug_serial
1643 );
fd0854ff 1644#endif
cea2e8a9 1645 Perl_dump_indent(aTHX_ level, file, "SV = ");
5357ca29
NC		 1646 if (type < SVt_LAST) {
1647 PerlIO_printf(file, "%s%s\n", svtypenames[type], s);
1648
1649 if (type == SVt_NULL) {
1650 SvREFCNT_dec(d);
1651 return;
1652 }
1653 } else {
faccc32b 1654 PerlIO_printf(file, "UNKNOWN(0x%"UVxf") %s\n", (UV)type, s);
cea89e20 1655 SvREFCNT_dec(d);
3967c732
JD		 1656 return;
1657 }
27bd069f 1658 if ((type >= SVt_PVIV && type != SVt_PVAV && type != SVt_PVHV
3cf51070 1659 && type != SVt_PVCV && !isGV_with_GP(sv) && type != SVt_PVFM
e77da3b2 1660 && type != SVt_PVIO && type != SVt_REGEXP)
4df7f6af 1661 || (type == SVt_IV && !SvROK(sv))) {
765f542d 1662 if (SvIsUV(sv)
f8c7b90f 1663#ifdef PERL_OLD_COPY_ON_WRITE
765f542d
NC		 1664 || SvIsCOW(sv)
1665#endif
1666 )
57def98f 1667 Perl_dump_indent(aTHX_ level, file, " UV = %"UVuf, (UV)SvUVX(sv));
cf2093f6 1668 else
57def98f 1669 Perl_dump_indent(aTHX_ level, file, " IV = %"IVdf, (IV)SvIVX(sv));
f8c7b90f 1670#ifdef PERL_OLD_COPY_ON_WRITE
765f542d
NC		 1671 if (SvIsCOW_shared_hash(sv))
1672 PerlIO_printf(file, " (HASH)");
1673 else if (SvIsCOW_normal(sv))
1674 PerlIO_printf(file, " (COW from 0x%"UVxf")", (UV)SvUVX(sv));
1675#endif
3967c732
JD		 1676 PerlIO_putc(file, '\n');
1677 }
0e4c4423
NC		 1678 if ((type == SVt_PVNV || type == SVt_PVMG) && SvFLAGS(sv) & SVpad_NAME) {
1679 Perl_dump_indent(aTHX_ level, file, " COP_LOW = %"UVuf"\n",
1680 (UV) COP_SEQ_RANGE_LOW(sv));
1681 Perl_dump_indent(aTHX_ level, file, " COP_HIGH = %"UVuf"\n",
1682 (UV) COP_SEQ_RANGE_HIGH(sv));
1683 } else if ((type >= SVt_PVNV && type != SVt_PVAV && type != SVt_PVHV
08e44740 1684 && type != SVt_PVCV && type != SVt_PVFM && type != SVt_REGEXP
c0a413d1 1685 && type != SVt_PVIO && !isGV_with_GP(sv) && !SvVALID(sv))
0e4c4423 1686 || type == SVt_NV) {
e54dc35b 1687 STORE_NUMERIC_LOCAL_SET_STANDARD();
57def98f 1688 /* %Vg doesn't work? --jhi */
cf2093f6 1689#ifdef USE_LONG_DOUBLE
2d4389e4 1690 Perl_dump_indent(aTHX_ level, file, " NV = %.*" PERL_PRIgldbl "\n", LDBL_DIG, SvNVX(sv));
cf2093f6 1691#else
cea2e8a9 1692 Perl_dump_indent(aTHX_ level, file, " NV = %.*g\n", DBL_DIG, SvNVX(sv));
cf2093f6 1693#endif
e54dc35b 1694 RESTORE_NUMERIC_LOCAL();
3967c732
JD		 1695 }
1696 if (SvROK(sv)) {
57def98f 1697 Perl_dump_indent(aTHX_ level, file, " RV = 0x%"UVxf"\n", PTR2UV(SvRV(sv)));
3967c732
JD		 1698 if (nest < maxnest)
1699 do_sv_dump(level+1, file, SvRV(sv), nest+1, maxnest, dumpops, pvlim);
3967c732 1700 }
cea89e20
JH		 1701 if (type < SVt_PV) {
1702 SvREFCNT_dec(d);
3967c732 1703 return;
cea89e20 1704 }
a49b46c6 1705 if ((type <= SVt_PVLV && !isGV_with_GP(sv)) || type == SVt_PVFM) {
b15aece3 1706 if (SvPVX_const(sv)) {
69240efd 1707 STRLEN delta;
7a4bba22 1708 if (SvOOK(sv)) {
69240efd 1709 SvOOK_offset(sv, delta);
7a4bba22 1710 Perl_dump_indent(aTHX_ level, file," OFFSET = %"UVuf"\n",
5186cc12 1711 (UV) delta);
69240efd
NC		 1712 } else {
1713 delta = 0;
7a4bba22 1714 }
b15aece3 1715 Perl_dump_indent(aTHX_ level, file," PV = 0x%"UVxf" ", PTR2UV(SvPVX_const(sv)));
7a4bba22
NC		 1716 if (SvOOK(sv)) {
1717 PerlIO_printf(file, "( %s . ) ",
1718 pv_display(d, SvPVX_const(sv) - delta, delta, 0,
1719 pvlim));
1720 }
b15aece3 1721 PerlIO_printf(file, "%s", pv_display(d, SvPVX_const(sv), SvCUR(sv), SvLEN(sv), pvlim));
e9569a7a
GG		 1722 if (SvUTF8(sv)) /* the 6? \x{....} */
1723 PerlIO_printf(file, " [UTF8 \"%s\"]", sv_uni_display(d, sv, 6 * SvCUR(sv), UNI_DISPLAY_QQ));
e6abe6d8 1724 PerlIO_printf(file, "\n");
57def98f
JH		 1725 Perl_dump_indent(aTHX_ level, file, " CUR = %"IVdf"\n", (IV)SvCUR(sv));
1726 Perl_dump_indent(aTHX_ level, file, " LEN = %"IVdf"\n", (IV)SvLEN(sv));
3967c732
JD		 1727 }
1728 else
cea2e8a9 1729 Perl_dump_indent(aTHX_ level, file, " PV = 0\n");
3967c732 1730 }
f19b4ba9 1731 if (type == SVt_REGEXP) {
288b8c02 1732 /* FIXME dumping
f19b4ba9 1733 Perl_dump_indent(aTHX_ level, file, " REGEXP = 0x%"UVxf"\n",
288b8c02
NC		 1734 PTR2UV(((struct regexp *)SvANY(sv))->xrx_regexp));
1735 */
f19b4ba9 1736 }
3967c732 1737 if (type >= SVt_PVMG) {
0e4c4423 1738 if (type == SVt_PVMG && SvPAD_OUR(sv)) {
61f9802b 1739 HV * const ost = SvOURSTASH(sv);
38cbaf55
RGS		 1740 if (ost)
1741 do_hv_dump(level, file, " OURSTASH", ost);
0e4c4423
NC		 1742 } else {
1743 if (SvMAGIC(sv))
8530ff28 1744 do_magic_dump(level, file, SvMAGIC(sv), nest+1, maxnest, dumpops, pvlim);
0e4c4423 1745 }
3967c732
JD		 1746 if (SvSTASH(sv))
1747 do_hv_dump(level, file, " STASH", SvSTASH(sv));
1748 }
1749 switch (type) {
3967c732 1750 case SVt_PVAV:
57def98f 1751 Perl_dump_indent(aTHX_ level, file, " ARRAY = 0x%"UVxf, PTR2UV(AvARRAY(sv)));
3967c732 1752 if (AvARRAY(sv) != AvALLOC(sv)) {
57def98f
JH		 1753 PerlIO_printf(file, " (offset=%"IVdf")\n", (IV)(AvARRAY(sv) - AvALLOC(sv)));
1754 Perl_dump_indent(aTHX_ level, file, " ALLOC = 0x%"UVxf"\n", PTR2UV(AvALLOC(sv)));
3967c732
JD		 1755 }
1756 else
1757 PerlIO_putc(file, '\n');
57def98f
JH		 1758 Perl_dump_indent(aTHX_ level, file, " FILL = %"IVdf"\n", (IV)AvFILLp(sv));
1759 Perl_dump_indent(aTHX_ level, file, " MAX = %"IVdf"\n", (IV)AvMAX(sv));
a3874608 1760 Perl_dump_indent(aTHX_ level, file, " ARYLEN = 0x%"UVxf"\n", SvMAGIC(sv) ? PTR2UV(AvARYLEN(sv)) : 0);
76f68e9b 1761 sv_setpvs(d, "");
11ca45c0
NC		 1762 if (AvREAL(sv)) sv_catpv(d, ",REAL");
1763 if (AvREIFY(sv)) sv_catpv(d, ",REIFY");
b15aece3
SP		 1764 Perl_dump_indent(aTHX_ level, file, " FLAGS = (%s)\n",
1765 SvCUR(d) ? SvPVX_const(d) + 1 : "");
502c6561 1766 if (nest < maxnest && av_len(MUTABLE_AV(sv)) >= 0) {
3967c732 1767 int count;
502c6561
NC		 1768 for (count = 0; count <= av_len(MUTABLE_AV(sv)) && count < maxnest; count++) {
1769 SV** const elt = av_fetch(MUTABLE_AV(sv),count,0);
3967c732 1770
57def98f 1771 Perl_dump_indent(aTHX_ level + 1, file, "Elt No. %"IVdf"\n", (IV)count);
2ef28da1 1772 if (elt)
3967c732
JD		 1773 do_sv_dump(level+1, file, *elt, nest+1, maxnest, dumpops, pvlim);
1774 }
1775 }
1776 break;
1777 case SVt_PVHV:
57def98f 1778 Perl_dump_indent(aTHX_ level, file, " ARRAY = 0x%"UVxf, PTR2UV(HvARRAY(sv)));
3967c732
JD		 1779 if (HvARRAY(sv) && HvKEYS(sv)) {
1780 /* Show distribution of HEs in the ARRAY */
1781 int freq[200];
bb7a0f54 1782#define FREQ_MAX ((int)(sizeof freq / sizeof freq[0] - 1))
3967c732
JD		 1783 int i;
1784 int max = 0;
1785 U32 pow2 = 2, keys = HvKEYS(sv);
65202027 1786 NV theoret, sum = 0;
3967c732
JD		 1787
1788 PerlIO_printf(file, " (");
1789 Zero(freq, FREQ_MAX + 1, int);
eb160463 1790 for (i = 0; (STRLEN)i <= HvMAX(sv); i++) {
c445ea15
AL		 1791 HE* h;
1792 int count = 0;
3967c732
JD		 1793 for (h = HvARRAY(sv)[i]; h; h = HeNEXT(h))
1794 count++;
1795 if (count > FREQ_MAX)
1796 count = FREQ_MAX;
1797 freq[count]++;
1798 if (max < count)
1799 max = count;
1800 }
1801 for (i = 0; i <= max; i++) {
1802 if (freq[i]) {
1803 PerlIO_printf(file, "%d%s:%d", i,
1804 (i == FREQ_MAX) ? "+" : "",
1805 freq[i]);
1806 if (i != max)
1807 PerlIO_printf(file, ", ");
1808 }
1809 }
1810 PerlIO_putc(file, ')');
b8fa94d8
MG		 1811 /* The "quality" of a hash is defined as the total number of
1812 comparisons needed to access every element once, relative
1813 to the expected number needed for a random hash.
1814
1815 The total number of comparisons is equal to the sum of
e76cd0fa
AMS		 1816 the squares of the number of entries in each bucket.
1817 For a random hash of n keys into k buckets, the expected
b8fa94d8
MG		 1818 value is
1819 n + n(n-1)/2k
1820 */
1821
3967c732
JD		 1822 for (i = max; i > 0; i--) { /* Precision: count down. */
1823 sum += freq[i] * i * i;
1824 }
155aba94 1825 while ((keys = keys >> 1))
3967c732 1826 pow2 = pow2 << 1;
3967c732 1827 theoret = HvKEYS(sv);
b8fa94d8 1828 theoret += theoret * (theoret-1)/pow2;
3967c732 1829 PerlIO_putc(file, '\n');
6b4667fc 1830 Perl_dump_indent(aTHX_ level, file, " hash quality = %.1"NVff"%%", theoret/sum*100);
3967c732
JD		 1831 }
1832 PerlIO_putc(file, '\n');
57def98f
JH		 1833 Perl_dump_indent(aTHX_ level, file, " KEYS = %"IVdf"\n", (IV)HvKEYS(sv));
1834 Perl_dump_indent(aTHX_ level, file, " FILL = %"IVdf"\n", (IV)HvFILL(sv));
1835 Perl_dump_indent(aTHX_ level, file, " MAX = %"IVdf"\n", (IV)HvMAX(sv));
bfcb3514
NC		 1836 Perl_dump_indent(aTHX_ level, file, " RITER = %"IVdf"\n", (IV)HvRITER_get(sv));
1837 Perl_dump_indent(aTHX_ level, file, " EITER = 0x%"UVxf"\n", PTR2UV(HvEITER_get(sv)));
8d2f4536 1838 {
b9ac451d 1839 MAGIC * const mg = mg_find(sv, PERL_MAGIC_symtab);
8d2f4536
NC		 1840 if (mg && mg->mg_obj) {
1841 Perl_dump_indent(aTHX_ level, file, " PMROOT = 0x%"UVxf"\n", PTR2UV(mg->mg_obj));
1842 }
1843 }
bfcb3514 1844 {
b9ac451d 1845 const char * const hvname = HvNAME_get(sv);
bfcb3514
NC		 1846 if (hvname)
1847 Perl_dump_indent(aTHX_ level, file, " NAME = \"%s\"\n", hvname);
1848 }
86f55936 1849 if (SvOOK(sv)) {
ad64d0ec 1850 AV * const backrefs
85fbaab2 1851 = *Perl_hv_backreferences_p(aTHX_ MUTABLE_HV(sv));
7d88e6c4 1852 struct mro_meta * const meta = HvAUX(sv)->xhv_mro_meta;
86f55936
NC		 1853 if (backrefs) {
1854 Perl_dump_indent(aTHX_ level, file, " BACKREFS = 0x%"UVxf"\n",
1855 PTR2UV(backrefs));
ad64d0ec 1856 do_sv_dump(level+1, file, MUTABLE_SV(backrefs), nest+1, maxnest,
86f55936
NC		 1857 dumpops, pvlim);
1858 }
7d88e6c4
NC		 1859 if (meta) {
1860 /* FIXME - mro_algs kflags can signal a UTF-8 name. */
1861 Perl_dump_indent(aTHX_ level, file, " MRO_WHICH = \"%.*s\" (0x%"UVxf")\n",
1862 (int)meta->mro_which->length,
1863 meta->mro_which->name,
1864 PTR2UV(meta->mro_which));
1865 Perl_dump_indent(aTHX_ level, file, " CACHE_GEN = 0x%"UVxf"\n",
1866 (UV)meta->cache_gen);
1867 Perl_dump_indent(aTHX_ level, file, " PKG_GEN = 0x%"UVxf"\n",
1868 (UV)meta->pkg_gen);
1869 if (meta->mro_linear_all) {
1870 Perl_dump_indent(aTHX_ level, file, " MRO_LINEAR_ALL = 0x%"UVxf"\n",
1871 PTR2UV(meta->mro_linear_all));
1872 do_sv_dump(level+1, file, MUTABLE_SV(meta->mro_linear_all), nest+1, maxnest,
1873 dumpops, pvlim);
1874 }
1875 if (meta->mro_linear_current) {
1876 Perl_dump_indent(aTHX_ level, file, " MRO_LINEAR_CURRENT = 0x%"UVxf"\n",
1877 PTR2UV(meta->mro_linear_current));
1878 do_sv_dump(level+1, file, MUTABLE_SV(meta->mro_linear_current), nest+1, maxnest,
1879 dumpops, pvlim);
1880 }
1881 if (meta->mro_nextmethod) {
1882 Perl_dump_indent(aTHX_ level, file, " MRO_NEXTMETHOD = 0x%"UVxf"\n",
1883 PTR2UV(meta->mro_nextmethod));
1884 do_sv_dump(level+1, file, MUTABLE_SV(meta->mro_nextmethod), nest+1, maxnest,
1885 dumpops, pvlim);
1886 }
1887 if (meta->isa) {
1888 Perl_dump_indent(aTHX_ level, file, " ISA = 0x%"UVxf"\n",
1889 PTR2UV(meta->isa));
1890 do_sv_dump(level+1, file, MUTABLE_SV(meta->isa), nest+1, maxnest,
1891 dumpops, pvlim);
1892 }
1893 }
86f55936 1894 }
002beaef
DM		 1895 if (nest < maxnest) {
1896 if (HvEITER_get(sv)) /* preserve iterator */
1897 Perl_dump_indent(aTHX_ level, file,
1898 " (*** Active iterator; skipping element dump ***)\n");
1899 else {
1900 HE *he;
1901 HV * const hv = MUTABLE_HV(sv);
1902 int count = maxnest - nest;
1903
1904 hv_iterinit(hv);
1905 while ((he = hv_iternext_flags(hv, HV_ITERNEXT_WANTPLACEHOLDERS))
1906 && count--) {
1907 STRLEN len;
1908 const U32 hash = HeHASH(he);
1909 SV * const keysv = hv_iterkeysv(he);
1910 const char * const keypv = SvPV_const(keysv, len);
1911 SV * const elt = hv_iterval(hv, he);
1912
1913 Perl_dump_indent(aTHX_ level+1, file, "Elt %s ", pv_display(d, keypv, len, 0, pvlim));
1914 if (SvUTF8(keysv))
1915 PerlIO_printf(file, "[UTF8 \"%s\"] ", sv_uni_display(d, keysv, 6 * SvCUR(keysv), UNI_DISPLAY_QQ));
1916 if (HeKREHASH(he))
1917 PerlIO_printf(file, "[REHASH] ");
1918 PerlIO_printf(file, "HASH = 0x%"UVxf"\n", (UV)hash);
1919 do_sv_dump(level+1, file, elt, nest+1, maxnest, dumpops, pvlim);
1920 }
1921 hv_iterinit(hv); /* Return to status quo */
3967c732 1922 }
3967c732
JD		 1923 }
1924 break;
1925 case SVt_PVCV:
cbf82dd0
NC		 1926 if (SvPOK(sv)) {
1927 STRLEN len;
1928 const char *const proto = SvPV_const(sv, len);
1929 Perl_dump_indent(aTHX_ level, file, " PROTOTYPE = \"%.*s\"\n",
1930 (int) len, proto);
1931 }
3967c732
JD		 1932 /* FALL THROUGH */
1933 case SVt_PVFM:
1934 do_hv_dump(level, file, " COMP_STASH", CvSTASH(sv));
d04ba589
NC		 1935 if (!CvISXSUB(sv)) {
1936 if (CvSTART(sv)) {
1937 Perl_dump_indent(aTHX_ level, file,
1938 " START = 0x%"UVxf" ===> %"IVdf"\n",
1939 PTR2UV(CvSTART(sv)),
1940 (IV)sequence_num(CvSTART(sv)));
1941 }
1942 Perl_dump_indent(aTHX_ level, file, " ROOT = 0x%"UVxf"\n",
1943 PTR2UV(CvROOT(sv)));
1944 if (CvROOT(sv) && dumpops) {
1945 do_op_dump(level+1, file, CvROOT(sv));
1946 }
1947 } else {
126f53f3 1948 SV * const constant = cv_const_sv((const CV *)sv);
b1886099 1949
d04ba589 1950 Perl_dump_indent(aTHX_ level, file, " XSUB = 0x%"UVxf"\n", PTR2UV(CvXSUB(sv)));
b1886099
NC		 1951
1952 if (constant) {
1953 Perl_dump_indent(aTHX_ level, file, " XSUBANY = 0x%"UVxf
1954 " (CONST SV)\n",
1955 PTR2UV(CvXSUBANY(sv).any_ptr));
1956 do_sv_dump(level+1, file, constant, nest+1, maxnest, dumpops,
1957 pvlim);
1958 } else {
1959 Perl_dump_indent(aTHX_ level, file, " XSUBANY = %"IVdf"\n",
1960 (IV)CvXSUBANY(sv).any_i32);
1961 }
1962 }
3967c732 1963 do_gvgv_dump(level, file, " GVGV::GV", CvGV(sv));
57843af0 1964 Perl_dump_indent(aTHX_ level, file, " FILE = \"%s\"\n", CvFILE(sv));
5129b2ca
NC		 1965 if (type == SVt_PVCV)
1966 Perl_dump_indent(aTHX_ level, file, " DEPTH = %"IVdf"\n", (IV)CvDEPTH(sv));
894356b3 1967 Perl_dump_indent(aTHX_ level, file, " FLAGS = 0x%"UVxf"\n", (UV)CvFLAGS(sv));
a3985cdc 1968 Perl_dump_indent(aTHX_ level, file, " OUTSIDE_SEQ = %"UVuf"\n", (UV)CvOUTSIDE_SEQ(sv));
3967c732 1969 if (type == SVt_PVFM)
57def98f
JH		 1970 Perl_dump_indent(aTHX_ level, file, " LINES = %"IVdf"\n", (IV)FmLINES(sv));
1971 Perl_dump_indent(aTHX_ level, file, " PADLIST = 0x%"UVxf"\n", PTR2UV(CvPADLIST(sv)));
dd2155a4
DM		 1972 if (nest < maxnest) {
1973 do_dump_pad(level+1, file, CvPADLIST(sv), 0);
3967c732
JD		 1974 }
1975 {
b9ac451d 1976 const CV * const outside = CvOUTSIDE(sv);
2ef28da1 1977 Perl_dump_indent(aTHX_ level, file, " OUTSIDE = 0x%"UVxf" (%s)\n",
57def98f 1978 PTR2UV(outside),
cf2093f6
JH		 1979 (!outside ? "null"
1980 : CvANON(outside) ? "ANON"
1981 : (outside == PL_main_cv) ? "MAIN"
1982 : CvUNIQUE(outside) ? "UNIQUE"
1983 : CvGV(outside) ? GvNAME(CvGV(outside)) : "UNDEFINED"));
3967c732
JD		 1984 }
1985 if (nest < maxnest && (CvCLONE(sv) || CvCLONED(sv)))
ad64d0ec 1986 do_sv_dump(level+1, file, MUTABLE_SV(CvOUTSIDE(sv)), nest+1, maxnest, dumpops, pvlim);
3967c732 1987 break;
926fc7b6
DM		 1988 case SVt_PVGV:
1989 case SVt_PVLV:
b9ac451d
AL		 1990 if (type == SVt_PVLV) {
1991 Perl_dump_indent(aTHX_ level, file, " TYPE = %c\n", LvTYPE(sv));
1992 Perl_dump_indent(aTHX_ level, file, " TARGOFF = %"IVdf"\n", (IV)LvTARGOFF(sv));
1993 Perl_dump_indent(aTHX_ level, file, " TARGLEN = %"IVdf"\n", (IV)LvTARGLEN(sv));
1994 Perl_dump_indent(aTHX_ level, file, " TARG = 0x%"UVxf"\n", PTR2UV(LvTARG(sv)));
1995 if (LvTYPE(sv) != 't' && LvTYPE(sv) != 'T')
1996 do_sv_dump(level+1, file, LvTARG(sv), nest+1, maxnest,
1997 dumpops, pvlim);
1998 }
eff3c707
NC		 1999 if (SvVALID(sv)) {
2000 Perl_dump_indent(aTHX_ level, file, " FLAGS = %u\n", (U8)BmFLAGS(sv));
2001 Perl_dump_indent(aTHX_ level, file, " RARE = %u\n", (U8)BmRARE(sv));
1ca32a20
JH		 2002 Perl_dump_indent(aTHX_ level, file, " PREVIOUS = %"UVuf"\n", (UV)BmPREVIOUS(sv));
2003 Perl_dump_indent(aTHX_ level, file, " USEFUL = %"IVdf"\n", (IV)BmUSEFUL(sv));
eff3c707 2004 }
926fc7b6
DM		 2005 if (!isGV_with_GP(sv))
2006 break;
cea2e8a9 2007 Perl_dump_indent(aTHX_ level, file, " NAME = \"%s\"\n", GvNAME(sv));
57def98f 2008 Perl_dump_indent(aTHX_ level, file, " NAMELEN = %"IVdf"\n", (IV)GvNAMELEN(sv));
3967c732 2009 do_hv_dump (level, file, " GvSTASH", GvSTASH(sv));
57def98f 2010 Perl_dump_indent(aTHX_ level, file, " GP = 0x%"UVxf"\n", PTR2UV(GvGP(sv)));
f472eb5c
GS		 2011 if (!GvGP(sv))
2012 break;
57def98f
JH		 2013 Perl_dump_indent(aTHX_ level, file, " SV = 0x%"UVxf"\n", PTR2UV(GvSV(sv)));
2014 Perl_dump_indent(aTHX_ level, file, " REFCNT = %"IVdf"\n", (IV)GvREFCNT(sv));
2015 Perl_dump_indent(aTHX_ level, file, " IO = 0x%"UVxf"\n", PTR2UV(GvIOp(sv)));
2016 Perl_dump_indent(aTHX_ level, file, " FORM = 0x%"UVxf" \n", PTR2UV(GvFORM(sv)));
2017 Perl_dump_indent(aTHX_ level, file, " AV = 0x%"UVxf"\n", PTR2UV(GvAV(sv)));
2018 Perl_dump_indent(aTHX_ level, file, " HV = 0x%"UVxf"\n", PTR2UV(GvHV(sv)));
2019 Perl_dump_indent(aTHX_ level, file, " CV = 0x%"UVxf"\n", PTR2UV(GvCV(sv)));
2020 Perl_dump_indent(aTHX_ level, file, " CVGEN = 0x%"UVxf"\n", (UV)GvCVGEN(sv));
57def98f 2021 Perl_dump_indent(aTHX_ level, file, " LINE = %"IVdf"\n", (IV)GvLINE(sv));
b195d487 2022 Perl_dump_indent(aTHX_ level, file, " FILE = \"%s\"\n", GvFILE(sv));
e39917cc 2023 Perl_dump_indent(aTHX_ level, file, " FLAGS = 0x%"UVxf"\n", (UV)GvFLAGS(sv));
3967c732
JD		 2024 do_gv_dump (level, file, " EGV", GvEGV(sv));
2025 break;
2026 case SVt_PVIO:
57def98f
JH		 2027 Perl_dump_indent(aTHX_ level, file, " IFP = 0x%"UVxf"\n", PTR2UV(IoIFP(sv)));
2028 Perl_dump_indent(aTHX_ level, file, " OFP = 0x%"UVxf"\n", PTR2UV(IoOFP(sv)));
2029 Perl_dump_indent(aTHX_ level, file, " DIRP = 0x%"UVxf"\n", PTR2UV(IoDIRP(sv)));
2030 Perl_dump_indent(aTHX_ level, file, " LINES = %"IVdf"\n", (IV)IoLINES(sv));
2031 Perl_dump_indent(aTHX_ level, file, " PAGE = %"IVdf"\n", (IV)IoPAGE(sv));
2032 Perl_dump_indent(aTHX_ level, file, " PAGE_LEN = %"IVdf"\n", (IV)IoPAGE_LEN(sv));
2033 Perl_dump_indent(aTHX_ level, file, " LINES_LEFT = %"IVdf"\n", (IV)IoLINES_LEFT(sv));
27533608 2034 if (IoTOP_NAME(sv))
cea2e8a9 2035 Perl_dump_indent(aTHX_ level, file, " TOP_NAME = \"%s\"\n", IoTOP_NAME(sv));
9ba1f565
NC		 2036 if (!IoTOP_GV(sv) || SvTYPE(IoTOP_GV(sv)) == SVt_PVGV)
2037 do_gv_dump (level, file, " TOP_GV", IoTOP_GV(sv));
2038 else {
2039 Perl_dump_indent(aTHX_ level, file, " TOP_GV = 0x%"UVxf"\n",
2040 PTR2UV(IoTOP_GV(sv)));
ad64d0ec
NC		 2041 do_sv_dump (level+1, file, MUTABLE_SV(IoTOP_GV(sv)), nest+1,
2042 maxnest, dumpops, pvlim);
9ba1f565
NC		 2043 }
2044 /* Source filters hide things that are not GVs in these three, so let's
2045 be careful out there. */
27533608 2046 if (IoFMT_NAME(sv))
cea2e8a9 2047 Perl_dump_indent(aTHX_ level, file, " FMT_NAME = \"%s\"\n", IoFMT_NAME(sv));
9ba1f565
NC		 2048 if (!IoFMT_GV(sv) || SvTYPE(IoFMT_GV(sv)) == SVt_PVGV)
2049 do_gv_dump (level, file, " FMT_GV", IoFMT_GV(sv));
2050 else {
2051 Perl_dump_indent(aTHX_ level, file, " FMT_GV = 0x%"UVxf"\n",
2052 PTR2UV(IoFMT_GV(sv)));
ad64d0ec
NC		 2053 do_sv_dump (level+1, file, MUTABLE_SV(IoFMT_GV(sv)), nest+1,
2054 maxnest, dumpops, pvlim);
9ba1f565 2055 }
27533608 2056 if (IoBOTTOM_NAME(sv))
cea2e8a9 2057 Perl_dump_indent(aTHX_ level, file, " BOTTOM_NAME = \"%s\"\n", IoBOTTOM_NAME(sv));
9ba1f565
NC		 2058 if (!IoBOTTOM_GV(sv) || SvTYPE(IoBOTTOM_GV(sv)) == SVt_PVGV)
2059 do_gv_dump (level, file, " BOTTOM_GV", IoBOTTOM_GV(sv));
2060 else {
2061 Perl_dump_indent(aTHX_ level, file, " BOTTOM_GV = 0x%"UVxf"\n",
2062 PTR2UV(IoBOTTOM_GV(sv)));
ad64d0ec
NC		 2063 do_sv_dump (level+1, file, MUTABLE_SV(IoBOTTOM_GV(sv)), nest+1,
2064 maxnest, dumpops, pvlim);
9ba1f565 2065 }
27533608 2066 if (isPRINT(IoTYPE(sv)))
cea2e8a9 2067 Perl_dump_indent(aTHX_ level, file, " TYPE = '%c'\n", IoTYPE(sv));
27533608 2068 else
cea2e8a9 2069 Perl_dump_indent(aTHX_ level, file, " TYPE = '\\%o'\n", IoTYPE(sv));
57def98f 2070 Perl_dump_indent(aTHX_ level, file, " FLAGS = 0x%"UVxf"\n", (UV)IoFLAGS(sv));
3967c732
JD		 2071 break;
2072 }
cea89e20 2073 SvREFCNT_dec(d);
3967c732
JD		 2074}
2075
2076void
864dbfa3 2077Perl_sv_dump(pTHX_ SV *sv)
3967c732 2078{
97aff369 2079 dVAR;
7918f24d
NC		 2080
2081 PERL_ARGS_ASSERT_SV_DUMP;
2082
d1029faa
JP		 2083 if (SvROK(sv))
2084 do_sv_dump(0, Perl_debug_log, sv, 0, 4, 0, 0);
2085 else
2086 do_sv_dump(0, Perl_debug_log, sv, 0, 0, 0, 0);
8d063cd8 2087}
bd16a5f0
IZ		 2088
2089int
2090Perl_runops_debug(pTHX)
2091{
97aff369 2092 dVAR;
bd16a5f0 2093 if (!PL_op) {
9b387841 2094 Perl_ck_warner_d(aTHX_ packWARN(WARN_DEBUGGING), "NULL OP IN RUN");
bd16a5f0
IZ		 2095 return 0;
2096 }
2097
9f3673fb 2098 DEBUG_l(Perl_deb(aTHX_ "Entering new RUNOPS level\n"));
bd16a5f0 2099 do {
bd16a5f0 2100 if (PL_debug) {
b9ac451d 2101 if (PL_watchaddr && (*PL_watchaddr != PL_watchok))
bd16a5f0
IZ		 2102 PerlIO_printf(Perl_debug_log,
2103 "WARNING: %"UVxf" changed from %"UVxf" to %"UVxf"\n",
2104 PTR2UV(PL_watchaddr), PTR2UV(PL_watchok),
2105 PTR2UV(*PL_watchaddr));
d6721266
DM		 2106 if (DEBUG_s_TEST_) {
2107 if (DEBUG_v_TEST_) {
2108 PerlIO_printf(Perl_debug_log, "\n");
2109 deb_stack_all();
2110 }
2111 else
2112 debstack();
2113 }
2114
2115
bd16a5f0
IZ		 2116 if (DEBUG_t_TEST_) debop(PL_op);
2117 if (DEBUG_P_TEST_) debprof(PL_op);
2118 }
16c91539 2119 } while ((PL_op = PL_op->op_ppaddr(aTHX)));
9f3673fb 2120 DEBUG_l(Perl_deb(aTHX_ "leaving RUNOPS level\n"));
bd16a5f0
IZ		 2121
2122 TAINT_NOT;
2123 return 0;
2124}
2125
2126I32
6867be6d 2127Perl_debop(pTHX_ const OP *o)
bd16a5f0 2128{
97aff369 2129 dVAR;
7918f24d
NC		 2130
2131 PERL_ARGS_ASSERT_DEBOP;
2132
1045810a
IZ		 2133 if (CopSTASH_eq(PL_curcop, PL_debstash) && !DEBUG_J_TEST_)
2134 return 0;
2135
bd16a5f0
IZ		 2136 Perl_deb(aTHX_ "%s", OP_NAME(o));
2137 switch (o->op_type) {
2138 case OP_CONST:
996c9baa 2139 case OP_HINTSEVAL:
6cefa69e 2140 /* With ITHREADS, consts are stored in the pad, and the right pad
7367e658 2141 * may not be active here, so check.
6cefa69e 2142 * Looks like only during compiling the pads are illegal.
7367e658 2143 */
6cefa69e
RU		 2144#ifdef USE_ITHREADS
2145 if ((((SVOP*)o)->op_sv) || !IN_PERL_COMPILETIME)
2146#endif
7367e658 2147 PerlIO_printf(Perl_debug_log, "(%s)", SvPEEK(cSVOPo_sv));
bd16a5f0
IZ		 2148 break;
2149 case OP_GVSV:
2150 case OP_GV:
2151 if (cGVOPo_gv) {
b9ac451d 2152 SV * const sv = newSV(0);
3b721df9 2153#ifdef PERL_MAD
84021b46 2154 /* FIXME - is this making unwarranted assumptions about the
3b721df9
NC		 2155 UTF-8 cleanliness of the dump file handle? */
2156 SvUTF8_on(sv);
2157#endif
bd61b366 2158 gv_fullname3(sv, cGVOPo_gv, NULL);
93524f2b 2159 PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
bd16a5f0
IZ		 2160 SvREFCNT_dec(sv);
2161 }
2162 else
2163 PerlIO_printf(Perl_debug_log, "(NULL)");
2164 break;
2165 case OP_PADSV:
2166 case OP_PADAV:
2167 case OP_PADHV:
a3b680e6 2168 {
bd16a5f0 2169 /* print the lexical's name */
b9ac451d 2170 CV * const cv = deb_curcv(cxstack_ix);
a3b680e6 2171 SV *sv;
bd16a5f0 2172 if (cv) {
b9ac451d 2173 AV * const padlist = CvPADLIST(cv);
502c6561 2174 AV * const comppad = MUTABLE_AV(*av_fetch(padlist, 0, FALSE));
bd16a5f0
IZ		 2175 sv = *av_fetch(comppad, o->op_targ, FALSE);
2176 } else
a0714e2c 2177 sv = NULL;
bd16a5f0 2178 if (sv)
b9ac451d 2179 PerlIO_printf(Perl_debug_log, "(%s)", SvPV_nolen_const(sv));
bd16a5f0 2180 else
b9ac451d 2181 PerlIO_printf(Perl_debug_log, "[%"UVuf"]", (UV)o->op_targ);
a3b680e6 2182 }
bd16a5f0
IZ		 2183 break;
2184 default:
091ab601 2185 break;
bd16a5f0
IZ		 2186 }
2187 PerlIO_printf(Perl_debug_log, "\n");
2188 return 0;
2189}
2190
2191STATIC CV*
61f9802b 2192S_deb_curcv(pTHX_ const I32 ix)
bd16a5f0 2193{
97aff369 2194 dVAR;
b9ac451d 2195 const PERL_CONTEXT * const cx = &cxstack[ix];
bd16a5f0
IZ		 2196 if (CxTYPE(cx) == CXt_SUB || CxTYPE(cx) == CXt_FORMAT)
2197 return cx->blk_sub.cv;
2198 else if (CxTYPE(cx) == CXt_EVAL && !CxTRYBLOCK(cx))
2199 return PL_compcv;
2200 else if (ix == 0 && PL_curstackinfo->si_type == PERLSI_MAIN)
2201 return PL_main_cv;
2202 else if (ix <= 0)
601f1833 2203 return NULL;
bd16a5f0
IZ		 2204 else
2205 return deb_curcv(ix - 1);
2206}
2207
2208void
2209Perl_watch(pTHX_ char **addr)
2210{
97aff369 2211 dVAR;
7918f24d
NC		 2212
2213 PERL_ARGS_ASSERT_WATCH;
2214
bd16a5f0
IZ		 2215 PL_watchaddr = addr;
2216 PL_watchok = *addr;
2217 PerlIO_printf(Perl_debug_log, "WATCHING, %"UVxf" is currently %"UVxf"\n",
2218 PTR2UV(PL_watchaddr), PTR2UV(PL_watchok));
2219}
2220
2221STATIC void
e1ec3a88 2222S_debprof(pTHX_ const OP *o)
bd16a5f0 2223{
97aff369 2224 dVAR;
7918f24d
NC		 2225
2226 PERL_ARGS_ASSERT_DEBPROF;
2227
61f9802b 2228 if (!DEBUG_J_TEST_ && CopSTASH_eq(PL_curcop, PL_debstash))
1045810a 2229 return;
bd16a5f0 2230 if (!PL_profiledata)
a02a5408 2231 Newxz(PL_profiledata, MAXO, U32);
bd16a5f0
IZ		 2232 ++PL_profiledata[o->op_type];
2233}
2234
2235void
2236Perl_debprofdump(pTHX)
2237{
97aff369 2238 dVAR;
bd16a5f0
IZ		 2239 unsigned i;
2240 if (!PL_profiledata)
2241 return;
2242 for (i = 0; i < MAXO; i++) {
2243 if (PL_profiledata[i])
2244 PerlIO_printf(Perl_debug_log,
2245 "%5lu %s\n", (unsigned long)PL_profiledata[i],
2246 PL_op_name[i]);
2247 }
2248}
66610fdd 2249
3b721df9
NC		 2250#ifdef PERL_MAD
2251/*
2252 * XML variants of most of the above routines
2253 */
2254
4136a0f7 2255STATIC void
3b721df9
NC		 2256S_xmldump_attr(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
2257{
2258 va_list args;
7918f24d
NC		 2259
2260 PERL_ARGS_ASSERT_XMLDUMP_ATTR;
2261
3b721df9
NC		 2262 PerlIO_printf(file, "\n ");
2263 va_start(args, pat);
2264 xmldump_vindent(level, file, pat, &args);
2265 va_end(args);
2266}
2267
2268
2269void
2270Perl_xmldump_indent(pTHX_ I32 level, PerlIO *file, const char* pat, ...)
2271{
2272 va_list args;
7918f24d 2273 PERL_ARGS_ASSERT_XMLDUMP_INDENT;
3b721df9
NC		 2274 va_start(args, pat);
2275 xmldump_vindent(level, file, pat, &args);
2276 va_end(args);
2277}
2278
2279void
2280Perl_xmldump_vindent(pTHX_ I32 level, PerlIO *file, const char* pat, va_list *args)
2281{
7918f24d
NC		 2282 PERL_ARGS_ASSERT_XMLDUMP_VINDENT;
2283
3b721df9
NC		 2284 PerlIO_printf(file, "%*s", (int)(level*PL_dumpindent), "");
2285 PerlIO_vprintf(file, pat, *args);
2286}
2287
2288void
2289Perl_xmldump_all(pTHX)
2290{
f0e3f042
CS		 2291 xmldump_all_perl(FALSE);
2292}
2293
2294void
2295Perl_xmldump_all_perl(pTHX_ bool justperl)
2296{
3b721df9
NC		 2297 PerlIO_setlinebuf(PL_xmlfp);
2298 if (PL_main_root)
2299 op_xmldump(PL_main_root);
3ab0c9fa 2300 xmldump_packsubs_perl(PL_defstash, justperl);
3b721df9
NC		 2301 if (PL_xmlfp != (PerlIO*)PerlIO_stdout())
2302 PerlIO_close(PL_xmlfp);
2303 PL_xmlfp = 0;
2304}
2305
2306void
2307Perl_xmldump_packsubs(pTHX_ const HV *stash)
2308{
28eb953d 2309 PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS;
3ab0c9fa
NC		 2310 xmldump_packsubs_perl(stash, FALSE);
2311}
2312
2313void
2314Perl_xmldump_packsubs_perl(pTHX_ const HV *stash, bool justperl)
2315{
3b721df9
NC		 2316 I32 i;
2317 HE *entry;
2318
28eb953d 2319 PERL_ARGS_ASSERT_XMLDUMP_PACKSUBS_PERL;
7918f24d 2320
3b721df9
NC		 2321 if (!HvARRAY(stash))
2322 return;
2323 for (i = 0; i <= (I32) HvMAX(stash); i++) {
2324 for (entry = HvARRAY(stash)[i]; entry; entry = HeNEXT(entry)) {
159b6efe 2325 GV *gv = MUTABLE_GV(HeVAL(entry));
3b721df9
NC		 2326 HV *hv;
2327 if (SvTYPE(gv) != SVt_PVGV || !GvGP(gv))
2328 continue;
2329 if (GvCVu(gv))
3ab0c9fa 2330 xmldump_sub_perl(gv, justperl);
3b721df9
NC		 2331 if (GvFORM(gv))
2332 xmldump_form(gv);
2333 if (HeKEY(entry)[HeKLEN(entry)-1] == ':'
2334 && (hv = GvHV(gv)) && hv != PL_defstash)
3ab0c9fa 2335 xmldump_packsubs_perl(hv, justperl); /* nested package */
3b721df9
NC		 2336 }
2337 }
2338}
2339
2340void
2341Perl_xmldump_sub(pTHX_ const GV *gv)
2342{
28eb953d 2343 PERL_ARGS_ASSERT_XMLDUMP_SUB;
f0e3f042
CS		 2344 xmldump_sub_perl(gv, FALSE);
2345}
2346
2347void
2348Perl_xmldump_sub_perl(pTHX_ const GV *gv, bool justperl)
2349{
2350 SV * sv;
3b721df9 2351
28eb953d 2352 PERL_ARGS_ASSERT_XMLDUMP_SUB_PERL;
7918f24d 2353
f0e3f042
CS		 2354 if (justperl && (CvISXSUB(GvCV(gv)) || !CvROOT(GvCV(gv))))
2355 return;
2356
2357 sv = sv_newmortal();
1a9a51d4 2358 gv_fullname3(sv, gv, NULL);
3b721df9
NC		 2359 Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nSUB %s = ", SvPVX(sv));
2360 if (CvXSUB(GvCV(gv)))
2361 Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "(xsub 0x%"UVxf" %d)\n",
2362 PTR2UV(CvXSUB(GvCV(gv))),
2363 (int)CvXSUBANY(GvCV(gv)).any_i32);
2364 else if (CvROOT(GvCV(gv)))
2365 op_xmldump(CvROOT(GvCV(gv)));
2366 else
2367 Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "<undef>\n");
2368}
2369
2370void
2371Perl_xmldump_form(pTHX_ const GV *gv)
2372{
61f9802b 2373 SV * const sv = sv_newmortal();
3b721df9 2374
7918f24d
NC		 2375 PERL_ARGS_ASSERT_XMLDUMP_FORM;
2376
1a9a51d4 2377 gv_fullname3(sv, gv, NULL);
3b721df9
NC		 2378 Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "\nFORMAT %s = ", SvPVX(sv));
2379 if (CvROOT(GvFORM(gv)))
2380 op_xmldump(CvROOT(GvFORM(gv)));
2381 else
2382 Perl_xmldump_indent(aTHX_ 0, PL_xmlfp, "<undef>\n");
2383}
2384
2385void
2386Perl_xmldump_eval(pTHX)
2387{
2388 op_xmldump(PL_eval_root);
2389}
2390
2391char *
2392Perl_sv_catxmlsv(pTHX_ SV *dsv, SV *ssv)
2393{
7918f24d 2394 PERL_ARGS_ASSERT_SV_CATXMLSV;
3b721df9
NC		 2395 return sv_catxmlpvn(dsv, SvPVX(ssv), SvCUR(ssv), SvUTF8(ssv));
2396}
2397
2398char *
20f84293 2399Perl_sv_catxmlpvn(pTHX_ SV *dsv, const char *pv, STRLEN len, int utf8)
3b721df9
NC		 2400{
2401 unsigned int c;
61f9802b 2402 const char * const e = pv + len;
20f84293 2403 const char * const start = pv;
3b721df9
NC		 2404 STRLEN dsvcur;
2405 STRLEN cl;
2406
7918f24d
NC		 2407 PERL_ARGS_ASSERT_SV_CATXMLPVN;
2408
76f68e9b 2409 sv_catpvs(dsv,"");
3b721df9
NC		 2410 dsvcur = SvCUR(dsv); /* in case we have to restart */
2411
2412 retry:
2413 while (pv < e) {
2414 if (utf8) {
2415 c = utf8_to_uvchr((U8*)pv, &cl);
2416 if (cl == 0) {
2417 SvCUR(dsv) = dsvcur;
2418 pv = start;
2419 utf8 = 0;
2420 goto retry;
2421 }
2422 }
2423 else
2424 c = (*pv & 255);
2425
2426 switch (c) {
2427 case 0x00:
2428 case 0x01:
2429 case 0x02:
2430 case 0x03:
2431 case 0x04:
2432 case 0x05:
2433 case 0x06:
2434 case 0x07:
2435 case 0x08:
2436 case 0x0b:
2437 case 0x0c:
2438 case 0x0e:
2439 case 0x0f:
2440 case 0x10:
2441 case 0x11:
2442 case 0x12:
2443 case 0x13:
2444 case 0x14:
2445 case 0x15:
2446 case 0x16:
2447 case 0x17:
2448 case 0x18:
2449 case 0x19:
2450 case 0x1a:
2451 case 0x1b:
2452 case 0x1c:
2453 case 0x1d:
2454 case 0x1e:
2455 case 0x1f:
2456 case 0x7f:
2457 case 0x80:
2458 case 0x81:
2459 case 0x82:
2460 case 0x83:
2461 case 0x84:
2462 case 0x86:
2463 case 0x87:
2464 case 0x88:
2465 case 0x89:
2466 case 0x90:
2467 case 0x91:
2468 case 0x92:
2469 case 0x93:
2470 case 0x94:
2471 case 0x95:
2472 case 0x96:
2473 case 0x97:
2474 case 0x98:
2475 case 0x99:
2476 case 0x9a:
2477 case 0x9b:
2478 case 0x9c:
2479 case 0x9d:
2480 case 0x9e:
2481 case 0x9f:
2482 Perl_sv_catpvf(aTHX_ dsv, "STUPIDXML(#x%X)", c);
2483 break;
2484 case '<':
f3a2811a 2485 sv_catpvs(dsv, "&lt;");
3b721df9
NC		 2486 break;
2487 case '>':
f3a2811a 2488 sv_catpvs(dsv, "&gt;");
3b721df9
NC		 2489 break;
2490 case '&':
f3a2811a 2491 sv_catpvs(dsv, "&amp;");
3b721df9
NC		 2492 break;
2493 case '"':
49de0815 2494 sv_catpvs(dsv, "&#34;");
3b721df9
NC		 2495 break;
2496 default:
2497 if (c < 0xD800) {
2498 if (c < 32 || c > 127) {
2499 Perl_sv_catpvf(aTHX_ dsv, "&#x%X;", c);
2500 }
2501 else {
5e7aa789
NC		 2502 const char string = (char) c;
2503 sv_catpvn(dsv, &string, 1);
3b721df9
NC		 2504 }
2505 break;
2506 }
2507 if ((c >= 0xD800 && c <= 0xDB7F) ||
2508 (c >= 0xDC00 && c <= 0xDFFF) ||
2509 (c >= 0xFFF0 && c <= 0xFFFF) ||
2510 c > 0x10ffff)
2511 Perl_sv_catpvf(aTHX_ dsv, "STUPIDXML(#x%X)", c);
2512 else
2513 Perl_sv_catpvf(aTHX_ dsv, "&#x%X;", c);
2514 }
2515
2516 if (utf8)
2517 pv += UTF8SKIP(pv);
2518 else
2519 pv++;
2520 }
2521
2522 return SvPVX(dsv);
2523}
2524
2525char *
2526Perl_sv_xmlpeek(pTHX_ SV *sv)
2527{
61f9802b 2528 SV * const t = sv_newmortal();
3b721df9
NC		 2529 STRLEN n_a;
2530 int unref = 0;
2531
7918f24d
NC		 2532 PERL_ARGS_ASSERT_SV_XMLPEEK;
2533
3b721df9 2534 sv_utf8_upgrade(t);
76f68e9b 2535 sv_setpvs(t, "");
3b721df9
NC		 2536 /* retry: */
2537 if (!sv) {
2538 sv_catpv(t, "VOID=\"\"");
2539 goto finish;
2540 }
ad64d0ec 2541 else if (sv == (const SV *)0x55555555 || SvTYPE(sv) == 'U') {
3b721df9
NC		 2542 sv_catpv(t, "WILD=\"\"");
2543 goto finish;
2544 }
2545 else if (sv == &PL_sv_undef || sv == &PL_sv_no || sv == &PL_sv_yes || sv == &PL_sv_placeholder) {
2546 if (sv == &PL_sv_undef) {
2547 sv_catpv(t, "SV_UNDEF=\"1\"");
2548 if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
2549 SVs_GMG|SVs_SMG|SVs_RMG)) &&
2550 SvREADONLY(sv))
2551 goto finish;
2552 }
2553 else if (sv == &PL_sv_no) {
2554 sv_catpv(t, "SV_NO=\"1\"");
2555 if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
2556 SVs_GMG|SVs_SMG|SVs_RMG)) &&
2557 !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
2558 SVp_POK|SVp_NOK)) &&
2559 SvCUR(sv) == 0 &&
2560 SvNVX(sv) == 0.0)
2561 goto finish;
2562 }
2563 else if (sv == &PL_sv_yes) {
2564 sv_catpv(t, "SV_YES=\"1\"");
2565 if (!(SvFLAGS(sv) & (SVf_ROK|SVf_OOK|SVs_OBJECT|
2566 SVs_GMG|SVs_SMG|SVs_RMG)) &&
2567 !(~SvFLAGS(sv) & (SVf_POK|SVf_NOK|SVf_READONLY|
2568 SVp_POK|SVp_NOK)) &&
2569 SvCUR(sv) == 1 &&
2570 SvPVX(sv) && *SvPVX(sv) == '1' &&
2571 SvNVX(sv) == 1.0)
2572 goto finish;
2573 }
2574 else {
2575 sv_catpv(t, "SV_PLACEHOLDER=\"1\"");
2576 if (!(SvFLAGS(sv) & (SVf_OK|SVf_OOK|SVs_OBJECT|
2577 SVs_GMG|SVs_SMG|SVs_RMG)) &&
2578 SvREADONLY(sv))
2579 goto finish;
2580 }
2581 sv_catpv(t, " XXX=\"\" ");
2582 }
2583 else if (SvREFCNT(sv) == 0) {
2584 sv_catpv(t, " refcnt=\"0\"");
2585 unref++;
2586 }
2587 else if (DEBUG_R_TEST_) {
2588 int is_tmp = 0;
2589 I32 ix;
2590 /* is this SV on the tmps stack? */
2591 for (ix=PL_tmps_ix; ix>=0; ix--) {
2592 if (PL_tmps_stack[ix] == sv) {
2593 is_tmp = 1;
2594 break;
2595 }
2596 }
2597 if (SvREFCNT(sv) > 1)
2598 Perl_sv_catpvf(aTHX_ t, " DRT=\"<%"UVuf"%s>\"", (UV)SvREFCNT(sv),
2599 is_tmp ? "T" : "");
2600 else if (is_tmp)
2601 sv_catpv(t, " DRT=\"<T>\"");
2602 }
2603
2604 if (SvROK(sv)) {
2605 sv_catpv(t, " ROK=\"\"");
2606 }
2607 switch (SvTYPE(sv)) {
2608 default:
2609 sv_catpv(t, " FREED=\"1\"");
2610 goto finish;
2611
2612 case SVt_NULL:
2613 sv_catpv(t, " UNDEF=\"1\"");
2614 goto finish;
2615 case SVt_IV:
2616 sv_catpv(t, " IV=\"");
2617 break;
2618 case SVt_NV:
2619 sv_catpv(t, " NV=\"");
2620 break;
3b721df9
NC		 2621 case SVt_PV:
2622 sv_catpv(t, " PV=\"");
2623 break;
2624 case SVt_PVIV:
2625 sv_catpv(t, " PVIV=\"");
2626 break;
2627 case SVt_PVNV:
2628 sv_catpv(t, " PVNV=\"");
2629 break;
2630 case SVt_PVMG:
2631 sv_catpv(t, " PVMG=\"");
2632 break;
2633 case SVt_PVLV:
2634 sv_catpv(t, " PVLV=\"");
2635 break;
2636 case SVt_PVAV:
2637 sv_catpv(t, " AV=\"");
2638 break;
2639 case SVt_PVHV:
2640 sv_catpv(t, " HV=\"");
2641 break;
2642 case SVt_PVCV:
2643 if (CvGV(sv))
2644 Perl_sv_catpvf(aTHX_ t, " CV=\"(%s)\"", GvNAME(CvGV(sv)));
2645 else
2646 sv_catpv(t, " CV=\"()\"");
2647 goto finish;
2648 case SVt_PVGV:
2649 sv_catpv(t, " GV=\"");
2650 break;
cecf5685
NC		 2651 case SVt_BIND:
2652 sv_catpv(t, " BIND=\"");
3b721df9 2653 break;
d914baab 2654 case SVt_REGEXP:
4df7f6af
NC		 2655 sv_catpv(t, " ORANGE=\"");
2656 break;
3b721df9
NC		 2657 case SVt_PVFM:
2658 sv_catpv(t, " FM=\"");
2659 break;
2660 case SVt_PVIO:
2661 sv_catpv(t, " IO=\"");
2662 break;
2663 }
2664
2665 if (SvPOKp(sv)) {
2666 if (SvPVX(sv)) {
2667 sv_catxmlsv(t, sv);
2668 }
2669 }
2670 else if (SvNOKp(sv)) {
2671 STORE_NUMERIC_LOCAL_SET_STANDARD();
2672 Perl_sv_catpvf(aTHX_ t, "%"NVgf"",SvNVX(sv));
2673 RESTORE_NUMERIC_LOCAL();
2674 }
2675 else if (SvIOKp(sv)) {
2676 if (SvIsUV(sv))
2677 Perl_sv_catpvf(aTHX_ t, "%"UVuf"", (UV)SvUVX(sv));
2678 else
2679 Perl_sv_catpvf(aTHX_ t, "%"IVdf"", (IV)SvIVX(sv));
2680 }
2681 else
2682 sv_catpv(t, "");
2683 sv_catpv(t, "\"");
2684
2685 finish:
61f9802b
AL		 2686 while (unref--)
2687 sv_catpv(t, ")");
3b721df9
NC		 2688 return SvPV(t, n_a);
2689}
2690
2691void
2692Perl_do_pmop_xmldump(pTHX_ I32 level, PerlIO *file, const PMOP *pm)
2693{
7918f24d
NC		 2694 PERL_ARGS_ASSERT_DO_PMOP_XMLDUMP;
2695
3b721df9
NC		 2696 if (!pm) {
2697 Perl_xmldump_indent(aTHX_ level, file, "<pmop/>\n");
2698 return;
2699 }
2700 Perl_xmldump_indent(aTHX_ level, file, "<pmop \n");
2701 level++;
2702 if (PM_GETRE(pm)) {
d914baab 2703 REGEXP *const r = PM_GETRE(pm);
643e696a 2704 SV * const tmpsv = newSVpvn_utf8("", 0, TRUE);
ad64d0ec 2705 sv_catxmlsv(tmpsv, MUTABLE_SV(r));
3b721df9
NC		 2706 Perl_xmldump_indent(aTHX_ level, file, "pre=\"%s\"\n",
2707 SvPVX(tmpsv));
2708 SvREFCNT_dec(tmpsv);
2709 Perl_xmldump_indent(aTHX_ level, file, "when=\"%s\"\n",
2710 (pm->op_private & OPpRUNTIME) ? "RUN" : "COMP");
2711 }
2712 else
2713 Perl_xmldump_indent(aTHX_ level, file, "pre=\"\" when=\"RUN\"\n");
d914baab 2714 if (pm->op_pmflags || (PM_GETRE(pm) && RX_CHECK_SUBSTR(PM_GETRE(pm)))) {
3df43ef7 2715 SV * const tmpsv = pm_description(pm);
3b721df9
NC		 2716 Perl_xmldump_indent(aTHX_ level, file, "pmflags=\"%s\"\n", SvCUR(tmpsv) ? SvPVX(tmpsv) + 1 : "");
2717 SvREFCNT_dec(tmpsv);
2718 }
2719
2720 level--;
20e98b0f 2721 if (pm->op_type != OP_PUSHRE && pm->op_pmreplrootu.op_pmreplroot) {
3b721df9
NC		 2722 Perl_xmldump_indent(aTHX_ level, file, ">\n");
2723 Perl_xmldump_indent(aTHX_ level+1, file, "<pm_repl>\n");
20e98b0f 2724 do_op_xmldump(level+2, file, pm->op_pmreplrootu.op_pmreplroot);
3b721df9
NC		 2725 Perl_xmldump_indent(aTHX_ level+1, file, "</pm_repl>\n");
2726 Perl_xmldump_indent(aTHX_ level, file, "</pmop>\n");
2727 }
2728 else
2729 Perl_xmldump_indent(aTHX_ level, file, "/>\n");
2730}
2731
2732void
2733Perl_pmop_xmldump(pTHX_ const PMOP *pm)
2734{
2735 do_pmop_xmldump(0, PL_xmlfp, pm);
2736}
2737
2738void
2739Perl_do_op_xmldump(pTHX_ I32 level, PerlIO *file, const OP *o)
2740{
2741 UV seq;
2742 int contents = 0;
7918f24d
NC		 2743
2744 PERL_ARGS_ASSERT_DO_OP_XMLDUMP;
2745
3b721df9
NC		 2746 if (!o)
2747 return;
2748 sequence(o);
2749 seq = sequence_num(o);
2750 Perl_xmldump_indent(aTHX_ level, file,
2751 "<op_%s seq=\"%"UVuf" -> ",
2752 OP_NAME(o),
2753 seq);
2754 level++;
2755 if (o->op_next)
2756 PerlIO_printf(file, seq ? "%"UVuf"\"" : "(%"UVuf")\"",
2757 sequence_num(o->op_next));
2758 else
2759 PerlIO_printf(file, "DONE\"");
2760
2761 if (o->op_targ) {
2762 if (o->op_type == OP_NULL)
2763 {
2764 PerlIO_printf(file, " was=\"%s\"", PL_op_name[o->op_targ]);
2765 if (o->op_targ == OP_NEXTSTATE)
2766 {
2767 if (CopLINE(cCOPo))
f5992bc4 2768 PerlIO_printf(file, " line=\"%"UVuf"\"",
3b721df9
NC		 2769 (UV)CopLINE(cCOPo));
2770 if (CopSTASHPV(cCOPo))
2771 PerlIO_printf(file, " package=\"%s\"",
2772 CopSTASHPV(cCOPo));
4b65a919 2773 if (CopLABEL(cCOPo))
3b721df9 2774 PerlIO_printf(file, " label=\"%s\"",
4b65a919 2775 CopLABEL(cCOPo));
3b721df9
NC		 2776 }
2777 }
2778 else
2779 PerlIO_printf(file, " targ=\"%ld\"", (long)o->op_targ);
2780 }
2781#ifdef DUMPADDR
2782 PerlIO_printf(file, " addr=\"0x%"UVxf" => 0x%"UVxf"\"", (UV)o, (UV)o->op_next);
2783#endif
2784 if (o->op_flags) {
76f68e9b 2785 SV * const tmpsv = newSVpvs("");
3b721df9
NC		 2786 switch (o->op_flags & OPf_WANT) {
2787 case OPf_WANT_VOID:
2788 sv_catpv(tmpsv, ",VOID");
2789 break;
2790 case OPf_WANT_SCALAR:
2791 sv_catpv(tmpsv, ",SCALAR");
2792 break;
2793 case OPf_WANT_LIST:
2794 sv_catpv(tmpsv, ",LIST");
2795 break;
2796 default:
2797 sv_catpv(tmpsv, ",UNKNOWN");
2798 break;
2799 }
2800 if (o->op_flags & OPf_KIDS)
2801 sv_catpv(tmpsv, ",KIDS");
2802 if (o->op_flags & OPf_PARENS)
2803 sv_catpv(tmpsv, ",PARENS");
2804 if (o->op_flags & OPf_STACKED)
2805 sv_catpv(tmpsv, ",STACKED");
2806 if (o->op_flags & OPf_REF)
2807 sv_catpv(tmpsv, ",REF");
2808 if (o->op_flags & OPf_MOD)
2809 sv_catpv(tmpsv, ",MOD");
2810 if (o->op_flags & OPf_SPECIAL)
2811 sv_catpv(tmpsv, ",SPECIAL");
2812 PerlIO_printf(file, " flags=\"%s\"", SvCUR(tmpsv) ? SvPVX(tmpsv) + 1 : "");
2813 SvREFCNT_dec(tmpsv);
2814 }
2815 if (o->op_private) {
76f68e9b 2816 SV * const tmpsv = newSVpvs("");
3b721df9
NC		 2817 if (PL_opargs[o->op_type] & OA_TARGLEX) {
2818 if (o->op_private & OPpTARGET_MY)
2819 sv_catpv(tmpsv, ",TARGET_MY");
2820 }
2821 else if (o->op_type == OP_LEAVESUB ||
2822 o->op_type == OP_LEAVE ||
2823 o->op_type == OP_LEAVESUBLV ||
2824 o->op_type == OP_LEAVEWRITE) {
2825 if (o->op_private & OPpREFCOUNTED)
2826 sv_catpv(tmpsv, ",REFCOUNTED");
2827 }
2828 else if (o->op_type == OP_AASSIGN) {
2829 if (o->op_private & OPpASSIGN_COMMON)
2830 sv_catpv(tmpsv, ",COMMON");
2831 }
2832 else if (o->op_type == OP_SASSIGN) {
2833 if (o->op_private & OPpASSIGN_BACKWARDS)
2834 sv_catpv(tmpsv, ",BACKWARDS");
2835 }
2836 else if (o->op_type == OP_TRANS) {
2837 if (o->op_private & OPpTRANS_SQUASH)
2838 sv_catpv(tmpsv, ",SQUASH");
2839 if (o->op_private & OPpTRANS_DELETE)
2840 sv_catpv(tmpsv, ",DELETE");
2841 if (o->op_private & OPpTRANS_COMPLEMENT)
2842 sv_catpv(tmpsv, ",COMPLEMENT");
2843 if (o->op_private & OPpTRANS_IDENTICAL)
2844 sv_catpv(tmpsv, ",IDENTICAL");
2845 if (o->op_private & OPpTRANS_GROWS)
2846 sv_catpv(tmpsv, ",GROWS");
2847 }
2848 else if (o->op_type == OP_REPEAT) {
2849 if (o->op_private & OPpREPEAT_DOLIST)
2850 sv_catpv(tmpsv, ",DOLIST");
2851 }
2852 else if (o->op_type == OP_ENTERSUB ||
2853 o->op_type == OP_RV2SV ||
2854 o->op_type == OP_GVSV ||
2855 o->op_type == OP_RV2AV ||
2856 o->op_type == OP_RV2HV ||
2857 o->op_type == OP_RV2GV ||
2858 o->op_type == OP_AELEM ||
2859 o->op_type == OP_HELEM )
2860 {
2861 if (o->op_type == OP_ENTERSUB) {
2862 if (o->op_private & OPpENTERSUB_AMPER)
2863 sv_catpv(tmpsv, ",AMPER");
2864 if (o->op_private & OPpENTERSUB_DB)
2865 sv_catpv(tmpsv, ",DB");
2866 if (o->op_private & OPpENTERSUB_HASTARG)
2867 sv_catpv(tmpsv, ",HASTARG");
2868 if (o->op_private & OPpENTERSUB_NOPAREN)
2869 sv_catpv(tmpsv, ",NOPAREN");
2870 if (o->op_private & OPpENTERSUB_INARGS)
2871 sv_catpv(tmpsv, ",INARGS");
2872 if (o->op_private & OPpENTERSUB_NOMOD)
2873 sv_catpv(tmpsv, ",NOMOD");
2874 }
2875 else {
2876 switch (o->op_private & OPpDEREF) {
2877 case OPpDEREF_SV:
2878 sv_catpv(tmpsv, ",SV");
2879 break;
2880 case OPpDEREF_AV:
2881 sv_catpv(tmpsv, ",AV");
2882 break;
2883 case OPpDEREF_HV:
2884 sv_catpv(tmpsv, ",HV");
2885 break;
2886 }
2887 if (o->op_private & OPpMAYBE_LVSUB)
2888 sv_catpv(tmpsv, ",MAYBE_LVSUB");
2889 }
2890 if (o->op_type == OP_AELEM || o->op_type == OP_HELEM) {
2891 if (o->op_private & OPpLVAL_DEFER)
2892 sv_catpv(tmpsv, ",LVAL_DEFER");
2893 }
2894 else {
2895 if (o->op_private & HINT_STRICT_REFS)
2896 sv_catpv(tmpsv, ",STRICT_REFS");
2897 if (o->op_private & OPpOUR_INTRO)
2898 sv_catpv(tmpsv, ",OUR_INTRO");
2899 }
2900 }
2901 else if (o->op_type == OP_CONST) {
2902 if (o->op_private & OPpCONST_BARE)
2903 sv_catpv(tmpsv, ",BARE");
2904 if (o->op_private & OPpCONST_STRICT)
2905 sv_catpv(tmpsv, ",STRICT");
2906 if (o->op_private & OPpCONST_ARYBASE)
2907 sv_catpv(tmpsv, ",ARYBASE");
2908 if (o->op_private & OPpCONST_WARNING)
2909 sv_catpv(tmpsv, ",WARNING");
2910 if (o->op_private & OPpCONST_ENTERED)
2911 sv_catpv(tmpsv, ",ENTERED");
2912 }
2913 else if (o->op_type == OP_FLIP) {
2914 if (o->op_private & OPpFLIP_LINENUM)
2915 sv_catpv(tmpsv, ",LINENUM");
2916 }
2917 else if (o->op_type == OP_FLOP) {
2918 if (o->op_private & OPpFLIP_LINENUM)
2919 sv_catpv(tmpsv, ",LINENUM");
2920 }
2921 else if (o->op_type == OP_RV2CV) {
2922 if (o->op_private & OPpLVAL_INTRO)
2923 sv_catpv(tmpsv, ",INTRO");
2924 }
2925 else if (o->op_type == OP_GV) {
2926 if (o->op_private & OPpEARLY_CV)
2927 sv_catpv(tmpsv, ",EARLY_CV");
2928 }
2929 else if (o->op_type == OP_LIST) {
2930 if (o->op_private & OPpLIST_GUESSED)
2931 sv_catpv(tmpsv, ",GUESSED");
2932 }
2933 else if (o->op_type == OP_DELETE) {
2934 if (o->op_private & OPpSLICE)
2935 sv_catpv(tmpsv, ",SLICE");
2936 }
2937 else if (o->op_type == OP_EXISTS) {
2938 if (o->op_private & OPpEXISTS_SUB)
2939 sv_catpv(tmpsv, ",EXISTS_SUB");
2940 }
2941 else if (o->op_type == OP_SORT) {
2942 if (o->op_private & OPpSORT_NUMERIC)
2943 sv_catpv(tmpsv, ",NUMERIC");
2944 if (o->op_private & OPpSORT_INTEGER)
2945 sv_catpv(tmpsv, ",INTEGER");
2946 if (o->op_private & OPpSORT_REVERSE)
2947 sv_catpv(tmpsv, ",REVERSE");
2948 }
3b721df9
NC		 2949 else if (o->op_type == OP_OPEN || o->op_type == OP_BACKTICK) {
2950 if (o->op_private & OPpOPEN_IN_RAW)
2951 sv_catpv(tmpsv, ",IN_RAW");
2952 if (o->op_private & OPpOPEN_IN_CRLF)
2953 sv_catpv(tmpsv, ",IN_CRLF");
2954 if (o->op_private & OPpOPEN_OUT_RAW)
2955 sv_catpv(tmpsv, ",OUT_RAW");
2956 if (o->op_private & OPpOPEN_OUT_CRLF)
2957 sv_catpv(tmpsv, ",OUT_CRLF");
2958 }
2959 else if (o->op_type == OP_EXIT) {
2960 if (o->op_private & OPpEXIT_VMSISH)
2961 sv_catpv(tmpsv, ",EXIT_VMSISH");
2962 if (o->op_private & OPpHUSH_VMSISH)
2963 sv_catpv(tmpsv, ",HUSH_VMSISH");
2964 }
2965 else if (o->op_type == OP_DIE) {
2966 if (o->op_private & OPpHUSH_VMSISH)
2967 sv_catpv(tmpsv, ",HUSH_VMSISH");
2968 }
2969 else if (PL_check[o->op_type] != MEMBER_TO_FPTR(Perl_ck_ftst)) {
6ecf81d6 2970 if (OP_IS_FILETEST_ACCESS(o->op_type) && o->op_private & OPpFT_ACCESS)
3b721df9
NC		 2971 sv_catpv(tmpsv, ",FT_ACCESS");
2972 if (o->op_private & OPpFT_STACKED)
2973 sv_catpv(tmpsv, ",FT_STACKED");
2974 }
2975 if (o->op_flags & OPf_MOD && o->op_private & OPpLVAL_INTRO)
2976 sv_catpv(tmpsv, ",INTRO");
2977 if (SvCUR(tmpsv))
2978 S_xmldump_attr(aTHX_ level, file, "private=\"%s\"", SvPVX(tmpsv) + 1);
2979 SvREFCNT_dec(tmpsv);
2980 }
2981
2982 switch (o->op_type) {
2983 case OP_AELEMFAST:
2984 if (o->op_flags & OPf_SPECIAL) {
2985 break;
2986 }
2987 case OP_GVSV:
2988 case OP_GV:
2989#ifdef USE_ITHREADS
2990 S_xmldump_attr(aTHX_ level, file, "padix=\"%" IVdf "\"", (IV)cPADOPo->op_padix);
2991#else
2992 if (cSVOPo->op_sv) {
d914baab
NC		 2993 SV * const tmpsv1 = newSVpvn_utf8(NULL, 0, TRUE);
2994 SV * const tmpsv2 = newSVpvn_utf8("", 0, TRUE);
3b721df9
NC		 2995 char *s;
2996 STRLEN len;
2997 ENTER;
2998 SAVEFREESV(tmpsv1);
2999 SAVEFREESV(tmpsv2);
159b6efe 3000 gv_fullname3(tmpsv1, MUTABLE_GV(cSVOPo->op_sv), NULL);
3b721df9
NC		 3001 s = SvPV(tmpsv1,len);
3002 sv_catxmlpvn(tmpsv2, s, len, 1);
3003 S_xmldump_attr(aTHX_ level, file, "gv=\"%s\"", SvPV(tmpsv2, len));
3004 LEAVE;
3005 }
3006 else
3007 S_xmldump_attr(aTHX_ level, file, "gv=\"NULL\"");
3008#endif
3009 break;
3010 case OP_CONST:
996c9baa 3011 case OP_HINTSEVAL:
3b721df9
NC		 3012 case OP_METHOD_NAMED:
3013#ifndef USE_ITHREADS
3014 /* with ITHREADS, consts are stored in the pad, and the right pad
3015 * may not be active here, so skip */
3016 S_xmldump_attr(aTHX_ level, file, "%s", sv_xmlpeek(cSVOPo_sv));
3017#endif
3018 break;
3019 case OP_ANONCODE:
3020 if (!contents) {
3021 contents = 1;
3022 PerlIO_printf(file, ">\n");
3023 }
3024 do_op_xmldump(level+1, file, CvROOT(cSVOPo_sv));
3025 break;
3b721df9
NC		 3026 case OP_NEXTSTATE:
3027 case OP_DBSTATE:
3028 if (CopLINE(cCOPo))
f5992bc4 3029 S_xmldump_attr(aTHX_ level, file, "line=\"%"UVuf"\"",
3b721df9
NC		 3030 (UV)CopLINE(cCOPo));
3031 if (CopSTASHPV(cCOPo))
3032 S_xmldump_attr(aTHX_ level, file, "package=\"%s\"",
3033 CopSTASHPV(cCOPo));
4b65a919 3034 if (CopLABEL(cCOPo))
3b721df9 3035 S_xmldump_attr(aTHX_ level, file, "label=\"%s\"",
4b65a919 3036 CopLABEL(cCOPo));
3b721df9
NC		 3037 break;
3038 case OP_ENTERLOOP:
3039 S_xmldump_attr(aTHX_ level, file, "redo=\"");
3040 if (cLOOPo->op_redoop)
3041 PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOOPo->op_redoop));
3042 else
3043 PerlIO_printf(file, "DONE\"");
3044 S_xmldump_attr(aTHX_ level, file, "next=\"");
3045 if (cLOOPo->op_nextop)
3046 PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOOPo->op_nextop));
3047 else
3048 PerlIO_printf(file, "DONE\"");
3049 S_xmldump_attr(aTHX_ level, file, "last=\"");
3050 if (cLOOPo->op_lastop)
3051 PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOOPo->op_lastop));
3052 else
3053 PerlIO_printf(file, "DONE\"");
3054 break;
3055 case OP_COND_EXPR:
3056 case OP_RANGE:
3057 case OP_MAPWHILE:
3058 case OP_GREPWHILE:
3059 case OP_OR:
3060 case OP_AND:
3061 S_xmldump_attr(aTHX_ level, file, "other=\"");
3062 if (cLOGOPo->op_other)
3063 PerlIO_printf(file, "%"UVuf"\"", sequence_num(cLOGOPo->op_other));
3064 else
3065 PerlIO_printf(file, "DONE\"");
3066 break;
3067 case OP_LEAVE:
3068 case OP_LEAVEEVAL:
3069 case OP_LEAVESUB:
3070 case OP_LEAVESUBLV:
3071 case OP_LEAVEWRITE:
3072 case OP_SCOPE:
3073 if (o->op_private & OPpREFCOUNTED)
3074 S_xmldump_attr(aTHX_ level, file, "refcnt=\"%"UVuf"\"", (UV)o->op_targ);
3075 break;
3076 default:
3077 break;
3078 }
3079
3080 if (PL_madskills && o->op_madprop) {
fb2b694a 3081 char prevkey = '\0';
d914baab 3082 SV * const tmpsv = newSVpvn_utf8("", 0, TRUE);
20f84293 3083 const MADPROP* mp = o->op_madprop;
61f9802b 3084
3b721df9
NC		 3085 if (!contents) {
3086 contents = 1;
3087 PerlIO_printf(file, ">\n");
3088 }
3089 Perl_xmldump_indent(aTHX_ level, file, "<madprops>\n");
3090 level++;
3091 while (mp) {
3092 char tmp = mp->mad_key;
76f68e9b 3093 sv_setpvs(tmpsv,"\"");
3b721df9
NC		 3094 if (tmp)
3095 sv_catxmlpvn(tmpsv, &tmp, 1, 0);
fb2b694a
GG		 3096 if ((tmp == '_') || (tmp == '#')) /* '_' '#' whitespace belong to the previous token. */
3097 sv_catxmlpvn(tmpsv, &prevkey, 1, 0);
3098 else
3099 prevkey = tmp;
3b721df9
NC		 3100 sv_catpv(tmpsv, "\"");
3101 switch (mp->mad_type) {
3102 case MAD_NULL:
3103 sv_catpv(tmpsv, "NULL");
3104 Perl_xmldump_indent(aTHX_ level, file, "<mad_null key=%s/>\n", SvPVX(tmpsv));
3105 break;
3106 case MAD_PV:
3107 sv_catpv(tmpsv, " val=\"");
3108 sv_catxmlpvn(tmpsv, (char*)mp->mad_val, mp->mad_vlen,1);
3109 sv_catpv(tmpsv, "\"");
3110 Perl_xmldump_indent(aTHX_ level, file, "<mad_pv key=%s/>\n", SvPVX(tmpsv));
3111 break;
3112 case MAD_SV:
3113 sv_catpv(tmpsv, " val=\"");
ad64d0ec 3114 sv_catxmlsv(tmpsv, MUTABLE_SV(mp->mad_val));
3b721df9
NC		 3115 sv_catpv(tmpsv, "\"");
3116 Perl_xmldump_indent(aTHX_ level, file, "<mad_sv key=%s/>\n", SvPVX(tmpsv));
3117 break;
3118 case MAD_OP:
3119 if ((OP*)mp->mad_val) {
3120 Perl_xmldump_indent(aTHX_ level, file, "<mad_op key=%s>\n", SvPVX(tmpsv));
3121 do_op_xmldump(level+1, file, (OP*)mp->mad_val);
3122 Perl_xmldump_indent(aTHX_ level, file, "</mad_op>\n");
3123 }
3124 break;
3125 default:
3126 Perl_xmldump_indent(aTHX_ level, file, "<mad_unk key=%s/>\n", SvPVX(tmpsv));
3127 break;
3128 }
3129 mp = mp->mad_next;
3130 }
3131 level--;
3132 Perl_xmldump_indent(aTHX_ level, file, "</madprops>\n");
3133
3134 SvREFCNT_dec(tmpsv);
3135 }
3136
3137 switch (o->op_type) {
3138 case OP_PUSHRE:
3139 case OP_MATCH:
3140 case OP_QR:
3141 case OP_SUBST:
3142 if (!contents) {
3143 contents = 1;
3144 PerlIO_printf(file, ">\n");
3145 }
3146 do_pmop_xmldump(level, file, cPMOPo);
3147 break;
3148 default:
3149 break;
3150 }
3151
3152 if (o->op_flags & OPf_KIDS) {
3153 OP *kid;
3154 if (!contents) {
3155 contents = 1;
3156 PerlIO_printf(file, ">\n");
3157 }
3158 for (kid = cUNOPo->op_first; kid; kid = kid->op_sibling)
3159 do_op_xmldump(level, file, kid);
3160 }
3161
3162 if (contents)
3163 Perl_xmldump_indent(aTHX_ level-1, file, "</op_%s>\n", OP_NAME(o));
3164 else
3165 PerlIO_printf(file, " />\n");
3166}
3167
3168void
3169Perl_op_xmldump(pTHX_ const OP *o)
3170{
7918f24d
NC		 3171 PERL_ARGS_ASSERT_OP_XMLDUMP;
3172
3b721df9
NC		 3173 do_op_xmldump(0, PL_xmlfp, o);
3174}
3175#endif
3176
66610fdd
RGS		 3177/*
3178 * Local variables:
3179 * c-indentation-style: bsd
3180 * c-basic-offset: 4
3181 * indent-tabs-mode: t
3182 * End:
3183 *
37442d52
RGS		 3184 * ex: set ts=8 sts=4 sw=4 noet:
3185 */
Unnamed repository; edit this file 'description' to name the repository.