5.2 The Block Form: Exception Handling

In this form, eval is followed by a block of code, not a scalar containing a string. It is used for handling run-time errors, or exceptions. Errors can be internal built-in ones (out-of-memory, divide-by-zero) or user-defined ones produced by die.

The following example shows how you can use the block form eval to trap a run-time divide-by-zero error:

eval {
     $a = 10; $b = 0;
     $c = $a / $b;     # Causes a run-time error, 
                       # which is trapped by eval
};
print $@;   # Prints  "Illegal division by 0 at try.pl line 3

When the script is compiled, Perl syntax-checks the block of code and generates code. If it encounters a run-time error, Perl skips the rest of the eval block and sets $@ to the corresponding error text.

To signal your own errors, you use die. Perl knows whether a piece of code is currently executing inside an eval, and so, when die is called, Perl simply gives the error string - die's argument - to the global $@, and jumps to the statement following the eval block. In the following example, open_file invokes die if it has trouble opening a file. To use this function, wrap it inside an eval.

sub open_file {
    open (F, $_[0]) || die "Could not open file: $!";
}

$f = 'test.dat';
while (1) {    
    eval {
          open_file($f);   # if open_file dies, the program doesn't quit
    };
    last unless $@;     # no error: break out of the loop.
    print "$f is not present. Please enter new file name $f";
    chomp($f = <STDIN>);
}

Java/C++ programmers would of course recognize the parallel to the throw, try, and catch statements, where try corresponds to the eval block, catch to the checking of $@, and throw to die. (Essentially, the caller says to the run-time environment, "Here, try this code, and catch whatever errors are thrown by the callee.")

One thing I like a lot about the Java environment is that both the interpreter and the standard libraries make extensive and consistent use of try, throw, and catch for error handling. In some ways, using these constructs is better than simply returning an error code, because it requires the programmer to pay attention to errors (if you ignore the error, the program dies).

In C++ and Java, a function can rethrow an exception if it doesn't want to handle it itself. In Perl, you can do so by calling die without arguments:

eval {
    ...
};
if ($@ =~ /sorry, bucko/) {
    ....
} else {
   # hmm .. don't know what to do with it.
   die;  # Identical to die $@
}

If there is an enclosing eval block, this exception will be caught; otherwise, the program terminates.

use Exception;
package AmountExceededException; # User-defined exception
@ISA = ('Exception');

package OverdraftException;      # User-defined exception
@ISA = ('Exception');

package BankAccount;
sub withdraw_money {
    my $amount = shift;
    if ($amount > 300) {
        throw new AmountExceededException;
    }
    if ($amount > $balance) {
         throw new OverdraftException;
    }
    ...    # Change balance
}

try {
    print "How much do you need?"; chomp($amount = <STDIN>);
    withdraw_money ($amount);
}
catch AmountExceededException => 
               sub {print 'Cannot withdraw more than $300'},
      OverdraftException      => 
               sub {print $_[0]->message},
      Default =>
               sub {print "Internal error. Try later"};