template.h

Go to the documentation of this file.

 
#include <derive-c/core/includes/def.h>
#if !defined(SKIP_INCLUDES)
    #include "includes.h"
#endif
 
#include <derive-c/core/alloc/def.h>
#include <derive-c/core/self/def.h>
 
typedef struct {
    char const* name;
    FILE* stream;
    NS(ALLOC, ref) alloc_ref;
} SELF;
 
DC_PUBLIC static SELF NS(SELF, new)(char const* name, FILE* stream, NS(ALLOC, ref) alloc_ref) {
    fprintf(stream, "[%s] %s(alloc=" DC_EXPAND_STRING(ALLOC) "@%p)\n", name, __func__,
            (void*)NS(NS(ALLOC, ref), deref)(alloc_ref));
    return (SELF){
        .name = name,
        .stream = stream,
        .alloc_ref = alloc_ref,
    };
}
 
DC_PUBLIC static void* NS(SELF, allocate_uninit)(SELF* self, size_t size) {
    DC_ASSUME(self);
    void* ptr = NS(ALLOC, allocate_uninit)(self->alloc_ref, size);
    fprintf(self->stream, "[%s] %s(size=%zu) -> %p\n", self->name, __func__, size, ptr);
    return ptr;
}
 
DC_PUBLIC static void* NS(SELF, allocate_zeroed)(SELF* self, size_t size) {
    DC_ASSUME(self);
    void* ptr = NS(ALLOC, allocate_zeroed)(self->alloc_ref, size);
    fprintf(self->stream, "[%s] %s(size=%zu) -> %p\n", self->name, __func__, size, ptr);
    return ptr;
}
 
DC_PUBLIC static void* NS(SELF, reallocate)(SELF* self, void* ptr, size_t old_size,
                                            size_t new_size) {
    DC_ASSUME(self);
    void* new_ptr = NS(ALLOC, reallocate)(self->alloc_ref, ptr, old_size, new_size);
    fprintf(self->stream, "[%s] %s(ptr=%p, old_size=%zu, new_size=%zu) -> %p\n", self->name,
            __func__, ptr, old_size, new_size, new_ptr);
    return new_ptr;
}
 
DC_PUBLIC static void NS(SELF, deallocate)(SELF* self, void* ptr, size_t size) {
    DC_ASSUME(self);
    fprintf(self->stream, "[%s] %s(ptr=%p, size=%zu)\n", self->name, __func__, ptr, size);
    NS(ALLOC, deallocate)(self->alloc_ref, ptr, size);
}
 
DC_PUBLIC static void NS(SELF, debug)(SELF const* self, dc_debug_fmt fmt, FILE* stream) {
    fprintf(stream, DC_EXPAND_STRING(SELF) "@%p {\n", (void*)self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "name: %s,\n", self->name);
    dc_debug_fmt_print(fmt, stream, "alloc: ");
    NS(ALLOC, debug)(NS(NS(ALLOC, ref), deref)(self->alloc_ref), fmt, stream);
    fprintf(stream, "\n");
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}
 
DC_PUBLIC static void NS(SELF, delete)(SELF* self) {
    DC_ASSUME(self);
    fprintf(self->stream, "[%s]: %s\n", self->name, __func__);
}
 
DC_TRAIT_REFERENCABLE_BY_PTR(SELF);
 
DC_TRAIT_ALLOC(SELF);
 
#include <derive-c/core/self/undef.h>
#include <derive-c/core/alloc/undef.h>
#include <derive-c/core/includes/undef.h>