#ifndef H_ED_SYS_20031003125620
#define H_ED_SYS_20031003125620

#ifdef __cplusplus
extern "C"
{
#endif

/* ---------------------------------------------------------------------
   (c) ED 1995-2006
   Projet       : CLIB
   Fonction     : Fonctions 'systeme'
   Module       : SYS
   Fichier      : SYS.H
   Creation     : 05-01-1995
   Modification : 16-06-2006
   --------------------------------------------------------------------- */

/* ---------------------------------------------------------------------
   Journal

   1.33 16-06-2006 deplace ASSERT() dans ed/inc/assert.h
   1.32 22-03-2006 Protection de SIZE_T_MAX
   1.31 15-11-2005 Ajout de la macro STR()
   1.30 25-06-2004 Differencie DJGPP de GCC
   1.29 15-12-2003 Ajout de SYS_get_str()
   1.28 01-12-2003 Suppression de la macro NOT_USED()
   1.27 11-07-2003 Recupere sys_time() et sys_clock() qui etaient dans
   .               sysalloc
   1.26 10-06-2003 Les macros MIN et MAX deviennent min() max()
   1.25 28-05-2003 Ajoute macros MIN et MAX (si non definies)
   1.24 15-04-2003 Ajoute compilateur _TMS320C5XX.
   1.23 04-01-2003 Ajoute (size_t) a l'init de SYS_G_stack_min.
   1.22 26-11-2002 Supprime macro PERR() C'est de la responsabilite des
   .               applications
   1.21 15-11-2002 Ajoute macros STACK_xxx()
   1.20 04-10-2002 Ajoute macros INFO(), EN_TRAVAUX() et PERR().
   .               ASIZE() devient NELEM()
   1.19 13-07-2002 LCLint
   1.18 26-04-2002 Supprime definitions de BYTE WORD LONG
   1.17 26-09-2001 Ajout definition U8 U16 et U32
   1.16 17-02-2001 SYS_dump() en stderr.
   1.15 01-12-2000 Ajout macro ENUM_CHECK()
   1.14 22-11-2000 Ajout macro ALIGN2() La macro PAR devient PAR_
   1.13 17-11-2000 dans ASET(), i devient aset_i
   1.12 16-11-2000 ajoute macros OCT_INTEGER_MAX etc...
   1.11 29-06-2000 ajoute LIM_STR()
   1.10 19-06-2000 ajoute ASET()
   1.9 16-06-2000 ajoute CHK_STR() et CHK_PTR()
   1.8 31-05-2000 les bits telecom (B1-B8) deviennent uint
   1.7 04-04-2000 TSIZE() devient ASIZE()
   1.6 30-03-2000 ajoute () dans les macros
   1.5 23-11-1999 dans SYS_print_dbg(), remplace free() par sys_free()
   1.4 17-11-1999 Mise en conformite ANSI de SYS_dump().
   .              Renforce' les controles
   1.3 15-01-1999 Normalisation
   1.2 29-12-1998 Ajout de SYS_StrDllExitType()
   1.1 09-09-1998 Ajout de SYS_FindInt()
   1.0 13-08-1998 SYS_sz_dbg() devient SYS_print_dbg

   0.5 09-08-1998 Ajout de SYS_sz_dbg()
   0.4 16-02-1998 le type de SYS_dump passe de (BYTE*) a (void*)
   0.3 22-01-1998 Ajout de SYS_in()
   0.2 09-01-1995 Compilation ANSI (suppression des "far")
   0.1 05-01-1995 Version Operationelle

   Specifications
   --------------

   ATTENTION

   Dans une macro, ne pas mettre de ';' (instruction vide...)
   C'est l'application qui le met.

   Exemple

   .  {
   .     MEM_GET;
   .
   .     MEM_TEST;
   .  }

   --------------------------------------------------------------------- */
#include <stddef.h>             /* size_t */
#include <limits.h>             /* CHAR_BIT */
#include <assert.h>             /* macros avec assert() */
#include <string.h>             /* memset() */
#include <stdio.h>              /* */
#include <stdlib.h>             /* ASSERT() */
#include <time.h>

#include "ed/inc/types.h"
#include "ed/inc/assert.h"

/* macros ============================================================== */

/* chaines numeriques les plus grandes */
#define OCT_INTEGER_MAX "777777777777"
#define DEC_INTEGER_MAX "-2147483648"
#define HEX_INTEGER_MAX "FFFFFFFF"

/* (c) Eric Sosman 2001 */
#define BIG_ENOUGH (1 + (sizeof(long) * CHAR_BIT + 2) / 3 + 1)

/* maximum number of elements of a given type */
#define MAX_NB(T) ((size_t)-1 / sizeof (T))

/* Min / Max
   Attention, les valeurs sont evalues deux fois.
 */
#ifndef min
#define min(a, b) ((a) < (b) ? (a) : (b))
#endif

#ifndef max
#define max(a, b) ((a) > (b) ? (a) : (b))
#endif

/* Fin de lignes pour stdio */
#ifndef EOL
#define EOL "\n"
#endif

#define GLO_OUTSTREAM stdout

/* afficher <fonction>() en travaux */
#define EN_TRAVAUX(fun)                       \
   fprintf (GLO_OUTSTREAM                     \
           ,"*E.T.* : '%s()' at %s:%u "EOL    \
           , #fun                             \
           , __FILE__                         \
           , (uint) __LINE__                  \
           );

/* afficher une information */
#define INFO(str)                   \
   fprintf (GLO_OUTSTREAM           \
           , "'%s' at %s:%u"EOL     \
           , str                    \
           , __FILE__               \
           , (uint) __LINE__)

/* printf programmable (debug)
 * usage : PRINTF (("Hi, I'm %u years old", 46))
 */
#define PRINTF(s)                   \
   printf s

/* stringizer macro */
#define STR_(a) #a
#define STR(a) STR_(a)

/* Specificites des compilateurs */
#define COMP_VER "?.?"
#define COMP_NAME "?"

#if defined (__BORLANDC__)
#include <alloc.h>
#undef COMP_VER
#undef COMP_NAME
#ifndef LCLINT
#define COMP_VER __TURBOC__
#else
#define COMP_VER 0
#endif
#define COMP_NAME "BC++"
   /* version maximale de Borland C supportant la variable globale '_MMODEL' */
#define VER_MAX_MMODEL 0x0410
#define SIZE_T_BIT 16
#include <string.h>
#define SYS_CLR(p, T) \
  memset ((p), 0, sizeof *(p))
#ifndef __STDC__
#include <dos.h>
#define STACK_SET(a) \
   extern uint _stklen = (a);
   extern uint SYS_G_stack_max;
   extern uint SYS_G_stack_min;
#define STACK_INIT() \
   SYS_G_stack_max = _SP

#define STACK_CHK()                     \
    do                                    \
    {                                     \
       if (_SP < SYS_G_stack_min)         \
       {                                  \
          SYS_G_stack_min = _SP;          \
       }                                  \
       ASSERT (SYS_G_stack_min >= 0x100); \
    }                                     \
    while (0)
#define STACK_PRINT() \
   SYS_print_stack()
#else
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()
#endif

/* Force floating point link */
   extern uint _floatconvert;
#pragma extref _floatconvert

   /* DJGPP */
#elif defined (__DJGPP__)
#undef COMP_VER
#undef COMP_NAME
#include </djgpp/include/sys/version.h>
#define COMP_VER	__DJGPP__
#define COMP_NAME "DJGPP"
#define SIZE_T_BIT 32
#define SYS_CLR(p, T)        \
   do                         \
   {                          \
      static const T z = {0}; \
      *(p) = z;               \
   }                          \
   while(0)
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()

   /* GCC */
#elif defined (__GNUC__)
#undef COMP_VER
#undef COMP_NAME
#define COMP_VER	__GNUC__
#define COMP_NAME "GCC"
#define SIZE_T_BIT 32
#define SYS_CLR(p, T)        \
   do                         \
   {                          \
      static const T z = {0}; \
      *(p) = z;               \
   }                          \
   while(0)
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()

#elif defined (_MRI)

#define SIZE_T_BIT 32
#include <string.h>
#define SYS_CLR(p, T) \
  memset ((p), 0, sizeof *(p))
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()

#elif defined (_MSC_VER)

#define SIZE_T_BIT 32
#undef COMP_VER
#undef COMP_NAME
#define COMP_VER	_MSC_VER
#define COMP_NAME "MSCV"
#define SYS_CLR(p, T)        \
   do                         \
   {                          \
      static const T z = {0}; \
      *(p) = z;               \
   }                          \
   while(0)
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()

#elif defined (__DIAB)

#define SIZE_T_BIT 32
#include <string.h>
#define SYS_CLR(p, T) \
  memset ((p), 0, sizeof *(p))
#undef COMP_NAME
#define COMP_NAME "DIABDATA"
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()

#elif defined (_TMS320C5XX)

#define SIZE_T_BIT 16
#include <string.h>
#define SYS_CLR(p, T) \
  memset ((p), 0, sizeof *(p))
#undef COMP_NAME
#define COMP_NAME "TMS320C5xx"
#define STACK_INIT()
#define STACK_SET(a)
#define STACK_CHK()
#define STACK_PRINT()

#else

#error "Some definitions are missing for this platform"

#endif

#define CLR SYS_CLR

#define OS "?"

#ifdef __MSDOS__
#undef OS
#define OS "MS-DOS"
#endif

#ifdef _Windows
#undef OS
#ifdef __WIN32__
#define OS "Win 32"
#else
#define OS "Win 16"
#endif
#endif


#include "ed/inc/pc_dbg.h"

#ifndef _Windows
#ifndef FAR
#ifdef __BORLANDC__
#define FAR far
#else
#define FAR
#endif
#endif
#endif


#ifdef __BORLANDC__
#else
#define farcoreleft() 0
#define coreleft() 0
#endif


/* taille max d'un size_t */
#ifndef SIZE_T_BIT
#error SIZE_T_BIT doit etre defini
#endif

#ifndef SIZE_T_MAX
#define SIZE_T_MAX ((SIZE_T_BIT==16)\
                     ?0xFFFFU:(SIZE_T_BIT==32)\
                     ?0xFFFFFFFFUL:0\
                    )
