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

int FCountLines (const char* FileName)
{
	FILE* FileOpen = NULL;//Ouvre le fichier...
	FileOpen = fopen(FileName, "r");
	if (FileOpen == NULL)
	{
		return -1;
	} else {
		char chaine[1000] = {NULL};
		int i = 0;
		while (fgets(chaine, 1000, FileOpen) != NULL) //On lit le fichier tant qu'on ne reçoit pas d'erreur (NULL)...
		{
			i++;
		}
		fclose(FileOpen);
		return i;
	}
}

/* CheckFunc :
   Retour : voir "Mots Clefs 2 ID.txt"
*/
int CheckFunc(char* LineContent)
{
	int Ubound = strlen(LineContent), i;
	for (i = 0; i < Ubound+1; i++)
	{
		if (LineContent[i] == '/' && LineContent[i+1] == '/')//Cherche les commentaire...
		{
			return -11;
		}
		if (LineContent[i] == '\n')//Cherche les lignes vides...
		{
			return -11;
		}
		if (LineContent[i] != ' ' && LineContent[i] != '	')//Exclus les caractères espace et tabulation.
		{
			if (LineContent[i] == '#' )//Recheche le type...
			{
				if (IsOnLeft(LineContent,"#include",i)) {return 11;}
				else if (IsOnLeft(LineContent,"#replace",i)) {return 12;}
				else if (IsOnLeft(LineContent,"#noNotifyErr",i)) {return 13;}
				else if (IsOnLeft(LineContent,"#isReplace",i)) {return 14;}
				else {return 0;}
			}
			if (LineContent[i] == '$' )
			{
				return 20;
			}
			if (LineContent[i] == 'f' )
			{
				if (IsOnLeft(LineContent,"for",i)) {return 41;}
				else if (IsOnLeft(LineContent,"fWrite",i)) {return 42;}
				else if (IsOnLeft(LineContent,"fRead",i)) {return 43;}
				else if (IsOnLeft(LineContent,"fDel",i)) {return 45;}
				else if (IsOnLeft(LineContent,"fCreate",i)) {return 46;}
				else if (IsOnLeft(LineContent,"fMove",i)) {return 47;}
				else if (IsOnLeft(LineContent,"fCopy",i)) {return 48;}
				else if (IsOnLeft(LineContent,"fRun",i)) {return 49;}
				else if (IsOnLeft(LineContent,"func",i)) {return 410;}
				else if (IsOnLeft(LineContent,"fExist",i)) {return 411;}
				else {return 0;}
			}
			if (LineContent[i] == 'd' )
			{
				if (IsOnLeft(LineContent,"dDel",i)) {return 51;}
				else if (IsOnLeft(LineContent,"dCreate",i)) {return 52;}
				else if (IsOnLeft(LineContent,"dMove",i)) {return 53;}
				else if (IsOnLeft(LineContent,"dCopy",i)) {return 54;}
				else if (IsOnLeft(LineContent,"dExist",i)) {return 55;}
				else {return 0;}
			}
			if (LineContent[i] == 'p' )
			{
				if (IsOnLeft(LineContent,"pDel",i)) {return 61;}
				else if (IsOnLeft(LineContent,"pSet",i)) {return 62;}
				else if (IsOnLeft(LineContent,"pExist",i)) {return 63;}
				else if (IsOnLeft(LineContent,"pWait",i)) {return 64;}
				else {return 0;}
			}
			if (LineContent[i] == 'm' )
			{
				if (IsOnLeft(LineContent,"mMove",i)) {return 71;}
				else if (IsOnLeft(LineContent,"mLeft",i)) {return 72;}
				else if (IsOnLeft(LineContent,"mRight",i)) {return 73;}
				else if (IsOnLeft(LineContent,"message",i)) {return 74;}
				else {return 0;}
			}
			if (LineContent[i] == 'k' )
			{
				if (IsOnLeft(LineContent,"kSend",i)) {return 81;}
				else if (IsOnLeft(LineContent,"kDown",i)) {return 82;}
				else if (IsOnLeft(LineContent,"kUp",i)) {return 83;}
				else {return 0;}
			}
			if (LineContent[i] == 'e' )
			{
				if (IsOnLeft(LineContent,"elseIf",i)) {return 92;}
				else if (IsOnLeft(LineContent,"else",i)) {return 91;}
				else if (IsOnLeft(LineContent,"exitLoop",i)) {return 93;}
				else if (IsOnLeft(LineContent,"exit",i)) {return 94;}
				else if (IsOnLeft(LineContent,"endW",i)) {return 95;}
				else if (IsOnLeft(LineContent,"endF",i)) {return 96;}
				else {return 0;}
			}
			if (LineContent[i] == 's' )
			{
				if (IsOnLeft(LineContent,"sleep",i)) {return 101;}
				else if (IsOnLeft(LineContent,"sSetErr",i)) {return 102;}
				else if (IsOnLeft(LineContent,"sExitCode",i)) {return 103;}
				else if (IsOnLeft(LineContent,"sGetOsInfo",i)) {return 105;}
				else if (IsOnLeft(LineContent,"sWriteErr",i)) {return 106;}
				else if (IsOnLeft(LineContent,"strInStr",i)) {return 107;}
				else if (IsOnLeft(LineContent,"strLeft",i)) {return 108;}
				else if (IsOnLeft(LineContent,"strLen",i)) {return 109;}
				else if (IsOnLeft(LineContent,"strReplace",i)) {return 1010;}
				else if (IsOnLeft(LineContent,"strRight",i)) {return 1011;}
				else if (IsOnLeft(LineContent,"sGetEnv",i)) {return 1012;}
				else if (IsOnLeft(LineContent,"sSetEnv",i)) {return 1013;}
				else {return 0;}
			}
			if (LineContent[i] == 'w' )
			{
				if (IsOnLeft(LineContent,"while",i)) {return 111;}
				else if (IsOnLeft(LineContent,"wActivate",i)) {return 112;}
				else if (IsOnLeft(LineContent,"wWait",i)) {return 113;}
				else if (IsOnLeft(LineContent,"wSetPos",i)) {return 114;}
				else if (IsOnLeft(LineContent,"wGetPos",i)) {return 115;}
				else if (IsOnLeft(LineContent,"wSetSize",i)) {return 116;}
				else if (IsOnLeft(LineContent,"wGetSize",i)) {return 117;}
				else if (IsOnLeft(LineContent,"wExist",i)) {return 118;}
				else {return 0;}
			}
			if (LineContent[i] == 'n' )
			{
				if (IsOnLeft(LineContent,"next",i)) {return 121;}
				else {return 0;}
			}
			if (LineContent[i] == 'i' )
			{
				if (IsOnLeft(LineContent,"if",i)) {return 131;}
				if (IsOnLeft(LineContent,"isDeclared",i)) {return 132;}
				else {return 0;}
			}
			if (LineContent[i] == 'c' )
			{
				if (IsOnLeft(LineContent,"console",i)) {return 141;}
				else if (IsOnLeft(LineContent,"cWrite",i)) {return 142;}
				else if (IsOnLeft(LineContent,"cClear",i)) {return 143;}
				else if (IsOnLeft(LineContent,"cGet",i)) {return 144;}
				else if (IsOnLeft(LineContent,"cTitle",i)) {return 145;}
				else if (IsOnLeft(LineContent,"cExec",i)) {return 146;}
				else {return 0;}
			}
			if (LineContent[i] == '}' )
			{
				return 150;
			}
			if (LineContent[i] == 'r' )
			{
				if (IsOnLeft(LineContent,"random",i)) {return 161;}
				else if (IsOnLeft(LineContent,"return",i)) {return 162;}
				else {return 0;}
			}
			return 0;
		}
	}
	return 0;
}

