Oberon-2 - Oberon-2

Oberon-2
OberonLogo.svg
Paradigmarozkazovací způsob, strukturovaný, modulární, objektově orientovaný
NavrhlNiklaus Wirth, Hanspeter Mössenböck
Poprvé se objevil1991
Psací disciplínasilný, statický
Ovlivněno
Oberon, Modula-2, Pascal
Ovlivněno
Součást Pascal, Jít

Oberon-2 je rozšíření originálu Oberon programovací jazyk to přidává omezené odraz a objektově orientované programování zařízení, otevřít pole jako základní typy ukazatelů, export pole jen pro čtení a znovu zavést smyčku FOR Modula-2.

Byl vyvinut v roce 1991 v ETH Curych podle Niklaus Wirth a Hanspeter Mössenböck, který je nyní na Institut für Systemsoftware (SSW) Univerzita v Linci, Rakousko. Oberon-2 je nadmnožinou společnosti Oberon a je s ní plně kompatibilní. Oberon-2 byl redesign Objekt Oberon.

Oberon-2 zdědil omezený odraz a jednoduchou dědičnost („rozšíření typu“) bez rozhraní nebo mixiny od Oberona, ale přidal efektivní virtuální metody („typ vázané procedury“). Volání metod byla vyřešena za běhu pomocí C ++ -styl tabulky virtuálních metod.

Ve srovnání s plně objektově orientovanými programovacími jazyky Pokec, v základních typech Oberon-2 nejsou objekty, třídy nejsou objekty, mnoho operací není metodami, není předávání zpráv (do jisté míry to lze emulovat odrazem a rozšířením zprávy, jak ukazuje ETH Oberon) a polymorfismus je omezen na podtřídy společné třídy (ne kachní psaní jako v Krajta,[1] a není možné definovat rozhraní jako v Jáva ). Oberon-2 nepodporuje zapouzdření na úrovni objektu / třídy, ale pro tento účel lze použít moduly.

Reflexe v Oberon-2 nepoužívá metaobjekty, ale jednoduše čte z deskriptorů typů kompilovaných do spustitelných binárních souborů a vystavených v modulech, které definují typy a / nebo postupy. Pokud je formát těchto struktur vystaven na jazykové úrovni (jako je tomu například v případě ETH Oberon), lze reflexi implementovat na úrovni knihovny. Lze jej tedy implementovat téměř výhradně na úrovni knihovny, aniž by se měnil jazykový kód. ETH Oberon skutečně značně využívá schopnosti reflexe na jazykové a knihovní úrovni.

Oberon-2 poskytuje integrovanou podporu běhu pro sběr odpadu podobnou Javě a provádí kontroly mezí a indexů polí atd., Které eliminují potenciální problémy s přepsáním mezí zásobníku a pole a problémy se správou manuální paměti spojené s C / C ++. Samostatná kompilace pomocí souborů symbolů a jmenných prostorů prostřednictvím architektury modulů zajišťuje rychlé opětovné sestavení, protože je nutné překompilovat pouze moduly se změněnými rozhraními.

Jazyk Součást Pascal[2] je zdokonalení (nadmnožina) Oberon-2.

Příklad kódu Oberon-2

Následující kód Oberon-2 by implementoval a velmi minimální třída seznamu:

MODUL Seznamy;    (*** deklarovat globální konstanty, typy a proměnné ***)    TYP        Seznam*    = UKAZATEL NA ListNode;        ListNode = ZÁZNAM            hodnota : Celé číslo;            další  : Seznam;        KONEC;    (*** deklarovat postupy ***)    POSTUP (l : Seznam) Přidat* (proti : Celé číslo);    ZAČÍT        LI l = NULA PAK            NOVÝ(l);             (* vytvořit instanci záznamu *)            l.hodnota := proti        JINÝ            l.další.Přidat(proti)      (* rekurzivní volání do .add (n) *)        KONEC    KONEC Přidat;    POSTUP (l : Seznam) Dostat* () : Celé číslo;    VAR        proti : Celé číslo;    ZAČÍT        LI l = NULA PAK            VRÁTIT SE 0           (* .get () musí vždy vrátit INTEGER *)        JINÝ            proti := l.hodnota;       (* tento řádek se zhroutí, pokud l je NIL *)            l := l.další;            VRÁTIT SE proti        KONEC    KONEC Dostat;KONEC Seznamy.

Rozšíření Oberon-2 na Oberon[3]

Postupy vázané na typ

