From 8a6652646a78c95346499672190ad59437f580a9 Mon Sep 17 00:00:00 2001 From: Patrick Pelissier Date: Tue, 14 Jul 2020 00:34:59 +0200 Subject: [PATCH] Fix formatting (Replace TAB with SPACE) --- m-bptree.h | 382 ++++++++++++++++++++++++++--------------------------- 1 file changed, 191 insertions(+), 191 deletions(-) diff --git a/m-bptree.h b/m-bptree.h index ede1decb..2f8dd310 100644 --- a/m-bptree.h +++ b/m-bptree.h @@ -45,9 +45,9 @@ /* Define a B+tree of a given type, of size N. with its associated functions USAGE: BPTREE_DEF(name, N, type, [, oplist_of_the_type]) */ -#define BPTREE_DEF(name, N, ...) \ +#define BPTREE_DEF(name, N, ...) \ M_BEGIN_PROTECTED_CODE \ - BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ + BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ ((name, N, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 0, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ), \ (name, N, __VA_ARGS__, __VA_ARGS__, 0, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ))) \ M_END_PROTECTED_CODE @@ -73,9 +73,9 @@ allowing multiple equal keys to exist, with its associated functions USAGE: BPTREE_MULTI_DEF(name, N, type, [, oplist_of_the_type]) */ -#define BPTREE_MULTI_DEF(name, N, ...) \ +#define BPTREE_MULTI_DEF(name, N, ...) \ M_BEGIN_PROTECTED_CODE \ - BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ + BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ ((name, N, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 0, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ), \ (name, N, __VA_ARGS__, __VA_ARGS__, 0, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ))) \ M_BEGIN_PROTECTED_CODE @@ -86,8 +86,8 @@ USAGE: BPTREE_OPLIST(name [, oplist_of_the_type]) */ #define BPTREE_OPLIST(...) \ BPTREEI_KEY_OPLIST_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ - ((__VA_ARGS__, M_DEFAULT_OPLIST ), \ - (__VA_ARGS__ ))) + ((__VA_ARGS__, M_DEFAULT_OPLIST ), \ + (__VA_ARGS__ ))) /* Define the oplist of a rbtree of type (from BPTREE_DEF2). @@ -95,10 +95,10 @@ NOTE: IT_REF is not exported so that the contained appears as not modifiable by algorithm. */ -#define BPTREE_OPLIST2(...) \ - BPTREEI_OPLIST2_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ +#define BPTREE_OPLIST2(...) \ + BPTREEI_OPLIST2_P1(M_IF_NARGS_EQ1(__VA_ARGS__) \ ((__VA_ARGS__, M_DEFAULT_OPLIST, M_DEFAULT_OPLIST ), \ - (__VA_ARGS__ ))) + (__VA_ARGS__ ))) @@ -109,92 +109,92 @@ #define BPTREEI_KEY_OPLIST_P1(arg) BPTREEI_KEY_OPLIST_P2 arg /* Validation of the given oplists */ -#define BPTREEI_KEY_OPLIST_P2(name, oplist) \ +#define BPTREEI_KEY_OPLIST_P2(name, oplist) \ M_IF_OPLIST(oplist)(BPTREEI_KEY_OPLIST_P3, BPTREEI_KEY_OPLIST_FAILURE)(name, oplist) /* Prepare a clean compilation failure */ -#define BPTREEI_KEY_OPLIST_FAILURE(name, oplist) \ +#define BPTREEI_KEY_OPLIST_FAILURE(name, oplist) \ ((M_LIB_ERROR(ARGUMENT_OF_BPTREE_OPLIST_IS_NOT_AN_OPLIST, name, oplist))) /* OPLIST definition of a b+tree */ -#define BPTREEI_KEY_OPLIST_P3(name, oplist) \ - (INIT(M_C(name, _init)), \ - INIT_SET(M_C(name, _init_set)), \ - SET(M_C(name, _set)), \ - CLEAR(M_C(name, _clear)), \ - INIT_MOVE(M_C(name, _init_move)), \ - MOVE(M_C(name, _move)), \ - SWAP(M_C(name, _swap)), \ - TYPE(M_C(name,_t)), \ - SUBTYPE(M_C(name, _type_t)), \ - IT_TYPE(M_C(name, _it_t)), \ - IT_FIRST(M_C(name,_it)), \ - IT_SET(M_C(name,_it_set)), \ - IT_END(M_C(name,_it_end)), \ - IT_END_P(M_C(name,_end_p)), \ - IT_EQUAL_P(M_C(name,_it_equal_p)), \ - IT_NEXT(M_C(name,_next)), \ - IT_REF(M_C(name,_ref)), \ - IT_CREF(M_C(name,_cref)), \ - CLEAN(M_C(name,_clean)), \ - PUSH(M_C(name,_push)), \ - GET_MIN(M_C(name,_min)), \ - GET_MAX(M_C(name,_max)), \ - M_IF_METHOD(GET_STR, oplist)(GET_STR(M_C(name, _get_str)),), \ - M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_C(name, _parse_str)),), \ - M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_C(name, _out_str)),), \ - M_IF_METHOD(IN_STR, oplist)(IN_STR(M_C(name, _in_str)),), \ - M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_C(name, _out_serial)),), \ - M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_C(name, _in_serial)),), \ - M_IF_METHOD(EQUAL, oplist)(EQUAL(M_C(name, _equal_p)),), \ - M_IF_METHOD(HASH, oplist)(HASH(M_C(name, _hash)),) \ - ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),) \ - ,M_IF_METHOD(REALLOC, oplist)(REALLOC(M_GET_REALLOC oplist),) \ - ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),) \ +#define BPTREEI_KEY_OPLIST_P3(name, oplist) \ + (INIT(M_C(name, _init)), \ + INIT_SET(M_C(name, _init_set)), \ + SET(M_C(name, _set)), \ + CLEAR(M_C(name, _clear)), \ + INIT_MOVE(M_C(name, _init_move)), \ + MOVE(M_C(name, _move)), \ + SWAP(M_C(name, _swap)), \ + TYPE(M_C(name,_t)), \ + SUBTYPE(M_C(name, _type_t)), \ + IT_TYPE(M_C(name, _it_t)), \ + IT_FIRST(M_C(name,_it)), \ + IT_SET(M_C(name,_it_set)), \ + IT_END(M_C(name,_it_end)), \ + IT_END_P(M_C(name,_end_p)), \ + IT_EQUAL_P(M_C(name,_it_equal_p)), \ + IT_NEXT(M_C(name,_next)), \ + IT_REF(M_C(name,_ref)), \ + IT_CREF(M_C(name,_cref)), \ + CLEAN(M_C(name,_clean)), \ + PUSH(M_C(name,_push)), \ + GET_MIN(M_C(name,_min)), \ + GET_MAX(M_C(name,_max)), \ + M_IF_METHOD(GET_STR, oplist)(GET_STR(M_C(name, _get_str)),), \ + M_IF_METHOD(PARSE_STR, oplist)(PARSE_STR(M_C(name, _parse_str)),), \ + M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_C(name, _out_str)),), \ + M_IF_METHOD(IN_STR, oplist)(IN_STR(M_C(name, _in_str)),), \ + M_IF_METHOD(OUT_SERIAL, oplist)(OUT_SERIAL(M_C(name, _out_serial)),), \ + M_IF_METHOD(IN_SERIAL, oplist)(IN_SERIAL(M_C(name, _in_serial)),), \ + M_IF_METHOD(EQUAL, oplist)(EQUAL(M_C(name, _equal_p)),), \ + M_IF_METHOD(HASH, oplist)(HASH(M_C(name, _hash)),) \ + ,M_IF_METHOD(NEW, oplist)(NEW(M_GET_NEW oplist),) \ + ,M_IF_METHOD(REALLOC, oplist)(REALLOC(M_GET_REALLOC oplist),) \ + ,M_IF_METHOD(DEL, oplist)(DEL(M_GET_DEL oplist),) \ ) /* Deferred evaluation */ #define BPTREEI_OPLIST2_P1(arg) BPTREEI_OPLIST2_P2 arg /* Validation of the given oplists */ -#define BPTREEI_OPLIST2_P2(name, key_oplist, value_oplist) \ +#define BPTREEI_OPLIST2_P2(name, key_oplist, value_oplist) \ M_IF_OPLIST(key_oplist)(BPTREEI_OPLIST2_P3, BPTREEI_OPLIST2_FAILURE)(name, key_oplist, value_oplist) -#define BPTREEI_OPLIST2_P3(name, key_oplist, value_oplist) \ +#define BPTREEI_OPLIST2_P3(name, key_oplist, value_oplist) \ M_IF_OPLIST(value_oplist)(BPTREEI_OPLIST2_P4, BPTREEI_OPLIST2_FAILURE)(name, key_oplist, value_oplist) /* Prepare a clean compilation failure */ -#define BPTREEI_OPLIST2_FAILURE(name, key_oplist, value_oplist) \ +#define BPTREEI_OPLIST2_FAILURE(name, key_oplist, value_oplist) \ ((M_LIB_ERROR(ARGUMENT_OF_BPTREE_OPLIST_IS_NOT_AN_OPLIST, name, key_oplist, value_oplist))) -#define BPTREEI_OPLIST2_P4(name, key_oplist, value_oplist) \ - (INIT(M_C(name, _init)), \ - INIT_SET(M_C(name, _init_set)), \ - SET(M_C(name, _set)), \ - CLEAR(M_C(name, _clear)), \ - INIT_MOVE(M_C(name, _init_move)), \ - MOVE(M_C(name, _move)), \ - SWAP(M_C(name, _swap)), \ - TYPE(M_C(name,_t)), \ - SUBTYPE(M_C(name, _type_t)), \ - TEST_EMPTY(M_C(name,_empty_p)), \ - IT_TYPE(M_C(name, _it_t)), \ - IT_FIRST(M_C(name,_it)), \ - IT_SET(M_C(name,_it_set)), \ - IT_END(M_C(name,_it_end)), \ - IT_END_P(M_C(name,_end_p)), \ - IT_EQUAL_P(M_C(name,_it_equal_p)), \ - IT_NEXT(M_C(name,_next)), \ - IT_CREF(M_C(name,_cref)), \ - CLEAN(M_C(name,_clean)), \ - GET_MIN(M_C(name,_min)), \ - GET_MAX(M_C(name,_max)), \ - KEY_TYPE(M_C(name, _key_type_t)), \ - VALUE_TYPE(M_C(name, _value_type_t)), \ - SET_KEY(M_C(name, _set_at)), \ - GET_KEY(M_C(name, _get)), \ - ERASE_KEY(M_C(name, _erase)), \ - KEY_OPLIST(key_oplist), \ - VALUE_OPLIST(value_oplist), \ +#define BPTREEI_OPLIST2_P4(name, key_oplist, value_oplist) \ + (INIT(M_C(name, _init)), \ + INIT_SET(M_C(name, _init_set)), \ + SET(M_C(name, _set)), \ + CLEAR(M_C(name, _clear)), \ + INIT_MOVE(M_C(name, _init_move)), \ + MOVE(M_C(name, _move)), \ + SWAP(M_C(name, _swap)), \ + TYPE(M_C(name,_t)), \ + SUBTYPE(M_C(name, _type_t)), \ + TEST_EMPTY(M_C(name,_empty_p)), \ + IT_TYPE(M_C(name, _it_t)), \ + IT_FIRST(M_C(name,_it)), \ + IT_SET(M_C(name,_it_set)), \ + IT_END(M_C(name,_it_end)), \ + IT_END_P(M_C(name,_end_p)), \ + IT_EQUAL_P(M_C(name,_it_equal_p)), \ + IT_NEXT(M_C(name,_next)), \ + IT_CREF(M_C(name,_cref)), \ + CLEAN(M_C(name,_clean)), \ + GET_MIN(M_C(name,_min)), \ + GET_MAX(M_C(name,_max)), \ + KEY_TYPE(M_C(name, _key_type_t)), \ + VALUE_TYPE(M_C(name, _value_type_t)), \ + SET_KEY(M_C(name, _set_at)), \ + GET_KEY(M_C(name, _get)), \ + ERASE_KEY(M_C(name, _erase)), \ + KEY_OPLIST(key_oplist), \ + VALUE_OPLIST(value_oplist), \ M_IF_METHOD_BOTH(GET_STR, key_oplist, value_oplist)(GET_STR(M_C(name, _get_str)),), \ M_IF_METHOD_BOTH(PARSE_STR, key_oplist, value_oplist)(PARSE_STR(M_C(name, _parse_str)),), \ M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)(OUT_STR(M_C(name, _out_str)),), \ @@ -203,9 +203,9 @@ M_IF_METHOD_BOTH(IN_SERIAL, key_oplist, value_oplist)(IN_SERIAL(M_C(name, _in_serial)),), \ M_IF_METHOD_BOTH(EQUAL, key_oplist, value_oplist)(EQUAL(M_C(name, _equal_p)),), \ M_IF_METHOD_BOTH(HASH, key_oplist, value_oplist)(HASH(M_C(name, _hash)),) \ - ,M_IF_METHOD(NEW, key_oplist)(NEW(M_GET_NEW oplist),) \ - ,M_IF_METHOD(REALLOC, key_oplist)(REALLOC(M_GET_REALLOC oplist),) \ - ,M_IF_METHOD(DEL, key_oplist)(DEL(M_GET_DEL oplist),) \ + ,M_IF_METHOD(NEW, key_oplist)(NEW(M_GET_NEW oplist),) \ + ,M_IF_METHOD(REALLOC, key_oplist)(REALLOC(M_GET_REALLOC oplist),) \ + ,M_IF_METHOD(DEL, key_oplist)(DEL(M_GET_DEL oplist),) \ ) @@ -435,10 +435,10 @@ if (M_C(name, _is_leaf)(o)) { \ /* Copy the associated values if it is a leaf and a MAP */ \ M_IF(isMap)( \ - for(int i = 0; i < num; i++) { \ - M_CALL_INIT_SET(value_oplist, n->kind.value[i], o->kind.value[i]); \ - } \ - , /* End of isMap */) \ + for(int i = 0; i < num; i++) { \ + M_CALL_INIT_SET(value_oplist, n->kind.value[i], o->kind.value[i]); \ + } \ + , /* End of isMap */) \ } else { \ /* Copy recursively the associated nodes if it is not a leaf */ \ for(int i = 0; i <= num; i++) { \ @@ -476,7 +476,7 @@ } \ \ static inline void M_C(name, _set)(tree_t b, const tree_t o) \ - { \ + { \ /* NOTE: We could reuse the already allocated nodes of 'b'. \ Not sure if it worth the effort */ \ M_C(name, _clear)(b); \ @@ -925,7 +925,7 @@ n = n->kind.node[n->num]; \ } \ it->node = n; \ - it->idx = -n->num; \ + it->idx = -n->num; \ } \ \ static inline void \ @@ -994,7 +994,7 @@ BPTREEI_NODE_CONTRACT(N, isMulti, key_oplist, n, b->root); \ for(i = 0; i < -n->num; i++) { \ if (M_CALL_CMP(key_oplist, key, n->key[i]) <= 0) \ - break; \ + break; \ } \ if (i == -n->num && n->next != NULL) { \ it->node = n->next; \ @@ -1105,118 +1105,118 @@ /* Define additional functions. Do not used any fields but the already defined methods */ #define BPTREEI_FUNC_ADDITIONAL_DEF2(name, N, key_t, key_oplist, value_t, value_oplist, isMap, isMulti, tree_t, node_t, pit_t, it_t) \ - \ - M_IF_METHOD_BOTH(EQUAL, key_oplist, value_oplist)( \ + \ + M_IF_METHOD_BOTH(EQUAL, key_oplist, value_oplist)( \ static inline bool M_C(name,_equal_p)(const tree_t t1, const tree_t t2) { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t2); \ if (t1->size != t2->size) return false; \ - if (t1->size == 0) return true; \ - /* Slow comparaison */ \ - it_t it1; \ - it_t it2; \ - /* NOTE: We can't compare two trees directly as they can be \ + if (t1->size == 0) return true; \ + /* Slow comparaison */ \ + it_t it1; \ + it_t it2; \ + /* NOTE: We can't compare two trees directly as they can be \ structuraly different but functionnaly equal (you get this by \ constructing the tree in a different way). We have to \ compare the ordered value within the tree. */ \ - M_C(name, _it)(it1, t1); \ - M_C(name, _it)(it2, t2); \ - while (!M_C(name, _end_p)(it1) \ - && !M_C(name, _end_p)(it2)) { \ - 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)( \ + M_C(name, _it)(it1, t1); \ + M_C(name, _it)(it2, t2); \ + while (!M_C(name, _end_p)(it1) \ + && !M_C(name, _end_p)(it2)) { \ + 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_CALL_EQUAL(key_oplist, *ref1->key_ptr, *ref2->key_ptr)) \ return false; \ if (!M_CALL_EQUAL(value_oplist, *ref1->value_ptr, *ref2->value_ptr)) \ return false; \ - , \ + , \ if (!M_CALL_EQUAL(key_oplist, *ref1, *ref2)) \ return false; \ - ) \ - M_C(name, _next)(it1); \ - M_C(name, _next)(it2); \ + ) \ + M_C(name, _next)(it1); \ + M_C(name, _next)(it2); \ } \ - return M_C(name, _end_p)(it1) \ - && M_C(name, _end_p)(it2); \ + return M_C(name, _end_p)(it1) \ + && M_C(name, _end_p)(it2); \ } \ , /* NO EQUAL METHOD */ ) \ - \ + \ M_IF_METHOD_BOTH(HASH, key_oplist, value_oplist)( \ static inline size_t M_C(name,_hash)(const tree_t t1) { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ M_HASH_DECL(hash); \ /* NOTE: We can't compute the hash directly for the same reason \ than for EQUAL operator. */ \ - it_t it1; \ - M_C(name, _it)(it1, t1); \ - 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_CALL_HASH(key_oplist, *ref1->key_ptr)); \ - M_HASH_UP(hash, M_CALL_HASH(value_oplist, *ref1->value_ptr)); \ - , \ - M_HASH_UP(hash, M_CALL_HASH(key_oplist, *ref1)); \ - ) \ - M_C(name, _next)(it1); \ + it_t it1; \ + M_C(name, _it)(it1, t1); \ + 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_CALL_HASH(key_oplist, *ref1->key_ptr)); \ + M_HASH_UP(hash, M_CALL_HASH(value_oplist, *ref1->value_ptr)); \ + , \ + M_HASH_UP(hash, M_CALL_HASH(key_oplist, *ref1)); \ + ) \ + M_C(name, _next)(it1); \ } \ - return M_HASH_FINAL (hash); \ + return M_HASH_FINAL (hash); \ } \ , /* NO HASH METHOD */ ) \ - \ + \ M_IF_METHOD_BOTH(GET_STR, key_oplist, value_oplist)( \ static inline void M_C(name, _get_str)(string_t str, \ - const tree_t t1, bool append) { \ + const tree_t t1, bool append) { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ assert(str != NULL); \ (append ? string_cat_str : string_set_str) (str, "["); \ /* NOTE: The print is really naive, and not really efficient */ \ bool commaToPrint = false; \ - it_t it; \ - for (M_C(name, _it)(it, t1) ; \ - !M_C(name, _end_p)(it); \ - M_C(name, _next)(it)) { \ + it_t it; \ + for (M_C(name, _it)(it, t1) ; \ + !M_C(name, _end_p)(it); \ + M_C(name, _next)(it)) { \ if (commaToPrint) \ - string_push_back (str, M_GET_SEPARATOR key_oplist); \ + string_push_back (str, M_GET_SEPARATOR key_oplist); \ commaToPrint = true; \ - const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \ - M_IF(isMap)( \ - M_CALL_GET_STR(key_oplist, str, *ref1->key_ptr, true); \ - string_cat_str(str, ":"); \ - M_CALL_GET_STR(value_oplist,str, *ref1->value_ptr, true) \ - , \ - M_CALL_GET_STR(key_oplist, str, *ref1, true); \ - ); \ - } \ + const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \ + M_IF(isMap)( \ + M_CALL_GET_STR(key_oplist, str, *ref1->key_ptr, true); \ + string_cat_str(str, ":"); \ + M_CALL_GET_STR(value_oplist,str, *ref1->value_ptr, true) \ + , \ + M_CALL_GET_STR(key_oplist, str, *ref1, true); \ + ); \ + } \ string_push_back (str, ']'); \ } \ , /* NO GET_STR */ ) \ - \ + \ M_IF_METHOD_BOTH(OUT_STR, key_oplist, value_oplist)( \ static inline void \ - M_C(name, _out_str)(FILE *file, tree_t const t1) \ + M_C(name, _out_str)(FILE *file, tree_t const t1) \ { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ assert (file != NULL); \ - fputc ('[', file); \ + fputc ('[', file); \ bool commaToPrint = false; \ - it_t it; \ - for (M_C(name, _it)(it, t1) ; \ - !M_C(name, _end_p)(it); \ - M_C(name, _next)(it)){ \ + it_t it; \ + for (M_C(name, _it)(it, t1) ; \ + !M_C(name, _end_p)(it); \ + M_C(name, _next)(it)){ \ if (commaToPrint) \ - fputc (M_GET_SEPARATOR key_oplist, file); \ + fputc (M_GET_SEPARATOR key_oplist, file); \ commaToPrint = true; \ - const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \ - M_IF(isMap)( \ - M_CALL_OUT_STR(key_oplist, file, *ref1->key_ptr); \ - fputc (':', file); \ - M_CALL_OUT_STR(value_oplist, file, *ref1->value_ptr) \ - , \ - M_CALL_OUT_STR(key_oplist, file, *ref1); \ - ); \ + const M_C(name, _type_t) *ref1 = M_C(name, _cref)(it); \ + M_IF(isMap)( \ + M_CALL_OUT_STR(key_oplist, file, *ref1->key_ptr); \ + fputc (':', file); \ + M_CALL_OUT_STR(value_oplist, file, *ref1->value_ptr) \ + , \ + M_CALL_OUT_STR(key_oplist, file, *ref1); \ + ); \ } \ - fputc (']', file); \ + fputc (']', file); \ } \ , /* no out_str */ ) \ \ @@ -1264,69 +1264,69 @@ \ M_IF_METHOD_BOTH(IN_STR, key_oplist, value_oplist)( \ static inline bool \ - M_C(name, _in_str)(tree_t t1, FILE *file) \ + M_C(name, _in_str)(tree_t t1, FILE *file) \ { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ assert (file != NULL); \ - M_C(name,_clean)(t1); \ - int c = fgetc(file); \ + M_C(name,_clean)(t1); \ + int c = fgetc(file); \ if (M_UNLIKELY (c != '[')) return false; \ c = fgetc(file); \ if (M_UNLIKELY (c == ']')) return true; \ if (M_UNLIKELY (c == EOF)) return false; \ ungetc(c, file); \ - key_t key; \ - M_CALL_INIT (key_oplist, key); \ - M_IF(isMap)(value_t value; \ - M_CALL_INIT (value_oplist, value); \ - ,) \ + key_t key; \ + M_CALL_INIT (key_oplist, key); \ + M_IF(isMap)(value_t value; \ + M_CALL_INIT (value_oplist, value); \ + ,) \ do { \ - bool b = M_CALL_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_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) \ - , \ - M_C(name, _push)(t1, key) \ - ); \ - } while (c == M_GET_SEPARATOR key_oplist); \ - M_CALL_CLEAR(key_oplist, key); \ - M_IF(isMap)(M_CALL_CLEAR(value_oplist, value); \ - ,) \ + do { c = fgetc(file); } while (isspace(c)); \ + if (b == false || c == EOF) break; \ + M_C(name, _set_at)(t1, key, value) \ + , \ + M_C(name, _push)(t1, key) \ + ); \ + } while (c == M_GET_SEPARATOR key_oplist); \ + M_CALL_CLEAR(key_oplist, key); \ + M_IF(isMap)(M_CALL_CLEAR(value_oplist, value); \ + ,) \ return c == ']'; \ } \ , /* no in_str */ ) \ - \ + \ M_IF_METHOD_BOTH(OUT_SERIAL, key_oplist, value_oplist)( \ static inline m_serial_return_code_t \ M_C(name, _out_serial)(m_serial_write_t f, tree_t const t1) \ { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ - assert (f != NULL && f->m_interface != NULL); \ + assert (f != NULL && f->m_interface != NULL); \ m_serial_return_code_t ret; \ m_serial_local_t local; \ const M_C(name, _type_t) *item; \ bool first_done = false; \ - it_t it; \ + it_t it; \ /* Format is different between associative container \ & set container */ \ - M_IF(isMap)( \ + M_IF(isMap)( \ ret = f->m_interface->write_map_start(local, f, t1->size); \ for (M_C(name, _it)(it, t1) ; \ !M_C(name, _end_p)(it); \ M_C(name, _next)(it)){ \ item = M_C(name, _cref)(it); \ if (first_done) \ - ret |= f->m_interface->write_map_next(local, f); \ + ret |= f->m_interface->write_map_next(local, f); \ ret |= M_CALL_OUT_SERIAL(key_oplist, f, *item->key_ptr); \ - ret |= f->m_interface->write_map_value(local, f); \ + ret |= f->m_interface->write_map_value(local, f); \ ret |= M_CALL_OUT_SERIAL(value_oplist, f, *item->value_ptr); \ first_done = true; \ } \ - ret |= f->m_interface->write_map_end(local, f); \ + ret |= f->m_interface->write_map_end(local, f); \ , \ ret = f->m_interface->write_array_start(local, f, t1->size); \ for (M_C(name, _it)(it, t1) ; \ @@ -1334,11 +1334,11 @@ M_C(name, _next)(it)){ \ item = M_C(name, _cref)(it); \ if (first_done) \ - ret |= f->m_interface->write_array_next(local, f); \ + ret |= f->m_interface->write_array_next(local, f); \ ret |= M_CALL_OUT_SERIAL(key_oplist, f, *item); \ first_done = true; \ } \ - ret |= f->m_interface->write_array_end(local, f); \ + ret |= f->m_interface->write_array_end(local, f); \ ) \ return ret & M_SERIAL_FAIL; \ } \ @@ -1349,26 +1349,26 @@ M_C(name, _in_serial)(tree_t t1, m_serial_read_t f) \ { \ BPTREEI_CONTRACT(N, isMulti, key_oplist, t1); \ - assert (f != NULL && f->m_interface != NULL); \ + assert (f != NULL && f->m_interface != NULL); \ m_serial_local_t local; \ m_serial_return_code_t ret; \ size_t estimated_size = 0; \ - key_t key; \ - M_C(name,_clean)(t1); \ + key_t key; \ + M_C(name,_clean)(t1); \ M_IF(isMap)( \ - value_t value; \ - ret = f->m_interface->read_map_start(local, f, &estimated_size); \ + value_t value; \ + ret = f->m_interface->read_map_start(local, f, &estimated_size); \ if (M_UNLIKELY (ret != M_SERIAL_OK_CONTINUE)) return ret; \ M_CALL_INIT(key_oplist, key); \ - M_CALL_INIT (value_oplist, value); \ - do { \ + M_CALL_INIT (value_oplist, value); \ + do { \ ret = M_CALL_IN_SERIAL(key_oplist, key, f); \ if (ret != M_SERIAL_OK_DONE) return M_SERIAL_FAIL; \ - ret = f->m_interface->read_map_value(local, f); \ + ret = f->m_interface->read_map_value(local, f); \ if (ret != M_SERIAL_OK_CONTINUE) return M_SERIAL_FAIL; \ ret = M_CALL_IN_SERIAL(value_oplist, value, f); \ if (ret != M_SERIAL_OK_DONE) return M_SERIAL_FAIL; \ - M_C(name, _set_at)(t1, key, value); \ + M_C(name, _set_at)(t1, key, value); \ } while ((ret = f->m_interface->read_map_next(local, f)) == M_SERIAL_OK_CONTINUE); \ M_CALL_CLEAR(key_oplist, key); \ M_CALL_CLEAR(value_oplist, value); \ @@ -1386,6 +1386,6 @@ return ret; \ } \ , /* no in_serial */ ) \ - \ + \ #endif