int CallFSPsFonc(char* LineContent, int FuncID)
{
	if (FuncID != -11)
	{
		fprintf(GetStdInfoHandle(), "Demande de lancement de la fonction d'ID %d :\n",FuncID);
		fflush(NULL);
	}
	if (FuncID != -11 && FuncID != 20)//Elimine les commentaires et les variables.
	{
		fprintf(GetStdInfoHandle(), "Recherche de parametres dans la fonction...\n");
		fflush(NULL);
		//Découpage des paramètres en 3 variables...
		char Void[1000], Par1[1000], Par2[1000], Par3[1000];
		sscanf(LineContent, "%[^(](%[^,],%[^,],%[^,]", &Void, &Par1, &Par2, &Par3);
		fprintf(GetStdInfoHandle(), "1er parametre : %s\n2nd parametre : %s\n3em parametre : %s\n", &Par1,&Par2,&Par3);
		fprintf(GetStdInfoHandle(), "Appel de la fonction source correspondante...\n",FuncID);
		fflush(NULL);
		//Appel de la fonction correspondante à l'ID...
		if (FuncID == 42) {return fWrite(Par1, Par2, Par3);}
		else if (FuncID == 45)   {return fDel(Par1, Par2, Par3);}
		else if (FuncID == 46)   {return fCreate(Par1, Par2, Par3);}
		else if (FuncID == 47)   {return fMove(Par1, Par2, Par3);}
		else if (FuncID == 48)   {return fCopy(Par1, Par2, Par3);}
		else if (FuncID == 49)   {return fRun(Par1, Par2, Par3);}
		else if (FuncID == 411)  {return fExist(Par1, Par2, Par3);}
		else if (FuncID == 51)   {return dDel(Par1, Par2, Par3);}
		else if (FuncID == 52)   {return dCreate(Par1, Par2, Par3);}
		else if (FuncID == 53)   {return dMove(Par1, Par2, Par3);}
		else if (FuncID == 54)   {return dCopy(Par1, Par2, Par3);}
		else if (FuncID == 55)   {return dExist(Par1, Par2, Par3);}
		else if (FuncID == 61)   {return pDel(Par1, Par2, Par3);}
		else if (FuncID == 62)   {return pSet(Par1, Par2, Par3);}
		else if (FuncID == 63)   {return pExist(Par1, Par2, Par3);}
		else if (FuncID == 64)   {return pWait(Par1, Par2, Par3);}
		else if (FuncID == 71)   {return mMove(Par1, Par2, Par3);}
		else if (FuncID == 72)   {return mLeft(Par1, Par2, Par3);}
		else if (FuncID == 73)   {return mRight(Par1, Par2, Par3);}
		else if (FuncID == 81)   {return kSend(Par1, Par2, Par3);}
		else if (FuncID == 82)   {return kDown(Par1, Par2, Par3);}
		else if (FuncID == 83)   {return kUp(Par1, Par2, Par3);}
		else if (FuncID == 74)   {return message(Par1, Par2, Par3);}
		else if (FuncID == 101)  {return sleep(Par1, Par2, Par3);}
		else if (FuncID == 102)  {return sSetErr(Par1, Par2, Par3);}
		else if (FuncID == 103)  {return sExitCode(Par1, Par2, Par3);}
		else if (FuncID == 106)  {return sWriteErr(Par1, Par2, Par3);}
		else if (FuncID == 112)  {return wActivate(Par1, Par2, Par3);}
		else if (FuncID == 113)  {return wWait(Par1, Par2, Par3);}
		else if (FuncID == 114)  {return wSetPos(Par1, Par2, Par3);}
		else if (FuncID == 115)  {return wGetPos(Par1, Par2, Par3);}
		else if (FuncID == 116)  {return wSetSize(Par1, Par2, Par3);}
		else if (FuncID == 117)  {return wGetSize(Par1, Par2, Par3);}
		else if (FuncID == 118)  {return wExist(Par1, Par2, Par3);}
		else if (FuncID == 132)  {return isDeclared(Par1, Par2, Par3);}
		else if (FuncID == 141)  {return console(Par1, Par2, Par3);}
		else if (FuncID == 142)  {return cWrite(Par1, Par2, Par3);}
		else if (FuncID == 143)  {return cClear(Par1, Par2, Par3);}
		else if (FuncID == 145)  {return cTitle(Par1, Par2, Par3);}
		else if (FuncID == 146)  {return cExec(Par1, Par2, Par3);}
		else if (FuncID == 161)  {return random(Par1, Par2, Par3);}
		else if (FuncID == 1013) {return sSetEnv(Par1, Par2, Par3);}

		return 0;
	}
	return 0;
}

