← Index
NYTProf Performance Profile   « line view »
For t/optimization.t
  Run on Thu Jan 8 22:47:42 2015
Reported on Thu Jan 8 22:48:05 2015

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