1 # Carp::Heavy uses some variables in common with Carp.
6 Carp::Heavy - heavy machinery, no user serviceable parts inside
10 # On one line so MakeMaker will see it.
11 use Carp; our $VERSION = $Carp::VERSION;
12 # use strict; # not yet
14 # 'use Carp' just installs some very lightweight stubs; the first time
15 # these are called, they require Carp::Heavy which installs the real
18 # The members of %Internal are packages that are internal to perl.
19 # Carp will not report errors from within these packages if it
20 # can. The members of %CarpInternal are internal to Perl's warning
21 # system. Carp will not report errors from within these packages
22 # either, and will not report calls *to* these packages for carp and
23 # croak. They replace $CarpLevel, which is deprecated. The
24 # $Max(EvalLen|(Arg(Len|Nums)) variables are used to specify how the eval
25 # text and function arguments should be formatted when printed.
27 # disable these by default, so they can live w/o require Carp
28 $CarpInternal{Carp}++;
29 $CarpInternal{warnings}++;
30 $Internal{Exporter}++;
31 $Internal{'Exporter::Heavy'}++;
34 our ($CarpLevel, $MaxArgNums, $MaxEvalLen, $MaxArgLen, $Verbose);
36 # XXX longmess_real and shortmess_real should really be merged into
37 # XXX {long|sort}mess_heavy at some point
40 # Icky backwards compatibility wrapper. :-(
42 # The story is that the original implementation hard-coded the
43 # number of call levels to go back, so calls to longmess were off
44 # by one. Other code began calling longmess and expecting this
45 # behaviour, so the replacement has to emulate that behaviour.
46 my $call_pack = caller();
47 if ($Internal{$call_pack} or $CarpInternal{$call_pack}) {
48 return longmess_heavy(@_);
51 local $CarpLevel = $CarpLevel + 1;
52 return longmess_heavy(@_);
57 # Icky backwards compatibility wrapper. :-(
58 local @CARP_NOT = caller();
62 # replace the two hooks added by Carp
64 # aliasing the whole glob rather than just the CV slot avoids 'redefined'
65 # warnings, even in the presence of perl -W (as used by lib/warnings.t !)
66 # However it has the potential to create infinite loops, if somehow Carp
67 # is forcibly reloaded, but $INC{"Carp/Heavy.pm"} remains true.
68 # Hence the extra hack of deleting the previous typeglob first.
70 delete $Carp::{shortmess_jmp};
71 delete $Carp::{longmess_jmp};
72 *longmess_jmp = *longmess_real;
73 *shortmess_jmp = *shortmess_real;
77 my $i = shift(@_) + 1;
81 qw(pack file line sub has_args wantarray evaltext is_require)
84 unless (defined $call_info{pack}) {
88 my $sub_name = Carp::get_subname(\%call_info);
89 if ($call_info{has_args}) {
90 my @args = map {Carp::format_arg($_)} @DB::args;
91 if ($MaxArgNums and @args > $MaxArgNums) { # More than we want to show?
95 # Push the args onto the subroutine
96 $sub_name .= '(' . join (', ', @args) . ')';
98 $call_info{sub_name} = $sub_name;
99 return wantarray() ? %call_info : \%call_info;
102 # Transform an argument to a function into a string.
106 $arg = defined($overload::VERSION) ? overload::StrVal($arg) : "$arg";
107 }elsif (not defined($arg)) {
111 $arg = str_len_trim($arg, $MaxArgLen);
114 $arg = "'$arg'" unless $arg =~ /^-?[\d.]+\z/;
116 # The following handling of "control chars" is direct from
117 # the original code - it is broken on Unicode though.
120 or $arg =~ s/([[:cntrl:]]|[[:^ascii:]])/sprintf("\\x{%x}",ord($1))/eg;
124 # Takes an inheritance cache and a package and returns
125 # an anon hash of known inheritances and anon array of
126 # inheritances which consequences have not been figured
131 $cache->{$pkg} ||= [{$pkg => $pkg}, [trusts_directly($pkg)]];
132 return @{$cache->{$pkg}};
135 # Takes the info from caller() and figures out the name of
136 # the sub/require/eval
139 if (defined($info->{evaltext})) {
140 my $eval = $info->{evaltext};
141 if ($info->{is_require}) {
142 return "require $eval";
145 $eval =~ s/([\\\'])/\\$1/g;
146 return "eval '" . str_len_trim($eval, $MaxEvalLen) . "'";
150 return ($info->{sub} eq '(eval)') ? 'eval {...}' : $info->{sub};
153 # Figures out what call (from the point of view of the caller)
154 # the long error backtrace should start at.
157 my $lvl = $CarpLevel;
159 my $pkg = caller(++$i);
160 unless(defined($pkg)) {
161 # This *shouldn't* happen.
164 $i = long_error_loc();
168 # OK, now I am irritated.
172 redo if $CarpInternal{$pkg};
173 redo unless 0 > --$lvl;
174 redo if $Internal{$pkg};
181 return @_ if ref($_[0]); # don't break references as exceptions
182 my $i = long_error_loc();
183 return ret_backtrace($i, @_);
186 # Returns a full stack backtrace starting from where it is
189 my ($i, @error) = @_;
191 my $err = join '', @error;
195 if (defined &Thread::tid) {
196 my $tid = Thread->self->tid;
197 $tid_msg = " thread $tid" if $tid;
200 my %i = caller_info($i);
201 $mess = "$err at $i{file} line $i{line}$tid_msg\n";
203 while (my %i = caller_info(++$i)) {
204 $mess .= "\t$i{sub_name} called at $i{file} line $i{line}$tid_msg\n";
211 my ($i, @error) = @_;
212 my $err = join '', @error;
216 if (defined &Thread::tid) {
217 my $tid = Thread->self->tid;
218 $tid_msg = " thread $tid" if $tid;
221 my %i = caller_info($i);
222 return "$err at $i{file} line $i{line}$tid_msg\n";
226 sub short_error_loc {
227 # You have to create your (hash)ref out here, rather than defaulting it
228 # inside trusts *on a lexical*, as you want it to persist across calls.
229 # (You can default it on $_[2], but that gets messy)
232 my $lvl = $CarpLevel;
234 my $called = caller($i++);
235 my $caller = caller($i);
237 return 0 unless defined($caller); # What happened?
238 redo if $Internal{$caller};
239 redo if $CarpInternal{$caller};
240 redo if $CarpInternal{$called};
241 redo if trusts($called, $caller, $cache);
242 redo if trusts($caller, $called, $cache);
243 redo unless 0 > --$lvl;
249 sub shortmess_heavy {
250 return longmess_heavy(@_) if $Verbose;
251 return @_ if ref($_[0]); # don't break references as exceptions
252 my $i = short_error_loc();
261 # If a string is too long, trims it with ...
264 my $max = shift || 0;
265 if (2 < $max and $max < length($str)) {
266 substr($str, $max - 3) = '...';
271 # Takes two packages and an optional cache. Says whether the
272 # first inherits from the second.
274 # Recursive versions of this have to work to avoid certain
275 # possible endless loops, and when following long chains of
276 # inheritance are less efficient.
281 my ($known, $partial) = get_status($cache, $child);
282 # Figure out consequences until we have an answer
283 while (@$partial and not exists $known->{$parent}) {
284 my $anc = shift @$partial;
285 next if exists $known->{$anc};
287 my ($anc_knows, $anc_partial) = get_status($cache, $anc);
288 my @found = keys %$anc_knows;
289 @$known{@found} = ();
290 push @$partial, @$anc_partial;
292 return exists $known->{$parent};
295 # Takes a package and gives a list of those trusted directly
296 sub trusts_directly {
300 return @{"$class\::CARP_NOT"}
301 ? @{"$class\::CARP_NOT"}