4.3BSD - /usr/src/new/pathalias/mem.c

   1: /* pathalias -- by steve bellovin, as told to peter honeyman */
   2: #ifndef lint
   3: static char *sccsid = "@(#)mem.c	8.1 (down!honey) 86/01/19";
   4: #endif
   5: 
   6: #include "def.h"
   7: 
   8: /* imported */
   9: extern char *sbrk();
  10: 
  11: link    *
  12: newlink()
  13: {
  14:     link    *rval;
  15: 
  16:     if ((rval = (link * ) calloc(1, sizeof(link))) == 0)
  17:         nomem();
  18:     return(rval);
  19: }
  20: 
  21: node    *
  22: newnode()
  23: {
  24:     node    *rval;
  25: 
  26:     if ((rval = (node * ) calloc(1, sizeof(node))) == 0)
  27:         nomem();
  28:     Ncount++;
  29:     return(rval);
  30: }
  31: 
  32: char    *
  33: strsave(s)
  34: char    *s;
  35: {
  36:     char *r;
  37: 
  38:     if ((r = malloc((unsigned int) strlen(s) + 1)) == 0)
  39:         nomem();
  40:     (void) strcpy(r, s);
  41:     return(r);
  42: }
  43: 
  44: #ifndef strclear
  45: void
  46: strclear(dst, len)
  47: register char *dst;
  48: register int len;
  49: {
  50:     while (--len >= 0)
  51:         *dst++ = 0;
  52: }
  53: #endif /*strclear*/
  54: 
  55: node    **
  56: newtable(size)
  57: long    size;
  58: {
  59:     node    **rval;
  60: 
  61:     if ((rval = (node **) calloc(1, (unsigned int) (size * sizeof(*rval)))) == 0)
  62:         nomem();
  63:     return(rval);
  64: }
  65: 
  66: freetable(t, size)
  67: node    **t;
  68: long    size;
  69: {
  70: #ifdef MYMALLOC
  71:     addtoheap((char *) t, (long) (size * sizeof(*t)));
  72: #else
  73:     free((char *) t);
  74: #endif
  75: }
  76: 
  77: nomem()
  78: {
  79:     fprintf(stderr, "%s: Out of memory (%ldk allocated)\n",
  80:             ProgName, allocation());
  81:     badmagic(1);
  82: }
  83: 
  84: /* data space allocation -- main sets End very early */
  85: allocation()
  86: {
  87:     static char *dataspace;
  88: 
  89:     if (dataspace == 0) {   /* first time */
  90:         dataspace = sbrk(0);        /* &end? */
  91:         return(0);
  92:     }
  93:     return((sbrk(0) - dataspace)/1024);
  94: }
  95: 
  96: #ifdef MYMALLOC
  97: 
  98: /* use c library malloc/calloc here, and here only */
  99: #undef malloc
 100: #undef calloc
 101: extern char *malloc(), *calloc();
 102: 
 103: /* allocate in MBUFSIZ chunks.  4k works ok (less 16 for malloc quirks). */
 104: #define MBUFSIZ (4 * 1024 - 16)
 105: 
 106: /*
 107:  * mess with ALIGN at your peril.  longword (== 0 mod 4)
 108:  * alignment seems to work everywhere.
 109:  */
 110: 
 111: #define ALIGN 2
 112: 
 113: typedef struct heap heap;
 114: struct heap {
 115:     heap *h_next;
 116:     long h_size;
 117: };
 118: 
 119: static heap *Mheap; /* not to be confused with a priority queue */
 120: 
 121: addtoheap(p, size)
 122: char *p;
 123: long size;
 124: {
 125:     int adjustment;
 126:     heap *pheap;
 127: 
 128:     /* p is aligned, but it doesn't hurt to check */
 129:     adjustment = align(p);
 130:     p += adjustment;
 131:     size -= adjustment;
 132: 
 133:     if (size < 1024)
 134:         return;     /* can't happen */
 135:     pheap = (heap *) p; /* pheap is shorthand */
 136:     pheap->h_next = Mheap;
 137:     pheap->h_size = size;
 138:     Mheap = pheap;
 139: }
 140: 
 141: /*
 142:  * buffered malloc()
 143:  *	returns space initialized to 0.  calloc isn't used, since
 144:  *	strclear can be faster.
 145:  *
 146:  * free is ignored, except for very large objects,
 147:  * which are returned to the heap with addtoheap().
 148:  */
 149: 
 150: char    *
 151: mymalloc(n)
 152: register unsigned int   n;
 153: {
 154:     static long size;       /* how much do we have on hand? */
 155:     static char *mstash;    /* where is it?  (kept aligned) */
 156:     register char   *rval;
 157: 
 158:     n += align((char *) n); /* keep everything aligned */
 159:     if (n >= 1024) {        /* from hash table */
 160:         rval = malloc(n);   /* aligned */
 161:         strclear(rval, n);
 162:         return(rval);
 163:     }
 164: 
 165: 
 166:     if (n > size) {
 167:         /* look in the heap (already aligned) */
 168:         if (Mheap) {
 169:             mstash = (char *) Mheap;
 170:             size = Mheap->h_size;
 171:             Mheap = Mheap->h_next;
 172:         } else {
 173:             mstash = malloc(MBUFSIZ);   /* aligned */
 174:             if (mstash == 0) {
 175:                 size = 0;
 176:                 return(0);
 177:             }
 178:             size = MBUFSIZ;
 179:         }
 180:         strclear(mstash, size);
 181:     }
 182:     rval = mstash;
 183:     mstash += n;
 184:     size -= n;
 185:     return(rval);
 186: }
 187: 
 188: /* what's the (mis-)alignment of n?  return the complement of (n mod 2^ALIGN) */
 189: align(n)
 190: char    *n;
 191: {
 192:     int abits;  /* misalignment bits in n */
 193: 
 194:     abits = (int) n & ~(0xff << ALIGN) & 0xff;
 195:     if (abits == 0)
 196:         return(0);
 197:     return((1 << ALIGN) - abits);
 198: }
 199: 
 200: #endif /*MYMALLOC*/

Defined functions

Defined variables

Defined struct's

Defined typedef's

Defined macros