/* ---------------------------------------------------------------------
   (c) ED 1999-2008
   Projet       : CLIB
   Fonction     : Gestion d'un buffer memoire
   Module       : BUF
   Fichier      : BUF.C
   Creation     : 17-11-1999
   Modification : 05-04-2008
   --------------------------------------------------------------------- */

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

   1.5 du 05-04-2008 ajoute "ed/inc/mem.h"
   1.4 du 03-06-2002 ajout du champ size
   1.3 du 31-05-2002 ajout de BUF_copy()
   1.2 du 09-03-2002 buf devient uint
   1.1 du 13-06-2000 Ajout de BUF_move()
   1.0 du 06-04-2000 Version operationelle
   0.0 du 17-11-1999 Creation

   --------------------------------------------------------------------- */
#ifdef __cplusplus
#error This source file is not C++ but rather C. Please use a C-compiler
#endif

#include "ed/inc/sys.h"
#include "ed/inc/buf.h"

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

#define MODULE "BUF"
#define VER "1.5"
#define ID MODULE" Module \"C\" (c) ED 1999-2003"

/* constants =========================================================== */
/* types =============================================================== */
/* structures ========================================================== */
/* private variables =================================================== */
/* private functions =================================================== */
/* entry points ======================================================== */

/* ---------------------------------------------------------------------
   BUF_sver()
   ---------------------------------------------------------------------
   Role : Retourne une chaine "Version"
   ---------------------------------------------------------------------
   E :
   S : Pointeur de chaine ASCIIZ
   --------------------------------------------------------------------- */
const char *BUF_sver (void)
{
   return VER;
}

/* ---------------------------------------------------------------------
   BUF_sid()
   ---------------------------------------------------------------------
   Role : Retourne une chaine "Identification"
   ---------------------------------------------------------------------
   E :
   S : Pointeur de chaine ASCIIZ
   --------------------------------------------------------------------- */
const char *BUF_sid (void)
{
   return ID;
}

/* ---------------------------------------------------------------------
   BUF_init()
   ---------------------------------------------------------------------
   Role : Initialisation
   ---------------------------------------------------------------------
   E : Pointeur de donnees
   E : buffer
   E : longueur
   E : type d'allocation
   S :
   --------------------------------------------------------------------- */
void BUF_init (sBUF * pBuf, uchar const *buf, size_t len, eMEM eMem)
{
   ENUM_CHECK ();

   if (pBuf != NULL)
   {
      ASSERT (eMem < MEM_NB);

      pBuf->len = len;
      pBuf->buf = buf;
      pBuf->eMem = eMem;
   }
}

/* ---------------------------------------------------------------------
   BUF_copy()
   ---------------------------------------------------------------------
   Role : Copy dynamique d'un bloc
   ---------------------------------------------------------------------
   E : Pointeur de donnees
   E : buffer
   E : longueur
   S :
   --------------------------------------------------------------------- */
int BUF_copy (sBUF * pBuf, uchar const *buf, size_t len)
{
   int err;

   ENUM_CHECK ();

   if (pBuf != NULL)
   {
      pBuf->buf = malloc (len);

      if (pBuf->buf)
      {
         memcpy ((char *) pBuf->buf, buf, len);
         pBuf->len = len;
         pBuf->eMem = MEM_DYN;
         err = 0;
      }
      else
      {
         err = 1;
      }
   }
   else
   {
      err = 1;
   }
   return err;
}

/* ---------------------------------------------------------------------
   BUF_init()
   ---------------------------------------------------------------------
   Role : Initialisation (chaine)
   ---------------------------------------------------------------------
   E : Pointeur de donnees
   E : chaine
   E : type d'allocation
   S :
   --------------------------------------------------------------------- */
void BUF_init_sz (sBUF * pBuf, char const *sz, eMEM eMem)
{
   if (pBuf != NULL)
   {
      size_t len = 0;

      /*assert (eMem >= 0); un enum est toujours > 0 ? */
      ASSERT (eMem < MEM_NB);

      if (sz)
      {
         len = strlen (sz);
      }

      BUF_init (pBuf, (uchar *) sz, len, eMem);
   }
}

/* ---------------------------------------------------------------------
   BUF_move()
   ---------------------------------------------------------------------
   Role : Deplacer (la source est effacee)
   ---------------------------------------------------------------------
   E : Source
   E : Destination
   S :
   --------------------------------------------------------------------- */
void BUF_move (sBUF * pBufSrc, sBUF * pBufDes)
{
   if (pBufSrc && pBufDes)
   {
      *pBufDes = *pBufSrc;

      {
         static const sBUF Buf0 =
         {0, 0, MEM_STA};
         *pBufSrc = Buf0;
      }

   }
}

/* ---------------------------------------------------------------------
   BUF_end()
   ---------------------------------------------------------------------
   Role : Liberation automatique du bloc de donnees si il est dynamique
   ---------------------------------------------------------------------
   E : Pointeur de donnees
   S :
   --------------------------------------------------------------------- */
void BUF_end (sBUF * pBuf)
{
   if (pBuf != NULL)
   {
      if (pBuf->buf != NULL)
      {
         if (pBuf->eMem == MEM_DYN)
         {
            free ((char *) pBuf->buf);
         }
         pBuf->eMem = MEM_STA;
      }
      pBuf->buf = NULL;
      pBuf->len = 0;
   }
}

/* public variables ==================================================== */

/* File generated by 'NEW.EXE' Ver 1.19 (c) ED 1998-99 */