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/index/bits_to_type/def.h>
#include <derive-c/core/index/type_to_strong/def.h>
#include <derive-c/utils/slot/template.h>
#include <derive-c/core/index/type_to_strong/undef.h>
#include <derive-c/core/index/bits_to_type/undef.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	value_t
struct	SELF
	An allocator that prints to stdout when it allocates or frees memory. More...
struct	IV_PAIR_CONST
struct	ITER_CONST
struct	IV_PAIR
struct	ITER

Macros
#define	INDEX_BITS   32
	A block based arena that allocated in block doubling in size. TODO(oliverkillane): look at bumaplo.
#define	VALUE   value_t
#define	VALUE_DELETE   value_delete
#define	VALUE_CLONE   value_clone
#define	VALUE_DEBUG   value_debug
#define	INITIAL_BLOCK_INDEX_BITS   8
#define	SLOT   NS(NAME, slot)
#define	SLOT_INDEX_TYPE   INDEX_TYPE
#define	SLOT_VALUE   VALUE
#define	SLOT_VALUE_CLONE   VALUE_CLONE
#define	SLOT_VALUE_CLONE   VALUE_CLONE
#define	SLOT_VALUE_DELETE   VALUE_DELETE
#define	INTERNAL_NAME   SLOT
#define	INVARIANT_CHECK(self)
#define	IV_PAIR_CONST   NS(SELF, iv_const)
#define	ITER_CONST   NS(SELF, iter_const)
#define	IV_PAIR   NS(SELF, iv)
#define	ITER   NS(SELF, iter)

Typedefs
typedef IV_PAIR_CONST	item

Functions
static void	VALUE_DELETE (value_t *self)
static value_t	VALUE_CLONE (value_t const *self)
static void	VALUE_DEBUG (VALUE const *self, dc_debug_fmt fmt, FILE *stream)
	DC_STATIC_ASSERT (sizeof(VALUE), "VALUE must be a non-zero sized type")
	DC_STATIC_ASSERT (INITIAL_BLOCK_INDEX_BITS< INDEX_BITS, "INITIAL_BLOCK_INDEX_BITS must be less than INDEX_BITS")
	DC_STATIC_ASSERT (INITIAL_BLOCK_INDEX_BITS > 0, "INITIAL_BLOCK_INDEX_BITS must be greater than zero")
static void PRIV	set_memory_tracking (SELF const *self)
static SELF	new (ALLOC *alloc)
static INDEX	insert (SELF *self, VALUE value)
static VALUE const *	try_read (SELF const *self, INDEX index)
static VALUE const *	read (SELF const *self, INDEX index)
static VALUE *	try_write (SELF *self, INDEX index)
static VALUE *	write (SELF *self, INDEX index)
static INDEX_TYPE	size (SELF const *self)
static SELF	clone (SELF const *self)
static bool	try_remove (SELF *self, INDEX index, VALUE *destination)
static VALUE	remove (SELF *self, INDEX index)
static void	delete (SELF *self)
static IV_PAIR_CONST	iv_const_empty ()
static bool	empty_item (IV_PAIR_CONST const *item)
static IV_PAIR_CONST	next (ITER_CONST *iter)
static ITER_CONST	get_iter_const (SELF const *self)
static void	debug (SELF const *self, dc_debug_fmt fmt, FILE *stream)
static IV_PAIR	iv_empty ()
static bool	empty_item (IV_PAIR const *item)
static IV_PAIR	next (ITER *iter)
static ITER	get_iter (SELF *self)
	DC_TRAIT_ARENA (SELF)

Variables
static const size_t	max_entries = MAX_INDEX

Macro Definition Documentation

INDEX_BITS

#define INDEX_BITS   32

A block based arena that allocated in block doubling in size. TODO(oliverkillane): look at bumaplo.

Blocks of doubling size are used to allocate elements.

• Block determined by checking the most significant bit
• Allows for efficient lookup of the block index For example with:

  INITIAL_BLOCK_INDEX_BITS = 3
  INDEX_BITS = 8

