Wikipedia

Oberon-2

Oberon-2is an extension of the originalOberonprogramming languagethat adds limitedreflective programming(reflection) andobject-oriented programmingfacilities, openarraysas pointer base types, read-only field export, and reintroduces theFORloop fromModula-2.

Oberon-2
ParadigmsImperative,structured,modular,object-oriented
FamilyWirthOberon
Designed byNiklaus Wirth
Hanspeter Mössenböck
DeveloperETH Zurich
First appeared1991;33 years ago(1991)
Typing disciplineStrong,hybrid (staticanddynamic)
ScopeLexical
PlatformCeres(NS32032),IA-32,x86-64
OSWindows,Linux,Solaris,macOS
Websitewww.ethoberon.ethz.ch
Influenced by
Oberon,Modula-2,Object Oberon
Influenced
Oberon-07,Zonnon,Active Oberon,Component Pascal,Go,Nim

It was developed in 1991 atETH ZurichbyNiklaus WirthandHanspeter Mössenböck,who is now at Institut für Systemsoftware (SSW) of theUniversity of Linz,Austria. Oberon-2 is a superset of Oberon, is fully compatible with it, and was a redesign ofObject Oberon.

Oberon-2 inherited limited reflection and singleinheritance( "type extension" ) without the interfaces ormixinsfrom Oberon, but added efficient virtualmethods( "type bound procedures" ). Method calls were resolved atruntimeusingC++-style virtual method tables.