/* Fontion IsOnLeft :
Retour : 1 si StringToSearch est à gauche de StringStart.
         0 si StringToSearch n'est pas à gauche de StringStart.
*/
int IsOnLeft(char* StringStart, char* StringToSearch, int iStart)
{
	int StartLen = strlen(StringStart), SearchLen = strlen(StringToSearch), i, j = 0;
	if (SearchLen > StartLen) {return 0;}
	for (i = iStart; i < SearchLen; i++)
	{
		if (StringStart[i] != StringToSearch[j]) {return 0;}//Cerche si un caractère vaut le bon...
		j++;
	}
	return 1;
}

/* Fontion IsOnRight :
Retour : 1 si StringToSearch est à droite de StringStart.
         0 si StringToSearch n'est pas à droite de StringStart.
*/
int IsOnRight(char* StringStart, char* StringToSearch, int iStart)
{
	int StartLen = strlen(StringStart), SearchLen = strlen(StringToSearch), i, j = strlen(StringToSearch)-1;
	if (SearchLen > StartLen) {return 0;}
	for (i = StartLen-iStart-1; i >= StartLen-SearchLen-iStart; i--)
	{
		if (StringStart[i] != StringToSearch[j]) {return 0;}
		j--;
	}
	return 1;
}

bool FolderExists(std::string file)
{
DWORD returnvalue;
returnvalue = GetFileAttributes(file.c_str());
	if(returnvalue == ((DWORD)-1))
	{
		return false;
	}
	else
	{	return true;
	}
}

