Typsystem och typkontroll

Det här är ungefär vad jag tänker säga på föreläsningen. Använd det för förberedelser, repetition och ledning. Det är inte en definition av kursinnehållet, och det ersätter inte kursboken.

Idag: Datatyper. Typsystem. Typkontroll.

• ALSU-07 avsnitt 6.3 och 6.5
• (ASU-86 6.1-6.2)

Statiska och dynamiska kontroller

• Static checking = performed by the compiler during compilation
• Dynamic checking = performed during execution of the target program

• Type checks
• Flow-of-control checks
• Uniqueness checks
• Name-related checks

int main() {
  int i;

  *i = 2; // invalid type argument of `unary *'
  break;  // break statement not within loop or switch
 e:
 e:       // duplicate label `e'
  return 0;
}

6.3 Type systems

• 1 / 3 -- "int / int = int" -- 0
• 1 / 3.0 -- "int / double = (double)int / double = double" -- 0.3333333

Type expressions

1. A basic type (int, char, etc.)
2. A type name (such as T after typedef int T;)
3. A type variable (can be used directly in some languages: type XT = typeof(x); XT y;)
4. A type constructor applied to one or more type expressions:
   • Pointers: pointer(T) -- C ex: *int
   • Arrays: array(I, T) -- Pascal ex: array[1..10] of integer; -- C ex: int a[10]
   • Products: T₁ x T₂ (that is, a "tuple", or "argument list")
   • Records: record(...) -- C ex: struct Customer { int nr; char name[10]; }
   • Functions: int x int -> int -- C++ ex: int f(int, int);

Type tree:

        ->
      /   \
     x     pointer
    / \       \
char   char  integer

        ->
      /   \
     x     pointer
    ||        \
   char      integer

If you haven't seen it before: cdecl

cdecl> declare a as pointer to int
int *a
cdecl> declare a as array 10 of pointer to function returning double
double (*a[10])()
cdecl> explain int *(*foo)[8]
declare foo as pointer to array 8 of pointer to int

Type systems

Static and dynamic checking of types

class Djur { public: int x; virtual void f() { } };
class Hund : public Djur { public: int y; };
class Katt : public Djur { public: int z; };

void f(Djur* djur) {
  Hund* hund = dynamic_cast<Hund*>(djur);
  if (hund != 0)
    hund->y = 4711;
}

int main() {
  f(new Djur());
  f(new Hund());
  f(new Katt());
}

Strong and weak typing

Strongly typed language = the compiler can guarantee that the program will execute without type errors.

Specification of a simple type checker

A simple language

Grammar (slighly modified from the one on ASU-86 page 349):

Program --> Declarations ; Expr
Declarations --> Declarations ; Declarations | id : Type
Type --> char | integer | array [ num ] of Type | *Type
Expr --> literal | num | id | Expr + Expr | Expr [ Expr ] | *Expr

Example program (with a type error?):

n : integer;
i : integer;
a : array [256] of char;
n + a[i] + 7

A translation scheme, with semantic actions, can be used for type checking. This part of the translation scheme saves the type of a variable in the symbol table (ASU-86 Fig 6.4):

Type --> char { Type.type := char; }
Type --> integer { Type.type := integer; }
Type --> *Type₁ { Type.type := pointer(Type₁.type); }
Type --> array [ num ] of Type₁ { Type.type := array(1..num.val, Type₁.type); }
Declarations --> id : Type { addtype(id.entry, T.type); }
Program --> Declarations ; Expr
Declarations --> Declarations ; Declarations

Type checking of expressions

Expr --> num { Expr.type := integer; }
Expr --> literal { Expr.type := char; }

Expr --> id { Expr.type := lookup(id.entry); }

Expr --> Expr1 + Expr2
  { if (Expr1.type == integer and Expr2.type == integer)
      Expr.type = integer;
    else
      Expr.type = type_error;
  }

Expr --> Expr1 [ Expr2 ]
  { if (Expr2.type == integer and Expr1.type == array(s, t))
      Expr.type = t;
    else
      Expr.type = type_error;
  }

Type checking of statements

The while statement:

Stmt --> while ( Expr ) Stmt1
  { if (Expr.type == integer and Stmt1.type == void)
      Stmt.type == void;
    else
      Stmt.type == type_error;
  }

Stmt --> Expr ;
  { if (Expr.type != type_error)
      Stmt.type == void;
    else
      Stmt.type == type_error;
  }

Type checking of functions

Expr --> Expr₁ ( Expr₂ )

f : int -> int;
f(7) + 3;

Type --> Type₁ "->" Type₂

Type --> Type1 "->" Type2
  { Type.type = function(Type1.type, Type2.type); }

Expr --> Expr1 ( Expr2 )
  { if (Expr1.type == function(s, t) and Expr2.type == s)
      Expr.type == t;
    else
      Expr.type == type_error;
  }

6.3.2 Equivalence of type expressions

• structural equivalence (two types are the same if they "look the same")
• name equivalence (each named type is a distinct type)

double m1[14][17];
double m2[14][17];

typedef int A[10];
typedef int B[10];
typedef int C[11];

int main() {
  A a;
  B b;
  C c;
  A* ap;
  B* bp;
  C* cp;

  ap = &a;
  ap = &b;
  ap = bp;

  ap = cp; /* warning: assignment from incompatible pointer type */
  ap = &c; /* warning: assignment from incompatible pointer type */

  return 0;
}

• structural equivalence: recurse down to basic types (int, char, etc.)
• name equivalence: just compare the names

C uses structural equivalence for all types except records ("structs"):

struct A { int foo; double fum; };
struct B { int blaj; double urko; };

struct A a;
struct B b;

a = b; /* error: incompatible types in assignment */

struct L {
  int foo;
  struct L* next;
};

typedef struct A TA1;
typedef struct A TA2;

TA1 ta1;
TA2 ta2;

ta1 = ta2; // ok

Kursen Kompilatorer och interpretatorer | Föreläsningar: 1 2 3 4 5 6 7 8 9 10 11 12