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 ENDEND 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 pEND Search;

PROCEDURE NewTree* (): Tree; VAR t: Tree;BEGIN NEW(t); NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL; RETURN tEND NewTree;

END Trees.

Oberon-2 extensions to Oberon

Source:

Type-bound procedures

Procedures can be bound to a record (or pointer) type. They are equivalent to instance methods in object-oriented terminology.

Read-only export

The use of exported variables and record fields can be restricted to read-only access. This is shown with a "-" visibility flag.

Open arrays

Open arrays which formerly could only be declared as formal parameter types may now be declared as pointer base types.

FOR statement

The FOR statement of Pascal and Modula-2 was not implemented in Oberon. It is reintroduced in Oberon-2.

Runtime type checking

Oberon-2 provides several mechanisms for checking the dynamic type of an object. For example, where a Bird object might be instantiated to either a Duck or a Cuckoo, Oberon-2 allows the programmer to respond to the actual type of the object at runtime.

The first, most conventional, approach is to rely on the type binding system. The second approach is to use the WITH statement, which allows the dynamic subtype of a variable to be checked directly. In both cases, once the subtype has been identified, the programmer can make use of any type-bound procedures or variables that are appropriate to the subtype. Examples of these approaches are shown below.

Note that the form of WITH statement used in Oberon-2 is unrelated to the Pascal and Modula-2 WITH statement. This method of abbreviating access to record fields is not implemented in Oberon or Oberon-2.

Type binding

MODULE Birds; TYPE Bird* = RECORD sound* : ARRAY 10 OF CHAR; END; END Birds. MODULE Ducks; IMPORT Birds; TYPE Duck* = RECORD (Birds.Bird) END; PROCEDURE SetSound* (VAR bird : Duck); BEGIN bird.sound := "Quack!" END SetSound; END Ducks. MODULE Cuckoos; IMPORT Birds; TYPE Cuckoo* = RECORD (Birds.Bird) END; PROCEDURE SetSound* (VAR bird : Cuckoo); BEGIN bird.sound := "Cuckoo!" END SetSound; END Cuckoos.

WITH statement

MODULE Test; IMPORT Out, Birds, Cuckoos, Ducks; TYPE SomeBird* = RECORD (Birds.Bird) END; VAR sb : SomeBird; c : Cuckoos.Cuckoo; d : Ducks.Duck; PROCEDURE SetSound* (VAR bird : Birds.Bird); BEGIN WITH bird : Cuckoos.Cuckoo DO bird.sound := "Cuckoo!" | bird : Ducks.Duck DO bird.sound := "Quack!" ELSE bird.sound := "Tweet!" END END SetSound; PROCEDURE MakeSound* (VAR b : Birds.Bird); BEGIN Out.Ln; Out.String(b.sound); Out.Ln END MakeSound; BEGIN SetSound(c); SetSound(d); SetSound(sb); MakeSound(c); MakeSound(d); MakeSound(sb) END Test.

POINTER

MODULE PointerBirds; IMPORT Out; TYPE BirdRec* = RECORD sound* : ARRAY 10 OF CHAR; END; DuckRec* = RECORD (BirdRec) END; CuckooRec* = RECORD (BirdRec) END; Bird = POINTER TO BirdRec; Cuckoo = POINTER TO CuckooRec; Duck = POINTER TO DuckRec; VAR pb : Bird; pc : Cuckoo; pd : Duck; PROCEDURE SetDuckSound* (bird : Duck); BEGIN bird.sound := "Quack!" END SetDuckSound; PROCEDURE SetCuckooSound* (bird : Cuckoo); BEGIN bird.sound := "Cuckoo!" END SetCuckooSound; PROCEDURE SetSound* (bird : Bird); BEGIN WITH bird : Cuckoo DO SetCuckooSound(bird) | bird : Duck DO SetDuckSound(bird) ELSE bird.sound := "Tweet!" END END SetSound; BEGIN NEW(pc); NEW(pd); SetCuckooSound(pc); SetDuckSound(pd); Out.Ln; Out.String(pc^.sound); Out.Ln; Out.Ln; Out.String(pd^.sound); Out.Ln; SetSound(pc); SetSound(pd); Out.Ln; Out.String(pc^.sound); Out.Ln; Out.Ln; Out.String(pd^.sound); Out.Ln; (* -------------------------------------- *) (* Pass dynamic type to procedure *) pb := pd; SetDuckSound(pb(Duck)); Out.Ln; Out.String(pb^.sound); Out.Ln; pb := pc; SetCuckooSound(pb(Cuckoo)); Out.Ln; Out.String(pb^.sound); Out.Ln; (* -------------------------------------- *) SetSound(pb); Out.Ln; Out.String(pb^.sound); Out.Ln; pb := pd; SetSound(pb); Out.Ln; Out.String(pb^.sound); Out.Ln; (* -------------------------------------- *) NEW(pb); SetSound(pb); Out.Ln; Out.String(pb^.sound); Out.Ln END PointerBirds.

IS operator

A third approach is possible using the IS operator. This is a relation operator with the same precedence as equals (=), greater (>), etc. but which tests dynamic type. Unlike the two other approaches, however, it does not allow the programmer access to the subtype that has been detected.

Syntax