int KILL_PROC_BY_NAME(const char *szToTerminate)
// Created: 6/23/2000  (RK)
// Last modified: 3/10/2002  (RK)
// Please report any problems or bugs to kochhar@physiology.wisc.edu
// The latest version of this routine can be found at:
//     http://www.neurophys.wisc.edu/ravi/software/killproc/
// Terminate the process "szToTerminate" if it is currently running
// This works for Win/95/98/ME and also Win/NT/2000/XP
// The process name is case-insensitive, i.e. "notepad.exe" and "NOTEPAD.EXE"
// will both work (for szToTerminate)
// Return codes are as follows:
//   0   = Process was successfully terminated
//   603 = Process was not currently running
//   604 = No permission to terminate process
//   605 = Unable to load PSAPI.DLL
//   602 = Unable to terminate process for some other reason
//   606 = Unable to identify system type
//   607 = Unsupported OS
//   632 = Invalid process name
//   700 = Unable to get procedure address from PSAPI.DLL
//   701 = Unable to get process list, EnumProcesses failed
//   702 = Unable to load KERNEL32.DLL
//   703 = Unable to get procedure address from KERNEL32.DLL
//   704 = CreateToolhelp32Snapshot failed
// Change history:
//   modified 3/8/2002  - Borland-C compatible if BORLANDC is defined as
//                        suggested by Bob Christensen
//   modified 3/10/2002 - Removed memory leaks as suggested by
//					      Jonathan Richard-Brochu (handles to Proc and Snapshot
//                        were not getting closed properly in some cases)
{
	BOOL bResult,bResultm;
	DWORD aiPID[1000],iCb=1000,iNumProc,iV2000=0;
	DWORD iCbneeded,i,iFound=0;
	char szName[MAX_PATH],szToTermUpper[MAX_PATH];
	HANDLE hProc,hSnapShot,hSnapShotm;
	OSVERSIONINFO osvi;
    HINSTANCE hInstLib;
	int iLen,iLenP,indx;
    HMODULE hMod;
	PROCESSENTRY32 procentry;      
	MODULEENTRY32 modentry;

	// Transfer Process name into "szToTermUpper" and
	// convert it to upper case
	iLenP=strlen(szToTerminate);
	if(iLenP<1 || iLenP>MAX_PATH) return 632;
	for(indx=0;indx<iLenP;indx++)
		szToTermUpper[indx]=toupper(szToTerminate[indx]);
	szToTermUpper[iLenP]=0;

     // PSAPI Function Pointers.
     BOOL (WINAPI *lpfEnumProcesses)( DWORD *, DWORD cb, DWORD * );
     BOOL (WINAPI *lpfEnumProcessModules)( HANDLE, HMODULE *,
        DWORD, LPDWORD );
     DWORD (WINAPI *lpfGetModuleBaseName)( HANDLE, HMODULE,
        LPTSTR, DWORD );

      // ToolHelp Function Pointers.
      HANDLE (WINAPI *lpfCreateToolhelp32Snapshot)(DWORD,DWORD) ;
      BOOL (WINAPI *lpfProcess32First)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfProcess32Next)(HANDLE,LPPROCESSENTRY32) ;
      BOOL (WINAPI *lpfModule32First)(HANDLE,LPMODULEENTRY32) ;
      BOOL (WINAPI *lpfModule32Next)(HANDLE,LPMODULEENTRY32) ;

	// First check what version of Windows we're in
	osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    bResult=GetVersionEx(&osvi);
	if(!bResult)     // Unable to identify system version
	    return 606;

	// At Present we only support Win/NT/2000/XP or Win/9x/ME
	if((osvi.dwPlatformId != VER_PLATFORM_WIN32_NT) &&
		(osvi.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS))
		return 607;

    if(osvi.dwPlatformId==VER_PLATFORM_WIN32_NT)
	{
		// Win/NT or 2000 or XP

         // Load library and get the procedures explicitly. We do
         // this so that we don't have to worry about modules using
         // this code failing to load under Windows 9x, because
         // it can't resolve references to the PSAPI.DLL.
         hInstLib = LoadLibraryA("PSAPI.DLL");
         if(hInstLib == NULL)
            return 605;

         // Get procedure addresses.
         lpfEnumProcesses = (BOOL(WINAPI *)(DWORD *,DWORD,DWORD*))
            GetProcAddress( hInstLib, "EnumProcesses" ) ;
         lpfEnumProcessModules = (BOOL(WINAPI *)(HANDLE, HMODULE *,
            DWORD, LPDWORD)) GetProcAddress( hInstLib,
            "EnumProcessModules" ) ;
         lpfGetModuleBaseName =(DWORD (WINAPI *)(HANDLE, HMODULE,
            LPTSTR, DWORD )) GetProcAddress( hInstLib,
            "GetModuleBaseNameA" ) ;

         if(lpfEnumProcesses == NULL ||
            lpfEnumProcessModules == NULL ||
            lpfGetModuleBaseName == NULL)
            {
               FreeLibrary(hInstLib);
               return 700;
            }
		 
		bResult=lpfEnumProcesses(aiPID,iCb,&iCbneeded);
		if(!bResult)
		{
			// Unable to get process list, EnumProcesses failed
            FreeLibrary(hInstLib);
			return 701;
		}

		// How many processes are there?
		iNumProc=iCbneeded/sizeof(DWORD);

		// Get and match the name of each process
		for(i=0;i<iNumProc;i++)
		{
			// Get the (module) name for this process

	        strcpy(szName,"Unknown");
			// First, get a handle to the process
	        hProc=OpenProcess(PROCESS_QUERY_INFORMATION|PROCESS_VM_READ,FALSE,
				aiPID[i]);
	        // Now, get the process name
	        if(hProc)
			{
               if(lpfEnumProcessModules(hProc,&hMod,sizeof(hMod),&iCbneeded) )
			   {
                  iLen=lpfGetModuleBaseName(hProc,hMod,szName,MAX_PATH);
			   }
			}
	        CloseHandle(hProc);
			// We will match regardless of lower or upper case
#ifdef BORLANDC
            if(strcmp(strupr(szName),szToTermUpper)==0)
#else
			if(strcmp(_strupr(szName),szToTermUpper)==0)
#endif
			{
				// Process found, now terminate it
				iFound=1;
				// First open for termination
				hProc=OpenProcess(PROCESS_TERMINATE,FALSE,aiPID[i]);
				if(hProc)
				{
					if(TerminateProcess(hProc,0))
					{
						// process terminated
						CloseHandle(hProc);
                        FreeLibrary(hInstLib);
						return 0;
					}
					else
					{
						// Unable to terminate process
						CloseHandle(hProc);
                        FreeLibrary(hInstLib);
						return 602;
					}
				}
				else
				{
					// Unable to open process for termination
                    FreeLibrary(hInstLib);
					return 604;
				}
			}
		}
	}

	if(osvi.dwPlatformId==VER_PLATFORM_WIN32_WINDOWS)
	{
		// Win/95 or 98 or ME
			
		hInstLib = LoadLibraryA("Kernel32.DLL");
		if( hInstLib == NULL )
			return 702;

		// Get procedure addresses.
		// We are linking to these functions of Kernel32
		// explicitly, because otherwise a module using
		// this code would fail to load under Windows NT,
		// which does not have the Toolhelp32
		// functions in the Kernel 32.
		lpfCreateToolhelp32Snapshot=
			(HANDLE(WINAPI *)(DWORD,DWORD))
			GetProcAddress( hInstLib,
			"CreateToolhelp32Snapshot" ) ;
		lpfProcess32First=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32First" ) ;
		lpfProcess32Next=
			(BOOL(WINAPI *)(HANDLE,LPPROCESSENTRY32))
			GetProcAddress( hInstLib, "Process32Next" ) ;
		lpfModule32First=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32First" ) ;
		lpfModule32Next=
			(BOOL(WINAPI *)(HANDLE,LPMODULEENTRY32))
			GetProcAddress( hInstLib, "Module32Next" ) ;
		if( lpfProcess32Next == NULL ||
			lpfProcess32First == NULL ||
		    lpfModule32Next == NULL ||
			lpfModule32First == NULL ||
			lpfCreateToolhelp32Snapshot == NULL )
		{
			FreeLibrary(hInstLib);
			return 703;
		}
			
		// The Process32.. and Module32.. routines return names in all uppercase

		// Get a handle to a Toolhelp snapshot of all the systems processes.

		hSnapShot = lpfCreateToolhelp32Snapshot(
			TH32CS_SNAPPROCESS, 0 ) ;
		if( hSnapShot == INVALID_HANDLE_VALUE )
		{
			FreeLibrary(hInstLib);
			return 704;
		}
		
        // Get the first process' information.
        procentry.dwSize = sizeof(PROCESSENTRY32);
        bResult=lpfProcess32First(hSnapShot,&procentry);

        // While there are processes, keep looping and checking.
        while(bResult)
        {
		    // Get a handle to a Toolhelp snapshot of this process.
		    hSnapShotm = lpfCreateToolhelp32Snapshot(
			    TH32CS_SNAPMODULE, procentry.th32ProcessID) ;
		    if( hSnapShotm == INVALID_HANDLE_VALUE )
			{
				CloseHandle(hSnapShot);
			    FreeLibrary(hInstLib);
			    return 704;
			}
			// Get the module list for this process
			modentry.dwSize=sizeof(MODULEENTRY32);
			bResultm=lpfModule32First(hSnapShotm,&modentry);

			// While there are modules, keep looping and checking
			while(bResultm)
			{
		        if(strcmp(modentry.szModule,szToTermUpper)==0)
				{
				    // Process found, now terminate it
				    iFound=1;
				    // First open for termination
				    hProc=OpenProcess(PROCESS_TERMINATE,FALSE,procentry.th32ProcessID);
				    if(hProc)
					{
					    if(TerminateProcess(hProc,0))
						{
						    // process terminated
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
			                FreeLibrary(hInstLib);
						    return 0;
						}
					    else
						{
						    // Unable to terminate process
							CloseHandle(hSnapShotm);
							CloseHandle(hSnapShot);
							CloseHandle(hProc);
			                FreeLibrary(hInstLib);
						    return 602;
						}
					}
				    else
					{
					    // Unable to open process for termination
						CloseHandle(hSnapShotm);
						CloseHandle(hSnapShot);
			            FreeLibrary(hInstLib);
					    return 604;
					}
				}
				else
				{  // Look for next modules for this process
					modentry.dwSize=sizeof(MODULEENTRY32);
					bResultm=lpfModule32Next(hSnapShotm,&modentry);
				}
			}

			//Keep looking
			CloseHandle(hSnapShotm);
            procentry.dwSize = sizeof(PROCESSENTRY32);
            bResult = lpfProcess32Next(hSnapShot,&procentry);
        }
		CloseHandle(hSnapShot);
	}
	if(iFound==0)
	{
		FreeLibrary(hInstLib);
		return 603;
	}
	FreeLibrary(hInstLib);
	return 0;
}

