Oberon (Programmiersprache) - Oberon (programming language)

Oberon
Oberon Programmiersprache logo.svg
Paradigmen Imperativ , strukturiert , modular , objektorientiert
Familie Wirth Oberon
Entworfen von Niklaus Wirth
Entwickler ETH Zürich
Erstmals erschienen 1987 ; Vor 34 Jahren ( 1987 )
Stabile Version
Oberon-07 / 6 März 2020 ; vor 18 Monaten ( 2020-03-06 )
Schreibdisziplin Stark , hybrid ( statisch und dynamisch )
Umfang Lexikalisches
Plattform ARM , StarkARM ; IA-32 , x86-64 ; SPARC , Ceres ( NS32032 )
Betriebssystem Windows , Linux , Solaris , klassisches Mac OS , Atari TOS , AmigaOS
Webseite www .projectoberon .com
Beeinflusst von
Modula-2
Beeinflusst
Oberon-2 , Oberon-07 , Zonnon , Go , Nim , Aktiver Oberon , Komponente Pascal

Oberon ist eine Allzweck- Programmiersprache, die erstmals 1987 von Niklaus Wirth veröffentlicht wurde und das neueste Mitglied der Wirthian-Familie von ALGOL- ähnlichen Sprachen ( Euler , ALGOL W , Pascal , Modula und Modula-2 ). Oberon war das Ergebnis konzentrierter Bemühungen, die Leistung von Modula-2 , dem direkten Nachfolger von Pascal , zu steigern und gleichzeitig seine Komplexität zu reduzieren. Die wichtigste Neuerung ist das Konzept der Typerweiterung von Datensatztypen. Es erlaubt, ausgehend von bestehenden Datentypen neue Datentypen zu konstruieren und diese in Beziehung zu setzen, abweichend vom Dogma der streng statischen Typisierung von Daten. Typerweiterung ist die Art der Vererbung von Wirth, die den Standpunkt der übergeordneten Site widerspiegelt. Oberon wurde im Rahmen der Implementierung eines Betriebssystems , auch Oberon genannt, an der ETH Zürich in der Schweiz entwickelt . Der Name stammt vom Mond des Planeten Uranus , genannt Oberon .

Oberon wird weiterhin von Wirth gepflegt und das neueste Compiler-Update für Project Oberon datiert vom 6. März 2020.

Entwurf

Oberon wurde nach einem Albert Einstein zugeschriebenen Motto entworfen : „Mache die Dinge so einfach wie möglich, aber nicht einfacher.“ Die Hauptrichtlinie bestand darin, sich auf grundlegende und wesentliche Funktionen zu konzentrieren und ephemere Themen auszulassen. Ein weiterer Faktor war die Erkenntnis der zunehmenden Komplexität in Sprachen wie C++ und Ada . Im Gegensatz dazu betont Oberon die Verwendung des Bibliothekskonzepts zur Erweiterung der Sprache. Aufzählungs- und Unterbereichstypen, die in Modula-2 vorhanden waren, wurden weggelassen, und Mengentypen sind auf Mengen von ganzen Zahlen beschränkt. Alle importierten Elemente müssen durch den Namen des Moduls gekennzeichnet sein, in dem sie deklariert sind. Untergeordnete Einrichtungen werden dadurch hervorgehoben, dass sie nur in einem Modul verwendet werden dürfen, das den Bezeichner SYSTEM in seiner Importliste enthält. Strenge Typüberprüfung , sogar über Module hinweg , Indexüberprüfung zur Laufzeit , Nullzeigerüberprüfung und das Konzept der sicheren Typerweiterung ermöglichen es der Programmierung weitgehend, sich allein auf die Sprachregeln zu verlassen.

Ziel dieser Strategie war es, eine Sprache zu entwickeln, die leichter zu erlernen, einfacher zu implementieren und sehr effizient ist. Oberon-Compiler gelten als kompakt und schnell und bieten gleichzeitig eine Codequalität, die mit kommerziellen Compilern vergleichbar ist.

Eigenschaften