Postupy mohou být vázány na typ záznamu (nebo ukazatele). Jsou ekvivalentní instančním metodám v objektově orientované terminologii.

Export pouze pro čtení

Použití exportovaných proměnných a polí záznamu lze omezit na přístup jen pro čtení. Toto je zobrazeno s příznakem viditelnosti „-“.

Otevřená pole

Otevřená pole, která dříve mohla být deklarována pouze jako formální typy parametrů, mohou být nyní deklarována jako základní typy ukazatelů.

Prohlášení FOR

Příkaz FOR Pascal a Modula-2 nebyl v Oberonu implementován. Je znovu zaveden v Oberon-2.

Kontrola typu za běhu

Oberon-2 poskytuje několik mechanismů pro kontrolu dynamický typ objektu. Například tam, kde může být objekt Bird vytvořen na kachnu nebo kukačku, umožňuje Oberon-2 programátorovi reagovat na skutečný typ objektu za běhu.

Prvním, nejkonvenčnějším přístupem je spoléhat se na systém vázání typu. Druhým přístupem je použití S prohlášení, což umožňuje dynamiku podtyp proměnné, která se má zkontrolovat přímo. V obou případech, jakmile bude identifikován podtyp, může programátor využít jakékoli procedury nebo proměnné vázané na typ, které jsou vhodné pro podtyp. Příklady těchto přístupů jsou uvedeny níže.

Všimněte si, že forma S příkaz použitý v Oberon-2 nesouvisí s příkazy Pascal a Modula-2 WITH. Tato metoda zkrácení přístupu k záznamovým polím není implementována v Oberon nebo Oberon-2.

Typ vazby

 MODUL Ptactvo;     TYP         Pták* = ZÁZNAM             zvuk* : POLE 10 Z Char;         KONEC; KONEC Ptactvo.  MODUL Kachny;     IMPORT Ptactvo;      TYP         Kachna* = ZÁZNAM (Ptactvo.Pták) KONEC;      POSTUP Nastavit zvuk* (VAR pták : Kachna);     ZAČÍT         pták.zvuk := "Šarlatán!"      KONEC Nastavit zvuk; KONEC Kachny.  MODUL Kukačky;     IMPORT Ptactvo;      TYP         Kukačka* = ZÁZNAM (Ptactvo.Pták) KONEC;      POSTUP Nastavit zvuk* (VAR pták : Kukačka);     ZAČÍT         pták.zvuk := "Kukačka!"     KONEC Nastavit zvuk; KONEC Kukačky.

S prohlášení

 MODUL Test;     IMPORT Ven, Ptactvo, Kukačky, Kachny;      TYP         SomeBird* = ZÁZNAM (Ptactvo.Pták) KONEC;      VAR         sb : SomeBird;         C  : Kukačky.Kukačka;         d  : Kachny.Kachna;      POSTUP Nastavit zvuk* (VAR pták : Ptactvo.Pták);     ZAČÍT         S pták : Kukačky.Kukačka DĚLAT              pták.zvuk := "Kukačka!"            | pták : Kachny.Kachna DĚLAT              pták.zvuk := "Šarlatán!"         JINÝ              pták.zvuk := "Tweet!"         KONEC     KONEC Nastavit zvuk;      POSTUP MakeSound* (VAR b : Ptactvo.Pták);     ZAČÍT         Ven.Ln;         Ven.Tětiva(b.zvuk);         Ven.Ln     KONEC MakeSound;  ZAČÍT     Nastavit zvuk(C);     Nastavit zvuk(d);     Nastavit zvuk(sb);      MakeSound(C);     MakeSound(d);     MakeSound(sb) KONEC Test.

