#include "Includes.h"// Inclus les fichiers...
#pragma comment(lib,"psapi.lib")
using namespace std;

ESTR* VarName[1000];//Création des variables de nom des variables.
ESTR* VarContent[1000];//Création des variables de contenu des variables.
ESTR* MacroName[18];//Création des variables de nom de macros.
ESTR* MacroContent[18];//Création des variables de contenu de macros.
ESTR* ReplaceName[1000];//Création des variables de nom de #replace.
ESTR* ReplaceContent[1000];//Création des variables de contenu de #replace.
ESTR* FuncName[1000];//Création des variables de nom de fonctions.
ESTR* FuncLinesAndFile[1000];//Création des variables de lignes et de fichiers de fonctions.
bool NO_NOTIFY_ERRORS = false;//Variable de notification d'erreur.
int LAST_FSP_SCRIPT_ERROR = 0;//Gestion d'erreur FSProg.
int CurrentLine = 0;//Déclaration d'autres variables...
int *CurrentLineOfCurrentFilePoint;//Pointeur vers le numéro de ligne du fichier.
int CurrentReplaceToCreate = 0;
int ReccursiveCall = 0;//Nombre d'appel de fonction récursives.
char *Parameters[10000];
int CurrentVarToCreate = 0;
int CurrentFuncToCreate = 0;
char *FileRunningPath;
char *ExeRunningPath;
char RealFileExec[255];//Fichier exécuté.
FILE *stdinfo = NULL;//Gestion du flux de sortie stdinfo...
bool StdInfoAlsoCreated = false;

