The tasks of the Error Handling process are to detect each error, report it to the user, and then make some recovery strategy and implement them to handle the error. During this whole process processing time of the program should not be slow.
Functions of Error Handler:
- Error Detection
- Error Report
- Error Recovery
Error handler=Error Detection+Error Report+Error Recovery.
An Error is the blank entries in the symbol table.
Errors in the program should be detected and reported by the parser. Whenever an error occurs, the parser can handle it and continue to parse the rest of the input. Although the parser is mostly responsible for checking for errors, errors may occur at various stages of the compilation process.
So, there are many types of errors and some of these are:
Types or Sources of Error – There are three types of error: logic, run-time and compile-time error:
- Logic errors occur when programs operate incorrectly but do not terminate abnormally (or crash). Unexpected or undesired outputs or other behaviour may result from a logic error, even if it is not immediately recognized as such.
- A run-time error is an error that takes place during the execution of a program and usually happens because of adverse system parameters or invalid input data. The lack of sufficient memory to run an application or a memory conflict with another program and logical error is an example of this. Logic errors occur when executed code does not produce the expected result. Logic errors are best handled by meticulous program debugging.
- Compile-time errors rise at compile-time, before the execution of the program. Syntax error or missing file reference that prevents the program from successfully compiling is an example of this.
Classification of Compile-time error –
- Lexical : This includes misspellings of identifiers, keywords or operators
- Syntactical : a missing semicolon or unbalanced parenthesis
- Semantical : incompatible value assignment or type mismatches between operator and operand
- Logical : code not reachable, infinite loop.
Finding error or reporting an error – Viable-prefix is the property of a parser that allows early detection of syntax errors.
- Goal detection of an error as soon as possible without further consuming unnecessary input
- How: detect an error as soon as the prefix of the input does not match a prefix of any string in the language.
Example: for(;), this will report an error as for having two semicolons inside braces.
Error Recovery –
The basic requirement for the compiler is to simply stop and issue a message, and cease compilation. There are some common recovery methods that are as follows.
We already discuss the errors. Now, let’s try to understand the recovery of errors in every phase of the compiler.
1. Panic mode recovery :
This is the easiest way of error-recovery and also, it prevents the parser from developing infinite loops while recovering error. The parser discards the input symbol one at a time until one of the designated (like end, semicolon) set of synchronizing tokens (are typically the statement or expression terminators) is found. This is adequate when the presence of multiple errors in the same statement is rare. Example: Consider the erroneous expression- (1 + + 2) + 3. Panic-mode recovery: Skip ahead to the next integer and then continue. Bison: use the special terminal error to describe how much input to skip.
2. Phase level recovery :
When an error is discovered, the parser performs local correction on the remaining input. If a parser encounters an error, it makes the necessary corrections on the remaining input so that the parser can continue to parse the rest of the statement. You can correct the error by deleting extra semicolons, replacing commas with semicolons, or reintroducing missing semicolons. To prevent going in an infinite loop during the correction, utmost care should be taken. Whenever any prefix is found in the remaining input, it is replaced with some string. In this way, the parser can continue to operate on its execution.
3. Error productions :
The use of the error production method can be incorporated if the user is aware of common mistakes that are encountered in grammar in conjunction with errors that produce erroneous constructs. When this is used, error messages can be generated during the parsing process, and the parsing can continue. Example: write 5x instead of 5*x
4. Global correction :
In order to recover from erroneous input, the parser analyzes the whole program and tries to find the closest match for it, which is error-free. The closest match is one that does not do many insertions, deletions, and changes of tokens. This method is not practical due to its high time and space complexity.
Advantages of Error Handling in Compiler Design:
1.Robustness: Mistake dealing with improves the strength of the compiler by permitting it to deal with and recuperate from different sorts of blunders smoothly. This guarantees that even within the sight of blunders, the compiler can keep handling the information program and give significant mistake messages.
2.Error location: By consolidating blunder taking care of components, a compiler can distinguish and recognize mistakes in the source code. This incorporates syntactic mistakes, semantic blunders, type blunders, and other potential issues that might make the program act startlingly or produce erroneous result.
3.Error revealing: Compiler mistake taking care of works with viable blunder answering to the client or software engineer. It creates engaging blunder messages that assist developers with understanding the nature and area of the mistake, empowering them to effectively fix the issues. Clear and exact mistake messages save designers significant time in the troubleshooting system.
4.Error recuperation: Mistake dealing with permits the compiler to recuperate from blunders and proceed with the aggregation cycle whenever the situation allows. This is accomplished through different methods like blunder adjustment, mistake synchronization, and resynchronization. The compiler endeavors to redress the blunders and continues with assemblage, keeping the whole interaction from being ended unexpectedly.
5.Incremental gathering: Mistake taking care of empowers gradual aggregation, where a compiler can order and execute right partitions of the program regardless of whether different segments contain blunders. This element is especially helpful for enormous scope projects, as it permits engineers to test and investigate explicit modules without recompiling the whole codebase.
6.Productivity improvement: With legitimate mistake taking care of, the compiler diminishes the time and exertion spent on troubleshooting and blunder fixing. By giving exact mistake messages and supporting blunder recuperation, it assists programmers with rapidly recognizing and resolve issues, prompting further developed efficiency and quicker advancement cycles.
7.Language turn of events: Mistake taking care of is a fundamental part of language plan and advancement. By consolidating mistake dealing with systems in the compiler, language fashioners can characterize the normal blunder conduct and authorize explicit standards and imperatives. This adds to the general dependability and consistency of the language, guaranteeing that developers stick to the expected utilization designs.
Disadvantages of error handling in compiler design:
Increased complexity: Error handling in compiler design can significantly increase the complexity of the compiler. This can make the compiler more challenging to develop, test, and maintain. The more complex the error handling mechanism is, the more difficult it becomes to ensure that it is working correctly and to find and fix errors.
Reduced performance: Error handling in compiler design can also impact the performance of the compiler. This is especially true if the error handling mechanism is time-consuming and computationally intensive. As a result, the compiler may take longer to compile programs and may require more resources to operate.
Increased development time: Developing an effective error handling mechanism can be a time-consuming process. This is because it requires significant testing and debugging to ensure that it works as intended. This can slow down the development process and result in longer development times.
Difficulty in error detection: While error handling is designed to identify and handle errors in the source code, it can also make it more difficult to detect errors. This is because the error handling mechanism may mask some errors, making it harder to identify them. Additionally, if the error handling mechanism is not working correctly, it may fail to detect errors altogether.
Next related article – Error detection and Recovery in Compiler