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

int LastRandomNumber = 22;
int IncrementRandom = 0;

//Pour des raisons d'accecibilité de variables, les directives se trouvent dans main.cpp

int fWrite(char *Par1, char *Par2, char *Par3)//Fonctions...
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	//StringParser(Par3);
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.

	if (*Par3 == '-')
	{
		//w+
		FILE* FileOpen = NULL;//Ouvre le fichier...
		FileOpen = fopen(Par1, "w+");
		if (!FileOpen)//Si le fichier n'as pas été ouvert...
		{
			return 0;
		} else {//Sinon...
			fprintf(FileOpen,"%s", Par2);//Ecrit dans le fichier, le ferme et envoie le retour correspondant...
			fclose(FileOpen);
			return 1;
		}
	} else if (*Par3 == '+')
	{
		//a+
		FILE* FileOpen = NULL;//Ouvre le fichier...
		FileOpen = fopen(Par1, "a+");
		if (!FileOpen)//Si le fichier n'as pas été ouvert...
		{
			return 0;
		} else {//Sinon...
			fprintf(FileOpen,"%s", Par2);//Ecrit dans le fichier, le ferme et envoie le retour correspondant...
			fclose(FileOpen);
			return 1;
		}
	} else {
		return 0;
	}
}

// La fonction "fRead()" est spéciale, elle est appelé uniquement depuis la fonction "StringParser()"
// car elle ne fonctionne qu'avec un retour dans une variable.
int fRead(char *FileToRead, char *StringToParse)
{
	StringParser(FileToRead);
	ParseAsPath(FileToRead);

	FILE* FileToOpen = NULL;//Ouvre le fichier...
	FileToOpen = fopen(FileToRead, "r");
	char FileContentToRead[10000];
	char FileLineTemp[10000];
	strcpy(FileContentToRead,"\0");
	
	if (!FileToOpen)//Verifie si le fichier a été ouvert...
	{
		strcpy(FileContentToRead,"0");
	} else {
		while (fgets(FileLineTemp,10000,FileToOpen) != NULL)//Lit tout le fichier...
		{
			strcat(FileContentToRead,FileLineTemp);
		}
		fclose(FileToOpen);
	}
		
	//AdSpecialChar(FileContentToRead);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...

	strcpy(StringToParse,FileContentToRead);
	return 0;
}

int fDel(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.

	int Return = remove(Par1);
	if (Return == 0)
	{
		return 1;
	} else {
		return 0;
	}
}

int fCreate(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.

	FILE* FileOpen = NULL;//Ouvre le fichier...
	FileOpen = fopen(Par1, "a+");
	if (!FileOpen)//Si le fichier n'as pas été ouvert...
	{
		return 0;
	} else {//Sinon...
		fclose(FileOpen);//Ferme le fichier et envoie le retour correspondant...
		return 1;
	}
}

int fMove(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.
	ParseAsPath(Par2);

	int Return = MoveFileA(Par1,Par2);
	if (Return == 0)
	{
		return 0;
	} else {
		return 1;
	}
}

int fCopy(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.
	ParseAsPath(Par2);

	int Return = CopyFileA(Par1,Par2,NULL);
	if (Return == 0)
	{
		return 0;
	} else {
		return 1;
	}
}

int fRun(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.
	if (*Par2 != '0')
		ParseAsPath(Par2);

	if (! IsOnLeft(Par1,"\"",0))//Ajoute des "" au chemin d'accès...
	{
		char Par1Tmp[1000];//Crée une sauvegarde du paramètre...
		strcpy(Par1Tmp,Par1);
		strcpy(Par1,"\"");
		strcat(Par1,Par1Tmp);
		strcat(Par1,"\"");
	}
	if (! IsOnLeft(Par2,"\"",0))//Ajoute des "" au chemin d'accès...
	{
		char Par2Tmp[1000];//Crée une sauvegarde du paramètre...
		strcpy(Par2Tmp,Par2);
		strcpy(Par2,"\"");
		strcat(Par2,Par2Tmp);
		strcat(Par2,"\"");
	}
	
	if (IsEqualNoCase(Par2,"\"0\""))
	{
		ShellExecute(NULL,NULL,Par1,NULL, NULL, SW_SHOWNORMAL);
		return 0;//Fonction sans retour, donc 0.
	} else {
		ShellExecute(NULL,NULL,Par2,Par1, NULL, SW_SHOWNORMAL);
		return 0;//Fonction sans retour, donc 0.
	}
}

