GL C/C++ Design Pattern 2. Interpréteur d un langage - étape 3 Construction de la Table des Symboles

Transcription

1 GL C/C++ Design Pattern 2 Interpréteur d un langage - étape 3 Construction de la Table des Symboles

2 Rappel du contexte Nous avons construit un analyseur syntaxique (lecteur de phrase) capable de parcourir un fichier texte, symbole par symbole, en vérifiant que le programme qu il contient est écrit selon la grammaire BNF de notre langage. Pour pouvoir réaliser l interprétation de ce programme, il va falloir construire, pendant l analyse syntaxique, une représentation du programme sous forme d arbre abstrait L interprétation du programme consistera alors à évaluer l arbe ainsi produit par un parcours récursif AP-6 : Interpréteur étape3-2

3 Programme analysé : debut fin i=1; i=i+3; Arbre Arbre Abstrait SeqInst Affectation Affectation OperateurBinaire + feuilles : Symboles Valués i 1 3 Table des Symboles Valués (ts) table AP-6 : Interpréteur étape3-3

4 Structure de l arbre Il s agit d un arbre n-aire dont les nœuds qui ne sont pas des feuilles représentent les «non terminaux» du langage : séquence d instructions, instruction, expression, Les feuilles de l arbre sont exclusivement constituées des symboles terminaux qui ont une valeur : ENTIER ou VARIABLE on parlera de symboles valués Pour représenter cet arbre, lors de l'étape suivante, on s inspirera du pattern «composite» vu précédemment AP-6 : Interpréteur étape3-4

5 Table des Symboles Naturellement, un même symbole valué (une variable en particulier) peut apparaître plusieurs fois dans un programme mais pour pouvoir calculer sa valeur lors de l interprétation, il faudra que l objet qui va représenter ce symbole dans l arbre soit unique! Pour cela, on va construire une Table des Symboles Valués qui va contenir, en un seul exemplaire, chaque symbole valué rencontré lors de l analyse syntaxique AP-6 : Interpréteur étape3-5

6 Table des Symboles Création de la table de symboles au moment de l analyse 2 classes sont rajoutées : TableSymboles (utilisation du template vector) SymboleValue (dérivée de Symbole.. c est un symbole qui a une valeur!) Table des Symboles valués (ts) table SymbolesValues Chaine code défini valeur "J" variable false "A" variable false debut J= A+ 12; b=12; fin "12" entier true 12 "b" variable false AP-6 : Interpréteur étape3-6

7 Classe SymboleValues - spécification class SymboleValue : public Symbole, // un symbole valué est un symbole public Noeud { // et c'est aussi une feuille de l'arbre abstrait public: SymboleValue(Symbole s); // construit un symbole valué à partir d'un symbole existant s ~SymboleValue( ) { void afficher (unsigned short indentation=0); // affiche le symbole en tant que noeud de l'arbre inline int getvaleur() { return valeur; // accesseur inline void setvaleur(int valeur) { this->valeur=valeur; defini=true; // accesseur inline bool estdefini() { return defini; // accesseur friend ostream & operator << (ostream & cout, SymboleValue symb); // affiche un symbole value sur cout private: bool defini; // indique si la valeur du symbole est définie int valeur; // valeur du symbole si elle est définie, zéro sinon ; AP-6 : Interpréteur étape3-7

