Catch Exceptions

When an exception is thrown via a throw statement, evaluation of the script halts and the Engine returns with Err(Box<EvalAltResult::ErrorRuntime>) containing the exception value that has been thrown.

It is possible, via the try ... catch statement, to catch exceptions, optionally with an error variable.

#![allow(unused)]
fn main() {
// Catch an exception and capturing its value
try
{
    throw 42;
}
catch (err)         // 'err' captures the thrown exception value
{
    print(err);     // prints 42
}

// Catch an exception without capturing its value
try
{
    print(42/0);    // deliberate divide-by-zero exception
}
catch               // no error variable - exception value is discarded
{
    print("Ouch!");
}

// Exception in the 'catch' block
try
{
    print(42/0);    // throw divide-by-zero exception
}
catch
{
    print("You seem to be dividing by zero here...");

    throw "die";    // a 'throw' statement inside a 'catch' block
                    // throws a new exception
}
}

Re-Throw Exception

Like the try ... catch syntax in most languages, it is possible to re-throw an exception within the catch block simply by another throw statement without a value.

#![allow(unused)]
fn main() {
try
{
    // Call something that will throw an exception...
    do_something_bad_that_throws();
}
catch
{
    print("Oooh! You've done something real bad!");

    throw;          // 'throw' without a value within a 'catch' block
                    // re-throws the original exception
}

}

Catchable Exceptions

Many script-oriented exceptions can be caught via try ... catch:

The error value in the catch clause is an object map containing information on the particular error, including its type, line and character position (if any), and source etc.

When the no_object feature is turned on, however, the error value is a simple string description.

Non-Catchable Exceptions

Some exceptions cannot be caught:

• Syntax error during parsing
• System error – e.g. script file not found
• Script evaluation metrics over safety limits
• Function calls nesting exceeding maximum call stack depth
• Script evaluation manually terminated