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