Compared to fully object-oriented languages likeSmalltalk,in Oberon-2, basicdata typesandclassesare notobjects,many operations are not methods, there is nomessage passing(it can be emulated somewhat by reflection and through message extension, as demonstrated in ETH Oberon), andpolymorphismis limited to subclasses of a common class (noduck typingas inPython,[1]and it's not possible to define interfaces as inJava). Oberon-2 does not supportencapsulationat object or class level, but modules can be used for this purpose.

Reflection in Oberon-2 does not usemetaobjects,but simply reads from type descriptorscompiledinto 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 thelibrarylevel. 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 forgarbage collectionsimilar 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 inCand C++. Separate compiling using symbol files andnamespacesvia the module architecture ensure fast rebuilds since only modules with changed interfaces need to be recompiled.

The languageComponent Pascal[2]is a refinement (a superset) of Oberon-2.

Example code

edit

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

MODULETrees;

TYPE
Tree*=POINTERTONode;
Node*=RECORD
name-:POINTERTOARRAYOFCHAR;
left,right:Tree
END;

PROCEDURE(t:Tree)Insert*(name:ARRAYOFCHAR);
VARp,father:Tree;
BEGINp:=t;
REPEATfather:=p;
IFname=p.name^THENRETURNEND;
IFname<p.name^THENp:=p.leftELSEp:=p.rightEND
UNTILp=NIL;
NEW(p);p.left:=NIL;p.right:=NIL;NEW(p.name,LEN(name)+1);COPY(name,p.name^);
IFname<father.name^THENfather.left:=pELSEfather.right:=pEND
ENDInsert;

PROCEDURE(t:Tree)Search*(name:ARRAYOFCHAR):Tree;
VARp:Tree;
BEGINp:=t;
WHILE(p#NIL)&(name#p.name^)DO
IFname<p.name^THENp:=p.leftELSEp:=p.rightEND
END;
RETURNp
ENDSearch;

PROCEDURENewTree*():Tree;
VARt:Tree;
BEGINNEW(t);NEW(t.name,1);t.name[0]:=0X;t.left:=NIL;t.right:=NIL;RETURNt
ENDNewTree;

ENDTrees.

Oberon-2 extensions to Oberon[3]

edit

Type-bound procedures

edit

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

Read-only export

edit

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

Open arrays

edit

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

FOR statement

edit

TheFORstatement of Pascal and Modula-2 was not implemented in Oberon. It is reintroduced in Oberon-2.

Runtime type checking

edit

Oberon-2 provides several mechanisms for checking thedynamictype 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 thetype binding system.The second approach is to use theWITHstatement,which allows the dynamicsubtypeof 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 ofWITHstatement 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

edit 
MODULEBirds;
TYPE
Bird*=RECORD
sound*:ARRAY10OFCHAR;
END;
ENDBirds.

MODULEDucks;
IMPORTBirds;

TYPE
Duck*=RECORD(Birds.Bird)END;

PROCEDURESetSound*(VARbird:Duck);
BEGIN
bird.sound:="Quack!"
ENDSetSound;
ENDDucks.

MODULECuckoos;
IMPORTBirds;

TYPE
Cuckoo*=RECORD(Birds.Bird)END;

PROCEDURESetSound*(VARbird:Cuckoo);
BEGIN
bird.sound:="Cuckoo!"
ENDSetSound;
ENDCuckoos.

WITHstatement

edit 
MODULETest;
IMPORTOut,Birds,Cuckoos,Ducks;

TYPE
SomeBird*=RECORD(Birds.Bird)END;

VAR
sb:SomeBird;
c:Cuckoos.Cuckoo;
d:Ducks.Duck;

PROCEDURESetSound*(VARbird:Birds.Bird);
BEGIN
WITHbird:Cuckoos.CuckooDO
bird.sound:="Cuckoo!"
|bird:Ducks.DuckDO
bird.sound:="Quack!"
ELSE
bird.sound:="Tweet!"
END
ENDSetSound;

PROCEDUREMakeSound*(VARb:Birds.Bird);
BEGIN
Out.Ln;
Out.String(b.sound);
Out.Ln
ENDMakeSound;

BEGIN
SetSound(c);
SetSound(d);
SetSound(sb);

MakeSound(c);
MakeSound(d);
MakeSound(sb)
ENDTest.

POINTER

edit 
MODULEPointerBirds;
IMPORTOut;

TYPE
BirdRec*=RECORD
sound*:ARRAY10OFCHAR;
END;
DuckRec*=RECORD(BirdRec)END;
CuckooRec*=RECORD(BirdRec)END;

Bird=POINTERTOBirdRec;
Cuckoo=POINTERTOCuckooRec;
Duck=POINTERTODuckRec;

VAR
pb:Bird;
pc:Cuckoo;
pd:Duck;

PROCEDURESetDuckSound*(bird:Duck);
BEGIN
bird.sound:="Quack!"
ENDSetDuckSound;

PROCEDURESetCuckooSound*(bird:Cuckoo);
BEGIN
bird.sound:="Cuckoo!"
ENDSetCuckooSound;

PROCEDURESetSound*(bird:Bird);
BEGIN
WITHbird:CuckooDO
SetCuckooSound(bird)
|bird:DuckDO
SetDuckSound(bird)
ELSE
bird.sound:="Tweet!"
END
ENDSetSound;

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
ENDPointerBirds.

ISoperator

edit

A third approach is possible using theISoperator.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

edit

The development of theALGOL→Pascal→Modula-2→ Oberon →Component Pascallanguage family is marked by areductionin the complexity of thelanguage syntax.The entire Oberon-2 language is described (Mössenböck & Wirth, March 1995) using only 33 grammatical productions in theextended 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

edit

Oberon-2 compilers maintained byETHinclude versions forWindows,Linux,Solaris,macOS.

TheOxford Oberon-2 compilercompiles to native machine code and can use a JIT on Windows, Linux, and macOS. It is created and maintained byMike Spiveyand uses the Keiko Virtual Machine.[4][5]

There is an Oberon-2Lexscanner andYaccparserby 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 namedNative Oberonwhich includes an operating system, and can directly boot on PC class hardware.

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

Programmer's Open Workbench(POW!)[6]is a very simpleintegrated development environment,which is provided with editor, linker, and Oberon-2 compiler. This compiles toWindowsexecutables. Fullsource codeis provided; the compiler is written in Oberon-2.

TheJava 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.

TheOptimizing Oberon-2 Compilercompiles to C, using theGNU Compiler Collection(GCC) toolchain for program generation.

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

XDS Modula2/Oberon2is a development system by Excelsior LLC, Novosibirsk, Russia. It contains an optimizing compiler for IntelPentium,or "via-C" translator forcross-platform softwaredevelopment. Available for Windows and Linux. The compiler is written in Oberon-2 and compiles itself.

Oberon Revivalis a project to bring Oberon 2 andComponent 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 areal-time operating systemforPowerPC,written in Oberon-2.

The Portable Oberon-2 Compiler (OP2) was developed to port theOberon Systemonto commercially available platforms.[7]

Keiko bytecode

edit

Oberon-2 can target the Keiko Virtual machine.[8][9] For example, like some other language compilers (seeO-code,p-code,etc.), theOxford Oberon-2 compilerfirst compiles to an intermediate bytecode (Keiko bytecode) which can be interpreted with a byte-code interpreter or usejust-in-time compilation.

See also

edit

References

edit
  1. ^"Related Reading".Dr. Dobb's.
  2. ^Pfister, Cuno (2001)."What's New in Component Pascal (changes from Oberon-2 to CP)"(PDF).Oberon microsystems.Archived fromthe original(PDF)on 15 May 2011.Retrieved10 January2007.
  3. ^Differences between Oberon and Oberon-2, Mössenböck and Wirth (1993)
  4. ^Spivey, Michael(2014).Specification of Keiko.Spivey's Corner(Report). Oriel College, University of Oxford. Archived fromthe originalon 4 March 2016.Retrieved9 July2023.
  5. ^Spivey, Michael(30 September 2020).Design overview for OBC: The Keiko Abstract Machine.Spivey's Corner(Report). Oriel College, University of Oxford.Retrieved9 July2023.The Oxford Oberon-2 compiler translates source programs into code for a stack-based abstract machine.... the Keiko machine.
  6. ^Collingbourne, H. (February 2000). "What Pascal's inventor did next".PC Plus.No. 160.
  7. ^Crelier, Régis (1994).Separate Compilation and Module Extension(PhD). ETH Zurich.doi:10.3929/ethz-a-000945227.hdl:20.500.11850/141604.Retrieved18 November2018.
  8. ^ Dr. Michael Spivey. "Specification of Keiko".
  9. ^ Dr. Michael Spivey. "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"

Further reading

edit
Wikibooks has a book on the topic of:Oberon
edit
Retrieved from "https://en.wikipedia.org/w/index.php?title=Oberon-2&oldid=1218542990"