Exception handling

Summary

In computing and computer programming, exception handling is the process of responding to the occurrence of exceptions – anomalous or exceptional conditions requiring special processing – during the execution of a program. In general, an exception breaks the normal flow of execution and executes a pre-registered exception handler; the details of how this is done depend on whether it is a hardware or software exception and how the software exception is implemented. Exception handling, if provided, is facilitated by specialized programming language constructs, hardware mechanisms like interrupts, or operating system (OS) inter-process communication (IPC) facilities like signals. Some exceptions, especially hardware ones, may be handled so gracefully that execution can resume where it was interrupted. Definition The definition of an exception is based on the observation that each procedure has a precondition, a set of circumstances for which it will terminate "normally". An

Official source

https://en.wikipedia.org/wiki/Exception_handling

About this result

This page is automatically generated and may contain information that is not correct, complete, up-to-date, or relevant to your search query. The same applies to every other page on this website. Please make sure to verify the information with EPFL's official sources.

Related publications (27)

Related publications

Related people (3)

Related people

Related units (2)

Related units

Related concepts (86)

Related concepts

Related courses (37)

Related courses

Related lectures (62)

Related lectures

In this report we present the specification of the operational semantics of Dart Kernel and a reference implementation of Dart Kernel in Dart. We design a CESK-like machine to specify the operational semantics of Dart Kernel and we implement an interpreter that follows closely the small-step semantics of the language. This approach allows us to define the behaviour of the rich features of Dart Kernel, such as exception handling and asynchronous execution. Since Dart Kernel is an evolving language, the specification is expected to evolve with it and the semantics for new features needs to be defined further. The work done for this project sets the grounds for further formalization of the behaviour of the language with a formal proof management system, as Coq.

2017

The chief aim of this survey is to discuss exception handling models which have been developed for concurrent object systems. In conducting this discussion we rely on the following fundamental principles: exception handling should be associated with structuring techniques; concurrent systems require exception handling which is different from that used in sequential systems; concurrent systems are best structured out of (nested) actions; atomicity of actions is crucial for developing complex systems. In this survey we adhere to the well-known classification of concurrent systems, developed in the 70s by C.A.R. Hoare, J.J. Horning and B. Randell, into cooperative, competitive and disjoint ones. Competitive systems are structured using atomic transactions. Atomic actions are used for structuring cooperative systems. Complex systems in which components can compete and cooperate are structured using Coordinated Atomic actions. The focus of the survey is on outlining models and schemes which combine these action-based structuring approaches with exception handling. In conclusion we emphasise that exception handling models should be adequate to the system development paradigm and structuring approaches used.

2001

Implementing Exceptions in Open Multithreaded Transactions

Jörg Kienzle

This position paper shows how Ada 95 exceptions have been used in a prototype implementation of a transaction support in order to provide more elaborate exception handling. The paper summarizes the open multithreaded transaction model, which is a transaction model suitable for concurrent programming languages, and analyzes the exception mechanism provided by the Ada 95 programming language. Different interfaces to the transaction support for the application programmer are presented, and the problems encountered during implementation of the prototype with respect to exception handling are discussed.

ACM Press2001