mpatrol.h

debug source code under unix platform.

MP_CONST char *__mp_function(__mp_alloctype);
int __mp_setuser(MP_CONST void *, MP_CONST void *);
int __mp_setmark(MP_CONST void *);
int __mp_info(MP_CONST void *, __mp_allocinfo *);
int __mp_syminfo(MP_CONST void *, __mp_symbolinfo *);
MP_CONST char *__mp_symbol(MP_CONST void *);
int __mp_printinfo(MP_CONST void *);
unsigned long __mp_snapshot(void);
size_t __mp_iterate(int (*)(MP_CONST void *, void *), void *, unsigned long);
size_t __mp_iterateall(int (*)(MP_CONST void *, void *), void *);
int __mp_addallocentry(MP_CONST char *, unsigned long, size_t);
int __mp_addfreeentry(MP_CONST char *, unsigned long, size_t);
void __mp_clearleaktable(void);
int __mp_startleaktable(void);
int __mp_stopleaktable(void);
void __mp_leaktable(size_t, int, unsigned char);
void __mp_memorymap(int);
void __mp_summary(void);
int __mp_stats(__mp_heapinfo *);
void __mp_checkheap(MP_CONST char *, MP_CONST char *, unsigned long);
__mp_prologuehandler __mp_prologue(MP_CONST __mp_prologuehandler);
__mp_epiloguehandler __mp_epilogue(MP_CONST __mp_epiloguehandler);
__mp_nomemoryhandler __mp_nomemory(MP_CONST __mp_nomemoryhandler);
void __mp_pushdelstack(MP_CONST char *, MP_CONST char *, unsigned long);
void __mp_popdelstack(char **, char **, unsigned long *);
int __mp_printf(MP_CONST char *, ...);
int __mp_vprintf(MP_CONST char *, va_list);
void __mp_printfwithloc(MP_CONST char *, MP_CONST char *, unsigned long,
                        MP_CONST char *, ...);
void __mp_vprintfwithloc(MP_CONST char *, MP_CONST char *, unsigned long,
                         MP_CONST char *, va_list);
void __mp_logmemory(MP_CONST void *, size_t);
int __mp_logstack(size_t);
int __mp_logaddr(MP_CONST void *);
int __mp_edit(MP_CONST char *, unsigned long);
int __mp_list(MP_CONST char *, unsigned long);
int __mp_view(MP_CONST char *, unsigned long);
int __mp_readcontents(MP_CONST char *, void *);
int __mp_writecontents(MP_CONST char *, MP_CONST void *);
long __mp_cmpcontents(MP_CONST char *, MP_CONST void *);
int __mp_remcontents(MP_CONST char *, MP_CONST void *);


#if defined(__STDC_VERSION__) && (__STDC_VERSION__ == 199901L)
#define __mp_locprintf(...) \
    __mp_printfwithloc(MP_FUNCNAME, __FILE__, __LINE__, __VA_ARGS__)
#elif defined(__GNUC__)
#define __mp_locprintf(a...) \
    __mp_printfwithloc(MP_FUNCNAME, __FILE__, __LINE__, a)
#else /* __STDC_VERSION__ && __GNUC__ */
static
void
__mp_locprintf(MP_CONST char *m, ...)
{
    va_list v;

    va_start(v, m);
    __mp_vprintfwithloc(NULL, NULL, 0, m, v);
    va_end(v);
}
#endif /* __STDC_VERSION__ && __GNUC__ */


#ifdef __cplusplus
}
#endif /* __cplusplus */

#else /* NDEBUG */

static int __mp_errno;

#define dealloca(p)

#define MP_NEW new
#define MP_NEW_NOTHROW new(std::nothrow)
#define MP_DELETE delete