int fExist(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.

	FILE * FileOpen = fopen(Par1,"r");
	if (FileOpen == NULL)
	{
		return 0;
	} else {
		fclose(FileOpen);
		return 1;
	}
}

int dDel(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.

	char Parametres[1000] = {"RMDIR /S /Q \""};
	std::strcat(Parametres,Par1);//Crée la chaine correspondante...
	std::strcat(Parametres,"\">NUL");

	system(Parametres);//Supprime le fichier.

	int Return = FolderExists(Par1);

	if (Return == 0)
	{
		return 1;
	} else {
		return 0;
	}
}

int dExist(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.
	if(PathIsDirectory((LPCSTR)Par1))
	{
		return 1;
	} else {
		return 0;
	}

}

int dCreate(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.

	int Return = CreateDirectory(Par1,NULL);
	if (Return == 0)
	{
		return 0;
	} else {
		return 1;
	}
}

int dMove(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.
	ParseAsPath(Par2);

	int Return = MoveFile(Par1, Par2);
	if (Return == 0)
	{
		return 0;
	} else {
		return 1;
	}
}

int dCopy(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	ParseAsPath(Par1);//Traitement pour les chemins d'accès relatifs.
	ParseAsPath(Par2);

	char Parametres[2022] = {"XCOPY \""};
	std::strcat(Parametres,Par1);//Crée la chaine correspondante...
	std::strcat(Parametres,"\" \"");
	std::strcat(Parametres,Par2);
	std::strcat(Parametres,"\" /E /C /I>NUL");

	system(Parametres);

	int Return = FolderExists(Par2);
	if (Return == 0)
	{
		return 0;
	} else {
		return 1;
	}
}

int pDel(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	
	int Return = KILL_PROC_BY_NAME(Par1);
	if (Return == 0)
	{
		return 1;
	} else {
		return 0;
	}
}

int pSet(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);

	HANDLE hProcess = GetProcessHandle( Par1);

	if (hProcess)
	{
		DWORD Priority = NORMAL_PRIORITY_CLASS;
		if (IsOnLeft(Par2,"-2",0)) {Priority = IDLE_PRIORITY_CLASS;}//Cherche et choisis la priorité...
		else if (IsOnLeft(Par2,"-1",0)) {Priority = BELOW_NORMAL_PRIORITY_CLASS;}
		else if (*Par2 == '0') {Priority = NORMAL_PRIORITY_CLASS;}
		else if (*Par2 == '1') {Priority = ABOVE_NORMAL_PRIORITY_CLASS;}
		else if (*Par2 == '2') {Priority = HIGH_PRIORITY_CLASS;}
		else if (*Par2 == '3') {Priority = REALTIME_PRIORITY_CLASS;}
		int Return = SetPriorityClass(hProcess,Priority);//Modifie la priorité
		CloseHandle(hProcess);//Ferme le processus.
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else {
		return -1;
	}
}

int pExist(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	HANDLE HandleProcess = GetProcessHandle( Par1);
	if (HandleProcess)
	{
		CloseHandle(HandleProcess);
		return 1;
	} else {
		CloseHandle(HandleProcess);
		return 0;
	}
}