UKAZATEL

 MODUL PointerBirds;     IMPORT Ven;      TYP         BirdRec*   = ZÁZNAM             zvuk* : POLE 10 Z Char;         KONEC;         DuckRec*   = ZÁZNAM (BirdRec) KONEC;         Kukačka* = ZÁZNAM (BirdRec) KONEC;          Pták   = UKAZATEL NA BirdRec;         Kukačka = UKAZATEL NA Kukačka;         Kachna   = UKAZATEL NA DuckRec;     VAR        str : Pták;        ks : Kukačka;        pd : Kachna;      POSTUP SetDuckSound* (pták : Kachna);     ZAČÍT         pták.zvuk := "Šarlatán!"     KONEC SetDuckSound;      POSTUP Nastavit zvuk kukačky* (pták : Kukačka);     ZAČÍT         pták.zvuk := "Kukačka!"     KONEC Nastavit zvuk kukačky;      POSTUP Nastavit zvuk* (pták : Pták);     ZAČÍT         S pták : Kukačka DĚLAT              Nastavit zvuk kukačky(pták)            | pták : Kachna DĚLAT              SetDuckSound(pták)         JINÝ              pták.zvuk := "Tweet!"         KONEC     KONEC Nastavit zvuk;  ZAČÍT     NOVÝ(ks);     NOVÝ(pd);      Nastavit zvuk kukačky(ks);     SetDuckSound(pd);      Ven.Ln; Ven.Tětiva(ks^.zvuk); Ven.Ln;     Ven.Ln; Ven.Tětiva(pd^.zvuk); Ven.Ln;      Nastavit zvuk(ks);     Nastavit zvuk(pd);      Ven.Ln; Ven.Tětiva(ks^.zvuk); Ven.Ln;     Ven.Ln; Ven.Tětiva(pd^.zvuk); Ven.Ln;  (* -------------------------------------- *) (* Předat dynamický typ postupu *)      str := pd;      SetDuckSound(str(Kachna));     Ven.Ln; Ven.Tětiva(str^.zvuk); Ven.Ln;      str := ks;      Nastavit zvuk kukačky(str(Kukačka));     Ven.Ln; Ven.Tětiva(str^.zvuk); Ven.Ln;  (* -------------------------------------- *)      Nastavit zvuk(str);     Ven.Ln; Ven.Tětiva(str^.zvuk); Ven.Ln;      str := pd;      Nastavit zvuk(str);     Ven.Ln; Ven.Tětiva(str^.zvuk); Ven.Ln;  (* -------------------------------------- *)      NOVÝ(str);      Nastavit zvuk(str);     Ven.Ln; Ven.Tětiva(str^.zvuk); Ven.Ln KONEC PointerBirds.

JE operátor

Třetí přístup je možný pomocí JE operátor. Toto je relační operátor se stejnou prioritou jako equals (=), větší (>) atd., ale který testuje dynamický typ. Na rozdíl od dvou dalších přístupů však neumožňuje programátorovi přístup k podtypu, který byl detekován.

Syntax

Rozvoj ALGOL - Pascal - Modula-2 - Oberon - Součást Pascal jazyková rodina je označena a snížení ve složitosti jazykové syntaxe. Je popsán celý jazyk Oberon-2 (Mössenböck & Wirth, březen 1995) používající pouze 33 gramatických produkcí v rozšířená forma Backus – Naur, Jak je ukázáno níže.

Modul = MODULE ident ";" [ImportList] DeclSeq [ZAČÍNAT StatementSeq] KONEC ident ".".ImportList = IMPORT [ident ":="] ident {"," [ident ":="] ident} ";".DeclSeq = { CONST {ConstDecl ";" } | TYP {Typ Dekl ";"} | VAR {VarDecl ";"}} {ProcDecl ";" | Vpřed ";"}.ConstDecl = IdentDef "=" ConstExpr.Typ Dekl = IdentDef "=" Typ.VarDecl = IdentList ":" Typ.ProcDecl = POSTUP [Přijímač] IdentDef [FormalPars] ";" DeclSeq [ZAČÍNAT StatementSeq] KONEC ident.Vpřed = POSTUP "^" [Přijímač] IdentDef [FormalPars].FormalPars = "(" [FPSekce {";" FPSekce}] ")" [":" Kvalitní].FPSekce = [VAR] ident {"," ident} ":" Typ.Přijímač = "(" [VAR] ident ":" ident ")".Typ = Kvalitní              | POLE [ConstExpr {"," ConstExpr}] Typ OF              | ZÁZNAM ["("Kvalitní")"] FieldList {";" FieldList} KONEC              | POINTER NA typ              | POSTUP [FormalPars].FieldList = [IdentList ":" Typ].StatementSeq = Prohlášení {";" Prohlášení}.Prohlášení = [ Označovatel ":=" Expr              | Označovatel ["(" [ExprList] ")"]              | IF Expr THEN StatementSeq {ELSIF Expr THEN StatementSeq} [ELSE StatementSeq] KONEC              | PŘÍPAD Výklad případu {"|" Případ} [ELSE StatementSeq] KONEC              | WHILE Expr DO StatementSeq END              | REPEAT StatementSeq UNTIL Expr              | PRO ident ":=" Expr TO Expr [Autor: ConstExpr] DO StatementSeq END              | LOOP StatementSeq END              | Prohlášení WITH Guard DO {"|" Prohlášení Guard DO Seq} [ELSE StatementSeq] KONEC              | VÝSTUP              | VRÁTIT SE [Expr]      ].	Případ = [Štítky Case {"," Štítky Case} ":" Prohlášení].Štítky Case = ConstExpr [".." ConstExpr].Hlídat = Kvalitní ":" Kvalitní.ConstExpr = Expr.Expr = SimpleExpr [Vztah SimpleExpr].SimpleExpr = ["+" | "-"] Období {Termín AddOp}.Období = Faktor {MulOp Factor}.Faktor = Označovatel ["(" [ExprList] ")"] | číslo | charakter | tětiva | NULA | Soubor | "(" Expr ")" | " ~ " Faktor.Soubor = "{" [Živel {"," Živel}] "}".Živel = Expr [".." Expr].Vztah = "=" | "#" | "<" | "<=" | ">" | ">=" | V | JE.AddOp = "+" | "-" | NEBO.MulOp = "*" | "/" | DIV | MOD | "&".Označovatel = Kvalitní {"." ident | "[" ExprList "]" | " ^ " | "(" Kvalitní ")"}.ExprList = Expr {"," Expr}.IdentList = IdentDef {"," IdentDef}.Kvalitní = [ident "."] ident.IdentDef = ident [" * " | " - "].

