odr/odr_mem.c

   1 /*
   2  * Copyright (c) 1995, Index Data
   3  * See the file LICENSE for details.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: odr_mem.c,v $
   7  * Revision 1.6  1995-08-21 09:10:41  quinn
   8  * Smallish fixes to suppport new formats.
   9  *
  10  * Revision 1.5  1995/05/16  08:50:55  quinn
  11  * License, documentation, and memory fixes
  12  *
  13  * Revision 1.4  1995/05/15  11:56:09  quinn
  14  * More work on memory management.
  15  *
  16  * Revision 1.3  1995/04/18  08:15:21  quinn
  17  * Added dynamic memory allocation on encoding (whew). Code is now somewhat
  18  * neater. We'll make the same change for decoding one day.
  19  *
  20  * Revision 1.2  1995/03/17  10:17:52  quinn
  21  * Added memory management.
  22  *
  23  * Revision 1.1  1995/03/14  10:27:40  quinn
  24  * Modified makefile to use common lib
  25  * Beginning to add memory management to odr
  26  *
  27  */
  28
  29 #include <stdlib.h>
  30 #include <odr.h>
  31 #include <dmalloc.h>
  32
  33 /* ------------------------ NIBBLE MEMORY ---------------------- */
  34
  35 #define ODR_MEM_CHUNK (10*1024)
  36
  37 typedef struct odr_memblock
  38 {
  39     char *buf;
  40     int size;
  41     int top;
  42     int total;
  43     struct odr_memblock *next;
  44 } odr_memblock;
  45
  46 static odr_memblock *freelist = 0; /* global freelist */
  47
  48 static void free_block(odr_memblock *p)
  49 {
  50     p->next = freelist;
  51     freelist = p;
  52 }
  53
  54 /*
  55  * acquire a block with a minimum of size free bytes.
  56  */
  57 static odr_memblock *get_block(int size)
  58 {
  59     odr_memblock *r, *l;
  60
  61     for (r = freelist, l = 0; r; l = r, r = r->next)
  62         if (r->size >= size)
  63             break;
  64     if (r)
  65         if (l)
  66             l->next = r->next;
  67         else
  68             freelist = r->next;
  69     else
  70     {
  71         int get = ODR_MEM_CHUNK;
  72
  73         if (get < size)
  74             get = size;
  75         if (!(r = malloc(sizeof(*r))))
  76             abort();
  77         if (!(r->buf = malloc(r->size = get)))
  78             abort();
  79     }
  80     r->top = 0;
  81     r->total = 0;
  82     return r;
  83 }
  84
  85 /*
  86  * Return p to the global freelist.
  87  */
  88 void odr_release_mem(ODR_MEM p)
  89 {
  90     odr_memblock *t;
  91
  92     while (p)
  93     {
  94         t = p;
  95         p = p->next;
  96         free_block(t);
  97     }
  98 }
  99
 100 /*
 101  * Extract the memory control block from o.
 102  */
 103 ODR_MEM odr_extract_mem(ODR o)
 104 {
 105     ODR_MEM r = o->mem;
 106
 107     o->mem = 0;
 108     return r;
 109 }
 110
 111 void *odr_malloc(ODR o, int size)
 112 {
 113     struct odr_memblock *p = o->mem;
 114     char *r;
 115
 116     if (!p || p->size - p->top < size)
 117         if (!(p = get_block(size)))
 118             abort();
 119         else
 120         {
 121             if (o->mem)
 122                 p->total = o->mem->total;
 123             p->next = o->mem;
 124             o->mem = p;
 125         }
 126     r = p->buf + p->top;
 127     /* align size */
 128     p->top += (size + (sizeof(long) - 1)) & ~(sizeof(long) - 1);
 129     p->total += size;
 130     return r;
 131 }
 132
 133 int odr_total(ODR o)
 134 {
 135     return o->mem ? o->mem->total : 0;
 136 }
 137
 138 /* ---------- memory management for data encoding ----------*/
 139
 140
 141 int odr_grow_block(odr_ecblock *b, int min_bytes)
 142 {
 143     int togrow;
 144
 145     if (!b->can_grow)
 146         return -1;
 147     if (!b->size)
 148         togrow = 1024;
 149     else
 150         togrow = b->size;
 151     if (togrow < min_bytes)
 152         togrow = min_bytes;
 153     if (b->size && !(b->buf = realloc(b->buf, b->size += togrow)))
 154         abort();
 155     else if (!b->size && !(b->buf = malloc(b->size = togrow)))
 156         abort();
 157 #ifdef ODR_DEBUG
 158     fprintf(stderr, "New size for encode_buffer: %d\n", b->size);
 159 #endif
 160     return 0;
 161 }
 162
 163 int odr_write(ODR o, unsigned char *buf, int bytes)
 164 {
 165     if (o->ecb.pos + bytes >= o->ecb.size && odr_grow_block(&o->ecb, bytes))
 166     {
 167         o->error = OSPACE;
 168         return -1;
 169     }
 170     memcpy(o->ecb.buf + o->ecb.pos, buf, bytes);
 171     o->ecb.pos += bytes;
 172     if (o->ecb.pos > o->ecb.top)
 173         o->ecb.top = o->ecb.pos;
 174     return 0;
 175 }
 176
 177 int odr_seek(ODR o, int whence, int offset)
 178 {
 179     if (whence == ODR_S_CUR)
 180         offset += o->ecb.pos;
 181     else if (whence == ODR_S_END)
 182         offset += o->ecb.top;
 183     if (offset > o->ecb.size && odr_grow_block(&o->ecb, offset - o->ecb.size))
 184     {
 185         o->error = OSPACE;
 186         return -1;
 187     }
 188     o->ecb.pos = offset;
 189     return 0;
 190 }