int KeyStrToID(char* KeyStr)
{
	/*if (*KeyStr == 'A') {return 0x41;}
	else if (*KeyStr == 'B') {return 0x42;}
	else if (*KeyStr == 'C') {return 0x43;}
	else if (*KeyStr == 'D') {return 0x44;}
	else if (*KeyStr == 'E') {return 0x45;}
	else if (*KeyStr == 'F') {return 0x46;}
	else if (*KeyStr == 'G') {return 0x47;}
	else if (*KeyStr == 'H') {return 0x48;}
	else if (*KeyStr == 'I') {return 0x49;}
	else if (*KeyStr == 'J') {return 0x4A;}
	else if (*KeyStr == 'K') {return 0x4B;}
	else if (*KeyStr == 'L') {return 0x4C;}
	else if (*KeyStr == 'M') {return 0x4D;}
	else if (*KeyStr == 'N') {return 0x4E;}
	else if (*KeyStr == 'O') {return 0x4F;}
	else if (*KeyStr == 'P') {return 0x50;}
	else if (*KeyStr == 'Q') {return 0x51;}
	else if (*KeyStr == 'R') {return 0x52;}
	else if (*KeyStr == 'S') {return 0x53;}
	else if (*KeyStr == 'T') {return 0x54;}
	else if (*KeyStr == 'U') {return 0x55;}
	else if (*KeyStr == 'V') {return 0x56;}
	else if (*KeyStr == 'W') {return 0x57;}
	else if (*KeyStr == 'X') {return 0x58;}
	else if (*KeyStr == 'Y') {return 0x59;}
	else if (*KeyStr == 'Z') {return 0x5A;}
	else if (*KeyStr == '0') {return 0x60;}
	else if (*KeyStr == '1') {return 0x61;}
	else if (*KeyStr == '2') {return 0x62;}
	else if (*KeyStr == '3') {return 0x63;}
	else if (*KeyStr == '4') {return 0x64;}
	else if (*KeyStr == '5') {return 0x65;}
	else if (*KeyStr == '6') {return 0x66;}
	else if (*KeyStr == '7') {return 0x67;}
	else if (*KeyStr == '8') {return 0x68;}
	else if (*KeyStr == '9') {return 0x69;}
	else if (*KeyStr == ' ') {return 0x20;}
	else if (*KeyStr == '*') {return 0x6a;}
	else if (*KeyStr == '+') {return 0x6b;}
	else if (*KeyStr == '-') {return 0x6d;}
	else if (*KeyStr == '/') {return 0x6f;}
	else if (IsEqualNoCase(KeyStr,"{win}")) {return 0x5B;}
	else if (IsEqualNoCase(KeyStr,"{tab}")) {return 0x09;}
	else if (IsEqualNoCase(KeyStr,"{ctrl}")) {return 0x11;}
	else if (IsEqualNoCase(KeyStr,"{alt}")) {return 0x12;}
	else if (IsEqualNoCase(KeyStr,"{esc}")) {return 0x1B;}
	else if (IsEqualNoCase(KeyStr,"{print}")) {return 0x2C;}
	else if (IsEqualNoCase(KeyStr,"{enter}")) {return 0x0D;}
	else if (IsEqualNoCase(KeyStr,"{bs}")) {return 0x08;}
	else if (IsEqualNoCase(KeyStr,"{del}")) {return 0x2E;}
	else if (IsEqualNoCase(KeyStr,"{caps}")) {return 0x14;}
	else if (IsEqualNoCase(KeyStr,"{space}")) {return 0x20;}
	else if (IsEqualNoCase(KeyStr,"{up}")) {return 0x26;}
	else if (IsEqualNoCase(KeyStr,"{down}")) {return 0x28;}
	else if (IsEqualNoCase(KeyStr,"{left}")) {return 0x25;}
	else if (IsEqualNoCase(KeyStr,"{right}")) {return 0x27;}
	else {return 0;}*/

	// On traite d'abord les codes ASCII transparents entre ASCII et les codes Virtual Key Codes
       if ((*KeyStr >= 'A' && *KeyStr <= 'Z') || (*KeyStr == ' ')) {return (int)*KeyStr;}
       if ((*KeyStr >= '0' && *KeyStr <= '9')) {return (VK_NUMPAD0+((int)*KeyStr) - '0');} //0x60
       else if (*KeyStr == '*') {return VK_MULTIPLY;} //0x6A
       else if (*KeyStr == '+') {return VK_ADD;} //0x6B
       else if (*KeyStr == '-') {return VK_SUBTRACT;} //0x6D
       else if (*KeyStr == '/') {return VK_DIVIDE;} //0x6F
       else if (*KeyStr == ',') {return VK_OEM_COMMA;} //0xBC
       else if (*KeyStr == '.') {return VK_OEM_PERIOD;} //0xBE
       else if (IsEqualNoCase(KeyStr,"{win}")) {return VK_LWIN;} //0x5B
       else if (IsEqualNoCase(KeyStr,"{tab}")) {return VK_TAB;} //0x09
       else if (IsEqualNoCase(KeyStr,"{ctrl}")) {return VK_CONTROL;} //0x11
       else if (IsEqualNoCase(KeyStr,"{alt}")) {return VK_MENU;} //0x12
       else if (IsEqualNoCase(KeyStr,"{esc}")) {return VK_ESCAPE;} //0x1B
       else if (IsEqualNoCase(KeyStr,"{print}")) {return VK_SNAPSHOT;} //0x2C
       else if (IsEqualNoCase(KeyStr,"{enter}")) {return VK_RETURN;} //0x0D
       else if (IsEqualNoCase(KeyStr,"{bs}")) {return VK_BACK;} //0x08
       else if (IsEqualNoCase(KeyStr,"{del}")) {return VK_DELETE;} //0x2E
       else if (IsEqualNoCase(KeyStr,"{caps}")) {return VK_CAPITAL;} //0x14
       else if (IsEqualNoCase(KeyStr,"{space}")) {return VK_SPACE;} //0x20
       else if (IsEqualNoCase(KeyStr,"{up}")) {return VK_UP;} //0x26
       else if (IsEqualNoCase(KeyStr,"{down}")) {return VK_DOWN;} //0x28
       else if (IsEqualNoCase(KeyStr,"{left}")) {return VK_LEFT;} //0x25
       else if (IsEqualNoCase(KeyStr,"{right}")) {return VK_RIGHT;} //0x27
       else if (IsEqualNoCase(KeyStr,"{pause}")) {return VK_PAUSE;} //0x13
       else if (IsEqualNoCase(KeyStr,"{pup}")) {return VK_PRIOR;} //0x21
       else if (IsEqualNoCase(KeyStr,"{pdown}")) {return VK_NEXT;} //0x22
       else if (IsEqualNoCase(KeyStr,"{end}")) {return VK_END;} //0x23
       else if (IsEqualNoCase(KeyStr,"{home}")) {return VK_HOME;} //0x24
       else if (IsEqualNoCase(KeyStr,"{sel}")) {return VK_SELECT;} //0x29
       else if (IsEqualNoCase(KeyStr,"{ins}")) {return VK_INSERT;} //0x2D
       else if (IsEqualNoCase(KeyStr,"{apps}")) {return VK_APPS;} //0x5D
       else if (IsEqualNoCase(KeyStr,"{sleep}")) {return VK_SLEEP;} //0x5F
       else if (IsEqualNoCase(KeyStr,"{sep}")) {return VK_SEPARATOR;} //0x6C
       else if (IsEqualNoCase(KeyStr,"{f1}")) {return VK_F1;} //0x70
       else if (IsEqualNoCase(KeyStr,"{f2}")) {return VK_F2;} //0x71
       else if (IsEqualNoCase(KeyStr,"{f3}")) {return VK_F3;} //0x72
       else if (IsEqualNoCase(KeyStr,"{f4}")) {return VK_F4;} //0x73
       else if (IsEqualNoCase(KeyStr,"{f5}")) {return VK_F5;} //0x74
       else if (IsEqualNoCase(KeyStr,"{f6}")) {return VK_F6;} //0x75
       else if (IsEqualNoCase(KeyStr,"{f7}")) {return VK_F7;} //0x76
       else if (IsEqualNoCase(KeyStr,"{f8}")) {return VK_F8;} //0x77
       else if (IsEqualNoCase(KeyStr,"{f9}")) {return VK_F9;} //0x78
       else if (IsEqualNoCase(KeyStr,"{f10}")) {return VK_F10;} //0x79
       else if (IsEqualNoCase(KeyStr,"{f11}")) {return VK_F11;} //0x7A
       else if (IsEqualNoCase(KeyStr,"{f12}")) {return VK_F12;} //0x7B
       else if (IsEqualNoCase(KeyStr,"{numlock}")) {return VK_NUMLOCK;} //0x90
       else if (IsEqualNoCase(KeyStr,"{scroll}")) {return VK_SCROLL;} //0x91
       else if (IsEqualNoCase(KeyStr,"{mail}")) {return VK_LAUNCH_MAIL;} //0xB4
       else if (IsEqualNoCase(KeyStr,"{media}")) {return VK_LAUNCH_MEDIA_SELECT;} //0xB5
       else if (IsEqualNoCase(KeyStr,"{app1}")) {return VK_LAUNCH_APP1;} //0xB6
       else if (IsEqualNoCase(KeyStr,"{app2}")) {return VK_LAUNCH_APP2;} //0xB7
       else if (IsEqualNoCase(KeyStr,"{attn}")) {return VK_ATTN;} //0xF6
       else {return 0;}
}

