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

=={{header|11l}}==

{{trans|Python}}

T U1 {}

 

F baz(i)

I i == 0

E

 

F bar(i)

print(‘Function foo caught exception U0’)

 

 

{{out}}

 

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

 

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

{{works with|Dyalog APL}}

 

⍝ Traps (exceptions) are just numbers

⍝ 500-999 are reserved for the user

⎕SIGNAL U0 U1[i]

∇

 

{{out}}

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.

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();

}

 

{{out}}

aborting the task, typically with an error message.

 

class U0 {};

class U1 {};

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

return 0;

 

Result:

 

=={{header|Clojure}}==

(def U1 (ex-info "U1" {}))

 

 

(defn -main [& args]

 

{{output}}

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

=={{header|Crystal}}==

 

end

 

end

 

 

<pre>

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

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

=={{header|Dyalect}}==

 

func baz() {

bazCallCount += 1

if bazCallCount == 1 {

} else if bazCallCount == 2 {

}

}

func bar() {

baz()

}

func foo() {

var calls = 2

bar()

} catch {

}

calls -= 1

}

 

{{out}}

 

 

=={{header|EchoLisp}}==

(define (foo)

(for ((i 2))

"U0 raised" catched

👓 error: U1 not catched

 

=={{header|EGL}}==

{{incorrect|EGL|calls to bar() from foo should be equivalent. Second call can't catch anything.}}

end

 

end

end

 

{{out}}

 

A file called main.e:

inherit EXCEPTIONS

 

end

end

 

{{out}}

 

=={{header|Elena}}==

class U0 : Exception

{

}

class U1 : Exception

{

}

singleton Exceptions

{

}

}

{

Exceptions.foo()

{{out}}

<pre>

U0 Caught

Call stack:

</pre>

 

=={{header|Elixir}}==

defmodule U1, do: defexception [:message]

 

end

 

 

{{out}}

 

=={{header|Erlang}}==

-module( exceptions_catch ).

 

 

end.

{{out}}

<pre>

 

=={{header|Factor}}==

IN: rosetta-code.nested-exceptions

 

] twice ;

 

{{out}}

<pre>

=={{header|Fantom}}==

 

const class U0 : Err

{

}

}

 

{{out}}

=={{header|FreeBASIC}}==

FreeBASIC does not support exceptions or the Try/Catch/Finally statement, as such. However, you can use the Err() function, together with an If (or Switch) statement, to provide somewhat similar functionality:

 

Enum ErrorTypes

Print

Print "Press any key to quit"

 

{{out}}

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

 

=={{header|Io}}==

U1 := Exception clone

 

)

 

{{out}}

<pre>foo caught U0

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

=={{header|jq}}==

{{works with|jq|>1.4}}

def baz(n):

if n==0 then error("U0")

(try bar(1) catch if . == "U0" then "We caught U0" else error(.) end);

 

{{out}}

$ jq -n -f Catch_an_exception_thrown_in_a_nested_call.jq

{{works with|Julia|0.6}}

 

struct U1 <: Exception end

 

end

 

 

{{out}}

 

=={{header|Kotlin}}==

 

class U0 : Throwable("U0 occurred")

fun main(args: Array<String>) {

foo()

 

{{out}}

There is no explicit try block. A catch implicitly wraps the instructions preceding it within a block into a try block.

 

val .U1 = h{"msg": "U1"}

 

 

for .i in [0, 1] {

.bar(.i)

}

}

 

 

{{out}}

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

 

=={{header|Maple}}==

end proc:

 

 

local i;

for i from 0 to 1 do

end do;

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

 

bar[i_] := baz[i];

baz[i_] := Switch[i,

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

Output:

<pre> foo[]

 

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

function foo()

 

foo();

 

{{out}}

message: [1x177 char]

identifier: 'BAZ:U0'

 

Error in ==> exceptionsCatchNestedCall at 29

 

=={{header|Nemerle}}==

using System.Console;

 

}

}

{{out}}

<pre>Exception U0 caught.

 

=={{header|Nim}}==

type U1 = object of Exception

 

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

Exceptions are used everywhere in OCaml, they are easy to write, and they are cheap.

exception U1

 

done

 

{{out}}

<pre>

