girepository/cmph/buffer_entry.c

   1 #include "buffer_entry.h"
   2 #include <stdio.h>
   3 #include <assert.h>
   4 #include <stdlib.h>
   5 #include <string.h>
   6
   7 struct __buffer_entry_t
   8 {
   9         FILE *fd;
  10         cmph_uint8 * buff;
  11         cmph_uint32 capacity, // buffer entry capacity
  12                     nbytes,   // buffer entry used bytes
  13                     pos;      // current read position in buffer entry
  14         cmph_uint8  eof;      // flag to indicate end of file
  15 };
  16
  17 buffer_entry_t * buffer_entry_new(cmph_uint32 capacity)
  18 {
  19         buffer_entry_t *buff_entry = (buffer_entry_t *)malloc(sizeof(buffer_entry_t));
  20         assert(buff_entry);
  21         buff_entry->fd = NULL;
  22         buff_entry->buff = NULL;
  23         buff_entry->capacity = capacity;
  24         buff_entry->nbytes = capacity;
  25         buff_entry->pos = capacity;
  26         buff_entry->eof = 0;
  27         return buff_entry;
  28 }
  29
  30 void buffer_entry_open(buffer_entry_t * buffer_entry, char * filename)
  31 {
  32         buffer_entry->fd = fopen(filename, "rb");
  33 }
  34
  35 void buffer_entry_set_capacity(buffer_entry_t * buffer_entry, cmph_uint32 capacity)
  36 {
  37         buffer_entry->capacity = capacity;
  38 }
  39
  40
  41 cmph_uint32 buffer_entry_get_capacity(buffer_entry_t * buffer_entry)
  42 {
  43         return buffer_entry->capacity;
  44 }
  45
  46 static void buffer_entry_load(buffer_entry_t * buffer_entry)
  47 {
  48         free(buffer_entry->buff);
  49         buffer_entry->buff = (cmph_uint8 *)calloc((size_t)buffer_entry->capacity, sizeof(cmph_uint8));
  50         buffer_entry->nbytes = (cmph_uint32)fread(buffer_entry->buff, (size_t)1, (size_t)buffer_entry->capacity, buffer_entry->fd);
  51         if (buffer_entry->nbytes != buffer_entry->capacity) buffer_entry->eof = 1;
  52         buffer_entry->pos = 0;
  53 }
  54
  55 cmph_uint8 * buffer_entry_read_key(buffer_entry_t * buffer_entry, cmph_uint32 * keylen)
  56 {
  57         cmph_uint8 * buf = NULL;
  58         cmph_uint32 lacked_bytes = sizeof(*keylen);
  59         cmph_uint32 copied_bytes = 0;
  60         if(buffer_entry->eof && (buffer_entry->pos == buffer_entry->nbytes)) // end
  61         {
  62                 free(buf);
  63                 return NULL;
  64         }
  65         if((buffer_entry->pos + lacked_bytes) > buffer_entry->nbytes)
  66         {
  67                 copied_bytes = buffer_entry->nbytes - buffer_entry->pos;
  68                 lacked_bytes = (buffer_entry->pos + lacked_bytes) - buffer_entry->nbytes;
  69                 if (copied_bytes != 0) memcpy(keylen, buffer_entry->buff + buffer_entry->pos, (size_t)copied_bytes);
  70                 buffer_entry_load(buffer_entry);
  71         }
  72         memcpy(keylen + copied_bytes, buffer_entry->buff + buffer_entry->pos, (size_t)lacked_bytes);
  73         buffer_entry->pos += lacked_bytes;
  74
  75         lacked_bytes = *keylen;
  76         copied_bytes = 0;
  77         buf = (cmph_uint8 *)malloc(*keylen + sizeof(*keylen));
  78         memcpy(buf, keylen, sizeof(*keylen));
  79         if((buffer_entry->pos + lacked_bytes) > buffer_entry->nbytes) {
  80                 copied_bytes = buffer_entry->nbytes - buffer_entry->pos;
  81                 lacked_bytes = (buffer_entry->pos + lacked_bytes) - buffer_entry->nbytes;
  82                 if (copied_bytes != 0) {
  83                         memcpy(buf + sizeof(*keylen), buffer_entry->buff + buffer_entry->pos, (size_t)copied_bytes);
  84                 }
  85                 buffer_entry_load(buffer_entry);
  86         }
  87         memcpy(buf+sizeof(*keylen)+copied_bytes, buffer_entry->buff + buffer_entry->pos, (size_t)lacked_bytes);
  88         buffer_entry->pos += lacked_bytes;
  89         return buf;
  90 }
  91
  92 void buffer_entry_destroy(buffer_entry_t * buffer_entry)
  93 {
  94   fclose(buffer_entry->fd);
  95   buffer_entry->fd = NULL;
  96   free(buffer_entry->buff);
  97   buffer_entry->buff = NULL;
  98   buffer_entry->capacity = 0;
  99   buffer_entry->nbytes = 0;
 100   buffer_entry->pos = 0;
 101   buffer_entry->eof = 0;
 102   free(buffer_entry);
 103 }