Exceptions: Difference between revisions

Cf. [[Exceptions Through Nested Calls]]

=={{header|Ada}}==

<lang ada>Foo_Error : exception;</lang>

<lang ada>procedure Foo is

begin

raise; -- continue propagation of

end if;</lang>

<lang ada>procedure Call_Foo is

begin

... -- this catches all other exceptions

end Call_Foo;</lang>

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:

<lang ada>with Ada.Exceptions; use Ada.Exceptions;

=={{header|Aikido}}==

Aikido provides <code>try</code>, <code>catch</code> and <code>throw</code> statements.

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.

<lang aikido>

</lang>

You can throw any value.

<lang aikido>

=={{header|ALGOL 68}}==

<lang algol68># a user defined object #

MODE OBJECTFOO = STRUCT ( PROC (REF OBJECTFOO)BOOL foo event mended, ... );

foo event mended OF foo := foo event

);</lang>

<lang algol68>OBJECTFOO foo proxy := foo base; # event routines are specific to an foo #

IF NOT (foo event mended OF foo base)(foo base) THEN undefined # trace back # FI

FI</lang>

<lang algol68>PROC raise foo event(REF OBJECTFOO foo)BOOL:

IF mend foo(foo) THEN

FALSE # OR fall back to default event routine #

FI</lang>

ALGOL 68 uses event routines extensively in the "standard transput"

(stdio) to manage the various events that arise when data is read

=={{header|AppleScript}}==

<lang applescript>try

set num to 1 / 0

end try</lang>

<lang applescript>try

set num to 1 / 0

end try</lang>

<lang applescript>error "Error message." number 2000</lang>

=={{header|AutoHotkey}}==

The setjmp()/longjmp() functions in the C standard library header <setjmp.h> are typically used for exception handling.

<lang c>#include <setjmp.h>

The exception can be of any type, this includes int's, other primitives, as well as objects.

<lang cpp>struct MyException

{

Note that in principle you can throw any copyable type as exception, including built-in types.

<lang cpp>// this function can throw any type of exception

void foo()

}</lang>

