Exceptions

From Rosetta Code
Jump to: navigation, search
Task
Exceptions
You are encouraged to solve this task according to the task description, using any language you may know.
Control Structures

These are examples of control structures. You may also be interested in:

This task is to give an example of an exception handling routine and to "throw" a new exception.

Cf. Exceptions Through Nested Calls

Contents

[edit] Ada

Define an exception

Foo_Error : exception;

Raise an exception

procedure Foo is
begin
raise Foo_Error;
end Foo;

Re-raising once caught exception:

  ...
exception
when Foo_Error =>
if ... then -- Alas, cannot handle it here,
raise; -- continue propagation of
end if;

Handle an exception

procedure Call_Foo is
begin
Foo;
exception
when Foo_Error =>
... -- do something
when others =>
... -- this catches all other exceptions
end Call_Foo;

Ada.Exceptions
The standard package Ada.Exceptions provides a possibility to attach messages to exceptions, to get exception occurrence information and textual description of exceptions. The following example illustrates basic functionality of:

with Ada.Exceptions;  use Ada.Exceptions;
with Ada.Text_IO; use Ada.Text_IO;
 
procedure Main is
begin
...
Raise_Exception (Foo_Error'Identity, "This is the exception message");
..
exception
when Error : others =>
Put_Line ("Something is wrong here" & Exception_Information (Error));
end Main;

[edit] Aikido

Aikido provides try, catch and throw statements.

Catching exceptions
There is one catch clause per try statement. The variable caught is whatever is thrown. It does not have to be a particular type, although there is a System.Exception class defined for system exceptions.

 
try {
var lines = readfile ("input.txt")
process (lines)
} catch (e) {
do_somthing(e)
}
 
 

Throwing exceptions
You can throw any value.

 
if (error) {
throw "Error"
}
 
if (something) {
throw new MyException (errorcode, a, b)
}
 
 
 

[edit] Aime

Simple Exception Throwing

void
throwing(void)
{
o_text("throwing...\n");
error("now!");
}
 
void
catching(void)
{
o_text("ready to catch\n");
if (trap(throwing)) {
o_text("caught!\n");
} else {
# nothing was thrown
}
}
 
integer
main(void)
{
catching();
 
return 0;
}
Output:
ready to catch
throwing...
aime: tmp/et: 5: now!
caught!

Exception Types

void
ft(integer a, text &s)
{
if (a & 1) {
s = "odd";
error("bad number");
} elif (a & a - 1) {
s = "not a power of two";
error("bad number");
}
}
 
void
fc(integer a)
{
text e;
 
if (trap(ft, a, e)) {
v_text("exception of type `");
v_text(e);
v_text("' thrown for ");
v_integer(a);
v_newline();
} else {
v_text("no exception thrown for ");
v_integer(a);
v_newline();
}
}
 
integer
main(void)
{
fc(5);
fc(6);
fc(8);
 
return 0;
}
Output:
aime: tmp/et1: 6: bad number
exception of type `odd' thrown for 5
aime: tmp/et1: 9: bad number
exception of type `not a power of two' thrown for 6
no exception thrown for 8

[edit] ALGOL 68

Typically: In the Algol68 transput an attempt is first made by the instance to "mend" an "exception" on an object. However: After a mend has failed, the exception may be "caught" by an outside block.

The "GOST 27975-88 Programming language ALGOL 68 extended" Soviet standard - (Язык программирования АЛГОЛ 68 расширенный (PDF)) had the addition mechanisms, e.g.: on, exception & raise.

Define an general exception handling mechanism on MODE FOOOBJECTNEW: Define an exception

# a user defined object #
MODE FOO = STRUCT ( ... )
FOOOBJECTNEW = STRUCT (FOOMEND foo exception x mended, FOO instance),
FOOOBJECT = REF FOOOBJECTNEW,
FOOMEND = PROC (FOOOBJECT)BOOL;
 
PROC on foo exception x = (FOOOBJECT foo, PROC (FOOOBJECT)BOOL foo exception x mend)VOID: (
foo exception x mended OF foo := foo exception x mend
);

Define how to raise an exception x:

PROC raise foo exception x = (FOOOBJECT foo)BOOL:
IF NOT (foo exception x mended OF foo instance)(foo instance) THEN
except foo exception x
FI

Raise an exception x on an instance:

FOOOBJECTNEW foo instance := foo base; # exception x routines are specific to a foo #
 
FOOMEND prior foo exception x mend = foo exception x mended OF foo;
on foo exception x(foo instance, raise foo exception x);
 
WHILE TRUE DO
# now manually raise example "foo exception x" #
raise foo exception x(foo instance)
OD;

Catch exception x:

 
on foo exception x(foo instance, prior foo exception x mend);
... EXIT
except foo exception x:
SKIP # exception x caught code here ... #
# to continue to propagate an exception x is a bit more problematic...#
# and requires nesting/restoring prior "raise foo exception x"#
on foo exception x(foo instance, prior foo exception x mend);
raise foo exception x(foo instance)

Standard Prelude "on event" routines
ALGOL 68 uses event routines extensively in the "standard transput" (stdio) to manage the various events that arise when data is read (or written) to a file or external device. The built in "on event" routines are:

  • on char error - if the character transput (input or output) in cannot be converted to the standard character set.
  • on format error - if the format specified is incompatible to the data being transput (input or output)
  • on line end - if an end of line was read while the program was "transputting" data
  • on logical file end - if the end of data was encountered during transput
  • on page end - if the end of a page was encountered during transput
  • on physical file end - if the end of physical media was encountered during transput
  • on value error - if the data transput was incompatibly with the variable being transput, eg a letter when a digit was expected.

All of the above allow the programmer to define a user created event routine when a particular event happens to a particular FILE. When such an event routine is called, then the routine can use any of the standard prelude routine to reposition the FILE and rectify the detected event, e.g.:

  • space or back space
  • new line, new page, set or reset.

For example: these may notify the operator to mount a new tape (in the case of physical file end).

The handler is permitted to return TRUE depending on whether the event has been handled and the program can can continue. And FALSE is when event remains un-handled, and the standard prelude event routine should be used. The handler is also permitted to exit to a label (without returning anything) if the user defined event routine determines that processing is complete.

[edit] AppleScript

try

try
set num to 1 / 0
--do something that might throw an error
end try

try-on error

try
set num to 1 / 0
--do something that might throw an error
on error errMess number errNum
--errMess and number errNum are optional
display alert "Error # " & errNum & return & errMess
end try

error

error "Error message." number 2000

[edit] AutoHotkey

[edit] True exceptions

Works with: AutoHotkey_L

In AutoHotkey_L Try, Catch, and Throw are available to handle exceptions.
From the Throw documentation:

try
BadlyCodedFunc()
catch e
MsgBox % "Error in " e.What ", which was called at line " e.Line
 
BadlyCodedFunc() {
throw Exception("Fail", -1)
}

[edit] ErrorLevel-based exceptions

In AutoHotkey_Basic, the only option for error-handling is using ErrorLevel

foo()
If ErrorLevel
Msgbox calling foo failed with: %ErrorLevel%
 
foo()
{
If success
Return
Else
ErrorLevel = foo_error
Return
}

[edit] BBC BASIC

      ON ERROR PROCerror(ERR, REPORT$) : END
 
ERROR 100, "User-generated exception"
END
 
DEF PROCerror(er%, rpt$)
PRINT "Exception occurred"
PRINT "Error number was " ; er%
PRINT "Error string was " rpt$
ENDPROC

Output:

Exception occurred
Error number was 100
Error string was User-generated exception

[edit] C

The setjmp()/longjmp() functions in the C standard library header <setjmp.h> are typically used for exception handling.

try-catch

#include <setjmp.h>
 
enum { MY_EXCEPTION = 1 }; /* any non-zero number */
 
jmp_buf env;
 
void foo()
{
longjmp(env, MY_EXCEPTION); /* throw MY_EXCEPTION */
}
 
void call_foo()
{
switch (setjmp(env)) {
case 0: /* try */
foo();
break;
case MY_EXCEPTION: /* catch MY_EXCEPTION */
/* handle exceptions of type MY_EXCEPTION */
break;
default:
/* handle any type of exception not handled by above catches */
/* note: if this "default" section is not included, that would be equivalent to a blank "default" section */
/* i.e. any exception not caught above would be caught and ignored */
/* there is no way to "let the exception through" */
}
}

With multi-thread support and nested exceptions

 
#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>
 
enum exceptions {
EXCEPTION_1 = 1,
EXCEPTION_2,
EXCEPTION_3
};
 
 
#define throw(exception) do { \
if (exp) \
longjmp(*exp, exception); \
printf("uncaught exception %d\n", exception); \
exit(exception); \
} while (0)

 
#define try(block, catch_block) \
{ \
jmp_buf *exception_outer = exp; \
jmp_buf exception_inner; \
exp = &exception_inner; \
int exception = setjmp(*exp); \
if (!exception) { \
do block while(0); \
exp = exception_outer; \
} else { \
exp = exception_outer; \
switch(exception) { \
catch_block \
default: \
throw(exception); \
} \
} \
}

 
#define catch(exception, block) \
case exception: do block while (0); break;

 
 