int pWait(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	StringParser(Par3);

	int Par2int;//Transforme les types char* en int...
	sscanf(Par2, "%d", &Par2int);
	int Par3int;
	sscanf(Par3, "%d", &Par3int);

	fprintf(GetStdInfoHandle(), "Attente du processus %s...\n", Par1);
	fflush(NULL);

	if (Par2int == 0)
	{
		while (GetProcessHandle(Par1) == NULL)//Boucle tant que le processus n'existe pas...
		{
			Sleep(Par3int);//Pause le temps demandé.
		}
		return 1;
	} else {
		clock_t Timer;//Variables de comptage du temps maximum.
		while (GetProcessHandle(Par1) == NULL)//Boucle tant que le processus n'existe pas...
		{
			Sleep(Par3int);//Pause le temps demandé.
			Timer=clock();
			if (((double) Timer/CLOCKS_PER_SEC)*1000 > Par2int)//Si le temps est écoulé...
			{
				return 0;//Retourne la valeur correspondante.
			}
		}
		return 1;
	}
}

int mMove(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	//StringParser(Par3);

	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);
	int Par2int;
	sscanf(Par2, "%d", &Par2int);

	if (*Par3 == '0')//Cherche les options...
	{
		int Return = SetCursorPos(Par1int,Par2int);//Déplace la souris...
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else if (*Par3 == '-')
	{
		POINT Cursorpos;//Récupère la position de la souris...
		GetCursorPos(&Cursorpos);
		int Return = SetCursorPos(Cursorpos.x-Par1int,Cursorpos.y-Par2int);//Déplace la souris...
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else if (*Par3 == '+')
	{
		POINT Cursorpos;//Récupère la position de la souris...
		GetCursorPos(&Cursorpos);
		int Return = SetCursorPos(Cursorpos.x+Par1int,Cursorpos.y+Par2int);//Déplace la souris...
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else {
		return 0;
	}
}

int mLeft(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	//StringParser(Par3);

	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);
	int Par2int;
	sscanf(Par2, "%d", &Par2int);

	if (*Par3 == '0')//Cherche les options...
	{
		int Return = SetCursorPos(Par1int,Par2int);//Déplace la souris...
		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); 
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else if (*Par3 == '-')
	{
		POINT Cursorpos;//Récupère la position de la souris...
		GetCursorPos(&Cursorpos);
		int Return = SetCursorPos(Cursorpos.x-Par1int,Cursorpos.y-Par2int);//Déplace la souris...
		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); 
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else if (*Par3 == '+')
	{
		POINT Cursorpos;//Récupère la position de la souris...
		GetCursorPos(&Cursorpos);
		int Return = SetCursorPos(Cursorpos.x+Par1int,Cursorpos.y+Par2int);//Déplace la souris...
		mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0); 
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else {
		return 0;
	}
	return 0;
}

int mRight(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	//StringParser(Par3);

	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);
	int Par2int;
	sscanf(Par2, "%d", &Par2int);

	if (*Par3 == '0')//Cherche les options...
	{
		int Return = SetCursorPos(Par1int,Par2int);//Déplace la souris...
		mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0); 
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else if (*Par3 == '-')
	{
		POINT Cursorpos;//Récupère la position de la souris...
		GetCursorPos(&Cursorpos);
		int Return = SetCursorPos(Cursorpos.x-Par1int,Cursorpos.y-Par2int);//Déplace la souris...
		mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0); 
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else if (*Par3 == '+')
	{
		POINT Cursorpos;//Récupère la position de la souris...
		GetCursorPos(&Cursorpos);
		int Return = SetCursorPos(Cursorpos.x+Par1int,Cursorpos.y+Par2int);//Déplace la souris...
		mouse_event(MOUSEEVENTF_RIGHTDOWN, 0, 0, 0, 0);
		mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0); 
		if (Return == 0)
		{
			return 0;
		} else {
			return 1;
		}
	} else {
		return 0;
	}
	return 0;
}

