view Code/Descriptors/yin/private/src/mwrap.h @ 4:92ca03a8fa99 tip

Update to ICASSP 2013 benchmark

/* 
19 Dec 94 - Sept 95
Alain de Cheveigne, LLF, CNRS/Universite Paris 7.
Modified: Sept 2000

file mwrap.h

To use the malloc wrappers: 
- include this file in all source files that call malloc routines, 
- link with mwrap.o,
- compile all files with -DMWRAP to turn on wrapping and checking. 

*/

#ifndef MWRAP_H
#define MWRAP_H

#include <stdio.h>
#include <stdlib.h>

/* NOTE: (char *) is used for pointer arithmetic.  
   Pointer arguments of all macros are cast to (char *). */

/* node structure for binary splay tree */
typedef struct mwrap_node_struct *mwrap_node ;
struct mwrap_node_struct {
  char *lo;			/* base of block */
  char *hi;			/* one beyond last address in block */
  mwrap_node up;
  mwrap_node left;
  mwrap_node right;
};


/* Abbreviations for macros.  Change in case of conflict.

	Assignment macros:
   GET(x)		equivalent to 'x' on a rhs, but memory address is checked before access
   SET(x)		equivalent to 'x' on a lhs, but memory address is checked before assignment
   CPY(p,q,n)	copy n values starting from p to n values starting from q, after checking both

	Test macros:
   POK(p)      pointer p is within an allocated block.
   BOK(b)      pointer b is the base of an allocated block.
   PQOK(p, q)  pointers p and q are in same allocated block.
   PBOK(p, b)  pointer p is in block of base b. 

   MWRAPOK()    check internal tree for sanity (slow)

	Query macros:
   PBASE(p)    base of block containing p, NULL if there is none.
   PBUMP(p)		one beyond last byte of block.
   PSIZE(p)    size of block containing p, -1 if none.

	Explicit block registering macros. 
   CHECKIN(lo, hi)  register block of bounds lo, hi
   CHECKOUT(lo)     unregister block of base lo
   
*/

#define GET(x) MWRAP_GET(x)
#define SET(x) MWRAP_SET(x)
#define CPY(p,q,n) MWRAP_CPY(p,q,n)
#define POK(p) MWRAP_POK(p)
#define BOK(b) MWRAP_BOK(b)
#define PQOK(p,q) MWRAP_PQOK((p),(q))
#define PBOK(p,b) MWRAP_PBOK((p),(b))
#define MWRAPOK() MWRAP_MWRAPOK()
#define PBASE(p) MWRAP_PBASE(p)
#define PSIZE(p) MWRAP_PSIZE(p)
#define CHECKIN(lo, hi)  MWRAP_CHECKIN((lo), (hi))
#define CHECKOUT(lo)     MWRAP_CHECKOUT(lo)


/* 	Definitions of macros.  
	All are conditional on MWRAP being defined. 
   	For speed, macros check for a "lucky" hit (block already
   	at root) before handing over to functions. */

#ifdef MWRAP	

#define MWRAP_GET(x) \
	( (MWRAP_POK(&x)) ? (x) : (x) )
	
#define MWRAP_SET(x) \
	MWRAP_POK(&x) ; (x)
	
#define MWRAP_CPY(p, q, n) \
	do {int i; \
		MWRAP_PQOK((p),(p)+(n-1)); \
		MWRAP_PQOK((q),(q)+(n-1)); \
		for(i=0;i<n;i++) (q)[i]=(p)[i]; \
	} while(0)

/* #define MWRAP_POK(p) \
	do { if (mwrap_tree \
 		&& (char *) (p) >= mwrap_tree->lo  \
 		&& (char *) (p) < mwrap_tree->hi) break; \
	mwrap_pok((char *) (p), __FILE__, __LINE__); } while (0) */
	
#define MWRAP_POK(p) \
	((mwrap_tree && (char *) (p) >= mwrap_tree->lo && (char *) (p) <mwrap_tree->hi) ? \
		1 : mwrap_pok((char *) (p), __FILE__, __LINE__))
	