#define throws jmp_buf* exp
 
// define a throwing function
void g(throws) {
printf("g !\n");
throw(EXCEPTION_1);
printf("shouldnt b here\n");
}
 
void h(throws, int a)
{
printf("h %d!\n", a);
throw(EXCEPTION_2);
}
 
void f(throws) {
try({
g(exp); // call g with intention to catch exceptions
},
catch(EXCEPTION_1, {
printf("exception 1\n");
h(exp, 50); // will throw exception 2 inside this catch block
}))
}
 
int main(int argc, char* argv[])
{
throws = NULL; // define exception stack base
try({
f(exp);
},
catch(EXCEPTION_2, {
printf("exception 2\n");
})
catch(EXCEPTION_3, {
printf("exception 3\n");
}))
 
h(exp, 60); // will result in "uncaught exception"
return 0;
}
 
 

Now all we need to do is add a finally block :) hint: it is possible

[edit] C++

C++ has no finally construct. Instead you can do this in the destructor of an object on the stack, which will be called if an exception is thrown.

The exception can be of any type, this includes int's, other primitives, as well as objects.

Defining exceptions

struct MyException
{
// data with info about exception
};

There's also a class std::exception which you can, but are not required to derive your exception class from. The advantage of doing so is that you can catch unknown exceptions and still get some meaningful information out. There are also more specific classes like std::runtime_error which derive from std::exception.

#include <exception>
struct MyException: std::exception
{
char const* what() const throw() { return "description"; }
}

Note that in principle you can throw any copyable type as exception, including built-in types.

Throw exceptions

// this function can throw any type of exception
void foo()
{
throw MyException();
}
 
// this function can only throw the types of exceptions that are listed
void foo2() throw(MyException)
{
throw MyException();
}
 
// this function turns any exceptions other than MyException into std::bad_exception
void foo3() throw(MyException, std::bad_exception)
{
throw MyException();
}

Catching exceptions

try {
foo();
}
catch (MyException &exc)
{
// handle exceptions of type MyException and derived
}
catch (std::exception &exc)
{
// handle exceptions derived from std::exception, which were not handled by above catches
// e.g.
std::cerr << exc.what() << std::endl;
}
catch (...)
{
// handle any type of exception not handled by above catches
}

[edit] C#

Works with: Visual Studio version 2005

Defining exceptions

public class MyException : Exception
{
// data with info about exception
};

Throw exceptions

void foo()
{
throw MyException();
}

Catching exceptions

try {
foo();
}
catch (MyException e)
{
// handle exceptions of type MyException and derived
}
catch
{
// handle any type of exception not handled by above catches
}

[edit] Clojure

Expression handling in Clojure is basically like Java in S-expressions:

