home *** CD-ROM | disk | FTP | other *** search
/ Enigma Amiga Life 110 / EnigmaAmiga110CD.iso / indispensabili / utility / apdf / xpdf-0.80 / goo / gmem.cc < prev    next >
C/C++ Source or Header  |  1999-04-11  |  4KB  |  187 lines
  1. /*
  2.  * gmem.cc
  3.  *
  4.  * Memory routines with out-of-memory checking.
  5.  *
  6.  * Copyright 1996 Derek B. Noonburg
  7.  *
  8.  * EL: replaced exit() calls by exceptions.
  9.  */
  10.  
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <stddef.h>
  14. #include <string.h>
  15. #include "gmem.h"
  16.  
  17. #ifdef __SASC
  18. #define throw(x) (fprintf(stderr,"Exception: %s\n",(x)),exit(EXIT_FAILURE));
  19. #endif
  20.  
  21. #ifdef DEBUG_MEM
  22. typedef struct _GMemHdr {
  23.   int size;
  24.   int index;
  25.   struct _GMemHdr *next;
  26. } GMemHdr;
  27.  
  28. #define gMemHdrSize ((sizeof(GMemHdr) + 7) & ~7)
  29. #define gMemTrlSize (sizeof(long))
  30.  
  31. #if gmemTrlSize==8
  32. #define gMemDeadVal 0xdeadbeefdeadbeef
  33. #else
  34. #define gMemDeadVal 0xdeadbeef
  35.  
  36. /* round data size so trailer will be aligned */
  37. #define gMemDataSize(size) \
  38.   ((((size) + gMemTrlSize - 1) / gMemTrlSize) * gMemTrlSize)
  39.  
  40. #endif
  41.  
  42. static GMemHdr *gMemList = NULL;
  43. static int gMemIndex = 0;
  44. static int gMemAlloc = 0;
  45. #endif
  46.  
  47. void *gmalloc(int size) {
  48. #if DEBUG_MEM
  49.   int size1;
  50.   char *mem;
  51.   GMemHdr *hdr;
  52.   void *data;
  53.   long *trl, *p;
  54.  
  55.   if (size == 0)
  56.     return NULL;
  57.   size1 = gMemDataSize(size);
  58.   if (!(mem = (char *)malloc(size1 + gMemHdrSize + gMemTrlSize))) {
  59.     fprintf(stderr, "Out of memory\n");
  60.     throw "Out of memory";//exit(1);
  61.   }
  62.   hdr = (GMemHdr *)mem;
  63.   data = (void *)(mem + gMemHdrSize);
  64.   trl = (long *)(mem + gMemHdrSize + size1);
  65.   hdr->size = size;
  66.   hdr->index = gMemIndex++;
  67.   hdr->next = gMemList;
  68.   gMemList = hdr;
  69.   ++gMemAlloc;
  70.   for (p = (long *)data; p <= trl; ++p)
  71.     *p = gMemDeadVal;
  72.   return data;
  73. #else
  74.   void *p;
  75.  
  76.   if (size == 0)
  77.     return NULL;
  78.   if (!(p = malloc(size))) {
  79.     throw("Out of memory");
  80.   }
  81.   return p;
  82. #endif
  83. }
  84.  
  85. void *grealloc(void *p, int size) {
  86. #if DEBUG_MEM
  87.   GMemHdr *hdr;
  88.   void *q;
  89.   int oldSize;
  90.  
  91.   if (size == 0) {
  92.     if (p)
  93.       gfree(p);
  94.     return NULL;
  95.   }
  96.   if (p) {
  97.     hdr = (GMemHdr *)((char *)p - gMemHdrSize);
  98.     oldSize = hdr->size;
  99.     q = gmalloc(size);
  100.     memcpy(q, p, size < oldSize ? size : oldSize);
  101.     gfree(p);
  102.   } else {
  103.     q = gmalloc(size);
  104.   }
  105.   return q;
  106. #else
  107.   void *q;
  108.  
  109.   if (size == 0) {
  110.     if (p)
  111.       free(p);
  112.     return NULL;
  113.   }
  114.   if (p)
  115.     q = realloc(p, size);
  116.   else
  117.     q = malloc(size);
  118.   if (!q) {
  119.     throw("Out of memory");
  120.   }
  121.   return q;
  122. #endif
  123. }
  124.  
  125. void gfree(void *p) {
  126. #ifdef DEBUG_MEM
  127.   int size;
  128.   GMemHdr *hdr;
  129.   GMemHdr *prevHdr, *q;
  130.   long *trl, *clr;
  131.  
  132.   if (p) {
  133.     hdr = (GMemHdr *)((char *)p - gMemHdrSize);
  134.     for (prevHdr = NULL, q = gMemList; q; prevHdr = q, q = q->next) {
  135.       if (q == hdr)
  136.     break;
  137.     }
  138.     if (q) {
  139.       if (prevHdr)
  140.     prevHdr->next = hdr->next;
  141.       else
  142.     gMemList = hdr->next;
  143.       --gMemAlloc;
  144.       size = gMemDataSize(hdr->size);
  145.       trl = (long *)((char *)hdr + gMemHdrSize + size);
  146.       if (*trl != gMemDeadVal) {
  147.     fprintf(stderr, "Overwrite past end of block %d at address %p\n",
  148.         hdr->index, p);
  149.       }
  150.       for (clr = (long *)hdr; clr <= trl; ++clr)
  151.     *clr = gMemDeadVal;
  152.       free(hdr);
  153.     } else {
  154.       fprintf(stderr, "Attempted to free bad address %p\n", p);
  155.     }
  156.   }
  157. #else
  158.   if (p)
  159.     free(p);
  160. #endif
  161. }
  162.  
  163. #ifdef DEBUG_MEM
  164. void gMemReport(FILE *f) {
  165.   GMemHdr *p;
  166.  
  167.   fprintf(f, "%d memory allocations in all\n", gMemIndex);
  168.   if (gMemAlloc > 0) {
  169.     fprintf(f, "%d memory blocks left allocated:\n", gMemAlloc);
  170.     fprintf(f, " index     size\n");
  171.     fprintf(f, "-------- --------\n");
  172.     for (p = gMemList; p; p = p->next)
  173.       fprintf(f, "%8d %8d\n", p->index, p->size);
  174.   } else {
  175.     fprintf(f, "No memory blocks left allocated\n");
  176.   }
  177. }
  178. #endif
  179.  
  180. char *copyString(char *s) {
  181.   char *s1;
  182.  
  183.   s1 = (char *)gmalloc(strlen(s) + 1);
  184.   strcpy(s1, s);
  185.   return s1;
  186. }
  187.