BitMask	Index	Entries	Offset	Block
XXXXX000	0	8	0	0
XXXXX111	7		7	0
XXXX1000	8	8	0	1
XXXX1111	15		7	1
XXX10000	16	16	0	2
XXX11111	31		15	2
XX100000	32	32	0	3
XX111111	63		31	3
X1000000	64	64	0	4
X1111111	127		63	4
10000000	128	128	0	5
11111111	255		127	5

Definition at line 41 of file template.h.

INITIAL_BLOCK_INDEX_BITS

#define INITIAL_BLOCK_INDEX_BITS   8

Definition at line 78 of file template.h.

INTERNAL_NAME

#define INTERNAL_NAME   SLOT

Definition at line 98 of file template.h.

INVARIANT_CHECK

#define INVARIANT_CHECK

(

self

)

Value:

    DC_ASSUME(self);                                                                               \
    DC_ASSUME(DC_ARENA_GEO_BLOCK_TO_SIZE((self)->block_current, INITIAL_BLOCK_INDEX_BITS) >=       \
              (self)->block_current_exclusive_end);                                                \
    DC_ASSUME((self)->count <= MAX_INDEX);

Definition at line 142 of file template.h.

#define INVARIANT_CHECK(self)                                                                      \
    DC_ASSUME(self);                                                                               \
    DC_ASSUME(DC_ARENA_GEO_BLOCK_TO_SIZE((self)->block_current, INITIAL_BLOCK_INDEX_BITS) >=       \
              (self)->block_current_exclusive_end);                                                \
    DC_ASSUME((self)->count <= MAX_INDEX);

ITER

#define ITER   NS(SELF, iter)

Definition at line 510 of file template.h.

ITER_CONST

#define ITER_CONST   NS(SELF, iter_const)

Definition at line 377 of file template.h.

IV_PAIR

#define IV_PAIR   NS(SELF, iv)

Definition at line 497 of file template.h.

IV_PAIR_CONST

#define IV_PAIR_CONST   NS(SELF, iv_const)

Definition at line 364 of file template.h.

SLOT

#define SLOT   NS(NAME, slot)

Definition at line 91 of file template.h.

SLOT_INDEX_TYPE

#define SLOT_INDEX_TYPE   INDEX_TYPE

Definition at line 93 of file template.h.

SLOT_VALUE

#define SLOT_VALUE   VALUE

Definition at line 94 of file template.h.

SLOT_VALUE_CLONE [1/2]

#define SLOT_VALUE_CLONE   VALUE_CLONE

Definition at line 95 of file template.h.

SLOT_VALUE_CLONE [2/2]

#define SLOT_VALUE_CLONE   VALUE_CLONE

Definition at line 95 of file template.h.

SLOT_VALUE_DELETE

#define SLOT_VALUE_DELETE   VALUE_DELETE

Definition at line 97 of file template.h.

VALUE

#define VALUE   value_t

Definition at line 51 of file template.h.

VALUE_CLONE

#define VALUE_CLONE   value_clone

Definition at line 54 of file template.h.

VALUE_DEBUG

#define VALUE_DEBUG   value_debug

Definition at line 56 of file template.h.

VALUE_DELETE

#define VALUE_DELETE   value_delete

Definition at line 52 of file template.h.

Typedef Documentation

item

typedef IV_PAIR_CONST item

Definition at line 378 of file template.h.

Function Documentation

clone()

SELF clone ( SELF const * self )

static

Definition at line 264 of file template.h.

                                              {
    INVARIANT_CHECK(self);
 
    SELF new_self = {
        .free_list = self->free_list,
        .count = self->count,
        .alloc = self->alloc,
        .derive_c_arena_blocks = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
        .block_current_exclusive_end = self->block_current_exclusive_end,
        .block_current = self->block_current,
        .blocks = {},
    };
 
    for (size_t block_index = 0; block_index <= self->block_current; block_index++) {
        size_t block_items = DC_ARENA_GEO_BLOCK_TO_SIZE(block_index, INITIAL_BLOCK_INDEX_BITS);
        SLOT* block_slots = (SLOT*)NS(ALLOC, malloc)(self->alloc, block_items * sizeof(SLOT));
        DC_ASSERT(block_slots);
        new_self.blocks[block_index] = block_slots;
 
        size_t const to_offset =
            block_index == self->block_current ? self->block_current_exclusive_end : block_items;
 
        for (size_t offset = 0; offset < to_offset; offset++) {
            SLOT* src_slot = &self->blocks[block_index][offset];
            SLOT* dst_slot = &new_self.blocks[block_index][offset];
 
            if (src_slot->present) {
                dst_slot->present = true;
                dst_slot->value = VALUE_CLONE(&src_slot->value);
                new_self.count++;
            } else {
                dst_slot->present = false;
            }
        }
    }
 
    PRIV(NS(SELF, set_memory_tracking))(&new_self);
 
    return new_self;
}