Zu den Merkmalen, die die Oberon-Sprache charakterisieren, gehören:

  • Groß-/Kleinschreibung beachtende Syntax mit Großbuchstaben-Schlüsselwörtern
  • Typenerweiterung mit Typenprüfung
  • Module und separates Kompilieren
  • String-Operationen
  • Isolieren von unsicherem Code
  • Unterstützung bei der Systemprogrammierung

Objektorientierung

Oberon unterstützt die Erweiterung von Datensatztypen zum Aufbau von Abstraktionen und heterogenen Strukturen. Im Gegensatz zu den späteren Dialekten Oberon-2 und Active Oberon fehlt dem ursprünglichen Oberon ein Dispatch-Mechanismus als Sprachmerkmal, sondern als Programmiertechnik oder Entwurfsmuster. Dies bietet große Flexibilität in OOP. Im Betriebssystem Oberon werden zwei Programmiertechniken zusammen für den Dispatch-Aufruf verwendet: Method Suite und Message Handler.

Methodensuite

Bei dieser Technik wird eine Tabelle der Prozedur Variablen definiert und eine globale Variable dieses Typs ist in dem erweiterten Modul und zugeordnet zurück in dem generischen Modul deklariert: 

MODULE Figures; (* Abstract module *)

TYPE
   Figure*    = POINTER TO FigureDesc;
   Interface* = POINTER TO InterfaceDesc;

   InterfaceDesc* = RECORD
      draw*  : PROCEDURE (f : Figure);
      clear* : PROCEDURE (f : Figure);
      mark*  : PROCEDURE (f : Figure);
      move*  : PROCEDURE (f : Figure; dx, dy : INTEGER);
   END;

   FigureDesc* = RECORD
      if : Interface;
   END;

PROCEDURE Init* (f : Figure; if : Interface);
BEGIN
   f.if := if
END Init;

PROCEDURE Draw* (f : Figure);
BEGIN
   f.if.draw(f)
END Draw;

(* Other procedures here *)

END Figures.

Wir erweitern den generischen Typ Figure um eine bestimmte Form: 

MODULE Rectangles;

IMPORT Figures;

TYPE
   Rectangle* = POINTER TO RectangleDesc;

   RectangleDesc* = RECORD
      (Figures.FigureDesc)
      x, y, w, h : INTEGER;
   END;

VAR
   if : Figures.Interface;

PROCEDURE New* (VAR r : Rectangle);
BEGIN
   NEW(r);
   Figures.Init(r, if)
END New;

PROCEDURE Draw* (f : Figure);
   VAR
      r : Rectangle;
BEGIN
   r := f(Rectangle); (* f AS Rectangle *)
   (* ... *)
END Draw;

(* Other procedures here *)

BEGIN (* Module initialisation *)
   NEW(if);
   if.draw  := Draw;
   if.clear := Clear;
   if.mark  := Mark;
   if.move  := Move
END Rectangles.

Der dynamische Versand erfolgt nur über Prozeduren im Figures-Modul, das das generische Modul ist.

Nachrichtenhandler

Diese Technik besteht darin, den Methodensatz durch ein einziges Verfahren zu ersetzen, das zwischen den verschiedenen Methoden unterscheidet: 

MODULE Figures; (* Abstract module *)

TYPE
   Figure*    = POINTER TO FigureDesc;

   Message*   = RECORD END;
   DrawMsg*   = RECORD (Message) END;
   ClearMsg*  = RECORD (Message) END;
   MarkMsg*   = RECORD (Message) END;
   MoveMsg*   = RECORD (Message) dx*, dy* : INTEGER END;

   Handler*   = PROCEDURE (f : Figure; VAR msg : Message);

   FigureDesc* = RECORD
      (* Abstract *)
      handle : Handler;
   END;

PROCEDURE Handle* (f : Figure; VAR msg : Message);
BEGIN
   f.handle(f, msg)
END Handle;

PROCEDURE Init* (f : Figure; handle : Handler);
BEGIN
   f.handle := handle
END Init;

END Figures.

Wir erweitern den generischen Typ Figure um eine bestimmte Form: 

MODULE Rectangles;

IMPORT Figures;

TYPE
   Rectangle* = POINTER TO RectangleDesc;

   RectangleDesc* = RECORD
      (Figures.FigureDesc)
      x, y, w, h : INTEGER;
   END;

