Type Checking

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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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 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. Example of static checks include.


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.

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).