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

 

Show/describe what happens when the program is run.

 

=={{header|Ada}}==

 

procedure Exceptions_From_Nested_Calls is

Foo;

end loop;

<pre>

Procedure Foo caught exception U0

raised EXCEPTIONS_FROM_NESTED_CALLS.U1 : exceptions_from_nested_calls.adb:13

</pre>

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

 

<pre>

Function foo caught exception u0

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

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

=={{header|AutoHotkey}}==

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

#include <stdlib.h>

 

 

 

}

 

}

 

}

 

}

 

}

 

}

 

 

}

}

}

 

</pre>

 

=={{header|C sharp|C#}}==

This example will first catch U0 and print "U0 Caught" to the console when it does. The uncaught U1 exception will then cause the program to terminate and print the type of the exception, location of the error, and the stack.

 

class Exceptions

{

foo();

}

 

<pre>

U0 Caught

</pre>

 

 

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

 

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

 

 

(trace foo bar baz)

 

1: (BAR USER-CONDITION-1)

2: (BAZ USER-CONDITION-1)

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

1: (BAR USER-CONDITION-2)

 

 

 

}

 

class U1 : Exception {

}

 

void foo() {

try {

}

}

}

 

 

}

 

void main() {

Exception U0 caught</pre>

 

=={{header|Eiffel}}==

 

A file called main.e:

inherit EXCEPTIONS

 

end

end

 

<pre>Caught U0 exception.

Won't catch U1 exception...

Exception number 3 not handled.

Developer exception:</pre>

 

=={{header|Fantom}}==

 

const class U0 : Err

{

}

}

 

<pre>

Caught U0

</pre>

 

 

=={{header|Go}}==

Not strictly conforming to task description as foo does not directly call bar.

 

//

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

var cs = make([]uintptr, 10)

 

 

// try implents the try/catch-like exception mechanism. It takes a function

if px, ok := pv.(exception); ok {

for _, ex := range exs {

trace("handling exception")

trace("panic over")

return

}

 

var u0, u1 exception

 

func foo() {

trace("start")

try(bar, []exception{u0})

try(bar, []exception{u0})

}

trace("complete")

<pre>

main: start

_func_001: Panic mode!

_func_001: can't recover this one!

 

----- stack segment boundary -----

</pre>

 

=={{header|Haskell}}==

 

import Control.Monad.Trans (lift)

 

case result of

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

 

foo

bar

baz

Caught error at top level: U1

 

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

 

 

 

class U0 : Exception()

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

U1().throw("Second exception")

 

<pre>

U0: First exception:

</pre>

 

 

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

class U1 extends Exception { }

 

foo();

}

<pre>

Function foo caught exception U0

at ExceptionsTest.main(ExceptionsTest.java:27)

</pre>

 

 

=={{header|JavaScript}}==

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

 

}

 

<pre>caught exception U0

js: "nested_calls.js", line 31: exception from uncaught JavaScript throw: U1</pre>

<pre>caught exception U0

uncaught exception: U1</pre>

 

=={{header|Lua}}==

function baz()

if baz_counter==1 then

 

foo()

output:

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

[C]: ?</pre>

 

function foo()

 

foo();

 

message: [1x177 char]

identifier: 'BAZ:U0'

 

Error in ==> exceptionsCatchNestedCall at 29

 

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

@end

@interface U1 : NSObject { }

void baz(int i) {

if (i == 0)

else

}

 

 

int main (int argc, const char * argv[]) {

 

 

return 0;

<pre>

2011-06-03 23:11:53.871 Untitled[9968:903] Function foo caught exception U0

 

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

 

<pre>

Procedure Foo caught exception u0

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

</pre>

 

=={{header|Perl}}==

foreach (0..1) {

eval { bar($_) };

}

 

<pre>

Function foo caught exception U0

...propagated at exceptionsnested.pl line 5.

</pre>

 

=={{header|PicoLisp}}==

(for Tag '(U0 U1)

(catch 'U0

 

(mapc trace '(foo bar baz))

<pre> foo :

bar : U0

 

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

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

test: proc options (main);

m = foo();

end test;

 

DESCRIPTION OF EXECUTION:

Function FOO is invoked.

FOO invokes BAR. BAR invoked BAZ.

by a SIGNAL statement and the condition U1 was signaled.

At offset +0000010D in procedure with entry FOO

 

=={{header|Python}}==

class U1(Exception): pass

 

bar(i)

except U0:

 

def bar(i):

raise U1 if i else U0

 

<pre>

Function foo caught exception U0

U1

</pre>

 

 

=={{header|R}}==

number_of_calls_to_baz <- 0

 

stop(e)

}

Example Usage:

foo() # Error: U0

traceback()

<pre>

6: stop(e) at file.r#11

2: tryCatch(bar()) at file.r#4

1: foo()

</pre>

 

=={{header|Ruby}}==

end

end

 

end

 

end

 

 

 

captured exception U0

foo

 

=={{header|Tcl}}==

{{works with|Tcl|8.5}}

 

proc foo {} {

 

foo

<pre>$ tclsh85 exceptions.tcl

caught exception U0

"foo"

(file "exceptions.tcl" line 26)</pre>

 

=={{header|Ursala}}==

 

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.

<pre>

$ echo "valid input" | foo

U1</pre>