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

=== True exceptions ===

{{works with|AutoHotkey_L}}

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 thread has exited.</pre>

=== ErrorLevel-based exceptions ===

[[AutoHotkey_Basic]] has very simple support for error tracking.

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

<pre>Exception U0 caught in foo

 

 

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

 

 

 

 

 

}

 

}

 

try {

}

}

}

 

void main() {

----------------

\test.d(20): pure void test.bar(int)

=={{header|Delphi}}==

{{Trans|D}}

 

{$APPTYPE CONSOLE}

begin

Foo;

 

<pre>

Exception U0 caught

 

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

 

<pre>Caught U0 exception.

Won't catch U1 exception...

Developer exception:</pre>

 

 

end

 

 

 

 

 

 

<pre>

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

}

trace("complete")

<pre>

main: start

main.main()

t.go:61 +0x31

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

=={{header|Perl}}==

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

foreach (0..1) {

eval { bar($_) };

}

 

<pre>

Function foo caught exception U0

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

=={{header|TXR}}==

 

@(defex u1)

@(define baz (x))

@(end)

@(define foo ())

@ (collect)

@num

@ (end)

@(end)

 

<pre>$ txr except.txr

caught u0: text0

txr: unhandled exception of type u1:

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