Peek.pm

   1 package Data::Peek;
   2
   3 use strict;
   4 use warnings;
   5
   6 use DynaLoader ();
   7
   8 use vars qw( $VERSION @ISA @EXPORT @EXPORT_OK );
   9 $VERSION   = "0.42";
  10 @ISA       = qw( DynaLoader Exporter );
  11 @EXPORT    = qw( DDumper DTidy DDsort DPeek DDisplay DDump DHexDump
  12                  DDual DGrow );
  13 @EXPORT_OK = qw( triplevar :tidy );
  14 push @EXPORT, "DDump_IO";
  15
  16 bootstrap Data::Peek $VERSION;
  17
  18 our $has_perlio;
  19 our $has_perltidy;
  20
  21 BEGIN {
  22     use Config;
  23     $has_perlio   = ($Config{useperlio} || "undef") eq "define";
  24     $has_perltidy = eval q{use Perl::Tidy; $Perl::Tidy::VERSION};
  25     }
  26
  27 ### ############# DDumper () ##################################################
  28
  29 use Data::Dumper;
  30
  31 my %sk = (
  32     undef       => 0,
  33     ""          => 0,
  34     0           => 0,
  35     1           => 1,
  36
  37     V   => sub {        # Sort by value
  38             my $r = shift;
  39             [         sort { $r->{$a} cmp $r->{$b} } keys %$r ];
  40             },
  41     VN  => sub {        # Sort by value numeric
  42             my $r = shift;
  43             [         sort { $r->{$a} <=> $r->{$b} } keys %$r ];
  44             },
  45     VNR => sub {        # Sort by value numeric reverse
  46             my $r = shift;
  47             [         sort { $r->{$b} <=> $r->{$a} } keys %$r ];
  48             },
  49     VR  => sub {        # Sort by value reverse
  50             my $r = shift;
  51             [         sort { $r->{$b} cmp $r->{$a} } keys %$r ];
  52             },
  53     R   => sub {        # Sort reverse
  54             my $r = shift;
  55             [ reverse sort                           keys %$r ];
  56             },
  57     );
  58 my  $_sortkeys = 1;
  59 our $_perltidy = 0;
  60
  61 sub DDsort
  62 {
  63     @_ or return;
  64
  65     $_sortkeys = exists $sk{$_[0]} ? $sk{$_[0]} : $_[0];
  66     } # DDsort
  67
  68 sub import
  69 {
  70     my @exp = @_;
  71     my @etl;
  72     foreach my $p (@exp) {
  73         exists $sk{$p} and DDsort ($p), next;
  74
  75         if ($p eq ":tidy") {
  76             $_perltidy = $has_perltidy;
  77             next;
  78             }
  79
  80         push @etl, $p;
  81         }
  82     __PACKAGE__->export_to_level (1, @etl);
  83     } # import
  84
  85 sub DDumper
  86 {
  87     $_perltidy and goto \&DTidy;
  88
  89     local $Data::Dumper::Sortkeys  = $_sortkeys;
  90     local $Data::Dumper::Indent    = 1;
  91     local $Data::Dumper::Quotekeys = 0;
  92     local $Data::Dumper::Deparse   = 1;
  93     local $Data::Dumper::Terse     = 1;
  94     local $Data::Dumper::Useqq     = 0; # I want unicode visible
  95
  96     my $s = Data::Dumper::Dumper @_;
  97     $s =~ s/^(\s*)(.*?)\s*=>/sprintf "%s%-16s =>", $1, $2/gme;  # Align =>
  98     $s =~ s/\bbless\s*\(\s*/bless (/gm and $s =~ s/\s+\)([;,])$/)$1/gm;
  99     $s =~ s/^(?=\s*[]}](?:[;,]|$))/  /gm;
 100     $s =~ s/^(\s*[{[]) *\n *(?=\S)(?![{[])/$1   /gm;
 101     $s =~ s/^(\s+)/$1$1/gm;
 102
 103     defined wantarray or warn $s;
 104     return $s;
 105     } # DDumper
 106
 107 sub DTidy
 108 {
 109     $has_perltidy or goto \&DDumper;
 110
 111     local $Data::Dumper::Sortkeys  = $_sortkeys;
 112     local $Data::Dumper::Indent    = 1;
 113     local $Data::Dumper::Quotekeys = 1;
 114     local $Data::Dumper::Deparse   = 1;
 115     local $Data::Dumper::Terse     = 1;
 116     local $Data::Dumper::Useqq     = 0;
 117
 118     my $s = Data::Dumper::Dumper @_;
 119     my $t;
 120     Perl::Tidy::perltidy (source => \$s, destination => \$t, argv => [
 121         # Disable stupid options in ~/.perltidyrc
 122         # people do so, even for root
 123         "--no-backup-and-modify-in-place",
 124         "--no-check-syntax",
 125         "--no-standard-output",
 126         "--no-warning-output",
 127         # RT#99514 - Perl::Tidy memoizes .perltidyrc incorrectly
 128         "--no-memoize",
 129         ]);
 130     $s = $t;
 131
 132     defined wantarray or warn $s;
 133     return $s;
 134     } # DTidy
 135
 136 ### ############# DDump () ####################################################
 137
 138 sub _DDump_ref
 139 {
 140     my (undef, $down) = (@_, 0);
 141
 142     my $ref = ref $_[0];
 143     if ($ref eq "SCALAR" || $ref eq "REF") {
 144         my %hash = DDump (${$_[0]}, $down);
 145         return { %hash };
 146         }
 147     if ($ref eq "ARRAY") {
 148         my @list;
 149         foreach my $list (@{$_[0]}) {
 150             my %hash = DDump ($list, $down);
 151             push @list, { %hash };
 152             }
 153         return [ @list ];
 154         }
 155     if ($ref eq "HASH") {
 156         my %hash;
 157         foreach my $key (sort keys %{$_[0]}) {
 158             $hash{DPeek ($key)} = { DDump ($_[0]->{$key}, $down) };
 159             }
 160         return { %hash };
 161         }
 162     undef;
 163     } # _DDump_ref
 164
 165 sub _DDump
 166 {
 167     my (undef, $down, $dump, $fh) = (@_, "");
 168
 169     if ($has_perlio and open $fh, ">", \$dump) {
 170         #print STDERR "Using DDump_IO\n";
 171         DDump_IO ($fh, $_[0], $down);
 172         close $fh;
 173         }
 174     else {
 175         #print STDERR "Using DDump_XS\n";
 176         $dump = DDump_XS ($_[0]);
 177         }
 178
 179     return $dump;
 180     } # _DDump
 181
 182 sub DDump ($;$)
 183 {
 184     my (undef, $down) = (@_, 0);
 185     my @dump = split m/[\r\n]+/, _DDump ($_[0], wantarray || $down) or return;
 186
 187     if (wantarray) {
 188         my %hash;
 189         ($hash{sv} = $dump[0]) =~ s/^SV\s*=\s*//;
 190         m/^\s+(\w+)\s*=\s*(.*)/ and $hash{$1} = $2 for @dump;
 191
 192         if (exists $hash{FLAGS}) {
 193             $hash{FLAGS} =~ tr/()//d;
 194             $hash{FLAGS} = { map { $_ => 1 } split m/,/ => $hash{FLAGS} };
 195             }
 196
 197         $down && ref $_[0] and
 198             $hash{RV} = _DDump_ref ($_[0], $down - 1) || $_[0];
 199         return %hash;
 200         }
 201
 202     my $dump = join "\n", @dump, "";
 203
 204     defined wantarray and return $dump;
 205
 206     warn $dump;
 207     } # DDump
 208
 209 sub DHexDump
 210 {
 211     use bytes;
 212     my $off = 0;
 213     my @out;
 214     my $var = @_ ? $_[0] : $_;
 215     defined $var or return;
 216     my $fmt = @_ > 1 && $_[1] < length ($var) ? "A$_[1]" : "A*";
 217     my $str = pack $fmt, $var;  # force stringification
 218     for (unpack "(A32)*", unpack "H*", $str) {
 219         my @b = unpack "(A2)*", $_;
 220         my $out = sprintf "%04x ", $off;
 221         $out .= " ".($b[$_]||"  ") for 0 ..  7;
 222         $out .= " ";
 223         $out .= " ".($b[$_]||"  ") for 8 .. 15;
 224         $out .= "  ";
 225         $out .= ($_ < 0x20 || $_ >= 0x7f ? "." : chr $_) for map { hex $_ } @b;
 226         push @out, $out."\n";
 227         $off += 16;
 228         }
 229
 230     wantarray and return @out;
 231
 232     defined wantarray and return join "", @out;
 233
 234     warn join "", @out;
 235     } # DHexDump
 236
 237 "Indent";
 238
 239 __END__
 240
 241 =head1 NAME
 242
 243 Data::Peek - A collection of low-level debug facilities
 244
 245 =head1 SYNOPSIS
 246
 247  use Data::Peek;
 248
 249  print DDumper \%hash;    # Same syntax as Data::Dumper
 250  DTidy { ref => $ref };
 251
 252  print DPeek \$var;
 253  my ($pv, $iv, $nv, $rv, $magic) = DDual ($var [, 1]);
 254  print DPeek for DDual ($!, 1);
 255  print DDisplay ("ab\nc\x{20ac}\rdef\n");
 256  print DHexDump ("ab\nc\x{20ac}\rdef\n");
 257
 258  my $dump = DDump $var;
 259  my %hash = DDump \@list;
 260  DDump \%hash;
 261
 262  my %hash = DDump (\%hash, 5);  # dig 5 levels deep
 263
 264  my $dump;
 265  open my $fh, ">", \$dump;
 266  DDump_IO ($fh, \%hash, 6);
 267  close $fh;
 268  print $dump;
 269
 270  # Imports
 271  use Data::Peek qw( :tidy VNR DGrow triplevar );
 272  my $x = ""; DGrow ($x, 10000);
 273  my $tv = triplevar ("\N{GREEK SMALL LETTER PI}", 3, "3.1415");
 274  DDsort ("R");
 275  DDumper [ $x ]; # use of :tidy make DDumper behave as DTidy
 276
 277 =head1 DESCRIPTION
 278
 279 Data::Peek started off as C<DDumper> being a wrapper module over
 280 L<Data::Dumper>, but grew out to be a set of low-level data
 281 introspection utilities that no other module provided yet, using the
 282 lowest level of the perl internals API as possible.
 283
 284 =head2 DDumper ($var, ...)
 285
 286 Not liking the default output of Data::Dumper, and always feeling the need
 287 to set C<$Data::Dumper::Sortkeys = 1;>, and not liking any of the default
 288 layouts, this function is just a wrapper around Data::Dumper::Dumper with
 289 everything set as I like it.
 290
 291     $Data::Dumper::Sortkeys = 1;
 292     $Data::Dumper::Indent   = 1;
 293
 294 If C<Data::Peek> is C<use>d with import argument C<:tidy>, the result is
 295 formatted according to L<Perl::Tidy>, see L<DTidy> below, otherwise the
 296 result is further beautified to meet my needs:
 297
 298   * quotation of hash keys has been removed (with the disadvantage
 299     that the output might not be parseable again).
 300   * arrows for hashes are aligned at 16 (longer keys don't align)
 301   * closing braces and brackets are now correctly aligned
 302
 303 In void context, C<DDumper ()> warn ()'s.
 304
 305 Example
 306
 307   $ perl -MDP \
 308     -e'DDumper { ape => 1, foo => "egg", bar => [ 2, "baz", undef ]};'
 309
 310   {   ape              => 1,
 311       bar              => [
 312           2,
 313           'baz',
 314           undef
 315           ],
 316       foo              => 'egg'
 317       };
 318
 319 =head2 DTidy ($var, ...)
 320
 321 C<DTidy> is an alternative to C<DDumper>, where the output of C<DDumper>
 322 is formatted using C<Perl::Tidy> (if available) according to your
 323 C<.perltidyrc> instead of the default behavior, maybe somewhat like (YMMV):
 324
 325   $ perl -MDP=:tidy \
 326     -we'DDumper { ape => 1, foo => "egg", bar => [ 2, "baz", undef ]};'
 327   {   'ape' => 1,
 328       'bar' => [2, 'baz', undef],
 329       'foo' => 'egg'
 330       }
 331
 332 If C<Data::Peek> is C<use>d with import argument C<:tidy>, this is the
 333 default output method for C<DDumper>.
 334
 335 If L<Perl::Tidy> is not available, C<DTidy> will fallback to C<DDumper>.
 336
 337 This idea was shamelessly copied from John McNamara's L<Data::Dumper::Perltidy>.
 338
 339 =head2 DDsort ( 0 | 1 | R | V | VR | VN | VNR )
 340
 341 Set the hash sort algorithm for DDumper. The default is to sort by key value.
 342
 343   0   - Do not sort
 344   1   - Sort by key
 345   R   - Reverse sort by key
 346   V   - Sort by value
 347   VR  - Reverse sort by value
 348   VN  - Sort by value numerical
 349   VNR - Reverse sort by value numerical
 350
 351 These can also be passed to import:
 352
 353   $ perl -MDP=VNR \
 354     -we'DDumper { foo => 1, bar => 2, zap => 3, gum => 13 }'
 355   {   gum              => 13,
 356       zap              => 3,
 357       bar              => 2,
 358       foo              => 1
 359       };
 360   $ perl -MDP=V \
 361     -we'DDumper { foo => 1, bar => 2, zap => 3, gum => 13 }'
 362   {   foo              => 1,
 363       gum              => 13,
 364       bar              => 2,
 365       zap              => 3
 366       };
 367
 368 =head2 DPeek
 369
 370 =head2 DPeek ($var)
 371
 372 Playing with C<sv_dump ()>, I found C<Perl_sv_peek ()>, and it might be
 373 very useful for simple checks. If C<$var> is omitted, uses $_.
 374
 375 Example
 376
 377   print DPeek "abc\x{0a}de\x{20ac}fg";
 378
 379   PV("abc\nde\342\202\254fg"\0) [UTF8 "abc\nde\x{20ac}fg"]
 380
 381 In void context, C<DPeek ()> prints to C<STDERR> plus a newline.
 382
 383 =head2 DDisplay
 384
 385 =head2 DDisplay ($var)
 386
 387 Show the PV content of a scalar the way perl debugging would have done.
 388 UTF-8 detection is on, so this is effectively the same as returning the
 389 first part the C<DPeek ()> returns for non-UTF8 PV's or the second part
 390 for UTF-8 PV's. C<DDisplay ()> returns the empty string for scalars that
 391 no have a valid PV.
 392
 393 Example
 394
 395   print DDisplay "abc\x{0a}de\x{20ac}fg";
 396
 397   "abc\nde\x{20ac}fg"
 398
 399 =head2 DHexDump
 400
 401 =head2 DHexDump ($var)
 402
 403 =head2 DHexDump ($var, $length)
 404
 405 Show the (stringified) content of a scalar as a hex-dump.  If C<$var>
 406 is omitted, C<$_> is dumped. Returns C<undef> or an empty list if
 407 C<$var> (or C<$_>) is undefined. If C<$length> is given and is lower than
 408 the length of the stringified C<$var>, only <$length> bytes are dumped.
 409
 410 In void context, the dump is done to STDERR. In scalar context, the
 411 complete dump is returned as a single string. In list context, the dump
 412 is returned as lines.
 413
 414 Example
 415
 416   print DHexDump "abc\x{0a}de\x{20ac}fg";
 417
 418   0000  61 62 63 0a 64 65 e2 82  ac 66 67                 abc.de...fg
 419
 420 =head2 my ($pv, $iv, $nv, $rv, $hm) = DDual ($var [, $getmagic])
 421
 422 DDual will return the basic elements in a variable, guaranteeing that no
 423 conversion takes place. This is very useful for dual-var variables, or
 424 when checking is a variable has defined entries for a certain type of
 425 scalar. For each String (PV), Integer (IV), Double (NV), and Reference (RV),
 426 the current value of C<$var> is returned or undef if it is not set (yet).
 427 The 5th element is an indicator if C<$var> has magic, which is B<not> invoked
 428 in the returned values, unless explicitly asked for with a true optional
 429 second argument.
 430
 431 Example
 432
 433   print DPeek for DDual ($!, 1);
 434
 435 In void context, DDual does the equivalent of
 436
 437   { my @d = DDual ($!, 1);
 438     print STDERR
 439       DPeek ($!), "\n",
 440       "  PV: ", DPeek ($d[0]), "\n",
 441       "  IV: ", DPeek ($d[1]), "\n",
 442       "  NV: ", DPeek ($d[2]), "\n",
 443       "  RV: ", DPeek ($d[3]), "\n";
 444     }
 445
 446 =head2 my $len = DGrow ($pv, $size)
 447
 448 Fastest way to preallocate space for a PV scalar. Returns the allocated
 449 length. If $size is smaller than the already allocated space, it will
 450 not shrink.
 451
 452  cmpthese (-2, {
 453      pack => q{my $x = ""; $x = pack "x20000"; $x = "";},
 454      op_x => q{my $x = ""; $x = "x"  x 20000;  $x = "";},
 455      grow => q{my $x = ""; DGrow ($x,  20000); $x = "";},
 456      });
 457
 458            Rate  op_x  pack  grow      5.8.9    5.10.1    5.12.4    5.14.2
 459  op_x   62127/s    --  -59%  -96%   118606/s  119730/s  352255/s  362605/s
 460  pack  152046/s  145%    --  -91%   380075/s  355666/s  347247/s  387349/s
 461  grow 1622943/s 2512%  967%    --  2818380/s 2918783/s 2672340/s 2886787/s
 462
 463 =head2 my $tp = triplevar ($pv, $iv, $nv)
 464
 465 When making C<DDual ()> I wondered if it were possible to create triple-val
 466 scalar variables. L<Scalar::Util> already gives us C<dualvar ()>, that creates
 467 you a scalar with different numeric and string values that return different
 468 values in different context. Not that C<triplevar ()> would be very useful,
 469 compared to C<dualvar ()>, but at least this shows that it is possible.
 470
 471 C<triplevar ()> is not exported by default.
 472
 473 Example:
 474
 475   print DPeek for DDual
 476       Data::Peek::triplevar ("\N{GREEK SMALL LETTER PI}", 3, 3.1415);
 477
 478   PV("\317\200"\0) [UTF8 "\x{3c0}"]
 479   IV(3)
 480   NV(3.1415)
 481   SV_UNDEF
 482   IV(0)
 483
 484 =head2 DDump ($var [, $dig_level])
 485
 486 A very useful module when debugging is C<Devel::Peek>, but is has one big
 487 disadvantage: it only prints to STDERR, which is not very handy when your
 488 code wants to inspect variables at a low level.
 489
 490 Perl itself has C<sv_dump ()>, which does something similar, but still
 491 prints to STDERR, and only one level deep.
 492
 493 C<DDump ()> is an attempt to make the innards available to the script level
 494 with a reasonable level of compatibility. C<DDump ()> is context sensitive.
 495
 496 In void context, it behaves exactly like C<Perl_sv_dump ()>.
 497
 498 In scalar context, it returns what C<Perl_sv_dump ()> would have printed.
 499
 500 In list context, it returns a hash of the variable's properties. In this mode
 501 you can pass an optional second argument that determines the depth of digging.
 502
 503 Example
 504
 505   print scalar DDump "abc\x{0a}de\x{20ac}fg"
 506
 507   SV = PV(0x723250) at 0x8432b0
 508     REFCNT = 1
 509     FLAGS = (PADBUSY,PADMY,POK,pPOK,UTF8)
 510     PV = 0x731ac0 "abc\nde\342\202\254fg"\0 [UTF8 "abc\nde\x{20ac}fg"]
 511     CUR = 11
 512     LEN = 16
 513
 514   my %h = DDump "abc\x{0a}de\x{20ac}fg";
 515   print DDumper \%h;
 516
 517   {   CUR              => '11',
 518       FLAGS            => {
 519           PADBUSY          => 1,
 520           PADMY            => 1,
 521           POK              => 1,
 522           UTF8             => 1,
 523           pPOK             => 1
 524           },
 525       LEN              => '16',
 526       PV               => '0x731ac0 "abc\\nde\\342\\202\\254fg"\\0 [UTF8 "abc\\nde\\x{20ac}fg"]',
 527       REFCNT           => '1',
 528       sv               => 'PV(0x723250) at 0x8432c0'
 529       };
 530
 531   my %h = DDump {
 532       ape => 1,
 533       foo => "egg",
 534       bar => [ 2, "baz", undef ],
 535       }, 1;
 536   print DDumper \%h;
 537
 538   {   FLAGS            => {
 539           PADBUSY          => 1,
 540           PADMY            => 1,
 541           ROK              => 1
 542           },
 543       REFCNT           => '1',
 544       RV               => {
 545           PVIV("ape")      => {
 546               FLAGS            => {
 547                   IOK              => 1,
 548                   PADBUSY          => 1,
 549                   PADMY            => 1,
 550                   pIOK             => 1
 551                   },
 552               IV               => '1',
 553               REFCNT           => '1',
 554               sv               => 'IV(0x747020) at 0x843a10'
 555               },
 556           PVIV("bar")      => {
 557               CUR              => '0',
 558               FLAGS            => {
 559                   PADBUSY          => 1,
 560                   PADMY            => 1,
 561                   ROK              => 1
 562                   },
 563               IV               => '1',
 564               LEN              => '0',
 565               PV               => '0x720210 ""',
 566               REFCNT           => '1',
 567               RV               => '0x720210',
 568               sv               => 'PVIV(0x7223e0) at 0x843a10'
 569               },
 570           PVIV("foo")      => {
 571               CUR              => '3',
 572               FLAGS            => {
 573                   PADBUSY          => 1,
 574                   PADMY            => 1,
 575                   POK              => 1,
 576                   pPOK             => 1
 577                   },
 578               IV               => '1',
 579               LEN              => '8',
 580               PV               => '0x7496c0 "egg"\\0',
 581               REFCNT           => '1',
 582               sv               => 'PVIV(0x7223e0) at 0x843a10'
 583               }
 584           },
 585       sv               => 'RV(0x79d058) at 0x843310'
 586       };
 587
 588 =head2 DDump_IO ($io, $var [, $dig_level])
 589
 590 A wrapper function around perl's internal C<Perl_do_sv_dump ()>, which
 591 makes C<Devel::Peek> completely superfluous.
 592
 593 Example
 594
 595   my $dump;
 596   open my $eh, ">", \$dump;
 597   DDump_IO ($eh, { 3 => 4, ape => [5..8]}, 6);
 598   close $eh;
 599   print $dump;
 600
 601   SV = RV(0x79d9e0) at 0x843f00
 602     REFCNT = 1
 603     FLAGS = (TEMP,ROK)
 604     RV = 0x741090
 605       SV = PVHV(0x79c948) at 0x741090
 606         REFCNT = 1
 607         FLAGS = (SHAREKEYS)
 608         IV = 2
 609         NV = 0
 610         ARRAY = 0x748ff0  (0:7, 2:1)
 611         hash quality = 62.5%
 612         KEYS = 2
 613         FILL = 1
 614         MAX = 7
 615         RITER = -1
 616         EITER = 0x0
 617           Elt "ape" HASH = 0x97623e03
 618           SV = RV(0x79d9d8) at 0x8440e0
 619             REFCNT = 1
 620             FLAGS = (ROK)
 621             RV = 0x741470
 622               SV = PVAV(0x7264b0) at 0x741470
 623                 REFCNT = 2
 624                 FLAGS = ()
 625                 IV = 0
 626                 NV = 0
 627                 ARRAY = 0x822f70
 628                 FILL = 3
 629                 MAX = 3
 630                 ARYLEN = 0x0
 631                 FLAGS = (REAL)
 632                   Elt No. 0
 633                   SV = IV(0x7467c8) at 0x7c1aa0
 634                     REFCNT = 1
 635                     FLAGS = (IOK,pIOK)
 636                     IV = 5
 637                   Elt No. 1
 638                   SV = IV(0x7467b0) at 0x8440f0
 639                     REFCNT = 1
 640                     FLAGS = (IOK,pIOK)
 641                     IV = 6
 642                   Elt No. 2
 643                   SV = IV(0x746810) at 0x75be00
 644                     REFCNT = 1
 645                     FLAGS = (IOK,pIOK)
 646                     IV = 7
 647                   Elt No. 3
 648                   SV = IV(0x746d38) at 0x7799d0
 649                     REFCNT = 1
 650                     FLAGS = (IOK,pIOK)
 651                     IV = 8
 652           Elt "3" HASH = 0xa400c7f3
 653           SV = IV(0x746fd0) at 0x7200e0
 654             REFCNT = 1
 655             FLAGS = (IOK,pIOK)
 656             IV = 4
 657
 658 =head1 INTERNALS
 659
 660 C<DDump ()> uses an XS wrapper around C<Perl_sv_dump ()> where the
 661 STDERR is temporarily caught to a pipe. The internal XS helper functions
 662 are not meant for user space
 663
 664 =head2 DDump_XS (SV *sv)
 665
 666 Base interface to internals for C<DDump ()>.
 667
 668 =head1 BUGS
 669
 670 Windows and AIX might be using a build where not all symbols that were
 671 supposed to be exported in the public API are not. Perl_pv_peek () is
 672 one of them.
 673
 674 Not all types of references are supported.
 675
 676 No idea how far back this goes in perl support, but Devel::PPPort has
 677 proven to be a big help.
 678
 679 =head1 SEE ALSO
 680
 681 L<Devel::Peek>, L<Data::Dumper>, L<Data::Dump>, L<Devel::Dumpvar>,
 682 L<Data::Dump::Streamer>, L<Data::Dumper::Perltidy>, L<Perl::Tidy>.
 683
 684 =head1 AUTHOR
 685
 686 H.Merijn Brand <h.m.brand@xs4all.nl>
 687
 688 =head1 COPYRIGHT AND LICENSE
 689
 690 Copyright (C) 2008-2015 H.Merijn Brand
 691
 692 This library is free software; you can redistribute it and/or modify
 693 it under the same terms as Perl itself.
 694
 695 =cut