Exception handling is the process of responding to events, during computation, exceptions - anomalous conditions or exceptions requiring special processing - often altering the normal flow of program execution. It is provided by the construction of specialized programming languages, computer hardware mechanisms such as interruptions or IPC operating system facilities such as signals.
In general, exceptions break the normal flow of execution and execute the pre-registration handler . Details about how this is done depend on whether it is an exception to hardware or software and how software exceptions are applied. Some exceptions, especially hardware ones, can be handled so gracefully that execution can continue if disconnected.
An alternative approach to handling exceptions in software is error checking, which maintains normal program flow with explicit checks later for reported contingencies using special return values ​​or some additional global variables such as the status of C's errno or floating point flags; or input validation to first filter out exceptional cases.
Video Exception handling
Handling exceptions in hardware
The hardware exception mechanism is processed by the CPU. This is intended to support error detection and redirect program flow to error handling routines. Status before exceptions are stored on the stack.
Hardware exclusion/handling: floating point IEEE 754
Handling exceptions in standard floating point hardware IEEE 754 refers to exceptional general conditions and specifies exceptions as "an event occurring when operations on certain operands do not have matching results for any plausible application." The operation may indicate one or more exceptions by applying defaults or, if explicitly requested, alternate language-defined handling. "
By default, IEEE 754 exceptions may be resumed and handled by replacing the specified values ​​for different exceptions, e.g. infinity to divide by zero exceptions, and give the flag status for later checks if the exception occurs (see C99 programming language for common examples of handling IEEE 754 exceptions). The exception handling styles enabled by the use of status flags include: first computing expressions using fast, direct implementation; check if it fails by testing the status flag; and then, if necessary, invoke slower, more numerically powerful implementations.
The IEEE 754 standard uses the term "trapping" to refer to user-handling exception handling exceptions in exceptional circumstances, and is an optional feature of the standard. This standard recommends several usage scenarios for this, including the application of non-default pre-substitution of a value followed by its return, to deal precisely with removable singularities.
The default behavior of IEEE 754 exception handling of the resumption after pre-substitution of default values ​​avoids the risk inherent in altering the program control flow on numerical exclusion. For example, in 1996 the inaugural flight from Ariane 5 (Flight 501) ended with a massive explosion that was partly due to the programming policy of copies. It handled the policy of aborting calculations on arithmetic errors, which in this case was a 64-bit floating point to a number overflow conversion round 16-bit. In the case of Flight 501 Ariane, programmers protected only four of the seven critical variables to overflow due to concerns about the computing constraints of on-board computers and rely on what turned out to be a false assumption about the possible range of values ​​for three unprotected variables as they reused code from Ariane 4, which they assume is true. According to William Kahan, the loss of Flight 501 would have been avoided if the exception handling policy of the IEEE 754 from the default substitution had been used because of the overflow of 64-bit conversion into 16-bit which caused the software to fail to run in a piece of code that turned out to be completely unnecessary on Ariane 5 The official report on the accident (conducted by the board of inquiry led by Jacques-Louis Lions) notes that "An underlying theme in the development of Ariane 5 is the bias against the mitigation of random failure. Suppliers of inertial navigation systems (SRIs) only follow the specifications given to it, which specifies that in the case of exceptions detected the processor must be discontinued.Exclusions are not due to random failure but design errors.Exclusions are detected, but are handled improperly because the views have been taken software that should be considered true until proven guilty. [...] Despite Failure yes is due to systematic software design errors, mechanisms can be introduced to reduce this type of problem. For example computers in SRI can continue to provide their best estimate of the required attitude information. There is reason to be concerned that software exceptions should be allowed, or even required, to cause the processor to cease when handling mission critical equipment. Indeed, the loss of proper software functions is dangerous because the same software runs on both SRI units. In the case of Ariane 501, this resulted in the transfer of two equally important equipment units. "
From a processing point of view, hardware interference is similar to a resume that can continue, even though it is not normally associated with the user program control flow.
Maps Exception handling
The exception handling facility provided by the operating system
The operating system can provide facilities to handle exceptions in the program through IPC. Typically, the interruptions caused by the execution of a process are handled by the interrupt service routine of the operating system, and the operating system can send signals to the process, which may require the operating system to register the signal handler to be called when the signal is raised, or let the operating system run the default action (such as ending the program). Common examples are SIGSEGV, SIGBUS, SIGILL, and SIGFPE.
Handling exceptions in software
The software handling exceptions and support provided by the software tools are somewhat different from those understood by handling exceptions in hardware, but similar concepts are also involved. In programming language mechanisms for exception handling, the term exceptions is typically used in a special sense to indicate data structures that store information about exceptional conditions. One mechanism for transferring controls, or raising exceptions, known as throw . Exceptions are said removed . Execution is transferred to "catch".
From a routine author's perspective, raising an exception is a useful way of signaling that the routine can not run normally - for example, when the input argument is invalid (eg a value outside the function domain) or when the resource he or she rely on is unavailable (such as a file lost, hard disk error, or error outside memory). In the system without exception, the routine needs to return some special error codes. However, this is sometimes complicated by semipredicate issues, where routine users need to write additional code to distinguish normal return values ​​from the wrong ones.
Programming languages ​​differ substantially in their understanding of what constitutes exceptions. Contemporary languages ​​can be divided into two groups:
- Language where exceptions are designed to be used as flow control structures: Available, Java, Modula-3, ML, OCaml, Python, and Ruby fall into this category.
- The language in which exceptions are only used to handle unexpected and unpredictable wrong situations: C, C #, Common Lisp, Eiffel, and Modula-2.
Kiniry also notes that "language design only partially affects the use of exceptions, and consequently, the way in which a person handles partial and total failures during system execution.Another great influence is an example of usage, usually in the core library and technical code samples, books, magazine articles , and online discussion forums, and in organizational code standards. "
Contemporary applications face many design challenges when considering exception handling strategies. Particularly in modern enterprise-level applications, exceptions must often cross process boundaries and engine boundaries. Part of designing a powerful exception handling strategy is to recognize when a process has failed to the point where it can not be handled economically by the software part of the process.
History
The exception of software handling was developed in Lisp in the 1960s and 1970s. This is derived from LISP 1.5 (1962), where the caught exception by the keyword ERRSET , which returns NIL in case of an error, rather than terminating program or enter the debugger. An upgrade error was introduced in MacLisp in the late 1960s through the keyword ERR . It's quickly used not only for error boosting, but for non-local control flow, and thus coupled with two new keywords, CATCH and THROW (MacLisp June 1972) , ordering ERRSET and ERR for error handling. Cleaning behavior is now generally called "finally" introduced in NIL (LISP's New Implementation) in the mid to late 1970s as UNWIND-PROTECT . It was later adopted by Common Lisp. Contemporary with this is dynamic-wind in Scheme, which handles exceptions in closing. The first paper on handling structured exemptions is Goodenough (1975a) and Goodenough (1975b). The exception handling was then widely adopted by many programming languages ​​from the 1980s onwards.
Initially, software exception handling includes both resumable exceptions (resident semantics), such as most hardware exceptions, and non-resumable exemptions (semantic termination). However, recovery semantics were deemed ineffective in practice in the 1970s and 1980s (see standardization C discussion cited below) and are no longer used in general, although provided by programming languages ​​such as Common Lisp and Dylan.
Semantics termination
Exception handling mechanisms in contemporary languages ​​are usually not terminated (semantics) as opposed to hardware exceptions, which can usually be resumed. It is based on experience using both, because there are theoretical and design arguments that support good decisions; this was much debated during the standardization discussions C 1989-1991, which resulted in a definitive decision for semantic termination. With reasons for such design for the C mechanism, Stroustrup notes:
[A] t Palo Alto [C standardization] meeting in November 1991, we heard a brilliant summary of the arguments for termination of semantics that supported both personal experience and data from Jim Mitchell (from Sun, formerly of Xerox PARC). Jim has been using exception handling in half a dozen languages ​​over a 20-year period and is an early supporter of the re-semantics as one of the key designers and executors of the Xerox Cedar/Mesa system. The message is
- "discontinuation is preferred after resumption, it is not a matter of opinion but of years of experience. The resumption is seductive, but invalid."
He supports this statement with the experience of several operating systems. The main example is Cedar/Mesa: It was written by people who liked and used its comeback, but after ten years of use, there is only one use of its remaining return in the half million line system - and that is a contextual investigation. Since the continuation is not really required for such context investigations, they remove it and find significant speed increases in that part of the system. In any case where the resumption of its use - for ten years - becomes a problem and a more appropriate design replaces it. Basically, any use of a restart has represented a failure to keep a separate level of abstraction.
Criticism
The contrasting view of exception handling security was provided by CAR Hoare in 1980, describing the Ada programming language as having "... a number of features and conventions of notation, many of them unnecessary and some of them, such as exception handling, even dangerous... [...] Do not allow this language in its present state to be used in applications where reliability is critical [...] The subsequent rocket getting lost as a result of programming language errors may not be an extraterrestrial space exploration on a benign journey to Venus : It may be a nuclear warhead that explodes in one of our own cities. "
Handling exceptions are often not handled properly in software, especially when there are multiple sources of exceptions; data flow analysis of 5 million lines of Java code found more than 1300 handling exception handling. Citing some previous research by others (1999-2004) and their own results, Weimer and Necula wrote that the significant issue with the exception is that they "create a concealed flow-control path that is difficult for programmers to think about".
Go was originally released with the exception of explicitly eliminated handling, with the developers arguing that it obfuscated the flow of control. Then, mechanisms like panic / recover are added to the language, suggested by the Go writer only for irreparable errors that should stop the entire process.
Exceptions, as unstructured streams, increase the risk of resource leaks (such as escaping parts locked by mutex, or temporarily holding open files) or inconsistent states. There are various techniques for resource management in the presence of exceptions, most often incorporating exhaust patterns with some form of calm protection (such as the finally clause), which automatically releases resources when the control is out of the code section.
Support exclusion in programming languages ​​
Many computer languages ​​have built-in support for exception and exception handling. These include ActionScript, Ada, BlitzMax, C, C #, COBOL, D, ECMAScript, Eiffel, Java, ML, Pascal Objects (eg Delphi, Free Pascal, and the like), PowerBuilder, Objective-C, OCaml, PHP 5), PL/1, PL/SQL, Prolog, Python, REALbasic, Ruby, Scala, Seed7, Smalltalk, Tcl, Visual Prolog, and most.NET languages. Exception handling is generally not resumable in these languages, and when an exception is thrown, the program will search again through the function call stack until the exception handler is found.
Some languages ​​require parsing the decomposition during this search. That is, if the function f contains the H handler for the E exception, the call function g , which in turn calls the function h , and exceptions E occur in h , then the h and g functions can stopped and H in f will handle E .
Uncorrupted exception exception handling language is Common Lisp with its Conditioning System and Smalltalk. Both call the exception handler and do not remove the stack. Exception controllers have the option to resume counting, continue or relax. This allows the program to continue computing in the exact same place where the error occurred (eg when a previously missing file is available) or to apply notification, recordkeeping, query and fluid variables over exception handling mechanisms (as performed in Smalltalk). The stackless application of the programming language Mythryl supports the handling of constant-time exceptions without reducing the voltage.
Excluding minor syntax differences, there are only a few exception handling styles used. In the most popular styles, exceptions are initiated by a special statement ( throw or raise ) with an exception object (eg with Java or Object Pascal) or a value of a special enumeration type that can be extended (for example with Ada or SML). The scope for exception handlers starts with a marker clause ( try or block language blocker like start ) and ends at the beginning of the first handler clause ( catch , < code> except , rescue ). Some clause handlers can follow, and each can specify which type of exception is handled and what name is used for the exception object.
Some languages ​​also permit clauses ( else ) to use if no exceptions occur before the end of the handler's scope is reached.
More generally, the related clause ( finally or assures ) is executed whether an exception occurs or not, usually to release the resources acquired in the exception handling block body. Specifically, C does not provide this construction, as it encourages the Resource Acquisition Is Initialization (RAII) technique that frees up resources using a destructor.
Overall, the exception handling code might look like this (in pseudocode like Java, note that the exception type called EmptyLineException needs to be declared somewhere):
As a minor variation, some languages ​​use a single handler clause, which deals with an exception class internally.
According to a 2008 paper by Westley Wiemer and George Necula, the syntax of the try blocks... finally in Java is a factor that contributes to software defects. When a method needs to handle the acquisition and release of 3-5 resources, the programmers do not seem to want to accumulate enough blocks due to readability issues, even when this would be the right solution. It is possible to use one try ... finally blocking even when dealing with multiple resources, but it requires the use of the correct sentinel value, which is another common source of bugs for this type of problem. Regarding the semantics of try ... catch ... finally builds in general, Wiemer and Necula write that "When try-catch-eventually conceptually simple, it has the most elaborate description of the execution in the language specification [Gosling et al., 1996] and requires four levels of "if" in its official English description.In short, it contains a large number of angular cases that programmers often overlook. "
C supports various error checking tools, but it is generally not considered to support "exception handling," although the standard setjmp and longjmp standard functions can be used to apply semantic exceptions.
Perl has optional support for handling structured exception.
Python support for exception handling is very broad and consistent. It's hard to write powerful Python programs without using try and except keywords.
Implementation of exception handling
Implementation of exception handling in programming languages ​​usually involves quite a lot of support both from the code generator and the runtime system that accompanies the compiler. (This is the addition of exception handling to C which terminates the useful life of the original C compiler, Cfront.) The two most common schemes. The first, dynamic registration , generates code that keeps updating the structure of the program status in case of exception handling. Typically, this adds a new element to the stack frame layout that knows what handlers are available for the function or method associated with that frame; if the exception is thrown, the pointer in the layout redirects the runtime to the appropriate handler code. This approach is compact in terms of space, but adds excess overhead to the frame entries and exits. It's typically used in many implementations Ada, for example, where complex generation and runtime support is already required for many other language features. Dynamic registration, which is easy enough to define, can receive proof of truth.
The second scheme, and which is implemented in many qualified C compilers, is a table-driven approach. This creates a static table at compile time and link time connecting the program counter range to program status with respect to exception handling. Then, if the exception is thrown, the runtime system looks at the location of the current instruction in the table and determines what the handler is playing and what needs to be done. This approach minimizes executive overhead for cases where exceptions are not cast. This happens at the cost of some space, but this space can be allocated to read-only, a special purpose data section that is not loaded or moved until an exception is actually cast. This second approach is also superior in terms of achieving thread security.
Schema definition and other implementations have also been proposed. For languages ​​that support metaprogramming, an approach that involves no overhead at all has advanced.
Handling exclusions based on design under contract
Different exception views are based on design principles based on contract and supported especially by Eiffel language. The idea is to provide a more rigorous basis for handling exceptions by defining exactly what constitutes "normal" and "abnormal" behavior. In particular, this approach is based on two concepts:
- Failure : the inability of an operation to fulfill its contract. For example, an addition may produce an arithmetic overflow (not fulfilling its contract calculating a good approximation to the number of maths); or routine may fail to meet its postcondition.
- Exceptions : abnormal events occurring during routine execution (the routine is " recipient " of exceptions) during its execution. Such an abnormal event originates from the failure of an operation called by the routine.
The "Safe Handling Exceptions Principle" as introduced by Bertrand Meyer in Object Oriented Software Construction then states that there are only two meaningful ways that can react routinely when an exception occurs:
- Failure, or "Organized panic": The routine fixes the status of an object by re-establishing invariant (this is the "organized" section), and then fails (panic), triggers an exception to the caller (so abnormal events are not ignored).
- Retry: Routines try the algorithm again, usually after changing some values ​​so that the next attempt will have a greater chance of succeeding.
Specifically, only ignoring exclusion is not allowed; blocks must be retried and successfully completed, or propagate exceptions to the caller.
Here is an example stated in Eiffel syntax. This assumes that the send_fast is usually a better way to send a message but may fail, triggering an exception; if so, the next algorithm uses send_slow , which will rarely fail. If send_slow fails, routine as a whole should fail, causing the caller to get an exception.
The local boolean variable is initialized to False at the beginning. If send_fast fails, body ( do clause) will be executed again, causing execution send_slow . If execution send_slow fails, then rescue clause will execute to end without else clause in final if ), causing overall routine execution to fail.
This approach has the advantage of clearly defining "normal" and "abnormal" cases: abnormal cases, which lead to exceptions, are one in which routines can not fulfill their contracts. It defines a clear role distribution: the do (normal body) clause to achieve, or try to achieve, the regular contract ; The rescue clause is responsible for rebuilding the context and restarting the process, if it has a chance to succeed, which are actually.
Although the exception in Eiffel has a fairly clear philosophy, Kiniry (2006) criticizes their implementation because "Exceptions that are part of the language definition are represented by INTEGER values, exceptions determined by developers by STRING values. [...] that, since they are the basic values ​​and not the objects, they have no semantics attached beyond what is expressed in a helper routine which certainly can not be very easy because of the overloading representation that is applicable (for example, one can not distinguish two integers with a value same). "
Unexpected Exceptions
If an exception is thrown and not caught (operationally, exceptions are thrown when no handler is specified), an uncaught exception is handled by the runtime; the routines that do this are called uncontrolled exception handlers . The most common default behavior is to terminate the program and print error messages to the console, usually including debugging information such as string representation of exceptions and stack traces. This is often avoided by having a top level (application-level) level handler (eg in the event loop) that catches an exception before they reach the runtime.
Note that even if an uncaught exception can result in an abnormally abnormal program (the program may be incorrect if an exception is not caught, especially by not returning part of the completed transaction, or not releasing resources), process ends normally (assuming the runtime is working correctly), because the runtime (which controls the execution of the program) can ensure a regular shutdown of the process.
In a multithreaded program, exceptions that are not captured in threads may even result in termination of the thread, not the whole process (exceptions not captured in thread-level handlers captured by the top handler). This is very important for the server, where for example the servlet (running on its own thread) can be stopped without the server as a whole affected.
Uncaught exception handlers that this standard may be replaced, either globally or per-thread, for example to provide alternative logging or end-user reporting of uncaught exceptions, or to resume threads that are terminated due to uncaught exceptions. For example, in Java this is done for single threads via Thread.setUncaughtExceptionHandler and globally via Thread.setDefaultUncaughtExceptionHandler ; in Python, this is done by modifying sys.excepthook .
Examination of static exceptions
Excluded exception
The Java designers designed the checked exceptions, which are a set of special exceptions. The unchecked exceptions that methods can increase are part of the method signature. For example, if a method may throw
Kiniry (2006) notes that Java libraries (as they were in 2006) are often inconsistent in their approach to reporting errors, because "Not all wrong situations in Java are represented by exceptions.Many methods return a special value indicating a failure encoded as a constant field of related classes. "
The checked exceptions are related to checking existing exceptions for the OCaml programming language. The external tool for OCaml is not visible (ie does not require syntactic annotation) and optional (ie it is possible to compile and run the program without checking exceptions, although this is not recommended for production code).
The CLU programming language has features with an interface closer to what Java is introducing later. A function can raise only the exceptions listed in its type, but any leaked exceptions from the called function will be automatically converted to the only runtime exception, failure , instead of generating a compile-time error. Then, Modula-3 has a similar feature. These features do not include compile time checks that are central to the concept of checked exceptions, and have not (since 2006) been incorporated into a primary programming language other than Java.
Early versions of the C programming language include an optional mechanism for checking exceptions, called exclusion specifications . By default, any function can remove any exceptions, but this is limited by the throw clause added to the function mark, which is specified where the exception of the function can be discarded. Exception specifications are not enforced at compile time. Violations result in global function std :: unexpected called. An empty exclusion spec can be given, which indicates that the function will be no exception. This is not standard when exception handling is added to the language because it will require too much code modification, will inhibit interaction with code written in other languages, and will tempt programmers to write too many handlers at local level. The explicit use of the blank exception specifics can, however, allow the C compiler to perform significant code and pile layout optimizations that generally have to be compressed when exception handling can occur in a function. Some analysts see the proper use of the exception specs in C as difficult to achieve. In the latest C language standard (C 11), the use of this exception specification as specified in the standard version of C 03 has been abandoned and removed from the language in C 17. Functions that will not throw any exceptions now can be denoted by unauthorized keywords.
Unlike Java, languages ​​like C # do not impose that exceptions should be caught. According to Hanspeter MÃÆ'¶ssenbÃÆ'¶ck, not distinguishing between the so-called (unchecked) exceptions and the un-checked exceptions makes the program more convenient, but less robust, as a result of an uncaught exception with a stack trace. Kiniry (2006) notes that Java JDK (version 1.4.1) throws a large number of uncontrolled exceptions: one for every 140 lines of code, while Eiffel uses them much more sparingly, with one thrown every 4,600 lines of code. Kiniry also writes that "As Java programmers know, the try code try catch volume in a typical Java application is sometimes greater than the comparative code required for explicit formal parameters and checking return values ​​in other languages ​​that do not checking out exceptions In fact, the general consensus among Java programmers is that dealing with exceptions examined is almost as unpleasant as a documentation writing job, so many programmers report that they "criticize" unchecked exceptions for many checked-but-ignored exceptions ". Kiniry also noted that the developers of C # turned out to be affected by this kind of user experience, with the following excerpt given to them (via Eric Gunnerson):
"Small program checks lead to conclusions that require exclusion specifications to improve developer productivity and improve code quality, but experience with large software projects shows different results - decreased productivity and little or no code quality improvement."
According to Anders Hejlsberg there is considerable agreement in their design group not to check the exception as a language feature in C #. Hejlsberg explained in an interview
"The throwing clause, at least the way it applies to Java, does not require you to handle exceptions, but if you do not resolve it, it forces you to acknowledge exactly which exceptions may be skipped.This requires you to either capture the exception or place them in the clause throw your own. To overcome this requirement, people do silly things. For example, they decorate each method with, "throwing Exceptions." It just completely outperforms the feature, and you've just made the programmer write more gobbledy gunk. does not help anyone. "
Views on usage
Unchecked exclusions can, at compile time, reduce the incidence of unhandled exclusions that appear at runtime in a given application. No exception exceptions (such as Java objects RuntimeException and Error ) remains untreated.
However, checked exclusions can require throws declaration of implementation details and reduce encapsulation, or encourage bad coding < code = "mw-highlight" dir = "ltr"> try / capture block that can hide valid exceptions from they are the appropriate handlers. Consider a code base that evolves over time. An interface can be declared to throw exceptions X and Y. In newer versions of code, if someone wants to throw an Z exception, it will render the new code incompatible with the previous usage. Furthermore, with an adapter pattern, where one body of code declares an interface which is then implemented by a different code body so that code can be installed and called by the first, the adapter code may have a rich set of exceptions to explain the problem but be forced to use the exception type declared in the interface.
It is possible to reduce the number of well-stated exceptions by declaring a superclass of all potentially disposed exceptions, or by defining and declaring the appropriate type of exception for the so-called method abstraction level and mapping lower-level exceptions for this type, preferably wrapped using an exception chain for preserving the root cause. Additionally, it is very likely that in the above example the interfaces are changed, the calling code needs to be modified as well, because in some cases the exception of the method that may be cast is part of the implicit interface of that method.
Using the throws Exception or capture ( Exception e ) is usually enough to satisfying the examination in Java. While this may have some usage, it basically circumvent the checked exception mechanism, which Oracle does not recommend.
Excluded types of exceptions are generally not allowed to be handled, except perhaps at the outer coverage level. This often represents a scenario that does not allow for recovery: RuntimeException often reflects programming defects, and Error is usually a non-recoverable JVM fault. Even in languages ​​that support checked exclusions, there are some cases where the use of checked exceptions is not appropriate.
Dynamic checking of exceptions
The exception handling exception point is to make sure that the code can handle the error conditions. To specify that the exception handling routines are strong enough, it is necessary to present code with a wide spectrum of invalid or unexpected inputs, such as can be made via software error injection and mutation testing (which is also sometimes referred to as test fuzz). One of the most difficult types of software to write exception handling routines is the software protocol, because a strong protocol implementation must be prepared to accept inputs that do not conform to the relevant specifications.
To ensure that meaningful regression analysis can be performed throughout the software development lifecycle process, any exception handling testing should be highly automated, and test cases must be scientifically produced, repeatable. Some commercially available systems have done the test.
In an engine runtime environment like Java or.NET, there are tools that connect to the runtime engine and whenever there is an exception of interest, they record debugging information that is in memory at the time the exception is thrown (calling stack and heap value). These tools are called automatic exclusion tools or error tapping tools and provide 'root-root' information for exceptions.
Sync exception
Somewhat related to the unchecked exception concept is the sync exceptionality . Sync exclusions occur on certain program statements whereas asynchronous exclusions can increase practically anywhere. Therefore handling an asynchronous exception can not be requested by the compiler. They are also difficult to program. Examples of asynchronous events naturally include pressing Ctrl-C to interrupt a program, and receiving signals such as "stop" or "suspend" from other execution sequences.
Programming languages ​​typically handle this by limiting asynchronicity, for example Java has terminated the use of the ThreadDeath exception that is used to allow one thread to stop the other. Conversely, there can be semi-asynchronous exceptions that only increase in the appropriate location of the program or simultaneously.
System condition
Common Lisp, Dylan and Smalltalk have a condition system (see Common Lisp Condition System) which includes the exception handling system mentioned earlier. In that language or environment, the emergence of a condition ("generalization error" according to Kent Pitman) implies a function call, and only at the end of the exclusion control decision to remove the pile can be retrieved.
Conditions are generalizations of exceptions. When a condition arises, the appropriate condition controller is sought and selected, in the order of stacks, to handle the condition. Conditions that do not represent errors can be safely not addressed completely; their only goal is to spread the user's instructions or warnings.
Continuing exceptions
This is related to the so-called re-start model exception handling, where some exceptions are said to be continuous : allowed to return to an expression marking an exception, after taking corrective actions on the handler. The condition system is generalized thus: in a non-serious condition handler (aka continuous exception ), it is possible to jump to a predefined restart point (aka restart ) located between expressions signal and condition controller. Restart is a function that is closed on top of some lexical environment, which allows the programmer to fix this environment before exiting the handler completely or removing even partial piles.
Restart a separate mechanism from policy
Handling conditions also provide a separation mechanism from the policy. Restart provides various possible mechanisms to recover from errors, but do not select appropriate mechanisms in certain situations. It is a provincial controlling condition, which (because it is located in a higher level code) has access to a wider view.
Example: Suppose there is a library function whose purpose is to parse a single syslog file entry. What should this function do if the entry is wrong? There is no right answer, because the same library can be used in various programs for various purposes. In an interactive log file browser, the right thing to do is to return an unparted entry so users can see it - but in an automated logging program, the right thing to do is to assign a zero value to a field that can not be read, but abort the error, if too many incorrect entries are formatted.
That is, questions can only be answered in terms of the broader purpose of the program, which is not known to the general purpose library function. Nevertheless, coming out with error messages is rarely the correct answer. So instead of just going out with errors, the function may build restart offer various ways to proceed - for example, to bypass log entries, to provide default or zero values ​​for unreadable fields, to ask users for missing values, or to remove the stack and cancel processing with an error message. The restart offered is the mechanism available for recovery from errors; selection restart by condition handler provides policy .
See also
- Be advised of exception handling
- Automatic exception handling
- Security exceptions
- Advanced
- Defensive program
- setjmp/longjmp
- Triple Damage
- Vector Exclusion Handling (VEH)
- Option type and option type, alternative way of handling errors in functional programming without exception
References
External links
- How to Handle Exceptions in Java
- The article "When should you capture RuntimeExceptions?"
- A Crash Course on Depths of Win32 Structured Exception Handling by Matt Pietrek - Microsoft Systems Journal (1997)
- The "All Exceptions Handled" article by James "Jim" Wilcox
- The "Extraordinary Philosophy" article by John M. Dlugosz
- Article "C Exception Handling" by Christophe de Dinechin
- The "Handling Exception in C without C" article by Tom Schotland and Peter Petersen
- The "Extraordinary Practice" article by Brian Goetz
- Article "Object Oriented Exception Control in Perl" by Arun Udaya Shankar
- The "handling of PHP exceptions" article by Christopher Hill
- The article "Practical C Error Handling in Hybrid Environment" by Gigi Sayfan
- The "Programming with Exception in C" article by Kyle Loudon
- The article "Structured Exception Handling Basics" by Vadim Kokielov
- The article "Uncontrollable Exceptions - Controversy"
- The conference slides of the Points Exclusion Handling Policy (pdf p. 46) by William Kahan
- Description of the Portland Pattern Repository
- Does Java Need Checking Exceptions?
- exceptions4c: An exception handling template for C
- Another exception handling template for ANSI/ISO C
- How to handle failed class constructors
- Java Exception Handling - Jakob Jenkov
- Java: How to re-configure exceptions without wrapping them. - Rob Austin
- Paper "Exception Handling in a Petri-Net Based Workflow Management" by Gert Faustmann and Dietmar Wikarski
- Problems and Benefits of Handling Exceptions
- Issues with Registered Exceptions - conversations with Anders Hejlsberg
- Java Exceptions Type
- Understanding and Using Exceptions in.NET
- Visual Prolog Exception Handling (wiki article)
Source of the article : Wikipedia
0 Comments