template.h File Reference

#include <stddef.h>
#include <derive-c/allocs/std.h>
#include <derive-c/core.h>
#include <derive-c/panic.h>
#include <derive-c/self.h>
#include <derive-c/allocs/null.h>
#include <derive-c/structures/vector/template.h>

Include dependency graph for template.h:

Go to the source code of this file.

Classes
struct	TRACKED_ENTRY
struct	SELF

Macros
#define	ALLOC   nullalloc
	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	ENTRIES   derive_c_entries_placeholder_name
#define	TRACKED_ENTRY   NAME(ENTRIES, entry)
#define	T   TRACKED_ENTRY
#define	ALLOC   stdalloc
	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	SELF   ENTRIES

Functions
static SELF	new (ALLOC *alloc)
static ENTRIES 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)

Macro Definition Documentation

ALLOC [1/2]

#define ALLOC   nullalloc

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.

Definition at line 21 of file template.h.

ALLOC [2/2]

#define ALLOC   stdalloc

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.

Definition at line 21 of file template.h.

ENTRIES

#define ENTRIES   derive_c_entries_placeholder_name

Definition at line 28 of file template.h.

SELF

#define SELF   ENTRIES

Definition at line 70 of file template.h.

T

#define T   TRACKED_ENTRY

Definition at line 68 of file template.h.

TRACKED_ENTRY

#define TRACKED_ENTRY   NAME(ENTRIES, entry)

Definition at line 55 of file template.h.

Function Documentation

calloc()

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

static

Definition at line 102 of file template.h.

                                                                       {
    DEBUG_ASSERT(self);
    void* ptr = NAME(ALLOC, calloc)(self->alloc, count, size);
    if (ptr) {
        NAME(ENTRIES, 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 132 of file template.h.

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

Here is the call graph for this function:

get_entries()

ENTRIES const * get_entries ( SELF const * self )

static

Definition at line 84 of file template.h.

                                                                {
    DEBUG_ASSERT(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 114 of file template.h.

                                                         {
    DEBUG_ASSERT(self);
    void* ptr = NAME(ALLOC, malloc)(self->alloc, size);
    if (ptr) {
        NAME(ENTRIES, 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 80 of file template.h.

                                          {
    return (SELF){.alloc = alloc, .entries = NAME(ENTRIES, new)(stdalloc_get())};
}

realloc()

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

static

Definition at line 126 of file template.h.

                                                                     {
    DEBUG_ASSERT(self);
    DEBUG_ASSERT(ptr);
    return NAME(ALLOC, realloc)(self->alloc, ptr, size);
}

Here is the call graph for this function:

unleak_and_delete()

void unleak_and_delete ( SELF * self )

static

Definition at line 89 of file template.h.

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

Here is the call graph for this function:

Here is the caller graph for this function: