heap.h

/*
 * heap.h
 */
#ifndef _lub_heap_h
#define _lub_heap_h
#include <stddef.h>

#include "lub/types.h"
#include "lub/c_decl.h"
_BEGIN_C_DECL

typedef struct lub_heap_s lub_heap_t;

typedef struct lub_heap_free_block_s lub_heap_free_block_t;

typedef struct lub_heap_stats_s lub_heap_stats_t;
struct lub_heap_stats_s
{
    /*----------------------------------------------------- */
    size_t segs;
    size_t segs_bytes;
    size_t segs_overhead;
    /*----------------------------------------------------- */
    size_t free_blocks;
    size_t free_bytes;
    size_t free_overhead;
    /*----------------------------------------------------- */
    size_t alloc_blocks;
    size_t alloc_bytes;
    size_t alloc_overhead;
    /*----------------------------------------------------- */
    size_t alloc_total_blocks;
    size_t alloc_total_bytes;
    /*----------------------------------------------------- */
    size_t alloc_hightide_blocks;
    size_t alloc_hightide_bytes;
    size_t alloc_hightide_overhead;
    size_t free_hightide_blocks;
    size_t free_hightide_bytes;
    size_t free_hightide_largest;
    size_t free_hightide_overhead;
    /*----------------------------------------------------- */
    size_t static_blocks;
    size_t static_bytes;    
    size_t static_overhead;
    /*----------------------------------------------------- */
};
typedef enum
{
    LUB_HEAP_OK,
    LUB_HEAP_FAILED,
    LUB_HEAP_DOUBLE_FREE,
    LUB_HEAP_CORRUPTED,
    LUB_HEAP_INVALID_POINTER
} lub_heap_status_t;

typedef struct {void *ptr;} struct_void_ptr;
typedef enum
{
    LUB_HEAP_ALIGN_NATIVE = sizeof(struct_void_ptr),
    LUB_HEAP_ALIGN_4    = 0x00000004,
    LUB_HEAP_ALIGN_8    = 0x00000008,
    LUB_HEAP_ALIGN_16   = 0x00000010,
    LUB_HEAP_ALIGN_32   = 0x00000020,
    LUB_HEAP_ALIGN_64   = 0x00000040,
    LUB_HEAP_ALIGN_128  = 0x00000080,
    LUB_HEAP_ALIGN_256  = 0x00000100,
    LUB_HEAP_ALIGN_512  = 0x00000200,
    LUB_HEAP_ALIGN_1024  = 0x00000400,
    LUB_HEAP_ALIGN_2048  = 0x00000800,
    LUB_HEAP_ALIGN_4096  = 0x00001000,
    LUB_HEAP_ALIGN_8192  = 0x00002000,
    LUB_HEAP_ALIGN_16384 = 0x00004000,
    LUB_HEAP_ALIGN_32768 = 0x00008000
} lub_heap_align_t;

typedef enum
{
    LUB_HEAP_SHOW_LEAKS,
    LUB_HEAP_SHOW_PARTIALS,
    LUB_HEAP_SHOW_ALL
} lub_heap_show_e;

typedef void 
    lub_heap_foreach_fn(
        void *block,
        unsigned index,
        size_t size,
        void *arg);

void
    lub_heap_foreach_segment(
        lub_heap_t *instance,
        lub_heap_foreach_fn *fn,
        void *arg);
void
    lub_heap_foreach_free_block(
        lub_heap_t *instance,
        lub_heap_foreach_fn *fn,
        void *arg);

lub_heap_t *
    lub_heap_create(
        void *start,
        size_t size
    );
void
    lub_heap_destroy(
        lub_heap_t *instance
    );
void 
    lub_heap_add_segment(
        lub_heap_t *instance,
        void *start,
        size_t size
    );
void *
    lub_heap_static_alloc(
        lub_heap_t *instance,
        size_t size
    );
lub_heap_status_t
    lub_heap_realloc(
        lub_heap_t *instance,
        char **ptr,
        size_t size,
        lub_heap_align_t alignment
    );
bool_t
    lub_heap_taint(
        bool_t enable
    );
bool_t
    lub_heap_is_tainting(void);
bool_t
    lub_heap_check(
        bool_t enable
    );

bool_t
    lub_heap_is_checking(void);

extern bool_t 
    lub_heap_check_memory(lub_heap_t *instance);

void 
    lub_heap_stop_here(
        lub_heap_status_t status,
        char *old_ptr,
        size_t new_size
    );

void
    lub_heap__get_stats(
        lub_heap_t *instance,
        lub_heap_stats_t *stats
    );

void
    lub_heap_show(
        lub_heap_t *instance,
        bool_t verbose
    );
size_t    
lub_heap__get_max_free(
        lub_heap_t *instance
    );

extern size_t
    lub_heap__get_block_overhead(void);

extern size_t
    lub_heap__get_block_size(const void *ptr);
void
    lub_heap_show_leaks(
        lub_heap_show_e how
    );

void
    lub_heap__set_framecount(
        unsigned framecount
    );

unsigned
    lub_heap__get_framecount(void);
    
extern bool_t 
    lub_heap_validate_pointer(lub_heap_t *instance,
                              char       *ptr);
#define LUB_HEAP_ZERO_ALLOC ((void*)-1)

extern void
    lub_heap_init(
        const char *program_name
    );


#if defined(__CYGWIN__)

extern void 
    cygwin_lub_heap_init(const char *file_name);

#define lub_heap_init(arg0) cygwin_lub_heap_init(arg0)

#endif /* __CYGWIN__ */

_END_C_DECL

#endif /* _lub_heap_h */

---