I would wrap the offending calls in an eval, and then check the value of $@ after to look for errors. See (brief) example below:

eval{&i_will_die};
if(defined($@)){
  # handle the error
}

sub i_will_die
{
   die "Life stinks, I give up\n";
}
[download]

$@ seems always to be defined:

$ perl -Mstrict -wle 'print defined $@'
1

Therefore you better check for a true value in $@:

if ($@) { ... }

--Frank

This is generally better than using return codes.

Depends on what kind of programming you are doing, and what you feel comfortable with. I've found return codes to be better to my taste in most cases.

You're certainly entitled to do it your own way, but modern programming practice is moving away from return codes to indicate errors and toward exceptions. You can see this in most recent books and in the prominent place exceptions have in recently designed languages.

There are two ways to deal with this. One is mentioned above, and that is wrapping dying code in eval{}, which is sort of like Java's try setup. Code inside the eval block may die, but if it does, it merely ends the eval block (and, as a bonus, $@ gets set to the message it died with).

eval {
   ... code that might die ...
};
if ($@) {
   # if we had an error.
   ... read $@ and decide on what to do ...
}
[download]

However, if you will always do the same thing upon death, you can also override the "die" signal. This would be used, for example, if you want to return a useful exit code to a wrapper script.

$SIG{__DIE__} = \&my_death;

sub my_death {
   warn @_;          #propagate the message via warn()
   POSIX::_exit(42); #exit with code 42
}
[download]

You should read about this in the perldocs before going the route above, as certain things (like I/O) are not a good idea when your app is in the throes of death. ;-)

Update: I forgot to add, if you do want to do "dangerous" things to recover from a fatal error, one way to accomplish this is to wrap your script's main logic in a subroutine (say, main()), and do something like this:

sub main {
   ... main program logic ...
}

eval { main() };
if ($@) {
   ... handle any fatal errors ...
}
[download]

This allows you to, among other things, put common housekeeping-on-exit routines inside an END{} block. For example:

eval { main() };
if ($@) {
   warn "FATAL: $@"; ## all I want to do is warn about the fatal.
}

END {
   close_all_files();
   issue_done_to_server();
}
[download]

This way, you will close all files and issue a done to the server (I made those up, BTW) whether you had fatal errors or not.