=={{header|Oforth}}==

 

Exception Class new: U1

try: e [ 0 bar ] when: [ e isKindOf(U0) ifTrue: [ "Catched" .cr ] else: [ e throw ] ]

try: e [ 1 bar ] when: [ e isKindOf(U0) ifTrue: [ "Catched" .cr ] else: [ e throw ] ]

 

{{out}}

 

Exceptions are caught by pattern matching.

proc {Foo}

for I in 1..2 do

end

in

 

{{out}}

 

=={{header|PARI/GP}}==

 

U0() = error("x = ", 1, " should not happen!");

baz(x) = if(x==1, U0(), x==2, U1());x;

bar() = baz(call++);

 

Output 1. call to foo():<pre>Caught exception, call=1</pre>

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

 

=={{header|Phix}}==

Phix does not have "exception classes" as such, instead you can just throw any string (on it's own) or any integer, optionally

with any (deeply nested) user_data that you like. All exceptions are always caught, however rethrowing is trivial.<br>

As per the discussion for Go, I should say that "bar(); bar();" cannot work - if you catch an exception from the first call,

control resumes within the catch handler, with no way to invoke that second bar(). But a simple loop does the trick.

{{out}}

<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

 

=={{header|Raku}}==

(formerly Perl 6)

{{trans|Perl}}

for 0..1 -> $i {

bar $i;

sub baz($i) { die "U$i" }

 

{{out}}

<pre>Function foo caught exception U0

<br>This type of exception handling (in REXX) has its limitation &nbsp;

(the label is known global to the program, but not to external subroutines).

call foo /*invoke the FOO function (below). */

say 'The REXX mainline program has completed.' /*indicate that Elroy was here. */

/* [↓] this U0 subroutine is ignored.*/

U0: return -1 /*handle exception if not caught. */

'''output'''

<pre>

 

=={{header|Ruby}}==

2.times do |i|

begin

class U1 < StandardError; 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,

=={{header|Rust}}==

Rust has panics, which are similar to exceptions in that they default to unwinding the stack and the unwinding can be caught. However, panics can be configured to simply abort the program and thus cannot be guaranteed to be catchable. Panics should only be used for situations which are truly unexpected. It is prefered to return an Option or Result when a function can fail. <code>Result<T, U></code> is an enum (or sum type) with variants <code>Ok(T)</code> and <code>Err(U)</code>, representing a success value or failure value. <code>main</code> can return a Result, in which case the debug representation of the error will be shown.

enum U {

U0(i32),

fn main() -> Result<(), U> {

foo()

{{out}}

<pre>Caught U0 in foo: 42

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

 

=={{header|Sidef}}==

 

func foo {

[0, 1].each { |i|

try { bar(i) }

}

}

 

{{out}}

<pre>

=={{header|Smalltalk}}==

{{works with|GNU Smalltalk}}

Exception subclass: #U0.

Exception subclass: #U1.

"Thirds time's a charm..."]

]

 

Running the code:

st> Foo new foo

'Call to bar was aborted by exception U0'

UndefinedObject>>executeStatements (a String:1)

nil

 

Explanation:<br/>

=={{header|Swift}}==

{{works with|Swift|2.x+}}

case U0

case U1

}

 

{{out}}

<pre>

 

{{works with|Tcl|8.5}}

 

proc foo {} {

 

foo

{{out}}

<pre>$ tclsh85 exceptions.tcl

=={{header|TXR}}==

 

@(defex u1)

@(define baz (x))

@ (end)

@(end)

 

{{out|Run}}

1

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

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

 

Inherits Exception

End Class

End If

End Sub

 

Control passes to the Catch block after U0 is thrown, and so the second call to Bar() is not made.

To prevent this, a loop can be used to run the entire Try statement twice:

 

For i = 1 To 2

Try

End Try

Next

 

{{out}}

 

We can use that approach here, re-throwing the second (uncaught) exception so that it terminates the script.

var U1 = "U1"

 

}

 

 

{{out}}

[./exceptions_nested line 23] in new(_) block argument

[./exceptions_nested line 28] in (script)

</pre>

 

=={{header|zkl}}==

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

 

fcn bar(e){baz(e)}

fcn baz(e){throw(e)}

{{out}}

<pre>