Disable bk EOLN_NATIVE conversions on all files in packages FILESPATHs, to prevent it screwing up patches.

BKrev: 4190111fA4MuVozAqwE7xOSL9fr-TA

1 files changed, 845 insertions, 0 deletions

diff --git a/powermanga/powermanga-0.79/linuxroutines.cpp b/powermanga/powermanga-0.79/linuxroutines.cpp
index e69de29bb2..39394eb026 100644
--- a/powermanga/powermanga-0.79/linuxroutines.cpp
+++ b/powermanga/powermanga-0.79/linuxroutines.cpp
@@ -0,0 +1,845 @@
+//*****************************************************************************
+// copyright (c) 1998-2003 TLK Games all rights reserved
+//-----------------------------------------------------------------------------
+// file         : "linuxroutines.cpp"
+// created      : 1999-08-19
+// updates      : 2004-08-01 
+//------------------------------------------------------------------------------
+// functions    :  int              mem_initialise(unsigned int _iNombreZones)
+//                 char*            reserveMemoire(unsigned int _iTailleMemoire)
+//                 void             libereMemoire(char* _pMemoire)
+//                 void             mem_libereTous()
+//                 int              load_pcx(char*, char*) ;
+//                 sDescriptionGfx* load_pcx(char*) ;
+//                 unsigned int     littleWord(char* _pMem) ;
+//                 short            litMot16bits(short* _pMem) ;
+//                 int              litMot32bits(int* _pMem) ;
+//                 int              chaine_cmp(char* _pChaine1, char* _pChaine2, unsigned int _iTaille) ;
+//                 char*            chargeFichier(char* _pNomFichier)
+//                 char*            chargeFichier(char* _pNomFichier, unsigned int* pTaille)
+//                 int              chargeFichier(char* _pNomFichier, char* _pMemoire)
+//                 void             fps_init()
+//                 void             fps_affiche() 
+//                 void             afficheErreur(char* _pErreur1, char* _pErreur2)
+//                 int              synchro_processusPause(int _iTemps)
+//                 int              synchro_CalculDifference()
+//                 int              synchro_CalculDifference2()
+//-----------------------------------------------------------------------------
+// This program is free software; you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation; either version 2 of the License, or (at your option) any later
+// version.
+// 
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+// details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+// Place - Suite 330, Boston, MA  02111-1307, USA.
+//
+//*****************************************************************************
+
+#include "powermanga.hpp"
+#include <errno.h>
+
+#ifndef SDL_TLK
+#include <sys/types.h>
+#include <sys/stat.h>
+#endif
+
+//..............................................................................
+extern unsigned int     iVerbeux;                              //1=affiche les arguments / 1=verbose mode
+
+//gestion de la memoire .........................................................
+typedef struct
+{ char *pMemoire;                                              //pointeur sur la zone memoire / pointer to memory zone
+  int   iTailleMemoire;                                         //taille de la zone en octets / size of memory zone in bytes
+}
+sListeMemoire;
+char                   *pZoneListeMemoire;
+sListeMemoire          *pZoneListeBase;
+sListeMemoire          *pZoneListeLibre;
+unsigned int            iTailleListe;                          //taille de la liste memoire / size of memory table             
+unsigned int            iNombreZonesMaximum;                   //nombre de zones memoires maxi / number maximum of memory zone
+unsigned int            iNombreZones;                          //nombre de zone actuelle       / number of memroy zone
+unsigned int            iOctetsTotal;                          //taille prise en octets        / total memory size allocated           
+unsigned int            iNombreZonesMax;                       //nombre maximum de zones reserves
+
+//..............................................................................
+unsigned int            iCompteurBoucle;
+#ifdef SDL_TLK 
+Uint32                  time_begin;
+Uint32                  temps_actuel;
+Uint32                  temps_sauve;
+Uint32                  temps_actuel2;
+Uint32                  temps_sauve2;
+#else
+static struct timeval   time_begin;
+static struct timeval   temps_actuel;
+static struct timeval   temps_sauve;
+static struct timeval   temps_actuel2;
+static struct timeval   temps_sauve2;
+#endif
+
+//..............................................................................
+short                   litMot16bitsBig(short *_pMem);
+unsigned short          litMot16bits(unsigned short *_pMem);
+extern const char       nomprefix[];
+extern unsigned int     iFrame3; 
+//------------------------------------------------------------------------------
+// initialise la liste memoire / initialise memory table
+// input =>  _iNombreZones : nombre de zones memoire possibles au maximum / number maximum of memory zone
+// ouput <= 0=erreur / 0=error
+//------------------------------------------------------------------------------
+int mem_initialise(unsigned int _iNombreZones)
+{
+  unsigned int _iIndex;
+  iNombreZones = 0;                                            // nombre de zones reservees a zero
+  pZoneListeMemoire = 0;
+  iNombreZonesMaximum = _iNombreZones;                         // nombre maximum de zones pouvant etre reservees 
+  iNombreZonesMax = 0;
+  iTailleListe = iNombreZonesMaximum * sizeof(sListeMemoire);
+  iOctetsTotal = iTailleListe;
+  pZoneListeMemoire = (char *)malloc(iTailleListe);
+  if(!pZoneListeMemoire)
+  { afficheErreur("malloc() failed", "linuxroutines/mem_initialise()");
+    return 0;
+  }
+  pZoneListeBase = (sListeMemoire *) pZoneListeMemoire;
+  pZoneListeLibre = pZoneListeBase;
+  sListeMemoire          *_pMem = pZoneListeBase;
+
+  for(_iIndex = 0; _iIndex < iNombreZonesMaximum; _iIndex++, _pMem++)   //clean memory table
+  { _pMem->pMemoire = 0x0;
+    _pMem->iTailleMemoire = 0x0;
+  }
+  return 1;
+}
+
+//------------------------------------------------------------------------------
+// reserve une zone memoire / allocate memory
+// input  => _iTailleMemoire : taille memoire en octets souhaitee / size of bytes
+// output <= _pMem           : adresse memoire (0=erreur) / pointer to memory
+//------------------------------------------------------------------------------
+char *reserveMemoire(unsigned int _iTailleMemoire)
+{
+  char                   *_pMem = 0x0;
+  char                   *_pMemoire = 0x0;
+  char                    _cZero = 0;
+  unsigned int            _iIndex;
+  if(iNombreZones >= iNombreZonesMaximum)
+  { printf ("linuxroutines.cpp/reserveMemoire(unsigned int) : table overflow ; size request %i bytes ; total allocate : % i in %i zones\n", _iTailleMemoire, iOctetsTotal, iNombreZones);
+    return 0;
+  }
+  _pMem = (char *)malloc(_iTailleMemoire);
+  if(!_pMem)
+  { printf ("linuxroutines.cpp/reserveMemoire(unsigned int) : malloc(int) return 0 ; size request %i bytes ; total allocate : % i in %i zones\n", _iTailleMemoire, iOctetsTotal, iNombreZones);
+    return 0;
+  }
+  iOctetsTotal += _iTailleMemoire;
+  pZoneListeLibre->pMemoire = _pMem;                           //pointeur memoire      
+  pZoneListeLibre->iTailleMemoire = _iTailleMemoire;           //taille en octets      
+  pZoneListeLibre += 1;
+  iNombreZones++;
+  if(iNombreZones > iNombreZonesMax)
+      iNombreZonesMax = iNombreZones; 
+  _pMemoire = _pMem;
+  for(_iIndex = 0; _iIndex < _iTailleMemoire; _iIndex++)
+    *(_pMemoire++) = _cZero;                                   //efface memoire        
+  return (_pMem);
+}
+
+//------------------------------------------------------------------------------
+// liberation d'une zone memoire / free memory
+// input => _pMemoire : adresse de la zone a liberer / pointer to memory
+//------------------------------------------------------------------------------
+void libereMemoire(char *_pMemoire)
+{
+  sListeMemoire          *_pListeMem;
+  sListeMemoire          *_pListeMemSource;
+  unsigned int            _iCompteur;
+  if(_pMemoire)
+  { _pListeMem = pZoneListeBase;
+    for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
+    { if(_pListeMem->pMemoire == _pMemoire)                    //on a trouve l'adresse dans la table ?
+      { free(_pMemoire);                                       //oui, libere la memoire                                
+        _pListeMemSource = _pListeMem + 1;
+        iOctetsTotal -= _pListeMem->iTailleMemoire;
+        iNombreZones--;
+        pZoneListeLibre--;
+        while (_iCompteur < iNombreZones)
+        { _pListeMem->pMemoire = _pListeMemSource->pMemoire;
+          _pListeMem->iTailleMemoire = _pListeMemSource->iTailleMemoire;
+          _iCompteur++;
+          _pListeMem++;
+          _pListeMemSource++;
+        }
+        _pListeMem->pMemoire = 0x0;
+        _pListeMem->iTailleMemoire = 0x0;
+        _pMemoire = 0;
+        break;
+      }
+    }
+    if(_pMemoire > 0)
+    { fprintf(stderr, "libereMemoire() : can't release the address %x\n", (int)_pMemoire);
+    }
+  }
+  else
+  { fprintf(stderr, "libereMemoire() : try to release a null address!\n");  
+  }
+}
+
+//------------------------------------------------------------------------------
+// retourne la taille d'une adresse memoire reservee / get memory zone's size
+// input => _pMem : pointeur sur une zone memoire / pointer to memory
+//------------------------------------------------------------------------------
+int mem_retourneTaille(char *_pMem)
+{
+  unsigned int            _iCompteur;
+  sListeMemoire          *_pListeMem = pZoneListeBase;
+  if(_pMem)
+  { for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
+    { if(_pListeMem->pMemoire == _pMem)
+        return _pListeMem->iTailleMemoire;
+    }
+  }
+  return 0;
+}
+
+//------------------------------------------------------------------------------
+// libere toutes les zones memoires / free all memory
+//------------------------------------------------------------------------------
+void mem_libereTous()
+{
+  unsigned int _iCompteur;
+  char *_pMemoire;
+  sListeMemoire *_pListeMem = pZoneListeBase;
+#ifdef _VERBEUX_
+  if(iVerbeux > 0)
+    fprintf(stdout, "> linuxroutines.cpp/mem_libereTous(): maximum of memory which were allocated during the game : %i\n", iNombreZonesMax);
+#endif
+  if(iNombreZones >0)
+  { 
+#ifdef _VERBEUX_
+    if(iVerbeux > 0)
+      fprintf(stdout, "> linuxroutines.cpp/mem_libereTous() : %i zones were not released.\n", iNombreZones);
+#endif
+    for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
+    { _pMemoire = _pListeMem->pMemoire;
+      if(_pMemoire)
+      { /* fprintf(stderr, "mem_libereTous: adresseMem =%x ; taille_mem=%ld\n", 
+          (int)_pListeMem->pMemoire, _pListeMem->iTailleMemoire); */
+        free(_pMemoire); //libere la memoire                             
+        _pListeMem->pMemoire = 0;
+        _pListeMem->iTailleMemoire = 0;
+      }
+    }
+    if(pZoneListeMemoire)
+    { free(pZoneListeMemoire);
+      pZoneListeMemoire = 0x0;
+    }
+    iNombreZones = 0;
+  }
+}
+
+//------------------------------------------------------------------------------
+// decompress pcx file 
+// input  =>  _pFichier     : filename
+// output <= _pStructureGfx : pointer to the "sDescriptionGfx" structure / 0=error 
+//------------------------------------------------------------------------------
+sDescriptionGfx *load_pcx(char *_pNomFichier)
+{
+  unsigned int            iLongeur;
+  unsigned int            ptr = 128;
+  unsigned char           nbr_bytes;
+  unsigned char           val;
+  unsigned int            i1, i, total;
+  unsigned char          *_pFichier, *_pAdresseMem;
+  sDescriptionGfx        *_pDescripGfx = 0x0;
+  _pFichier = (unsigned char *)chargeFichier(_pNomFichier, &iLongeur);  //load file in memory
+  if(!_pFichier) return 0;
+  unsigned short         *_p16 = (unsigned short *)_pFichier;
+  unsigned int            _iLarge = (litMot16bits(_p16 + 4) - litMot16bits(_p16 + 2)) + 1;      //image width
+  unsigned int            _iHaut = (litMot16bits(_p16 + 5) - litMot16bits(_p16 + 3)) + 1;       //image height
+  unsigned int            _iProfondeur = _pFichier[3];         //bits per pixel
+
+  _pDescripGfx = (sDescriptionGfx *) reserveMemoire(sizeof(sDescriptionGfx));   //allocate structure memory
+  if(!_pDescripGfx)
+  { afficheErreur("_pDescripGfx out of memory", "linuxroutines.cpp/load_pcx()");
+    return 0;
+  }
+  _pDescripGfx->iLargeur = _iLarge;
+  _pDescripGfx->iHauteur = _iHaut;
+  _pDescripGfx->iProfond = _iProfondeur;
+  _pDescripGfx->iTaille = _iLarge * _iHaut * (_iProfondeur >> 3);
+  _pDescripGfx->pAdresse = reserveMemoire(_pDescripGfx->iTaille);       //allocate image memory
+  if(!_pDescripGfx->pAdresse)
+  { libereMemoire((char *)_pDescripGfx);
+    printf("linuxroutines.cpp/load_pcx() : height=%i / width=%i \n", _iLarge, _iHaut);
+    afficheErreur("_pDescripGfx->iTaille : out of memory\n", "linuxroutines.cpp/reserveMemoire()");
+    return 0;
+  }
+  //decompress rle
+  _pAdresseMem = (unsigned char *)_pDescripGfx->pAdresse;
+  total = 0;
+  i = iLongeur - 768;
+  while (ptr < i)
+  { if((_pFichier[ptr] & 0xC0) == 0xC0)
+    { nbr_bytes = _pFichier[ptr] & 0x3F;
+      ptr++;
+    }
+    else
+      nbr_bytes = 1;
+    val = _pFichier[ptr];
+    total += nbr_bytes;                  // Samuel Hocevar
+    if(total >= _pDescripGfx->iTaille)
+    break;
+    for(i1 = 0; i1 < nbr_bytes; i1++)
+    { *_pAdresseMem = val;
+      _pAdresseMem++;
+    }
+    ptr++;
+  }
+  libereMemoire((char *)_pFichier);
+#ifdef _VERBEUX_
+  if(iVerbeux > 0)
+    fprintf (
+      stdout,
+      "> linuxroutines.cpp/load_pcx(): \"%s\"; height=%i; width=%i; size=%i\n",
+      _pNomFichier,
+      _iLarge,
+      _iHaut,
+      _pDescripGfx->iTaille);
+#endif
+  return _pDescripGfx;
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un mot de 16 bits code en memoire en little-endian
+// input  => _pMem    : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+unsigned int littleWord(char *_pMem)
+{
+  unsigned short *t = (unsigned short *)_pMem;
+  return *t;
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un long mot signe de 16 bits little-endian (compatible little-endian/big-endian)
+// input  => _pMem    : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+short litMot16bits(short *_pMem)
+{
+  short  _iValeur = 0;
+  unsigned char  *_pMemoire = (unsigned char *)_pMem;
+  _iValeur = _pMemoire[1];                                     //lit du little endian pour un powerpc
+  _iValeur <<= 8;
+  _iValeur += _pMemoire[0];
+  return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un long mot signe de 16 bits little-endian (compatible little-endian/big-endian)
+// input  => _pMem    : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+unsigned short litMot16bits(unsigned short *_pMem)
+{
+  unsigned short          _iValeur = 0;
+  unsigned char          *_pMemoire = (unsigned char *)_pMem;
+  _iValeur = _pMemoire[1];                                     //lit du little endian pour un powerpc
+  _iValeur <<= 8;
+  _iValeur += _pMemoire[0];
+  return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+// lecture d'un long mot signe de 16 bits big-endian (compatible little-endian/big-endian)
+// input => _pMem    : pointeur sur le mot en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+short litMot16bitsBig(short *_pMem)
+{
+  short                   _iValeur = 0;
+  unsigned char          *_pMemoire = (unsigned char *)_pMem;
+  _iValeur = _pMemoire[0];                                     //lit du big endian pour un 80x86
+  _iValeur <<= 8;
+  _iValeur += _pMemoire[1];
+  return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+//lecture d'un long mot signe de 32 bits little-endian(compatible little-endian/big-endian)
+// input  => _pMem    : pointeur sur le mot 32 bits en memoire
+// output <= _iValeur : valeur utilisale
+//------------------------------------------------------------------------------
+int litMot32bits(int *_pMem)
+{
+  int                     _iValeur = 0;
+  unsigned char          *_pMemoire = (unsigned char *)_pMem;
+  _iValeur = _pMemoire[3];
+  _iValeur <<= 8;
+  _iValeur += _pMemoire[2];
+  _iValeur <<= 8;
+  _iValeur = _pMemoire[1];
+  _iValeur <<= 8;
+  _iValeur += _pMemoire[0];
+  return (_iValeur);
+}
+
+//------------------------------------------------------------------------------
+// convertit un long mot de 32 bits en memoire little-endian => big-endian
+//------------------------------------------------------------------------------
+void convert32bits_2bigendian (unsigned char* memory)
+{ unsigned char b0, b1, b2, b3;
+  b0 = memory[1];
+  b1 = memory[0];
+  b2 = memory[3];
+  b3 = memory[2];
+  memory[0] = b2;
+  memory[1] = b3;
+  memory[2] = b0;
+  memory[3] = b1;
+}
+
+//------------------------------------------------------------------------------
+//comparaison de deux chaines de caracteres
+// input  => _pChaine1 : pointeur sur la premiere chaine
+//        => _pChaine1 : pointeur sur la deuxieme chaine
+//        => _iTaille  : longeurs en octets de chaines
+// output <= 0les chaines ont au moins une difference / 1=les chaines sont identiques
+//------------------------------------------------------------------------------
+int chaine_cmp(char *_pChaine1, char *_pChaine2, unsigned int _iTaille)
+{
+  unsigned int            _iLongeur = _iTaille;
+  char                   *_pMem1 = _pChaine1;
+  char                   *_pMem2 = _pChaine2;
+  unsigned int            _iIndex;
+  char                    _cOctet1, _cOctet2;
+  for(_iIndex = 0; _iIndex < _iLongeur; _iIndex++)
+  { _cOctet1 = _pMem1[_iIndex];
+    _cOctet2 = _pMem2[_iIndex];
+    if(_cOctet2 != _cOctet1)
+      return (0);
+  }
+  return (1);
+}
+
+//------------------------------------------------------------------------------
+// locate a file under one of the data directories (thanx to Andre Majorel :-)
+// input  =>  name : name of file relative to data directory
+// output <=  0    : could not locate file (not found, or not enough
+//                   memory, or the name given was absolute)
+// other           : pointer to a malloc'd buffer containing the name
+//                   under which the file was found. free()-ing the
+//                   buffer is the responsibility of the caller.
+//------------------------------------------------------------------------------
+static const char      *data_directories[]=
+{ ".",                                                         // Normally unused, except when running from the source directory...
+  "/opt/QtPalmtop/share/games/powermanga/",
+  0                                                            // Special value meaning "$(PREFIX)/share/games/powermanga/"
+                                                               // Also marks end of list
+};
+static char pathstring[256];
+
+char *locate_data_file(const char *const name)
+{
+  
+  for(int i = 0; i < 256; i++)
+	pathstring[i] = 0;
+	
+  if(name == 0) return 0;
+  if(*name == '/') return strdup(name);                        // Guillaume Cottenceau (2001-03-15) replace "return 0;" by "strdup(name);"
+                                                               // En effet, nous sommes dans le cas ou le programme recherche dans /usr/share/games/powermanga
+  for(const char **p = data_directories;; p++)
+  { char *pathname;
+    if(*p == 0)
+    { const char *subdir = "/share/games/powermanga/";
+      pathname = &pathstring[0];
+      /*pathname=(char *)malloc(strlen(nomprefix) + strlen(subdir) + strlen(name) + 1);
+      if(pathname == 0)
+      { fflush(stdout);
+        fprintf(stderr, "powermanga: not enough memory\n");
+        return 0;
+      }*/
+      strcpy(pathname, nomprefix);
+      strcat(pathname, subdir);
+      strcat(pathname, name);
+    }
+    else if(**p == '~')                                        // Not used anymore
+    { static const char       bogus = '\0';
+      static const char      *home_dir = &bogus;
+      if(home_dir == &bogus) home_dir = getenv("HOME");
+      if(home_dir == 0) continue;                             // $HOME not set. Skip this directory.
+      pathname = &pathstring[0];
+      
+      /*pathname = (char *)malloc(strlen(home_dir) + 1 + strlen(*p + 1) + 1 + strlen(name) + 1);
+      if(pathname == 0)
+      { fflush(stdout);
+        fprintf(stderr, "powermanga: not enough memory\n");
+        return 0;
+      }*/
+      strcpy(pathname, home_dir);
+      strcat(pathname, *p + 1);
+      strcat(pathname, "/");
+      strcat(pathname, name);
+    }
+    else
+    {
+      pathname = &pathstring[0];
+      /*pathname = (char *)malloc(strlen(*p) + 1 + strlen(name) + 1);
+      if(pathname == 0)
+      { fflush(stdout);
+        fprintf(stderr, "powermanga: not enough memory\n");
+        return 0;
+      }*/
+      strcpy(pathname, *p);
+      strcat(pathname, "/");
+      strcat(pathname, name);
+    }
+    //puts(pathname);  // DEBUG
+#ifdef WIN32
+    struct _stat s;
+    if(_stat(pathname, &s) == 0 && !_S_ISDIR(s.st_mode))
+      return pathname;
+#else
+    struct stat s;
+    if(stat(pathname, &s) == 0 && !S_ISDIR(s.st_mode))
+      return pathname;
+#endif
+    //free(pathname);
+    if(*p == 0) break;
+  }
+  return 0;                                                    // Not found.
+}
+
+//------------------------------------------------------------------------------
+// load a file in memory / charge un fichier en memoire
+// input =>  _pNomFichier  : nom du fichier
+//           _pAdresse     : adresse de chargemebt
+//           _iTaille      : taille a lire
+// output <= 1             : tout c'est bien passe
+//           0             : erreur
+//------------------------------------------------------------------------------
+char *chargeFichier(char *_pNomFichier)
+{
+  unsigned int            _pTaille;
+  return chargeFichier(_pNomFichier, &_pTaille);
+}
+
+//------------------------------------------------------------------------------
+// load a file in memory 
+// input => _pNomFichier : filename
+// sortie <= _pMemoire   : ptr/integer 
+//------------------------------------------------------------------------------
+char *chargeFichier(char *_pNomFichier, unsigned int *pTaille)
+{
+  int _iHandle;
+  char *_pMemoire;
+  struct stat sDescriptionFichier;
+  char *pathname = locate_data_file(_pNomFichier);
+  if(pathname == 0)
+  { printf("linuxroutines/chargeFichier() : can't locate file : %s\n\n", _pNomFichier);
+    return 0;
+  }
+#ifdef WIN32
+  _iHandle = open(pathname, O_RDONLY | O_BINARY, 0); 
+#else
+  _iHandle = open(pathname, O_RDONLY, 0); 
+#endif
+  if(_iHandle == -1)
+  { printf("linuxroutines/chargeFichier() : can't open file : %s (%s)\n\n", pathname, strerror(errno));
+    //free(pathname);
+    return 0;
+  }
+  if(fstat(_iHandle, &sDescriptionFichier))
+  { printf("linuxroutines/chargeFichier() : can't stat file : %s (%s)\n\n", pathname, strerror(errno));
+    close(_iHandle);
+    //free(pathname);
+    return 0;
+  }
+  (*pTaille) = sDescriptionFichier.st_size;                    //sauve taille
+  _pMemoire = reserveMemoire(sDescriptionFichier.st_size);     //reserve la place en memoire pour lire le fichier
+  if(!_pMemoire)
+  { printf("linuxroutines/chargeFichier() %s : out of memory\n\n", pathname);
+    close(_iHandle);
+    //free(pathname);
+    return 0;
+  }
+  if(read(_iHandle, _pMemoire, sDescriptionFichier.st_size) != sDescriptionFichier.st_size)
+  { libereMemoire(_pMemoire);
+    printf("linuxroutines/chargeFichier() can't read file %s (%s)\n\n", pathname, strerror(errno));
+    close(_iHandle);
+    //free(pathname);
+    return 0;
+  }
+  close(_iHandle);
+#ifdef _VERBEUX_
+  if(iVerbeux > 1)
+    printf("linuxroutines/chargeFichier : file %s was loaded in memory\n", pathname);
+#endif
+  //free(pathname);
+  return _pMemoire;
+}
+
+//------------------------------------------------------------------------------
+// load a file in memory / charge un fichier en memoire
+// input   => _pNomFichier : filename / nom du fichier
+//         => _pMemoire    : pointer to memory / pointeur sur la memoire   
+// output <= 1             : 0 error/erreur
+//------------------------------------------------------------------------------
+int chargeFichier(char *_pNomFichier, char *_pMemoire)
+{
+  int                     _iHandle;
+  struct stat             sDescriptionFichier;
+  char                   *pathname = locate_data_file(_pNomFichier);
+  if(pathname == 0)
+  { printf("linuxroutines/chargeFichier() : can't locate file : %s\n\n", _pNomFichier);
+    return 0;
+  }
+#ifdef WIN32
+  _iHandle = open(pathname, O_RDONLY | O_BINARY, 0); 
+#else
+  _iHandle = open(pathname, O_RDONLY, 0); 
+#endif
+  if(_iHandle == -1)
+  { printf ("linuxroutines.cpp/chargeFichier() : can't open file : %s (%s)\n\n", pathname, strerror(errno));
+    //free(pathname);
+    return 0;
+  }
+  if(fstat(_iHandle, &sDescriptionFichier))
+  { printf ("linuxroutines.cpp/chargeFichier() : can't stat file : %s (%s)\n\n", pathname, strerror(errno));
+    close(_iHandle);
+    //free(pathname);
+    return 0;
+  }
+  if(read(_iHandle, _pMemoire, sDescriptionFichier.st_size) != sDescriptionFichier.st_size)
+  { printf("linuxroutines.cpp/chargeFichier() can't read file %s (%s)\n\n", pathname, strerror(errno));
+    close(_iHandle);
+    //free(pathname);
+    return 0;
+  }
+  close(_iHandle);
+#ifdef _VERBEUX_
+  if(iVerbeux > 1) printf("linuxroutines/chargeFichier : file %s was loaded in memory\n", pathname);
+#endif
+  //free(pathname);
+  return 1;
+}
+
+//------------------------------------------------------------------------------
+// initialise le compteur de boucle et l'heure de depart du programme
+//------------------------------------------------------------------------------
+void fps_init()
+{
+#ifdef SDL_TLK 
+  time_begin = SDL_GetTicks();
+  temps_sauve = SDL_GetTicks();
+  temps_sauve2 = SDL_GetTicks();
+#else
+  gettimeofday(&time_begin, NULL);
+  gettimeofday(&temps_sauve, NULL);
+  gettimeofday(&temps_sauve2, NULL);
+#endif
+  iCompteurBoucle = 0;
+}
+
+//------------------------------------------------------------------------------
+// affiche information sur le systeme
+//------------------------------------------------------------------------------
+void fps_affiche()
+{
+  
+#ifdef SDL_TLK
+  double fps;
+  unsigned long duration;
+  Sint32 time_end; 
+  time_end = SDL_GetTicks();
+  duration = time_end - time_begin;
+  fps = (1000.0 * iCompteurBoucle) / duration;
+  if(iVerbeux > 0)
+  { printf("> linuxroutines.cpp/number of loops : %i\n", iCompteurBoucle);
+    printf("> linuxroutines.cpp/running time    : %li\n", duration);
+    printf("> linuxroutines.cpp/fps_affiche()   : frames per seconde : %g \n", fps);
+  }
+#else  
+  struct utsname          kernel;
+  struct stat             statmem;
+  unsigned long           duration;
+  double                  fps;
+  double                  mem;
+  char                    os_name[32];
+  char                    os_vers[32];
+  char                    cpu[64];
+  char                    freq[32];
+  FILE                   *cpuinfo;
+  char                    txt[256];
+  static struct timeval   time_end;
+
+  //calcul le temps total d'execution ............................................
+  gettimeofday(&time_end, NULL);
+  duration = (time_end.tv_sec - time_begin.tv_sec) * 1000 + (time_end.tv_usec - time_begin.tv_usec) / 1000;
+  fps = (1000.0 * iCompteurBoucle) / duration;
+
+  //version du systeme d'exploitation ............................................
+  if(uname(&kernel) < 0)
+  { strcpy(os_name, "?");
+    strcpy(os_vers, "");
+  }
+  else
+  { strncpy(os_name, kernel.sysname, 32);
+    strncpy(os_vers, kernel.release, 32);
+  }
+  //processeur & memoire physique du systeme .....................................
+  stat("/proc/kcore", &statmem);
+  mem = ((float)statmem.st_size) / 1024 / 1024;
+  strcpy(cpu, "Unknown");
+  strcpy(freq, "Unknown");
+  cpuinfo = fopen("/proc/cpuinfo", "r");
+  if(cpuinfo != NULL)
+  { while (fgets(txt, 255, cpuinfo))
+    { if(!strncmp(txt, "model", 5))
+      { int                     i = 0;
+        while (txt[i] != ':') i++;
+        i += 2;
+        for(int j = 0; j < 64;)
+        { if(txt[i++] != '\n') cpu[j++] = txt[i - 1];
+        }
+      }
+      if(!strncmp(txt, "cpu MHz", 7))
+      { int                     i = 0;
+        while (txt[i] != ':') i++;
+        i += 2;
+        sprintf(freq, "%d", atoi(txt + i));
+      }
+    }
+  }
+  //processeur & memoire physique du systeme .....................................
+  if(iVerbeux > 0)
+  { printf("operating system   : %s %s\n", os_name, os_vers);
+    printf("processor          : %s at %s Mhz with %.0f RAM\n", cpu, freq, mem);
+    printf("number of loops    : %i\n", iCompteurBoucle);
+    printf("running time       : %li\n", duration);
+    printf("frames per seconde : %g \n", fps);
+    //printf ( "Compilateur      : %s\n" , COMPILO );
+  }
+#endif
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _Message :  message 
+//------------------------------------------------------------------------------
+void afficheMessage(char *_Message)
+{ 
+  printf("%s\n", _Message);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _Message1 :  message 1 
+//       => _Message2 :  message 2 
+//------------------------------------------------------------------------------
+void afficheMessage(char *_Message1, char *_Message2)
+{
+  printf("%s %s\n", _Message1, _Message2);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input => _pErreur1 : error message 
+//       => _pErreur2 : title error
+//------------------------------------------------------------------------------
+void afficheErreur(char *_pErreur1, char *_pErreur2)
+{
+  printf("%s %s\n", _pErreur2, _pErreur1);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input        => _pErreur1 : error message 
+//              => _pErreur2 : title error
+//              => _pErreur3 : error message
+//------------------------------------------------------------------------------
+void afficheErreur(char *_pErreur1, char *_pErreur2, char *_pErreur3)
+{
+  printf("%s %s %s\n", _pErreur2, _pErreur1, _pErreur3);
+}
+
+//------------------------------------------------------------------------------
+// display error message
+// input        => _pErreur1 : error message 
+//              => _pErreur2 : title error
+//              => _iErreur : error number
+//------------------------------------------------------------------------------
+void afficheErreur(char *_pErreur1, char *_pErreur2, int _iErreur)
+{
+  printf("%s %s error=%i\n", _pErreur2, _pErreur1, _iErreur);
+}
+
+//------------------------------------------------------------------------------
+// sleep process
+// input => i : time
+//------------------------------------------------------------------------------
+int synchro_processusPause(int _iTemps)
+{
+#ifdef SDL_TLK 
+  if(_iTemps > (int)iFrame3)
+    _iTemps = iFrame3;
+  if(_iTemps > 0)
+    SDL_Delay(_iTemps);
+  return (_iTemps > 0 ? _iTemps : 0);
+#else
+  struct timeval temps;
+  if(_iTemps > (int)iFrame3)
+    _iTemps = iFrame3;
+  if(_iTemps > 0)
+  { temps.tv_usec = _iTemps % (unsigned long)1000000;
+    temps.tv_sec = _iTemps / (unsigned long)1000000;
+    //sleep for a time interval
+    select(0, NULL, NULL, NULL, &temps);
+  }
+  return (_iTemps > 0 ? _iTemps : 0);
+#endif
+}
+
+#ifdef SDL_TLK
+int synchro_CalculDifference()
+{
+  int _iDifference;
+  temps_actuel = SDL_GetTicks();
+  _iDifference = temps_actuel - temps_sauve;
+  temps_sauve = temps_actuel;
+  return _iDifference;
+}
+#else
+//------------------------------------------------------------------------------
+// calcul la difference entre deux heure differentes
+// sortie <= : _iDifference
+//------------------------------------------------------------------------------
+int synchro_CalculDifference()
+{
+  int _iDifference;
+  gettimeofday(&temps_actuel, NULL);
+  _iDifference = (1000000 * (temps_actuel.tv_sec - temps_sauve.tv_sec)) + (temps_actuel.tv_usec - temps_sauve.tv_usec);
+  temps_sauve = temps_actuel;
+  return _iDifference;
+}
+
+//------------------------------------------------------------------------------
+// calcul la difference entre deux heure differentes
+// sortie <= : _iDifference
+//------------------------------------------------------------------------------
+int synchro_CalculDifference2()
+{
+  int _iDifference;
+  gettimeofday(&temps_actuel2, NULL);
+  _iDifference = (1000000 * (temps_actuel2.tv_sec - temps_sauve2.tv_sec)) + (temps_actuel2.tv_usec - temps_sauve2.tv_usec);
+  temps_sauve2 = temps_actuel2;
+  return _iDifference;
+}
+#endif