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

{{Task|Control Structures}}

{{omit from|GUISS}}

{{omit from|M4}}

{{omit from|Retro}}

 

Show how to create a user-defined exception   and   show how to catch an exception raised from several nested calls away.

Show/describe what happens when the program is run.

<br><br>

 

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

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

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

}

 

{{out}}

</pre>

 

 

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

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

(define (foo)

(for ((i 2))

"U0 raised" catched

👓 error: U1 not catched

 

=={{header|Eiffel}}==

 

A file called main.e:

inherit EXCEPTIONS

 

end

end

 

{{out}}

Developer exception:</pre>

 

{{out}}

<pre>

</pre>

 

=={{header|Elixir}}==

defmodule U1, do: defexception [:message]

 

end

 

 

{{out}}

<pre>

U0 rescued

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

"We caught U0"

jq: error: U1

 

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

errorexample.lua:34: in main chunk

[C]: ?</pre>

 

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

</pre>

Output 3. call to foo():<pre>3</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

 

=={{header|REXX}}==

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

from exception.rb:2:in `foo'

from exception.rb:23:in `<main>'</pre>

 

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

 

 

 

 

 

 

 

 

 

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

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>