← Index
NYTProf Performance Profile   « line view »
For flows_to_es.pl
  Run on Mon May 9 23:27:59 2016
Reported on Mon May 9 23:28:08 2016

Filename/usr/lib/perl/5.18/Data/Dumper.pm
StatementsExecuted 39 statements in 6.00ms
Subroutines
Calls P F Exclusive
Time		 Inclusive
Time		 Subroutine
1111.13ms1.42msData::Dumper::::BEGIN@273Data::Dumper::BEGIN@273
111236µs239µsData::Dumper::::BEGIN@734Data::Dumper::BEGIN@734
11119µs154µsData::Dumper::::BEGIN@24Data::Dumper::BEGIN@24
11111µs11µsData::Dumper::::BEGIN@18Data::Dumper::BEGIN@18
11110µs10µsData::Dumper::::BEGIN@12Data::Dumper::BEGIN@12
1118µs47µsData::Dumper::::BEGIN@22Data::Dumper::BEGIN@22
1112µs2µsData::Dumper::::_vstringData::Dumper::_vstring (xsub)
0000s0sData::Dumper::::BlessData::Dumper::Bless
0000s0sData::Dumper::::DESTROYData::Dumper::DESTROY
0000s0sData::Dumper::::DeepcopyData::Dumper::Deepcopy
0000s0sData::Dumper::::DeparseData::Dumper::Deparse
0000s0sData::Dumper::::DumpData::Dumper::Dump
0000s0sData::Dumper::::DumperData::Dumper::Dumper
0000s0sData::Dumper::::DumperXData::Dumper::DumperX
0000s0sData::Dumper::::DumpperlData::Dumper::Dumpperl
0000s0sData::Dumper::::FreezerData::Dumper::Freezer
0000s0sData::Dumper::::IndentData::Dumper::Indent
0000s0sData::Dumper::::MaxdepthData::Dumper::Maxdepth
0000s0sData::Dumper::::MaxrecurseData::Dumper::Maxrecurse
0000s0sData::Dumper::::NamesData::Dumper::Names
0000s0sData::Dumper::::PadData::Dumper::Pad
0000s0sData::Dumper::::PairData::Dumper::Pair
0000s0sData::Dumper::::PurityData::Dumper::Purity
0000s0sData::Dumper::::QuotekeysData::Dumper::Quotekeys
0000s0sData::Dumper::::ResetData::Dumper::Reset
0000s0sData::Dumper::::SeenData::Dumper::Seen
0000s0sData::Dumper::::SortkeysData::Dumper::Sortkeys
0000s0sData::Dumper::::SparseseenData::Dumper::Sparseseen
0000s0sData::Dumper::::TerseData::Dumper::Terse
0000s0sData::Dumper::::ToasterData::Dumper::Toaster
0000s0sData::Dumper::::UseperlData::Dumper::Useperl
0000s0sData::Dumper::::UseqqData::Dumper::Useqq
0000s0sData::Dumper::::ValuesData::Dumper::Values
0000s0sData::Dumper::::VarnameData::Dumper::Varname
0000s0sData::Dumper::::_compose_outData::Dumper::_compose_out
0000s0sData::Dumper::::_dumpData::Dumper::_dump
0000s0sData::Dumper::::_quoteData::Dumper::_quote
0000s0sData::Dumper::::_refine_nameData::Dumper::_refine_name
0000s0sData::Dumper::::_sortkeysData::Dumper::_sortkeys
0000s0sData::Dumper::::format_refaddrData::Dumper::format_refaddr
0000s0sData::Dumper::::init_refaddr_formatData::Dumper::init_refaddr_format
0000s0sData::Dumper::::newData::Dumper::new
0000s0sData::Dumper::::qquoteData::Dumper::qquote
Call graph for these subroutines as a Graphviz dot language file.
Line State
ments		 Time
on line		 Calls Time
in subs		 Code
1#
2# Data/Dumper.pm
3#
4# convert perl data structures into perl syntax suitable for both printing
5# and eval
6#
7# Documentation at the __END__
8#
9
10package Data::Dumper;
11
12
# spent 10µs within Data::Dumper::BEGIN@12 which was called: # once (10µs+0s) by main::BEGIN@9 at line 14
BEGIN {
1316µs $VERSION = '2.145'; # Don't forget to set version and release
14124µs110µs} # date in POD below!
# spent 10µs making 1 call to Data::Dumper::BEGIN@12
15
16#$| = 1;
17
18255µs111µs
# spent 11µs within Data::Dumper::BEGIN@18 which was called: # once (11µs+0s) by main::BEGIN@9 at line 18
use 5.006_001;
# spent 11µs making 1 call to Data::Dumper::BEGIN@18
191800nsrequire Exporter;
201553µsrequire overload;
21
22285µs286µs
# spent 47µs (8+39) within Data::Dumper::BEGIN@22 which was called: # once (8µs+39µs) by main::BEGIN@9 at line 22
use Carp;
# spent 47µs making 1 call to Data::Dumper::BEGIN@22 # spent 39µs making 1 call to Exporter::import
23
24
# spent 154µs (19+134) within Data::Dumper::BEGIN@24 which was called: # once (19µs+134µs) by main::BEGIN@9 at line 38
BEGIN {
2516µs @ISA = qw(Exporter);
261500ns @EXPORT = qw(Dumper);
271500ns @EXPORT_OK = qw(DumperX);
28
29 # if run under miniperl, or otherwise lacking dynamic loading,
30 # XSLoader should be attempted to load, or the pure perl flag
31 # toggled on load failure.
3214µs eval {
331400ns require XSLoader;
341142µs1134µs XSLoader::load( 'Data::Dumper' );
# spent 134µs making 1 call to XSLoader::load
351700ns 1
36 }
37 or $Useperl = 1;
3811.13ms1154µs}
# spent 154µs making 1 call to Data::Dumper::BEGIN@24
39
40# module vars and their defaults
411400ns$Indent = 2 unless defined $Indent;
421300ns$Purity = 0 unless defined $Purity;
431400ns$Pad = "" unless defined $Pad;
441300ns$Varname = "VAR" unless defined $Varname;
451200ns$Useqq = 0 unless defined $Useqq;
461100ns$Terse = 0 unless defined $Terse;
471300ns$Freezer = "" unless defined $Freezer;
481200ns$Toaster = "" unless defined $Toaster;
491200ns$Deepcopy = 0 unless defined $Deepcopy;
501200ns$Quotekeys = 1 unless defined $Quotekeys;
511300ns$Bless = "bless" unless defined $Bless;
52#$Expdepth = 0 unless defined $Expdepth;
531100ns$Maxdepth = 0 unless defined $Maxdepth;
541300ns$Pair = ' => ' unless defined $Pair;
551200ns$Useperl = 0 unless defined $Useperl;
561100ns$Sortkeys = 0 unless defined $Sortkeys;
571100ns$Deparse = 0 unless defined $Deparse;
581200ns$Sparseseen = 0 unless defined $Sparseseen;
591200ns$Maxrecurse = 1000 unless defined $Maxrecurse;
60
61#
62# expects an arrayref of values to be dumped.
63# can optionally pass an arrayref of names for the values.
64# names must have leading $ sign stripped. begin the name with *
65# to cause output of arrays and hashes rather than refs.
66#
67sub new {
68 my($c, $v, $n) = @_;
69
70 croak "Usage: PACKAGE->new(ARRAYREF, [ARRAYREF])"
71 unless (defined($v) && (ref($v) eq 'ARRAY'));
72 $n = [] unless (defined($n) && (ref($n) eq 'ARRAY'));
73
74 my($s) = {
75 level => 0, # current recursive depth
76 indent => $Indent, # various styles of indenting
77 pad => $Pad, # all lines prefixed by this string
78 xpad => "", # padding-per-level
79 apad => "", # added padding for hash keys n such
80 sep => "", # list separator
81 pair => $Pair, # hash key/value separator: defaults to ' => '
82 seen => {}, # local (nested) refs (id => [name, val])
83 todump => $v, # values to dump []
84 names => $n, # optional names for values []
85 varname => $Varname, # prefix to use for tagging nameless ones
86 purity => $Purity, # degree to which output is evalable
87 useqq => $Useqq, # use "" for strings (backslashitis ensues)
88 terse => $Terse, # avoid name output (where feasible)
89 freezer => $Freezer, # name of Freezer method for objects
90 toaster => $Toaster, # name of method to revive objects
91 deepcopy => $Deepcopy, # dont cross-ref, except to stop recursion
92 quotekeys => $Quotekeys, # quote hash keys
93 'bless' => $Bless, # keyword to use for "bless"
94# expdepth => $Expdepth, # cutoff depth for explicit dumping
95 maxdepth => $Maxdepth, # depth beyond which we give up
96 maxrecurse => $Maxrecurse, # depth beyond which we abort
97 useperl => $Useperl, # use the pure Perl implementation
98 sortkeys => $Sortkeys, # flag or filter for sorting hash keys
99 deparse => $Deparse, # use B::Deparse for coderefs
100 noseen => $Sparseseen, # do not populate the seen hash unless necessary
101 };
102
103 if ($Indent > 0) {
104 $s->{xpad} = " ";
105 $s->{sep} = "\n";
106 }
107 return bless($s, $c);
108}
109
110# Packed numeric addresses take less memory. Plus pack is faster than sprintf
111
112# Most users of current versions of Data::Dumper will be 5.008 or later.
113# Anyone on 5.6.1 and 5.6.2 upgrading will be rare (particularly judging by
114# the bug reports from users on those platforms), so for the common case avoid
115# complexity, and avoid even compiling the unneeded code.
116
117sub init_refaddr_format {
118}
119
120sub format_refaddr {
121 require Scalar::Util;
122 pack "J", Scalar::Util::refaddr(shift);
123};
124
1251600nsif ($] < 5.008) {
126 eval <<'EOC' or die;
127 no warnings 'redefine';
128 my $refaddr_format;
129 sub init_refaddr_format {
130 require Config;
131 my $f = $Config::Config{uvxformat};
132 $f =~ tr/"//d;
133 $refaddr_format = "0x%" . $f;
134 }
135
136 sub format_refaddr {
137 require Scalar::Util;
138 sprintf $refaddr_format, Scalar::Util::refaddr(shift);
139 }
140
141 1
142EOC
143}
144
145#
146# add-to or query the table of already seen references
147#
148sub Seen {
149 my($s, $g) = @_;
150 if (defined($g) && (ref($g) eq 'HASH')) {
151 init_refaddr_format();
152 my($k, $v, $id);
153 while (($k, $v) = each %$g) {
154 if (defined $v) {
155 if (ref $v) {
156 $id = format_refaddr($v);
157 if ($k =~ /^[*](.*)$/) {
158 $k = (ref $v eq 'ARRAY') ? ( "\\\@" . $1 ) :
159 (ref $v eq 'HASH') ? ( "\\\%" . $1 ) :
160 (ref $v eq 'CODE') ? ( "\\\&" . $1 ) :
161 ( "\$" . $1 ) ;
162 }
163 elsif ($k !~ /^\$/) {
164 $k = "\$" . $k;
165 }
166 $s->{seen}{$id} = [$k, $v];
167 }
168 else {
169 carp "Only refs supported, ignoring non-ref item \$$k";
170 }
171 }
172 else {
173 carp "Value of ref must be defined; ignoring undefined item \$$k";
174 }
175 }
176 return $s;
177 }
178 else {
179 return map { @$_ } values %{$s->{seen}};
180 }
181}
182
183#
184# set or query the values to be dumped
185#
186sub Values {
187 my($s, $v) = @_;
188 if (defined($v)) {
189 if (ref($v) eq 'ARRAY') {
190 $s->{todump} = [@$v]; # make a copy
191 return $s;
192 }
193 else {
194 croak "Argument to Values, if provided, must be array ref";
195 }
196 }
197 else {
198 return @{$s->{todump}};
199 }
200}
201
202#
203# set or query the names of the values to be dumped
204#
205sub Names {
206 my($s, $n) = @_;
207 if (defined($n)) {
208 if (ref($n) eq 'ARRAY') {
209 $s->{names} = [@$n]; # make a copy
210 return $s;
211 }
212 else {
213 croak "Argument to Names, if provided, must be array ref";
214 }
215 }
216 else {
217 return @{$s->{names}};
218 }
219}
220
221sub DESTROY {}
222
223sub Dump {
224 return &Dumpxs
225 unless $Data::Dumper::Useperl || (ref($_[0]) && $_[0]->{useperl}) ||
226 $Data::Dumper::Useqq || (ref($_[0]) && $_[0]->{useqq}) ||
227 $Data::Dumper::Deparse || (ref($_[0]) && $_[0]->{deparse});
228 return &Dumpperl;
229}
230
231#
232# dump the refs in the current dumper object.
233# expects same args as new() if called via package name.
234#
235sub Dumpperl {
236 my($s) = shift;
237 my(@out, $val, $name);
238 my($i) = 0;
239 local(@post);
240 init_refaddr_format();
241
242 $s = $s->new(@_) unless ref $s;
243
244 for $val (@{$s->{todump}}) {
245 @post = ();
246 $name = $s->{names}[$i++];
247 $name = $s->_refine_name($name, $val, $i);
248
249 my $valstr;
250 {
251 local($s->{apad}) = $s->{apad};
252 $s->{apad} .= ' ' x (length($name) + 3) if $s->{indent} >= 2 and !$s->{terse};
253 $valstr = $s->_dump($val, $name);
254 }
255
256 $valstr = "$name = " . $valstr . ';' if @post or !$s->{terse};
257 my $out = $s->_compose_out($valstr, \@post);
258
259 push @out, $out;
260 }
261 return wantarray ? @out : join('', @out);
262}
263
264# wrap string in single quotes (escaping if needed)
265sub _quote {
266 my $val = shift;
267 $val =~ s/([\\\'])/\\$1/g;
268 return "'" . $val . "'";
269}
270
271# Old Perls (5.14-) have trouble resetting vstring magic when it is no
272# longer valid.
27323.08ms31.46ms
# spent 1.42ms (1.13+282µs) within Data::Dumper::BEGIN@273 which was called: # once (1.13ms+282µs) by main::BEGIN@9 at line 273
use constant _bad_vsmg => defined &_vstring && (_vstring(~v0)||'') eq "v0";
# spent 1.42ms making 1 call to Data::Dumper::BEGIN@273 # spent 38µs making 1 call to constant::import # spent 2µs making 1 call to Data::Dumper::_vstring
274
275#
276# twist, toil and turn;
277# and recurse, of course.
278# sometimes sordidly;
279# and curse if no recourse.
280#
281sub _dump {
282 my($s, $val, $name) = @_;
283 my($out, $type, $id, $sname);
284
285 $type = ref $val;
286 $out = "";
287
288 if ($type) {
289
290 # Call the freezer method if it's specified and the object has the
291 # method. Trap errors and warn() instead of die()ing, like the XS
292 # implementation.
293 my $freezer = $s->{freezer};
294 if ($freezer and UNIVERSAL::can($val, $freezer)) {
295 eval { $val->$freezer() };
296 warn "WARNING(Freezer method call failed): $@" if $@;
297 }
298
299 require Scalar::Util;
300 my $realpack = Scalar::Util::blessed($val);
301 my $realtype = $realpack ? Scalar::Util::reftype($val) : ref $val;
302 $id = format_refaddr($val);
303
304 # Note: By this point $name is always defined and of non-zero length.
305 # Keep a tab on it so that we dont fall into recursive pit.
306 if (exists $s->{seen}{$id}) {
307 if ($s->{purity} and $s->{level} > 0) {
308 $out = ($realtype eq 'HASH') ? '{}' :
309 ($realtype eq 'ARRAY') ? '[]' :
310 'do{my $o}' ;
311 push @post, $name . " = " . $s->{seen}{$id}[0];
312 }
313 else {
314 $out = $s->{seen}{$id}[0];
315 if ($name =~ /^([\@\%])/) {
316 my $start = $1;
317 if ($out =~ /^\\$start/) {
318 $out = substr($out, 1);
319 }
320 else {
321 $out = $start . '{' . $out . '}';
322 }
323 }
324 }
325 return $out;
326 }
327 else {
328 # store our name
329 $s->{seen}{$id} = [ (
330 ($name =~ /^[@%]/)
331 ? ('\\' . $name )
332 : ($realtype eq 'CODE' and $name =~ /^[*](.*)$/)
333 ? ('\\&' . $1 )
334 : $name
335 ), $val ];
336 }
337 my $no_bless = 0;
338 my $is_regex = 0;
339 if ( $realpack and ($] >= 5.009005 ? re::is_regexp($val) : $realpack eq 'Regexp') ) {
340 $is_regex = 1;
341 $no_bless = $realpack eq 'Regexp';
342 }
343
344 # If purity is not set and maxdepth is set, then check depth:
345 # if we have reached maximum depth, return the string
346 # representation of the thing we are currently examining
347 # at this depth (i.e., 'Foo=ARRAY(0xdeadbeef)').
348 if (!$s->{purity}
349 and defined($s->{maxdepth})
350 and $s->{maxdepth} > 0
351 and $s->{level} >= $s->{maxdepth})
352 {
353 return qq['$val'];
354 }
355
356 # avoid recursing infinitely [perl #122111]
357 if ($s->{maxrecurse} > 0
358 and $s->{level} >= $s->{maxrecurse}) {
359 die "Recursion limit of $s->{maxrecurse} exceeded";
360 }
361
362 # we have a blessed ref
363 my ($blesspad);
364 if ($realpack and !$no_bless) {
365 $out = $s->{'bless'} . '( ';
366 $blesspad = $s->{apad};
367 $s->{apad} .= ' ' if ($s->{indent} >= 2);
368 }
369
370 $s->{level}++;
371 my $ipad = $s->{xpad} x $s->{level};
372
373 if ($is_regex) {
374 my $pat;
375 # This really sucks, re:regexp_pattern is in ext/re/re.xs and not in
376 # universal.c, and even worse we cant just require that re to be loaded
377 # we *have* to use() it.
378 # We should probably move it to universal.c for 5.10.1 and fix this.
379 # Currently we only use re::regexp_pattern when the re is blessed into another
380 # package. This has the disadvantage of meaning that a DD dump won't round trip
381 # as the pattern will be repeatedly wrapped with the same modifiers.
382 # This is an aesthetic issue so we will leave it for now, but we could use
383 # regexp_pattern() in list context to get the modifiers separately.
384 # But since this means loading the full debugging engine in process we wont
385 # bother unless its necessary for accuracy.
386 if (($realpack ne 'Regexp') && defined(*re::regexp_pattern{CODE})) {
387 $pat = re::regexp_pattern($val);
388 }
389 else {
390 $pat = "$val";
391 }
392 $pat =~ s <(\\.)|/> { $1 || '\\/' }ge;
393 $out .= "qr/$pat/";
394 }
395 elsif ($realtype eq 'SCALAR' || $realtype eq 'REF'
396 || $realtype eq 'VSTRING') {
397 if ($realpack) {
398 $out .= 'do{\\(my $o = ' . $s->_dump($$val, "\${$name}") . ')}';
399 }
400 else {
401 $out .= '\\' . $s->_dump($$val, "\${$name}");
402 }
403 }
404 elsif ($realtype eq 'GLOB') {
405 $out .= '\\' . $s->_dump($$val, "*{$name}");
406 }
407 elsif ($realtype eq 'ARRAY') {
408 my($pad, $mname);
409 my($i) = 0;
410 $out .= ($name =~ /^\@/) ? '(' : '[';
411 $pad = $s->{sep} . $s->{pad} . $s->{apad};
412 ($name =~ /^\@(.*)$/) ? ($mname = "\$" . $1) :
413 # omit -> if $foo->[0]->{bar}, but not ${$foo->[0]}->{bar}
414 ($name =~ /^\\?[\%\@\*\$][^{].*[]}]$/) ? ($mname = $name) :
415 ($mname = $name . '->');
416 $mname .= '->' if $mname =~ /^\*.+\{[A-Z]+\}$/;
417 for my $v (@$val) {
418 $sname = $mname . '[' . $i . ']';
419 $out .= $pad . $ipad . '#' . $i
420 if $s->{indent} >= 3;
421 $out .= $pad . $ipad . $s->_dump($v, $sname);
422 $out .= "," if $i++ < $#$val;
423 }
424 $out .= $pad . ($s->{xpad} x ($s->{level} - 1)) if $i;
425 $out .= ($name =~ /^\@/) ? ')' : ']';
426 }
427 elsif ($realtype eq 'HASH') {
428 my ($k, $v, $pad, $lpad, $mname, $pair);
429 $out .= ($name =~ /^\%/) ? '(' : '{';
430 $pad = $s->{sep} . $s->{pad} . $s->{apad};
431 $lpad = $s->{apad};
432 $pair = $s->{pair};
433 ($name =~ /^\%(.*)$/) ? ($mname = "\$" . $1) :
434 # omit -> if $foo->[0]->{bar}, but not ${$foo->[0]}->{bar}
435 ($name =~ /^\\?[\%\@\*\$][^{].*[]}]$/) ? ($mname = $name) :
436 ($mname = $name . '->');
437 $mname .= '->' if $mname =~ /^\*.+\{[A-Z]+\}$/;
438 my $sortkeys = defined($s->{sortkeys}) ? $s->{sortkeys} : '';
439 my $keys = [];
440 if ($sortkeys) {
441 if (ref($s->{sortkeys}) eq 'CODE') {
442 $keys = $s->{sortkeys}($val);
443 unless (ref($keys) eq 'ARRAY') {
444 carp "Sortkeys subroutine did not return ARRAYREF";
445 $keys = [];
446 }
447 }
448 else {
449 $keys = [ sort keys %$val ];
450 }
451 }
452
453 # Ensure hash iterator is reset
454 keys(%$val);
455
456 my $key;
457 while (($k, $v) = ! $sortkeys ? (each %$val) :
458 @$keys ? ($key = shift(@$keys), $val->{$key}) :
459 () )
460 {
461 my $nk = $s->_dump($k, "");
462 $nk = $1
463 if !$s->{quotekeys} and $nk =~ /^[\"\']([A-Za-z_]\w*)[\"\']$/;
464 $sname = $mname . '{' . $nk . '}';
465 $out .= $pad . $ipad . $nk . $pair;
466
467 # temporarily alter apad
468 $s->{apad} .= (" " x (length($nk) + 4))
469 if $s->{indent} >= 2;
470 $out .= $s->_dump($val->{$k}, $sname) . ",";
471 $s->{apad} = $lpad
472 if $s->{indent} >= 2;
473 }
474 if (substr($out, -1) eq ',') {
475 chop $out;
476 $out .= $pad . ($s->{xpad} x ($s->{level} - 1));
477 }
478 $out .= ($name =~ /^\%/) ? ')' : '}';
479 }
480 elsif ($realtype eq 'CODE') {
481 if ($s->{deparse}) {
482 require B::Deparse;
483 my $sub = 'sub ' . (B::Deparse->new)->coderef2text($val);
484 $pad = $s->{sep} . $s->{pad} . $s->{apad} . $s->{xpad} x ($s->{level} - 1);
485 $sub =~ s/\n/$pad/gse;
486 $out .= $sub;
487 }
488 else {
489 $out .= 'sub { "DUMMY" }';
490 carp "Encountered CODE ref, using dummy placeholder" if $s->{purity};
491 }
492 }
493 else {
494 croak "Can't handle '$realtype' type";
495 }
496
497 if ($realpack and !$no_bless) { # we have a blessed ref
498 $out .= ', ' . _quote($realpack) . ' )';
499 $out .= '->' . $s->{toaster} . '()'
500 if $s->{toaster} ne '';
501 $s->{apad} = $blesspad;
502 }
503 $s->{level}--;
504 }
505 else { # simple scalar
506
507 my $ref = \$_[1];
508 my $v;
509 # first, catalog the scalar
510 if ($name ne '') {
511 $id = format_refaddr($ref);
512 if (exists $s->{seen}{$id}) {
513 if ($s->{seen}{$id}[2]) {
514 $out = $s->{seen}{$id}[0];
515 #warn "[<$out]\n";
516 return "\${$out}";
517 }
518 }
519 else {
520 #warn "[>\\$name]\n";
521 $s->{seen}{$id} = ["\\$name", $ref];
522 }
523 }
524 $ref = \$val;
525 if (ref($ref) eq 'GLOB') { # glob
526 my $name = substr($val, 1);
527 if ($name =~ /^[A-Za-z_][\w:]*$/ && $name ne 'main::') {
528 $name =~ s/^main::/::/;
529 $sname = $name;
530 }
531 else {
532 $sname = $s->_dump(
533 $name eq 'main::' || $] < 5.007 && $name eq "main::\0"
534 ? ''
535 : $name,
536 "",
537 );
538 $sname = '{' . $sname . '}';
539 }
540 if ($s->{purity}) {
541 my $k;
542 local ($s->{level}) = 0;
543 for $k (qw(SCALAR ARRAY HASH)) {
544 my $gval = *$val{$k};
545 next unless defined $gval;
546 next if $k eq "SCALAR" && ! defined $$gval; # always there
547
548 # _dump can push into @post, so we hold our place using $postlen
549 my $postlen = scalar @post;
550 $post[$postlen] = "\*$sname = ";
551 local ($s->{apad}) = " " x length($post[$postlen]) if $s->{indent} >= 2;
552 $post[$postlen] .= $s->_dump($gval, "\*$sname\{$k\}");
553 }
554 }
555 $out .= '*' . $sname;
556 }
557 elsif (!defined($val)) {
558 $out .= "undef";
559 }
560 elsif (defined &_vstring and $v = _vstring($val)
561 and !_bad_vsmg || eval $v eq $val) {
562 $out .= $v;
563 }
564 elsif (!defined &_vstring
565 and ref $ref eq 'VSTRING' || eval{Scalar::Util::isvstring($val)}) {
566 $out .= sprintf "%vd", $val;
567 }
568 elsif ($val =~ /^(?:0|-?[1-9]\d{0,8})\z/) { # safe decimal number
569 $out .= $val;
570 }
571 else { # string
572 if ($s->{useqq} or $val =~ tr/\0-\377//c) {
573 # Fall back to qq if there's Unicode
574 $out .= qquote($val, $s->{useqq});
575 }
576 else {
577 $out .= _quote($val);
578 }
579 }
580 }
581 if ($id) {
582 # if we made it this far, $id was added to seen list at current
583 # level, so remove it to get deep copies
584 if ($s->{deepcopy}) {
585 delete($s->{seen}{$id});
586 }
587 elsif ($name) {
588 $s->{seen}{$id}[2] = 1;
589 }
590 }
591 return $out;
592}
593
594#
595# non-OO style of earlier version
596#
597sub Dumper {
598 return Data::Dumper->Dump([@_]);
599}
600
601# compat stub
602sub DumperX {
603 return Data::Dumper->Dumpxs([@_], []);
604}
605
606#
607# reset the "seen" cache
608#
609sub Reset {
610 my($s) = shift;
611 $s->{seen} = {};
612 return $s;
613}
614
615sub Indent {
616 my($s, $v) = @_;
617 if (defined($v)) {
618 if ($v == 0) {
619 $s->{xpad} = "";
620 $s->{sep} = "";
621 }
622 else {
623 $s->{xpad} = " ";
624 $s->{sep} = "\n";
625 }
626 $s->{indent} = $v;
627 return $s;
628 }
629 else {
630 return $s->{indent};
631 }
632}
633
634sub Pair {
635 my($s, $v) = @_;
636 defined($v) ? (($s->{pair} = $v), return $s) : $s->{pair};
637}
638
639sub Pad {
640 my($s, $v) = @_;
641 defined($v) ? (($s->{pad} = $v), return $s) : $s->{pad};
642}
643
644sub Varname {
645 my($s, $v) = @_;
646 defined($v) ? (($s->{varname} = $v), return $s) : $s->{varname};
647}
648
649sub Purity {
650 my($s, $v) = @_;
651 defined($v) ? (($s->{purity} = $v), return $s) : $s->{purity};
652}
653
654sub Useqq {
655 my($s, $v) = @_;
656 defined($v) ? (($s->{useqq} = $v), return $s) : $s->{useqq};
657}
658
659sub Terse {
660 my($s, $v) = @_;
661 defined($v) ? (($s->{terse} = $v), return $s) : $s->{terse};
662}
663
664sub Freezer {
665 my($s, $v) = @_;
666 defined($v) ? (($s->{freezer} = $v), return $s) : $s->{freezer};
667}
668
669sub Toaster {
670 my($s, $v) = @_;
671 defined($v) ? (($s->{toaster} = $v), return $s) : $s->{toaster};
672}
673
674sub Deepcopy {
675 my($s, $v) = @_;
676 defined($v) ? (($s->{deepcopy} = $v), return $s) : $s->{deepcopy};
677}
678
679sub Quotekeys {
680 my($s, $v) = @_;
681 defined($v) ? (($s->{quotekeys} = $v), return $s) : $s->{quotekeys};
682}
683
684sub Bless {
685 my($s, $v) = @_;
686 defined($v) ? (($s->{'bless'} = $v), return $s) : $s->{'bless'};
687}
688
689sub Maxdepth {
690 my($s, $v) = @_;
691 defined($v) ? (($s->{'maxdepth'} = $v), return $s) : $s->{'maxdepth'};
692}
693
694sub Maxrecurse {
695 my($s, $v) = @_;
696 defined($v) ? (($s->{'maxrecurse'} = $v), return $s) : $s->{'maxrecurse'};
697}
698
699sub Useperl {
700 my($s, $v) = @_;
701 defined($v) ? (($s->{'useperl'} = $v), return $s) : $s->{'useperl'};
702}
703
704sub Sortkeys {
705 my($s, $v) = @_;
706 defined($v) ? (($s->{'sortkeys'} = $v), return $s) : $s->{'sortkeys'};
707}
708
709sub Deparse {
710 my($s, $v) = @_;
711 defined($v) ? (($s->{'deparse'} = $v), return $s) : $s->{'deparse'};
712}
713
714sub Sparseseen {
715 my($s, $v) = @_;
716 defined($v) ? (($s->{'noseen'} = $v), return $s) : $s->{'noseen'};
717}
718
719# used by qquote below
72013µsmy %esc = (
721 "\a" => "\\a",
722 "\b" => "\\b",
723 "\t" => "\\t",
724 "\n" => "\\n",
725 "\f" => "\\f",
726 "\r" => "\\r",
727 "\e" => "\\e",
728);
729
730# put a string value in double quotes
731sub qquote {
732 local($_) = shift;
733 s/([\\\"\@\$])/\\$1/g;
7342899µs2242µs
# spent 239µs (236+3) within Data::Dumper::BEGIN@734 which was called: # once (236µs+3µs) by main::BEGIN@9 at line 734
my $bytes; { use bytes; $bytes = length }
# spent 239µs making 1 call to Data::Dumper::BEGIN@734 # spent 3µs making 1 call to bytes::import
735 s/([^\x00-\x7f])/'\x{'.sprintf("%x",ord($1)).'}'/ge if $bytes > length;
736 return qq("$_") unless
737 /[^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~]/; # fast exit
738
739 my $high = shift || "";
740 s/([\a\b\t\n\f\r\e])/$esc{$1}/g;
741
742 if (ord('^')==94) { # ascii
743 # no need for 3 digits in escape for these
744 s/([\0-\037])(?!\d)/'\\'.sprintf('%o',ord($1))/eg;
745 s/([\0-\037\177])/'\\'.sprintf('%03o',ord($1))/eg;
746 # all but last branch below not supported --BEHAVIOR SUBJECT TO CHANGE--
747 if ($high eq "iso8859") {
748 s/([\200-\240])/'\\'.sprintf('%o',ord($1))/eg;
749 } elsif ($high eq "utf8") {
750# use utf8;
751# $str =~ s/([^\040-\176])/sprintf "\\x{%04x}", ord($1)/ge;
752 } elsif ($high eq "8bit") {
753 # leave it as it is
754 } else {
755 s/([\200-\377])/'\\'.sprintf('%03o',ord($1))/eg;
756 s/([^\040-\176])/sprintf "\\x{%04x}", ord($1)/ge;
757 }
758 }
759 else { # ebcdic
760 s{([^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~])(?!\d)}
761 {my $v = ord($1); '\\'.sprintf(($v <= 037 ? '%o' : '%03o'), $v)}eg;
762 s{([^ !"\#\$%&'()*+,\-.\/0-9:;<=>?\@A-Z[\\\]^_`a-z{|}~])}
763 {'\\'.sprintf('%03o',ord($1))}eg;
764 }
765
766 return qq("$_");
767}
768
769# helper sub to sort hash keys in Perl < 5.8.0 where we don't have
770# access to sortsv() from XS
771sub _sortkeys { [ sort keys %{$_[0]} ] }
772
773sub _refine_name {
774 my $s = shift;
775 my ($name, $val, $i) = @_;
776 if (defined $name) {
777 if ($name =~ /^[*](.*)$/) {
778 if (defined $val) {
779 $name = (ref $val eq 'ARRAY') ? ( "\@" . $1 ) :
780 (ref $val eq 'HASH') ? ( "\%" . $1 ) :
781 (ref $val eq 'CODE') ? ( "\*" . $1 ) :
782 ( "\$" . $1 ) ;
783 }
784 else {
785 $name = "\$" . $1;
786 }
787 }
788 elsif ($name !~ /^\$/) {
789 $name = "\$" . $name;
790 }
791 }
792 else { # no names provided
793 $name = "\$" . $s->{varname} . $i;
794 }
795 return $name;
796}
797
798sub _compose_out {
799 my $s = shift;
800 my ($valstr, $postref) = @_;
801 my $out = "";
802 $out .= $s->{pad} . $valstr . $s->{sep};
803 if (@{$postref}) {
804 $out .= $s->{pad} .
805 join(';' . $s->{sep} . $s->{pad}, @{$postref}) .
806 ';' .
807 $s->{sep};
808 }
809 return $out;
810}
811
812110µs1;
813__END__
 
# spent 2µs within Data::Dumper::_vstring which was called: # once (2µs+0s) by Data::Dumper::BEGIN@273 at line 273
sub Data::Dumper::_vstring; # xsub
Report produced by the NYTProf 5.06 Perl profiler, developed by Tim Bunce and Adam Kaplan.