tools/cxref/memory.c

   1 /***************************************
   2   $Header$
   3
   4   C Cross Referencing & Documentation tool. Version 1.5.
   5
   6   Memory management functions
   7   ******************/ /******************
   8   Written by Andrew M. Bishop
   9
  10   This file Copyright 1995,96,97 Andrew M. Bishop
  11   It may be distributed under the GNU Public License, version 2, or
  12   any higher version.  See section COPYING of the GNU Public license
  13   for conditions under which this file may be redistributed.
  14   ***************************************/
  15
  16 /*+ The amount of debugging, non-zero for totals, 2 for logging, 4 for printing each call. +*/
  17 #define DEBUG 0
  18
  19 /* The configure output */
  20
  21 #include "autoconfig.h"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26
  27 #ifdef USE_STD_ARG
  28 #include <stdarg.h>
  29 #else
  30 #include <varargs.h>
  31 #endif
  32
  33 #include "memory.h"
  34
  35 /*+ A private memory heap is used to reduce the number of malloc calls that are made, the Heap type is a pointer to this. +*/
  36 typedef struct _Heap *Heap;
  37
  38 /*+ A structure containing all of the information about the private heap in a linked list. +*/
  39 struct _Heap
  40 {
  41  char* mem;                             /*+ The memory that is private to the heap. +*/
  42  Heap next;                             /*+ The next Heap structure. +*/
  43 };
  44
  45 /*+ Local variable to control the usage of the private heap; +*/
  46 static Heap first=NULL;                 /*+ the first segment of memory on the private heap. +*/
  47 static int heap_left=0;                 /*+ the amount of space left in the current heap segment. +*/
  48
  49 static char* get_space(unsigned int l);
  50 static Heap add_to_heap(unsigned int l);
  51
  52 #if DEBUG&2
  53 /*+ Variable used for debugging, not a good thing to do. what if more than 16384 mallocs? +*/
  54 static void* addresses[16384];
  55 static char* files[16384];
  56 static int   lines[16384];
  57 #endif
  58 #if DEBUG
  59 /*+ Variable used for debugging. +*/
  60 static int malloc_count=0;
  61 static int realloc_count=0;
  62 static int free_count=0;
  63 #endif
  64
  65
  66 /*++++++++++++++++++++++++++++++++++++++
  67   A replacement malloc() function.
  68
  69   void* SafeMalloc Returns the address.
  70
  71   unsigned int size The size of the memory to allocate.
  72
  73   char* file The file that the function is called from.
  74
  75   int line The line number that the function is called from.
  76   ++++++++++++++++++++++++++++++++++++++*/
  77
  78 void* SafeMalloc(unsigned int size,char* file,int line)
  79 {
  80  void* rptr=malloc(size);
  81
  82 #if DEBUG&4
  83  printf("$$Malloc #%5d of %4d bytes at %08lx (%s:%3d)\n",malloc_count+1,size,(long)rptr,file,line);
  84 #endif
  85 #if DEBUG&2
  86  if(malloc_count==(sizeof(addresses)/sizeof(addresses[0])))
  87    {fprintf(stderr,"$$Too many Mallocs to log, edit memory.c\n");exit(3);}
  88  addresses[malloc_count]=(void*)rptr;
  89  files[malloc_count]=file;
  90  lines[malloc_count]=line;
  91 #endif
  92 #if DEBUG
  93  malloc_count++;
  94  if(!rptr) printf("$$Warning Malloc() returning NULL (%s:%3d)\n",file,line);
  95 #endif
  96 #if !DEBUG
  97  if(!rptr) printf("Warning Malloc() returning NULL (%s:%3d)\n",file,line);
  98 #endif
  99
 100  return(rptr);
 101 }
 102
 103
 104 /*++++++++++++++++++++++++++++++++++++++
 105   A replacement calloc() function.
 106
 107   void* SafeCalloc Returns the address.
 108
 109   unsigned int n The number of items to allocate.
 110
 111   unsigned int size The size of the memory to allocate.
 112
 113   char* file The file that the function is called from.
 114
 115   int line The line number that the function is called from.
 116   ++++++++++++++++++++++++++++++++++++++*/
 117
 118 void* SafeCalloc(unsigned int n,unsigned int size,char* file,int line)
 119 {
 120  void* rptr=calloc(n,size);
 121
 122 #if DEBUG&4
 123  printf("$$Calloc #%5d of %4d bytes at %08lx (%s:%3d)\n",malloc_count+1,size,(long)rptr,file,line);
 124 #endif
 125 #if DEBUG&2
 126  if(malloc_count==(sizeof(addresses)/sizeof(addresses[0])))
 127    {fprintf(stderr,"$$Too many Mallocs to log, edit memory.c\n");exit(3);}
 128  addresses[malloc_count]=(void*)rptr;
 129  files[malloc_count]=file;
 130  lines[malloc_count]=line;
 131 #endif
 132 #if DEBUG
 133  malloc_count++;
 134  if(!rptr) printf("$$Warning Calloc() returning NULL (%s:%3d)\n",file,line);
 135 #endif
 136 #if !DEBUG
 137  if(!rptr) printf("Warning Calloc() returning NULL (%s:%3d)\n",file,line);
 138 #endif
 139
 140  return(rptr);
 141 }
 142
 143
 144 /*++++++++++++++++++++++++++++++++++++++
 145   A replacement realloc() function.
 146
 147   void* SafeRealloc Returns the address.
 148
 149   void* ptr The old pointer.
 150
 151   unsigned int size The size of the new memory to allocate.
 152
 153   char* file The file that the function is called from.
 154
 155   int line The line number that the function is called from.
 156   ++++++++++++++++++++++++++++++++++++++*/
 157
 158 void* SafeRealloc(void* ptr,unsigned int size,char* file,int line)
 159 {
 160  void* rptr=realloc(ptr,size);
 161
 162 #if DEBUG&4
 163  printf("$$Realloc #%4d of %4d bytes at %08lx (old %08lx) (%s:%3d)\n",realloc_count+1,size,(long)rptr,(long)ptr,file,line);
 164 #endif
 165 #if DEBUG&2
 166  {
 167   int i;
 168   for(i=0;i<malloc_count;i++)
 169      if(addresses[i]==(void*)ptr)
 170        {addresses[i]=rptr;break;}
 171   if(i==malloc_count)
 172      printf("$$Realloc() called for a non Malloced pointer %08lx (%s:%3d)\n",(long)ptr,file,line);
 173  }
 174 #endif
 175 #if DEBUG
 176  realloc_count++;
 177  if(!rptr) printf("$$Warning Realloc() returning NULL (%s:%3d)\n",file,line);
 178 #endif
 179 #if !DEBUG
 180  if(!rptr) printf("Warning Realloc() returning NULL (%s:%3d)\n",file,line);
 181 #endif
 182
 183  return(rptr);
 184 }
 185
 186
 187 /*++++++++++++++++++++++++++++++++++++++
 188   A replacement free() function.
 189
 190   void* ptr The pointer that is to be freed up.
 191
 192   char* file The file that the function is called from.
 193
 194   int line The line number that the function is called from.
 195   ++++++++++++++++++++++++++++++++++++++*/
 196
 197 void SafeFree(void* ptr,char* file,int line)
 198 {
 199 #if DEBUG&4
 200  printf("$$Free #%5d at %08lx (%s:%3d)\n",free_count+1,(long)ptr,file,line);
 201 #endif
 202 #if DEBUG&2
 203  {
 204   int i;
 205   for(i=0;i<malloc_count;i++)
 206      if(addresses[i]==(void*)ptr)
 207        {addresses[i]=(void*)1;break;}
 208   if(i==malloc_count)
 209      printf("$$Free() called for a non Malloced pointer %08lx (%s:%3d)\n",(long)ptr,file,line);
 210  }
 211 #endif
 212 #if DEBUG
 213  free_count++;
 214  if(!ptr) printf("$$Calling Free() on NULL (%s:%3d)\n",file,line);
 215  else
 216 #endif
 217 #if !DEBUG
 218  if(!ptr) printf("Calling Free() on NULL (%s:%3d)\n",file,line);
 219  else
 220 #endif
 221
 222  free(ptr);
 223 }
 224
 225
 226 /*++++++++++++++++++++++++++++++++++++++
 227   A function to copy a string on the public global heap.
 228
 229   char* SafeMallocString Returns the copy of the string.
 230
 231   char* x The string to be copied.
 232
 233   char* file The file that the function is called from.
 234
 235   int line The line number that the function is called from.
 236   ++++++++++++++++++++++++++++++++++++++*/
 237
 238 char* SafeMallocString(char* x,char* file,int line)
 239 {
 240  char* t=NULL;
 241
 242  if(x)
 243    {
 244     t=(char*)SafeMalloc(strlen(x)+1,file,line);
 245     strcpy(t,x);
 246    }
 247
 248  return(t);
 249 }
 250
 251
 252 /*++++++++++++++++++++++++++++++++++++++
 253   A function to copy a string on the local private memory heap.
 254
 255   char* CopyString Returns the copy of the string.
 256
 257   char* x The string to be copied.
 258   ++++++++++++++++++++++++++++++++++++++*/
 259
 260 char* CopyString(char* x)
 261 {
 262  char* t=NULL;
 263
 264  if(x)
 265    {
 266     t=get_space(strlen(x)+1);
 267     strcpy(t,x);
 268    }
 269
 270  return(t);
 271 }
 272
 273
 274 /*++++++++++++++++++++++++++++++++++++++
 275   A function to concatenate a number of strings.
 276
 277   char* ConcatStrings Returns the a pointer to the new string.
 278
 279   int n The number of strings
 280
 281   char* s The first string.
 282
 283   ... The other strings, 'n' including 's'.
 284
 285   Any of the strings that are inputs can be NULL, in this case they are quietly ignored.
 286   ++++++++++++++++++++++++++++++++++++++*/
 287
 288 char* ConcatStrings(int n,char* s, ...)
 289 {
 290  char* t=NULL,*str;
 291  unsigned int l=0;
 292  int i;
 293  va_list ap;
 294
 295 #ifdef USE_STD_ARG
 296  va_start(ap,s);
 297 #else
 298  va_start(ap);
 299 #endif
 300
 301  for(i=0;i<n;i++)
 302    {
 303     if(i)
 304        str=va_arg(ap, char *);
 305     else
 306        str=s;
 307
 308     if(str)
 309        l+=strlen(str);
 310    }
 311
 312  va_end(ap);
 313
 314  if(l)
 315    {
 316     t=get_space(l+1); t[0]=0;
 317
 318 #ifdef USE_STD_ARG
 319     va_start(ap,s);
 320 #else
 321     va_start(ap);
 322 #endif
 323
 324     for(i=0;i<n;i++)
 325       {
 326        if(i)
 327           str=va_arg(ap, char *);
 328        else
 329           str=s;
 330
 331        if(str)
 332           strcat(t,str);
 333       }
 334
 335     va_end(ap);
 336    }
 337
 338  return(t);
 339 }
 340
 341
 342 /*++++++++++++++++++++++++++++++++++++++
 343   Prints out the number of mallocs / reallocs and frees.
 344   ++++++++++++++++++++++++++++++++++++++*/
 345
 346 void PrintMemoryStatistics(void)
 347 {
 348 #if DEBUG
 349  printf("\n"
 350         "$$Memory usage : %5d Malloc()/Calloc() calls\n"
 351         "$$               %5d Realloc() calls\n"
 352         "$$               %5d Free() calls\n"
 353         "$$               %5d Net calls (Malloc-Free)\n",
 354         malloc_count,realloc_count,free_count,malloc_count-free_count);
 355 #endif
 356
 357 #if DEBUG&2
 358  {
 359   int i;
 360   for(i=0;i<malloc_count;i++)
 361      if(addresses[i]!=(void*)1)
 362         printf("$$Malloc #%5d at address %08lx is not freed (%s:%3d) = '%s'\n",i+1,(long)addresses[i],files[i],lines[i],(char*)addresses[i]);
 363  }
 364 #endif
 365 }
 366
 367
 368 /*++++++++++++++++++++++++++++++++++++++
 369   Tidies up the local heap of memory.
 370   ++++++++++++++++++++++++++++++++++++++*/
 371
 372 void TidyMemory(void)
 373 {
 374  if(first)
 375    {
 376     Heap h=first,n;
 377     do
 378       {
 379        n=h->next;
 380        Free(h->mem);
 381        Free(h);
 382        h=n;
 383       }
 384     while(h);
 385    }
 386
 387  first=NULL;
 388  heap_left=0;
 389 }
 390
 391 /*+ The size of each of the heap allocations +*/
 392 #define HEAP_INC 8192
 393
 394 /*+ The size of a string that is large enough to have it's own mallocation. +*/
 395 #define SMALL_STRING 256
 396
 397 /*++++++++++++++++++++++++++++++++++++++
 398   A function to get some memory for a string, allocate a new heap structure if needed.
 399
 400   char* get_space Returns a pointer to enough space.
 401
 402   unsigned int l The amount of space that is needed.
 403   ++++++++++++++++++++++++++++++++++++++*/
 404
 405 static char* get_space(unsigned int l)
 406 {
 407  static Heap current=NULL;
 408  char* r=NULL;
 409
 410  if(l <= SMALL_STRING)
 411    {
 412     if(heap_left < l)
 413       {
 414        current=add_to_heap(HEAP_INC);
 415        heap_left=HEAP_INC;
 416       }
 417
 418     heap_left-=l;
 419
 420     r=&current->mem[heap_left]; /* Work downwards */
 421    }
 422  else
 423    {
 424     Heap h=add_to_heap(l);
 425     r=h->mem;
 426    }
 427
 428  return(r);
 429 }
 430
 431
 432 /*++++++++++++++++++++++++++++++++++++++
 433   Add some bytes to the privately maintained memory heap.
 434
 435   Heap add_to_heap Returns a pointer to the required memory.
 436
 437   unsigned int l The size of the memory that is required.
 438   ++++++++++++++++++++++++++++++++++++++*/
 439
 440 static Heap add_to_heap(unsigned int l)
 441 {
 442  Heap* h=&first;
 443
 444  while(*h)
 445     h=&(*h)->next;
 446
 447  *h=(Heap)Malloc(sizeof(struct _Heap));
 448  (*h)->next=NULL;
 449  (*h)->mem=(char*)Malloc(l);
 450
 451  return(*h);
 452 }