1

Pertemuan 18 & 19Semantic Analyzer (type checking)

Matakuliah : T0174 / Teknik Kompilasi

Tahun : 2005

Versi : 1/6

2

Learning Outcomes

Pada akhir pertemuan ini, diharapkan mahasiswa

akan mampu :• Mahasiswa dapat menjelaskan proses type

checking dan peranannya dalam compiler (C2)• Mahasiswa dapat menunjukkan berbagai

metode type checking dalam teknik kompilasi (C3)

3

Outline Materi

• Type system

• Spesifikasi type checker sederhana

• Type expression

• Type conversion

• Operator dan fungsi overloading

• Fungsi-fungsi polymorphic

4

Type Checking• A compiler has to do semantic checks in addition to syntactic checks.• Semantic Checks

– Static – done during compilation– Dynamic – done during run-time

• Type checking is one of these static checking operations.– we may not do all type checking at compile-time. – Some systems also use dynamic type checking too.

• A type system is a collection of rules for assigning type expressions to the parts of a program.

• A type checker implements a type system.• A sound type system eliminates run-time type checking for type errors.• A programming language is strongly-typed, if every program its compiler

accepts will execute without type errors.– In practice, some of type checking operations are done at run-time (so, most of

the programming languages are not strongly-typed).– Ex: int x[100]; … x[i] most of the compilers cannot guarantee that i will be

between 0 and 99

5

Type Expression• The type of a language construct is denoted by a type expression.• A type expression can be:

– A basic type • a primitive data type such as integer, real, char, boolean, … • type-error to signal a type error• void : no type

– A type name• a name can be used to denote a type expression.

– A type constructor applies to other type expressions.• arrays: If T is a type expression, then array(I,T) is a type expression where I denotes

index range. Ex: array(0..99,int)• products: If T1 and T2 are type expressions, then their cartesian product T1 x T2 is a

type expression. Ex: int x int• pointers: If T is a type expression, then pointer(T) is a type expression. Ex:

pointer(int)• functions: We may treat functions in a programming language as mapping from a

domain type D to a range type R. So, the type of a function can be denoted by the type expression D→R where D are R type expressions. Ex: int→int represents the type of a function which takes an int value as parameter, and its return type is also int.

6

A Simple Type Checking System

P → D;E

D → D;DD → id:T { addtype(id.entry,T.type) }T → char { T.type=char }T → int { T.type=int }T → real { T.type=real }

T → ↑T1 { T.type=pointer(T1.type) }

T → array[intnum] of T1 { T.type=array(1..intnum.val,T1.type) }

7

Type Checking of Expressions

E → id { E.type=lookup(id.entry) }

E → charliteral { E.type=char }

E → intliteral { E.type=int }

E → realliteral { E.type=real }

E → E1 + E2 { if (E1.type=int and E2.type=int) then E.type=int

else if (E1.type=int and E2.type=real) then E.type=real

else if (E1.type=real and E2.type=int) then E.type=real

else if (E1.type=real and E2.type=real) then E.type=real

else E.type=type-error }

E → E1 [E2] { if (E2.type=int and E1.type=array(s,t)) then E.type=t

else E.type=type-error }

E → E1 ↑ { if (E1.type=pointer(t)) then E.type=t

else E.type=type-error }

8

Type Checking of Statements

