#include <stddef.h>

#include <string.h>

#include <stdlib.h>

#include <assert.h>

#include <stdint.h>

#include <stdio.h>

#include "err.h"

#ifndef vec_malloc

#define vec_malloc malloc

#ifndef vec_realloc

#define vec_realloc realloc

#ifndef vec_memset

#define vec_memset memset

#ifndef vec_memcpy

#define vec_memcpy memcpy

#ifndef vec_memmove

#define vec_memmove memmove

#undef VEC_DEFAULT_SIZE

#ifdef VEC_SETTINGS_DEFAULT_SIZE

#define VEC_DEFAULT_SIZE VEC_SETTINGS_DEFAULT_SIZE

#define VEC_DEFAULT_SIZE 4

#undef VEC_STRUCT_ITEMS

#ifdef VEC_SETTINGS_STRUCT_ITEMS

#define VEC_STRUCT_ITEMS VEC_SETTINGS_STRUCT_ITEMS

#define VEC_STRUCT_ITEMS items

#undef VEC_KEEP_ZERO_END

#ifdef VEC_SETTINGS_KEEP_ZERO_END

#define VEC_KEEP_ZERO_END VEC_SETTINGS_KEEP_ZERO_END

#define VEC_KEEP_ZERO_END 0

#ifndef VEC_H

#define VEC_CAST_FREE(X) ((void *)(X))

#define VEC_TYPE_FREE(F,X,T) ((void (*)(T *))(F))(VEC_CAST_FREE(X))

typedef enum {

VEC_ERROR_NONE,

/* errors below */

VEC_ERROR_MALLOC,

VEC_ERROR_REALLOC,

/* errors above */

VEC_ERROR__COUNT,

} VecErrorList;

#define VEC_ITEM_BY_VAL(T) T

#define VEC_ITEM_BY_REF(T) T *

#define VEC_ITEM(T, M) VEC_ITEM_##M(T)

#define VEC_REF_BY_VAL &

#define VEC_REF_BY_REF

#define VEC_REF(M) VEC_REF_##M

#define VEC_VAL_BY_VAL

#define VEC_VAL_BY_REF *

#define VEC_VAL(M) VEC_VAL_##M

#define VEC_RREF_BY_VAL

#define VEC_RREF_BY_REF &

#define VEC_RREF(M) VEC_RREF_##M

#define VEC_ASSERT_REAL(x) ASSERT(x, "assertion failed")

#define VEC_ASSERT_BY_REF(x) VEC_ASSERT_REAL(x)

#define VEC_ASSERT_BY_VAL(x)

#define VEC_ASSERT(x, M) VEC_ASSERT_##M(x)

#define VEC_IS_BY_REF_BY_REF 1

#define VEC_IS_BY_REF_BY_VAL 0

#define VEC_IS_BY_REF(M) VEC_IS_BY_REF_##M

#define VEC_H

#define VEC_INCLUDE(N, A, T, M, MODULE, ...) \

VEC_INCLUDE_##MODULE(N, A, T, M, ##__VA_ARGS__)

#define VEC_INCLUDE_BASE(N, A, T, M) \

typedef struct N { \

size_t cap; \

size_t last; \

size_t first; \

VEC_ITEM(T, M) *VEC_STRUCT_ITEMS; \

} N; \

typedef struct R##N { \

size_t last; \

size_t first; \

VEC_ITEM(T, M) *VEC_STRUCT_ITEMS; \

} R##N; \

\

/* common implementation */ \

void A##_clear(N *vec); \

size_t A##_length(const N vec); \

size_t A##_capacity(const N *vec); \

int A##_empty(const N *vec); \

ErrDecl A##_resize(N *vec, size_t cap); \

ErrDecl A##_shrink(N *vec); \

/* single item operations */ \

ErrDecl A##_push_front(N *vec, VEC_ITEM(T, M) val); \

ErrDecl A##_push_back(N *vec, VEC_ITEM(T, M) val); \

