Exceptions/Catch an exception thrown in a nested call: Difference between revisions

{{omit from|GUISS}}

{{omit from|M4}}

{{omit from|Retro}}

 

 

Show/describe what happens when the program is run.

 

=={{header|Ada}}==

 

procedure Exceptions_From_Nested_Calls is

Foo;

end loop;

{{out}}

<pre>

 

=={{header|Aime}}==

baz(integer i)

{

 

return 0;

{{out}}

<pre>Exception `U0' thrown

 

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

 

{{works with|ALGOL 68|Standard - no extensions to language used}}

 

c.f. [[Exceptions#ALGOL_68|ALGOL 68 Exceptions]] for more details.

INT value,

STRUCT(

FI;

 

{{out}}

<pre>

'''par''' clause, then all parallel the threads are terminated and the

program continues in the parent thread. <!-- example needed -->

=={{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/>

When this program is run, the first exception (U0) is raised, and caught by the try-catch section. This causes a Message Box containing the text "An exception was raised: First Exception" to be displayed by the script. The second exception is not caught, generating a runtime error.

global U1 := Exception("Second Exception")

 

else if ( calls = 2 )

throw U1

The runtime error:

<pre>Error: Second Exception

The global ErrorLevel keeps track of the last error.

Here is one way to keep track of nested errors:

Return

 

ErrorLevel .= "U0"

Return 1

 

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

{{works with|BBC BASIC for Windows}}

U0& = 123

U1& = 124

ENDCASE

ENDPROC

{{out}} (the second message is output by the default error handler):

<pre>Exception U0 caught in foo

U0 and U1 are boring for debugging purposes. Added something to help with that.

 

#include <stdlib.h>

 

 

 

{{out}}

<pre>Foo entering bar.

Bar door is closed.

*** Error: U1 Bartender Error. Bartender kicked customer out of bar Baz.

</pre>

 

aborting the task, typically with an error message.

 

class U0 {};

class U1 {};

std::cout<< "Should never get here!\n";

return 0;

 

Result:

The exact behavior for an uncaught exception is implementation-defined.

 

 

 

 

<pre>

</pre>

 

 

=={{header|Common Lisp}}==

 

(define-condition user-condition-2 (error) ())

 

 

(trace foo bar baz)

 

{{out}} (the numbered lines are output from <code>trace</code>):

1: (BAR USER-CONDITION-1)

2: (BAZ USER-CONDITION-1)

foo: Caught: Condition USER-CONDITION-1 was signalled.

1: (BAR USER-CONDITION-2)

 

At this point, the debugger (if any) is invoked

with the unhandled condition of type USER-CONDITION-2.

 

=={{header|D}}==

First exception will be caught and message will be displayed,

second will be caught by default exception handler.

this() @safe pure nothrow { super("U0 error message"); }

}

void main() {

foo;

{{out}}

<pre>test.U1(at)test.d(8): U1 error message

=={{header|Delphi}}==

{{Trans|D}}

 

{$APPTYPE CONSOLE}

begin

Foo;

 

{{out}}

 

The uncaught exception shows a Windows Error Report dialog.

 

=={{header|DWScript}}==

{{Trans|D}}

First exception will be caught and message will be displayed, second will be caught by default exception handler.

type Exception2 = class (Exception) end;

 

end;

 

Result:

<pre>Exception1 caught

User defined exception: Error message 2</pre>

 

=={{header|Eiffel}}==

 

A file called main.e:

inherit EXCEPTIONS

 

end

end

 

{{out}}

Developer exception:</pre>

 

 

 

 

 

 

{{out}}

<pre>

</pre>

 

=={{header|Erlang}}==

-module( exceptions_catch ).

 

 

end.

{{out}}

<pre>

in call from exceptions_catch:'-task/0-lc$^0/1-0-'/1 (src/exceptions_catch.erl, line 5)

in call from exceptions_catch:'-task/0-lc$^0/1-0-'/1 (src/exceptions_catch.erl, line 5)

</pre>

 

=={{header|Fantom}}==

 

const class U0 : Err

{

}

}

 

{{out}}

The second exception is not handled, and results in the program finishing

and printing a stack trace.

 

=={{header|Go}}==

The solution here is to define a wrapper, or proxy function, called try.

Function foo calls bar indirectly through try.

//

// As all Go programmers should know, the Go authors are sharply critical of

}

trace("complete")

{{out}}

<pre>

</pre>

A simpler example, closer to the task description:

 

import "fmt"

foo()

fmt.Println("No panic")

[http://play.golang.org/p/X2pa8zE1Ce Run in Go Playground].

{{out}}

=={{header|Haskell}}==

 

import Control.Monad.Trans (lift)

 

case result of

Left e -> putStrLn ("Caught error at top level: " ++ show e)

 

{{out}}

not found in languages that natively support exceptions.</i>

 

 

class U0 : Exception()

initial U0().throw("First exception")

U1().throw("Second exception")

 

{{out}}

Note: it may be possible to implement exceptions in Icon; however,

it would require a major rework and would likely be inelegant.

 

=={{header|J}}==

J leaves most of the implementation of exceptions to the programmer, so:

 

smoutput 'main'

try. foo ''

smoutput ' baz'

type_jthrow_=: 'U',":y throw.

 

'''Example use:'''

main

foo

bar

baz

 

=={{header|Java}}==

(or a superclass thereof), unless they are unchecked exceptions

(subclasses of <code>RuntimeException</code> or <code>Error</code>):

class U1 extends Exception { }

 

foo();

}

{{out}}

<pre>

The <code>callee.name</code> property, and the <code>catch(e if ...)</code> statement are Mozilla JavaScript extensions.

 

U.prototype.toString = function(){return this.className;}

 

}

 

{{out}} from [[Rhino]]:

<pre>caught exception U0

<pre>caught exception U0

uncaught exception: U1</pre>

 

=={{header|Lasso}}==

but we can easily add one like so.

 

local(

gb = givenblock,

var(bazzed) ? fail('U1') | $bazzed = true

fail('U0')

 

{{out}}

 

=={{header|Lua}}==

function baz()

if baz_counter==1 then

 

foo()

output:

<pre>lua: errorexample.lua:31: U1

[C]: ?</pre>

 

 

bar[i_] := baz[i];

baz[i_] := Switch[i,

1, Throw["Exception U0 in baz"];,

Output:

<pre> foo[]

-> Exception U0 in baz</pre>

 

=={{header|MATLAB}} / {{header|Octave}}==

function foo()

 

foo();

 

message: [1x177 char]

identifier: 'BAZ:U0'

 

Error in ==> exceptionsCatchNestedCall at 29

 

=={{header|Nemerle}}==

using System.Console;

 

}

}

{{out}}

<pre>Exception U0 caught.

at NestedExceptions.NestedExceptions.Main()</pre>

 

 

proc baz(i) =

echo "Function foo caught exception U0"

 

{{out}}

<pre>Function foo caught exception U0

 

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

@end

@interface U1 : NSObject { }

}

return 0;

{{out}}

<pre>

 

=={{header|OCaml}}==

exception U1

 

done

 

<pre>

Function foo caught exception U0

Exception: U1.

</pre>

 

 

Exceptions are caught by pattern matching.

proc {Foo}

for I in 1..2 do

end

in

 

{{out}}

%**--------------------------------------------------------------

</pre>

 

=={{header|Pascal}}==

=={{header|Perl}}==

Note: Both exceptions are caught and one is re-raised rather than only one being caught.

foreach (0..1) {

eval { bar($_) };

}

 

{{out}}

<pre>

</pre>

 

 

 

 

 

=={{header|PicoLisp}}==

(for Tag '(U0 U1)

(catch 'U0

 

(mapc trace '(foo bar baz))

{{out}}

<pre> foo :

 

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

/* Exceptions: Catch an exception thrown in a nested call */

test: proc options (main);

m = foo();

end test;

 

DESCRIPTION OF EXECUTION:

There is no extra syntax to add to functions and/or methods such as ''bar'',

to say what exceptions they may raise or pass through them:

class U1(Exception): pass

 

raise U1 if i else U0

 

{{out}}

<pre>

through the nested function calls together with the name of the

uncaught exception, (U1) to stderr, then quit the running program.

 

=={{header|R}}==

in your own environment.

See ?new.env and ?get.

number_of_calls_to_baz <- 0

 

stop(e)

}

Example Usage:

foo() # Error: U0

traceback()

{{out}}

<pre>

 

=={{header|Racket}}==

#lang racket

 

(foo)

{{out}}

Function foo caught exception U0

. . failed 1

 

 

 

 

{{out}}

exception U0 caught in FOO

</pre>

 

=={{header|Ruby}}==

end

end

 

end

 

end

 

 

 

The first call to foo causes the U0 exception. It gets rescued.

The second call results in a U1 exception which is not rescued,

so the program dumps a stacktrace and exits.

{{out}}

captured exception U0

 

=={{header|Scala}}==

{{libheader|Scala}}

class U0 extends Exception

class U1 extends Exception

foo

}

Exception U0 is caught, exception U1 is caught and re-thrown.

Program execution is terminated as the U1 exception is not caught

is not [http://seed7.sourceforge.net/manual/errors.htm#Handlers handled]

the program is terminated and a [http://seed7.sourceforge.net/manual/errors.htm#Stack_trace stack trace] is written.

 

const EXCEPTION: U0 is enumlit;

begin

foo;

 

{{out}}

</pre>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

=={{header|Tcl}}==

 

{{works with|Tcl|8.5}}

 

proc foo {} {

 

foo

{{out}}

<pre>$ tclsh85 exceptions.tcl

=={{header|TXR}}==

 

@(defex u1)

@(define baz (x))

@(end)

@(define foo ())

@ (collect)

@num

@ (end)

@(end)

 

{{out|Run}}

caught u0: text0

txr: unhandled exception of type u1:

</pre>

 

=={{header|Ursala}}==

if baz raises an exception.

The exception is caught or not by foo.

 

baz =

guard(

:/'foo received this result from normal termination of bar:'+ bar,

Note that the definition of bar includes no conditional (?) or exception

handling operators, and is written without regard for any exceptions.

baz threw a user-defined empty string exception

U1</pre>

 

=={{header|zkl}}==

class U1(Exception.Exception){fcn init{Exception.init("U1")}}

 

fcn bar(e){baz(e)}

fcn baz(e){throw(e)}

{{out}}

<pre>