home *** CD-ROM | disk | FTP | other *** search
/ Photo CD Demo 1 / Demo.bin / gle / gle / memory.c < prev    next >
C/C++ Source or Header  |  1992-11-29  |  2KB  |  139 lines
  1. #include "all.h"
  2. #ifndef __TURBOC__
  3. #define farcalloc calloc
  4. #else
  5. #include <alloc.h>
  6. #endif
  7. #ifdef unix
  8. #include <malloc.h>
  9. #endif
  10. extern char errgle[];
  11. int free_savemem(void);
  12. char *sdup(char *s)
  13. {
  14.     char *v;
  15.     v = myalloc(strlen(s)+1);
  16.     strcpy(v,s);
  17.     return v;
  18. }
  19. char *save_memory;
  20. free_savemem()
  21. {
  22.     if (save_memory!=NULL) free(save_memory);
  23.     save_memory = 0;
  24. }
  25. init_memory()
  26. {
  27.     save_memory = malloc(1000);
  28.     if (save_memory == NULL) gle_abort("Not able to allocate save memory\n");
  29. }
  30. static long totalmem,worst;
  31. void myfree(void *p)
  32. {
  33.     myfrees(p,"UNKNOWN");
  34. }
  35. void myfrees(void *p,char *s)
  36. {
  37.     static long *l;
  38.     l = p;
  39.     totalmem -= *(--l);
  40.     if (*(--l)!=1234) {
  41.         sprintf(errgle,"Free memory (%s) not mine %ld  %ld \n",s,*l,*(++l));
  42.         gle_abort(errgle);
  43.     }
  44.     free(l);
  45.     return;
  46. }
  47. void *myallocn(long nitems,long size)
  48. {
  49.     return myallocz(nitems*size);
  50. }
  51. void *myalloc(long size)
  52. {
  53.     static void *p;
  54.     static long *l;
  55.     if (size==0) {
  56.         sprintf(errgle," error, attempt to allocate ZERO memory \n");
  57.         gle_abort(errgle);
  58.     }
  59.     if (size>40000) gprint(" allocating a lot of memory %d \n",size);
  60.     p = malloc(size+8);
  61.     if (p==NULL) {
  62.         freeafont();
  63.         p = malloc(size+8);
  64.         if (p==NULL) {
  65.          free_savemem();
  66.          sprintf(errgle,"\n Memory allocation failure (size %d)  \n"
  67.             ,size);
  68.          gle_abort(errgle);
  69.         }
  70.     }
  71.     l = p;
  72.     *l++ = 1234;
  73.     *l = size+8;
  74.     totalmem += *l;
  75.     if (totalmem>worst) worst = totalmem;
  76.     p = ++l;
  77.     return p;
  78. }
  79. void *myallocz(long size)
  80. {
  81.     static void *p;
  82.     static long *l;
  83.     if (size==0) {
  84.         free_savemem();
  85.         sprintf(errgle," zerror, attempt to allocate ZERO memory \n");
  86.         gle_abort(errgle);
  87.     }
  88.     if (size>40000) {
  89.       gprint("(z) allocating a lot of memory %ld \n",size);
  90.     }
  91.     p = farcalloc(1,size+8);
  92. /*    p = farcalloc((size+8)/4,4);*/
  93.     if (p==NULL) {
  94.        freeafont();
  95.        p = farcalloc(1,size+8);
  96. /*        if (p==NULL) {
  97.         free_cache();
  98.         gprint("Freeing cached characters\n");
  99.         p = farcalloc(1,size+8);
  100.        }
  101. */
  102.        if (p==NULL) {
  103.         free_savemem();
  104.         sprintf(errgle,"\n\n (z) Memory allocation failure %d  \n\n"
  105.             ,size);
  106.         gle_abort(errgle);
  107.        }
  108.     }
  109.     l = p;
  110.     *l++ = 1234;
  111.     *l = size+8;
  112.     totalmem += *l;
  113.     if (totalmem>worst) worst = totalmem;
  114.     p = ++l;
  115.     return p;
  116. }
  117. long mem_total()
  118. {
  119.     return totalmem;
  120. }
  121. long mem_worst()
  122. {
  123.     return worst;
  124. }
  125.  
  126. long gtotalmem;
  127. #ifdef __TURBOC__
  128. #include <alloc.h>
  129. void far * far _graphgetmem(unsigned size)
  130. {
  131.     return(myalloc(size));
  132. }
  133. void far _graphfreemem(void far *ptr, unsigned size)
  134. {
  135.     myfree(ptr);
  136. }
  137.  
  138. #endif
  139.