View source for Oberon-2

{{Short description|Programming language}}
{{Multiple issues|
{{Primary sources|date=April 2011}}
{{External links|date=February 2024}}
}}
{{Use dmy dates|date=January 2021}}
{{Infobox programming language
| name = Oberon-2
| logo = Oberon programming language logo.svg
| paradigms = [[Imperative programming|Imperative]], [[Structured programming|structured]], [[Modular programming|modular]], [[Object-oriented programming|object-oriented]]
| family = [[Niklaus Wirth|Wirth]] [[Oberon (programming language)|Oberon]]
| designer = [[Niklaus Wirth]]<br/>[[:de:Hanspeter Mössenböck|Hanspeter Mössenböck]]
| developer = [[ETH Zurich]]
| released = {{Start date and age|1991}}
| latest release version = 
| latest release date = <!-- {{Start date and age|202y|mm|yy|df=yes}} -->
| typing = [[Strong and weak typing|Strong]], hybrid ([[Static typing|static]] and [[Dynamic typing|dynamic]])
| scope = [[Scope (computer science)|Lexical]]
| programming language = 
| platform = [[Ceres (workstation)|Ceres]] ([[NS32000|NS32032]]), [[IA-32]], [[x86-64]]<!-- [[SPARC]]? -->
| operating system = [[Microsoft Windows|Windows]], [[Linux]], [[Solaris (operating system)|Solaris]], [[macOS]]
| license = 
| file ext = 
| file format = <!-- or: | file formats = -->
| website = {{URL|www.ethoberon.ethz.ch}}
| implementations = 
| dialects = 
| influenced by = [[Oberon (programming language)|Oberon]], [[Modula-2]], [[Object Oberon]]
| influenced = [[Oberon (programming language)#Oberon-07|Oberon-07]], [[Zonnon]], [[Active Oberon]], [[Component Pascal]], [[Go (programming language)|Go]], [[Nim (programming language)|Nim]]
}}
'''Oberon-2''' is an extension of the original [[Oberon (programming language)|Oberon]] [[programming language]] that adds limited [[reflective programming]] (reflection) and [[object-oriented programming]] facilities, open [[Array data structure|arrays]] as pointer base types, read-only field export, and reintroduces the <code>FOR</code> loop from [[Modula-2]].

It was developed in 1991 at [[ETH Zurich]] by [[Niklaus Wirth]] and [[:de:Hanspeter Mössenböck|Hanspeter Mössenböck]], who is now at Institut für Systemsoftware (SSW) of the [[University of Linz]], Austria. Oberon-2 is a superset of Oberon, is fully compatible with it, and was a redesign of [[Object Oberon]].

Oberon-2 inherited limited reflection and single [[Inheritance (object-oriented programming)|inheritance]] ("type extension") without the interfaces or [[mixin]]s from Oberon, but added efficient virtual [[Method (computer programming)|methods]] ("type bound procedures"). Method calls were resolved at [[Runtime (program lifecycle phase)|runtime]] using [[C++]]-style virtual method tables.

Compared to fully object-oriented languages like [[Smalltalk]], in Oberon-2, basic [[data type]]s and [[Class (programming)|classes]] are not [[Object (computer science)|objects]], many operations are not methods, there is no [[message passing]] (it can be emulated somewhat by reflection and through message extension, as demonstrated in ETH Oberon), and [[Polymorphism (computer science)|polymorphism]] is limited to subclasses of a common class (no [[duck typing]] as in [[Python (programming language)|Python]],<ref>{{Cite web |url=http://www.drdobbs.com/templates-and-duck-typing/184401971 |title=Related Reading |website=Dr. Dobb's}}</ref> and it's not possible to define interfaces as in [[Java (programming language)|Java]]). Oberon-2 does not support [[Encapsulation (computer programming)|encapsulation]] at object or class level, but modules can be used for this purpose.

Reflection in Oberon-2 does not use [[metaobject]]s, but simply reads from type descriptors [[Compiler|compiled]] into the executable binaries, and exposed in the modules that define the types and/or procedures. If the format of these structures are exposed at the language level (as is the case for ETH Oberon, for example), reflection could be implemented at the [[Library (computing)|library]] level. It could thus be implemented almost entirely at library level, without changing the language code. Indeed, ETH Oberon makes use of language-level and library-level reflection abilities extensively.

Oberon-2 provides built-in runtime support for [[Garbage collection (computer science)|garbage collection]] similar to Java and performs bounds and array index checks, etc., that eliminate the potential stack and array bounds overwriting problems and manual memory management issues inherent in [[C (programming language)|C]] and C++. Separate compiling using symbol files and [[namespace]]s via the module architecture ensure fast rebuilds since only modules with changed interfaces need to be recompiled.

The language [[Component Pascal]]<ref>{{Cite web |last=Pfister |first=Cuno |date=2001 |url=http://www.oberon.ch/pdf/CP-New.pdf |title=What's New in Component Pascal (changes from Oberon-2 to CP) |website=Oberon microsystems |access-date=10 January 2007 |url-status=dead |archive-url=https://web.archive.org/web/20110515111149/http://www.oberon.ch/pdf/CP-New.pdf |archive-date=2011-05-15}}</ref> is a refinement (a superset) of Oberon-2.

== Example code ==
The following Oberon-2 code implements a simple binary tree:

<syntaxhighlight lang="modula2" style="font-size:10pt">
MODULE Trees;

TYPE
    Tree* = POINTER TO Node;
    Node* = RECORD
        name-: POINTER TO ARRAY OF CHAR;
        left, right: Tree
    END;

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 NewTree* (): Tree;
    VAR t: Tree;
BEGIN NEW(t); NEW(t.name, 1); t.name[0] := 0X; t.left := NIL; t.right := NIL; RETURN t
END NewTree;

END Trees.
</syntaxhighlight>

== Oberon-2 extensions to Oberon ==
Source:<ref>[https://www.research-collection.ethz.ch/handle/20.500.11850/68904 Differences between Oberon and Oberon-2, Mössenböck and Wirth (1993)]</ref>
=== 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 <code>FOR</code> 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 ''<code>WITH</code> statement'', which allows the dynamic [[Subtyping|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 <code>WITH</code> 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 ====
<syntaxhighlight lang="componentpascal">
 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.
</syntaxhighlight>

==== <code>WITH</code> statement ====
<syntaxhighlight lang="componentpascal">
 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.
</syntaxhighlight>

==== <code>POINTER</code> ====
<syntaxhighlight lang="componentpascal">
 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.
</syntaxhighlight>

==== <code>IS</code> operator ====
A third approach is possible using the '''<code>IS</code> operator'''. This is a relation operator with the same precedence as equals (<code>=</code>), greater (<code>></code>), 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 (programming language)|Pascal]] → [[Modula-2]] → Oberon → [[Component Pascal]] language family is marked by a ''reduction'' in the complexity of the [[Syntax (programming languages)|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.

<syntaxhighlight lang="ebnf">
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 ["*" | "-"].
</syntaxhighlight>

== Implementations ==
Oberon-2 compilers maintained by [[ETH]] include versions for [[Windows]], [[Linux]], [[Oracle Solaris|Solaris]], [[macOS]].

The [http://spivey.oriel.ox.ac.uk/corner/Oxford_Oberon-2_compiler Oxford Oberon-2 compiler] compiles to native machine code and can use a JIT on Windows, Linux, and macOS. It is created and maintained by [[Michael Spivey|Mike Spivey]] and uses the Keiko Virtual Machine.<ref>{{cite report |last=Spivey |first=Michael |author-link=Michael Spivey |year=2014 |url=https://spivey.oriel.ox.ac.uk/corner/Specification_of_Keiko_(Compilers) |title=Specification of Keiko |website=Spivey's Corner |publisher=Oriel College, University of Oxford |archive-url=https://web.archive.org/web/20160304070606/https://spivey.oriel.ox.ac.uk/corner/Specification_of_Keiko_(Compilers) |archive-date=4 March 2016 |access-date=9 July 2023}}</ref><ref>{{cite report |last=Spivey |first=Michael |author-link=Michael Spivey |date=30 September 2020 |url=https://spivey.oriel.ox.ac.uk/corner/Design_overview_for_OBC |title=Design overview for OBC: The Keiko Abstract Machine |website=Spivey's Corner |publisher=Oriel College, University of Oxford |quote=The Oxford Oberon-2 compiler translates source programs into code for a stack-based abstract machine. ... the Keiko machine. |access-date=9 July 2023}}</ref>

There is an Oberon-2 [[Lex (software)|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.

[http://www.fim.uni-linz.ac.at/pow/Pow.htm Programmer's Open Workbench] (POW!)<ref>{{Cite magazine |last=Collingbourne |first=H. |date=February 2000 |title=What Pascal's inventor did next |magazine=[[PC Plus]] |issue=160}}</ref> is a very simple [[integrated development environment]], which is provided with editor, linker, and Oberon-2 compiler. This compiles to [[Microsoft Windows|Windows]] executables. Full [[source code]] is provided; the compiler is written in Oberon-2.

The [https://web.archive.org/web/20110720112830/http://www.uni-vologda.ac.ru/JOB/ Java to Oberon Compiler] (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 [https://sourceforge.net/projects/ooc Optimizing Oberon-2 Compiler] compiles to C, using the [[GNU Compiler Collection]] (GCC) toolchain for program generation.

[http://www.ralphsommerer.com/obn.htm Oberon Script] 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.

[https://web.archive.org/web/20110820112230/http://www.excelsior-usa.com/xds.html XDS Modula2/Oberon2] 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.

[https://sourceforge.net/projects/oberonrevival/files/ Oberon Revival] 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.<ref name="OP2">{{cite thesis |last=Crelier |first=Régis |year=1994 |type=PhD |url=https://www.research-collection.ethz.ch/handle/20.500.11850/141604 |title=Separate Compilation and Module Extension |publisher=ETH Zurich |doi=10.3929/ethz-a-000945227 |hdl=20.500.11850/141604 |access-date=18 November 2018}}</ref>

== Keiko bytecode ==

Oberon-2 can target the Keiko Virtual machine.<ref name="keiko_spec">
Dr. Michael Spivey.
[https://web.archive.org/web/20160304070606/https://spivey.oriel.ox.ac.uk/corner/Specification_of_Keiko_(Compilers) "Specification of Keiko"].
</ref><ref name="keiko machine" >
Dr. Michael Spivey.
[https://spivey.oriel.ox.ac.uk/corner/Design_overview_for_OBC "Design overview for OBC: The Keiko Abstract Machine"].
quote:
"The Oxford Oberon--2 compiler translates source programs into code for a stack-based abstract machine... the Keiko machine"
</ref>
For example, like some other language compilers (see [[O-code]], [[p-code]], etc.),
the [http://spivey.oriel.ox.ac.uk/corner/Oxford_Oberon-2_compiler Oxford Oberon-2 compiler] first compiles to an intermediate bytecode (Keiko bytecode) which can be interpreted with a byte-code interpreter or use [[just-in-time compilation]].

==See also==
{{Portal|Computer programming}}
* [[A2 (operating system)]]

== References ==
{{Reflist}}

== Further reading ==
{{Wikibooks|Oberon}}
* "''[https://web.archive.org/web/20130529020132/http://www.ethoberon.ethz.ch/genealogy.html Oberon Language Genealogy Tree]''" maintained at [[ETHZ]]
* "Second International Modula-2 Conference", September 1991.
* [http://members.home.nl/jmr272/Oberon/ModToOberon.pdf From Modula to Oberon] {{Webarchive|url=https://web.archive.org/web/20140223114227/http://members.home.nl/jmr272/Oberon/ModToOberon.pdf |date=23 February 2014 }} Wirth (1990)
* [http://www.inf.ethz.ch/personal/wirth/ProgInOberon.pdf Programming in Oberon - A derivative of Programming in Modula-2] Wirth (1982)
* [http://www.inf.ethz.ch/personal/wirth/Oberon/Oberon.Report.pdf The Programming Language Oberon] Wirth (1990)
* [http://www.ssw.uni-linz.ac.at/Research/Papers/Oberon2.pdf The Programming Language Oberon-2] H. Mössenböck, N. Wirth, Institut für Computersysteme, [[ETH Zurich]], January 1992 and [https://dblp.org/db/journals/stp/stp12.html Structured Programming] (1991) 12(4): 179-195.
* [http://www.ethoberon.ethz.ch/books.html Various references including electronic online versions]
* [http://ssw.jku.at/Research/Books/Oberon2.pdf Object-Oriented Programming in Oberon-2] Hanspeter Mössenböck (1994). (Available from [http://ssw.jku.at/Research/Books/ Johannes Kepler University] as PDF with the friendly permission of Springer-Verlag)
* [http://ssw.jku.at/Research/Books/DesignPatterns.pdf Design Patterns in Oberon-2 and Component Pascal]
* [http://www.inf.ethz.ch/personal/wirth/ProjectOberon1992.pdf Project Oberon. The design of an Operating System and Compiler] Niklaus Wirth & Jürg Gutknecht (2005)
* [http://www.inf.ethz.ch/personal/wirth/ProjectOberon Project Oberon. The design of an Operating System and Compiler] Niklaus Wirth & Jürg Gutknecht (2013)

== External links ==
* {{Official website|www.ethoberon.ethz.ch}}, ETH Zürich
* [https://web.archive.org/web/20050221100629/http://www.oberon.ethz.ch/ Oberon Reference page at ETH Zürich]
* [http://www.ssw.uni-linz.ac.at/Research/Projects/Oberon.html Oberon at SSW, Linz]
* [http://www.zinnamturm.eu/downloadsOS.htm#Pow Pow Tutorial (in Romanian language), by Dan Popa]
* [http://www.ssw.uni-linz.ac.at/Research/Projects/Reflection/Reflection99/paper.ps The Oberon-2 Reflection Model and its Applications]

{{Modula, Oberon}}
{{Wirth}}

[[Category:Modula programming language family]]
[[Category:Object-oriented programming languages]]
[[Category:Oberon programming language family]]
[[Category:Programming languages created in 1991]]