rename packages/ to recipes/ per earlier agreement

See links below for more details:
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21326
http://thread.gmane.org/gmane.comp.handhelds.openembedded/21816

Signed-off-by: Denys Dmytriyenko <denis@denix.org>
Acked-by: Mike Westerhof <mwester@dls.net>
Acked-by: Philip Balister <philip@balister.org>
Acked-by: Khem Raj <raj.khem@gmail.com>
Acked-by: Marcin Juszkiewicz <hrw@openembedded.org>
Acked-by: Koen Kooi <koen@openembedded.org>
Acked-by: Frans Meulenbroeks <fransmeulenbroeks@gmail.com>

1 files changed, 0 insertions, 845 deletions

diff --git a/packages/powermanga/powermanga-0.79/linuxroutines.cpp b/packages/powermanga/powermanga-0.79/linuxroutines.cpp
deleted file mode 100644
index 39394eb026..0000000000
--- a/packages/powermanga/powermanga-0.79/linuxroutines.cpp
+++ /dev/null
@@ -1,845 +0,0 @@
-//*****************************************************************************
-// 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