use warnings;
use strict;

my $thing;

eval {$thing->Cells(1234)};

print "Error <$@>" if $@;
[download]

Correct. Of course, in this case, it would be better to check

defined($thing)
[download]

and avoid the error in the first place.

1. The Perl Interpreter.
2. C Library.
3. Operating System.
4. External Programs.

These variables can be accessed many ways (they have more than one form), for example you can use $! or $OS_ERROR or $ERRNO to read the current value of the C error number in numeric context also you can use $! in string context to yield the corresponding system error string..

perlvar has valuable information about these different variables.

Can't call method "Cells" on an undefined value at Perl_XYZ.pl line XX. My question here is that: where is that error message stored

Just wondering why you are concerned about this....

I am looking for a way to capture the last thrown error in case the perl script aborts due to some error, coz I have to capture and return that error to QTP from where my perl script was invoked.

That error line was just an example. I am handling the errors almost every where, but I just need a way to be sure, if an error that I have not handled occurs, at least I have the right error text being returned.

Thanks,
J

I am looking for a way to capture the last thrown error in case the perl script aborts due to some error

If the error is printed by a die statement, you can of course catch the exception using eval (and the message will be stored in $@). In the example you gave, this will likely work (unless some of the intervening functions in the call stack do some nasty countermeasures, of course). If the error is just printed without throwing an exception, there is no way to handle it, unless you are willing to modify the source code which causes the error.

-- 
Ronald Fischer <ynnor@mm.st>

In my home-grown logger class I use the following hooks:

    $SIG{__WARN__} = \&log_error;
    $SIG{__DIE__} = sub { log_fatal_error( @_ ); exit 1 };
[download]

... which makes my log routines get called whenever a warning is issued or the die command is used. This does not work universally, because $SIG{__DIE__} will also get triggered in the following situation:

$SIG{__DIE__} = sub { print "good-by\n" };
eval {
    die "adios";
}
[download]

Which usually is not what you want. But in my case it works out fine because I don't have stacks of eval{} layers and any exception is fatal in my situation.