Exception handling syntax

Exception handling syntax

Exception handling syntax varies between programming languages to accommodate their overall syntax. Some languages don't call the concept exception handling or they may not have direct facilities for it, but they can still provide means for implementing it.

Catalogue of exception handling syntaxes

= Ada =

Exception declarations

Some_Error : exception;

Raising exceptions

raise Some_Error;

raise Some_Error with "Out of memory"; -- specific diagnostic message

Exception handling and propagation

with Ada.Exceptions, Ada.Text_IO;

procedure Foo is Some_Error : exception;begin Do_Something_Interesting;exception -- Start of exception handlers when Constraint_Error => ... -- Handle constraint error when Storage_Error => -- Propagate Storage_Error as a different exception with a useful message raise Some_Error with "Out of memory"; when Error : others => -- Handle all others Ada.Text_IO.Put("Exception: "); Ada.Text_IO.Put_Line(Ada.Exceptions.Exception_Name(Error)); Ada.Text_IO.Put_Line(Ada.Exceptions.Exception_Message(Error));end Foo;


ON ERROR GOTO handlerOPEN "Somefile.txt" FOR INPUT AS #1CLOSE #1PRINT "File opened successfully"END

handler:PRINT "File does not exist"END


The most common way to implement exception handling in standard Cis to use setjmp/longjmp functions:
#include enum { SOME_EXCEPTION = 1 };jmp_buf state;int main(){ int exception; if((exception = setjmp(state)) = 0) // try { if(/* something happened */) longjmp(state, SOME_EXCEPTION); // throw SOME_EXCEPTION } else switch(exception) { case SOME_EXCEPTION: // catch SOME_EXCEPTION puts("SOME_EXCEPTION caught"); break; default: // catch ... puts("Some strange exception"); } return 0;}

Some operating systems also have similar features, for example Microsoft Windows has "Structured Exception Handling" (SEH):int filterExpression (EXCEPTION_POINTERS* ep) { ++ep->ContextRecord->Eip; return EXCEPTION_CONTINUE_EXECUTION;}int main() { static int zero; __try { zero = 1/zero; printf ("Past the exception. "); } __except (filterExpression (GetExceptionInformation())) { printf ("Handler called. "); } return 0;}

* see also Vectored Exception Handling (VEH).

= C# =