#endif

/* Macro permettant de supprimmer un warning
 * (parametre non utilise par exemple)
 * ED/01/12/03 17:48 : renommee (etait 'NOT_USED()')
 */
#define SYS_NOT_USED(a) (void) (a)

#define SYS_high(d)   (uchar) (((d) >> 8) & 0xFF)
#define SYS_low(d)    (uchar) ((d) & 0xFF)
#define SYS_word(l,h) (ushort) ((l) | ((h)<<8))

/* Number of elements in an array */
#define NELEM(a) (sizeof (a) / sizeof *(a))

/* initizalisation de tableaux */
#define ASET(a,sts)                               \
do                                                \
{                                                 \
   size_t aset_i;                                 \
   for (aset_i = 0; aset_i < NELEM (a); aset_i++) \
   {                                              \
      (a)[aset_i] = sts;                          \
   }                                              \
}                                                 \
while(0)

/* pollution controlee d'une structure */
#ifndef NDEBUG
#define GARBAGE(p) memset((p),0x55,sizeof *(p))
#else
#define GARBAGE(p)
#endif

/* controles */
#define LIM_STR(s) (s)[sizeof (s) - 1]=0
#define CHK_STR(s) ASSERT((s)[sizeof (s) - 1]==0)

#ifndef NDEBUG
#define LIM_PTR(p,l) (p)[(l) -1]=0
#else
#define LIM_PTR(p,l)
#endif
#define CHK_PTR(p,l) ASSERT((p)[(l) -1]==0)