ErrDecl A##_push_at(N *vec, size_t index, VEC_ITEM(T, M) val); \

/* TODO */ void A##_set_front(N *vec, VEC_ITEM(T, M) val); \

/* TODO */ void A##_set_back(N *vec, VEC_ITEM(T, M) val); \

void A##_set_at(N *vec, size_t index, VEC_ITEM(T, M) val); \

void A##_pop_front(N *vec, T *val); \

void A##_pop_back(N *vec, T *val); \

void A##_pop_at(N *vec, size_t index, T *val); \

VEC_ITEM(T, M) A##_get_front(const N *vec); \

VEC_ITEM(T, M) A##_get_back(const N *vec); \

VEC_ITEM(T, M) A##_get_at(const N *vec, size_t index); \

/* slice operations */ \

/* TODO */ ErrDecl A##_extend_front(N *vec, N *v2); \

/* TODO */ ErrDecl A##_extend_back(N *vec, N v2); \

/* TODO */ ErrDecl A##_extend_at(N *vec, size_t index, N *v2); \

/* TODO */ ErrDecl A##_paste_front(N *vec, N *v2, size_t n); \

/* TODO */ ErrDecl A##_paste_back(N *vec, N *v2, size_t n); \

/* TODO */ ErrDecl A##_paste_at(N *vec, size_t index, N *v2, size_t n); \

/* TODO */ ErrDecl A##_cut_front(N *vec, N *v2, size_t n); \

/* TODO */ ErrDecl A##_cut_back(N *vec, N *v2, size_t n); \

/* TODO */ ErrDecl A##_cut_at(N *vec, size_t from, size_t n, N *v2); \

/* TODO */ ErrDecl A##_cat_front(N *vec, N *v2, size_t n); \

/* TODO */ ErrDecl A##_cat_back(N *vec, N *v2, size_t n); \

/* TODO */ ErrDecl A##_cat_at(N *vec, size_t from, size_t n, N *v2); \

/* miscellaneous operations */ \

void A##_swap(N *vec, size_t i1, size_t i2); \

void A##_reverse(N *vec); \

/* TODO */ void A##_reverse_slice(N *vec, size_t from, size_t n); \

VEC_ITEM(T, M)*A##_iter_begin(const N vec); \

VEC_ITEM(T, M)*A##_iter_end(const N *vec); \

VEC_ITEM(T, M)*A##_iter_at(const N *vec, size_t index); \

/* split implementation */ \

void A##_free(N *vec); \

void A##_zero(N *vec); \

size_t A##_reserved(const N *vec); \

ErrDecl A##_reserve(N *vec, size_t cap); \

ErrDecl A##_copy(N *dst, const N *src); \

ErrDecl r##A##_copy(N *dst, const R##N *src); \

/* referenced */\

R##N r##A##_r##A(const R##N vec); \

R##N A##_r##A(const N vec); \

void r##A##_clear(R##N *vec); \

size_t r##A##_length(const R##N vec); \

int r##A##_empty(const R##N *vec); \

void r##A##_pop_front(R##N *vec, T *val); \

void r##A##_pop_back(R##N *vec, T *val); \

void r##A##_set_at(R##N *vec, size_t index, VEC_ITEM(T, M) val); \

void r##A##_pop_front(R##N *vec, T *val); \

void r##A##_pop_back(R##N *vec, T *val); \

void r##A##_pop_at(R##N *vec, size_t index, T *val); \

/* TODO */ int r##A##_extend_back(N *vec, R##N v2); \

VEC_ITEM(T, M) r##A##_get_front(const R##N *vec); \

VEC_ITEM(T, M) r##A##_get_back(const R##N *vec); \

VEC_ITEM(T, M) r##A##_get_at(const R##N *vec, size_t index); \

VEC_ITEM(T, M)*r##A##_iter_begin(const R##N vec); \

VEC_ITEM(T, M)*r##A##_iter_end(const R##N *vec); \

VEC_ITEM(T, M)*r##A##_iter_at(const R##N *vec, size_t index); \

