View source for Exception handling syntax

{{Short description|Keywords provided by a programming language}}
{{Cleanup bare URLs|date=August 2022}}
'''Exception handling syntax''' is the set of keywords and/or structures provided by a computer [[programming language]] to allow [[exception handling (programming)|exception handling]], which separates the handling of errors that arise during a program's operation from its ordinary processes. Syntax for exception handling varies between [[programming language]]s, partly to cover semantic differences but largely to fit into each language's overall [[syntax#Syntax in computer science|syntactic structure]]. Some languages do not call the relevant concept "[[exception handling]]"; others may not have direct facilities for it, but can still provide means to implement it.

Most commonly, error handling uses a <code>try...[catch...][finally...]</code> block, and errors are created via a <code>throw</code> statement, but there is significant variation in naming and syntax.

== Catalogue of exception handling syntaxes ==

=== Ada ===
{{Further|Ada (programming language)}}
{{Wikibooks|Ada Programming|Exceptions}}

; Exception declarations
<syntaxhighlight lang="ada">
Some_Error : exception;
</syntaxhighlight>

; Raising exceptions
<syntaxhighlight lang="ada">
raise Some_Error;

raise Some_Error with "Out of memory"; -- specific diagnostic message
</syntaxhighlight>

; Exception handling and propagation
<syntaxhighlight lang="ada">
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;
</syntaxhighlight>

=== Assembly language ===
{{Further|Assembly language}}
Most assembly languages will have a macro instruction or an interrupt address available for the particular system to intercept events such as illegal op codes, program check, data errors, overflow, [[divide by zero]], and other such. IBM and Univac mainframes had the [[STXIT]] macro. [[Digital Equipment Corporation]] [[RT11]] systems had trap vectors for program errors, i/o interrupts, and such. [[DOS]] has certain interrupt addresses. [[Microsoft Windows]] has specific module calls to trap program errors.

=== ATS ===
{{Further|ATS (programming language)}}

<syntaxhighlight lang="ocaml">
exception MyException of (string, int) (* exceptions can carry a value *)

implement main0 (): void =
	try $raise MyException("not enough food", 2) with
	| ~MyException(s, i) => begin
			$extfcall(void, "fprintf", stderr_ref, "%s: %d", s, i);
			fileref_close(stderr_ref);
		end
</syntaxhighlight>

=== Bash ===
{{Further|Bash (Unix shell)}}

<syntaxhighlight lang="bash">
#!/usr/bin/env bash
#set -e provides another error mechanism
print_error(){
	echo "there was an error"
}
trap print_error exit #list signals to trap
tempfile=`mktemp`
trap "rm $tempfile" exit
./other.sh || echo warning: other failed
echo oops)
echo never printed
</syntaxhighlight>

One can set a trap for multiple errors, responding to any signal with syntax like:

: {{code|2=bash|trap 'echo Error at line ${LINENO}' ERR}}

=== BASIC ===
{{Further|BASIC}}
An ''On Error goto/gosub'' structure is used in BASIC and is quite different from modern exception handling; in BASIC there is only one global handler whereas in modern exception handling, exception handlers are stacked.

<syntaxhighlight lang="qbasic">
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  ' RESUME may be used instead which returns control to original position.
</syntaxhighlight>

=== C ===
{{Further|C (programming language)}}
C does not provide direct support to exception handling: it is the programmer's responsibility to prevent errors in the first place and test return values from the functions.

In any case, a possible way to implement exception handling in standard C is to use [[setjmp.h|setjmp/longjmp]] functions:
<syntaxhighlight lang="c">
#include <setjmp.h>
#include <stdio.h>
#include <stdlib.h>

enum { SOME_EXCEPTION = 1 } exception;
jmp_buf state;

int main(void)
{
  if (!setjmp(state))                      // try
  {
    if (/* something happened */)
    {
      exception = SOME_EXCEPTION;
      longjmp(state, 0);                  // throw SOME_EXCEPTION
    }
  } 
  else switch(exception)
  {             
    case SOME_EXCEPTION:                  // catch SOME_EXCEPTION
      puts("SOME_EXCEPTION caught");
      break;
    default:                              // catch ...
      puts("Some strange exception");
  }
  return EXIT_SUCCESS;
}
</syntaxhighlight>

==== Microsoft-specific ====
{{Further|Microsoft-specific exception handling mechanisms}}
Two types exist:
* Structured Exception Handling (SEH)
* Vectored Exception Handling (VEH, introduced in [[Windows XP]])
Example of SEH in C programming language:
<syntaxhighlight lang="c">
int filterExpression (EXCEPTION_POINTERS* ep) {
   ep->ContextRecord->Eip += 8; // divide instruction may be encoded from 2 to 8 bytes
   return EXCEPTION_CONTINUE_EXECUTION;
}
int main(void) {
   static int zero;
   __try {
       zero = 1/zero;
       __asm {
         nop
         nop
         nop
         nop
         nop
         nop
         nop
       }
       printf ("Past the exception.\n");
   } __except (filterExpression (GetExceptionInformation())) {
       printf ("Handler called.\n");
   }
   return 0;
}
</syntaxhighlight>

=== C# ===
{{Further|C Sharp (programming language)}}
A <code>try</code> block must have at least one <code>catch</code> or <code>finally</code> clause and at most one <code>finally</code> clause.
<syntaxhighlight lang="csharp">
public static void Main()
{
    try
    {
        // Code that could throw an exception.
    }
    catch (HttpException ex)
    {
        // Handles a HttpException. The exception object is stored in "ex".
    }
    catch (Exception)
    {
        // Handles any CLR exception that is not a HttpException.
        // Since the exception has not been given an identifier, it cannot be referenced.
    }
    catch
    {
        // Handles anything that might be thrown, including non-CLR exceptions.
    }
    finally
    {
        // Always run when leaving the try block (including catch clauses), regardless of whether any exceptions were thrown or whether they were handled.
        // Often used to clean up and close resources such a file handles.
        // May not be run when Environment.FailFast() is called and in other system-wide exceptional conditions (e.g. power loss), or when the process crashes due to an exception in another thread.
    }
}
</syntaxhighlight>

=== C++ ===
{{Further|C++}}
<syntaxhighlight lang="cpp">
import std;

int main() {
    try {
        // do something (might throw an exception)
    } catch (const std::exception& e) {
        // handle exception e
    } catch (...) {
        // catches all exceptions, not already caught by a catch block before
        // can be used to catch exception of unknown or irrelevant type
    }
}
</syntaxhighlight>
In C++, a ''[[Resource Acquisition Is Initialization|resource acquisition is initialization]]'' technique can be used to clean up resources in exceptional situations. C++ intentionally does not support {{Cpp|finally}}.<ref>[http://www.stroustrup.com/bs_faq2.html#finally Bjarne Stroustrup's FAQ]</ref> The outer braces for the method are optional.

=== ColdFusion Markup Language (CFML) ===
{{Further|ColdFusion Markup Language}}

==== Script syntax ====
<syntaxhighlight lang="javascript">
<cfscript>
try {
	//throw CF9+
	throw(type="TypeOfException", message="Oops", detail="xyz");
	// alternate throw syntax:
	throw "Oops"; // this equivalent to the "message" value in the above example
} catch (any e) {
	writeOutput("Error: " & e.message);
	rethrow; //CF9+
} finally { //CF9+
	writeOutput("I run even if no error");
}
</cfscript>
</syntaxhighlight>

Adobe ColdFusion documentation<ref>{{Cite web |url=https://learn.adobe.com/wiki/display/coldfusionen/Handling+exceptions |title=Handling exceptions |access-date=2014-01-01 |archive-url=https://web.archive.org/web/20140102193946/https://learn.adobe.com/wiki/display/coldfusionen/Handling+exceptions |archive-date=2014-01-02 |url-status=dead }}</ref>

==== Tag syntax ====
<syntaxhighlight lang="cfm">
<cftry> 
    code that may cause an exception 
    <cfcatch ...> 
        <cftry> 
            First level of exception handling code 
            <cfcatch ...> 
                Second level of exception handling code 
            </cfcatch>
            <cffinally> 
                    final code    
             </cffinally> 
        </cftry> 
    </cfcatch> 
</cftry>
</syntaxhighlight>
Adobe ColdFusion documentation<ref>{{Cite web |url=https://learn.adobe.com/wiki/display/coldfusionen/Exception+handling+tags |title=Exception handling tags |access-date=2014-01-01 |archive-url=https://web.archive.org/web/20140102192259/https://learn.adobe.com/wiki/display/coldfusionen/Exception+handling+tags |archive-date=2014-01-02 |url-status=dead }}</ref>

==== Railo-Lucee specific syntax ====
{{Further|Railo|Lucee}}
Added to the standard syntax above, CFML dialects of [[Railo]] and [[Lucee]] allow a <code>retry</code> statement.<ref>https://issues.jboss.org/browse/RAILO-2176 # JBoss Community issue tracker ticket for adding <code>retry</code></ref>

This statement returns processing to the start of the prior <code>try</code> block.

CFScript example:
<syntaxhighlight lang="javascript">
try {
	// code which could result in an exception
} catch (any e){
	retry;
}
</syntaxhighlight>

Tag-syntax example:
<syntaxhighlight lang="cfm">
<cftry>

	<!--- code which could result in an exception --->

	<cfcatch>
		<cfretry>
	</cfcatch>
</cftry>
</syntaxhighlight>

=== D ===
{{Further|D (programming language)}}
<syntaxhighlight lang="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;
}
</syntaxhighlight>
In D, a {{D-lang|finally}} clause or the [[Resource Acquisition Is Initialization|resource acquisition is initialization]] technique can be used to clean up resources in exceptional situations.

=== Delphi ===
{{Further|Delphi (programming language)}}
; Exception declarations
<syntaxhighlight lang="delphi">
type ECustom = class(Exception) // Exceptions are children of the class Exception.
  private
    FCustomData: SomeType;      // Exceptions may have custom extensions.
  public
    constructor CreateCustom(Data: SomeType); // Needs an implementation
    property CustomData: SomeType read FCustomData;
  end;
</syntaxhighlight>

; Raising exceptions
<syntaxhighlight lang="delphi">
raise Exception.Create('Message');

raise Exception.CreateFmt('Message with values: %d, %d',[value1, value2]); // See SysUtils.Format() for parameters.

raise ECustom.CreateCustom(X);
</syntaxhighlight>

; Exception handling and propagation<ref>Borland, Delphi Version 7.0, Online help</ref>
<syntaxhighlight lang="delphi">
try // For finally.
  try // For except.
    ... // Code that may raise an exception.
  except
    on C:ECustom do
      begin
        ... // Handle ECustom.
        ... if Predicate(C.CustomData) then ...
      end;
    on S:ESomeOtherException do
      begin
        // Propagate as an other exception.
        raise EYetAnotherException.Create(S.Message); 
      end;
    on E:Exception do
      begin
        ... // Handle other exceptions.
        raise; // Propagate.
      end;
  end; 
finally
  // Code to execute whether or not an exception is raised (e.g., clean-up code).
end;
</syntaxhighlight>

=== Erlang ===
{{Further|Erlang (programming language)}}
<syntaxhighlight lang="erlang">
try
  % some dangerous code
catch
  throw:{someError, X} -> ok;    % handle an exception
  error:X -> ok;                 % handle another exception
  _:_ -> ok                      % handle all exceptions
after
  % clean up
end
</syntaxhighlight>

=== F# ===
{{Further|F_Sharp_(programming_language)}}
In addition to the OCaml-based <code>try...with</code>, F# also has the separate <code>try...finally</code> construct, which has the same behavior as a try block with a <code>finally</code> clause in other .NET languages.

For comparison, this is a translation of [[#C#|the C# sample above]].
<syntaxhighlight lang="fsharp">
try
    try
        () (* Code that could throw an exception. *)
    with
    | :? System.Net.WebException as ex -> () (* Handles a WebException. The exception object is stored in "ex". *)
    | :? exn -> () (* Handles any CLR exception. Since the exception has not been given an identifier, it cannot be referenced. *)
    | _ -> () (* Handles anything that might be thrown, including non-CLR exceptions. *)
finally
    () 
    (*
       Always run when leaving the try block, regardless of whether any exceptions were thrown or whether they were handled.
       Often used to clean up and close resources such a file handles.
       May not be run when Environment.FailFast() is called and in other system-wide exceptional conditions (e.g. power loss), or when the process crashes due to an exception in another thread.
    *)
</syntaxhighlight>

For comparison, this is translation of [[#OCaml|the OCaml sample below]].
<syntaxhighlight lang="fsharp">
exception MyException of string * int (* exceptions can carry a value *)
let _ =
  try
    raise (MyException ("not enough food", 2));
    printfn "Not reached"
  with
  | MyException (s, i) -> 
      printf "MyException: %s, %d\n" s i
  | e ->  (* catch all exceptions *)
     eprintf "Unexpected exception : %O" e;
     eprintf "%O" e.StackTrace
</syntaxhighlight>

=== Haskell ===
{{Further|Haskell (programming language)}}
Haskell does not have special syntax for exceptions. Instead, a {{Haskell|try}}/{{Haskell|catch}}/{{Haskell|finally}}/{{Haskell|etc}}. interface is provided by functions.

<syntaxhighlight lang="haskell">
import Prelude hiding(catch)
import Control.Exception
instance Exception Int
instance Exception Double
main = do
  catch
    (catch
      (throw (42::Int))
      (\e-> print (0,e::Double)))
    (\e-> print (1,e::Int))
</syntaxhighlight>

prints

 (1,42)

in analogy with this C++

<syntaxhighlight lang="cpp">
import std;

int main() {
    try {
        throw static_cast<int>(42);
    } catch(double e) {
        std::println("(0,{})", e);
    } catch(int e) {
        std::println("(1,{})", e);
    }
}
</syntaxhighlight>

Another example is

<syntaxhighlight lang="haskell">
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
}
</syntaxhighlight>

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

=== Java ===
{{Further|Java (programming language)}}
{{Wikibooks|Java Programming|Exceptions}}
A <code>try</code> block must have at least one <code>catch</code> or <code>finally</code> clause and at most one <code>finally</code> clause.
<syntaxhighlight lang="java">
try {
    // Normal execution path.
    throw new EmptyStackException();
} catch (ExampleException ee) {
    // Deal with the ExampleException.
} finally {
    // Always run when leaving the try block (including finally clauses), regardless of whether any exceptions were thrown or whether they were handled.
    // Cleans up and closes resources acquired in the try block.
    // May not be run when System.exit() is called and in other system-wide exceptional conditions (e.g. power loss).
    // Rarely used after try-with-resources was added to the language (see below).
}
</syntaxhighlight>
If multiple resources are acquired, the correct way to deal with them is with nested try blocks.<ref>Bloch, Joshua (2018). ''Effective Java, Third Edition''. Addison-Wesley. Item 9, p. 54. {{ISBN|978-0-13-468599-1}}</ref> For this reason and others, ''try-with-resources'' was added to the language to almost entirely replace finally clauses. Resources acquired in a parentheses after the try keyword will be cleaned up automatically. Classes used in these statements must implement an interface called AutoCloseable.<ref>{{cite web | url=https://docs.oracle.com/javase/tutorial/essential/exceptions/tryResourceClose.html | title=The try-with-resources Statement (The Java™ Tutorials > Essential Java Classes > Exceptions) }}</ref>
<syntaxhighlight lang="java">
try (FileReader fr = new FileReader(path); 
     BufferedReader br = new BufferedReader(fr)) {
    // Normal execution path.
} catch (IOException ioe) { 
    // Deal with exception.
}   // Resources in the try statement are automatically closed afterwards.
finally {
    // A finally clause can be included, and will run after the resources in the try statements are closed.
}
</syntaxhighlight>

=== JavaScript ===
{{Further|JavaScript}}
The design of JavaScript makes loud/hard errors very uncommon. [[Soft error|Soft/quiet errors]] are much more prevalent. Hard errors propagate to the nearest <code>try</code> statement, which must be followed by either a single <code>catch</code> clause, a single <code>finally</code> clause, or both.
<syntaxhighlight lang="javascript">
try {
  // Statements in which exceptions might be thrown
  throw new Error("error");
} catch (error) {
  // Statements that execute in the event of an exception
} finally {
  // Statements that execute afterward either way
}
</syntaxhighlight>

If there is no <code>try</code> statement at all, then the webpage does not crash. Rather, an error is logged to the console and the stack is cleared. However, JavaScript has the interesting quirk of asynchronous externally-invoked entry points. Whereas, in most other languages, there is always some part of the code running at all times, JavaScript does not have to run linearly from start to end. For example, event listeners, Promises, and timers can be invoked by the browser at a later point in time and run in an isolated but shared context with the rest of the code. Observe how the code below will throw a new error every 4 seconds for an indefinite period of time or until the browser/tab/computer is closed.
<syntaxhighlight lang="javascript">
setInterval(function() {
  throw new Error("Example of an error thrown on a 4 second interval.");
}, 4000);
</syntaxhighlight>

Another interesting quirk is polymorphism: JavaScript can throw primitive values as errors.
<syntaxhighlight lang="javascript">
try {
  throw 12345; // primitive number
} catch (error) {
  console.log(error); // logs 12345 as a primitive number to the console
}
</syntaxhighlight>

Note that the <code>catch</code> clause is a catch-all, which catches every type of error. There is no syntaxical ability to assign different handlers to different error types aside from experimental and presently removed Gecko extensions from many years ago. Instead, one can either propagate the error by using a <code>throw</code> statement inside the <code>catch</code> statement, or use multiple conditional cases. Let us compare an example in Java and its rough equivalents in JavaScript.
<syntaxhighlight lang="java">
// Example in Java
try {
    Integer i = null;
    i.intValue(); // throws a NullPointerException
} catch (NullPointerException error) {
    // Variable might be null
} catch (ArithmeticException error) {
    // Handle problems with numbers
}
</syntaxhighlight>
<syntaxhighlight lang="javascript">
// Approximation #1 in JavaScript
try {
  // Statements in which exceptions might be thrown
  var example = null;
  example.toString();
} catch (error) {
  if (error.type === "TypeError") {
    // Variable might be null
  } else if (error.type === "RangeError") {
    // Handle problems with numbers
  }
}
</syntaxhighlight>
<syntaxhighlight lang="javascript">
// Approximation #2 in JavaScript
try {
  try {
    // Statements in which exceptions might be thrown
    var example = null;
    example.toString();
  } catch (error) {
    if (error.type !== "TypeError") throw error;
    // Variable might be null
  }
} catch (error) {
  if (error.type !== "RangeError") throw error;
  // Handle problems with numbers
}
</syntaxhighlight>

Another aspect of exceptions are promises, which handle the exception asynchronously. Handling the exception asynchronously has the benefit that errors inside the error handler do not propagate further outwards.
<syntaxhighlight lang="javascript">
new Promise(function() {
	throw new Error("Example error!");
}).catch(function(err) {
	console.log("Caught ", err);
});
</syntaxhighlight>
Also observe how event handlers can tie into promises as well.
<syntaxhighlight lang="javascript">
addEventListener("unhandledrejection", function(event) {
  console.log(event.reason);
  event.preventDefault(); //prevent logging the error via console.error to the console--the default behavior
});

new Promise(function() {
  throw new Error("Example error!");
});
</syntaxhighlight>

Lastly, note that, as JavaScript uses mark-and-sweep garbage-collection, there is never any memory leakage from throw statements because the browser automatically cleans dead objects&mdash;even with circular references.
<syntaxhighlight lang="javascript">
try {
  // Statements in which exceptions might be thrown
  const obj = {};
  obj.selfPropExample = obj; // circular reference
  throw obj;
} catch (error) {
  // Statements that execute in the event of an exception
}
</syntaxhighlight>

=== Kotlin ===
{{Further|Kotlin (programming language)}}
<syntaxhighlight lang="kotlin">
try {
    // Code that may throw an exception
} catch (e: SomeException) {
    // Code for handling the exception
}
</syntaxhighlight>

=== Lisp ===
{{Further|Lisp (programming language)}}

==== Common Lisp ====
{{Further|Common Lisp}}
<syntaxhighlight lang="lisp">
(ignore-errors (/ 1 0))

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

(unwind-protect
    (progn
       (print "enter an expression")
       (eval (read)))
  (print "This print will always be executed, similar to finally."))
</syntaxhighlight>

=== Lua ===
{{Further|Lua (programming language)}}
Lua uses the <code>pcall</code> and <code>xpcall</code> functions, with <code>xpcall</code> taking a function to act as a <code>catch</code> block.
; Predefined function
<syntaxhighlight lang="lua">
function foo(x)
  if x then 
    return x
  else
    error "Not a true value"
  end
end

function attempt(arg)
  success, value = pcall(foo, arg)

  if not success then 
    print("Error: " .. tostring(value))
  else
    print("Returned: " .. tostring(value))
  end
end

attempt("hello")
  -- Returned: hello

attempt(nil)
  -- Error: stdin:5: Not a true value

attempt({})
  -- Returned: table: 00809308
    
if foo(42) then print "Success" end
  -- Success

</syntaxhighlight>
; Anonymous function
<syntaxhighlight lang="lua">
if pcall(
  function()
    -- Do something that might throw an error.
  end) 
then
  print "No errors"  -- Executed if the protected call was successful.
else
  print "Error encountered"  -- Executed if the protected call failed.
end

print "Done"  -- Will always be executed
</syntaxhighlight>

=== Next Generation Shell ===
{{Further|Next Generation Shell}}

; Defining custom exception type
<syntaxhighlight lang="ps1">
type MyError(Error)
</syntaxhighlight>

; Raising exceptions
<syntaxhighlight lang="ps1">
throw MyError("this happened")
</syntaxhighlight>

; Exception handling and propagation
<syntaxhighlight lang="ps1">
try {
  # something
} catch(e:MyError) {
  guard e.val = 7
  # ...
} catch(e:MyError) {
  # ...
} catch(e:Error) {
  # ...
}
</syntaxhighlight>

; Ignoring exceptions - try without catch
<syntaxhighlight lang="ps1">
try 1/0  # evaluates to null
</syntaxhighlight>

; Ignoring exceptions - "tor" operator
"tor" is try-or operator. In case of any exception when evaluating the argument on the left, evaluates to the argument on the right.
<syntaxhighlight lang="ps1">
1/0 tor 20  # evaluates to 20
</syntaxhighlight>

; "block" - facility to use exceptions to return a value
<syntaxhighlight lang="ps1">
my_result = block my_block {  # "block" catches exception thrown by return below
  # do calculation
  if calculation_finished() {
    my_block.return(42)  # throws exception
  }
}
</syntaxhighlight>

=== Objective-C ===
{{Further|Objective-C}}
; Exception declarations
<syntaxhighlight lang="objc">
NSException *exception = [NSException exceptionWithName:@"myException"
                           reason:@"yourReason"  userInfo:nil];
</syntaxhighlight>

; Raising exceptions
<syntaxhighlight lang="objc">
@throw exception;
</syntaxhighlight>

; Exception handling and propagation
<syntaxhighlight lang="objc">
@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.
    ...
}
</syntaxhighlight>

=== OCaml ===
{{Further|OCaml}}
<syntaxhighlight lang="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
  | e ->  (* catch all exceptions *)
     Printf.eprintf "Unexpected exception : %s" (Printexc.to_string e);
     (*If using Ocaml >= 3.11, it is possible to also print a backtrace: *)
     Printexc.print_backtrace stderr;
       (* Needs to beforehand enable backtrace recording with
           Printexc.record_backtrace true
         or by setting the environment variable OCAMLRUNPARAM="b1"*)
</syntaxhighlight>

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

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

<syntaxhighlight lang="perl">
eval {
    open(FILE, $file) || die MyException::File->new($!);
    while (<FILE>) {
        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 $@'
    }
}
</syntaxhighlight>

The {{Perl2|__DIE__}} pseudo-signal can be trapped to handle calls to {{Perl2|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.

<syntaxhighlight lang="perl">
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);
    }
};
</syntaxhighlight>

The forms shown above can sometimes fail if the global variable {{Perl2|$@}} is changed between when the exception is thrown and when it is checked in the {{Perl2|if ($@)}} statement. This can happen in multi-threaded environments, or even in single-threaded environments when other code (typically
called in the destruction of some object) resets the global variable before the checking code.
The following example shows a way to avoid this problem (see [https://archive.today/20130415214802/http://www.perlfoundation.org/perl5/index.cgi?exception_handling] or [https://stackoverflow.com/a/10343025];  ''cf''. [http://mvp.kablamo.org/essentials/die-eval/]). But at the cost of not being able to use return values:

<syntaxhighlight lang="perl">
eval {
    # Code that could throw an exception (using 'die') but does NOT use the return statement;
    1;
} or do {
    # Handle exception here. The exception string is in $@
};
</syntaxhighlight>

Several modules in the Comprehensive Perl Archive Network ([[CPAN]]) expand on the basic mechanism:
* {{Perl2|Error}} provides a set of exception classes and allows use of the try/throw/catch/finally syntax.
* {{Perl2|TryCatch}}, {{Perl2|Try::Tiny}} and {{Perl2|Nice::Try}} all allow the use of try/catch/finally syntax instead of boilerplate to handle exceptions correctly.
* {{Perl2|Exception::Class}} is a base class and class-maker for derived exception classes. It provides a full structured [[stack trace]] in {{Perl2|$@->trace}} and {{Perl2|$@->trace->as_string}}.
* {{Perl2|Fatal}} overloads previously defined functions that return true/false e.g., {{Perl2|open}}, {{Perl2|close}}, {{Perl2|read}}, {{Perl2|write}}, etc. This allows built-in functions and others to be used as if they threw exceptions.

=== PHP ===
{{Further|PHP}}
<syntaxhighlight lang="php">
// Exception handling is only available in PHP versions 5 and greater.
try {
    // Code that might throw an exception
    throw new Exception('Invalid URL.');
} catch (FirstExceptionClass $exception) {
    // Code that handles this exception
} catch (SecondExceptionClass $exception) {
    // Code that handles a different exception
} finally {
    // Perform cleanup, whether an exception occurred or not.
}
</syntaxhighlight>

=== PowerBuilder ===
{{Further|PowerBuilder}}
Exception handling is available in PowerBuilder versions 8.0 and above.

<pre>
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
END TRY
</pre>

=== PowerShell ===
{{Further|PowerShell}}

==== Version 1.0 ====
<syntaxhighlight lang="powershell">
trap [Exception]
{
    # Statements that execute in the event of an exception
}
# Statements in which exceptions might be thrown
</syntaxhighlight>

==== Version 2.0 ====
<syntaxhighlight lang="powershell">
Try {
    Import-Module ActiveDirectory
    }
Catch [Exception1] {
  # Statements that execute in the event of an exception, matching the exception
    }
Catch [Exception2],[Exception3etc] {
  # Statements that execute in the event of an exception, matching any of the exceptions
    }
Catch {
  # Statements that execute in the event of an exception, not handled more specifically
    }
</syntaxhighlight>

=== Python ===
{{Further|Python (programming language)}}
<syntaxhighlight lang="python">
f = None
try:
    f = open("aFileName", "w")
    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()
</syntaxhighlight>

=== R ===
{{Further|R (programming language)}}
<syntaxhighlight lang="splus">
tryCatch({
   stop("Here an error is signaled")   # default S3-class is simpleError a subclass of error
   cat("This and the following lines are not executed because the error is trapped before\n")
   stop( structure(simpleError("mySpecialError message"),class=c("specialError","error","condition")) )
}
,specialError=function(e){
    cat("catches errors of class specialError\n")
}
,error=function(e){
    cat("catches the default error\n")
}
,finally={ cat("do some cleanup (e.g., setwd)\n") }
)
</syntaxhighlight>

=== Rebol ===
{{Further|Rebol}}
<syntaxhighlight lang="rebol">
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 error
print 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
</syntaxhighlight>

=== Rexx ===
{{Further|Rexx}}
<syntaxhighlight lang="rexx">
 signal on halt;
 do a = 1
	 say a
	 do 100000 /* a delay */
	 end
 end
 halt:
 say "The program was stopped by the user"
 exit
</syntaxhighlight>

=== Ruby ===
{{Further|Ruby (programming language)}}
<syntaxhighlight lang="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
rescue
  # This catches all exceptions derived from StandardError
  retry # This executes the begin section again
else
  # This is executed only if no exceptions were raised
ensure
  # This is always executed, exception or not
end
</syntaxhighlight>

=== S-Lang ===
{{Further|S-Lang}}

  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 {{S-Lang|new_exception}} function, e.g., 
  new_exception ("MyIOError", IOError, "My I/O Error");
will create an exception called {{S-Lang|MyIOError}} as a subclass of {{S-Lang|IOError}}. Exceptions may be generated using the throw statement, which can throw arbitrary [[S-Lang]] objects.

=== Smalltalk ===
{{Further|Smalltalk}}
<syntaxhighlight lang="smalltalk">
  [ "code that might throw an exception" ]
     on: ExceptionClass 
     do: [:ex | "code that handles exception" ].
</syntaxhighlight>

The general mechanism is provided by the message {{Smalltalk|on:do:}}.<ref>{{Cite web |url=http://pharobyexample.org/ |title=Pharo by Example |access-date=2010-03-20 |archive-url=https://web.archive.org/web/20091021035635/http://pharobyexample.org/ |archive-date=2009-10-21 |url-status=dead }}</ref> Exceptions are just normal objects that subclass {{Smalltalk|Error}}, you throw one by creating an instance and sending it a {{Smalltalk|#signal}} message, e.g., {{Smalltalk|MyException new signal}}. The handling mechanism ({{Smalltalk|#on:do:}}) is again just a normal message implemented by {{Smalltalk|BlockClosure}}. The thrown exception is passed as a parameter to the handling block closure, and can be queried, as well as potentially sending {{Smalltalk|#resume}} to it, to allow execution flow to continue.

=== Swift ===
{{Further|Swift (programming language)}}
Exception handling is supported since Swift 2.
<syntaxhighlight lang="swift">
enum MyException : ErrorType {
  case Foo(String, Int)
}
func someFunc() throws {
  throw MyException.Foo("not enough food", 2)
}
do {
  try someFunc()
  print("Not reached")
} catch MyException.Foo(let s, let i) {
  print("MyException: \(s), \(i)")
} catch {
  print("Unexpected exception : \(error)")
}
</syntaxhighlight>

=== Tcl ===
{{Further|Tcl}}
<syntaxhighlight lang="tcl">
if { [ catch {
    foo
} err ] } {
    puts "Error: $err"
}
</syntaxhighlight>
Since Tcl 8.6, there is also a try command:
<syntaxhighlight lang="tcl">
try {
    someCommandWithExceptions
} on ok {res opt} {
    # handle normal case.
} trap ListPattern1 {err opt} {
    # handle exceptions with an errorcode matching ListPattern1
} trap ListPattern2 {err opt} {
    # ...
} on error {err opt} {
    # handle everything else.
} finally {
    # run whatever commands must run after the try-block.
}
</syntaxhighlight>

=== VBScript ===
{{Further|VBScript}}
<syntaxhighlight lang="vbnet">
With New Try: On Error Resume Next
    'do Something (only one statement recommended)
.Catch: On Error GoTo 0: Select Case .Number
    Case 0 'this line is required when using 'Case Else' clause because of the lack of "Is" keyword in VBScript Case statement
        'no exception
    Case SOME_ERRORNUMBER
        'exception handling
    Case Else
        'unknown exception
End Select: End With

' *** Try Class ***
Class Try
    Private mstrDescription
    Private mlngHelpContext
    Private mstrHelpFile
    Private mlngNumber
    Private mstrSource

    Public Sub Catch()
        mstrDescription = Err.Description
        mlngHelpContext = Err.HelpContext
        mstrHelpFile = Err.HelpFile
        mlngNumber = Err.Number
        mstrSource = Err.Source
    End Sub

    Public Property Get Source()
        Source = mstrSource
    End Property
    
    Public Property Get Number()
        Number = mlngNumber
    End Property

    Public Property Get HelpFile()
        HelpFile = mstrHelpFile
    End Property
    
    Public Property Get HelpContext()
        HelpContext = mlngHelpContext
    End Property
    
    Public Property Get Description()
        Description = mstrDescription
    End Property
End Class
</syntaxhighlight><ref name="VBexhandle">{{Cite web |url=https://sites.google.com/site/truetryforvisualbasic/ |title=Try-Catch for VB |access-date=2012-03-17 |archive-date=2016-04-16 |archive-url=https://web.archive.org/web/20160416093023/https://sites.google.com/site/truetryforvisualbasic/ |url-status=dead }}</ref>

=== Visual Basic 6 ===
{{Further|Visual Basic}}
Exception handling syntax is very similar to Basic. Error handling is local on each procedure.
<syntaxhighlight lang="vbnet">
On Error GoTo HandlerLabel 'When error has occurred jumps to HandlerLabel, which is defined anywhere within Function or Sub
'or
On Error GoTo 0 'switch off error handling. Error causes fatal runtime error and stops application
'or
On Error Resume Next 'Object Err is set, but execution continues on next command. You can still use Err object to check error state.
'...
Err.Raise 6   ' Generate an "Overflow" error using built-in object Err. If there is no error handler, calling procedure can catch exception by same syntax
'...

FinallyLabel: 'just common label within procedure (non official emulation of Finally section from other languages)
    'cleanup code, always executed
Exit Sub 'exits procedure

'because we are after Exit Sub statement, next code is hidden for non-error execution
HandlerLabel: 'defines a common label, here used for exception handling.
If Err.Number = 6 Then 'Select Case statement is typically better solution
    Resume FinallyLabel 'continue execution on specific label. Typically something with meaning of "Finally" in other languages
    'or
    Resume Next 'continue execution on statement next to "Err.Raise 6"
    'or
    Resume 'continue execution on (repeat) statement "Err.Raise 6"
End If

MsgBox Err.Number & " " & Err.Source & " " & Erl & " " & Err.Description & " " & Err.LastDllError 'show message box with important error properties
    'Erl is VB6 built-in line number global variable (if used). Typically is used some kind of IDE Add-In, which labels every code line with number before compilation
Resume FinallyLabel
</syntaxhighlight>

Example of specific (non official) implementation of exception handling, which uses object of class "Try". 
<syntaxhighlight lang="vbnet">
With New Try: On Error Resume Next 'Create new object of class "Try" and use it. Then set this object as default. Can be "Dim T As New Try: ... ... T.Catch
    'do Something (only one statement recommended)
.Catch: On Error GoTo 0: Select Case .Number 'Call Try.Catch() procedure. Then switch off error handling. Then use "switch-like" statement on result of Try.Number property (value of property Err.Number of built-in Err object)
    Case SOME_ERRORNUMBER
        'exception handling
    Case Is <> 0 'When Err.Number is zero, no error has occurred
        'unknown exception
End Select: End With

' *** Try Class ***
Private mstrDescription  As String
Private mlngHelpContext  As Long
Private mstrHelpFile     As String
Private mlngLastDllError As Long
Private mlngNumber       As Long
Private mstrSource       As String

Public Sub Catch()
    mstrDescription = Err.Description
    mlngHelpContext = Err.HelpContext
    mstrHelpFile = Err.HelpFile
    mlngLastDllError = Err.LastDllError
    mlngNumber = Err.Number
    mstrSource = Err.Source
End Sub

Public Property Get Source() As String
    Source = mstrSource
End Property

Public Property Get Number() As Long
    Number = mlngNumber
End Property

Public Property Get LastDllError() As Long
    LastDllError = mlngLastDllError
End Property

Public Property Get HelpFile() As String
    HelpFile = mstrHelpFile
End Property

Public Property Get HelpContext() As Long
    HelpContext = mlngHelpContext
End Property

Public Property Get Description() As String
    Description = mstrDescription
End Property
</syntaxhighlight><ref name="VBexhandle" />

==== Visual Basic .NET ====
{{Further|Visual Basic .NET}}
A <code>Try</code> block must have at least one clause <code>Catch</code> or <code>Finally</code> clause and at most one <code>Finally</code> clause.
<syntaxhighlight lang="vbnet">
Try
   ' code to be executed here
Catch ex As Exception When condition
   ' Handle Exception when a specific condition is true. The exception object is stored in "ex".
Catch ex As ExceptionType
   ' Handle Exception of a specified type (i.e. DivideByZeroException, OverflowException, etc.)
Catch ex As Exception
   ' Handle Exception (catch all exceptions of a type not previously specified)
Catch
   ' Handles anything that might be thrown, including non-CLR exceptions.
Finally
   ' Always run when leaving the try block (including catch clauses), regardless of whether any exceptions were thrown or whether they were handled.
   ' Often used to clean up and close resources such a file handles.
   ' May not be run when Environment.FailFast() is called and in other system-wide exceptional conditions (e.g. power loss), or when the process crashes due to an exception in another thread.
End Try
</syntaxhighlight>

=== Visual Prolog ===
{{Further|Visual Prolog}}

<syntaxhighlight lang="visualprolog">
try
    % Block to protect
catch TraceId do
    % Code to execute in the event of an exception; TraceId gives access to the exception information
finally
    % Code will be executed regardles however the other parts behave
end try
</syntaxhighlight><ref>http://wiki.visual-prolog.com/index.php?title=Language_Reference/Terms#Try-catch-finally</ref>

=== X++ ===
{{Further|Microsoft Dynamics AX}}
<syntaxhighlight lang="x++">
public static void Main(Args _args)
{
   try
   {
      // Code that could throw an exception.
   }
   catch (Exception::Error) // Or any other exception type.
   {
      // Process the error.
   }
   catch
   {
      // Process any other exception type not handled previously.
   }

   // Code here will execute as long as any exception is caught.
}
</syntaxhighlight>

== References ==
{{Reflist}}

== See also ==
* [[Exception handling]] for the semantics of exception handling
* [[Syntax of programming languages|Syntax]] for definition of syntax in computer science

{{DEFAULTSORT:Exception Handling Syntax}}
<!--Categories-->
[[Category:Programming language syntax]]
[[Category:Control flow]]
[[Category:Programming language comparisons]]
<!-- Hidden categories below -->
[[Category:Articles with example Ada code]]
[[Category:Articles with example BASIC code]]
[[Category:Articles with example C code]]
[[Category:Articles with example C++ code]]
[[Category:Articles with example C Sharp code]]
[[Category:Articles with example Haskell code]]
[[Category:Articles with example Java code]]
[[Category:Articles with example JavaScript code]]
[[Category:Articles with example Lisp (programming language) code]]
[[Category:Articles with example Objective-C code]]
[[Category:Articles with example OCaml code]]
[[Category:Articles with example Pascal code]]
[[Category:Articles with example Perl code]]
[[Category:Articles with example PHP code]]
[[Category:Articles with example Python (programming language) code]]
[[Category:Articles with example R code]]
[[Category:Articles with example Ruby code]]
[[Category:Articles with example Smalltalk code]]
[[Category:Articles with example Swift code]]
[[Category:Articles with example Tcl code]]