/* alignements */
#define ALIGN2(a) ((a) & 1 ? (a) + 1 : (a))

#ifndef NDEBUG
/* Controle taille enum a mettre dans toutes les unites de compilation */
   typedef enum
   {
      ENUM_DUMMY_ = -1
   }
   enum_t;
#define ENUM_CHECK() ASSERT(sizeof (enum_t) == sizeof (int))
#else
#define ENUM_CHECK()
#endif

/* ---------------------------------------------------------------------
   Constantes
   --------------------------------------------------------------------- */

#ifndef WIN32
   /* Paragraphe */
#define PAR_ 0x10L
   /* Adresse physique */
#define ADR(ptr) (FP_SEG(&ptr)*PAR_)+FP_OFF(&ptr)
#endif

#if defined(__TINY__)
#ifdef _Windows
#error Mode TINY Interdit sous Windows
#endif
#define T_MEM "TINY"
#endif

#if defined(__SMALL__)
#define T_MEM "SMALL"
#endif

#if defined(__MEDIUM__)
#define T_MEM "MEDIUM"
#endif

#if defined(__COMPACT__)
#define T_MEM "COMPACT"
#endif

#if defined(__LARGE__)
#define T_MEM "LARGE"
#endif

#if defined(__HUGE__)
#if defined _Windows
#error Mode HUGE Interdit sous Windows
#endif
#define T_MEM "HUGE"
#endif

#if defined(__FLAT__)
#if !defined(__WIN32__)
#error Mode FLAT Requiet WIN32 ou NT
#endif
#define T_MEM "FLAT"
#endif

