2 # This package is heavily used. Be small. Be fast. Be good.
4 # Comments added by Andy Wardley <abw@kfs.org> 09-Apr-98, based on an
5 # _almost_ complete understanding of the package. Corrections and
6 # comments are welcome.
8 # longmess() crawls all the way up the stack reporting on all the function
9 # calls made. The error string, $error, is originally constructed from the
10 # arguments passed into longmess() via confess(), cluck() or shortmess().
11 # This gets appended with the stack trace messages which are generated for
12 # each function call on the stack.
15 return @_ if ref $_[0];
16 my $error = join '', @_;
18 my $i = 1 + $CarpLevel;
19 my ($pack,$file,$line,$sub,$hargs,$eval,$require);
22 # crawl up the stack....
24 while (do { { package DB; @a = caller($i++) } } ) {
25 # get copies of the variables returned from caller()
26 ($pack,$file,$line,$sub,$hargs,undef,$eval,$require) = @a;
28 # if the $error error string is newline terminated then it
29 # is copied into $mess. Otherwise, $mess gets set (at the end of
30 # the 'else {' section below) to one of two things. The first time
31 # through, it is set to the "$error at $file line $line" message.
32 # $error is then set to 'called' which triggers subsequent loop
33 # iterations to append $sub to $mess before appending the "$error
34 # at $file line $line" which now actually reads "called at $file line
35 # $line". Thus, the stack trace message is constructed:
37 # first time: $mess = $error at $file line $line
38 # subsequent times: $mess .= $sub $error at $file line $line
41 if ($error =~ m/\n$/) {
44 # Build a string, $sub, which names the sub-routine called.
45 # This may also be "require ...", "eval '...' or "eval {...}"
48 $sub = "require $eval";
50 $eval =~ s/([\\\'])/\\$1/g;
51 if ($MaxEvalLen && length($eval) > $MaxEvalLen) {
52 substr($eval,$MaxEvalLen) = '...';
54 $sub = "eval '$eval'";
56 } elsif ($sub eq '(eval)') {
59 # if there are any arguments in the sub-routine call, format
60 # them according to the format variables defined earlier in
61 # this file and join them onto the $sub sub-routine string
63 # we may trash some of the args so we take a copy
64 @a = @DB::args; # must get local copy of args
65 # don't print any more than $MaxArgNums
66 if ($MaxArgNums and @a > $MaxArgNums) {
67 # cap the length of $#a and set the last element to '...'
72 # set args to the string "undef" if undefined
73 $_ = "undef", next unless defined $_;
75 # dunno what this is for...
81 # terminate the string early with '...' if too long
82 substr($_,$MaxArgLen) = '...'
83 if $MaxArgLen and $MaxArgLen < length;
85 # 'quote' arg unless it looks like a number
86 $_ = "'$_'" unless /^-?[\d.]+$/;
87 # print high-end chars as 'M-<char>'
88 s/([\200-\377])/sprintf("M-%c",ord($1)&0177)/eg;
89 # print remaining control chars as ^<char>
90 s/([\0-\37\177])/sprintf("^%c",ord($1)^64)/eg;
92 # append ('all', 'the', 'arguments') to the $sub string
93 $sub .= '(' . join(', ', @a) . ')';
95 # here's where the error message, $mess, gets constructed
96 $mess .= "\t$sub " if $error eq "called";
97 $mess .= "$error at $file line $line";
98 if (exists $main::{'Thread::'}) {
99 my $tid = Thread->self->tid;
100 $mess .= " thread $tid" if $tid;
104 # we don't need to print the actual error message again so we can
105 # change this to "called" so that the string "$error at $file line
106 # $line" makes sense as "called at $file line $line".
109 # this kludge circumvents die's incorrect handling of NUL
110 my $msg = \($mess || $error);
116 # shortmess() is called by carp() and croak() to skip all the way up to
117 # the top-level caller's package and report the error from there. confess()
118 # and cluck() generate a full stack trace so they call longmess() to
119 # generate that. In verbose mode shortmess() calls longmess() so
120 # you always get a stack trace
122 sub shortmess_heavy { # Short-circuit &longmess if called via multiple packages
123 goto &longmess_heavy if $Verbose;
124 return @_ if ref $_[0];
125 my $error = join '', @_;
126 my ($prevpack) = caller(1);
127 my $extra = $CarpLevel;
129 my ($pack,$file,$line);
130 # when reporting an error, we want to report it from the context of the
131 # calling package. So what is the calling package? Within a module,
132 # there may be many calls between methods and perhaps between sub-classes
133 # and super-classes, but the user isn't interested in what happens
134 # inside the package. We start by building a hash array which keeps
135 # track of all the packages to which the calling package belongs. We
136 # do this by examining its @ISA variable. Any call from a base class
137 # method (one of our caller's @ISA packages) can be ignored
138 my %isa = ($prevpack,1);
140 # merge all the caller's @ISA packages into %isa.
141 @isa{@{"${prevpack}::ISA"}} = ()
142 if(@{"${prevpack}::ISA"});
144 # now we crawl up the calling stack and look at all the packages in
145 # there. For each package, we look to see if it has an @ISA and then
146 # we see if our caller features in that list. That would imply that
147 # our caller is a derived class of that package and its calls can also
149 while (($pack,$file,$line) = caller($i++)) {
150 if(@{$pack . "::ISA"}) {
151 my @i = @{$pack . "::ISA"};
154 # merge any relevant packages into %isa
156 if(exists $i{$prevpack} || exists $isa{$pack});
159 # and here's where we do the ignoring... if the package in
160 # question is one of our caller's base or derived packages then
161 # we can ignore it (skip it) and go onto the next (but note that
162 # the continue { } block below gets called every time)
164 if(exists $isa{$pack});
166 # Hey! We've found a package that isn't one of our caller's
167 # clan....but wait, $extra refers to the number of 'extra' levels
168 # we should skip up. If $extra > 0 then this is a false alarm.
169 # We must merge the package into the %isa hash (so we can ignore it
170 # if it pops up again), decrement $extra, and continue.
173 @isa{@{$pack . "::ISA"}} = ()
174 if(@{$pack . "::ISA"});
177 # OK! We've got a candidate package. Time to construct the
178 # relevant error message and return it. die() doesn't like
179 # to be given NUL characters (which $msg may contain) so we
182 $msg = "$error at $file line $line";
183 if (exists $main::{'Thread::'}) {
184 my $tid = Thread->self->tid;
185 $mess .= " thread $tid" if $tid;
196 # uh-oh! It looks like we crawled all the way up the stack and
197 # never found a candidate package. Oh well, let's call longmess
198 # to generate a full stack trace. We use the magical form of 'goto'
199 # so that this shortmess() function doesn't appear on the stack
200 # to further confuse longmess() about it's calling package.
201 goto &longmess_heavy;