This is assignment from my Concept of Programming Language lecturer
Mr. Tri Djoko Wahjono
1. Define exception, exception handler, raising an exception, disabling an exception, continuation, finalization, and built-in exception.
– Exception : any unusual event, erroneous or not, that is detectable by either hardware or software and that may require special processing.
Exception handler : a code unit which processes an exception.
Raising an exception : When a event associated with an exception occurs
Disabling an exception : Ignoring a certain hardware-detectable exceptions.
Continuation : Control transfer to somewhere in the program outside of the handler code or program might terminate .
Finalization : ability to complete some computation regardless of how subprogram execution terminates.
Built-in exception : Exception that is not made by the user, but rather comes as default.
2. When is an exception thrown or raised ?
– When an event associated with an exception occurs
3. What are the advantages of having support for exception handling built in to a language ?
– Without built-in exception handling, the code to detect error condition can be a clutter to the program. Existence of built-in exception handling would simplify a source program.
4. Give an example of hardware-detectable execution.
– Division by zero
5. What does it mean for an exception to be bound to an exception handler ?
– A specific exception is to be handled by a specific exception handler also, because different exceptions are to be treated differently.
6. What is exception propagation in Ada ?
– A powerful tool for constructing more reliable software systems.
8. Where does execution continue after an exception is handled in Ada ?
– Control simply continues after the exception clause.
10. What are the four exceptions defined in the Standard package of Ada ?
– Constraint_Error,Program_Error,Storage_Error, and Tasking_Error.
11. Are there any predefined exceptions in Ada ?
– Yes, there are, for example Ada.Text_IO defines the End_Error exception.
12. What is the use of Suppress pragma in Ada ?
– Run-time checks that are parts of built-in exceptions can be disabled in Ada programs
13. Describe three problems with Ada’s exception handling.
– The propagation model, which allows exceptions to be propagated to an outer scope in which the exception is not visible, inadequacy of exception handling for tasks, and exception handling was not extended to deal with new constructs in Ada 95.
1. What mechanism did early programming languages provide to detect to attempt to deal with errors ?
– There were no possibility for the user program to detect or attempt to deal with errors. In case if error happens, the program will be terminated and control will be transferred to the operating system.
2. Describe the approach for the detection of subscript range errors used in C and Java.
– C does not check subscript ranges. While in Java, compilers usually generate a code to check the correctness of every subscript expression. If any exception generates, an unchecked exception is thrown.
6. In languages without exception-handling facilities, it is common to have most subprograms include an “error” parameter, which can be set to some values representing “OK” or some other value representing “error in procedure”. What advantage does a linguistic exception-handling facility like that of Ada have over this method?
– There are several advantages, for example in Ada, using an error flag parameter in all subprograms. One advantage is that the code to test the error is eliminated after every call. Such test code makes program longer and harder to read. Second advantage is that exceptions can be propagated farther in a uniform and implicit way. Also, there is an advantage that all program use a similar method to deal with exceptions, which enhances readability.
7. In a language without exception-handling facilities, we could send an error-handling procedure as a parameter to each procedure that can detect errors that must be handled. What disadvantages are there to this method ?
– There are several disadvantages of sending error handling subprograms to other subprograms. One is that it may be necessary to send several error handlers to some subprograms, greatly complicating both the writing and execution of calls. Another is that there is no method of propagating exceptions, meaning that they must all be handled locally. This complicates exception handling, because it requires more attention to handling in more places.