Exceptions: Difference between revisions

{{omit from|M4}}

{{omit from|Retro}}

 

This task is to give an example of an exception handling routine

 

=={{header|11l}}==

String message

F (message)

 

X.try

X.catch SillyError se

 

=={{header|8086 Assembly}}==

An exception in assembly language is often little more than just a conditional branch. Most MS-DOS system calls return the carry flag set if an error occured, and the error code will be returned in <code>AX</code>. This lets you write your own exception handler that prints a relevant error message to the screen. You'll need to read the documentation to know what each error code means.

 

mov dx,offset filename

mov cx,0

je FileAlreadyExistsError

 

 

=={{header|Ada}}==

 

'''Define an exception'''

 

'''Raise an exception'''

begin

raise Foo_Error;

Re-raising once caught exception:

exception

when Foo_Error =>

if ... then -- Alas, cannot handle it here,

raise; -- continue propagation of

 

'''Handle an exception'''

begin

Foo;

when others =>

... -- this catches all other exceptions

 

'''Ada.Exceptions'''<br>

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.Text_IO; use Ada.Text_IO;

 

when Error : others =>

Put_Line ("Something is wrong here" & Exception_Information (Error));

 

=={{header|Aikido}}==

'''Catching exceptions'''<br>

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

try {

var lines = readfile ("input.txt")

}

 

 

'''Throwing exceptions'''<br>

You can throw any value.

