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

 

 

}

}

}

 

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

 

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

 

function foo()

 

foo();

 

message: [1x177 char]

identifier: 'BAZ:U0'

 

Error in ==> exceptionsCatchNestedCall at 29

 

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

 

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