feature-variables-typees: ajout de Valeur et ValeurEntiere

SymboleValue.cpp

@@ -2,14 +2,14 @@
 #include "Exceptions.h"
 #include "Visiteur.h"
 #include <stdlib.h>
+#include "ValeurEntiere.h"
 
 SymboleValue::SymboleValue(const Symbole & s) :
 Symbole(s.getChaine()) {
   if (s == "<ENTIER>") {
-    m_valeur = atoi(s.getChaine().c_str()); // c_str convertit une string en char*
-    m_defini = true;
+    setValeur(atoi(s.getChaine().c_str())); // c_str convertit une string en char*
   } else if (s == "<CHAINE>") {
-      m_valeur = -1;
+      setValeur(-1);
       m_defini = true;
   } else {
     m_defini = false;
@@ -26,3 +26,9 @@ ostream & operator<<(ostream & cout, const SymboleValue & symbole) {
   else cout << "indefinie ";
   return cout;
 }
+
+
+void SymboleValue::setValeur(int valeur) {
+    this->m_valeur=new ValeurEntiere(valeur);
+    m_defini=true;
+}

SymboleValue.h

@@ -7,6 +7,7 @@ using namespace std;
 
 #include "Symbole.h"
 #include "ArbreAbstrait.h"
+#include "Valeur.h"
 
 class Visiteur;
 
@@ -16,16 +17,16 @@ class SymboleValue : public Symbole,  // Un symbole valué est un symbole qui a
 	  SymboleValue(const Symbole & s); // Construit un symbole valué à partir d'un symbole existant s
 	  ~SymboleValue( ) {}
           void accepter(Visiteur& visiteur) override;
-	  inline void setValeur(int valeur)    { this->m_valeur=valeur; m_defini=true;  } // accesseur
-          inline int  getValeur() const        { return this->m_valeur;                 } // accesseur
-	  inline bool estDefini()              { return m_defini;                       } // accesseur
-	  inline int  getValeur()              { return m_valeur;                       } // accesseur
+	  void setValeur(int valeur); 
+          inline void     setValeur(Valeur* v)     { m_valeur = v; m_defini = true; }
+          inline Valeur*  getValeur() const        { return this->m_valeur;         } // accesseur
+	  inline bool     estDefini()              { return m_defini;               } // accesseur
 
 	  friend ostream & operator << (ostream & cout, const SymboleValue & symbole); // affiche un symbole value sur cout
 
 private:
-	  bool m_defini;	// indique si la valeur du symbole est définie
-	  int  m_valeur;	// valeur du symbole si elle est définie, zéro sinon
+	  bool     m_defini;	// indique si la valeur du symbole est définie
+	  Valeur*  m_valeur;	// valeur du symbole si elle est définie, zéro sinon
 
 };
 

Valeur.h

@@ -0,0 +1,44 @@
+#ifndef VALEUR_H
+#define VALEUR_H
+
+#include <string>
+#include <ostream>
+
+class Valeur {
+public:
+    virtual int getEntier() const = 0;
+    virtual float getReel() const = 0;
+    virtual std::string getChaine() const = 0;
+    virtual bool isVrai() const = 0;
+
+    virtual Valeur* const operator+(const Valeur* v) const = 0;
+    virtual Valeur* const operator-(const Valeur* v) const = 0;
+    virtual Valeur* const operator*(const Valeur* v) const = 0;
+    virtual Valeur* const operator/(const Valeur* v) const = 0;
+    virtual bool operator> (const Valeur* v) const = 0;
+    virtual bool operator>=(const Valeur* v) const = 0;
+    virtual bool operator< (const Valeur* v) const = 0;
+    virtual bool operator<=(const Valeur* v) const = 0;
+    virtual bool operator==(const Valeur* v) const = 0;
+    virtual bool operator!=(const Valeur* v) const = 0;
+
+    bool operator&&(Valeur* v) {
+        return isVrai() && v->isVrai();
+    }
+
+    bool operator||(Valeur* v) {
+        return isVrai() || v->isVrai();
+    }
+
+    bool operator!() {
+        return !isVrai();
+    }
+};
+
+inline std::ostream& operator<<(std::ostream& out, Valeur* v) {
+    out << v->getChaine();
+    return out;
+}
+
+#endif /* VALEUR_H */
+

ValeurEntiere.cpp

@@ -0,0 +1,62 @@
+#include "ValeurEntiere.h"
+#include "Valeur.h"
+
+#include <string>
+
+ValeurEntiere::ValeurEntiere(int valeur) : m_valeur(valeur) {}
+
+bool ValeurEntiere::isVrai() const {
+    return m_valeur != 0;
+}
+
+int ValeurEntiere::getEntier() const {
+    return m_valeur;
+}
+
+float ValeurEntiere::getReel() const {
+    return ((float) m_valeur);
+}
+
+std::string ValeurEntiere::getChaine() const {
+    return std::to_string(m_valeur);
+}
+
+Valeur* const ValeurEntiere::operator+(const Valeur* v) const {
+    return new ValeurEntiere(m_valeur + v->getEntier());
+}
+
+Valeur* const ValeurEntiere::operator-(const Valeur* v) const {
+    return new ValeurEntiere(m_valeur - v->getEntier());
+}
+
+Valeur* const ValeurEntiere::operator*(const Valeur* v) const {
+    return new ValeurEntiere(m_valeur * v->getEntier());
+}
+
+Valeur* const ValeurEntiere::operator/(const Valeur* v) const {
+    return new ValeurEntiere(m_valeur / v->getEntier());
+}
+
+bool ValeurEntiere::operator>(const Valeur* v) const {
+    return m_valeur > v->getEntier();
+}
+
+bool ValeurEntiere::operator>=(const Valeur* v) const {
+    return m_valeur >= v->getEntier();
+}
+
+bool ValeurEntiere::operator<(const Valeur* v) const {
+    return m_valeur < v->getEntier();
+}
+
+bool ValeurEntiere::operator<=(const Valeur* v) const {
+    return m_valeur <= v->getEntier();
+}
+
+bool ValeurEntiere::operator==(const Valeur* v) const {
+    return m_valeur == v->getEntier();
+}
+
+bool ValeurEntiere::operator!=(const Valeur* v) const {
+    return m_valeur != v->getEntier();
+}

ValeurEntiere.h

@@ -0,0 +1,30 @@
+#ifndef VALEURENTIERE_H
+#define VALEURENTIERE_H
+
+#include "Valeur.h"
+#include <string>
+
+class ValeurEntiere : public Valeur {
+public:
+    ValeurEntiere(int valeur);
+    int getEntier() const override;
+    float getReel() const override;
+    std::string getChaine() const override;
+    bool isVrai() const override;
+
+    Valeur* const operator+(const Valeur* v) const override;
+    Valeur* const operator-(const Valeur* v) const override;
+    Valeur* const operator*(const Valeur* v) const override;
+    Valeur* const operator/(const Valeur* v) const override;
+    bool operator> (const Valeur* v) const override;
+    bool operator>=(const Valeur* v) const override;
+    bool operator< (const Valeur* v) const override;
+    bool operator<=(const Valeur* v) const override;
+    bool operator==(const Valeur* v) const override;
+    bool operator!=(const Valeur* v) const override;
+private:
+    int m_valeur;
+};
+
+#endif /* VALEURENTIERE_H */
+

VisiteurExecuter.cpp

@@ -1,4 +1,5 @@
 #include "VisiteurExecuter.h"
+#include "ValeurEntiere.h"
 
 void VisiteurExecuter::visiterNoeudSeqInst(NoeudSeqInst* noeud) {
     for (unsigned int i = 0; i < noeud->getInstructions().size(); i++)
@@ -11,7 +12,7 @@ void VisiteurExecuter::visiterNoeudAffectation(NoeudAffectation* noeud) {
 }
 
 void VisiteurExecuter::visiterNoeudOperateurBinaire(NoeudOperateurBinaire* noeud) {  
-    int og, od, valeur;
+    Valeur *og, *od, *valeur;
     if (noeud->getOperandeGauche() != nullptr) {
         noeud->getOperandeGauche()->accepter(*this); // On évalue l'opérande gauche
         og = m_derniereValeur;
@@ -21,21 +22,21 @@ void VisiteurExecuter::visiterNoeudOperateurBinaire(NoeudOperateurBinaire* noeud
         od = m_derniereValeur; 
     }
     // Et on combine les deux opérandes en fonctions de l'opérateur
-    if (noeud->getOperateur() == "+") valeur = (og + od);
-    else if (noeud->getOperateur() == "-") valeur = (og - od);
-    else if (noeud->getOperateur() == "*") valeur = (og * od);
-    else if (noeud->getOperateur() == "==") valeur = (og == od);
-    else if (noeud->getOperateur() == "!=") valeur = (og != od);
-    else if (noeud->getOperateur() == "<") valeur = (og < od);
-    else if (noeud->getOperateur() == ">") valeur = (og > od);
-    else if (noeud->getOperateur() == "<=") valeur = (og <= od);
-    else if (noeud->getOperateur() == ">=") valeur = (og >= od);
-    else if (noeud->getOperateur() == "et") valeur = (og && od);
-    else if (noeud->getOperateur() == "ou") valeur = (og || od);
-    else if (noeud->getOperateur() == "non") valeur = (!og);
+    if (noeud->getOperateur() == "+") valeur = (*og + od);
+    else if (noeud->getOperateur() == "-") valeur = (*og - od);
+    else if (noeud->getOperateur() == "*") valeur = (*og * od);
+    else if (noeud->getOperateur() == "==") valeur = new ValeurEntiere(*og == od);
+    else if (noeud->getOperateur() == "!=") valeur = new ValeurEntiere(*og != od);
+    else if (noeud->getOperateur() == "<") valeur = new ValeurEntiere(*og < od);
+    else if (noeud->getOperateur() == ">") valeur = new ValeurEntiere(*og > od);
+    else if (noeud->getOperateur() == "<=") valeur = new ValeurEntiere(*og <= od);
+    else if (noeud->getOperateur() == ">=") valeur = new ValeurEntiere(*og >= od);
+    else if (noeud->getOperateur() == "et") valeur = new ValeurEntiere(*og && od);
+    else if (noeud->getOperateur() == "ou") valeur = new ValeurEntiere(*og || od);
+    else if (noeud->getOperateur() == "non") valeur = new ValeurEntiere(!*og);
     else if (noeud->getOperateur() == "/") {
         if (od == 0) throw DivParZeroException();
-        valeur = og / od;
+        valeur = *og / od;
     }
     m_derniereValeur = valeur;
 }

VisiteurExecuter.h

@@ -2,6 +2,7 @@
 #define VISITEUREXECUTER_H
 
 #include "Visiteur.h"
+#include "Valeur.h"
 
 class VisiteurExecuter : public Visiteur {
 public:
@@ -16,7 +17,7 @@ class VisiteurExecuter : public Visiteur {
     void visiterNoeudInstEcrire(NoeudInstEcrire* noeud) override;
     void visiterSymboleValue(SymboleValue* symbole) override;
 private:
-    int m_derniereValeur = 0;
+    Valeur* m_derniereValeur = 0;
 };
 
 #endif /* VISITEUREXECUTER_H */

main.cpp

@@ -6,6 +6,8 @@ using namespace std;
 #include "VisiteurExecuter.h"
 #include "VisiteurCompiler.h"
 
+#include "ValeurEntiere.h"
+
 void compiler(ostream& out, const TableSymboles& symboles, Noeud* arbre);
 
 int main(int argc, char* argv[]) {