The Programming Language Oberon-2

1. Introduction

Type extension makes Oberon-2 an object-oriented language. An object is a variable of an abstract data type consisting of private data (its state) and procedures that operate on this data. Abstract data types are declared as extensible records. Oberon-2 covers most terms of object-oriented languages by the established vocabulary of imperative languages in order to minimize the number of notions for similar concepts.

This report is not intended as a programmer's tutorial. It is intentionally kept concise. Its function is to serve as a reference for programmers, implementors, and manual writers. What remains unsaid is mostly left so intentionally, either because it can be derived from stated rules of the language, or because it would require to commit the definition when a general commitment appears as unwise.

Appendix A defines some terms that are used to express the type checking rules of Oberon-2. Where they appear in the text, they are written in italics to indicate their special meaning (e.g. the same type).

2. Syntax

3. Vocabulary and Representation

1. Identifiers are sequences of letters and digits. The first character must be a letter.

x

Scan

Oberon2

GetSymbol

firstLetter

A real number always contains a decimal point. Optionally it may also contain a decimal scale factor. The letter E (or D) means "times ten to the power of". A real number is of type REAL, unless it has a scale factor containing the letter D. In this case it is of type LONGREAL.

"Oberon-2"

"Don't worry!"

"x"

N = 100

limit = 2*N - 1

fullSet = {MIN(SET) .. MAX(SET)}

Table = ARRAY N OF REAL

Tree = POINTER TO Node

Node = RECORD

  key: INTEGER;

  left, right: Tree

END

CenterTree = POINTER TO CenterNode

CenterNode = RECORD (Node)

  width: INTEGER;

  subnode: Tree

END

Function = PROCEDURE(x: INTEGER): INTEGER

Arrays declared without length are called open arrays. They are restricted to pointer base types (see 6.4), element types of open array types, and formal parameter types (see 10.1). Examples:

ARRAY 10, N OF INTEGER

ARRAY OF CHAR

Examples of record type declarations:

RECORD

  day, month, year: INTEGER

END

RECORD

  name, firstname: ARRAY 32 OF CHAR;

  age: INTEGER;

  salary: REAL

END

Examples of variable declarations (refer to examples in Ch. 6):

i, j, k: INTEGER

x, y: REAL

p, q: BOOLEAN

s: SET

F: Function

a: ARRAY 100 OF REAL

w: ARRAY 16 OF RECORD

     name: ARRAY 32 OF CHAR;

     count: INTEGER

   END

t, c: Tree

Examples of designators (refer to examples in Ch. 7):

Examples:

i := 0

p := i = j

x := i + 1

k := log2(i+j)

F := log2	(* see 10.1 *)

s := {2, 3, 5, 7, 11, 13}

a[i] := (x+y) * (x-y)

t.key := i

w[i+1].name := "John"

t := c

If a formal parameter is a variable parameter, the corresponding actual parameter must be a designator denoting a variable. If it denotes an element of a structured variable, the component selectors are evaluated when the formal/actual parameter substitution takes place, i.e. before the execution of the procedure. If a formal parameter is a value parameter, the corresponding actual parameter must be an expression. This expression is evaluated before the procedure activation, and the resulting value is assigned to the formal parameter (see also 10.1).

WriteInt(i*2+1)  (* see 10.1 *)

INC(w[k].count)

t.Insert("John")  (* see 11 *)

Example:

IF (ch >= "A") & (ch <= "Z") THEN ReadIdentifier

ELSIF (ch >= "0") & (ch <= "9") THEN ReadNumber

ELSIF (ch = " ' ") OR (ch = ' " ') THEN ReadString

ELSE SpecialCharacter

END

CASE ch OF

  "A" .. "Z": ReadIdentifier

| "0" .. "9": ReadNumber

| "'", '"': ReadString

ELSE SpecialCharacter

END

WHILE i > 0 DO i := i DIV 2; k := k + 1 END