void r##A##_zero(R##N *vec); \

/****************************************/

#define VEC_INCLUDE_ERR(N, A, T, M) \

/* error strings for certain fail cases */ \

char *ERR_##A##_resize(void *x, ...); \

char *ERR_##A##_reserve(void *x, ...); \

char *ERR_##A##_push_back(void *x, ...); \

char *ERR_##A##_extend_back(void *x, ...); \

char *ERR_r##A##_extend_back(void *x, ...); \

char *ERR_##A##_copy(void *x, ...); \

char *ERR_r##A##_copy(void *x, ...); \

/****************************************/

#define VEC_INCLUDE_SORT(N, A, T, M) void A##_sort(N *vec);

#define VEC_INCLUDE_SORT2(N, A, T, M, A2) void A##_sort_##A2(N *vec);

#define VEC_IMPLEMENT(N, A, T, M, MODULE, ...) \

VEC_IMPLEMENT_##MODULE(N, A, T, M, ##__VA_ARGS__) \

#define VEC_IMPLEMENT_BASE(N, A, T, M, F) \

/* private */ \

/*VEC_IMPLEMENT_COMMON_STATIC_F(N, A, T, F); */\

VEC_IMPLEMENT_COMMON_STATIC_ZERO(N, A, T, F); \

VEC_IMPLEMENT_COMMON_STATIC_GET(N, A, T, F, M); \

VEC_IMPLEMENT_##M##_STATIC_SHRINK_BACK(N, A, T, F); \

VEC_IMPLEMENT_##M##_STATIC_SHRINK_FRONT(N, A, T, F); \

/* public */ \

VEC_IMPLEMENT_COMMON_CLEAR(N, A, T, F); \

VEC_IMPLEMENT_COMMON_LENGTH(N, A, T, F); \

VEC_IMPLEMENT_COMMON_CAPACITY(N, A, T, F); \

VEC_IMPLEMENT_COMMON_EMPTY(N, A, T, F); \

VEC_IMPLEMENT_COMMON_RESIZE(N, A, T, F); \

VEC_IMPLEMENT_COMMON_SHRINK(N, A, T, F); \