/* #define MWRAP_BOK(b) \
	do { if (mwrap_tree \
 		&& (char *) (b) == mwrap_tree->lo) break; \
 	mwrap_bok((char *) (b), __FILE__, __LINE__);	} while (0) */

#define MWRAP_BOK(b) \
	((mwrap_tree && (char *) (b) == mwrap_tree->lo) ? 1 : mwrap_bok((char *) (b), __FILE__, __LINE__))


/* #define MWRAP_PQOK(p, q) \
	do { if (mwrap_tree \
		&& (char *) (p) >= mwrap_tree->lo \
 		&& (char *) (p) < mwrap_tree->hi \
 		&& (char *) (q) >= mwrap_tree->lo \
 		&& (char *) (q) < mwrap_tree->lo) break; \
 	mwrap_pqok((char *)(p), (char *)(q), __FILE__, __LINE__); } while (0) */

#define MWRAP_PQOK(p,q) \
	((mwrap_tree \
	&& (char *) (p) >= mwrap_tree->lo \
	&& (char *) (p) < mwrap_tree->hi \
	&& (char *) (q) >= mwrap_tree->lo \
	&& (char *) (q) < mwrap_tree->lo ) ? \
	1 : mwrap_pqok((char *)(p), (char *)(q), __FILE__, __LINE__))

/* #define MWRAP_PBOK(p, b) \
	do { if (mwrap_tree \
		&& (char *) (b) == mwrap_tree->lo \
 		&& (char *) (p) >= mwrap_tree->lo \
 		&& (char *) (p) < mwrap_tree->lo) break; \
 	mwrap_pbok((char *)(p), (char *)(b), __FILE__, __LINE__); } while (0) */

#define MWRAP_PBOK(p, b) \
	(( mwrap_tree \
		&& (char *) (b) == mwrap_tree->lo \
 		&& (char *) (p) >= mwrap_tree->lo \
 		&& (char *) (p) < mwrap_tree->lo) ? \
		1 : mwrap_pbok((char *)(p), (char *)(b), __FILE__, __LINE__))

#define MWRAP_MWRAPOK() mwrap_checktree(__FILE__, __LINE__)

#define MWRAP_PBASE(p) mwrap_pbase((char *) p)
#define MWRAP_PBUMP(p) mwrap_pbump((char *) p)
#define MWRAP_PSIZE(p) mwrap_psize((char *) p)
#define MWRAP_CHECKIN(lo, hi) \
        mwrap_checkin((char *) (lo), (char *) (hi), __FILE__, __LINE__)
#define MWRAP_CHECKOUT(lo) \
        mwrap_checkout( (char *) (lo), __FILE__, __LINE__)

#else

#define MWRAP_GET(x) (x)
#define MWRAP_SET(x) (x)
#define MWRAP_CPY(p,q,n) 
#define MWRAP_POK(p) 
#define MWRAP_BOK(p)
#define MWRAP_PBOK(p,b)
#define MWRAP_PQOK(p,q)
#define MWRAP_MWRAPOK() 
#define MWRAP_PBASE(p) (void *) mwrap_squeal(__FILE__, __LINE__)
#define MWRAP_PBUMP(p) (void *) mwrap_squeal(__FILE__, __LINE__)
#define MWRAP_PSIZE(p) (long) mwrap_squeal(__FILE__, __LINE__)
#define MWRAP_CHECKIN(lo, hi)
#define MWRAP_CHECKOUT(lo)
#endif 


/* Wrapping macros.
   
   If MWRAP is defined, all malloc routines are wrapped and the 
   original routines are available as "nowrap_malloc()", etc..

   If MWRAP is not defined, malloc routines are not wrapped
   and "nowrap_malloc()", etc. are #defined to "malloc()", etc. 
*/
   
#ifdef MWRAP

