Advanced Exception Handling Techniques

1. Chapter 14 Exception Handling and Event Handling

2. Chapter 14 Topics • Introduction to Exception Handling (EH) • Exception Handling in Ada • Exception Handling in C++ • Exception Handling in Java

3. Introduction to Exception Handling • In a language without exception handling (EH) • When an exception occurs, control goes to the operating system, where a message is displayed and the program is terminated • In a language with exception handling • Programs are allowed to trap some exceptions, thereby providing the possibility of fixing the problem and continuing on

4. Example

5. Basic Concepts • Many languages allow programs to trap input/output errors (including EOF) • An exceptionis any unusual event, either erroneous or not, detectable by either hardware or software, that may require special processing • If special processing is required after detecting an exception, the processing is called exception handling • The exception handling code unit is called an exceptionhandler

6. EOF Example in C++ #include <iostream.h>#include <fstream.h>#include <assert.h> int main(void){int data;    // file contains an undermined number of integersifstream fin; // declare stream variable name fin.open("myfile",ios::in); // open file     assert (!fin.fail( ));          fin >> data;  // get first number from the file (priming the input statement)// You must attempt to read info prior to an eof( ) test.     while (!fin.eof( )) //if not at end of file, continue reading     {cout<<data<<endl;   //print numbers to screen          fin >> data;        //get next number from file     }fin.close( );       //close file     assert(!fin.fail( ));     return 0;} EOF is a exception that is handled by this program

7. Exception Handling Alternatives • An exception is raised when its associated event occurs • A language that does not have exception handling capabilities can still define, detect, raise, and handle exceptions • However, it requires user’s definition • Software detected • Alternatives: • Define an auxiliary parameter or use the return value to indicate the return status of a subprogram • Explicitly call an exception handling subprogram to all subprograms

8. Advantages of Built-in Exception Handling • So, why we still prefer Exception Handling? • Error detection code is tedious to write and it clutters the program • Exception handling forces programmers to consider many different possible errors • Exception propagation allows exception handling code to be reused

9. Design Issues • How are exception handlers specified? • What is scope of exception handler? • How is an exception occurrence bound to an exception handler? • Can information about the exception be passed to the handler? • Where does execution continueafter an exception handler completes its execution? • continuation vs. resumption • Is there any form of finalization activities needed?

10. Design Issues (continued) • How to specify a user-defined exceptions? • Should a language provide default exception handlers for a program, which do not its own? • Can predefined exceptions be explicitly raised? • Should hardware-related errors be treated as exceptions? • Are there any predefined exceptions? • How can exceptions be disabled?

11. Exception Handling Control Flow

12. Exception Handling in Ada • The frame of an exception handler in Ada is either a subprogram body, a package body, a task, or a block • Because exception handlers are usually local to the code, they do not have parameters

13. Ada Exception Handlers • Handler form: whenexception_choice{|exception_choice} => statement_sequence ... [when others => statement_sequence] exception_choice form: exception_name | others • Handlers are placed at the end of the block or unit, where they occur

14. Ada Example with Ada.Exceptions, Ada.Text_IO; procedure Foo is Some_Error : exception; begin Do_Something_Interesting; exception -- Start of exception handlers whenConstraint_Error=> ... -- Handle constraint error whenStorage_Error => -- Propagate Storage_Error as a different exception with a useful message raiseSome_Error with "Out of memory"; whenError : others => -- Handle all others Ada.Text_IO.Put("Exception: "); Ada.Text_IO.Put_Line(Ada.Exceptions.Exception_Name(Error)); Ada.Text_IO.Put_Line(Ada.Exceptions.Exception_Message(Error)); end Foo;

15. Binding Exceptions to Handlers • If the block or unit does not have a handler for an exception, the exception is propagated elsewhere to be handled • Procedure - propagate it to the caller • Block - propagate it to the scope, where it appears • Package body - propagate it to the declaration part of the unit that declared the package • if it is a library unit, the program is terminated • Task • No propagation; if it has a handler, execute it; in either case, mark it "completed"

16. Continuation • The block/unit that raises an exception but does not handle it  Always terminated!

17. Other Design Choices • User-defined Exceptions form: exception_name_list : exception; • Raising Exceptions form: raise [exception_name] • (the exception name is not required if it is in a handler--in this case, it propagates the same exception) • Exception conditions can be disabled with: pragam SUPPRESS(exception_list) • Predefined Exceptions • Constraint_Error- index constraints, range constraints, etc. • Program_Error - call to a subprogram whose body has not been elaborated • Storage_Error - system runs out of heap • Tasking_Error - an error associated with tasks

18. Evaluation • The Ada design for exception handling demonstrates the state-of-the-art in language design in 1980 • It was the only widely used language with exception handling until it was added to C++ • The propagation model allows exceptions to be propagated to an outer scope, where the exception would not be visible • Therefore, it is not always possible to determine the origin of propagated exceptions • Exception handling is inadequate for tasks

19. C++ Exception Handlers • Added to C++ in 1990 • Exception Handlers Form: try { -- code that is expected to raise an exception } catch (formal parameter) { -- handler code } ... catch (formal parameter) { -- handler code }

20. C++ Example #include <exception> int main() { try { // do something (might throw an exception) } catch (conststd::exception& e) { // handle exception e } catch (...) { // unknown exception, should not happen } }

