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/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	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...

Macros
#define	INVARIANT_CHECK(self)

Functions
static ssize_t PRIV	read (void *capture, char *buf, size_t size)
static ssize_t PRIV	write (void *capture, const char *data, size_t size)
static int PRIV	seek (void *capture, off_t *offset, int whence)
static int PRIV	close (void *capture)
static DC_PUBLIC SELF	new (ref alloc_ref)
static DC_PUBLIC FILE *	stream (SELF *self)
static DC_PUBLIC void	reset (SELF *self)
	Resets the string, but keps the same stream pointer alive.
static DC_PUBLIC char const *	string (SELF const *self)
	Gets access to the null terminated string.
static DC_PUBLIC char *	release_string (SELF *self)
static DC_PUBLIC size_t	string_size (SELF *self)
static DC_PUBLIC void	delete (SELF *self)

Variables
static size_t const	additional_alloc_size = 32

Macro Definition Documentation

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

    DC_ASSUME(self);                                                                               \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->stream && (self)->capacity > 0));                       \
    DC_ASSUME(DC_WHEN((self)->capacity == 0, !(self)->buf));                                       \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->size_without_null + 1 <= (self)->capacity));

Definition at line 26 of file template.h.

#define INVARIANT_CHECK(self)                                                                      \
    DC_ASSUME(self);                                                                               \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->stream && (self)->capacity > 0));                       \
    DC_ASSUME(DC_WHEN((self)->capacity == 0, !(self)->buf));                                       \
    DC_ASSUME(DC_WHEN((self)->buf, (self)->size_without_null + 1 <= (self)->capacity));

Function Documentation

close()

int PRIV close ( void * capture )

static

Definition at line 92 of file template.h.

                                                {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
    return 0;
}

delete()

DC_PUBLIC void delete ( SELF * self )

static

Definition at line 165 of file template.h.

                                                   {
    INVARIANT_CHECK(self);
    if (self->stream) {
        fclose(self->stream);
    }
    if (self->buf) {
        NS(ALLOC, deallocate)(self->alloc_ref, self->buf, self->capacity);
    }
}

new()

DC_PUBLIC SELF new ( ref alloc_ref )

static

Definition at line 98 of file template.h.

                                                              {
    return (SELF){
        .stream = NULL,
        .buf = NULL,
        .size_without_null = 0,
        .capacity = 0,
        .alloc_ref = alloc_ref,
    };
}

read()

ssize_t PRIV read ( void * capture, char * buf, size_t size )

static

Definition at line 32 of file template.h.

                                                 {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
 
    (void)buf;
    (void)size;
 
    DC_PANIC("cookie set in write-only mode, but read was called.");
}

release_string()

DC_PUBLIC char * release_string ( SELF * self )

static

Disowns the current string, free/management with chosen allocator determined by user. DANGER: The user needs to be careful to cleanup the string using the same allocator as the string builder.

Definition at line 150 of file template.h.

                                                            {
    INVARIANT_CHECK(self);
    char* buf = self->buf;
    self->size_without_null = 0;
    self->buf = NULL;
    self->capacity = 0;
 
    return buf;
}

reset()

DC_PUBLIC void reset ( SELF * self )

static

Resets the string, but keps the same stream pointer alive.

Definition at line 133 of file template.h.

                                                  {
    INVARIANT_CHECK(self);
    self->size_without_null = 0;
}

seek()

int PRIV seek ( void * capture, off_t * offset, int whence )

static

Definition at line 80 of file template.h.

                                            {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
    (void)offset;
    (void)whence;
 
    errno = EPERM; // NOLINT(misc-include-cleaner)
    return -1;
}

stream()

DC_PUBLIC FILE * stream ( SELF * self )

static

Examples

complex/employees.c, container/arena.c, container/map.c, container/queue.c, container/set.c, utils/option.c, and utils/result.c.

Definition at line 108 of file template.h.

                                                    {
    INVARIANT_CHECK(self);
 
    if (self->stream == NULL) {
        cookie_io_functions_t /* NOLINT(misc-include-cleaner) */ const io = {
            .read = PRIV(NS(SELF, read)),
            .write = PRIV(NS(SELF, write)),
            .seek = PRIV(NS(SELF, seek)),
            .close = PRIV(NS(SELF, close)),
        };
        self->stream = fopencookie(self, "w", io);
        DC_ASSERT(self->stream != NULL, "Failed to open stream for string builder, with error: %s",
                  strerror(errno));
 
        // JUSTIFY: No buffering
        // - No performance advantage to buffering writes - this already writes to an in memory
        //   buffer
        // - No need to fflush
        setvbuf(self->stream, NULL, _IONBF, 0);
    }
 
    return self->stream;
}

string()

DC_PUBLIC char const * string ( SELF const * self )

static

Gets access to the null terminated string.

Definition at line 139 of file template.h.

                                                                {
    INVARIANT_CHECK(self);
    if (self->size_without_null == 0) {
        return "";
    }
    return self->buf;
}

string_size()

DC_PUBLIC size_t string_size ( SELF * self )

static

Definition at line 160 of file template.h.

                                                          {
    INVARIANT_CHECK(self);
    return self->size_without_null;
}

write()

ssize_t PRIV write ( void * capture, const char * data, size_t size )

static

Definition at line 44 of file template.h.

                                                                                   {
    SELF* self = (SELF*)capture;
    INVARIANT_CHECK(self);
 
    // JUSTIFY: Unpoisoning passed data to write
    //  - glibc is not instrumented for msan, so sometimes the entire buffer can be deivered as
    //    uninitialised.
    //  - Hence we consider fopenccokie's write as a 'tainted source', and enforce correct memory
    //    capabilities
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_NONE, DC_MEMORY_TRACKER_CAP_READ_WRITE, data, size);
 
    if (self->size_without_null + size + 1 > self->capacity) {
        size_t new_capacity;
        char* new_buf;
        if (self->buf != NULL) {
            size_t const growth_factor = 2;
            new_capacity =
                (self->capacity * growth_factor) + size + NS(SELF, additional_alloc_size);
            new_buf = (char*)NS(ALLOC, reallocate)(self->alloc_ref, self->buf, self->capacity,
                                                   new_capacity);
        } else {
            DC_ASSUME(self->capacity == 0);
            new_capacity = size + 1 + NS(SELF, additional_alloc_size);
            new_buf = (char*)NS(ALLOC, allocate_uninit)(self->alloc_ref, new_capacity);
        }
 
        self->capacity = new_capacity;
        self->buf = new_buf;
    }
 
    memcpy(self->buf + self->size_without_null, data, size);
    self->size_without_null += size;
    self->buf[self->size_without_null] = '\0';
    return (ssize_t)size;
}

Variable Documentation

additional_alloc_size

size_t const additional_alloc_size = 32

static

Definition at line 24 of file template.h.