package Carp;
-our $VERSION = '1.01';
+our $VERSION = '1.04';
=head1 NAME
confess - die of errors with stack backtrace
+shortmess - return the message that carp and croak produce
+
+longmess - return the message that cluck and confess produce
+
=head1 SYNOPSIS
use Carp;
use Carp qw(cluck);
cluck "This is how we got here!";
+ print FH Carp::shortmess("This will have caller's details added");
+ print FH Carp::longmess("This will have stack backtrace added");
+
=head1 DESCRIPTION
The Carp routines are useful in your own modules because
they act like die() or warn(), but with a message which is more
likely to be useful to a user of your module. In the case of
-cluck and confess that context is a summary of every
-call in the call-stack. For a shorter message you can use carp
-or croak which try to report the error as being from where
+cluck, confess, and longmess that context is a summary of every
+call in the call-stack. For a shorter message you can use carp,
+croak or shortmess which report the error as being from where
your module was called. There is no guarantee that that is where
the error was, but it is a good educated guess.
-Here is a more complete description of how the shorter message works.
-What it does is search the call-stack for a function call stack where
+You can also alter the way the output and logic of C<Carp> works, by
+changing some global variables in the C<Carp> namespace. See the
+section on C<GLOBAL VARIABLES> below.
+
+Here is a more complete description of how shortmess works. What
+it does is search the call-stack for a function call stack where
it hasn't been told that there shouldn't be an error. If every
call is marked safe, it then gives up and gives a full stack
backtrace instead. In other words it presumes that the first likely
=item 1.
-Any call from a package to itself is safe.
+Any call from a package to itself is safe.
=item 2.
=item 5.
Any call to Carp is safe. (This rule is what keeps it from
-reporting the error where you call carp or croak.)
+reporting the error where you call carp/croak/shortmess.)
=back
or by including the string C<MCarp=verbose> in the PERL5OPT
environment variable.
-=head1 BUGS
-
-The Carp routines don't handle exception objects currently.
-If called with a first argument that is a reference, they simply
-call die() or warn(), as appropriate.
+Alternately, you can set the global variable C<$Carp::Verbose> to true.
+See the C<GLOBAL VARIABLES> section below.
=cut
# $Max(EvalLen|(Arg(Len|Nums)) variables are used to specify how the eval
# text and function arguments should be formatted when printed.
+# Comments added by Jos I. Boumans <kane@dwim.org> 11-Aug-2004
+# I can not get %CarpInternal or %Internal to work as advertised,
+# therefor leaving it out of the below documentation.
+# $CarpLevel may be decprecated according to the last comment, but
+# after 6 years, it's still around and in heavy use ;)
+
+=pod
+
+=head1 GLOBAL VARIABLES
+
+=head2 $Carp::CarpLevel
+
+This variable determines how many call frames are to be skipped when
+reporting where an error occurred on a call to one of C<Carp>'s
+functions. For example:
+
+ $Carp::CarpLevel = 1;
+ sub bar { .... or _error('Wrong input') }
+ sub _error { Carp::carp(@_) }
+
+This would make Carp report the error as coming from C<bar>'s caller,
+rather than from C<_error>'s caller, as it normally would.
+
+Defaults to C<0>.
+
+=head2 $Carp::MaxEvalLen
+
+This variable determines how many characters of a string-eval are to
+be shown in the output. Use a value of C<0> to show all text.
+
+Defaults to C<0>.
+
+=head2 $Carp::MaxArgLen
+
+This variable determines how many characters of each argument to a
+function to print. Use a value of C<0> to show the full length of the
+argument.
+
+Defaults to C<64>.
+
+=head2 $Carp::MaxArgNums
+
+This variable determines how many arguments to each function to show.
+Use a value of C<0> to show all arguments to a function call.
+
+Defaults to C<8>.
+
+=head2 $Carp::Verbose
+
+This variable makes C<Carp> use the C<longmess> function at all times.
+This effectively means that all calls to C<carp> become C<cluck> and
+all calls to C<croak> become C<confess>.
+
+Note, this is analogous to using C<use Carp 'verbose'>.
+
+Defaults to C<0>.
+
+=cut
+
+# disable these by default, so they can live w/o require Carp
$CarpInternal{Carp}++;
-$CarpLevel = 0; # How many extra package levels to skip on carp.
- # How many calls to skip on confess.
- # Reconciling these notions is hard, use
- # %Internal and %CarpInternal instead.
-$MaxEvalLen = 0; # How much eval '...text...' to show. 0 = all.
-$MaxArgLen = 64; # How much of each argument to print. 0 = all.
-$MaxArgNums = 8; # How many arguments to print. 0 = all.
-$Verbose = 0; # If true then make shortmess call longmess instead
+$CarpInternal{warnings}++;
+$Internal{Exporter}++;
+$Internal{'Exporter::Heavy'}++;
+$CarpLevel = 0; # How many extra package levels to skip on carp.
+ # How many calls to skip on confess.
+ # Reconciling these notions is hard, use
+ # %Internal and %CarpInternal instead.
+$MaxEvalLen = 0; # How much eval '...text...' to show. 0 = all.
+$MaxArgLen = 64; # How much of each argument to print. 0 = all.
+$MaxArgNums = 8; # How many arguments to print. 0 = all.
+$Verbose = 0; # If true then make shortmess call longmess instead
require Exporter;
@ISA = ('Exporter');
@EXPORT = qw(confess croak carp);
-@EXPORT_OK = qw(cluck);
-
-# we handle verbose usage ("perl -MCarp=verbose script.pl") ourselves
-# and then erase all traces of this call so that Exporter doesn't
-# know that we have been here. BTW subclasses shouldn't try to
-# do anything useful with 'verbose', including have that be their
-# name...
-sub import {
- if (grep 'verbose' eq $_, @_) {
- @_ = grep 'verbose' ne $_, @_;
- $Verbose = "verbose";
- }
- goto &Exporter::import;
+@EXPORT_OK = qw(cluck verbose longmess shortmess);
+@EXPORT_FAIL = qw(verbose); # hook to enable verbose mode
+
+=head1 BUGS
+
+The Carp routines don't handle exception objects currently.
+If called with a first argument that is a reference, they simply
+call die() or warn(), as appropriate.
+
+=cut
+
+# if the caller specifies verbose usage ("perl -MCarp=verbose script.pl")
+# then the following method will be called by the Exporter which knows
+# to do this thanks to @EXPORT_FAIL, above. $_[1] will contain the word
+# 'verbose'.
+
+sub export_fail {
+ shift;
+ $Verbose = shift if $_[0] eq 'verbose';
+ return @_;
}
# each function call on the stack.
sub longmess {
- { local $@; require Carp::Heavy; } # XXX fix require to not clear $@?
+ {
+ local $@;
+ # XXX fix require to not clear $@?
+ # don't use require unless we need to (for Safe compartments)
+ require Carp::Heavy unless $INC{"Carp/Heavy.pm"};
+ }
# Icky backwards compatibility wrapper. :-(
my $call_pack = caller();
if ($Internal{$call_pack} or $CarpInternal{$call_pack}) {
# you always get a stack trace
sub shortmess { # Short-circuit &longmess if called via multiple packages
- { local $@; require Carp::Heavy; } # XXX fix require to not clear $@?
+ {
+ local $@;
+ # XXX fix require to not clear $@?
+ # don't use require unless we need to (for Safe compartments)
+ require Carp::Heavy unless $INC{"Carp/Heavy.pm"};
+ }
# Icky backwards compatibility wrapper. :-(
my $call_pack = caller();
local @CARP_NOT = caller();