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:

1. 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.
2. 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.
3. 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 –
1. Lexical : This includes misspellings of identifiers, keywords or operators
2. Syntactical : a missing semicolon or unbalanced parenthesis
3. Semantical : incompatible value assignment or type mismatches between operator and
operand
4. 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.
E->int|E+E|(E)|error int|(error)
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.