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