#define __mp_init() ((void) 0)
#define __mp_reinit() ((void) 0)
#define __mp_fini() ((void) 0)
#define __mp_atexit(f) ((int) 0)
#define __mp_setoption(o, v) ((unsigned long) ~0L)
#define __mp_getoption(o, v) ((int) 0)
#define __mp_alloc(l, a, f, s, t, u, g, h, k) ((void *) NULL)
#define __mp_strdup(p, l, f, s, t, u, k) ((char *) NULL)
#define __mp_realloc(p, l, a, f, s, t, u, g, h, k) ((void *) NULL)
#define __mp_free(p, f, s, t, u, k) ((void) 0)
#define __mp_setmem(p, l, c, f, s, t, u, k) ((void *) NULL)
#define __mp_copymem(p, q, l, c, f, s, t, u, k) ((void *) NULL)
#define __mp_locatemem(p, l, q, m, f, s, t, u, k) ((void *) NULL)
#define __mp_comparemem(p, q, l, f, s, t, u, k) ((int) 0)
#define __mp_libversion() ((unsigned long) MPATROL_VERSION)
#define __mp_strerror(f) ((MP_CONST char *) NULL)
#define __mp_function(f) ((MP_CONST char *) NULL)
#define __mp_setuser(p, d) ((int) 0)
#define __mp_setmark(p) ((int) 0)
#define __mp_info(p, d) ((int) 0)
#define __mp_syminfo(p, d) ((int) 0)
#define __mp_symbol(p) ((MP_CONST char *) NULL)
#define __mp_printinfo(p) ((int) 0)
#define __mp_snapshot() ((unsigned long) 0)
#define __mp_iterate(p, d, s) ((size_t) 0)
#define __mp_iterateall(p, d) ((size_t) 0)
#define __mp_addallocentry(f, l, c) ((int) 0)
#define __mp_addfreeentry(f, l, c) ((int) 0)
#define __mp_clearleaktable() ((void) 0)
#define __mp_startleaktable() ((int) 0)
#define __mp_stopleaktable() ((int) 0)
#define __mp_leaktable(l, o, f) ((void) 0)
#define __mp_memorymap(s) ((void) 0)
#define __mp_summary() ((void) 0)
#define __mp_stats(d) ((int) 0)
#define __mp_checkheap(s, t, u) ((void) 0)
#define __mp_check() ((void) 0)
#define __mp_prologue(h) ((__mp_prologuehandler) NULL)
#define __mp_epilogue(h) ((__mp_epiloguehandler) NULL)
#define __mp_nomemory(h) ((__mp_nomemoryhandler) NULL)
#define __mp_pushdelstack(s, t, u) ((void) 0)
#define __mp_popdelstack(s, t, u) ((void) 0)
#define __mp_vprintf(s, v) ((int) 0)
#define __mp_vprintfwithloc(s, t, u, m, v) ((void) 0)
#define __mp_vlocprintf(m, v) ((void) 0)
#define __mp_logmemory(p, l) ((void) 0)
#define __mp_logstack(k) ((int) 0)
#define __mp_logaddr(p) ((int) 0)
#define __mp_edit(f, l) ((int) 0)
#define __mp_list(f, l) ((int) 0)
#define __mp_view(f, l) ((int) 0)
#define __mp_readcontents(s, p) ((int) 0)
#define __mp_writecontents(s, p) ((int) 0)
#define __mp_cmpcontents(s, p) ((long) -1)
#define __mp_remcontents(s, p) ((int) 0)

#if defined(__STDC_VERSION__) && (__STDC_VERSION__ == 199901L)
#define __mp_printf(...) ((int) 0)
#define __mp_printfwithloc(s, t, u, ...) ((void) 0)
#define __mp_locprintf(...) ((void) 0)
#elif defined(__GNUC__)
#define __mp_printf(a...) ((int) 0)
#define __mp_printfwithloc(s, t, u, a...) ((void) 0)
#define __mp_locprintf(a...) ((void) 0)
#else /* __STDC_VERSION__ && __GNUC__ */
static
int
__mp_printf(MP_CONST char *s, ...)
{
    return 0;
}

static
void
__mp_printfwithloc(MP_CONST char *s, MP_CONST char *t, unsigned long u,
                   MP_CONST char *m, ...)
{
}

static
void
__mp_locprintf(MP_CONST char *m, ...)
{
}
#endif /* __STDC_VERSION__ && __GNUC__ */

#endif /* NDEBUG */


#define mpatrol_init __mp_init
#define mpatrol_reinit __mp_reinit
#define mpatrol_fini __mp_fini
#define mpatrol_atexit __mp_atexit
#define mpatrol_setoption __mp_setoption
#define mpatrol_getoption __mp_getoption
#define mpatrol_alloc __mp_alloc
#define mpatrol_strdup __mp_strdup
#define mpatrol_realloc __mp_realloc
#define mpatrol_free __mp_free
#define mpatrol_setmem __mp_setmem
#define mpatrol_copymem __mp_copymem
#define mpatrol_locatemem __mp_locatemem
#define mpatrol_comparemem __mp_comparemem
#define mpatrol_libversion __mp_libversion
#define mpatrol_strerror __mp_strerror
#define mpatrol_function __mp_function
#define mpatrol_setuser __mp_setuser
#define mpatrol_setmark __mp_setmark
#define mpatrol_info __mp_info
#define mpatrol_syminfo __mp_syminfo
#define mpatrol_symbol __mp_symbol
#define mpatrol_printinfo __mp_printinfo
#define mpatrol_snapshot __mp_snapshot
#define mpatrol_iterate __mp_iterate
#define mpatrol_iterateall __mp_iterateall
#define mpatrol_addallocentry __mp_addallocentry
#define mpatrol_addfreeentry __mp_addfreeentry
#define mpatrol_clearleaktable __mp_clearleaktable
#define mpatrol_startleaktable __mp_startleaktable
#define mpatrol_stopleaktable __mp_stopleaktable
#define mpatrol_leaktable __mp_leaktable
#define mpatrol_memorymap __mp_memorymap
#define mpatrol_summary __mp_summary
#define mpatrol_stats __mp_stats
#define mpatrol_checkheap __mp_checkheap
#define mpatrol_check __mp_check
#define mpatrol_prologue __mp_prologue
#define mpatrol_epilogue __mp_epilogue
#define mpatrol_nomemory __mp_nomemory
#define mpatrol_pushdelstack __mp_pushdelstack
#define mpatrol_popdelstack __mp_popdelstack
#define mpatrol_printf __mp_printf
#define mpatrol_vprintf __mp_vprintf
#define mpatrol_printfwithloc __mp_printfwithloc
#define mpatrol_vprintfwithloc __mp_vprintfwithloc
#define mpatrol_locprintf __mp_locprintf
#define mpatrol_vlocprintf __mp_vlocprintf
#define mpatrol_logmemory __mp_logmemory
#define mpatrol_logstack __mp_logstack
#define mpatrol_logaddr __mp_logaddr
#define mpatrol_edit __mp_edit
#define mpatrol_list __mp_list
#define mpatrol_view __mp_view
#define mpatrol_readcontents __mp_readcontents
#define mpatrol_writecontents __mp_writecontents
#define mpatrol_cmpcontents __mp_cmpcontents
#define mpatrol_remcontents __mp_remcontents


