It sounds to me like Carp and its replacement for die, croak is what you really want here. croak dies "at the place of call" instead of within your module. The source code of Carp.pm should also tell you how to get the information about the line number out of perl. perldoc -f caller also tells you how to get this information yourself.

I particularly like the confess function of carp. It is just such a good name for what it does *. It captures both the angst and the deeply spiritual nature of debugging in a single word. Confess damnit :-)

* dies with complete call stack trace

cheers

tachyon

Try this: http://www.perlmonks.org/?node=caller

For development- or debugging-purpose I like to use something like the following piece of code:

# somewhere at the beginning of the code
$SIG{__WARN__} = \&Warning;
$SIG{__DIE__}  = \&Die;

# anywhere
# ------------------------------------------------------------
sub Warning {
    my @text = @_;
    warn "------------------------------------------------------------
+\n";
    warn "WARNING: @text\n";
    my $count = 0;
    {
    my ($package, $filename, $line, $sub) = caller($count);
    last unless defined $line;
    warn sprintf("%02i %5i %-35s %-20s\n", $count++, $line, $sub,
             $filename);
    redo;
    }
} # Warning
# ------------------------------------------------------------
sub Die {
    my @text = @_;
    warn "------------------------------------------------------------
+\n";
    warn "FATAL ERROR: @text\n";
    my $count = 0;
    {
    my ($package, $filename, $line, $sub) = caller($count);
    last unless defined $line;
    warn sprintf("%02i %5i %-35s %-20s\n", $count++, $line, $sub,
             $filename);
    redo;
    }
    exit 1;
} # Die
# ------------------------------------------------------------
[download]

This installs "signal handlers" for die and warn which are executed every time when the functions die and warn are executed and print a backtrace on how the line the warning or die was produced was reached...

The problem is that when you ask for the traceback, the program has already died, so the call stack is destroyed.

To solve the problem, you have to arrange to stop the program before it dies.

In this case for example, first put the die in a separate line:

255[am]king ~/a$ cat a
print "Hello\n";
a(0);
print "Middle\n";
a(1);
print "Goodbye\n";

sub a {
   $parameter = shift;
   if( $parameter ) {
   die # <--- line 10
   };
}
[download]

[am]king ~/a$ perl a
Hello
Middle
Died at a line 10.
[download]

255[am]king ~/a$ perl -wd a

Loading DB routines from perl5db.pl version 1.27
Editor support available.

Enter h or `h h' for help, or `man perldebug' for more help.

main::(a:1):    print "Hello\n";
  DB<1> b 10
  DB<2> c
Hello
Middle
main::a(a:10):     die # <--- line 10
  DB<2> T
. = main::a(1) called from file `a' line 4
  DB<2> Died at a line 10.
 at a line 10
        main::a(1) called at a line 4
255[am]king ~/a$
[download]

perl -Mdiagnostics test.pl
Hello
Middle
Died at test.pl line 9 (#1)
    (F) You passed die() an empty string (the equivalent of die "") or
    you called it with no args and both $@ and $_ were empty.
     
Uncaught exception from user code:
        Died at - line 9.
        main::a(1) called at - line 4

Actually, if you turn on t at the beginning of your debugging, perl -d does tell you who called the function. Here is the screen shot:

C:\Perl\bin>perl -d b.pl

Loading DB routines from perl5db.pl version 1.25
Editor support available.

Enter h or `h h' for help, or `perldoc perldebug' for more help.

main::(b.pl:1): print "Hello\n";
  DB<1> t
Trace = on
  DB<1> s
Hello
main::(b.pl:2):  a(0);
  DB<1> s
main::a(b.pl:8):            $parameter = shift;
  DB<1> s
main::a(b.pl:9):            if( $parameter ) { die };
  DB<1> s
main::(b.pl:3):  print "Middle\n";
  DB<1> s
Middle
main::(b.pl:4):  a(1);
  DB<1> s
main::a(b.pl:8):            $parameter = shift;
  DB<1> s
main::a(b.pl:9):            if( $parameter ) { die };
  DB<1> s
main::a(b.pl:9):            if( $parameter ) { die };
  DB<1> s
Died at b.pl line 9.
        main::a(1) called at b.pl line 4
Debugged program terminated.  Use q to quit or R to restart,
  use O inhibit_exit to avoid stopping after program termination,
  h q, h R or h O to get additional info.
  DB<1>
[download]

Cool.

The real script that inspired the example ran for two hours before dying. Under 'trace' I imagine it would run for a decade. But that's a great tip for smaller scripts.

Obviously it would be nicer if you can trace the call stack, or the chain of exceptions. However, in this case, you yourself actually made the situation difficult. Why not die with some meaningful message? In pratical you should always call die with a meaningful hint:

print "Hello\n";
 a(0);
 print "Middle\n";
 a(1);
 print "Goodbye\n";

 sub a {
    $parameter = shift;
    if( $parameter ) { die "parameter = $parameter\n"};
 }
[download]

Lots of time, there are simple answers to difficult situations.

It is not always possible to arrange for a graceful death.

The script that inspired my question dynamically generated arguments, and the failure was based on complex conditions. I really DID need to know what line it came from. Printing out the bad argument (which I did do) was not enough.

print "Hello\n";
 a(0, __LINE__);
 print "Middle\n";
 a(1, __LINE__);
 print "Goodbye\n";
 
 sub a {
    ($parameter, $line) = @_;
    if( $parameter ) { die "$line\n";};
 }
[download]