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