Refactoring and starts to move to C++ 11. Add a first unit test to ac…

…company refactoring.
Sidoine · Jul 22, 2015 · 5f5345d · 5f5345d
1 parent b3a7a5b
commit 5f5345d
Show file tree

Hide file tree

Showing 30 changed files with 1,037 additions and 685 deletions.
diff --git a/.gitignore b/.gitignore
@@ -32,3 +32,7 @@ bin
 Debug
 *.vcxproj.user
 *.*sdf
+*.ncrunchsolution
+*.ncrunchsolution.user
+*.crunchsolution.cache
+*.ipch
diff --git a/boehmgc/include/gc_cpp.h b/boehmgc/include/gc_cpp.h
@@ -165,7 +165,11 @@ enum GCPlacement {UseGC,
                   NoGC, PointerFreeGC};
 
 class gc {public:
-    inline void* operator new( size_t size );
+	virtual ~gc()
+	{
+	}
+
+	inline void* operator new( size_t size );
     inline void* operator new( size_t size, GCPlacement gcp );
     inline void* operator new( size_t size, void *p );
     	/* Must be redefined here, since the other overloadings	*/

diff --git a/include/gotopp/gppmodule.h b/include/gotopp/gppmodule.h
@@ -146,6 +146,10 @@ namespace GotoPP
 	class IInterpreteur
 	{
 	public:
+		virtual ~IInterpreteur()
+		{
+		}
+
 		template<class T>
 		T Lire(){return (T)LireObjet();}
 
@@ -243,12 +247,16 @@ namespace GotoPP
 	class IProgramme
 	{
 	public:
+		virtual ~IProgramme()
+		{
+		}
+
 		virtual float GetVersion()=0;
-		virtual ISymbole * NouvelleClasseC(const carac *Nom, voidf allocateur, ISymbole * parent=0)=0;
-		virtual ISymbole * NouvelleMethodeC(voidf Fonc, const carac *Nom, ISymbole * parent=0)=0;
+		virtual ISymbole * NouvelleClasseC(const carac *Nom, voidf allocateur, ISymbole * parent=nullptr)=0;
+		virtual ISymbole * NouvelleMethodeC(voidf Fonc, const carac *Nom, ISymbole * parent=nullptr)=0;
 		/*virtual void NouvellePropriete(void *c, carac *Nom, int Prive, 
 			voidf FonctionLire, voidf FonctionEcrire)=0;*/
-		virtual ISymbole * NouvelleFonctionC(voidf Fonc, const carac *Nom, ISymbole * parent=0)=0;
+		virtual ISymbole * NouvelleFonctionC(voidf Fonc, const carac *Nom, ISymbole * parent=nullptr)=0;
 		//virtual int NouvelleVariable(const carac *Nom)=0;
 	};
 

diff --git a/include/gotopp/compilateur.h → include/gotopp/icompilateur.h b/include/gotopp/compilateur.h → include/gotopp/icompilateur.h
@@ -20,6 +20,10 @@ namespace GotoPP
 	class ICompilateur
 	{
 	public:
+		virtual ~ICompilateur()
+		{
+		}
+
 		virtual BoutCode* Charger(const carac * fichier)=0;//Charge et compile ce fichier
 		virtual BoutCode* Compiler(const carac *CodeSource)=0;//Compile ce code source
 

diff --git a/include/gotopp/machine.h b/include/gotopp/machine.h
@@ -64,6 +64,12 @@ namespace GotoPP
 
 	class CInterpreteur:public gc, public IInterpreteur
 	{
+	public:
+		~CInterpreteur() override 
+		{
+		}
+
+	private:
 		CPile Pile2;
 		index_t BasenParams;
 		tableauval * This;
@@ -98,7 +104,7 @@ namespace GotoPP
 		void Executer();
 		void ExecuterCatch(code * i);
 		void ExecuterCatch();
-		void ContenuPile();
+		// void ContenuPile();
 		void Sauver(FILE *F);
 		void Charger(FILE *F,int Taille);
 		void Reinit();
@@ -112,47 +118,48 @@ namespace GotoPP
 		void LireThis();
 		void AfficherErreur(CErreur & e);
 		void AfficherErreur(const carac *c);
+		void Depiler2(valeur & val);
 
 	public: //Implémentation de IInterpreteur
-		IObjet * GetThis();
-		virtual const chaineval * LireChaine();
-		virtual int LireEntier();
-		virtual float LireFlottant();
-		virtual void * LirePointeur();
-		virtual void * LireVariable(int v);
-		virtual IChaineA * LireChaineA();
-		virtual void FinParametres();
-		virtual IObjet * LireObjet();
-		virtual ITableauValeurs * LireTableauValeurs();
-		virtual regexp * LireRegExp();
-		virtual IValeur *LireValeur();
-		virtual entier64 LireEntier64();
-		virtual int GetNombreParametres();
+		IObjet * GetThis() override;
+		virtual const IChaine * LireChaine() override;
+		virtual int LireEntier() override;
+		virtual float LireFlottant() override;
+		virtual void * LirePointeur() override;
+		virtual void * LireVariable(int v) override;
+		virtual IChaineA * LireChaineA() override;
+		virtual void FinParametres() override;
+		virtual IObjet * LireObjet() override;
+		virtual ITableauValeurs * LireTableauValeurs() override;
+		virtual regexp * LireRegExp() override;
+		virtual IValeur *LireValeur() override;
+		virtual entier64 LireEntier64() override;
+		virtual int GetNombreParametres() override;
 
-		virtual void RetournerChaine(carac * c);
-		virtual void RetournerChaineA(char * c);
-		virtual void RetournerEntier(int i);
-		virtual void RetournerFlottant(float f);
-		virtual void RetournerIndefini();
-		virtual void RetournerChaine(const IChaine * chaine);
-		virtual void RetournerCarac(carac c);
-		virtual void RetournerTableauValeurs(ITableauValeurs * tableau);
-		virtual void RetournerEntier64(entier64 i);
-		virtual void RetournerObjet(IObjet * o);
+		virtual void RetournerChaine(carac * c) override;
+		virtual void RetournerChaineA(char * c) override;
+		virtual void RetournerEntier(int i) override;
+		virtual void RetournerFlottant(float f) override;
+		virtual void RetournerIndefini() override;
+		virtual void RetournerChaine(const IChaine * chaine) override;
+		virtual void RetournerCarac(carac c) override;
+		virtual void RetournerTableauValeurs(ITableauValeurs * tableau) override;
+		virtual void RetournerEntier64(entier64 i) override;
+		virtual void RetournerObjet(IObjet * o) override;
 
-		virtual void Modifier(void * p, IObjet * o);
-		virtual void Modifier(void * p, int i);
-		virtual void Modifier(void * p, carac * c);
-		virtual void Modifier(void * p, carac * c, int l);
+		virtual void Modifier(void * p, IObjet * o) override;
+		virtual void Modifier(void * p, int i) override;
+		virtual void Modifier(void * p, carac * c) override;
+		virtual void Modifier(void * p, carac * c, int l) override;
 #ifdef _UNICODE
-		virtual void Modifier(void * p, char * c, int l);
+		virtual void Modifier(void * p, char * c, int l) override;
 #endif
 
 		virtual void Ajouter(void *p, const chaineval * clef, const chaineval * val, size_t lval);
 
-		virtual void Exception(carac *Texte);
-		virtual void DebutParametres();
-		virtual void AppelerFonction(code* f);
+		virtual void Exception(carac *Texte) override;
+		virtual void DebutParametres() override;
+		virtual void AppelerFonction(code* f) override;
 	};
 
 	typedef void (CInterpreteur::*FonctionGPP)();

diff --git a/include/gotopp/pile.h b/include/gotopp/pile.h
@@ -26,6 +26,7 @@ Pile de valeurs
 
 #ifndef _PILE_H
 #define _PILE_H
+#include <gotopp/base.h>
 
 namespace GotoPP
 {

diff --git a/include/gotopp/programme.h b/include/gotopp/programme.h
@@ -1,9 +1,9 @@
-
 #ifndef _GPP_H
 #define _GPP_H
 
 #include "mutex.h"
 #include "gppmodule.h"
+#include <gotopp/base.h>
 
 namespace GotoPP
 {
@@ -17,7 +17,7 @@ namespace GotoPP
 	};
 
 	/// Les instructions de la machine virtuelle
-	enum Code
+	enum class Code : code
 	{
 		I_STOP,
 		I_DEFINIR,
@@ -198,7 +198,7 @@ namespace GotoPP
 	class Programme:public gc, public IProgramme
 	{
 	public://Implémentation de IProgramme
-		virtual float GetVersion();
+		virtual float GetVersion() override;
 		/*virtual Symbole * NouvellePropriete(carac *Nom, int Prive, 
 			voidf FonctionLire, voidf FonctionEcrire);*/
 		//virtual int NouvelleVariable(const carac *Nom);
@@ -219,36 +219,36 @@ namespace GotoPP
 		Symbole * symboleGlobal;
 
 		Symbole * NouvelleVariable(const carac *Nom, size_t lNom,
-								   CType type, Symbole * parent=0);
+								   CType type, Symbole * parent=nullptr);
 		Symbole * NouvelleVariable(const carac *Nom, CType type,
-								   Symbole * parent=0);
+								   Symbole * parent=nullptr);
 
 		Symbole * NouvelleVariable(const carac *Nom, Symbole * cl, 
-								   Symbole * parent=0);
+								   Symbole * parent=nullptr);
 
-		ISymbole * NouvelleFonctionC(voidf f,const carac *Nom, ISymbole * parent=0);
+		ISymbole * NouvelleFonctionC(voidf f,const carac *Nom, ISymbole * parent=nullptr) override;
 
-		ISymbole * NouvelleFonctionC(voidf f,const carac *Nom,carac*Type,ISymbole * parent=0);
+		ISymbole * NouvelleFonctionC(voidf f,const carac *Nom,carac*Type,ISymbole * parent=nullptr);
 
-		Symbole * NouveauSymbole(const carac *Nom, size_t lNom, CType type, Symbole * parent=0);
-		Symbole * ChercherClasse(const carac *Nom, Symbole * parent=0);
-		ISymbole * NouvelleClasseC(const carac *Nom, size_t lNom,voidf constructeur, ISymbole * parent=0);
-		ISymbole * NouvelleMethodeC(voidf Fonc, const carac *Nom,  ISymbole * parent=0);
+		Symbole * NouveauSymbole(const carac *Nom, size_t lNom, CType type, Symbole * parent=nullptr);
+		Symbole * ChercherClasse(const carac *Nom, Symbole * parent=nullptr);
+		ISymbole * NouvelleClasseC(const carac *Nom, size_t lNom,voidf constructeur, ISymbole * parent=nullptr);
+		ISymbole * NouvelleMethodeC(voidf Fonc, const carac *Nom,  ISymbole * parent=nullptr) override;
 		Symbole * NouvelleConstante(const carac *Nom, size_t lNom,
-										int val, Symbole * parent=0);
-		Symbole * NouvelleConstante(const carac * Nom, size_t lNom, Symbole * parent=0);
+										int val, Symbole * parent=nullptr);
+		Symbole * NouvelleConstante(const carac * Nom, size_t lNom, Symbole * parent=nullptr);
 
 		carac * NomVarGlob(index_t i);
 		carac * NomEtiquette(code *c);
 		void DefClasses();
 		void InitVarGlob();
 		code * ChercherEtiquette(int i);
 
-		ISymbole * NouvelleClasseC(const carac * Nom, voidf constructeur, ISymbole * parent=0)
+		ISymbole * NouvelleClasseC(const carac * Nom, voidf constructeur, ISymbole * parent=nullptr) override
 		{
 			return NouvelleClasseC(Nom,czlen(Nom),constructeur,parent);
 		}
-		Symbole * NouvelleConstante(const carac *Nom, int val, Symbole * parent=0)
+		Symbole * NouvelleConstante(const carac *Nom, int val, Symbole * parent=nullptr)
 		{
 			return NouvelleConstante(Nom,czlen(Nom),val,parent);
 		}

diff --git a/interpreteur/interne/divers.cpp b/interpreteur/interne/divers.cpp
@@ -34,7 +34,7 @@ Free Software Fundation, Inc.
 #endif
 
 #include <gotopp/base.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include <gotopp/programme.h>
 #include <gotopp/mutex.h>
 

diff --git a/interpreteur/interne/io.cpp b/interpreteur/interne/io.cpp
@@ -32,7 +32,7 @@ au syst�me (syst�me de fichiers, date...).
 #endif
 
 #include <gotopp/base.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include <gotopp/programme.h>
 #include <gotopp/mutex.h>
 

diff --git a/interpreteur/princ/desass.cpp b/interpreteur/princ/desass.cpp
@@ -27,7 +27,7 @@ approchant.
 #include <gotopp/base.h>
 #include <gotopp/programme.h>
 #include <gotopp/instruction.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include "gpp.h"
 
 
@@ -50,7 +50,7 @@ void Gpp::Desass(Programme *programme,bool UneLigne,  GotoPP::BoutCode & Ins)
 	while (!Ins.Fin())
 	{
 		code c=Ins.LireCode();
-		if (c==I_DEBUTLIGNE)
+		if (c == code(Code::I_DEBUTLIGNE))
 		{
 			nLignes++;
 			if (UneLigne && nLignes==2)
@@ -73,18 +73,17 @@ void Gpp::Desass(Programme *programme,bool UneLigne,  GotoPP::BoutCode & Ins)
 			{	
 			case TYPE_CARAC:
 				{
-					carac c=Ins.LireCarac();
-					if (byte(c)<32)
-						czoprintf(_T(" ^%c"),'A'+c);
+					carac caractere=Ins.LireCarac();
+					if (byte(caractere)<32)
+						czoprintf(_T(" ^%c"),'A'+caractere);
 					else
-						czoprintf(_T(" %c"),c);
+						czoprintf(_T(" %c"),caractere);
 					break;	
 				}
 			case TYPE_ETIQUETTE:
 				{
-					code * c=Ins.LireEtiquette();
-					czoprintf(_T(" :%p [%s]"),c,
-						programme->NomEtiquette(c));
+					code * code=Ins.LireEtiquette();
+					czoprintf(_T(" :%p [%s]"), code, programme->NomEtiquette(code));
 					break;
 				}
 			case TYPE_ENTIER:

diff --git a/interpreteur/princ/gpp.cpp b/interpreteur/princ/gpp.cpp
@@ -26,7 +26,7 @@ Bref, des heures d'amusement en perspective.
 
 */
 #include <gotopp/base.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include <gotopp/erreur.h>
 #include <gotopp/machine.h>
 #include <gotopp/programme.h>

diff --git a/src/commun/global.cpp b/src/commun/global.cpp
@@ -1,6 +1,6 @@
 #define DEFINITIONS
 #include <gotopp/base.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include <gotopp/programme.h>
 #include <gotopp/global.h>
 #include <time.h>

diff --git a/src/commun/outils.cpp b/src/commun/outils.cpp
@@ -37,7 +37,7 @@ programmes.
 #endif
 
 #include <gotopp/base.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include <gotopp/erreur.h>
 #include <gotopp/instruction.h>
 #include <gotopp/programme.h>

diff --git a/src/commun/programme.cpp b/src/commun/programme.cpp
@@ -1,5 +1,5 @@
 #include <gotopp/base.h>
-#include <gotopp/compilateur.h>
+#include <gotopp/icompilateur.h>
 #include <gotopp/programme.h>
 #include <gotopp/mutex.h>
 #include <gotopp/erreur.h>

diff --git a/src/compilateur/bloc.h b/src/compilateur/bloc.h
@@ -0,0 +1,44 @@
+#ifndef GOTOPP_COMPILATEUR_BLOC_H
+#define GOTOPP_COMPILATEUR_BLOC_H
+#include <gotopp/symbole.h>
+#include <gotopp/tableaux.h>
+#include <gc_cpp.h>
+
+namespace GotoPP
+{
+	struct LigneDeCode;
+
+	enum class TypeBloc
+	{
+		Si,
+		Sinon,
+		TantQue,
+		Switch,
+		Fonction,
+		Rien,
+		For,
+		ForEach,
+		Classe
+	};
+
+	struct Bloc : public gc
+	{
+		TypeBloc type;
+		bool blocLigne;
+		int depart;
+		Tableau<int> breaks;
+		Tableau<int> continues;
+		Symbole * symbole;
+
+		// L'espace de nommage parent était spécifié dans la définition du bloc, on doit le supprimer aussi
+		bool classeSpecifiee;
+
+		// Le i++ là dedans : for (i=0;i<10;i++)
+		LigneDeCode * pasDuFor;
+		Symbole * indice, *tableau, *iterateur;
+		Bloc() : blocLigne(false), classeSpecifiee(false), pasDuFor(nullptr)
+		{}
+	};
+}
+
+#endif