8 Classe SymboleValues - implémentation SymboleValue::SymboleValue(Symbole s) : Symbole(s.getChaine()) { if (s == "<ENTIER>") { valeur = atoi(s.getchaine().c_str()); // c_str convertit une string en char* // atoi convertit une chaine en int defini = true; else { valeur = 0; defini = false; void SymboleValue::afficher(unsigned short indentation) { Noeud::afficher(indentation); cout << "Feuille - Symbole value : " << getchaine() << endl; // on affiche la chaine // Attention : cette fonction (operator) n'est pas membre de la classe SymboleValue ostream & operator <<(ostream & cout, SymboleValue symb) { cout << (Symbole) symb << "\t\t - Valeur="; if (symb.defini) cout << symb.valeur << " "; else cout << "indefinie "; return cout; AP-6 : Interpréteur étape3-8

9 Table des Symboles - spécification class TableSymboles { public: TableSymboles(); // Construit une table vide de pointeurs sur des symboles valués SymboleValue * chercheajoute(symbole s); // si s est identique à un symbole valué déjà présent dans la table, // on renvoie un pointeur sur ce symbole valué // Sinon on insère un nouveau symbole valué correspondant à s // et on renvoie un pointeur sur le nouveau symbole valué inséré friend ostream & operator <<(ostream & cout, TableSymboles ts); // affiche ts sur cout private: vector<symbolevalue *> table; // la table des symboles valués, triée sur la chaine ; AP-6 : Interpréteur étape3-9

10 Rappel : le patron < vector> // Exemple : déclaration d'un vecteur v de réels vector<float> v; // parcours de V en utilisant des indices for (unsigned int i=0; i<v.size(); i++) cout << v[i]; // parcours de V en utilisant des itérateurs vector<float>::iterator it; // déclaration d'un itérateur for (it=v.begin(); it<v.end(); it++) cout << *it; // insertion d'un élément, en tête par exemple it = v.insert(v.begin(), 8.2); // V[0]=8.2, V[1]=10.5, V[2]=20.3, v.size()=3 // it pointe sur v[0] AP-6 : Interpréteur étape 3-10

11 Table des Symboles - Implémentation TableSymboles::TableSymboles() : table() // Construit une table des symboles valués vide { //////////////////////////////////////////////////////////////////////////////// SymboleValue * TableSymboles::chercheAjoute(Symbole s) // si s est identique à un symbole valué déjà présent dans la table, // on renvoie un pointeur sur ce symbole valué. // Sinon, on insère un nouveau symbole valué correspondant à s // et on renvoie un pointeur sur le nouveau symbole valué inséré. { vector<symbolevalue*>::iterator i; i=table.begin(); while (i<table.end() && (**i).getchaine() < s.getchaine()) i++; if (i==table.end() (**i).getchaine()!= s.getchaine()) // si pas trouvé... i=table.insert(i, new SymboleValue(s)); return *i; AP-6 : Interpréteur étape 3-11

12 Table des Symboles - Implémentation ostream & operator <<(ostream & cout, TableSymboles ts) // affiche ts sur cout { cout << endl << "Contenu de la Table des Symboles Values :"<< endl << "========================================="<< endl << endl; for (unsigned int i=0; i<ts.table.size(); i++) cout << " "<< *(ts.table[i])<< endl; cout << endl; return cout; AP-6 : Interpréteur étape 3-12

13 Modification du lecteur de Phrase spécif. public: LecteurPhraseAvecTable(string nomfich); // Construit un lecteur de phrase pour vérifier // la syntaxe du programme dans le fichier nomfich void analyse(); // Si le contenu du fichier est conforme à la grammaire, // cette méthode se termine normalement et affiche un message "Syntaxe correcte". // la table des symboles (ts) aura été construite // Sinon, le programme sera interrompu (exit). inline TableSymboles getts() { return ts; // accesseur private: LecteurSymbole ls; // le lecteur de symboles utilisé pour analyser le fichier TableSymboles ts; // la table des symboles valués // le reste est inchangé ; AP-6 : Interpréteur étape 3-13

14 Modification du lecteur de Phrase impl. LecteurPhraseAvecTable::LecteurPhraseAvecTable(string nomfich) : ls(nomfich), ts() { //////////////////////////////////////////////////////////////////////////////// void LecteurPhraseAvecTable::affectation() { // <affectation> ::= <variable> = <expression> // sautersymcour("<variable>"); testersymcour("<variable>"); ts.chercheajoute(ls.getsymcour()); ls.suivant(); sautersymcour("="); expression(); AP-6 : Interpréteur étape 3-14

15 Modification du lecteur de Phrase impl. void LecteurPhraseAvecTable::facteur() { // <facteur> ::= <entier> <variable> - <facteur> ( <expression> ) if (ls.getsymcour()=="<variable>" ls.getsymcour()=="<entier>") { ts.chercheajoute(ls.getsymcour()); ls.suivant(); else if (ls.getsymcour()=="-") { ls.suivant(); facteur(); else if (ls.getsymcour()=="(") { ls.suivant(); expression(); sautersymcour(")"); else erreur("<facteur>"); AP-6 : Interpréteur étape 3-15

16 Résultat programme01.txt debut i = 1; i = i+3; fin TestLecteurPhraseAvecTable int main(int argc, char* argv[]) { LecteurPhraseAvecTable lp("programme01.txt"); lp.analyse(); // on lance l'analyse cout << lp.getts(); // on affiche la table des symboles Trace Syntaxe correcte. Contenu de la Table des Symboles Values : ========================================= Symbole de type <ENTIER> : "1" - Valeur=1 Symbole de type <ENTIER> : "3" - Valeur=3 Symbole de type <VARIABLE> : "i" - Valeur=indefinie AP-6 : Interpréteur étape 3-16

17 AP 6 Polymorphisme Petit Complément utile pour gérer des valeurs de différents types (entier, chaîne, réel)

18 1. Identification de type à l'exécution La norme ANSI stipule que C++ doit offrir un mécanisme permettant d'identifier, lors de l'exécution, le type d'une variable, d'une expression ou d'un objet En particulier, il est possible de connaître le véritable type d'un objet désigné par un pointeur ou une référence L'opérateur qui permet cela est : typeid Cet opérateur renvoie un résultat de classe : type_info La classe type_info fournit une méthode name() qui renvoie le type sous la forme d'une chaîne de caractère (char*) Les opérateurs == et!= permettent de comparer deux objets de la classe type_info AP-6 : Interpréteur étape 3-18

19 1. Identification de type à l'exécution #include <iostream> #include <typeinfo> using namespace std ; // pour typeid class point { public : virtual void affiche () { // ici vide - utile pour le polymorphisme ; class pointcol : public point { public : void affiche () { // ici vide ; main() { point p ; pointcol pc ; point * adp ; adp = &p ; cout << "type de adp : " << typeid (adp).name() << "\n" ; cout << "type de *adp : " << typeid (*adp).name() << "\n" ; adp = &pc ; cout << "type de adp : " << typeid (adp).name() << "\n" ; cout << "type de *adp : " << typeid (*adp).name() << "\n" ; trace type de adp : point * type de *adp : point type de adp : point * type de *adp : pointcol AP-6 : Interpréteur étape 3-19

20 1. Comparaison de types à l'exécution // mêmes déclarations que dans l'exemple précédent main() { point p1, p2 ; pointcol pc ; point * adp1, * adp2 ; adp1 = &p1 ; adp2 = &p2 ; cout << "En A : les objets pointes par adp1 et adp2 sont de " ; if (typeid(*adp1) == typeid (*adp2)) cout << "meme type\n" ; else cout << "types differents\n" ; adp1 = &p1 ; adp2 = &pc ; cout << "En B : les objets pointes par adp1 et adp2 sont de " ; if (typeid(*adp1) == typeid (*adp2)) cout << "meme type\n" ; else cout << "types differents\n" ; trace En A : les objets pointes par adp1 et adp2 sont de meme type En B : les objets pointes par adp1 et adp2 sont de types differents AP-6 : Interpréteur étape 3-20

21 1. Comparaison de types à l'exécution // mêmes déclarations que dans l'exemple précédent void fct (point & a, point & b) { if (typeid(a) == typeid(b)) cout << "reference a des objets de meme type \n" ; else cout << "reference a des objets de types differents \n" ; main() { point p ; pointcol pc1, pc2 ; cout << "Appel A : " ; fct (pc1, pc2) ; cout << "Appel B : " ; fct (p, pc1) ; trace Appel A : reference a des objets de meme type Appel B : reference a des objets de types differents AP-6 : Interpréteur étape 3-21

22 2. Les Cast dynamiques Dans une situation de polymorphisme, étant donné un objet désigné par un pointeur : On sait agir sur cet objet en fonction de son type, On peut connaître son type exact au moment de l'exécution mais le type du pointeur utilisé reste toujours celui défini lors de la compilation! main() { point p ; pointcol pc ; point * adp ; adp = &pc ; cout << "type de adp : " << typeid (adp).name() << "\n" ; cout << "type de *adp : " << typeid (*adp).name() << "\n" ; trace type de adp : point * type de *adp : pointcol AP-6 : Interpréteur étape 3-22

23 2. Les Cast dynamiques Dans l'exemple précédent, si l'on sait que adp, qui est de type point *, pointe sur un objet de type pointcol, on peut souhaiter convertir sa valeur en un pointeur de type pointcol* Ceci peut-être réalisé à l'aide de l'opérateur de cast dynamique : pointcol * adpc = dynamic_cast <pointcol *> (adp); La conversion aboutit si l'objet pointé est d'un type identique ou d'un type descendant du type d'arrivée demandé Lorsque l'opérateur n'aboutit pas : il renvoie NULL s'il s'agit d'une conversion de pointeur il déclence une exception bad_cast s'il s'agit d'une conversion de référence. AP-6 : Interpréteur étape 3-23

24 2. Les Cast dynamiques // Situation de polymorphisme : C dérive de B qui dérive de A main() { A a ; B b ; C c ; A * ada, * ada1 ; B * adb, * adb1 ; C * adc ; ada = &a ; // ada de type A* pointe sur un A ; // sa conversion dynamique en B* ne marche pas adb = dynamic_cast <B *> (ada) ; cout << "dc <B*>(ada) " << adb << "\n" ; ada = &b ; // ada de type A* pointe sur un B ; // sa conversion dynamique en B* marche adb = dynamic_cast <B *> (ada) ; cout << "dc <B*> ada " << adb << "\n" ; // sa conversion dynamique en A* marche ada1 = dynamic_cast <A*> (ada) ; cout << "dc <A*> ada " << ada1 << "\n" ; // mais sa conversion dynamique en C* ne marche pas adc = dynamic_cast <C *> (ada) ; cout << "dc <C*> ada " << adc << "\n" ; adb = &b ; // adb de type B* pointe sur un B // sa conversion dynamique en A* marche ada1 = dynamic_cast <A *> (adb) ; cout << "dc <A*> adb " << ada1 << "\n" ; // sa conversion dynamique en B* marche adb1 = dynamic_cast <B *> (adb) ; cout << "dc <A*> adb1 " << adb1 << "\n" ; // mais sa conversion dynamique en C* ne marche pas adc = dynamic_cast <C *> (adb) ; cout << "dc <C*> adb1 " << adc << "\n" ; AP-6 : Interpréteur étape 3-24