"Fossies" - the Fresh Open Source Software archive

Member "jacl1.4.1/docs/TclJava/JavaTryCmd.html" (27 Apr 2006, 5829 Bytes) of package /linux/misc/jacl1.4.1.tar.gz:


Caution: In this restricted "Fossies" environment the current HTML page may not be correctly presentated and may have some non-functional links. Alternatively you can here view or download the uninterpreted raw source code. A member file download can also be achieved by clicking within a package contents listing on the according byte size field.


The java::try Command


Usage:

java::try script ?catch exception_pair script? ?finally script?

The java::try command provides access to Java's try-catch-finally construct. In Tcl, the catch command is used to manage exceptional runtime conditions. Unfortunatly, the catch command is not able to deal with multiple error conditions without complex and ugly code. This makes it difficult to use the catch command with Java methods because Java methods can raise exceptions of multiple types. The java::try command solves this problem by providing a way to manage multiple exceptional conditions in Tcl, just like Java programmers can do with the try-catch-finally construct.

The script argument is evaluated in the interpreter. If a Tcl error or a Java exception is raised during the evaluation of script then each catch clause is searched to determine if a match to the exceptional condition is found. A match is found if a Tcl error was generated and the first element of the exception_pair list is TclException, or if the error was a Java exception and the first element of the exception_pair list is a Java class name that exactly matches or is a superclass of the thrown exception. If a match for the exceptional condition is found then the script argument is executed to handle the exception. After each catch clause has been processed the optional finally clause will be checked and if given, the script for the finally clause will be executed. It is important to note that if a finally clause is given, the script for the finally clause will be executed even if the exceptional condition was not caught in any of the catch clauses and that after the evaluation the original exceptional condition will be raised again. At least one catch clause must be given if the optional finally clause is not provided.

The only special case to take note of is TclInterruptedException. This exception can't be caught since it is used to indicate that interp execution has been interrupted. If a TclInterruptedException is raised, none of the catch blocks will be matched, but a finally block will still be run before the exception is propagated.

Examples:

Lets assume we have a Tcl proc called "bad" that raises an exceptional condition.

proc bad {} { do something bad }

We could use the catch command around an invocation of bad to protect the script from errors.

if {[catch {bad} err]} {
    puts "error in procedure bad: $err"
}
If we wanted to do the same thing using the java::try command we could use the following code.
java::try {
    bad
} catch {TclException err} {
    puts "error in procedure bad: $err"
}

Of course this example does not really demonstrate why the java::try command is any better then using catch. To see why we need the java::try command we need to look at an example where multiple exceptional conditions could be raised.

Suppose we wanted to call a Tcl command that was implemented with a combination of Tcl and Java code. For this example we assume a jcombo command already exists in the interpreter. We could then use the java::try command to manage exceptional conditions that could be raised while processing the jcombo command.

java::try {
    jcombo
} catch {TclException e} {
    puts "a Tcl error occurred"
} catch {IOException e} {
    puts "a Java IOException occurred"
} catch {NumberFormatException e} {
    puts "a Java NumberFormatException occurred"
}

It is possible to use the catch command to catch both Tcl and Java errors, but the code would be very complex and would not be as easy to understand as this simple example.

An experienced user might notice that the name of the exception type in the above example is not fully qualified. For instance, the fully qualified name of IOException is java.io.IOException. The java::try command will accept either form of the exception type name. The following two examples are equivalent.

java::try {
    #some code
} catch {java.io.IOException e} {
}

java::try {
    #some code
} catch {IOException e} {
}

Here is an example of using java::try with a finally clause. The finally script will be evaluated once the main script has been evaluated and all of the exception handlers have been checked.

java::try {
    #some code
} catch {TclException e} {
    #handle Tcl error
} finally {
    #do local cleanup
}

The finally clause can also be used without a catch clause.

java::try {
    #some code
} finally {
    #do local cleanup
}

One important thing to note about the java::try command is that as long as the finally script does not raise an exceptional condition, the value returned by the command will be the return value of the main script or a catch script. This example demonstrates the behavior.

java::try {
    set i 1
} finally {
    set j 2
}

The value returned by the java::try command in this example will be 1 not 2. If an exceptional condition is raised inside the finally script, it will be propagated normally.

Copyright © 1997-1998 Sun Microsystems, Inc.