Implementace

Oberon-2 kompilátory udržované ETH zahrnují verze pro Windows, Linux, Solaris, Mac OS X.

The Oxford Oberon-2 kompilátor kompiluje do nativního strojového kódu a může používat JIT na Windows, Linux a Mac OS X. Je vytvořen / udržován Mike Spivey a používá Virtuální stroj Keiko.

K dispozici je Oberon-2 Lex skener a Yacc analyzátor Stephen J Bevan z Manchester University ve Velké Británii na základě odkazu v referencích Mössenböck a Wirth. Je ve verzi 1.4.

Existuje vydání s názvem Nativní Oberon který obsahuje operační systém a lze jej přímo spustit z hardwaru třídy PC.

A .SÍŤ na ETHZ byla také vyvinuta implementace Oberonu s přidáním některých menších rozšíření souvisejících s .NET.

Programátorský otevřený pracovní stůl (POW!)[4] je velmi jednoduché integrované vývojové prostředí, které je dodáváno s editorem, linkerem a kompilátorem Oberon-2. Toto se kompiluje do Okna spustitelné soubory. K dispozici je celý zdrojový kód - překladač je napsán v Oberon-2.

The Překladač Java to Oberon (JOB) byl napsán na univerzitě ve Vologdě v Rusku. Produkuje objektový kód ve formě souborů třídy Java (bytecode ). K dispozici jsou některé třídy specifické pro JOB, které jsou kompatibilní s Javou, ale které používají hierarchii komponent více Oberon.

The Optimalizace kompilátoru Oberon-2 kompiluje do C pomocí nástroje gcc pro generování programu.

Oberon Script je překladač, který překládá celý jazyk Oberon do JavaScript. Vlastní překladač je napsán v JavaScriptu a lze jej proto volat z webových stránek za účelem zpracování HTML skript oddíly napsané v Oberonu.

XDS Modula2 / Oberon2 je vývojový systém společnosti Excelsior LLC, Novosibirsk, Rusko. Obsahuje optimalizační kompilátor pro Intel Pentium nebo překladač „via-C“ pro vývoj napříč platformami. K dispozici pro Windows a Linux. Kompilátor je napsán na Oberon-2 a kompiluje se sám.

Oberon Revival je projekt přinést Oberon 2 a Součást Pascal (BlackBox Component Builder ) na Linux a Win32. Linuxový port blackboxu nebyl dříve k dispozici a původně fungoval pouze v systému Microsoft Windows.

XOberon je operační systém v reálném čase pro PowerPC, napsaný v Oberon-2.

Viz také

Reference

  1. ^ http://www.drdobbs.com/templates-and-duck-typing/184401971
  2. ^ „What's New in Component Pascal (changes from Oberon-2 to CP), Cuno Pfister (2001)“ (PDF). Archivovány od originál (PDF) dne 15. 5. 2011. Citováno 2007-01-10.
  3. ^ Rozdíly mezi Oberonem a Oberonem-2, Mössenböck a Wirth (1993)
  4. ^ H. Collingbourne - Co udělal vynálezce Pascala dál - PC Plus, Číslo 160, únor 2000

Vývoj Oberonu a Oberonu-2

Podrobné dokumenty

Knihy

externí odkazy