Exceptions: Difference between revisions

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

String message

F (message)

X SillyError(‘egg’)

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

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

=={{header|BBC BASIC}}==

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.

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

<= new("MyException raised");

'''Throw exceptions'''

{

MyException.raise()

}

'''Catching exceptions'''

{

o.foo()

{

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

Exceptions in langur are hashes guaranteed to contain certain fields, even if they're empty.

throw "not a math exception"

# no exception

...

An else section on a catch is optional. As of 0.7, you can also use else if on a catch.

A shortened catch does not allow an else section (action for no exception).

catch if _err["cat"] == "math" {

} else {

throw

.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