if (error) {

throw "Error"

 

 

 

=={{header|Aime}}==

'''Simple Exception Throwing'''

throwing(void)

{

 

return 0;

{{out}}

<pre>ready to catch

caught!</pre>

'''Exception Types'''

ft(integer a, text &s)

{

 

return 0;

{{out}}

<pre>aime: tmp/et1: 6: bad number

{{works with|ALGOL 68G|Any - tested with release [http://sourceforge.net/projects/algol68/files/algol68g/algol68g-2.8 algol68g-2.8].}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

Define an general event handling mechanism on MODE OBJ:

* try to parallel pythons exception handling flexibility

OP (SCOPEOBJ #up scope#)VOID RESET = obj reset;

 

 

MODE OBJ=UNION(REF INT, REF REAL, REF STRING,# etc # VOID);

RESET obj scope reset;

 

<pre>

sum sqs: +4900

 

'''try'''

set num to 1 / 0

--do something that might throw an error

 

'''try-on error'''

set num to 1 / 0

--do something that might throw an error

--errMess and number errNum are optional

display alert "Error # " & errNum & return & errMess

 

'''error'''

=={{header|AutoHotkey}}==

=== True exceptions ===

In [[AutoHotkey_L]] [http://l.autohotkey.net/docs/commands/Try.htm Try], [http://l.autohotkey.net/docs/commands/Catch.htm Catch], and [http://l.autohotkey.net/docs/commands/Throw.htm Throw] are available to handle exceptions.<br/>

From the [http://l.autohotkey.net/docs/commands/Throw.htm Throw documentation]:

BadlyCodedFunc()

catch e

BadlyCodedFunc() {

throw Exception("Fail", -1)

=== ErrorLevel-based exceptions ===

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

If ErrorLevel

Msgbox calling foo failed with: %ErrorLevel%

ErrorLevel = foo_error

Return

 

ERROR 100, "User-generated exception"

PRINT "Error number was " ; er%

PRINT "Error string was " rpt$

'''Output:'''

<pre>

 

=={{header|blz}}==

try

1 / 0 # Throw an exception

print("An error occured!")

end

 

=={{header|Bracmat}}==

percolates further up, so calling the function <code>MyFunction</code> fails as well, making the whole program fail.

 

= someText XMLstuff

. ( get$!arg:?someText

)

& MyFunction$"Tralula.txt"

If you copy/paste this code to the Bracmat prompt <em>without the statement delimiter <code>;</code></em>, you will see an 'F' after the output, indicating that your input failed to

evaluate successfully.

F

</pre>

 

=={{header|C}}==

'''try-catch'''

 

enum { MY_EXCEPTION = 1 }; /* any non-zero number */

/* there is no way to "let the exception through" */

}

 

With multi-thread support and nested exceptions

#include <stdio.h>

#include <setjmp.h>

}

 

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

 

 

'''Defining exceptions'''

{

// data with info about exception

 

'''Throw exceptions'''

{

throw MyException();

 

'''Catching exceptions'''

foo();

}

{

// handle any type of exception not handled by above catches

 

=={{header|C++}}==

 

'''Defining exceptions'''

{

// data with info about exception

 

However thrown exceptions should almost always derive from <tt>std::exception</tt>. The advantage of doing so is that you can catch unknown exceptions and still get some meaningful information. There are also more specific classes like <tt>std::runtime_error</tt> which also derive from <tt>std::exception</tt>.

 

struct MyException: std::exception

{

virtual const char* what() const noexcept { return "description"; }

 

'''Throw exceptions'''

{

throw MyException();

 

'''Catching exceptions'''

foo();

}

{

// handle any type of exception not handled by above catches

 

=={{header|Clojure}}==

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

(if (> (rand) 0.5)

(throw (RuntimeException. "oops!"))

(println e)

(finally

 

=={{header|ColdFusion}}==

inside &lt;cfscript&gt;:

 

foo();

} catch (Any e) {

// handle exception e

 

otherwise:

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

</cfcatch>

 

=={{header|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, <code>unexpected-odd-number</code>, defines a function <code>get-number</code> which generates a random number, returning it if it is even, but signaling an <code>unexpected-odd-number</code> condition if it is odd. The function <code>get-even-number</code> uses <code>[http://www.lispworks.com/documentation/HyperSpec/Body/m_hand_1.htm handler-case]</code> to call <code>get-number</code> returning its result if no condition is signaled, and, in the case that an <code>unexpected-odd-number</code> condition is signaled, returning one plus the odd number.

 

((number :reader number :initarg :number))

(:report (lambda (condition stream)

(handler-case (get-number)

(unexpected-odd-number (condition)

 

A good introduction to Lisp's condition system is the chapter [http://gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html Beyond Exception Handling: Conditions and Restarts] from Peter Seibel's [http://gigamonkeys.com/book/ Practical Common Lisp].

 

=={{header|D}}==

 

/// Throw Exceptions

void main() {

test4();

 

=={{header|Delphi}}==

 

'''Throw Exceptions'''

begin

raise Exception.Create('Sample Exception');

 

'''Catch Exceptions'''

begin

try

raise; // Rethrowing

end;

 

'''Ways to implement finally'''

begin

try

ShowMessage('test3 finally');

end;

 

=={{header|Dyalect}}==

 

throw @NegativesNotAllowed(x) when x < 0

this + x

} catch {

@NegativesNotAllowed(x) => print("Negative number: \(x)")

 

=={{header|DWScript}}==

 

'''Throw Exceptions'''

begin

raise Exception.Create('Sample Exception');

 

'''Catch Exceptions'''

begin

try

end;

end;

 

'''Ways to implement finally'''

begin

try

PrintLn('Test3 finally');

end;

 

=={{header|Déjà Vu}}==

 

raise :value-error

 

stuff-going-wrong

catch value-error:

{{out}}

<pre>Whoops!</pre>

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

 

if (arg == 43) {

return "Bob"

return ["notok", exceptionObj]

}

 

# value: ["not ok", problem: Who?]

 

 

? catching(45.7)

 

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.

The above code rewritten to use ejectors:

 

if (arg == 43) {

return "Bob"

return ["notok", exceptionObj]

}

 

# value: ["not ok", problem: Who?]

 

 

? catching(45.7)

 

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.

For example, suppose we have nameOf written as follows:

 

def nameOf(arg :int, ejector) {

if (nameTable == null) {

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.

 

'''Defining exceptions'''

{

constructor new()

 

'''Throw exceptions'''

{

MyException.raise()

}

 

'''Catching exceptions'''

{

}

{

// handle exceptions of type MyException and derived

 

'''Catching any exception'''

{

// handle any type of exception

 

=={{header|Erlang}}==

-module( exceptions ).

 

 

end.

{{out}}

<pre>

 

'''Throw Exceptions'''

 

TUPLE: velociraptor ;

 

Or a shorthand for this:

 

'''Catch Exceptions'''

: try-foo

[ foo ] [ foo-failed ] recover ;

[ "Fail" throw ] catch ! returns "Fail"

[ "Hi" print ] catch ! returns f (looks the same as throwing f; don't throw f)

 

=={{header|Fancy}}==

# StandardError is base class for all exception classes

class MyError : StandardError {

# this will always be executed (as in e.g. Java)

"This is how exception handling in Fancy works :)" println

 

=={{header|Fantom}}==

 

// Create a new error class by subclassing sys::Err

const class SpecialErr : Err

}

}

 

{{out}}

 

'''Throw Exceptions'''

 

'''Catch Exceptions'''

: test ( -- )

['] f catch report

test example. (Output shown in bold)

 

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:

 

=={{header|FreeBASIC}}==

FreeBASIC does not support exceptions or the Try/Catch/Finally statement, as such.

However, you can use the Err() function, together with a Switch statement, to provide somewhat similar functionality:

 

Enum ErrorType

Print

Print "Press any key to quit"

 

{{out}}

=={{header|Gambas}}==

'''[https://gambas-playground.proko.eu/?gist=c3abec93bc7f135203f1f7582f5c3a19 Click this link to run this code]'''

Dim iInteger As Integer

 

Print Error.Text

 

Output:

<pre>

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

 

 

import "fmt"

foo()

fmt.Println("glad that's over.")

{{out}}

<pre>

'''Throw exceptions'''<br>

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

 

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

 

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

 

'''Catching exceptions'''<br>

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 IO computations here -}

`catch` \ex -> do

 

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

 

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

{- do IO computations here -}

`catchDyn` \ex -> do

 

=={{header|HolyC}}==

The <code>catch</code> block does not have the capability to differentiate between specific exceptions. Instead, all exceptions for a <code>try</code> block are handled by a single <code>catch</code> block.

 

U8 *err = 'Error';

throw(err); // throw exception

Print("Raised 'Error'");

PutExcept; // print the exception and stack trace

 

==Icon and {{header|Unicon}}==

support exceptions.</i>

 

 

procedure main(A)

if numeric(i) = 3 then Exception().throw("bad value of "||i)

return i

 

A sample run is:

An exception in an explicit definition can be detected with <tt>try.</tt> and <tt>catcht.</tt> and can be thrown with <tt> throw. </tt> as seen below.

 

if. y-:'bad argument' do.

throw.

 

tryThis 'bad argument'

 

=={{header|Java}}==

 

'''Defining exceptions'''

public class MyException extends Exception {

//Put specific info in here

 

//Unchecked exception

 

'''Throw exceptions'''

throw new MyException();

}

public void fooUnchecked() {

throw new MyRuntimeException();

 

'''Catching exceptions'''

fooChecked();

}

finally {

//This code is always executed after exiting the try block

{{works with|Java|7+}}

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

try{

throwsNumberFormatException();

throw e;

}

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

 

'''Throwing exceptions'''

 

throw new Error('Not implemented!');

 

'''Catching exceptions'''

 

element.attachEvent('onclick', doStuff);

}

finally {

eventSetup = true;

 

=={{header|jq}}==

 

The "try" clause takes the form:

where FILTER and CATCHER may be any jq expressions.

 

 

'''Example''':

def abs: if . < 0 then -. else . end;

if a == 0 and b == 0 then error("0/0")

elif . == "division by 0" then null

else "\(.): \(a) / \(b)"

 

# test(0;0) # produces 0

{{works with|Julia|0.6}}

 

try sqrt(x)

catch

@show extendedsqrt(1) # 1

@show extendedsqrt(-1) # 0.0 + 1.0im

 

=={{header|Kotlin}}==

 

// In Kotlin all Exception classes derive from Throwable and, by convention, end with the word 'Exception'

fun main(args: Array<String>) {

goo()

 

{{out}}

 

=={{header|langur}}==

A catch causes all the statements preceding it within a block to be the implicit try block.

 

 

# change result...

} else {

} else {

# no exception

 

 

 

 

 

.safediv(7, 7) # 1

 

=={{header|Lasso}}==

handle_error => {

// do something else

}

fail(-1,'Oops')

 

=={{header|Lingo}}==

Lingo has no try...catch mechanism. A script error will always end execution of the current call stack. There is however a mechanism that prevents that script errors quit the execution of the current movie/projector: you can set up an "alertHook" that is called when such errors occur. This alertHook can then e.g. log the error to a file or database, and if it returns 1, the movie/projector continues to play:

 

 

on alertHook (me, errorType, errorMessage, alertType)

 

return 1 -- continues movie playback, no error dialog

 

on prepareMovie

_player.alertHook = script("ErrorHandler")

 

In terms of the behavior described above, a "throw" command triggering custom errors that behave exactly like real script errors can be implemented like this:

 

-- usage: throw("Custom error 23")

on throw (msg)

_player.alertHook.alertHook("Script runtime error", msg, #script)

abort() -- exits call stack

 

=={{header|Logo}}==

{{works with|UCB Logo}}

if :b = 0 [(throw "divzero 0)]

output :a / :b

to div.safely :a :b

output catch "divzero [div.checked :a :b]

There are also some predefined exceptions:

* '''throw "toplevel''' returns to the interactive prompt if uncaught (like control-C)

=={{header|Logtalk}}==

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

:- object(exceptions).

 

 

:- end_object.

{{out}}

<pre>

=={{header|Lua}}==

'''Throwing an Exception'''<br>

error("Something bad happened!")

 

'''Catching Exceptions'''<br>

function throw_error()

error("Whoops")

status, errmsg = pcall(throw_error)

print("errmsg = ", errmsg)

 

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

function throw_error_with_argment(argument)

error(string.format("Whoops! argument = %s", argument))

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:<br />

function throw_error_with_argment(argument)

return "hello!"

status, errmsg = pcall(throw_error_with_argment, "foobar 123")

print("errmsg = ", errmsg)

 

=={{header|M2000 Interpreter}}==

Module Errors {

Module Check {

Errors

Print Error$=""

{{out}}

<pre>

fail.mk

 

 

Using -@ to ignore the exception.

catch.mk

 

 

Using explicit exit 0 to ignore the exception.

catch.mk

 

 

=={{header|Maple}}==

errorproc:=proc(n)

local a;

end try;

end proc;

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

Example usage :

 

Catch[f[2] + f[3]]

 

=={{header|MATLAB}}==

 

Sample usage:

 

=={{header|Modula-3}}==

'''Defining exceptions'''<br>

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

 

'''Throw exceptions'''<br>

Exceptions can be bound to procedures using RAISES:

...

RAISE EndOfFile;

 

'''Catching exceptions'''

Foo();

EXCEPT

| EndOfFile => HandleFoo();

 

Modula-3 also has a FINALLY keyword:

Foo();

FINALLY

CleanupFoo(); (* always executed *)

 

=={{header|MOO}}==

'''Throw exceptions'''<br>

Values can be raised to exceptions using raise():

 

'''Catching exceptions'''

this:foo();

except e (ANY)

this:bar(e);

 

MOO also has a finally statement:

this:foo();

finally

this:bar();

 

'''Shorthand'''

 

=={{header|Nanoquery}}==

invalid "this statement will fail"

catch e

println "caught an exception"

println e

Throwing exceptions:

 

=={{header|Nemerle}}==

class MyException : Exception

{

finally {

... // code executes whether or not exception was thrown

 

=={{header|NetRexx}}==

As <tt>NetRexx</tt> runs under the control of a JVM it has the same exception model as [[#Java|Java]].

options replace format comments java crossref symbols nobinary

 

super('I resent that!')

return

'''Output:'''

<pre>

=={{header|Nim}}==

'''Defining exceptions'''

'''Throwing an exception'''

'''Handling an exception'''

spam()

except SillyError:

echo "Got another exception"

finally:

 

=={{header|Objective-C}}==

'''Defining exceptions'''<br>

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

//Put specific info in here

}

 

'''Throw exceptions'''

@throw [NSException exceptionWithName:@"TerribleException"

reason:@"OMGWTFBBQ111!1" userInfo:nil];

 

'''Catching exceptions'''

[self foo];

}

@finally {

//This code is always executed after exiting the try block

 

=={{header|OCaml}}==

'''Defining exceptions'''<br>

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

 

'''Throw exceptions'''<br>

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

match x with

1 -> raise My_Exception

| 2 -> raise (Another_Exception "hi mom")

| _ -> 5

 

'''Catching exceptions'''<br>

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

string_of_int (foo 2)

with

My_Exception -> "got my exception"

| Another_Exception s -> s

 

=={{header|Oforth}}==

It is also possible to create new exception classes (see Exception.of).

 

: iwillCatch

try: e [ iwillThrowAnException ] when: [ "Exception catched :" . e .cr ]

try: e [ 1 2 over last ] when: [ "Exception catched :" . e .cr ]

 

{{out}}

'''Throw exceptions'''<br>

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

 

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

 

raise someError(debug:unit) end

catch someError(debug:d(stack:ST ...)...) then

{Inspect ST}

 

See also: [http://www.mozart-oz.org/documentation/base/exception.html Exceptions] in the Oz documentation.

'''Catching exceptions'''<br>

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

{Foo}

catch sillyError then

finally

{Fin}

 

=={{header|PARI/GP}}==

|User-initiated error

|}

"caught"

,

error("bad stuff")

 

===Throwing errors in GP===

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

 

===Throwing errors in PARI===

|}

</div>

 

===Catching errors in PARI===

It is rare that this mechanism needs to be used in PARI, rather than standard [[#C|C]] methods, but the function <code>closure_trapgen</code> (similar to <code>closure_evalgen</code>) is available:

if (x == (GEN)1L) // Was there an error?

 

=={{header|Pascal}}==

Exceptions using the core [http://perldoc.perl.org/functions/eval.html eval] function:

 

die "Danger, danger, Will Robinson!";

 

 

# rethrow

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

The same using the [http://search.cpan.org/perldoc?Try::Tiny Try::Tiny] module:

 

try {

die "this could go wrong mightily";

} catch {

print;

 

'''Other styles'''<br>

'''Throwing exceptions'''<br>

You can throw any string (on it's own) or any integer, optionally with any (deeply nested) user_data that you like.

<span style="color: #008080;">throw<span style="color: #0000FF;">(<span style="color: #008000;">"oh no"<span style="color: #0000FF;">)</span>

<span style="color: #008080;">throw<span style="color: #0000FF;">(<span style="color: #000000;">1<span style="color: #0000FF;">)</span>

<span style="color: #008080;">throw<span style="color: #0000FF;">(<span style="color: #000000;">501<span style="color: #0000FF;">,<span style="color: #0000FF;">{<span style="color: #008000;">"she"<span style="color: #0000FF;">,<span style="color: #000000;">made<span style="color: #0000FF;">[<span style="color: #000000;">me<span style="color: #0000FF;">]<span style="color: #0000FF;">,<span style="color: #000000;">Do<span style="color: #0000FF;">(<span style="color: #000000;">it<span style="color: #0000FF;">)<span style="color: #0000FF;">}<span style="color: #0000FF;">)

 

'''Catching exceptions'''<br>

There is one and only one non-optional catch clause per try statement. <br>

The variable caught is a sequence, augmented with run-time diagnostics, with whatever was thrown in e[E_CODE] and/or e[E_USER].

<span style="color: #008080;">try</span>

<span style="color: #000000;">one_of<span style="color: #0000FF;">(<span style="color: #000000;">these<span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">try

 

An uncaught exception terminates the program in error, otherwise control resumes in the catch clause or after the end try,

PHL does not support multiple catch-clauses.

 

 

extern printf;

}

return 0;

 

=={{header|PHP}}==

 

'''Define exceptions'''

{

// Custom exception attributes & methods

 

'''Throwing exceptions'''

{

throw new Exception('Exception message');

 

'''Catching Exceptions'''

throwsException();

} catch (Exception $e) {

echo 'Caught exception: ' . $e->getMessage();

 

=={{header|PicoLisp}}==

'throw' will transfer control to a 'catch' environment

that was set up with the given label.

(println 1) # Do some processing (print '1')

(throw 'thisLabel 2) # Abort processing and return '2'

{{out}}

<pre>1 # '1' is printed

 

=={{header|PL/I}}==

/* Define a new exception, called "my_condition". */

on condition (my_condition) snap begin;

/* to be printed, and execution then resumes at the statement */

/* following the SIGNAL statement. */

 

=={{header|PL/pgSQL}}==

 

'''Raise an exception'''

begin

raise exception 'this is a generic user exception';

raise exception division_by_zero;

end;

 

'''Handle an exception'''

 

Hande division by zero and re-raising once caught other exception:

create function special_division(p_num double precision, p_den double precision) returns text

as $body$

raise;

end;

 

=={{header|Pop11}}==

'''Throwing exceptions'''

 

throw([my_exception my_data]);

 

'''Catching exceptions'''

 

vars cargo;

define catcher();

enddefine;

 

 

=={{header|PowerShell}}==

'''Throw an exception:'''

throw "Any error message."

{{Out}}

<pre>

</pre>

'''Throw a more specific exception:'''

throw [System.IO.FileNotFoundException] ".\temp.txt not found."

{{Out}}

<pre>

</pre>

'''Using <code>try {} catch {}</code> is better for more complex error checking because you can test specific errors:'''

try

{

Write-Host "Other exception"

}

{{Out}}

<pre>

</pre>

'''Errors are objects like any other in PowerShell, so you may capture any detail of it:'''

$Error[0] | Get-Member

{{Out}}

<pre>

 

=={{header|Prolog}}==

\+ integer(X),

throw(b('not even an int')).

format('~w~n', Msg),

!.

{{Out}}

<pre>

 

=={{header|PureBasic}}==

MessageRequester("Exception test", "The following error happened: " + ErrorMessage())

EndProcedure

OnErrorCall(@ErrorHandler())

 

 

=={{header|Python}}==

'''Defining an exception'''

 

class SillyError(exceptions.Exception):

def __init__(self,args=None):

 

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

 

 

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).

 

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

 

{{works with|Python|2.5}}

 

Passing an argument to the constructor of an exception class:

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|2.x and 3.x}}

 

'''Handling an exception'''<br>

try-except-else-finally

 

foo()

except SillyError, se:

quux()

finally:

 

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).

 

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

foo()

except SillyError as se:

quux()

finally:

 

=={{header|Quackery}}==

When the condition is detected, <code>a</code>, or one of the words it invokes, will put a suitable message on the system ancillary stack called <code>message</code>, and invoke the word <code>bail</code>.

 

 

The one piece of necessary information about changes to the system state that Quackery cannot infer, even in "typical" usage, is the maximum number of items on the stack that may be removed or replaced during the execution of <code>a</code>. This needs to be specified by the programmer. (If the programmer is following conventions about stack comments, this could be gleaned from <code>a</code>'s stack comment, but Quackery steadfastly disregards all comments.) In this example, <code>a</code> consumes three stack items, so that is included in the code. How many it returns if there is no exception raised is not necessary information.

 

 

<code>backup</code> makes a copy of the 3 topmost items on the stack and performs other necessary actions to ensure that the system state can be restored if <code>bail</code> is invoked during the execution of <code>a</code>.

 

'''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(

{

finally = message("This is called whether or not an exception occured")

)

 

=={{header|Racket}}==

 

#lang racket

 

;; raise the exception

(raise (exn:my-exception "Hi!" (current-continuation-marks))))

 

=={{header|Raku}}==

{{works with|rakudo|2015-09-10}}

The Raku 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. The inside of a CATCH functions as a switch statement on the current exception.

die "Help I'm dieing!";

CATCH {

CATCH {

default { note "No you're not."; say $_.Str; }

 

<pre>

Rake comes with [http://design.raku.org/S04.html#Phasers phasers], that are called when certain conditions in the life of a program, routine or block are met. <tt>CATCH</tt> is one of them and works nicely together with <tt>LEAVE</tt> that is called even if an exception would force the current block to be left immediately. It's a nice place to put your cleanup code.

 

ENTER { note '1) f has been entered' }

LEAVE { note '2) f has been left' }

CATCH {

when X::AdHoc { note q{6) no, I'm dead}; }

 

<pre>1) f has been entered

=={{header|Raven}}==

 

 

define foo

catch

custom_error =

 

=={{header|REXX}}==

This type of exception handling (in REXX) has its limitation

(the label is local to the program, not external subroutines).

do j=9 by -5

say 'the square root of ' j " is " sqrt(j)

do k=j+5 to 0 by -1; numeric digits m.k; g=(g+x/g) * .5; end /*k*/

numeric digits d; return g/1

'''output'''

<pre>

 

=={{header|Ring}}==

Try

see 1/0

Catch

Done

 

=={{header|Ruby}}==

'''Defining an exception'''

 

class SillyError < Exception

 

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

 

 

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

rescue SillyError => se

puts se # writes 'egg' to stdout

 

foo

rescue ArgumentError => e

# always runs

baz

 

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.

 

 

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

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

 

throw :done

end

catch :done do

foo

 

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.

It is illustrated by the code below:

 

// Error

use std::io::{Error, ErrorKind};

panicking_function();

}

 

=={{header|Scala}}==

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

 

class AccountBlockException extends Exception

class InsufficientFundsException(val amount: Double) extends Exception

object NotImplementedErrorTest extends App {

??? // Throws scala.NotImplementedError: an implementation is missing

 

{{out}}Running entry point CheckingAccount

 

=={{header|Scheme}}==

(if (even? xx)

xx

(all-ok)))

 

 

=={{header|Seed7}}==

begin

raise RANGE_ERROR;

 

'''Handle an exception'''

begin

block

writeln("catched RANGE_ERROR");

end block;

 

=={{header|Sidef}}==

An exception is thrown by the ''die'' keyword, which, if not caught, it terminates the program with an appropriate exit code.

}

 

{{out}}

<pre>

msg: I'm dead! at test.sf line 2.

I'm alive...

</pre>

 

'''Handling Exceptions'''

 

[

block handlingCases: {Abort -> [| :_ | ^ Nil]}

 

'''Define Exceptions'''

 

"An Abort is a Restart which exits the computation, unwinding the stack."

 

[

c tryHandlers

 

'''Throwing Exceptions'''<br>

{{lines too long|Slate}}

 

=={{header|Smalltalk}}==

Throwing an Exception

 

"exit"

 

Transcript show: 'Throwing yawp'; cr.

 

Throwing yawp

Object: nil error: Yawp!

Error(Exception)>>signal: (AnsiExcept.st:226)

UndefinedObject(Object)>>error: (AnsiExcept.st:1565)

 

Handling an Exception

 

"exit"

 

] on: Error do: [ :e |

Transcript show: 'Caught yawp'; cr.

 

Throwing yawp

 

=={{header|SQL PL}}==

{{works with|Db2 LUW}}

With SQL PL:

--#SET TERMINATOR @

 

END IF;

END @

The next example just raise an exception, does not wrap a raised one.

BEGIN

SIGNAL SQLSTATE '75002'

SET MESSAGE_TEXT = 'Customer number is not known';

END @

Output:

<pre>

 

'''Define Exceptions'''

 

'''Throw Exceptions'''

 

'''Catch Exceptions'''

 

=={{header|Stata}}==

Example of usage:

 

if _rc {

if _rc==601 {

display "there was an error with return code " _rc

}

 

Similarly, Mata has functions '''[http://www.stata.com/help.cgi?mf_error error]''' and '''[http://www.stata.com/help.cgi?mf_exit exit]''' to terminate execution, as well as '''[http://www.stata.com/help.cgi?mf_assert assert]''' and '''asserteq'''.

'''Defining exceptions'''<br />

Exceptions can be of any type that conforms to the <code>ErrorType</code> protocol.

case TerribleException

 

'''Throw exceptions'''<br />

A function that throws an exception must be explicitly declared so:

throw MyException.TerribleException

 

'''Catching exceptions'''

try foo()

} catch MyException.TerribleException { // this can be any pattern

} catch {

//Catch any exception

 

=={{header|Tcl}}==

 

# Throw

}

 

This creates the stack trace

<pre>error message for stack trace

 

=={{header|Transd}}==

 

mainModule : {

_start: (lambda (func1))

}

OUTPUT:

---------------

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 monkey primate)

@(defex human primate)

@(end)@#output

@(end)@#try

 

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.

=={{header|Ursa}}==

Catching exceptions:

invalid "this statement will fail"

catch syntaxerror

# console.err is optional here

out "caught an exception" endl console.err

Throwing exceptions:

 

=={{header|Ursala}}==

raises an exception with the diagnostic message 'epic fail'.

(The diagnostic message can also be made to depend on the input.)

 

thrower = ~&?/'success'! -[epic fail]-!%

 

 

If the exception is not caught, the program terminates immediately and

 

throwing exceptions

['new error' 1 2 3] throw

'should not come here' puts

 

catching them

 

 

=={{header|VBA}}==

 

'''Throw exceptions'''

err.raise(vbObjectError + 1050)

End Sub

Error vbObjectError + 1051

End Sub

 

'''Catching exceptions'''

'by convention, a simple handler

On Error GoTo catch

end_try:

'by convention, often just a drop through from the catch block

 

=={{header|Visual Basic .NET}}==

 

'''Defining exceptions'''

Inherits Exception

'data with info about exception

 

'''Throw exceptions'''

Throw New MyException

 

'''Catching exceptions'''

Try

foo()

'code here occurs whether or not there was an exception

End Try

 

=={{header|Wren}}==

 

Here's an example of all this.

if (!(a is Num && a.isInteger) || !(b is Num && b.isInteger)) Fiber.abort("Invalid argument(s).")

if (b == 0) Fiber.abort("Division by zero error.")

System.print("%(e[0]) / %(e[1]) = %(d)")

}

 

{{out}}

Caught Num does not implement 'badMethod()'.

</pre>

 

=={{header|zkl}}==

catch { println(__exception," was thrown") }

fallthrough { println("No exception was thrown") }

{{out}}

<pre>

</pre>

If you want "finally" functionality, use onExit or onExitBlock:

try{

onExitBlock("Exit code".println);

}

f(False); println("--------");

{{out}}

<pre>

 

=={{header|Zig}}==

// To replace exceptions, Zig has error enums to handle error states.

 

return err;

};