New upstream version 24.0.1+dfsg1
This commit is contained in:
Sebastian Ramacher
parent
b14f9eae6d
commit
5a730d6ec3
842 changed files with 42245 additions and 33385 deletions
|
|
@ -46,50 +46,50 @@ struct darray {
|
|||
|
||||
static inline void darray_init(struct darray *dst)
|
||||
{
|
||||
dst->array = NULL;
|
||||
dst->num = 0;
|
||||
dst->array = NULL;
|
||||
dst->num = 0;
|
||||
dst->capacity = 0;
|
||||
}
|
||||
|
||||
static inline void darray_free(struct darray *dst)
|
||||
{
|
||||
bfree(dst->array);
|
||||
dst->array = NULL;
|
||||
dst->num = 0;
|
||||
dst->array = NULL;
|
||||
dst->num = 0;
|
||||
dst->capacity = 0;
|
||||
}
|
||||
|
||||
static inline size_t darray_alloc_size(const size_t element_size,
|
||||
const struct darray *da)
|
||||
const struct darray *da)
|
||||
{
|
||||
return element_size*da->num;
|
||||
return element_size * da->num;
|
||||
}
|
||||
|
||||
static inline void *darray_item(const size_t element_size,
|
||||
const struct darray *da, size_t idx)
|
||||
const struct darray *da, size_t idx)
|
||||
{
|
||||
return (void*)(((uint8_t*)da->array) + element_size*idx);
|
||||
return (void *)(((uint8_t *)da->array) + element_size * idx);
|
||||
}
|
||||
|
||||
static inline void *darray_end(const size_t element_size,
|
||||
const struct darray *da)
|
||||
const struct darray *da)
|
||||
{
|
||||
if (!da->num)
|
||||
return NULL;
|
||||
|
||||
return darray_item(element_size, da, da->num-1);
|
||||
return darray_item(element_size, da, da->num - 1);
|
||||
}
|
||||
|
||||
static inline void darray_reserve(const size_t element_size,
|
||||
struct darray *dst, const size_t capacity)
|
||||
static inline void darray_reserve(const size_t element_size, struct darray *dst,
|
||||
const size_t capacity)
|
||||
{
|
||||
void *ptr;
|
||||
if (capacity == 0 || capacity <= dst->num)
|
||||
return;
|
||||
|
||||
ptr = bmalloc(element_size*capacity);
|
||||
ptr = bmalloc(element_size * capacity);
|
||||
if (dst->num)
|
||||
memcpy(ptr, dst->array, element_size*dst->num);
|
||||
memcpy(ptr, dst->array, element_size * dst->num);
|
||||
if (dst->array)
|
||||
bfree(dst->array);
|
||||
dst->array = ptr;
|
||||
|
|
@ -97,27 +97,28 @@ static inline void darray_reserve(const size_t element_size,
|
|||
}
|
||||
|
||||
static inline void darray_ensure_capacity(const size_t element_size,
|
||||
struct darray *dst, const size_t new_size)
|
||||
struct darray *dst,
|
||||
const size_t new_size)
|
||||
{
|
||||
size_t new_cap;
|
||||
void *ptr;
|
||||
if (new_size <= dst->capacity)
|
||||
return;
|
||||
|
||||
new_cap = (!dst->capacity) ? new_size : dst->capacity*2;
|
||||
new_cap = (!dst->capacity) ? new_size : dst->capacity * 2;
|
||||
if (new_size > new_cap)
|
||||
new_cap = new_size;
|
||||
ptr = bmalloc(element_size*new_cap);
|
||||
ptr = bmalloc(element_size * new_cap);
|
||||
if (dst->capacity)
|
||||
memcpy(ptr, dst->array, element_size*dst->capacity);
|
||||
memcpy(ptr, dst->array, element_size * dst->capacity);
|
||||
if (dst->array)
|
||||
bfree(dst->array);
|
||||
dst->array = ptr;
|
||||
dst->capacity = new_cap;
|
||||
}
|
||||
|
||||
static inline void darray_resize(const size_t element_size,
|
||||
struct darray *dst, const size_t size)
|
||||
static inline void darray_resize(const size_t element_size, struct darray *dst,
|
||||
const size_t size)
|
||||
{
|
||||
int b_clear;
|
||||
size_t old_num;
|
||||
|
|
@ -137,38 +138,40 @@ static inline void darray_resize(const size_t element_size,
|
|||
|
||||
if (b_clear)
|
||||
memset(darray_item(element_size, dst, old_num), 0,
|
||||
element_size * (dst->num-old_num));
|
||||
element_size * (dst->num - old_num));
|
||||
}
|
||||
|
||||
static inline void darray_copy(const size_t element_size, struct darray *dst,
|
||||
const struct darray *da)
|
||||
const struct darray *da)
|
||||
{
|
||||
if (da->num == 0) {
|
||||
darray_free(dst);
|
||||
} else {
|
||||
darray_resize(element_size, dst, da->num);
|
||||
memcpy(dst->array, da->array, element_size*da->num);
|
||||
memcpy(dst->array, da->array, element_size * da->num);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void darray_copy_array(const size_t element_size,
|
||||
struct darray *dst, const void *array, const size_t num)
|
||||
struct darray *dst, const void *array,
|
||||
const size_t num)
|
||||
{
|
||||
darray_resize(element_size, dst, num);
|
||||
memcpy(dst->array, array, element_size*dst->num);
|
||||
memcpy(dst->array, array, element_size * dst->num);
|
||||
}
|
||||
|
||||
static inline void darray_move(struct darray *dst, struct darray *src)
|
||||
{
|
||||
darray_free(dst);
|
||||
memcpy(dst, src, sizeof(struct darray));
|
||||
src->array = NULL;
|
||||
src->array = NULL;
|
||||
src->capacity = 0;
|
||||
src->num = 0;
|
||||
src->num = 0;
|
||||
}
|
||||
|
||||
static inline size_t darray_find(const size_t element_size,
|
||||
const struct darray *da, const void *item, const size_t idx)
|
||||
const struct darray *da, const void *item,
|
||||
const size_t idx)
|
||||
{
|
||||
size_t i;
|
||||
|
||||
|
|
@ -184,16 +187,16 @@ static inline size_t darray_find(const size_t element_size,
|
|||
}
|
||||
|
||||
static inline size_t darray_push_back(const size_t element_size,
|
||||
struct darray *dst, const void *item)
|
||||
struct darray *dst, const void *item)
|
||||
{
|
||||
darray_ensure_capacity(element_size, dst, ++dst->num);
|
||||
memcpy(darray_end(element_size, dst), item, element_size);
|
||||
|
||||
return dst->num-1;
|
||||
return dst->num - 1;
|
||||
}
|
||||
|
||||
static inline void *darray_push_back_new(const size_t element_size,
|
||||
struct darray *dst)
|
||||
struct darray *dst)
|
||||
{
|
||||
void *last;
|
||||
|
||||
|
|
@ -205,7 +208,8 @@ static inline void *darray_push_back_new(const size_t element_size,
|
|||
}
|
||||
|
||||
static inline size_t darray_push_back_array(const size_t element_size,
|
||||
struct darray *dst, const void *array, const size_t num)
|
||||
struct darray *dst,
|
||||
const void *array, const size_t num)
|
||||
{
|
||||
size_t old_num;
|
||||
if (!dst)
|
||||
|
|
@ -214,21 +218,22 @@ static inline size_t darray_push_back_array(const size_t element_size,
|
|||
return dst->num;
|
||||
|
||||
old_num = dst->num;
|
||||
darray_resize(element_size, dst, dst->num+num);
|
||||
darray_resize(element_size, dst, dst->num + num);
|
||||
memcpy(darray_item(element_size, dst, old_num), array,
|
||||
element_size*num);
|
||||
element_size * num);
|
||||
|
||||
return old_num;
|
||||
}
|
||||
|
||||
static inline size_t darray_push_back_darray(const size_t element_size,
|
||||
struct darray *dst, const struct darray *da)
|
||||
struct darray *dst,
|
||||
const struct darray *da)
|
||||
{
|
||||
return darray_push_back_array(element_size, dst, da->array, da->num);
|
||||
}
|
||||
|
||||
static inline void darray_insert(const size_t element_size, struct darray *dst,
|
||||
const size_t idx, const void *item)
|
||||
const size_t idx, const void *item)
|
||||
{
|
||||
void *new_item;
|
||||
size_t move_count;
|
||||
|
|
@ -245,13 +250,13 @@ static inline void darray_insert(const size_t element_size, struct darray *dst,
|
|||
|
||||
new_item = darray_item(element_size, dst, idx);
|
||||
|
||||
memmove(darray_item(element_size, dst, idx+1), new_item,
|
||||
move_count*element_size);
|
||||
memmove(darray_item(element_size, dst, idx + 1), new_item,
|
||||
move_count * element_size);
|
||||
memcpy(new_item, item, element_size);
|
||||
}
|
||||
|
||||
static inline void *darray_insert_new(const size_t element_size,
|
||||
struct darray *dst, const size_t idx)
|
||||
struct darray *dst, const size_t idx)
|
||||
{
|
||||
void *item;
|
||||
size_t move_count;
|
||||
|
|
@ -264,16 +269,16 @@ static inline void *darray_insert_new(const size_t element_size,
|
|||
|
||||
move_count = dst->num - idx;
|
||||
darray_ensure_capacity(element_size, dst, ++dst->num);
|
||||
memmove(darray_item(element_size, dst, idx+1), item,
|
||||
move_count*element_size);
|
||||
memmove(darray_item(element_size, dst, idx + 1), item,
|
||||
move_count * element_size);
|
||||
|
||||
memset(item, 0, element_size);
|
||||
return item;
|
||||
}
|
||||
|
||||
static inline void darray_insert_array(const size_t element_size,
|
||||
struct darray *dst, const size_t idx,
|
||||
const void *array, const size_t num)
|
||||
struct darray *dst, const size_t idx,
|
||||
const void *array, const size_t num)
|
||||
{
|
||||
size_t old_num;
|
||||
|
||||
|
|
@ -282,22 +287,23 @@ static inline void darray_insert_array(const size_t element_size,
|
|||
assert(idx < dst->num);
|
||||
|
||||
old_num = dst->num;
|
||||
darray_resize(element_size, dst, dst->num+num);
|
||||
darray_resize(element_size, dst, dst->num + num);
|
||||
|
||||
memmove(darray_item(element_size, dst, idx+num),
|
||||
darray_item(element_size, dst, idx),
|
||||
element_size*(old_num-idx));
|
||||
memcpy(darray_item(element_size, dst, idx), array, element_size*num);
|
||||
memmove(darray_item(element_size, dst, idx + num),
|
||||
darray_item(element_size, dst, idx),
|
||||
element_size * (old_num - idx));
|
||||
memcpy(darray_item(element_size, dst, idx), array, element_size * num);
|
||||
}
|
||||
|
||||
static inline void darray_insert_darray(const size_t element_size,
|
||||
struct darray *dst, const size_t idx, const struct darray *da)
|
||||
struct darray *dst, const size_t idx,
|
||||
const struct darray *da)
|
||||
{
|
||||
darray_insert_array(element_size, dst, idx, da->array, da->num);
|
||||
}
|
||||
|
||||
static inline void darray_erase(const size_t element_size, struct darray *dst,
|
||||
const size_t idx)
|
||||
const size_t idx)
|
||||
{
|
||||
assert(idx < dst->num);
|
||||
|
||||
|
|
@ -305,12 +311,12 @@ static inline void darray_erase(const size_t element_size, struct darray *dst,
|
|||
return;
|
||||
|
||||
memmove(darray_item(element_size, dst, idx),
|
||||
darray_item(element_size, dst, idx+1),
|
||||
element_size*(dst->num-idx));
|
||||
darray_item(element_size, dst, idx + 1),
|
||||
element_size * (dst->num - idx));
|
||||
}
|
||||
|
||||
static inline void darray_erase_item(const size_t element_size,
|
||||
struct darray *dst, const void *item)
|
||||
struct darray *dst, const void *item)
|
||||
{
|
||||
size_t idx = darray_find(element_size, dst, item, 0);
|
||||
if (idx != DARRAY_INVALID)
|
||||
|
|
@ -318,7 +324,8 @@ static inline void darray_erase_item(const size_t element_size,
|
|||
}
|
||||
|
||||
static inline void darray_erase_range(const size_t element_size,
|
||||
struct darray *dst, const size_t start, const size_t end)
|
||||
struct darray *dst, const size_t start,
|
||||
const size_t end)
|
||||
{
|
||||
size_t count, move_count;
|
||||
|
||||
|
|
@ -326,7 +333,7 @@ static inline void darray_erase_range(const size_t element_size,
|
|||
assert(end <= dst->num);
|
||||
assert(end > start);
|
||||
|
||||
count = end-start;
|
||||
count = end - start;
|
||||
if (count == 1) {
|
||||
darray_erase(element_size, dst, start);
|
||||
return;
|
||||
|
|
@ -338,30 +345,31 @@ static inline void darray_erase_range(const size_t element_size,
|
|||
move_count = dst->num - end;
|
||||
if (move_count)
|
||||
memmove(darray_item(element_size, dst, start),
|
||||
darray_item(element_size, dst, end),
|
||||
move_count * element_size);
|
||||
darray_item(element_size, dst, end),
|
||||
move_count * element_size);
|
||||
|
||||
dst->num -= count;
|
||||
}
|
||||
|
||||
static inline void darray_pop_back(const size_t element_size,
|
||||
struct darray *dst)
|
||||
struct darray *dst)
|
||||
{
|
||||
assert(dst->num != 0);
|
||||
|
||||
if (dst->num)
|
||||
darray_erase(element_size, dst, dst->num-1);
|
||||
darray_erase(element_size, dst, dst->num - 1);
|
||||
}
|
||||
|
||||
static inline void darray_join(const size_t element_size, struct darray *dst,
|
||||
struct darray *da)
|
||||
struct darray *da)
|
||||
{
|
||||
darray_push_back_darray(element_size, dst, da);
|
||||
darray_free(da);
|
||||
}
|
||||
|
||||
static inline void darray_split(const size_t element_size, struct darray *dst1,
|
||||
struct darray *dst2, const struct darray *da, const size_t idx)
|
||||
struct darray *dst2, const struct darray *da,
|
||||
const size_t idx)
|
||||
{
|
||||
struct darray temp;
|
||||
|
||||
|
|
@ -377,43 +385,44 @@ static inline void darray_split(const size_t element_size, struct darray *dst1,
|
|||
if (da->num) {
|
||||
if (idx)
|
||||
darray_copy_array(element_size, dst1, temp.array,
|
||||
temp.num);
|
||||
if (idx < temp.num-1)
|
||||
temp.num);
|
||||
if (idx < temp.num - 1)
|
||||
darray_copy_array(element_size, dst2,
|
||||
darray_item(element_size, &temp, idx),
|
||||
temp.num-idx);
|
||||
darray_item(element_size, &temp, idx),
|
||||
temp.num - idx);
|
||||
}
|
||||
|
||||
darray_free(&temp);
|
||||
}
|
||||
|
||||
static inline void darray_move_item(const size_t element_size,
|
||||
struct darray *dst, const size_t from, const size_t to)
|
||||
struct darray *dst, const size_t from,
|
||||
const size_t to)
|
||||
{
|
||||
void *temp, *p_from, *p_to;
|
||||
|
||||
if (from == to)
|
||||
return;
|
||||
|
||||
temp = malloc(element_size);
|
||||
temp = malloc(element_size);
|
||||
p_from = darray_item(element_size, dst, from);
|
||||
p_to = darray_item(element_size, dst, to);
|
||||
p_to = darray_item(element_size, dst, to);
|
||||
|
||||
memcpy(temp, p_from, element_size);
|
||||
|
||||
if (to < from)
|
||||
memmove(darray_item(element_size, dst, to+1), p_to,
|
||||
element_size*(from-to));
|
||||
memmove(darray_item(element_size, dst, to + 1), p_to,
|
||||
element_size * (from - to));
|
||||
else
|
||||
memmove(p_from, darray_item(element_size, dst, from+1),
|
||||
element_size*(to-from));
|
||||
memmove(p_from, darray_item(element_size, dst, from + 1),
|
||||
element_size * (to - from));
|
||||
|
||||
memcpy(p_to, temp, element_size);
|
||||
free(temp);
|
||||
}
|
||||
|
||||
static inline void darray_swap(const size_t element_size,
|
||||
struct darray *dst, const size_t a, const size_t b)
|
||||
static inline void darray_swap(const size_t element_size, struct darray *dst,
|
||||
const size_t a, const size_t b)
|
||||
{
|
||||
void *temp, *a_ptr, *b_ptr;
|
||||
|
||||
|
|
@ -423,13 +432,13 @@ static inline void darray_swap(const size_t element_size,
|
|||
if (a == b)
|
||||
return;
|
||||
|
||||
temp = malloc(element_size);
|
||||
temp = malloc(element_size);
|
||||
a_ptr = darray_item(element_size, dst, a);
|
||||
b_ptr = darray_item(element_size, dst, b);
|
||||
|
||||
memcpy(temp, a_ptr, element_size);
|
||||
memcpy(temp, a_ptr, element_size);
|
||||
memcpy(a_ptr, b_ptr, element_size);
|
||||
memcpy(b_ptr, temp, element_size);
|
||||
memcpy(b_ptr, temp, element_size);
|
||||
|
||||
free(temp);
|
||||
}
|
||||
|
|
@ -457,7 +466,7 @@ static inline void darray_swap(const size_t element_size,
|
|||
|
||||
#define da_free(v) darray_free(&v.da)
|
||||
|
||||
#define da_alloc_size(v) (sizeof(*v.array)*v.num)
|
||||
#define da_alloc_size(v) (sizeof(*v.array) * v.num)
|
||||
|
||||
#define da_end(v) darray_end(sizeof(*v.array), &v.da)
|
||||
|
||||
|
|
@ -466,16 +475,14 @@ static inline void darray_swap(const size_t element_size,
|
|||
|
||||
#define da_resize(v, size) darray_resize(sizeof(*v.array), &v.da, size)
|
||||
|
||||
#define da_copy(dst, src) \
|
||||
darray_copy(sizeof(*dst.array), &dst.da, &src.da)
|
||||
#define da_copy(dst, src) darray_copy(sizeof(*dst.array), &dst.da, &src.da)
|
||||
|
||||
#define da_copy_array(dst, src_array, n) \
|
||||
darray_copy_array(sizeof(*dst.array), &dst.da, src_array, n)
|
||||
|
||||
#define da_move(dst, src) darray_move(&dst.da, &src.da)
|
||||
|
||||
#define da_find(v, item, idx) \
|
||||
darray_find(sizeof(*v.array), &v.da, item, idx)
|
||||
#define da_find(v, item, idx) darray_find(sizeof(*v.array), &v.da, item, idx)
|
||||
|
||||
#define da_push_back(v, item) darray_push_back(sizeof(*v.array), &v.da, item)
|
||||
|
||||
|
|
@ -490,19 +497,15 @@ static inline void darray_swap(const size_t element_size,
|
|||
#define da_insert(v, idx, item) \
|
||||
darray_insert(sizeof(*v.array), &v.da, idx, item)
|
||||
|
||||
#define da_insert_new(v, idx) \
|
||||
darray_insert_new(sizeof(*v.array), &v.da, idx)
|
||||
#define da_insert_new(v, idx) darray_insert_new(sizeof(*v.array), &v.da, idx)
|
||||
|
||||
#define da_insert_array(dst, idx, src_array, n) \
|
||||
darray_insert_array(sizeof(*dst.array), &dst.da, idx, \
|
||||
src_array, n)
|
||||
darray_insert_array(sizeof(*dst.array), &dst.da, idx, src_array, n)
|
||||
|
||||
#define da_insert_da(dst, idx, src) \
|
||||
darray_insert_darray(sizeof(*dst.array), &dst.da, idx, \
|
||||
&src.da)
|
||||
darray_insert_darray(sizeof(*dst.array), &dst.da, idx, &src.da)
|
||||
|
||||
#define da_erase(dst, idx) \
|
||||
darray_erase(sizeof(*dst.array), &dst.da, idx)
|
||||
#define da_erase(dst, idx) darray_erase(sizeof(*dst.array), &dst.da, idx)
|
||||
|
||||
#define da_erase_item(dst, item) \
|
||||
darray_erase_item(sizeof(*dst.array), &dst.da, item)
|
||||
|
|
@ -510,21 +513,17 @@ static inline void darray_swap(const size_t element_size,
|
|||
#define da_erase_range(dst, from, to) \
|
||||
darray_erase_range(sizeof(*dst.array), &dst.da, from, to)
|
||||
|
||||
#define da_pop_back(dst) \
|
||||
darray_pop_back(sizeof(*dst.array), &dst.da);
|
||||
#define da_pop_back(dst) darray_pop_back(sizeof(*dst.array), &dst.da);
|
||||
|
||||
#define da_join(dst, src) \
|
||||
darray_join(sizeof(*dst.array), &dst.da, &src.da)
|
||||
#define da_join(dst, src) darray_join(sizeof(*dst.array), &dst.da, &src.da)
|
||||
|
||||
#define da_split(dst1, dst2, src, idx) \
|
||||
darray_split(sizeof(*src.array), &dst1.da, &dst2.da, \
|
||||
&src.da, idx)
|
||||
darray_split(sizeof(*src.array), &dst1.da, &dst2.da, &src.da, idx)
|
||||
|
||||
#define da_move_item(v, from, to) \
|
||||
darray_move_item(sizeof(*v.array), &v.da, from, to)
|
||||
|
||||
#define da_swap(v, idx1, idx2) \
|
||||
darray_swap(sizeof(*v.array), &v.da, idx1, idx2)
|
||||
#define da_swap(v, idx1, idx2) darray_swap(sizeof(*v.array), &v.da, idx1, idx2)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue