B compiler Btree manager specification 1.7
From ClearSy Tools
Note : this translation of the original .pdf documentation don't include any pictures. If you want to see them, refers to .pdf documentation
AUTHOR RESUME : this document presente Specifications of beTree manager of B Compiler
Versions history
ClearSy : Initial versions, 03/07/2008
Chapter 1 : Introduction
Le compilateur B permet d'analyser un fichier source ASCII qui implémente un composant B. Il produit une structure de données qui représente ce composant. Cette structure de données est un arbre, appelé Betree 1. Cet arbre est décoré, car il contient toutes les informations de typage du composant, et résolu, car les accès aux données dans ce composant sont représentés non pas sous forme syntaxique, mais sous forme de référence vers leur définition. Pièce centrale du compilateur B, le Gestionnaire de Betree fournit les services suivants : - Modélisation des noeuds du Betree. - Ensemble de méthodes d'exploitation du contenu d'un Betree. - Ensemble de méthodes de modification ou d'enrichissement du contenu d'un Betree. - Ensemble de méthodes de sauvegarde, de restauration et de visualisation d'un Betree. C'est le gestionnaire de Betree qui offre l'interface de programmation du compilateur B. C'est donc l'interlocuteur privilégié des clients du compilateur B. Ce document spécifie la modélisation des noeuds du Betree, ainsi que les méthodes associées. Cette spécification est réalisée au moyen de techniques orientées objet et s'adresse prioritairement aux lecteurs familiers de ces technologies. Toutefois, un bref rappel de la terminologie employée et des principes de base des méthodes objets est donnée au Chapter 2, permettant l'accès de ce document à un lecteur familier des langages procéduraux classiques. Il s'adresse principalement aux personnes qui écrivent des outils basés sur le compilateur B. Toutefois, il donne su±samment d'informations pour servir de point d'entrée à une personne souhaitant modifier ou enrichir le compilateur B. Il présente successivement : - Les exigences qui s'appliquent au gestionnaire de Betree : partie I page 7. - Les classes de base utilisées dans la modélisation : partie II page 13. - La modélisation des composants, dans la partie III page 43. - Les gestionnaires utilisés pour offrir des services de haut niveau : partie IV page 67. - La modélisation des substitutions, des prédicats et des expressions, dans les parties res- pectives V, VI et VII aux pages 81, 97 et 107. - La modélisation des types, dans la partie VIII page 129. - La modélisation des projets gérés par l'Atelier B, dans la partie IX page 143. - Les classes auxiliaires du compilateur dans la partie XI page 185. - L'API du compilateur dans l'annexe A page 199.. - La méthode d'ajout d'une classe utilisateur dans l'annexe B page 205. Il est à noter que ce document ne spécifie que l'interface publique du gestionnaire de Betree, c'est à dire l'ensemble des méthodes utilisables par les clients du compilateur B. Il ne décrit pas les méthodes \internes" au compilateur B. Ces méthodes sont détaillées dans le document de conception du gestionnaire de Betree ([CPL7]).
Chapter 2 : Terminology & conventions used
Terminology
API \Application Program Interface". Interface de programmation1 offerte par une biblio- thèque. Classe Entité qui définit une structure de données et un ensemble de méthodes communes à une famille d'objets. Constructeur Méthode fournie par une classe permettant de créer dynamiquement une ins- tance de la classe. CVS \Concurrent Versions System". Outils puissants de gestion de configuration, basés sur RCSy. Destructeur Méthode fournie par une classe permettant de détruire une instance de la classe. Fonction membre Synonyme de Méthode. Gestionnaire Objet particulier qui a pour but de gèrer des informations au niveau global. Exemple : le gestionnaire d'objets gère les informations sur les objets créés au cours d'une compilation. GOP Outil de l'Atelier B: Générateur d'Obligations de Preuve Héritage Une classe A peut hériter d'une classe B. Dans ce cas, A hérite automatiquement de toute la structure de données de B, ainsi que de l'ensemble de ses fonctions. HTML Hypertext Markup Langage. Langage d'écriture de pages comportant des liens hyper- texte. Ces pages sont ensuites lues au moyen d'un navigateur comme par exemple Netscape. Instance Une instance d'une classe est un objet fabriqué à partir du modèle fourni par la classe. L'instance possède une copie qui lui est propre de la structure de données de la classe, et peut être manipulée au moyen de toutes les méthodes offertes par la classe. Lexème Suite de caractères formant une entité lexicale (\mot").
Magic number Code de contr^ole permettant de vérifier l'intégrité d'une entité (objet, fi- chier, . . . ). Pour cela, on teste l'égalité entre la valeur de référence du magic number et d'un nombre placé dans l'entité. Métaclasse Classe qui décrit une autre classe. Méthode Fonction offerte par une classe que l'on peut utiliser via une instance de la classe. Méthode virtuelle Méthode offerte par une classe, pouvant éventuellement être ra±née dans une ou plusieurs de ses sous-classes. Méthode purement virtuelle Méthode virtuelle offerte mais non implémentée par une classe de base. La méthode n'est pas implémentée car le niveau d'abstraction de la classe est trop élevé pour pouvoir l'implémenter. RCS \Revision Control System". Ensemble d'outils GNU permettant de gérer la configuration de fichiers SCCS \Source Code Control System". Ensemble d'outils permettant de gérer la configuration de fichiers Superclasse Si une classe B hérite d'une classe A, alors A est une superclasse de B. Par transi- tivité, les superclasses de A sont également des superclasses de B. Sous-classe Si une classe B hérite d'une classe A, alors B est une sous-classe de A. Par transitivité, les sous-classes de B sont également des sous-classes de A.
Conventions & syntax
- Les \objets informatiques" tels que les noms de fichiers, de fenêtre ou les choix d'op- tions dans les menus sont écrits au moyen d'une police non-proportionnelle, comme dans l'exemple ci-dessous : La machine MM.mch. Les échanges d'entrées/sorties entre l'utilisateur et le logiciel sont décrits au moyen de la même police. Pour différencier les entrées des sorties, les messages produits par le logiciel seront précédés du signe >, et les entrées du signe %, comme dans l'exemple ci-dessous : % ls > AA.mch AA_1.imp SCCS - Les mots dont la signification est expliquée dans le glossaire (Chapter 2.1, page 3) sont suivis d'une astérisque, comme dans l'exemple suivant : \L'utilisateur de l'IHMy"
First part : Requirement
Chapter 3 : Software product missions
Introduction
Le gestionnaire de Betree joue un r^ole central dans la nouvelle chaîne de l'Atelier B. Il fournit : - Des fonctionnalités de création d'arbre, utilisées au cours des passes de compilation pour créer le Betree qui représente un module. - Des fonctionnalités de sauvegarde et de restauration d'arbre, qui assurent la persistance d'un Betree. - Des fonctionnalités de parcours et d'exploitation d'arbre, utilisées par les applicatifs de l'Atelier B. - Des fonctionnalités d'enrichissement d'arbre, pouvant être utilisées par des applicatifs de l'Atelier B pour y placer des informations qui leur sont propres (obligations de preuve, . . . ).
Software position in the system
La figure 3.1 présente l'architecture générale du compilateur B.
Chapter 4 : General functions of the software
Les fonctions générales du gestionnaire de Betree sont les suivantes : - Modélisation de la structure de données du Betree. Cette modélisation est effectuée en utilisant des technologies orientées objet. Le gestionnaire offre donc un ensemble hiérar- chisé de classes permettant de modéliser un Betree. - Fourniture de fonctions de création et de destruction d'un arbre complet, ou d'un de ses noeuds. - Fourniture de fonctions permettant d'accéder aux informations stockées dans un Betree, ainsi que de les enrichir. - Fourniture de méthodes de sauvegarde disque, puis de restauration d'un Betree. - Fourniture d'un module de portabilité assurant la recompilation immédiate du compila- teur B sur tous les systèmes d'exploitation cibles.
Interfaces
Interfaces with hardware
Le gestionnaire de Betree contient un module de portabilité destiné à offrir des services \de haut niveau" permettant son portage sur de multiples plate-formes. On rappelle que le document [CPL1] impose la portabilité du code source sur des systèmes Sun-Os, Solaris, HP-UX, Linux et Windows-95 ou Windows NT. Ce module est composé d'un fichier d'interface C++ (le fichier c_port.h) ainsi que d'un fichier de code source C++ (le fichier c_port.cpp). Ce module fournit les services suivants : - Service d'insertion d'identifiants de gestion de version logicielle aux formats SCCSy et RCSy, permettant d'identifier les composants du logiciel à partir des commandes respec- tives what et ident. - Définition des macros suivantes : - TRUE et FALSE - function, qui n'est pas expansée et permet d'extraire automatiquement la liste de toutes les fonctions d'un projet si on a inséré cette macro dans les déclarations et les définitions de toutes les fonctions, comme dans l'exemple suivant : int function ma_fonction(void) ; void *function mon_autre_fonction(void) - } - ASSERT, qui permet de placer des assertions dans le code qui ne sont pas compilées si l'on utilise l'option NO_CHECKS - Implémentation des fonctions htonl, htons, ntohl et ntohs pour Windows95. - Implémentation de la fonction getopt pour Windows95.
Interfaces with others software products
Interface avec le système d'exploitation Le paragraphe 5.5.3 fournit une description de l'interfa»cage des fichiers binaires crées par le compilateur B avec la commande Unix file. Interface avec les clients du gestionnaire Le gestionnaire de Betree exporte le fichier c_api.h qui est le point d'entrée unique du compi- lateur B pour les clients. Les fonctions offertes par ce module sont décrites au Chapter A page 199. Les modules clients développés en utilisant les fonctionnalités du compilateur B doivent donc inclure ce fichier 1.
Interfaces with files or data-bases
Le Chapter 5.5 page 22 décrit le format des fichiers binaires de sauvegarde des Betree.
Requirement of conception and achievement
Le logiciel doit être réalisé en langage C++. Il doit être conforme à la norme ANSI-C++. Pour s'en assurer, on peut par exemple vérifier que la compilation du logiciel avec le compilateur GNU gcc et l' option -Wall, puis avec le compilateur Visual-C++ de Microsoft, ne produit aucun message d'avertissement.
Second part : base classes
Chapter 5 : Classe T object
Classe presentation
La figure 5.1 montre la hiérarchie générale des classes utilisées pour modéliser les noeuds du Betree. Toutes les classes héritent d'une superclassey de base, la classe T_object, qui modélise les propriétés communes à toutes les classes utilisées par le Betree. La figure 5.2 montre une vue générale des services offerts par la classe T_object. Les principaux services offerts sont les suivants : - Possibilité de savoir si un objet quelconque en mémoire est une instance de T_object par vérification de \magic number"y : fonction object_test. - Obtention du type précis d'un objet : lexème, machine, opération, identificateur, prédicat, etc : méthode get_node_type. Obtention du nom de la classe d'appartenance d'un objet. - Sauvegarde disque et restauration (i.e. persistance des objets) : méthodes dump_disk et load_disk. - Production d'une page HTMLy décrivant précisément un objet : méthode dump_HTML. - Gestion de champs et de fonctions \utilisateur", c'est à dire gérés par le client, lui permet- tant d'exploiter et d'enrichir un Betree. Par construction, ces méthodes sont héritées par toutes les sous-classes de T_object. Autrement dit, elle pourront être utilisées pour toute les instances des classes T_item, T_lexem, . . .
Structure of complementary datas
Le type énuméré T_node_type permet de modéliser les noms des différents types de noeuds de l'arbre. Les valeurs énumérées sont nommées systématiquement en utilisant la règle suivante : la valeur énumérée qui permet de discriminer les instances de la classe T_xx est appelée NODE_XX. Le tableau ci-après donne la correspondance entre les classes du Betree et les instance de T_node_type associées.
Function offered by the classe
La fonction object_test prend en entrée un pointeur de type quelconque et renvoie TRUE1 si le pointeur référence une instance de T_object2, et FALSE sinon.
Methods offered by the classe
Construction methods
/*
* * TROUUUUUUUUUUU * */
Format binary files backup
Description
Le compilateur de Betree permet de sauvegarder, puis de restaurer l'intégralité d'un Betree sous forme d'un fichier binaire stocké sur disque. Le format des fichiers binaires est illustré dans la figure 5.3.
Portability
Ces fichiers sont composés de données binaires au format \network", c'est à dire indépendant de la représentation des nombres sur le système h^ote. Ainsi, les fichiers pourront être partagés sur des machines Sun, HP, PC et Alpha. On utilisera les macros normalisées Unix BSD4.3 htonx et ntohx pour effectuer respectivement les opérations de sauvegarde et de restauration des données. Le module de portabilité, décrit au paragraphe 4.1.1, fournit une implémentation de ces macros pour les systèmes qui n'en disposent pas nativement.
File content
Le fichier binaire est composé de sept sections successives : 1. Une section qui comporte le \magic number"y du fichier. 2. Une section qui contient tous les objets du Betree. 3. Une section qui contient toutes les chaînes du Betree. 4. Une section qui contient la table des objets. 5. Une section qui contient la table des chaînes. 6. Une section qui contient l'offset de la table des objets. 7. Une section qui contient l'offset de la table des chaînes. Le \magic number"y permet de s'assurer du format du fichier binaire lors de sa lecture. Il est décrit au paragraphe 5.5.3. Magic number Le compilateur B place des informations de \magic number"y en tête des fichiers binaires qu'il génère 4. Ces informations peuvent être exploitées par la commande Unix file si on ajoute les informations des fichiers du Betree à sa base de données. Ainsi, dans la distribution GNU de file, on ajoute le fichier atelierb suivant dans le sous- répertoire Magdir :
- ------------------------------------------------------------------------------
- atelierb: file(1) magic for Atelier-B/B compiler
0 belong &0x19998800 Syntaxic Betree from bcomp version %c 0 belong &0x29998800 Semantic Betree from bcomp version %c Une recompilation de file permet alors de reconnaître les fichiers binaires du Betree, comme dans l'exemple ci-dessous : % bcomp -i AA.mch -s AA.bin % file AA.bin > AA.bin: Syntaxic Betree from bcomp version 1
Pour aboutir à ce résultat, le compilateur B place en tête des fichiers binaires qu'il produit un entier long de 32 bits qui a le format suivant 5 : x999 88yy , oµu respectivement : - yy est le numéro majeur de version, codé en ASCII (par exemple on met 31 pour '1') sur 2 octets. - x est un identifiant permettant de déterminer le type de Betree stocké dans le fichier. Actuellement, les types de Betree modélisés sont les suivants : - Betree syntaxique, pour lequel x = 1. - Betree sémantique, pour lequel x = 2. Objets et table des objets Les objets du Betree sont sauvegardés les uns après les autres dans la section qui contient les objets du Betree. Cette section est indexée par un compteur d'octets. Par convention, elle débute à l'index 0. Ainsi, si cette section contient une instance de la classe de T_betree puis une instance de la classe de T_machine, alors l'instance de T_betree est stockée à l'index 0, et celle de T_machine à l'index sizeof(T_betree). La table des objets permet d'indiquer à quelle index on trouve l'objet Les objets sont sauvegardées sous forme \brute", champ après champ. Au fur et à mesure de leur sauvegarde, on leur attribue un rang : 0 pour le premier objet, 1 pour le suivant, . . . Pour les champs de type \pointeur sur un objet", on ne stocke pas l'adresse contenue dans le pointeur, car cette information n'a aucun sens dans l'absolu, mais le rang de l'objet pointé. La table des objets permet d'obtenir la correspondance entre le rang d'un objet et l'index auquel il est sauvegardé. Cette table, constituée au fur et à mesure de la sauvegarde, permet de retrouver les objets au cours de la relecture du fichier. Chaînes et table des chaînes Tout comme les objets, les chaînes sont stockées séquentiellement dans le fichier disque. On leur attribue un rang, qui permet de les retrouver, et on les sépare par des caractères '\0'. La table des chaînes est terminée par n caractères '\0', oµu n est déterminé afin d'obtenir un alignement correct de la table des objets 6. Offsets Les deux offsets stockés à la fin du fichier permettent de retrouver les tables des objets et des chaînes, et donc de retrouver les informations du Betree.
Mode of operating a binary file
Les fichiers binaires du Betree sont destinés à être exploités comme suit : - Vérification du \magic number"y du fichier. Obtention de sa taille t. - Lecture des offsets tables des objets et des chaînes aux index respectifs t ¡ 2T et t ¡ T oµu T =sizeof(int). - Lecture des chaînes. - Lecture des objets. - Résolution des références sur les chaînes et sur les objets au moyen des tables de chaînes et d'objets.
Chapter 6 : The class T item
Presentation of the class
Principle
La classe T_item factorise toutes les propriétés communes aux noeuds du Betree. Dans la pra- tique, les instances de la classe T_object sont soit des noeuds du Betree, donc des instances de T_item, soit des lexèmes, donc des instances de la classe T_lexem1. La figure 5.1 de la page 13 montre la hiérarchie générale des classes utilisées pour modéliser les noeuds du Betree, et en particulier la hiérarchie des classes qui héritent de T_item. La figure 6.1 montre une vue générale des services offerts par la classe T_item. Les principaux services offerts par la classe T_item sont décrits dans les paragraphes 6.1.2 à 6.1.6
String
Les instances de T_item sont con»cues nativement comme des éléments de listes. Ainsi, elles possèdent toutes les propriétés nécessaires à leur insertion dans une liste chaînée, comme illustré dans la figure 6.2. On implémente ainsi une structure de liste dans laquelle on peut, à partir de chaque élément, se déplacer vers l'élément suivant (respectivement précédent) en parcourant le champ next (respec- tivement prev). En outre, chaque élément de la liste connaît son \père" (champ father), c'est à dire le noeud de l'arbre à qui appartient la liste. Par exemple, la classe T_machine, qui est une sous-classe de T_item possède une liste d'opéra- tions. Ces opérations sont chaînées entre elles, et ont pour père l'instance de T_machine décrite précédemment. Le paragraphe 6.2.1 donne un exemple de modélisation et d'utilisation de liste.
= Link management
La mémoire utilisée pour stocker les objets est allouée dynamiquement au fur et à mesure des besoins des programmes, et libérée par ces derniers quand ils ne l'utilisent plus.
On utilise alors une notion de responsabilité : l'entité qui demande la création d'un objet est responsable de sa libération. Si un objet est référencé (\partagé") par plusieurs autres objets, la situation se complique car l'entité qui a crée l'objet ne peut pas demander unilatéralement sa destruction. Par exemple, dans le cas illustré par les étapes 1 à 3 de la figure 6.3, l'entité A qui a créé un objet X ne peut pas unilatéralement demander sa libération lorsqu'elle ne l'utilise plus car un objet B référence également X. Une libération autoritaire de X par A laisserait une référence corrompue dans B. Par contre, dès que B n'utilise plus X (ce qui est par exemple le cas dès que B est libéré), alors X doit être libéré car il n'est plus utilisé. Pour réaliser cette fonctionnalité, les instances de T_item possèdent un compteur de liens qui est géré comme suit : - La création d'une instance de T_item met son compteur de liens à la valeur 1. On dit que le créateur de l'objet (A dans notre exemple) a posé un lien sur cette instance (X dans notre exemple). - Si un objet (B dans notre exemple) référence une instance de T_item qui a déjà été créée, il doit poser un lien sur cette instance au moyen de la fonction link. Cette fonction incrémente de 1 le compteur de liens de l'objet référencé. - Si un objet n'utilise plus une instance de T_item qu'il a créée ou sur laquelle il a posé un lien, il doit libérer ce lien au moyen de la fonction unlink. Cette fonction décrémente de 1 le compteur de liens de l'objet référencé. - Si le compteur de liens d'un objet devient nul, alors l'objet est libéré par le gestionnaire de mémoire.
Reviews management
Dans le Betree, comme indiqué dans le document [CPL5], les commentaires sont \accrochés" au noeud \non commentaire" qui les suit dans l'arbre. Ainsi, la classe T_item possède une liste qui permet de chaîner ces commentaires. Le chaînage est fait automatiquement par le constructeury de la classe.
Pragmas management
Comme indiqué au Chapter 38.5, les pragmas sont accrochés à la machine en cours d'analyse.
Others proprieties
Référence sur le Betree Les instances de la classe T_item possèdent une référence sur le Betree auxquelles elles appar- tiennent, ainsi qu'une référence sur le lexème qu'elles décrivent.
Offered methods by class
Construction methods with string at end of the list
La méthode crée une instance de T_item, chaînée en queue de la liste définie par adr_first et adr_last et dont le père est father. L'instance appartient au Betree betree et provient de l'analyse du lexème ref_lexem. Exemple d'utilisation On veut créer une liste my_list de T_item dans une instance de la classe T_my_class, sous-classe de T_item. On ajoute les deux champs suivants dans la définition de T_my_class : T_item *first_my_list ; T_item *last_my_list ; Dans le constructeury de T_my_class, on initialise ces deux champs à NULL. On ajoute ensuite les éléments un par un en appelant le constructeury de T_item comme suit : new T_item(&first_my_list, // adresse du premier element de la liste &last_my_list, // adresse du dernier element de la lister this, // pere : l'instance de T_my_class betree, // le Betree ref_lexem) ; // le lexeme analyse La liste pourra ensuite être parcourue comme suit :
T_item *cur_item = first_my_list ; while (cur_item != NULL) - // Traitement de l'element courant ... // Element suivant de la liste cur_item = cur_item->get_next() ; }
Construction methods with string after an element of the list
Prototype /* */ La méthode crée une instance de T_item, chaînée après l'élément after_this_item de liste définie par adr_first et adr_last et dont le père est father. L'instance appartient au Betree betree et provient de l'analyse du lexème ref_lexem. Dans le cas particulier oµu after_this_item vaut NULL, l'élément est crée en début de liste. L'utilisation de cette méthode est en tous points similaire à celle du constructeur qui chaîne en fin de liste présenté au paragraphe précédent.
/*
* * GROS TROUUUUUU * */
Third part : Components
Chapter 8 : Introduction
Cette partie présente les classes utilisées pour modéliser les composants B: - La classe T_betree, décrite au Chapter 9 page 45, modélise un Betree, c'est à dire le point d'entrée de la représentation d'un composant B. - Le Chapter 10 page 49 décrit les classes T_machine et T_used_machine, qui modélisent respectivement un composant B, et une utilisation (au sens SEES, INCLUDES, . . . ) d'un composant B. - Le Chapter 11 page 61 présente les classes T_op et T_used_op, qui modélisent respec- tivement les opérations développées et les opérations promues. La classe T_generic_op, Troisième partie : Les composants =
Chapter 9 : the BeTree
Introduction
La classe T_betree modélise le noeud racine d'un Betree. A partir de ce noeud, on peut accéder à toutes les informations contenues dans l'arbre. C'est donc le point d'entrée de tout outil souhaitant exploiter un Betree. Cette classe permet d'accéder au composant décrit dans le Betree, à ses définitions, à son nom et à son checksum, et à ses informations de gestion de configuration (au for- mat CVSy, RCSy ou SCCSy. Pour cela, on détecte la présence de %Z% ou de @(#) ou de $Id: compo.tex,v 1.4 2000/02/23 10:57:50 lv Exp $ dans les chaînes de caractères. La dernière occurrence de l'un de ces marqueurs est stocké dans le champ revision_ID du Betree).
/*
* * GROS TROUUUUUU * */
Fourth part : Managers
Chapter 12 : Introduction
Le compilateur B utilise un certain nombre de gestionnaires. Les gestionnaires sont des objets dont le statut est particulier : ce sont des instances uniques d'une classe, qui sont dédiées à une t^ache au niveau global. Ainsi, les gestionnaires suivants sont utilisés par le compilateur B: - Le gestionnaire d'objets, décrit au Chapter 13. Il a pour but de gèrer les objets alloués dynamiquement au cours d'une séance de compilation. - Le gestionnaire de Betrees. Décrit au Chapter 14, il centralise les informations contenues dans la forêt de Betree représentant le composant en cours d'analyse, ainsi que tous ses composants requis. - Le gestionnaire de métaclasses, qui offre une description exhaustive de toutes les classes utilisées dans la modélisation d'un Betree. Le Chapter 15 précise le concept de métaclasse, et décrit l'utilisation de ce gestionnaire.
Chapter 13 : Objects manager
Introduction
Le gestionnaire d'objets est utilisé par le compilateur B pour stocker des informations globales relatives à la gestion des objets au cours d'une de ses utilisations. Par objet, on entend ici uniquement instance de T_object. Les instances des autres classes ne sont pas gèrées par le gestionnaire d'objets (en particulier, il ne se gère pas \lui-même") Le gestionnaire d'objets est unique, il est créé lors de l'initialisation du compilateur B. Il est modélisé en tant qu'instance de la classe T_object_manager. Il est principalement utilisée de fa»con interne au compilateur pour optimiser des opérations de parcours d'arbre.
Obtaining manager objects
La fonction T_object_manager *get_object_manager(void) permet d'obtenir le gestionnaire d'objets du compilateur B.
Methods exported by the manager objects
List global identifiers
Chaque création d'une instance de T_ident provoque, outre l'allocation et l'initialisation de la structure de données associée, le chaînage de cette instance dans une liste globale des identifi- cateurs, possédée par le gestionnaire d'objets. Cette liste référence ainsi tous les identificateurs créés au cours de la session de compilation, qu'ils correspondent à la définition d'un identificateur ou à son utilisation, et qu'ils appartiennent au Betree au cours d'analyse ou non.
Les identificateurs sont chaînés dans cette liste au moyen de leurs champs next_ident et prev_ident. Ainsi, on utilisera les méthodes T_ident::get_next_ident et T_ident::get_prev_ident, dé- crites au paragraphe 21.12.2, pour se déplacer dans cette liste.
Production of HTML page
Pour favoriser le débogage et l'exploration des structures de données, le gestionnaire d'objet possède une méthode de production de page HTML, bien que la classe T_object_manager ne soit pas une sous-classe de T_object. Le prototype de cette méthode est le suivant :
FILE *function T_object_manager::dump_html(void)
Chapter 14 : Gestionnaire de Betree
Introduction
Au cours de la phase d'analyse sémantique décrite dans le document [CPL6], tous les Betree sémantiques des composants requis sont chargés en mémoire. Ils forment alors une forêt de Betrees, permettant l'accès à toutes leurs informations via le gestionnaire de Betree, qui est l'entité qui centralise toutes les racines de Betree. Dans l'exemple de la figure 14.1, l'analyse sémantique du composant CC_1.imp qui implémente le composant CC.mch et qui voit les composants AA.mch et BB.mch, provoque le chargement des Betrees de tous ces composants. Ces Betrees sont alors stockés dans une forêt, µa laquelle l'utilisateur peut accèder via le gestionnaire de Betree, comme le montre cette figure 14.1. Le paragraphe 14.2 décrit les méthodes offertes par la classe T_betree_manager, qui est utilisée pour modéliser le gestionnaire de Betree. Enfin, la classe T_betree_list est utilisée pour chainer les Betrees de la forêt dans des listes du type \est vu par", \est utilisé par", . . . . Le paragraphe 14.3 décrit ensuite les méthodes offertes par cette classe. On rappelle que, comme précisé au paragraphe 9.3, on obtient le gestionnaire de Betree au moyen de la méthode get_manager de la classe T_betree.
The class T betree manager
Access to betrees list
La classe T_betree_manager exporte la méthode suivante : /* */ La liste est ensuite parcourue au moyen des méthodes get_next_betree et get_prev_betree de la classe T_betree1.
Search of a BeTree
La fonction betree_manager_get_betree permet de chercher un Betree dans la forêt. Elle renvoie le Betree recherché s'il existe, ou NULL sinon. Le prototype de cette fonction est le suivant :
extern T_betree *function betree_manager_get_betree(T_symbol *betree_name)
La recherche se fait en précisant le nom du Betree, en utilisant la notation pointée en cas de renommage (exemple : i1.AA).
Class T betree list
La classe T_betree_list modélise une liste de Betrees. Cette liste est en fait une liste de T_list_link, qui sont autant d'indirections vers les Betree concernés. Elle est utilisée dans les méthodes get_used_by, get_seen_by, . . . de la classe T_betree. Elle exporte la méthode suivante : /* */
Chapter 15 : Metaclass manager
Introduction
Definition
Une métaclasse est une classe qui décrit une autre classe. Ainsi, si ° est une classe, alors la métaclasse ¡ de ° permet d'obtenir des informations sur ° telles que : - Nom de la classe ° : \gamma" - Liste des champs de ° : Ã1; Ã2 : : : Ãn - Pour chaque champ Ãi de gamma: - Nom du champ - Type du champ : objet, chaîne, entier, . . . - Si le champ est un objet, type de référence sur cet objet : réference privée, publique, . . . Ces concepts sont décrits au paragraphe 15.2.2. - Offset du champ dans la structure
Interest
Ces informations sont fondamentales pour l'écriture d'algorithmes génériques tels que les algo- rithmes de clonage d'objet, de sauvegarde/restauration disque, . . . . Elles permettent également d'écrire des outils d'exploration systématique d'arbre (débogueur HTML, décompilateur) qui s'adaptent dynamiquement en fonction des évolutions de l'arbre.
Metaclass manager
Le compilateur B possède un gestionnaire de métaclasse, qui permet d'obtenir la métaclasse de toute sous-classe de T_object. Son API est la suivante :
// Obtention de la metclasse pour un node_type donne extern T_metaclass *function get_metaclass(T_node_type node_type) ;
Ainsi, on obtient la métaclasse d'une instance quelconque de T_object par le code suivant : T_metaclass *meta = get_metaclass(object->get_node_type()) ;
Metaclass modelisation
Class T metaclass
La classe T_metaclass modélise une métaclasse du Betree. Elle exporte les méthodes suivantes : /* */
Class T field
La classe T_field modélise un champ d'une classe. Elle exporte les méthodes suivantes : /* */
Fifth part : Substitutions
Chapter 16 : Class T substitution
Class presentation
La figure 16.1 montre la hiérarchie générale des classes utilisées pour modéliser les noeuds de type \substitution" du Betree. Toutes ces classes héritent d'une superclassey de base, la classe T_substitution, qui modélise les propriétés communes des substitutions. La figure 16.2 montre une vue générale des services offerts par la classe T_substitution. Les substitutions qui appartiennent à un même bloc (le corps d'une opération, le corps de la clause INITIALISATION, . . . ) sont stockées dans une liste. Ainsi, les éléments du Betree qui référencent une substitution implémentent cette référence au moyen d'une liste de substitutions. Comme précisé au paragraphe 6.2.1, ces listes sont implémentées en utilisant deux champs qui représentent respectivement le premier et le dernier élément de la liste. Les instances de T_substitution possèdent un champ link_type, de type T_substitution_ link_type, qui permet de connaître la synchronisation entre deux substitutions consécutives d'une liste. Les valeurs énumérées offertes par ce type sont LINK_PARALLEL et LINK_SEQUENCE, modélisant respectivement un déroulement en parallèle ou en séquence.
Methods offered by class
= Read & upgrade methods of type of conduct
/* */
Search method of missing END
/* */ Si l'analyse syntaxique d'un composant échoue par manque d'un END fermant un bloc ou le composant, cette méthode virtuelle est appelée pour trouver quelle est la substitution de type \bloc" pour laquelle le END de fin a pu être oublié, déclenchant en cascade une désynchronisation de l'attribution des END par l'analyseur syntaxique et aboutissant à l'erreur précitée. La recherche se fait en utilisant l'heuristique suivante : on recherche si le END de fin de bloc est aligné sur le lexème de début de bloc (par exemple, dans un BEGIN .. END, on vérifie que le BEGIN et que le END sont alignés). La méthode émet un message d'avertissement si elle pense avoir détecté un END manquant. Cette méthode est redéfinie dans toutes les sous-classes de type bloc de T_substitution. Par défaut, dans la classe de base T_substitution, la méthode ne fait rien.
Chapter 17 : under-class of T substitution
La figure 16.1 de la page 81 montre la hiérarchie générale des classes qui héritent de la classe T_substitution. Les paragraphes 17.1 à 17.16 décrivent ces classes.
Class T affect
Cette classe modélise les substitutions de type affectation. Elle permet de connaître les variables qui sont modifiées, ainsi que les expressions
/* */
Class T any
Cette classe modélise les substitutions de type ANY . . . WHERE. Elle permet de connaître : - les identifiants introduits dans la clause - le prédicat de la clause WHERE - les substitutions de la clause THEN - La localisation du END de fin. Elle exporte les méthodes suivantes :
Class T assert
Cette classe modélise les substitutions de type ASSERT. Elle permet de connaître : - le prédicat de la clause - les substitutions de la clause THEN - La localisation du END de fin. Elle exporte les méthodes suivantes :
/* */
/*
* *GROS TROU * */
Sixth part : Predicates
Chapter 18 : Class T predicate
Class presentation
La figure 18.1 montre la hiérarchie générale des classes utilisées pour modéliser les noeuds de type prédicat du Betree. Toutes ces classes héritent d'une superclassey de base, la classe T_predicate, qui modélise les propriétés communes à toutes les prédicats utilisées par le Betree. La figure 18.2 montre une vue générale des services offerts par la classe T_predicate. Au contraire des substitutions qui sont chaînées dans des listes, les prédicats sont représentés sous forme d'arbre unique. Ainsi, les objets qui référencent des prédicats utilisent un seul champ pour implémenter cette référence. L'arbre obtenu est un arbre n-aire qui permet d'exploiter sans ambiguité de priorité le prédicat. Ainsi, dans l'exemple de la figure 18.3 de la page 99, dans la représentation du prédicat 'x : INT & y : INT', il n'y a pas d'ambiguité de priorité entre les opérateurs ':' et '&' car la racine de l'arbre obtenu est une instance de T_binary_predicate qui modélise le \et", et les deux feuilles de ce noeud modélisent les deux prédicats de typage de x et y.
Offered methods by class
La classe T_predicate ne définit aucune méthode qui lui soit propre.
Chapter 19 : under-classes of T predicate
La figure 18.1 de la page 97 montre la hiérarchie générale des classes qui héritent de la classe T_predicate. Les paragraphes 19.1 à 19.7 décrivent ces classes.
Class T binary predicate
Cette classe modélise les prédicats binaires, c'est à dire les prédicats de type \et", \ou", \im- plique" et \équivaut à". Elle permet de connaître le type du prédicat binaire au moyen du type énuméré T_binary_predicate_type décrit au paragraphe 19.1.1, ainsi que ses deux opérandes, pred1 et pred2, respectivement parties gauche et droite du prédicat.
/*
* * GROS TROUUUUUUU * */
Seventh part : Expressions
Chapter 20 : Class T expr
Classe presentation
La figure 20.1 page 108 montre la hiérarchie générale des classes utilisées pour modéliser les noeuds de type expression du Betree. Toutes ces classes héritent d'une superclassey de base, la classe T_expr, qui modélise les propriétés communes à toutes les expressions utilisées par le Betree. La figure 20.2 page 109 montre une vue générale des services offerts par la classe T_expr. Au contraire des substitutions qui sont chaînées dans des listes, les expressions sont représentés sous forme d'arbre unique. Ainsi, les objets qui référencent des expressions utilisent un seul champ pour implémenter cette référence. L'arbre obtenu est un arbre n-aire qui permet d'ex- ploiter sans ambiguité de priorité l'expression. Ainsi, dans l'exemple de la figure 20.3 de la page 110, dans la représentation de l'expression '(x + 2) ¤ 3', il n'y a pas d'ambiguité de priorité entre les opérateurs '+' et '*' car la racine de l'arbre obtenu est une instance de T_binary_op qui modélise le '*', et les deux feuilles de ce noeud modélisent les deux opérandes de la multiplication. On note par ailleurs que si les parenthèses sont conservées dans le Betree pour des raisons de tra»cabilité (classe T_expr_with_parenthesis), elles ne sont pas nécessaires à l'analyse sans ambiguité de l'arbre.
Offered methods by the class
La classe T_expr exporte une seule méthode qui lui est propre, la méthode strip_parenthesis, qui permet de supprimer les parenthèses autour d'une expression. En effet, comme expliqué au paragraphe précédent, les parenthèses ne sont pas nécessaires pour évaluer sans ambiguité les expressions car elles sont stockés dans des arbres n-aires.
/* */
Chapter 21 : Under-class of T expr
La figure 20.1 de la page 108 montre la hiérarchie générale des classes qui héritent de la classe T_expr. Les paragraphes 21.1 à 21.24 décrivent ces classes.
Class T array item
Cette classe modélise un élément de tableau (par exemple tab(1,2)). Elle permet de connaître le nom du tableau accédé ainsi que la liste des indexes utilisés pour cet accès. Attention, la phase d'analyse syntaxique ne permet pas de distinguer les accès à des éléments de tableau (classe T_array_item) des appels de fonction (classe T op result). Par conséquent, ces deux entités sont modélisées uniquement au moyen de la classe T_op_result, et sont éventuel- lement transformées en instance de T_array_item au cours de la phase d'analyse sémantique. La classe T_array_item exporte les méthodes suivantes :
/* */
Class T binary op
Cette classe modélise les opérateurs binaires. Elle permet de connaître le type de l'opérateur binaire au moyen du type énuméré T_binary_operator décrit au paragraphe 21.2.1, ainsi que ses deux opérandes, op1 et op2, respectivement parties gauche et droite de l'opérateur.
/*
* * TOO MANY BOARD, SEE LATER(MAYBE) * */