VEC_IMPLEMENT_COMMON_ITER_BEGIN(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_ITER_END(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_ITER_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_POP_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_POP_BACK(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_POP_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_GET_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_GET_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_GET_BACK(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_SET_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_PUSH_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_PUSH_BACK(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_PUSH_AT(N, A, T, F, M); \

/* slice */ \

VEC_IMPLEMENT_COMMON_EXTEND_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_EXTEND_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_CUT_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_CUT_BACK(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_CUT_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_PASTE_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_PASTE_BACK(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_PASTE_AT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_CAT_FRONT(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_CAT_BACK(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_CAT_AT(N, A, T, F, M); \

/* reference */ \

VEC_IMPLEMENT_REFER_CONSTRUCT(N, A, T, M); \

VEC_IMPLEMENT_COMMON_LENGTH(R##N, r##A, T, 0); \

VEC_IMPLEMENT_COMMON_CLEAR(R##N, r##A, T, 0); \

VEC_IMPLEMENT_COMMON_EMPTY(R##N, r##A, T, 0); \

VEC_IMPLEMENT_COMMON_ITER_BEGIN(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_ITER_END(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_ITER_AT(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_POP_FRONT(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_POP_BACK(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_POP_AT(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_GET_AT(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_GET_FRONT(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_GET_BACK(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_SET_AT(R##N, r##A, T, 0, M); \

VEC_IMPLEMENT_COMMON_EXTEND_BACK(N, A, R##N, r##A, T, F, M) \

/* rest */ \

VEC_IMPLEMENT_COMMON_SWAP(N, A, T, F, M); \

VEC_IMPLEMENT_COMMON_REVERSE(N, A, T, F); \

VEC_IMPLEMENT_COMMON_EXTEND_BACK(N, A, N, A, T, F, M) \

VEC_IMPLEMENT_##M##_FREE(N, A, T, F); \

VEC_IMPLEMENT_##M##_ZERO(N, A, T, F); \

VEC_IMPLEMENT_##M##_RESERVED(N, A, T, F); \

VEC_IMPLEMENT_##M##_RESERVE(N, A, T, F); \

VEC_IMPLEMENT_##M##_COPY(N, A, T, F); \

VEC_IMPLEMENT_COMMON_RCOPY(N, A, T, F); \

/****************************************/

#define VEC_IMPLEMENT_ERR(N, A, T, M) \

/* error strings for certain fail cases */ \

char *ERR_##A##_resize(void *x, ...) { return "failed resizing vector"; } \

char *ERR_##A##_reserve(void *x, ...) { return "failed reserving memory for vector"; } \

char *ERR_##A##_push_back(void *x, ...) { return "failed pushing back item to vector"; } \

char *ERR_r##A##_extend_back(void *x, ...) { return "failed pushing back item to vector"; } \

char *ERR_##A##_extend_back(void *x, ...) { return "failed pushing back item to vector"; } \

char *ERR_##A##_copy(void *x, ...) { return "failed copying vector"; } \

char *ERR_r##A##_copy(void *x, ...) { return "failed copying vector"; } \

/****************************************/

#define VEC_IMPLEMENT_REFER_CONSTRUCT(N, A, T, M) \

inline R##N A##_r##A(const N vec) { \

R##N ref = { \

.first = vec.first, \

.last = vec.last, \

.VEC_STRUCT_ITEMS = vec.VEC_STRUCT_ITEMS \

}; \

return ref; \

} \

inline R##N r##A##_r##A(const R##N vec) { \

return vec; \

}

#define VEC_IMPLEMENT_COMMON_STATIC_GET(N, A, T, F, M) \

static inline VEC_ITEM(T, M) *A##_static_get(const N *vec, size_t index) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT_REAL(index < vec->last); \

VEC_ASSERT_REAL(index >= vec->first); \

return &vec->VEC_STRUCT_ITEMS[index]; \

} \

static inline VEC_ITEM(T, M) *r##A##_static_get(const R##N *vec, size_t index) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT_REAL(index < vec->last); \

VEC_ASSERT_REAL(index >= vec->first); \

return &vec->VEC_STRUCT_ITEMS[index]; \

}

#define VEC_IMPLEMENT_BY_VAL_STATIC_SHRINK_BACK(N, A, T, F) \

static inline int A##_static_shrink_back(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

size_t cap = vec->cap; \

size_t last = vec->last; \

size_t required = vec->cap ? vec->cap : VEC_DEFAULT_SIZE;\

while(required > last) required /= 2; \

required *= 2; \

if(required < vec->cap) { \

if(required) { \

if(F != 0) { \

for(size_t i = required; i < cap; i++) { \

VEC_TYPE_FREE(F, &vec->VEC_STRUCT_ITEMS[i], T); \

} \

} \

void *temp = vec_realloc(vec->VEC_STRUCT_ITEMS, sizeof(*vec->VEC_STRUCT_ITEMS) * required); \

if(!temp) return VEC_ERROR_REALLOC; \

vec->VEC_STRUCT_ITEMS = temp; \

vec->cap = required; \

} else { \

A##_free(vec); \

} \

} \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_BY_VAL_STATIC_SHRINK_FRONT(N, A, T, F) \

static inline int A##_static_shrink_front(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

size_t first = vec->first; \

if(first) { \

vec->first = 0; \

T *item = A##_static_get(vec, 0); \

if(F != 0) { \

for(size_t i = 0; i < first; i++) { \

VEC_TYPE_FREE(F, &vec->VEC_STRUCT_ITEMS[i], T); \

} \

} \

vec_memmove(item, item + first, sizeof(T) * (vec->last - first)); \

/* TODO: is that really needed? */ vec_memset(item + vec->last - first, 0, sizeof(T) * (first)); \

vec->last -= first; \

} \

return 0; \

}

#define VEC_IMPLEMENT_BY_REF_STATIC_SHRINK_BACK(N, A, T, F) \

static inline int A##_static_shrink_back(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

size_t cap = vec->cap; \

size_t last = vec->last; \

size_t required = vec->cap ? vec->cap : VEC_DEFAULT_SIZE;\

while(required > last) required /= 2; \

required *= 2; \

if(required < vec->cap) { \

if(required) { \

for(size_t i = required; i < cap; i++) { \

if(F != 0) { \

VEC_TYPE_FREE(F, vec->VEC_STRUCT_ITEMS[i], T); \

} \

free(vec->VEC_STRUCT_ITEMS[i]); \

/*memset(&vec->VEC_STRUCT_ITEMS[i], 0, sizeof(vec->VEC_STRUCT_ITEMS[i]));*/ \

} \

void *temp = vec_realloc(vec->VEC_STRUCT_ITEMS, sizeof(*vec->VEC_STRUCT_ITEMS) * required); \

if(!temp) return VEC_ERROR_REALLOC; \

vec->VEC_STRUCT_ITEMS = temp; \

vec->cap = required; \

} else { \

A##_free(vec); \

} \

} \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_BY_REF_STATIC_SHRINK_FRONT(N, A, T, F) \

static inline int A##_static_shrink_front(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

size_t first = vec->first; \

if(first) { \

vec->first = 0; \

T **item = A##_static_get(vec, 0); \

if(F != 0) { \

for(size_t i = 0; i < first; i++) { \

VEC_TYPE_FREE(F, vec->VEC_STRUCT_ITEMS[i], T); \

} \

} \

/* we have to preserve all items, since they're alloced */ \

T **residuals = malloc(sizeof(T *) * first); \

if(!residuals) return VEC_ERROR_MALLOC; \

vec_memcpy(residuals, item, sizeof(T *) * (first)); \

vec_memmove(item, item + first, sizeof(T *) * (vec->last - first)); \

vec_memcpy(item + vec->last - first, residuals, sizeof(T *) * (first)); \

free(residuals); \

vec->last -= first; \

} \

return 0; \

}

#define VEC_IMPLEMENT_SORT(N, A, T, M, CMP) \

inline void A##_sort(N *vec) { \

/* shell sort, https://rosettacode.org/wiki/Sorting_algorithms/Shell_sort#C */ \

size_t h, i, j, n = A##_length(*vec); \

T temp; \

for (h = n; h /= 2;) { \

for (i = h; i < n; i++) { \

/*t = a[i]; */\

temp = VEC_VAL(M) A##_get_at(vec, i); \

/*for (j = i; j >= h && t < a[j - h]; j -= h) { */\

for (j = i; j >= h && CMP(VEC_RREF(M) temp, A##_get_at(vec, j-h)) < 0; j -= h) { \

A##_set_at(vec, j, A##_get_at(vec, j-h)); \

/*a[j] = a[j - h]; */\

} \

/*a[j] = t; */\

A##_set_at(vec, j, VEC_RREF(M) temp); \

#define VEC_IMPLEMENT_SORT2(N, A, T, M, CMP, A2) \

inline void A##_sort_##A2(N *vec) { \

/* shell sort, https://rosettacode.org/wiki/Sorting_algorithms/Shell_sort#C */ \

size_t h, i, j, n = A##_length(*vec); \

T temp; \

for (h = n; h /= 2;) { \

for (i = h; i < n; i++) { \

/*t = a[i]; */\

temp = VEC_VAL(M) A##_get_at(vec, i); \

/*for (j = i; j >= h && t < a[j - h]; j -= h) { */\

for (j = i; j >= h && CMP(VEC_RREF(M) temp, A##_get_at(vec, j-h)) < 0; j -= h) { \

A##_set_at(vec, j, A##_get_at(vec, j-h)); \

/*a[j] = a[j - h]; */\

} \

/*a[j] = t; */\

A##_set_at(vec, j, VEC_RREF(M) temp); \

#define VEC_IMPLEMENT_COMMON_STATIC_ZERO(N, A, T, F) \

static inline void A##_static_zero(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

vec_memset(vec, 0, sizeof(*vec)); \

}

#define VEC_IMPLEMENT_COMMON_CLEAR(N, A, T, F) \

inline void A##_clear(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

vec->first = 0; \

vec->last = 0; \

}

#define VEC_IMPLEMENT_COMMON_LENGTH(N, A, T, F) \

inline size_t A##_length(const N vec) \

{ \

/*VEC_ASSERT_REAL(vec);*/ \

return vec.last - vec.first; \

}

#define VEC_IMPLEMENT_COMMON_CAPACITY(N, A, T, F) \

inline size_t A##_capacity(const N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

return vec->cap; \

}

#define VEC_IMPLEMENT_COMMON_EMPTY(N, A, T, F) \

inline int A##_empty(const N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

return (vec->first == vec->last); \

}

#define VEC_IMPLEMENT_COMMON_RESIZE(N, A, T, F) \

ErrImpl A##_resize(N *vec, size_t cap) \

{ \

VEC_ASSERT_REAL(vec); \

int result = VEC_ERROR_NONE; \

A##_static_shrink_front(vec); \

result |= result ?: A##_reserve(vec, cap); \

vec->last = cap; \

result |= result ?: A##_static_shrink_back(vec); \

return result; \

}

#define VEC_IMPLEMENT_COMMON_SHRINK(N, A, T, F) \

ErrImpl A##_shrink(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

int result = A##_static_shrink_front(vec); \

result |= A##_static_shrink_back(vec); \

return result; \

}

#define VEC_IMPLEMENT_COMMON_ITER_BEGIN(N, A, T, F, M) \

inline VEC_ITEM(T, M)*A##_iter_begin(const N vec) \

{ \

/*VEC_ASSERT_REAL(vec);*/ \

VEC_ASSERT_REAL(vec.first <= vec.last); \

return vec.VEC_STRUCT_ITEMS + vec.first; \

}

#define VEC_IMPLEMENT_COMMON_ITER_END(N, A, T, F, M) \

inline VEC_ITEM(T, M)*A##_iter_end(const N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT_REAL(vec->first <= vec->last); \

return vec->VEC_STRUCT_ITEMS + vec->last; \

}

#define VEC_IMPLEMENT_COMMON_ITER_AT(N, A, T, F, M) \

inline VEC_ITEM(T, M)*A##_iter_at(const N *vec, size_t index) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT_REAL(vec->first + index <= vec->last); \

return vec->VEC_STRUCT_ITEMS + vec->first + index; \

}

#define VEC_IMPLEMENT_COMMON_POP_FRONT(N, A, T, F, M) \

inline void A##_pop_front(N *vec, T *val) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT_REAL(vec->last > vec->first); \

if(val) { \

size_t first = vec->first; \

VEC_ITEM(T, M) *item = A##_static_get(vec, first); \

vec_memcpy(val, VEC_REF(M) *item, sizeof(T)); \

vec_memset(item, 0, sizeof(*item)); \

} \

vec->first++; \

}

#define VEC_IMPLEMENT_COMMON_POP_BACK(N, A, T, F, M) \

inline void A##_pop_back(N *vec, T *val) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT_REAL(vec->last > vec->first); \

if(val) { \

size_t back = vec->last - 1; \

VEC_ITEM(T, M) *item = A##_static_get(vec, back); \

vec_memcpy(val, VEC_REF(M) *item, sizeof(T)); \

vec_memset(item, 0, sizeof(*item)); \

} \

vec->last--; \

}

#define VEC_IMPLEMENT_COMMON_GET_AT(N, A, T, F, M) \

inline VEC_ITEM(T, M) A##_get_at(const N *vec, size_t index) \

{ \

VEC_ASSERT_REAL(vec); \

return *A##_static_get(vec, index + vec->first); \

}

#define VEC_IMPLEMENT_COMMON_GET_FRONT(N, A, T, F, M) \

inline VEC_ITEM(T, M) A##_get_front(const N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

return *A##_static_get(vec, vec->first); \

}

#define VEC_IMPLEMENT_COMMON_GET_BACK(N, A, T, F, M) \

inline VEC_ITEM(T, M) A##_get_back(const N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

return *A##_static_get(vec, vec->last - 1); \

}

#define VEC_IMPLEMENT_COMMON_SET_AT(N, A, T, F, M) \

inline void A##_set_at(N *vec, size_t index, VEC_ITEM(T, M) val) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT(val, M); \

T *item = VEC_REF(M) *A##_static_get(vec, index + vec->first); \

/* BAD! IDEA! E.G. WHEN SORGING! if(F != 0) VEC_TYPE_FREE(F, item, T);*/ \

vec_memcpy(item, VEC_REF(M) val, sizeof(T)); \

}

#define VEC_IMPLEMENT_COMMON_POP_AT(N, A, T, F, M) \

inline void A##_pop_at(N *vec, size_t index, T *val) \

{ \

VEC_ASSERT_REAL(vec); \

/*VEC_ASSERT(val, M);*/ \

VEC_ITEM(T, M) *item = A##_static_get(vec, index + vec->first); \

VEC_ITEM(T, M) pop = *item; \

if(val) { \

vec_memcpy(val, VEC_REF(M) *item, sizeof(T)); \

vec_memset(item, 0, sizeof(*item)); \

} \

VEC_ITEM(T, M) *last = A##_static_get(vec, vec->last - 1); \

vec->last--; \

vec_memmove(item, item + 1, sizeof(*item) * (vec->last - index - vec->first)); \

*last = pop; \

return; \

}

#define VEC_IMPLEMENT_COMMON_PUSH_AT(N, A, T, F, M) \

inline int A##_push_at(N *vec, size_t index, VEC_ITEM(T, M) val) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT(val, M); \

int result = A##_reserve(vec, vec->last + 1); \

if(result) return result; \

vec->last++; \

VEC_ITEM(T, M) *item = A##_static_get(vec, index + vec->first); \

vec_memmove(item + 1, item, sizeof(*item) * (vec->last - index - vec->first - 1)); \

vec_memcpy(VEC_REF(M) *item, VEC_REF(M) val, sizeof(T)); \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_COMMON_PUSH_FRONT(N, A, T, F, M) \

inline int A##_push_front(N *vec, VEC_ITEM(T, M) val) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT(val, M); \

int result = A##_reserve(vec, vec->last + 1); \

if(result) return result; \

size_t len = vec->last++ - vec->first; \

VEC_ITEM(T, M) *item = A##_static_get(vec, vec->first); \

vec_memmove(item + 1, item, sizeof(*item) * len); \

vec_memcpy(VEC_REF(M) *item, VEC_REF(M) val, sizeof(T)); \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_COMMON_PUSH_BACK(N, A, T, F, M) \

inline int A##_push_back(N *vec, VEC_ITEM(T, M) val) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ASSERT(val, M); \

int result = A##_reserve(vec, vec->last + 1); \

if(result) return result; \

size_t back = vec->last++; \

T *item = VEC_REF(M) *A##_static_get(vec, back); \

/* TODO add a new parameter: clearing function! so we don't free this! => we'll still overwrite 2 linew below... */ \

/*if(F != 0) VEC_TYPE_FREE(F, item, T);*/ /* required (?) in case we pop back (but don't free (?)) and then push back again */ \

vec_memcpy(item, VEC_REF(M) val, sizeof(T)); \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_COMMON_SWAP(N, A, T, F, M) \

inline void A##_swap(N *vec, size_t i1, size_t i2) \

{ \

VEC_ASSERT_REAL(vec); \

VEC_ITEM(T, M) *v1 = A##_static_get(vec, i1 + vec->first); \

VEC_ITEM(T, M) *v2 = A##_static_get(vec, i2 + vec->first); \

VEC_ITEM(T, M) tmp; \

vec_memcpy(&tmp, v1, sizeof(tmp)); \

vec_memcpy(v1, v2, sizeof(tmp)); \

vec_memcpy(v2, &tmp, sizeof(tmp)); \

}

#define VEC_IMPLEMENT_COMMON_REVERSE(N, A, T, F) \

inline void A##_reverse(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

size_t len = A##_length(*vec); \

size_t len2 = len / 2; \

for(size_t i = 0; i < len2; i++) { \

A##_swap(vec, i, len - i - 1); \

} \

}

#define VEC_IMPLEMENT_BY_VAL_FREE(N, A, T, F) \

inline void A##_free(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

if(!vec->VEC_STRUCT_ITEMS) return; \

/*printff(ERR_STRINGIFY(A) " freeing : %p", vec->VEC_STRUCT_ITEMS);*/\

if(F != 0) { \

for(size_t i = 0; i < vec->cap; i++) { \

/*printff(" freeing : %p", &vec->VEC_STRUCT_ITEMS[i]);*/\

VEC_TYPE_FREE(F, &vec->VEC_STRUCT_ITEMS[i], T); \

} \

} \

if(vec->cap) { \

free(vec->VEC_STRUCT_ITEMS); \

} \

A##_static_zero(vec); \

}

#define VEC_IMPLEMENT_BY_VAL_ZERO(N, A, T, F) \

inline void A##_zero(N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

vec_memset(vec, 0, sizeof(*vec)); \

}

#define VEC_IMPLEMENT_BY_VAL_RESERVED(N, A, T, F) \

inline size_t A##_reserved(const N *vec) \

{ \

VEC_ASSERT_REAL(vec); \

size_t result = 0; \

result += (sizeof(*vec->VEC_STRUCT_ITEMS) * vec->cap); \

return result; \

}

#define VEC_IMPLEMENT_BY_VAL_RESERVE(N, A, T, F) \

ErrImpl A##_reserve(N *vec, size_t cap) \

{ \

VEC_ASSERT_REAL(vec); \

cap += VEC_KEEP_ZERO_END; \

size_t cap_is = vec->cap; \

if(cap > cap_is) { \

size_t required = vec->cap ? vec->cap : VEC_DEFAULT_SIZE;\

while(required < cap) required *= 2; \

if(required > vec->cap) { \

void *temp = vec_realloc(vec->VEC_STRUCT_ITEMS, sizeof(*vec->VEC_STRUCT_ITEMS) * required); \

if(!temp) return VEC_ERROR_REALLOC; \

vec->VEC_STRUCT_ITEMS = temp; \

vec_memset(&vec->VEC_STRUCT_ITEMS[cap_is], 0, sizeof(*vec->VEC_STRUCT_ITEMS) * (required - cap_is)); \

vec->cap = required; \

} \

} \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_BY_VAL_COPY(N, A, T, F) \

ErrImpl A##_copy(N *dst, const N *src) \

{ \

VEC_ASSERT_REAL(dst); \

VEC_ASSERT_REAL(src); \

VEC_ASSERT_REAL(dst != src); \

A##_clear(dst); \

if(A##_length(*src)) { \

int result = A##_reserve(dst, A##_length(*src) + VEC_KEEP_ZERO_END); \

if(result) return result; \

vec_memcpy(A##_iter_begin(*dst), A##_iter_begin(*src), sizeof(*dst->VEC_STRUCT_ITEMS) * A##_length(*src)); \

dst->last = A##_length(*src); \

} \

if(VEC_KEEP_ZERO_END) { \

vec_memset(&dst->VEC_STRUCT_ITEMS[dst->last], 0, sizeof(*dst->VEC_STRUCT_ITEMS) * VEC_KEEP_ZERO_END); \

} \

return VEC_ERROR_NONE; \

}

#define VEC_IMPLEMENT_BY_REF_FREE(N, A, T, F) \

inline void A##_free(N *vec) \