#ifndef MWRAP_C			
#define malloc(size)     mwrap_malloc((size), __FILE__, __LINE__)
#define free(p)          mwrap_free((p), __FILE__, __LINE__)
#define realloc(p, size) mwrap_realloc((p), (size), __FILE__, __LINE__)
#define calloc(n, size)  mwrap_calloc((n), (size), __FILE__, __LINE__)
#define cfree(p)         mwrap_cfree((p), __FILE__, __LINE__)
#define valloc(size)     mwrap_valloc((size), __FILE__, __LINE__)
#define vfree(p)         mwrap_vfree((p), __FILE__, __LINE__)
#define memalign(a, p)   mwrap_memalign((a), (p), __FILE__, __LINE__)
#endif /* MWRAP_C */

#else

#ifndef MWRAP_C
#define nowrap_malloc(size)     malloc(size)
#define nowrap_free(p)          free(p)
#define nowrap_realloc(p, size) realloc(p)
#define nowrap_calloc(n, size)  calloc((n), (size))
#define nowrap_cfree(p)         cfree(p)
#define nowrap_valloc(size)     valloc(size)
#define nowrap_vfree(p)         vfree(p)
#define nowrap_memalign(a, p)   memalign((a), (p))
#endif /* MWRAP_C */

#endif /* MWRAP */


/* three global variables */

#ifndef MWRAP_C				  
extern mwrap_node mwrap_tree;	/* the tree */
extern char *mwrap_file;		/* caller source file */
extern long mwrap_line;		/* line in caller source file */
#endif				


/* Data types used by malloc library. Modify if necessary */
typedef void DATATYPE;		/* returned by malloc(), etc. */
typedef size_t SIZETYPE;	/* fed to malloc(), etc. */
typedef void VOIDTYPE;		/* returned by free(), etc. */


/* prototypes of routines made public */

/* malloc wrappers */
DATATYPE *mwrap_malloc(SIZETYPE size, char *file, long line);
VOIDTYPE mwrap_free(DATATYPE *p, char *file, long line);
DATATYPE *mwrap_realloc(DATATYPE *p, SIZETYPE size, char *file, long line);
DATATYPE *mwrap_calloc(SIZETYPE n, SIZETYPE size, char *file, long line);
VOIDTYPE mwrap_cfree(DATATYPE *p, char *file, long line);
DATATYPE *mwrap_valloc(SIZETYPE size, char *file, long line);
VOIDTYPE mwrap_vfree(DATATYPE *p, char *file, long line);
DATATYPE *mwrap_memalign(SIZETYPE alignment, SIZETYPE size, char *file, long line);

/* unwrapped versions */
#ifdef MWRAP
DATATYPE *nowrap_malloc(SIZETYPE size);
VOIDTYPE nowrap_free(DATATYPE *p);
DATATYPE *nowrap_realloc(DATATYPE *p, SIZETYPE size);
DATATYPE *nowrap_calloc(SIZETYPE n, SIZETYPE size);
VOIDTYPE nowrap_cfree(DATATYPE *p);
DATATYPE *nowrap_valloc(SIZETYPE size);
VOIDTYPE nowrap_vfree(DATATYPE *p);
DATATYPE *nowrap_memalign(SIZETYPE alignment, SIZETYPE size);
#endif

/* explicit block registering */
void mwrap_checkin(char *lo, char *hi, char *file, long line);
void mwrap_checkout(char *lo, char *file, long line);

/* tests & queries */
int mwrap_pok(char *p, char *file, long line);
int mwrap_bok(char *b, char *file, long line);
int mwrap_pqok(char *p, char *q, char *file, long line);
int mwrap_pbok(char *p, char *b, char *file, long line);
char *mwrap_pbase(char *p);
char *mwrap_pbump(char *p);
long mwrap_psize(char *p);
long mwrap_squeal(char *file, long line);

/* change default functions */
void mwrap_set_errorfunction(void (*f)(int level));
void mwrap_set_messagefunction(void (*f)(int level, char * message));

#endif