no message

David René
1 parent f90f4995
Showing 16 changed files with 15 additions and 4311 deletions Show diff stats
anubis_dev/vm/proj/win32/.cvsignore
anubis_dev/vm/proj/win32/vm.dsp
anubis_dev/vm/src/FileIO.cpp
anubis_dev/vm/src/FileIO.h
anubis_dev/vm/src/IniFile.cpp
anubis_dev/vm/src/IniFile.h
anubis_dev/vm/src/String.cpp
anubis_dev/vm/src/String.h
anubis_dev/vm/src/anbexec.cpp
anubis_dev/vm/src/debug_log.cpp
anubis_dev/vm/src/debug_log.h
anubis_dev/vm/src/sslstuff.cpp
anubis_dev/vm/src/vm.cpp
anubis_dev/vm/src/vm.h
anubis_dev/vm/src/win32/host_graph.c
anubis_dev/vm/src/win32stuff.cpp
+*.obj
+*.pdb
 \ No newline at end of file
@@ -200,11 +200,11 @@ SOURCE=..\..\..\cipher\blowfish.c
 # End Source File
 # Begin Source File
  
-SOURCE=..\..\src\debug_log.cpp
+SOURCE=..\..\..\share\DebugLog.cpp
 # End Source File
 # Begin Source File
  
-SOURCE=..\..\src\FileIO.cpp
+SOURCE=..\..\..\share\FileIO.cpp
 # End Source File
 # Begin Source File
  
@@ -252,7 +252,7 @@ SOURCE=..\..\src\vmtools.cpp
 # End Source File
 # Begin Source File
  
-SOURCE=..\..\src\win32stuff.cpp
+SOURCE=..\..\..\share\win32stuff.cpp
 # End Source File
 # End Group
 # Begin Group "Header Files"
@@ -292,10 +292,6 @@ SOURCE=..\..\src\dependencies.h
 # End Source File
 # Begin Source File
  
-SOURCE=..\..\src\FileIO.h
-# End Source File
-# Begin Source File
-
 SOURCE=..\..\src\graphics.h
 # End Source File
 # Begin Source File