#if !MP_NOCPLUSPLUS
#ifdef __cplusplus
#ifndef NDEBUG


#if !defined(_WIN32) || defined(__GNUC__)
namespace std
{
#endif /* _WIN32 && __GNUC__ */


/* Set the low-memory handler.
 */

MP_INLINE
new_handler
set_new_handler(new_handler h) throw()
{
    return (new_handler) __mp_nomemory((__mp_nomemoryhandler) h);
}


#if !defined(_WIN32) || defined(__GNUC__)
}
#endif /* _WIN32 && __GNUC__ */


/* Override operator new.
 */

MP_INLINE
void *
operator new(size_t l, MP_CONST char *s, MP_CONST char *t, unsigned long u)
             throw(std::bad_alloc)
{
    void *p;

    if ((p = __mp_alloc(l, 0, MP_AT_NEW, s, t, u, NULL, 0, 0)) == NULL)
        throw std::bad_alloc();
    return p;
}


/* Override nothrow version of operator new.
 */

MP_INLINE
void *
operator new(size_t l, MP_CONST char *s, MP_CONST char *t, unsigned long u,
             MP_CONST std::nothrow_t&) throw()
{
    return __mp_alloc(l, 0, MP_AT_NEW, s, t, u, NULL, 0, 0);
}


/* Override operator new[].
 */

MP_INLINE
void *
operator new[](size_t l, MP_CONST char *s, MP_CONST char *t, unsigned long u)
               throw(std::bad_alloc)
{
    void *p;

    if ((p = __mp_alloc(l, 0, MP_AT_NEWVEC, s, t, u, NULL, 0, 0)) == NULL)
        throw std::bad_alloc();
    return p;
}


/* Override nothrow version of operator new[].
 */

MP_INLINE
void *
operator new[](size_t l, MP_CONST char *s, MP_CONST char *t, unsigned long u,
               MP_CONST std::nothrow_t&) throw()
{
    return __mp_alloc(l, 0, MP_AT_NEWVEC, s, t, u, NULL, 0, 0);
}


/* Override operator delete.
 */

MP_INLINE
void
operator delete(void *p) throw()
{
    char *s, *t;
    unsigned long u;

    __mp_popdelstack(&s, &t, &u);
    __mp_free(p, MP_AT_DELETE, s, t, u, 0);
}


/* Override nothrow version of operator delete.
 */

MP_INLINE
void
operator delete(void *p, MP_CONST std::nothrow_t&) throw()
{
    char *s, *t;
    unsigned long u;

    __mp_popdelstack(&s, &t, &u);
    __mp_free(p, MP_AT_DELETE, s, t, u, 0);
}


/* Override operator delete[].
 */

MP_INLINE
void
operator delete[](void *p) throw()
{
    char *s, *t;
    unsigned long u;

    __mp_popdelstack(&s, &t, &u);
    __mp_free(p, MP_AT_DELETEVEC, s, t, u, 0);
}


/* Override nothrow version of operator delete[].
 */

MP_INLINE
void
operator delete[](void *p, MP_CONST std::nothrow_t&) throw()
{
    char *s, *t;
    unsigned long u;

    __mp_popdelstack(&s, &t, &u);
    __mp_free(p, MP_AT_DELETEVEC, s, t, u, 0);
}


#if MP_NONEWDELETE
#define MP_NEW ::new(MP_FUNCNAME, __FILE__, __LINE__)
#define MP_NEW_NOTHROW ::new(MP_FUNCNAME, __FILE__, __LINE__, std::nothrow)
#define MP_DELETE __mp_pushdelstack(MP_FUNCNAME, __FILE__, __LINE__), ::delete
#else /* MP_NONEWDELETE */
#define new ::new(MP_FUNCNAME, __FILE__, __LINE__)
#define delete __mp_pushdelstack(MP_FUNCNAME, __FILE__, __LINE__), ::delete
#endif /* MP_NONEWDELETE */

#endif /* NDEBUG */
#endif /* __cplusplus */
#endif /* MP_NOCPLUSPLUS */


#endif /* MP_MPATROL_H */