Oberon-2

cet article se rapporte au langage de la programmation Oberon-2 plus nouveau. Pour la langue originale plus ancienne d'Oberon, voir le Oberon-1 .

Le Oberon-2 est une prolongation du langage de programmation original d'Oberon qui ajoute les équipements de programmation orientés objectivement limités de réflexion et , des rangées ouvertes comme indicateur basent des types, exportation de champ inaltérable et réintroduisent POUR la boucle de Modula-2.

Il a été développé en 1991 au ETH Zurich par le Niklaus Wirth et le Hanspeter Mössenböck , qui est maintenant au für Systemsoftware d'Institut (SSW) de l'université de Linz, Autriche. Oberon-2 est un superjeu de Oberon , et est entièrement compatible avec lui. Oberon-2 était une conception d'objet Oberon .

Oberon-2 a hérité de la réflexion limitée et de la transmission simple (" ; dactylographier l'extension" ;) sans interfaces ou mixins d'Oberon, mais méthodes virtuelles efficaces supplémentaires (" ; dactylographier le procedures" attaché ;). Les appels de méthode étaient resolved à d'exécution using le C++ - dénommer les tables virtuelles de méthode.

Sont pas comparés aux langages de programmation entièrement orientée objectivement aimer la causerie , dans les types Oberon-2 de base ne des objets, les classes ne sont pas des objets, beaucoup d'opérations ne sont pas des méthodes, il n'y a aucun message de passant (dans une certaine mesure il peut être émulé par réflexion et par la prolongation de message, comme démontré dans le système d'Oberon 3), et le polymorphisme est limité aux sous-classes d'une classe commune (aucun canard de dactylographiant comme dans la causerie /rubis , et de lui n'est possible pour définir des interfaces comme dans le Java ). Oberon-2 ne soutient pas l'encapsulation au niveau d'objet/classe, mais des modules peuvent être utilisés à cette fin.

La réflexion dans Oberon-2 n'emploie pas des méta-objets, mais lit simplement du type descripteurs compilés dans les binaires exécutables, et exposés dans les modules qui définissent les types et/ou les procédures. Si le format de ces structures sont exposés au niveau de langue (de même que la caisse pour le système 3 d'Oberon, par exemple), la réflexion pourrait être mise en application au niveau de bibliothèque. Elle pourrait donc être mise en application presque entièrement au niveau de bibliothèque, sans changer le code de langue. En effet, le système 3 d'Oberon se sert des possibilités de langue-niveau et de réflexion de bibliothèque-niveau intensivement.

Histoire des langues d'Oberon

Le original Oberon a été conçu pour être une langue « sûre » ; il utilise des limites de de rangée vérifiant , collection d'ordures et type la vérification fort du . Ces dispositifs, en particulier ceux qui permettent à des erreurs de logique d'être détectées dès que possible (c. à au moment de la compilation), peuvent de manière significative réduire le nombre de bogues se produisant dans un programme au temps d'exécution. Cependant, une partie comporte inclus dans d'autres langues afin d'essayer de réduire les bogues (par exemple des énumérations et des gammes programmeur-définies sur des nombres entiers), a été omise. En conséquence, plus de soin devrait être pris par le programmeur, en travaillant avec des expressions numériques, pour éviter des erreurs de logique.

Oberon a été prévu pour rendre des erreurs plus dures en partie en rendant le code moins opaque, et en partie parce que des dispositifs non inclus ne peuvent pas être abusés. Cette approche peut être prise encore autre, comme dans le APL , qui est tous deux particulièrement laconiques et renommés pour être moins que facile à comprendre, mais Oberon a été délibérément construit pour ne pas trop simplifier.

Car c'est une intention dont le succès ne peut pas être facilement mesuré, là reste un certain désaccord qu'Oberon a atteint ses buts prévus à cet égard. Une objection à sa stratégie de simplification de conception de langue a été exprimée par le Jean Ichbiah , l'architecte d'ADA quand Wirth a critiqué l'ADA pour être trop grand ; il a répondu " ; Il y a des périodes où Wirth croit en petites solutions pour de grands problèmes. Je ne crois pas en cette sorte de miracle. Les grands problèmes ont besoin de grandes solutions ! " ; Les réalisateurs d'Oberon ont même estimé qu'Oberon est allé trop loin à cet égard - Oberon-2 a renvoyé « POUR » le rapport à cette version de la langue.

Il peut discuter que le manque d'inclure un dispositif peut forcer le programmeur au reimplement le dispositif en son code, menant à la « réinvention de roue » multiple et aux problèmes conséquents. Les bibliothèques peuvent atténuer ceci - plus ou moins - effectivement selon l'utilisation gracieuse de dispositif et d'une langue de telles bibliothèques. Le Java est un exemple d'une langue relativement simple (cependant loin moins ainsi qu'Oberon) incluse dans de grandes bibliothèques standard. (Oberon a une bibliothèque standard beaucoup plus petite que Java.) Autant de l'effort d'apprendre n'importe quelle langue apprend les bibliothèques standard, l'objection d'Ichbiah ci-dessus peut être prolongé à une stratégie de simplification en entrant des dispositifs de la langue de noyau dans les bibliothèques standard. Wirth, et Oberon évente, arguent du fait qu'Oberon a essentiellement, et effectivement, évité ce problème.

Code de l'exemple Oberon-2

Le code Oberon-2 suivant mettrait en application une classe simple de liste :

 MODULE ListClass ;  DACTYLOGRAPHIER List* = INDICATEUR à ListNode ;  ListNode = DISQUE   valeur : NOMBRE ENTIER ;   après : Liste ;  EXTRÉMITÉ ; 
 PROCÉDÉ (l : Liste) Add* (v : NOMBRE ENTIER) ; COMMENCER  (*… *) L'EXTRÉMITÉ s'ajoutent ; PROCÉDÉ (l : Liste) AddLast* (v : NOMBRE ENTIER) ; COMMENCER  (*… *) FINIR AddLast ; PROCÉDÉ (l : Liste) AddAt* (I : NOMBRE ENTIER ; v : NOMBRE ENTIER) ; COMMENCER  (*… *) FINIR AddAt ; PROCÉDÉ (l : Liste) Remove* ; COMMENCER  (*… *) L'EXTRÉMITÉ enlèvent ; PROCÉDÉ (l : Liste) RemoveLast* ; COMMENCER  (*… *) FINIR RemoveLast ; PROCÉDÉ (l : Liste) RemoveAt* (I : NOMBRE ENTIER) ; COMMENCER  (*… *) FINIR RemoveAt ; 
 EXTRÉMITÉ ListClass.

Dispositifs de l'Oberon original

Caractéristiques principales

Les dispositifs suivants caractérisent la langue d'Oberon :
de

Pascal - comme, mais syntaxe plus conformée
Type-prolongation avec la type-vérification forte
Modules avec les interfaces et la compilation séparée type-vérifiées
Compatibilité entre tous les types numériques (expressions mélangées)
Opérations limitées de corde du
Soutien de la programmation système

Drapeaux de visibilité

Les variables globales, les types, les constantes, et les procédures sont par défaut seulement évident dans le module de déclaration. Elles peuvent être rendues publiques à d'autres modules en les suffixant avec un drapeau , à savoir un astérisque (*) de visibilité de pour la permission lecture/écriture. Le défaut a été choisi pour assurer la sûreté au cas où un drapeau était par distraction omis.

Les variables locales, les types, les constantes, et les procédures sont toujours évidents seulement au procédé de déclaration.

Appel par la référence ou par valeur

Deux modes possibles sont disponibles pour des paramètres de procédé. l'Appeler-par-valeur (CBV) permet à des expressions d'être employées comme paramètres, de sorte que la valeur de l'expression soit passée vers le bas au procédé. l'Appeler-par-référence (CBR) permet à des variables d'être employées, de sorte que la valeur de la variable puisse être changée par le procédé. Un procédé peut déclarer un paramètre de CBR en le mettant en tête avec le mot-clé de VAR.

Prolongements Oberon-2 à Oberon

Type-bondir les procédures

Des procédures peuvent être liées à un type record (ou indicateur). Elles sont équivalentes aux méthodes d'exemple dans la terminologie orientée objectivement.

Exportation inaltérable

L'utilisation des variables et des champs exportés de disque peut être limitée à l'accès inaltérable. Ceci est montré avec un " ; - " ; drapeau de visibilité.

Ouvrir les rangées

Ouvrir les rangées qui précédemment pourraient seulement être déclarées pendant que des types de paramètre formel peuvent maintenant être déclarés en tant que types de base d'indicateur.

POUR le rapport

POUR le rapport de Pascal et de Modula-2 n'a pas été mis en application dans Oberon. Il est réintroduit dans Oberon-2.

Type vérification d'exécution

Oberon-2 fournit plusieurs mécanismes pour vérifier le type dynamique du d'un objet. Par exemple, où un objet d'oiseau pourrait être instancié à un canard ou à un coucou, Oberon-2 permet au programmeur de répondre au type réel de l'objet à d'exécution.

Le premier, le plus conventionnel, approche est de compter sur le type le système obligatoire . La deuxième approche est d'employer le rapport du WITH, qui permet au sous-type dynamique d'une variable d'être vérifié directement. Dans les deux cas, une fois que le sous-type a été identifié, le programmeur peut se servir du tout type-bondissent les procédures ou les variables qui sont appropriées au sous-type. Des exemples de ces approches sont montrés ci-dessous.

Noter que la forme de rapport de WITH utilisée dans Oberon-2 est indépendante du Pascal et du Modula-2 AVEC le rapport. Cette méthode d'abréger l'accès aux champs record n'est pas appliquée dans Oberon ou Oberon-2.

Type de liant

 Oiseaux de MODULE ;  DACTYLOGRAPHIER Bird* = DISQUE    sound* : RANGÉE 10 DE CHAR ;   EXTRÉMITÉ ; Oiseaux d'EXTRÉMITÉ. (*-------------------------------------*) Canards de MODULE ;  Oiseaux d'IMPORTATION ;  DACTYLOGRAPHIER Duck* = EXTRÉMITÉ du DISQUE (Birds.Bird) ;   makeSound* de PROCÉDÉ (oiseau de variété : Canard) ;  COMMENCER LA COPIE (" ; Charlatan ! " ; , bird.sound) ; makeSound d'EXTRÉMITÉ ; 
 Canards d'EXTRÉMITÉ. (*-------------------------------------*) Coucous de MODULE ;  Oiseaux d'IMPORTATION ; 
 DACTYLOGRAPHIER Cuckoo* = EXTRÉMITÉ du DISQUE (Birds.Bird) ;   makeSound* de PROCÉDÉ (oiseau de variété : Coucou) ;  COMMENCER LA COPIE (" ; Coucou ! " ; , bird.sound) ; makeSound d'EXTRÉMITÉ ; 
 Coucous d'EXTRÉMITÉ.

rapport du WITH

 Essai de MODULE ; IMPORTATION dehors, oiseaux, Cuckooo, canards ;  DACTYLOGRAPHIER SomeBird* = EXTRÉMITÉ du DISQUE (Birds.Bird) ; 
 Sb de variété : SomeBird ;  Variété c : Cuckoos.Cuckoo ;  Variété d : Ducks.Duck ;  setSound* de PROCÉDÉ (oiseau de variété : Birds.Bird) ;  COMMENCER  AVEC l'oiseau : Cuckoos.sound : = " ; Coucou ! " ; ;  | oiseau : Ducks.sound : = " ; Charlatan ! " ; ;  AUTREMENT    bird.sound : = " ; Bip ! " ; ;  EXTRÉMITÉ ;  setSound d'EXTRÉMITÉ ; 
 PROCÉDÉ MakeSound* (variété b : Birds.Bird) ;  COMMENCER  Out.Ln ;  FINIR MakeSound ; 
 COMMENCER 
 setSound (c) ;  setSound (d) ;  setSound (Sb) ;  MakeSound (c) ;  MakeSound (d) ;  MakeSound (Sb) ; 
 Essai d'EXTRÉMITÉ.

POINTER

 MODULE PointerBirds ; IMPORTATION dehors ;   DACTYLOGRAPHIER BirdRec* = sound* RECORD : RANGÉE 10 DE CHAR ; EXTRÉMITÉ ;  DuckRec* = EXTRÉMITÉ de DISQUE (BirdRec) ;  CuckooRec* = EXTRÉMITÉ de DISQUE (BirdRec) ; 
  DACTYLOGRAPHIER l'oiseau = l'INDICATEUR à BirdRec ;  Coucou = INDICATEUR à CuckooRec ;  Canard = INDICATEUR à DuckRec ; 
 Pb de variété : Oiseau ;  PC : Coucou ;  palladium : Canard ; 
 makeDuckSound* de PROCÉDÉ (oiseau : Canard) ;  COMMENCER LA COPIE (" ; Charlatan ! " ; , bird.sound) makeDuckSound d'EXTRÉMITÉ ;  makeCuckooSound* de PROCÉDÉ (oiseau : Coucou) ;  COMMENCER LA COPIE (" ; Coucou ! " ; , bird.sound) makeCuckooSound d'EXTRÉMITÉ ; 
 makeSound* de PROCÉDÉ (oiseau : Oiseau) ;  COMMENCER  AVEC l'oiseau : Le coucou FONT le makeCuckooSound (oiseau) ;  | oiseau : Le canard FONT le makeDuckSound (l'oiseau)   AUTREMENT   COPIER (" ; Bip ! " ; , bird.sound) ;  EXTRÉMITÉ ;  makeSound d'EXTRÉMITÉ ; 
 COMMENCER NOUVEAU (PC) ; NOUVEAU (palladium) ;  makeCuckooSound (PC) ; makeDuckSound (palladium) ;  Out.Ln ; 
  makeSound (PC) ; makeSound (palladium) ; 
  Out.Ln ; (* -------------------------------------- *) (* passer le type dynamique au procédé *) 
  Pb : = palladium ; 
  makeDuckSound (Pb (canard)) ; Out.Ln ; 
  Pb : = PC ; 
  makeCuckooSound (Pb (coucou)) ; Out.Ln ; (* -------------------------------------- *) 
  makeSound (Pb) ; Out.Ln ; 
  Pb : = palladium ;  makeSound (Pb) ; Out.Ln ; (* -------------------------------------- *) NOUVEAU (Pb) ;  makeSound (Pb) ; Out.Ln ;  EXTRÉMITÉ PointerBirds.

Une troisième approche est possible using l'opérateur du IS. C'est un opérateur de relation avec la même priorité que les égales (=), plus grand (>), etc. mais qui examine le type dynamique. À la différence des deux autres approches, cependant, il ne permet pas l'accès de programmeur au sous-type qui a été détecté.

Syntaxe

Le développement de l'algol - Pascal de - le Modula-2 - Oberon - famille de langue composante de Pascal de est marqué par une réduction la complexité de la syntaxe de langue. La langue Oberon-2 entière est décrite ( Mössenböck et Wirth, 1993 ) en utilisant seulement 33 productions grammaticales sous la forme prolongée par de Backus-Naur, comme montré ci-dessous.

 " de module = d'identification de MODULE ; ; " ; " d'identification d'EXTRÉMITÉ de DeclSeq StatementSeq ;. ImportList = " d'IMPORTATION ; : =" ; identification {" ; , " ; " ; : =" ; " d'identification} ; ; " ;. DeclSeq = {CONST {" de ConstDecl ; ; " ; } | DACTYLOGRAPHIER {" de TypeDecl ; ; " ;} | Variété {" de VarDecl ; ; " ;}} {" de ProcDecl ; ; " ; | " de ForwardDecl ; ; " ;}. " de ConstDecl = d'IdentDef ; =" ; ConstExpr. " de TypeDecl = d'IdentDef ; =" ; Type. " de VarDecl = d'IdentList ; : " ; Type. ProcDecl = " d'IdentDef de PROCÉDÉ ; ; " ; Identification d'EXTRÉMITÉ de DeclSeq StatementSeq. ForwardDecl = " de PROCÉDÉ ; ^" ; IdentDef. FormalPars = " ; (" ; {" ; ; " ; " de FPSection} ;)" ; Qualident. FPSection = identification {" ; , " ; " d'identification} ; : " ; Type. Récepteur = " ; (" ; " d'identification ; : " ; " d'identification ;)" ;. Type = Qualident   | RANGÉE {" ; , " ; ConstExpr} de type   | FieldList RECORD {" ; ; " ; EXTRÉMITÉ de FieldList}   | INDICATEUR à dactylographier   | PROCÉDÉ. FieldList = " ; : " ; Type. StatementSeq = rapport {" ; ; " ; Rapport}. " de rapport = d'indicateur ; : =" ; Expr   | Indicateur [" d'ExprList ;)" ;]   | SI EXTRÉMITÉ d'Expr PUIS StatementSeq {ELSIF Expr PUIS StatementSeq} StatementSeq   | CAISSE Expr de cas {" ; |" ; EXTRÉMITÉ de StatementSeq de cas}   | TANDIS QU'Expr FONT l'EXTRÉMITÉ de StatementSeq   | RÉPÉTER StatementSeq JUSQU'à Expr   | POUR le " d'identification ; : =" ; Expr à Expr ConstExpr FONT l'EXTRÉMITÉ de StatementSeq   | EXTRÉMITÉ de StatementSeq de BOUCLE   | AVEC le garde FAIRE StatementSeq {" ; |" ; Le garde FONT l'EXTRÉMITÉ de StatementSeq} StatementSeq   | SORTIE   | RETOUR  ].	 Cas = {" ; , " ; " de CaseLabels} ; : " ; StatementSeq. CaseLabels = ConstExpr ConstExpr. " de garde = de Qualident ; : " ; Qualident. Expr = SimpleExpr SimpleExpr. SimpleExpr = | " ; - " ; Limite {limite d'AddOp}. Limite = facteur {facteur de MulOp}. Facteur = indicateur [" d'ExprList ;)" ;] | nombre | caractère | corde | ZÉRO | Ensemble | " ; (" ; " d'Expr ;)" ; | " ; " de ~ ; Facteur. Ensemble = " ; {" ; {" ; , " ; " d'élément} ;}" ;. Élément = Expr Expr. Relation = " ; =" ; | " ; #" ; | " ; <" ; | " ; <=" ; | " ; >" ; | " ; >=" ; | DANS | EST. AddOp = " ; +" ; | " ; - " ; | OU. MulOp = " ; * " ; | " ; /" ; | Division | Mod | " ; &" ;. Indicateur = Qualident {" ;. " ; identification | " ; " d'ExprList ; " ; | " ; " de ^ ; | " ; (" ; " de Qualident ;)" ;}. ExprList = Expr {" ; , " ; Expr}. IdentList = IdentDef {" ; , " ; IdentDef}. " ; identification. IdentDef = identification * " ; | " ; - " ;.

Réalisations

Les compilateurs Oberon-2 maintenus par ETH incluent des versions pour Windows, Linux, le Solaris, OS X.

Il y a un analyseur de Yacc de module de balayage et de de Lex du Oberon-2 par Stephen J Bevan de l'université de Manchester, R-U, basé sur celui dans la référence de Mössenböck et de Wirth. Il est à la version 1.

Il y a un dégagement appelé le Oberon indigène de qui inclut un du système d'exploitation, et peut directement initialiser sur le matériel de classe de PC.

Une exécution du .NET d'Oberon avec l'addition de quelques prolongements mineurs de .NET-related a été également développée à ETHZ.

L'établi ouvert du programmeur (PRISONNIER DE GUERRE !) est un environnement de développement integrated très simple, qui est équipé de rédacteur, d'éditeur de liens et de compilateur Oberon-2. Ceci compile aux executables de Windows . Le plein code source est fourni - le compilateur est écrit dans Oberon-2.

Le Java au compilateur d'Oberon (le TRAVAIL) a été écrit à l'université de Vologda en Russie. Il produit le code d'objet sous forme de dossiers de classe de Java ( Bytecode ). On fournit quelques classes Travail-spécifiques qui sont Java compatible, mais qui employer un plus Oberon-comme la hiérarchie composante.

Le compilateur Oberon-2 de linéarisation compile à C, using le toolchain de GCC pour la génération de programme.

Le manuscrit d'Oberon est un compilateur qui traduit la pleine langue d'Oberon en Javascript . Le compilateur proprement dit est écrit dans le Javascript et peut donc s'appeler des pages Web afin de traiter des sections du manuscrit de HTML de écrites dans Oberon.

Random links: