fstack_template.h

Go to the documentation of this file.

// Copyright (c) 2026 abxh
// SPDX-License-Identifier: MIT


 
#ifdef __cplusplus
#ifdef __GNUC__
#define restrict __restrict__
#else
#define restrict
#endif
extern "C" {
#endif
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
// macro definitions: {{{

#ifndef PASTE
#define PASTE(a, b) a##b
#endif

#ifndef XPASTE
#define XPASTE(a, b) PASTE(a, b)
#endif

#ifndef JOIN
#define JOIN(a, b) XPASTE(a, XPASTE(_, b))
#endif

#ifndef FSTACK_FOR_EACH
#define FSTACK_FOR_EACH(self, index, value) \
    for ((index) = (self)->count; (index) > 0 && ((value) = (self)->values[(index) - 1], true); (index)--)
#endif

#ifndef FSTACK_FOR_EACH_REVERSE
#define FSTACK_FOR_EACH_REVERSE(self, index, value) \
    for ((index) = 0; (index) < (self)->count && ((value) = (self)->values[(index)], true); (index)++)
#endif

#ifndef FSTACK_CALC_SIZEOF
#define FSTACK_CALC_SIZEOF(fstack_name, capacity) \
    (uint32_t)(offsetof(struct fstack_name, values) + capacity * sizeof(((struct fstack_name *)0)->values[0]))
#endif

#ifndef FSTACK_CALC_SIZEOF_OVERFLOWS
#define FSTACK_CALC_SIZEOF_OVERFLOWS(fstack_name, capacity) \
    (capacity > (UINT32_MAX - offsetof(struct fstack_name, values)) / sizeof(((struct fstack_name *)0)->values[0]))
#endif

#ifndef NAME
#error "Must define NAME."
#define FUNCTION_DEFINITIONS
#define TYPE_DEFINITIONS
#else
#define FSTACK_NAME NAME
#endif

#ifndef VALUE_TYPE
#define VALUE_TYPE int
#error "Must define VALUE_TYPE."
#endif

#ifndef FUNCTION_LINKAGE
#define FUNCTION_LINKAGE
#endif

#define FSTACK_TYPE     struct FSTACK_NAME
#define FSTACK_IS_EMPTY JOIN(FSTACK_NAME, is_empty)
#define FSTACK_IS_FULL  JOIN(FSTACK_NAME, is_full)
#define FSTACK_INIT     JOIN(FSTACK_NAME, init)
 
// }}}
 
// type definitions: {{{
 
struct FSTACK_NAME;

#ifdef TYPE_DEFINITIONS

struct FSTACK_NAME {
    uint32_t count;      
    uint32_t capacity;   
    VALUE_TYPE values[]; 
};
 
#endif
 
// }}}
 
// function declarations: {{{

FUNCTION_LINKAGE FSTACK_TYPE *JOIN(FSTACK_NAME, init)(FSTACK_TYPE *self, const uint32_t capacity);

FUNCTION_LINKAGE FSTACK_TYPE *JOIN(FSTACK_NAME,
                                   create_custom)(const uint32_t capacity, void *context_ptr,
                                                  void *(*allocate)(void *context_ptr, size_t alignment, size_t size));

FUNCTION_LINKAGE FSTACK_TYPE *JOIN(FSTACK_NAME, create)(const uint32_t capacity);

FUNCTION_LINKAGE void JOIN(FSTACK_NAME, destroy_custom)(FSTACK_TYPE *self, void *context_ptr,
                                                        void (*deallocate)(void *context_ptr, void *mem));

FUNCTION_LINKAGE void JOIN(FSTACK_NAME, destroy)(FSTACK_TYPE *self);

FUNCTION_LINKAGE bool JOIN(FSTACK_NAME, is_empty)(const FSTACK_TYPE *self);

FUNCTION_LINKAGE bool JOIN(FSTACK_NAME, is_full)(const FSTACK_TYPE *self);

FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, at)(const FSTACK_TYPE *self, const uint32_t index);

FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, get_top)(const FSTACK_TYPE *self);

FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, get_bottom)(const FSTACK_TYPE *self);

FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, peek)(const FSTACK_TYPE *self);

FUNCTION_LINKAGE void JOIN(FSTACK_NAME, push)(FSTACK_TYPE *self, const VALUE_TYPE value);

FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, pop)(FSTACK_TYPE *self);

FUNCTION_LINKAGE void JOIN(FSTACK_NAME, clear)(FSTACK_TYPE *self);

FUNCTION_LINKAGE void JOIN(FSTACK_NAME, copy)(FSTACK_TYPE *restrict dest_ptr, const FSTACK_TYPE *restrict src_ptr);
 
// }}}
 
// function definitions: {{{

#ifdef FUNCTION_DEFINITIONS
 
#include <assert.h>
#include <stdalign.h>
#include <stdlib.h>
#include <string.h>
 
FUNCTION_LINKAGE FSTACK_TYPE *JOIN(FSTACK_NAME, init)(FSTACK_TYPE *self, const uint32_t capacity)
{
    assert(self);
 
    self->count = 0;
    self->capacity = capacity;
 
    return self;
}
 
