admin/mlib
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Start porting to M_CALL infrastructure, enabling support for

Browse Source 
API transformation.
This commit is contained in:
Patrick Pelissier committed 2018-09-08 22:49:12 +02:00
1 parent 7c83d733cd
commit bb8de993b6
4 files changed
+163 -163
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

m-array.h
+54 -54
View File
@@ -137,7 +137,7 @@
{ \ { \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
for(size_t i = 0; i < v->size; i++) \ for(size_t i = 0; i < v->size; i++) \
M_GET_CLEAR oplist(v->ptr[i]); \ M_CALL_CLEAR(oplist, v->ptr[i]); \
v->size = 0; \ v->size = 0; \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
} \ } \
@@ -147,7 +147,7 @@
{ \ { \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
M_C(name, _clean)(v); \ M_C(name, _clean)(v); \
M_GET_FREE oplist(v->ptr); \ M_CALL_FREE(oplist, v->ptr); \
v->alloc = 0; \ v->alloc = 0; \
v->ptr = NULL; \ v->ptr = NULL; \
} \ } \
@@ -160,7 +160,7 @@
if (M_UNLIKELY (d == s)) return; \ if (M_UNLIKELY (d == s)) return; \
if (s->size > d->alloc) { \ if (s->size > d->alloc) { \
const size_t alloc = s->size; \ const size_t alloc = s->size; \
type *ptr = M_GET_REALLOC oplist (type, d->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, d->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL)) { \ if (M_UNLIKELY (ptr == NULL)) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return ; \ return ; \
@@ -170,11 +170,11 @@
} \ } \
size_t i, step1 = M_MIN(s->size, d->size); \ size_t i, step1 = M_MIN(s->size, d->size); \
for(i = 0; i < step1; i++) \ for(i = 0; i < step1; i++) \
M_GET_SET oplist (d->ptr[i], s->ptr[i]); \ M_CALL_SET(oplist, d->ptr[i], s->ptr[i]); \
for( ; i < s->size; i++) \ for( ; i < s->size; i++) \
M_GET_INIT_SET oplist (d->ptr[i], s->ptr[i]); \ M_CALL_INIT_SET(oplist, d->ptr[i], s->ptr[i]); \
for( ; i < d->size; i++) \ for( ; i < d->size; i++) \
M_GET_CLEAR oplist (d->ptr[i]); \ M_CALL_CLEAR(oplist, d->ptr[i]); \
d->size = s->size; \ d->size = s->size; \
ARRAYI_CONTRACT(d); \ ARRAYI_CONTRACT(d); \
} \ } \
@@ -213,7 +213,7 @@
{ \ { \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
assert(v->size > 0 && v->ptr != NULL && i < v->size); \ assert(v->size > 0 && v->ptr != NULL && i < v->size); \
M_GET_SET oplist(v->ptr[i], x); \ M_CALL_SET(oplist, v->ptr[i], x); \
} \ } \
\ \
static inline type const * \ static inline type const * \
@@ -230,13 +230,13 @@
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
if (M_UNLIKELY (v->size >= v->alloc)) { \ if (M_UNLIKELY (v->size >= v->alloc)) { \
assert(v->size == v->alloc); \ assert(v->size == v->alloc); \
size_t alloc = M_GET_INC_ALLOC oplist (v->alloc); \ size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc); \
if (M_UNLIKELY (alloc <= v->alloc)) { \ if (M_UNLIKELY (alloc <= v->alloc)) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return NULL; \ return NULL; \
} \ } \
assert (alloc > v->size); \ assert (alloc > v->size); \
type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return NULL; \ return NULL; \
@@ -257,7 +257,7 @@
type *data = M_C(name, _push_raw)(v); \ type *data = M_C(name, _push_raw)(v); \
if (M_UNLIKELY (data == NULL) ) \ if (M_UNLIKELY (data == NULL) ) \
return; \ return; \
M_GET_INIT_SET oplist(*data, x); \ M_CALL_INIT_SET(oplist, *data, x); \
} \ } \
\ \
M_IF_METHOD(INIT, oplist)( \ M_IF_METHOD(INIT, oplist)( \
@@ -267,7 +267,7 @@
type *data = M_C(name, _push_raw)(v); \ type *data = M_C(name, _push_raw)(v); \
if (M_UNLIKELY (data == NULL) ) \ if (M_UNLIKELY (data == NULL) ) \
return NULL; \ return NULL; \
M_GET_INIT oplist(*data); \ M_CALL_INIT(oplist, *data); \
return data; \ return data; \
} \ } \
, /* No INIT */ ) \ , /* No INIT */ ) \
@@ -289,13 +289,13 @@
assert (key <= v->size); \ assert (key <= v->size); \
if (M_UNLIKELY (v->size >= v->alloc) ) { \ if (M_UNLIKELY (v->size >= v->alloc) ) { \
assert(v->size == v->alloc); \ assert(v->size == v->alloc); \
size_t alloc = M_GET_INC_ALLOC oplist (v->alloc); \ size_t alloc = M_CALL_INC_ALLOC(oplist, v->alloc); \
if (M_UNLIKELY (alloc <= v->alloc)) { \ if (M_UNLIKELY (alloc <= v->alloc)) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return ; \ return ; \
} \ } \
assert (alloc > v->size); \ assert (alloc > v->size); \
type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return; \ return; \
@@ -306,7 +306,7 @@
assert(v->ptr != NULL); \ assert(v->ptr != NULL); \
memmove(&v->ptr[key+1], &v->ptr[key], (v->size-key)*sizeof(type)); \ memmove(&v->ptr[key+1], &v->ptr[key], (v->size-key)*sizeof(type)); \
v->size++; \ v->size++; \
M_GET_INIT_SET oplist (v->ptr[key], x); \ M_CALL_INIT_SET(oplist, v->ptr[key], x); \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
} \ } \
\ \
@@ -318,13 +318,13 @@
if (v->size > size) { \ if (v->size > size) { \
/* Decrease size of array */ \ /* Decrease size of array */ \
for(size_t i = size ; i < v->size; i++) \ for(size_t i = size ; i < v->size; i++) \
M_GET_CLEAR oplist(v->ptr[i]); \ M_CALL_CLEAR(oplist, v->ptr[i]); \
v->size = size; \ v->size = size; \
} else if (v->size < size) { \ } else if (v->size < size) { \
/* Increase size of array */ \ /* Increase size of array */ \
if (size > v->alloc) { \ if (size > v->alloc) { \
size_t alloc = size ; \ size_t alloc = size ; \
type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return; \ return; \
@@ -333,7 +333,7 @@
v->alloc = alloc; \ v->alloc = alloc; \
} \ } \
for(size_t i = v->size ; i < size; i++) \ for(size_t i = v->size ; i < size; i++) \
M_GET_INIT oplist(v->ptr[i]); \ M_CALL_INIT(oplist, v->ptr[i]); \
v->size = size; \ v->size = size; \
} \ } \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
@@ -349,11 +349,11 @@
alloc = v->size; \ alloc = v->size; \
} \ } \
if (M_UNLIKELY (alloc == 0)) { \ if (M_UNLIKELY (alloc == 0)) { \
M_GET_FREE oplist (v->ptr); \ M_CALL_FREE(oplist, v->ptr); \
v->size = v->alloc = 0; \ v->size = v->alloc = 0; \
v->ptr = NULL; \ v->ptr = NULL; \
} else { \ } else { \
type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return; \ return; \
@@ -374,13 +374,13 @@
if (v->size <= size) { \ if (v->size <= size) { \
/* Increase size of array */ \ /* Increase size of array */ \
if (M_UNLIKELY (size > v->alloc) ) { \ if (M_UNLIKELY (size > v->alloc) ) { \
size_t alloc = M_GET_INC_ALLOC oplist (size) ; \ size_t alloc = M_CALL_INC_ALLOC(oplist, size) ; \
/* In case of overflow of size_t */ \ /* In case of overflow of size_t */ \
if (M_UNLIKELY (alloc <= v->alloc)) { \ if (M_UNLIKELY (alloc <= v->alloc)) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return NULL; \ return NULL; \
} \ } \
type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return NULL; \ return NULL; \
@@ -389,7 +389,7 @@
v->alloc = alloc; \ v->alloc = alloc; \
} \ } \
for(size_t i = v->size ; i < size; i++) \ for(size_t i = v->size ; i < size; i++) \
M_GET_INIT oplist(v->ptr[i]); \ M_CALL_INIT(oplist, v->ptr[i]); \
v->size = size; \ v->size = size; \
} \ } \
assert (idx < v->size); \ assert (idx < v->size); \
@@ -407,7 +407,7 @@
if (dest) { \ if (dest) { \
M_DO_MOVE (oplist, *dest, v->ptr[v->size]); \ M_DO_MOVE (oplist, *dest, v->ptr[v->size]); \
} else { \ } else { \
M_GET_CLEAR oplist (v->ptr[v->size]); \ M_CALL_CLEAR(oplist, v->ptr[v->size]); \
} \ } \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
} \ } \
@@ -463,7 +463,7 @@
if (dest) \ if (dest) \
M_DO_MOVE (oplist, *dest, v->ptr[i]); \ M_DO_MOVE (oplist, *dest, v->ptr[i]); \
else \ else \
M_GET_CLEAR oplist (v->ptr[i]); \ M_CALL_CLEAR(oplist, v->ptr[i]); \
memmove(&v->ptr[i], &v->ptr[i+1], sizeof(type)*(v->size - i) ); \ memmove(&v->ptr[i], &v->ptr[i+1], sizeof(type)*(v->size - i) ); \
v->size--; \ v->size--; \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
@@ -478,12 +478,12 @@
size_t size = v->size + num; \ size_t size = v->size + num; \
/* Avoid overflow of v->size + num */ \ /* Avoid overflow of v->size + num */ \
if (v->size > v->alloc-num) { \ if (v->size > v->alloc-num) { \
size_t alloc = M_GET_INC_ALLOC oplist (size) ; \ size_t alloc = M_CALL_INC_ALLOC(oplist, size) ; \
if (M_UNLIKELY (size <= v->size || alloc <= v->alloc)) { \ if (M_UNLIKELY (size <= v->size || alloc <= v->alloc)) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return ; \ return ; \
} \ } \
type *ptr = M_GET_REALLOC oplist (type, v->ptr, alloc); \ type *ptr = M_CALL_REALLOC(oplist, type, v->ptr, alloc); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * alloc); \ M_MEMORY_FULL(sizeof (type) * alloc); \
return; \ return; \
@@ -493,7 +493,7 @@
} \ } \
memmove(&v->ptr[i+num], &v->ptr[i], sizeof(type)*(v->size - i) ); \ memmove(&v->ptr[i+num], &v->ptr[i], sizeof(type)*(v->size - i) ); \
for(size_t k = i ; k < i+num; k++) \ for(size_t k = i ; k < i+num; k++) \
M_GET_INIT oplist(v->ptr[k]); \ M_CALL_INIT(oplist, v->ptr[k]); \
v->size = size; \ v->size = size; \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
} \ } \
@@ -505,7 +505,7 @@
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
assert(i < v->size && j <= v->size && i < j && v->ptr != NULL); \ assert(i < v->size && j <= v->size && i < j && v->ptr != NULL); \
for(size_t k = i ; k < j; k++) \ for(size_t k = i ; k < j; k++) \
M_GET_CLEAR oplist(v->ptr[k]); \ M_CALL_CLEAR(oplist, v->ptr[k]); \
memmove(&v->ptr[i], &v->ptr[j], sizeof(type)*(v->size - j) ); \ memmove(&v->ptr[i], &v->ptr[j], sizeof(type)*(v->size - j) ); \
v->size -= (j-i); \ v->size -= (j-i); \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
@@ -536,14 +536,14 @@
assert(i < v->size && j < v->size && v->ptr != NULL); \ assert(i < v->size && j < v->size && v->ptr != NULL); \
type tmp; \ type tmp; \
M_IF_METHOD(INIT_MOVE, oplist) ( \ M_IF_METHOD(INIT_MOVE, oplist) ( \
M_GET_INIT_MOVE oplist (tmp, v->ptr[i]); \ M_CALL_INIT_MOVE(oplist, tmp, v->ptr[i]); \
M_GET_INIT_MOVE oplist (v->ptr[i], v->ptr[j]); \ M_CALL_INIT_MOVE(oplist, v->ptr[i], v->ptr[j]); \
M_GET_INIT_MOVE oplist (v->ptr[j], tmp); \ M_CALL_INIT_MOVE(oplist, v->ptr[j], tmp); \
, \ , \
M_GET_INIT_SET oplist (tmp, v->ptr[i]); \ M_CALL_INIT_SET(oplist, tmp, v->ptr[i]); \
M_GET_SET oplist(v->ptr[i], v->ptr[j]); \ M_CALL_SET(oplist, v->ptr[i], v->ptr[j]); \
M_GET_SET oplist(v->ptr[j], tmp); \ M_CALL_SET(oplist, v->ptr[j], tmp); \
M_GET_CLEAR oplist(tmp); \ M_CALL_CLEAR(oplist, tmp); \
) /* IF INIT_MOVE method */ \ ) /* IF INIT_MOVE method */ \
ARRAYI_CONTRACT(v); \ ARRAYI_CONTRACT(v); \
} \ } \
@@ -708,8 +708,8 @@
M_ASSUME(max >= th); \ M_ASSUME(max >= th); \
for(size_t i = 1; i < max; i++) { \ for(size_t i = 1; i < max; i++) { \
size_t j = i; \ size_t j = i; \
while (j > 0 && M_GET_CMP oplist (tab[k+j-1], tab[k+j]) > 0) { \ while (j > 0 && M_CALL_CMP(oplist, tab[k+j-1], tab[k+j]) > 0) { \
M_GET_SWAP oplist (tab[k+j-1], tab[k+j]); \ M_CALL_SWAP(oplist, tab[k+j-1], tab[k+j]); \
j = j - 1; \ j = j - 1; \
} \ } \
} \ } \
@@ -730,8 +730,8 @@
assert (0 < n2 && n2 <= size); \ assert (0 < n2 && n2 <= size); \
k += n1+n2; \ k += n1+n2; \
for (;;) { \ for (;;) { \
if (M_GET_CMP oplist (*el1, *el2) <= 0) { \ if (M_CALL_CMP(oplist, *el1, *el2) <= 0) { \
M_GET_SET oplist (*dest, *el1); \ M_CALL_SET(oplist, *dest, *el1); \
dest++; \ dest++; \
el1++; \ el1++; \
if (-- n1 == 0) { \ if (-- n1 == 0) { \
@@ -742,7 +742,7 @@
break; \ break; \
} \ } \
} else { \ } else { \
M_GET_SET oplist (*dest, *el2); \ M_CALL_SET(oplist, *dest, *el2); \
dest++; \ dest++; \
el2++; \ el2++; \
if (-- n2 == 0) { \ if (-- n2 == 0) { \
@@ -768,13 +768,13 @@
{ \ { \
if (M_UNLIKELY (l->size < 2)) \ if (M_UNLIKELY (l->size < 2)) \
return; \ return; \
type *temp = M_GET_REALLOC oplist (type, NULL, l->size); \ type *temp = M_CALL_REALLOC(oplist, type, NULL, l->size); \
if (temp == NULL) { \ if (temp == NULL) { \
M_MEMORY_FULL(sizeof (type) * l->size); \ M_MEMORY_FULL(sizeof (type) * l->size); \
return ; \ return ; \
} \ } \
M_C(name, _special_stable_sort_noalloc)(l->ptr, l->size, temp); \ M_C(name, _special_stable_sort_noalloc)(l->ptr, l->size, temp); \
M_GET_FREE oplist(temp); \ M_CALL_FREE(oplist, temp); \
} \ } \
,) /* IF SWAP method */ \ ,) /* IF SWAP method */ \
\ \
@@ -793,7 +793,7 @@
!M_C(name, _end_p)(it); \ !M_C(name, _end_p)(it); \
M_C(name, _next)(it)){ \ M_C(name, _next)(it)){ \
type const *item = M_C(name, _cref)(it); \ type const *item = M_C(name, _cref)(it); \
M_GET_GET_STR oplist (str, *item, true); \ M_CALL_GET_STR(oplist, str, *item, true); \
if (!M_C(name, _last_p)(it)) \ if (!M_C(name, _last_p)(it)) \
string_push_back (str, M_GET_SEPARATOR oplist); \ string_push_back (str, M_GET_SEPARATOR oplist); \
} \ } \
@@ -811,7 +811,7 @@
fputc ('[', file); \ fputc ('[', file); \
for (size_t i = 0; i < array->size; i++) { \ for (size_t i = 0; i < array->size; i++) { \
type const *item = M_C(name, _cget)(array, i); \ type const *item = M_C(name, _cget)(array, i); \
M_GET_OUT_STR oplist (file, *item); \ M_CALL_OUT_STR(oplist, file, *item); \
if (i != array->size-1) \ if (i != array->size-1) \
fputc (M_GET_SEPARATOR oplist, file); \ fputc (M_GET_SEPARATOR oplist, file); \
} \ } \
@@ -834,14 +834,14 @@
if (M_UNLIKELY (c == 0)) goto exit; \ if (M_UNLIKELY (c == 0)) goto exit; \
str--; \ str--; \
type item; \ type item; \
M_GET_INIT oplist (item); \ M_CALL_INIT(oplist, item); \
do { \ do { \
bool b = M_GET_PARSE_STR oplist (item, str, &str); \ bool b = M_CALL_PARSE_STR(oplist, item, str, &str); \
do { c = *str++; } while (isspace(c)); \ do { c = *str++; } while (isspace(c)); \
if (b == false || c == 0) { goto exit; } \ if (b == false || c == 0) { goto exit; } \
M_C(name, _push_back)(array, item); \ M_C(name, _push_back)(array, item); \
} while (c == M_GET_SEPARATOR oplist); \ } while (c == M_GET_SEPARATOR oplist); \
M_GET_CLEAR oplist (item); \ M_CALL_CLEAR(oplist, item); \
ARRAYI_CONTRACT(array); \ ARRAYI_CONTRACT(array); \
success = (c == ']'); \ success = (c == ']'); \
exit: \ exit: \
@@ -864,14 +864,14 @@
if (M_UNLIKELY (c == EOF)) return false; \ if (M_UNLIKELY (c == EOF)) return false; \
ungetc(c, file); \ ungetc(c, file); \
type item; \ type item; \
M_GET_INIT oplist (item); \ M_CALL_INIT(oplist, item); \
do { \ do { \
bool b = M_GET_IN_STR oplist (item, file); \ bool b = M_CALL_IN_STR(oplist, item, file); \
do { c = fgetc(file); } while (isspace(c)); \ do { c = fgetc(file); } while (isspace(c)); \
if (b == false || c == EOF) { break; } \ if (b == false || c == EOF) { break; } \
M_C(name, _push_back)(array, item); \ M_C(name, _push_back)(array, item); \
} while (c == M_GET_SEPARATOR oplist); \ } while (c == M_GET_SEPARATOR oplist); \
M_GET_CLEAR oplist (item); \ M_CALL_CLEAR(oplist, item); \
ARRAYI_CONTRACT(array); \ ARRAYI_CONTRACT(array); \
return c == ']'; \ return c == ']'; \
} \ } \
@@ -889,7 +889,7 @@
for(i = 0; i < array1->size; i++) { \ for(i = 0; i < array1->size; i++) { \
type const *item1 = M_C(name, _cget)(array1, i); \ type const *item1 = M_C(name, _cget)(array1, i); \
type const *item2 = M_C(name, _cget)(array2, i); \ type const *item2 = M_C(name, _cget)(array2, i); \
bool b = M_GET_EQUAL oplist (*item1, *item2); \ bool b = M_CALL_EQUAL(oplist, *item1, *item2); \
if (!b) return false; \ if (!b) return false; \
} \ } \
return i == array1->size; \ return i == array1->size; \
@@ -903,7 +903,7 @@
ARRAYI_CONTRACT(array); \ ARRAYI_CONTRACT(array); \
M_HASH_DECL(hash); \ M_HASH_DECL(hash); \
for(size_t i = 0 ; i < array->size; i++) { \ for(size_t i = 0 ; i < array->size; i++) { \
size_t hi = M_GET_HASH oplist (array->ptr[i]); \ size_t hi = M_CALL_HASH(oplist, array->ptr[i]); \
M_HASH_UP(hash, hi); \ M_HASH_UP(hash, hi); \
} \ } \
return M_HASH_FINAL (hash); \ return M_HASH_FINAL (hash); \
@@ -918,7 +918,7 @@
if (M_LIKELY (a2->size > 0)) { \ if (M_LIKELY (a2->size > 0)) { \
size_t newSize = a1->size + a2->size; \ size_t newSize = a1->size + a2->size; \
if (newSize > a1->alloc) { \ if (newSize > a1->alloc) { \
type *ptr = M_GET_REALLOC oplist (type, a1->ptr, newSize); \ type *ptr = M_CALL_REALLOC(oplist, type, a1->ptr, newSize); \
if (M_UNLIKELY (ptr == NULL) ) { \ if (M_UNLIKELY (ptr == NULL) ) { \
M_MEMORY_FULL(sizeof (type) * newSize); \ M_MEMORY_FULL(sizeof (type) * newSize); \
} \ } \
m-bptree.h
+54 -54
View File
@@ -151,10 +151,10 @@
assert (c2 <= num2 && num2 <= N); \ assert (c2 <= num2 && num2 <= N); \
} \ } \
for(int i2 = 1; i2 < num2 ; i2++) { \ for(int i2 = 1; i2 < num2 ; i2++) { \
assert (M_GET_CMP key_oplist((node)->key[i2-1], (node)->key[i2]) < 0); \ assert (M_CALL_CMP(key_oplist, (node)->key[i2-1], (node)->key[i2]) < 0); \
} \ } \
if ((node)->next != NULL) \ if ((node)->next != NULL) \
assert (M_GET_CMP key_oplist((node)->key[num2-1], (node)->next->key[0]) < 0); \ assert (M_CALL_CMP(key_oplist, (node)->key[num2-1], (node)->next->key[0]) < 0); \
} while (0) } while (0)
#endif #endif
@@ -217,7 +217,7 @@
/* Can be optimized later to alloc for leaf or for node */ \ /* Can be optimized later to alloc for leaf or for node */ \
static inline node_t M_C(name, _new_node)(void) \ static inline node_t M_C(name, _new_node)(void) \
{ \ { \
node_t n = M_GET_NEW key_oplist (struct M_C(name, _node_s)); \ node_t n = M_CALL_NEW(key_oplist, struct M_C(name, _node_s)); \
if (M_UNLIKELY (n == NULL)) { \ if (M_UNLIKELY (n == NULL)) { \
M_MEMORY_FULL(sizeof (node_t)); \ M_MEMORY_FULL(sizeof (node_t)); \
assert (0); \ assert (0); \
@@ -270,15 +270,15 @@
int num = M_C(name, _get_num)(n); \ int num = M_C(name, _get_num)(n); \
M_IF(isMap)(bool is_leaf = M_C(name, _is_leaf)(n);,) \ M_IF(isMap)(bool is_leaf = M_C(name, _is_leaf)(n);,) \
for(int j = 0; j < num; j++) { \ for(int j = 0; j < num; j++) { \
M_GET_CLEAR key_oplist(n->key[j]); \ M_CALL_CLEAR(key_oplist, n->key[j]); \
M_IF(isMap)(if (is_leaf) { \ M_IF(isMap)(if (is_leaf) { \
M_GET_CLEAR value_oplist (n->kind.value[j]); \ M_CALL_CLEAR(value_oplist, n->kind.value[j]); \
},) \ },) \
} \ } \
/* Next node of the same height */ \ /* Next node of the same height */ \
next = n->next; \ next = n->next; \
if (i != 0) { \ if (i != 0) { \
M_GET_DEL key_oplist (n); \ M_CALL_DEL(key_oplist, n); \
} \ } \
n = next; \ n = next; \
} \ } \
@@ -294,7 +294,7 @@
BPTREEI_CONTRACT(N, key_oplist, b); \ BPTREEI_CONTRACT(N, key_oplist, b); \
M_C(name, _clean)(b); \ M_C(name, _clean)(b); \
/* Once the tree is clean, only the root remains */ \ /* Once the tree is clean, only the root remains */ \
M_GET_DEL key_oplist (b->root); \ M_CALL_DEL(key_oplist, b->root); \
b->root = NULL; \ b->root = NULL; \
} \ } \
\ \
@@ -305,12 +305,12 @@
n->next = NULL; \ n->next = NULL; \
int num = M_C(name, _get_num)(o); \ int num = M_C(name, _get_num)(o); \
for(int i = 0; i < num; i++) { \ for(int i = 0; i < num; i++) { \
M_GET_INIT_SET key_oplist(n->key[i], o->key[i]); \ M_CALL_INIT_SET(key_oplist, n->key[i], o->key[i]); \
} \ } \
if (M_C(name, _is_leaf)(o)) { \ if (M_C(name, _is_leaf)(o)) { \
M_IF(isMap)( \ M_IF(isMap)( \
for(int i = 0; i < num; i++) { \ for(int i = 0; i < num; i++) { \
M_GET_INIT_SET value_oplist (n->kind.value[i], o->kind.value[i]); \ M_CALL_INIT_SET(value_oplist, n->kind.value[i], o->kind.value[i]); \
} \ } \
,) \ ,) \
} else { \ } else { \
@@ -375,7 +375,7 @@
the choosen type and size , it simply means that the \ the choosen type and size , it simply means that the \
size of B+TREE is too big (TBC) and shall be reduced. */ \ size of B+TREE is too big (TBC) and shall be reduced. */ \
for(i = 0; i < hi; i++) { \ for(i = 0; i < hi; i++) { \
if (M_GET_CMP key_oplist (key, n->key[i]) < 0) \ if (M_CALL_CMP(key_oplist, key, n->key[i]) < 0) \
break; \ break; \
} \ } \
pit->parent[np++] = n; \ pit->parent[np++] = n; \
@@ -395,7 +395,7 @@
int cmp = 0; \ int cmp = 0; \
BPTREEI_NODE_CONTRACT(N, key_oplist, n, b->root); \ BPTREEI_NODE_CONTRACT(N, key_oplist, n, b->root); \
for(int i = 0; cmp >= 0 && i < -n->num; i++) { \ for(int i = 0; cmp >= 0 && i < -n->num; i++) { \
cmp = M_GET_CMP key_oplist (key, n->key[i]); \ cmp = M_CALL_CMP(key_oplist, key, n->key[i]); \
if (cmp == 0) \ if (cmp == 0) \
return M_IF(isMap)(&n->kind.value[i],&n->key[i]); \ return M_IF(isMap)(&n->kind.value[i],&n->key[i]); \
} \ } \
@@ -413,10 +413,10 @@
int i, num = M_C(name, _get_num)(n); \ int i, num = M_C(name, _get_num)(n); \
assert (num <= N); \ assert (num <= N); \
for(i = 0; i < num; i++) { \ for(i = 0; i < num; i++) { \
int cmp = M_GET_CMP key_oplist (key, n->key[i]); \ int cmp = M_CALL_CMP(key_oplist, key, n->key[i]); \
if (cmp <= 0) { \ if (cmp <= 0) { \
if (M_UNLIKELY (cmp == 0)) { \ if (M_UNLIKELY (cmp == 0)) { \
M_IF(isMap)(M_GET_SET value_oplist (n->kind.value[i], value);,) \ M_IF(isMap)(M_CALL_SET(value_oplist, n->kind.value[i], value);,) \
return -1; \ return -1; \
} \ } \
/* Move tables to make space for insertion */ \ /* Move tables to make space for insertion */ \
@@ -425,8 +425,8 @@
break; \ break; \
} \ } \
} \ } \
M_GET_INIT_SET key_oplist (n->key[i], key); \ M_CALL_INIT_SET(key_oplist, n->key[i], key); \
M_IF(isMap)(M_GET_INIT_SET value_oplist (n->kind.value[i], value);,) \ M_IF(isMap)(M_CALL_INIT_SET(value_oplist, n->kind.value[i], value);,) \
n->num += -1; /* Increase num as num<0 for leaf */ \ n->num += -1; /* Increase num as num<0 for leaf */ \
return i; \ return i; \
} \ } \
@@ -437,7 +437,7 @@
int i, num = M_C(name, _get_num)(n); \ int i, num = M_C(name, _get_num)(n); \
assert (num <= N); \ assert (num <= N); \
for(i = 0; i < num; i++) { \ for(i = 0; i < num; i++) { \
int cmp = M_GET_CMP key_oplist (key, n->key[i]); \ int cmp = M_CALL_CMP(key_oplist, key, n->key[i]); \
assert (cmp != 0); \ assert (cmp != 0); \
if (cmp < 0) { \ if (cmp < 0) { \
/* Move tables to make space for insertion */ \ /* Move tables to make space for insertion */ \
@@ -446,7 +446,7 @@
break; \ break; \
} \ } \
} \ } \
M_GET_INIT_SET key_oplist (n->key[i], key); \ M_CALL_INIT_SET(key_oplist, n->key[i], key); \
n->num += 1; \ n->num += 1; \
return i; \ return i; \
} \ } \
@@ -492,7 +492,7 @@
/* We reach root. Need to increase the height of the tree.*/ \ /* We reach root. Need to increase the height of the tree.*/ \
node_t parent = M_C(name, _new_node)(); \ node_t parent = M_C(name, _new_node)(); \
parent->num = 1; \ parent->num = 1; \
M_GET_INIT_SET key_oplist (parent->key[0], *key_ptr); \ M_CALL_INIT_SET(key_oplist, parent->key[0], *key_ptr); \
parent->kind.node[0] = leaf; \ parent->kind.node[0] = leaf; \
parent->kind.node[1] = nleaf; \ parent->kind.node[1] = nleaf; \
b->root = parent; \ b->root = parent; \
@@ -537,10 +537,10 @@
assert(M_C(name, _is_leaf)(n)); \ assert(M_C(name, _is_leaf)(n)); \
int num = M_C(name, _get_num)(n); \ int num = M_C(name, _get_num)(n); \
for(int i = 0; i < num; i++) { \ for(int i = 0; i < num; i++) { \
int cmp = M_GET_CMP key_oplist(key, n->key[i]); \ int cmp = M_CALL_CMP(key_oplist, key, n->key[i]); \
if (cmp == 0) { \ if (cmp == 0) { \
M_GET_CLEAR key_oplist (n->key[i]); \ M_CALL_CLEAR(key_oplist, n->key[i]); \
M_IF(isMap)(M_GET_CLEAR value_oplist (n->kind.value[i]);,) \ M_IF(isMap)(M_CALL_CLEAR(value_oplist, n->kind.value[i]);,) \
memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(num-1-i)); \ memmove(&n->key[i], &n->key[i+1], sizeof(key_t)*(num-1-i)); \
M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(num-1-i));,) \ M_IF(isMap)(memmove(&n->kind.value[i], &n->kind.value[i+1], sizeof(value_t)*(num-1-i));,) \
n->num -= -1; /* decrease number as num is < 0 */ \ n->num -= -1; /* decrease number as num is < 0 */ \
@@ -569,7 +569,7 @@
M_IF(isMap)(memmove (&right->kind.value[0], &left->kind.value[num_left-1], sizeof (value_t));,) \ M_IF(isMap)(memmove (&right->kind.value[0], &left->kind.value[num_left-1], sizeof (value_t));,) \
right->num = -num_right - 1; \ right->num = -num_right - 1; \
left->num = -num_left + 1; \ left->num = -num_left + 1; \
M_GET_SET key_oplist (parent->key[k], right->key[0]); \ M_CALL_SET(key_oplist, parent->key[k], right->key[0]); \
} else { \ } else { \
memmove(&right->kind.node[1], &right->kind.node[0], sizeof(node_t)*(num_right+1)); \ memmove(&right->kind.node[1], &right->kind.node[0], sizeof(node_t)*(num_right+1)); \
/* parent[k] is move to right[0] (clear). parent[k] is therefore clear */ \ /* parent[k] is move to right[0] (clear). parent[k] is therefore clear */ \
@@ -603,7 +603,7 @@
M_IF(isMap)(memmove (&right->kind.value[0], &right->kind.value[1], sizeof(value_t)*(num_right-1));,) \ M_IF(isMap)(memmove (&right->kind.value[0], &right->kind.value[1], sizeof(value_t)*(num_right-1));,) \
right->num = -num_right + 1; \ right->num = -num_right + 1; \
left->num = -num_left - 1; \ left->num = -num_left - 1; \
M_GET_SET key_oplist (parent->key[k], right->key[0]); \ M_CALL_SET(key_oplist, parent->key[k], right->key[0]); \
} else { \ } else { \
memmove (&left->key[num_left], &parent->key[k], sizeof (key_t)); \ memmove (&left->key[num_left], &parent->key[k], sizeof (key_t)); \
memmove (&parent->key[k], &right->key[0], sizeof (key_t)); \ memmove (&parent->key[k], &right->key[0], sizeof (key_t)); \
@@ -637,13 +637,13 @@
assert (num_left + num_right + 1 <= N); \ assert (num_left + num_right + 1 <= N); \
memmove(&left->key[num_left+1], &right->key[0], sizeof(key_t)*num_right); \ memmove(&left->key[num_left+1], &right->key[0], sizeof(key_t)*num_right); \
memmove(&left->kind.node[num_left+1], &right->kind.node[0], sizeof(node_t)*(num_right+1)); \ memmove(&left->kind.node[num_left+1], &right->kind.node[0], sizeof(node_t)*(num_right+1)); \
M_GET_INIT_SET key_oplist (left->key[num_left], parent->key[k]); \ M_CALL_INIT_SET(key_oplist, left->key[num_left], parent->key[k]); \
left->num = num_left + 1 + num_right; \ left->num = num_left + 1 + num_right; \
} \ } \
left->next = right->next; \ left->next = right->next; \
M_GET_DEL key_oplist (right); \ M_CALL_DEL(key_oplist, right); \
/* remove k'th key from the parent */ \ /* remove k'th key from the parent */ \
M_GET_CLEAR key_oplist (parent->key[k]); \ M_CALL_CLEAR(key_oplist, parent->key[k]); \
memmove(&parent->key[k], &parent->key[k+1], sizeof(key_t)*(num_parent - k - 1)); \ memmove(&parent->key[k], &parent->key[k+1], sizeof(key_t)*(num_parent - k - 1)); \
memmove(&parent->kind.node[k+1], &parent->kind.node[k+2], sizeof(node_t)*(num_parent - k -1)); \ memmove(&parent->kind.node[k+1], &parent->kind.node[k+2], sizeof(node_t)*(num_parent - k -1)); \
parent->num --; \ parent->num --; \
@@ -705,7 +705,7 @@
if (M_C(name, _get_num)(parent) == 0) { \ if (M_C(name, _get_num)(parent) == 0) { \
/* Update root (deleted) */ \ /* Update root (deleted) */ \
b->root = parent->kind.node[0]; \ b->root = parent->kind.node[0]; \
M_GET_DEL key_oplist (parent); \ M_CALL_DEL(key_oplist, parent); \
} \ } \
return true; \ return true; \
} \ } \
@@ -722,7 +722,7 @@
if (ref == NULL) { \ if (ref == NULL) { \
return false; \ return false; \
} \ } \
M_GET_SET value_oplist (*ptr, *ref); \ M_CALL_SET(value_oplist, *ptr, *ref); \
} \ } \
return M_C(name, _remove)(b, key); \ return M_C(name, _remove)(b, key); \
} \ } \
@@ -820,7 +820,7 @@
int i; \ int i; \
BPTREEI_NODE_CONTRACT(N, key_oplist, n, b->root); \ BPTREEI_NODE_CONTRACT(N, key_oplist, n, b->root); \
for(i = 0; i < -n->num; i++) { \ for(i = 0; i < -n->num; i++) { \
if (M_GET_CMP key_oplist (key, n->key[i]) <= 0) \ if (M_CALL_CMP(key_oplist, key, n->key[i]) <= 0) \
break; \ break; \
} \ } \
if (i == -n->num && n->next != NULL) { \ if (i == -n->num && n->next != NULL) { \
@@ -836,7 +836,7 @@
assert (it != NULL); \ assert (it != NULL); \
node_t n = it->node; \ node_t n = it->node; \
if (it->idx >= -n->num) return true; \ if (it->idx >= -n->num) return true; \
int cmp = M_GET_CMP key_oplist (n->key[it->idx], key); \ int cmp = M_CALL_CMP(key_oplist, n->key[it->idx], key); \
return (cmp >= 0); \ return (cmp >= 0); \
} \ } \
\ \
@@ -936,12 +936,12 @@
const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it1); \ const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it1); \
const M_C(name, _type_t) *ref2 = M_C(name, _cref)(it2); \ const M_C(name, _type_t) *ref2 = M_C(name, _cref)(it2); \
M_IF(isMap)( \ M_IF(isMap)( \
if (!M_GET_EQUAL key_oplist (*ref1->key_ptr, *ref2->key_ptr)) \ if (!M_CALL_EQUAL(key_oplist, *ref1->key_ptr, *ref2->key_ptr)) \
return false; \ return false; \
if (!M_GET_EQUAL value_oplist (*ref1->value_ptr, *ref2->value_ptr)) \ if (!M_CALL_EQUAL(value_oplist, *ref1->value_ptr, *ref2->value_ptr)) \
return false; \ return false; \
, \ , \
if (!M_GET_EQUAL key_oplist (*ref1, *ref2)) \ if (!M_CALL_EQUAL(key_oplist, *ref1, *ref2)) \
return false; \ return false; \
) \ ) \
M_C(name, _next)(it1); \ M_C(name, _next)(it1); \
@@ -963,10 +963,10 @@
while (!M_C(name, _end_p)(it1)) { \ while (!M_C(name, _end_p)(it1)) { \
const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it1); \ const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it1); \
M_IF(isMap)( \ M_IF(isMap)( \
M_HASH_UP(hash, M_GET_HASH key_oplist (*ref1->key_ptr)); \ M_HASH_UP(hash, M_CALL_HASH(key_oplist, *ref1->key_ptr)); \
M_HASH_UP(hash, M_GET_HASH value_oplist (*ref1->value_ptr)); \ M_HASH_UP(hash, M_CALL_HASH(value_oplist, *ref1->value_ptr)); \
, \ , \
M_HASH_UP(hash, M_GET_HASH key_oplist (*ref1)); \ M_HASH_UP(hash, M_CALL_HASH(key_oplist, *ref1)); \
) \ ) \
M_C(name, _next)(it1); \ M_C(name, _next)(it1); \
} \ } \
@@ -991,11 +991,11 @@
commaToPrint = true; \ commaToPrint = true; \
const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \ const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \
M_IF(isMap)( \ M_IF(isMap)( \
M_GET_GET_STR key_oplist(str, *ref1->key_ptr, true); \ M_CALL_GET_STR(key_oplist, str, *ref1->key_ptr, true); \
string_cat_str(str, ":"); \ string_cat_str(str, ":"); \
M_GET_GET_STR value_oplist(str, *ref1->value_ptr, true) \ M_CALL_GET_STR(value_oplist,str, *ref1->value_ptr, true) \
, \ , \
M_GET_GET_STR key_oplist(str, *ref1, true); \ M_CALL_GET_STR(key_oplist, str, *ref1, true); \
); \ ); \
} \ } \
string_push_back (str, ']'); \ string_push_back (str, ']'); \
@@ -1019,11 +1019,11 @@
commaToPrint = true; \ commaToPrint = true; \
const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \ const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \
M_IF(isMap)( \ M_IF(isMap)( \
M_GET_OUT_STR key_oplist(file, *ref1->key_ptr); \ M_CALL_OUT_STR(key_oplist, file, *ref1->key_ptr); \
fputc (':', file); \ fputc (':', file); \
M_GET_OUT_STR value_oplist(file, *ref1->value_ptr) \ M_CALL_OUT_STR(value_oplist, file, *ref1->value_ptr) \
, \ , \
M_GET_OUT_STR key_oplist(file, *ref1); \ M_CALL_OUT_STR(key_oplist, file, *ref1); \
); \ ); \
} \ } \
fputc (']', file); \ fputc (']', file); \
@@ -1045,16 +1045,16 @@
if (M_UNLIKELY (c == 0)) goto exit; \ if (M_UNLIKELY (c == 0)) goto exit; \
str--; \ str--; \
key_t key; \ key_t key; \
M_GET_INIT key_oplist (key); \ M_CALL_INIT(key_oplist, key); \
M_IF(isMap)(value_t value; \ M_IF(isMap)(value_t value; \
M_GET_INIT value_oplist (value); \ M_CALL_INIT(value_oplist, value); \
,) \ ,) \
do { \ do { \
bool b = M_GET_PARSE_STR key_oplist (key, str, &str); \ bool b = M_CALL_PARSE_STR(key_oplist, key, str, &str); \
do { c = *str++; } while (isspace(c)); \ do { c = *str++; } while (isspace(c)); \
if (b == false) goto exit; \ if (b == false) goto exit; \
M_IF(isMap)(if (c != ':') goto exit; \ M_IF(isMap)(if (c != ':') goto exit; \
b = M_GET_PARSE_STR value_oplist(value, str, &str); \ b = M_CALL_PARSE_STR(value_oplist, value, str, &str); \
do { c = *str++; } while (isspace(c)); \ do { c = *str++; } while (isspace(c)); \
if (b == false || c == 0) goto exit; \ if (b == false || c == 0) goto exit; \
M_C(name, _set_at)(t1, key, value) \ M_C(name, _set_at)(t1, key, value) \
@@ -1062,8 +1062,8 @@
M_C(name, _push)(t1, key) \ M_C(name, _push)(t1, key) \
); \ ); \
} while (c == M_GET_SEPARATOR key_oplist); \ } while (c == M_GET_SEPARATOR key_oplist); \
M_GET_CLEAR key_oplist (key); \ M_CALL_CLEAR(key_oplist, key); \
M_IF(isMap)(M_GET_CLEAR value_oplist (value); \ M_IF(isMap)(M_CALL_CLEAR(value_oplist, value); \
,) \ ,) \
success = (c == ']'); \ success = (c == ']'); \
exit: \ exit: \
@@ -1086,16 +1086,16 @@
if (M_UNLIKELY (c == EOF)) return false; \ if (M_UNLIKELY (c == EOF)) return false; \
ungetc(c, file); \ ungetc(c, file); \
key_t key; \ key_t key; \
M_GET_INIT key_oplist (key); \ M_CALL_INIT (key_oplist, key); \
M_IF(isMap)(value_t value; \ M_IF(isMap)(value_t value; \
M_GET_INIT value_oplist (value); \ M_CALL_INIT (value_oplist, value); \
,) \ ,) \
do { \ do { \
bool b = M_GET_IN_STR key_oplist (key, file); \ bool b = M_CALL_IN_STR(key_oplist, key, file); \
do { c = fgetc(file); } while (isspace(c)); \ do { c = fgetc(file); } while (isspace(c)); \
if (b == false) break; \ if (b == false) break; \
M_IF(isMap)(if (c!=':') break; \ M_IF(isMap)(if (c!=':') break; \
b = M_GET_IN_STR value_oplist(value, file); \ b = M_CALL_IN_STR(value_oplist,value, file); \
do { c = fgetc(file); } while (isspace(c)); \ do { c = fgetc(file); } while (isspace(c)); \
if (b == false || c == EOF) break; \ if (b == false || c == EOF) break; \
M_C(name, _set_at)(t1, key, value) \ M_C(name, _set_at)(t1, key, value) \
@@ -1103,8 +1103,8 @@
M_C(name, _push)(t1, key) \ M_C(name, _push)(t1, key) \
); \ ); \
} while (c == M_GET_SEPARATOR key_oplist); \ } while (c == M_GET_SEPARATOR key_oplist); \
M_GET_CLEAR key_oplist (key); \ M_CALL_CLEAR(key_oplist, key); \
M_IF(isMap)(M_GET_CLEAR value_oplist (value); \ M_IF(isMap)(M_CALL_CLEAR(value_oplist, value); \
,) \ ,) \
return c == ']'; \ return c == ']'; \
} \ } \
m-buffer.h
+26 -26
View File
@@ -131,7 +131,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
} else \ } else \
assert(BUFFERI_POLICY_P((policy), BUFFER_UNBLOCKING)); \ assert(BUFFERI_POLICY_P((policy), BUFFER_UNBLOCKING)); \
BUFFERI_IF_CTE_SIZE(m_size)( , \ BUFFERI_IF_CTE_SIZE(m_size)( , \
v->data = M_GET_REALLOC oplist (type, NULL, BUFFERI_SIZE(m_size)); \ v->data = M_CALL_REALLOC(oplist, type, NULL, BUFFERI_SIZE(m_size)); \
if (v->data == NULL) { \ if (v->data == NULL) { \
M_MEMORY_FULL (BUFFERI_SIZE(m_size)*sizeof(type)); \ M_MEMORY_FULL (BUFFERI_SIZE(m_size)*sizeof(type)); \
return; \ return; \
@@ -139,7 +139,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
) \ ) \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
for(size_t i = 0; i < size; i++) { \ for(size_t i = 0; i < size; i++) { \
M_GET_INIT oplist(v->data[i]); \ M_CALL_INIT(oplist, v->data[i]); \
} \ } \
} \ } \
BUFFERI_CONTRACT(v,m_size); \ BUFFERI_CONTRACT(v,m_size); \
@@ -151,12 +151,12 @@ M_C(name, _init)(buffer_t v, size_t size) \
BUFFERI_CONTRACT(v,m_size); \ BUFFERI_CONTRACT(v,m_size); \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
for(size_t i = 0; i < BUFFERI_SIZE(m_size); i++) { \ for(size_t i = 0; i < BUFFERI_SIZE(m_size); i++) { \
M_GET_CLEAR oplist(v->data[i]); \ M_CALL_CLEAR(oplist, v->data[i]); \
} \ } \
} else { \ } else { \
size_t i = BUFFERI_POLICY_P((policy), BUFFER_STACK) ? 0 : v->idx_cons; \ size_t i = BUFFERI_POLICY_P((policy), BUFFER_STACK) ? 0 : v->idx_cons; \
while (i != v->idx_prod) { \ while (i != v->idx_prod) { \
M_GET_CLEAR oplist(v->data[i]); \ M_CALL_CLEAR(oplist, v->data[i]); \
i++; \ i++; \
if (!BUFFERI_POLICY_P((policy), BUFFER_STACK) && i >= BUFFERI_SIZE(m_size)) \ if (!BUFFERI_POLICY_P((policy), BUFFER_STACK) && i >= BUFFERI_SIZE(m_size)) \
i = 0; \ i = 0; \
@@ -175,7 +175,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
BUFFERI_CONTRACT(v,m_size); \ BUFFERI_CONTRACT(v,m_size); \
M_C(name, _int_clear_obj)(v); \ M_C(name, _int_clear_obj)(v); \
BUFFERI_IF_CTE_SIZE(m_size)( , \ BUFFERI_IF_CTE_SIZE(m_size)( , \
M_GET_FREE oplist (v->data); \ M_CALL_FREE(oplist, v->data); \
v->data = NULL; \ v->data = NULL; \
) \ ) \
v->overwrite = 0; \ v->overwrite = 0; \
@@ -272,7 +272,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
idx = idx >= BUFFERI_SIZE(m_size) ? BUFFERI_SIZE(m_size)-1 : idx; \ idx = idx >= BUFFERI_SIZE(m_size) ? BUFFERI_SIZE(m_size)-1 : idx; \
} \ } \
/* Update data in the buffer */ \ /* Update data in the buffer */ \
M_GET_SET oplist (v->data[idx], data); \ M_CALL_SET(oplist, v->data[idx], data); \
previousSize = BUFFERI_SIZE(m_size); \ previousSize = BUFFERI_SIZE(m_size); \
\ \
} else { \ } else { \
@@ -280,9 +280,9 @@ M_C(name, _init)(buffer_t v, size_t size) \
/* Add a new item in the buffer */ \ /* Add a new item in the buffer */ \
/* PUSH data in the buffer */ \ /* PUSH data in the buffer */ \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (v->data[idx], data); \ M_CALL_SET(oplist, v->data[idx], data); \
} else { \ } else { \
M_GET_INIT_SET oplist(v->data[idx], data); \ M_CALL_INIT_SET(oplist, v->data[idx], data); \
} \ } \
\ \
/* Increment production INDEX of the buffer */ \ /* Increment production INDEX of the buffer */ \
@@ -344,7 +344,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
if (!BUFFERI_POLICY_P((policy), BUFFER_STACK)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_STACK)) { \
/* FIFO queue */ \ /* FIFO queue */ \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (*data, v->data[v->idx_cons]); \ M_CALL_SET(oplist, *data, v->data[v->idx_cons]); \
} else { \ } else { \
M_DO_INIT_MOVE (oplist, *data, v->data[v->idx_cons]); \ M_DO_INIT_MOVE (oplist, *data, v->data[v->idx_cons]); \
} \ } \
@@ -353,7 +353,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
/* STACK queue */ \ /* STACK queue */ \
v->idx_prod --; \ v->idx_prod --; \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (*data, v->data[v->idx_prod]); \ M_CALL_SET(oplist, *data, v->data[v->idx_prod]); \
} else { \ } else { \
M_DO_INIT_MOVE (oplist, *data, v->data[v->idx_prod]); \ M_DO_INIT_MOVE (oplist, *data, v->data[v->idx_prod]); \
} \ } \
@@ -505,9 +505,9 @@ M_C(name, _init)(buffer_t v, size_t size) \
return false; \ return false; \
} \ } \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (table->Tab[i].x, x); \ M_CALL_SET(oplist, table->Tab[i].x, x); \
} else { \ } else { \
M_GET_INIT_SET oplist (table->Tab[i].x, x); \ M_CALL_INIT_SET(oplist, table->Tab[i].x, x); \
} \ } \
atomic_store_explicit(&table->Tab[i].seq, 2*idx, memory_order_release); \ atomic_store_explicit(&table->Tab[i].seq, 2*idx, memory_order_release); \
QUEUEI_MPMC_CONTRACT(table); \ QUEUEI_MPMC_CONTRACT(table); \
@@ -534,7 +534,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
return false; \ return false; \
} \ } \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (*ptr , table->Tab[i].x); \ M_CALL_SET(oplist, *ptr, table->Tab[i].x); \
} else { \ } else { \
M_DO_INIT_MOVE (oplist, *ptr, table->Tab[i].x); \ M_DO_INIT_MOVE (oplist, *ptr, table->Tab[i].x); \
} \ } \
@@ -553,7 +553,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
atomic_init(&buffer->ProdIdx, (unsigned int) size); \ atomic_init(&buffer->ProdIdx, (unsigned int) size); \
atomic_init(&buffer->ConsoIdx, (unsigned int) size); \ atomic_init(&buffer->ConsoIdx, (unsigned int) size); \
buffer->size = size; \ buffer->size = size; \
buffer->Tab = M_GET_REALLOC oplist (M_C(name, _el_t), NULL, size); \ buffer->Tab = M_CALL_REALLOC(oplist, M_C(name, _el_t), NULL, size); \
if (buffer->Tab == NULL) { \ if (buffer->Tab == NULL) { \
M_MEMORY_FULL (size*sizeof(M_C(name, _el_t) )); \ M_MEMORY_FULL (size*sizeof(M_C(name, _el_t) )); \
return; \ return; \
@@ -561,7 +561,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
for(unsigned int j = 0; j < size; j++) { \ for(unsigned int j = 0; j < size; j++) { \
atomic_init(&buffer->Tab[j].seq, 2*j+1U); \ atomic_init(&buffer->Tab[j].seq, 2*j+1U); \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_INIT oplist (buffer->Tab[j].x); \ M_CALL_INIT(oplist, buffer->Tab[j].x); \
} \ } \
} \ } \
QUEUEI_MPMC_CONTRACT(buffer); \ QUEUEI_MPMC_CONTRACT(buffer); \
@@ -573,7 +573,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
QUEUEI_MPMC_CONTRACT(buffer); \ QUEUEI_MPMC_CONTRACT(buffer); \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
for(unsigned int j = 0; j < buffer->size; j++) { \ for(unsigned int j = 0; j < buffer->size; j++) { \
M_GET_CLEAR oplist (buffer->Tab[j].x); \ M_CALL_CLEAR(oplist, buffer->Tab[j].x); \
} \ } \
} else { \ } else { \
unsigned int iP = atomic_load_explicit(&buffer->ProdIdx, memory_order_relaxed); \ unsigned int iP = atomic_load_explicit(&buffer->ProdIdx, memory_order_relaxed); \
@@ -581,13 +581,13 @@ M_C(name, _init)(buffer_t v, size_t size) \
unsigned int iC = atomic_load_explicit(&buffer->ConsoIdx, memory_order_relaxed); \ unsigned int iC = atomic_load_explicit(&buffer->ConsoIdx, memory_order_relaxed); \
unsigned int j = iC & (buffer->size -1); \ unsigned int j = iC & (buffer->size -1); \
while (i != j) { \ while (i != j) { \
M_GET_CLEAR oplist(buffer->Tab[j].x); \ M_CALL_CLEAR(oplist, buffer->Tab[j].x); \
j++; \ j++; \
if (j >= buffer->size) \ if (j >= buffer->size) \
j = 0; \ j = 0; \
} \ } \
} \ } \
M_GET_FREE oplist (buffer->Tab); \ M_CALL_FREE(oplist, buffer->Tab); \
buffer->Tab = NULL; /* safer */ \ buffer->Tab = NULL; /* safer */ \
} \ } \
\ \
@@ -682,9 +682,9 @@ M_C(name, _init)(buffer_t v, size_t size) \
return false; \ return false; \
unsigned int i = w & (table->size -1); \ unsigned int i = w & (table->size -1); \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (table->Tab[i].x, x); \ M_CALL_SET(oplist, table->Tab[i].x, x); \
} else { \ } else { \
M_GET_INIT_SET oplist (table->Tab[i].x, x); \ M_CALL_INIT_SET(oplist, table->Tab[i].x, x); \
} \ } \
atomic_store_explicit(&table->prodIdx, w+1, memory_order_release); \ atomic_store_explicit(&table->prodIdx, w+1, memory_order_release); \
QUEUEI_SPSC_CONTRACT(table); \ QUEUEI_SPSC_CONTRACT(table); \
@@ -704,7 +704,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
return false; \ return false; \
unsigned int i = r & (table->size -1); \ unsigned int i = r & (table->size -1); \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
M_GET_SET oplist (*ptr , table->Tab[i].x); \ M_CALL_SET(oplist, *ptr , table->Tab[i].x); \
} else { \ } else { \
M_DO_INIT_MOVE (oplist, *ptr, table->Tab[i].x); \ M_DO_INIT_MOVE (oplist, *ptr, table->Tab[i].x); \
} \ } \
@@ -762,14 +762,14 @@ M_C(name, _init)(buffer_t v, size_t size) \
atomic_init(&buffer->prodIdx, (unsigned int) size); \ atomic_init(&buffer->prodIdx, (unsigned int) size); \
atomic_init(&buffer->consoIdx, (unsigned int) size); \ atomic_init(&buffer->consoIdx, (unsigned int) size); \
buffer->size = size; \ buffer->size = size; \
buffer->Tab = M_GET_REALLOC oplist (M_C(name, _el_t), NULL, size); \ buffer->Tab = M_CALL_REALLOC(oplist, M_C(name, _el_t), NULL, size); \
if (buffer->Tab == NULL) { \ if (buffer->Tab == NULL) { \
M_MEMORY_FULL (size*sizeof(M_C(name, _el_t) )); \ M_MEMORY_FULL (size*sizeof(M_C(name, _el_t) )); \
return; \ return; \
} \ } \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
for(size_t j = 0; j < size; j++) { \ for(size_t j = 0; j < size; j++) { \
M_GET_INIT oplist (buffer->Tab[j].x); \ M_CALL_INIT(oplist, buffer->Tab[j].x); \
} \ } \
} \ } \
QUEUEI_SPSC_CONTRACT(buffer); \ QUEUEI_SPSC_CONTRACT(buffer); \
@@ -781,7 +781,7 @@ M_C(name, _init)(buffer_t v, size_t size) \
QUEUEI_SPSC_CONTRACT(buffer); \ QUEUEI_SPSC_CONTRACT(buffer); \
if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \ if (!BUFFERI_POLICY_P((policy), BUFFER_PUSH_INIT_POP_MOVE)) { \
for(unsigned int j = 0; j < buffer->size; j++) { \ for(unsigned int j = 0; j < buffer->size; j++) { \
M_GET_CLEAR oplist (buffer->Tab[j].x); \ M_CALL_CLEAR(oplist, buffer->Tab[j].x); \
} \ } \
} else { \ } else { \
unsigned int iP = atomic_load_explicit(&buffer->prodIdx, memory_order_relaxed); \ unsigned int iP = atomic_load_explicit(&buffer->prodIdx, memory_order_relaxed); \
@@ -789,13 +789,13 @@ M_C(name, _init)(buffer_t v, size_t size) \
unsigned int iC = atomic_load_explicit(&buffer->consoIdx, memory_order_relaxed); \ unsigned int iC = atomic_load_explicit(&buffer->consoIdx, memory_order_relaxed); \
unsigned int j = iC & (buffer->size -1); \ unsigned int j = iC & (buffer->size -1); \
while (i != j) { \ while (i != j) { \
M_GET_CLEAR oplist(buffer->Tab[j].x); \ M_CALL_CLEAR(oplist, buffer->Tab[j].x); \
j++; \ j++; \
if (j >= buffer->size) \ if (j >= buffer->size) \
j = 0; \ j = 0; \
} \ } \
} \ } \
M_GET_FREE oplist (buffer->Tab); \ M_CALL_FREE(oplist, buffer->Tab); \
buffer->Tab = NULL; /* safer */ \ buffer->Tab = NULL; /* safer */ \
} \ } \
\ \
m-list.h
+29 -29
View File
@@ -114,10 +114,10 @@
, /* No mempool allocation */ \ , /* No mempool allocation */ \
\ \
static inline struct M_C(name, _s) *M_C(name, _int_new)(void) { \ static inline struct M_C(name, _s) *M_C(name, _int_new)(void) { \
return M_GET_NEW oplist (struct M_C(name, _s)); \ return M_CALL_NEW(oplist, struct M_C(name, _s)); \
} \ } \
static inline void M_C(name,_int_del)(struct M_C(name, _s) *ptr) { \ static inline void M_C(name,_int_del)(struct M_C(name, _s) *ptr) { \
M_GET_DEL oplist (ptr); \ M_CALL_DEL(oplist, ptr); \
} \ } \
) \ ) \
@@ -162,7 +162,7 @@
*v = NULL; \ *v = NULL; \
while (it != NULL) { \ while (it != NULL) { \
struct M_C(name, _s) *next = it->next; \ struct M_C(name, _s) *next = it->next; \
M_GET_CLEAR oplist(it->data); \ M_CALL_CLEAR(oplist, it->data); \
M_C(name,_int_del)(it); \ M_C(name,_int_del)(it); \
it = next; \ it = next; \
} \ } \
@@ -206,7 +206,7 @@
type *data = M_C(name, _push_raw)(v); \ type *data = M_C(name, _push_raw)(v); \
if (M_UNLIKELY (data == NULL)) \ if (M_UNLIKELY (data == NULL)) \
return; \ return; \
M_GET_INIT_SET oplist(*data, x); \ M_CALL_INIT_SET(oplist, *data, x); \
} \ } \
\ \
M_IF_METHOD(INIT, oplist)( \ M_IF_METHOD(INIT, oplist)( \
@@ -216,7 +216,7 @@
type *data = M_C(name, _push_raw)(v); \ type *data = M_C(name, _push_raw)(v); \
if (M_UNLIKELY (data == NULL)) \ if (M_UNLIKELY (data == NULL)) \
return NULL; \ return NULL; \
M_GET_INIT oplist(*data); \ M_CALL_INIT(oplist, *data); \
return data; \ return data; \
} \ } \
, /* No INIT */) \ , /* No INIT */) \
@@ -229,7 +229,7 @@
if (data != NULL) { \ if (data != NULL) { \
M_DO_MOVE (oplist, *data, (*v)->data); \ M_DO_MOVE (oplist, *data, (*v)->data); \
} else { \ } else { \
M_GET_CLEAR oplist((*v)->data); \ M_CALL_CLEAR(oplist, (*v)->data); \
} \ } \
struct M_C(name, _s) *tofree = *v; \ struct M_C(name, _s) *tofree = *v; \
*v = (*v)->next; \ *v = (*v)->next; \
@@ -409,7 +409,7 @@
M_MEMORY_FULL(sizeof (struct M_C(name, _s))); \ M_MEMORY_FULL(sizeof (struct M_C(name, _s))); \
return; \ return; \
} \ } \
M_GET_INIT_SET oplist(next->data, x); \ M_CALL_INIT_SET(oplist, next->data, x); \
struct M_C(name, _s) *current = insertion_point->current; \ struct M_C(name, _s) *current = insertion_point->current; \
if (M_UNLIKELY (current == NULL)) { \ if (M_UNLIKELY (current == NULL)) { \
next->next = *list; \ next->next = *list; \
@@ -434,7 +434,7 @@
} else { \ } else { \
removing_point->previous->next = next; \ removing_point->previous->next = next; \
} \ } \
M_GET_CLEAR oplist(removing_point->current->data); \ M_CALL_CLEAR(oplist, removing_point->current->data); \
M_C(name,_int_del) (removing_point->current); \ M_C(name,_int_del) (removing_point->current); \
removing_point->current = next; \ removing_point->current = next; \
LISTI_CONTRACT(list); \ LISTI_CONTRACT(list); \
@@ -460,7 +460,7 @@
return; \ return; \
} \ } \
update_list = &next->next; \ update_list = &next->next; \
M_GET_INIT_SET oplist(next->data, it_org->data); \ M_CALL_INIT_SET(oplist, next->data, it_org->data); \
it_org = it_org->next; \ it_org = it_org->next; \
} \ } \
*update_list = NULL; \ *update_list = NULL; \
@@ -593,7 +593,7 @@
!M_C(name, _end_p)(it); \ !M_C(name, _end_p)(it); \
M_C(name, _next)(it)){ \ M_C(name, _next)(it)){ \
type const *item = M_C(name, _cref)(it); \ type const *item = M_C(name, _cref)(it); \
M_GET_GET_STR oplist (str, *item, true); \ M_CALL_GET_STR(oplist, str, *item, true); \
if (!M_C(name, _last_p)(it)) \ if (!M_C(name, _last_p)(it)) \
string_push_back (str, M_GET_SEPARATOR oplist); \ string_push_back (str, M_GET_SEPARATOR oplist); \
} \ } \
@@ -612,7 +612,7 @@
!M_C(name, _end_p)(it); \ !M_C(name, _end_p)(it); \
M_C(name, _next)(it)){ \ M_C(name, _next)(it)){ \
type const *item = M_C(name, _cref)(it); \ type const *item = M_C(name, _cref)(it); \
M_GET_OUT_STR oplist (file, *item); \ M_CALL_OUT_STR(oplist, file, *item); \
if (!M_C(name, _last_p)(it)) \ if (!M_C(name, _last_p)(it)) \
fputc (M_GET_SEPARATOR oplist, file); \ fputc (M_GET_SEPARATOR oplist, file); \
} \ } \
@@ -634,14 +634,14 @@
if (M_UNLIKELY (c == 0)) goto exit; \ if (M_UNLIKELY (c == 0)) goto exit; \
str--; \ str--; \
type item; \ type item; \
M_GET_INIT oplist (item); \ M_CALL_INIT(oplist, item); \
do { \ do { \
bool b = M_GET_PARSE_STR oplist (item, str, &str); \ bool b = M_CALL_PARSE_STR(oplist, item, str, &str); \
do { c = *str++; } while (isspace(c)); \ do { c = *str++; } while (isspace(c)); \
if (b == false || c == 0) { goto exit; } \ if (b == false || c == 0) { goto exit; } \
M_C(name, _push_back)(list, item); \ M_C(name, _push_back)(list, item); \
} while (c == M_GET_SEPARATOR oplist); \ } while (c == M_GET_SEPARATOR oplist); \
M_GET_CLEAR oplist (item); \ M_CALL_CLEAR(oplist, item); \
M_C(name, _reverse)(list); \ M_C(name, _reverse)(list); \
success = (c == ']'); \ success = (c == ']'); \
exit: \ exit: \
@@ -663,14 +663,14 @@
if (M_UNLIKELY (c == EOF)) return false; \ if (M_UNLIKELY (c == EOF)) return false; \
ungetc(c, file); \ ungetc(c, file); \
type item; \ type item; \
M_GET_INIT oplist (item); \ M_CALL_INIT(oplist, item); \
do { \ do { \
bool b = M_GET_IN_STR oplist (item, file); \ bool b = M_CALL_IN_STR(oplist, item, file); \
do { c = fgetc(file); } while (isspace(c)); \ do { c = fgetc(file); } while (isspace(c)); \
if (b == false || c == EOF) { break; } \ if (b == false || c == EOF) { break; } \
M_C(name, _push_back)(list, item); \ M_C(name, _push_back)(list, item); \
} while (c == M_GET_SEPARATOR oplist); \ } while (c == M_GET_SEPARATOR oplist); \
M_GET_CLEAR oplist (item); \ M_CALL_CLEAR(oplist, item); \
M_C(name, _reverse)(list); \ M_C(name, _reverse)(list); \
return c == ']'; \ return c == ']'; \
} \ } \
@@ -690,7 +690,7 @@
&&!M_C(name, _end_p)(it2)) { \ &&!M_C(name, _end_p)(it2)) { \
type const *item1 = M_C(name, _cref)(it1); \ type const *item1 = M_C(name, _cref)(it1); \
type const *item2 = M_C(name, _cref)(it2); \ type const *item2 = M_C(name, _cref)(it2); \
bool b = M_GET_EQUAL oplist (*item1, *item2); \ bool b = M_CALL_EQUAL(oplist, *item1, *item2); \
if (!b) return false; \ if (!b) return false; \
M_C(name, _next)(it1); \ M_C(name, _next)(it1); \
M_C(name, _next)(it2); \ M_C(name, _next)(it2); \
@@ -711,7 +711,7 @@
!M_C(name, _end_p)(it); \ !M_C(name, _end_p)(it); \
M_C(name, _next)(it)) { \ M_C(name, _next)(it)) { \
type const *item = M_C(name, _cref)(it); \ type const *item = M_C(name, _cref)(it); \
size_t hi = M_GET_HASH oplist (*item); \ size_t hi = M_CALL_HASH(oplist, *item); \
M_HASH_UP(hash, hi); \ M_HASH_UP(hash, hi); \
} \ } \
return M_HASH_FINAL (hash); \ return M_HASH_FINAL (hash); \
@@ -774,7 +774,7 @@
struct M_C(name, _s) *it = v->back; \ struct M_C(name, _s) *it = v->back; \
while (it != NULL) { \ while (it != NULL) { \
struct M_C(name, _s) *next = it->next; \ struct M_C(name, _s) *next = it->next; \
M_GET_CLEAR oplist(it->data); \ M_CALL_CLEAR(oplist, it->data); \
M_C(name,_int_del)(it); \ M_C(name,_int_del)(it); \
it = next; \ it = next; \
} \ } \
@@ -824,7 +824,7 @@
type *data = M_C(name, _push_back_raw)(v); \ type *data = M_C(name, _push_back_raw)(v); \
if (M_UNLIKELY (data == NULL)) \ if (M_UNLIKELY (data == NULL)) \
return; \ return; \
M_GET_INIT_SET oplist(*data, x); \ M_CALL_INIT_SET(oplist, *data, x); \
} \ } \
\ \
M_IF_METHOD(INIT, oplist)( \ M_IF_METHOD(INIT, oplist)( \
@@ -834,7 +834,7 @@
type *data = M_C(name, _push_back_raw)(v); \ type *data = M_C(name, _push_back_raw)(v); \
if (M_UNLIKELY (data == NULL)) \ if (M_UNLIKELY (data == NULL)) \
return NULL; \ return NULL; \
M_GET_INIT oplist(*data); \ M_CALL_INIT(oplist, *data); \
return data; \ return data; \
} \ } \
, /* No INIT */ ) \ , /* No INIT */ ) \
@@ -862,9 +862,9 @@
assert (v->back != NULL); \ assert (v->back != NULL); \
struct M_C(name, _s) *tofree = v->back; \ struct M_C(name, _s) *tofree = v->back; \
if (data != NULL) { \ if (data != NULL) { \
M_GET_SET oplist(*data, tofree->data); \ M_CALL_SET(oplist, *data, tofree->data); \
} \ } \
M_GET_CLEAR oplist(tofree->data); \ M_CALL_CLEAR(oplist, tofree->data); \
v->back = tofree->next; \ v->back = tofree->next; \
M_C(name,_int_del)(tofree); \ M_C(name,_int_del)(tofree); \
/* Update front too if the list became empty */ \ /* Update front too if the list became empty */ \
@@ -929,7 +929,7 @@
type *data = M_C(name, _push_front_raw)(v); \ type *data = M_C(name, _push_front_raw)(v); \
if (M_UNLIKELY (data == NULL)) \ if (M_UNLIKELY (data == NULL)) \
return; \ return; \
M_GET_INIT_SET oplist(*data, x); \ M_CALL_INIT_SET(oplist, *data, x); \
} \ } \
\ \
static inline void \ static inline void \
@@ -949,7 +949,7 @@
type *data = M_C(name, _push_back_raw)(v); \ type *data = M_C(name, _push_back_raw)(v); \
if (M_UNLIKELY (data == NULL)) \ if (M_UNLIKELY (data == NULL)) \
return NULL; \ return NULL; \
M_GET_INIT oplist(*data); \ M_CALL_INIT(oplist, *data); \
return data; \ return data; \
} \ } \
, /* No INIT */) \ , /* No INIT */) \
@@ -1064,7 +1064,7 @@
M_MEMORY_FULL(sizeof (struct M_C(name, _s))); \ M_MEMORY_FULL(sizeof (struct M_C(name, _s))); \
return; \ return; \
} \ } \
M_GET_INIT_SET oplist(next->data, x); \ M_CALL_INIT_SET(oplist, next->data, x); \
if (M_UNLIKELY (insertion_point->current == NULL)) { \ if (M_UNLIKELY (insertion_point->current == NULL)) { \
next->next = list->back; \ next->next = list->back; \
list->back = next; \ list->back = next; \
@@ -1100,7 +1100,7 @@
front = (next == NULL) ? previous : front; \ front = (next == NULL) ? previous : front; \
list->front = front; \ list->front = front; \
/* Remove node */ \ /* Remove node */ \
M_GET_CLEAR oplist(removing_point->current->data); \ M_CALL_CLEAR(oplist, removing_point->current->data); \
M_C(name,_int_del) (removing_point->current); \ M_C(name,_int_del) (removing_point->current); \
removing_point->current = next; \ removing_point->current = next; \
} \ } \
@@ -1125,7 +1125,7 @@
return; \ return; \
} \ } \
update_list = &next->next; \ update_list = &next->next; \
M_GET_INIT_SET oplist(next->data, it_org->data); \ M_CALL_INIT_SET(oplist, next->data, it_org->data); \
it_org = it_org->next; \ it_org = it_org->next; \
} \ } \
list->front = next; \ list->front = next; \