PROCEDURE Draw* (r : Rectangle);
BEGIN
  (* ... *)
END Draw;

(* Other procedures here *)

PROCEDURE Handle* (f: Figure; VAR msg: Figures.Message);
   VAR
      r : Rectangle;
BEGIN
   r := f(Rectangle);
   IF    msg IS Figures.DrawMsg THEN Draw(r)
   ELSIF msg IS Figures.MarkMsg THEN Mark(r)
   ELSIF msg IS Figures.MoveMsg THEN Move(r, msg(Figures.MoveMsg).dx, msg(Figures.MoveMsg).dy)
   ELSE  (* ignore *)
   END
END Handle;

PROCEDURE New* (VAR r : Rectangle);
BEGIN
   NEW(r);
   Figures.Init(r, Handle)
END New;

END Rectangles.

Im Oberon-Betriebssystem werden diese beiden Techniken für den dynamischen Versand verwendet. Die erste wird für eine bekannte Reihe von Methoden verwendet; die zweite wird für alle neuen Methoden verwendet, die im Erweiterungsmodul deklariert werden. Wenn beispielsweise das Erweiterungsmodul Rectangles eine neue Rotate()-Prozedur implementieren sollte, könnte diese innerhalb des Figures-Moduls nur über einen Message-Handler aufgerufen werden.

Implementierungen und Varianten

Oberon

Kostenlose Implementierungen von Oberon (die Sprache) und Oberon (das Betriebssystem) sind im Internet zu finden (einige davon stammen von der ETHZ selbst).

Oberon-2

Hauptartikel: Oberon-2

An der ersten veröffentlichten Spezifikation wurden einige Änderungen vorgenommen. Zum Beispiel wurden Funktionen der objektorientierten Programmierung (OOP) hinzugefügt, die FORSchleife wurde wieder eingeführt. Das Ergebnis war Oberon-2 . Eine Version namens Native Oberon, die ein Betriebssystem enthält und direkt auf IBM-PC-kompatibler Hardware booten kann . An der ETHZ wurde auch eine .NET- Implementierung von Oberon mit einigen kleineren .NET-bezogenen Erweiterungen entwickelt. 1993 brachte ein Spin-off-Unternehmen der ETHZ einen Dialekt von Oberon-2 mit dem Namen Oberon-L auf den Markt . 1997 wurde es in Component Pascal umbenannt .

Die von der ETH entwickelten Oberon-2-Compiler umfassen Versionen für Microsoft Windows , Linux , Solaris und das klassische Mac OS . Für einige andere Betriebssysteme, einschließlich Atari TOS und AmigaOS, existieren Implementierungen aus anderen Quellen .

Es gibt einen Oberon-2 Lex- Scanner und einen Yacc- Parser von Stephen J Bevan von der Manchester University, UK, basierend auf dem in der Referenz von Mössenböck und Wirth. Es ist in der Version 1.4.

Andere Compiler sind Oxford Oberon-2, das auch Oberon-07 versteht, und Vishap Oberon. Letztere basiert auf Josef Templs Oberon to C- Sprache Source-to-Source-Compiler (Transpiler) namens Ofront, der wiederum auf dem OP2-Compiler von Regis Crelier an der ETHZ basiert.

Oberon-07

Oberon-07, 2007 von Niklaus Wirth definiert und 2008, 2011, 2013, 2014, 2015 und 2016 überarbeitet, basiert auf der Originalversion von Oberon und nicht auf Oberon-2. Die wichtigsten Änderungen sind: explizite numerische Konvertierungsfunktionen (zB FLOORund FLT) müssen verwendet werden, die Anweisungen WITH, LOOPund EXITwurden weggelassen, WHILEAnweisungen wurden erweitert, CASEAnweisungen können für Typerweiterungstests verwendet werden, RETURNAnweisungen können nur an das Ende einer Funktion angeschlossen werden, importierte Variablen und strukturierte Wertparameter sind schreibgeschützt und Arrays können ohne Verwendung von zugewiesen werden COPY.