S id = E { if (id.type=E.type then S.type=void

else S.type=type-error }

S if E then S1 { if (E.type=boolean then S.type=S1.type

else S.type=type-error }

S while E do S1 { if (E.type=boolean then S.type=S1.type

else S.type=type-error }

9

Type Checking of Functions

E E1 ( E2 ) { if (E2.type=s and E1.type=st) then E.type=t

else E.type=type-error }

Ex: int f(double x, char y) { ... }

f: double x char int

argument types return type

10

Structural Equivalence of Type Expressions

• How do we know that two type expressions are equal?• As long as type expressions are built from basic types (no

type names), we may use structural equivalence between two type expressions

Structural Equivalence Algorithm (sequiv):if (s and t are same basic types) then return true

else if (s=array(s1,s2) and t=array(t1,t2)) then return (sequiv(s1,t1) and sequiv(s2,t2))

else if (s = s1 x s2 and t = t1 x t2) then return (sequiv(s1,t1) and sequiv(s2,t2))

else if (s=pointer(s1) and t=pointer(t1)) then return (sequiv(s1,t1))

else if (s = s1 s2 and t = t1 t2) then return (sequiv(s1,t1) and sequiv(s2,t2))else return false

11

Names for Type Expressions

• In some programming languages, we give a name to a type expression, and we use that name as a type expression afterwards.

type link = cell; ? p,q,r,s have same types ?

var p,q : link;var r,s : cell

• How do we treat type names?– Get equivalent type expression for a type name (then

use structural equivalence), or– Treat a type name as a basic type.

12

Cycles in Type Expressions

type link = cell;type cell = record

x : int,next : link

end;

• We cannot use structural equivalence if there are cycles in type expressions.

• We have to treat type names as basic types. but this means that the type expression link is

different than the type expression cell.

13

Type Conversions

x + y ? what is the type of this expression (int or double)?

• What kind of codes we have to produce, if the type of x is double and the type of y is int?

inttoreal y,,t1

real+ t1,x,t2

14

Static Checking

Static checking aims to ensure, at compile time, that syntactic and semantic constraints of the source language are obeyed. E.g.:– Type checks: operators and operands must have

compatible types.– Flow-of-control checks: control transfer statements

must have legitimate targets (e.g., break/continue statements).

– Uniqueness checks: a language may dictate unique occurrences in some situations, e.g., variable declarations, case labels in switch statements.

These checks can often be integrated with parsing.

15

Data Types and Type Checking

• A data type is a set of values together with a set of operations that can be performed on them.

• Type checking aims to verify that operations in a program code are, in fact, permissible on their operand values.

• Reasoning about types: – The language provides a set of base types and a set

of type constructors;– The compiler uses type expressions to represent

types definable by the language.

16

Type Constructors and Type Expressions

A type expression denotes (i.e., is a syntactic representation of) the type of a program entity:

– A base type is a type expression (e.g., boolean, char, int, float);– A type name is a type expression;– A type constructor applied to type expressions is a type

expression, e.g.:• arrays: if T is a type expression then so is array(T);

• records: if T1, …, Tn are type expressions and f1, …, fn is a list of (unique) identifiers, then record(f1:T1, …, fn:Tn) is a type expression;

• pointers: if T is a type expression then so is ptr(T);

• functions: if T, T1, …, Tn are type expressions, then so is (T1, …, Tn) T.

17

Why use Type Expressions?

char *X;

char **f()

{

X = “GOTCHA!”

return &X;

}

main()

{

printf(“%c\n”, (*f())[2]);

/* legal??? */

}

Program Code Type Expression Rule f ()ptr(ptr(char)) symbol table lookup

f() ptr(ptr(char)) if e : T1T2 and e1 : T1 then e(e1) : T2

*f() ptr(char) if e : ptr(T) then *e : T *f() array(char) if e : ptr(T) then e : array(T) (*f()) array(char) if e : T then (e) : T 2 int base type

(*f())[2] char if e1 : array(T) and e2 : int then e1[e2] : T

What about: qsort((void **)lptr,0,k,(int (*)(void*,void*))(num ? ncmp : strcmp));

18

Notions of Type Equivalence

1. Name equivalence:In some languages (e.g., Pascal), types can be given names. Name equivalence views distinct type names as distinct types: two types

are name equivalent if and only if they have the same type name.

2. Structural equivalence:Two type expressions are structurally equivalent if they have the same

structure, i.e., if both apply the same type constructor to structurally equivalent type expressions.

E.g.: in the Pascal fragmenttype p = node; q = node;var x : p; y : q;

x and y are structurally equivalent, but not name-equivalent.

19

Representing Type Expressions

Type graphs: A graph-structured representation of type expressions:– Basic types are given predefined “internal values”;– Named types can be represented via pointers into a

hash table.– A composite type expression f (T1,…,Tn) is

represented as a node identifying the constructor f and with pointers to the nodes for T1, …, Tn.

E.g.: int x[10][20]:

20

Type Checking Expressions

Production Semantic Rule Yacc Code

E → id E.type = id.type { $$ = symtab_lookup(id_name); }

E → intcon E.type = INTEGER { $$ = INTEGER; }

E → E1 + E2 E.type = result_type(E1.type, E2.type)

{ $$ = result_type($1, $3); }

/* arithmetic type conversions */Type result_type(Type t1, Type t2){ if (t1 == error || t2 == error) return error; if (t1 == t2) return t1; if (t1 == double || t2 == double) return double; if (t1 == float || t2 == float) return float; …}

Return types:– currently: the type of the expression

– down the road:• type• location• code to evaluate the expression

21

Type Checking Expressions: cont’d

Arrays:

E → id[ E1 ] { t1 = id.type;

if (t1 == ARRAY E1.type == INTEGER)

E.type = id.element_type;

else

E.type = error;

}

22

Type Checking Expressions: cont’d

Function calls:

E → id ‘(‘ expr_list ‘)’ { if (id.return_type == VOID) E.type = error; else if ( chk_arg_types(id, expr_list) ) /* actuals match

formals in number, type */

E.type = id.return_type; else E.type = error; }

23

Type Checking Statements

Different kinds of statements have different type requirements. E.g.:– if, while statements may require boolean

conditiona;– LHS of an assignment must be an “l-value”,

i.e., something that can be assigned.– LHS and RHS of an assignment must have

“compatible” types. If they are of different types, conversion will be necessary.

24

Operator Overloading

• Overloading refers to the use of the same syntax to refer to different operations, depending on the operand types.E.g.: in Java, ‘+’ can refer to integer addition, floating

point addition, or string concatenation.

• The compiler uses operand type information to resolve the overloading, i.e., figure out which operation is actually referred to. If there is insufficient information to resolve

overloading, the compiler may give an error.