#if defined(__DJGPP__) || defined(_MSC_VER) || defined(_MRI)
#define T_MEM "FLAT"
#endif

/*
   MODULE est le nom du module courant de l'application
   Le programmeur doit le definir dans chaque module de la facon suivante :
   DEF_MODULE ("SYS")
 */

#define DEF_MODULE(a) static const char MODULE[]=a

#ifndef SYS_NO_AFF_MEM
#define aff_mem() printf ("%s Mem : %u oct\n", MODULE, coreleft())
#ifdef _Windows
/* NOTA : Sans signification sous Windows */
#define aff_dmem(wMem)                                    \
do{                                                         \
   ulong dwDiff_ = wMem - GetFreeSpace(0);                  \
   if (dwDiff_)                                             \
   {                                                        \
      printf ("%s Memoire non rendue : %lu oct"             \
              " (a titre indicatif)\n"                      \
              ,MODULE                                       \
              ,dwDiff_                                      \
              );                                            \
   }                                                        \
   else                                                     \
   {                                                        \
      printf ("%s Memoire Liberee\n", MODULE);              \
   }                                                        \
}while(0)
#else
#define aff_dmem(wMem)                                      \
   do                                                         \
   {                                                          \
      ulong dwDiff_ = wMem - coreleft();              \
      if (dwDiff_)                                            \
      {                                                       \
         printf ("%s Memoire non rendue : %lu oct\n"          \
                 ,MODULE                                      \
                 , (ulong) dwDiff_                    \
                 );                                           \
      }                                                       \
      else                                                    \
      {                                                       \
         printf ("%s Memoire Liberee\n", MODULE);             \
      }                                                       \
   }                                                          \
   while(0)
#endif

#define aff_memfar() printf ("%s Mem : %lu oct\n",MODULE,farcoreleft())
#define aff_dmemfar(dMem)                                  \
do {                                                        \
   ulong diff = dMem - farcoreleft();               \
   if (diff)                                                \
   {                                                        \
      printf ("%s Memoire far non rendue : %lu oct\n"       \
             ,MODULE                                        \
             , (ulong) diff                         \
             );                                             \
   }                                                        \
   else                                                     \
   {                                                        \
      printf ("%s Memoire far Liberee\n",MODULE);           \
   }                                                        \
} while(0)

#ifndef NDEBUG
#ifdef _Windows
#define MEM_GET \
   {                             \
      ulong dwMem_ = GetFreeSpace(0); \
      printf ( "%s %s Ver %X.%X %s %lu %s\n" \
             ,MODULE                         \
				 ,COMP_NAME                      \
             ,SYS_high(COMP_VER)             \
				 ,SYS_low(COMP_VER)              \
             ,T_MEM                          \
             ,dwMem_                         \
             ,OS);

#define MEM_TEST  \
      aff_dmem(dwMem_);\
   }
#else
#define MEM_GET                                           \
   {                                                        \
   ulong dwMem_ = coreleft();                               \
      printf( "%s %s Ver %X.%X %s %lu %s\n"                 \
                    ,MODULE                                 \
				        ,COMP_NAME,SYS_high(COMP_VER)           \
						  ,SYS_low(COMP_VER),T_MEM,dwMem_,OS);

#define MEM_TEST                                          \
      aff_dmem(dwMem_);                                     \
   }
#endif
#else
#define MEM_GET
#define MEM_TEST
#endif

#endif

/* Bits 'telecom' */
#define B1 ((uint)bit7)
#define B2 ((uint)bit6)
#define B3 ((uint)bit5)
#define B4 ((uint)bit4)
#define B5 ((uint)bit3)
#define B6 ((uint)bit2)
#define B7 ((uint)bit1)
#define B8 ((uint)bit0)


/* constants =========================================================== */
/* types =============================================================== */

#ifdef SYS_TYPES

/* MSDOS... INTEL, TURBO C... */
#ifdef __BORLANDC__
#ifndef BYTE
   typedef uchar BYTE;
#endif
#ifndef WORD
   typedef ushort int WORD;
#endif
#ifndef DWORD
   typedef ulong DWORD;
#endif
#endif

#ifdef _MRI
#ifndef BYTE
   typedef uchar BYTE;
#endif
#ifndef WORD
   typedef ushort int WORD;
#endif
#ifndef DWORD
   typedef ulong DWORD;
#endif

   typedef uchar volatile U8;
   typedef ushort volatile U16;
   typedef ulong volatile U32;

#endif

