diff --git a/ArbreAbstrait.cpp b/ArbreAbstrait.cpp
index 5e95d9e..3f3b1c3 100644
--- a/ArbreAbstrait.cpp
+++ b/ArbreAbstrait.cpp
@@ -134,4 +134,26 @@ void NoeudInstEcrire::ajoute(Noeud* instruction) {
 
 void NoeudInstEcrire::accepter(Visiteur& visiteur) {
     visiteur.visiterNoeudInstEcrire(this);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// NoeudInstAppel
+////////////////////////////////////////////////////////////////////////////////
+
+NoeudInstAppel::NoeudInstAppel(Symbole nom, vector<Noeud*> parametres)
+: m_nom(nom), m_parametres(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);
 }
\ No newline at end of file
diff --git a/ArbreAbstrait.h b/ArbreAbstrait.h
index c325c9c..99155c0 100644
--- a/ArbreAbstrait.h
+++ b/ArbreAbstrait.h
@@ -198,4 +198,41 @@ class NoeudInstEcrire : public Noeud {
     vector<Noeud*> m_ecritures;
 };
 
+////////////////////////////////////////////////////////////////////////////////
+class NoeudInstAppel : public Noeud {
+    // Classe pour représenter un noeud "instruction appel"
+public:
+    NoeudInstAppel(Symbole nom, vector<Noeud*> parametres);
+    // Construit une "instruction appel" avec son nom et ses paramètres
+
+    ~NoeudInstAppel() {
+    } // A cause du destructeur virtuel de la classe Noeud
+    void accepter(Visiteur& visiteur) override;
+
+    inline Symbole        getNom() const { return m_nom; }
+    inline vector<Noeud*> getParametres() const { return m_parametres; }
+
+private:
+    Symbole        m_nom;
+    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 */
diff --git a/Instruction.cpp b/Instruction.cpp
index 483d757..492b612 100644
--- a/Instruction.cpp
+++ b/Instruction.cpp
@@ -5,7 +5,7 @@ Instruction::Instruction() {
 
 bool Instruction::isInstruction(Symbole sym) {
     int i = 0;
-    while (i < 7 && !(sym == m_instructions[i])) {
+    while (i < 8 && !(sym == m_instructions[i])) {
         i++;
     }
 return sym == m_instructions[i];
diff --git a/Instruction.h b/Instruction.h
index 6e38df4..eb45b67 100644
--- a/Instruction.h
+++ b/Instruction.h
@@ -22,7 +22,7 @@ class Instruction {
     Instruction();
     bool isInstruction(Symbole sym);
 private:
-    string m_instructions[7] = {"<VARIABLE>","ecrire","si","pour","tantque","repeter","lire"};
+    string m_instructions[8] = {"<VARIABLE>","ecrire","si","pour","tantque","repeter","lire","appel"};
 
 };
 
diff --git a/Interpreteur.cpp b/Interpreteur.cpp
index a77a15c..6f2834b 100644
--- a/Interpreteur.cpp
+++ b/Interpreteur.cpp
@@ -1,5 +1,6 @@
 #include "Interpreteur.h"
 #include "Instruction.h"
+#include "TableProcedures.h"
 #include <stdlib.h>
 #include <iostream>
 using namespace std;
@@ -44,17 +45,49 @@ void Interpreteur::erreur(const string & message) const {
 }
 
 Noeud* Interpreteur::programme() {
-  // <programme> ::= procedure principale() <seqInst> finproc FIN_FICHIER
-  testerEtAvancer("procedure");
-  testerEtAvancer("principale");
-  testerEtAvancer("(");
-  testerEtAvancer(")");
-  Noeud* sequence = seqInst();
-  testerEtAvancer("finproc");
-  tester("<FINDEFICHIER>");
-  return sequence;
+    // <programme> ::= {procedure <procedure>} procedure principale() <seqInst> finproc FIN_FICHIER
+    Noeud* sequence = nullptr;
+    while (sequence == nullptr) {
+        testerEtAvancer("procedure");
+        if (m_lecteur.getSymbole() == "<VARIABLE>") {
+            procedure();
+        } else {
+            testerEtAvancer("principale");
+            testerEtAvancer("(");
+            testerEtAvancer(")");
+            sequence = seqInst();
+            testerEtAvancer("finproc");
+            tester("<FINDEFICHIER>");
+        }
+    }
+    return sequence;
 }
 
+void Interpreteur::procedure() {
+    // <procedure> ::= <variable>([<variable> {, <variable> }]) <seqInst> finproc
+    TableSymboles table = m_table;
+    m_table = TableSymboles();
+    std::vector<SymboleValue*> parametres;
+    
+    tester("<VARIABLE>");
+    Symbole nom = m_lecteur.getSymbole();
+    m_lecteur.avancer();
+    testerEtAvancer("(");
+    if (m_lecteur.getSymbole() == "<VARIABLE>") {
+        parametres.push_back(m_table.chercheAjoute(m_lecteur.getSymbole()));
+        m_lecteur.avancer();
+        while (m_lecteur.verifierPourAvancer(",")) {
+            tester("<VARIABLE>");
+            parametres.push_back(m_table.chercheAjoute(m_lecteur.getSymbole()));
+        }
+    }
+    testerEtAvancer(")");
+    Noeud* sequence = seqInst();
+    testerEtAvancer("finproc");
+    TableProcedures::getTable()->ajoutProcedure(nom, new Procedure(m_table, sequence, parametres));
+    m_table = table;
+}   
+
 Noeud* Interpreteur::seqInst() {
     // <seqInst> ::= <inst> { <inst> }
     Instruction* instructions = new Instruction();
@@ -101,6 +134,9 @@ Noeud* Interpreteur::inst() {
   else if(m_lecteur.getSymbole() == "lire"){
       return instLire();
   }
+  else if(m_lecteur.getSymbole() == "appel"){
+      return instAppel();
+  }
   else {
       erreur("Instruction incorrecte");
       return nullptr;
@@ -182,9 +218,9 @@ Noeud* Interpreteur::expMult(){
 }
 
 Noeud* Interpreteur::facteur() {
-  // <facteur> ::= <entier> | <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>") {
+  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
     m_lecteur.avancer();
   } else if (m_lecteur.getSymbole() == "-") { // - <facteur>
@@ -199,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;
@@ -320,4 +358,37 @@ Noeud* Interpreteur::instLire(){
     testerEtAvancer(")");
     testerEtAvancer(";");
     return var;
-}
\ No newline at end of file
+}
+
+Noeud* Interpreteur::instAppel() {
+    // <appel> ::= appel <variable>([<expression> {, <expression>}]);
+    testerEtAvancer("appel");
+    tester("<VARIABLE>");
+    Symbole nom = m_lecteur.getSymbole();
+    m_lecteur.avancer();
+    testerEtAvancer("(");
+    
+    std::vector<Noeud*> parametres;
+    if (m_lecteur.getSymbole() != ")") {
+        parametres.push_back(expression());
+        while (m_lecteur.verifierPourAvancer(",")) {
+            parametres.push_back(expression());
+        }
+    }
+    testerEtAvancer(")");
+    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);
+} 
\ No newline at end of file
diff --git a/Interpreteur.h b/Interpreteur.h
index c10a453..bca525c 100644
--- a/Interpreteur.h
+++ b/Interpreteur.h
@@ -24,10 +24,11 @@ class Interpreteur {
     Lecteur        m_lecteur;  // Le lecteur de symboles utilisé pour analyser le fichier
     TableSymboles  m_table;    // La table des symboles valués
     Noeud*         m_arbre;    // L'arbre abstrait
-    bool           m_erreur;   // Etat de l'intrpreteur
+    bool           m_erreur;   // Etat de l'interpreteur
 
     // Implémentation de la grammaire
-    Noeud*  programme();   //   <programme> ::= procedure principale() <seqInst> finproc FIN_FICHIER
+    Noeud*  programme();   //   <programme> ::= {procedure <procedure>} procedure principale() <seqInst> finproc FIN_FICHIER
+    void    procedure();   //   <procedure> ::= <variable>([<variable> {, <variable> }]) <seqInst> finproc
 
     Noeud*  seqInst();	   //     <seqInst> ::= <inst> { <inst> }
     Noeud*  inst();	   //        <inst> ::= <affectation> ; | <instSi>
@@ -37,14 +38,16 @@ class Interpreteur {
     Noeud*  expComp();     //     <expComp> ::= <expAdd> { == | != | < | <= | > | >= <expAdd> }
     Noeud*  expAdd();      //      <expAdd> ::= <expMult> { + | - <expMult> }
     Noeud*  expMult();     //     <expMult> ::= <facteur> { * | / <facteur> }
-    Noeud*  facteur();     //     <facteur> ::= <entier>  |  <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
     Noeud*  instTantQue(); // <instTantQue> ::= tantque ( <expression> ) <seqInst> fintantque
-    Noeud*  instLire();    //   <instLire>  ::= lire (variable {, variable});
+    Noeud*  instLire();    //   <instLire>  ::= lire (<variable> {, <variable>});
     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
diff --git a/Lecteur.cpp b/Lecteur.cpp
index 6194c68..9614332 100644
--- a/Lecteur.cpp
+++ b/Lecteur.cpp
@@ -61,7 +61,7 @@ string Lecteur::motSuivant() {
     do {
       s = s + m_lecteurCar.getCaractere();
       m_lecteurCar.avancer();
-    } while (isdigit(m_lecteurCar.getCaractere()));
+    } while (isdigit(m_lecteurCar.getCaractere()) || m_lecteurCar.getCaractere() == '.');
 
   else if (isalpha(m_lecteurCar.getCaractere()))
     // c'est le début d'un mot
diff --git a/Procedure.cpp b/Procedure.cpp
new file mode 100644
index 0000000..962cc60
--- /dev/null
+++ b/Procedure.cpp
@@ -0,0 +1,14 @@
+#include "Procedure.h"
+
+Procedure::Procedure(TableSymboles table, Noeud* sequence, std::vector<SymboleValue*> parametres) 
+: m_table(table), m_sequence(sequence), m_params(parametres) {}
+
+void Procedure::accepter(Visiteur& visiteur) {
+    m_sequence->accepter(visiteur);
+}
+
+void Procedure::empiler(std::vector<Valeur*> parametres) {
+    for (int i = 0; i < parametres.size() && i < m_params.size(); i++) {
+        m_params[i]->setValeur(parametres[i]);
+    }
+}
\ No newline at end of file
diff --git a/Procedure.h b/Procedure.h
new file mode 100644
index 0000000..896ef3b
--- /dev/null
+++ b/Procedure.h
@@ -0,0 +1,21 @@
+#ifndef PROCEDURE_H
+#define PROCEDURE_H
+
+#include "ArbreAbstrait.h"
+#include "TableSymboles.h"
+#include "SymboleValue.h"
+#include <vector>
+
+class Procedure : public Noeud {
+public:
+    Procedure(TableSymboles table, Noeud* sequence, std::vector<SymboleValue*> parametres);
+    void accepter(Visiteur& visiteur) override;
+    void empiler(std::vector<Valeur*> parametres);
+private:
+    TableSymboles              m_table;
+    Noeud*                     m_sequence;
+    std::vector<SymboleValue*> m_params;
+};
+
+#endif /* PROCEDURE_H */
+
diff --git a/Symbole.cpp b/Symbole.cpp
index a8b8beb..75cd708 100644
--- a/Symbole.cpp
+++ b/Symbole.cpp
@@ -11,6 +11,7 @@ const char * Symbole::FICHIER_MOTS_CLES = "motsCles.txt";
 Symbole::Symbole(const string & s) : m_chaine(s) {
   // attention : l'ordre des tests ci-dessous n'est pas innocent !
   if (s == "") this->m_categorie = FINDEFICHIER;
+  else if (isdigit(s[0]) && s.find('.') != string::npos) this->m_categorie = REEL;
   else if (isdigit(s[0])) this->m_categorie = ENTIER;
   else if (s.size() >= 2 && s[0] == '"' && s[s.size() - 1] == '"') this->m_categorie = CHAINE;
   else if (isMotCle(s)) this->m_categorie = MOTCLE;
@@ -22,6 +23,7 @@ bool Symbole::operator==(const string & ch) const {
   return this->m_chaine == ch ||
           (this->m_categorie == VARIABLE     && (ch == "<VARIABLE>"     || ch == "<variable>")) ||
           (this->m_categorie == ENTIER       && (ch == "<ENTIER>"       || ch == "<entier>"))   ||
+          (this->m_categorie == REEL         && (ch == "<REEL>"         || ch == "<reel>"))     ||
           (this->m_categorie == CHAINE       && (ch == "<CHAINE>"       || ch == "<chaine>"))   ||
           (this->m_categorie == INDEFINI     && (ch == "<INDEFINI>"     || ch == "<indefini>")) ||
           (this->m_categorie == FINDEFICHIER && (ch == "<FINDEFICHIER>" || ch == "<findefichier>"));
@@ -56,6 +58,7 @@ ostream & operator<<(ostream & cout, const Symbole & symbole) {
   if      (symbole.m_categorie == Symbole::MOTCLE)       cout << "<MOTCLE>      ";
   else if (symbole.m_categorie == Symbole::VARIABLE)     cout << "<VARIABLE>    ";
   else if (symbole.m_categorie == Symbole::ENTIER)       cout << "<ENTIER>      ";
+  else if (symbole.m_categorie == Symbole::REEL)         cout << "<REEL>        ";
   else if (symbole.m_categorie == Symbole::CHAINE)       cout << "<CHAINE>      ";
   else if (symbole.m_categorie == Symbole::INDEFINI)     cout << "<INDEFINI>    ";
   else if (symbole.m_categorie == Symbole::FINDEFICHIER) cout << "<FINDEFICHIER>";
diff --git a/Symbole.h b/Symbole.h
index 71929d5..3ade486 100644
--- a/Symbole.h
+++ b/Symbole.h
@@ -16,7 +16,7 @@ class Symbole {
 	friend ostream & operator <<(ostream & cout, const Symbole & symbole); // Fonction amie pour pouvoir afficher un symbole sur cout 
 
 private:
-    	enum m_categorie { MOTCLE, VARIABLE, ENTIER, CHAINE, INDEFINI, FINDEFICHIER };
+    	enum m_categorie { MOTCLE, VARIABLE, ENTIER, REEL, CHAINE, INDEFINI, FINDEFICHIER };
 	string           m_chaine;             // Chaîne du symbole
 	m_categorie      m_categorie;          // Categorie du symbole (voir type énuméré ci-dessus)
 	bool             isMotCle(const string & s) const;  // Renvoie vrai si s est un mot clé du langage
diff --git a/SymboleValue.cpp b/SymboleValue.cpp
index 12a2260..3f356ce 100644
--- a/SymboleValue.cpp
+++ b/SymboleValue.cpp
@@ -2,14 +2,19 @@
 #include "Exceptions.h"
 #include "Visiteur.h"
 #include <stdlib.h>
+#include "ValeurEntiere.h"
+#include "ValeurReelle.h"
+#include "ValeurChaine.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;
+      this->m_valeur = new ValeurChaine(s.getChaine().substr(1, s.getChaine().size() - 2));
+      m_defini = true;
+  } else if (s == "<REEL>") {
+      this->m_valeur = new ValeurReelle(stof(s.getChaine()));
       m_defini = true;
   } else {
     m_defini = false;
@@ -26,3 +31,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;
+}
\ No newline at end of file
diff --git a/SymboleValue.h b/SymboleValue.h
index ae430ca..64554fe 100644
--- a/SymboleValue.h
+++ b/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
 
 };
 
diff --git a/TableProcedures.cpp b/TableProcedures.cpp
new file mode 100644
index 0000000..e129d29
--- /dev/null
+++ b/TableProcedures.cpp
@@ -0,0 +1,33 @@
+#include "TableProcedures.h"
+#include "Procedure.h"
+#include <algorithm>
+
+TableProcedures* TableProcedures::table = nullptr;
+
+TableProcedures::TableProcedures() {}
+
+TableProcedures* TableProcedures::getTable() {
+    if (table == nullptr) {
+        table = new TableProcedures();
+    }
+    
+    return table;
+}
+
+void TableProcedures::ajoutProcedure(Symbole nom, Procedure* procedure) {
+    std::string nomProcedure(nom.getChaine());
+    m_procedures.push_back(procedure);
+    m_noms.push_back(nom.getChaine());
+}
+
+void TableProcedures::executerProcedure(Symbole nom, std::vector<Noeud*> parametres, VisiteurExecuter& v) {
+    long i = std::distance(m_noms.begin(), std::find(m_noms.begin(), m_noms.end(), nom.getChaine()));
+    Procedure* p = m_procedures[i];
+    std::vector<Valeur*> params;
+    for (Noeud* noeud : parametres) {
+        noeud->accepter(v);
+        params.push_back(v.getDerniereValeur());
+    }
+    p->empiler(params);
+    p->accepter(v);
+}
\ No newline at end of file
diff --git a/TableProcedures.h b/TableProcedures.h
new file mode 100644
index 0000000..6cb4489
--- /dev/null
+++ b/TableProcedures.h
@@ -0,0 +1,25 @@
+#ifndef TABLEPROCEDURES_H
+#define TABLEPROCEDURES_H
+
+#include <map>
+#include <vector>
+#include <string>
+#include "Symbole.h"
+#include "Procedure.h"
+#include "VisiteurExecuter.h"
+
+class TableProcedures {
+public:
+    static TableProcedures* getTable();
+    void ajoutProcedure(Symbole nom, Procedure* procedure);
+    void executerProcedure(Symbole nom, std::vector<Noeud*> parametres, VisiteurExecuter& v);
+private:
+    TableProcedures();
+    static TableProcedures* table;
+
+    std::vector<Procedure*> m_procedures;
+    std::vector<std::string> m_noms;
+};
+
+#endif /* TABLEPROCEDURES_H */
+
diff --git a/Valeur.h b/Valeur.h
new file mode 100644
index 0000000..82dd4da
--- /dev/null
+++ b/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 */
+
diff --git a/ValeurChaine.cpp b/ValeurChaine.cpp
new file mode 100644
index 0000000..75d8f1b
--- /dev/null
+++ b/ValeurChaine.cpp
@@ -0,0 +1,66 @@
+#include "ValeurChaine.h"
+#include "ValeurReelle.h"
+
+#include <string>
+
+ValeurChaine::ValeurChaine(std::string valeur) : m_valeur(valeur) {}
+
+bool ValeurChaine::isVrai() const {
+    return m_valeur.size() > 0;
+}
+
+int ValeurChaine::getEntier() const {
+    return std::stoi(m_valeur);
+}
+
+float ValeurChaine::getReel() const {
+    return std::stof(m_valeur);
+}
+
+std::string ValeurChaine::getChaine() const {
+    return m_valeur;
+}
+
+Valeur* const ValeurChaine::operator+(const Valeur* v) const {
+    return new ValeurChaine(m_valeur + v->getChaine());
+}
+
+Valeur* const ValeurChaine::operator-(const Valeur* v) const {
+    return new ValeurReelle(std::stof(m_valeur) - v->getReel());
+}
+
+Valeur* const ValeurChaine::operator*(const Valeur* v) const {
+    std::string val = "";
+    for (int i = 0; i < v->getEntier(); i++) {
+        val += m_valeur;
+    }
+    return new ValeurChaine(val);
+}
+
+Valeur* const ValeurChaine::operator/(const Valeur* v) const {
+    return new ValeurReelle(std::stof(m_valeur) / v->getReel());
+}
+
+bool ValeurChaine::operator>(const Valeur* v) const {
+    return m_valeur > v->getChaine();
+}
+
+bool ValeurChaine::operator>=(const Valeur* v) const {
+    return m_valeur >= v->getChaine();
+}
+
+bool ValeurChaine::operator<(const Valeur* v) const {
+    return m_valeur < v->getChaine();
+}
+
+bool ValeurChaine::operator<=(const Valeur* v) const {
+    return m_valeur <= v->getChaine();
+}
+
+bool ValeurChaine::operator==(const Valeur* v) const {
+    return m_valeur == v->getChaine();
+}
+
+bool ValeurChaine::operator!=(const Valeur* v) const {
+    return m_valeur != v->getChaine();
+}
\ No newline at end of file
diff --git a/ValeurChaine.h b/ValeurChaine.h
new file mode 100644
index 0000000..e9499b3
--- /dev/null
+++ b/ValeurChaine.h
@@ -0,0 +1,30 @@
+#ifndef VALEURCHAINE_H
+#define VALEURCHAINE_H
+
+#include "Valeur.h"
+#include <string>
+
+class ValeurChaine : public Valeur {
+public:
+    ValeurChaine(std::string 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:
+    std::string m_valeur;
+};
+
+#endif /* VALEURCHAINE_H */
+
diff --git a/ValeurEntiere.cpp b/ValeurEntiere.cpp
new file mode 100644
index 0000000..ac625a5
--- /dev/null
+++ b/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();
+}
\ No newline at end of file
diff --git a/ValeurEntiere.h b/ValeurEntiere.h
new file mode 100644
index 0000000..bf1d0a0
--- /dev/null
+++ b/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 */
+
diff --git a/ValeurReelle.cpp b/ValeurReelle.cpp
new file mode 100644
index 0000000..133dea1
--- /dev/null
+++ b/ValeurReelle.cpp
@@ -0,0 +1,61 @@
+#include "ValeurReelle.h"
+
+#include <string>
+
+ValeurReelle::ValeurReelle(float valeur) : m_valeur(valeur) {}
+
+bool ValeurReelle::isVrai() const {
+    return m_valeur != 0;
+}
+
+int ValeurReelle::getEntier() const {
+    return ((int) m_valeur);
+}
+
+float ValeurReelle::getReel() const {
+    return m_valeur;
+}
+
+std::string ValeurReelle::getChaine() const {
+    return std::to_string(m_valeur);
+}
+
+Valeur* const ValeurReelle::operator+(const Valeur* v) const {
+    return new ValeurReelle(m_valeur + v->getReel());
+}
+
+Valeur* const ValeurReelle::operator-(const Valeur* v) const {
+    return new ValeurReelle(m_valeur - v->getReel());
+}
+
+Valeur* const ValeurReelle::operator*(const Valeur* v) const {
+    return new ValeurReelle(m_valeur * v->getReel());
+}
+
+Valeur* const ValeurReelle::operator/(const Valeur* v) const {
+    return new ValeurReelle(m_valeur / v->getReel());
+}
+
+bool ValeurReelle::operator>(const Valeur* v) const {
+    return m_valeur > v->getReel();
+}
+
+bool ValeurReelle::operator>=(const Valeur* v) const {
+    return m_valeur >= v->getReel();
+}
+
+bool ValeurReelle::operator<(const Valeur* v) const {
+    return m_valeur < v->getReel();
+}
+
+bool ValeurReelle::operator<=(const Valeur* v) const {
+    return m_valeur <= v->getReel();
+}
+
+bool ValeurReelle::operator==(const Valeur* v) const {
+    return m_valeur == v->getReel();
+}
+
+bool ValeurReelle::operator!=(const Valeur* v) const {
+    return m_valeur != v->getReel();
+}
\ No newline at end of file
diff --git a/ValeurReelle.h b/ValeurReelle.h
new file mode 100644
index 0000000..74c7b51
--- /dev/null
+++ b/ValeurReelle.h
@@ -0,0 +1,30 @@
+#ifndef VALEURREELLE_H
+#define VALEURREELLE_H
+
+#include "Valeur.h"
+#include <string>
+
+class ValeurReelle : public Valeur {
+public:
+    ValeurReelle(float 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:
+    float m_valeur;
+};
+
+#endif /* VALEURREELLE_H */
+
diff --git a/Visiteur.h b/Visiteur.h
index 33a25bd..050546d 100644
--- a/Visiteur.h
+++ b/Visiteur.h
@@ -28,6 +28,8 @@ class Visiteur {
     virtual void visiterNoeudInstTantQue(NoeudInstTantQue* noeud) = 0;
     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;
 };
 
diff --git a/VisiteurCompiler.cpp b/VisiteurCompiler.cpp
index 13abcf7..9d59365 100644
--- a/VisiteurCompiler.cpp
+++ b/VisiteurCompiler.cpp
@@ -12,11 +12,6 @@ void VisiteurCompiler::visiterNoeudSeqInst(NoeudSeqInst* noeud) {
 }
 
 void VisiteurCompiler::visiterNoeudAffectation(NoeudAffectation* noeud) {
-    bool instructionSeule = true;
-    if (m_indentation < 0) {
-        instructionSeule = false;
-    }
-
     int indent = m_indentation;
     m_indentation = -1;
     noeud->getVariable()->accepter(*this);
@@ -24,7 +19,6 @@ void VisiteurCompiler::visiterNoeudAffectation(NoeudAffectation* noeud) {
     noeud->getExpression()->accepter(*this);
 
     m_indentation = indent;
-    if (instructionSeule) m_out << ";";
 }
 
 void VisiteurCompiler::visiterNoeudOperateurBinaire(NoeudOperateurBinaire* noeud) {
@@ -34,11 +28,11 @@ void VisiteurCompiler::visiterNoeudOperateurBinaire(NoeudOperateurBinaire* noeud
     
     m_out << "(";
     if (op == "non") {
-        m_out << "!";
+        m_out << "not ";
         noeud->getOperandeGauche()->accepter(*this);
     } else {
-        if (op == "et") op = "&&";
-        else if (op == "ou") op = "||";
+        if (op == "et") op = " and ";
+        else if (op == "ou") op = " or ";
 
         noeud->getOperandeGauche()->accepter(*this);
         m_out << op;
@@ -52,23 +46,22 @@ void VisiteurCompiler::visiterNoeudOperateurBinaire(NoeudOperateurBinaire* noeud
 void VisiteurCompiler::visiterNoeudInstSi(NoeudInstSi* noeud) {
     std::string indent(m_indentation * 4, ' ');
     if (noeud->getCondition() != nullptr) {
-        if (!noeud->isPremiereCondition()) { m_out << ' '; }
-        m_out << "if (";
+        m_out << "if ";
         int indentOrigine = m_indentation;
         m_indentation = -1;
         noeud->getCondition()->accepter(*this);
         m_indentation = indentOrigine;
-        m_out << ")";
+    } else {
+        m_out << "se";
     }
 
-    m_out << " {" << endl;
+    m_out << ":" << endl;
     m_indentation++;
     noeud->getSequence()->accepter(*this);
     m_indentation--;
-    m_out << indent << "}";
 
     if (noeud->getProchaineCondition() != nullptr) {
-        m_out << " else";
+        m_out << "el";
         noeud->getProchaineCondition()->accepter(*this);
     } else {
         m_out << endl;
@@ -77,73 +70,90 @@ void VisiteurCompiler::visiterNoeudInstSi(NoeudInstSi* noeud) {
 
 void VisiteurCompiler::visiterNoeudInstRepeter(NoeudInstRepeter* noeud) {
     std::string indent(m_indentation * 4, ' ');
-    m_out << "do {" << endl;
-    m_indentation++;
-    noeud->getSequence()->accepter(*this);
-    m_indentation--;
-    m_out << indent << "} while (!(";
+    m_out << indent << "transpilation_dowhile_boolean = 0" << endl;
+    m_out << "while not (";
     int indentOrigine = m_indentation;
     m_indentation = -1;
     noeud->getCondition()->accepter(*this);
     m_indentation = indentOrigine;
-    m_out << "));" << endl;
+    m_out << ") or transpilation_dowhile_boolean == 0:" << endl;
+    m_indentation++;
+    m_out << indent << "    transpilation_dowhile_boolean+=1" << endl;
+    noeud->getSequence()->accepter(*this);
+    m_indentation--;
 }
 
 void VisiteurCompiler::visiterNoeudInstPour(NoeudInstPour* noeud) {
     std::string indent(4 * m_indentation, ' ');
     int indentOrigine = m_indentation;
-    m_indentation = -1;
-    m_out << "for (";
+    
     if (noeud->getInit() != nullptr) noeud->getInit()->accepter(*this);
-    m_out << ";";
+    m_out << endl;
+    m_indentation = -1;
+    m_out << "while";
     noeud->getCondition()->accepter(*this);
-    m_out << ";";
-    if (noeud->getAffectation() != nullptr) noeud->getAffectation()->accepter(*this);
-    m_out << ") {" << endl;
+    m_out << ":" << endl;
     m_indentation = indentOrigine + 1;
     noeud->getSequence()->accepter(*this);
+    m_out << indent << "    ";
+    if (noeud->getAffectation() != nullptr) noeud->getAffectation()->accepter(*this);
     m_indentation--;
-    m_out << indent << "}" << endl;
 }
 
 void VisiteurCompiler::visiterNoeudInstTantQue(NoeudInstTantQue* noeud) {
     std::string indent(m_indentation * 4, ' ');
     m_out << "while " ;
     noeud->getCondition()->accepter(*this);
-    m_out << " {" << endl;
+    m_out << ":" << endl;
     m_indentation++;
     noeud->getSequence()->accepter(*this);
     m_indentation--;
-    m_out << indent << "}" << endl;
 }
 
 void VisiteurCompiler::visiterNoeudInstLire(NoeudInstLire* noeud) {
-    m_out << "std::cin";
+    std::string indent(m_indentation * 4, ' ');
     for (Noeud* var : noeud->getVariables()) {
-        m_out << " >> ";
-        int indent = m_indentation;
+        m_out << indent;
+        int currIndent = m_indentation;
         m_indentation = -1;
         var->accepter(*this);
-        m_indentation = indent;
+        m_indentation = currIndent;
+        m_out << " = input()" << endl;
     }
-
-    m_out << ";";
 }
 
 void VisiteurCompiler::visiterNoeudInstEcrire(NoeudInstEcrire* noeud) {
-    m_out << "std::cout";
+    std::string indent(m_indentation * 4, ' ');
+    bool first = true;
     for (Noeud* inst : noeud->getEcritures()) {
-        m_out << " << ";
-        if ((typeid (*inst) == typeid (SymboleValue) && *((SymboleValue*) inst) == "<CHAINE>")) {
-            m_out << ((SymboleValue*) inst)->getChaine();
-        } else {
-            int indent = m_indentation;
-            m_indentation = -1;
-            inst->accepter(*this);
-            m_indentation = indent;
-        }
+        if (first) m_out << "print(";
+        else m_out << indent << "print(";
+        
+        int currIndent = m_indentation;
+        m_indentation = -1;
+        inst->accepter(*this);
+        m_indentation = currIndent;
+        m_out << ", end = '')" << endl;
+        first = false;
     }
-    m_out << ";";
+    m_out << indent << "print('')" << endl;
+}
+
+void VisiteurCompiler::visiterNoeudInstAppel(NoeudInstAppel* noeud) {
+    m_out << noeud->getNom().getChaine() << "(";
+    for(int i = 0; i < noeud->getParametres().size(); i++) {
+        if (i != 0) { m_out << ", "; }
+        noeud->getParametres()[i]->accepter(*this);
+    }
+    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) {
diff --git a/VisiteurCompiler.h b/VisiteurCompiler.h
index 7b5d885..df75399 100644
--- a/VisiteurCompiler.h
+++ b/VisiteurCompiler.h
@@ -1,21 +1,9 @@
-/*
- * To change this license header, choose License Headers in Project Properties.
- * To change this template file, choose Tools | Templates
- * and open the template in the editor.
- */
-
-/* 
- * File:   VisiteurCompiler.h
- * Author: feelzor
- *
- * Created on October 30, 2019, 3:10 PM
- */
-
 #ifndef VISITEURCOMPILER_H
 #define VISITEURCOMPILER_H
 
 #include "Visiteur.h"
 
+// Cette classe permet de transpiler le code en Python3
 class VisiteurCompiler : public Visiteur {
 public:
     VisiteurCompiler(std::ostream& out, int indentation);
@@ -29,6 +17,8 @@ class VisiteurCompiler : public Visiteur {
     void visiterNoeudInstTantQue(NoeudInstTantQue* noeud) override;
     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:
diff --git a/VisiteurExecuter.cpp b/VisiteurExecuter.cpp
index 6c98456..ecd2d20 100644
--- a/VisiteurExecuter.cpp
+++ b/VisiteurExecuter.cpp
@@ -1,4 +1,6 @@
 #include "VisiteurExecuter.h"
+#include "ValeurEntiere.h"
+#include "TableProcedures.h"
 
 void VisiteurExecuter::visiterNoeudSeqInst(NoeudSeqInst* noeud) {
     for (unsigned int i = 0; i < noeud->getInstructions().size(); i++)
@@ -11,7 +13,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 +23,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;
 }
@@ -43,7 +45,7 @@ void VisiteurExecuter::visiterNoeudOperateurBinaire(NoeudOperateurBinaire* noeud
 void VisiteurExecuter::visiterNoeudInstSi(NoeudInstSi* noeud) {
     if (noeud->getCondition() != nullptr) {
         noeud->getCondition()->accepter(*this);
-        if (m_derniereValeur) {
+        if (m_derniereValeur->isVrai()) {
             noeud->getSequence()->accepter(*this);
         } else if (noeud->getProchaineCondition() != nullptr) {
             noeud->getProchaineCondition()->accepter(*this);
@@ -63,7 +65,7 @@ void VisiteurExecuter::visiterNoeudInstRepeter(NoeudInstRepeter* noeud) {
 void VisiteurExecuter::visiterNoeudInstPour(NoeudInstPour* noeud) {
     if (noeud->getInit() != nullptr) noeud->getInit()->accepter(*this);
     noeud->getCondition()->accepter(*this);
-    while (m_derniereValeur) {
+    while (m_derniereValeur->isVrai()) {
         noeud->getSequence()->accepter(*this);
         if (noeud->getAffectation() != nullptr) noeud->getAffectation()->accepter(*this);
         noeud->getCondition()->accepter(*this);
@@ -72,7 +74,7 @@ void VisiteurExecuter::visiterNoeudInstPour(NoeudInstPour* noeud) {
 
 void VisiteurExecuter::visiterNoeudInstTantQue(NoeudInstTantQue* noeud) {
     noeud->getCondition()->accepter(*this);
-    while (m_derniereValeur) {
+    while (m_derniereValeur->isVrai()) {
         noeud->getSequence()->accepter(*this);
         noeud->getCondition()->accepter(*this);
     }
@@ -96,17 +98,24 @@ void VisiteurExecuter::visiterNoeudInstLire(NoeudInstLire* noeud) {
 
 void VisiteurExecuter::visiterNoeudInstEcrire(NoeudInstEcrire* noeud) {
     for (Noeud* inst : noeud->getEcritures()) {
-        if ((typeid (*inst) == typeid (SymboleValue) && *((SymboleValue*) inst) == "<CHAINE>")) {
-            string s = ((SymboleValue*) inst)->getChaine();
-            cout << s.substr(1, s.size() - 2); // On retire le premier et le dernier caractère (les ")
-        } else {
-            m_derniereValeur = 0;
-            inst->accepter(*this);
-            cout << m_derniereValeur;
-        }
+        m_derniereValeur = 0;
+        inst->accepter(*this);
+        cout << m_derniereValeur;
     }
 }
 
+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();
diff --git a/VisiteurExecuter.h b/VisiteurExecuter.h
index cf3c12d..bdaa9f9 100644
--- a/VisiteurExecuter.h
+++ b/VisiteurExecuter.h
@@ -2,6 +2,7 @@
 #define VISITEUREXECUTER_H
 
 #include "Visiteur.h"
+#include "Valeur.h"
 
 class VisiteurExecuter : public Visiteur {
 public:
@@ -14,9 +15,13 @@ class VisiteurExecuter : public Visiteur {
     void visiterNoeudInstTantQue(NoeudInstTantQue* noeud) override;
     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; }
 private:
-    int m_derniereValeur = 0;
+    Valeur* m_derniereValeur;
 };
 
 #endif /* VISITEUREXECUTER_H */
diff --git a/main.cpp b/main.cpp
index 997fa4f..09ee76f 100644
--- a/main.cpp
+++ b/main.cpp
@@ -6,9 +6,12 @@ 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[]) {
+    srand (time(NULL));
     bool compile = false;
     string nomFich;
     ofstream o;
@@ -42,6 +45,7 @@ int main(int argc, char* argv[]) {
             cout << endl << "================ Syntaxe Correcte" << endl;
         } else {
             cout << endl << "================ Syntaxe Incorrecte" << endl;
+            return 1;
         }
         if (compile) {
             compiler(*out, interpreteur.getTable(), interpreteur.getArbre());
@@ -69,16 +73,7 @@ int main(int argc, char* argv[]) {
 }
 
 void compiler(ostream& out, const TableSymboles& symboles, Noeud* arbre) {
-    std::string indentationBasique(4, ' ');
-    out << "#include <iostream>" << endl << endl;
-    out << "int main() {" << endl;
-    for (int i = 0; i < symboles.getTaille(); i++) {
-        const SymboleValue s = symboles[i];
-        if (s == "<VARIABLE>") {
-            out << indentationBasique << "int " << s.getChaine() << ";" << endl;
-        }
-    }
-    VisiteurCompiler visiteur(out, 1);
+    out << "import random" << endl;
+    VisiteurCompiler visiteur(out, 0);
     arbre->accepter(visiteur);
-    out << "}" << endl;
 }
\ No newline at end of file
diff --git a/motsCles.txt b/motsCles.txt
index df58fd9..2699be0 100644
--- a/motsCles.txt
+++ b/motsCles.txt
@@ -33,3 +33,5 @@ ecrire
 et
 ou
 non
+appel
+alea
\ No newline at end of file
diff --git a/pom.txt b/pom.txt
new file mode 100644
index 0000000..a4068eb
--- /dev/null
+++ b/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
\ No newline at end of file
diff --git a/testSi.txt b/test01-SiSinonSi.txt
similarity index 100%
rename from testSi.txt
rename to test01-SiSinonSi.txt
diff --git a/testTantQue.txt b/test02-TantQue.txt
similarity index 100%
rename from testTantQue.txt
rename to test02-TantQue.txt
diff --git a/testRepeter.txt b/test03-Repeter.txt
similarity index 100%
rename from testRepeter.txt
rename to test03-Repeter.txt
diff --git a/testPour.txt b/test04-Pour.txt
similarity index 100%
rename from testPour.txt
rename to test04-Pour.txt
diff --git a/testEcrire.txt b/test05-Ecrire.txt
similarity index 100%
rename from testEcrire.txt
rename to test05-Ecrire.txt
diff --git a/testLire.txt b/test06-Lire.txt
similarity index 100%
rename from testLire.txt
rename to test06-Lire.txt
diff --git a/testPourErreurSyntaxe.txt b/test07-PourErreurSyntaxe.txt
similarity index 100%
rename from testPourErreurSyntaxe.txt
rename to test07-PourErreurSyntaxe.txt
diff --git a/test08-alea.txt b/test08-alea.txt
new file mode 100644
index 0000000..c744db8
--- /dev/null
+++ b/test08-alea.txt
@@ -0,0 +1,6 @@
+# Résultat attendu :
+# i : Nombre entre 1 et 100
+
+procedure principale()
+    i = alea(1, 100);
+finproc
diff --git a/test09-Procedure.txt b/test09-Procedure.txt
new file mode 100644
index 0000000..a80f3c6
--- /dev/null
+++ b/test09-Procedure.txt
@@ -0,0 +1,9 @@
+# Résultat attendu : 9
+
+procedure carre(a)
+    ecrire(a * a);
+finproc
+
+procedure principale()
+    appel carre(3);
+finproc
\ No newline at end of file
diff --git a/testAffectation.txt b/testAffectation.txt
index 6d6adb1..cb02f7f 100644
--- a/testAffectation.txt
+++ b/testAffectation.txt
@@ -2,9 +2,18 @@
 # Résultat attendu :
 # i = 6
 # j = 3
+# k = 2.3
+# l = 5.3
+# m = 5
+# n = BlaBlaCar
 procedure principale()
     i = 6;
     j = i / 2;
+    k = 2.3;
+    l = k + j;
+    m = j + k;
+    n = "Bla" * 2 + "Car";
+    o = alea(3, 100);
 finproc
 
 
diff --git a/tests/TestInstPour.cpp b/tests/TestInstPour.cpp
index ed66fb2..c09bb1c 100644
--- a/tests/TestInstPour.cpp
+++ b/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);
     }