Oberon-07-Compiler wurden zur Verwendung mit vielen verschiedenen Computersystemen entwickelt. Wirths Compiler zielt auf einen Computer mit reduziertem Befehlssatz (RISC) seines eigenen Designs ab, der verwendet wurde, um die 2013-Version des Project Oberon- Betriebssystems auf einem Xilinx- Field-Programmable Gate Array (FPGA) Spartan-3-Board zu implementieren . Portierungen des RISC-Prozessors auf FPGA Spartan-6, Spartan-7, Artix-7 und ein RISC-Emulator für Windows (kompilierbar unter Linux und macOS und Binärdateien für Windows verfügbar) sind ebenfalls vorhanden. OBNC wird über C kompiliert und kann auf jedem Portable Operating System Interface ( POSIX )-kompatiblen Betriebssystem verwendet werden. Die kommerzielle Astrobe- Implementierung zielt auf 32-Bit-ARM-Cortex- M3- , M4- und M7-Mikrocontroller ab. Der Patchouli- Compiler erzeugt 64-Bit-Windows-Binärdateien. Oberon-07M produziert 32-Bit-Windows-Binärdateien und implementiert die Revision 2008 der Sprache. Akron's produziert Binärdateien sowohl für Windows als auch für Linux. OberonJS übersetzt Oberon in JavaScript . Es gibt eine Online-IDE für Oberon . oberonc ist eine Implementierung für die Java Virtual Machine .

Aktives Oberon

Active Oberon ist eine weitere Variante von Oberon, die Objekte (mit objektzentriertem Zugriffsschutz und lokaler Aktivitätskontrolle), systemgeschützte Assertionen, präemptives Prioritäts-Scheduling und eine geänderte Syntax für Methoden ( im Oberon-Vokabular als typgebundene Prozeduren bezeichnet ) hinzufügt . Objekte können aktiv sein, das heißt, sie können Threads oder Prozesse sein. Darüber hinaus verfügt Active Oberon über eine Möglichkeit, Operatoren (einschließlich Überladungen) zu implementieren, eine erweiterte Syntax für die Verwendung von Arrays (siehe OberonX-Spracherweiterungen und Proceedings of the 7th Joint Modular Languages ​​Conference 2006 Oxford, UK) und kennt sich mit Namensräumen aus . Das Betriebssystem A2 (früher Active Object System (AOS), dann Bluebottle ), insbesondere der Kernel , synchronisiert und koordiniert verschiedene aktive Objekte.

Die ETHZ hat Active Oberon veröffentlicht, das aktive Objekte und die darauf basierenden Betriebssysteme (Active Object System (AOS), Bluebottle, A2) und Umgebung (JDK, HTTP, FTP, etc.) für die Sprache unterstützt. Wie bei vielen früheren Entwürfen der ETHZ stehen beide Versionen im Internet zum Download bereit. Ab 2003 umfassen die unterstützten Zentralprozessoren (CPUs) Single- und Dual-Core x86 und StrongARM .

Verwandte Sprachen

Die Entwicklung der Sprachen wurde in dieser Familie fortgesetzt. Eine weitere Erweiterung von Oberon-2, ursprünglich Oberon/L genannt, aber später in Component Pascal umbenannt , wurde für Windows und klassisches Mac OS von Oberon microsystems, einem kommerziellen Spin-off der ETHZ, und für .NET von der Queensland University of Technology entwickelt . Darüber hinaus tragen die Sprachen Lagoona und Obliq Oberon-Methoden in spezialisierte Gebiete.

Spätere .NET-Entwicklungsbemühungen an der ETHZ konzentrierten sich auf eine neue Sprache namens Zonnon . Dies beinhaltet die Funktionen von Oberon und stellt einige von Pascal wieder her (aufgezählte Typen, integrierte IO), weist jedoch einige syntaktische Unterschiede auf. Zu den weiteren Funktionen gehören die Unterstützung für aktive Objekte, das Überladen von Operatoren und die Ausnahmebehandlung.

Oberon-V (ursprünglich Seneca genannt, nach Seneca dem Jüngeren ) ist ein Nachkomme von Oberon, der für numerische Anwendungen auf Supercomputern , insbesondere Vektor- oder Pipeline- Architekturen, entwickelt wurde. Es enthält Array-Konstruktoren und eine ALLAnweisung.

Siehe auch

Ressourcen

Allgemein

Entwicklung von Oberon

Verweise