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