/* Cette fonction retourne le handle d'un processus à partir de son nom */
HANDLE GetProcessHandle( char* szprocessname)
{
	DWORD dwprocessids[1024];
	DWORD dwreturned;
	char szbuffer[MAX_PATH];
	if(EnumProcesses(dwprocessids,1024,&dwreturned))
	{
		DWORD i;
		HANDLE hProcess;
		HMODULE hmod;
		DWORD dwcount=dwreturned/sizeof(DWORD);
		for(i=0;i<dwcount;i++)
		{
			hProcess=OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_VM_READ | PROCESS_SET_INFORMATION,0,dwprocessids[i]);
			if(hProcess)
			{
				if(EnumProcessModules(hProcess,&hmod,sizeof(HMODULE),&dwreturned))
				{
					GetModuleBaseName(hProcess,hmod,szbuffer,MAX_PATH);
					if(!lstrcmpi(szbuffer,szprocessname))return hProcess;
				}
				CloseHandle(hProcess);
			}
		}
	}
	return NULL;
}

char *replace(char *s, char *old, char *New)
{
	char *ret;
	int i, count = 0;
	size_t newlen = strlen(New);
	size_t oldlen = strlen(old);

	for (i = 0; s[i] != '\0'; i++)
	{
		if (strstr(&s[i], old) == &s[i])
		{
			count++;
			i += oldlen - 1;
		}
	}

	ret = (char*)malloc(i + count * (newlen - oldlen));
	if (ret == NULL)
	ExitErrLog(EXIT_FAILURE);

	i = 0;
	while (*s)
	{
		if (strstr(s, old) == s)
		{
			strcpy(&ret[i], New);
			i += newlen;
			s += oldlen;
		} else
		{
			ret[i++] = *s++;
		}
	}
	ret[i] = '\0';

	return ret;
}

