fstack.h

Go to the documentation of this file.

/*  fstack.h
 *
 *  Copyright (C) 2023 abxh
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *  See the file LICENSE included with this distribution for more
 *  information. */
 
// macro definitions: {{{
 
#ifndef FSTACK_H
#define FSTACK_H
 
#include "paste.h" // PASTE, XPASTE, JOIN
 
#include <assert.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
 
#define fstack_for_each(self, index, value) \
    for ((index) = (self)->count; (index) > 0 && ((value) = (self)->values[(index) - 1], true); (index)--)
 
#define fstack_for_each_reverse(self, index, value) \
    for ((index) = 0; (index) < (self)->count && ((value) = (self)->values[(index)], true); (index)++)
 
#define fstack_calc_sizeof(fstack_name, capacity) \
    (uint32_t)(offsetof(struct fstack_name, values) + capacity * sizeof(((struct fstack_name *)0)->values[0]))
 
#define fstack_calc_sizeof_overflows(fstack_name, capacity) \
    (capacity > (UINT32_MAX - offsetof(struct fstack_name, values)) / sizeof(((struct fstack_name *)0)->values[0]))
 
#endif // FSTACK_H
 
#ifndef NAME
#define NAME fstack
#error "Must define NAME."
#else
#define FSTACK_NAME NAME
#endif
 
#ifndef VALUE_TYPE
#define VALUE_TYPE int
#error "Must define VALUE_TYPE."
#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)
#define FSTACK_CALC_SIZEOF JOIN(FSTACK_NAME, calc_sizeof)
 
// }}}
 
// type definitions: {{{
 
struct FSTACK_NAME {
    uint32_t count;      
    uint32_t capacity;   
    VALUE_TYPE values[]; 
};
 
// }}}
 
// function definitions: {{{
 
static inline FSTACK_TYPE *JOIN(FSTACK_NAME, init)(FSTACK_TYPE *self, const uint32_t capacity)
{
    assert(self);
 
    self->count = 0;
    self->capacity = capacity;
 
    return self;
}
 
static inline FSTACK_TYPE *JOIN(FSTACK_NAME, create)(const uint32_t capacity)
{
    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 *)calloc(1, size);
 
    if (!self) {
        return NULL;
    }
 
    FSTACK_INIT(self, capacity);
 
    return self;
}
 
static inline void JOIN(FSTACK_NAME, destroy)(FSTACK_TYPE *self)
{
    assert(self != NULL);
 
    free(self);
}
 
static inline bool JOIN(FSTACK_NAME, is_empty)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
 
    return self->count == 0;
}
 
static inline bool JOIN(FSTACK_NAME, is_full)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
 
    return self->count == self->capacity;
}
 
static inline 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];
}
 
static inline 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];
}
 
static inline VALUE_TYPE JOIN(FSTACK_NAME, get_bottom)(const FSTACK_TYPE *self)
{
    assert(self != NULL);
    assert(FSTACK_IS_EMPTY(self) == false);
 
    return self->values[0];
}
 
static inline VALUE_TYPE JOIN(FSTACK_NAME, peek)(const FSTACK_TYPE *self)
{
    return JOIN(FSTACK_NAME, get_top)(self);
}
 
static inline 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;
}
 
static inline VALUE_TYPE JOIN(FSTACK_NAME, pop)(FSTACK_TYPE *self)
{
    assert(self != NULL);
    assert(FSTACK_IS_EMPTY(self) == false);
 
    return self->values[--self->count];
}
 
static inline void JOIN(FSTACK_NAME, clear)(FSTACK_TYPE *self)
{
    assert(self != NULL);
    self->count = 0;
}
 
static inline 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;
}
 
// }}}
 
// macro undefs: {{{
#undef NAME
#undef VALUE_TYPE
 
#undef FSTACK_NAME
#undef FSTACK_TYPE
#undef FSTACK_IS_EMPTY
#undef FSTACK_IS_FULL
#undef FSTACK_INIT
#undef FSTACK_CALC_SIZEOF
// }}}
 
// vim: ft=c fdm=marker