template.h File Reference

#include <stddef.h>
#include <derive-c/alloc/trait.h>
#include <derive-c/core/prelude.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/alloc/undef.h>
#include <derive-c/core/self/undef.h>

Include dependency graph for template.h:

Go to the source code of this file.

Classes
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)
	TRAIT_ALLOC (SELF)

Macro Definition Documentation

ALLOC

#define ALLOC   stdalloc

Definition at line 59 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 43 of file template.h.

INTERNAL_NAME

#define INTERNAL_NAME   ENTRIES_VECTOR

Definition at line 60 of file template.h.

ITEM

#define ITEM   TRACKED_ENTRY

Definition at line 58 of file template.h.

TRACKED_ENTRY

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

Definition at line 44 of file template.h.

Function Documentation

calloc()

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

static

Definition at line 92 of file template.h.

                                                                     {
    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;
}

Here is the call graph for this function:

free()

void free ( SELF * self, void * ptr )

static

Definition at line 122 of file template.h.

                                                  {
    ASSUME(ptr);
    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) {
            ASSUME(!entry->freed);
            entry->freed = true;
            break;
        }
    }
 
    NS(ALLOC, free)(self->alloc, ptr);
}

Here is the call graph for this function:

get_entries()

ENTRIES_VECTOR const * get_entries ( SELF const * self )

static

Definition at line 74 of file template.h.

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

Here is the call graph for this function:

Here is the caller graph for this function:

malloc()

void * malloc ( SELF * self, size_t size )

static

Definition at line 104 of file template.h.

                                                       {
    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;
}

Here is the call graph for this function:

new()

SELF new ( ALLOC * alloc )

static

Definition at line 70 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 116 of file template.h.

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

Here is the call graph for this function:

TRAIT_ALLOC()

TRAIT_ALLOC

(

SELF

)

unleak_and_delete()

void unleak_and_delete ( SELF * self )

static

Definition at line 79 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);
}

Here is the call graph for this function:

Here is the caller graph for this function: