Just that (for Matlab).zip

/* 19 Dec 94 - 15 Sept 95 - 12 June 98 Alain de Cheveigne, LLF, CNRS/Universite Paris 7. Debugging wrapper for malloc() functions. */ #define MWRAP_C #define MWRAP #include "mwrap.h" void mexErrMsgTxt( const char *error_msg ); #define GROWSIZE 8192 * 10 /* number of nodes preallocated in node pool. Each node is 20 bytes. */ /* #define NL fprintf(stderr,"\n"); #define DOT fprintf(stderr,"."); #define DASH fprintf(stderr,"-"); #define OK \ {fprintf(stderr, "%s<%d> ", __FILE__, __LINE__);\ fprintf(stderr,"OK\n");} */ #define DIE(s) do {char c[100]; sprintf(c, "%d %s ", mwrap_line, s); mexErrMsgTxt(c);} while(0) #define DIE1(s,v1) do {char c[100]; sprintf(c, "%d %s", mwrap_line, s); mexErrMsgTxt(c);} while(0) #define DIE2(s,v1,v2) do {char c[100]; sprintf(c, "%d %s", mwrap_line, s); mexErrMsgTxt(c);} while(0) #define DIE3(s,v1,v2,v3) do {char c[100]; sprintf(c, "%d %s", mwrap_line, s); mexErrMsgTxt(c);} while(0) #define PRINT3(string, v1, v2, v3) mexErrMsgTxt((string)); /* #define DIE(s) \ do {fprintf(stderr, "%s/%d: ", mwrap_file, mwrap_line);\ fprintf(stderr, (s)); fprintf(stderr, "\n"); exit(1);} \ while (0) #define DIE1(s, value) \ do {fprintf(stderr, "%s/%d: ", mwrap_file, mwrap_line);\ fprintf(stderr, (s), (value)); fprintf(stderr, "\n"); exit(1);} \ while (0) #define DIE2(s, v1,v2) \ do {fprintf(stderr, "%s/%d: ", mwrap_file, mwrap_line);\ fprintf(stderr, s, (v1),(v2)); fprintf(stderr, "\n"); exit(1);} \ while (0) #define DIE3(s,v1,v2,v3) \ do {fprintf(stderr, "%s/%d: ", mwrap_file, mwrap_line);\ fprintf(stderr, s, (v1), (v2), (v3)); \ fprintf(stderr, "\n"); exit(1);} while (0) #define PRINT3(string, v1, v2, v3) do {fprintf(stderr,string, v1,v2,v3);} \ while(0) */ #define NOK(n) mwrap_checknode(n); /* MWRAP_SPLAY() defined as a macro to allow slightly faster splaying, especially when the node is already root or next to root */ #define MWRAP_SPLAY(n) do { \ mwrap_node father; \ father = (n)->up; \ while (father) { \ if (!father->up) MWRAP_SINGLE_ROTATE(n); \ else MWRAP_DOUBLE_ROTATE(n); \ father = (n)->up; \ } \ } while (0); #define MWRAP_SINGLE_ROTATE(n) do { \ mwrap_node p, B; \ p = (n)->up; \ if (p->left == (n)) { \ B = (n)->right; (n)->right = p; \ p->left = B; if (B) B->up = p; \ } else { \ B = (n)->left; (n)->left = p; \ p->right = B; if (B) B->up = p; \ } \ p->up = (n); \ n->up = NULL; \ } while (0) #define MWRAP_DOUBLE_ROTATE(n) mwrap_double_rotate(n) /* update lowest and highest known stack address */ #define STACK(p) do {\ if (mwrap_stack_lo>(char *)(p)) mwrap_stack_lo=(char *)(p); \ if (mwrap_stack_hi<(char *)(p)) mwrap_stack_hi=(char *)(p); \ } while (0) static void mwrap_register(char *lo, char *hi); static void mwrap_delete(mwrap_node n); static mwrap_node mwrap_leftmost(mwrap_node tree); static void mwrap_checksub(mwrap_node tree, char *low, char *high); static mwrap_node mwrap_newnode(); static void mwrap_freenode(mwrap_node n) ; static void mwrap_single_rotate(mwrap_node n); static void mwrap_double_rotate(mwrap_node n); static void mwrap_splay(mwrap_node n); static void mwrap_check_stack(char *p); /* check if pointer to stack */ static char *heap_lowest; /* lowest address so far */ static char *heap_highest; /* highest address so far +1 */ static mwrap_node tree_lowest; /* lowest address used by tree */ static mwrap_node tree_highest; /* highest address used by tree +1 */ void mwrap_checktree(char *file, long line); /* global variables */ mwrap_node mwrap_tree = NULL; /* the tree */ char *mwrap_file; /* caller source file */ long mwrap_line; /* line in caller source file */ char *mwrap_stack_lo = (char *) -1; /* lowest known stack address */ char *mwrap_stack_hi = (char *) -1; /* highest known stack address */ /* Mwrap wraps the four basic malloc routines: malloc, calloc , realloc, free. If you wish it to handle more exotic routines, turn on the following switches. */ #define MWRAP_CFREE /* cfree() */ #define MWRAP_VMALLOC /* vmalloc() */ #define MWRAP_VFREE /* vfree() */ /* #define MWRAP_MEMALIGN /* memalign */ /* wrappers for routines of the malloc family */ /* malloc */ DATATYPE *mwrap_malloc(SIZETYPE size, char *file, long line) { DATATYPE *p; int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; p = malloc(size); if (!p) DIE1("malloc failed (size=%d)", size); /* check for negative size or overflow */ if ((char *) p > (char *) p+size) DIE1("malloc called with size = %d", size); mwrap_register((char *) p, ((char *) p + size)); return p; } /* free */ VOIDTYPE mwrap_free(DATATYPE *p, char *file, long line) { int dummy; STACK(&dummy); /*fprintf(stderr, "%#x\n", p); */ mwrap_file = file; mwrap_line = line; mwrap_bok(p, file, line); /* side effect: node is root of mwrap_tree */ mwrap_delete(mwrap_tree); /* delete that node */ free(p); } /* realloc */ DATATYPE *mwrap_realloc(DATATYPE *p, SIZETYPE size, char *file, long line) { int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; mwrap_bok(p, file, line); /* side effect: node is root of mwrap_tree */ mwrap_delete(mwrap_tree); /* delete that node */ p = realloc(p, size); if (!p) DIE1("ralloc failed (size=%d)", size); if ((char *) p > (char *) p+size) DIE1("realloc called with size = %d", size); mwrap_register((char *) p, (char *) p + size); return p; } /* calloc */ DATATYPE *mwrap_calloc(SIZETYPE n, SIZETYPE size, char *file, long line) { DATATYPE *p; int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; if (size <= 0) DIE1("calloc called with size = %d", size); p = calloc(n, size); if (!p) DIE2("calloc failed (n=%d, size=%d)", n, size); mwrap_register((char *) p, (char *) p + n*size); return p; } /* cfree */ #ifdef MWRAP_CFREE VOIDTYPE mwrap_cfree(DATATYPE *p, char *file, long line) { int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; mwrap_bok(p, file, line); /* side effect: node is root of mwrap_tree */ mwrap_delete(mwrap_tree); /* cfree(p); */ free(p); } #endif /* valloc */ #ifdef MWRAP_VALLOC DATATYPE *mwrap_valloc(SIZETYPE size, char *file, long line) { DATATYPE *p; int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; p = (DATATYPE *) valloc(size); if (!p) DIE1("valloc failed (size=%d)", size); if ((char *) p > (char *p) p+size) DIE1("valloc called with size = %d", size); mwrap_register((char *) p, (char *) p + size); return p; } #endif /* vfree */ #ifdef MWRAP_VFREE VOIDTYPE mwrap_vfree(DATATYPE *p, char *file, long line) { int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; mwrap_bok(p, file, line); /* side effect: node is root of mwrap_tree */ mwrap_delete(mwrap_tree); /* vfree(p); */ free(p); } #endif /* memalign */ #ifdef MWRAP_MEMALIGN DATATYPE *mwrap_memalign(SIZETYPE alignment, SIZETYPE size, char *file, long line) { DATATYPE *p; int dummy; STACK(&dummy); mwrap_file = file; mwrap_line = line; p = (DATATYPE *) memalign(alignment, size); /* dunno why I need the cast... */ if (!p) DIE2("memalign failed (alignment=%d, size=%d)", alignment, size); if ((char *) p > (char *p) p+size) DIE1("memalign called with size = %d", size); mwrap_register((char *) p, (char *) p + size); return p; } #endif /* unwrapped versions */ DATATYPE *nowrap_malloc(SIZETYPE size) { return malloc(size); } /* free */ VOIDTYPE nowrap_free(DATATYPE *p) { free(p); } /* realloc */ DATATYPE *nowrap_realloc(DATATYPE *p, SIZETYPE size) { return realloc(p, size); } /* calloc */ DATATYPE *nowrap_calloc(SIZETYPE n, SIZETYPE size) { return calloc(n, size); } /* cfree */ #ifdef MWRAP_CFREE VOIDTYPE nowrap_cfree(DATATYPE *p) { /