Rename macros:
* CAT* --> M_C*
This commit is contained in:
Patrick Pelissier committed
1 parent
8613bdbca6
commit
cb433aa2a8
15 files changed
+806
-809
No files matched your search
@@ -50,33 +50,33 @@
|
||||
/********************************** INTERNAL ************************************/
|
||||
|
||||
#define ARRAYI_OPLIST(name, oplist) \
|
||||
(INIT(CAT3(array_, name, _init)) \
|
||||
,INIT_SET(CAT3(array_, name, _init_set)) \
|
||||
,SET(CAT3(array_, name, _set)) \
|
||||
,CLEAR(CAT3(array_, name, _clear)) \
|
||||
,INIT_MOVE(CAT3(array_, name, _init_move)) \
|
||||
,MOVE(CAT3(array_, name, _move)) \
|
||||
,TYPE(CAT3(array_,name,_t)) \
|
||||
,SUBTYPE(CAT3(array_type_,name,_t)) \
|
||||
,IT_TYPE(CAT3(array_it_,name,_t)) \
|
||||
,IT_FIRST(CAT3(array_,name,_it)) \
|
||||
,IT_SET(CAT3(array_,name,_it_set)) \
|
||||
,IT_END_P(CAT3(array_,name,_end_p)) \
|
||||
,IT_LAST_P(CAT3(array_,name,_last_p)) \
|
||||
,IT_EQUAL_P(CAT3(array_,name,_it_equal_p)) \
|
||||
,IT_NEXT(CAT3(array_,name,_next)) \
|
||||
,IT_PREVIOUS(CAT3(array_,name,_previous)) \
|
||||
,IT_REF(CAT3(array_,name,_ref)) \
|
||||
,IT_CREF(CAT3(array_,name,_cref)) \
|
||||
,CLEAN(CAT3(array_,name,_clean)) \
|
||||
,PUSH(CAT3(array_,name,_push_back)) \
|
||||
,POP(CAT3(array_,name,_pop_back)) \
|
||||
(INIT(M_C3(array_, name, _init)) \
|
||||
,INIT_SET(M_C3(array_, name, _init_set)) \
|
||||
,SET(M_C3(array_, name, _set)) \
|
||||
,CLEAR(M_C3(array_, name, _clear)) \
|
||||
,INIT_MOVE(M_C3(array_, name, _init_move)) \
|
||||
,MOVE(M_C3(array_, name, _move)) \
|
||||
,TYPE(M_C3(array_,name,_t)) \
|
||||
,SUBTYPE(M_C3(array_type_,name,_t)) \
|
||||
,IT_TYPE(M_C3(array_it_,name,_t)) \
|
||||
,IT_FIRST(M_C3(array_,name,_it)) \
|
||||
,IT_SET(M_C3(array_,name,_it_set)) \
|
||||
,IT_END_P(M_C3(array_,name,_end_p)) \
|
||||
,IT_LAST_P(M_C3(array_,name,_last_p)) \
|
||||
,IT_EQUAL_P(M_C3(array_,name,_it_equal_p)) \
|
||||
,IT_NEXT(M_C3(array_,name,_next)) \
|
||||
,IT_PREVIOUS(M_C3(array_,name,_previous)) \
|
||||
,IT_REF(M_C3(array_,name,_ref)) \
|
||||
,IT_CREF(M_C3(array_,name,_cref)) \
|
||||
,CLEAN(M_C3(array_,name,_clean)) \
|
||||
,PUSH(M_C3(array_,name,_push_back)) \
|
||||
,POP(M_C3(array_,name,_pop_back)) \
|
||||
,OPLIST(oplist) \
|
||||
,M_IF_METHOD(CMP, oplist)(SORT(CAT3(array_, name, _sort)),) \
|
||||
,M_IF_METHOD(GET_STR, oplist)(GET_STR(CAT3(array_, name, _get_str)),) \
|
||||
,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(CAT3(array_, name, _out_str)),) \
|
||||
,M_IF_METHOD(IN_STR, oplist)(IN_STR(CAT3(array_, name, _in_str)),) \
|
||||
,M_IF_METHOD(EQUAL, oplist)(EQUAL(CAT3(array_, type, _equal_p)),) \
|
||||
,M_IF_METHOD(CMP, oplist)(SORT(M_C3(array_, name, _sort)),) \
|
||||
,M_IF_METHOD(GET_STR, oplist)(GET_STR(M_C3(array_, name, _get_str)),) \
|
||||
,M_IF_METHOD(OUT_STR, oplist)(OUT_STR(M_C3(array_, name, _out_str)),) \
|
||||
,M_IF_METHOD(IN_STR, oplist)(IN_STR(M_C3(array_, name, _in_str)),) \
|
||||
,M_IF_METHOD(EQUAL, oplist)(EQUAL(M_C3(array_, type, _equal_p)),) \
|
||||
)
|
||||
|
||||
// Compute alloc from size.
|
||||
@@ -84,33 +84,33 @@
|
||||
|
||||
// Internal
|
||||
#define ARRAYI_DEF2(name, type, oplist) \
|
||||
typedef struct CAT3(array_, name, _s) { \
|
||||
typedef struct M_C3(array_, name, _s) { \
|
||||
size_t size, alloc; \
|
||||
type *ptr; \
|
||||
} CAT3(array_, name,_t)[1]; \
|
||||
} M_C3(array_, name,_t)[1]; \
|
||||
\
|
||||
typedef union { \
|
||||
type *ptr; \
|
||||
const type *cptr; \
|
||||
} CAT3(array_union_, name,_t); \
|
||||
} M_C3(array_union_, name,_t); \
|
||||
\
|
||||
typedef type CAT3(array_type_,name,_t); \
|
||||
typedef type M_C3(array_type_,name,_t); \
|
||||
\
|
||||
typedef struct CAT3(array_it_,name,_s) { \
|
||||
typedef struct M_C3(array_it_,name,_s) { \
|
||||
size_t index; \
|
||||
struct CAT3(array_, name, _s) *array; \
|
||||
} CAT3(array_it_,name,_t)[1]; \
|
||||
struct M_C3(array_, name, _s) *array; \
|
||||
} M_C3(array_it_,name,_t)[1]; \
|
||||
\
|
||||
static inline const type * \
|
||||
CAT3(array_, name, _const_cast)(type *ptr) \
|
||||
M_C3(array_, name, _const_cast)(type *ptr) \
|
||||
{ \
|
||||
CAT3(array_union_, name,_t) u; \
|
||||
M_C3(array_union_, name,_t) u; \
|
||||
u.ptr = ptr; \
|
||||
return u.cptr; \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _init)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _init)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
v->size = v->alloc = 0; \
|
||||
@@ -118,7 +118,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _clean)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _clean)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL && v->size <= v->alloc); \
|
||||
for(size_t i = 0; i < v->size; i++) \
|
||||
@@ -127,18 +127,18 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _clear)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _clear)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL && v->size <= v->alloc); \
|
||||
CAT3(array_, name, _clean)(v); \
|
||||
M_C3(array_, name, _clean)(v); \
|
||||
M_MEMORY_FREE(v->ptr); \
|
||||
v->alloc = 0; \
|
||||
v->ptr = NULL; \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _set)(CAT3(array_, name,_t) d, \
|
||||
const CAT3(array_, name,_t) s) \
|
||||
M_C3(array_, name, _set)(M_C3(array_, name,_t) d, \
|
||||
const M_C3(array_, name,_t) s) \
|
||||
{ \
|
||||
assert (d != NULL && s != NULL \
|
||||
&& d->size <= d->alloc && s->size <= s->alloc); \
|
||||
@@ -165,17 +165,17 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _init_set)(CAT3(array_, name,_t) d, \
|
||||
const CAT3(array_, name,_t) s) \
|
||||
M_C3(array_, name, _init_set)(M_C3(array_, name,_t) d, \
|
||||
const M_C3(array_, name,_t) s) \
|
||||
{ \
|
||||
assert (d != s); \
|
||||
CAT3(array_, name, _init)(d); \
|
||||
CAT3(array_, name, _set)(d, s); \
|
||||
M_C3(array_, name, _init)(d); \
|
||||
M_C3(array_, name, _set)(d, s); \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _init_move)(CAT3(array_, name,_t) d, \
|
||||
CAT3(array_, name,_t) s) \
|
||||
M_C3(array_, name, _init_move)(M_C3(array_, name,_t) d, \
|
||||
M_C3(array_, name,_t) s) \
|
||||
{ \
|
||||
assert (d != s); \
|
||||
d->size = s->size; \
|
||||
@@ -186,30 +186,30 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _move)(CAT3(array_, name,_t) d, \
|
||||
CAT3(array_, name,_t) s) \
|
||||
M_C3(array_, name, _move)(M_C3(array_, name,_t) d, \
|
||||
M_C3(array_, name,_t) s) \
|
||||
{ \
|
||||
assert (d != s); \
|
||||
CAT3(array_, name, _clear)(d); \
|
||||
CAT3(array_, name, _init_move)(d, s); \
|
||||
M_C3(array_, name, _clear)(d); \
|
||||
M_C3(array_, name, _init_move)(d, s); \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _set_at)(CAT3(array_, name,_t) v, size_t i, type x) \
|
||||
M_C3(array_, name, _set_at)(M_C3(array_, name,_t) v, size_t i, type x) \
|
||||
{ \
|
||||
assert(v != NULL && i < v->size && v->ptr != NULL); \
|
||||
M_GET_SET oplist(v->ptr[i], x); \
|
||||
} \
|
||||
\
|
||||
static inline const type * \
|
||||
CAT3(array_, name, _back)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _back)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL && v->ptr != NULL); \
|
||||
return CAT3(array_, name, _const_cast)(&v->ptr[v->size-1]); \
|
||||
return M_C3(array_, name, _const_cast)(&v->ptr[v->size-1]); \
|
||||
} \
|
||||
\
|
||||
static inline type * \
|
||||
CAT3(array_, name, _push_raw)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _push_raw)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL && v->size <= v->alloc); \
|
||||
if (v->size >= v->alloc) { \
|
||||
@@ -231,20 +231,20 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _push_back)(CAT3(array_, name,_t) v, type const x) \
|
||||
M_C3(array_, name, _push_back)(M_C3(array_, name,_t) v, type const x) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
type *data = CAT3(array_, name, _push_raw)(v); \
|
||||
type *data = M_C3(array_, name, _push_raw)(v); \
|
||||
if (data == NULL) \
|
||||
return; \
|
||||
M_GET_INIT_SET oplist(*data, x); \
|
||||
} \
|
||||
\
|
||||
static inline type * \
|
||||
CAT3(array_, name, _push_new)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _push_new)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
type *data = CAT3(array_, name, _push_raw)(v); \
|
||||
type *data = M_C3(array_, name, _push_raw)(v); \
|
||||
if (data == NULL) \
|
||||
return NULL; \
|
||||
M_GET_INIT oplist(*data); \
|
||||
@@ -252,7 +252,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _push_at)(CAT3(array_, name,_t) v, size_t key, type const x) \
|
||||
M_C3(array_, name, _push_at)(M_C3(array_, name,_t) v, size_t key, type const x) \
|
||||
{ \
|
||||
assert (v != NULL && key <= v->size && v->size <= v->alloc); \
|
||||
if (v->size >= v->alloc) { \
|
||||
@@ -274,7 +274,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _resize)(CAT3(array_, name, _t) v, size_t size) \
|
||||
M_C3(array_, name, _resize)(M_C3(array_, name, _t) v, size_t size) \
|
||||
{ \
|
||||
assert (v != NULL && v->size <= v->alloc); \
|
||||
if (v->size > size) { \
|
||||
@@ -302,7 +302,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _set_at2)(CAT3(array_, name,_t) v, size_t idx, type x) \
|
||||
M_C3(array_, name, _set_at2)(M_C3(array_, name,_t) v, size_t idx, type x) \
|
||||
{ \
|
||||
assert (v != NULL && v->size <= v->alloc); \
|
||||
size_t size = idx + 1; \
|
||||
@@ -327,7 +327,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _pop_back)(type *dest, CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _pop_back)(type *dest, M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL && v->size > 0 && v->ptr != NULL); \
|
||||
v->size--; \
|
||||
@@ -341,28 +341,28 @@
|
||||
} \
|
||||
\
|
||||
static inline bool \
|
||||
CAT3(array_, name, _empty_p)(const CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _empty_p)(const M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
return v->size == 0; \
|
||||
} \
|
||||
\
|
||||
static inline size_t \
|
||||
CAT3(array_, name, _size)(const CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _size)(const M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
return v->size; \
|
||||
} \
|
||||
\
|
||||
static inline size_t \
|
||||
CAT3(array_, name, _capacity)(const CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _capacity)(const M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
return v->alloc; \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _pop_at)(type *dest, CAT3(array_, name,_t) v, size_t i) \
|
||||
M_C3(array_, name, _pop_at)(type *dest, M_C3(array_, name,_t) v, size_t i) \
|
||||
{ \
|
||||
assert(v != NULL && v->size > 0 && i < v->size && v->ptr != NULL); \
|
||||
if (dest) \
|
||||
@@ -377,7 +377,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _insert_v)(CAT3(array_, name,_t) v, size_t i, size_t j) \
|
||||
M_C3(array_, name, _insert_v)(M_C3(array_, name,_t) v, size_t i, size_t j) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
assert(i < v->size && j <= v->size && i < j); \
|
||||
@@ -399,7 +399,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _remove_v)(CAT3(array_, name,_t) v, size_t i, size_t j) \
|
||||
M_C3(array_, name, _remove_v)(M_C3(array_, name,_t) v, size_t i, size_t j) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
assert(i < v->size && j <= v->size && i < j && v->ptr != NULL); \
|
||||
@@ -410,13 +410,13 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_,name, _remove)(CAT3(array_, name,_t) v, size_t i) \
|
||||
M_C3(array_,name, _remove)(M_C3(array_, name,_t) v, size_t i) \
|
||||
{ \
|
||||
CAT3(array_, name, _pop_at)(NULL, v, i); \
|
||||
M_C3(array_, name, _pop_at)(NULL, v, i); \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _swap)(CAT3(array_, name,_t) v, size_t i, size_t j) \
|
||||
M_C3(array_, name, _swap)(M_C3(array_, name,_t) v, size_t i, size_t j) \
|
||||
{ \
|
||||
assert (v != NULL); \
|
||||
assert(i < v->size && j < v->size && v->ptr != NULL); \
|
||||
@@ -434,7 +434,7 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _shrink_to_fit)(CAT3(array_, name,_t) v) \
|
||||
M_C3(array_, name, _shrink_to_fit)(M_C3(array_, name,_t) v) \
|
||||
{ \
|
||||
assert (v != NULL && v->size <= v->alloc); \
|
||||
v->ptr = M_MEMORY_REALLOC (type, v->ptr, v->size); \
|
||||
@@ -443,22 +443,22 @@
|
||||
} \
|
||||
\
|
||||
static inline type * \
|
||||
CAT3(array_, name, _get)(CAT3(array_, name,_t) v, size_t i) \
|
||||
M_C3(array_, name, _get)(M_C3(array_, name,_t) v, size_t i) \
|
||||
{ \
|
||||
assert (v != NULL && i < v->size && v->ptr != NULL); \
|
||||
return &v->ptr[i]; \
|
||||
} \
|
||||
\
|
||||
static inline const type * \
|
||||
CAT3(array_, name, _cget)(const CAT3(array_, name,_t) v, size_t i) \
|
||||
M_C3(array_, name, _cget)(const M_C3(array_, name,_t) v, size_t i) \
|
||||
{ \
|
||||
assert(v != NULL && i < v->size && v->ptr != NULL); \
|
||||
return CAT3(array_, name, _const_cast)(&v->ptr[i]); \
|
||||
return M_C3(array_, name, _const_cast)(&v->ptr[i]); \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _it)(CAT3(array_it_,name,_t) it, \
|
||||
CAT3(array_, name, _t) v) \
|
||||
M_C3(array_, name, _it)(M_C3(array_it_,name,_t) it, \
|
||||
M_C3(array_, name, _t) v) \
|
||||
{ \
|
||||
assert (it != NULL && v != NULL); \
|
||||
it->index = 0; \
|
||||
@@ -466,8 +466,8 @@
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _it_set)(CAT3(array_it_,name,_t) it, \
|
||||
const CAT3(array_it_, name, _t) org) \
|
||||
M_C3(array_, name, _it_set)(M_C3(array_it_,name,_t) it, \
|
||||
const M_C3(array_it_, name, _t) org) \
|
||||
{ \
|
||||
assert (it != NULL && org != NULL); \
|
||||
it->index = org->index; \
|
||||
@@ -475,14 +475,14 @@
|
||||
} \
|
||||
\
|
||||
static inline bool \
|
||||
CAT3(array_, name, _end_p)(const CAT3(array_it_, name, _t) it) \
|
||||
M_C3(array_, name, _end_p)(const M_C3(array_it_, name, _t) it) \
|
||||
{ \
|
||||
assert(it != NULL && it->array != NULL); \
|
||||
return (it->index) >= it->array->size; \
|
||||
} \
|
||||
\
|
||||
static inline bool \
|
||||
CAT3(array_, name, _last_p)(const CAT3(array_it_, name, _t) it) \
|
||||
M_C3(array_, name, _last_p)(const M_C3(array_it_, name, _t) it) \
|
||||
{ \
|
||||
assert(it != NULL && it->array != NULL); \
|
||||
/* Case i=0 & s=0 ==> true since unsigned type */ \
|
||||
@@ -490,22 +490,22 @@
|
||||
} \
|
||||
\
|
||||
static inline bool \
|
||||
CAT3(array_, name, _it_equal_p)(const CAT3(array_it_, name,_t) it1, \
|
||||
const CAT3(array_it_, name,_t) it2) \
|
||||
M_C3(array_, name, _it_equal_p)(const M_C3(array_it_, name,_t) it1, \
|
||||
const M_C3(array_it_, name,_t) it2) \
|
||||
{ \
|
||||
assert(it1 != NULL && it2 != NULL); \
|
||||
return it1->array == it2->array && it1->index == it2->index; \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _next)(CAT3(array_it_,name,_t) it) \
|
||||
M_C3(array_, name, _next)(M_C3(array_it_,name,_t) it) \
|
||||
{ \
|
||||
assert(it != NULL && it->array != NULL); \
|
||||
it->index ++; \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _previous)(CAT3(array_it_,name,_t) it) \
|
||||
M_C3(array_, name, _previous)(M_C3(array_it_,name,_t) it) \
|
||||
{ \
|
||||
assert(it != NULL && it->array != NULL); \
|
||||
/* In the case index=0, it will be set to (unsigned) -1 \
|
||||
@@ -514,29 +514,29 @@
|
||||
} \
|
||||
\
|
||||
static inline type * \
|
||||
CAT3(array_, name, _ref)(CAT3(array_it_, name,_t) it) \
|
||||
M_C3(array_, name, _ref)(M_C3(array_it_, name,_t) it) \
|
||||
{ \
|
||||
assert(it != NULL); \
|
||||
return CAT3(array_, name, _get)(it->array, it->index); \
|
||||
return M_C3(array_, name, _get)(it->array, it->index); \
|
||||
} \
|
||||
\
|
||||
static inline const type * \
|
||||
CAT3(array_, name, _cref)(const CAT3(array_it_, name,_t) it) \
|
||||
M_C3(array_, name, _cref)(const M_C3(array_it_, name,_t) it) \
|
||||
{ \
|
||||
assert(it != NULL); \
|
||||
return CAT3(array_, name, _cget)(it->array, it->index); \
|
||||
return M_C3(array_, name, _cget)(it->array, it->index); \
|
||||
} \
|
||||
\
|
||||
static inline void \
|
||||
CAT3(array_, name, _insert)(CAT3(array_it_, name,_t) it, type const x) \
|
||||
M_C3(array_, name, _insert)(M_C3(array_it_, name,_t) it, type const x) \
|
||||
{ \
|
||||
assert(it != NULL); \
|
||||
CAT3(array_, name, _push_at)(it->array, it->index, x); \
|
||||
M_C3(array_, name, _push_at)(it->array, it->index, x); \
|
||||
} \
|
||||
\
|
||||
M_IF_METHOD(CMP, oplist) \
|
||||
( \
|
||||
static inline void CAT3(array_, name, _sort)(CAT3(array_, name,_t) l, \
|
||||
static inline void M_C3(array_, name, _sort)(M_C3(array_, name,_t) l, \
|
||||
int (*func_type) (const type *a, const type *b))\
|
||||
{ \
|
||||
/* Using qsort is more compact but slower than a full templated \
|
||||
@@ -550,18 +550,18 @@
|
||||
\
|
||||
M_IF_METHOD(GET_STR, oplist)( \
|
||||
static inline void \
|
||||
CAT3(array_, name, _get_str)(string_t str, CAT3(array_, name,_t) array, \
|
||||
M_C3(array_, name, _get_str)(string_t str, M_C3(array_, name,_t) array, \
|
||||
bool append) \
|
||||
{ \
|
||||
assert (str != NULL && array != NULL); \
|
||||
(append ? string_cat_str : string_set_str) (str, "["); \
|
||||
CAT3(array_it_, name, _t) it; \
|
||||
for (CAT3(array_, name, _it)(it, array) ; \
|
||||
!CAT3(array_, name, _end_p)(it); \
|
||||
CAT3(array_, name, _next)(it)){ \
|
||||
const type *item = CAT3(array_, name, _cref)(it); \
|
||||
M_C3(array_it_, name, _t) it; \
|
||||
for (M_C3(array_, name, _it)(it, array) ; \
|
||||
!M_C3(array_, name, _end_p)(it); \
|
||||
M_C3(array_, name, _next)(it)){ \
|
||||
const type *item = M_C3(array_, name, _cref)(it); \
|
||||
M_GET_GET_STR oplist (str, *item, true); \
|
||||
if (!CAT3(array_, name, _last_p)(it)) \
|
||||
if (!M_C3(array_, name, _last_p)(it)) \
|
||||
string_push_back (str, M_GET_SEPARATOR oplist); \
|
||||
} \
|
||||
string_push_back (str, ']'); \
|
||||
@@ -570,17 +570,17 @@
|
||||
\
|
||||
M_IF_METHOD(OUT_STR, oplist)( \
|
||||
static inline void \
|
||||
CAT3(array_, name, _out_str)(FILE *file, CAT3(array_, name,_t) array) \
|
||||
M_C3(array_, name, _out_str)(FILE *file, M_C3(array_, name,_t) array) \
|
||||
{ \
|
||||
assert (file != NULL && array != NULL); \
|
||||
fprintf (file, "["); \
|
||||
CAT3(array_it_, name, _t) it; \
|
||||
for (CAT3(array_, name, _it)(it, array) ; \
|
||||
!CAT3(array_, name, _end_p)(it); \
|
||||
CAT3(array_, name, _next)(it)){ \
|
||||
const type *item = CAT3(array_, name, _cref)(it); \
|
||||
M_C3(array_it_, name, _t) it; \
|
||||
for (M_C3(array_, name, _it)(it, array) ; \
|
||||
!M_C3(array_, name, _end_p)(it); \
|
||||
M_C3(array_, name, _next)(it)){ \
|
||||
const type *item = M_C3(array_, name, _cref)(it); \
|
||||
M_GET_OUT_STR oplist (file, *item); \
|
||||
if (!CAT3(array_, name, _last_p)(it)) \
|
||||
if (!M_C3(array_, name, _last_p)(it)) \
|
||||
fputc (M_GET_SEPARATOR oplist, file); \
|
||||
} \
|
||||
fprintf (file, "]"); \
|
||||
@@ -589,10 +589,10 @@
|
||||
\
|
||||
M_IF_METHOD(IN_STR, oplist)( \
|
||||
static inline bool \
|
||||
CAT3(array_, name, _in_str)(CAT3(array_, name,_t) array, FILE *file) \
|
||||
M_C3(array_, name, _in_str)(M_C3(array_, name,_t) array, FILE *file) \
|
||||
{ \
|
||||
assert (file != NULL && array != NULL); \
|
||||
CAT3(array_, name,_clean)(array); \
|
||||
M_C3(array_, name,_clean)(array); \
|
||||
char c = fgetc(file); \
|
||||
if (c != '[') return false; \
|
||||
type item; \
|
||||
@@ -600,7 +600,7 @@
|
||||
do { \
|
||||
bool b = M_GET_IN_STR oplist (item, file); \
|
||||
if (!b) { M_GET_CLEAR oplist (item); return false; } \
|
||||
CAT3(array_, name, _push_back)(array, item); \
|
||||
M_C3(array_, name, _push_back)(array, item); \
|
||||
c = fgetc(file); \
|
||||
} while (c == M_GET_SEPARATOR oplist && !feof(file) && !ferror(file)); \
|
||||
M_GET_CLEAR oplist (item); \
|
||||
@@ -610,26 +610,26 @@
|
||||
\
|
||||
M_IF_METHOD(EQUAL, oplist)( \
|
||||
static inline bool \
|
||||
CAT3(array_, name, _equal_p)(CAT3(array_, name,_t) array1, \
|
||||
CAT3(array_, name,_t) array2) \
|
||||
M_C3(array_, name, _equal_p)(M_C3(array_, name,_t) array1, \
|
||||
M_C3(array_, name,_t) array2) \
|
||||
{ \
|
||||
assert (array1 != NULL && array2 != NULL); \
|
||||
if (array1->size != array2->size) return false; \
|
||||
CAT3(array_it_, name, _t) it1; \
|
||||
CAT3(array_it_, name, _t) it2; \
|
||||
CAT3(array_, name, _it)(it1, array1); \
|
||||
CAT3(array_, name, _it)(it2, array2); \
|
||||
while (!CAT3(array_, name, _end_p)(it1) \
|
||||
&&!CAT3(array_, name, _end_p)(it2)) { \
|
||||
const type *item1 = CAT3(array_, name, _cref)(it1); \
|
||||
const type *item2 = CAT3(array_, name, _cref)(it2); \
|
||||
M_C3(array_it_, name, _t) it1; \
|
||||
M_C3(array_it_, name, _t) it2; \
|
||||
M_C3(array_, name, _it)(it1, array1); \
|
||||
M_C3(array_, name, _it)(it2, array2); \
|
||||
while (!M_C3(array_, name, _end_p)(it1) \
|
||||
&&!M_C3(array_, name, _end_p)(it2)) { \
|
||||
const type *item1 = M_C3(array_, name, _cref)(it1); \
|
||||
const type *item2 = M_C3(array_, name, _cref)(it2); \
|
||||
bool b = M_GET_EQUAL oplist (*item1, *item2); \
|
||||
if (!b) return false; \
|
||||
CAT3(array_, name, _next)(it1); \
|
||||
CAT3(array_, name, _next)(it2); \
|
||||
M_C3(array_, name, _next)(it1); \
|
||||
M_C3(array_, name, _next)(it2); \
|
||||
} \
|
||||
return CAT3(array_, name, _end_p)(it1) \
|
||||
&& CAT3(array_, name, _end_p)(it2); \
|
||||
return M_C3(array_, name, _end_p)(it1) \
|
||||
&& M_C3(array_, name, _end_p)(it2); \
|
||||
} \
|
||||
, /* no equal */ ) \
|
||||
\
|
||||
|
||||
Reference in new issue
Block a user