int kSend(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	int OldLen = strlen(Par1);

	if (strlen(Par1) != 1 && ! IsOnLeft(Par1,"{",0))//Cherche des lignes multiples...
	{
		int i;
		for ( i=0; i<OldLen; i++)
		{
			if (IsOnLeft(Par1,"{",0))
			{ 
				int j;
				char SpecialKey[8];
				bool Loop = true;
				for ( j=0; j<8; j++)
				{
					if (Loop)
					{
						SpecialKey[j] = Par1[j];
					}
					if (Par1[j] == '}')
					{
						Loop = false;
					}
				}
				SpecialKey[j-1] = '\0';
				strcpy(Par1,Par1+j-1);
				int ByteKeyValue = KeyStrToID(SpecialKey);//Rehcerche la valeur Héxadecimale de la touche demandée.
				keybd_event(ByteKeyValue,0,0,0);//Appuie sur la touche.
				keybd_event(ByteKeyValue,0,KEYEVENTF_KEYUP/* 0x0002 */,0);//Relache la touche.
			} else {
				Par1[0] = toupper(Par1[0]);//Met en majuscule.
				char ParChar[2] = {Par1[0],'\0'};
				strcpy(Par1,Par1+1);//Supprime le caractère traité.
				int ByteKeyValue = KeyStrToID(ParChar);//Rehcerche la valeur Héxadecimale de la touche demandée.
				keybd_event(ByteKeyValue,0,0,0);//Appuie sur la touche.
				keybd_event(ByteKeyValue,0,KEYEVENTF_KEYUP/* 0x0002 */,0);//Relache la touche.
			}
		}
		return 0;
	} else {
		Par1[0] = toupper(Par1[0]);//Met en majuscule.
		int ByteKeyValue = KeyStrToID(Par1);//Rehcerche la valeur Héxadecimale de la touche demandée.
		keybd_event(ByteKeyValue,0,0,0);//Appuie sur la touche.
		keybd_event(ByteKeyValue,0,KEYEVENTF_KEYUP,0);//Relache la touche.
		return 0;
	}
}

int kDown(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	int ByteKeyValue = KeyStrToID(Par1);//Rehcerche la valeur Héxadecimale de la touche demandée.
	keybd_event(ByteKeyValue,0,0,0);//Appuie sur la touche.
	return 0;
}

int kUp(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	int ByteKeyValue = KeyStrToID(Par1);//Rehcerche la valeur Héxadecimale de la touche demandée.
	keybd_event(ByteKeyValue,0,KEYEVENTF_KEYUP,0);//Relache la touche.
	return 0;
}

int message(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	StringParser(Par3);

	if (IsEqualNoCase(Par2,"42"))
		strcpy(Par2,"La grande question sur la vie, l'univers et le reste");

	int Par3int;//Transforme les types char* en int...
	sscanf(Par3, "%d", &Par3int);

	int Return = MessageBox(NULL,Par2, Par1, Par3int);
	return Return;
}

int sleep(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);

	fprintf(GetStdInfoHandle(), "Pause de %d milli-secondes...\n",Par1int);//Affiche qu'une pause est en cours...
	fflush(NULL);

	Sleep(Par1int);//Fait une pause...
	return 0;
}

int random(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	
	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);
	int Par2int;
	sscanf(Par2, "%d", &Par2int);
	Par2int++;

	if (Par1int == Par2int) {return Par1int;}//Getsion des erreurs...
	if (Par2int-1 < Par1int) {return 0;}

	bool Reverse = false;
	if (Par1int < 0 )//Gestion des nombres négatifs...
	{
		Par1int = 0 - Par1int;
		Par2int += Par1int;
		Reverse = true;
	}
	
	srand(time(NULL));
	int Random = (rand() % Par2int);

	bool Loop = false;
	while ((Random < Par1int && Random > Par2int) || ! Loop)
	{
		Loop = true;
		srand(time(NULL)+LastRandomNumber-Random+IncrementRandom);
		IncrementRandom+=4;
		Random = (rand() % Par2int);
		if (Random == LastRandomNumber)
		{
			srand(time(NULL)+Random);
			Random = (rand() % Par2int);
		}
	}

	LastRandomNumber = Random;

	if (Reverse == true)
	{
		Random -= Par1int;
	}

	return Random;
}

int sSetErr(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);

	SetLastFSPError(Par1int);

	if (GetLastFSPError() == Par1int)
		return 1;
	else
		return 0;
}

int sExitCode(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	int Par1int;//Transforme les types char* en int...
	sscanf(Par1, "%d", &Par1int);

	ExitErrLog(Par1int);//Quitte le script.
	return 0;
}

