Oberon (programmeringsspråk)

Oberon
Oberon programming language logo.svg
Paradigm Imperativ , strukturerad , modulär , objektorienterad
Familj Wirth Oberon
Designad av Niklaus Wirth
Utvecklare ETH Zürich
Dök först upp 1987 ; 36 år sedan ( 1987 )
Stabil frisättning
Oberon-07 / 6 mars 2020 ; för 3 år sedan ( 2020-03-06 )
Maskinskrivningsdisciplin Stark , hybrid ( statisk och dynamisk )
Omfattning Lexikalisk
Plattform ARM , StrongARM ; IA-32 , x86-64 ; SPARC , Ceres ( NS32032 )
OS Windows , Linux , Solaris , klassiskt Mac OS , Atari TOS , AmigaOS
Hemsida www .projectoberon .com
Influerad av
Modula-2
Influerad
Oberon-2 , Oberon-07 , Active Oberon , Component Pascal , Zonnon , Go , Nim

Oberon är ett allmänt programmeringsspråk som först publicerades 1987 av Niklaus Wirth och den senaste medlemmen av Wirthian-familjen av ALGOL -liknande språk ( Euler , ALGOL W , Pascal , Modula och Modula-2 ). Oberon var resultatet av ett koncentrerat försök att öka kraften hos Modula-2 , den direkta efterföljaren till Pascal , och samtidigt minska dess komplexitet. Dess huvudsakliga nyhet är konceptet med typförlängning av posttyper. Det tillåter att konstruera nya datatyper på basis av befintliga och relatera dem, vilket avviker från dogmen om strikt statisk typning av data. Typtillägg är Wirths sätt att arva som återspeglar den överordnade webbplatsens synvinkel. Oberon utvecklades som en del av implementeringen av ett operativsystem , även kallat Oberon vid ETH Zürich i Schweiz . Namnet kommer från månen på planeten Uranus , som heter Oberon .

Oberon underhålls fortfarande av Wirth och den senaste kompilatoruppdateringen för Project Oberon är daterad 6 mars 2020.

Design

Oberon är designad med ett motto som tillskrivs Albert Einstein i åtanke: "Gör saker så enkelt som möjligt, men inte enklare." Den huvudsakliga riktlinjen var att koncentrera sig på funktioner som är grundläggande och väsentliga och att utelämna tillfälliga problem. En annan faktor var erkännandet av den ökande komplexiteten i språk som C++ och Ada . I motsats till dessa framhåller Oberon användningen av bibliotekskonceptet för att utöka språket. Uppräknings- och delområdestyper, som fanns i Modula-2, uteslöts, och mängdtyper är begränsade till uppsättningar av heltal. Alla importerade artiklar måste kvalificeras med namnet på modulen där de deklareras. Lågnivåanläggningar markeras genom att endast tillåta dem att användas i en modul som inkluderar identifieraren SYSTEM i sin importlista. Strikt typkontroll , även över moduler, och indexkontroll vid körning , kontroll av nollpekare och konceptet för säker typ av tillägg tillåter till stor del att programmering enbart förlitar sig på språkreglerna.

Syftet med denna strategi var att skapa ett språk som är lättare att lära sig, enklare att implementera och mycket effektivt. Oberon-kompilatorer har setts som kompakta och snabba, samtidigt som de ger kodkvalitet jämförbar med kommersiella kompilatorer.

Egenskaper

Funktioner som kännetecknar Oberon-språket inkluderar:

  • Skiftlägeskänslig syntax med nyckelord med versaler
  • Typförlängning med typprovning
  • Moduler och separat kompilering
  • Strängoperationer
  • Isolera osäker kod
  • Stöd för systemprogrammering

Objektorientering

Oberon stöder utvidgning av posttyper för konstruktion av abstraktioner och heterogena strukturer. I motsats till de senare dialekterna, Oberon-2 och Active Oberon, saknar den ursprungliga Oberon en sändningsmekanism som språkfunktion men har den som en programmeringsteknik eller designmönster. Detta ger stor flexibilitet i OOP. I operativsystemet Oberon används två programmeringstekniker tillsammans för sändningsanropet: Metodsvit och meddelandehanterare.

Metodsvit

definieras en tabell med procedurvariabler och en global variabel av denna typ deklareras i den utökade modulen och tilldelas tillbaka i den generiska modulen: 




 MODUL  Figurer;  (* Abstrakt modul *)  TYP  Figur* =  POINTER TO  FigureDesc; Interface* =   POINTER TO  InterfaceDesc; InterfaceDesc* =   RECORD  draw* :  PROCEDURE  (f : Figur); clear* :   PROCEDUR  (f : Figur); mark* :   PROCEDUR  (f : Figur); flytta* :   PROCEDUR  (f : Figur; dx, dy :  INTEGER  );  SLUT  ; FigureDesc* =   RECORD  if : Interface;  SLUT  ;  PROCEDUR  Init* (f : Figur; if : Interface);  BEGIN  f.if := if  END  Init;  PROCEDUR  Rita* (f : Figur);  BEGIN  f.if.draw(f)  END  Draw;  (* Andra procedurer här *)  SLUT  Figurer.