FUNCTION_LINKAGE FSTACK_TYPE *JOIN(FSTACK_NAME,
                                   create_custom)(const uint32_t capacity, void *context_ptr,
                                                  void *(*allocate)(void *context_ptr, size_t alignment, size_t size))
{
    if (capacity == 0 || FSTACK_CALC_SIZEOF_OVERFLOWS(FSTACK_NAME, capacity)) {
        return NULL;
    }
 
    const uint32_t size = FSTACK_CALC_SIZEOF(FSTACK_NAME, capacity);
 
    FSTACK_TYPE *self = (FSTACK_TYPE *)allocate(context_ptr, alignof(FSTACK_TYPE), size);
 
    if (!self) {
        return NULL;
    }
 
    memset(self, 0, size);
    FSTACK_INIT(self, capacity);
 
    return self;
}

static inline void *JOIN(internal, JOIN(FSTACK_NAME, allocate))(void *context_ptr, size_t alignment, size_t size)
{
    (void)context_ptr;
    (void)alignment;
    return malloc(size);
}
 
FUNCTION_LINKAGE FSTACK_TYPE *JOIN(FSTACK_NAME, create)(const uint32_t capacity)
{
    return JOIN(FSTACK_NAME, create_custom)(capacity, NULL, JOIN(internal, JOIN(FSTACK_NAME, allocate)));
}
 
FUNCTION_LINKAGE void JOIN(FSTACK_NAME, destroy_custom)(FSTACK_TYPE *self, void *context_ptr,
                                                        void (*deallocate)(void *context_ptr, void *mem))
{
    assert(self != NULL);
 
    deallocate(context_ptr, self);
}

static inline void JOIN(internal, JOIN(FSTACK_NAME, deallocate))(void *context_ptr, void *mem)
{
    (void)context_ptr;
    free(mem);
}
 
FUNCTION_LINKAGE void JOIN(FSTACK_NAME, destroy)(FSTACK_TYPE *self)
{
    assert(self != NULL);
 
    JOIN(FSTACK_NAME, destroy_custom)(self, NULL, JOIN(internal, JOIN(FSTACK_NAME, deallocate)));
}
 
FUNCTION_LINKAGE bool JOIN(FSTACK_NAME, is_empty)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
 
    return self->count == 0;
}
 
FUNCTION_LINKAGE bool JOIN(FSTACK_NAME, is_full)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
 
    return self->count == self->capacity;
}
 
FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, at)(const FSTACK_TYPE *self, const uint32_t index)
{
    assert(self != NULL);
    assert(index < self->count);
 
    return self->values[self->count - 1 - index];
}
 
FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, get_top)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
    assert(FSTACK_IS_EMPTY(self) == false);
 
    return self->values[self->count - 1];
}
 
FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, get_bottom)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
    assert(FSTACK_IS_EMPTY(self) == false);
 
    return self->values[0];
}
 
FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, peek)(const FSTACK_TYPE *self)
{
    return JOIN(FSTACK_NAME, get_top)(self);
}
 
FUNCTION_LINKAGE void JOIN(FSTACK_NAME, push)(FSTACK_TYPE *self, const VALUE_TYPE value)
{
    assert(self != NULL);
    assert(FSTACK_IS_FULL(self) == false);
 
    self->values[self->count++] = value;
}
 
FUNCTION_LINKAGE VALUE_TYPE JOIN(FSTACK_NAME, pop)(FSTACK_TYPE *self)
{
    assert(self != NULL);
    assert(FSTACK_IS_EMPTY(self) == false);
 
    return self->values[--self->count];
}
 
FUNCTION_LINKAGE void JOIN(FSTACK_NAME, clear)(FSTACK_TYPE *self)
{
    assert(self != NULL);
    self->count = 0;
}
 
FUNCTION_LINKAGE void JOIN(FSTACK_NAME, copy)(FSTACK_TYPE *restrict dest_ptr, const FSTACK_TYPE *restrict src_ptr)
{
    assert(src_ptr != NULL);
    assert(dest_ptr != NULL);
    assert(src_ptr->count <= dest_ptr->capacity);
    assert(FSTACK_IS_EMPTY(dest_ptr));
 
    for (uint32_t i = 0; i < src_ptr->count; i++) {
        dest_ptr->values[i] = src_ptr->values[i];
    }
    dest_ptr->count = src_ptr->count;
}
 
#endif
 
// }}}
 
// macro undefs: {{{
#undef NAME
#undef VALUE_TYPE
#undef FUNCTION_LINKAGE
#undef FUNCTION_DEFINITIONS
#undef TYPE_DEFINITIONS
 
#undef FSTACK_NAME
#undef FSTACK_TYPE
#undef FSTACK_IS_EMPTY
#undef FSTACK_IS_FULL
#undef FSTACK_INIT
 
// }}}
 
#ifdef __cplusplus
}
#endif
 
// vim: ft=c fdm=marker