// La fonction "sGetOsInfo()" est spéciale, elle est appelé uniquement depuis la fonction "StringParser()"
// car elle ne fonctionne qu'avec un retour dans une variable.
int sGetOsInfo(char *InfoToGet, char *StringToParse)
{
	StringParser(InfoToGet);//Execute et modifie les paramètres...

	if (IsEqualNoCase(InfoToGet,"name") == true)
	{
		std::string OsName = getRegKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductName");
		strcpy(StringToParse,OsName.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"version") == true) {
		std::string OsVersion = getRegKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentVersion");
		strcpy(StringToParse,OsVersion.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"build") == true) {
		std::string OsBuild = getRegKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "CurrentBuild");
		strcpy(StringToParse,OsBuild.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"dir") == true) {
		std::string OsRoot = getRegKey("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "SystemRoot");
		strcpy(StringToParse,OsRoot.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"biosversion") == true) {
		std::string BiosVersion = getRegKey("HARDWARE\\DESCRIPTION\\System", "SystemBiosVersion");
		strcpy(StringToParse,BiosVersion.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"biosdate") == true) {
		std::string BiosDate = getRegKey("HARDWARE\\DESCRIPTION\\System", "SystemBiosDate");
		strcpy(StringToParse,BiosDate.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"computermark") == true) {
		std::string CompMark = getRegKey("HARDWARE\\DESCRIPTION\\System\\BIOS", "SystemManufacturer");
		strcpy(StringToParse,CompMark.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"computermodel") == true) {
		std::string CompModel = getRegKey("HARDWARE\\DESCRIPTION\\System\\BIOS", "SystemProductName");
		strcpy(StringToParse,CompModel.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else if (IsEqualNoCase(InfoToGet,"computername") == true) {
		std::string CompName = getRegKey("SYSTEM\\CurrentControlSet\\Control\\ComputerName\\ActiveComputerName", "ComputerName");
		strcpy(StringToParse,CompName.c_str());
		AdSpecialChar(StringToParse);//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
		return 0;
	} else {
		strcpy(StringToParse,"0");
		return 0;
	}
}

int sWriteErr(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	fprintf(GetStdInfoHandle(), "\n%s\n", Par1);//Ecrit dans le flux stdinfo.
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED | FOREGROUND_INTENSITY);//Met le texte en rouge.
	fprintf(stderr,  "\n%s\n", Par1);//Ecrit dans le flux stderr.
	SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE | FOREGROUND_INTENSITY);//Met le texte en blanc.
	fflush(NULL);//Actualise le flux.
	if (! Get_NO_NOTIFY_ERRORS())
		MessageBox(NULL,Par1,"FSProg erreur",16);
	return 0;
}

// Les fonction string sont spéciales, elles sont appelés uniquement depuis la fonction "StringParser()"
// car elles ne fonctionnent qu'avec un retour dans une variable.
int strInStr(char *String, char *SubString, char *CaseSens, char *StringToParse)
{
	StringParser(String);//Execute et modifie les paramètres...
	StringParser(SubString);
	StringParser(CaseSens);

	int iLoop, CaseSensInt = atoi(CaseSens)/*Converti du char* en int.*/;
	if (CaseSensInt == 0) {//Si ne doit pas respécter la casse, met en majuscule.
		for (iLoop = 0; iLoop < strlen(String); iLoop++) {String[iLoop] = toupper(String[iLoop]);}
		for (iLoop = 0; iLoop < strlen(SubString); iLoop++) {SubString[iLoop] = toupper(SubString[iLoop]);}}

	if (strstr(String,SubString))
		strcpy(StringToParse,"1");
	else
		strcpy(StringToParse,"0");
	return 0;
}

