home *** CD-ROM | disk | FTP | other *** search
/ Frozen Fish 1: Amiga / FrozenFish-Apr94.iso / bbs / alib / d3xx / d386 / xlispstat.lha / XLispStat / src1.lzh / IView / stmem.c < prev   
Encoding:
C/C++ Source or Header  |  1990-10-04  |  4.4 KB  |  201 lines
  1. /* stmem.c - memory allocation routines.                               */
  2. /* XLISP-STAT 2.1 Copyright (c) 1990, by Luke Tierney                  */
  3. /* Additions to Xlisp 2.1, Copyright (c) 1989 by David Michael Betz    */
  4. /* You may give out copies of this software; for conditions see the    */
  5. /* file COPYING included with this distribution.                       */
  6.  
  7. #include <stdlib.h>
  8. #include "xlisp.h"
  9. #include "osdef.h"
  10. #ifdef ANSI
  11. #include "xlproto.h"
  12. #include "xlsproto.h"
  13. #include "iviewproto.h"
  14. #include "Stproto.h"
  15. #include "osproto.h"
  16. #else
  17. #include "xlfun.h"
  18. #include "xlsfun.h"
  19. #include "iviewfun.h"
  20. #include "Stfun.h"
  21. #include "osfun.h"
  22. #endif ANSI
  23.  
  24. #ifdef MACINTOSH
  25. #ifdef MPWC
  26. # include <Memory.h>
  27. # define MemErr MemError()
  28. #else
  29. # undef TRUE
  30. # undef FALSE
  31. # include <MemoryMgr.h>
  32. #endif MPWC
  33. #endif MACINTOSH
  34.  
  35. #define nil 0L
  36.  
  37. /**************************************************************************/
  38. /**                                                                      **/
  39. /**             Error Message and Memory Allocation Functions            **/
  40. /**                                                                      **/
  41. /**************************************************************************/
  42.  
  43. void StPerror(s)
  44.     char *s;
  45. {
  46.   xlfail(s);
  47. }
  48.  
  49. /*char*/void *StCalloc(n, m) /* changed JKL */
  50.     int n, m;
  51. {
  52.   char *val;
  53.  
  54.   if ((val = calloc(n, m)) == nil) {
  55.     gc();
  56.     if ((val = calloc(n, m)) == nil)
  57.       StPerror("allocation failed");
  58.   }
  59.   return(val);
  60. }
  61.  
  62. void StFree(p)
  63.     /*char*/ void *p; /* changed JKL */
  64. {
  65.   if (p != nil) free(p);
  66. }
  67.  
  68. /**************************************************************************/
  69. /**                                                                      **/
  70. /**                  Reallocatable Data Pointer Package                  **/
  71. /**                                                                      **/
  72. /**  (This is needed on the Mac because the realloc function does not    **/
  73. /**          work and also to help reduce heap fragmentation.)           **/
  74. /**                                                                      **/
  75. /**************************************************************************/
  76. /*  in iviewdef.h JKL
  77. #ifdef MACINTOSH
  78. typedef char **StReallocData;
  79. #else
  80. typedef struct{
  81.   int size;
  82.   char *data;
  83. } realloc_data, *StReallocData;
  84. #endif MACINTOSH
  85. */
  86. StReallocData StRCalloc(n, m)
  87.     int n, m;
  88. {
  89. #ifdef MACINTOSH
  90.   Handle h;
  91.   long size;
  92.   char *p;
  93.   
  94.   size = ((long) n) * ((long) m);
  95.   if ((h = NewHandle(size)) == nil || MemErr) {
  96.     gc();
  97.     if ((h = NewHandle(size)) == nil || MemErr) 
  98.       StPerror("Allocation Failed");
  99.   }
  100.   for (p = (char *) *h; size > 0; *p++ = 0, size--);
  101.   return ((StReallocData) h);
  102. #else
  103.   StReallocData r;
  104.  
  105.   r = (StReallocData) StCalloc(sizeof(realloc_data), 1);
  106.   r->size = n * m;
  107.   r->data = StCalloc(r->size, 1);
  108.   return(r);
  109. #endif MACINTOSH
  110. }
  111.  
  112. void StRFree(d)
  113.      StReallocData d;
  114. {
  115. #ifdef MACINTOSH
  116.   if (d != nil) DisposHandle(d);
  117. #else
  118.   if (d != nil) {
  119.     StFree(d->data);
  120.     StFree(d);
  121.   }
  122. #endif MACINTOSH
  123.  
  124. }
  125.  
  126. StReallocData StRRealloc(d, n, m)
  127.     StReallocData d;
  128.     int n, m;
  129. {
  130. #ifdef MACINTOSH
  131.   long oldSize, newSize, i;
  132.   char *p;
  133.   
  134.   oldSize = (d != nil) ? GetHandleSize(d) : 0;
  135.   newSize = (long) n * (long) m;
  136.   
  137.   if (d == nil) d = (StReallocData) NewHandle(newSize);
  138.   else SetHandleSize(d, newSize);
  139.   if (d == nil || MemErr) StPerror("Allocation Failed");
  140.   
  141.   for (p = (char *) *d, i = oldSize; i < newSize; p[i] = 0, i++);
  142.   
  143.   return (d);
  144. #else
  145.   int oldsize, size;
  146.   
  147.   if (d == nil) {
  148.     d = StRCalloc(n, m);
  149. /*    if (d == nil) StPerror("Allocation Failed"); no longer necessary JKL */
  150.   }
  151.   else {
  152.     size = n * m;
  153.     d->data = realloc(d->data, size);
  154. /*    if (d->data == nil) StPerror("Allocation Failed"); no longer necessary JKL */
  155.     oldsize = d->size;
  156.     d->size = size;
  157.     if (size > oldsize) {
  158.       bzero(d->data + oldsize, size - oldsize);
  159.     }
  160.   }
  161.   return(d);
  162. #endif MACINTOSH
  163. }
  164.  
  165. long StRSize(d)
  166.     StReallocData d;
  167. {
  168. #ifdef MACINTOSH
  169.   return ((d != nil) ? GetHandleSize(d) : 0L);
  170. #else
  171.   return((d != nil) ? d->size : 0);
  172. #endif MACINTOSH
  173. }
  174.  
  175. /*char*/ void *StRPtr(d)
  176.     StReallocData d;
  177. {
  178. #ifdef MACINTOSH
  179.   return ((d != nil) ? (char *) *d : nil);
  180. #else
  181.   if (d != nil && d->data == nil) xlfail("bad relocatable data");
  182.   return((d != nil) ? d->data : nil);
  183. #endif MACINTOSH
  184. }
  185.  
  186. void StRLock(d)
  187.     StReallocData d;
  188. {
  189. #ifdef MACINTOSH
  190.   HLock(d);
  191. #endif MACINTOSH
  192. }
  193.  
  194. void StRUnlock(d)
  195.     StReallocData d;
  196. {
  197. #ifdef MACINTOSH
  198.   HUnlock(d);
  199. #endif MACINTOSH
  200. }
  201.