Vi utökar den generiska typen Figur till en specifik form:

   
   


 
    MODUL  Rektanglar;  IMPORTERA  siffror;  TYP  Rektangel* =  PEKAR TILL  RectangleDesc; RectangleDesc* =   RECORD  (Figures.FigureDesc) x, y, w, h :  INTEGER  ;  SLUT  ;  VAR  om : Figurer.Gränssnitt;  PROCEDUR  Ny* (  VAR  r : rektangel);  BÖRJA  NYTT  (r); Figures.Init(r, if)   END  New;  PROCEDUR  Rita* (f : Figur);  VAR  r : Rektangel;  BEGIN  r := f(Rektangel);  (* f AS rektangel *)  (* ... *)  END  Draw;  (* Andra procedurer här *)  BEGIN  (* Modulinitiering *)  NEW  (om); if.draw := Draw;  if.clear := Rensa;  if.mark := Mark;  if.move := Flytta   END  rektanglar.

Dynamisk sändning görs endast via procedurer i modulen Figurer som är den generiska modulen.

Meddelandehanterare

Denna teknik består av att ersätta uppsättningen metoder med en enda procedur, som skiljer mellan de olika metoderna:


 
       MODUL  Figurer;  (* Abstrakt modul *)  TYP  Figur* =  POINTER TO  FigureDesc; Meddelande* =   RECORD END  ; DrawMsg* =   RECORD  (Meddelande)  END  ; ClearMsg* =   RECORD  (Meddelande)  END  ; MarkMsg* =   RECORD  (Meddelande)  END  ; MoveMsg* =   RECORD  (Meddelande) dx*, dy* :  INTEGER  END  ; Hanterare* =   PROCEDUR  (f : Bild;  VAR  meddelande : Meddelande); FigureDesc* =   RECORD  (* Abstrakt *)  handtag: Handler;  SLUT  ;  PROCEDUR  Handtag* (f : Bild;  VAR  medd.: Meddelande);  BEGIN  f.handle(f, msg)  END  Handle;  PROCEDUR  Init* (f : Figur; handtag : Hanterare);  BEGIN  f.handle := handle  END  Init;  SLUT  siffror.

Vi utökar den generiska typen Figur till en specifik form:

  


  
   

    MODUL  Rektanglar;  IMPORTERA  siffror;  TYP  Rektangel* =  PEKAR TILL  RectangleDesc; RectangleDesc* =   RECORD  (Figures.FigureDesc) x, y, w, h : INTEGER;  SLUT  ;  PROCEDUR  Rita* (r : rektangel);  BEGIN  (* ... *)  END  Draw;  (* Andra procedurer här *)  PROCEDUR  Handle* (f: Figur;  VAR  medd.: Figures.Message);  VAR  r : Rektangel;  BEGIN  r := f(Rektangel);  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). )  ANNAT  (* ignorera *)  END  END  Handle;  PROCEDUR  Ny* (  VAR  r : rektangel);  BÖRJA  NYTT  (r); Figures.Init(r, Handle)   END  New;  SLUT  Rektanglar.

I operativsystemet Oberon används båda dessa tekniker för dynamisk sändning. Den första används för en känd uppsättning metoder; den andra används för alla nya metoder som deklareras i tilläggsmodulen. Till exempel, om tilläggsmodulen Rectangles skulle implementera en ny Rotate()-procedur, kan den inom Figures-modulen endast anropas via en meddelandehanterare.

Implementeringar och varianter

Oberon

Kostnadsfria implementeringar av Oberon (språket) och Oberon (operativsystemet) kan hittas på Internet (flera är från ETHZ själv).

Oberon-2

Huvudartikel: Oberon-2

Några ändringar gjordes i den första släppta specifikationen. Till exempel, objektorienterad programmering (OOP)-funktioner lades till, FOR -slingan återinfördes. Resultatet blev Oberon-2 . En utgåva, som heter Native Oberon , som inkluderar ett operativsystem och kan starta direkt på IBM PC-kompatibel hårdvara. En .NET- implementering av Oberon med tillägg av några mindre .NET-relaterade tillägg utvecklades också på ETHZ. 1993 tog ett avknoppningsföretag från ETHZ en dialekt av Oberon-2 till marknaden med namnet Oberon-L . 1997 döptes den om till Component Pascal .

Oberon-2-kompilatorer utvecklade av ETH inkluderar versioner för Microsoft Windows , Linux , Solaris och klassiska Mac OS . Implementeringar från andra källor finns för vissa andra operativsystem, inklusive Atari TOS och AmigaOS .

Det finns en Oberon-2 Lex- skanner och Yacc -parser av Stephen J Bevan från Manchester University, Storbritannien, baserad på den i Mössenböck och Wirth-referensen. Det finns i version 1.4.

