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[ with "Out of memory" ];

Exception handling and propagation

with Ada.Exceptions; use Ada.Exceptions; 

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

BASIC

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

handler:
PRINT "File does not exist"
END

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
   }
}

C++

#include <exception>
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.

D

 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.

Java

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
}

Ruby

begin
  # Do something nifty
  raise SomeError, "This is the error message!"  # Uh-oh!
rescue SomeError
  # This is executed when a SomeError exception
  # is raised
rescue AnotherError => error
  # Here, the exception object is referenced from the
  # `error' variable
else
  # This is executed only if no exceptions were raised
ensure
  # This is always executed, exception or not
end

Python

try:
   f = file("aFileName")
except IOError:
   print "Unable to open file"
except:  # catch all exceptions
   print "Unexpected error"
else:    # no exception was raised
   try:
       f.write(could_make_error())
   finally:  # clean-up actions
       f.close()

OCaml

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\n" s i
  | _ ->  (* catch all exceptions *)
      print_endline "Unexpected exception"

C

The most common way to implement exception handling in standard C is to use setjmp/longjmp functions:

#include <setjmp.h>
#include <stdio.h>
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.\n");
   } __except (filterExpression (GetExceptionInformation())) {
       printf ("Handler called.\n");
   }
   return 0;
}

see also Vector Exception Handling (VEH).

Perl

eval {
    # Code that could throw an exception
}
if($@){
    # Handle exception here. (The exception object is in $@)
}

PHP

// Exception handling is only available in PHP versions 5 and greater.

== try ==

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)

Delphi

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 data
     end
end