<lang cpp>try {

foo();

{{works with|Visual Studio|2005}}

<lang csharp>public class MyException : Exception

{

};</lang>

<lang csharp>void foo()

{

}</lang>

<lang csharp>try {

foo();

=={{header|ColdFusion}}==

inside &lt;cfscript&gt;:

=={{header|D}}==

<lang d>void test() {

throw new Exception("Sample Exception");

}</lang>

<lang d>void test2() {

try test();

In debug mode, stack traces can be generated via an external package, but the standard library does not support it by default.

<lang d>void test3() {

try test2();

=={{header|E}}==

An exception ''object'' describes what the problem is and has nothing to do with control flow.

There are two control flow constructs used with exceptions: throw and eject.

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

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.

Ejectors provide the same sort of "exit to catch block" control flow that throw/catch do, but with an explicit path rather than implicitly "nearest enclosing". Ejectors are also used as a general purpose control construct as well as for exceptions.

=={{header|Factor}}==

<lang factor>"Install Linux, Problem Solved" throw

velociraptor</lang>

<lang factor>! Preferred exception handling

: try-foo

Forth's exception mechanism is, like most things in Forth, very simple but powerful. CATCH captures the data and return stack pointers, then executes an execution token. THROW conditionally throws a value up to the most recent CATCH, restoring the stack pointers.

<lang forth>: f ( -- ) 1 throw ." f " ; \ will throw a "1"

: g ( -- ) 0 throw ." g " ; \ does not throw</lang>

<lang forth>: report ( n -- ) ?dup if ." caught " . else ." no throw" then ;

: test ( -- )

Exceptions can be implemented using monads; no special syntax is necessary.[http://haskell.org/haskellwiki/Exception] In GHC, specialized functionality for exceptions are provided by the <tt>Control.Exception</tt> module.

The type "Exception", which contains pre-defined exceptions, cannot be extended. You can however use "dynamic exceptions", which can be of any type that is of "Typeable" class. <!-- Somebody look over this; I don't really understand it. -->

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

<lang haskell>do {- ... -}

else throwDyn myException</lang>

The "catch" function performs the whole try-catch stuff. It is usually used in infix style:

pattern-matches on the exception type and argument:

=={{header|J}}==

Program<tt> u :: v </tt>executes <tt>u</tt> and provides its result as output unless an error occurs. In case of error, the result of <tt>v</tt> is provided instead.<br>

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.

An exception needs to extend the Exception type.

<lang java>//Checked exception

public class MyException extends Exception {

public class MyRuntimeException extends RuntimeException {}</lang>

<lang java>public void fooChecked() throws MyException {

throw new MyException();

}</lang>

<lang java>try {

fooChecked();

=={{header|JavaScript}}==

<lang javascript>function doStuff() {

}</lang>

<lang javascript>try {

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

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

<lang modula3>EXCEPTION EndOfFile;

EXCEPTION Error(TEXT);</lang>

Exceptions can be bound to procedures using RAISES:

<lang modula3>PROCEDURE Foo() RAISES { EndOfFile } =

...</lang>

<lang modula3>TRY

Foo();

=={{header|MOO}}==

Values can be raised to exceptions using raise():

<lang moo>raise(E_PERM);</lang>

<lang moo>try

this:foo();

endtry</lang>

<lang moo>`this:foo()!ANY=>this:bar()';</lang>

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

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:

<lang objc>@interface MyException : NSException {

@end</lang>

<lang objc>- (void)foo {

@throw [NSException exceptionWithName:@"TerribleException"

}</lang>

<lang objc>@try {

[self foo];

=={{header|OCaml}}==

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

<lang ocaml>exception My_Exception;;

exception Another_Exception of string;;</lang>

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

<lang ocaml>let foo x =

;;</lang>

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

<lang ocaml>try

=={{header|Oz}}==

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

<lang oz>raise sillyError end

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

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

<lang oz>try

=={{header|Perl}}==

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

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:

die $_;</lang>

More complicated exception handling can be achieved in Perl using [http://search.cpan.org/perldoc?TryCatch TryCatch] or [http://search.cpan.org/perldoc?Exception::Class Exception::Class] modules.

Exceptions were not available prior to PHP 5.0

<lang php>class MyException extends Exception

{

}</lang>

<lang php>function throwsException()

{

throw new Exception('Exception message');

}</lang>

<lang php>try {

throwsException();

=={{header|Pop11}}==

<lang pop11>define throw_exception();

enddefine;</lang>

<lang pop11>define main();

=={{header|Python}}==

<lang python>import exceptions

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

{{works with|Python|2.x and 3.x}}

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

<lang python>def spam():

{{works with|Python|2.5}}

Passing an argument to the constructor of an exception class:

<lang python>def spam():

raise SillyError('egg')</lang>

{{works with|Python|2.5}}

{{works with|Python|3.0}}

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

<lang python>try:

=={{header|Ruby}}==

<lang ruby>class SillyError < Exception

This example makes "MyInvalidArgument" an type of ArgumentError (one of the built-in exceptions). It's simply declared as a subclass of the existing exception and no over-riding is necessary. (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).

<lang ruby>def spam

end</lang>

rescue/else/ensure

The "rescue" clause is like the "catch" clause in other languages. The "ensure" clause is like the "finally" clause in other languages.

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

=={{header|Slate}}==

<lang slate>se@(SceneElement traits) doWithRestart: block

].</lang>

<lang slate>conditions define: #Abort &parents: {Restart}.

].</lang>

{{Lines_too_long}}

<lang slate>(fileName endsWith: '.image') ifTrue: [error: 'Image filename specified where Slate source expected. Make sure you run slate with the -i flag to specify an image.'].</lang>

=={{header|Standard ML}}==

<lang sml>exception MyException;

exception MyDataException of int; (* can be any first-class type, not just int *)</lang>

<lang sml>fun f() = raise MyException;

fun g() = raise MyDataException 22;</lang>

<lang sml>val x = f() handle MyException => 22;

val y = f() handle MyDataException x => x;</lang>

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

<lang vbnet>Class MyException

Inherits Exception

End Class</lang>

<lang vbnet>Sub foo()

Throw New MyException

End Sub</lang>

<lang vbnet>Sub bar()

Try

The major limitations are that nested Try/Catch blocks must be constructed by the user, and that the User Defined Labels required for the Catch/Finally blocks may not be reused within a subroutine. For these reasons, it is conventional to only have only 1 Try/Catch block per subroutine.

<lang vba>Sub foo1()

err.raise(vbObjectError + 1050)

</lang>

<lang vba>Sub bar1()

'by convention, a simple handler