summaryrefslogtreecommitdiff
path: root/reference/C/CONTRIB/SNIP/mem.h
diff options
context:
space:
mode:
Diffstat (limited to 'reference/C/CONTRIB/SNIP/mem.h')
-rwxr-xr-xreference/C/CONTRIB/SNIP/mem.h212
1 files changed, 212 insertions, 0 deletions
diff --git a/reference/C/CONTRIB/SNIP/mem.h b/reference/C/CONTRIB/SNIP/mem.h
new file mode 100755
index 0000000..d40ad25
--- /dev/null
+++ b/reference/C/CONTRIB/SNIP/mem.h
@@ -0,0 +1,212 @@
+/*
+** This is a copyrighted work which is functionally identical to work
+** originally published in Micro Cornucopia magazine (issue #52, March-April,
+** 1990) and is freely licensed by the author, Walter Bright, for any use.
+*/
+
+/*_ mem.h Fri May 26 1989 Modified by: Walter Bright */
+/* $Header: /home/cvs/c_cpp_reference/reference/C/CONTRIB/SNIP/mem.h,v 1.1.1.1 2000/02/24 23:01:19 tasin Exp $ */
+/* Copyright 1986-1988 by Northwest Software */
+/* All Rights Reserved */
+/* Written by Walter Bright */
+
+#ifndef MEM_H
+#define MEM_H 1
+
+#ifndef TOOLKIT_H
+#include "toolkit.h"
+#endif
+
+/*
+ * Memory management routines.
+ *
+ * Compiling:
+ *
+ * #define MEM_DEBUG 1 when compiling to enable extended debugging
+ * features.
+ *
+ * Features always enabled:
+ *
+ * o mem_init() is called at startup, and mem_term() at
+ * close, which checks to see that the number of alloc's is
+ * the same as the number of free's.
+ * o Behavior on out-of-memory conditions can be controlled
+ * via mem_setexception().
+ *
+ * Extended debugging features:
+ *
+ * o Enabled by #define MEM_DEBUG 1 when compiling.
+ * o Check values are inserted before and after the alloc'ed data
+ * to detect pointer underruns and overruns.
+ * o Free'd pointers are checked against alloc'ed pointers.
+ * o Free'd storage is cleared to smoke out references to free'd data.
+ * o Realloc'd pointers are always changed, and the previous storage
+ * is cleared, to detect erroneous dependencies on the previous
+ * pointer.
+ * o The routine mem_checkptr() is provided to check an alloc'ed
+ * pointer.
+ */
+
+/********************* GLOBAL VARIABLES *************************/
+
+extern int mem_inited; /* != 0 if mem package is initialized. */
+ /* Test this if you have other packages */
+ /* that depend on mem being initialized */
+
+/********************* PUBLIC FUNCTIONS *************************/
+
+/***********************************
+ * Set behavior when mem runs out of memory.
+ * Input:
+ * flag = MEM_ABORTMSG: Abort the program with the message
+ * 'Fatal error: out of memory' sent
+ * to stdout. This is the default behavior.
+ * MEM_ABORT: Abort the program with no message.
+ * MEM_RETNULL: Return NULL back to caller.
+ * MEM_CALLFP: Call application-specified function.
+ * fp must be supplied.
+ * fp Optional function pointer. Supplied if
+ * (flag == MEM_CALLFP). This function returns
+ * MEM_XXXXX, indicating what mem should do next.
+ * The function could do things like swap
+ * data out to disk to free up more memory.
+ * fp could also return:
+ * MEM_RETRY: Try again to allocate the space. Be
+ * careful not to go into an infinite loop.
+ */
+
+#if __cplusplus
+enum MEM_E { MEM_ABORTMSG, MEM_ABORT, MEM_RETNULL, MEM_CALLFP, MEM_RETRY };
+void mem_setexception P((enum MEM_E, int (*)()));
+#else
+#define MEM_ABORTMSG 0
+#define MEM_ABORT 1
+#define MEM_RETNULL 2
+#define MEM_CALLFP 3
+#define MEM_RETRY 4
+void mem_setexception P((int, int(*)()));
+#endif
+
+
+/****************************
+ * Allocate space for string, copy string into it, and
+ * return pointer to the new string.
+ * This routine doesn't really belong here, but it is used so often
+ * that I gave up and put it here.
+ * Use:
+ * char *mem_strdup(const char *s);
+ * Returns:
+ * pointer to copied string if succussful.
+ * else returns NULL (if MEM_RETNULL)
+ */
+
+char *mem_strdup P((const char *));
+
+/**************************
+ * Function so we can have a pointer to function mem_free().
+ * This is needed since mem_free is sometimes defined as a macro,
+ * and then the preprocessor screws up.
+ * The pointer to mem_free() is used frequently with the list package.
+ * Use:
+ * void mem_freefp(void *p);
+ */
+
+/***************************
+ * Check for errors. This routine does a consistency check on the
+ * storage allocator, looking for corrupted data. It should be called
+ * when the application has CPU cycles to burn.
+ * Use:
+ * void mem_check(void);
+ */
+
+void mem_check P((void ));
+
+/***************************
+ * Check ptr to see if it is in the range of allocated data.
+ * Cause assertion failure if it isn't.
+ */
+
+void mem_checkptr P((void *ptr));
+
+/***************************
+ * Allocate and return a pointer to numbytes of storage.
+ * Use:
+ * void *mem_malloc(unsigned numbytes);
+ * void *mem_calloc(unsigned numbytes); allocated memory is cleared
+ * Input:
+ * numbytes Number of bytes to allocate
+ * Returns:
+ * if (numbytes > 0)
+ * pointer to allocated data, NULL if out of memory
+ * else
+ * return NULL
+ */
+
+void *mem_malloc P((unsigned));
+void *mem_calloc P((unsigned));
+
+/*****************************
+ * Reallocate memory.
+ * Use:
+ * void *mem_realloc(void *ptr,unsigned numbytes);
+ */
+
+void *mem_realloc P((void *,unsigned));
+
+/*****************************
+ * Free memory allocated by mem_malloc(), mem_calloc() or mem_realloc().
+ * Use:
+ * void mem_free(void *ptr);
+ */
+
+void mem_free P((void *));
+
+/***************************
+ * Initialize memory handler.
+ * Use:
+ * void mem_init(void);
+ * Output:
+ * mem_inited = 1
+ */
+
+void mem_init P((void ));
+
+/***************************
+ * Terminate memory handler. Useful for checking for errors.
+ * Use:
+ * void mem_term(void);
+ * Output:
+ * mem_inited = 0
+ */
+
+void mem_term P((void ));
+
+/* The following stuff forms the implementation rather than the
+ * definition, so ignore it.
+ */
+
+#if MEM_DEBUG /* if creating debug version */
+#define mem_strdup(p) mem_strdup_debug((p),__FILE__,__LINE__)
+#define mem_malloc(u) mem_malloc_debug((u),__FILE__,__LINE__)
+#define mem_calloc(u) mem_calloc_debug((u),__FILE__,__LINE__)
+#define mem_realloc(p,u) mem_realloc_debug((p),(u),__FILE__,__LINE__)
+#define mem_free(p) mem_free_debug((p),__FILE__,__LINE__)
+
+char *mem_strdup_debug P((const char *,char *,int));
+void *mem_calloc_debug P((unsigned,char *,int));
+void *mem_malloc_debug P((unsigned,char *,int));
+void *mem_realloc_debug P((void *,unsigned,char *,int));
+void mem_free_debug P((void *,char *,int));
+void mem_freefp P((void *));
+
+void mem_setnewfileline P((void *,char *,int));
+
+#else
+
+#define mem_freefp mem_free
+#define mem_check()
+#define mem_checkptr(p)
+
+#endif /* MEM_DEBUG */
+
+#endif /* MEM_H */