template.h File Reference

#include <derive-c/core/includes/def.h>
#include "includes.h"
#include <derive-c/core/alloc/def.h>
#include <derive-c/core/self/def.h>
#include <derive-c/alloc/std.h>
#include <derive-c/container/vector/dynamic/template.h>
#include <derive-c/core/self/undef.h>
#include <derive-c/core/alloc/undef.h>
#include <derive-c/core/includes/undef.h>

Go to the source code of this file.

Data Structures
struct	TRACKED_ENTRY
struct	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...

Macros
#define	ENTRIES_VECTOR   NS(NAME, entries)
	For unit tests expected to throw, as C has no unwind, we cannot free allocated memory. This macro wraps the allocator in debug, to allow clearing leaks after an exception.
#define	TRACKED_ENTRY   NS(EXPAND(ENTRIES), entry)
#define	ITEM   TRACKED_ENTRY
#define	ALLOC   stdalloc
#define	INTERNAL_NAME   ENTRIES_VECTOR

Functions
static SELF	new (ALLOC *alloc)
static ENTRIES_VECTOR const *	get_entries (SELF const *self)
static void	unleak_and_delete (SELF *self)
static void *	calloc (SELF *self, size_t count, size_t size)
static void *	malloc (SELF *self, size_t size)
static void *	realloc (SELF *self, void *ptr, size_t size)
static void	free (SELF *self, void *ptr)
static void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
	DC_TRAIT_ALLOC (SELF)

Macro Definition Documentation

ALLOC

#define ALLOC   stdalloc

Definition at line 64 of file template.h.

ENTRIES_VECTOR

#define ENTRIES_VECTOR   NS(NAME, entries)

For unit tests expected to throw, as C has no unwind, we cannot free allocated memory. This macro wraps the allocator in debug, to allow clearing leaks after an exception.

In release, it is a no-op / pass through.

As this is entirely C, we do not get the niceties of a C++ RAII allocator guard shebang. However, this is usable inside unit tests written in C.

Definition at line 48 of file template.h.

INTERNAL_NAME

#define INTERNAL_NAME   ENTRIES_VECTOR

Definition at line 65 of file template.h.

ITEM

#define ITEM   TRACKED_ENTRY

Definition at line 63 of file template.h.

TRACKED_ENTRY

#define TRACKED_ENTRY   NS(EXPAND(ENTRIES), entry)

Definition at line 49 of file template.h.

Function Documentation

calloc()

void * calloc ( SELF * self, size_t count, size_t size )

static

Definition at line 97 of file template.h.

                                                                     {
    DC_ASSUME(self);
    void* ptr = NS(ALLOC, calloc)(self->alloc, count, size);
    if (ptr) {
        NS(ENTRIES_VECTOR, push)(&self->entries, (TRACKED_ENTRY){
                                                     .ptr = ptr,
                                                     .freed = false,
                                                 });
    }
    return ptr;
}

DC_TRAIT_ALLOC()

DC_TRAIT_ALLOC

(

SELF

)

debug()

void debug ( SELF const * self, dc_debug_fmt fmt, FILE * stream )

static

Definition at line 145 of file template.h.

                                                                              {
    fprintf(stream, STRINGIFY(SELF) " @%p {", self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "base: " STRINGIFY(ALLOC) "@%p,\n", self->alloc);
    NS(ENTRIES_VECTOR, debug)(&self->entries, fmt, stream);
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

free()

void free ( SELF * self, void * ptr )

static

Definition at line 127 of file template.h.

                                                  {
    DC_ASSUME(ptr);
    DC_ASSUME(self);
 
    NS(ENTRIES_VECTOR, iter) iter = NS(ENTRIES_VECTOR, get_iter)(&self->entries);
    TRACKED_ENTRY* entry;
 
    while ((entry = NS(ENTRIES_VECTOR, iter_next)(&iter))) {
        if (entry->ptr == ptr) {
            DC_ASSUME(!entry->freed);
            entry->freed = true;
            break;
        }
    }
 
    NS(ALLOC, free)(self->alloc, ptr);
}

get_entries()

ENTRIES_VECTOR const * get_entries ( SELF const * self )

static

Definition at line 79 of file template.h.

                                                                     {
    DC_ASSUME(self);
    return &self->entries;
}

malloc()

void * malloc ( SELF * self, size_t size )

static

Definition at line 109 of file template.h.

                                                       {
    DC_ASSUME(self);
    void* ptr = NS(ALLOC, malloc)(self->alloc, size);
    if (ptr) {
        NS(ENTRIES_VECTOR, push)(&self->entries, (TRACKED_ENTRY){
                                                     .ptr = ptr,
                                                     .freed = false,
                                                 });
    }
    return ptr;
}

new()

SELF new ( ALLOC * alloc )

static

Definition at line 75 of file template.h.

                                        {
    return (SELF){.alloc = alloc, .entries = NS(ENTRIES_VECTOR, new)(stdalloc_get())};
}

realloc()

void * realloc ( SELF * self, void * ptr, size_t size )

static

Definition at line 121 of file template.h.

                                                                   {
    DC_ASSUME(self);
    DC_ASSUME(ptr);
    return NS(ALLOC, realloc)(self->alloc, ptr, size);
}

unleak_and_delete()

void unleak_and_delete ( SELF * self )

static

Definition at line 84 of file template.h.

                                                    {
    NS(ENTRIES_VECTOR, iter) iter = NS(ENTRIES_VECTOR, get_iter)(&self->entries);
    TRACKED_ENTRY* entry;
 
    while ((entry = NS(ENTRIES_VECTOR, iter_next)(&iter))) {
        if (!entry->freed) {
            NS(ALLOC, free)(self->alloc, entry->ptr);
        }
    }
 
    NS(ENTRIES_VECTOR, delete)(&self->entries);
}