WHILE (t # NIL) & (t.key # i) DO t := t.left END

Examples:

FOR i := 0 TO 79 DO k := k + a[i] END

FOR i := 79 TO 1 BY -1 DO a[i] := a[i-1] END

LOOP

  ReadInt(i);

  IF i < 0 THEN EXIT END;

  WriteInt(i)

END

Example:

WITH t: CenterTree DO i := t.width; c := t.subnode END

Objects declared in the environment of the procedure are also visible in those parts of the procedure in which they are not concealed by a locally declared object with the same name.

Examples of procedure declarations:

PROCEDURE ReadInt(VAR x: INTEGER);

  VAR i: INTEGER; ch: CHAR;

BEGIN i := 0; Read(ch);

  WHILE ("0" <= ch) & (ch <= "9") DO

    i := 10*i + (ORD(ch)-ORD("0")); Read(ch)

  END;

  x := i

END ReadInt

PROCEDURE WriteInt(x: INTEGER); (*0 <= x <100000*)

VAR i: INTEGER; buf: ARRAY 5 OF INTEGER;

BEGIN i := 0;

  REPEAT buf[i] := x MOD 10; x := x DIV 10; INC(i) UNTIL x = 0;

  REPEAT DEC(i); Write(CHR(buf[i] + ORD("0"))) UNTIL i = 0

END WriteInt

PROCEDURE WriteString(s: ARRAY OF CHAR);

  VAR i: INTEGER;

BEGIN i := 0;

  WHILE (i < LEN(s)) & (s[i] # 0X) DO Write(s[i]); INC(i) END

END WriteString;

PROCEDURE log2(x: INTEGER): INTEGER;

  VAR y: INTEGER; (*assume x>0*)

BEGIN

  y := 0; WHILE x > 1 DO x := x DIV 2; INC(y) END;

  RETURN y

END log2

Examples:

PROCEDURE (t: Tree) Insert (node: Tree);

  VAR p, father: Tree;

BEGIN p := t;

  REPEAT father := p;

    IF node.key = p.key THEN RETURN END;

    IF node.key < p.key THEN

      p := p.left

    ELSE

      p := p.right

    END

  UNTIL p = NIL;

  IF node.key < father.key THEN

    father.left := node

  ELSE

    father.right := node

  END;

  node.left := NIL; node.right := NIL

END Insert;

PROCEDURE (t: CenterTree) Insert (node: Tree);  (*redefinition*)

BEGIN

  WriteInt(node(CenterTree).width);

  t.Insert^ (node)  (* calls the Insert procedure bound to Tree *)

END Insert;

The statement sequence following the symbol BEGIN is executed when the module is added to a system (loaded), which is done after the imported modules have been loaded. It follows that cyclic import of modules is illegal. Individual (parameterless and exported) procedures can be activated from the system, and these procedures serve as commands (see Appendix D1).

MODULE Trees;  (* exports: Tree, Node, Insert, Search, Write, Init *)

  IMPORT Texts, Oberon;  (* exports read-only: Node.name *)



  TYPE

    Tree* = POINTER TO Node;

    Node* = RECORD

      name-: POINTER TO ARRAY OF CHAR;

      left, right: Tree

    END;



  VAR w: Texts.Writer;



  PROCEDURE (t: Tree) Insert* (name: ARRAY OF CHAR);

    VAR p, father: Tree;

  BEGIN p := t;

    REPEAT father := p;

      IF name = p.name^ THEN RETURN END;

      IF name < p.name^ THEN p := p.left ELSE p := p.right END

    UNTIL p = NIL;

    NEW(p); p.left := NIL; p.right := NIL;

    NEW(p.name, LEN(name)+1); COPY(name, p.name^);

    IF name < father.name^ THEN

      father.left := p

    ELSE

      father.right := p

    END

  END Insert;



  PROCEDURE (t: Tree) Search* (name: ARRAY OF CHAR): Tree;

    VAR p: Tree;

  BEGIN p := t;

    WHILE (p # NIL) & (name # p.name^) DO

      IF name < p.name^ THEN p := p.left ELSE p := p.right END

    END;

    RETURN p

  END Search;



  PROCEDURE (t: Tree) Write*;

  BEGIN

    IF t.left # NIL THEN t.left.Write END;

    Texts.WriteString(w, t.name^); Texts.WriteLn(w);

    Texts.Append(Oberon.Log, w.buf);

    IF t.right # NIL THEN t.right.Write END

  END Write;



  PROCEDURE Init* (t: Tree);

  BEGIN NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL

  END Init;



BEGIN Texts.OpenWriter(w)

END Trees.

Integer types

SHORTINT, INTEGER, LONGINT

Real types

REAL, LONGREAL

Numeric types

integer types, real types

Same types

Two variables a and b with types Ta and Tb are of the same type if

1. Ta and Tb are both denoted by the same type identifier, or
2. Ta is declared to equal Tb in a type declaration of the form Ta = Tb, or
3. a and b appear in the same identifier list in a variable, record field, or formal parameter declaration and are not open arrays.

Equal types

Two types Ta and Tb are equal if

1. Ta and Tb are the same type, or
2. Ta and Tb are open array types with equal element types, or
3. Ta and Tb are procedure types whose formal parameter lists match.

Type inclusion

Numeric types include (the values of) smaller numeric types according to the following hierarchy:

LONGREAL >= REAL >= LONGINT >= INTEGER >= SHORTINT

Type extension (base type)

Given a type declaration Tb = RECORD(Ta)...END, Tb is a direct extension of Ta, and Ta is a direct base type of Tb. A type Tb is an extension of a type Ta (Ta is a base type of Tb) if

1. Ta and Tb are the same types, or
2. Tb is a direct extension of an extension of Ta

If Pa = POINTER TO Ta and Pb = POINTER TO Tb , Pb is an extension of Pa (Pa is) a base type of Pb ) if Tb is an extension of Ta.

Assignment compatible

An expression e of type Te is assignment compatible with a variable v of type Tv if one of the following conditions hold:

1. Te and Tv are the same type;
2. Te and Tv are numeric types and Tv includes Te;
3. Te and Tv are record types and Te is an extension of Tv and the dynamic type of v is Tv;
4. Te and Tv are pointer types and Te is an extension of Tv;
5. Tv is a pointer or a procedure type and e is NIL;
6. Tv is ARRAY n OF CHAR, e is a string constant with m characters, and m <n;
7. Tv is a procedure type and e is the name of a procedure whose formal parameters match those of Tv.

Array compatible

An actual parameter a of type Ta is array compatible with a formal parameter f of type Tf if

1. Tf and Ta are the same type, or
2. Tf is an open array, Ta is any array, and their element types are array compatible, or
3. Tf is ARRAY OF CHAR and a is a string.

Expression compatible

For a given operator, the types of its operands are expression compatible if they conform to the following table (which shows also the result type of the expression). Character arrays that are to be compared must contain 0X as a terminator. Type T1 must be an extension of type T0:

operator	first operand	second operand	result type
+ - *	numeric	numeric	smallest numeric type including both operands
/	numeric	numeric	smallest real type including both operands
+ - * /	SET	SET	SET
DIV MOD	integer	integer	smallest integer type including both operands
OR & ~	BOOLEAN	BOOLEAN	BOOLEAN
= # < <= > >=	numeric CHAR character array, string	numeric CHAR character array, string	BOOLEAN BOOLEAN BOOLEAN
= #	BOOLEAN SET NIL, pointer type T0 or T1 procedure type T, NIL	BOOLEAN SET NIL, pointer type T0 or T1 procedure type T, NIL	BOOLEAN BOOLEAN BOOLEAN BOOLEAN
IN	integer	SET	BOOLEAN
IS	type T0	type T1	BOOLEAN

Matching formal parameter lists

Two formal parameter lists match if

1. they have the same number of parameters, and
2. they have either the same function result type or none, and
3. parameters at corresponding positions have equal types, and
4. parameters at corresponding positions are both either value or variable parameters.