bool IsTrue(char *Condition)
{
	if (strstr(Condition," && "))//Test les conditions multiples...
	{
		char Condition1[1000];
		sscanf(Condition, "%[^ && ]", &Condition1);//Recherche la première condition.
		strcpy( Condition, Condition + strlen(Condition1) + 4);//Supprime le  && .
		if (IsTrue(Condition) && IsTrue(Condition1)) {
			return true;
		} else {
			return false;
		}
	}
	if (strstr(Condition," || "))//Test les conditions multiples...
	{
		char Condition1[1000];
		sscanf(Condition, "%[^ || ]", &Condition1);//Recherche la première condition.
		strcpy( Condition, Condition + strlen(Condition1) + 4);//Supprime le  || .
		if (IsTrue(Condition) || IsTrue(Condition1)) {
			return true;
		} else {
			return false;
		}
	}

	bool True, False;

	if (IsOnLeft(Condition,"! ",0))//Cherche une négation...
	{
		True = false;
		False = true;
		strcpy( Condition, Condition + 2);//Supprime le ! .
	} else {
		True = true;
		False = false;
	}
	
	if (strstr(Condition,"!="))//Cherche le non-égal...
	{
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^!=]!=%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		if (IsOnLeft(FirstPart,SecondPart,0) && IsOnLeft(SecondPart,FirstPart,0))
		{
			return False;
		} else {
			return True;
		}
	} else if (strstr(Condition,"==")){// Cherche le égale (avec casse)...
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^==]==%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		if (IsOnLeft(FirstPart,SecondPart,0) && IsOnLeft(SecondPart,FirstPart,0))
		{
			return True;
		} else {
			return False;
		}
	} else if (strstr(Condition,"<=")) {//Cherche l'inférieur ou égal...
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^<=]<=%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		int FirstPartint, SecondParint;//Transforme les types char* en int...
		sscanf(FirstPart, "%d", &FirstPartint);
		sscanf(SecondPart, "%d", &SecondParint);

		if (FirstPartint <= SecondParint)
		{
			return True;
		} else {
			return False;
		}
	} else if (strstr(Condition,">=")) {//Cherche le supérieur ou égal...
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^>=]>=%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		int FirstPartint, SecondParint;//Transforme les types char* en int...
		sscanf(FirstPart, "%d", &FirstPartint);
		sscanf(SecondPart, "%d", &SecondParint);

		if (FirstPartint >= SecondParint)
		{
			return True;
		} else {
			return False;
		}
	} else if (strstr(Condition,"=")){// Cherche le égale (sans casse)...
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^=]=%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		if (IsEqualNoCase(FirstPart,SecondPart))
		{
			return True;
		} else {
			return False;
		}
	} else if (strstr(Condition,"<")) {//Cherche le strictement inférieur...
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^<]<%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		int FirstPartint, SecondParint;//Transforme les types char* en int...
		sscanf(FirstPart, "%d", &FirstPartint);
		sscanf(SecondPart, "%d", &SecondParint);

		if (FirstPartint < SecondParint)
		{
			return True;
		} else {
			return False;
		}
	} else if (strstr(Condition,">")) {//Cherche l'inférieur ou égal...
		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^>]>%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		int FirstPartint, SecondParint;//Transforme les types char* en int...
		sscanf(FirstPart, "%d", &FirstPartint);
		sscanf(SecondPart, "%d", &SecondParint);

		if (FirstPartint > SecondParint)
		{
			return True;
		} else {
			return False;
		}
	} else {//Si aucune condition...
		strcat(Condition,"!=0");//Cherche si la valeur est non nulle.

		char FirstPart[1000], SecondPart[1000];
		sscanf(Condition, "%[^!=]!=%[^\0]", &FirstPart, &SecondPart);//Recherche des deux partis.

		StringParser(FirstPart);//Execute et modifie les paramètres...
		StringParser(SecondPart);

		if (IsOnLeft(FirstPart,SecondPart,0) && IsOnLeft(SecondPart,FirstPart,0))
		{
			return False;
		} else {
			return True;
		}
	}
}