DC_STATIC_ASSERT() [1/3]

DC_STATIC_ASSERT	(	INITIAL_BLOCK_INDEX_BITS	,
		0	,
		"INITIAL_BLOCK_INDEX_BITS must be greater than zero"	)

DC_STATIC_ASSERT() [2/3]

DC_STATIC_ASSERT

(

)

DC_STATIC_ASSERT() [3/3]

DC_STATIC_ASSERT	(	sizeof(VALUE)	,
		"VALUE must be a non-zero sized type"	)

DC_TRAIT_ARENA()

DC_TRAIT_ARENA

(

SELF

)

debug()

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

static

Definition at line 429 of file template.h.

                                                                              {
    fprintf(stream, EXPAND_STRING(SELF) "@%p {\n", self);
    fmt = dc_debug_fmt_scope_begin(fmt);
    dc_debug_fmt_print(fmt, stream, "count: %lu,\n", self->count);
 
    if (self->free_list == INDEX_NONE) {
        dc_debug_fmt_print(fmt, stream, "free_list: INDEX_NONE,\n");
    } else {
        dc_debug_fmt_print(fmt, stream, "free_list: %lu,\n", (size_t)self->free_list);
    }
 
    dc_debug_fmt_print(fmt, stream, "alloc: ");
    NS(ALLOC, debug)(self->alloc, fmt, stream);
    fprintf(stream, ",\n");
 
    dc_debug_fmt_print(fmt, stream, "blocks: [");
    fmt = dc_debug_fmt_scope_begin(fmt);
    for (size_t block = 0; block <= self->block_current; block++) {
        dc_debug_fmt_print(fmt, stream, "{\n");
        fmt = dc_debug_fmt_scope_begin(fmt);
 
        size_t const capacity = DC_ARENA_GEO_BLOCK_TO_SIZE(block, INITIAL_BLOCK_INDEX_BITS);
        size_t const to_offset =
            block == self->block_current ? self->block_current_exclusive_end : capacity;
 
        dc_debug_fmt_print(fmt, stream, "block_index: %lu,\n", block);
        dc_debug_fmt_print(fmt, stream, "block_ptr: %p,\n", self->blocks[block]);
        dc_debug_fmt_print(fmt, stream, "capacity: %lu,\n", capacity);
        dc_debug_fmt_print(fmt, stream, "size: %lu,\n", to_offset);
        dc_debug_fmt_print(fmt, stream, "slots: [\n");
        fmt = dc_debug_fmt_scope_begin(fmt);
 
        for (size_t offset = 0; offset < to_offset; offset++) {
            SLOT* slot = &self->blocks[block][offset];
            dc_debug_fmt_print(fmt, stream, "{\n");
            fmt = dc_debug_fmt_scope_begin(fmt);
 
            dc_debug_fmt_print(fmt, stream, "present: %s,\n", slot->present ? "true" : "false");
            if (slot->present) {
                dc_debug_fmt_print(fmt, stream, "value: ");
                VALUE_DEBUG(&slot->value, fmt, stream);
                fprintf(stream, ",\n");
            } else {
                dc_debug_fmt_print(fmt, stream, "next_free: %lu,\n", (size_t)slot->next_free);
            }
 
            fmt = dc_debug_fmt_scope_end(fmt);
            dc_debug_fmt_print(fmt, stream, "},\n");
        }
 
        fmt = dc_debug_fmt_scope_end(fmt);
        dc_debug_fmt_print(fmt, stream, "],\n");
 
        /* Close the block's scope and print its closing brace */
        fmt = dc_debug_fmt_scope_end(fmt);
        dc_debug_fmt_print(fmt, stream, "},\n");
    }
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "],\n");
 
    fmt = dc_debug_fmt_scope_end(fmt);
    dc_debug_fmt_print(fmt, stream, "}");
}