int strLeft(char *String, char *Count, char *StringToParse)
{
	StringParser(String);//Execute et modifie les paramètres...
	StringParser(Count);
	int i, CountInt = atoi(Count)/*Converti du char* en int.*/;
	strcpy(StringToParse,"");//Vide le contenu de StringToParse.
	
	if (CountInt < 0) {//Cherche les erreur de Count...
		strcpy(StringToParse,"0");
		return 0;
	}

	if (CountInt > strlen(String))//Cherche les erreur de Count...
	{
		strcpy(StringToParse,String);
		return 0;
	}

	for ( i=0; i<CountInt; i++)
		StringToParse[i] = String[i];
	StringToParse[i] = '\0';

	return 0;
}

int strLen(char *String, char *StringToParse)
{
	StringParser(String);//Execute et modifie les paramètres...
	sprintf(StringToParse,"%d",strlen(String));
	
	if (strlen(String) == 1014)//Cherche les lignes vides.
		strcpy(StringToParse,"0");

	return 0;
}

int strRight(char *String, char *Count, char *StringToParse)
{
	StringParser(String);//Execute et modifie les paramètres...
	StringParser(Count);
	int i, CountInt = atoi(Count)/*Converti du char* en int.*/, C = 0;
	strcpy(StringToParse,"");//Vide le contenu de StringToParse.
	
	if (CountInt < 0) {//Cherche les erreur de Count...
		strcpy(StringToParse,"0");
		return 0;
	}

	if (CountInt > strlen(String))//Cherche les erreur de Count...
	{
		strcpy(StringToParse,String);
		return 0;
	}

	for ( i=(strlen(String)-CountInt); i<strlen(String); i++)
	{
		StringToParse[C] = String[i];
		C++ ;
	}
	StringToParse[C] = '\0';

	return 0;
}

int strReplace(char *String, char *SubString1, char *SubString2, char *StringToParse)
{
	StringParser(String);//Execute et modifie les paramètres...
	StringParser(SubString1);
	StringParser(SubString2);

	strcpy(StringToParse,replace(String,SubString1,SubString2));

	return 0;
}

int sSetEnv(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);

	char EnvToSet[10000];
	strcpy(EnvToSet,Par1);
	strcat(EnvToSet,"=");
	strcat(EnvToSet,Par2);
	
	if (putenv(EnvToSet) == 0)
	{
		return 1;
	} else {
		return 0;
	}
}

// La fonction "sGetEnv()" est spéciale, elle est appelé uniquement depuis la fonction "StringParser()"
// car elle ne fonctionne qu'avec un retour dans une variable.
int sGetEnv(char *VarEnvToGet, char *StringToParse)
{
	StringParser(VarEnvToGet);//Execute et modifie les paramètres...

	if (getenv(VarEnvToGet) != NULL) {
		strcpy(StringToParse,getenv(VarEnvToGet));
	} else {
		strcpy(StringToParse,"0");
	}
	return 0;
}

int console (char *Par1, char *Par2, char *Par3)
{
	if (IsEqualNoCase(Par1,"show"))
	{
		ShowWindow (GetConsoleWindow(), TRUE);//Affiche la fenêtre console.
		return 1;
	} else if (IsEqualNoCase(Par1,"hide"))
	{
		ShowWindow (GetConsoleWindow(), FALSE);//Cache la fenêtre console.
		return 1;
	} else {
		return 0;
	}
}

int cWrite(char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	if (IsEqualNoCase(Par1,"42"))
		strcpy(Par1,"La grande question sur la vie, l'univers et le reste\n");

	printf("%s", Par1);
	return 0;
}

int cClear(char *Par1, char *Par2, char *Par3)
{
	system("CLS");
	return 0;
}

// La fonction "cGet()" est spéciale, elle est appelé uniquement depuis la fonction "StringParser()"
// car elle ne fonctionne qu'avec un retour dans une variable.
int cGet(char *StringToParse)
{
	char ReturnStdIn[10000];
	gets(ReturnStdIn);
	strcpy(StringToParse,ReturnStdIn);
	return 0;
}

int cTitle (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	char Command[1000] = {"TITLE "};//Prépare la commandes...
	strcat(Command,Par1);
	strcat(Command,">nul");

	system(Command);
	
	return 0;
}

int cExec (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	system(Par1);

	return 0;
}

int isDeclared (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	if (VarExist(Par1) != -1)
	{
		return 1;
	} else {
		return 0;
	}
}