The development of the ALGOL -> Pascal -> Modula-2 -> Oberon -> Component Pascal language family is marked by a reduction in the complexity of the language syntax. The entire Oberon-2 language is described (Mössenböck & Wirth, March 1995) using only 33 grammatical productions in the extended Backus-Naur form, as shown below.

Module = MODULE ident ";" [ImportList] DeclSeq [BEGIN StatementSeq] END ident ".".ImportList = IMPORT [ident ":="] ident {"," [ident ":="] ident} ";".DeclSeq = { CONST {ConstDecl ";" } | TYPE {TypeDecl ";"} | VAR {VarDecl ";"}} {ProcDecl ";" | ForwardDecl ";"}.ConstDecl = IdentDef "=" ConstExpr.TypeDecl = IdentDef "=" Type.VarDecl = IdentList ":" Type.ProcDecl = PROCEDURE [Receiver] IdentDef [FormalPars] ";" DeclSeq [BEGIN StatementSeq] END ident.ForwardDecl = PROCEDURE "^" [Receiver] IdentDef [FormalPars].FormalPars = "(" [FPSection {";" FPSection}] ")" [":" Qualident].FPSection = [VAR] ident {"," ident} ":" Type.Receiver = "(" [VAR] ident ":" ident ")".Type = Qualident | ARRAY [ConstExpr {"," ConstExpr}] OF Type | RECORD ["("Qualident")"] FieldList {";" FieldList} END | POINTER TO Type | PROCEDURE [FormalPars].FieldList = [IdentList ":" Type].StatementSeq = Statement {";" Statement}.Statement = [ Designator ":=" Expr | Designator ["(" [ExprList] ")"] | IF Expr THEN StatementSeq {ELSIF Expr THEN StatementSeq} [ELSE StatementSeq] END | CASE Expr OF Case {"|" Case} [ELSE StatementSeq] END | WHILE Expr DO StatementSeq END | REPEAT StatementSeq UNTIL Expr | FOR ident ":=" Expr TO Expr [BY ConstExpr] DO StatementSeq END | LOOP StatementSeq END | WITH Guard DO StatementSeq {"|" Guard DO StatementSeq} [ELSE StatementSeq] END | EXIT | RETURN [Expr] ]. Case = [CaseLabels {"," CaseLabels} ":" StatementSeq].CaseLabels = ConstExpr [".." ConstExpr].Guard = Qualident ":" Qualident.ConstExpr = Expr.Expr = SimpleExpr [Relation SimpleExpr].SimpleExpr = ["+" | "-"] Term {AddOp Term}.Term = Factor {MulOp Factor}.Factor = Designator ["(" [ExprList] ")"] | number | character | string | NIL | Set | "(" Expr ")" | "~" Factor.Set = "{" [Element {"," Element}] "}".Element = Expr [".." Expr].Relation = "=" | "#" | "<" | "<=" | ">" | ">=" | IN | IS.AddOp = "+" | "-" | OR.MulOp = "*" | "/" | DIV | MOD | "&".Designator = Qualident {"." ident | "[" ExprList "]" | "^" | "(" Qualident ")"}.ExprList = Expr {"," Expr}.IdentList = IdentDef {"," IdentDef}.Qualident = [ident "."] ident.IdentDef = ident ["*" | "-"].

Implementations

Oberon-2 compilers maintained by ETH include versions for Windows, Linux, Solaris, macOS.

The compiles to native machine code and can use a JIT on Windows, Linux, and macOS. It is created and maintained by Mike Spivey and uses the Keiko Virtual Machine.

There is an Oberon-2 Lex scanner and Yacc parser by Stephen J. Bevan of Manchester University, UK, based on the one in the Mössenböck and Wirth reference. It is at version 1.4.

There is a release named Native Oberon which includes an operating system, and can directly boot on PC class hardware.

A .NET implementation of Oberon with the addition of some minor .NET-related extensions has been developed at ETHZ.

(POW!) is a very simple integrated development environment, which is provided with editor, linker, and Oberon-2 compiler. This compiles to Windows executables. Full source code is provided; the compiler is written in Oberon-2.

The (JOB) was written at the University of Vologda in Russia. It produces object code in the form of Java class files (bytecode). Some JOB-specific classes are provided which are Java compatible, but which use a more Oberon-like component hierarchy.

The compiles to C, using the GNU Compiler Collection (GCC) toolchain for program generation.

is a compiler that translates the full Oberon language into JavaScript. The compiler is written in JavaScript and can thus be called from Web pages to process scripts written in Oberon.

is a development system by Excelsior LLC, Novosibirsk, Russia. It contains an optimizing compiler for Intel Pentium, or "via-C" translator for cross-platform software development. Available for Windows and Linux. The compiler is written in Oberon-2 and compiles itself.

is a project to bring Oberon 2 and Component Pascal (BlackBox Component Builder) to Linux and Win32. The Linux port of BlackBox was unavailable before and it originally ran on only Microsoft Windows.

XOberon is a real-time operating system for PowerPC, written in Oberon-2.

The Portable Oberon-2 Compiler (OP2) was developed to port the Oberon System onto commercially available platforms.

Keiko bytecode

Oberon-2 can target the Keiko Virtual machine.For example, like some other language compilers (see O-code, p-code, etc.),the first compiles to an intermediate bytecode (Keiko bytecode) which can be interpreted with a byte-code interpreter or use just-in-time compilation.