Merge branch 'master' into feature-procedures

ArbreAbstrait.cpp

@@ -147,3 +147,13 @@ NoeudInstAppel::NoeudInstAppel(Symbole nom, vector<Noeud*> parametres)
 void NoeudInstAppel::accepter(Visiteur& visiteur) {
     visiteur.visiterNoeudInstAppel(this);
 }
+
+////////////////////////////////////////////////////////////////////////////////
+// NoeudInstAlea
+////////////////////////////////////////////////////////////////////////////////
+
+NoeudAlea::NoeudAlea(Noeud* min, Noeud* max) : m_min(min), m_max(max) {}
+
+void NoeudAlea::accepter(Visiteur& visiteur) {
+    visiteur.visiterNoeudAlea(this);
+}

ArbreAbstrait.h

@@ -203,7 +203,7 @@ class NoeudInstAppel : public Noeud {
     // Classe pour représenter un noeud "instruction appel"
 public:
     NoeudInstAppel(Symbole nom, vector<Noeud*> parametres);
-    // Construit une "instruction appel" avec sa condition et sa séquence d'instruction
+    // Construit une "instruction appel" avec son nom et ses paramètres
 
     ~NoeudInstAppel() {
     } // A cause du destructeur virtuel de la classe Noeud
@@ -217,4 +217,22 @@ class NoeudInstAppel : public Noeud {
     vector<Noeud*> m_parametres;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+class NoeudAlea : public Noeud {
+    // Classe pour représenter un noeud "alea"
+public:
+    NoeudAlea(Noeud* min, Noeud* max);
+    // Construit un "alea" avec son min et son max
+
+    ~NoeudAlea() {
+    } // A cause du destructeur virtuel de la classe Noeud
+    void accepter(Visiteur& visiteur) override;
+
+    inline Noeud* getMin() const { return m_min; }
+    inline Noeud* getMax() const { return m_max; }
+
+private:
+    Noeud* m_min;
+    Noeud* m_max;
+};
 #endif /* ARBREABSTRAIT_H */

Interpreteur.cpp

@@ -218,7 +218,7 @@ Noeud* Interpreteur::expMult(){
 }
 
 Noeud* Interpreteur::facteur() {
-  // <facteur> ::= <entier> | <reel> | <chaine> | <variable> | - <facteur> | non <facteur> | ( <expression> )
+  // <facteur> ::= <entier> | <reel> | <chaine> | <variable> | - <facteur> | non <facteur> | ( <expression> ) | <alea>
   Noeud* fact = nullptr;
   if (m_lecteur.getSymbole() == "<VARIABLE>" || m_lecteur.getSymbole() == "<ENTIER>" || m_lecteur.getSymbole() == "<REEL>" || m_lecteur.getSymbole() == "<CHAINE>") {
     fact = m_table.chercheAjoute(m_lecteur.getSymbole()); // on ajoute la variable ou l'entier à la table
@@ -235,6 +235,8 @@ Noeud* Interpreteur::facteur() {
     m_lecteur.avancer();
     fact = expression();
     testerEtAvancer(")");
+  } else if (m_lecteur.getSymbole() == "alea") {
+    fact = alea();
   } else
     erreur("Facteur incorrect");
   return fact;
@@ -377,4 +379,16 @@ Noeud* Interpreteur::instAppel() {
     testerEtAvancer(";");
 
     return new NoeudInstAppel(nom, parametres);
+} 
+
+Noeud* Interpreteur::alea() {
+    // <alea> ::= alea(<expression>, <expression>)
+    testerEtAvancer("alea");
+    testerEtAvancer("(");
+    Noeud* min = expression();
+    testerEtAvancer(",");
+    Noeud* max = expression();
+    testerEtAvancer(")");
+
+    return new NoeudAlea(min, max);
 }

Interpreteur.h

@@ -38,7 +38,7 @@ class Interpreteur {
     Noeud*  expComp();     //     <expComp> ::= <expAdd> { == | != | < | <= | > | >= <expAdd> }
     Noeud*  expAdd();      //      <expAdd> ::= <expMult> { + | - <expMult> }
     Noeud*  expMult();     //     <expMult> ::= <facteur> { * | / <facteur> }
-    Noeud*  facteur();     //     <facteur> ::= <entier>  |  <reel>  |  <chaine>  |  <variable>  |  - <facteur>  | non <facteur> | ( <expression> )
+    Noeud*  facteur();     //     <facteur> ::= <entier>  |  <reel>  |  <chaine>  |  <variable>  |  - <facteur>  | non <facteur> | ( <expression> ) | <alea>
                            //   <opBinaire> ::= + | - | *  | / | < | > | <= | >= | == | != | et | ou
     Noeud*  instSi();      //      <instSi> ::= si ( <expression> ) <seqInst> { sinonsi (<expression>) <seqInst> } [ sinon <seqInst> ] finsi
     Noeud*  instPour();    //    <instPour> ::= pour ( [ <affectation> ] ; <expression> ; [ <affection> ]) <seqInst> finpour
@@ -47,6 +47,7 @@ class Interpreteur {
     Noeud*  instEcrire();  //  <instEcrire> ::= ecrire ( <expression> | <chaine> {, <expression> | <chaine> } );
     Noeud*  instRepeter(); // <instRepeter> ::= repeter <seqInst> jusqua ( <expression> )
     Noeud*  instAppel();   //       <appel> ::= appel <variable>([<expression> {, <expression>}]);
+    Noeud*  alea();        //        <alea> ::= alea(<expression>, <expression>)
 
     // outils pour simplifier l'analyse syntaxique
     void tester (const string & symboleAttendu) const;   // Si symbole courant != symboleAttendu, on lève une exception

Visiteur.h

@@ -31,6 +31,7 @@ class Visiteur {
     virtual void visiterNoeudInstLire(NoeudInstLire* noeud) = 0;
     virtual void visiterNoeudInstEcrire(NoeudInstEcrire* noeud) = 0;
     virtual void visiterNoeudInstAppel(NoeudInstAppel* noeud) = 0;
+    virtual void visiterNoeudAlea(NoeudAlea* noeud) = 0;
     virtual void visiterSymboleValue(SymboleValue* symbole) = 0;
 };
 

VisiteurCompiler.cpp

@@ -162,6 +162,14 @@ void VisiteurCompiler::visiterNoeudInstAppel(NoeudInstAppel* noeud) {
     m_out << ")" << endl;
 }
 
+void VisiteurCompiler::visiterNoeudAlea(NoeudAlea* noeud) {
+    m_out << "random.randint(";
+    noeud->getMin()->accepter(*this);
+    m_out << ",";
+    noeud->getMax()->accepter(*this);
+    m_out << ")" << endl;
+}
+
 void VisiteurCompiler::visiterSymboleValue(SymboleValue* symbole) {
     m_out << symbole->getChaine();
 }

VisiteurCompiler.h

@@ -19,6 +19,7 @@ class VisiteurCompiler : public Visiteur {
     void visiterNoeudInstLire(NoeudInstLire* noeud) override;
     void visiterNoeudInstEcrire(NoeudInstEcrire* noeud) override;
     void visiterNoeudInstAppel(NoeudInstAppel* noeud) override;
+    void visiterNoeudAlea(NoeudAlea* noeud) override;
     void visiterSymboleValue(SymboleValue* symbole) override;
 
 private:

VisiteurExecuter.cpp

@@ -112,6 +112,14 @@ void VisiteurExecuter::visiterNoeudInstAppel(NoeudInstAppel* noeud) {
     TableProcedures::getTable()->executerProcedure(noeud->getNom(), noeud->getParametres(), *this);
 }
 
+void VisiteurExecuter::visiterNoeudAlea(NoeudAlea* noeud) {
+    noeud->getMin()->accepter(*this);
+    int min = m_derniereValeur->getEntier();
+    noeud->getMax()->accepter(*this);
+    int max = m_derniereValeur->getEntier();
+    m_derniereValeur = new ValeurEntiere(rand() % (max - min) + min);
+}
+
 void VisiteurExecuter::visiterSymboleValue(SymboleValue* symbole) {
     if (!symbole->estDefini()) throw IndefiniException(); // on lève une exception si valeur non définie
     m_derniereValeur = symbole->getValeur();

VisiteurExecuter.h

@@ -17,6 +17,7 @@ class VisiteurExecuter : public Visiteur {
     void visiterNoeudInstLire(NoeudInstLire* noeud) override;
     void visiterNoeudInstEcrire(NoeudInstEcrire* noeud) override;
     void visiterNoeudInstAppel(NoeudInstAppel* noeud) override;
+    void visiterNoeudAlea(NoeudAlea* noeud) override;
     void visiterSymboleValue(SymboleValue* symbole) override;
 
     inline Valeur* getDerniereValeur() { return m_derniereValeur; }

main.cpp

@@ -12,6 +12,7 @@ using namespace std;
 void compiler(ostream& out, const TableSymboles& symboles, Noeud* arbre);
 
 int main(int argc, char* argv[]) {
+    srand (time(NULL));
     bool compile = false;
     string nomFich;
     ofstream o;
@@ -73,6 +74,7 @@ int main(int argc, char* argv[]) {
 }
 
 void compiler(ostream& out, const TableSymboles& symboles, Noeud* arbre) {
+    out << "import random" << endl;
     VisiteurCompiler visiteur(out, 0);
     TableProcedures::getTable()->compilerProcedures(visiteur);
     arbre->accepter(visiteur);

motsCles.txt

@@ -34,3 +34,4 @@ et
 ou
 non
 appel
+alea

pom.txt

@@ -0,0 +1,18 @@
+procedure principale()
+    ecrire("Entrez le minimum et le maximum : ");
+    lire(min, max);
+    nbMyst = alea(min, max);
+    nbDevin = nbMyst - 1;
+    nbCoups = 0;
+    tantque (nbDevin != nbMyst)
+        lire(nbDevin);
+        nbCoups = nbCoups + 1;
+        si (nbMyst > nbDevin)
+            ecrire("C'est plus");
+        sinonsi (nbMyst < nbDevin)
+            ecrire("C'est moins");
+        finsi
+    fintantque
+
+    ecrire("Bravo, vous avez trouvé en ", nbCoups, " coup(s)");
+finproc

test08-alea.txt

@@ -0,0 +1,6 @@
+# Résultat attendu :
+# i : Nombre entre 1 et 100
+
+procedure principale()
+    i = alea(1, 100);
+finproc

testAffectation.txt

@@ -13,6 +13,7 @@ procedure principale()
     l = k + j;
     m = j + k;
     n = "Bla" * 2 + "Car";
+    o = alea(3, 100);
 finproc
 
 

tests/TestInstPour.cpp

@@ -32,7 +32,7 @@ void TestInstPour::tearDown() {
 }
 
 void TestInstPour::testPour() {
-    std::ifstream fichier("testPour.txt");
+    std::ifstream fichier("test04-Pour.txt");
     if (!fichier) {
         CPPUNIT_ASSERT_MESSAGE("Fichier impossible à ouvrir", false);
     }
@@ -43,12 +43,12 @@ void TestInstPour::testPour() {
     interpreteur.getArbre()->accepter(visiteur);
 
     const TableSymboles& table = interpreteur.getTable();
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test valeur i", 11, table[3].getValeur());
-    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test valeur j", 385, table[4].getValeur());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test valeur i", 11, table[3].getValeur()->getEntier());
+    CPPUNIT_ASSERT_EQUAL_MESSAGE("Test valeur j", 385, table[4].getValeur()->getEntier());
 }
 
 void TestInstPour::testPourErreur() {
-    std::ifstream fichier("testPourErreurSyntaxe.txt");
+    std::ifstream fichier("test07-PourErreurSyntaxe.txt");
     if (!fichier) {
         CPPUNIT_ASSERT_MESSAGE("Fichier impossible à ouvrir", false);
     }