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