(try
(if (> (rand) 0.5)
(throw (RuntimeException. "oops!"))
(println "see this half the time")
(catch RuntimeException e
(println e)
(finally
(println "always see this"))

[edit] ColdFusion

Catch Exceptions
inside <cfscript>:

try {
foo();
} catch (Any e) {
// handle exception e
}

otherwise:

<cftry>
<cfcatch type="Database|...">
</cfcatch>
</cftry>

[edit] Common Lisp

The Common Lisp condition system allows much more control over condition signaling and condition handling than many exception-based systems. The following example, however, simply defines a condition type, unexpected-odd-number, defines a function get-number which generates a random number, returning it if it is even, but signaling an unexpected-odd-number condition if it is odd. The function get-even-number uses handler-case to call get-number returning its result if no condition is signaled, and, in the case that an unexpected-odd-number condition is signaled, returning one plus the odd number.

(define-condition unexpected-odd-number (error)
((number :reader number :initarg :number))
(:report (lambda (condition stream)
(format stream "Unexpected odd number: ~w."
(number condition)))))
 
(defun get-number (&aux (n (random 100)))
(if (not (oddp n)) n
(error 'unexpected-odd-number :number n)))
 
(defun get-even-number ()
(handler-case (get-number)
(unexpected-odd-number (condition)
(1+ (number condition)))))

A good introduction to Lisp's condition system is the chapter Beyond Exception Handling: Conditions and Restarts from Peter Seibel's Practical Common Lisp.

In Common Lisp, there are functions throw and catch, but these are not related to the condition system. Rather, they provide another mechanism for non-local control transfer.

[edit] D

import std.stdio;
 
/// Throw Exceptions
/// Stack traces are generated compiling with the -g switch.
void test1() {
throw new Exception("Sample Exception");
}
 
/// Catch Exceptions
void test2() {
try {
test1();
} catch (Exception ex) {
writeln(ex);
throw ex; // rethrow
}
}
 
/// Ways to implement finally
void test3() {
try test2();
finally writeln("test3 finally");
}
 
/// Or also with scope guards
void test4() {
scope(exit) writeln("Test4 done");
scope(failure) writeln("Test4 exited by exception");
scope(success) writeln("Test4 exited by return or function end");
test2();
}
 
void main() {
test4();
}

[edit] Delphi

Throw Exceptions

procedure test;
begin
raise Exception.Create('Sample Exception');
end;

Catch Exceptions

procedure test2;
begin
try
test;
except
ShowMessage(Exception(ExceptObject).Message); // Showing exception message
raise; // Rethrowing
end;
end;

Ways to implement finally

procedure test3;
begin
try
test2;
finally
ShowMessage('test3 finally');
end;
end;

[edit] Déjà Vu

stuff-going-wrong:
raise :value-error
 
try:
stuff-going-wrong
catch value-error:
!print "Whoops!"
Output:
Whoops!

[edit] DWScript

Throw Exceptions

procedure Test;
begin
raise Exception.Create('Sample Exception');
end;

Catch Exceptions

procedure Test2;
begin
try
test;
except
on E: Exception do begin // Filter by exception class
PrintLn(E.Message); // Showing exception message
raise; // Rethrowing
end;
end;
end;

Ways to implement finally

procedure Test3;
begin
try
test2;
finally
PrintLn('Test3 finally');
end;
end;

[edit] E

Exceptions

An exception object describes what the problem is and has nothing to do with control flow.

Due to E's ancestry as a JVM scripting language, E does not yet have any standard mechanism for user-defined exception types.

A string provided in place of an exception will be coerced to a generic exception object.

There are two control flow constructs used with exceptions: throw and eject.

Throw and catch

throw is the built-in function which throws exceptions in the conventional sense: control goes to the catch block of the most recently entered try/catch construct.

def nameOf(arg :int) {
if (arg == 43) {
return "Bob"
} else {
throw("Who?")
}
}
 
def catching(arg) {
try {
return ["ok", nameOf(arg)]
} catch exceptionObj {
return ["notok", exceptionObj]
}
}
? catching(42)
# value: ["not ok", problem: Who?]
 
? catching(43)
# value: ["ok", "Bob"]
 
? catching(45.7)
# value: ["not ok", problem: the float64 45.7 doesn't coerce to an int]

However, there is a problem here: exceptions accidentally produced or uncaught from inside a given module can lead to the calling program getting information about the internals that it shouldn't have (possibly a security problem). As a result of this, we are planning to move to a 'sealed exception' model where throw and catch have the same control flow, but only debuggers can see any information in a caught exception other than "a throw happened". For situations where the caller should have information about what happened, the ejector mechanism will be used.

Ejectors

Ejectors provide the same sort of "exit to catch block" control flow that throw/catch do, but with an explicit path rather than implicitly "nearest enclosing". Ejectors are also used as a general purpose control construct as well as for exceptions.

The escape ej { body } catch pat { catch block } construct creates an ejector object and binds it to ej, which is valid for as long as body is executing. An ejector object is a function; if it is called, then control immediately passes to the catch block, with its argument bound to pat.

The above code rewritten to use ejectors:

def nameOf(arg :int, ejector) {
if (arg == 43) {
return "Bob"
} else {
ejector("Who?")
}
}
 
def catching(arg) {
escape unnamed {
return ["ok", nameOf(arg, unnamed)]
} catch exceptionObj {
return ["notok", exceptionObj]
}
}
? catching(42)
# value: ["not ok", problem: Who?]
 
? catching(43)
# value: ["ok", "Bob"]
 
? catching(45.7)
# problem: the float64 45.7 doesn't coerce to an int

Note that the escape-catch block does not catch the coercion error resulting from passing a float64 instead of an int, since that is an (implicit) throw.

(One further refinement: While an ejector is an ordinary function, which does not return, it is generally desirable to protect against being supplied a function which unexpectedly does return. For this purpose we have throw.eject which calls the supplied function and throws if that function returns: throw.eject(ejector, "Who?"))

The benefit of using ejectors to communicate exceptions, besides the information-leak prevention described above, is that only exceptions intended to be handled by that catch block will be passed to it; unexpected internal errors will be handled by general try/catch handlers.

For example, suppose we have nameOf written as follows:

var nameTable := null
def nameOf(arg :int, ejector) {
if (nameTable == null) {
nameTable := <import:nameTableParser>.parseFile(<file:nameTable.txt>)
}
if (nameTable.maps(arg)) {
return nameTable[arg]
} else {
ejector(makeNotFoundException("Who?"))
}
}

Suppose that loading the parser, or reading the file, throws a NotFoundException (note this exception type was made up for this example). Even though it is of the same type as the "Who?" exception, it will not be caught by the caller's escape/catch block since it was not passed via the ejector, whereas a traditional "try { ... } catch ex :NotFoundException { ... }" as in other languages would, leading to incorrect handling of the error.

[edit] Erlang

 
-module( exceptions ).
 
-export( [task/0] ).
 
task() ->
try
erlang:throw( new_exception )
 
catch
_:Exception -> io:fwrite( "Catched ~p~n", [Exception] )
 
end.
 
Output:
14> exceptions:task().
Catched new_exception

[edit] Factor

Throw Exceptions

"Install Linux, Problem Solved" throw
 
TUPLE: velociraptor ;
\ velociraptor new throw

Or a shorthand for this:

ERROR: velociraptor ;
velociraptor

Catch Exceptions

! Preferred exception handling
: try-foo
[ foo ] [ foo-failed ] recover ;
 
: try-bar
[ bar ] [ bar-errored ] [ bar-always ] cleanup ;
 
! Used rarely
[ "Fail" throw ] try  ! throws a "Fail"
[ "Fail" throw ] catch ! returns "Fail"
[ "Hi" print ] catch  ! returns f (looks the same as throwing f; don't throw f)
[ f throw ] catch  ! returns f, bad! use recover or cleanup instead

[edit] Fancy

# define custom exception class
# StandardError is base class for all exception classes
class MyError : StandardError {
def initialize: message {
# forward to StdError's initialize method
super initialize: message
}
}
 
try {
# raises/throws a new MyError exception within try-block
MyError new: "my message" . raise!
} catch MyError => e {
# catch exception
# this will print "my message"
e message println
} finally {
# this will always be executed (as in e.g. Java)
"This is how exception handling in Fancy works :)" println
}

[edit] Fantom

 
// Create a new error class by subclassing sys::Err
const class SpecialErr : Err
{
// you must provide some message about the error
// to the parent class, for reporting
new make () : super ("special error") {}
}
 
class Main
{
static Void fn ()
{
throw SpecialErr ()
}
 
public static Void main ()
{
try
fn()
catch (SpecialErr e)
echo ("Caught " + e)
}
}
 

Output:

$ fan exceptions.fan 
Caught exceptions_0::SpecialErr: special error

[edit] Forth

Forth's exception mechanism is, like most things in Forth, very simple but powerful. CATCH captures the data and return stack pointers, then executes an execution token. THROW conditionally throws a value up to the most recent CATCH, restoring the stack pointers.

Throw Exceptions

: f ( -- )  1 throw ." f " ;  \ will throw a "1"
: g ( -- ) 0 throw ." g " ; \ does not throw

Catch Exceptions

: report ( n -- ) ?dup if ." caught " . else ." no throw" then ;
: test ( -- )
['] f catch report
['] g catch report ;

test example. (Output shown in bold)

cr test
'''caught 1 g no throw ok'''

Note that CATCH only restores the stack pointers, not the stack values, so any values that were changed during the execution of the token will have undefined values. In practice, this means writing code to clean up the stack, like this:

10 ['] myfun catch if drop then

[edit] Go

Go does not have exceptions, but does have built-in functions for error handling. panic(x) "throws" a value, and recover() "catches" it.

recover() needs to be called in a "deferred" function call, otherwise it will have no effect. defer delays the function call until the current function returns (or crashes).

package main
 
import "fmt"
 
func foo() {
fmt.Println("let's foo...")
defer func() {
if err := recover(); err != nil {
fmt.Printf("Error: %v\n", err)
}
}()
panic("FAIL!")
fmt.Println("there's no point in going on.")
}
 
func main() {
foo()
fmt.Println("glad that's over.")
}

Outputs:

let's foo...
Error: FAIL!
glad that's over.

[edit] Haskell

Exceptions can be implemented using monads; no special syntax is necessary.[1] In GHC, specialized functionality for exceptions are provided by the Control.Exception module.

Defining exceptions
The type "Exception", which contains pre-defined exceptions, cannot be extended. You can however use "dynamic exceptions", which can be of any type that is of "Typeable" class.

Throw exceptions
In the context of the IO monad, use "throwIO" to throw exceptions; the expression will return any type:

do {- ... -}
throwIO SomeException

In purely functional context, use "throw" to throw exceptions; the expression will match any type:

if condition then 3
else throw SomeException

To throw a user-defined exception, use "throwDyn":

if condition then 3
else throwDyn myException

Catching exceptions
The "catch" function performs the whole try-catch stuff. It is usually used in infix style: pattern-matches on the exception type and argument:

do
{- do IO computations here -}
`catch` \ex -> do
{- handle exception "ex" here -}

Note: Control.Exception's "catch" is different than Prelude's "catch".

To catch a user-defined exception, use "catchDyn":

do
{- do IO computations here -}
`catchDyn` \ex -> do
{- handle exception "ex" here -}

[edit] Icon and Unicon

The following Unicon example makes use of support for exceptions found in the The Unicon Code Library. Since exception support is not built into Unicon, but rather implemented as Unicon code, there are limitations not found in languages that natively support exceptions.

import Exceptions
 
procedure main(A)
every i := !A do {
case Try().call{ write(g(i)) } of {
Try().catch(): {
x := Try().getException()
write(x.getMessage(), ":\n", x.getLocation())
}
}
}
end
 
procedure g(i)
if numeric(i) = 3 then Exception().throw("bad value of "||i)
return i
end

A sample run is:

-> ExceptionTest 1 2 3 4 5
1
2
Exception: bad value of 3:
    procedure g [ExceptionTest.icn:15]
    procedure main [ExceptionTest.icn:5]

4
5
->

Note: it may be possible to implement exceptions in Icon; however, it would require a major rework and would likely be inelegant.

[edit] J

Tacit
Program u :: v executes u and provides its result as output unless an error occurs. In case of error, the result of v is provided instead.

Explicit
An exception in an explicit definition can be detected with try. and catcht. and can be thrown with throw. as seen below.

   pickyPicky =: verb define
if. y-:'bad argument' do.
throw.
else.
'thanks!'
end.
)
 
tryThis =: verb define
try.
pickyPicky y
catcht.
'Uh oh!'
end.
)
 
tryThis 'bad argument'
Uh oh!

[edit] Java

An exception needs to extend the Exception type.

Defining exceptions

//Checked exception
public class MyException extends Exception {
//Put specific info in here
}
 
//Unchecked exception
public class MyRuntimeException extends RuntimeException {}

Throw exceptions

public void fooChecked() throws MyException {
throw new MyException();
}
 
public void fooUnchecked() {
throw new MyRuntimeException();
}

Catching exceptions

try {
fooChecked();
}
catch(MyException exc) {
//Catch only your specified type of exception
}
catch(Exception exc) {
//Catch any non-system error exception
}
catch(Throwable exc) {
//Catch everything including system errors (not recommended)
}
finally {
//This code is always executed after exiting the try block
}
Works with: Java version 7+

Java 7 added "multicatch" and "smart rethrow".

public void foo() throws UnsupportedDataTypeException{
try{
throwsNumberFormatException();
//the following methods throw exceptions which extend IOException
throwsUnsupportedDataTypeException();
throwsFileNotFoundException();
}catch(FileNotFoundException | NumberFormatException ex){
//deal with these two Exceptions without duplicating code
}catch(IOException e){
//deal with the UnsupportedDataTypeException as well as any other unchecked IOExceptions
throw e;
}
}

In previous versions of Java, foo() would have to declare that it throws an IOException. The "smart rethrow" recognizes that the only checked exception that can result in the rethrow ("throw e;") is an UnsupportedDataTypeException. The last catch block will still catch any other unchecked IOExceptions and rethrow them, but foo() only needs to declare that UnsupportedDataTypeExceptions are thrown from it since that's the only checked exception that can cause a rethrow.

The other catch block uses the same code to handle both FileNotFoundExceptions and NumberFormatExceptions by adding a | between the exception types that are declared.

[edit] JavaScript

Throwing exceptions

function doStuff() {
throw new Error('Not implemented!');
}

Catching exceptions

try {
element.attachEvent('onclick', doStuff);
}
catch(e if e instanceof TypeError) {
element.addEventListener('click', doStuff, false);
}
finally {
eventSetup = true;
}

[edit] Lasso

protect => {
handle_error => {
// do something else
}
fail(-1,'Oops')
}

[edit]

Works with: UCB Logo
to div.checked :a :b
if :b = 0 [(throw "divzero 0)]
output :a / :b
end
to div.safely :a :b
output catch "divzero [div.checked :a :b]
end

There are also some predefined exceptions:

  • throw "toplevel returns to the interactive prompt if uncaught (like control-C)
  • (throw "error [message]) prints a message like a primitive, bypassing normal catch output
  • throw "system immediately exits Logo to the shell
  • catch "error will catch any thrown error instead of printing an error message

[edit] Logtalk

Logtalk exception-handling mechanism is based on the catch/3 and throw/1 predicates inherited from Prolog:

 
:- object(exceptions).
 
:- public(double/2).
double(X, Y) :-
catch(double_it(X,Y), Error, handler(Error, Y)).
 
handler(error(not_a_number(X), logtalk(This::double(X,Y), Sender)), Y) :-
% try to fix the error and resume computation;
% if not possible, rethrow the exception
( catch(number_codes(Nx, X), _, fail) ->
double_it(Nx, Y)
; throw(error(not_a_number(X), logtalk(This::double(X,Y), Sender)))
).
 
double_it(X, Y) :-
( number(X) ->
Y is 2*X
; this(This),
sender(Sender),
throw(error(not_a_number(X), logtalk(This::double(X,Y), Sender)))
).
 
:- end_object.
 

Sample output:

 
| ?- exceptions::double(1, Double).
Double = 2
yes
 
| ?- exceptions::double("1", Double).
Double = 2
yes
 
| ?- exceptions::double(a, Double).
uncaught exception: error(not_a_number(a),logtalk(exceptions::double(a,_),user))
 

[edit] Lua

Throwing an Exception

 
error("Something bad happened!")
 

Catching Exceptions

 
function throw_error()
error("Whoops")
-- won't ever appear, due to previous error() call
return "hello!"
end
 
-- 'status' is false if 'throw_error' threw an error
-- otherwise, when everything went well, it will be true.
-- 'errmsg' contains the error message, plus filename and line number of where the error occured
status, errmsg = pcall(throw_error)
print("errmsg = ", errmsg)
 

Note that `pcall` passes every argument after the function object or function name to said function:

 
function throw_error_with_argment(argument)
error(string.format("Whoops! argument = %s", argument))
-- won't ever appear, due to previous error() call
return "hello!"
end
 
status, errmsg = pcall(throw_error_with_argment, "foobar 123")
print("errmsg = ", errmsg)
 

If a function does not throw an error, 'errmsg' (which might be called 'returned' as well) contains the value(s) returned from the function:

 
function throw_error_with_argment(argument)
return "hello!"
end
 
status, errmsg = pcall(throw_error_with_argment, "foobar 123")
print("errmsg = ", errmsg)
 

[edit] Make

In make, an exception is caused when a rule returns a non-zero status i.e the below will fail as false returns 1, (thus raising exception)

fail.mk

all:
false

Using -@ to ignore the exception.

catch.mk

all:
-@make -f fail.mk

Using explicit exit 0 to ignore the exception.

catch.mk

all:
make -f fail.mk; exit 0

[edit] Mathematica

f[x_] := If[x > 10, Throw[overflow], x!]
 
Example usage :
Catch[f[2] + f[11]]
-> overflow
 
Catch[f[2] + f[3]]
-> 8

[edit] MATLAB

Errors are thrown using the "error" keyword.

Sample usage:

>> error 'Help'
??? Help

[edit] Modula-3

Defining exceptions
Exceptions can only be declared at the "top-level" of a module or interface. Arguments are optional.

EXCEPTION EndOfFile;
EXCEPTION Error(TEXT);

Throw exceptions
Exceptions can be bound to procedures using RAISES:

PROCEDURE Foo() RAISES { EndOfFile } =
...
RAISE EndOfFile;
...

Catching exceptions

TRY
Foo();
EXCEPT
| EndOfFile => HandleFoo();
END;

Modula-3 also has a FINALLY keyword:

TRY
Foo();
FINALLY
CleanupFoo(); (* always executed *)
END;


[edit] MOO

Throw exceptions
Values can be raised to exceptions using raise():

raise(E_PERM);

Catching exceptions

try
this:foo();
except e (ANY)
this:bar(e);
endtry

MOO also has a finally statement:

try
this:foo();
finally
this:bar();
endtry

Shorthand

`this:foo()!ANY=>this:bar()';

[edit] Nemerle

// define a new exception
class MyException : Exception
{
...
}
 
// throw an exception
Foo() : void
{
throw MyException();
}
 
// catching exceptions
try {
Foo();
}
catch { // catch block uses pattern matching syntax
|e is MyException => ... // handle exception
|_ => throw e // rethrow unhandled exception
}
finally {
... // code executes whether or not exception was thrown
}

[edit] NetRexx

As NetRexx runs under the control of a JVM it has the same exception model as Java.

/* NetRexx */
options replace format comments java crossref symbols nobinary
 
-- =============================================================================
class RExceptions public
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method test() public signals RExceptions.TakeException
if (1 == 1) then signal RExceptions.TakeException()
return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method main(args = String[]) public static
do
RExceptions().test()
catch ex = Exception
say ex.toString()
end
 
return;
 
-- =============================================================================
class RExceptions.TakeException public extends Exception
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method TakeException() public
super('I resent that!')
return
 

Output:

RExceptions$TakeException: I resent that!

[edit] Nimrod

Defining exceptions

type SillyError = object of EBase

Throwing an exception

proc spam() =
raise newException(SillyError, "Some error")

Handling an exception

try:
spam()
except SillyError:
echo "Got SillyError with message: ", getCurrentExceptionMsg()
except:
echo "Got another exception"
finally:
echo "Finally"

[edit] Objective-C

Defining exceptions
Exceptions can be any Objective-C object, though they are usually instances of NSException. You can create a subclass of NSException if necessary:

@interface MyException : NSException {
//Put specific info in here
}
@end

Throw exceptions

- (void)foo {
@throw [NSException exceptionWithName:@"TerribleException"
reason:@"OMGWTFBBQ111!1" userInfo:nil];
}

Catching exceptions

@try {
[self foo];
}
@catch (MyException *exc) {
//Catch only your specified type of exception
}
@catch (NSException *exc) {
//Catch any NSException or subclass
NSLog(@"caught exception named %@, with reason: %@", [exc name], [exc reason]);
}
@catch (id exc) {
//Catch any kind of object
}
@finally {
//This code is always executed after exiting the try block
}

[edit] OCaml

Defining exceptions
Like constructors, exceptions may or may not have an argument:

exception My_Exception;;
exception Another_Exception of string;;

Throw exceptions
Throw exceptions with the "raise" function; the expression will match any type:

let foo x =
match x with
1 -> raise My_Exception
| 2 -> raise (Another_Exception "hi mom")
| _ -> 5
;;

Catching exceptions
The "with" syntax pattern-matches on the exception type and argument:

try
string_of_int (foo 2)
with
My_Exception -> "got my exception"
| Another_Exception s -> s
| _ -> "unknown exception"

[edit] Oz

Throw exceptions
Any value can be thrown as an exception. Typically record values are used.

raise sillyError end
raise slightlyLessSilly(data:42 reason:outOfMemory) end

By using a record value with a feature debug set to unit you can indicate that the exception shall have debug information (including a stack trace).

try
raise someError(debug:unit) end
catch someError(debug:d(stack:ST ...)...) then
{Inspect ST}
end

See also: Exceptions in the Oz documentation.

Catching exceptions
Exception are caught with pattern matching. Ellipsis indicating additional optional fields are often useful here.

try
{Foo}
catch sillyError then
{Bar}
[] slightlyLessSilly(data:D ...) then
{Quux D}
[] _ then %% an unknown type of exception was thrown
{Baz}
finally
{Fin}
end

[edit] PARI/GP

[edit] Catching errors in GP

The errors that can be trapped in GP are:

alarmer generic error
gdiver division by 0
invmoder impossible modular inverse
archer not available on this architecture or operating system
typeer wrong type
errpile the PARI stack overflows
talker generic error
user User-initiated error
trap(/* specific error can be given here, or leave blank to catch all */,
"caught"
,
error("bad stuff")
)

[edit] Throwing errors in GP

The only error that can be thrown in GP is user error:

error("Text of error here")

[edit] Throwing errors in PARI

Many more errors can be caught and thrown directly in PARI:

0 Generic error
talker2 ?
bugparier Bug, please report
alarmer Generic error
openfiler File I/O
talker Generic error
flagerr Invalid flag
impl Not implemented
archer Not available on this system
notfuncer Not a function in function call
precer Precision too low
typeer Incorrect type
consister Inconsistent data
user User-initiated error
errpile Stack overflow
overflower Overflow
matinv1 Non-invertible matrix (in gauss)
mattype1 Not a square matrix
arither1 Not an integer argument in an arithmetic function
primer1 Not enough precomputed primes
invmoder Impossible inverse
constpoler Constant polynomial
notpoler Not a polynomial
redpoler Reducible polynomial
zeropoler Zero polynomial
operi "Impossible"
operf "Forbidden"
gdiver Division by zero
memer Not enough memory
negexper Negative exponent
sqrter5 Non quadratic residue (in gsqrt)
noer Not an error...
pari_err(arither1, "functionName"); // Gives "*** functionName: not an integer argument in an arithmetic function"

[edit] Catching errors in PARI

It is rare that this mechanism needs to be used in PARI, rather than standard C methods, but the function closure_trapgen (similar to closure_evalgen) is available:

GEN x = closure_trapgen(arither1, f); // Executes the function f, catching "not an integer argument in an arithmetic function" errors
if (x == (GEN)1L) // Was there an error?
pari_printf("Don't do that!\n"); // Recover

[edit] Pascal

See Delphi

[edit] Perl

Using eval
Exceptions using the core eval function:

# throw an exception
die "Danger, danger, Will Robinson!";
 
# catch an exception and show it
eval {
die "this could go wrong mightily";
};
print $@ if $@;
 
# rethrow
die $@;

See http://perldoc.perl.org/perlvar.html#%24EVAL_ERROR for the meaning of the special variable $@. See http://search.cpan.org/dist/Error for advanced object based-exception handling.

Using Try::Tiny
The same using the Try::Tiny module:

# throw an exception
die "Danger, danger, Will Robinson!";
# catch an exception and show it
try {
die "this could go wrong mightily";
} catch {
print;
};
# rethrow (inside of catch)
die $_;

Other styles
More complicated exception handling can be achieved in Perl using TryCatch or Exception::Class modules.

[edit] Perl 6

The Perl 6 equivalent to Perl 5's eval {...} is try {...}. A try block by default has a CATCH block that handles all fatal exceptions by ignoring them. If you define a CATCH block within the try, it replaces the default CATCH. It also makes the try keyword redundant, because any block can function as a try block if you put a CATCH block within it. For furthur information see: http://perlcabal.org/syn/S04.html#Exception_handlers

try { die "Help I'm dieing!"; CATCH { note $_.uc; say "Cough, Cough, Aiee!!" } }
 
CATCH { note "No you're not."; say $_; }
 
say "Yay. I'm alive.";
 
die "I'm dead.";
 
say "Arrgh.";
HELP I'M DIEING!
Cough, Cough, Aiee!!
Yay. I'm alive.
No you're not.
I'm dead.

[edit] PHL

PHL does not support multiple catch-clauses.

module exceptions;
 
extern printf;
 
struct @MyException : @Exception {
 
};
 
@Void func throws ex [
throw new @MyException;
]
 
@Integer main [
try func();
catch (e) {
if (e::getType == "MyException") {
printf("MyException thrown!\n");
} else {
printf("Unhandled exception!\n");
}
}
return 0;
]

[edit] PHP

Works with: PHP version 5.0+

Exceptions were not available prior to PHP 5.0

Define exceptions

class MyException extends Exception
{
// Custom exception attributes & methods
}

Throwing exceptions

function throwsException()
{
throw new Exception('Exception message');
}

Catching Exceptions

try {
throwsException();
} catch (Exception $e) {
echo 'Caught exception: ' . $e->getMessage();
}

[edit] PicoLisp

catch, throw (and finally) can be used for exception handling. 'throw' will transfer control to a 'catch' environment that was set up with the given label.

(catch 'thisLabel          # Catch this label
(println 1) # Do some processing (print '1')
(throw 'thisLabel 2) # Abort processing and return '2'
(println 3) ) # This is never reached

Output:

1        # '1' is printed
-> 2     # '2' is returned

[edit] PL/I

 
/* Define a new exception, called "my_condition". */
on condition (my_condition) snap begin;
put skip list ('My condition raised.');
end;
 
/* Raise that exception */
signal condition (my_condition);
 
/* Raising that exception causes the message "My condition raised" */
/* to be printed, and execution then resumes at the statement */
/* following the SIGNAL statement. */
 

[edit] Pop11

Throwing exceptions

define throw_exception();
throw([my_exception my_data]);
enddefine;

Catching exceptions

define main();
vars cargo;
define catcher();
 ;;; print exception data
cargo =>
enddefine;
catch(throw_exception, catcher, [my_exception ?cargo]);
enddefine;
 
main();

[edit] PureBasic

Procedure ErrorHandler()
MessageRequester("Exception test", "The following error happened: " + ErrorMessage())
EndProcedure
 
MessageRequester("Exception test", "Test start")
 
OnErrorCall(@ErrorHandler())
 
RaiseError(#PB_OnError_InvalidMemory) ;a custom error# can also be used here depending on the OS being compiled for

[edit] Python

Defining an exception

import exceptions
class SillyError(exceptions.Exception):
def __init__(self,args=None):
self.args=args

Note: In most cases new exceptions are defined simply using the pass statement. For example:

class MyInvalidArgument(ValueError):
pass

This example makes "MyInvalidArgument" an type of ValueError (one of the built-in exceptions). It's simply declared as a subclass of the existing exception and no over-riding is necessary. (An except clause for ValueError would catch MyInvalidArgument exceptions ... but one's code could insert a more specific exception handler for the more specific type of exception).

Throwing an exception

Works with: Python version 2.x and 3.x

Creating an exception using the default constructor of an exception class:

def spam():
raise SillyError # equivalent to raise SillyError()
Works with: Python version 2.5

Passing an argument to the constructor of an exception class:

def spam():
raise SillyError, 'egg' # equivalent to raise SillyError('egg')

The above syntax is removed in Python 3.0; but the following syntax works in Python 2.x and 3.x, so should be preferred.

Works with: Python version 2.x and 3.x
def spam():
raise SillyError('egg')

Handling an exception

Works with: Python version 2.5

try-except-else-finally

try:
foo()
except SillyError, se:
print se.args
bar()
else:
# no exception occurred
quux()
finally:
baz()

Before Python 2.5 it was not possible to use finally and except together. (It was necessary to nest a separate try...except block inside of your try...finally block).

Works with: Python version 3.0

Note: Python3 will change the syntax of except slightly, but in a way that is not backwards compatible. In Python 2.x and earlier the except statement could list a single exception or a tuple/list of exceptions and optionally a name to which the exception object will be bound. In the old versions the exception's name followed a comma (as in the foregoing example). In Python3 the syntax will become: except Exception1 [,Exception2 ...] as ExceptionName

try:
foo()
except SillyError as se:
print(se.args)
bar()
else:
# no exception occurred
quux()
finally:
baz()

[edit] R

Define an exception

 
e <- simpleError("This is a simpleError")
 

Raise an exception

 
stop("An error has occured")
stop(e) #where e is a simpleError, as above
 

Handle an exception

 
tryCatch(
{
if(runif(1) > 0.5)
{
message("This doesn't throw an error")
} else
{
stop("This is an error")
}
},
error = function(e) message(paste("An error occured", e$message, sep = ": ")),
finally = message("This is called whether or not an exception occured")
)
 

[edit] Racket

 
#lang racket
 
;; define a new exception type
(struct exn:my-exception exn ())
 
;; handler that prints the message ("Hi!")
(define (handler exn)
(displayln (exn-message exn)))
 
;; install exception handlers
(with-handlers ([exn:my-exception? handler])
 ;; raise the exception
(raise (exn:my-exception "Hi!" (current-continuation-marks))))
 

[edit] Raven

42 as custom_error
 
define foo
custom_error throw
 
try
foo
catch
custom_error =
if 'oops' print

[edit] REXX

While the REXX language doesn't have a throw capability pe se, it does have the ability to catch exceptions (by label).
This type of exception handling (in REXX) has its limitation (the label is local to the program, not external subroutines).

/*REXX pgm to demonstrate handling an exception; catching is via a label*/
do j=9 by -5 for 100
say 'square root of' j "is" sqrt(j)
end /*j*/
exit /*stick a fork in it, we're done.*/
 
.sqrtNeg: say 'illegal SQRT argument (argument is negative):' x
exit /*exit (terminate) this program. */
 
/*─────────────────────────────────────SQRT subroutine──────────────────*/
sqrt: procedure; parse arg x; if x=0 then return 0; d=digits();numeric dig
g=.sqrtGuess(); do j=0 while p>9; m.j=p; p=p%2+1; end
do k=j+5 to 0 by -1; if m.k>11 then numeric digits m.k; g=.5*(g+x/g)
numeric digits d; return g/1
.sqrtGuess: if x<0 then signal .sqrtNeg; numeric form; m.=11; p=d+d%
parse value format(x,2,1,,0) 'E0' with g 'E' _ .; return g*.5'E'_%

output

square root of 9 is 3
square root of 4 is 2
illegal SQRT argument (argument is negative): -1

[edit] Ruby

Defining an exception

# define an exception
class SillyError < Exception
end

SillyError is simply declared as a subclass of Exception. No over-riding is necessary.

class MyInvalidArgument < ArgumentError
end

MyInvalidArgument is a type of ArgumentError (a built-in class). A rescue clause for ArgumentError would catch MyInvalidArgument exceptions ... but one's code could insert a more specific exception handler for the more specific type of exception.

Handling an exception

 
# raise (throw) an exception
def spam
raise SillyError, 'egg'
end
 
# rescue (catch) an exception
begin
spam
rescue SillyError => se
puts se # writes 'egg' to stdout
end
begin
foo
rescue ArgumentError => e
# rescues a MyInvalidArgument or any other ArgumentError
bar
rescue => e
# rescues a StandardError
quack
else
# runs if no exception occurred
quux
ensure
# always runs
baz
end

ArgumentError is a type of StandardError, but Ruby uses the first matching "rescue" clause. So we never "quack" for an ArgumentError, but we only "bar" for it.

The "rescue" clause is like the "catch" clause in other languages. The "ensure" clause is like the "finally" clause in other languages.

# short way to rescue any StandardError
quotient = 1 / 0 rescue "sorry"

The short form "a rescue b" returns a, but if a raises a StandardError, then it returns b. (ZeroDivisionError is a subclass of StandardError.)

Catch and throw

Ruby has a separate exception-like system that is meant to be used to exit out of deep executions that are not errors.

def foo
throw :done
end
 
catch :done do
foo
end

With Ruby 1.8, you can only "throw" and "catch" symbols. With Ruby 1.9, you can throw and catch any object. Like exceptions, the throw can be made from a function defined elsewhere from the catch block.

[edit] Scala

Library: Scala

In Scala there is, thank heavens, no "checked exception" doctrine. Exceptions can be freely implemented, it's the skill of the programmer to use them right. This example is bad example of using exceptions, only to show that they can be used.

In there are 3 main entries: object CheckingAccount, CheckingBlockingAccount and NotImplementedErrorTest to selective start this solution and demonstrate the working of exceptions and handling.

//Defining exceptions
class AccountBlockException extends Exception
class InsufficientFundsException(val amount: Double) extends Exception
 
class CheckingAccount(number: Int, var blocked: Boolean = false, var balance: Double = 0.0) {
def deposit(amount: Double) { // Throwing an exception 1
if (blocked) throw new AccountBlockException
balance += amount
}
 
def withdraw(amount: Double) { // Throwing an exception 2
if (blocked) throw new AccountBlockException
if (amount <= balance) balance -= amount
else throw new InsufficientFundsException(amount - balance)
}
}
 
object CheckingAccount extends App {
 
class ExampleException1 extends Exception
 
val c = new CheckingAccount(101)
println("Depositing $500...")
try {
c.deposit(500.00)
println("\nWithdrawing $100...")
c.withdraw(100.00)
println("\nWithdrawing $600...")
c.withdraw(600.00)
} catch { // Exception handler
case ac: InsufficientFundsException => println(s"Sorry, but you are short ${'$'} ${ac.amount}")
case ac: AccountBlockException => println("Account blocked.")
 
///////////////////////////// An example of multiple exception handler ////////////////////////
case e@(_: ExampleException1 |
_: InterruptedException) => println(s"Out of memory or something else.")
 
case e: Exception => e.printStackTrace()
case _: Throwable => // Exception cached without any action
} finally println("Have a nice day")
}
 
object CheckingBlockingAccount extends App {
val c = new CheckingAccount(102, true)
println("Depositing $500...")
try {
c.deposit(500.00)
println("\nWithdrawing $100...")
c.withdraw(100.00)
println("\nWithdrawing $600...")
c.withdraw(600.00)
} catch { // Exception handler
case ac: InsufficientFundsException => println(s"Sorry, but you are short ${'$'} ${ac.amount}")
case ac: AccountBlockException => println("Account blocked.")
case e: Exception => e.printStackTrace()
case _: Throwable =>
} finally println("Have a nice day")
}
 
object NotImplementedErrorTest extends App {
??? // Throws scala.NotImplementedError: an implementation is missing
}
Output:
Running entry point CheckingAccount
Depositing $500...

Withdrawing $100...

Withdrawing $600...
Sorry, but you are short $ 200.0
Have a nice day
Output:
Running entry point CheckingBlockingAccount
Depositing $500...
Account blocked.
Have a nice day
Output:
Running entry point NotImplementedErrorTest
Exception in thread "main" scala.NotImplementedError: an implementation is missing
  at scala.Predef$.$qmark$qmark$qmark(Predef.scala:252)
  at NotImplementedErrorTest$delayedInit$body.apply(CheckingAccount.scala:53)
  .....

[edit] Scheme

Exception handling can be created with any language supporting continuations, using as few primitves as possible, exception handling in Scheme can look like this. (But anyone wishing to continue using exceptions will abstract them into macros).
(define (me-errors xx exception)
(if (even? xx)
xx
(exception)))
 
;example that does nothing special on exception
(call/cc
(lambda (exception)
(me-errors 222 exception)
(display "I guess everything is alright")))
 
;example that laments oddness on exception
(call/cc
(lambda (all-ok) ;used to "jump" over exception handling
 
(call/cc
(lambda (exception-handle)
(me-errors 333 exception-handle)
(display "I guess everything is alright")
(all-ok)))
 
(display "oh my god it is ODD!")))

[edit] Seed7

Raise an exception
const proc: foo is func
begin
raise RANGE_ERROR;
end func;

Handle an exception

const proc: main is func
begin
block
foo;
exception
catch RANGE_ERROR:
writeln("catched RANGE_ERROR");
end block;
end func;

[edit] Slate

Handling Exceptions

se@(SceneElement traits) doWithRestart: block
[
block handlingCases: {Abort -> [| :_ | ^ Nil]}
].

Define Exceptions

conditions define: #Abort &parents: {Restart}.
"An Abort is a Restart which exits the computation, unwinding the stack."
 
_@lobby abort
[
Abort signal
].
_@(Abort traits) describeOn: console
[
console ; 'Abort evaluation of expression\n'
].
 
"This will call:"
c@(Condition traits) signal
"Signalling a Condition."
[
c tryHandlers
].

Throwing Exceptions

Some lines in this example are too long (more than 80 characters). Please fix the code if it's possible and remove this message.
(fileName endsWith: '.image') ifTrue: [error: 'Image filename specified where Slate source expected. Make sure you run slate with the -i flag to specify an image.'].

[edit] Smalltalk

Throwing an Exception

"exec" "gst" "-f" "$0" "$0" "$*"
"exit"
 
Transcript show: 'Throwing yawp'; cr.
self error: 'Yawp!'.
$ ./yawp.st 
Throwing yawp
Object: nil error: Yawp!
Error(Exception)>>signal (AnsiExcept.st:216)
Error(Exception)>>signal: (AnsiExcept.st:226)
UndefinedObject(Object)>>error: (AnsiExcept.st:1565)
UndefinedObject>>executeStatements (yawp.st:5)

Handling an Exception

"exec" "gst" "-f" "$0" "$0" "$*"
"exit"
 
[
Transcript show: 'Throwing yawp'; cr.
self error: 'Yawp!'.
] on: Error do: [ :e |
Transcript show: 'Caught yawp'; cr.
].
$ ./yawp.st 
Throwing yawp
Caught yawp

[edit] Standard ML

Define Exceptions

exception MyException;
exception MyDataException of int; (* can be any first-class type, not just int *)

Throw Exceptions

fun f() = raise MyException;
fun g() = raise MyDataException 22;

Catch Exceptions

val x = f() handle MyException => 22;
val y = f() handle MyDataException x => x;

[edit] Tcl

package require Tcl 8.5
 
# Throw
proc e {args} {
error "error message" "error message for stack trace" {errorCode list}
}
 
# Catch and rethrow
proc f {} {
if {[catch {e 1 2 3 4} errMsg options] != 0} {
return -options $options $errMsg
}
}
 
f

This creates the stack trace

error message for stack trace
    (procedure "e" line 1)
    invoked from within
"e 1 2 3 4"
    (procedure "f" line 2)
    invoked from within
"f"

[edit] TXR

Here is a complicated exceptions example straight from the manual.

This is a deliberately convoluted way to process input consisting of lines which have the form:
{monkey | gorilla | human} <name>

Some custom exceptions are defined, and arranged into a hierarchy via @(defex) directives. An exception precedence hierarchy is established. A gorilla is a kind of ape, and an ape is a kind of primate. A monkey is a kind of primate, and so is a human.

In the main @(collect) clause, we have a try protect block in which we collect three different cases of primate. For each one, we throw an exception with the primate type symbol, and its name. This is caught in the catch clause as the argument "name". The catch clause performs another pattern match, @kind @name. This match is being applied to exactly the same line of data for which the exception was thrown (backtracking!). Therefore the @kind variable will collect the primate type. However @name already has a binding since it is the argument of the catch. Since it has a value already, that value has to match what is in the data. Of course, it does since it was derived from that data. The data and the variable unify against each other.

@(defex gorilla ape primate)
@(defex monkey primate)
@(defex human primate)
@(collect)
@(try)
@(cases)
gorilla @name
@(throw gorilla name)
@(or)
monkey @name
@(throw monkey name)
@(or)
human @name
@(throw human name)
@(end)@#cases
@(catch primate (name))
@kind @name
@(output)
we have a primate @name of kind @kind
@(end)@#output
@(end)@#try
@(end)@#collect

Sample interactive run. Here the input is typed into standard input from the tty. The output is interleaved with the input, since TXR doesn't reads ahead only as much data as it needs.

$ txr primates.txr -
[TTY]human Harry
[TTY]gorilla Gordon
[OUT]we have a primate Harry of kind human
[TTY]monkey Mike
[OUT]we have a primate Gordon of kind gorilla
[TTY][Ctrl-D/EOF]
[OUT]we have a primate Mike of kind monkey

[edit] Ursala

In this program fragment, a function named thrower returns the string 'success' if its argument is non-empty, but otherwise raises an exception with the diagnostic message 'epic fail'. (The diagnostic message can also be made to depend on the input.)

#import std
 
thrower = ~&?/'success'! -[epic fail]-!%
 
catcher = guard(thrower,---[someone failed]-)

If the exception is not caught, the program terminates immediately and the diagnostic is written to stderr. Alternatively, a calling function or any caller thereof can be defined to catch an exception as shown. The exception handler may inspect and arbitrarily modify the diagnostic message, but normal execution may not be resumed. In this example, the exception handler appends some additional verbiage to the message.

[edit] V

throwing exceptions

[myproc
['new error' 1 2 3] throw
'should not come here' puts
].

catching them

[myproc] [puts] catch
=[new error 1 2 3]

[edit] Visual Basic .NET

Defining exceptions

Class MyException 
Inherits Exception
'data with info about exception
End Class


Throw exceptions

Sub foo()
Throw New MyException
End Sub

Catching exceptions

Sub bar()
Try
foo()
Catch e As MyException When e.Data.Contains("Foo")
' handle exceptions of type MyException when the exception contains specific data
Catch e As MyException
' handle exceptions of type MyException and derived exceptions
Catch e As Exception
' handle any type of exception not handled by above catches
Finally
'code here occurs whether or not there was an exception
End Try
End Sub

[edit] Visual Basic for Applications

For historical reasons, Exceptions are called 'Errors' in VBA and VB Classic. VBA inherited several distinct exception handling models, which may be freely mixed and matched. The major limitations are that nested Try/Catch blocks must be constructed by the user, and that the User Defined Labels required for the Catch/Finally blocks may not be reused within a subroutine. For these reasons, it is conventional to only have only 1 Try/Catch block per subroutine.

Throw exceptions

Sub foo1()
err.raise(vbObjectError + 1050)
End Sub
 
Sub foo2()
Error vbObjectError + 1051
End Sub
 

Catching exceptions

Sub bar1()
'by convention, a simple handler
On Error Goto Catch
fooX
Exit Sub
Catch:
'handle all exceptions
Exit Sub
 
Sub bar2()
'a more complex handler, illustrating some of the flexibility of VBA exception handling
on error goto catch
100 fooX
200 fooY
'finally block may be placed anywhere: this is complexity for it's own sake:
goto finally
 
catch:
if erl= 100 then
' handle exception at first line: in this case, by ignoring it:
resume next
else
select case err.nummber
case vbObjectError + 1050
' handle exceptions of type 1050
case vbObjectError + 1051
' handle exceptions of type 1051
case else
' handle any type of exception not handled by above catches or line numbers
resume finally
 
finally:
'code here occurs whether or not there was an exception
'block may be placed anywhere
'by convention, often just a drop through to an Exit Sub, rather tnan a code block
Goto end_try:
 
end_try:
'by convention, often just a drop through from the catch block
exit sub

[edit] zkl

try{ throw(Exception.BadDay) }
catch { println(__exception," was thrown") }
println("OK");
Output:
BadDay(I'm having a bad day) was thrown
OK
Personal tools
Namespaces

Variants
Actions
Community
Explore
Misc
Toolbox