home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 13 / AACD13.ISO / AACD / Programming / Atmel / Asm / src / buff.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-08-22  |  2.2 KB  |  150 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3.  
  4. typedef unsigned char BYTE;
  5. typedef unsigned long ULONG;
  6.  
  7. #include "buff.h"
  8.  
  9. #define BUFFCHUNK_SIZE  8192
  10.  
  11. int BuffEOF(struct MemBuffer *Buf)
  12. {
  13.   if (Buf->Offset >= Buf->Used)
  14.   {
  15.     return 1;
  16.   }
  17.   return 0;
  18. }
  19.  
  20. int BuffPutS(const char *s, struct MemBuffer *Buf)
  21. {
  22.   while(*s)
  23.   {
  24.     if (BuffPutC(*s, Buf) == 0) return(-1);
  25.     s++;
  26.   }
  27.   return(1);
  28. }
  29.  
  30. char *BuffGetS(char *s, int n, struct MemBuffer *Buf)
  31. {
  32.   char *p=s;
  33.   int k;
  34.  
  35.   do
  36.   {
  37.     k=BuffGetC(Buf);
  38.     if (k == -1) return (NULL);
  39.     *p++=k;
  40.   }while( (--n) && (k!='\n') );
  41.   *p++=0;
  42.   return(s);
  43. }
  44.  
  45. int BuffGetC(struct MemBuffer *Buf)
  46. {
  47.   BYTE Return;
  48.  
  49.   if (Buf->Offset >= Buf->Used)
  50.   {
  51.     return -1;
  52.   }
  53.  
  54.   Return = Buf->Buffer[Buf->Offset];
  55.   Buf->Offset++;
  56.   return (Return);
  57. }
  58.  
  59. int BuffPutC(BYTE Ch, struct MemBuffer *Buf)
  60. {
  61.   if (Buf == NULL)
  62.   {
  63.     return -1;
  64.   }
  65.  
  66.   if (Buf->Buffer == NULL)   /*Allocate some memory for buffer*/
  67.   {
  68.     Buf->Buffer = (BYTE*)malloc(BUFFCHUNK_SIZE);
  69.     if (Buf->Buffer == NULL)
  70.     {
  71.       return -1;
  72.     }
  73.     Buf->Offset = 0;
  74.     Buf->Used = 0;
  75.     Buf->Buff_Size = BUFFCHUNK_SIZE;
  76.   }
  77.  
  78.   Buf->Buffer[Buf->Offset] = Ch;
  79.   Buf->Offset++;
  80.   if (Buf->Offset > Buf->Used)
  81.   {
  82.     Buf->Used = Buf->Offset;
  83.   }
  84.   if (Buf->Offset >= Buf->Buff_Size )
  85.   {
  86.     BYTE *Tmp;
  87.     Tmp = (BYTE*)realloc(Buf->Buffer, Buf->Buff_Size + BUFFCHUNK_SIZE);
  88.     if (Tmp == NULL)
  89.     {
  90.       return -1;
  91.     }
  92.     Buf->Buff_Size += BUFFCHUNK_SIZE;
  93.     Buf->Buffer = Tmp;
  94.   }
  95.   return 1;
  96. }
  97.  
  98. void BuffRewind(struct MemBuffer *Buf)
  99. {
  100.   if (Buf != NULL)
  101.   {
  102.     Buf->Offset = 0;
  103.   }
  104. }
  105.  
  106. void KillBuffer(struct MemBuffer *Buf)
  107. {
  108.   if(Buf != NULL)
  109.   {
  110.     if (Buf->Buffer != NULL)
  111.     {
  112.       free(Buf->Buffer);
  113.     }
  114.     free(Buf);
  115.   }
  116. }
  117.  
  118. struct MemBuffer *OpenBuffer(void)
  119. {
  120.   struct MemBuffer *Res;
  121.  
  122.   Res = (struct MemBuffer*)malloc(sizeof(struct MemBuffer));
  123.   if (Res != NULL)
  124.   {
  125.     Res->Buffer = NULL;
  126.     Res->Offset = 0;
  127.     Res->Used = 0;
  128.     Res->Buff_Size = 0;
  129.   }
  130.   return Res;
  131. }
  132.  
  133. void BuffDump(char *Filename, struct MemBuffer *Buf)
  134. {
  135.   FILE *Out;
  136.   ULONG Count;
  137.  
  138.   Out = fopen(Filename,"w");
  139.   if (Out == NULL)
  140.   {
  141.     return;
  142.   }
  143.  
  144.   for(Count=0; Count<Buf->Used; Count++)
  145.   {
  146.     fputc(Buf->Buffer[Count],Out);
  147.   }
  148.   fclose(Out);
  149. }
  150.