int wActivate (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	HWND WinHandle = FindWindow(NULL, Par1);

	if (WinHandle==NULL)
		return -1;

	if (SetForegroundWindow(WinHandle))
	{
		return 1;
	} else {
		return 0;
	}
}

int wWait (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	StringParser(Par3);

	int Par2int;//Transforme les types char* en int...
	sscanf(Par2, "%d", &Par2int);
	int Par3int;
	sscanf(Par3, "%d", &Par3int);

	fprintf(GetStdInfoHandle(), "Attente de l'existence de la fenêtre %s...\n", Par1);
	fflush(NULL);

	if (Par2int == 0)
	{
		while (FindWindow(NULL, Par1) == NULL)//Boucle tant que la fenêtre n'existe pas...
		{
			Sleep(Par3int);//Pause le temps demandé.
		}
		return 1;
	} else {
		clock_t Timer;//Variables de comptage du temps maximum.
		while (FindWindow(NULL, Par1) == NULL)//Boucle tant que la fenêtre n'existe pas...
		{
			Sleep(Par3int);//Pause le temps demandé.
			Timer=clock();
			if (((double) Timer/CLOCKS_PER_SEC)*1000 > Par2int)//Si le temps est écoulé...
			{
				return 0;//Retourne la valeur correspondante.
			}
		}
		return 1;
	}
}

int wSetPos (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	StringParser(Par3);

	int Par2int;//Transforme les types char* en int...
	sscanf(Par2, "%d", &Par2int);
	int Par3int;
	sscanf(Par3, "%d", &Par3int);

	HWND WinHandle = FindWindow(NULL, Par1);

	if (WinHandle==NULL)
		return -1;

	if (SetWindowPos(WinHandle,NULL,Par2int,Par3int,NULL,NULL,SWP_NOSIZE))
	{
		return 1;
	} else {
		return 0;
	}
}

int wGetPos (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);

	// Cherche si la fenêtre existe...
	HWND WinHandle = FindWindow(NULL, Par1);

	if (WinHandle==NULL)
		return -1;

	// Récupère la position...
	WINDOWPLACEMENT WinPlace;
	GetWindowPlacement(WinHandle,&WinPlace);
	RECT WinPos = WinPlace.rcNormalPosition;

	// Cherche la position demandée...
	if (IsEqualNoCase(Par2, "left"))
	{
		return WinPos.left;
	} else if (IsEqualNoCase(Par2, "top")) {
		return WinPos.top;
	} else {
		return -2;
	}
}

int wSetSize (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);
	StringParser(Par3);

	int Par2int;//Transforme les types char* en int...
	sscanf(Par2, "%d", &Par2int);
	int Par3int;
	sscanf(Par3, "%d", &Par3int);

	HWND WinHandle = FindWindow(NULL, Par1);

	if (WinHandle==NULL)
		return -1;

	if (SetWindowPos(WinHandle,NULL,NULL,NULL,Par2int,Par3int,SWP_NOMOVE))
	{
		return 1;
	} else {
		return 0;
	}
}

int wGetSize (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...
	StringParser(Par2);

	// Cherche si la fenêtre existe...
	HWND WinHandle = FindWindow(NULL, Par1);

	if (WinHandle==NULL)
		return -1;

	// Récupère la taille...
	WINDOWPLACEMENT WinPlace;
	GetWindowPlacement(WinHandle,&WinPlace);
	RECT WinPos = WinPlace.rcNormalPosition;

	// Cherche la taille demandée...
	if (IsEqualNoCase(Par2, "width"))
	{
		return WinPos.right-WinPos.left;
	} else if (IsEqualNoCase(Par2, "height")) {
		return WinPos.bottom-WinPos.top;
	} else {
		return -2;
	}
}

int wExist (char *Par1, char *Par2, char *Par3)
{
	StringParser(Par1);//Execute et modifie les paramètres...

	// Cherche si la fenêtre existe...
	if (FindWindow(NULL, Par1)==NULL)
		return 0;
	else
		return 1;
}