21. The catch Function • catch is the name of all handlers • it is an overloaded name, so the formal parameter of each must be unique • The formal parameter need not have a variable • It can be simply a type name to distinguish it from others • The formal parameter can be used to transfer information to the handler • The formal parameter can be an ellipsis, such that it handles all exceptions not yet handled

22. Throwing Exceptions • Exceptions are all raised explicitly by the statement: throw [expression]; • The brackets are metasymbols • A throw without an operand can only appear in a handler; when it appears, it simply re-raises the exception, which is then handled elsewhere • The type of the expression disambiguates the intended handler

23. Unhandled Exceptions • If there is an unhandled exception in a function • The exception will be propagated to the caller of that function • This propagation continues • Until it reaches to the main function • If no handler is found, then the default handler will be called

24. Continuation • After a handler completes its job, control flow moves to the first statement immediately after the try construction • Other design choices • All exceptions are user-defined • Exceptions are neither specified nor declared • The default handler, unexpected, simply terminates the program; unexpected can be redefined by the user • Functions can list the exceptions they may raise • Without a specification, a function can raise any exception (the throw clause)

25. Evaluation • Similar to Ada • User cannot specify hardware-related exceptions • Sometimes, since formal parameter of a exception may be omitted • No appropriate handler can be chosen • The formal parameter is need, because we also need to consider the exception of exception handler

26. Exception Handling in Java • Based on that of C++ • but more suitable to OOP • All exceptions are objects of classes that are descendants of the Throwable class

27. Classes of Exceptions • The Java library includes two subclasses of Throwable : • Error • It indicates serious problems that a reasonable application should not try to catch. • Thrown by the Java interpreter for events, such as heap overflow • Never handled by user programs • Exception • It indicates conditions that a reasonable application might want to catch • User-defined exceptions are usually subclasses of this class • Has two predefined subclasses, • IOException • RuntimeException (e.g., ArrayIndexOutOfBoundsException and NullPointerException

28. Java Exception Handlers • Similar to those of C++ • except every catch requires a named parameter and all parameters must be descendants of Throwable • e.g., ArrayIndexOutOfBoundsException and NullPointerException • Syntax of try clause is exactly like C++ • Like C++, exceptions are thrown with throw, but often the throw includes the new operator to create the object, as in: throw new MyException();

29. Java Throw Example // This is now correct. class ThrowsDemo{ static void throwOne() throws IllegalAccessException { System.out.println("Inside throwOne."); throw new IllegalAccessException("demo"); } public static void main(String args[]) { try { throwOne(); } catch (IllegalAccessException e) { System.out.println("Caught " + e); } } } // This program contains an error and will not compile. class ThrowsDemo{ static void throwOne() { System.out.println("Inside throwOne."); throw new IllegalAccessException("demo"); } public static void main(String args[]) { throwOne(); } }

30. Binding Exceptions to Handlers • Binding an exception to a handler is simpler in Java than it is in C++ • An exception can be handled and re-thrown by including a throwin the handler (a handler could also throw a different exception)

31. Continuation • If no handler is found in the try construct, the search is continued in the nearest enclosing try construct • If no handler is found in the method, the exception is propagated to the method’s caller • If the exception is propagated all the way to main(), and still no handler is found; the program is terminated • To insure that all exceptions are caught, a handler can be included in any try construct that catches all exceptions • Simply use an Exceptionclass parameter • Of course, it must be the last in the try construct

32. Checked and Unchecked Exceptions • The Java throws clause is quite different from the throw clause of C++ • Exceptions of class Error and RunTimeException and all of their descendants are called unchecked exceptions • All other exceptions are called checked exceptions • Checked exceptions that may be thrown by a method must be either: • Listed in the throws clause, or • Handled in the method

33. The finally Clause • Can appear at the end of a try construct • Form: finally { ... } • Purpose  To specify code that is to be executed, regardless of what happens in the try construct

34. Example • A try construct with a finally clause can be used outside exception handling try { for (index = 0; index < 100; index++) { … if (…) { return; } //** end of if } //** end of try clause finally { … } //** end of try construct

35. Classic Java Interview Questions • What’s the difference between final, finally, and finalize • final can be used to mark a variable "unchangeable" or a methodnot "overrideable" private final String name = "foo"; //the reference name can never change finally is used in a try/catch statement to execute code "always" lock.lock(); try { //do stuff } catch (SomeException se) { //handle se } finally { lock.unlock(); //always executed, even if Exception or Error or se } public void finalize() { //free resources (e.g. unallocate memory) super.finalize(); } finalize is called when an object is garbage collected

36. Assertions • Statements in the program declaring a boolean expression regarding the current state of the computation • When evaluated to true nothing happens • When evaluated to false an AssertionErrorexception is thrown • Can be disabled during runtime without program modification or recompilation • Two forms • assertcondition; • assertcondition: expression;

37. Assertion Example When you enter the number within range, output will be displayed like: When you enter  the number out of range, output will be like:

38. Evaluation • The types of exceptions makes more sense than in Java • The throws clause is better than that of C++ • The throw clause in C++ says little to the programmer • The finally clause is always useful • The Java interpreter throws a variety of exceptions that can be handled by user programs

39. Summary • Ada provides extensive exception-handling facilities with a comprehensive set of built-in exceptions. • C++ includes no predefined exceptions • Exceptions are bound to handlers by connecting the type of expression in the throw statement to that of the formal parameter of the catch function • Java exceptions are similar to C++ exceptions except that a Java exception must be a descendant of the Throwable class. Additionally Java includes a finally clause