lib/Carp/Heavy.pm

   1 # Carp::Heavy uses some variables in common with Carp.
   2 package Carp;
   3
   4 =head1 NAME
   5
   6 Carp::Heavy - heavy machinery, no user serviceable parts inside
   7
   8 =cut
   9
  10 # On one line so MakeMaker will see it.
  11 use Carp;  our $VERSION = $Carp::VERSION;
  12 # use strict; # not yet
  13
  14 # 'use Carp' just installs some very lightweight stubs; the first time
  15 # these are called, they require Carp::Heavy which installs the real
  16 # routines.
  17
  18 # Comments added by Andy Wardley <abw@kfs.org> 09-Apr-98, based on an
  19 # _almost_ complete understanding of the package.  Corrections and
  20 # comments are welcome.
  21
  22 # The members of %Internal are packages that are internal to perl.
  23 # Carp will not report errors from within these packages if it
  24 # can.  The members of %CarpInternal are internal to Perl's warning
  25 # system.  Carp will not report errors from within these packages
  26 # either, and will not report calls *to* these packages for carp and
  27 # croak.  They replace $CarpLevel, which is deprecated.    The
  28 # $Max(EvalLen|(Arg(Len|Nums)) variables are used to specify how the eval
  29 # text and function arguments should be formatted when printed.
  30
  31 # Comments added by Jos I. Boumans <kane@dwim.org> 11-Aug-2004
  32 # I can not get %CarpInternal or %Internal to work as advertised,
  33 # therefore leaving it out of the below documentation.
  34 # $CarpLevel may be decprecated according to the last comment, but
  35 # after 6 years, it's still around and in heavy use ;)
  36
  37 # disable these by default, so they can live w/o require Carp
  38 $CarpInternal{Carp}++;
  39 $CarpInternal{warnings}++;
  40 $Internal{Exporter}++;
  41 $Internal{'Exporter::Heavy'}++;
  42
  43
  44 our ($CarpLevel, $MaxArgNums, $MaxEvalLen, $MaxArgLen, $Verbose);
  45
  46 # XXX longmess_real and shortmess_real should really be merged into
  47 # XXX {long|sort}mess_heavy at some point
  48
  49 sub  longmess_real {
  50     # Icky backwards compatibility wrapper. :-(
  51     my $call_pack = caller();
  52     if ($Internal{$call_pack} or $CarpInternal{$call_pack}) {
  53       return longmess_heavy(@_);
  54     }
  55     else {
  56       local $CarpLevel = $CarpLevel + 1;
  57       return longmess_heavy(@_);
  58     }
  59 };
  60
  61 sub shortmess_real {
  62     # Icky backwards compatibility wrapper. :-(
  63     my $call_pack = caller();
  64     local @CARP_NOT = caller();
  65     shortmess_heavy(@_);
  66 };
  67
  68 # replace the two hooks added by Carp
  69
  70 # aliasing the whole glob rather than just the CV slot avoids 'redefined'
  71 # warnings, even in the presence of perl -W (as used by lib/warnings.t !)
  72
  73 *longmess_jmp  = *longmess_real;
  74 *shortmess_jmp = *shortmess_real;
  75
  76
  77 sub caller_info {
  78   my $i = shift(@_) + 1;
  79   package DB;
  80   my %call_info;
  81   @call_info{
  82     qw(pack file line sub has_args wantarray evaltext is_require)
  83   } = caller($i);
  84
  85   unless (defined $call_info{pack}) {
  86     return ();
  87   }
  88
  89   my $sub_name = Carp::get_subname(\%call_info);
  90   if ($call_info{has_args}) {
  91     my @args = map {Carp::format_arg($_)} @DB::args;
  92     if ($MaxArgNums and @args > $MaxArgNums) { # More than we want to show?
  93       $#args = $MaxArgNums;
  94       push @args, '...';
  95     }
  96     # Push the args onto the subroutine
  97     $sub_name .= '(' . join (', ', @args) . ')';
  98   }
  99   $call_info{sub_name} = $sub_name;
 100   return wantarray() ? %call_info : \%call_info;
 101 }
 102
 103 # Transform an argument to a function into a string.
 104 sub format_arg {
 105   my $arg = shift;
 106   if (ref($arg)) {
 107       $arg = defined($overload::VERSION) ? overload::StrVal($arg) : "$arg";
 108   }elsif (not defined($arg)) {
 109     $arg = 'undef';
 110   }
 111   $arg =~ s/'/\\'/g;
 112   $arg = str_len_trim($arg, $MaxArgLen);
 113
 114   # Quote it?
 115   $arg = "'$arg'" unless $arg =~ /^-?[\d.]+\z/;
 116
 117   # The following handling of "control chars" is direct from
 118   # the original code - it is broken on Unicode though.
 119   # Suggestions?
 120   utf8::is_utf8($arg)
 121     or $arg =~ s/([[:cntrl:]]|[[:^ascii:]])/sprintf("\\x{%x}",ord($1))/eg;
 122   return $arg;
 123 }
 124
 125 # Takes an inheritance cache and a package and returns
 126 # an anon hash of known inheritances and anon array of
 127 # inheritances which consequences have not been figured
 128 # for.
 129 sub get_status {
 130     my $cache = shift;
 131     my $pkg = shift;
 132     $cache->{$pkg} ||= [{$pkg => $pkg}, [trusts_directly($pkg)]];
 133     return @{$cache->{$pkg}};
 134 }
 135
 136 # Takes the info from caller() and figures out the name of
 137 # the sub/require/eval
 138 sub get_subname {
 139   my $info = shift;
 140   if (defined($info->{evaltext})) {
 141     my $eval = $info->{evaltext};
 142     if ($info->{is_require}) {
 143       return "require $eval";
 144     }
 145     else {
 146       $eval =~ s/([\\\'])/\\$1/g;
 147       return "eval '" . str_len_trim($eval, $MaxEvalLen) . "'";
 148     }
 149   }
 150
 151   return ($info->{sub} eq '(eval)') ? 'eval {...}' : $info->{sub};
 152 }
 153
 154 # Figures out what call (from the point of view of the caller)
 155 # the long error backtrace should start at.
 156 sub long_error_loc {
 157   my $i;
 158   my $lvl = $CarpLevel;
 159   {
 160     my $pkg = caller(++$i);
 161     unless(defined($pkg)) {
 162       # This *shouldn't* happen.
 163       if (%Internal) {
 164         local %Internal;
 165         $i = long_error_loc();
 166         last;
 167       }
 168       else {
 169         # OK, now I am irritated.
 170         return 2;
 171       }
 172     }
 173     redo if $CarpInternal{$pkg};
 174     redo unless 0 > --$lvl;
 175     redo if $Internal{$pkg};
 176   }
 177   return $i - 1;
 178 }
 179
 180
 181 sub longmess_heavy {
 182   return @_ if ref($_[0]); # don't break references as exceptions
 183   my $i = long_error_loc();
 184   return ret_backtrace($i, @_);
 185 }
 186
 187 # Returns a full stack backtrace starting from where it is
 188 # told.
 189 sub ret_backtrace {
 190   my ($i, @error) = @_;
 191   my $mess;
 192   my $err = join '', @error;
 193   $i++;
 194
 195   my $tid_msg = '';
 196   if (defined &Thread::tid) {
 197     my $tid = Thread->self->tid;
 198     $tid_msg = " thread $tid" if $tid;
 199   }
 200
 201   my %i = caller_info($i);
 202   $mess = "$err at $i{file} line $i{line}$tid_msg\n";
 203
 204   while (my %i = caller_info(++$i)) {
 205       $mess .= "\t$i{sub_name} called at $i{file} line $i{line}$tid_msg\n";
 206   }
 207
 208   return $mess;
 209 }
 210
 211 sub ret_summary {
 212   my ($i, @error) = @_;
 213   my $err = join '', @error;
 214   $i++;
 215
 216   my $tid_msg = '';
 217   if (defined &Thread::tid) {
 218     my $tid = Thread->self->tid;
 219     $tid_msg = " thread $tid" if $tid;
 220   }
 221
 222   my %i = caller_info($i);
 223   return "$err at $i{file} line $i{line}$tid_msg\n";
 224 }
 225
 226
 227 sub short_error_loc {
 228   my $cache;
 229   my $i = 1;
 230   my $lvl = $CarpLevel;
 231   {
 232     my $called = caller($i++);
 233     my $caller = caller($i);
 234
 235     return 0 unless defined($caller); # What happened?
 236     redo if $Internal{$caller};
 237     redo if $CarpInternal{$called};
 238     redo if trusts($called, $caller, $cache);
 239     redo if trusts($caller, $called, $cache);
 240     redo unless 0 > --$lvl;
 241   }
 242   return $i - 1;
 243 }
 244
 245
 246 sub shortmess_heavy {
 247   return longmess_heavy(@_) if $Verbose;
 248   return @_ if ref($_[0]); # don't break references as exceptions
 249   my $i = short_error_loc();
 250   if ($i) {
 251     ret_summary($i, @_);
 252   }
 253   else {
 254     longmess_heavy(@_);
 255   }
 256 }
 257
 258 # If a string is too long, trims it with ...
 259 sub str_len_trim {
 260   my $str = shift;
 261   my $max = shift || 0;
 262   if (2 < $max and $max < length($str)) {
 263     substr($str, $max - 3) = '...';
 264   }
 265   return $str;
 266 }
 267
 268 # Takes two packages and an optional cache.  Says whether the
 269 # first inherits from the second.
 270 #
 271 # Recursive versions of this have to work to avoid certain
 272 # possible endless loops, and when following long chains of
 273 # inheritance are less efficient.
 274 sub trusts {
 275     my $child = shift;
 276     my $parent = shift;
 277     my $cache = shift || {};
 278     my ($known, $partial) = get_status($cache, $child);
 279     # Figure out consequences until we have an answer
 280     while (@$partial and not exists $known->{$parent}) {
 281         my $anc = shift @$partial;
 282         next if exists $known->{$anc};
 283         $known->{$anc}++;
 284         my ($anc_knows, $anc_partial) = get_status($cache, $anc);
 285         my @found = keys %$anc_knows;
 286         @$known{@found} = ();
 287         push @$partial, @$anc_partial;
 288     }
 289     return exists $known->{$parent};
 290 }
 291
 292 # Takes a package and gives a list of those trusted directly
 293 sub trusts_directly {
 294     my $class = shift;
 295     no strict 'refs';
 296     no warnings 'once';
 297     return @{"$class\::CARP_NOT"}
 298       ? @{"$class\::CARP_NOT"}
 299       : @{"$class\::ISA"};
 300 }
 301
 302 1;
 303