#ifdef __DJGPP__
#ifndef BYTE
   typedef uchar BYTE;
#endif
#ifndef WORD
   typedef ushort int WORD;
#endif
#ifndef DWORD
   typedef ulong DWORD;
#endif
#endif

#ifdef _MSC_VER
#ifndef BYTE
   typedef uchar BYTE;
#endif
#ifndef WORD
   typedef ushort int WORD;
#endif
#ifndef DWORD
   typedef ulong DWORD;
#endif
#endif

#ifndef _Windows
#include "ed/inc/bool.h"
#else
#include <windows.h>
#endif

#include "ed/inc/bits.h"

#endif                          /* ~SYS_NO_TYPES */

/* types fixes pour materiel */
   typedef uchar volatile U8;
   typedef ushort volatile U16;
   typedef ulong volatile U32;

/* structures ========================================================== */

/* Structure de donnees pour le tableau de SYS_get_str() */
   typedef struct
   {
      int value;
      char const *string;
   }
   SYS_int_str_s;

/* entry points ======================================================== */
/* public data ========================================================= */

#if defined (__TURBOC__) && (__TURBOC__ <= VER_MAX_MMODEL)
/* Run time memory model information */
#define T_MMODEL SYS_Smmodel[SYS_mmodel(NULL)]

   typedef enum
   {
      MMODEL_PTR_NEAR,
      MMODEL_PTR_FAR,
      MMODEL_PTR_NB
   }
   tMMODEL_PTR;

   typedef enum
   {
      /*        b7   b6 0=NEAR 1=FAR   */
      /*        CODE DATA              */
      MMODEL_TINY,              /* 0x00xx 0    0                 */
      MMODEL_SMALL,             /* 0x00xx 0    0                 */
      MMODEL_MEDIUM,            /* 0x80xx 1    0                 */
      MMODEL_COMPACT,           /* 0x40xx 0    1                 */
      MMODEL_LARGE,             /* 0xC0xx 1    1                 */
      MMODEL_HUGE,              /* 0xC0xx 1    1                 */
      MMODEL_FLAT,              /* ED/16-12-98 : ajout           */
      MMODEL_NB
   }
   tMMODEL;

   typedef struct
   {
      tMMODEL_PTR code;         /* type de pointeur CODE */
      tMMODEL_PTR data;         /* type de pointeur DATA */
      tMMODEL model;            /* Modele de memoire */
   }
   sMMODEL;

/* Strings */
   extern const char *SYS_Smmodel[MMODEL_NB];
   extern const char *SYS_Smmodel_ptr[MMODEL_PTR_NB];


   tMMODEL SYS_mmodel (sMMODEL * pmmodel);
#endif                          /* __TURBOC__ <=VER_MAX_MMODEL */


#if !defined(__STRICT_ANSI__) && (defined(__BORLANDC__) || defined(__DJGPP__))
   typedef union
   {
      struct
      {
         uchar bl;              /* INTEL : Poids faible en tete */
         uchar bh;
      }
      b;

      ushort w;

   }
   uWD;

   typedef union
   {
      struct
      {
         uchar b0;              /* INTEL : Poids faible en tete */
         uchar b1;
         uchar b2;
         uchar b3;
      }
      b;

      struct
      {
         ushort wl;
         ushort wh;
      }
      w;

      ulong d;

   }
   uDW;
#endif


#ifdef BF_SAT_SAGEM
/* Systeme d'entete pour BF SAT-SAGEM */

   typedef int (*AE_PTRFCT) (); /* Type pointeur de fonction
                                   (parametres non specifies) */

#define AE_ENTTAB(nom,reserve,nubloc,revision,version,indice,nbpte) \
typedef  struct            \
{                          \
   uchar   AE_RES0  ;         \
   uchar   AE_NUBLOC;         \
   uchar   AE_REV   ;         \
   uchar   AE_VERS  ;         \
   ushort   AE_PATCH ;         \
   ushort   AE_NBPTE ;         \
   AE_PTRFCT  AE_PG[(nbpte)]; \
} AE_BLOC_;                  \
AE_BLOC_ const nom =         \
{                          \
   (reserve)               \
  ,(nubloc)                \
  ,(revision)              \
  ,(version)               \
  ,(indice)                \
  ,(nbpte)                 \
  ,                        \
   {

#define AE_PTETAB(nom,nomprog) \
     (AE_PTRFCT)(nomprog)

#define AE_PTEFIN(nom,nomprog) \
     (AE_PTRFCT)(nomprog)      \
   }                          \
}
#endif