delete()

void delete ( SELF * self )

static

Definition at line 342 of file template.h.

                                         {
    INVARIANT_CHECK(self);
 
    for (uint8_t block = 0; block <= self->block_current; block++) {
        size_t const to_offset = block == self->block_current
                                     ? self->block_current_exclusive_end
                                     : DC_ARENA_GEO_BLOCK_TO_SIZE(block, INITIAL_BLOCK_INDEX_BITS);
 
        for (size_t offset = 0; offset < to_offset; offset++) {
            SLOT* slot = &self->blocks[block][offset];
            if (slot->present) {
                VALUE_DELETE(&slot->value);
            }
        }
 
        dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_CONTAINER, DC_MEMORY_TRACKER_CAP_WRITE,
                              self->blocks[block],
                              DC_ARENA_GEO_BLOCK_TO_SIZE(block, INITIAL_BLOCK_INDEX_BITS));
        NS(ALLOC, free)(self->alloc, self->blocks[block]);
    }
}

empty_item() [1/2]

bool empty_item ( IV_PAIR const * item )

static

Definition at line 513 of file template.h.

{ return item->value == NULL; }

empty_item() [2/2]

bool empty_item ( IV_PAIR_CONST const * item )

static

Definition at line 380 of file template.h.

{ return item->value == NULL; }

get_iter()

ITER get_iter ( SELF * self )

static

