diff --git a/m-tuple.h b/m-tuple.h index 37fe80e9..5f1834a7 100644 --- a/m-tuple.h +++ b/m-tuple.h @@ -53,7 +53,7 @@ */ #ifndef __cplusplus #define TUPLE_ORDER(name, ...) \ - ( (const int[]) {M_MAP2_C(TUPLE_ORDER_CONVERT, name, __VA_ARGS__), 0}) + ( (const int[]) {M_MAP2_C(TUPLEI_ORDER_CONVERT, name, __VA_ARGS__), 0}) #else #include namespace m_tuple { @@ -68,8 +68,8 @@ namespace m_tuple { } }; } -#define TUPLE_ORDER(name, ...) \ - (m_tuple::m_int_array({M_MAP2_C(TUPLE_ORDER_CONVERT, name, __VA_ARGS__), 0}).data) +#define TUPLE_ORDER(name, ...) \ + (m_tuple::m_int_array({M_MAP2_C(TUPLEI_ORDER_CONVERT, name, __VA_ARGS__), 0}).data) #endif @@ -100,7 +100,8 @@ namespace m_tuple { // Test if all third argument of all arguments is an oplist #define TUPLEI_IF_ALL_OPLIST(...) \ M_IF(M_REDUCE(TUPLEI_IS_OPLIST_P, M_AND, __VA_ARGS__)) -// Test if the third argument is an oplist + +// Test if the third argument of (name, type, oplist) is an oplist #define TUPLEI_IS_OPLIST_P(a) \ M_OPLIST_P(M_RET_ARG3 a) @@ -114,227 +115,227 @@ namespace m_tuple { /* Define the tuple */ #define TUPLEI_DEF2_P3(name, ...) \ - TUPLE_DEFINE_TYPE(name, __VA_ARGS__) \ - TUPLE_DEFINE_ENUM(name, __VA_ARGS__) \ - TUPLE_CONTROL_ALL_OPLIST(name, __VA_ARGS__) \ - TUPLEI_IF_ALL(INIT, __VA_ARGS__)(TUPLE_DEFINE_INIT(name, __VA_ARGS__),) \ - TUPLE_DEFINE_INIT_SET(name, __VA_ARGS__) \ - TUPLE_DEFINE_INIT_SET2(name, __VA_ARGS__) \ - TUPLE_DEFINE_SET(name, __VA_ARGS__) \ - TUPLE_DEFINE_SET2(name, __VA_ARGS__) \ - TUPLE_DEFINE_CLEAR(name, __VA_ARGS__) \ - TUPLE_DEFINE_GETTER_FIELD(name, __VA_ARGS__) \ - TUPLE_DEFINE_SETTER_FIELD(name, __VA_ARGS__) \ - TUPLEI_IF_ALL(CMP, __VA_ARGS__)(TUPLE_DEFINE_CMP(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(CMP, __VA_ARGS__)(TUPLE_DEFINE_CMP_ORDER(name, __VA_ARGS__),) \ - TUPLE_DEFINE_CMP_FIELD(name, __VA_ARGS__) \ - TUPLEI_IF_ALL(HASH, __VA_ARGS__)(TUPLE_DEFINE_HASH(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(EQUAL, __VA_ARGS__)(TUPLE_DEFINE_EQUAL(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(GET_STR, __VA_ARGS__)(TUPLE_DEFINE_GET_STR(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(OUT_STR, __VA_ARGS__)(TUPLE_DEFINE_OUT_STR(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(IN_STR, __VA_ARGS__)(TUPLE_DEFINE_IN_STR(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(PARSE_STR, __VA_ARGS__)(TUPLE_DEFINE_PARSE_STR(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(OUT_SERIAL, __VA_ARGS__)(TUPLE_DEFINE_OUT_SERIAL(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(IN_SERIAL, __VA_ARGS__)(TUPLE_DEFINE_IN_SERIAL(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(INIT_MOVE, __VA_ARGS__)(TUPLE_DEFINE_INIT_MOVE(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(MOVE, __VA_ARGS__)(TUPLE_DEFINE_MOVE(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(SWAP, __VA_ARGS__)(TUPLE_DEFINE_SWAP(name, __VA_ARGS__),) \ - TUPLEI_IF_ALL(CLEAN, __VA_ARGS__)(TUPLE_DEFINE_CLEAN(name, __VA_ARGS__),) + TUPLEI_DEFINE_TYPE(name, __VA_ARGS__) \ + TUPLEI_DEFINE_ENUM(name, __VA_ARGS__) \ + TUPLEI_CONTROL_ALL_OPLIST(name, __VA_ARGS__) \ + TUPLEI_IF_ALL(INIT, __VA_ARGS__)(TUPLEI_DEFINE_INIT(name, __VA_ARGS__),) \ + TUPLEI_DEFINE_INIT_SET(name, __VA_ARGS__) \ + TUPLEI_DEFINE_INIT_SET2(name, __VA_ARGS__) \ + TUPLEI_DEFINE_SET(name, __VA_ARGS__) \ + TUPLEI_DEFINE_SET2(name, __VA_ARGS__) \ + TUPLEI_DEFINE_CLEAR(name, __VA_ARGS__) \ + TUPLEI_DEFINE_GETTER_FIELD(name, __VA_ARGS__) \ + TUPLEI_DEFINE_SETTER_FIELD(name, __VA_ARGS__) \ + TUPLEI_IF_ALL(CMP, __VA_ARGS__)(TUPLEI_DEFINE_CMP(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(CMP, __VA_ARGS__)(TUPLEI_DEFINE_CMP_ORDER(name, __VA_ARGS__),) \ + TUPLEI_DEFINE_CMP_FIELD(name, __VA_ARGS__) \ + TUPLEI_IF_ALL(HASH, __VA_ARGS__)(TUPLEI_DEFINE_HASH(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(EQUAL, __VA_ARGS__)(TUPLEI_DEFINE_EQUAL(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(GET_STR, __VA_ARGS__)(TUPLEI_DEFINE_GET_STR(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(OUT_STR, __VA_ARGS__)(TUPLEI_DEFINE_OUT_STR(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(IN_STR, __VA_ARGS__)(TUPLEI_DEFINE_IN_STR(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(PARSE_STR, __VA_ARGS__)(TUPLEI_DEFINE_PARSE_STR(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(OUT_SERIAL, __VA_ARGS__)(TUPLEI_DEFINE_OUT_SERIAL(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(IN_SERIAL, __VA_ARGS__)(TUPLEI_DEFINE_IN_SERIAL(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(INIT_MOVE, __VA_ARGS__)(TUPLEI_DEFINE_INIT_MOVE(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(MOVE, __VA_ARGS__)(TUPLEI_DEFINE_MOVE(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(SWAP, __VA_ARGS__)(TUPLEI_DEFINE_SWAP(name, __VA_ARGS__),) \ + TUPLEI_IF_ALL(CLEAN, __VA_ARGS__)(TUPLEI_DEFINE_CLEAN(name, __VA_ARGS__),) /* Provide order for _cmp_order */ -#define TUPLE_ORDER_CONVERT(name, x) M_C(name, M_C(TUPLE_ORDER_CONVERT_, x)) -#define TUPLE_ORDER_CONVERT_ASC(x) M_C3(_,x,_value) -#define TUPLE_ORDER_CONVERT_DSC(x) M_C3(_,x,_value)*-1 +#define TUPLEI_ORDER_CONVERT(name, x) M_C(name, M_C(TUPLEI_ORDER_CONVERT_, x)) +#define TUPLEI_ORDER_CONVERT_ASC(x) M_C3(_,x,_value) +#define TUPLEI_ORDER_CONVERT_DSC(x) M_C3(_,x,_value)*-1 /* Get the field name, the type, the oplist or the methods based on the tuple (field, type, oplist) */ -#define TUPLE_GET_FIELD(f,t,o) f -#define TUPLE_GET_TYPE(f,t,o) t -#define TUPLE_GET_OPLIST(f,t,o) o -#define TUPLE_GET_INIT(f,t,o) M_GET_INIT o -#define TUPLE_GET_INIT_SET(f,t,o) M_GET_INIT_SET o -#define TUPLE_GET_INIT_MOVE(f,t,o) M_GET_INIT_MOVE o -#define TUPLE_GET_MOVE(f,t,o) M_GET_MOVE o -#define TUPLE_GET_SET(f,t,o) M_GET_SET o -#define TUPLE_GET_CLEAR(f,t,o) M_GET_CLEAR o -#define TUPLE_GET_CMP(f,t,o) M_GET_CMP o -#define TUPLE_GET_HASH(f,t,o) M_GET_HASH o -#define TUPLE_GET_EQUAL(f,t,o) M_GET_EQUAL o -#define TUPLE_GET_STR(f,t,o) M_GET_GET_STR o -#define TUPLE_GET_OUT_STR(f,t,o) M_GET_OUT_STR o -#define TUPLE_GET_IN_STR(f,t,o) M_GET_IN_STR o -#define TUPLE_GET_OUT_SERIAL(f,t,o) M_GET_OUT_SERIAL o -#define TUPLE_GET_IN_SERIAL(f,t,o) M_GET_IN_SERIAL o -#define TUPLE_GET_PARSE_STR(f,t,o) M_GET_PARSE_STR o -#define TUPLE_GET_SWAP(f,t,o) M_GET_SWAP o -#define TUPLE_GET_CLEAN(f,t,o) M_GET_CLEAN o +#define TUPLEI_GET_FIELD(f,t,o) f +#define TUPLEI_GET_TYPE(f,t,o) t +#define TUPLEI_GET_OPLIST(f,t,o) o +#define TUPLEI_GET_INIT(f,t,o) M_GET_INIT o +#define TUPLEI_GET_INIT_SET(f,t,o) M_GET_INIT_SET o +#define TUPLEI_GET_INIT_MOVE(f,t,o) M_GET_INIT_MOVE o +#define TUPLEI_GET_MOVE(f,t,o) M_GET_MOVE o +#define TUPLEI_GET_SET(f,t,o) M_GET_SET o +#define TUPLEI_GET_CLEAR(f,t,o) M_GET_CLEAR o +#define TUPLEI_GET_CMP(f,t,o) M_GET_CMP o +#define TUPLEI_GET_HASH(f,t,o) M_GET_HASH o +#define TUPLEI_GET_EQUAL(f,t,o) M_GET_EQUAL o +#define TUPLEI_GET_STR(f,t,o) M_GET_GET_STR o +#define TUPLEI_GET_OUT_STR(f,t,o) M_GET_OUT_STR o +#define TUPLEI_GET_IN_STR(f,t,o) M_GET_IN_STR o +#define TUPLEI_GET_OUT_SERIAL(f,t,o) M_GET_OUT_SERIAL o +#define TUPLEI_GET_IN_SERIAL(f,t,o) M_GET_IN_SERIAL o +#define TUPLEI_GET_PARSE_STR(f,t,o) M_GET_PARSE_STR o +#define TUPLEI_GET_SWAP(f,t,o) M_GET_SWAP o +#define TUPLEI_GET_CLEAN(f,t,o) M_GET_CLEAN o /* Call the method associated to the given operator for the given parameter of the tuple t=(name, type, oplist) */ -#define TUPLE_CALL_INIT(t, ...) M_APPLY_API(TUPLE_GET_INIT t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_INIT_SET(t, ...) M_APPLY_API(TUPLE_GET_INIT_SET t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_INIT_MOVE(t, ...) M_APPLY_API(TUPLE_GET_INIT_MOVE t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_MOVE(t, ...) M_APPLY_API(TUPLE_GET_MOVE t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_SET(t, ...) M_APPLY_API(TUPLE_GET_SET t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_CLEAR(t, ...) M_APPLY_API(TUPLE_GET_CLEAR t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_CMP(t, ...) M_APPLY_API(TUPLE_GET_CMP t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_HASH(t, ...) M_APPLY_API(TUPLE_GET_HASH t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_EQUAL(t, ...) M_APPLY_API(TUPLE_GET_EQUAL t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_GET_STR(t, ...) M_APPLY_API(TUPLE_GET_STR t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_OUT_STR(t, ...) M_APPLY_API(TUPLE_GET_OUT_STR t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_IN_STR(t, ...) M_APPLY_API(TUPLE_GET_IN_STR t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_PARSE_STR(t, ...) M_APPLY_API(TUPLE_GET_PARSE_STR t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_OUT_SERIAL(t, ...) M_APPLY_API(TUPLE_GET_OUT_SERIAL t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_IN_SERIAL(t, ...) M_APPLY_API(TUPLE_GET_IN_SERIAL t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_SWAP(t, ...) M_APPLY_API(TUPLE_GET_SWAP t, TUPLE_GET_OPLIST t, __VA_ARGS__) -#define TUPLE_CALL_CLEAN(t, ...) M_APPLY_API(TUPLE_GET_CLEAN t, TUPLE_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_INIT(t, ...) M_APPLY_API(TUPLEI_GET_INIT t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_INIT_SET(t, ...) M_APPLY_API(TUPLEI_GET_INIT_SET t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_INIT_MOVE(t, ...) M_APPLY_API(TUPLEI_GET_INIT_MOVE t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_MOVE(t, ...) M_APPLY_API(TUPLEI_GET_MOVE t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_SET(t, ...) M_APPLY_API(TUPLEI_GET_SET t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_CLEAR(t, ...) M_APPLY_API(TUPLEI_GET_CLEAR t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_CMP(t, ...) M_APPLY_API(TUPLEI_GET_CMP t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_HASH(t, ...) M_APPLY_API(TUPLEI_GET_HASH t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_EQUAL(t, ...) M_APPLY_API(TUPLEI_GET_EQUAL t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_GET_STR(t, ...) M_APPLY_API(TUPLEI_GET_STR t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_OUT_STR(t, ...) M_APPLY_API(TUPLEI_GET_OUT_STR t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_IN_STR(t, ...) M_APPLY_API(TUPLEI_GET_IN_STR t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_PARSE_STR(t, ...) M_APPLY_API(TUPLEI_GET_PARSE_STR t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_OUT_SERIAL(t, ...) M_APPLY_API(TUPLEI_GET_OUT_SERIAL t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_IN_SERIAL(t, ...) M_APPLY_API(TUPLEI_GET_IN_SERIAL t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_SWAP(t, ...) M_APPLY_API(TUPLEI_GET_SWAP t, TUPLEI_GET_OPLIST t, __VA_ARGS__) +#define TUPLEI_CALL_CLEAN(t, ...) M_APPLY_API(TUPLEI_GET_CLEAN t, TUPLEI_GET_OPLIST t, __VA_ARGS__) /* Define the type of a tuple */ -#define TUPLE_DEFINE_TYPE(name, ...) \ +#define TUPLEI_DEFINE_TYPE(name, ...) \ typedef struct M_C(name, _s) { \ - M_MAP(TUPLE_DEFINE_RECUR_TYPE_ELE , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_RECUR_TYPE_ELE , __VA_ARGS__) \ } M_C(name,_t)[1]; \ typedef struct M_C(name, _s) *M_C(name, _ptr); \ typedef const struct M_C(name, _s) *M_C(name, _srcptr); -#define TUPLE_DEFINE_RECUR_TYPE_ELE(a) \ - TUPLE_GET_TYPE a TUPLE_GET_FIELD a ; +#define TUPLEI_DEFINE_RECUR_TYPE_ELE(a) \ + TUPLEI_GET_TYPE a TUPLEI_GET_FIELD a ; /* Define the basic enumerate, identifying a parameter */ -#define TUPLE_DEFINE_ENUM(name, ...) \ +#define TUPLEI_DEFINE_ENUM(name, ...) \ typedef enum { \ M_C(name, _first_one_val), \ - M_MAP2_C(TUPLE_DEFINE_ENUM_ELE , name, __VA_ARGS__) \ + M_MAP2_C(TUPLEI_DEFINE_ENUM_ELE , name, __VA_ARGS__) \ } M_C(name,_field_e); -#define TUPLE_DEFINE_ENUM_ELE(name, a) \ - M_C4(name, _, TUPLE_GET_FIELD a, _value) +#define TUPLEI_DEFINE_ENUM_ELE(name, a) \ + M_C4(name, _, TUPLEI_GET_FIELD a, _value) /* Control that all given oplists of all parameters are really oplists */ -#define TUPLE_CONTROL_ALL_OPLIST(name, ...) \ - M_MAP2(TUPLE_CONTROL_OPLIST, name, __VA_ARGS__) +#define TUPLEI_CONTROL_ALL_OPLIST(name, ...) \ + M_MAP2(TUPLEI_CONTROL_OPLIST, name, __VA_ARGS__) -#define TUPLE_CONTROL_OPLIST(name, a) \ - M_CHECK_COMPATIBLE_OPLIST(name, TUPLE_GET_FIELD a, \ - TUPLE_GET_TYPE a, TUPLE_GET_OPLIST a) +#define TUPLEI_CONTROL_OPLIST(name, a) \ + M_CHECK_COMPATIBLE_OPLIST(name, TUPLEI_GET_FIELD a, \ + TUPLEI_GET_TYPE a, TUPLEI_GET_OPLIST a) /* Define the INIT method calling the INIT method for all params */ -#define TUPLE_DEFINE_INIT(name, ...) \ +#define TUPLEI_DEFINE_INIT(name, ...) \ static inline void M_C(name, _init)(M_C(name,_t) my) { \ - M_MAP(TUPLE_DEFINE_INIT_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_INIT_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_INIT_FUNC(a) \ - TUPLE_CALL_INIT(a, my -> TUPLE_GET_FIELD a ); +#define TUPLEI_DEFINE_INIT_FUNC(a) \ + TUPLEI_CALL_INIT(a, my -> TUPLEI_GET_FIELD a ); /* Define the INIT_SET method calling the INIT_SET method for all params */ -#define TUPLE_DEFINE_INIT_SET(name, ...) \ +#define TUPLEI_DEFINE_INIT_SET(name, ...) \ static inline void M_C(name, _init_set)(M_C(name,_t) my , M_C(name,_t) const org) { \ TUPLEI_CONTRACT(org); \ - M_MAP(TUPLE_DEFINE_INIT_SET_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_INIT_SET_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_INIT_SET_FUNC(a) \ - TUPLE_CALL_INIT_SET(a, my -> TUPLE_GET_FIELD a , org -> TUPLE_GET_FIELD a ); +#define TUPLEI_DEFINE_INIT_SET_FUNC(a) \ + TUPLEI_CALL_INIT_SET(a, my -> TUPLEI_GET_FIELD a , org -> TUPLEI_GET_FIELD a ); /* Define the INIT_WITH method calling the INIT_SET method for all params. */ /* FIXME: To rename? */ -#define TUPLE_DEFINE_INIT_SET2(name, ...) \ +#define TUPLEI_DEFINE_INIT_SET2(name, ...) \ static inline void M_C(name, _init_set2)(M_C(name,_t) my \ - M_MAP(TUPLE_DEFINE_INIT_SET2_PROTO, __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_INIT_SET2_PROTO, __VA_ARGS__) \ ) { \ - M_MAP(TUPLE_DEFINE_INIT_SET2_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_INIT_SET2_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_INIT_SET2_PROTO(a) \ - , TUPLE_GET_TYPE a const TUPLE_GET_FIELD a +#define TUPLEI_DEFINE_INIT_SET2_PROTO(a) \ + , TUPLEI_GET_TYPE a const TUPLEI_GET_FIELD a -#define TUPLE_DEFINE_INIT_SET2_FUNC(a) \ - TUPLE_CALL_INIT_SET(a, my -> TUPLE_GET_FIELD a , TUPLE_GET_FIELD a ); +#define TUPLEI_DEFINE_INIT_SET2_FUNC(a) \ + TUPLEI_CALL_INIT_SET(a, my -> TUPLEI_GET_FIELD a , TUPLEI_GET_FIELD a ); /* Define the SET method calling the SET method for all params. */ -#define TUPLE_DEFINE_SET(name, ...) \ +#define TUPLEI_DEFINE_SET(name, ...) \ static inline void M_C(name, _set)(M_C(name,_t) my , \ M_C(name,_t) const org) { \ TUPLEI_CONTRACT(my); \ TUPLEI_CONTRACT(org); \ - M_MAP(TUPLE_DEFINE_SET_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_SET_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_SET_FUNC(a) \ - TUPLE_CALL_SET(a, my -> TUPLE_GET_FIELD a , org -> TUPLE_GET_FIELD a ); +#define TUPLEI_DEFINE_SET_FUNC(a) \ + TUPLEI_CALL_SET(a, my -> TUPLEI_GET_FIELD a , org -> TUPLEI_GET_FIELD a ); /* Define the SET_WITH method calling the SET method for all params. */ /* FIXME: To rename? */ -#define TUPLE_DEFINE_SET2(name, ...) \ +#define TUPLEI_DEFINE_SET2(name, ...) \ static inline void M_C(name, _set2)(M_C(name,_t) my \ - M_MAP(TUPLE_DEFINE_SET2_PROTO, __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_SET2_PROTO, __VA_ARGS__) \ ) { \ TUPLEI_CONTRACT(my); \ - M_MAP(TUPLE_DEFINE_SET2_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_SET2_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_SET2_PROTO(a) \ - , TUPLE_GET_TYPE a const TUPLE_GET_FIELD a +#define TUPLEI_DEFINE_SET2_PROTO(a) \ + , TUPLEI_GET_TYPE a const TUPLEI_GET_FIELD a -#define TUPLE_DEFINE_SET2_FUNC(a) \ - TUPLE_CALL_SET(a, my -> TUPLE_GET_FIELD a , TUPLE_GET_FIELD a ); +#define TUPLEI_DEFINE_SET2_FUNC(a) \ + TUPLEI_CALL_SET(a, my -> TUPLEI_GET_FIELD a , TUPLEI_GET_FIELD a ); /* Define the CLEAR method calling the CLEAR method for all params. */ -#define TUPLE_DEFINE_CLEAR(name, ...) \ +#define TUPLEI_DEFINE_CLEAR(name, ...) \ static inline void M_C(name, _clear)(M_C(name,_t) my) { \ TUPLEI_CONTRACT(my); \ - M_MAP(TUPLE_DEFINE_CLEAR_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_CLEAR_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_CLEAR_FUNC(a) \ - TUPLE_CALL_CLEAR(a, my -> TUPLE_GET_FIELD a ); +#define TUPLEI_DEFINE_CLEAR_FUNC(a) \ + TUPLEI_CALL_CLEAR(a, my -> TUPLEI_GET_FIELD a ); /* Define the GET_AT_field & CGET_AT methods for all params. */ -#define TUPLE_DEFINE_GETTER_FIELD(name, ...) \ - M_MAP2(TUPLE_DEFINE_GETTER_FIELD_PROTO, name, __VA_ARGS__) +#define TUPLEI_DEFINE_GETTER_FIELD(name, ...) \ + M_MAP2(TUPLEI_DEFINE_GETTER_FIELD_PROTO, name, __VA_ARGS__) -#define TUPLE_DEFINE_GETTER_FIELD_PROTO(name, a) \ - static inline TUPLE_GET_TYPE a * M_C3(name, _get_at_, TUPLE_GET_FIELD a) \ +#define TUPLEI_DEFINE_GETTER_FIELD_PROTO(name, a) \ + static inline TUPLEI_GET_TYPE a * M_C3(name, _get_at_, TUPLEI_GET_FIELD a) \ (M_C(name,_t) my) { \ TUPLEI_CONTRACT(my); \ - return &(my->TUPLE_GET_FIELD a); \ + return &(my->TUPLEI_GET_FIELD a); \ } \ - static inline TUPLE_GET_TYPE a const * M_C3(name, _cget_at_, TUPLE_GET_FIELD a) \ + static inline TUPLEI_GET_TYPE a const * M_C3(name, _cget_at_, TUPLEI_GET_FIELD a) \ (M_C(name,_t) const my) { \ TUPLEI_CONTRACT(my); \ - return &(my->TUPLE_GET_FIELD a); \ + return &(my->TUPLEI_GET_FIELD a); \ } /* Define the SET_field methods for all params. */ -#define TUPLE_DEFINE_SETTER_FIELD(name, ...) \ - M_MAP2(TUPLE_DEFINE_SETTER_FIELD_PROTO, name, __VA_ARGS__) +#define TUPLEI_DEFINE_SETTER_FIELD(name, ...) \ + M_MAP2(TUPLEI_DEFINE_SETTER_FIELD_PROTO, name, __VA_ARGS__) -#define TUPLE_DEFINE_SETTER_FIELD_PROTO(name, a) \ - static inline void M_C3(name, _set_, TUPLE_GET_FIELD a) \ - (M_C(name,_t) my, TUPLE_GET_TYPE a const TUPLE_GET_FIELD a) { \ +#define TUPLEI_DEFINE_SETTER_FIELD_PROTO(name, a) \ + static inline void M_C3(name, _set_, TUPLEI_GET_FIELD a) \ + (M_C(name,_t) my, TUPLEI_GET_TYPE a const TUPLEI_GET_FIELD a) { \ TUPLEI_CONTRACT(my); \ - TUPLE_CALL_SET(a, my ->TUPLE_GET_FIELD a, TUPLE_GET_FIELD a); \ + TUPLEI_CALL_SET(a, my ->TUPLEI_GET_FIELD a, TUPLEI_GET_FIELD a); \ } /* Define the CMP method by calling CMP methods for all params. */ -#define TUPLE_DEFINE_CMP(name, ...) \ +#define TUPLEI_DEFINE_CMP(name, ...) \ static inline int M_C(name, _cmp)(M_C(name,_t) const e1 , \ M_C(name,_t) const e2) { \ int i; \ TUPLEI_CONTRACT(e1); \ TUPLEI_CONTRACT(e2); \ - M_MAP(TUPLE_DEFINE_CMP_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_CMP_FUNC , __VA_ARGS__) \ return 0; \ } -#define TUPLE_DEFINE_CMP_FUNC(a) \ - i = TUPLE_CALL_CMP(a, e1 -> TUPLE_GET_FIELD a , e2 -> TUPLE_GET_FIELD a ); \ +#define TUPLEI_DEFINE_CMP_FUNC(a) \ + i = TUPLEI_CALL_CMP(a, e1 -> TUPLEI_GET_FIELD a , e2 -> TUPLEI_GET_FIELD a ); \ if (i != 0) return i; @@ -342,7 +343,7 @@ namespace m_tuple { In the right order FIXME: _cmp_order is not supported by algorithm yet. */ -#define TUPLE_DEFINE_CMP_ORDER(name, ...) \ +#define TUPLEI_DEFINE_CMP_ORDER(name, ...) \ static inline int M_C(name, _cmp_order)(M_C(name,_t) const e1 , \ M_C(name,_t) const e2, \ const int order[]) { \ @@ -353,30 +354,30 @@ namespace m_tuple { i=*order++; \ switch (i) { \ case 0: return 0; \ - M_MAP2(TUPLE_DEFINE_CMP_ORDER_FUNC , name, __VA_ARGS__) \ + M_MAP2(TUPLEI_DEFINE_CMP_ORDER_FUNC , name, __VA_ARGS__) \ default: assert(0); \ } \ } \ } -#define TUPLE_DEFINE_CMP_ORDER_FUNC(name, a) \ - case M_C4(name, _, TUPLE_GET_FIELD a, _value): \ - case -M_C4(name, _, TUPLE_GET_FIELD a, _value): \ - r = TUPLE_CALL_CMP(a, e1 -> TUPLE_GET_FIELD a , e2 -> TUPLE_GET_FIELD a ); \ +#define TUPLEI_DEFINE_CMP_ORDER_FUNC(name, a) \ + case M_C4(name, _, TUPLEI_GET_FIELD a, _value): \ + case -M_C4(name, _, TUPLEI_GET_FIELD a, _value): \ + r = TUPLEI_CALL_CMP(a, e1 -> TUPLEI_GET_FIELD a , e2 -> TUPLEI_GET_FIELD a ); \ if (r != 0) return i < 0 ? -r : r; \ break; /* Define a CMP_field method for all given params that export a CMP method */ -#define TUPLE_DEFINE_CMP_FIELD(name, ...) \ - M_MAP2(TUPLE_MAP_CMP_FIELD, name, __VA_ARGS__) +#define TUPLEI_DEFINE_CMP_FIELD(name, ...) \ + M_MAP2(TUPLEI_MAP_CMP_FIELD, name, __VA_ARGS__) -#define TUPLE_MAP_CMP_FIELD(name, a) \ - M_IF_METHOD(CMP, TUPLE_GET_OPLIST a)( \ - TUPLE_DEFINE_CMP_FIELD_FUNC(name, TUPLE_GET_FIELD a, TUPLE_GET_CMP a), \ +#define TUPLEI_MAP_CMP_FIELD(name, a) \ + M_IF_METHOD(CMP, TUPLEI_GET_OPLIST a)( \ + TUPLEI_DEFINE_CMP_FIELD_FUNC(name, TUPLEI_GET_FIELD a, TUPLEI_GET_CMP a), \ ) -#define TUPLE_DEFINE_CMP_FIELD_FUNC(name, field, func_cmp) \ +#define TUPLEI_DEFINE_CMP_FIELD_FUNC(name, field, func_cmp) \ static inline int M_C3(name, _cmp_, field)(M_C(name,_t) const e1 , \ M_C(name,_t) const e2) { \ TUPLEI_CONTRACT(e1); \ @@ -386,36 +387,36 @@ namespace m_tuple { /* Define a EQUAL method by calling the EQUAL methods for all params */ -#define TUPLE_DEFINE_EQUAL(name, ...) \ +#define TUPLEI_DEFINE_EQUAL(name, ...) \ static inline bool M_C(name, _equal_p)(M_C(name,_t) const e1 , \ M_C(name,_t) const e2) { \ bool b; \ TUPLEI_CONTRACT(e1); \ TUPLEI_CONTRACT(e2); \ - M_MAP(TUPLE_DEFINE_EQUAL_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_EQUAL_FUNC , __VA_ARGS__) \ return true; \ } -#define TUPLE_DEFINE_EQUAL_FUNC(a) \ - b = TUPLE_CALL_EQUAL(a, e1 -> TUPLE_GET_FIELD a , e2 -> TUPLE_GET_FIELD a ); \ +#define TUPLEI_DEFINE_EQUAL_FUNC(a) \ + b = TUPLEI_CALL_EQUAL(a, e1 -> TUPLEI_GET_FIELD a , e2 -> TUPLEI_GET_FIELD a ); \ if (!b) return false; /* Define a HASH method by calling the HASH methods for all params */ -#define TUPLE_DEFINE_HASH(name, ...) \ +#define TUPLEI_DEFINE_HASH(name, ...) \ static inline size_t M_C(name, _hash)(M_C(name,_t) const e1) { \ TUPLEI_CONTRACT(e1); \ M_HASH_DECL(hash); \ - M_MAP(TUPLE_DEFINE_HASH_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_HASH_FUNC , __VA_ARGS__) \ return M_HASH_FINAL (hash); \ } -#define TUPLE_DEFINE_HASH_FUNC(a) \ - M_HASH_UP(hash, TUPLE_CALL_HASH(a, e1 -> TUPLE_GET_FIELD a) ); +#define TUPLEI_DEFINE_HASH_FUNC(a) \ + M_HASH_UP(hash, TUPLEI_CALL_HASH(a, e1 -> TUPLEI_GET_FIELD a) ); /* Define a GET_STR method by calling the GET_STR methods for all params */ -#define TUPLE_DEFINE_GET_STR(name, ...) \ +#define TUPLEI_DEFINE_GET_STR(name, ...) \ static inline void M_C(name, _get_str)(string_t str, \ M_C(name,_t) const el, \ bool append) { \ @@ -423,59 +424,59 @@ namespace m_tuple { TUPLEI_CONTRACT(el); \ assert (str != NULL); \ (append ? string_cat_str : string_set_str) (str, "("); \ - M_MAP(TUPLE_DEFINE_GET_STR_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_GET_STR_FUNC , __VA_ARGS__) \ string_push_back (str, ')'); \ } -#define TUPLE_DEFINE_GET_STR_FUNC(a) \ +#define TUPLEI_DEFINE_GET_STR_FUNC(a) \ if (comma) string_push_back (str, ','); \ comma = true; \ - TUPLE_CALL_GET_STR(a, str, el -> TUPLE_GET_FIELD a, true); \ + TUPLEI_CALL_GET_STR(a, str, el -> TUPLEI_GET_FIELD a, true); \ /* Define a OUT_STR method by calling the OUT_STR methods for all params */ -#define TUPLE_DEFINE_OUT_STR(name, ...) \ +#define TUPLEI_DEFINE_OUT_STR(name, ...) \ static inline void M_C(name, _out_str)(FILE *f, \ M_C(name,_t) const el) { \ bool comma = false; \ TUPLEI_CONTRACT(el); \ assert (f != NULL); \ fputc('(', f); \ - M_MAP(TUPLE_DEFINE_OUT_STR_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_OUT_STR_FUNC , __VA_ARGS__) \ fputc (')', f); \ } -#define TUPLE_DEFINE_OUT_STR_FUNC(a) \ +#define TUPLEI_DEFINE_OUT_STR_FUNC(a) \ if (comma) fputc (',', f); \ comma = true; \ - TUPLE_CALL_OUT_STR(a, f, el -> TUPLE_GET_FIELD a); \ + TUPLEI_CALL_OUT_STR(a, f, el -> TUPLEI_GET_FIELD a); \ /* Define a IN_STR method by calling the IN_STR methods for all params */ -#define TUPLE_DEFINE_IN_STR(name, ...) \ +#define TUPLEI_DEFINE_IN_STR(name, ...) \ static inline bool M_C(name, _in_str)(M_C(name,_t) el, FILE *f) { \ bool comma = false; \ TUPLEI_CONTRACT(el); \ assert (f != NULL); \ int c = fgetc(f); \ if (c != '(') return false; \ - M_MAP(TUPLE_DEFINE_IN_STR_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_IN_STR_FUNC , __VA_ARGS__) \ c = fgetc(f); \ return (c == ')'); \ } -#define TUPLE_DEFINE_IN_STR_FUNC(a) \ +#define TUPLEI_DEFINE_IN_STR_FUNC(a) \ if (comma) { \ c = fgetc (f); \ if (c != ',' || c == EOF) return false; \ } \ comma = true; \ - if (TUPLE_CALL_IN_STR(a, el -> TUPLE_GET_FIELD a, f) == false) \ + if (TUPLEI_CALL_IN_STR(a, el -> TUPLEI_GET_FIELD a, f) == false) \ return false ; \ /* Define a PARSE_STR method by calling the PARSE_STR methods for all params */ -#define TUPLE_DEFINE_PARSE_STR(name, ...) \ +#define TUPLEI_DEFINE_PARSE_STR(name, ...) \ static inline bool M_C(name, _parse_str)(M_C(name,_t) el, \ const char str[], \ const char **endptr) { \ @@ -485,7 +486,7 @@ namespace m_tuple { bool comma = false; \ int c = *str++; \ if (c != '(') goto exit; \ - M_MAP(TUPLE_DEFINE_PARSE_STR_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_PARSE_STR_FUNC , __VA_ARGS__) \ c = *str++; \ success = (c == ')'); \ exit: \ @@ -493,23 +494,23 @@ namespace m_tuple { return success; \ } -#define TUPLE_DEFINE_PARSE_STR_FUNC(a) \ +#define TUPLEI_DEFINE_PARSE_STR_FUNC(a) \ if (comma) { \ c = *str++; \ if (c != ',' || c == 0) goto exit; \ } \ comma = true; \ - if (TUPLE_CALL_PARSE_STR(a, el -> TUPLE_GET_FIELD a, str, &str) == false) \ + if (TUPLEI_CALL_PARSE_STR(a, el -> TUPLEI_GET_FIELD a, str, &str) == false) \ goto exit ; \ /* Return the parameter name as a C string */ -#define TUPLE_STRINGIFY_NAME(a) \ - M_APPLY(M_AS_STR, TUPLE_GET_FIELD a) +#define TUPLEI_STRINGIFY_NAME(a) \ + M_APPLY(M_AS_STR, TUPLEI_GET_FIELD a) /* Define a OUT_SERIAL method by calling the OUT_SERIAL methods for all params */ -#define TUPLE_DEFINE_OUT_SERIAL(name, ...) \ +#define TUPLEI_DEFINE_OUT_SERIAL(name, ...) \ static inline m_serial_return_code_t \ M_C(name, _out_serial)(m_serial_write_t f, \ M_C(name,_t) const el) { \ @@ -518,25 +519,25 @@ namespace m_tuple { const int field_max = M_NARGS(__VA_ARGS__); \ /* Define a constant static table of all fields names */ \ static const char *const field_name[] = \ - { M_REDUCE(TUPLE_STRINGIFY_NAME, M_ID, __VA_ARGS__) }; \ + { M_REDUCE(TUPLEI_STRINGIFY_NAME, M_ID, __VA_ARGS__) }; \ int index = 0; \ m_serial_local_t local; \ m_serial_return_code_t ret; \ ret = f->m_interface->write_tuple_start(local, f); \ - M_MAP(TUPLE_DEFINE_OUT_SERIAL_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_OUT_SERIAL_FUNC , __VA_ARGS__) \ assert( index == field_max); \ ret |= f->m_interface->write_tuple_end(local, f); \ return ret & M_SERIAL_FAIL; \ } -#define TUPLE_DEFINE_OUT_SERIAL_FUNC(a) \ +#define TUPLEI_DEFINE_OUT_SERIAL_FUNC(a) \ f->m_interface->write_tuple_id(local, f, field_name, field_max, index); \ - TUPLE_CALL_OUT_SERIAL(a, f, el -> TUPLE_GET_FIELD a); \ + TUPLEI_CALL_OUT_SERIAL(a, f, el -> TUPLEI_GET_FIELD a); \ index++; \ /* Define a IN_SERIAL method by calling the IN_SERIAL methods for all params */ -#define TUPLE_DEFINE_IN_SERIAL(name, ...) \ +#define TUPLEI_DEFINE_IN_SERIAL(name, ...) \ static inline m_serial_return_code_t \ M_C(name, _in_serial)(M_C(name,_t) el, m_serial_read_t f) { \ TUPLEI_CONTRACT(el); \ @@ -544,7 +545,7 @@ namespace m_tuple { int index = -1; \ const int field_max = M_NARGS(__VA_ARGS__); \ static const char *const field_name[] = \ - { M_REDUCE(TUPLE_STRINGIFY_NAME, M_ID, __VA_ARGS__) }; \ + { M_REDUCE(TUPLEI_STRINGIFY_NAME, M_ID, __VA_ARGS__) }; \ m_serial_local_t local; \ m_serial_return_code_t ret; \ ret = f->m_interface->read_tuple_start(local, f); \ @@ -553,7 +554,7 @@ namespace m_tuple { if (ret == M_SERIAL_OK_CONTINUE) { \ assert (index >= 0 && index < field_max); \ switch (1+index) { \ - M_MAP2(TUPLE_DEFINE_IN_SERIAL_FUNC , name, __VA_ARGS__) \ + M_MAP2(TUPLEI_DEFINE_IN_SERIAL_FUNC , name, __VA_ARGS__) \ default: assert(0); \ } \ ret = (ret == M_SERIAL_OK_DONE) ? M_SERIAL_OK_CONTINUE : M_SERIAL_FAIL; \ @@ -562,68 +563,68 @@ namespace m_tuple { return ret; \ } -#define TUPLE_DEFINE_IN_SERIAL_FUNC(name, a) \ - case M_C4(name, _, TUPLE_GET_FIELD a, _value): \ - ret = TUPLE_CALL_IN_SERIAL(a, el -> TUPLE_GET_FIELD a, f); \ +#define TUPLEI_DEFINE_IN_SERIAL_FUNC(name, a) \ + case M_C4(name, _, TUPLEI_GET_FIELD a, _value): \ + ret = TUPLEI_CALL_IN_SERIAL(a, el -> TUPLEI_GET_FIELD a, f); \ break; \ /* Define a INIT_MOVE method by calling the INIT_MOVE methods for all params */ -#define TUPLE_DEFINE_INIT_MOVE(name, ...) \ +#define TUPLEI_DEFINE_INIT_MOVE(name, ...) \ static inline void M_C(name, _init_move)(M_C(name,_t) el, M_C(name,_t) org) { \ TUPLEI_CONTRACT(el); \ - M_MAP(TUPLE_DEFINE_INIT_MOVE_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_INIT_MOVE_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_INIT_MOVE_FUNC(a) \ - TUPLE_CALL_INIT_MOVE(a, el -> TUPLE_GET_FIELD a, org -> TUPLE_GET_FIELD a); +#define TUPLEI_DEFINE_INIT_MOVE_FUNC(a) \ + TUPLEI_CALL_INIT_MOVE(a, el -> TUPLEI_GET_FIELD a, org -> TUPLEI_GET_FIELD a); /* Define a MOVE method by calling the MOVE methods for all params */ -#define TUPLE_DEFINE_MOVE(name, ...) \ +#define TUPLEI_DEFINE_MOVE(name, ...) \ static inline void M_C(name, _move)(M_C(name,_t) el, M_C(name,_t) org) { \ TUPLEI_CONTRACT(el); \ - M_MAP(TUPLE_DEFINE_MOVE_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_MOVE_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_MOVE_FUNC(a) \ - TUPLE_CALL_MOVE(a, el -> TUPLE_GET_FIELD a, org -> TUPLE_GET_FIELD a); +#define TUPLEI_DEFINE_MOVE_FUNC(a) \ + TUPLEI_CALL_MOVE(a, el -> TUPLEI_GET_FIELD a, org -> TUPLEI_GET_FIELD a); /* Define a SWAP method by calling the SWAP methods for all params */ -#define TUPLE_DEFINE_SWAP(name, ...) \ +#define TUPLEI_DEFINE_SWAP(name, ...) \ static inline void M_C(name, _swap)(M_C(name,_t) el1, M_C(name,_t) el2) { \ TUPLEI_CONTRACT(el1); \ TUPLEI_CONTRACT(el2); \ - M_MAP(TUPLE_DEFINE_SWAP_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_SWAP_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_SWAP_FUNC(a) \ - TUPLE_CALL_SWAP(a, el1 -> TUPLE_GET_FIELD a, el2 -> TUPLE_GET_FIELD a); +#define TUPLEI_DEFINE_SWAP_FUNC(a) \ + TUPLEI_CALL_SWAP(a, el1 -> TUPLEI_GET_FIELD a, el2 -> TUPLEI_GET_FIELD a); /* Define a CLEAN method by calling the CLEAN methods for all params */ -#define TUPLE_DEFINE_CLEAN(name, ...) \ +#define TUPLEI_DEFINE_CLEAN(name, ...) \ static inline void M_C(name, _clean)(M_C(name,_t) el1) { \ TUPLEI_CONTRACT(el1); \ - M_MAP(TUPLE_DEFINE_CLEAN_FUNC , __VA_ARGS__) \ + M_MAP(TUPLEI_DEFINE_CLEAN_FUNC , __VA_ARGS__) \ } -#define TUPLE_DEFINE_CLEAN_FUNC(a) \ - TUPLE_CALL_CLEAN(a, el1 -> TUPLE_GET_FIELD a); +#define TUPLEI_DEFINE_CLEAN_FUNC(a) \ + TUPLEI_CALL_CLEAN(a, el1 -> TUPLEI_GET_FIELD a); /* Macros for testing for the presence of a method in the parameter (name, type, oplist) */ -#define TUPLE_TEST_METHOD_P(method, trio) \ - M_APPLY(TUPLE_TEST_METHOD2_P, method, M_OPFLAT trio) +#define TUPLEI_TEST_METHOD_P(method, trio) \ + M_APPLY(TUPLEI_TEST_METHOD2_P, method, M_OPFLAT trio) -#define TUPLE_TEST_METHOD2_P(method, f, t, op) \ +#define TUPLEI_TEST_METHOD2_P(method, f, t, op) \ M_TEST_METHOD_P(method, op) /* Macros for testing for the presence of a method in all the params */ #define TUPLEI_IF_ALL(method, ...) \ - M_IF(M_REDUCE2(TUPLE_TEST_METHOD_P, M_AND, method, __VA_ARGS__)) + M_IF(M_REDUCE2(TUPLEI_TEST_METHOD_P, M_AND, method, __VA_ARGS__)) // deferred evaluation #define TUPLEI_OPLIST_P1(arg) TUPLEI_OPLIST_P2 arg @@ -634,7 +635,7 @@ namespace m_tuple { /* Prepare a clean compilation failure */ #define TUPLEI_OPLIST_FAILURE(name, ...) \ - ((M_LIB_ERROR(ONE_ARGUMENT_OF_TUPLE_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__))) + ((M_LIB_ERROR(ONE_ARGUMENT_OF_TUPLEI_OPLIST_IS_NOT_AN_OPLIST, name, __VA_ARGS__))) /* Define the TUPLE oplist */ #define TUPLEI_OPLIST_P3(name, ...) \