Data-Dumper-Interp
view release on metacpan or search on metacpan
Updated shared test libraries. Fixed support for older Perls.
7.009 - Generalized Useqq="style=BEFORE,AFTER" in lieu of "qq=BA"
7.008 - Diagnose invalid method modifier when imported, not when 1st called
- Test messages to try to diagnose mystery test failure only on Windows
- Generate META.json
7.00? - Remove multiple "use 5.xxx" which is deprecated in Perl 5.39.8
7.005 - Windows portability; Rm multiple use VERSION (deprecated in perl 5.9)
7.004 - 'd' method modifier ("debug friendly") enables 'condense' and, if
STDOUT is a utf-encoding handle, 'spacedots'. Always used by dvis.
7.003 - Fix bug where $. was not preserved on first call (termwidth detection)
7.002 - Use wide chars only with Useqq("unicode") and utf STDOUT or ERR.
'l' method modifier omits quotes in vis() string result.
Useqq("underscores") separates digits of large numbers.
Useqq("hex") shows numbers in hexadecimal
Useqq("octets") optimizes string display for binary data, e.g.
show octal escapes and not \n \r etc.
7.001 - dvis (and any with Useqq(...:condense) show replicated chars compactly
6.011 - Silence 'stty' message if no terminal width is available
6.010 - trying to find mystery test failure on one Windows smoker host
6.009 - Fix result-parsing bug with Deparse(1).
Show (classname) before [] and {} from overloaded operators.
lib/Data/Dumper/Interp.pm view on Meta::CPAN
##FIXME: Refaddr(1) has no effect inside Blessed structures
use strict; use warnings FATAL => 'all'; use utf8;
#use 5.010; # say, state
#use 5.011; # cpantester gets warning that 5.11 is the minimum acceptable
#use 5.014; # /r for non-destructive substitution
use 5.018; # lexical_subs
use feature qw(say state lexical_subs current_sub);
use feature 'lexical_subs';
use feature 'unicode_strings';
package
# newline so Dist::Zilla::Plugin::PkgVersion won't add $VERSION
DB {
sub DB_Vis_Evalwrapper {
eval $Data::Dumper::Interp::string_to_eval; ## no critic
}
}
lib/Data/Dumper/Interp.pm view on Meta::CPAN
$Truncsuffix = "..." unless defined $Truncsuffix;
$Trunctailwidth = 0 unless defined $Trunctailwidth;
$Objects = 1 unless defined $Objects;
$Refaddr = 0 unless defined $Refaddr;
$Foldwidth = undef unless defined $Foldwidth; # undef auto-detects
$Foldwidth1 = undef unless defined $Foldwidth1; # override for 1st
# The following override Data::Dumper defaults
# Initial D::D values are captured once when we are first loaded.
#$Useqq = "<unicode:controlpic>" unless defined $Useqq;
$Useqq = "<unicode>" unless defined $Useqq;
$Quotekeys = 0 unless defined $Quotekeys;
$Sortkeys = \&__sortkeys unless defined $Sortkeys;
$Maxdepth = $Data::Dumper::Maxdepth unless defined $Maxdepth;
$Maxrecurse = $Data::Dumper::Maxrecurse unless defined $Maxrecurse;
$Deparse = 0 unless defined $Deparse;
$Deepcopy = 0 unless defined $Deepcopy;
}
_reset_defaults(); # at startup
# This user-callable function (or method) restores default defaults
lib/Data/Dumper/Interp.pm view on Meta::CPAN
elsif ($basename eq "ivis") {
$code .= " { \@_ = ( &__getself" ;
}
elsif ($basename eq "dvis") {
$code .= " { \@_ = ( &__getself->_EnabUseqqFeature(_utfoutput() ? ':showspaces:condense' : ':condense')" ;
#$code .= " { \@_ = ( &__getself->_EnabUseqqFeature(':showspaces')" ;
}
else { oops "basename=",u($basename) }
my $useqq = "";
$useqq .= ":unicode:controlpics" if delete $mod{c};
$useqq .= ":condense" if delete $mod{C};
$code .= '->Debug(2)' if delete $mod{D};
$useqq .= ":hex" if delete $mod{h};
$code .= '->Objects(0)' if delete $mod{o};
$useqq .= ":octets" if delete $mod{O};
$code .= '->Refaddr(1)' if delete $mod{r};
$useqq .= ":underscores" if delete $mod{u};
$code .= "->Useqq(\$Useqq.'${useqq}')" if $useqq ne "";
lib/Data/Dumper/Interp.pm view on Meta::CPAN
s/(['"])
(?:\Q${\_MAGIC_NOQUOTES_PFX}\E) (.*?)
(\1)/do{ local $_ = $2;
s!\\(.)!$1!g; # undo double-quotish backslash escapes
$_ }/xegs;
s/\Q${\_MAGIC_KEEPQUOTES_PFX}\E//gs;
}
sub __unesc_unicode() { # edits $_
if (/^"/) {
# Data::Dumper with Useqq(1) outputs wide characters as hex escapes;
# turn them back into the original characters if "printable".
# That means "Graph" category EXCEPT:
# BOM (which is ZERO WIDTH NO-BREAK SPACE so is considered "Graphical")
# and any other "Format" category Unicode characters; we want see those
# in hex.
s{
\G (?: [^\\]++ | \\[^x] )*+ \K (?<w> \\x\x{7B} (?<hex>[a-fA-F0-9]+) \x{7D} )
}{
lib/Data/Dumper/Interp.pm view on Meta::CPAN
sub _postprocess_DD_result {
(my $self, local $_, my $original) = @_;
no warnings 'recursion';
my ($debug, $listform, $foldwidth, $foldwidth1)
= @$self{qw/Debug _Listform Foldwidth Foldwidth1/};
my $useqq = $self->Useqq();
carp "WARNING: The Useqq specification string ",_dbvis($useqq)," contains a non-ASCII character but 'use utf8;' was not in effect when the literal was compiled; the intended chracter was probably not used.\n"
if $useqq =~ /[^\x{0}-\x{7F}]/ && !utf8::is_utf8($useqq);
my ($unesc_unicode,$condense_strings,$octet_strings,$nums_in_hex,
$controlpics,$showspaces,$underscores,$q_pfx,$q_lq,$q_rq);
if ($useqq && $useqq ne "1") {
my @useqq = split /(?<!\\):/, $useqq;
foreach (@useqq) {
$unesc_unicode = 1,next if /utf|unic/;
$condense_strings = 1,next if /cond/;
$octet_strings = 1,next if /octet/;
$nums_in_hex = 1,next if /hex/;
$controlpics = 1,next if /pic/;
$showspaces = 1,next if /space/;
$underscores = 1,next if /under/;
$_ = "qq={}" if $_ eq "qq"; # deprecated
if (/^qq=(.)(.)$/) { # deprecated
$q_pfx = "qq"; $q_lq = $1; $q_rq = $2;
next
lib/Data/Dumper/Interp.pm view on Meta::CPAN
}
}
my $pad = $self->Pad() // "";
$indent_unit = 2; # make configurable?
my $maxlinelen = $foldwidth1 || $foldwidth || INT_MAX;
my $maxlineNlen = ($foldwidth // INT_MAX) - length($pad);
if ($unesc_unicode && _utfoutput()) {
# Probably it's safe to use wide characters
$COND_LB = "\N{LEFT DOUBLE PARENTHESIS}";
$COND_RB = "\N{RIGHT DOUBLE PARENTHESIS}";
$COND_MULT = "\N{MULTIPLICATION SIGN}";
$LQ = "«";
$RQ = "»";
} else {
$COND_LB = "(";
$COND_RB = ")";
$COND_MULT = "x";
lib/Data/Dumper/Interp.pm view on Meta::CPAN
my $top = { tlen => 0, children => [] };
my $context = $top;
my $prepending = "";
my sub atom($;$) {
(local $_, my $mode) = @_;
$mode //= "";
__unmagic_atom ;
__unesc_unicode if $unesc_unicode;
__unesc_nonoctal if $octet_strings;
__subst_controlpic_backesc if $controlpics;
__subst_visiblespaces if $showspaces;
__condense_strings(8) if $condense_strings;
__change_quotechars($q_pfx, $q_lq, $q_rq) if defined($q_pfx);
__nums_in_hex if $nums_in_hex;
__nums_with_underscores if $underscores;
if ($prepending) { $_ = $prepending . $_; $prepending = ""; }
lib/Data/Dumper/Interp.pm view on Meta::CPAN
value, e.g. "A.20" sorts before "A.100". See C<Data::Dumper> documentation.
=head2 Useqq(I<argument>)
0 means generate 'single quoted' strings when possible.
1 means generate "double quoted" strings as-is from Data::Dumper.
Non-ASCII charcters will likely appeqar as hex or octal escapes.
Otherwise generate "double quoted" strings enhanced according to option
keywords given as a :-separated list, e.g. Useqq("unicode:controlpics").
The avilable options are:
=over 4
=item "unicode"
Printable ("graphic")
characters are shown as themselves rather than hex escapes, and
'\n', '\t', etc. are shown for ASCII control codes.
=item "controlpics"
Show ASCII control characters using single "control picture" characters:
'â¤' is shown for newline instead of '\n', and
similarly †⇠∠⛠⌠â ≠for \0 \a \b \e \f \r \t.
Every character occupies the same space with a fixed-width font, but
the tiny "control picures" can be hard to read;
to see traditional \n etc. while still seeing wide characters as themselves,
set C<Useqq> to just "unicode";
=item "octets"
Optimize for viewing binary strings (i.e. strings of octets, not "wide"
characters). Octal escapes are shown instead of \n, \r, etc.
=item "showspaces"
Make space characters visible (as 'â£').
lib/Data/Dumper/Interp.pm view on Meta::CPAN
=item "condense"
Repeated characters in strings are shown as "⸨I<char>xI<repcount>⸩".
For example
vec(my $s, 31, 1) = 1;
my $str = unpack "b*", $s;
say $str;
-->00000000000000000000000000000001
say visnew->Useqq("unicode:condense")->visl($str);
-->⸨0×31⸩1
=item "underscores"
Show numbers with '_' seprating groups of 3 digits.
=item "style=OPENQUOTE,CLOSEQUOTE"
Use the given symbols instead of double quotes. The symbols may
contain multiple characters. Escape , or : with backslash(E<92>).
lib/Data/Dumper/Interp.pm view on Meta::CPAN
=item "qq=XY"
(Deprecated) Equivalent to "style=qqX,Y"
=item "qq"
(Deprecated) Equivalent to "style=qq{,}"
=back
The default is C<Useqq('unicode')> except for C<dvis> which also
enables 'condense' and possibly 'showspaces'.
Functions/methods with 'q' in their name force C<Useqq(0)>;
=head2 Quotekeys
=head2 Maxdepth
=head2 Maxrecurse
=head2 Deparse
t/20_globalstuff.t view on Meta::CPAN
state $result //=
# There must be a better way...
(($^O !~ /win|dos/i && $^O =~ /ix$|ux$|bsd|svr|uni|osf|sv$/)
|| $^O eq 'darwin'
|| $^O eq 'cygwin'
)
&& -w "/dev/null";
$result;
}
my $unicode_str = join "", map { chr($_) } (0x263A .. 0x2650);
# Certain combinations of Math::Big* are incompatible (undefined BigInt::_register_callback):
# Math::BigInt 1.999829
# Math::BigFloat 1.999829
# Math::BigRat 0.2614
#
# In an attempt to avoid these troubles, require known-good versions
use Math::BigInt 1.999837 ();
use Math::BigFloat 1.999837 ();
use Math::BigRat 0.2624 ();
t/20_globalstuff.t view on Meta::CPAN
diag sprintf "%-24s %s\n",
$modname . '@' . u(${"${modname}::VERSION"}),
$path;
} else {
diag "(Module '$modname' is not available)\n";
}
}
diag "";
# Has Data::Dumper::Useqq('utf8') been fixed?
{ my $s = Data::Dumper->new([$unicode_str],['unicode_str'])->Terse(1)->Useqq('utf8')->Dump;
chomp $s;
$s =~ s/^"(.*)"$/$1/s or die "bug";
if ($s =~ tr/\0-\377//c) {
diag "!!! Useqq('utf8') seems to have been fixed in Data::Dumper !!! \n";
diag "!!! and is now passing through wide characters as themselves.\n";
diag "!!! Consider changing $pkgname to not bother parsing hex escapes?";
} else {
diag "Useqq('utf8') is still broken in Data::Dumper.\n"
}
}
t/20_globalstuff.t view on Meta::CPAN
waitpid($pid,0);
my $wstat = $?;
seek($tmp,0,0) or die "seek tmp:$!";
while (<$tmp>) { print "##subproc:$_"; }
die "With no tty, ${pkgname}::Foldwidth defaulted to ", ($wstat >> 8)|($wstat & !0xFF), " (not 80 as expected)"
unless $wstat == (80 << 8);
$? = 0;
}
ok(1, "Foldwidth default initialization");
# Basic check of printable unicode pass-thru
my $vis_outstr = vis($unicode_str);
diag " unicode_str=\"$unicode_str\"\n";
diag "${pkgname} output=$vis_outstr\n";
if (substr($vis_outstr,1,length($vis_outstr)-2) ne $unicode_str) {
die "Unicode does not come through unmolested!";
}
ok(1, "Unicode wide char pass-thru");
# Check that we recognize a Config arg of 'undef' as false, rather than
# acting like not args are present. The result should be the object ref.
if (! ref callPkgNew()->Useqq(undef)) {
diag "WARNING: Data::Dumper methods do not recognize undef boolean args as 'false'.\n";
}
ok(1, "Configmethod(undef) recognized as (false)");
t/25_importopts.t view on Meta::CPAN
change_one(Trunctailwidth => 42);
change_one(Objects => 0);
change_one(Objects => 1);
change_one(Objects => '{overloads => "transparent"}');
change_one(Refaddr => 'undef');
change_one(Refaddr => 0);
change_one(Foldwidth => 55);
change_one(Foldwidth1 => 56);
change_one(Foldwidth => $defaults{Foldwidth});
change_one(Useqq => 1);
change_one(Useqq => "'unicode:condense'");
change_one(Useqq => '"unicode"');
change_one(Quotekeys => 0);
change_one(Quotekeys => 1);
change_one(Sortkeys => 1);
change_one(Sortkeys => 0);
change_one(Maxdepth => 18);
change_one(Maxdepth => 0);
change_one(Maxrecurse => 19);
change_one(Maxrecurse => 0);
change_one(Deparse => 1);
change_one(Deparse => 0);
t/50_shebang.t view on Meta::CPAN
42,
{A => 0, BBBBBBBBBBBBB => "foo"},
);
timed_run {
mycheck 'dvis @backtrack_bugtest_data',
'@backtrack_bugtest_data=(42,{A => 0,BBBBBBBBBBBBB => "foo"})',
dvis('@backtrack_bugtest_data');
} 0.10; # some cpan test machines are slow!
sub vis_sans_quotes($) {
my $r = visnew->Useqq("unicode")->vis($_[0]);
$r =~ s/^"(.*)"$/$1/ or oops;
$r
}
{ my @items = (qw/A Z 8 9 ? ! @ $ % ^ & * ( ) _ - = + . ? : ; > < ./,
"#", ",", "\0", "\1", "\x{80}", "\x{C0}", "\x{FF}", "\\",
);
my $repcount = 20;
for my $before_item ("X", "0") { # Can't test \0 because it can become \000
for my $after_item ("Z", "\0", "0") {
t/50_shebang.t view on Meta::CPAN
my ($LB, $MULT, $RB) = ($Data::Dumper::Interp::COND_LB,
$Data::Dumper::Interp::COND_MULT,
$Data::Dumper::Interp::COND_RB);
next if $item eq $LB;
next if $item eq $MULT;
next if $item eq $RB;
my $exp = '"'.vis_sans_quotes($before)
.$LB.vis_sans_quotes($item).$MULT.$repcount.$RB
.vis_sans_quotes($after).'"';
like($got, $exp, "condense",
visnew->Useqq("unicode")->dvis('$before $item $after $str'));
}
}
}
}
sub doquoting($$) {
my ($input, $useqq) = @_;
my $quoted = $input;
if ($useqq) {
my %subopts;
t/50_shebang.t view on Meta::CPAN
}
}
$quoted =~ s/([\$\@\\])/\\$1/gs;
if (delete $subopts{controlpic}) {
$quoted =~ s/\n/\N{SYMBOL FOR NEWLINE}/gs;
$quoted =~ s/\t/\N{SYMBOL FOR HORIZONTAL TABULATION}/gs;
} else {
$quoted =~ s/\n/\\n/gs;
$quoted =~ s/\t/\\t/gs;
}
my $unicode = delete $subopts{unicode} || delete $subopts{utf8};
if (!$unicode) {
$quoted = join("", map{ ord($_) > 127 ? sprintf("\\x{%x}", ord($_)) : $_ }
split //,$quoted);
}
if (my $arg = delete $subopts{qq}) {
my ($left, $right) = split //, ($arg eq 1 ? "{}" : $arg);
$quoted =~ s/([\Q${left}${right}\E])/\\$1/g;
$quoted = "qq" . $left . $quoted . $right;
} else {
$quoted =~ s/"/\\"/g;
$quoted = '"' . $quoted . '"';
t/50_shebang.t view on Meta::CPAN
sub show_white($) {
local $_ = shift;
return "(Is undef)" unless defined;
s/\t/<tab>/sg;
s/( +)$/"<space>" x length($1)/seg; # only trailing spaces
s/\n/<newline>\n/sg;
$_
}
my $unicode_str = join "", map { chr($_) } (0x263A .. 0x2650);
my $byte_str = join "",map { chr $_ } 10..30;
sub get_closure(;$) {
my ($clobber) = @_;
confess "Non-zero CHILD_ERROR ($?)" if $? != 0;
my %closure_h = (%toplex_h);
my @closure_a = (@toplex_a);
my $closure_ar = \@closure_a;
my $closure_hr = \%closure_h;
t/50_shebang.t view on Meta::CPAN
confess "Non-zero CHILD_ERROR ($?)" if $? != 0;
# Perl is inconsistent about whether an eval in package DB can see
# lexicals in enclosing scopes. Sometimes it can, sometimes not.
# However explicitly referencing those "global lexicals" in the closure
# seems to make it work.
# 5/16/16: Perl v5.22.1 *segfaults* if these are included
# (at least *_obj). But removing them all causes some to appear
# to be non-existent.
my $forget_me_not = [
\$unicode_str, \$byte_str,
\@toplex_a, \%toplex_h, \$toplex_hr, \$toplex_ar, \$toplex_obj,
\@global_a, \%global_h, \$global_hr, \$global_ar, \$global_obj,
];
# Referencing these intermediate variables also prevents them from
# being destroyed before this closure is executed:
my $saverefs = [ \%closure_h, \@closure_a, \$closure_ar, \$closure_hr, \$closure_obj ];
my $zero = 0;
t/50_shebang.t view on Meta::CPAN
local $local_regexp = $toplex_regexp;
use constant CPICS_DEFAULT => 0; # is Useqq('controlpics') the default?
my @dvis_tests = (
[ __LINE__, q(hexesc:\x{263a}), qq(hexesc:\N{U+263A}) ], # \x{...} in dvis input
[ __LINE__, q(NUesc:\N{U+263a}), qq(NUesc:\N{U+263A}) ], # \N{U+...} in dvis input
[ __LINE__, q(aaa\\\\bbb), q(aaa\bbb) ],
[ __LINE__, q(re is $toplex_regexp), q(re is toplex_regexp=qr/my.*regexp/) ],
#[ q($unicode_str\n), qq(unicode_str=\" \\x{263a} \\x{263b} \\x{263c} \\x{263d} \\x{263e} \\x{263f} \\x{2640} \\x{2641} \\x{2642} \\x{2643} \\x{2644} \\x{2645} \\x{2646} \\x{2647} \\x{2648} \\x{2649} \\x{264a} \\x{264b} \\x{264c} \\x{264d} \\x{26...
[__LINE__, q($unicode_str\n), qq(unicode_str="${unicode_str}"\n) ],
[__LINE__, q(unicodehex_str=\"\\x{263a}\\x{263b}\\x{263c}\\x{263d}\\x{263e}\\x{263f}\\x{2640}\\x{2641}\\x{2642}\\x{2643}\\x{2644}\\x{2645}\\x{2646}\\x{2647}\\x{2648}\\x{2649}\\x{264a}\\x{264b}\\x{264c}\\x{264d}\\x{264e}\\x{264f}\\x{2650}\"\n), qq...
(CPICS_DEFAULT ? (
[__LINE__, q($byte_str\n), qq(byte_str=\"\N{SYMBOL FOR NEWLINE}\\13\N{SYMBOL FOR FORM FEED}\N{SYMBOL FOR CARRIAGE RETURN}\\16\\17\\20\\21\\22\\23\\24\\25\\26\\27\\30\\31\\32\N{SYMBOL FOR ESCAPE}\\34\\35\\36\"\n) ]
):(
[__LINE__, q($byte_str\n), qq(byte_str=\"\\n\\13\\f\\r\\16\\17\\20\\21\\22\\23\\24\\25\\26\\27\\30\\31\\32\\e\\34\\35\\36\"\n) ],
#[__LINE__, q($byte_str\n), qq(byte_str=\"\\n\\x{B}\\f\\r\\x{E}\\x{F}\\x{10}\\x{11}\\x{12}\\x{13}\\x{14}\\x{15}\\x{16}\\x{17}\\x{18}\\x{19}\\x{1A}\\e\\x{1C}\\x{1D}\\x{1E}\"\n) ],
)),
[__LINE__, q($flex\n), qq(flex=\"Lexical${SS}in${SS}sub${SS}f\"\n) ],
[__LINE__, q($$flex_ref\n), qq(\$\$flex_ref=\"Lexical${SS}in${SS}sub${SS}f\"\n) ],
t/50_shebang.t view on Meta::CPAN
$actual = $@ if $@;
$@ = $dollarat_val;
mycheck(
"Test case lno $lno, (use_oo=$use_oo) dvis input "
. $quotes[0].show_white($dvis_input).$quotes[1],
$expected,
$actual);
}
for my $useqq (0, 1, "utf8", "unicode", "unicode:controlpic",
"unicode:qq", "unicode:qq=()", "qq",
) {
my $input = $expected.$dvis_input.'qqq@_(\(\))){\{\}\""'."'"; # gnarly
# Now Data::Dumper (version 2.174) forces "double quoted" output
# if there are any Unicode characters present.
# So we can not test single-quoted mode in those cases
next
#if !$useqq && $input =~ tr/\0-\377//c;
if !$useqq && $input =~ /\P{PosixGraph}/a;
my $exp = doquoting($input, $useqq);
my $act = Data::Dumper::Interp->new()->Useqq($useqq)->vis($input);
t/t_Common.pm view on Meta::CPAN
# # Unless we are testing DDI
# no warnings 'once';
# # Don't follow overloads e.g. stringify
# $Data::Dumper::Interp::Objects = {overloads => "ignore"};
# }
unless (Cwd::abs_path(__FILE__) =~ /Data-Dumper-Interp/) {
# unless we are testing DDI
Data::Dumper::Interp->import::into($target,
qw/:DEFAULT rdvis rvis addrvis_digits/);
$Data::Dumper::Interp::Useqq = 'unicode'; # omit 'controlpic' to get \t etc.
}
# chain to Exporter to export any other importable items
goto &Exporter::import
}
use File::Temp 0.23 ();
sub mytempfile { ##DEPRECATED
Path::Tiny->tempfile(@_); # does everything we used to do
t/t_TestCommon.pm view on Meta::CPAN
use POSIX qw/INT_MAX/;
use File::Basename qw/dirname/;
use Capture::Tiny qw/capture capture_merged tee_merged/;
use Env qw/@PATH @PERL5LIB/; # ties @PATH, @PERL5LIB
use Config;
BEGIN {
unless (Cwd::abs_path(__FILE__) =~ /Data-Dumper-Interp/) {
# Unless we are testing DDI
#$Data::Dumper::Interp::Foldwidth = undef; # use terminal width
$Data::Dumper::Interp::Useqq = "controlpics:unicode";
}
}
sub bug(@) { @_=("BUG FOUND:",@_); goto &Carp::confess }
# Parse manual-testing args from @ARGV
my @orig_ARGV = @ARGV;
our ($debug, $verbose, $silent, $savepath, $nobail, $nonrandom, %dvs);
use Getopt::Long qw(GetOptions);
Getopt::Long::Configure("pass_through");
t/t_TestCommon.pm view on Meta::CPAN
sub showcontrols(_) {
local $_ = shift;
s/\n/\N{U+2424}/sg; # a special NL glyph
s/[\x{00}-\x{1F}]/ chr( ord($&)+0x2400 ) /aseg;
rawstr
}
# Show controls as traditional \t \n etc. if possible
sub showstr(_) {
if (defined &Data::Dumper::Interp::visnew) {
return visnew->Useqq("unicode")->vis(shift);
} else {
# I don't want to require Data::Dumper::Interp to be
# loaded although it will be if t_Common.pm was used also.
return showcontrols(shift);
}
}
# Show the raw string in French Quotes.
# If STDOUT is not UTF-8 encoded, also show D::D hex escapes
# so we can still see something useful in output from non-Unicode platforms.
( run in 0.535 second using v1.01-cache-2.11-cpan-88abd93f124 )