public static void Main(){ try { // Code that could throw an exception } catch(System.Net.WebException exp) { // Process a WebException } catch(System.Exception) { // Process a System level CLR exception, that is not a System.Net.WebException, // since the exception has not been given an identifier it cannot be referenced } catch { // Process a non-CLR exception } finally { // (optional) code that will *always* execute


#include int main() { try { // do something (might throw an exception) } catch (const std::exception& e) { // handle exception e } catch (...) { // unknown exception, should not happen In C++, a resource acquisition is initialization technique can be used to clean up resources in exceptional situations.


import std.stdio; // for writefln()int main() { try { // do something that might throw an exception } catch (FooException e) { // handle exceptions of type FooException } catch (Object o) { // handle any other exceptions writefln("Unhandled exception: ", o); return 1; } return 0;}In D, a finally clause or the resource acquisition is initialization technique can be used to clean up resources in exceptional situations.


try try // Code which may raise an exception except on E:Exception do // Code to call when an exception is raised end;finally // Code which will be executed whether or not an exception is raised (e.g. clean-up code)end;

Fault Tolerant Shell

try for 30 minutes cd /tmp rm -f data forany host in xxx yyy zzz wget http://${host}/fresh.data -O data endend

= Haskell =

Haskell does not have special syntax for exception handling, because throwing an exception can be realized generically as a monad. However, the function catch can be used within the IO monad:

do { -- Statements in which errors might be thrown} `catch` ex -> do { -- Statements that execute in the event of an exception, with 'ex' bound to the exception}

In purely functional code, if only one error condition exists, the Maybe monad may be sufficient, and is an instance of Haskell's Monad class by default. More complex error propagation can be achieved using the Error or ErrorT monads, for which similar syntax (using `catch`) is supported.


try { // Normal execution path} catch (ExampleException ee) { // deal with the ExampleException} finally { // This optional section is executed upon termination of any of the try or catch blocks above}


try { // Statements in which exceptions might be thrown} catch(error) { // Statements that execute in the event of an exception} finally { // Statements that execute afterward either way}

Common Lisp

(ignore-errors (/ 1 0))

(handler-case (progn (print "enter an expression") (eval (read))) (error (e) (print e)))


Exception declarations

NSException *exception = [NSException exceptionWithName:@"myException" reason:@"whatever" userInfo:nil] ;

Raising exceptions

@throw exception;

Exception handling and propagation

@try { ...}@catch (SomeException *se) { // Handle a specific exception type. ...}@catch (NSException *ne) { // Handle general exceptions. ...

// Propagate the exception so that it's handled at a higher level. @throw;}@catch (id ue) { // Catch all thrown objects. ...}@finally { // Perform cleanup, whether an exception occurred or not. ...}


exception MyException of string * int (* exceptions can carry a value *)let _ = try raise (MyException ("not enough food", 2)); print_endline "Not reached" with
MyException (s, i) -> Printf.printf "MyException: %s, %d " s i
_ -> (* catch all exceptions *) print_endline "Unexpected exception"


The Perl mechanism for exception handling uses die to throw an exception when wrapped inside an eval { ... }; block. After the eval, the special variable $@ contains the value passed from die.

eval { # Code that could throw an exception (using 'die') open(FILE, $file) || die "Could not open file: $!"; while () { process_line($_); } close(FILE) || die "Could not close $file: $!";};if ($@) { # Handle exception here. The exception string is in $@}

Perl 5.005 added the ability to throw objects as well as strings. This allows for better introspection and handling of types of exceptions.

eval { open(FILE, $file) || die MyException::File->new($!); while () { process_line($_); } close(FILE) || die MyException::File->new($!);};if ($@) { # The exception object is in $@ if ($@->isa('MyException::File')) { # Handle file exception } else { # Generic exception handling # or re-throw with 'die $@'

The __DIE__ pseudo-signal can be trapped to handle calls to die. This is not suitable for exception handling since it is global. However it can be used to convert string-based exceptions from third-party packages into objects.

local $SIG{__DIE__} = sub { my $err = shift; if ($err->isa('MyException')) { die $err; # re-throw } else { # Otherwise construct a MyException with $err as a string die MyException::Default->new($err); ;

A number of modules in CPAN expand on the basic mechanism:
* Error provides a set of exception classes and allows use of the try/throw/catch/finally syntax.
* Exception::Class is a base class and class-maker for derived exception classes. It provides a full structured stack trace in $@->trace and $@->trace->as_string.
* Fatal overloads previously defined functions that return true/false e.g. open, close, read, write, etc. This allows built-in functions and others to be used as if they threw exceptions.


// Exception handling is only available in PHP versions 5 and greater.try{... // Code which might throw an exception}catch (FirstExceptionClass $exception) {... // Code which handles this exception} catch (SecondExceptionClass $exception) { // you get the idea what i mean ;)}(php5powerprogramming: ISBN 0-13-147149-X, page 77)


Exception handling is available in PowerBuilder versions 8.0 and above.

TRY // Normal execution pathCATCH (ExampleException ee) // deal with the ExampleExceptionFINALLY // This optional section is executed upon termination of any of the try or catch blocks aboveEND TRY


f = Nonetry: f = file("aFileName") f.write(could_make_error())except IOError: print "Unable to open file"except: # catch all exceptions print "Unexpected error"else: # executed if no exceptions are raised print "File write completed successfully"finally: # clean-up actions, always executed if f: f.close()


REBOL [ Title: "Exception and error handling examples"]

; TRY a block; capturing an error! and converting to object!if error? exception: try [1 / 0] [probe disarm exception]

; ATTEMPT results in the value of the block or the value none on errorprint attempt [divide 1 0]

; User generated exceptions can be any datatype!example: func ["A function to throw an exception"] [ throw "I'm a string! exception"] catch [example]

; User generated exceptions can also be named,; and functions can include additional run time attributes sophisticated: func ["A function to throw a named error exception" [catch] [ throw/name make error! "I'm an error! exception" 'moniker] catch/name [sophisticated] 'moniker


begin # Do something nifty raise SomeError, "This is the error message!" # Uh-oh!rescue SomeError # This is executed when a SomeError exception # is raisedrescue AnotherError => error # Here, the exception object is referenced from the # `error' variableelse # This is executed only if no exceptions were raisedensure # This is always executed, exception or notend


try { % code that might throw an exception } catch SomeError: { % code that handles this exception } catch SomeOtherError: { % code that handles this exception } finally % optional block { % This code will always get executed }

New exceptions may be created using the new_exception function, e.g., new_exception ("MyIOError", IOError, "My I/O Error");will create an exception called MyIOError as a subclass of IOError.Exceptions may be generated using the throw statement, which can throwarbitrary S-Lang objects.

Visual Basic .NET

Try ' Do SomethingCatch ex As Exception When condition ' Handle Exception when a specific condition is trueCatch ex As Exception ' Handle ExceptionFinally ' Cleanup, close connections etc ' NB this code is always executed regardless of if an Exception was raised or not!End Try

Windows PowerShell

trap [Exception] { // Statements that execute in the event of an exception}// Statements in which exceptions might be thrown

ee also

*Exception handling for the semantics of exception handling
*Syntax for definition of syntax in computer science

Wikimedia Foundation. 2010.

Look at other dictionaries:

  • Exception handling — is a programming language construct or computer hardware mechanism designed to handle the occurrence of exceptions, special conditions that change the normal flow of program execution. Programming languages differ considerably in their support… …   Wikipedia

  • Microsoft-specific exception handling mechanisms — Microsoft Windows OS family employs some exception handling mechanisms that are based on the operation system specifics. Contents 1 Structured Exception Handling 1.1 Usage 1.2 Implementation 1.3 …   Wikipedia

  • C Sharp syntax — The correct title of this article is C# syntax. The substitution or omission of the # sign is because of technical restrictions. Main article: C Sharp (programming language) This article describes the syntax of the C# programming language. The… …   Wikipedia

  • JavaScript syntax — This article is part of the JavaScript series. JavaScript JavaScript syntax JavaScript topics This box: view · …   Wikipedia

  • Python syntax and semantics — The syntax of the Python programming language is the set of rules that defines how a Python program will be written and interpreted (by both the runtime system and by human readers). Python was designed to be a highly readable language. It aims… …   Wikipedia

  • PHP syntax and semantics — The syntax of the PHP programming language is the set of rules that defines how a PHP program will be written and interpreted. Overview PHP only parses code within its delimiters. Anything outside its delimiters is sent directly to the output and …   Wikipedia

  • Java-Syntax — Duke, das Java Maskottchen Die Syntax der Programmiersprache Java ist in der Java Language Specification definiert, ebenso wie die Semantik von Java. Dieser Artikel gibt einen Überblick über die Java Syntax und stellt einige ihrer Besonderheiten… …   Deutsch Wikipedia

  • C syntax — The syntax of the C programming language is a set of rules that specifies whether the sequence of characters in a file is conforming C source code. The rules specify how the character sequences are to be chunked into tokens (the lexical grammar) …   Wikipedia

  • Comparison of programming languages (basic instructions) — Programming language comparisons General comparison Basic syntax Basic instructions Arrays Associative arrays String operations …   Wikipedia

  • ColdFusion — This article is about the computer programming language. For other uses, see Cold Fusion (disambiguation). Adobe ColdFusion Original author(s) Jeremy and JJ Allaire Developer(s) …   Wikipedia

Share the article and excerpts

Direct link
Do a right-click on the link above
and select “Copy Link”

We are using cookies for the best presentation of our site. Continuing to use this site, you agree with this.