/* entry points ======================================================== */

/* ---------------------------------------------------------------------
   SYS_sid()
   ---------------------------------------------------------------------
   Role : retourne une chaine avec l'identification du module
   ---------------------------------------------------------------------
   E :
   S : identification
   --------------------------------------------------------------------- */
   char const *SYS_sid (void);

/* ---------------------------------------------------------------------
   SYS_sver()
   ---------------------------------------------------------------------
   Role : retourne une chaine avec la version
   ---------------------------------------------------------------------
   E :
   S : version
   --------------------------------------------------------------------- */
   char const *SYS_sver (void);

/* ---------------------------------------------------------------------
   SYS_dump()
   ---------------------------------------------------------------------
   Role : Dumper une zone memoire vers stdout
   ---------------------------------------------------------------------
   E : adresse de debut de la zone
   E : longueur a dumper (en octets)
   S :
   --------------------------------------------------------------------- */
   void SYS_dump (void const *const p, size_t const len);

/* ---------------------------------------------------------------------
   SYS_dump16()
   ---------------------------------------------------------------------
   Role : Dumper une zone memoire vers stdout en 16 bits
   ---------------------------------------------------------------------
   E : adresse de debut de la zone
   E : longueur a dumper (en mots de 16 bits)
   S :
   --------------------------------------------------------------------- */
   void SYS_dump16 (void const *const p, size_t const len);

/* ---------------------------------------------------------------------
   SYS_IntIn()
   ---------------------------------------------------------------------
   Role : cherche un 'int' dans un tableau d'entier, et retourne 1 si
   il l'a trouve, ou 0 sinon.
   ---------------------------------------------------------------------
   E : Adresse du tableau
   E : Nombre d'entiers du tableau
   E : Valeur recherchee
   S : 0=Pas trouve 1=Trouve
   --------------------------------------------------------------------- */
   int SYS_IntIn (int const *const ai, const size_t size, const int val);

/* ---------------------------------------------------------------------
   SYS_FindInt()
   ---------------------------------------------------------------------
   Role : cherche un 'int' dans un tableau d'entier, et retourne son rang
   si il l'a trouve, ou -1 sinon.
   ---------------------------------------------------------------------
   E : Adresse du tableau
   E : Nombre d'entiers du tableau
   E : Valeur recherchee
   S : -1=Pas trouve >0=Rang
   --------------------------------------------------------------------- */
   int SYS_FindInt (int const *const ai
                    ,size_t const size
                    ,int const val);

/* --------------------------------------------------------------------
   SYS_get_str()
   --------------------------------------------------------------------
   retourne une chaine en fonction d'un int
   --------------------------------------------------------------------
   E : value
   S : string ou "?" si inconnue
   -------------------------------------------------------------------- */
   char const *SYS_get_str (SYS_int_str_s const *const as
                            ,size_t const nb
                            ,int const val);

/* ---------------------------------------------------------------------
   SYS_DwIndex()
   ---------------------------------------------------------------------
   Retourne le rang d'un ulong dans un tableau ou -1 si absent
   ---------------------------------------------------------------------
   E : adresse
   E : npmbre d'elements
   E : valeur cherchee
   S : valeur -1 = absent
   --------------------------------------------------------------------- */
   int SYS_DwIndex (const ulong * adw
                    ,const size_t size
                    ,const ulong dw);


#ifdef _Windows
#ifndef WIN32

/* ---------------------------------------------------------------------
   StrDllExitType()
   ---------------------------------------------------------------------
   Get DLL Exit type string
   --------------------------------------------------------------------- */
   const char *SYS_StrDllExitType (const int nExitType);
#endif
#endif


/* ---------------------------------------------------------------------
   SYS_print_stack()
   ---------------------------------------------------------------------
   Prints the stack status
   --------------------------------------------------------------------- */
   void SYS_print_stack (void);

/* ---------------------------------------------------------------------
   sys_clock()
   ---------------------------------------------------------------------
   Role :
   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
   clock_t sys_clock (void);

/* ---------------------------------------------------------------------
   sys_time()
   ---------------------------------------------------------------------
   Role :
   ---------------------------------------------------------------------
   E :
   S :
   --------------------------------------------------------------------- */
   time_t sys_time (time_t * timer);


/* public data ========================================================= */

#ifdef __cplusplus
}
#endif

#endif                          /* H_ED_SYS_20031003125620 */

/* Guards added by GUARD (c) ED 2000-2003 Feb 14 2003 Ver. 1.5 */