int main(int argc, char *argv[])
{
	bool LastCondition = true;
	bool OriginalLastCondition = true;
	bool IsOnCondition = false;
	bool IsOnLoopWhile = false;
	bool IsOnLoopFor = false;
	bool IsThereAnyElseIf = false;
	char LastLoopCondition[1000];
	int StartOfLastLoop = 0;

	int CurrentLineOfCurrentFile = 0;
	CurrentLineOfCurrentFilePoint = &CurrentLineOfCurrentFile;
	int LStart = -1;
	int LEnd = -1;

	HWND CONSOLE_WINDOWS_HANDLE = GetConsoleWindow();
	
	if (argc != -1)//Cherche les paramètres...
	{
	
	//Réservé pour la compilation Fsp2Exe...
#ifdef FSP_PSEUDO_COMPILE_MODE

	char IsExe[100];
	if (argc >= 4)
	{
		strcpy(IsExe,argv[3]);
	} else {
		strcpy(IsExe,"0000");
	}
	if (! IsOnLeft(IsExe,"file-exe",0))
	{
		char *TempReturn = {getenv("TEMP")};//Récupère le dossier temporaire...
		char Param[10000];//Lance le fichier avec paramètres...
		if (argc >= 2)
		{
			strcat(TempReturn,"FSPTEMP.FSP");
			strcpy(Param,"\"");
			strcat(Param,TempReturn);
			strcat(Param,"\" \"");
			strcat(Param,argv[1]);
			strcat(Param,"\" \"file-exe\"");
		} else {
			strcat(TempReturn,"FSPTEMP.FSP");
			strcpy(Param,"\"");
			strcat(Param,TempReturn);
			strcat(Param,"\" \"0\" \"file-exe\"");
		}
		ExtractResource(10, TempReturn);
		ShellExecute(NULL,NULL,argv[0],Param,NULL,SW_SHOWNORMAL);
		return 0;		
	}
#endif

		if (argv[2] != NULL)
		{
			*Parameters = argv[2];
		} else {
			*Parameters = "0";
		}
	}

	if (argc != -1)
	{
		ShowWindow (CONSOLE_WINDOWS_HANDLE, FALSE);//Cache la fenêtre console.
		//Réservé pour la compilation Fsp2Cpp...
#ifdef FSP_PSEUDO_COMPILE_MODE
		FileRunningPath = argv[0];
#else
		FileRunningPath = argv[1];
#endif
		ExeRunningPath = argv[0];
		system("TITLE FSProg.exe>NUL");//Prépare la console.
		fprintf(GetStdInfoHandle(), "FSProg.exe\n\nVersion	%s\nBeta	%d\nDate	%s\n\n(C) Copyright 2012 LeCoindAide.com\n\nChargement en cours...\n\n", FSP_CURRENT_VERSION, FSP_IS_BETA, FSP_PRODUCT_DATE);
		fflush(NULL);
		
	} else {
		if (strstr(argv[1],"::"))//Cherche un appel de fonction...
		{

			char LStartChar[100], LEndChar[100], FFile[1000];
			sscanf(argv[1], "%[^::]::%[^::]::%[^\0]", &LStartChar, &LEndChar, &FFile);//Cherche les paramètres.

			sscanf(LStartChar, "%d", &LStart);//Transforme les types char* en int...
			sscanf(LEndChar, "%d", &LEnd);
			argv[1] = FFile;

		} else {
			fprintf(GetStdInfoHandle(), "\nLancement d'un fichier inclus...\n");
			fflush(NULL);
		}
	}
	
	if (argv[1] == NULL)//Verifie si un fichier est choisis...
	{
		std::string NewFile = openfilename("Fichiers FSProg (*.fsp)\0*.fsp\0", NULL);//Ouvre une fenêtre de choix de fichier...
		char *NewFileChar[] = {(char*)NewFile.c_str()};
		if (*NewFileChar[0] == '\0') {exit (0);}
		if (argc >= 3)
		{
			char Param[10000];//Lance le fichier avec paramètres...
			strcpy(Param,"\"");
			strcat(Param,*NewFileChar);
			strcat(Param,"\" \"");
			strcat(Param,argv[2]);
			strcat(Param,"\"");
			ShellExecute(NULL,NULL,argv[0],Param,NULL,SW_SHOWNORMAL);
		} else {
			char Param[10000];//Lance le fichier avec paramètres...
			strcpy(Param,"\"");
			strcat(Param,*NewFileChar);
			strcat(Param,"\"");
			ShellExecute(NULL,NULL,argv[0],Param,NULL,SW_SHOWNORMAL);
		}
		return 0;
	}

	strcpy(RealFileExec,argv[1]);//Nom du fichier exécuté (pour "ExitErrLog()").

	FILE* FileOpen = NULL;//Ouvre le fichier...
	FileOpen = fopen(argv[1], "r");
	
	if (!FileOpen)//Verifie si le fichier a été ouvert...
	{
		if (argc != -1)//Affiche un message si le fichier n'a pas été inclus...
		{
			MessageBox(NULL,"Erreur !\n\nLe fichier choisis n'existe pas ou est indisponnible !","FSProg erreur !",16);
		}
		return 0;
	}

	char LineContent[10000] = {NULL};//Déclaration des variables...
	int i = 0, LineNumber = FCountLines(argv[1]);

	if (argc != -1)
	{
		for (i = 0; i < 1000; i++)//Initialisation des variables de nom et de de contenu des variables...
		{
			VarName[i]=InitESTR();
			VarContent[i]=InitESTR();
			ReplaceName[i]=InitESTR();
			ReplaceContent[i]=InitESTR();
			FuncName[i]=InitESTR();
			FuncLinesAndFile[i]=InitESTR();
		}
		i = 0;//Réinitialisation de la variable i.
	}
	
	if (LineNumber == -1)
	{
		if (argc != -1)//Affiche un message si le fichier n'a pas été inclus...
		{
			MessageBox(NULL,"Erreur !\n\nImpossible de lire dans le fichier !","FSProg erreur !",16);
		}
		fclose(FileOpen);
		return 0;
	}
	
	bool IsOnFunc = false;

	if (LStart != -1)//Si on lance une fonction, se rend à la bonne ligne...
	{
		while (LStart-1 > CurrentLineOfCurrentFile)
		{
			fgets(LineContent, 10000, FileOpen);
			CurrentLineOfCurrentFile++;
		}
		IsOnFunc = true;
	}

	char LineContentCpy[10000];

	while (fgets(LineContent, 10000, FileOpen) != NULL && (IsOnFunc == true || LStart == -1) )//Boucle de lecture de toutes les lignes...
	{
		//Vide la mémoire...
		EmptyWorkingSet(GetCurrentProcess());

		CurrentLine++;
		CurrentLineOfCurrentFile++;
		strcpy(LineContentCpy,LineContent);//Crée une copie de la variable (pour #isReplace).

		if (IsOnFunc == true)//Cherche la fin d'une func...
		{
			if (CurrentLineOfCurrentFile > LEnd)
				return 0;
		}
		
		DelBlankLeftChars(LineContent);
		if (LastCondition == false && (IsOnCondition == true || IsOnLoopWhile == true || IsOnLoopFor == true) && ! IsOnLeft(LineContent,"}",0))//Supprime la ligne si il y a condition fausse...
		{
			strcpy(LineContent, "//");
		}

		for ( i = 0; i < 1000; i++)//Cherche les #replace...
		{
			if (ESTR_PTRC(ReplaceName[i])[0] != NULL)
			{
				strcpy(LineContent,replace(LineContent, ESTR_PTRC(ReplaceName[i]), ESTR_PTRC(ReplaceContent[i])));//Les remplaces par leur valeur...
			}
		}
		
		i = 0;

		int ReturnFunc = CheckFunc(LineContent);//Cherche l'ID de la fonction...
		if (ReturnFunc == 0)//Cherche une fonction utilisateur...
		{
			char Func[1000];
			if (IsOnLeft(LineContent," ",0))//Supprime les espaces ou tabuations...
			{
				sscanf(LineContent, " %[^\n]", &Func);//Cherche le nom de fonction.
			} else if (IsOnLeft(LineContent,"	",0)) {
				sscanf(LineContent, "	%[^\n]", &Func);//Cherche le nom de fonction.
			} else {
				sscanf(LineContent, "%[^\n]", &Func);//Cherche le nom de fonction.
			}

			int FuncEx = FuncExist(Func);
			if (FuncEx != -1)
			{

				fprintf(GetStdInfoHandle(), "Appel de la fonction supplementaire \"%s\"\n", Func);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				char* argvTmp[2] = {NULL,{ESTR_PTRC(FuncLinesAndFile[FuncEx])}};//Crée argv.
				
				char RealFileExecCpy[255];//Sauvegarde les variables...
				strcpy(RealFileExecCpy,RealFileExec);
				int *CurrentLineOfCurrentFilePointCpy = CurrentLineOfCurrentFilePoint;

				ReccursiveCall++;
				if (ReccursiveCall >= 3) {//Cherche les appels recursifs trop nombreux...
					fprintf(GetStdInfoHandle(), "Erreur : Appel récursif de plus de 2 fonctions à la ligne %d !\nL'exécution du script va être arrêté !",CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
					fflush(NULL);
					if(!NO_NOTIFY_ERRORS) {
						char MsgErrConsole[1000] = {"Erreur : Appel récursif de plus de 2 fonctions à la ligne "};
						char CurrentLineChar[1000];//Converti du int en char*...
						sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
						strcat(MsgErrConsole,CurrentLineChar);
						strcat(MsgErrConsole," !\n\nL'exécution du script va être arrêté !");
						MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					}
					ExitErrLog(410);
				}

				main(-1,argvTmp);//Exécute la fonction.

				ReccursiveCall--;

				strcpy(RealFileExec,RealFileExecCpy);//Réstaure les variables.
				CurrentLineOfCurrentFilePoint = CurrentLineOfCurrentFilePointCpy;
				
				fprintf(GetStdInfoHandle(), "Fin d'appel de la fonction.\n\n", Func);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				
			} else {
				fprintf(GetStdInfoHandle(), "Attention, aucune fonction trouvée à la ligne %d!\n\n", CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrNoFunc[1000] = {"Attention, aucune fonction trouvée à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrNoFunc,CurrentLineChar);
					strcat(MsgErrNoFunc," !");
					MessageBox(NULL,MsgErrNoFunc,"FSProg erreur",48);//Erreur si aucune fonction trouvée...
				}
			}
		} else if (ReturnFunc == 94){
			fclose(FileOpen);
			exit(94);//Quitte le script en renvoyant 94.

		} else if (ReturnFunc == 11) {Dinclude(LineContent);//Recherche des directives...
		} else if (ReturnFunc == 12) {Dreplace(LineContent);
		} else if (ReturnFunc == 13) {NO_NOTIFY_ERRORS = true;
		} else if (ReturnFunc == 14) {//#isReplace
			char Void[1000], ReplaceToFound[1000], VarToSet[1000];
			sscanf(LineContentCpy, "%[^ ] %[^ ] %[^\n]", &Void, &ReplaceToFound, &VarToSet);//Cherche les paramètres.
			if (ReplaceExist(ReplaceToFound) == -1)
			{
				int IsReplace = 0;
				strcpy(LineContent,VarToSet);//Modifie pour définition de la variable...
				strcat(LineContent,"=0");
			} else {
				int IsReplace = 1;
				strcpy(LineContent,VarToSet);//Modifie pour définition de la variable...
				strcat(LineContent,"=1");
			}
			char VarNameToGet[100], VarContentToGet[10000];//Définis la variable...
			if (IsOnLeft(LineContent,"$",0))
			{
				sscanf(LineContent, "$%[^;];=%[^\n]", &VarNameToGet, &VarContentToGet);//Recherche du nom de variable et du contenu et inscription dans la variables des variables...
			} else {
				sscanf(LineContent, "%[^$]$%[^;];=%[^\n]", &Void, &VarNameToGet, &VarContentToGet);//Recherche du nom de variable et du contenu et inscription dans la variables des variables...
			}
			StringParser(VarContentToGet);//Execute et modifie les chaines...
			AdSpecialChar(VarContentToGet);//Ajoute les caractères de remplacement.
			VarSetData( VarNameToGet, VarContentToGet);//Définis la variable.
			
/*
		} else if (ReturnFunc == 141) {//Fonction console() particulière.
			char Void[1000], Par1[1000];
			sscanf(LineContent, "%[^(](%[^)]", &Void, &Par1);//Cherche le premier paramètre.
			if (IsOnLeft(Par1,"show",0))
			{
				ShowWindow (CONSOLE_WINDOWS_HANDLE, TRUE);//Affiche la fenêtre console.
			} else if (IsOnLeft(Par1,"hide",0))
			{
				ShowWindow (CONSOLE_WINDOWS_HANDLE, FALSE);//Cache la fenêtre console.
			} else {
				fprintf(GetStdInfoHandle(), "Erreur : console() paramètre \"%ds\" invalide à la ligne %d !",Par1,CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : console() paramètre \""};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,Par1);
					strcat(MsgErrConsole,"\" invalide à la ligne ");
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
				}
			}
	*/		
		} else if (ReturnFunc == 162) {//Fonction return...
			if (IsOnFunc == true) {
				return 0;
			} else {
				fprintf(GetStdInfoHandle(), "Erreur : return appelé en dehors d'une fonction à la ligne %d !",CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : return appelé en dehors d'une fonction à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
				}
				ExitErrLog(162);
			}

		} else if (ReturnFunc == 144) {//Fonction cGet()...
			char ReturnStdIn[10000];
			scanf("%s", ReturnStdIn);

		} else if (ReturnFunc == 20) {//Déclaration de variables...
			char Void[1000], VarNameToGet[100], VarContentToGet[10000];
			if (IsOnLeft(LineContent,"$",0))
			{
				sscanf(LineContent, "$%[^;];=%[^\n]", &VarNameToGet, &VarContentToGet);//Recherche du nom de variable et du contenu et inscription dans la variables des variables...
			} else {
				sscanf(LineContent, "%[^$]$%[^;];=%[^\n]", &Void, &VarNameToGet, &VarContentToGet);//Recherche du nom de variable et du contenu et inscription dans la variables des variables...
			}
			StringParser(VarContentToGet);//Execute et modifie les chaines...
			AdSpecialChar(VarContentToGet);//Ajoute les caractères de remplacement.
			VarSetData( VarNameToGet, VarContentToGet);//Définis la variable.
			//ESTR_PTRC(VarContent[0])//Convertir un pointeur ESTR en char

		} else if (ReturnFunc == 410) {//Cherche les func...

			char Void[1000], FuncNameToGet[100];
			sscanf(LineContent, "%[^ ] %[^\n]", &Void, &FuncNameToGet);//Recherche du nom de fonction...

			int StartFunc = 0;
			int CurrentLineSave = CurrentLine;
			StartFunc = CurrentLineOfCurrentFile+1;

			bool CloseFind = false;//Cherche la fermeture de fonction...
			int EndFunc = 0;
			while (!CloseFind)
			{
				if (fgets(LineContent, 10000, FileOpen) == NULL)
				{
					fprintf(GetStdInfoHandle(), "Erreur : \"endF\" non trouvé avant la fin du fichier !\nL'execution du script va etre arrete !");//Ecrit dans le flux stdinfo.
					fflush(NULL);
						
					if(!NO_NOTIFY_ERRORS)
					{
						MessageBox(NULL,"Erreur : \"endF\" non trouvé avant la fin du fichier !\n\nL'éxécution du script va être arrêté !","FSProg erreur",16);
						fclose(FileOpen);
					}
					ExitErrLog(410);
				}
				CurrentLine++;
				CurrentLineOfCurrentFile++;
				if (IsOnLeft(LineContent,"endF",0))
				{
					CloseFind = true;
					EndFunc = CurrentLineOfCurrentFile-1;
				}
			}

			int FuncEx = FuncExist(FuncNameToGet);
			if (FuncEx == -1)//Si la fonction n'existe pas...
			{
				if (CurrentFuncToCreate == 1000)//Cherche si le nombre n'est pas dépassé...
				{
					fprintf(GetStdInfoHandle(), "Erreur : nombre de fonction dépassé à la ligne %s !\nL'exécution du script va être arrêté.", CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
					fflush(NULL);
					
					if(!NO_NOTIFY_ERRORS)
					{
						char MsgErrConsole[1000] = {"Erreur : nombre de fonction dépassé à la ligne "};
						char CurrentLineChar[1000];//Converti du int en char*...
						sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
						strcat(MsgErrConsole,CurrentLineChar);
						strcat(MsgErrConsole," !\nLe script va être arrêté.");
						MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					}
					ExitErrLog(1);
				}

				EsCpy(FuncName[CurrentFuncToCreate], FuncNameToGet);//Alloue la mémoire pour le nom de foncion...
				
				char Temp[1000];
				char TempToChar[1000];//Converti du int en char*...
				sprintf (TempToChar, "%d", StartFunc);
				strcpy(Temp,TempToChar);
				strcat(Temp,"::");
				sprintf (TempToChar, "%d", EndFunc);//Converti du int en char*.
				strcat(Temp,TempToChar);
				strcat(Temp,"::");
				strcat(Temp,argv[1]);
				EsCpy(FuncLinesAndFile[CurrentFuncToCreate], Temp);
				CurrentFuncToCreate++;
				fprintf(GetStdInfoHandle(), "Enregistrement de la fonction \"%s\" avec comme paramètres \"%s\".\n\n",ESTR_PTRC(FuncName[CurrentFuncToCreate-1]), ESTR_PTRC(FuncLinesAndFile[CurrentFuncToCreate-1]));
				fflush(NULL);
				
			} else {//Si elle existe...
				fprintf(GetStdInfoHandle(), "Erreur : fonction \"%s\" créée une seconde fois à la ligne %d !\nL'exécution du script va être arrêté.", FuncNameToGet, CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Fonction \""};
					strcat(MsgErrConsole,FuncNameToGet);
					strcat(MsgErrConsole,"\" créée une seconde fois à la ligne ");
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(410);
			}

		} else if (ReturnFunc == 96) {//Cherche les "endF"...
			fprintf(GetStdInfoHandle(), "Erreur : endF appelé sans ouverture à la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
			fflush(NULL);
			
			if(!NO_NOTIFY_ERRORS) {
				char MsgErrConsole[1000] = {"Erreur : endF appelé sans ouverture à la ligne "};
				char CurrentLineChar[1000];//Converti du int en char*...
				sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
				strcat(MsgErrConsole,CurrentLineChar);
				strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
				MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
				fclose(FileOpen);
			}
			ExitErrLog(96);

		} else if (ReturnFunc == 131){//Conditions if...
			fprintf(GetStdInfoHandle(), "Recherche d'une possible condition \"if\"...\n");
			fflush(NULL);
			if (IsOnCondition == true)//Vérifie si n'est pas déjà dans une condition...
			{
				fprintf(GetStdInfoHandle(), "Erreur : Condition \"if\" appelé avant la fin de la premiere condition à la ligne %d !\nL'exécution du script va être arrêté.", CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Condition \"if\" appelé avant la fin de la première condition à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(131);
			} else {
				char Void[1000], Condition[10000];
				sscanf(LineContent, "%[^(](%[^)]", &Void, &Condition);//Recherche la condition.
				fprintf(GetStdInfoHandle(), "Condition accépté avec paramètres : \"%s\".\n",Condition);
				fflush(NULL);
				IsThereAnyElseIf = false;
				if (IsTrue(Condition))//Vérifie la condition...
				{
					LastCondition = true;
					OriginalLastCondition = true;
					fprintf(GetStdInfoHandle(), "Condition valide.\nExécution des lignes suivantes...\n");
					fflush(NULL);
				} else {
					LastCondition = false;
					OriginalLastCondition = false;
					fprintf(GetStdInfoHandle(), "Condition invalide.\nPas d'exécution des lignes suivantes...\n");
					fflush(NULL);
				}

				while (!IsOnCondition)
				{
					char *fGetsChar = fgets(LineContent, 10000, FileOpen);
					DelBlankLeftChars(LineContent);
					if (fGetsChar == NULL || IsOnLeft(LineContent,"}",0))//Lit une autre ligne...
					{
						fprintf(GetStdInfoHandle(), "Erreur : { non trouvé avant l'appel de fin de condition ou  avant la fin du fichier !\nL'exécution du script va être arrêté.");//Ecrit dans le flux stdinfo.
						fflush(NULL);
							
						if(!NO_NOTIFY_ERRORS)
						{
							MessageBox(NULL,"Erreur : { non trouvé avant l'appel de fin de condition ou avant la fin du fichier !\n\nL'éxécution du script va être arrêté !","FSProg erreur",16);
							fclose(FileOpen);
						}
						ExitErrLog(131);
					}
					CurrentLine++;
					CurrentLineOfCurrentFile++;
					if (IsOnLeft(LineContent,"{",0))
					{
						IsOnCondition = true;
					}
				}
			}
			fprintf(GetStdInfoHandle(), "\n");
			fflush(NULL);

		} else if (ReturnFunc == 91) {//Conditions else...
			fprintf(GetStdInfoHandle(), "Recherche d'une possible condition \"else\"...\n");
			fflush(NULL);
			if (IsOnCondition == true)//Vérifie si n'est pas déjà dans une condition...
			{
				fprintf(GetStdInfoHandle(), "Erreur : Condition \"else\" appelé avant la fin de la premiere condition à la ligne %d !\nL'exécution du script va être arrêté.", CurrentLineOfCurrentFile);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Condition \"else\" appelé avant la fin de la première condition à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(91);
			} else {
				fprintf(GetStdInfoHandle(), "Condition accépté sans paramètres.\n");
				fflush(NULL);
				while (!IsOnCondition)
				{
					char *fGetsChar = fgets(LineContent, 10000, FileOpen);
					DelBlankLeftChars(LineContent);
					if (fGetsChar == NULL || IsOnLeft(LineContent,"}",0))//Lit une autre ligne...
					{
						fprintf(GetStdInfoHandle(), "Erreur : { non trouvé avant l'appel de fin de condition ou avant la fin du fichier !\nL'exécution du script va être arrêté.", CurrentLine);//Ecrit dans le flux stdinfo.
						fflush(NULL);
						if(!NO_NOTIFY_ERRORS)
						{
							MessageBox(NULL,"Erreur : { non trouvé avant l'appel de fin de condition ou avant la fin du fichier !\n\nL'éxécution du script va être arrêté !","FSProg erreur",16);
							fclose(FileOpen);
						}
						ExitErrLog(91);
					}
					CurrentLine++;
					CurrentLineOfCurrentFile++;
					if (IsOnLeft(LineContent,"{",0))
					{
						IsOnCondition = true;
						if (!IsThereAnyElseIf)//Vérifie si aucun else/elseIf n'as déjà été appelé...
						{
							if (OriginalLastCondition == true)//Inverse la condition...
							{
								LastCondition = false;
								fprintf(GetStdInfoHandle(), "Condition invalide.\nPas d'exécution des lignes suivantes...\n");
								fflush(NULL);
							} else {
								LastCondition = true;
								IsThereAnyElseIf = true;
								fprintf(GetStdInfoHandle(), "Condition valide.\nExécution des lignes suivantes...\n");
								fflush(NULL);
							}
						} else {
							LastCondition = false;
							fprintf(GetStdInfoHandle(), "Condition invalide.\nPas d'exécution des lignes suivantes...\n");
							fflush(NULL);
						}
					}
				}
			}
			fprintf(GetStdInfoHandle(), "\n");
			fflush(NULL);

		} else if (ReturnFunc == 92) {//Conditions elseIf...
			fprintf(GetStdInfoHandle(), "Recherche d'une possible condition \"elseIf\"...\n");
			fflush(NULL);
			if (IsOnCondition == true)//Vérifie si n'est pas déjà dans une condition...
			{
				fprintf(GetStdInfoHandle(), "Erreur : Condition \"elseIf\" appelé avant la fin de la premiere condition à la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Condition \"elseIf\" appelé avant la fin de la première condition à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(92);
			} else {
				char Void[1000], Condition[10000];
				sscanf(LineContent, "%[^(](%[^)]", &Void, &Condition);//Recherche la condition.
				fprintf(GetStdInfoHandle(), "Condition accepté avec paramètres : \"%s\".\n",Condition);
				fflush(NULL);
				
				if (!IsThereAnyElseIf)
				{
					if (OriginalLastCondition == false)
					{
						if (IsTrue(Condition))//Vérifie la condition...
						{
							LastCondition = true;
							IsThereAnyElseIf = true;
							fprintf(GetStdInfoHandle(), "Condition valide.\nExécution des lignes suivantes...\n");
							fflush(NULL);
						} else {
							LastCondition = false;
							fprintf(GetStdInfoHandle(), "Condition invalide.\nPas d'exécution des lignes suivantes...\n");
							fflush(NULL);
						}
					} else {
						LastCondition = false;
						fprintf(GetStdInfoHandle(), "Condition invalide.\nPas d'exécution des lignes suivantes...\n");
						fflush(NULL);
					}
				} else {
					LastCondition = false;
					fprintf(GetStdInfoHandle(), "Condition invalide.\nPas d'exécution des lignes suivantes...\n");
					fflush(NULL);
				}

				while (!IsOnCondition)
				{
					char *fGetsChar = fgets(LineContent, 10000, FileOpen);
					DelBlankLeftChars(LineContent);
					if (fGetsChar == NULL || IsOnLeft(LineContent,"}",0))//Lit une autre ligne...
					{
						fprintf(GetStdInfoHandle(), "Erreur : { non trouvé avant l'appel de fin de condition ou avant la fin du fichier !\nL'exécution du script va être arrêté.");
						fflush(NULL);
							
						if(!NO_NOTIFY_ERRORS)
						{
							MessageBox(NULL,"Erreur : { non trouvé avant l'appel de fin de condition ou avant la fin du fichier !\n\nL'éxécution du script va être arrêté !","FSProg erreur",16);
							fclose(FileOpen);
						}
						ExitErrLog(131);
					}
					CurrentLine++;
					CurrentLineOfCurrentFile++;
					if (IsOnLeft(LineContent,"{",0))
					{
						IsOnCondition = true;
					}
				}
			}
			fprintf(GetStdInfoHandle(), "\n");
			fflush(NULL);

		} else if (ReturnFunc == 111) {//Boucles while...
			fprintf(GetStdInfoHandle(), "Recherche d'une possible boucle \"while\"...\n");
			fflush(NULL);
			if (IsOnLoopWhile == true)//Vérifie si n'est pas déjà dans une boucle...
			{
				fprintf(GetStdInfoHandle(), "Erreur : Boucle \"while\" appelé avant la fin de boucle a la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Boucle \"while\" appelé avant la fin de boucle à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(111);
			} else {
				char Void[1000], Condition[10000];
				sscanf(LineContent, "%[^(](%[^)]", &Void, &Condition);//Recherche la condition.
				strcpy(LastLoopCondition,Condition);//Crée une copie de la condition.
				fprintf(GetStdInfoHandle(), "Boucle accepté avec paramètres : \"%s\".\n",Condition);
				fflush(NULL);
			
				if (IsTrue(Condition))
				{
					IsOnLoopWhile = true;
					StartOfLastLoop = CurrentLineOfCurrentFile+1;
				} else {
					IsOnLoopWhile = true;
					LastCondition = false;
				}
			}
			fprintf(GetStdInfoHandle(), "\n");
			fflush(NULL);

		} else if (ReturnFunc == 41) {//Boucles for...
			fprintf(GetStdInfoHandle(), "Recherche d'une possible boucle \"for\"...\n");
			fflush(NULL);
			if (IsOnLoopFor == true)//Vérifie si n'est pas déjà dans une boucle...
			{
				fprintf(GetStdInfoHandle(), "Erreur : Boucle \"for\" appelé avant la fin de boucle a la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Boucle \"for\" appelé avant la fin de boucle à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(41);
			} else {
				char Void[1000], Var[1000], Condition[10000], Increment[1000];
				sscanf(LineContent, "%[^(](%[^,],%[^,],%[^)]", &Void, &Var, &Condition, &Increment);//Recherche la condition.
				strcpy(LastLoopCondition,LineContent);//Crée une copie de la ligne.
				
				char VarNameToGet[100], VarContentToGet[10000];//Déclare la variable....
				sscanf(Var, "$%[^;];=%[^\0]", &VarNameToGet, &VarContentToGet);//Recherche du nom de variable et du contenu et inscription dans la variables des variables...
				StringParser(VarContentToGet);//Execute et modifie les chaines...
				AdSpecialChar(VarContentToGet);//Ajoute les caractères de remplacement.
				VarSetData( VarNameToGet, VarContentToGet);//Définis la variable.

				if (IsTrue(Condition))
				{
		
					IsOnLoopFor = true;
					StartOfLastLoop = CurrentLineOfCurrentFile+1;
				} else {
					IsOnLoopFor = true;
					LastCondition = false;
				}
			}
			fprintf(GetStdInfoHandle(), "\n");
			fflush(NULL);

		} else if (ReturnFunc == 93) {//Sortie de boucle exitLoop...
			if (IsOnLoopWhile == true)
			{
				
				IsOnLoopWhile = false;
				LastCondition = true;
				OriginalLastCondition = true;
				IsOnCondition = false;
				IsThereAnyElseIf = false;
				bool EndWFound = false;
				while (!EndWFound)
				{
					CurrentLine++;
					CurrentLineOfCurrentFile++;
					fgets(LineContent, 10000, FileOpen);
					DelBlankLeftChars(LineContent);
					if (IsOnLeft(LineContent,"endW",0)) {EndWFound = true;}
				}
				fprintf(GetStdInfoHandle(), "Fin de la boucle \"while\" par \"exitLoop\".\n\n");
				fflush(NULL);
				
			} else if (IsOnLoopFor == true) {
				
				IsOnLoopFor = false;
				LastCondition = true;
				OriginalLastCondition = true;
				IsOnCondition = false;
				IsThereAnyElseIf = false;
				bool NextFound = false;
				while (!NextFound)
				{
					CurrentLine++;
					CurrentLineOfCurrentFile++;
					fgets(LineContent, 10000, FileOpen);
					DelBlankLeftChars(LineContent);
					if (IsOnLeft(LineContent,"next",0)) {NextFound = true;}
				}
				fprintf(GetStdInfoHandle(), "Fin de la boucle \"for\" par \"exitLoop\".\n\n");
				fflush(NULL);
				
			} else {
				fprintf(GetStdInfoHandle(), "Attention : \"exitLoop\" appelé sans boucle à la ligne %d !\n",CurrentLineOfCurrentFile);
				fflush(NULL);
				
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Attention : \"exitLoop\" appelé sans boucle à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !");
					MessageBox(NULL,MsgErrConsole,"FSProg : Avertissement",48);
					fclose(FileOpen);
				}
				ExitErrLog(150);
			}

		} else if (ReturnFunc == 150) {//Fin de conditions...
			if (IsOnCondition) {
				IsOnCondition = false;
				LastCondition = true;
				fprintf(GetStdInfoHandle(), "Fin de la condition.\n\n");
				fflush(NULL);
			} else {
				fprintf(GetStdInfoHandle(), "Erreur : } appelé sans ouverture à la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
				fflush(NULL);
				
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : } appelé sans ouverture à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(150);
			}
		} else if (ReturnFunc == 95) {//Fin des boucles while...
			if (IsOnLoopWhile)
			{
				if (IsTrue(LastLoopCondition))
				{
					CurrentLine = CurrentLine-CurrentLineOfCurrentFile;//Retourne au début du fichier...
					CurrentLineOfCurrentFile = 1;
					fseek(FileOpen,0,SEEK_SET);
					while (CurrentLineOfCurrentFile < StartOfLastLoop)//Retourne au début de la boucle...
					{
						CurrentLine++;
						CurrentLineOfCurrentFile++;
						fgets(LineContent, 10000, FileOpen);
					}
					CurrentLine--;
					CurrentLineOfCurrentFile--;
					fprintf(GetStdInfoHandle(), "Retour au début de la boucle \"while\".\n\n");
					fflush(NULL);
				} else {
					IsOnLoopWhile = false;
					LastCondition = true;
					fprintf(GetStdInfoHandle(), "Fin de la boucle \"while\".\n\n");
					fflush(NULL);
				}
			} else {
				fprintf(GetStdInfoHandle(), "Erreur : \"endW\" appelé sans \"while\" à la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : \"endW\" appelé sans \"while\" à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(95);
			}
		} else if (ReturnFunc == 121) {//Fin des boucles for...
		if (IsOnLoopFor)
			{
				char Void[1000], Var[1000], Condition[10000], Increment[1000], TempIncrement[1000] = {"$"};
				sscanf(LastLoopCondition, "%[^(](%[^,],%[^,],%[^)]", &Void, &Var, &Condition, &Increment);//Recherche la condition.
				
				char VarNameToGet[100];//Cherche la variable...
				sscanf(Var, "$%[^;];=%[^\0]", &VarNameToGet, &Void);//Recherche du nom de variable et du contenu et inscription dans la variables des variables...
				strcat(TempIncrement,VarNameToGet);//Crée la variable à modifier (ex : $i;+1)...
				strcat(TempIncrement,";");
				strcat(TempIncrement,Increment);
				StringParser(TempIncrement);
				EsCpy(VarContent[VarExist(VarNameToGet)],TempIncrement);
				
				if (IsTrue(Condition))
				{
					CurrentLine = CurrentLine-CurrentLineOfCurrentFile;//Retourne au début du fichier...
					CurrentLineOfCurrentFile = 1;
					fseek(FileOpen,0,SEEK_SET);
					while (CurrentLineOfCurrentFile < StartOfLastLoop)//Retourne au début de la boucle...
					{
						CurrentLine++;
						CurrentLineOfCurrentFile++;
						fgets(LineContent, 10000, FileOpen);
					}
					CurrentLine--;
					CurrentLineOfCurrentFile--;
					fprintf(GetStdInfoHandle(), "Retour au début de la boucle \"for\".\n\n");
					fflush(NULL);
				} else {
					IsOnLoopFor = false;
					fprintf(GetStdInfoHandle(), "Fin de la boucle \"for\".\n\n");
					fflush(NULL);
				}
			} else {
				fprintf(GetStdInfoHandle(), "Erreur \"next\" appelé sans \"for\" à la ligne %d !\nL'exécution du script va être arrêté.",CurrentLineOfCurrentFile);
				fflush(NULL);
					
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : \"next\" appelé sans \"for\" à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", CurrentLineOfCurrentFile);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'éxécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
					fclose(FileOpen);
				}
				ExitErrLog(121);
			}

		} else {//Sinon, cherche les paramètres de la fonction...
			strcpy(LineContent,replace(LineContent, ")", ",0,0,0)"));//Remplaces les ) par ,NULL)...
			int ReturnCall = CallFSPsFonc(LineContent, ReturnFunc);//Appel la fonction qui va appeler la fonction.
			if (ReturnFunc != -11)
			{
				fprintf(GetStdInfoHandle(), "Appel de la fonction d'ID %d terminé avec code %d.\n\n", ReturnFunc, ReturnCall);//Ecriture d'infos dans la console.
				fflush(NULL);
			}
		}
	}
	fclose(FileOpen);
	return 0;
}

int StringParser(char *StringToParse)
{
	int i = 0, coutMax = 0;
	char StringToParseCopy[10000];//Crée une copie de la variable.
	strcpy(StringToParseCopy,StringToParse);
	
	strcpy(StringToParse,replace(StringToParse, "NULL", ""));//Remplace NULL par \0.

	//###### >> Cherche et execute des fonctions...
	int ReturnFunc = CheckFunc(StringToParse);//Cherche l'ID de la fonction...
	if (ReturnFunc == 94){
		exit(94);

	} else if (ReturnFunc == 43) {//Fonction fRead()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], FileToRead[1000];
		sscanf(StringToParse, "%[^(](%[^,]", &Void, &FileToRead);//Cherche les paramètres.

		fRead(FileToRead,StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc == 105) {//Fonction sGetOsInfo()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], InfoToGet[1000];
		sscanf(StringToParse, "%[^(](%[^,]", &Void, &InfoToGet);//Cherche les paramètres.

		sGetOsInfo(InfoToGet,StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc == 107) {//Fonction strInStr()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], String[1000], SubString[1000], CaseSens[1000];
		sscanf(StringToParse, "%[^(](%[^,],%[^,],%[^,]", &Void, &String, &SubString, &CaseSens);//Cherche les paramètres.
		
		strInStr(String, SubString, CaseSens, StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc == 108) {//Fonction strLeft()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], String[1000], Count[1000];
		sscanf(StringToParse, "%[^(](%[^,],%[^,]", &Void, &String, &Count);//Cherche les paramètres.
		
		strLeft(String, Count, StringToParse);//Appel la fonction.
		return 0;
		
	} else if (ReturnFunc == 109) {//Fonction strLen()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], String[1000];
		sscanf(StringToParse, "%[^(](%[^,]", &Void, &String);//Cherche les paramètres.
		
		strLen(String, StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc == 1011) {//Fonction strLeft()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], String[1000], Count[1000];
		sscanf(StringToParse, "%[^(](%[^,],%[^,]", &Void, &String, &Count);//Cherche les paramètres.
		
		strRight(String, Count, StringToParse);//Appel la fonction.
		return 0;
		
	} else if (ReturnFunc == 1010) {//Fonction strReplace()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], String[1000], SubString1[1000], SubString2[1000];
		sscanf(StringToParse, "%[^(](%[^,],%[^,],%[^,]", &Void, &String, &SubString1, &SubString2);//Cherche les paramètres.
		
		strReplace(String, SubString1, SubString2, StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc == 1012) {//Fonction sGetEnv()...
		strcpy(StringToParse,replace(StringToParse,")",",0,0,0)"));
		char Void[1000], String[1000];
		sscanf(StringToParse, "%[^(](%[^,]", &Void, &String);//Cherche les paramètres.
		
		sGetEnv(String, StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc == 144) {//Fonction cGet()...
		cGet(StringToParse);//Appel la fonction.
		return 0;

	} else if (ReturnFunc != 0 && ReturnFunc != 20){//Sinon, cherche les paramètres de la fonction...
		strcpy(StringToParse,replace(StringToParse, ")", ",0,0,0)"));//Remplaces les ) par ,NULL)...
		int ReturnCall = CallFSPsFonc(StringToParse, ReturnFunc);//Appel la fonction qui va appeler la fonction.
		fprintf(GetStdInfoHandle(), "Appel de la fonction d'ID %d terminé avec code %d pour StringParser.\n\n", ReturnFunc, ReturnCall);//Ecriture d'infos dans la console.
		fflush(NULL);
		char ReturnCallChar[1000];
		sprintf (ReturnCallChar, "%d", ReturnCall);
		strcpy(StringToParse,ReturnCallChar);
		return 0;
	} else if (ReturnFunc == 0) {//Cherche les fonctions supplémentaires...

		int FuncEx = FuncExist(StringToParse);
		if (FuncEx != -1)
		{
			fprintf(GetStdInfoHandle(), "Appel de la fonction supplémentaire \"%s\"\n", StringToParse);//Ecrit dans le flux stdinfo.
			fflush(NULL);
			char* argvTmp[2] = {NULL,{ESTR_PTRC(FuncLinesAndFile[FuncEx])}};//Crée argv.
			
			char RealFileExecCpy[255];//Sauvegarde les variables...
			strcpy(RealFileExecCpy,RealFileExec);
			int *CurrentLineOfCurrentFilePointCpy = CurrentLineOfCurrentFilePoint;

			ReccursiveCall++;
			if (ReccursiveCall >= 2) {//Cherche les appels recursifs trop nombreux...
				fprintf(GetStdInfoHandle(), "Erreur : Appel récursif de plus de 2 fonctions à la ligne %d !\nL'exécution du script va être arrêté !",*CurrentLineOfCurrentFilePoint);//Ecrit dans le flux stdinfo.
				fflush(NULL);
				if(!NO_NOTIFY_ERRORS) {
					char MsgErrConsole[1000] = {"Erreur : Appel récursif de plus de 2 fonctions à la ligne "};
					char CurrentLineChar[1000];//Converti du int en char*...
					sprintf (CurrentLineChar, "%d", *CurrentLineOfCurrentFilePoint);
					strcat(MsgErrConsole,CurrentLineChar);
					strcat(MsgErrConsole," !\n\nL'exécution du script va être arrêté !");
					MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
				}
				ExitErrLog(410);
			}

			main(-1,argvTmp);//Exécute la fonction.

			ReccursiveCall--;

			strcpy(RealFileExec,RealFileExecCpy);//Réstaure les variables.
			CurrentLineOfCurrentFilePoint = CurrentLineOfCurrentFilePointCpy;

			fprintf(GetStdInfoHandle(), "Fin d'appel de la fonction.\n\n", StringToParse);//Ecrit dans le flux stdinfo.
			fflush(NULL);
			strcpy(StringToParse,"0");
			return 0;
		}
	}
		
	//####################################################################################################################
	//####################################################################################################################


	while (strstr(StringToParse,"$") != NULL && strstr(StringToParse,";") != NULL)//Cherche les variables...
	{
		coutMax++;

		char Void[1000], VarNameToGet[100], VarNameToSearch[102] = {"$"};

		if (IsOnLeft(StringToParse,"$",0))
		{
			sscanf(StringToParse, "$%[^;]", &VarNameToGet);
		} else {
			sscanf(StringToParse, "%[^$]$%[^;]", &Void, &VarNameToGet);
		}
		strcat(VarNameToSearch,VarNameToGet);
		strcat(VarNameToSearch,";");
		if (coutMax > 1000) {//Affiche une erreur...
			fprintf(GetStdInfoHandle(), "Attention : Variable %s non trouvée à la ligne %d !",VarNameToSearch, *CurrentLineOfCurrentFilePoint);
			fflush(NULL);
			if (!NO_NOTIFY_ERRORS)
			{
				char MsgErrVar[1000] = {"Attention !\nVariable "};
				char CurrentLineChar[1000];//Converti du int en char*...
				sprintf (CurrentLineChar, "%d", *CurrentLineOfCurrentFilePoint);
				strcat(MsgErrVar,VarNameToSearch);
				strcat(MsgErrVar," non trouvée à la ligne ");
				strcat(MsgErrVar,CurrentLineChar);
				strcat(MsgErrVar," !");
				MessageBox(NULL,MsgErrVar,"FSProg erreur",48);
				strcpy(StringToParse,StringToParseCopy);
				return 1;
			}
		}
		for ( i = 0; i < 1000; i++)
		{
			char  VarNameWithChar[102] = {"$"};
			strcat(VarNameWithChar,ESTR_PTRC(VarName[i]));
			strcat(VarNameWithChar,";");
			if (IsOnLeft(VarNameToSearch,VarNameWithChar,0))
			{
				strcpy(StringToParse,replace(StringToParse, VarNameToSearch, ESTR_PTRC(VarContent[i])));//Les remplaces par leur valeur...
			}
		}
	}

	//####################################################################################################################
	//####################################################################################################################

	coutMax = 0;
	i = 0;

	for (i = 0; i < 18; i++)//Initialisation des variables de nom et de contenu des macros...
	{
		MacroName[i]=InitESTR();
		MacroContent[i]=InitESTR();
	}

	EsCpy(MacroName[0], "script");//Alloue la mémoire pour le nom des macros...
	EsCpy(MacroName[1], "dir");
	EsCpy(MacroName[2], "user");
	EsCpy(MacroName[3], "deskW");
	EsCpy(MacroName[4], "deskH");
	EsCpy(MacroName[5], "hour");
	EsCpy(MacroName[6], "min");
	EsCpy(MacroName[7], "sec");
	EsCpy(MacroName[8], "par");
	EsCpy(MacroName[9], "error");
	EsCpy(MacroName[10], "cr");
	EsCpy(MacroName[11], "lf");
	EsCpy(MacroName[12], "crlf");
	EsCpy(MacroName[13], "year");
	EsCpy(MacroName[14], "mon");
	EsCpy(MacroName[15], "day");
	EsCpy(MacroName[16], "ver");
	EsCpy(MacroName[17], "compiled");
	
	int j, k = 0, BackSlashOcc = -1;
	char FileDir[100000];
	for (i = strlen(FileRunningPath); i >= 0; i--)
	{
		if (FileRunningPath[i] == '\\' && BackSlashOcc == -1)//Cherche un \.
		{
			BackSlashOcc = i;
			for (j = BackSlashOcc+1; j <= strlen(FileRunningPath); j++)//Crée la variable contenant l'emplacement du fichier...
			{
				FileDir[k] = FileRunningPath[j];
				k++;
			}
			FileDir[k] = '\0';
		}
	}
	EsCpy(MacroContent[0], FileDir);//Alloue la mémoire pour le contenu des macros...
	i = 0;

	BackSlashOcc = -1;
	*FileDir = NULL;
	for (i = strlen(FileRunningPath); i >= 0; i--)
	{
		if (FileRunningPath[i] == '\\' && BackSlashOcc == -1)//Cherche un \.
		{
			BackSlashOcc = i;
			for (j = 0; j < BackSlashOcc; j++)//Crée la variable contenant l'emplacement du fichier...
			{
				FileDir[j] = FileRunningPath[j];
			}
			FileDir[j] = '\0';
		}
	}
	EsCpy(MacroContent[1], FileDir);
	i = 0;
	
	char acUserName[100];
	DWORD nUserName = sizeof(acUserName);
	GetUserName(acUserName, &nUserName);
	EsCpy(MacroContent[2], acUserName);

	char TempToInt[1000];//Converti du int en char*...
	sprintf (TempToInt, "%d", GetSystemMetrics(SM_CXSCREEN));
	EsCpy(MacroContent[3], TempToInt);
	sprintf (TempToInt, "%d", GetSystemMetrics(SM_CYSCREEN)) ;//Converti du int en char*.
	EsCpy(MacroContent[4], TempToInt);

	time_t timestamp;//Recupère l'heure et la date...
	struct tm * timeGet;
	timestamp = time(NULL);
	timeGet = localtime(&timestamp);
	sprintf(TempToInt, "%d", timeGet->tm_hour);//Converti du int en char*.
	EsCpy(MacroContent[5], TempToInt);
	sprintf(TempToInt, "%d", timeGet->tm_min);//Converti du int en char*.
	EsCpy(MacroContent[6], TempToInt);
	sprintf(TempToInt, "%d", timeGet->tm_sec);//Converti du int en char*.
	EsCpy(MacroContent[7], TempToInt);
	sprintf(TempToInt, "%d", 1900 + timeGet->tm_year);//Converti du int en char*.
	EsCpy(MacroContent[13], TempToInt);
	sprintf(TempToInt, "%d", 1 + timeGet->tm_mon);//Converti du int en char*.
	EsCpy(MacroContent[14], TempToInt);
	sprintf(TempToInt, "%d", timeGet->tm_mday);//Converti du int en char*.
	EsCpy(MacroContent[15], TempToInt);
	EsCpy(MacroContent[16], FSP_CURRENT_VERSION);
#ifdef FSP_PSEUDO_COMPILE_MODE
	EsCpy(MacroContent[17], "1");
#else
	EsCpy(MacroContent[17], "0");
#endif

	EsCpy(MacroContent[8], *Parameters);
	
	sprintf(TempToInt, "%d", GetLastFSPError());//Converti du int en char*.
	EsCpy(MacroContent[9], TempToInt);
	EsCpy(MacroContent[10], "\r");
	EsCpy(MacroContent[11], "\f");
	EsCpy(MacroContent[12], "\n");

	while (strstr(StringToParse,"_") != NULL && strstr(StringToParse,";") != NULL)//Cherche les macros...
	{
		coutMax++;

		char Void[1000], MacroNameToGet[100], MacroNameToSearch[100] = {"_"};
		
		if (IsOnLeft(StringToParse,"_",0))
		{
			sscanf(StringToParse, "_%[^;]", &MacroNameToGet);
		} else {
			sscanf(StringToParse, "%[^_]_%[^;]", &Void, &MacroNameToGet);
		}
		strcat(MacroNameToSearch,MacroNameToGet);
		strcat(MacroNameToSearch,";");
		
		if (coutMax > 1000) {//Affiche une erreur...
			fprintf(GetStdInfoHandle(), "Attention : Macro %s non trouvée à la ligne %d !",MacroNameToSearch,*CurrentLineOfCurrentFilePoint);
			fflush(NULL);
			if (!NO_NOTIFY_ERRORS)
			{
				char MsgErrMacro[1000] = {"Attention !\nMacro "};
				char CurrentLineChar[1000];//Converti du int en char*...
				sprintf (CurrentLineChar, "%d", *CurrentLineOfCurrentFilePoint);
				strcat(MsgErrMacro,MacroNameToSearch);
				strcat(MsgErrMacro," non trouvée à la ligne ");
				strcat(MsgErrMacro,CurrentLineChar);
				strcat(MsgErrMacro," !");
				MessageBox(NULL,MsgErrMacro,"FSProg erreur",48);
				strcpy(StringToParse,StringToParseCopy);
				return 1;
			}
		}

		for ( i = 0; i < 18; i++)
		{
			char  MacroNameWithChar[102] = {"_"};
			strcat(MacroNameWithChar,ESTR_PTRC(MacroName[i]));
			strcat(MacroNameWithChar,";");
			if (IsOnLeft(MacroNameToSearch,MacroNameWithChar,0))
			{
				strcpy(StringToParse,replace(StringToParse, MacroNameToSearch, ESTR_PTRC(MacroContent[i])));//Les remplaces par leur valeur...
			}
		}
	}

	if (strstr(StringToParseCopy,"+") || strstr(StringToParseCopy,"-") || strstr(StringToParseCopy,"*") || strstr(StringToParseCopy,"/") || strstr(StringToParseCopy,"%"))//Calcule les expressions...
	{
		double ReturnCalc = ExprCalc( StringToParse);
		char TempToChar[1000];//Converti du int en char*...
		sprintf (TempToChar, "%.6f", ReturnCalc);
		bool IsGoodNumber = false;
		if (IsOnRight(TempToChar,"0",0) && ! IsGoodNumber)
			sprintf (TempToChar, "%.5f", ReturnCalc);
		else
			IsGoodNumber = true;
		if (IsOnRight(TempToChar,"0",0) && ! IsGoodNumber)
			sprintf (TempToChar, "%.4f", ReturnCalc);
		else
			IsGoodNumber = true;
		if (IsOnRight(TempToChar,"0",0) && ! IsGoodNumber)
			sprintf (TempToChar, "%.3f", ReturnCalc);
		else
			IsGoodNumber = true;
		if (IsOnRight(TempToChar,"0",0) && ! IsGoodNumber)
			sprintf (TempToChar, "%.2f", ReturnCalc);
		else
			IsGoodNumber = true;
		if (IsOnRight(TempToChar,"0",0) && ! IsGoodNumber)
			sprintf (TempToChar, "%.1f", ReturnCalc);
		else
			IsGoodNumber = true;
		if (IsOnRight(TempToChar,"0",0) && ! IsGoodNumber)
			sprintf (TempToChar, "%.0f", ReturnCalc);
		else
			IsGoodNumber = true;
		strcpy( StringToParse, TempToChar);
	}

	strcpy(StringToParse,replace(StringToParse, "{d}", "$"));//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
	strcpy(StringToParse,replace(StringToParse, "{v}", ","));
	strcpy(StringToParse,replace(StringToParse, "{p}", ";"));
	strcpy(StringToParse,replace(StringToParse, "{u}", "_"));
	strcpy(StringToParse,replace(StringToParse, "{po}", "("));
	strcpy(StringToParse,replace(StringToParse, "{pc}", ")"));

	strcpy(StringToParse,replace(StringToParse, "{plus}", "+"));
	strcpy(StringToParse,replace(StringToParse, "{less}", "-"));
	strcpy(StringToParse,replace(StringToParse, "{mult}", "*"));
	strcpy(StringToParse,replace(StringToParse, "{divi}", "/"));
	strcpy(StringToParse,replace(StringToParse, "{modu}", "%"));

	strcpy(StringToParse,replace(StringToParse, "{em}", "!"));
	strcpy(StringToParse,replace(StringToParse, "{and}", "&"));
	strcpy(StringToParse,replace(StringToParse, "{vb}", "|"));
	
	strcpy(StringToParse,replace(StringToParse, "{{}", "{"));
	strcpy(StringToParse,replace(StringToParse, "{}}", "}"));
	return 0;
}

int Dinclude(char *LineContent)//Directives...
{
	if (strstr(LineContent,"<") != NULL)
	{
		char Void[1000], FileToInclude[1000];
		sscanf(LineContent, "%[^<]<%[^>]", &Void, &FileToInclude);//Recherche du nom de fichier.

		int i, j, BackSlashOcc = -1;
		char FileDir[100000];
		for (i = strlen(ExeRunningPath); i >= 0; i--)
		{
			if (ExeRunningPath[i] == '\\' && BackSlashOcc == -1)//Cherche un \.
			{
				BackSlashOcc = i;
				for (j = 0; j <= BackSlashOcc; j++)//Crée la variable contenant l'emplacement du fichier...
				{
					FileDir[j] = ExeRunningPath[j];
				}
				FileDir[j] = '\0';
			}
		}

		std::strcat(FileDir,"Includes\\");//Ajoute le Includes\.
		std::strcat(FileDir,FileToInclude);//Nom de fichier.
		char* argv[2] = {NULL,{FileDir}};//Crée argv.

		if (fopen(FileDir,"r") == NULL)
		{
			fprintf(GetStdInfoHandle(), "Erreur : Le fichier inclus <%s> est introuvable !\nL'exécution du script va être arrêté.",FileDir);
			fflush(NULL);
			char Message[1000] = {"Erreur !\n\nLe fichier inclus <"};//Crée le message d'erreur !
			strcat(Message,FileDir);
			strcat(Message, "> est introuvable !\n\nL'éxécution du script va être arrêté !");
			MessageBox(NULL,Message,"FSProg erreur",16);
			ExitErrLog(11);
		}

		fprintf(GetStdInfoHandle(), "\nLancement du fichier <%s> en tant qu'inclus...\n", FileToInclude);//Affiche le nom du fichier inclus.
		fflush(NULL);
		
		char RealFileExecCpy[255];//Sauvegarde les variables...
		strcpy(RealFileExecCpy,RealFileExec);
		int *CurrentLineOfCurrentFilePointCpy = CurrentLineOfCurrentFilePoint;

		main(-1, argv);//Execute le fichier inclus.

		strcpy(RealFileExec,RealFileExecCpy);//Réstaure les variables.
		CurrentLineOfCurrentFilePoint = CurrentLineOfCurrentFilePointCpy;

		fprintf(GetStdInfoHandle(), "Fin du lancement du fichier inclus.\n\n", FileToInclude);//Affiche le nom du fichier inclus.
		fflush(NULL);
		
		return 0;

	} else {
		char Void[1000], FileToInclude[1000];
		sscanf(LineContent, "%[^\"]\"%[^\"]", &Void, &FileToInclude);//Recherche du nom de fichier.

		ParseAsPath(FileToInclude);//Traitement pour les chemins d'accès relatifs.

		char* argv[2] = {NULL,{FileToInclude}};//Crée argv.
		
		if (fopen(FileToInclude,"r") == NULL)
		{
			fprintf(GetStdInfoHandle(), "Erreur : Le fichier inclus \"%s\" est introuvable !\nL'exécution du script va être arrêté.",FileToInclude);
			fflush(NULL);
			char Message[1000] = {"Erreur !\n\nLe fichier inclus \""};//Crée le message d'erreur !
			strcat(Message,FileToInclude);
			strcat(Message, "\" est introuvable !\n\nL'éxécution du script va être arrêté !");
			MessageBox(NULL,Message,"FSProg erreur",16);
			ExitErrLog(11);
		}

		fprintf(GetStdInfoHandle(), "\nLancement du fichier \"%s\" en tant qu'inclus...\n", FileToInclude);//Affiche le nom du fichier inclus.
		fflush(NULL);
		
		char RealFileExecCpy[255];//Sauvegarde les variables...
		strcpy(RealFileExecCpy,RealFileExec);
		int *CurrentLineOfCurrentFilePointCpy = CurrentLineOfCurrentFilePoint;

		main(-1, argv);//Execute le fichier inclus.

		strcpy(RealFileExec,RealFileExecCpy);//Réstaure les variables.
		CurrentLineOfCurrentFilePoint = CurrentLineOfCurrentFilePointCpy;

		fprintf(GetStdInfoHandle(), "Fin du lancement du fichier inclus.\n\n", FileToInclude);//Affiche le nom du fichier inclus.
		fflush(NULL);
		
		return 0;
	}
}

int Dreplace(char *LineContent)
{
	if (CurrentReplaceToCreate == 1000)//Cherche si le nombre n'est pas dépassé...
	{
		fprintf(GetStdInfoHandle(), "Erreur : Nombre de \"#replace\" dépassé à la ligne %d !\nL'exécution du script va être arrêté.",*CurrentLineOfCurrentFilePoint);
		fflush(NULL);
			
		if(!NO_NOTIFY_ERRORS)
		{
			char MsgErrConsole[1000] = {"Erreur : nombre de \"#replace\" dépassé à la ligne "};
			char CurrentLineChar[1000];//Converti du int en char*...
			sprintf (CurrentLineChar, "%d", *CurrentLineOfCurrentFilePoint);
			strcat(MsgErrConsole,CurrentLineChar);
			strcat(MsgErrConsole," !\nL'éxécution du script va être arrêté");
			MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
		}
		ExitErrLog(12);
	}
	char Void[1000], ReplaceNameToGet[1000], ReplaceContentToGet[1000];
	sscanf(LineContent, "%[^ ] %[^ ] %[^\n]", &Void, &ReplaceNameToGet, &ReplaceContentToGet);
	EsCpy(ReplaceName[CurrentReplaceToCreate], ReplaceNameToGet);
	EsCpy(ReplaceContent[CurrentReplaceToCreate], ReplaceContentToGet);
	fprintf(GetStdInfoHandle(), "\nCréation du remplacement #%d...\nNom >> %s\nContenu >> %s\n",CurrentReplaceToCreate,ReplaceNameToGet,ReplaceContentToGet);
	fflush(NULL);
	CurrentReplaceToCreate++;
	return 0;
}

int VarExist(char *VarNameToSearch)
{
	int i, cout = -1;
	for ( i = 0; i < 1000; i++)
	{
		if (IsOnLeft(ESTR_PTRC(VarName[i]),VarNameToSearch,0) && IsOnLeft(VarNameToSearch,ESTR_PTRC(VarName[i]),0))
		{
			cout = i;
		}
	}
	return cout;
}

int FuncExist(char *FuncNameToSearch)
{
	int i, cout = -1;
	for ( i = 0; i < 1000; i++)
	{
		if (IsOnLeft(ESTR_PTRC(FuncName[i]),FuncNameToSearch,0) && IsOnLeft(FuncNameToSearch,ESTR_PTRC(FuncName[i]),0))
		{
			cout = i;
		}
	}
	return cout;
}

int ReplaceExist(char *ReplaceNameToSearch)
{
	int i, cout = -1;
	for ( i = 0; i < 1000; i++)
	{
		if (IsOnLeft(ESTR_PTRC(ReplaceName[i]),ReplaceNameToSearch,0) && IsOnLeft(ReplaceNameToSearch,ESTR_PTRC(ReplaceName[i]),0))
		{
			cout = i;
		}
	}
	return cout;
}

int ParseAsPath(char *StringToParse)
{
	if (!strstr(StringToParse, ":"))
	{
		int i, j, BackSlashOcc = -1;
		char FileDir[10000];
		for (i = strlen(FileRunningPath); i >= 0; i--)
		{
			if (FileRunningPath[i] == '\\' && BackSlashOcc == -1)//Cherche un \.
			{
				BackSlashOcc = i;
				for (j = 0; j <= BackSlashOcc; j++)//Crée la variable contenant l'emplacement du fichier...
				{
					FileDir[j] = FileRunningPath[j];
				}
				FileDir[j] = '\0';
			}
		}
		strcat(FileDir,StringToParse);
		strcpy(StringToParse,FileDir);
	}
	return 0;
}

//Fonction d'allocation de variables...
int VarSetData(char *VarNameToGet, char *VarContentToGet)
{
	int VarEx = VarExist(VarNameToGet);
	if (VarEx == -1)//Si la variable n'existe pas...
	{
		if (CurrentVarToCreate == 1000)//Cherche si le nombre n'est pas dépassé...
		{
			fprintf(GetStdInfoHandle(), "Erreur : Nombre de variables déppasé à la ligne %d !\nL'exécution du script va être arrêté.",*CurrentLineOfCurrentFilePoint);
			fflush(NULL);
				
			if(!NO_NOTIFY_ERRORS)
			{
				char MsgErrConsole[1000] = {"Erreur : nombre de variable dépassé à la ligne "};
				char CurrentLineChar[1000];//Converti du int en char*...
				sprintf (CurrentLineChar, "%d", *CurrentLineOfCurrentFilePoint);
				strcat(MsgErrConsole,CurrentLineChar);
				strcat(MsgErrConsole," !\nL'éxécution du script va être arrêté.");
				MessageBox(NULL,MsgErrConsole,"FSProg erreur",16);
			}
			ExitErrLog (20);
		}
		EsCpy(VarName[CurrentVarToCreate], VarNameToGet);//Alloue la mémoire pour le nom et le contenu...
		EsCpy(VarContent[CurrentVarToCreate], VarContentToGet);
		fprintf(GetStdInfoHandle(), "\nCréation de la variable #%d...\nNom >> %s\nContenu >> %s\n",CurrentVarToCreate,VarNameToGet,VarContentToGet);
		fflush(NULL);
		CurrentVarToCreate++;
	} else {//Si elle existe...
		EsCpy(VarContent[VarEx], VarContentToGet);//Modifie sa valeur.
		fprintf(GetStdInfoHandle(), "\Modification de la variable #%d...\nNom >> %s\nContenu >> %s\n",VarEx,VarNameToGet,VarContentToGet);
		fflush(NULL);
	}
	return 0;
}

void ExitErrLog(int ExitCode)
{
	fprintf(GetStdInfoHandle(), "\n\n ==> Fin du script avec code %d",ExitCode);
#ifndef FSP_PSEUDO_COMPILE_MODE
	FILE * ErrFile = NULL;

	char TempPath[1000];
	strcpy(TempPath,getenv("TEMP"));
	
	strcat(TempPath,"\\FSPErr.txt");
	
	ErrFile = fopen(TempPath,"w+");
	fputs("..:: Fichier d'erreur script FSProg ::..\n\nFichier lancé ......... ",ErrFile);
	fputs(FileRunningPath,ErrFile);
	
	char DateAndHour[] = {"_crlf;Date .................. _day;{divi}_mon;{divi}_year;_crlf;Heure ................. _hour;:_min;:_sec;"};//Ecrit l'heure et la date...
	StringParser(DateAndHour);
	fputs(DateAndHour,ErrFile);
	
	fputs("\nCode de sortie ........ ",ErrFile);

	char IntToChar[1000];//Converti du int en char*...
	sprintf (IntToChar, "%d", ExitCode);

	fputs(IntToChar,ErrFile);
	fputs("\nNombre de variables ... ",ErrFile);
	sprintf (IntToChar, "%d", CurrentVarToCreate);
	fputs(IntToChar,ErrFile);
	fputs("\nNombre de fonctions ... ",ErrFile);
	sprintf (IntToChar, "%d", CurrentFuncToCreate);
	fputs(IntToChar,ErrFile);
	fputs("\nNombre de #replace .... ",ErrFile);
	sprintf (IntToChar, "%d", CurrentReplaceToCreate);
	fputs(IntToChar,ErrFile);
	fputs("\nCode d'erreur ......... ",ErrFile);
	sprintf (IntToChar, "%d", GetLastFSPError());
	fputs(IntToChar,ErrFile);
	fputs("\nNotification d'erreur . ",ErrFile);
	if (NO_NOTIFY_ERRORS)
		fputs("Non",ErrFile);
	else
		fputs("Oui",ErrFile);
	fputs("\nFichier réel exécuté .. ",ErrFile);
	fputs(RealFileExec,ErrFile);
	fputs("\nLigne exécutée ........ ",ErrFile);
	sprintf (IntToChar, "%d", *CurrentLineOfCurrentFilePoint);
	fputs(IntToChar,ErrFile);

	fputs("\n\nContenu de la mémoire :\n\nVariables :",ErrFile);

	int i;
	for (i=0; i<CurrentVarToCreate;i++)
	{
		fputs("\nVar #",ErrFile);
		sprintf (IntToChar, "%d", i);
		fputs(IntToChar,ErrFile);
		fputs("\n    Nom >> ",ErrFile);
		fputs(ESTR_PTRC(VarName[i]),ErrFile);
		fputs("\nContenu >> ",ErrFile);
		fputs(ESTR_PTRC(VarContent[i]),ErrFile);
		fputs("\n",ErrFile);
	}
	fputs("\nFonctions :",ErrFile);
	for (i=0; i<CurrentFuncToCreate;i++)
	{
		fputs("\nFunc #",ErrFile);
		sprintf (IntToChar, "%d", i);
		fputs(IntToChar,ErrFile);
		fputs("\nNom >> ",ErrFile);
		fputs(ESTR_PTRC(FuncName[i]),ErrFile);
		fputs("\n ID >> ",ErrFile);
		fputs(ESTR_PTRC(FuncLinesAndFile[i]),ErrFile);
		fputs("\n",ErrFile);
	}
	fputs("\nreplace :",ErrFile);
	for (i=0; i<CurrentReplaceToCreate;i++)
	{
		fputs("\nreplace #",ErrFile);
		sprintf (IntToChar, "%d", i);
		fputs(IntToChar,ErrFile);
		fputs("\n    Nom >> ",ErrFile);
		fputs(ESTR_PTRC(ReplaceName[i]),ErrFile);
		fputs("\nContenu >> ",ErrFile);
		fputs(ESTR_PTRC(ReplaceContent[i]),ErrFile);
		fputs("\n",ErrFile);
	}
#endif
	exit(ExitCode);
}

bool Get_NO_NOTIFY_ERRORS()
{
	if (NO_NOTIFY_ERRORS)
		return true;
	else
		return false;
}

int GetLastFSPError()
{
	return LAST_FSP_SCRIPT_ERROR;
}

int SetLastFSPError(int Error)
{
	LAST_FSP_SCRIPT_ERROR = Error;
	if (GetLastFSPError() == Error)
	{
		return 1;
	} else {
		return 0;
	}
}

FILE *GetStdInfoHandle()
{
	if (! StdInfoAlsoCreated)
	{
		char TempDir[1000];
		strcpy(TempDir,getenv("TEMP"));
		strcat(TempDir,"\\stdinfo");
		stdinfo = fopen(TempDir,"w+");
		StdInfoAlsoCreated = true;
	}
	return stdinfo;
}