-
-#include "FileIO.h"
-#include <string.h>
-#include "debug_log.h"
-#include "dependencies.h"
-   
-   
-#if defined(__BEOS__) || defined(_LINUX_)
-#include <unistd.h>
-#include <stdlib.h>   
-#endif   
-   
-USING_NAMESPACE(CM);
-
-char FileSeparator(void)
-{
-#ifdef WIN32
-		return '\\';
-#elif defined(__BEOS__) || defined (_LINUX_)
-		return '/';
-#endif
-
-}
-
-void NormalizeFileName(char *pathName)
-{
-int		size = strlen(pathName);
-
-	for( int i = 0; i < size; i++)
-	{
-		if(pathName[i] == '\\' || pathName[i] == '/')
-		{
-#ifdef WIN32
-		pathName[i] = '\\';
-#elif defined(__BEOS__) || defined (_LINUX_)
-		pathName[i] = '/';
-#endif
-		}
-	}		
-}
-
-String GetVMRootDir(char * argv0)
-{
-#ifdef WIN32
-  String execDir = argv0;
-  NormalizeFileName((char *)execDir.Cstr());
-  int lastSlash = execDir.LastIndexOf('\\');
-  if(lastSlash != -1)
-    execDir = execDir.Substring(0, lastSlash);
-  else if (execDir.LastIndexOf(':') == -1)
-    {
-      execDir = ".";
-    }
-  return execDir;
-#endif
-#if defined(__BEOS__) || defined(_LINUX_)
-  String execDir; 
-  char *evPATH;
-  char *buf; 
-  int i,j,k; 
-
-  if (argv0[0] == '/')
-    {
-      i = 0; 
-      while (argv0[i] != 0) i++; 
-      while (argv0[i] != '/') i--;
-      argv0[i] = 0; 
-      execDir = argv0; 
-      return execDir; 
-    }
-  else
-    {
-      if ((evPATH = getenv("PATH")) == NULL)
-        {
-          LOGERROR("Your 'PATH' shell variable is not defined.\n"); // will probably never happen
-          my_exit(1); 
-        }
-   
-      if ((buf = (char *)malloc(strlen(evPATH)+strlen(argv0)+10)) == NULL)
-        {
-          LOGERROR("Not enough memory.\n");
-          my_exit(1);    
-        }
-
-      /* evPATH contains:
-   
-      "path_1:path_2:...:path_n"
-   
-      */ 
-   
-      i = 0;  // marker for beginning of path
-   
-      while (evPATH[i] != 0)   // while there is still some path to check
-        {
-          if (evPATH[i] == ':') { i++; } // avoid a possible leading ':'
-          // copy path to buffer
-          for (j = 0; evPATH[i+j] != ':' && evPATH[i+j] != 0; j++) { buf[j] = evPATH[i+j]; }
-          // append "/anbexec"
-          buf[j] = '/';
-          for (k = 0; argv0[k] != 0; k++) { buf[j+1+k] = argv0[k]; }
-          // put a delimiting zero
-          buf[j+1+k] = 0; 
-          // check if the file "path/anbexec" exists 
-          if (access(buf,F_OK) == 0)  // our file is here
-            {
-              // replace the '/' just before 'anbexec' by 0 (j did not change)
-              buf[j] = 0;    
-              printf("Directory of executable is '%s'\n",buf); 
-              execDir = buf; 
-              free(buf);
-              return execDir; 
-            }
-          // advance i
-          i += j; 
-        }
-   
-      LOGERROR("Unable to find directory of executable '%s'.\n",argv0); 
-      my_exit(1); 
-      return (String)NULL; 
-    }
-#endif
-}
-
-   
-#ifndef __FILE_IO_H__
-#define __FILE_IO_H__
-
-#include "AnubisSupport.h"
-#include "String.h"
-
-char FileSeparator(void);
-void NormalizeFileName(char *pathName);
-CM::String GetVMRootDir(char * argv0);
-
-#endif
-    /*******************************************************************
- * Fonctions de gestion de fichiers de parametres (.inf)           *
- *                                                                 *
- * Fichier source des fonctions.                                   *
- *                                                                 *
- * (c) 1996 - Philippe Castella                                    *
- * (c) 2000-2002 - David RENE move to C++ class                    *
- * (c) 2003-2004 - Carlipa Systems
- *******************************************************************/
-
-#include "AnubisSupport.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <malloc.h>
-#include <string.h>
-//#include "root/CSErrors.h"
-#include "IniFile.h"
-//#include "root/time/MLDate.h"
-//#include "root/DebugLog.h"
-//#include "root/support/PortableMacros.h"
-//#include "root/base64.h"
-//#include "root/time/MLDate.h"   //contient worldwideAtoF
-//#include "root/Path.h"
-//#include "root/FileIO.h"
-
-#define TYPE_DEFAULT 0
-#define TYPE_BASE64  1
-
-USING_NAMESPACE(CM);
-
-/*-----------------------------------------------------------------*
- * InfCreate : fonction de creation/ouverture d'un fichier .inf    *
- *                                                                 *
- * Entree : nom du fichier .inf                                    *
- * Sortie : un pointeur sur la nouvelle structure creee            *
- *                                                                 *
- * Derniere modification : 11 decembre 1996                        *
- *-----------------------------------------------------------------*/
-IniFile::IniFile(const String &fileName)
-{
- Init(fileName.Cstr());
-}
-
-IniFile::IniFile (const char *nomFic)
-{
- Init(nomFic);
-}
-
-void IniFile::Init(const char *nomFic)
-{
- _initCheck        = B_ERROR;
- _lastReadSection = NULL;
- _lastIsSection  = NULL;
- _mustSave         = false;
- _readCache        = NULL;
- _cacheByteCount   = 0;
- _cacheByteIdx     = 0;
- _currentstrVar    = NULL;
- _readError        = B_OK;
- strIni      = NULL;
-
- /* Ouverture du fichier */
- FILE *fileHandle = fopen (nomFic, "r");
- if(fileHandle == NULL /*&& FileExist(nomFic)*/)
- {
-  _initCheck = B_ERROR;
-  return;
- }
- /* Allocation de la memoire necessaire e la structure */
- strIni = new inifile_struct;
- if (strIni)
- {
-  /* Mise jour de la structure */
-  strIni->FileName = nomFic;
-  strIni->FirstSection = (InfSection *)0;
-
-  /* Si fichier existe, on lit son contenu */
-  if (fileHandle)
-  { /* Lecture ligne a ligne du fichier = remplir la structure */
-   //bigtime_t beginTime = GetCurrentuS();
-   ReadFile(fileHandle);
-   //bigtime_t endTime = GetCurrentuS();
-
-   //LOGTRACE("ReadFile [%s] %I64d milli ",nomFic, (endTime - beginTime)/1000);
-  }
-  _initCheck = B_OK;
- }
- else
- {
-  strIni = (inifile_struct *)0;
-  _initCheck = B_NO_MEMORY;
- }
- /* Fermeture du fichier */
- if(fileHandle)
-  fclose (fileHandle);
-}
-
-status_t IniFile::InitCheck() const
-{
- return _initCheck;
-}
-
-/*-----------------------------------------------------------------*
- * InfWriteBool    : Ajout d'une variable de type booleen.         *
- * InfWriteChar    : Ajout d'une variable de type char.            *
- * InfWriteInteger : Ajout d'une variable de type entier.          *
- * InfWriteInt64   : Ajout d'une variable de type entier 64.       *
- * InfWriteLong    : Ajout d'une variable de type long.            *
- * InfWriteFloat   : Ajout d'une variable de type double.          *
- * InfWriteString  : Ajout d'une variable de type chaine de car.   *
- *                                                                 *
- * Entree : nom de la section                                      *
- *          nom de la variable                                     *
- *          valeur de la variable                                  *
- * I/O    : L'adresse du pointeur sur la structure de donnees.     *
- *                                                                 *
- * Derniere modification : 3/6/2002                                *
- *-----------------------------------------------------------------*/
-void IniFile::WriteBool (const char *section, const char *var, bool val)
-{
- if (val)
-  AddVar (section, var, "1");
- else
-  AddVar (section, var, "0");
-}
-
-void IniFile::WriteChar (const char *section, const char *var, char val)
-{
- char buf[10];
-
- sprintf(buf, "%d", (int)val);
-// itoa ((int)val, buf, 10);
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteInteger (const char *section, const char *var, int  val)
-{
- char buf[10];
-
- sprintf(buf, "%d", (int)val);
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteInt64 (const char *section, const char *var, int64 val)
-{
- char buf[32];
-#ifdef WIN32
- sprintf(buf, "%I64d", val);
-#elif __BEOS__
- sprintf(buf, "%Ld", val);
-#endif
-
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteInt32 (const char *section, const char *var, int32  val)
-{
- char buf[10];
-
- sprintf(buf, "%ld", (int32)val);
-// ltoa (val, buf, 10);
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteInt16 (const char *section, const char *var, int16  val)
-{
- char buf[10];
-
- sprintf(buf, "%d", (int16)val);
-// ltoa (val, buf, 10);
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteLong (const char *section, const char *var, long  val)
-{
- char buf[10];
-
- sprintf(buf, "%ld", (long)val);
-// ltoa (val, buf, 10);
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteFloat (const char *section, const char *var, float val)
-{
- char buf[32];
-
- worldwideFtoA(val, buf, 31, 14, 'e');
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteDouble (const char *section, const char *var, double val)
-{
- char buf[32];
-
- worldwideFtoA(val, buf, 31, 14, 'g');
- AddVar (section, var, buf);
-}
-
-void IniFile::WriteString (const char *section, const char *var, const char *val)
-{
- AddVar (section, var, val);
-}
-
-void IniFile::WriteString (const char *section, const char *var, const String &val)
-{
- AddVar (section, var, val());
-}
-
-//void
-//IniFile::WriteStringList(const char *section, const char *var, char separator, const StringList & strList)
-//{
-// WriteString(section, var, strList.MakeFlattenedString(separator));
-//}
-//
-//void IniFile::WriteMessage(const char * section, const char *var, const PortableMessage &msg)
-//{
-// struct buffer_st b;
-//
-// size_t msgSize = msg.FlattenedSize();
-// uint8 * buffer = new uint8[msgSize];
-// msg.Flatten(buffer);
-//
-// ::Base64Encode(&b, (const char *)buffer, msgSize);
-//
-// AddVar(section, var, b.data, TYPE_BASE64);
-// 
-// SAFE_DELETE_TAB(buffer);
-// buffer_delete(&b);
-//}
-/*-----------------------------------------------------------------*
- * InfReadBool    : Lecture d'une variable de type booleen.        *
- * InfReadChar    : Lecture d'une variable de type char.           *
- * InfReadInteger : Lecture d'une variable de type entier.         *
- * InfReadLong    : Lecture d'une variable de type long.           *
- * InfReadFloat   : Lecture d'une variable de type double.         *
- * InfReadString  : Lecture d'une variable de type chaine de car.  *
- *                                                                 *
- * Entree : Le pointeur sur la structure de donnees.               *
- *          nom de la section                                      *
- *          nom de la variable                                     *
- *          valeur par defaut de la variable si non trouvee        *
- * I/O    : valeur de la variable                                  *
- *                                                                 *
- * Derniere modification : 3/6/2002                                *
- * DR                                                              *
- *-----------------------------------------------------------------*/
-status_t IniFile::ReadBool (const char *section, const char *var, bool def, bool *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = (bool)(atoi(buf) ? true : false);
- return err;
-}
-
-status_t IniFile::ReadChar (const char *section, const char *var, char def, char  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = (char)(atoi (buf));
- return err;
-}
-
-status_t IniFile::ReadInteger (const char *section, const char *var, int  def, int  *val)  const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = atoi (buf);
- return err;
-}
-
-status_t IniFile::ReadInt64 (const char *section, const char *var, int64  def, int64  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = atoI64(buf);
- return err;
-}
-
-status_t IniFile::ReadInt32 (const char *section, const char *var, int32  def, int32  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = atol (buf);
- return err;
-}
-
-status_t IniFile::ReadInt16 (const char *section, const char *var, int16  def, int16  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = atoi (buf);
- return err;
-}
-
-
-status_t IniFile::ReadLong (const char *section, const char *var, long  def, long  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = atol (buf);
- return err;
-}
-
-status_t IniFile::ReadDouble (const char *section, const char *var, double  def, double  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
-  *val = worldwideAtoF(buf);
- return err;
-}
-
-status_t IniFile::ReadFloat (const char *section, const char *var, float  def, float  *val) const
-{
- char buf[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf);
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  *val = def;
- else
- {
-  *val = (float)worldwideAtoF(buf);
- }
- return err;
-}
-
-status_t IniFile::ReadString (const char *section, const char *var, const char *def, char  *val) const
-{
- int len = 129;
- char * buf = new char[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf, &len);
- if(err == B_NO_MEMORY)
- {
-  SAFE_DELETE_TAB(buf);
-  buf = new char[len];
-  err = GetValeur(section, var, buf, &len);
- }
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  strcpy (val, def);
- else
-  strcpy (val, buf);
- SAFE_DELETE_TAB(buf);
- return err;
-}
-
-status_t IniFile::ReadString (const char *section, const char *var, const char *def, String  &val) const
-{
- int len = 129;
- char * buf = new char[129];
-
- /* Recuperation de la valeur de la variable */
- status_t err = GetValeur(section, var, buf, &len);
- if(err == B_NO_MEMORY)
- {
-  SAFE_DELETE_TAB(buf);
-  buf = new char[len];
-  err = GetValeur(section, var, buf, &len);
- }
-
- /* Si rien trouve -> retourner val par defaut, sinon la valeur */
- if (! *buf)
-  val = def;
- else
-  val = buf;
- SAFE_DELETE_TAB(buf);
- return err;
-}
-
-//status_t IniFile::ReadStringList (const char *section, const char *var, char* pattern, StringList  &val) const
-//{
-// PortableString chaine;
-//
-// ReadString(section, var,"",chaine);
-// val.ParseString(chaine, pattern);
-// 
-// return CS_OK;
-//}
-//
-//status_t IniFile::ReadMessage (const char *section, const char *var, PortableMessage &msg) const
-//{
-// int llen = 2048;
-// char * buf = new char[llen];
-// memset(buf, 0, llen);
-// buffer_st result;
-//
-// /* Recuperation de la valeur de la variable */
-// status_t err = GetValeur(section, var, buf, &llen);
-// if(err == CS_NO_MEMORY)
-// {
-//  SAFE_DELETE_TAB(buf);
-//  buf = new char[llen];
-//  err = GetValeur(section, var, buf, &llen);
-// }
-// if (err == CS_OK && *buf)
-// {
-//  // buffer_new(&result);
-//  Base64Decode(&result, buf, strlen(buf));
-//  msg.Unflatten((unsigned char *)result.data, result.offset);
-//  buffer_delete(&result);
-// } 
-// SAFE_DELETE_TAB(buf);
-// return err;
-//}
-
-/*-----------------------------------------------------------------*
- * InfFree : Fonction de restitution de la memoire allouee         *
- *      dynamiquement.                                     *
- *                                                                 *
- * Derniere modification : 4 aout 2003                             *
- *-----------------------------------------------------------------*/
-void IniFile::InfFree ()
-{
- /* Si on ne pointe pas sur du vide */
- if (strIni != NULL)
- {
-  /* Effacement de la structure */
-  SAFE_DELETE(strIni);
- }
-}
-
-/*-----------------------------------------------------------------*
- * InfDeleteVar : Fonction de suppression d'une variable.          *
- *                                                                 *
- * Entree : Le pointeur sur la structure de donnes.               *
- *          Le nom de la section                                   *
- *          Le nom de la variable                                  *
- *                                                                 *
- * Derniere modification : 25 decembre 1996                        *
- *-----------------------------------------------------------------*/
-void IniFile::DeleteVar (const char *section, const char *var)
-{
- InfSection *strSection;
- InfVar *strVar, *oldVar;
-
- if (strIni)
- {
-  /* On recherche si la section existe bien */
-  strSection = strIni->FirstSection;
-  while (strSection != (InfSection *)0)
-  {
-   if (strcmp(strSection->SectionName, section) == 0)
-   {
-    strVar = oldVar = strSection->FirstVar;
-    while (strVar != (InfVar *)0)
-    {
-     if (strcmp (strVar->VarName, var) == 0)
-     {
-      oldVar->NextVar = strVar->NextVar;
-      if (strSection->FirstVar == strVar)
-       strSection->FirstVar = strVar->NextVar;
-      free (strVar->VarName);
-      free (strVar->VarVal);
-      free (strVar);
-      return;
-     }
-     oldVar = strVar;
-     strVar = strVar->NextVar;
-    }
-   }
-   strSection = strSection->NextSection;
-  }
- }
-}
-
-/*-----------------------------------------------------------------*
- * InfDeleteSection : Fonction de suppression d'une section.       *
- *                                                                 *
- * Entree : Le nom de la section                                   *
- *          Le nom de la variable                                  *
- * I/O    : L'adresse du pointeur sur la structure de donnees.     *
- *                                                                 *
- * Derniere modification : 25 decembre 1996                        *
- *-----------------------------------------------------------------*/
-void IniFile::DeleteSection (const char *section)
-{
- InfSection *strSection, *oldSection;
-
- if (strIni)
- {
-  /* On recherche si la section existe bien */
-  strSection = strIni->FirstSection;
-  oldSection = strSection;
-  while (strSection != (InfSection *)0)
-  {
-   if (strcmp(strSection->SectionName, section) == 0)
-   {
-    if (oldSection == strSection)
-     strIni->FirstSection = strSection->NextSection;
-    else
-     oldSection->NextSection = strSection->NextSection;
-    free (strSection->SectionName);
-    if (strSection == _lastReadSection) // VB 20/09/04 lantage DeleteSection() suivi de AddVar() -> GetSection();
-     _lastReadSection = NULL;
-    free (strSection);
-    return;
-   }
-   oldSection = strSection;
-   strSection = strSection->NextSection;
-  }
- }
-}
-
-int IniFile::ReadLine (FILE *ficIni, char *ligne, size_t lineSize)
-{
-/*-----------------------------------------------------------------*
- * ReadLine : Fonction de lecture d'une ligne dans un fichier ASCII*
- *                                                                 *
- * Entree : Le descripteur du fichier ouvert avec fopen            *
- * I/O    : un buffer pour stocker les donnees lues                *
- * Sortie : Le nombre de caracteres composant la ligne, -1 si EOF  *
- *                                                                 *
- * Derniere modification : 11 decembre 1996                        *
- *-----------------------------------------------------------------*/
- register char car;
- register int cpt = 0;
-
- if(!_readCache || _cacheByteIdx == _cacheByteCount)
-  ReadCache(ficIni);
-
- if(!_cacheByteCount)
- {
-  SAFE_DELETE(_readCache);
-  return -1;
- }
- /* Lire car. par car. jusqu'a la fin de ligne ou fin de fichier   */
-
- while ((car = _readCache[_cacheByteIdx++]) != '\n')
- {
-  // If the line is too big, this is probably an error in the file.
-  // So to skip this line, we continue to read without saving the end
-  if(cpt < (int)lineSize - 1)
-   ligne[cpt++] = car;
-  else
-   _readError = B_LINE_TOO_LONG;
-
-  if(_cacheByteIdx == _cacheByteCount)
-  {
-   ReadCache(ficIni);
-   if(!_cacheByteCount)
-   {
-    break;
-   }
-  }
- }
- ligne[cpt] = '\0';
-
- /* Renvoie le nombre de caracteres lus */
- return cpt;
-}
-
-
-void IniFile::ReadCache(FILE* fileHandle)
-{
- if(!_readCache)
- {
-  _readCache = new char[65536*8]; 
- }
-
- _cacheByteCount = fread(_readCache,1, 65536*8, fileHandle);
- _cacheByteIdx = 0;
-
-}
-
-#ifdef o
-//int IniFile::ReadLine (FILE *ficIni, char *ligne)
-//{
-///*-----------------------------------------------------------------*
-// * ReadLine : Fonction de lecture d'une ligne dans un fichier ASCII*
-// *                                                                 *
-// * Entree : Le descripteur du fichier ouvert avec fopen            *
-// * I/O    : un buffer pour stocker les donnees lues                *
-// * Sortie : Le nombre de caracteres composant la ligne, -1 si EOF  *
-// *                                                                 *
-// * Derniere modification : 11 decembre 1996                        *
-// *-----------------------------------------------------------------*/
-// register char car;
-// register int cpt = 0;
-//
-// 
-//
-// /* Lire car. par car. jusqu'a la fin de ligne ou fin de fichier   */
-// if(fgets(ligne, 1154, ficIni))
-// {
-//   cpt = strlen(ligne)-1;
-//   ligne[cpt] = '\0';
-//  return cpt;
-// }
-// return -1;
-//}
-//
-//int IniFile::ReadLine (FILE *ficIni, char *ligne)
-//{
-///*-----------------------------------------------------------------*
-// * ReadLine : Fonction de lecture d'une ligne dans un fichier ASCII*
-// *                                                                 *
-// * Entree : Le descripteur du fichier ouvert avec fopen            *
-// * I/O    : un buffer pour stocker les donnees lues                *
-// * Sortie : Le nombre de caracteres composant la ligne, -1 si EOF  *
-// *                                                                 *
-// * Derniere modification : 11 decembre 1996                        *
-// *-----------------------------------------------------------------*/
-// register char car;
-// register int cpt = 0;
-//
-//
-// /* Lire car. par car. jusqu'a la fin de ligne ou fin de fichier   */
-// while (! feof(ficIni) && ((car = fgetc(ficIni)) != '\n'))
-//  ligne[cpt++] = car;
-// ligne[cpt] = '\0';
-//
-// /* Si fin de fichier, on le signale */
-// if (feof(ficIni))
-//  cpt = -1;
-//
-// /* Renvoie le nombre de caracteres lus */
-// return cpt;
-//}
-#endif
-/*-----------------------------------------------------------------*
- * ReadFile : Fonction de lecture des donnees contenue dans le     *
- *            fichier .inf                                         *
- *                                                                 *
- * I/O    : L'adresse du pointeur sur la structure de donnees.     *
- *                                                                 *
- * Derniere modification : 22/09/2002                              *
- *                                                                 *
- * Remarque : une ligne ne doit pas depasser 1154 caracteres c-a-d *
- *            128 car. pour la variable et 1024 pour la valeur.    *
- *-----------------------------------------------------------------*/
-void IniFile::ReadFile (FILE *fileHandle)
-{
- register int nbCar, i, j;
- char section[65];
- const size_t lineSize = 1154;
- char read_buf[lineSize];
- char var[129];
- char val[1025];
- String myBuff;
- _readError = B_OK;
-
- /* Lecture du fichier ligne par ligne */
- while ((nbCar = ReadLine (fileHandle, read_buf, lineSize)) > -1)
- {
-  if (nbCar > 0)
-  { /* Pas une ligne vide */
-   if (read_buf[0] == '[')  // Si debut de Section
-   { // [nom de la section] 
-    i = 1;
-    j = 0;
-
-    // Lire titre de la section
-    while (read_buf[i] != ']' && read_buf[i] != '\0')
-     section[j++] = read_buf[i++];
-    section[j] = '\0';
-
-    /* Creation de la section dans la structure de donnees */
-    AddSectionInCache(section);
-//   AddSection(section);
-   }
-   else if(read_buf[0] == '#') //C'est un commentaire
-   {
-    continue; //donc on passe a la ligne suivante
-   }
-   else
-   { /* var=val */
-    i = 0;
-    j = 0;
-
-    /* Lire nom de la variable */
-    while (read_buf[i] != '=' && read_buf[i] != '\0')
-    {
-     var[j++] = read_buf[i++];
-    }
-
-    //Il n'y a pas de nom de variable, on passe a la ligne suivante
-    if(read_buf[i] == '\0')
-     continue;
-
-    var[j] = '\0';
-    i++;
-
-    //Si apres le = il y a @\n c'est que c'est du base 64
-    if(strcmp(read_buf+i,"@BEGIN base64 - Don't Edit@") == 0)
-    {
-     myBuff ="";
-
-     while ((nbCar = ReadLine (fileHandle, read_buf, lineSize)) > -1)
-     {
-      if(strcmp(read_buf,"@END base64@") == 0)
-      {
-       AddVar(section, var, myBuff(), TYPE_BASE64);
-       break;
-      }
-      else
-       myBuff << read_buf;
-     }
-    }
-    else /* Lire valeur de la variable */
-    {
-     j = 0;
-     while (read_buf[i] != '\0')
-      val[j++] = read_buf[i++];
-     val[j] = '\0';
-     /* Creation de la variable dans la structure de donnees*/
-     AddVar(section, var, val);
-    }
-
-   }
-  }
- }
-}
-
-InfSection *IniFile::AddSectionInCache (const char *section)
-{
-InfSection *NewSection;
-
- if(_lastReadSection)
- {
-  NewSection = (InfSection *)malloc (sizeof(InfSection));
-  if (NewSection)
-  {
-   /* Allocation memoire pour le nom de la section */
-   NewSection->SectionName = (char *)malloc (strlen(section) + 1);
-   if (! NewSection->SectionName)
-   {
-    free (NewSection);
-    return (InfSection *)0;
-   }
-
-   /* Mettre a jour le contenu de la structure */
-   strcpy (NewSection->SectionName, section);
-   NewSection->NextSection = (InfSection *)0;
-   NewSection->FirstVar = (InfVar *)0;
-
-   _lastReadSection->NextSection = NewSection;
-
-   }
- }
-
- return (InfSection *)0;
-}
-
-/*-----------------------------------------------------------------*
- * AddSection : Fonction permettant de creer une nouvelle section  *
- *              si celle-ci n'existe pas deja.                     *
- *                                                                 *
- * Entree : le nom de la section                                   *
- * I/O    : L'adresse du pointeur sur la structure de donnees.     *
- *                                                                 *
- * Derniere modification : 11 decembre 1996                        *
- *-----------------------------------------------------------------*/
-InfSection *IniFile::AddSection (const char *section)
-{
- InfSection *strSection = strIni->FirstSection;
- InfSection *NewSection;
-
- /* On recherche si la section existe deja */
- while (strSection != (InfSection *)0)
- {
-  if (strcmp(strSection->SectionName, section) == 0)
-   return strSection;
-  strSection = strSection->NextSection;
- }
-
- /* Si elle n'existe pas, on la rajoute */
- NewSection = (InfSection *)malloc (sizeof(InfSection));
- if (NewSection)
- {
-  /* Allocation memoire pour le nom de la section */
-  NewSection->SectionName = (char *)malloc (strlen(section) + 1);
-  if (! NewSection->SectionName)
-  {
-   free (NewSection);
-   return (InfSection *)0;
-  }
-
-  /* Mettre a jour le contenu de la structure */
-  strcpy (NewSection->SectionName, section);
-  NewSection->NextSection = (InfSection *)0;
-  NewSection->FirstVar = (InfVar *)0;
-
-  strSection = strIni->FirstSection;
-  /* Si premiere section ...*/
-  if (strSection == (InfSection *)0)
-  {
-   strIni->FirstSection = NewSection;
-   return strIni->FirstSection;
-  }
-  else /* ...sinon */
-  {
-   while (strSection->NextSection != (InfSection *)NULL)
-    strSection = strSection->NextSection;
-
-   strSection->NextSection = NewSection;
-    return strSection->NextSection;
-   }
- }
- return (InfSection *)0;
-}
-
-/*-----------------------------------------------------------------*
- * AddVar : Fonction permettant de creer une nouvelle variable dans*
- *          une section donnees si elle n'existe pas deja.         *
- *                                                                 *
- * Entree : le nom de la section                                   *
- *          le nom de la variable                                  *
- *          la valeur de la variable                               * 
- * I/O    : L'adresse du pointeur sur la structure de donnees.     *
- *                                                                 *
- * Derniere modification : 11 decembre 1996                        *
- *-----------------------------------------------------------------*/
-status_t IniFile::AddVar (const char *section, const char *var, const char *val, uint8 type)
-{
- InfSection *strSection = NULL;
- InfVar *strVar = NULL, *NewVar = NULL;
- bool ok = false;
-
- if (strIni)
- {
-  strSection = GetSection(section);
-  if(strSection == NULL)
-   strSection = AddSection (section);
-  if (strSection == (InfSection *)NULL)
-   return B_NO_MEMORY;
-
-  /* On recherche si la variable existe deja */
-  strVar = strSection->FirstVar;
-  while (strVar != (InfVar *)0)
-  {
-   /* Si on trouve la variable, on sort de la boucle */
-   if (strcmp(strVar->VarName,var) == 0)
-   {
-    ok = true;
-    break;
-   }
-   strVar = strVar->NextVar;
-  }
- 
-  /* Si variable non trouvee, on la cree */
-  if (! ok)
-  {
-   NewVar = (InfVar *)malloc (sizeof(InfVar));
-   memset(NewVar, 0, sizeof(InfVar));
-   if (NewVar)
-   {
-    NewVar->type = type;   //Type de variable
-    NewVar->VarName = (char *)malloc(strlen(var) + 1);
-    if (! NewVar->VarName)
-    {
-     free (NewVar);
-     return B_NO_MEMORY;
-    }
-    NewVar->VarVal = NULL;
-    strcpy (NewVar->VarName, var);
-    NewVar->NextVar = (InfVar *)0;
-       
-    strVar = strSection->FirstVar;
-    if (strVar == (InfVar *)0)
-    {
-     strSection->FirstVar = NewVar;
-     strVar = strSection->FirstVar;
-    }
-    else
-    {
-     while (strVar->NextVar != (InfVar *)NULL)
-      strVar = strVar->NextVar;
-
-     strVar->NextVar = NewVar;
-     strVar = strVar->NextVar;
-    }
-   }  
-  }
-
-  /* Mise a jour de la valeur de la variable */
-  if(strVar->VarVal)
-   strVar->VarVal = (char *)realloc (strVar->VarVal, strlen(val) + 1);
-  else
-   strVar->VarVal = (char *)malloc (strlen(val) + 1);
-  if (strVar->VarVal)
-   strcpy (strVar->VarVal, val);
-  else
-   return B_NO_MEMORY;
- }
- return B_OK;
-}
-
-status_t IniFile::Update(void)
-{
- return SaveFileOnly();
-}
-
-IniFile::~IniFile(void)
-{
- if(_mustSave)
-  SaveFileAndDelete();
- else
-  FreeTree();
-
- InfFree ();
-}
-
-/*------------------------------------------------------------------------*
- * FreeTree : Fonction permettant d'effacer completement la structure.    *
- *------------------------------------------------------------------------*/
-void IniFile::FreeTree (void)
-{
-InfSection *strSection = NULL;
-InfSection *oldSection = NULL;
-InfVar *strVar = NULL;
-InfVar *oldVar = NULL;
-//int index = 0;
-
-
- if(strIni)
- {
-  strSection = strIni->FirstSection;
-  while (strSection != (InfSection *)0)
-  {
-   /* Premiere variable */
-   strVar = strSection->FirstVar;
-   while (strVar != (InfVar *)0)
-   {
-    /* Variable suivante */
-    oldVar = strVar;
-    strVar = strVar->NextVar;
-
-    /* Supprimer variable, valeur et structure */
-    free (oldVar->VarName);
-    free (oldVar->VarVal);
-    free (oldVar);
-   }
-   
-   /* Section suivante */
-   oldSection = strSection;
-   strSection = strSection->NextSection;
-
-   /* Supprimer nom et structure */
-   free (oldSection->SectionName);
-   free (oldSection);
-  }
-  strIni->FirstSection = NULL;
- }
- _lastReadSection = NULL;
-}
-
-FILE *IniFile::SafeCreate()
-{
- FILE * fileHandle = NULL;
- if(strIni)
- {
-  // Create the parent directoy if this is a pathname.
-//  if((strchr(strIni->FileName.Cstr(), '\\') != NULL) || (strchr(strIni->FileName.Cstr(), '/') != NULL))
-//  {
-//   Path pathName(strIni->FileName);
-//   Path path;
-//   pathName.GetParent(&path);
-//   CreateAllDirectories(path.GetPath());
-//  }
-    fileHandle = fopen(strIni->FileName.Cstr(), "w");
-    if(!fileHandle)
-    {
-//      LOGERROR("IniFile Can't create [%s] file", strIni->FileName.c_str());
-      _initCheck = B_ERROR;
-      return NULL;
-    }
- }
- return fileHandle;
-}
-
-
-/*-----------------------------------------------------------------*
- * SaveFile : Fonction permettant de sauvegarder le fichier .inf   *
- *            tout en effacant au fur et a mesure la structure.    *
- *-----------------------------------------------------------------*/
-status_t IniFile::SaveFileAndDelete(void)
-{
-FILE *fileHandle;
-InfSection *strSection, *oldSection;
-InfVar *strVar, *oldVar;
-char *buffer;
-uint32 index = 0;
-char line[1024];
-uint32 len;
-
- if(strIni == NULL)
-  return B_NO_INIT;
-
-uint32 bufLen = 65536*8;
- buffer = (char *)malloc (sizeof (char) * (bufLen)); // 64KO
- if(buffer == NULL)
- {
-//  LOGERROR("Can't allocate buffer in %s line %d", __FILE__, __LINE__);
-  return B_NO_MEMORY;
- }
- 
- /* Ouvrir fichier parametre */
- fileHandle = SafeCreate();
- if(fileHandle == NULL)
- {
-//  LOGERROR("CS::Inifile::SaveFileAndDelete() can't create file !");
-  return B_FILE_ERROR;
- }
-
- strSection = strIni->FirstSection;
- while (strSection != (InfSection *)0)
- {
-  /* Ecriture du nom de la section */
-  sprintf (line, "[%s]\n", strSection->SectionName);
-  len = strlen(line);
-
-  if(index + len > bufLen)
-  {
-   bufLen += len;
-   buffer = (char *)realloc (buffer, bufLen);
-  }
-  memcpy(buffer + index , line, len);
-  index += len;
-
-  /* Premiere variable */
-  strVar = strSection->FirstVar;
-  while (strVar != (InfVar *)0)
-  {
-   switch(strVar->type)
-   {
-    case TYPE_DEFAULT:
-    {
-     /* Ecriture de la variable et de sa valeur */
-     sprintf (line, "%s=%s\n", strVar->VarName, strVar->VarVal);
-     len = strlen(line);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , line, len);
-     index += len;
-     break;
-    }
-    case TYPE_BASE64:
-    {
-     sprintf (line, "%s=@BEGIN base64 - Don't Edit@\n", strVar->VarName);
-     len = strlen(line);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , line, len);
-     index += len;
-
-     len = strlen(strVar->VarVal);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , strVar->VarVal, len);
-     index += len;
-
-     // security control to handle an ununderstandable bug ('\n' not found in result buffer)
-     if(buffer[index-1] != '\n')
-      buffer[index++] = '\n';
-
-     sprintf (line, "@END base64@\n");
-     len = strlen(line);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , line, len);
-     index += len;
-     break;
-    }
-    default:
-    {
-//     LOGWARNING("CSInifile save : unknown type [%d]", strVar->type);
-    }
-
-   } //switch
-
-   /* Variable suivante */
-   oldVar = strVar;
-   strVar = strVar->NextVar;
-
-   /* Supprimer variable, valeur et structure */
-   free (oldVar->VarName);
-   free (oldVar->VarVal);
-   free (oldVar);
-   
-   //Un p'tit flush au cas ou
-   if(fileHandle && index > 60000*8)
-   {
-    fwrite(buffer, index, 1, fileHandle);
-    index = 0;
-   }
-
-  } //while
-
-  sprintf (line, "\n");
-  len = strlen(line);
-  if(index + len > bufLen)
-  {
-   bufLen += len;
-   buffer = (char *)realloc (buffer, bufLen);
-  }
-  memcpy(buffer + index , line, len);
-  index += len;
-  if(fileHandle && index > 60000*8)
-  {
-   fwrite(buffer, index, 1, fileHandle);
-   index = 0;
-  }
-  /* Section suivante */
-  oldSection = strSection;
-  strSection = strSection->NextSection;
-
-  /* Supprimer nom et structure */
-  free (oldSection->SectionName);
-  free (oldSection);
- }
-
- /* Fermer fichier parametre */
- if(index && fileHandle)
- {
-  fwrite(buffer, index, 1, fileHandle);
- }
-
- if(fileHandle)
-  fclose (fileHandle);
-
- if(buffer)
-  free (buffer);
-
- _mustSave = false;
- return B_OK;
-}
-
-
-/*-----------------------------------------------------------------*
- * SaveFile : Fonction permettant de sauvegarder le fichier .inf   *
- *            sans effacer la structure.                           *
- *-----------------------------------------------------------------*/
-status_t IniFile::SaveFileOnly(void)
-{
-FILE *fileHandle = NULL;
-InfSection *strSection = NULL;
-InfVar *strVar = NULL;
-char *buffer = NULL;
-uint32 index = 0;
-char line[1024];
-uint32 len = 0;
-
- if(strIni == NULL)
-  return B_NO_INIT;
-
-uint32 bufLen = 65536*8;
- buffer = (char *)malloc (sizeof (char) * (bufLen)); // 64KO
-
- if(buffer == NULL)
- {
-//  LOGERROR("Can't allocate buffer in %s line %d", __FILE__, __LINE__);
-  return B_NO_MEMORY;
- }
-
- /* Ouvrir fichier parametre */
- fileHandle = SafeCreate();
- if(fileHandle == NULL)
- {
-//  LOGERROR("Can't open ini file '%s' in %s line %d", strIni->FileName.c_str(), __FILE__, __LINE__);
-  return B_FILE_ERROR;
- }
-
- strSection = strIni->FirstSection;
- while (strSection != (InfSection *)0)
- {
-  /* Ecriture du nom de la section */
-  sprintf (line, "[%s]\n", strSection->SectionName);
-  len = strlen(line);
-  if(index + len > bufLen)
-  {
-   bufLen += len;
-   buffer = (char *)realloc (buffer, bufLen);
-  }
-  memcpy(buffer + index , line, len);
-  index += len;
-
-  /* Premiere variable */
-  strVar = strSection->FirstVar;
-  while (strVar != (InfVar *)0)
-  {
-   switch(strVar->type)
-   {
-    case TYPE_DEFAULT:
-    {
-     /* Ecriture de la variable et de sa valeur */
-     sprintf (line, "%s=%s\n", strVar->VarName, strVar->VarVal);
-     len = strlen(line);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , line, len);
-     index += len;
-     break;
-    }
-    case TYPE_BASE64:
-    {
-     sprintf (line, "%s=@BEGIN base64 - Don't Edit@\n", strVar->VarName);
-     len = strlen(line);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , line, len);
-     index += len;
-
-     len = strlen(strVar->VarVal);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , strVar->VarVal, len);
-     index += len;
-
-     // security control to handle an ununderstandable bug ('\n' not found in result buffer)
-     if(buffer[index-1] != '\n')
-      buffer[index++] = '\n';
-
-     sprintf (line, "@END base64@\n");
-     len = strlen(line);
-     if(index + len > bufLen)
-     {
-      bufLen += len;
-      buffer = (char *)realloc (buffer, bufLen);
-     }
-     memcpy(buffer + index , line, len);
-     index += len;
-     break;
-    }
-    default:
-    {
-//     LOGWARNING("CSInifile save : unknown type [%d]", strVar->type);
-    }
-   } //switch
-
-//   /* Ecriture de la variable et de sa valeur */
-//   sprintf (line, "%s=%s\n", strVar->VarName, strVar->VarVal);
-//   len = strlen(line);
-//   memcpy(buffer + index , line, len);
-//   index += len;
-//
-   /* Variable suivante */
-   strVar = strVar->NextVar;
-  }
-  
-  sprintf (line, "\n");
-  len = strlen(line);
-  if(index + len > bufLen)
-  {
-   bufLen += len;
-   buffer = (char *)realloc (buffer, bufLen);
-  }
-  memcpy(buffer + index , line, len);
-  index += len;
-  if(fileHandle && index > 60000)
-  {
-   fwrite(buffer, index, 1, fileHandle);
-   index = 0;
-  }
-  /* Section suivante */
-  strSection = strSection->NextSection;
- }
-
- /* Fermer fichier parametre */
- if(index && fileHandle)
- {
-  fwrite(buffer, index, 1, fileHandle);
- }
-
- if(fileHandle)
-  fclose (fileHandle);
-
- if(buffer)
-  free (buffer);
-
- return B_OK;
-}
-
-bool IniFile::IsSection(const char *section) const
-{
- InfSection *strSection;
-
- if(_lastIsSection && strcmp(_lastIsSection->SectionName, section) == 0)
- {
-  _lastIsSection =  _lastIsSection->NextSection;
-  return true;
- }
-
- /* Recherche de la section */
- strSection = strIni->FirstSection;
- while ((strSection != (InfSection *)0))
- {
-  if(strcmp(strSection->SectionName, section) == 0)
-  {
-   _lastIsSection = strSection->NextSection;
-   return true;
-  }
-  strSection = strSection->NextSection;
- }
-
- return false;
-}
-
-/*-----------------------------------------------------------------*
- * GetValeur : Fonction permettant de recuperer le contenu d'une   *
- *             variable donnee d'une section donnee.               *
- *                                                                 *
- * Entree : Le pointeur sur la structure de donnees.               *
- *          le nom de la section                                   *
- *          le nom de la variable                                  *
- * I/O    : Le buffer qui va contenir la valeur                    *
- *                                                                 *
- * Derniere modification : 11 decembre 1996                        *
- *-----------------------------------------------------------------*/
-status_t IniFile::GetValeur (const char *section, const char *var, char *buf, int * len) const
-{
- status_t err = B_OK;
- InfSection *strSection = GetSection(section);
- InfVar *strVar;
-
- /* Si section non trouvee, buffer vide */
- if (strSection == (InfSection *)0)
- {
-  strcpy (buf, "");
-  err = B_NAME_NOT_FOUND;
- }
- else
- {
-  /* Recherche de la variable */
-  strVar = strSection->FirstVar;
-  while ((strVar != (InfVar *)0) && strcmp(strVar->VarName, var) != 0)
-   strVar = strVar->NextVar;
-
-  /* Si variable non trouvee, buffer vide */
-  if (strVar == (InfVar *)0)
-  {
-   strcpy (buf, "");
-   err = B_NAME_NOT_FOUND;
-  }
-  else /* sinon copier la valeur dans le buffer */
-  {
-   //J'ai un buffer dont la longueur est donnee, c'est a dire que
-   //je peux l'agrandir le cas echeant
-   if(len)
-   {
-//    int llen = *len;
-    int varLen = strlen(strVar->VarVal) + 1;
-
-    if(*len < varLen)
-    {
-     *len = varLen;
-     return B_NO_MEMORY;
-//     SAFE_DELETE_TAB(buf);
-//     buf = new char[varLen+1];
-//     *len = varLen;
-    }
-   }
-
-   strcpy (buf, strVar->VarVal);
-  }
- }
- return err;
-}
-
-bool IniFile::SetSectionName(const char *oldSectionName, const char *newSectionName)
-{
- InfSection *infSection = GetSection(oldSectionName);
- if(infSection)
- {
-  strcpy(infSection->SectionName, newSectionName);
-  return true;
- }
- return false;
-}
-
-InfSection * 
-IniFile::GetSection(const char *section) const
-{
- InfSection *strSection = NULL;
-
- if(_lastReadSection && strcmp(_lastReadSection->SectionName, section) == 0)
- {
-  strSection = _lastReadSection;
- }
- else if(_lastReadSection && 
-     _lastReadSection->NextSection && 
-     strcmp(_lastReadSection->NextSection->SectionName, section) == 0)
- {
-  _lastReadSection = strSection = _lastReadSection->NextSection;
- }
- else
- {
-  /* Recherche de la section */
-  strSection = strIni->FirstSection;
-  while ((strSection != (InfSection *)0) && strcmp(strSection->SectionName, section) != 0)
-   strSection = strSection->NextSection;
-  
-  if(strSection)
-   _lastReadSection = strSection;
- }
- return strSection;
-}
-
-InfVar * 
-IniFile::GetVariable(const char *var) const
-{
- InfVar * strVar = _lastReadSection->FirstVar;
- while ((strVar != (InfVar *)0) && strcmp(strVar->VarName, var) != 0)
-  strVar = strVar->NextVar;
- return strVar;
-}
-
-InfVar * 
-IniFile::GetVariable(const char *section, const char *var) const
-{
- GetSection(section); // setup the cached value of _lastReadSection
- return GetVariable(var);
-}
-
-bool 
-IniFile::IsVariable(const char * sectionName, const char * var) const
-{
- InfSection *strSection = GetSection(sectionName);
- if(strSection)
- {
-  InfVar * strVar = GetVariable(var);
-  if(strVar)
-   return true;
- }
- return false;
-}
-
-bool 
-IniFile::GetFirstVarName(const char * sectionName, char * var)
-{
- InfSection *strSection = GetSection(sectionName);
- if(strSection)
- {
-  InfVar * strVar = strSection->FirstVar;
-  strcpy(var, strVar->VarName);
-  _currentstrVar = strVar;
-  return true;
- }
- _currentstrVar = NULL;
- return false;
-}
-
-bool 
-IniFile::GetNextVarName(char * var)
-{
- if(_currentstrVar)
- {
-  InfVar * strVar = _currentstrVar->NextVar;
-  if (strVar)
-  {
-   strcpy(var, strVar->VarName);
-   _currentstrVar = strVar;
-   return true;
-  }
- }
- _currentstrVar = NULL;
- return false;
-}
-
-char * uI64toa( uint64 value,char * pstr)
-{
-#ifdef WIN32
- return _ui64toa(value, pstr, 10);
-#endif
- return NULL; 
-}
-
-char * I64toa( int64 value,char * pstr)
-{
-#ifdef WIN32
- return _i64toa(value, pstr, 10);
-#endif
- return NULL; 
-}
-
-int64 CM::atoI64(const char * pstr)
-{
-#ifdef WIN32
- return _atoi64(pstr);
-#endif
- return 0; 
-}
-
-double CM::worldwideAtoF(const char *z)
-{
-  int sign = 1;
-  long double v1 = 0.0;
-  if( *z=='-' )
- {
-    sign = -1;
-    z++;
-  }
- else if( *z=='+' )
- {
-    z++;
-  }
-
-  while( isdigit(*z) )
- {
-    v1 = v1*10.0 + (*z - '0');
-    z++;
-  }
-
- //in a worldwide, they are two possible decimal point, 
- //the dot for english speaking country
- //and comma for the rest of world
-  if( *z == '.' || *z == ',')
- {
-    long double divisor = 1.0;
-    z++;
-    while( isdigit(*z) )
-  {
-      v1 = v1*10.0 + (*z - '0');
-      divisor *= 10.0;
-      z++;
-    }
-    v1 /= divisor;
-  }
-
-  if( *z=='e' || *z=='E' ){
-    int esign = 1;
-    int eval = 0;
-    long double scale = 1.0;
-    z++;
-    if( *z=='-' )
-  {
-      esign = -1;
-      z++;
-    }
-  else if( *z=='+' )
-  {
-      z++;
-    }
-  
-    while( isdigit(*z) )
-  {
-      eval = eval*10 + *z - '0';
-      z++;
-    }
-    while( eval>=64 )
-  { 
-   scale *= 1.0e+64; eval -= 64; 
-  }
-    while( eval>=16 )
-  { 
-   scale *= 1.0e+16; eval -= 16; 
-  }
-    while( eval>=4 )
-  {
-   scale *= 1.0e+4; eval -= 4; 
-  }
-    while( eval>=1 )
-  { 
-   scale *= 1.0e+1; eval -= 1; 
-  }
-    if( esign<0 )
-  {
-      v1 /= scale;
-    }else
-  {
-      v1 *= scale;
-    }
-  }
-  return sign<0 ? -v1 : v1;
-}
-
- /*
-  **  ftoa  - FLOATING POINT TO ASCII CONVERSION
-  **
-  **  CODE derived from ingres, ~ingres/source/gutil/ftoa.c
-  **
-  **  'Value' is converted to an ascii character string and stored
-  **  into 'ascii'.  Ascii should have room for at least 'width' + 1
-  **  characters.  'Width' is the width of the output field (max).
-  **  'Prec' is the number of characters to put after the decimal
-  **  point. The format of the output string is controlled by
-  **  'format'.
-  **
-  **  'Format' can be:
-  **    e or E: "E" format output
-  **    f or F:  "F" format output
-  **    g or G:  "F" format output if it will fit, otherwise
-  **      use "E" format.
-  **    n or N:  same as G, but decimal points will not always
-  **      be aligned.
-  **
-  **  If 'format' is upper case, the "E" comes out in upper case;
-  **  otherwise it comes out in lower case.
-  **
-  **  When the field width is not big enough, it fills the field with
-  **  stars ("*****") and returns zero.  Normal return is the width
-  **  of the output field (sometimes shorter than 'width').
-  */
-  int CM::worldwideFtoA(double value, char *ascii, int width, int prec1, char format)
-{
-auto int expon;
-auto int sign;
-int   avail = 0;
-char    *a = NULL;
-char    *p = NULL;
-char  mode;
-int   lowercase;
-int   prec;
- 
- /*   extern char  *ecvt(), *fcvt();*/
- 
-  prec = prec1;
-  mode = format;
-  lowercase = 'a' - 'A';
-  if (mode >= 'a')
-   mode -= 'a' - 'A';
-  else
-   lowercase = 0;
- 
-  if (mode != 'E')
-  {
-   /* try 'F' style output */
-   p = fcvt(value, prec, &expon, &sign);
-   avail = width;
-   a = ascii;
- 
-   /* output sign */
-   if (sign)
-   {
-    avail--;
-    *a++ = '-';
-   }
- 
-   /* output '0' before the decimal point */
-   if (expon <= 0)
-   {
-    *a++ = '0';
-    avail--;
-   }
- 
-   /* compute space length left after dec pt and fraction */
-   avail -= prec + 1;
-   if (mode == 'G')
-    avail -= 4;
- 
-   if (avail >= expon)
-   {
- 
-    /* it fits.  output */
-    while (expon > 0)
-    {
-     /* output left of dp */
-     expon--;
-     if (*p)
-      *a++ = *p++;
-     else
-      *a++ = '0';
-    }
- 
-    /* output fraction (right of dec pt) */
-    avail = expon;
-    goto frac_out;
-   }
-   /* won't fit; let's hope for G format */
-  }
- 
-  if (mode != 'F')
-  {
-   /* try to do E style output */
-   p = ecvt(value, prec + 1, &expon, &sign);
-   avail = width - 5;
-   a = ascii;
- 
-   /* output the sign */
-   if (sign)
-   {
-    *a++ = '-';
-    avail--;
-   }
-  }
- 
-  /* check for field too small */
-  if (mode == 'F' || avail < prec)
-  {
-   /* sorry joker, you lose */
-   a = ascii;
-   for (avail = width; avail > 0; avail--)
-    *a++ = '*';
-   *a = 0;
-   return 0;
-  }
- 
-  /* it fits; output the number */
-  mode = 'E';
- 
-  /* output the LHS single digit */
-  *a++ = *p++;
-  expon--;
- 
-  /* output the rhs */
-  avail = 1;
- 
- frac_out:
-  *a++ = '.';
-  while (prec > 0)
-  {
-   prec--;
-   if (avail < 0)
-   {
-    avail++;
-    *a++ = '0';
-   }
-   else
-   {
-    if (*p)
-     *a++ = *p++;
-    else
-     *a++ = '0';
-   }
-  }
- 
-  /* output the exponent */
-  if (mode == 'E')
-  {
-   *a++ = 'E' + lowercase;
-   if (expon < 0)
-   {
-    *a++ = '-';
-    expon = -expon;
-   }
-   else
-    *a++ = '+';
-   *a++ = (expon / 10) % 10 + '0';
-   *a++ = expon % 10 + '0';
-  }
- 
-  /* output spaces on the end in G format */
-  if (mode == 'G')
-  {
-   *a++ = ' ';
-   *a++ = ' ';
-   *a++ = ' ';
-   *a++ = ' ';
-  }
- 
-  /* finally, we can return */
-  *a = 0;
-  avail = a - ascii;
-  return avail;
-}
-#ifndef __INIFILE_H__
-#define __INIFILE_H__
-
-#include "AnubisSupport.h"
-#include "String.h"
-//#include "MediaListeBuild.h"
-//#include "root/support/PortableTypeDefs.h"
-//#include "root/PortableString.h"
-//#include "root/PortableMessage.h"
-//#include "root/StringList.h"
-
-#include <stdio.h>
-
-BEGIN_NAMESPACE(CM);
-
-/* Une ligne du fichier (autre qu'un entete de section) ==>   NomVariable=valeur                                              */
-typedef struct _var
-{
- char *VarName;        /* Nom de la variable              */
- char *VarVal;         /* Valeur de la variable           */
- uint8 type;          /* Type de variable         */
- struct _var *NextVar;     /* Variable suivante               */
-} InfVar;
-
-/* Liste des sections ==> [Nom de la section]                      */
-typedef struct _sect
-{
- char *SectionName;      /* Nom de la Section               */
- InfVar *FirstVar;       /* Premier element de la section   */
- struct _sect *NextSection;  /* Section suivante                */
-} InfSection;
-
-/* Structure d'un fichier .inf                                     */
-typedef struct _inf
-{
- String FileName;
- InfSection *FirstSection;
-} inifile_struct;
-
-/**
- * Fonctions de fichier INI comme MS Windows                       
- */
-
-
-
-/**
- */
-
-class IniFile
-{
-
- public:
-
-   IniFile(const char *nomFic);
-
-   IniFile(const String &fileName);
-   
-   virtual ~IniFile(void);
-
-   /**
-    * Give the initialization status. Especialy return an error when openning
-    * the file fail (maybe due to a lock by another process?).
-    * Call this before to read or write value. 
-    */
-   status_t InitCheck() const;
-   
-  /** Ecrit un booleen
-   * @param section nom de la section dans laquelle se trouve la valeur a ecrire
-   * @param var nom de la variable a ecrire dans la section
-   * @param val valeur a ecrire
-   */
-void WriteBool(const char *section, const char *var, bool val);
-void WriteChar(const char *section, const char *var, char val);
-void WriteInteger(const char *section, const char *var, int val);
-void WriteInt64(const char *section, const char *var, int64 val);
-void WriteInt32(const char *section, const char *var, int32 val);
-void WriteInt16(const char *section, const char *var, int16 val);
-void WriteLong(const char *section, const char *var, long val);
-void WriteFloat(const char *section, const char *var, float val);
-void WriteDouble(const char *section, const char *var, double val);
-void WriteString(const char *section, const char *var, const char *val);
-void WriteString(const char *section, const char *var, const String &str);
-//void WriteStringList(const char *section, const char *var, char separator, const StringList & strList);
-//void WriteMessage(const char *section, const char *var, const PortableMessage &);
-  /** 
-   * Lit un booleen dans le fichier ini
-   * @return _B_OK si la variable a été trouvée, B_NAME_NOT_FOUND sinon
-   * @param section nom de la section dans laquelle se trouve la valeur recherche
-   * @param var   nom de la variable a recherche dans la section
-   * @param def   valeur par defaut au cas ou la valeur n'est pas trouve
-   * @param val   pointeur sur la variable devant recevoir le resultat
-   */
-status_t ReadBool(const char *section, const char *var, bool def, bool *val) const;
-status_t ReadChar(const char *section, const char *var, char def, char *val) const;
-status_t ReadInteger(const char *section, const char *var, int  def, int   *val) const;
-status_t ReadInt64(const char *section, const char *var, int64  def, int64   *val) const;
-status_t ReadInt32(const char *section, const char *var, int32  def, int32   *val)const;
-status_t ReadInt16(const char *section, const char *var, int16  def, int16   *val) const;
-status_t ReadLong(const char *section, const char *var, long  def, long  *val) const;
-status_t ReadFloat(const char *section, const char *var, float  def, float  *val) const;
-status_t ReadDouble(const char *section, const char *var, double  def, double  *val) const;
-status_t ReadString(const char *section, const char *var, const char *def, char  *val) const;
-status_t ReadString(const char *section, const char *var, const char *def, String  &val) const;
-//status_t ReadMessage(const char *section, const char *var, PortableMessage &val) const;
-//status_t ReadStringList(const char *section, const char *var, char *pattern, StringList &val) const;
-
-/* Fonction de suppression de variables et de sections             */
-
- /** Permet de verifier si une section existe dans le fichier INI associee l'objet.
-  * @param sectionName section dont on cherche l'existence dans le fichier.
-  * @return true si la section demande existe sinon false
-  */
-  bool IsSection(const char * sectionName) const;
-  /**
-   * Allow section name modification
-    * @param oldSectionName  original section Name to be replaced
-    * @param newSectionName  new section Name
-   */
-  bool SetSectionName(const char *oldSectionName, const char *newSectionName);
-
-  /** 
-   * Permet de verifier si une variable existe dans dasn une section donnée.
-   * @param sectionName section contenant la variable
-   * @param var     nom de la variable recherchée
-   * @return true si la section demande existe sinon false
-   */
-  bool IsVariable(const char * sectionName, const char * var) const;
-
-  /** 
-   * Permet connaitre la première entrée dans la section donnée.
-   * @param sectionName section contenant la variable
-   * @param var     nom de la première variable
-   * @return true si une variable existe sinon false
-   */
-  bool GetFirstVarName(const char * sectionName, char * var);
-  /** 
-   * Permet connaitre l'entrée suivante après l'appel à la fonction GetFirstVarName().
-   * @param var     nom de la variable
-   * @return true si une variable existe sinon false
-   */
-  bool GetNextVarName(char * var);
-
-  InfSection *AddSectionInCache (const char *section);
-  void ReadCache(FILE* fileHandle);
-
- /** Sauve le contenu de l'arborescence en memoire sur disque
-   * */
- status_t Update(void);
- void MustSaveOnQuit(void)
-     { _mustSave = true;}
-
- /**
-  * If an error occurs while reading the file, this function returns the error code.
-  * When a read error is encountered, the IniFile is still usable but some 
-  * datas may be missing.
-  */
- status_t GetReadError() const {
-  return _readError;
- }
-
- /**
-  * Delete all sections and variables from this IniFile.
-  */
- void Clear() {
-  FreeTree();
- }
- /**
-  * Delete a conplete section with all the subsections.
-  */
- void DeleteSection (const char *section);
- /**
-  * Delete a variable in a section
-  */
- void DeleteVar(const char *section, const char *var);
-
-private:
- status_t _initCheck;
- inifile_struct *strIni;
- mutable InfSection *_lastReadSection;
- mutable InfSection *_lastIsSection;
- char * _readCache;
- size_t _cacheByteCount;
- size_t _cacheByteIdx;
- // Variable servant uniquement pour les fonctions GetFirstVarName() et GetNextVarName()
- InfVar * _currentstrVar;
-
- void Init(const char *nomFic);
- FILE *SafeCreate();
- int  ReadLine (FILE *ficIni, char *ligne, size_t lineSize);
- void ReadFile (FILE *fileHandle);
- InfSection *AddSection (const char *section);
-
- status_t AddVar (const char *section, const char *var, const char *val, uint8 = 0);
-
- status_t SaveFileAndDelete(void);
- status_t SaveFileOnly(void);
- void FreeTree(void);
- /**
-  * Free all datas without saving them.
-  */
- void InfFree (void);
-
- /**
-  * Fonction permettant de recuperer le contenu d'une variable donnee d'une 
-  * section donnee.
-  *
-  * @return B_OK if the section and value if found, B_NAME_NOT_FOUND else
-  * @param section le nom de la section
-  * @param var   le nom de la variable
-  * @param len   target buffer size
-  */
- status_t GetValeur(const char *section, const char *var, char *buf, int * len = 0 ) const;
-
- /**
-  * Returns the section named \a section.
-  */
- InfSection * GetSection(const char *section) const;
- /**
-  * Returns the variable named \a var from the section named \a section.
-  */
- InfVar * GetVariable(const char *section, const char *var) const;
- /**
-  * Returns the variable named \a var from the current section
-  * (section in \c _lastReadSection).
-  */
- InfVar * GetVariable(const char *var) const;
-
- bool _mustSave;
- status_t _readError;
-};
-
-char *  uI64toa( uint64 value, char * pstr);
-char *  I64toa( int64 value, char * pstr);
-int64   atoI64( const char * pstr);
-double  worldwideAtoF(const char *z);
-int     worldwideFtoA(double value, char *ascii, int width, int prec1, char format);
-
-END_NAMESPACE(CM);
-
-#endif
-/* This file is Copyright 2005 Level Control Systems.  See the included LICENSE.txt file for details. */  
-
-#include "AnubisSupport.h"
-#include "String.h"
-//#include "system/GlobalMemoryAllocator.h"
-#include <stdarg.h>
-#include <stdio.h>
-#include <stdlib.h>
-
-BEGIN_NAMESPACE(CM);
-
-String :: ~String() 
-{
-   if (_buffer != _smallBuffer) 
-     SAFE_FREE(_buffer);
-}
-
-status_t
-String::SetFromString(const String & s, uint32 firstChar, uint32 afterLastChar)
-{
-   afterLastChar = anubisMin(afterLastChar, s.Length());
-   uint32 len = (afterLastChar > firstChar) ? (afterLastChar-firstChar) : 0;
-   if (len > 0)
-   {
-      if (EnsureBufferSize(len+1, false) != B_NO_ERROR) return B_ERROR;
-      if (&s == this) memmove(_buffer, s()+firstChar, len);
-                 else memcpy( _buffer, s()+firstChar, len);
-      _buffer[len] = '\0';
-      _length = len;
-   }
-   else Clear();
-
-   return B_NO_ERROR;
-}
-
-status_t
-String::SetCstr(const char * str, uint32 maxLen)
-{
-   // If (str)'s got a NUL byte before maxLen, make (maxLen) smaller.
-   // We can't call strlen(str) because we don't have any guarantee that the NUL 
-   // byte even exists!  Without a NUL byte, strlen() could run off into the weeds...
-   uint32 sLen = 0;
-   if (str) {while((sLen<maxLen)&&(str[sLen] != '\0')) sLen++;}
-   if (sLen < maxLen) maxLen = sLen;
-   if (maxLen > 0)
-   {
-      if (str[maxLen-1] != '\0') maxLen++;  // make room to add the NUL byte if necessary
-      if (EnsureBufferSize(maxLen, false) != B_NO_ERROR) return B_ERROR;
-      if (anubisInRange((char *)str, _buffer, &_buffer[_length])) memmove(_buffer, str, maxLen-1);
-                                                             else memcpy(_buffer, str, maxLen-1);
-      _buffer[maxLen-1] = '\0';
-      _length = maxLen-1;
-   }
-   else Clear();
-
-   return B_NO_ERROR;
-}
-
-String &
-String::operator-=(const char aChar)
-{
-   int idx = LastIndexOf(aChar);
-   if (idx >= 0)
-   {
-      String temp = Substring(idx+1);
-      (*this) = this->Substring(0, idx);
-      (*this) += temp;
-   }
-   return *this;
-}
-
-String &
-String::operator+=(const String &other)
-{
-   uint32 otherLen = other.Length();
-   if ((otherLen > 0)&&(EnsureBufferSize(Length() + otherLen + 1, true) == B_NO_ERROR))
-   {
-      memcpy(&_buffer[_length], other(), other.Length()+1);
-      _length += otherLen;
-   }
-   return *this;
-}
-
-String &
-String::operator+=(const char * other)
-{
-   if (other == NULL) other = "";
-   uint32 otherLen = strlen(other);
-   if (otherLen > 0)
-   {
-           if (anubisInRange(other, (const char *)_buffer, (const char *)(_buffer+_length))) return operator+=(String(other));  // avoid self-entanglement
-      else if (EnsureBufferSize(Length() + otherLen + 1, true) == B_NO_ERROR)
-      {
-         memcpy(&_buffer[_length], other, otherLen+1);
-         _length += otherLen;
-      }
-   }
-   return *this;
-}
-
-String &
-String::operator-=(const String &other)
-{
-   if (*this == other) *this = "";
-   else
-   {
-      int idx = LastIndexOf(other);
-      if (idx >= 0)
-      {
-         String temp = Substring(idx+other.Length());
-         (*this) = Substring(0, idx);
-         (*this) += temp;
-      }
-   }
-   return *this;
-}
-
-String &
-String::operator<<(int rhs)
-{
-   char buff[64];
-   sprintf(buff, "%d", rhs);
-   return *this << buff;
-}
-
-String &
-String::operator<<(float rhs)
-{
-   char buff[64];
-   sprintf(buff, "%.2f", rhs);
-   return *this << buff;
-}
-
-String &
-String::operator<<(bool rhs)
-{
-   const char* val = rhs ? "true" : "false"; 
-   return *this << val;
-}
- 
-void
-String::Reverse()
-{
-   if ((_buffer)&&(Length() > 0))
-   {
-      uint32 from = 0;
-      uint32 to = Length()-1;
-      while(from<to) anubisSwap(_buffer[from++], _buffer[to--]);
-   }
-}
-
-uint32
-String::Replace(char findChar, char replaceChar)
-{
-   uint32 ret = 0; 
-   if ((_buffer)&&(findChar != replaceChar))
-   {
-      char * c = _buffer;
-      while(*c)
-      {
-         if (*c == findChar) 
-         {
-            *c = replaceChar;
-            ret++;
-         }
-         c++;
-      }
-   }
-   return ret;
-}
-   
-int32
-String::Replace(const String & replaceMe, const String & withMe)
-{
-   if (replaceMe.Length() == 0) return -1;  // can't replace an empty string, that's silly!
-   if (replaceMe == withMe) return GetNumInstancesOf(replaceMe);  // no changes necessary!
-
-   String temp;
-   int32 perInstanceDelta = ((int32)withMe.Length())-((int32)replaceMe.Length());
-   if (perInstanceDelta > 0)
-   {
-      // If we are replacing a shorter string with a longer string, we'll have to do a copy-and-swap
-      uint32 numInstances = GetNumInstancesOf(replaceMe);
-      if (numInstances == 0) return 0;  // no changes necessary!
-      if (temp.Prealloc(Length()+(perInstanceDelta*numInstances)) != B_NO_ERROR) return -1;
-   }
-
-   // This code works for both the in-place and the copy-over modes!
-   int32 ret = 0;
-   const char * readPtr = Cstr();
-   char * writePtr = (perInstanceDelta > 0) ? temp._buffer : NULL;
-   while(1)
-   {
-      char * nextReplaceMe = strstr((char *) readPtr, (char *) replaceMe());
-      if (nextReplaceMe)
-      {
-         ret++;
-         if (writePtr)
-         {
-            uint32 numBytes = nextReplaceMe-readPtr;
-            if (perInstanceDelta != 0) memmove(writePtr, readPtr, numBytes);
-            writePtr += numBytes;
-         }
-         else writePtr = nextReplaceMe;
-
-         memcpy(writePtr, withMe(), withMe.Length());
-         readPtr  = nextReplaceMe + replaceMe.Length();
-         writePtr += withMe.Length();
-      }
-      else
-      {
-         if (writePtr)
-         {
-            // Finish up
-            uint32 numBytes = Cstr()+Length()-readPtr;
-            if (perInstanceDelta != 0) memmove(writePtr, readPtr, numBytes);
-            writePtr += numBytes;
-            *writePtr = '\0';
-            if (perInstanceDelta > 0) 
-            {
-               temp._length = writePtr-temp();
-               SwapContents(temp);
-            }
-            else _length = writePtr-Cstr();
-         }
-         return ret;
-      }
-   }
-   return ret;  // just to shut the compiler up; we never actually get here
-}
-
-void
-String::SwapContents(String & s)
-{
-//   TCHECKPOINT;
-
-   if (&s != this)
-   {
-      bool thisSmall = (  _buffer ==   _smallBuffer);
-      bool sSmall    = (s._buffer == s._smallBuffer);
-
-      if ((sSmall)&&(thisSmall))
-      {
-         for (int32 i=anubisMax(_length, s._length); i>=0; i--) anubisSwap(_smallBuffer[i], s._smallBuffer[i]);
-      }
-      else if (thisSmall)
-      {
-         _buffer      = s._buffer;
-         _bufferLen   = s._bufferLen;
-         s._buffer    = s._smallBuffer;
-         s._bufferLen = sizeof(s._smallBuffer);
-         memcpy(s._smallBuffer, _smallBuffer, _length+1);
-      }
-      else if (sSmall)
-      {
-         s._buffer    = _buffer;
-         s._bufferLen = _bufferLen;
-         _buffer      = _smallBuffer;
-         _bufferLen   = sizeof(_smallBuffer);
-         memcpy(_smallBuffer, s._smallBuffer, s._length+1);
-      }
-      else
-      {
-         anubisSwap(_buffer,    s._buffer);
-         anubisSwap(_bufferLen, s._bufferLen);
-      }
-
-      anubisSwap(_length, s._length);   // always do this
-   }
-}
-
-int
-String::LastIndexOf(const String &s2, uint32 fromIndex) const
-{
-   if (s2.Length() == 0) return Length()-1;
-   if (fromIndex >= Length()) return -1;
-   for (int i=fromIndex; i>=0; i--) if (strncmp(Cstr()+i, s2.Cstr(), s2.Length()) == 0) return i;
-   return -1;
-}
-
-int
-String::LastIndexOf(const char * s2, uint32 fromIndex) const
-{
-   if (s2 == NULL) s2 = "";
-   uint32 s2Len = strlen(s2);
-   if (s2Len == 0) return Length()-1;
-   if (fromIndex >= Length()) return -1;
-   for (int i=fromIndex; i>=0; i--) if (strncmp(Cstr()+i, s2, s2Len) == 0) return i;
-   return -1;
-}
-
-String
-String::ToLowerCase() const
-{
-   String ret(*this);
-   if (ret._buffer) for (uint32 i=0; i<ret.Length(); i++) ret._buffer[i] = (char)tolower(ret._buffer[i]);
-   return ret;
-}
-
-String
-String::ToUpperCase() const
-{
-   String ret(*this);
-   if (ret._buffer) for (uint32 i=0; i<ret.Length(); i++) ret._buffer[i] = (char)toupper(ret._buffer[i]);
-   return ret;
-}
- 
-String 
-String::Trim() const 
-{ 
-   int32 len = (int32) Length();
-   const char * s = Cstr();
-   int32 startIdx; for (startIdx = 0;     startIdx<len;    startIdx++) if (!IsSpaceChar(s[startIdx])) break; 
-   int32 endIdx;   for (endIdx   = len-1; endIdx>startIdx; endIdx--)   if (!IsSpaceChar(s[endIdx]))   break; 
-   return String(*this, (uint32)startIdx, (uint32)(endIdx+1));
-}
-
-uint32 String :: GetNumInstancesOf(char ch) const
-{
-   uint32 ret = 0;
-   for (const char * s = Cstr(); (*s != '\0'); s++) if (*s == ch) ret++; 
-   return ret;
-}
-
-uint32 String :: GetNumInstancesOf(const String & substring) const
-{
-   uint32 ret = 0;
-   if (substring.Length() > 0)
-   {
-      uint32 lastIdx = 0;
-      int32 idx;
-      while((idx = IndexOf(substring, lastIdx)) >= 0)
-      {
-         ret++;
-         lastIdx = idx + substring.Length();
-      }
-   }
-   return ret;
-}
-
-uint32 String :: GetNumInstancesOf(const char * substring) const
-{
-   if (substring == NULL) substring = "";
-   uint32 ret = 0;
-   uint32 substringLength = strlen(substring);
-   if (substringLength > 0)
-   {
-      uint32 lastIdx = 0;
-      int32 idx;
-      while((idx = IndexOf(substring, lastIdx)) >= 0)
-      {
-         ret++;
-         lastIdx = idx + substringLength;
-      }
-   }
-   return ret;
-}
-
-String String :: Prepend(const String & str, uint32 count) const
-{
-   String ret;
-   uint32 newLen = (count*str.Length())+Length();
-   if (ret.Prealloc(newLen) == B_NO_ERROR)
-   {
-      char * b = ret._buffer;
-
-      if (str.Length() > 0)
-      {
-         for (uint32 i=0; i<count; i++)
-         {
-            memcpy(b, str(), str.Length());
-            b += str.Length();
-         }
-      }
-      if (Length() > 0)
-      {
-         memcpy(b, Cstr(), Length()); 
-         b += Length();
-      }
-      ret._length = (b-ret._buffer);
-      ret._buffer[ret._length] = '\0';   // terminate the string
-   }
-   return ret;
-}
-
-String String :: Prepend(const char * str, uint32 count) const
-{
-   if (anubisInRange(str, (const char *)_buffer, (const char *)(_buffer+Length()))) return Prepend(String(str), count);  // avoid self-entanglement!
-   else
-   {
-      if (str == NULL) str = "";
-      uint32 sLen = strlen(str);
-      String ret;
-      uint32 newLen = (count*sLen)+Length();
-      if (ret.Prealloc(newLen) == B_NO_ERROR)
-      {
-         char * b = ret._buffer;
-
-         if (sLen > 0)
-         {
-            for (uint32 i=0; i<count; i++)
-            {
-               memcpy(b, str, sLen);
-               b += sLen;
-            }
-         }
-         if (Length() > 0)
-         {
-            memcpy(b, Cstr(), Length()); 
-            b += Length();
-         }
-         ret._length = (b-ret._buffer);
-         ret._buffer[ret._length] = '\0';   // terminate the string
-      }
-      return ret;
-   }
-}
-
-String String :: Append(const String & str, uint32 count) const
-{
-   String ret;
-   uint32 newLen = Length()+(count*str.Length());
-   if (ret.Prealloc(newLen) == B_NO_ERROR)
-   {
-      char * b = ret._buffer;
-      if (Length() > 0)
-      {
-         memcpy(b, Cstr(), Length()); 
-         b += Length();
-      }
-      if (str.Length() > 0)
-      {
-         for (uint32 i=0; i<count; i++)
-         {
-            memcpy(b, str(), str.Length());
-            b += str.Length();
-         }
-      }
-      ret._length = (b-ret._buffer);
-      ret._buffer[ret._length] = '\0';   // terminate the string
-   }
-   return ret;
-}
-
-String String :: Append(const char * str, uint32 count) const
-{
-   if (anubisInRange(str, (const char *)_buffer, (const char *)(_buffer+Length()))) return Append(String(str), count);  // avoid self-entanglement!
-   else
-   {
-      if (str == NULL) str = "";
-      uint32 sLen = strlen(str);
-      String ret;
-      uint32 newLen = Length()+(count*sLen);
-      if (ret.Prealloc(newLen) == B_NO_ERROR)
-      {
-         char * b = ret._buffer;
-         if (Length() > 0)
-         {
-            memcpy(b, Cstr(), Length()); 
-            b += Length();
-         }
-         if (sLen > 0)
-         {
-            for (uint32 i=0; i<count; i++)
-            {
-               memcpy(b, str, sLen);
-               b += sLen;
-            }
-         }
-         ret._length = (b-ret._buffer);
-         ret._buffer[ret._length] = '\0';   // terminate the string
-      }
-      return ret;
-   }
-}
-
-// This method tries to ensure that at least (newBufLen) chars
-// are available for storing data in.  (requestedBufLen) should include
-// the terminating NUL.  If (retainValue) is true, the current string value
-// will be retained; otherwise it should be set right after this call
-// returns...
-status_t String::EnsureBufferSize(uint32 requestedBufLen, bool retainValue)
-{
-   if (requestedBufLen > _bufferLen)
-   {
-      if (requestedBufLen <= sizeof(_smallBuffer))  // guaranteed only to be true the very first time we are called!
-      {
-         // For small initial requests, we can just set up our buffer pointer to point to our static-buffer area.  Cheap!
-         _buffer    = _smallBuffer;
-         _bufferLen = sizeof(_smallBuffer);
-      }
-      else
-      {
-         // If we're doing a first-time allocation, allocate exactly the number of the bytes requested.
-         // If it's a re-allocation, allocate more than requested as it's more likely to happen yet another time...
-         uint32 newBufLen = (_buffer == NULL) ? requestedBufLen : (requestedBufLen * 2);
-         if (retainValue)
-         {
-            if ((_buffer)&&(_buffer != _smallBuffer))
-            {
-               // We can call muscleRealloc() to hopefully avoid data copying
-               char * newBuf = (char *)realloc(_buffer, newBufLen);
-               if (newBuf)
-               {
-                  _buffer    = newBuf;
-                  _bufferLen = newBufLen;
-               }
-               else
-               {
-//                  WARN_OUT_OF_MEMORY;
-                  return B_ERROR;
-               }
-            }
-            else
-            {
-               // Oops, muscleRealloc() won't do.... we'll just have to copy the bytes over
-               char * newBuf = (char *) malloc(newBufLen);
-               if (newBuf == NULL) 
-               {
-//                  WARN_OUT_OF_MEMORY;
-                  return B_ERROR;
-               }
-               if (_buffer) 
-                 memcpy(newBuf, _buffer, Length()+1);
-               if (_buffer != _smallBuffer) 
-                 SAFE_FREE(_buffer);
-               _buffer    = newBuf;
-               _bufferLen = newBufLen;
-            }
-         }
-         else
-         {
-            // If the caller doesn't care about retaining the value, then it's
-            // probably cheaper just to free our buffer and get a new one.
-            char * newBuf = (char *) malloc(newBufLen);
-            if (newBuf == NULL) 
-            {
-//               WARN_OUT_OF_MEMORY;
-               return B_ERROR;
-            }
-            if (_buffer != _smallBuffer) 
-              SAFE_FREE(_buffer);
-            _buffer    = newBuf;
-            _bufferLen = newBufLen;
-         }
-      }
-   }
-   return B_NO_ERROR;
-}
-
-String String :: Pad(uint32 minLength, bool padOnRight, char padChar) const
-{
-   if (Length() < minLength)
-   {
-      uint32 padLen = minLength-Length();
-      String temp; temp += padChar;
-      return (padOnRight) ? Append(temp, padLen) : Prepend(temp, padLen);
-   }
-   else return *this;
-}
-
-#define ARG_IMPLEMENTATION   \
-   char buf[256];            \
-   sprintf(buf, fmt, value); \
-   return ArgAux(buf)
-
-String String :: Arg(int8   value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(uint8  value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(int16  value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(uint16 value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(int32  value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(uint32 value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(int64  value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(uint64 value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(double value, const char * fmt) const {ARG_IMPLEMENTATION;}
-String String :: Arg(const String & value)           const {return ArgAux(value());}
-String String :: Arg(const char * value)             const {return ArgAux(value);}
-
-String String :: ArgAux(const char * buf) const
-{
-   int32 lowestArg = -1;
-   const char * s = Cstr();
-   while(*s != '\0')
-   {
-      if (*s == '%')
-      {
-         s++;
-         if (anubisInRange(*s, '0', '9'))
-         {
-            int32 val = atol(s);
-            lowestArg = (lowestArg < 0) ? val : anubisMin(val, lowestArg);
-            while(anubisInRange(*s, '0', '9')) s++; 
-         }
-      }
-      else s++;
-   }
-
-   if (lowestArg >= 0)
-   {
-      char token[64];
-      sprintf(token, "%%%li", lowestArg);
-      String ret(*this);
-      (void) ret.Replace(token, buf);
-      return ret;
-   }
-   else return *this;
-}
-
-const String & GetEmptyString()
-{
-   static const String _empty;
-   return _empty;
-}
-
-/*--- ElfHash --------------------------------------------------- 
- *  The published hash algorithm used in the UNIX ELF format 
- *  for object files. Accepts a pointer to a string to be hashed 
- *  and returns an unsigned long. 
- *  jaf:  stolen from: http://www.ddj.com/articles/1996/9604/9604b/9604b.htm?topic=algorithms
- *-------------------------------------------------------------*/ 
-uint32 CStringHashFunc(const char * n)
-{
-    uint32 h = 0, g; 
-    const unsigned char * name = (const unsigned char *) n;
-    while (*name) 
-    { 
-        h = (h << 4) + *name++; 
-        if ((g = h & 0xF0000000) != 0) h ^= g >> 24; 
-        h &= ~g; 
-    } 
-    return h; 
-}
-
-int CStringCompareFunc(const char * const & s1, const char * const & s2, void *)
-{
-    return strcmp(s1, s2);
-}
-
-int StringCompareFunc(const String & s1, const String & s2, void *)
-{
-   return anubisCompare(s1, s2);
-}
-
-END_NAMESPACE(CM);
-/* This file is Copyright 2005 Level Control Systems.  See the included LICENSE.txt file for details. */
-/* This class was derived from the String class written by Michael Olivero (mike95@mike95.com) */
- 
-/* NOTE TO MACOS/X X-CODE USERS:  If you are trying to #include <string.h>
- * and X-Code is "helpfully" pulling in this file instead (because the
- * OS/X filesystem is case-insensitive), you can get around that problem
- * by adding "USE_HEADERMAP = NO" to your X-Code target settings.
- * ref:  http://lists.apple.com/archives/xcode-users/2004/Aug/msg00934.html
- *  --Jeremy
- */
-
-#ifndef MuscleString_h
-#define MuscleString_h
-
-#include <string.h> 
-#include <ctype.h> 
-#include "AnubisSupport.h"
-
-BEGIN_NAMESPACE(CM);
-
-#ifndef SMALL_MUSCLE_STRING_LENGTH
-# define SMALL_MUSCLE_STRING_LENGTH 7  // strings shorter than this length can be stored inline, without requiring an extra new[].
-#endif
-
-/** A nice hashing function for use with (const char *)'s */
-uint32 CStringHashFunc(const char * str); 
-
-/** A character string class.  Represents a dynamically resizable NUL-terminated string. */
-class String
-{
-public:
-   /** Constructor.
-    *  @param str If non-NULL, the initial value for this String.
-    *  @param maxLen The maximum number of characters to place into
-    *                this String (not including the NUL terminator byte).
-    *                Default is unlimited (i.e. scan the entire string no matter how long it is)
-    */
-   String(const char * str = NULL, uint32 maxLen = ((uint32)-1)) : _buffer(NULL), _bufferLen(0), _length(0) {if (str) (void) SetCstr(str, maxLen);}
-
-   /** Copy Constructor. 
-     * @param str String to become a copy of.
-     */
-   String(const String & str) : _buffer(NULL), _bufferLen(0), _length(0) {(void) SetFromString(str);}
-
-   /** This constructor sets this String to be a substring of the specified String.
-     * @param str String to become a copy of.
-     * @param beginIndex Index of the first character in (str) to include.
-     * @param endIndex Index after the last character in (str) to include.  
-     *                 Defaults to a very large number, so that by default the entire remainder of the string is included.
-     */
-   String(const String & str, uint32 beginIndex, uint32 endIndex=((uint32)-1)) : _buffer(NULL), _bufferLen(0), _length(0) {(void) SetFromString(str, beginIndex, endIndex);}
-
-   /** Destructor. */
-   virtual ~String();
-
-   /** Assignment Operator.  Sets this string to be a one-character string
-     * @param val The character that should be the sole character in this String.
-     */
-   String & operator = (char val) {(void) SetCstr(&val, 1); return *this;}
-
-   /** Assignment Operator. 
-     * @param val Pointer to the C-style string to copy from.  If NULL, this string will become "".
-     */
-   String & operator = (const char * val) {(void) SetCstr(val); return *this;}
-
-   /** Assignment Operator. 
-     * @param rhs String to become a copy of.
-     */
-   String & operator = (const String &rhs) {(void) SetFromString(rhs); return *this;}
-
-   /** Append Operator. 
-    *  @param rhs A string to append to this string.
-    */
-   String & operator += (const String &rhs);
-
-   /** Append Operator. 
-    *  @param rhs A string to append to this string.  If NULL, this operation is a no-op.
-    */
-   String & operator += (const char * rhs);
-
-   /** Append Operator.
-    *  @param ch A character to append to this string.
-    */
-   String & operator += (const char ch)
-   {
-      if (EnsureBufferSize(Length()+2, true) == B_NO_ERROR)
-      {
-         _buffer[_length++] = ch;
-         _buffer[_length]   = '\0';
-      }
-      return *this;
-   }
-   
-   /** Remove Operator. 
-    *  @param rhs A substring to remove from this string;  the
-    *             last instance of the substring will be cut out.
-    *             If (rhs) is not found, there is no effect.
-    */
-   String & operator -= (const String &rhs);
-
-   /** Remove Operator.
-    *  @param ch A character to remove from this string;  the last
-    *            instance of this char will be cut out.  If (ch) is
-    *            not found, there is no effect.
-    */
-   String & operator -= (const char ch);
-   
-   /** Append 'Stream' Operator.
-    *  @param rhs A String to append to this string.
-    *  @return a non const String refrence to 'this' so you can chain appends.
-    */
-   String & operator << (const String& rhs) {return (*this += rhs);}
-
-   /** Append 'Stream' Operator.
-    *  @param rhs A const char* to append to this string.
-    *  @return a non const String refrence to 'this' so you can chain appends.
-    */
-   String & operator << (const char* rhs) {return (*this += rhs);}
-   
-   /** Append 'Stream' Operator.
-    *  @param rhs An int to append to this string.
-    *  @return a non const String refrence to 'this' so you can chain appends.
-    */
-   String & operator << (int rhs);   
-
-   /** Append 'Stream' Operator.
-    *  @param rhs A float to append to this string. Formatting is set at 2 decimals of precision.
-    *  @return a non const String refrence to 'this' so you can chain appends.
-    */
-   String & operator << (float rhs);   
-
-   /** Append 'Stream' Operator.
-    *  @param rhs A bool to append to this string. Converts to 'true' and 'false' strings appropriately.
-    *  @return a non const String refrence to 'this' so you can chain appends.
-    */
-   String & operator << (bool rhs);
-
-   /** Comparison Operator.  Returns true if the two strings are equal (as determined by strcmp())
-     * @param rhs A string to compare ourself with
-     */
-   bool operator == (const String &rhs) const {return ((this == &rhs)||((Length() == rhs.Length())&&(strcmp(Cstr(), rhs.Cstr()) == 0)));}
-
-   /** Comparison Operator.  Returns true if the two strings are equal (as determined by strcmp())
-     * @param rhs Pointer to a C string to compare with.  NULL pointers are considered a synonym for "".
-     */
-   bool operator == (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") == 0);}
-
-   /** Comparison Operator.  Returns true if the two strings are not equal (as determined by strcmp())
-     * @param rhs A string to compare ourself with
-     */
-   bool operator != (const String &rhs) const {return !(*this == rhs);}
-
-   /** Comparison Operator.  Returns true if the two strings are not equal (as determined by strcmp())
-     * @param rhs Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool operator != (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") != 0);}
-
-   /** Comparison Operator.  Returns true if this string comes before (rhs) lexically. 
-     * @param rhs A string to compare ourself with
-     */
-   bool operator < (const String &rhs) const {return (this == &rhs) ? false : (strcmp(Cstr(), rhs.Cstr()) < 0);}
-
-   /** Comparison Operator.  Returns true if this string comes before (rhs) lexically. 
-     * @param rhs Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool operator < (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") < 0);}
-
-   /** Comparison Operator.  Returns true if this string comes after (rhs) lexically. 
-     * @param rhs A string to compare ourself with
-     */
-   bool operator > (const String &rhs) const {return (this == &rhs) ? false : (strcmp(Cstr(), rhs.Cstr()) > 0);}
-
-   /** Comparison Operator.  Returns true if this string comes after (rhs) lexically. 
-     * @param rhs Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool operator > (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") > 0);}
-
-   /** Comparison Operator.  Returns true if the two strings are equal, or this string comes before (rhs) lexically. 
-     * @param rhs A string to compare ourself with
-     */
-   bool operator <= (const String &rhs) const {return (this == &rhs) ? true : (strcmp(Cstr(), rhs.Cstr()) <= 0);}
-
-   /** Comparison Operator.  Returns true if the two strings are equal, or this string comes before (rhs) lexically. 
-     * @param rhs Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool operator <= (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") <= 0);}
-
-   /** Comparison Operator.  Returns true if the two strings are equal, or this string comes after (rhs) lexically. 
-     * @param rhs A string to compare ourself with
-     */
-   bool operator >= (const String &rhs) const {return (this == &rhs) ? true : (strcmp(Cstr(), rhs.Cstr()) >= 0);}
-
-   /** Comparison Operator.  Returns true if the two strings are equal, or this string comes after (rhs) lexically. 
-     * @param rhs Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool operator >= (const char * rhs) const {return (strcmp(Cstr(), rhs?rhs:"") >= 0);}
-
-   /** Array Operator.  Used to get easy access to the characters that make up this string.
-    *  @param index Index of the character to return.  Be sure to only use valid indices!
-    */
-   char operator [] (uint32 index) const {VerifyIndex(index); return _buffer[index];}
-
-   /** Array Operator.  Used to get easy access to the characters that make up this string.
-    *  @param index Index of the character to set.  Be sure to only use valid indices!
-    */
-   char & operator [] (uint32 index) {VerifyIndex(index); return _buffer[index];}
-
-   /** Returns the character at the (index)'th position in the string.
-    *  @param index A value between 0 and (Length()-1), inclusive.
-    *  @return A character value.
-    */
-   char CharAt(uint32 index) const {return operator[](index);}
- 
-   /** Compares this string to another string using strcmp() 
-     * @param rhs A string to compare ourself with
-     */
-   int CompareTo(const String & rhs) const {return strcmp(Cstr(), rhs.Cstr());}
-
-   /** Compares this string to a C string using strcmp()
-     * @param rhs Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   int CompareTo(const char * rhs) const {return strcmp(Cstr(), rhs?rhs:"");}
-
-   /** Returns a read-only C-style pointer to our held character string. */
-   const char * Cstr() const {return _buffer ? _buffer : "";}
-
-   /** Convenience synonym for Cstr(). */
-   const char * operator()() const {return Cstr();}  
-
-   /** Clears this string so that it contains no characters.  Equivalent to setting it to "". */
-   void Clear() {if (_buffer) _buffer[0] = '\0'; _length = 0;}
-
-   /** Sets our state from the given C-style string.
-     * @param str The new string to copy from.  If maxLen is negative, this may be NULL.
-     * @param maxLen If set, the number of characters to copy (not including the NUL
-     *               terminator byte).  By default, the number of characters is determined
-     *               automatically by scanning the string.
-     */
-   status_t SetCstr(const char * str, uint32 maxLen = ((uint32)-1));
-
-   /** Sets our state from the given String.  This is similar to the copy constructor, except
-     * that it allows you to optionally specify a maximum length, and it allows you to detect
-     * out-of-memory errors.
-     * @param str The new string to copy from.
-     * @param beginIndex Index of the first character in (str) to include.
-     * @param endIndex Index after the last character in (str) to include.  
-     *                 Defaults to a very large number, so that by default the entire remainder of the string is included.
-     * @returns B_NO_ERROR on success, or B_ERROR on failure (out of memory?)
-     */
-   status_t SetFromString(const String & str, uint32 firstChar = 0, uint32 maxLen = ((uint32)-1));
-
-   /** Returns true iff this string starts with (prefix) 
-     * @param c a character to check for at the end of this String.
-     */
-   bool EndsWith(char c) const {return (_length > 0)&&(_buffer[_length-1] == c);}
-
-   /** Returns true iff this string ends with (suffix) 
-     * @param suffix a String to check for at the end of this String.
-     */
-   bool EndsWith(const String &suffix) const {return (Length() < suffix.Length()) ? false : (strcmp(Cstr()+(Length()-suffix.Length()), suffix.Cstr()) == 0);}
-
-   /** Returns true iff this string ends with (suffix) 
-     * @param suffix a String to check for at the end of this String.  NULL pointers are treated as a synonym for "".
-     */
-   bool EndsWith(const char * suffix) const
-   { 
-      if (suffix == NULL) suffix = "";
-      uint32 suffixLen = strlen(suffix);
-      return (Length() < suffixLen) ? false : (strcmp(Cstr()+(Length()-suffixLen), suffix) == 0); 
-   }
-
-   /** Returns true iff this string is equal to (string), as determined by strcmp(). 
-     * @param str a String to compare this String with.
-     */
-   bool Equals(const String & str) const {return (*this == str);}
-
-   /** Returns true iff this string is equal to (str), as determined by strcmp(). 
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool Equals(const char * str) const {return (*this == str);}
-
-   /** Returns true iff this string contains a single character (c). 
-     * @param c a character to compare this String with.
-     */
-   bool Equals(char c) const {return (_length == 1)&&(_buffer[0] == c);}
-
-   /** Returns the first index of (ch) in this string starting at or after (fromIndex), or -1 if not found. 
-     * @param ch A character to look for in this string.
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int IndexOf(char ch, uint32 fromIndex = 0) const
-   {
-      const char * temp = (fromIndex < Length()) ? strchr(Cstr()+fromIndex, ch) : NULL; 
-      return temp ? (temp - Cstr()) : -1; 
-   }
-
-   /** Returns the first index of substring (str) in this string starting at or after (fromIndex), or -1 if not found. 
-     * @param str A String to look for in this string.
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int IndexOf(const String &str, uint32 fromIndex = 0) const
-   {
-      const char * temp = (fromIndex < Length()) ? strstr(Cstr()+fromIndex, str()) : NULL;
-      return temp ? (temp - Cstr()) : -1;
-   }
-
-   /** Returns the first index of substring (str) in this string starting at or after (fromIndex), or -1 if not found.
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int IndexOf(const char * str, uint32 fromIndex = 0) const
-   {
-      const char * temp = (fromIndex < Length()) ? strstr(Cstr()+fromIndex, str?str:"") : NULL;
-      return temp ? (temp - Cstr()) : -1;
-   }
-
-   /** Returns the last index of (ch) in this string starting at or after (fromIndex), or -1 if not found. 
-     * @param ch A character to look for in this string.
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int LastIndexOf(char ch, uint32 fromIndex = 0) const
-   {
-      const char * lio = (fromIndex < Length()) ? strrchr(Cstr()+fromIndex, ch) : NULL;
-      return lio ? (lio - Cstr()) : -1;
-   }
-
-   /** Returns the last index of substring (str) in this string  
-     * @param str A String to look for in this string.
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int LastIndexOf(const String &str) const {return (str.Length() <= Length()) ? LastIndexOf(str, Length()-str.Length()) : -1;}
-
-   /** Returns the last index of substring (str) in this string 
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   int LastIndexOf(const char * str) const
-   {
-      if (str == NULL) str = "";
-      uint32 strLen = strlen(str);
-      return (strLen <= Length()) ? LastIndexOf(str, Length()-strLen) : -1;
-   }
-
-   /** Returns the last index of substring (str) in this string starting at or after (fromIndex), or -1 if not found.
-     * @param str A String to look for in this string.
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int LastIndexOf(const String &str, uint32 fromIndex) const;
-
-   /** Returns the last index of substring (str) in this string starting at or after (fromIndex), or -1 if not found. 
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     * @param fromIndex Index of the first character to start searching at in this String.  Defaults to zero (i.e. start from the first character)
-     */
-   int LastIndexOf(const char * str, uint32 fromIndex) const;
-
-   /** Returns the number of characters in the string (not including the terminating NUL byte) */
-   uint32 Length() const {return _length;}
-
-   /** Returns the number of instances of (c) in this string. */
-   uint32 GetNumInstancesOf(char ch) const;
-
-   /** Returns the number of instances of (substring) in this string. */
-   uint32 GetNumInstancesOf(const String & substring) const;
-
-   /** Returns the number of instances of (substring) in this string. */
-   uint32 GetNumInstancesOf(const char * substring) const;
-
-   /** Returns true iff this string starts with (prefix) */
-   bool StartsWith(char c) const {return (_length > 0)&&(_buffer[0] == c);}
-
-   /** Returns true iff this string starts with (prefix) */
-   bool StartsWith(const String &str) const {return ((Length() >= str.Length())&&(strncmp(Cstr(), str(), str.Length()) == 0));}
-
-   /** Returns true iff this string starts with (prefix)
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool StartsWith(const char * prefix) const
-   {
-      if (prefix == NULL) prefix = "";
-      uint32 prefixLen = strlen(prefix);
-      return (Length() < prefixLen) ? false : (strncmp(Cstr(), prefix, prefixLen) == 0);
-   }
-
-   /** Returns true iff this string starts with the first (offset) characters of (prefix) */
-   bool StartsWith(const String &prefix, uint32 offset) const {return ((offset+prefix.Length()<=Length())&&(strncmp(Cstr()+offset, prefix.Cstr(), prefix.Length()) == 0));}
-
-   /** Returns true iff this string starts with the first (offset) characters of (prefix) 
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     */
-   bool StartsWith(const char * prefix, uint32 offset) const
-   {
-      if (prefix == NULL) prefix = "";
-      uint32 prefixLen = strlen(prefix);
-      return ((offset+prefixLen<=Length())&&(strncmp(Cstr()+offset, prefix, prefixLen) == 0));
-   }
-
-   /** Returns a string that consists of (count) copies of (str), followed by this string. */
-   String Prepend(const String & str, uint32 count = 1) const;
-
-   /** Returns a string that consists of (count) copies of (str), followed by this string. 
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     * @param count How many instances of (str) should be prepended to this string.  Defaults to 1.
-     */
-   String Prepend(const char * str, uint32 count = 1) const;
-
-   /** Returns a string that consists of this string followed by (count) copies of (str). */
-   String Append(const String & str, uint32 count = 1) const;
-
-   /** Returns a string that consists of this string followed by (count) copies of (str). 
-     * @param str Pointer to a C string to compare to.  NULL pointers are considered a synonym for "".
-     * @param count How many instances of (str) should be appended to this string.  Defaults to 1.
-     */
-   String Append(const char * str, uint32 count = 1) const;
-
-   /** Returns a string that is like this string, but padded out to the specified minimum length with (padChar).
-    *  @param minLength Minimum length that the returned string should be.
-    *  @param padOnRight If true, (padChar)s will be added to the right; if false (the default), they will be added on the left.
-    *  @param padChar The character to pad out the string with.  Defaults to ' '.
-    *  @returns the new, padded String.
-    */
-   String Pad(uint32 minLength, bool padOnRight = false, char padChar = ' ') const;
-
-   /** Returns a string that consists of only the last part of this string, starting with index (beginIndex).  Does not modify the string it is called on. */
-   String Substring(uint32 beginIndex) const {return String(*this, beginIndex);}
-
-   /** Returns a string that consists of only the characters in this string from range (beginIndex) to (endIndex-1).  Does not modify the string it is called on. */
-   String Substring(uint32 beginIndex, uint32 endIndex) const {return String(*this, beginIndex, endIndex);}
-
-   /** Returns a string that consists of only the last part of this string, starting with the first character after the last instance of (markerString).  
-    *  If (markerString) is not found in the string, then this entire String is returned.
-    *  For example, String("this is a test").Substring("is a") returns " test".
-    *  Does not modify the string it is called on. 
-    */
-   String Substring(const String & markerString) const
-   {
-      int idx = LastIndexOf(markerString);
-      return (idx >= 0) ? String(*this, idx+markerString.Length()) : *this;
-   }
-
-   /** See the Substring(const String &) documentation for details. */
-   String Substring(const char * markerString) const
-   {
-      int idx = LastIndexOf(markerString);
-      return (idx >= 0) ? String(*this, idx+strlen(markerString)) : *this;  // if (idx >= 0), then we know markerString is non-NULL
-   }
-
-   /** Returns a string that consists of only the characters in the string from range (beginIndex) until the character just before
-    *  the first character in (markerString).  If (markerString) is not found, then the entire substring starting at (beginIndex) is returned.
-    *  For example, String("this is a test").Substring(1, "is a") returns "his ".
-    *  Does not modify the string it is called on. 
-    */
-   String Substring(uint32 beginIndex, const String & markerString) const {return String(*this, beginIndex, (uint32) IndexOf(markerString, beginIndex));}
-
-   /** See the Substring(uint32, const String &) documentation for details. */
-   String Substring(uint32 beginIndex, const char * markerString) const {return String(*this, beginIndex, (uint32) IndexOf(markerString, beginIndex));}
-
-   /** Returns an all lower-case version of this string.  Does not modify the string it is called on. */
-   String ToLowerCase() const; 
-
-   /** Returns an all upper-case version of this string.  Does not modify the string it is called on. */
-   String ToUpperCase() const; 
-
-   /** Returns an version of this string that has all leading and trailing whitespace removed.  Does not modify the string it is called on. */
-   String Trim() const;  
-
-   /** Swaps the state of this string with (swapWithMe).  Very efficient since little or no data copying is required. */
-   void SwapContents(String & swapWithMe);
-
-   /** Like CompareTo(), but case insensitive. */
-   int CompareToIgnoreCase(const String &s) const             {return ToLowerCase().CompareTo(s.ToLowerCase());}
-
-   /** Like EndsWith(), but case insensitive. */
-   bool EndsWithIgnoreCase(char c) const                      {return (_length > 0)&&(tolower(_buffer[_length-1]) == tolower(c));}
-
-   /** Like EndsWith(), but case insensitive. */
-   bool EndsWithIgnoreCase(const String &s) const             {return ToLowerCase().EndsWith(s.ToLowerCase());}
-
-   /** Like Equals(), but case insensitive. */
-   bool EqualsIgnoreCase(const String &s) const               {return ToLowerCase().Equals(s.ToLowerCase());}
-
-   /** Like Equals(), but case insensitive. */
-   bool EqualsIgnoreCase(char c) const                        {return (_length==1)&&(tolower(_buffer[0])==tolower(c));}
-
-   /** Like IndexOf(), but case insensitive. */
-   int IndexOfIgnoreCase(const String &s) const               {return ToLowerCase().IndexOf(s.ToLowerCase());}
-
-   /** Like IndexOf(), but case insensitive. */
-   int IndexOfIgnoreCase(const String &s, uint32 f) const     {return ToLowerCase().IndexOf(s.ToLowerCase(),f);}
-
-   /** Like IndexOf(), but case insensitive. */
-   int IndexOfIgnoreCase(char ch) const                       {return ToLowerCase().IndexOf((char)tolower(ch));}
-
-   /** Like IndexOf(), but case insensitive. */
-   int IndexOfIgnoreCase(char ch, uint32 f) const             {return ToLowerCase().IndexOf((char)tolower(ch),f);}
-
-   /** Like LastIndexOf(), but case insensitive. */
-   int LastIndexOfIgnoreCase(const String &s) const           {return ToLowerCase().LastIndexOf(s.ToLowerCase());}
-
-   /** Like LastIndexOf(), but case insensitive. */
-   int LastIndexOfIgnoreCase(const String &s, uint32 f) const {return ToLowerCase().LastIndexOf(s.ToLowerCase(),f);}
-
-   /** Like LastIndexOf(), but case insensitive. */
-   int LastIndexOfIgnoreCase(char ch) const                   {return ToLowerCase().LastIndexOf((char)tolower(ch));}
-
-   /** Like LastIndexOf(), but case insensitive. */
-   int LastIndexOfIgnoreCase(char ch, uint32 f) const         {return ToLowerCase().LastIndexOf((char)tolower(ch),f);}
-
-   /** Like EndsWith(), but case insensitive. */
-   bool StartsWithIgnoreCase(char c) const                    {return (_length > 0)&&(tolower(_buffer[0]) == tolower(c));}
-
-   /** Like StartsWith(), but case insensitive. */
-   bool StartsWithIgnoreCase(const String &s) const           {return ToLowerCase().StartsWith(s.ToLowerCase());}
-
-   /** Like StartsWith(), but case insensitive. */
-   bool StartsWithIgnoreCase(const String &s, uint32 o) const {return ToLowerCase().StartsWith(s.ToLowerCase(),o);}
-
-   /** Returns a hash code for this string */
-   inline uint32 HashCode() const {return CStringHashFunc(Cstr());}
-
-   /** Replaces all instances of (oldChar) in this string with (newChar).
-     * @param replaceMe The character to search for.
-     * @param withMe The character to replace all occurrences of (replaceMe) with.
-     * @returns The number of characters that were successfully replaced.
-     */
-   uint32 Replace(char replaceMe, char withMe); 
-
-   /** Replaces all instances of (replaceMe) in this string with (withMe).
-     * @param replaceMe The substring to search for.
-     * @param withMe The substring to replace all occurrences of (replaceMe) with.
-     * @returns The number of substrings that were successfully replaced, or -1
-     *          if the operation failed (out of memory, or (replaceMe) was of length zero)
-     */
-   int32 Replace(const String & replaceMe, const String & withMe); 
- 
-   /** Reverses the order of all characters in the string, so that e.g. "string" becomes "gnirts" */
-   void Reverse();
-
-   /** Part of the Flattenable interface.
-    *  @return false
-    */
-   virtual bool IsFixedSize() const {return false;}
-
-   /** Part of the Flattenable interface.
-    *  @return B_STRING_TYPE
-    */
-   status_t Prealloc(uint32 numChars) {return EnsureBufferSize(numChars+1, true);}
-
-   /** Returns a string like this string, but with the appropriate %# tokens
-     * replaced with a textual representation of the values passed in as (value).
-     * For example, String("%1 is a %2").Arg(13).Arg("bakers dozen") would return
-     * the string "13 is a bakers dozen".
-     * @param value The value to replace in the string.
-     * @param fmt The format parameter to pass to sprintf().  Note that if you supply your
-     *            own format string, you'll need to be careful since a badly chosen format
-     *            string could lead to a crash or out-of-bounds memory overwrite.  In particular,
-     *            the format string should match the type specified, and should not lead to
-     *            more than 256 bytes being written.
-     * @returns a new String with the appropriate tokens replaced.
-     */
-   String Arg(int8 value,   const char * fmt = "%i")   const;
-
-   /** As above, but for uint8 values. */
-   String Arg(uint8 value,  const char * fmt = "%u")   const;
-
-   /** As above, but for int16 values. */
-   String Arg(int16 value,  const char * fmt = "%i")   const;
-
-   /** As above, but for uint16 values. */
-   String Arg(uint16 value, const char * fmt = "%u")   const;
-
-   /** As above, but for int32 values. */
-   String Arg(int32 value,  const char * fmt = "%li")  const;
-
-   /** As above, but for uint32 values. */
-   String Arg(uint32 value, const char * fmt = "%lu")  const;
-
-   /** As above, but for int64 values. */
-   String Arg(int64 value,  const char * fmt = INT64_FORMAT_SPEC) const;
-
-   /** As above, but for uint64 values. */
-   String Arg(uint64 value, const char * fmt = UINT64_FORMAT_SPEC) const;
-
-   /** As above, but for double values. */
-   String Arg(double value, const char * fmt = "%f")   const;
-
-   /** As above, but for string values. */
-   String Arg(const String & value) const;
-   String Arg(const char * value) const;
-
-private:
-   bool IsSpaceChar(char c) const {return ((c==' ')||(c=='\t')||(c=='\r')||(c=='\n'));}
-   status_t EnsureBufferSize(uint32 newBufLen, bool retainValue);
-   String ArgAux(const char * buf) const;
-
-   char _smallBuffer[SMALL_MUSCLE_STRING_LENGTH+1];  // store very small strings in-line, to avoid dynamic allocation
-   char * _buffer;            // Stores the chars.  May point at (_smallBuffer), or a dynamically allocated buffer
-   uint32 _bufferLen;         // Number of bytes pointed to by (_buffer)
-   uint32 _length;            // cached strlen(_buffer)
-
-   void VerifyIndex(uint32 index) const 
-   {
-#ifdef ANUBIS_AVOID_ASSERTIONS
-      (void) index;  // avoid compiler warnings
-#else
-      MASSERT(index < _length, "Index Out Of Bounds Exception");
-#endif
-   }
-};
-
-/** Convenience method:  returns a string with no characters in it (a.k.a. "") */
-const String & GetEmptyString();
-
-template <class T> class HashFunctor;
-
-template <>
-class HashFunctor<String>
-{
-public:
-   uint32 operator () (const String & x) const {return CStringHashFunc(x());}
-};
-
-template <>
-class HashFunctor<const char *>
-{
-public:
-   uint32 operator () (const char * x) const {return CStringHashFunc(x);}
-};
-
-/** A function for comparing (const String &)'s -- calls the String operators */
-int StringCompareFunc(const String &, const String &, void *);
-
-/** A function for comparing (const char *)'s -- calls strcmp() */
-int CStringCompareFunc(const char * const &, const char * const &, void *);
-
-inline String operator+(const String & lhs, const String &rhs)  {String ret(lhs); ret += rhs; return ret;}
-inline String operator+(const String & lhs, const char *rhs)    {String ret(lhs); ret += rhs; return ret;}
-inline String operator+(const char * lhs,   const String & rhs) {String ret(lhs); ret += rhs; return ret;}
-inline String operator+(const String & lhs, char rhs)           {String ret(lhs); ret += rhs; return ret;}
-inline String operator-(const String & lhs, const String &rhs)  {String ret(lhs); ret -= rhs; return ret;}
-inline String operator-(const String & lhs, const char *rhs)    {String ret(lhs); ret -= rhs; return ret;}
-inline String operator-(const char *lhs,    const String &rhs)  {String ret(lhs); ret -= rhs; return ret;}
-inline String operator-(const String & lhs, char rhs)           {String ret(lhs); ret -= rhs; return ret;}
-
-END_NAMESPACE(muscle);
-
-#endif
@@ -120,11 +120,11 @@ void handle_sigsegv(int sig)
  
 int security_zone_size = 0;    
  
-char *home_directory = NULL;    
+String home_directory;    
 String anubis_directory; 
 String my_anubis_directory; 
 String anubisVMRootDirectory;
-char *trusted_certs_directory = NULL;    
+String trusted_certs_directory;    
  
 fd_set rfds; 
 fd_set wfds;
@@ -998,7 +998,7 @@ int main(int argc, char **argv)
  
   //here we make all host OS dependencies init, before entering in kernel land
   kernelInit();
-  anubisVMRootDirectory = GetVMRootDir(argv[0]);
+  anubisVMRootDirectory = GetProgramRootDir(argv[0]);
   LOGINFO("ROOT DIR %s\n",anubisVMRootDirectory.Cstr());
 #ifdef WIN32_OLD   
   lpCmdLine = GetCommandLine();
@@ -1203,7 +1203,7 @@ int main(int argc, char **argv)
               LOGERROR("Not enough memory.\n"); 
               my_exit(1); 
             }
-          sprintf(trusted_certs_directory,"%s/trusted_certs",my_anubis_directory.Cstr()); 
+          trusted_certs_directory = my_anubis_directory + "/trusted_certs"; 
         }
  
       if ((random_file = (char *)malloc(my_anubis_directory.Length()+30)) == NULL)
-/*
-* Gestion de la console du terminal
-*
-* (c)2004 Alain Prouté
-* Auteur : David RENE david.rene@free.fr
-*
-*/
-
-#include <stdarg.h>
-#include <stdio.h>
-#include <string.h>
-#include <stdlib.h>
-#include "debug_log.h"
-#include <time.h>
-
-#ifdef WIN32
-#include <windows.h>
-#endif
-
-
-
-void LogInfo(const char *format, ...)
-{
- char buf[2048];
- va_list ap;
- va_start (ap, format);
- vsprintf (buf, format, ap);
- va_end (ap);
- Log(stdout, buf);
-}
-
-void LogError(const char *format, ...)
-{
- char buf[2048];
- va_list ap;
- va_start (ap, format);
- vsprintf (buf, format, ap);
- va_end (ap);
- Log(stderr, buf);
-}
-
-void Log(FILE * output, char *logString)
-{
- //Ecris sur la console fenetre
-#if defined (__BEOS__) || (_LINUX_) || (WIN32)
-  fprintf(output, "%s", logString);
-    if(output == stderr)
-      fflush(output);
-#endif 
-}
-#ifndef __DEBUGLOG_H__
-#define __DEBUGLOG_H__
-
-#include <stdio.h>
-//if(DebugLog::Db)
-//{ 
-// char prompt[32]; 
-// GetPrompt(prompt); 
-// DebugLog::Db->SetPrompt(prompt);
-//} 
-//if(DebugLog::Db)
-// DebugLog::Db->LogCriticalError###
-
-//#define LOGCRITICALERROR if(DebugLog::Db) DebugLog::Db->LogCriticalError
-#define LOGERROR     LogError
-//#define PRINTF      if(DebugLog::Db) DebugLog::Db->LogWarning
-#define LOGINFO      LogInfo
-//#define LOGDEBUG     if(DebugLog::Db) DebugLog::Db->LogDebug
-//#define LOGTRACE     if(DebugLog::Db) DebugLog::Db->LogTrace
-
-
- 
-// void LogCriticalError(const char *format, ...);
- void LogError(const char *format, ...);
-// void LogWarning(const char *format, ...);
- void LogInfo(const char *format, ...);
-// void LogDebug(const char *format, ...);
-// void LogTrace(const char *format, ...);
- 
- void Log(FILE *, char *format);
- 
-#endif
-   
-   
@@ -57,6 +57,7 @@ int sslnofree = 0;
  
 extern String anubis_directory; 
 extern String my_anubis_directory; 
+extern String trusted_certs_directory;
  
 static char *tmp_file_name = "tmp_17dee617b56ed2e6ce54b4042ed87ad4db57d68c"; 
  
@@ -371,9 +372,9 @@ void init_openssl(void)
       my_exit(1);  
     }
  
-  if (!(SSL_CTX_load_verify_locations(ssl_ctx,NULL,trusted_certs_directory)))
+  if (!(SSL_CTX_load_verify_locations(ssl_ctx,NULL,trusted_certs_directory.Cstr())))
     {
-      LOGERROR("Cannot load trusted certificates from '%s'.\n",trusted_certs_directory);
+      LOGERROR("Cannot load trusted certificates from '%s'.\n",trusted_certs_directory.Cstr());
       my_exit(1); 
     }
   SSL_CTX_set_verify_depth(ssl_ctx,1); 
@@ -89,7 +89,7 @@ U32 end_debug = 0;
  
 extern String anubis_directory; 
 extern String my_anubis_directory; 
-
+extern String trusted_certs_directory;
  
 #define vmbuf_size (2000)   
 char vmbuf[vmbuf_size]; 
@@ -8559,7 +8559,7 @@ if (debugging ||
                                       NID_commonName,peer_CN,256),
           do { m_R = 3; m_IP += 1+2; goto do_computing; } while(0)); 
  
-          if (trusted_certs_directory == NULL)
+          if (trusted_certs_directory.Length() == NULL)
             {
               m_R = 0;    // ca_directory_not_found
             }
@@ -48,7 +48,7 @@
 #include <openssl/rand.h>
  
 extern SSL_CTX *ssl_ctx; 
-extern char *   trusted_certs_directory;    
+//extern char *   trusted_certs_directory;    
 #endif
  
 #ifdef WIN32
-
-   
-/* Windows dedicated file */ 
-   
-   
-#include "../host_graph.h"
-#include "../vm.h"
-#include <assert.h>
-#include <zmouse.h>
-
-HWND	hDesktop; 
-HDC	domain_area;
-
-int host_translate_key(int k);
-int host_translate_exkey(int k);
-U8  host_translate_keyboard_state(unsigned int state);
-
-
-void host_init_graphism(void)
-{
-	RECT rect;
-	hDesktop = GetDesktopWindow();
-	domain_area = GetDC(NULL);
-
-	rect.bottom;
-}
-
-BOOL host_sc_open_host_window(U32 xPos, U32 yPos, U32 wSize, U32 hSize, char * winTitle, BOOL transcientFlag, U32 * the_window, U32 * the_gc)
-{
-WNDCLASSEX	wc; 
-HWND				lHWND;
-HostWindow	the_window_ptr;
-
-	wc.cbSize		= sizeof(WNDCLASSEX); 
-	wc.style		= CS_HREDRAW | CS_VREDRAW;
-	wc.lpfnWndProc		= AnubisWindowProc;
-	wc.cbClsExtra		= 0; 
-	wc.cbWndExtra		= 0; 
-	wc.hInstance	        = (HINSTANCE)0x00400000;
-	wc.hIcon		= NULL; 
-	wc.hCursor		= LoadCursor(NULL, IDC_ARROW); 
-  wc.hbrBackground	        = NULL; 
-	wc.lpszMenuName		= NULL; 
-  wc.lpszClassName	        = winTitle; 
-	wc.hIconSm		= NULL;   
-	
-	RegisterClassEx(&wc); 
-
-/* Create the window */
-	lHWND = CreateWindow(winTitle, 
-			    winTitle,
-			    WS_OVERLAPPEDWINDOW, //WS_POPUP, //,
-		            xPos,
-			    yPos,
-			    wSize, 
-			    hSize,
-			    NULL,
-			    NULL,
-			    NULL,
-			    NULL); 
-
-
-	the_window_ptr = (HostWindow)malloc(sizeof(HostWindow_type));
-
-	if(the_window_ptr)
-	{
-		memset(the_window_ptr,0,sizeof(HostWindow_type));
-
-		the_window_ptr->handle = lHWND;
-
-		*the_window = (U32)the_window_ptr;
-		*the_gc	    = (U32)NULL;
-
-		//always return TRUE at this time, maybe we manage error in the future
-		return TRUE;
-	}
-	
-	return FALSE;
-}
-
-void	host_sc_show_host_window(U32 theWindow)
-{
-	HostWindow win = (HostWindow)theWindow;
-
-	ShowWindow(win->handle, SW_SHOW);
-	UpdateWindow(win->handle);
-  SetCursor(LoadCursor(NULL, IDC_ARROW));
-}
-
-void	host_sc_hide_host_window(U32 theWindow)
-{
-	HostWindow win = (HostWindow)theWindow;
-
-	ShowWindow(win->handle, SW_HIDE);
-	UpdateWindow(win->handle);
-  
-}
-
-void host_free_host_window(U32 winPointer)
-{
-	assert(winPointer);
-
-	free((HostWindow) winPointer);
-
-}
-
-void host_free_host_pixmap(U32 pixPointer)
-{
-	assert(pixPointer);
-	free((HostImage) pixPointer);
-}
-
-void host_free_host_gc(U32 winPointer)
-{
-	//nothing to do at this time
-	return; 
-}
-
-void	host_sc_host_window_size(U32 theWindow, int * wSize, int * hSize)
-{
-	RECT rect;
-	HostWindow win = (HostWindow)theWindow;
-	
-	GetWindowRect(win->handle, &rect);
-	*wSize = rect.right - rect.left;
-	*hSize = rect.bottom - rect.top;
-}
-
-void    host_sc_resize_host_window(U32 theWindow, int width, int height)
-{
-   Salut David !
-     noublie pas de mettre quelque chose comme sup(30,width) et sup(30,height) pour éviter les tailles
-     négatives ou trop petites. 
-}
-   
-void	host_pixmap_size(U32 thePixmap, int * wSize, int * hSize)
-{
-	HostImage pixmap = (HostImage)thePixmap;
-	BITMAP retBitmap;
-
-	GetObject(pixmap->hBitmap, sizeof(BITMAP), &retBitmap);
-
-	* wSize = retBitmap.bmWidth;
-	* hSize = retBitmap.bmHeight;
-}
-
-void	host_free_graphical_resources(void)
-{
-}
-
-void	host_change_host_window_title(U32 theWindow, char *title)
-{
-	HostWindow win = (HostWindow)theWindow;
-	
-	SetWindowText(win->handle, title);
-}
-
-void host_begin_paint(U32 theWindow)
-{
-	HostWindow win = (HostWindow)theWindow;
-	
-	BeginPaint(win->handle, &(win->pnt));
-}
-
-void host_end_paint(U32 theWindow)
-{
-	HostWindow win = (HostWindow)theWindow;
-	EndPaint(win->handle, &(win->pnt));
-}
-
-U32	host_create_pixmap(U32 target_width, U32 target_height)
-{
-	HostImage pixmap; 
-	HDC tempDC;
-	HBITMAP tempBitmap;
-	
-	pixmap = (HostImage)malloc(sizeof(HostImage_type));
-	tempDC = CreateCompatibleDC(domain_area);
-  tempBitmap = CreateCompatibleBitmap(domain_area,target_width ,target_height);
-
-	pixmap->hBitmap = tempBitmap;
-	pixmap->hDC = tempDC;
-
-	return (U32)pixmap;
-}
-
-void	host_paint_pixel_to(U32 dest, U32 x, U32 y, U32 color)
-{
-	COLORREF result;
-	HostImage pixmap = (HostImage)dest;
-
-	SelectObject(pixmap->hDC, pixmap->hBitmap);
-	result = SetPixel(pixmap->hDC, x,y, (COLORREF) RGB_to_X(color));
-}
-
-void	host_sc_paint_rectangle(U32 theWindow, U32 gc, int xX, int y, int w, int h, U32 color)
-{
-	RECT tmpRect;
-	HBRUSH tmpBrush;
-	unsigned long xcolor = RGB_to_X(color); 
-	HostWindow win = (HostWindow)theWindow;
-
-	HDC lgc	= GetDC(win->handle);
-	
-  tmpRect.left		= xX;
-	tmpRect.top			= y;
-	tmpRect.right		= xX + w;
-	tmpRect.bottom	= y+h;
-	tmpBrush = CreateSolidBrush(color);
-	FillRect(lgc ,&tmpRect, tmpBrush);
-	DeleteObject(tmpBrush);
-
-	ReleaseDC(win->handle, lgc);
-}
-void	host_sc_paint_rectangle_to_buffer(U32 pixMap, int xX, int y, int w, int h, U32 color)
-{
-	RECT tmpRect;
-	HBRUSH tmpBrush;
-	unsigned long xcolor = RGB_to_X(color); 
-	HostImage pix = (HostImage)pixMap;
-
-	tmpRect.left		= xX;
-	tmpRect.top			= y;
-	tmpRect.right		= xX + w;
-	tmpRect.bottom	= y+h;
-	tmpBrush = CreateSolidBrush(color);
-	FillRect(pix->hDC ,&tmpRect, tmpBrush);
-	DeleteObject(tmpBrush);
-}
-
-void host_draw_pixel_to_buffer(U32 buffer, int x, int y, U32 color)
-{
-	COLORREF result;
-	COLORREF xcolor = RGB_to_X(color); 
-	HostImage pix = (HostImage)buffer;
-
-	SelectObject(pix->hDC, pix->hBitmap);
-	result = SetPixel(pix->hDC, x,y, xcolor);
-}
-
-void	host_paint_host_image(U32 theWindow, U32 thePixmap, int a, int b, int u, int v, int x, int y)
-{
-	BOOL result;
-	HostWindow	win = (HostWindow)theWindow;
-	HostImage		pix = (HostImage)thePixmap;
- 	HDC winHDC = GetDC(win->handle);
-
- 	result = BitBlt(winHDC, x, y, u, v, pix->hDC, a, b, SRCCOPY);
-
- 	ReleaseDC(win->handle, winHDC);
-}
-
-
-void host_paint_host_image_to_buffer(U32 src, U32 dest, int src_x, int src_y, 
-                                                        int src_w, int src_h, 
-                                                        int dest_x, int dest_y)
-{
-	BOOL result;
-	HostImage	lSrc  = (HostImage)src;
-	HostImage	lDest = (HostImage)dest;
-
-	result = BitBlt(lDest->hDC, dest_x, dest_y, src_w, src_h, lSrc->hDC,src_x, src_y, SRCCOPY);
-
-}
-
-/* Internal use only */
-
-void	host_sc_screen_size(int *witdh, int *height)
-{
-	RECT tmpRect;
-	GetClientRect(hDesktop, &tmpRect);
-
-	*witdh	= tmpRect.right;
-	*height	= tmpRect.bottom;
-}
-
-void	host_queue_host_window_events(void)
-{
-	MSG msg; 
-	LRESULT lResult; 
-
-begin:   /* we jump here when we have processed a message ourself, i.e. 
-		 without returning to run_thot. */
-
-	/* test for a pending message from Windows without waiting for it */
-	if (!PeekMessage(&msg,NULL,0,0,PM_NOREMOVE)) 
-	{
-		/* no message is pending. return 0 so that run_thot will know that
-		no message is pending. This will let it work on another stuff, like 
-		updating the clocks... Don't worry about other processes. After all,
-		Windows is now a preemptive multitasking system. */
-    return; 
-	}
-
-	/* if there is one, get the pending message */
-	if (!GetMessage(&msg,NULL,0,0))
-	{
-		/*  Here the message is WM_QUIT: we must quit. */ 
-		return ;              /* after having dumped the current state */
-	}
-    else
-	{
-		/* Due to Windows' method of message transmission, we must return 
-		the translated message to Windows, which will call us again through
-		WindowProc... Thanks Bill ! */ 
-                TranslateMessage(&msg); 
-		lResult = DispatchMessage(&msg);    
-                /* see you again in WindowProc (below) */
-	       
-		if (lResult == -1) 
-			goto begin; 
-		else 
-			return /*(int)lResult*/; 
-	}
-}
-
-
-//#define show_events   
-
-/* Here is the actual processing of host (Windows) messages */
-LRESULT CALLBACK AnubisWindowProc(HWND hWnd, 
-				UINT message, 
-				WPARAM wParam,
-				LPARAM lParam)
-{
-  U32 R = 0; 
-  U32 handle; 
-  int retValue = 1;
-  /*
-    'HostWindowEvent' (see 'predefined.anubis') is a large type:
- 
-    offsets:                       0             4   5   6   7   8   9   10  11  12  13  14  15  16  17
-    -----------------------------------------------------------------------------------------------------
-    quit                    * ---> |     cnt     | 0 |        
-    expose                  * ---> |     cnt     | 1 |
-    pointer_entering        * ---> |     cnt     | 2 |
-    pointer_leaving         * ---> |     cnt     | 3 |
-    key_down                * ---> |     cnt     | 4 | s |   k   |
-    mouse_move              * ---> |     cnt     | 5 | s |       x       |        y      |
-    mouse_click             * ---> |     cnt     | 6 | s | c |      x        |       y       |
-    mouse_wheel             * ---> |     cnt     | 7 | s |     delta     |        x      |       y      |
-    other events are never generated here
-   
-    We allocate a segment big enough for any alternative. 
-  */
-
-  if ((R = allocate_data_segment(5,the_allocator)) == 0) 
-    /* Since the introduction of 'mouse_wheel' we need 5 words, not only 4. */
-    return 0; /* try next time */
-	
-  handle = (U32)hWnd; 
-
-  switch(message)
-    {
-    case WM_DESTROY:
-      {
-#ifdef show_events
-        LOGINFO("WM_DESTROY\n");
-#endif   
-        ((U8 *)R)[4] = 0;    /* quit */ 
-        break;
-      }
-    case WM_PAINT:
-      {
-#ifdef show_events
-        LOGINFO("WM_PAINT\n");
-#endif   
-        ((U8 *)R)[4] = 1;    /* expose */ 
-         retValue = 0;
-        break;
-      }
-
-    case WM_SETCURSOR:
-      {
-#ifdef show_events
-        LOGINFO("WM_SETCURSOR\n");
-#endif   
-        ((U8 *)R)[4] = 2;    /* pointer_entering */ 
-        break;
-      }
-  
-    case WM_NCMOUSEMOVE:
-      {
-#ifdef show_events
-        LOGINFO("WM_NCMOUSEMOUVE\n");
-#endif   
-        ((U8 *)R)[4] = 3;     /* pointer_leaving */
-        //retValue = 0;
-        break;
-      }
-   
-    case WM_KEYDOWN:
-      {
-#ifdef show_events
-        LOGINFO("WM_KEYDOWN\n");
-#endif   
-        ((U8 *)R)[4] = 4;    /* key_down */ 
-        ((U8 *)R)[5] = 0;   
-        ((U8 *)R)[6] = host_translate_exkey(wParam);
-        //retValue = 0;
-        break;
-      }
-   
-    case WM_CHAR:
-      {
-#ifdef show_events
-        LOGINFO("WM_CHAR\n");
-#endif   
-        ((U8 *)R)[4] = 4;    /* key_down */ 
-        ((U8 *)R)[5] = 0;   
-        ((U8 *)R)[6] = host_translate_key(wParam);
-        //retValue = 0;
-        break; 
-      }    
-   
-    case WM_MOUSEMOVE:
-      {
-#ifdef show_events
-        LOGINFO("WM_MOUSEMOUVE\n");
-#endif   
-        ((U8 *)R)[4] = 5;    /* mouse_move */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;   
-        *((U32 *)(((U8 *)R)+6))  = (U32)LOWORD(lParam); 
-        *((U32 *)(((U8 *)R)+10)) = (U32)HIWORD(lParam); 
-        //LOGINFO("MOUSE_MOVE x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-        break;
-      }   
-   
-    case WM_LBUTTONDOWN:
-      {
-#ifdef show_events
-        LOGINFO("WM_LBUTTONDOWN\n");
-#endif   
-        ((U8 *)R)[4] = 6;		/* mouse_click */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;  
-        ((U8 *)R)[6] = MC_left_down;		/* left_down   */ 
-        *((U32 *)(((U8 *)R)+7))  = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+11)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC LEFT DOWN  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-        break;
-      }
-   
-    case WM_LBUTTONUP:
-      {
-#ifdef show_events
-        LOGINFO("WM_LBUTTONUP\n");
-#endif   
-        ((U8 *)R)[4] = 6;		/* mouse_click */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;
-        ((U8 *)R)[6] = MC_left_up;		/* left_up     */  
-        *((U32 *)(((U8 *)R)+7))  = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+11)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC LEFT UP  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-
-        break;
-      }
-   
-    case WM_MBUTTONDOWN:
-      {
-#ifdef show_events
-        LOGINFO("WM_MBUTTONDOWN\n");
-#endif   
-        ((U8 *)R)[4] = 6;		/* mouse_click */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;  
-        ((U8 *)R)[6] = MC_middle_down;		/* left_down   */ 
-        *((U32 *)(((U8 *)R)+7))  = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+11)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC MIDDLE DOWN  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-
-        break;
-      }
-   
-    case WM_MBUTTONUP:
-      {
-#ifdef show_events
-        LOGINFO("WM_MBUTTONUP\n");
-#endif   
-        ((U8 *)R)[4] = 6;		/* mouse_click */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;
-        ((U8 *)R)[6] = MC_middle_up;		/* left_up     */  
-        *((U32 *)(((U8 *)R)+7))  = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+11)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC MIDDLE UP  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-
-        break;
-      }
-   
-    case WM_RBUTTONDOWN:
-      {
-#ifdef show_events
-        LOGINFO("WM_RBUTTONDOWN\n");
-#endif   
-        ((U8 *)R)[4] = 6;		/* mouse_click */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;
-        ((U8 *)R)[6] = MC_right_down;		/* right_down  */
-        *((U32 *)(((U8 *)R)+7))  = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+11)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC RIGHT DOWN  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-
-        break;
-      }
-   
-    case WM_RBUTTONUP:
-      {
-#ifdef show_events
-        LOGINFO("WM_RBUTTONUP\n");
-#endif   
-        ((U8 *)R)[4] = 6;		/* mouse_click */ 
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam) ;
-        ((U8 *)R)[6] = MC_right_up;		/* right_up    */
-        *((U32 *)(((U8 *)R)+7))  = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+11)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC RIGHT UP  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        //retValue = 0;
-
-        break;
-      }
-   
-    case WM_MOUSEWHEEL:
-      {
-#ifdef show_events
-        LOGINFO("WM_MOUSEWHEEL\n");
-#endif   
-        ((U8 *)R)[4] = 7; /* mouse wheel */
-        ((U8 *)R)[5] = host_translate_keyboard_state(wParam);
-        *((U32 *)(((U8 *)R)+6))  = (U32)HIWORD(wParam); 
-        *((U32 *)(((U8 *)R)+10)) = (U32)LOWORD(lParam);
-        *((U32 *)(((U8 *)R)+14)) = (U32)HIWORD(lParam);
-        //LOGINFO("MC RIGHT UP  x=%d y=%d\n", LOWORD(lParam), HIWORD(lParam) );
-        break;
-      }
-
-    default: 
-#ifdef show_events
-      LOGINFO("other event\n");
-#endif   
-      return DefWindowProc(hWnd,message,wParam,lParam);  
-    }
-
-  //add event to Anubis Land
-  queue_event(R, handle);
-
-  return retValue;
-
-}
-
-U8 host_translate_keyboard_state(unsigned int state)
-{
-	U8 result;
-
-	result  = state & MK_SHIFT;
-	result |= (state & MK_CONTROL) << 1;
-	result |= (state & MK_ALT)     << 2;
-	result |= (state & MK_LBUTTON) << 3;
-	result |= (state & MK_MBUTTON) << 4;
-	result |= (state & MK_RBUTTON) << 4;
-
-	return result;
-	
-}
-
-int host_translate_key(int k)
-{
-  switch (k)
-    {
-      /* decimal digits */
-      /*
-    case VK_0:    return '0'; 
-    case VK_1:    return '1'; 
-    case VK_2:    return '2'; 
-    case VK_3:    return '3'; 
-    case VK_4:    return '4'; 
-    case VK_5:    return '5'; 
-    case VK_6:    return '6'; 
-    case VK_7:    return '7'; 
-    case VK_8:    return '8'; 
-    case VK_9:    return '9'; 
-      */    
-              /* not defined in winuser.h !!! but same as '0', '1, etc... */ 
-
-      /* accented letters */
-    case 0xFC: return 129;      /* u trema */
-    case 0xE9: return 130;      /* e accute */
-    case 0xE2: return 131;      /* a circumflex */
-    case 0xE4: return 132;      /* a trema */
-    case 0xE0: return 133;      /* a grave */
-    case 0xE7: return 135;      /* c cedilla */ 
-    case 0xEA: return 136;      /* e circumflex */
-    case 0xEB: return 137;      /* e trema */
-    case 0xE8: return 138;      /* e grave */
-    case 0xEF: return 139;      /* i trema */ 
-    case 0xEE: return 140;      /* i circumflex */
-    case 0xF4: return 147;      /* o circumflex */
-    case 0xF6: return 148;      /* o trema */
-    case 0xFB: return 150;      /* u circumflex */
-    case 0xF9: return 151;      /* u grave */ 
-
-      /* special keys */ 
-      /*
-    case VK_LEFT:          return left_arrow_key; 
-    case VK_RIGHT:         return right_arrow_key; 
-    case VK_UP:            return up_arrow_key; 
-    case VK_DOWN:          return down_arrow_key; 
-    case VK_BACK:          return backspace_key; 
-    case VK_TAB:           return tab_key; 
-    case VK_RETURN:        return enter_key; 
-    case VK_ESCAPE:        return escape_key; 
-    case VK_DELETE:        return del_key; 
-    case VK_INSERT:        return ins_key; 
-    case VK_HOME:          return home_key; 
-    case VK_END:           return end_key; 
-    case VK_PRIOR:         return page_up_key; 
-    case VK_NEXT:          return page_down_key; 
-    case VK_F1:            return F1_key; 
-    case VK_F2:            return F2_key; 
-    case VK_F3:            return F3_key; 
-    case VK_F4:            return F4_key; 
-    case VK_F5:            return F5_key; 
-    case VK_F6:            return F6_key; 
-    case VK_F7:            return F7_key; 
-    case VK_F8:            return F8_key; 
-    case VK_F9:            return F9_key; 
-    case VK_F10:           return F10_key; 
-      */
-   
-      /* ordinary character keys */
-    default: return k; 
-    }
-}
-
-int host_translate_exkey(int k)
-{
-  switch (k)
-    {
-      /* special keys */ 
-    case VK_LEFT:          return KSK_left; 
-    case VK_RIGHT:         return KSK_right; 
-    case VK_UP:            return KSK_up; 
-    case VK_DOWN:          return KSK_down; 
-    case VK_BACK:          return KSK_backspace; 
-    case VK_TAB:           return KSK_tab; 
-    case VK_RETURN:        return KSK_enter; 
-    case VK_ESCAPE:        return KSK_escape; 
-    case VK_DELETE:        return KSK_del; 
-    case VK_INSERT:        return KSK_insert; 
-    case VK_HOME:          return KSK_home; 
-    case VK_END:           return KSK_end; 
-    case VK_PRIOR:         return KSK_page_up; 
-    case VK_NEXT:          return KSK_page_down; 
-    case VK_F1:            return KSK_f1; 
-    case VK_F2:            return KSK_f2; 
-    case VK_F3:            return KSK_f3; 
-    case VK_F4:            return KSK_f4; 
-    case VK_F5:            return KSK_f5; 
-    case VK_F6:            return KSK_f6;  
-    case VK_F7:            return KSK_f7; 
-    case VK_F8:            return KSK_f8; 
-    case VK_F9:            return KSK_f9; 
-    case VK_F10:           return KSK_f10; 
-   
-      /* ordinary character keys */
-    default: return k; 
-    }
-}
-   
-#include "dependencies.h"
-#include "debug_log.h"
-#include <assert.h>
-
-int kernelInit(void)
-{
-
-  WSADATA wsadata; 
-
- /* Open console for output  */
-// AllocConsole();
-
-  assert(sizeof(long) == 4); 
-   
-  if (WSAStartup(MAKEWORD(2,2),&wsadata) != 0)
-    {
-      LOGERROR("Winsock.dll not found."); 
-      my_exit(1); 
-    }
- return 1;
-}
-
-char * getpass(char * in)
-{
- return "";
-}
-
-
-void my_exit(int returnCode)
-{
-// WaitForKeyboard();
- exit(returnCode); 
-}
-
-void WaitForKeyboard(void)
-{
-   INPUT_RECORD inpRecord;
-  DWORD readRecord = 0;
-  BOOL quit = FALSE;
-
-  while ( quit == FALSE) 
-  {
-   ReadConsoleInput(GetStdHandle(STD_INPUT_HANDLE), &inpRecord, 1, &readRecord);
-   if(inpRecord.EventType == KEY_EVENT )
-    quit = TRUE;
-  }
-
-}
-   
-