bool IsEqualNoCase(char *Str1, char *Str2)
{
	if (strlen(Str1) != strlen(Str2))//Vérifie si elles ont la même taille...
	{
		return false;
	}
	int i;
	for ( i=0; i<=strlen(Str1); i++)//Boucle pour vérifier caractère par caractère...
	{
		if (toupper(Str1[i]) != toupper(Str2[i]))//Si les caractères en majuscule ne correspondent pas...
		{
			return false;
		}
	}
	return true;
}

double ExprCalc( char *Expression)
{
	if (IsOnLeft(Expression,"-",0))
	{
		char TempZero[1000] = {"0"};
		strcat(TempZero,Expression);
		strcpy(Expression,TempZero);
	}
	EXPSTART expStart;
	double dResult;
	ExpressionLoad(&expStart, Expression, EXPRESSION_FLOATS);
	ExpressionCalculate(&expStart,  EXPRESSION_FLOATS , &dResult, NULL);
	return dResult; 
}

BOOL ExtractResource(DWORD ResId, LPCTSTR  FileName)
{
	HRSRC  hRes = FindResource(0, (LPTSTR)ResId, RT_RCDATA);
	LPVOID lpRes = LockResource(LoadResource(0, hRes));
	DWORD  dwSize = SizeofResource(0, hRes), dwWrite = -1;
	
	if(lpRes && dwSize)
	{
		HANDLE hFile = CreateFile(FileName, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
		
		if(hFile != INVALID_HANDLE_VALUE)
		{
			WriteFile(hFile, lpRes, dwSize, &dwWrite, 0);
			CloseHandle(hFile);
		}
	}
	return dwWrite == dwSize;
}

std::string openfilename(char *filter, HWND owner)
{
	OPENFILENAME ofn;
	char fileName[MAX_PATH] = "";
	ZeroMemory(&ofn, sizeof(ofn));
	ofn.lStructSize = sizeof(OPENFILENAME);
	ofn.hwndOwner = owner;
	ofn.lpstrFilter = filter;
	ofn.lpstrFile = fileName;
	ofn.nMaxFile = MAX_PATH;
	ofn.Flags = OFN_EXPLORER | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
	ofn.lpstrDefExt = "";
	std::string fileNameStr;
	if ( GetOpenFileName(&ofn) )
		fileNameStr = fileName;
	return fileNameStr;
}

/**
* @param location The location of the registry key. For example "Software\\Bethesda Softworks\\Morrowind"
* @param name the name of the registry key, for example "Installed Path"
* @return the value of the key or an empty string if an error occured.
*/
// Créée par Yacoby.
std::string getRegKey(const std::string& location, const std::string& name)
{
    HKEY key;
    TCHAR value[1024]; 
    DWORD bufLen = 1024*sizeof(TCHAR);
    long ret;
    ret = RegOpenKeyExA(HKEY_LOCAL_MACHINE, location.c_str(), 0, KEY_QUERY_VALUE, &key);
    if( ret != ERROR_SUCCESS ){
        return std::string();
    }
    ret = RegQueryValueExA(key, name.c_str(), 0, 0, (LPBYTE) value, &bufLen);
    RegCloseKey(key);
    if ( (ret != ERROR_SUCCESS) || (bufLen > 1024*sizeof(TCHAR)) ){
        return std::string();
    }
    std::string stringValue = std::string(value, (size_t)bufLen - 1);
    size_t i = stringValue.length();
    while( i > 0 && stringValue[i-1] == '\0' ){
        --i;
    }
    return stringValue.substr(0,i); 
}

int AdSpecialChar(char *StringToSet)
{
	strcpy(StringToSet,replace(StringToSet, "$", "{d}"));//Remplace les caractères interdits ($ , ; _ ( ) { et }")...
	strcpy(StringToSet,replace(StringToSet, ",", "{v}"));
	strcpy(StringToSet,replace(StringToSet, ";", "{p}"));
	strcpy(StringToSet,replace(StringToSet, "_", "{u}"));
	strcpy(StringToSet,replace(StringToSet, "(", "{po}"));
	strcpy(StringToSet,replace(StringToSet, ")", "{pc}"));
	strcpy(StringToSet,replace(StringToSet, "+", "{plus}"));
	strcpy(StringToSet,replace(StringToSet, "-", "{less}"));
	strcpy(StringToSet,replace(StringToSet, "*", "{mult}"));
	strcpy(StringToSet,replace(StringToSet, "/", "{divi}"));
	strcpy(StringToSet,replace(StringToSet, "%", "{modu}"));
	strcpy(StringToSet,replace(StringToSet, "!", "{em}"));
	strcpy(StringToSet,replace(StringToSet, "&", "{and}"));
	strcpy(StringToSet,replace(StringToSet, "|", "{vb}"));
	strcpy(StringToSet,replace(StringToSet,"\n","_crlf;"));
	return 0;
}

int DelBlankLeftChars(char *StringToClear)
{
	while (1)
	{
		if (IsOnLeft(StringToClear," ",0) || IsOnLeft(StringToClear,"	",0))
		{
			strcpy(StringToClear,StringToClear+1);
		} else {
			return 1;
		}
		if (strlen(StringToClear) == 1) {return 0;}
	}
}