TYPE CHECKING
Introduction:
The compiler must perform static checking (checking done at compiler time).This ensures that certain types of programming errors will be detected and reported.
A compiler must check that the source program follows both the syntactic and semantic conversions of the source language. This checking is called static checking example of static checks include.
Some example of static checks is:
Type checks: A compiler should report an error if an operator is applied to an incompatible operand.
Flow-of-control checks: Statements that cause flow of control to leave a construct must have some place to which to transfer flow of control. For example, branching to non-existent labels.
Uniqueness checks: Objects should be defined only once. This is true in many languages.
Name-related checks: Sometimes, the same name must appear two or more times. For example, in Ada the name of a block must appear both at the beginning of the block and at the end.
A compiler
should report an error if an operator is applied to an incompatible operand.
This checking is called Type checking.
Type information
gathered by a type checker may be needed when code is generated. For example,
arithmetic operators may be different at the machine level for different types
of operands (real and integer).
TYPE SYSTEM:
The type
analysis and type checking is an important activity done in the semantic
analysis phase. The need for type checking is:
- To detect the errors arising in the expression due to incompatible operand.
- To generate intermediate code for expressions and statements. Typically language supports two types of data types- basic and constructed.
The basic data type are- integer, character, and
real, Boolean, enumerated data type. And Arrays, record (structure),set and
pointer are the constructed types. The constructed data types are build using
basic data types.
Fig
1:- Position of Type checking
Type
Expression: Type of a language construct. It is either a basic type or is formed by applying an operator called a type constructor to other type expressions.
A type system is a collection of rules for assigning
type expression to the various parts of a program. A type checker implements a
type system. Different type system may be used by different compilers or
processors of the system Language.
Checking done by a compiler is said to be static
checking of types, while checking done when the target program runs is terminal
dynamic checking of types.
A source type
system eliminates the need for dynamic checking for type errors because it
allows us to determine statically that these errors cannot occur when the
target program runs.
Type checking should have a property of error
recovery.