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_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_2_POWER_2 = 0x00000004,
    LUB_HEAP_ALIGN_2_POWER_3 = 0x00000008,
    LUB_HEAP_ALIGN_2_POWER_4 = 0x00000010,
    LUB_HEAP_ALIGN_2_POWER_5 = 0x00000020,
    LUB_HEAP_ALIGN_2_POWER_6 = 0x00000040,
    LUB_HEAP_ALIGN_2_POWER_7 = 0x00000080,
    LUB_HEAP_ALIGN_2_POWER_8 = 0x00000100,
    LUB_HEAP_ALIGN_2_POWER_9 = 0x00000200,
    LUB_HEAP_ALIGN_2_POWER_10 = 0x00000400,
    LUB_HEAP_ALIGN_2_POWER_11 = 0x00000800,
    LUB_HEAP_ALIGN_2_POWER_12 = 0x00001000,
    LUB_HEAP_ALIGN_2_POWER_13 = 0x00002000,
    LUB_HEAP_ALIGN_2_POWER_14 = 0x00004000,
    LUB_HEAP_ALIGN_2_POWER_15 = 0x00008000,
    LUB_HEAP_ALIGN_2_POWER_16 = 0x00010000,
    LUB_HEAP_ALIGN_2_POWER_17 = 0x00020000,
    LUB_HEAP_ALIGN_2_POWER_18 = 0x00040000,
    LUB_HEAP_ALIGN_2_POWER_19 = 0x00080000,
    LUB_HEAP_ALIGN_2_POWER_20 = 0x00100000,
    LUB_HEAP_ALIGN_2_POWER_21 = 0x00200000,
    LUB_HEAP_ALIGN_2_POWER_22 = 0x00400000,
    LUB_HEAP_ALIGN_2_POWER_23 = 0x00800000,
    LUB_HEAP_ALIGN_2_POWER_24 = 0x01000000,
    LUB_HEAP_ALIGN_2_POWER_25 = 0x02000000,
    LUB_HEAP_ALIGN_2_POWER_26 = 0x04000000,
    LUB_HEAP_ALIGN_2_POWER_27 = 0x08000000
} 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(lub_heap_t *instance,
                                 const void *ptr);

extern size_t
    lub_heap__get_block_size(lub_heap_t *instance,
                             const void *ptr);
extern void
    lub_heap_leak_scan(void);
extern bool_t
    lub_heap_leak_report(
        lub_heap_show_e how,
        const char *substring
    );

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__ */

lub_heap_status_t
    lub_heap_cache_init(
        lub_heap_t *instance,
        lub_heap_align_t max_block_size,
        size_t num_max_blocks
    );
void
    lub_heap_leak_suppress_detection(
        lub_heap_t *instance
    );
void
    lub_heap_leak_restore_detection(
        lub_heap_t *instance
    );

size_t
    lub_heap_overhead_size(
        lub_heap_align_t max_block_size,
        size_t num_max_blocks
    );


_END_C_DECL

#endif /* _lub_heap_h */

---