home *** CD-ROM | disk | FTP | other *** search
/ Media Share 9 / MEDIASHARE_09.ISO / cprog / newprt10.zip / MEM.H < prev    next >
C/C++ Source or Header  |  1991-03-28  |  7KB  |  241 lines
  1. /*_ mem.h   Fri May 26 1989   Modified by: Walter Bright */
  2. /* $Header: /proj/products/merlin/port/RCS/mem.h,v 1.11 89/10/23 11:39:00 bright Exp $ */
  3. /* Copyright 1986-1988 by Northwest Software    */
  4. /* All Rights Reserved              */
  5. /* Written by Walter Bright         */
  6.  
  7. #ifdef __cplusplus
  8. extern "C" {
  9. #endif
  10.  
  11. #ifndef MEM_H
  12. #define MEM_H    1
  13.  
  14. #ifndef TOOLKIT_H
  15. #include    "toolkit.h"
  16. #endif
  17.  
  18. /*
  19.  * Memory management routines.
  20.  *
  21.  * Compiling:
  22.  *
  23.  *    #define MEM_DEBUG 1 when compiling to enable extended debugging
  24.  *    features.
  25.  *
  26.  * Features always enabled:
  27.  *
  28.  *    o mem_init() is called at startup, and mem_term() at
  29.  *      close, which checks to see that the number of alloc's is
  30.  *      the same as the number of free's.
  31.  *    o Behavior on out-of-memory conditions can be controlled
  32.  *      via mem_setexception().
  33.  *
  34.  * Extended debugging features:
  35.  *
  36.  *    o Enabled by #define MEM_DEBUG 1 when compiling.
  37.  *    o Check values are inserted before and after the alloc'ed data
  38.  *      to detect pointer underruns and overruns.
  39.  *    o Free'd pointers are checked against alloc'ed pointers.
  40.  *    o Free'd storage is cleared to smoke out references to free'd data.
  41.  *    o Realloc'd pointers are always changed, and the previous storage
  42.  *      is cleared, to detect erroneous dependencies on the previous
  43.  *      pointer.
  44.  *    o The routine mem_checkptr() is provided to check an alloc'ed
  45.  *      pointer.
  46.  */
  47.  
  48. /********************* GLOBAL VARIABLES *************************/
  49.  
  50. extern int mem_inited;        /* != 0 if mem package is initialized.    */
  51.                 /* Test this if you have other packages    */
  52.                 /* that depend on mem being initialized    */
  53.  
  54. /********************* PUBLIC FUNCTIONS *************************/
  55.  
  56. /***********************************
  57.  * Set behavior when mem runs out of memory.
  58.  * Input:
  59.  *    flag =    MEM_ABORTMSG:    Abort the program with the message
  60.  *                'Fatal error: out of memory' sent
  61.  *                to stdout. This is the default behavior.
  62.  *        MEM_ABORT:    Abort the program with no message.
  63.  *        MEM_RETNULL:    Return NULL back to caller.
  64.  *        MEM_CALLFP:    Call application-specified function.
  65.  *                fp must be supplied.
  66.  *    fp            Optional function pointer. Supplied if
  67.  *                (flag == MEM_CALLFP). This function returns
  68.  *                MEM_XXXXX, indicating what mem should do next.
  69.  *                The function could do things like swap
  70.  *                data out to disk to free up more memory.
  71.  *    fp could also return:
  72.  *        MEM_RETRY:    Try again to allocate the space. Be
  73.  *                careful not to go into an infinite loop.
  74.  */
  75.  
  76. #if __ZTC__
  77. enum MEM_E { MEM_ABORTMSG, MEM_ABORT, MEM_RETNULL, MEM_CALLFP, MEM_RETRY };
  78. void mem_setexception P((enum MEM_E,...));
  79. #else
  80. #define MEM_ABORTMSG    0
  81. #define MEM_ABORT    1
  82. #define MEM_RETNULL    2
  83. #define MEM_CALLFP    3
  84. #define MEM_RETRY    4
  85. void mem_setexception P((int,...));
  86. #endif
  87.  
  88.  
  89. /****************************
  90.  * Allocate space for string, copy string into it, and
  91.  * return pointer to the new string.
  92.  * This routine doesn't really belong here, but it is used so often
  93.  * that I gave up and put it here.
  94.  * Use:
  95.  *    char *mem_strdup(const char *s);
  96.  * Returns:
  97.  *    pointer to copied string if succussful.
  98.  *    else returns NULL (if MEM_RETNULL)
  99.  */
  100.  
  101. char *mem_strdup P((const char *));
  102.  
  103. /**************************
  104.  * Function so we can have a pointer to function mem_free().
  105.  * This is needed since mem_free is sometimes defined as a macro,
  106.  * and then the preprocessor screws up.
  107.  * The pointer to mem_free() is used frequently with the list package.
  108.  * Use:
  109.  *    void mem_freefp(void *p);
  110.  */
  111.  
  112. /***************************
  113.  * Check for errors. This routine does a consistency check on the
  114.  * storage allocator, looking for corrupted data. It should be called
  115.  * when the application has CPU cycles to burn.
  116.  * Use:
  117.  *    void mem_check(void);
  118.  */
  119.  
  120. void mem_check P((void ));
  121.  
  122. /***************************
  123.  * Check ptr to see if it is in the range of allocated data.
  124.  * Cause assertion failure if it isn't.
  125.  */
  126.  
  127. void mem_checkptr P((void *ptr));
  128.  
  129. /***************************
  130.  * Allocate and return a pointer to numbytes of storage.
  131.  * Use:
  132.  *    void *mem_malloc(unsigned numbytes);
  133.  *    void *mem_calloc(unsigned numbytes); allocated memory is cleared
  134.  * Input:
  135.  *    numbytes    Number of bytes to allocate
  136.  * Returns:
  137.  *    if (numbytes > 0)
  138.  *        pointer to allocated data, NULL if out of memory
  139.  *    else
  140.  *        return NULL
  141.  */
  142.  
  143. void *mem_malloc P((unsigned));
  144. void *mem_calloc P((unsigned));
  145.  
  146. /*****************************
  147.  * Reallocate memory.
  148.  * Use:
  149.  *    void *mem_realloc(void *ptr,unsigned numbytes);
  150.  */
  151.  
  152. void *mem_realloc P((void *,unsigned));
  153.  
  154. /*****************************
  155.  * Free memory allocated by mem_malloc(), mem_calloc() or mem_realloc().
  156.  * Use:
  157.  *    void mem_free(void *ptr);
  158.  */
  159.  
  160. void mem_free P((void *));
  161.  
  162. /***************************
  163.  * Initialize memory handler.
  164.  * Use:
  165.  *    void mem_init(void);
  166.  * Output:
  167.  *    mem_inited = 1
  168.  */
  169.  
  170. void mem_init P((void ));
  171.  
  172. /***************************
  173.  * Terminate memory handler. Useful for checking for errors.
  174.  * Use:
  175.  *    void mem_term(void);
  176.  * Output:
  177.  *    mem_inited = 0
  178.  */
  179.  
  180. void mem_term P((void ));
  181.  
  182. /*******************************
  183.  * Allocate memory and clear it.
  184.  * This routine is special in that no overhead is kept for what
  185.  * the size of the allocated block is. Thus, the application needs
  186.  * too keep track of that. Free only with mem_sfree().
  187.  */
  188.  
  189. #if MEM_DEBUG || !__ZTC__
  190. #define mem_scalloc mem_calloc
  191. #else
  192. void *mem_scalloc P((size_t numbytes));
  193. #endif
  194.  
  195. /*******************************
  196.  * Free memory allocated with mem_scalloc().
  197.  * Input:
  198.  *    ptr    value returned by mem_scalloc().
  199.  *    numbytes    size (must be same value as passed to mem_scalloc())
  200.  */
  201.  
  202. #if MEM_DEBUG || !__ZTC__
  203. #define mem_sfree(ptr,size) mem_free(ptr)
  204. #else
  205. void mem_sfree P((void *ptr, size_t numbytes));
  206. #endif
  207.  
  208. /* The following stuff forms the implementation rather than the
  209.  * definition, so ignore it.
  210.  */
  211.  
  212. #if MEM_DEBUG        /* if creating debug version    */
  213. #define mem_strdup(p)    mem_strdup_debug((p),__FILE__,__LINE__)
  214. #define mem_malloc(u)    mem_malloc_debug((u),__FILE__,__LINE__)
  215. #define mem_calloc(u)    mem_calloc_debug((u),__FILE__,__LINE__)
  216. #define mem_realloc(p,u)    mem_realloc_debug((p),(u),__FILE__,__LINE__)
  217. #define mem_free(p)    mem_free_debug((p),__FILE__,__LINE__)
  218.  
  219. char *mem_strdup_debug    P((const char *,char *,int));
  220. void *mem_calloc_debug    P((unsigned,char *,int));
  221. void *mem_malloc_debug    P((unsigned,char *,int));
  222. void *mem_realloc_debug P((void *,unsigned,char *,int));
  223. void  mem_free_debug    P((void *,char *,int));
  224. void  mem_freefp    P((void *));
  225.  
  226. void mem_setnewfileline P((void *,char *,int));
  227.  
  228. #else
  229.  
  230. #define mem_freefp    mem_free
  231. #define mem_check()
  232. #define mem_checkptr(p)
  233.  
  234. #endif /* MEM_DEBUG */
  235.  
  236. #endif /* MEM_H */
  237.  
  238. #ifdef __cplusplus
  239. }
  240. #endif
  241.