Andra kompilatorer inkluderar Oxford Oberon-2, som också förstår Oberon-07, och Vishap Oberon. Den sistnämnda är baserad på Josef Templs Oberon to C -språk käll-till-källa-kompilator (transpilerare) vid namn Ofront, som i sin tur är baserad på OP2-kompilatorn utvecklad av Regis Crelier på ETHZ.

Oberon-07

Oberon-07, definierad av Niklaus Wirth 2007 och reviderad 2008, 2011, 2013, 2014, 2015 och 2016 är baserad på den ursprungliga versionen av Oberon snarare än Oberon-2. De viktigaste ändringarna är: explicita numeriska konverteringsfunktioner (t.ex. FLOOR och FLT ) måste användas, WITH , LOOP och EXIT -satserna uteslöts, WHILE -satser utökades, CASE -satser kan användas för typexpansionstester, RETURN -satser kan endast användas kopplade till slutet av en funktion, importerade variabler och strukturerade värdeparametrar är skrivskyddade och arrayer kan tilldelas utan att använda COPY .

Oberon-07-kompilatorer har utvecklats för användning med många olika datorsystem. Wirths kompilator riktar in sig på en Reduced Instruction Set Computer ) av sin egen design som användes för att implementera 2013 års version av Project Oberon -operativsystemet på ett Xilinx -fältprogrammerbar gate array (FPGA) Spartan-3-kort. Portar för RISC-processorn till FPGA Spartan-6, Spartan-7, Artix-7 och en RISC-emulator för Windows (kompilerbar på Linux och macOS , och binärfiler tillgängliga för Windows) finns också. OBNC kompileras via C och kan användas på alla POSIX -kompatibla operativsystem (Portable Operating System Interface). Den kommersiella av Astrobe är inriktad på 32-bitars ARM Cortex-M3, M4 och M7 mikrokontroller. Patchouli- kompilatorn producerar 64-bitars Windows-binärfiler. Oberon-07M producerar 32-bitars Windows-binärfiler och implementerar version 2008 av språket. Akron's producerar binärer för både Windows och Linux. OberonJS översätter Oberon till JavaScript . Det finns online-IDE för Oberon . oberonc är en implementering för den virtuella Java-maskinen .

Aktiv Oberon

Active Oberon är ännu en variant av Oberon, som lägger till objekt (med objektcentrerat åtkomstskydd och lokal aktivitetskontroll), systembevakade påståenden, förebyggande prioritetsschemaläggning och en ändrad syntax för metoder (namngivna typbundna procedurer i Oberons vokabulär ) . Objekt kan vara aktiva, vilket betyder att de kan vara trådar eller processer. Dessutom har Active Oberon ett sätt att implementera operatörer (inklusive överbelastning), en avancerad syntax för att använda arrayer (se OberonX språktillägg och Proceedings of the 7th Joint Modular Languages ​​Conference 2006 Oxford, Storbritannien), och känner till namnrymder . Operativsystemet A2 (tidigare Active Object System (AOS), sedan Bluebottle ), speciellt kärnan , synkroniserar och koordinerar olika aktiva objekt.

ETHZ har släppt Active Oberon som stöder aktiva objekt, och operativsystemen baserade på detta (Active Object System (AOS), Bluebottle, A2) och miljö (JDK, HTTP, FTP, etc.) för språket. Som med många tidigare konstruktioner från ETHZ finns versioner av båda tillgängliga för nedladdning på Internet. Från och med 2003 inkluderar de centrala bearbetningsenheterna (CPU) som stöds single och dual core x86 och StrongARM .

Besläktade språk

Utvecklingen av språken i denna familj fortsatte. En ytterligare förlängning av Oberon-2 hette ursprungligen Oberon/L men döptes senare om till Component Pascal (CP). CP utvecklades för Windows och klassiskt Mac OS av Oberon microsystems, ett kommersiellt spin-off-företag från ETHZ, och för .NET av Queensland University of Technology . Språken Lagoona och Obliq för vidare Oberonmetoder till specialiserade områden.

Senare .NET-utvecklingsinsatser på ETHZ fokuserade på ett nytt språk som heter Zonnon . Detta inkluderar funktionerna i Oberon och återställer några från Pascal (uppräknade typer, inbyggd IO) men har några syntaktiska skillnader. Andra funktioner inkluderar stöd för aktiva objekt, operatörsöverbelastning och undantagshantering.

Oberon-V (ursprungligen namngiven Seneca, efter Seneca den yngre ) är en ättling till Oberon designad för numeriska tillämpningar på superdatorer , särskilt vektor- eller pipelinearkitekturer . Den innehåller array-konstruktörer och en ALL- sats.

Se även

Resurser

Allmän

Utvecklingen av Oberon

Hämtad från " https://en.wikipedia.org/w/index.php?title=Oberon_(programming_language)&oldid=1100504779 "