Definition at line 552 of file template.h.

                                           {
    INVARIANT_CHECK(self);
 
    return (ITER){
        .arena = self,
        .next_index = 0,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

get_iter_const()

ITER_CONST get_iter_const ( SELF const * self )

static

Definition at line 419 of file template.h.

                                                             {
    INVARIANT_CHECK(self);
 
    return (ITER_CONST){
        .arena = self,
        .next_index = 0,
        .version = mutation_tracker_get(&self->iterator_invalidation_tracker),
    };
}

insert()

INDEX insert ( SELF * self, VALUE value )

static

Definition at line 173 of file template.h.

                                                       {
    INVARIANT_CHECK(self);
    DC_ASSERT(self->count < MAX_INDEX);
 
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    if (self->free_list != INDEX_NONE) {
        INDEX_TYPE free_index = self->free_list;
 
        uint8_t block = DC_ARENA_GEO_INDEX_TO_BLOCK(free_index, INITIAL_BLOCK_INDEX_BITS);
        size_t offset = DC_ARENA_GEO_INDEX_TO_OFFSET(free_index, block, INITIAL_BLOCK_INDEX_BITS);
        SLOT* free_slot = &self->blocks[block][offset];
 
        DC_ASSUME(!free_slot->present, "The free list should only contain free slots");
        self->free_list = free_slot->next_free;
 
        free_slot->present = true;
        NS(SLOT, fill)(free_slot, value);
        self->count++;
 
        return (INDEX){.index = free_index};
    }
 
    if (self->block_current_exclusive_end ==
        DC_ARENA_GEO_BLOCK_TO_SIZE(self->block_current, INITIAL_BLOCK_INDEX_BITS)) {
        DC_ASSUME(self->block_current < sizeof(self->blocks) / sizeof(SLOT*));
 
        self->block_current++;
        size_t block_items =
            DC_ARENA_GEO_BLOCK_TO_SIZE(self->block_current, INITIAL_BLOCK_INDEX_BITS);
        SLOT* block_slots = (SLOT*)NS(ALLOC, malloc)(self->alloc, block_items * sizeof(SLOT));
        DC_ASSERT(block_slots);
 
        self->blocks[self->block_current] = block_slots;
        self->block_current_exclusive_end = 0;
    }
 
    size_t offset = self->block_current_exclusive_end;
    NS(SLOT, fill)(&self->blocks[self->block_current][offset], value);
    INDEX_TYPE new_index = (INDEX_TYPE)(DC_ARENA_GEO_BLOCK_OFFSET_TO_INDEX(
        self->block_current, offset, INITIAL_BLOCK_INDEX_BITS));
 
    self->block_current_exclusive_end++;
    self->count++;
 
    PRIV(NS(SELF, set_memory_tracking))(self);
 
    return (INDEX){.index = new_index};
}

iv_const_empty()

IV_PAIR_CONST iv_const_empty ( )

static

Definition at line 370 of file template.h.

                                                {
    return (IV_PAIR_CONST){
        .index = {.index = INDEX_NONE},
        .value = NULL,
    };
}

iv_empty()

IV_PAIR iv_empty ( )

static

Definition at line 503 of file template.h.

                                    {
    return (IV_PAIR){
        .index = {.index = INDEX_NONE},
        .value = NULL,
    };
}

new()

SELF new ( ALLOC * alloc )

static

Definition at line 148 of file template.h.

                                        {
    uint8_t initial_block = 0;
    size_t initial_block_items =
        DC_ARENA_GEO_BLOCK_TO_SIZE(initial_block, INITIAL_BLOCK_INDEX_BITS);
    SLOT* initial_block_slots = (SLOT*)NS(ALLOC, malloc)(alloc, initial_block_items * sizeof(SLOT));
    DC_ASSERT(initial_block_slots);
 
    SELF self = {
        .free_list = INDEX_NONE,
        .count = 0,
        .alloc = alloc,
        .derive_c_arena_blocks = dc_gdb_marker_new(),
        .iterator_invalidation_tracker = mutation_tracker_new(),
        .block_current_exclusive_end = 0,
        .block_current = initial_block,
        .blocks =
            {
                initial_block_slots,
            },
    };
 
    PRIV(NS(SELF, set_memory_tracking))(&self);
    return self;
}

next() [1/2]

IV_PAIR next ( ITER * iter )

static

Definition at line 521 of file template.h.

                                          {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
 
    while (iter->next_index < MAX_INDEX) {
        uint8_t block = DC_ARENA_GEO_INDEX_TO_BLOCK(iter->next_index, INITIAL_BLOCK_INDEX_BITS);
        size_t offset =
            DC_ARENA_GEO_INDEX_TO_OFFSET(iter->next_index, block, INITIAL_BLOCK_INDEX_BITS);
 
        if ((block == iter->arena->block_current &&
             offset >= iter->arena->block_current_exclusive_end) ||
            (block > iter->arena->block_current)) {
            break;
        }
 
        SLOT* slot = &iter->arena->blocks[block][offset];
        if (slot->present) {
            IV_PAIR result = {
                .index = (INDEX){.index = iter->next_index},
                .value = &slot->value,
            };
            iter->next_index++;
            return result;
        }
 
        iter->next_index++;
    }
 
    return NS(SELF, iv_empty)();
}

next() [2/2]

IV_PAIR_CONST next ( ITER_CONST * iter )

static

Definition at line 388 of file template.h.

                                                            {
    DC_ASSUME(iter);
    mutation_version_check(&iter->version);
 
    while (iter->next_index < MAX_INDEX) {
        uint8_t block = DC_ARENA_GEO_INDEX_TO_BLOCK(iter->next_index, INITIAL_BLOCK_INDEX_BITS);
        size_t offset =
            DC_ARENA_GEO_INDEX_TO_OFFSET(iter->next_index, block, INITIAL_BLOCK_INDEX_BITS);
 
        if ((block == iter->arena->block_current &&
             offset >= iter->arena->block_current_exclusive_end) ||
            (block > iter->arena->block_current)) {
            break;
        }
 
        SLOT* slot = &iter->arena->blocks[block][offset];
        if (slot->present) {
            IV_PAIR_CONST const result = {
                .index = (INDEX){.index = iter->next_index},
                .value = &slot->value,
            };
            iter->next_index++;
            return result;
        }
 
        iter->next_index++;
    }
 
    return NS(SELF, iv_const_empty)();
}

read()

VALUE const * read ( SELF const * self, INDEX index )

static

Definition at line 245 of file template.h.

                                                                  {
    VALUE const* value = NS(SELF, try_read)(self, index);
    DC_ASSERT(value);
    return value;
}

remove()

VALUE remove ( SELF * self, INDEX index )

static

Definition at line 333 of file template.h.

                                                       {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    VALUE value;
    DC_ASSERT(NS(SELF, try_remove)(self, index, &value));
    return value;
}

set_memory_tracking()

void PRIV set_memory_tracking ( SELF const * self )

static

Definition at line 119 of file template.h.

                                                                  {
    for (uint8_t block_index = 0; block_index <= self->block_current; block_index++) {
        size_t block_items =
            block_index == self->block_current
                ? self->block_current_exclusive_end
                : DC_ARENA_GEO_BLOCK_TO_SIZE(block_index, INITIAL_BLOCK_INDEX_BITS);
        for (size_t offset = 0; offset < block_items; offset++) {
            SLOT* slot = &self->blocks[block_index][offset];
            if (slot->present) {
                NS(SLOT, memory_tracker_present)(slot);
            } else {
                NS(SLOT, memory_tracker_empty)(slot);
            }
        }
    }
 
    size_t tail_slots = DC_ARENA_GEO_BLOCK_TO_SIZE(self->block_current, INITIAL_BLOCK_INDEX_BITS) -
                        (self->block_current_exclusive_end - 1);
    dc_memory_tracker_set(DC_MEMORY_TRACKER_LVL_CONTAINER, DC_MEMORY_TRACKER_CAP_NONE,
                          &self->blocks[self->block_current][self->block_current_exclusive_end],
                          tail_slots * sizeof(SLOT));
}

size()

INDEX_TYPE size ( SELF const * self )

static

Definition at line 259 of file template.h.

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

try_read()

VALUE const * try_read ( SELF const * self, INDEX index )

static

Definition at line 223 of file template.h.

                                                                      {
    INVARIANT_CHECK(self);
 
    uint8_t block = DC_ARENA_GEO_INDEX_TO_BLOCK(index.index, INITIAL_BLOCK_INDEX_BITS);
    if (block > self->block_current) {
        return NULL;
    }
 
    size_t offset = DC_ARENA_GEO_INDEX_TO_OFFSET(index.index, block, INITIAL_BLOCK_INDEX_BITS);
 
    if (block == self->block_current && offset >= self->block_current_exclusive_end) {
        return NULL;
    }
 
    SLOT* slot = &self->blocks[block][offset];
    if (!slot->present) {
        return NULL;
    }
 
    return &slot->value;
}

try_remove()

bool try_remove ( SELF * self, INDEX index, VALUE * destination )

static

Definition at line 306 of file template.h.

                                                                              {
    INVARIANT_CHECK(self);
    mutation_tracker_mutate(&self->iterator_invalidation_tracker);
 
    uint8_t block = DC_ARENA_GEO_INDEX_TO_BLOCK(index.index, INITIAL_BLOCK_INDEX_BITS);
    if (block > self->block_current) {
        return false;
    }
 
    size_t offset = DC_ARENA_GEO_INDEX_TO_OFFSET(index.index, block, INITIAL_BLOCK_INDEX_BITS);
 
    if (block == self->block_current && offset >= self->block_current_exclusive_end) {
        return false;
    }
 
    SLOT* slot = &self->blocks[block][offset];
    if (slot->present) {
        *destination = slot->value;
        slot->present = false;
        NS(SLOT, set_empty)(slot, self->free_list);
        self->free_list = index.index;
        self->count--;
        return true;
    }
    return false;
}

try_write()

VALUE * try_write ( SELF * self, INDEX index )

static

Definition at line 251 of file template.h.

                                                           {
    return (VALUE*)NS(SELF, try_read)(self, index);
}

VALUE_CLONE()

value_t VALUE_CLONE ( value_t const * self )

static

VALUE_DEBUG()

void VALUE_DEBUG ( VALUE const * self, dc_debug_fmt fmt, FILE * stream )

static

VALUE_DELETE()

void VALUE_DELETE ( value_t * self )

static

write()

VALUE * write ( SELF * self, INDEX index )

static

Definition at line 255 of file template.h.

                                                       {
    return (VALUE*)NS(SELF, read)(self, index);
}

Variable Documentation

max_entries

const size_t max_entries = MAX_INDEX

static

Definition at line 86 of file template.h.