#ifndef GCC_VEC_H
#define GCC_VEC_H
+#include "statistics.h" /* For MEM_STAT_DECL. */
+
/* The macros here implement a set of templated vector types and
associated interfaces. These templates are implemented with
macros, as we're not in C++ land. The interface functions are
#define VEC_iterate(T,V,I,P) (VEC_OP(T,base,iterate)(VEC_BASE(V),I,&(P)))
+/* Convenience macro for forward iteration. */
+
+#define FOR_EACH_VEC_ELT(T, V, I, P) \
+ for (I = 0; VEC_iterate (T, (V), (I), (P)); ++(I))
+
+/* Likewise, but start from FROM rather than 0. */
+
+#define FOR_EACH_VEC_ELT_FROM(T, V, I, P, FROM) \
+ for (I = (FROM); VEC_iterate (T, (V), (I), (P)); ++(I))
+
+/* Convenience macro for reverse iteration. */
+
+#define FOR_EACH_VEC_ELT_REVERSE(T,V,I,P) \
+ for (I = VEC_length (T, (V)) - 1; \
+ VEC_iterate (T, (V), (I), (P)); \
+ (I)--)
+
/* Allocate new vector.
VEC(T,A) *VEC_T_A_alloc(int reserve);
#define VEC_reserve_exact(T,A,V,R) \
(VEC_OP(T,A,reserve_exact)(&(V),R VEC_CHECK_INFO MEM_STAT_INFO))
+/* Copy elements with no reallocation
+ void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Integer
+ void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Pointer
+ void VEC_T_splice (VEC(T) *dst, VEC(T) *src); // Object
+
+ Copy the elements in SRC to the end of DST as if by memcpy. DST and
+ SRC need not be allocated with the same mechanism, although they most
+ often will be. DST is assumed to have sufficient headroom
+ available. */
+
+#define VEC_splice(T,DST,SRC) \
+ (VEC_OP(T,base,splice)(VEC_BASE(DST), VEC_BASE(SRC) VEC_CHECK_INFO))
+
+/* Copy elements with reallocation
+ void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Integer
+ void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Pointer
+ void VEC_T_safe_splice (VEC(T,A) *&dst, VEC(T) *src); // Object
+
+ Copy the elements in SRC to the end of DST as if by memcpy. DST and
+ SRC need not be allocated with the same mechanism, although they most
+ often will be. DST need not have sufficient headroom and will be
+ reallocated if needed. */
+
+#define VEC_safe_splice(T,A,DST,SRC) \
+ (VEC_OP(T,A,safe_splice)(&(DST), VEC_BASE(SRC) VEC_CHECK_INFO MEM_STAT_INFO))
+
/* Push object with no reallocation
T *VEC_T_quick_push (VEC(T) *v, T obj); // Integer
T *VEC_T_quick_push (VEC(T) *v, T obj); // Pointer
void VEC_T_block_remove (VEC(T) *v, unsigned ix, unsigned len);
Remove LEN elements starting at the IXth. Ordering is retained.
- This is an O(1) operation. */
+ This is an O(N) operation due to memmove. */
#define VEC_block_remove(T,V,I,L) \
(VEC_OP(T,base,block_remove)(VEC_BASE(V),I,L VEC_CHECK_INFO))
#define VEC_address(T,V) (VEC_OP(T,base,address)(VEC_BASE(V)))
+/* Conveniently sort the contents of the vector with qsort.
+ void VEC_qsort (VEC(T) *v, int (*cmp_func)(const void *, const void *)) */
+
+#define VEC_qsort(T,V,CMP) qsort(VEC_address (T,V), VEC_length(T,V), \
+ sizeof (T), CMP)
+
/* Find the first index in the vector not less than the object.
unsigned VEC_T_lower_bound (VEC(T) *v, const T val,
bool (*lessthan) (const T, const T)); // Integer
#ifdef GATHER_STATISTICS
void vec_heap_free (void *);
#else
-#define vec_heap_free(V) free (V)
+/* Avoid problems with frontends that #define free(x). */
+#define vec_heap_free(V) (free) (V)
#endif
#if ENABLE_CHECKING
VEC, DEF_VEC_*, and DEF_VEC_ALLOC_* macros. If you change the
expansions of these macros you may need to change gengtype too. */
+typedef struct GTY(()) vec_prefix
+{
+ unsigned num;
+ unsigned alloc;
+} vec_prefix;
+
#define VEC(T,A) VEC_##T##_##A
#define VEC_OP(T,A,OP) VEC_##T##_##A##_##OP
#define VEC_T(T,B) \
typedef struct VEC(T,B) \
{ \
- unsigned num; \
- unsigned alloc; \
+ struct vec_prefix prefix; \
T vec[1]; \
} VEC(T,B)
#define VEC_T_GTY(T,B) \
typedef struct GTY(()) VEC(T,B) \
{ \
- unsigned num; \
- unsigned alloc; \
- T GTY ((length ("%h.num"))) vec[1]; \
+ struct vec_prefix prefix; \
+ T GTY ((length ("%h.prefix.num"))) vec[1]; \
} VEC(T,B)
/* Derived vector type, user visible. */
} VEC(T,A)
/* Convert to base type. */
+#if GCC_VERSION >= 4000
+#define VEC_BASE(P) \
+ ((offsetof (__typeof (*P), base) == 0 || (P)) ? &(P)->base : 0)
+#else
#define VEC_BASE(P) ((P) ? &(P)->base : 0)
+#endif
/* Vector of integer-like object. */
#define DEF_VEC_I(T) \
#define DEF_VEC_FUNC_P(T) \
static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \
{ \
- return vec_ ? vec_->num : 0; \
+ return vec_ ? vec_->prefix.num : 0; \
} \
\
static inline T VEC_OP (T,base,last) \
(const VEC(T,base) *vec_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_ && vec_->num, "last", T, base); \
+ VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); \
\
- return vec_->vec[vec_->num - 1]; \
+ return vec_->vec[vec_->prefix.num - 1]; \
} \
\
static inline T VEC_OP (T,base,index) \
(const VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \
+ VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); \
\
return vec_->vec[ix_]; \
} \
static inline int VEC_OP (T,base,iterate) \
(const VEC(T,base) *vec_, unsigned ix_, T *ptr) \
{ \
- if (vec_ && ix_ < vec_->num) \
+ if (vec_ && ix_ < vec_->prefix.num) \
{ \
*ptr = vec_->vec[ix_]; \
return 1; \
static inline void VEC_OP (T,base,embedded_init) \
(VEC(T,base) *vec_, int alloc_) \
{ \
- vec_->num = 0; \
- vec_->alloc = alloc_; \
+ vec_->prefix.num = 0; \
+ vec_->prefix.alloc = alloc_; \
} \
\
static inline int VEC_OP (T,base,space) \
(VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \
{ \
VEC_ASSERT (alloc_ >= 0, "space", T, base); \
- return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \
+ return vec_ ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ : !alloc_; \
+} \
+ \
+static inline void VEC_OP(T,base,splice) \
+ (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \
+{ \
+ if (src_) \
+ { \
+ unsigned len_ = src_->prefix.num; \
+ VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", T, base); \
+ \
+ memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); \
+ dst_->prefix.num += len_; \
+ } \
} \
\
static inline T *VEC_OP (T,base,quick_push) \
{ \
T *slot_; \
\
- VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \
- slot_ = &vec_->vec[vec_->num++]; \
+ VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); \
+ slot_ = &vec_->vec[vec_->prefix.num++]; \
*slot_ = obj_; \
\
return slot_; \
{ \
T obj_; \
\
- VEC_ASSERT (vec_->num, "pop", T, base); \
- obj_ = vec_->vec[--vec_->num]; \
+ VEC_ASSERT (vec_->prefix.num, "pop", T, base); \
+ obj_ = vec_->vec[--vec_->prefix.num]; \
\
return obj_; \
} \
static inline void VEC_OP (T,base,truncate) \
(VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \
+ VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); \
if (vec_) \
- vec_->num = size_; \
+ vec_->prefix.num = size_; \
} \
\
static inline T VEC_OP (T,base,replace) \
{ \
T old_obj_; \
\
- VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \
+ VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); \
old_obj_ = vec_->vec[ix_]; \
vec_->vec[ix_] = obj_; \
\
{ \
T *slot_; \
\
- VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \
- VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \
+ VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); \
+ VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); \
slot_ = &vec_->vec[ix_]; \
- memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
+ memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); \
*slot_ = obj_; \
\
return slot_; \
T *slot_; \
T obj_; \
\
- VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
+ VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \
slot_ = &vec_->vec[ix_]; \
obj_ = *slot_; \
- memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
+ memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); \
\
return obj_; \
} \
T *slot_; \
T obj_; \
\
- VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
+ VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \
slot_ = &vec_->vec[ix_]; \
obj_ = *slot_; \
- *slot_ = vec_->vec[--vec_->num]; \
+ *slot_ = vec_->vec[--vec_->prefix.num]; \
\
return obj_; \
} \
{ \
T *slot_; \
\
- VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \
+ VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); \
slot_ = &vec_->vec[ix_]; \
- vec_->num -= len_; \
- memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
+ vec_->prefix.num -= len_; \
+ memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); \
} \
\
static inline T *VEC_OP (T,base,address) \
\
static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
{ \
- size_t len_ = vec_ ? vec_->num : 0; \
+ size_t len_ = vec_ ? vec_->prefix.num : 0; \
VEC (T,A) *new_vec_ = NULL; \
\
if (len_) \
new_vec_ = (VEC (T,A) *)(vec_##A##_p_reserve_exact \
(NULL, len_ PASS_MEM_STAT)); \
\
- new_vec_->base.num = len_; \
+ new_vec_->base.prefix.num = len_; \
memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
} \
return new_vec_; \
&& VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
"grow", T, A); \
VEC_OP (T,A,reserve_exact) (vec_, \
- size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
+ size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \
VEC_CHECK_PASS PASS_MEM_STAT); \
- VEC_BASE (*vec_)->num = size_; \
+ VEC_BASE (*vec_)->prefix.num = size_; \
} \
\
static inline void VEC_OP (T,A,safe_grow_cleared) \
sizeof (T) * (size_ - oldsize)); \
} \
\
+static inline void VEC_OP(T,A,safe_splice) \
+ (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \
+{ \
+ if (src_) \
+ { \
+ VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \
+ VEC_CHECK_PASS MEM_STAT_INFO); \
+ \
+ VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \
+ VEC_CHECK_PASS); \
+ } \
+} \
+ \
static inline T *VEC_OP (T,A,safe_push) \
(VEC(T,A) **vec_, T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
{ \
#define DEF_VEC_FUNC_O(T) \
static inline unsigned VEC_OP (T,base,length) (const VEC(T,base) *vec_) \
{ \
- return vec_ ? vec_->num : 0; \
+ return vec_ ? vec_->prefix.num : 0; \
} \
\
static inline T *VEC_OP (T,base,last) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_ && vec_->num, "last", T, base); \
+ VEC_ASSERT (vec_ && vec_->prefix.num, "last", T, base); \
\
- return &vec_->vec[vec_->num - 1]; \
+ return &vec_->vec[vec_->prefix.num - 1]; \
} \
\
static inline T *VEC_OP (T,base,index) \
(VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_ && ix_ < vec_->num, "index", T, base); \
+ VEC_ASSERT (vec_ && ix_ < vec_->prefix.num, "index", T, base); \
\
return &vec_->vec[ix_]; \
} \
static inline int VEC_OP (T,base,iterate) \
(VEC(T,base) *vec_, unsigned ix_, T **ptr) \
{ \
- if (vec_ && ix_ < vec_->num) \
+ if (vec_ && ix_ < vec_->prefix.num) \
{ \
*ptr = &vec_->vec[ix_]; \
return 1; \
static inline void VEC_OP (T,base,embedded_init) \
(VEC(T,base) *vec_, int alloc_) \
{ \
- vec_->num = 0; \
- vec_->alloc = alloc_; \
+ vec_->prefix.num = 0; \
+ vec_->prefix.alloc = alloc_; \
} \
\
static inline int VEC_OP (T,base,space) \
(VEC(T,base) *vec_, int alloc_ VEC_CHECK_DECL) \
{ \
VEC_ASSERT (alloc_ >= 0, "space", T, base); \
- return vec_ ? vec_->alloc - vec_->num >= (unsigned)alloc_ : !alloc_; \
+ return vec_ ? vec_->prefix.alloc - vec_->prefix.num >= (unsigned)alloc_ : !alloc_; \
+} \
+ \
+static inline void VEC_OP(T,base,splice) \
+ (VEC(T,base) *dst_, VEC(T,base) *src_ VEC_CHECK_DECL) \
+{ \
+ if (src_) \
+ { \
+ unsigned len_ = src_->prefix.num; \
+ VEC_ASSERT (dst_->prefix.num + len_ <= dst_->prefix.alloc, "splice", T, base); \
+ \
+ memcpy (&dst_->vec[dst_->prefix.num], &src_->vec[0], len_ * sizeof (T)); \
+ dst_->prefix.num += len_; \
+ } \
} \
\
static inline T *VEC_OP (T,base,quick_push) \
{ \
T *slot_; \
\
- VEC_ASSERT (vec_->num < vec_->alloc, "push", T, base); \
- slot_ = &vec_->vec[vec_->num++]; \
+ VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "push", T, base); \
+ slot_ = &vec_->vec[vec_->prefix.num++]; \
if (obj_) \
*slot_ = *obj_; \
\
\
static inline void VEC_OP (T,base,pop) (VEC(T,base) *vec_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_->num, "pop", T, base); \
- --vec_->num; \
+ VEC_ASSERT (vec_->prefix.num, "pop", T, base); \
+ --vec_->prefix.num; \
} \
\
static inline void VEC_OP (T,base,truncate) \
(VEC(T,base) *vec_, unsigned size_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (vec_ ? vec_->num >= size_ : !size_, "truncate", T, base); \
+ VEC_ASSERT (vec_ ? vec_->prefix.num >= size_ : !size_, "truncate", T, base); \
if (vec_) \
- vec_->num = size_; \
+ vec_->prefix.num = size_; \
} \
\
static inline T *VEC_OP (T,base,replace) \
{ \
T *slot_; \
\
- VEC_ASSERT (ix_ < vec_->num, "replace", T, base); \
+ VEC_ASSERT (ix_ < vec_->prefix.num, "replace", T, base); \
slot_ = &vec_->vec[ix_]; \
if (obj_) \
*slot_ = *obj_; \
{ \
T *slot_; \
\
- VEC_ASSERT (vec_->num < vec_->alloc, "insert", T, base); \
- VEC_ASSERT (ix_ <= vec_->num, "insert", T, base); \
+ VEC_ASSERT (vec_->prefix.num < vec_->prefix.alloc, "insert", T, base); \
+ VEC_ASSERT (ix_ <= vec_->prefix.num, "insert", T, base); \
slot_ = &vec_->vec[ix_]; \
- memmove (slot_ + 1, slot_, (vec_->num++ - ix_) * sizeof (T)); \
+ memmove (slot_ + 1, slot_, (vec_->prefix.num++ - ix_) * sizeof (T)); \
if (obj_) \
*slot_ = *obj_; \
\
{ \
T *slot_; \
\
- VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
+ VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \
slot_ = &vec_->vec[ix_]; \
- memmove (slot_, slot_ + 1, (--vec_->num - ix_) * sizeof (T)); \
+ memmove (slot_, slot_ + 1, (--vec_->prefix.num - ix_) * sizeof (T)); \
} \
\
static inline void VEC_OP (T,base,unordered_remove) \
(VEC(T,base) *vec_, unsigned ix_ VEC_CHECK_DECL) \
{ \
- VEC_ASSERT (ix_ < vec_->num, "remove", T, base); \
- vec_->vec[ix_] = vec_->vec[--vec_->num]; \
+ VEC_ASSERT (ix_ < vec_->prefix.num, "remove", T, base); \
+ vec_->vec[ix_] = vec_->vec[--vec_->prefix.num]; \
} \
\
static inline void VEC_OP (T,base,block_remove) \
{ \
T *slot_; \
\
- VEC_ASSERT (ix_ + len_ <= vec_->num, "block_remove", T, base); \
+ VEC_ASSERT (ix_ + len_ <= vec_->prefix.num, "block_remove", T, base); \
slot_ = &vec_->vec[ix_]; \
- vec_->num -= len_; \
- memmove (slot_, slot_ + len_, (vec_->num - ix_) * sizeof (T)); \
+ vec_->prefix.num -= len_; \
+ memmove (slot_, slot_ + len_, (vec_->prefix.num - ix_) * sizeof (T)); \
} \
\
static inline T *VEC_OP (T,base,address) \
#define DEF_VEC_NONALLOC_FUNCS_O(T,A) \
static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
{ \
- size_t len_ = vec_ ? vec_->num : 0; \
+ size_t len_ = vec_ ? vec_->prefix.num : 0; \
VEC (T,A) *new_vec_ = NULL; \
\
if (len_) \
offsetof (VEC(T,A),base.vec), sizeof (T) \
PASS_MEM_STAT)); \
\
- new_vec_->base.num = len_; \
+ new_vec_->base.prefix.num = len_; \
memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
} \
return new_vec_; \
&& VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
"grow", T, A); \
VEC_OP (T,A,reserve_exact) (vec_, \
- size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
+ size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \
VEC_CHECK_PASS PASS_MEM_STAT); \
- VEC_BASE (*vec_)->num = size_; \
+ VEC_BASE (*vec_)->prefix.num = size_; \
} \
\
static inline void VEC_OP (T,A,safe_grow_cleared) \
sizeof (T) * (size_ - oldsize)); \
} \
\
+static inline void VEC_OP(T,A,safe_splice) \
+ (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \
+{ \
+ if (src_) \
+ { \
+ VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \
+ VEC_CHECK_PASS MEM_STAT_INFO); \
+ \
+ VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \
+ VEC_CHECK_PASS); \
+ } \
+} \
+ \
static inline T *VEC_OP (T,A,safe_push) \
(VEC(T,A) **vec_, const T *obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
{ \
#define DEF_VEC_NONALLOC_FUNCS_I(T,A) \
static inline VEC(T,A) *VEC_OP (T,A,copy) (VEC(T,base) *vec_ MEM_STAT_DECL) \
{ \
- size_t len_ = vec_ ? vec_->num : 0; \
+ size_t len_ = vec_ ? vec_->prefix.num : 0; \
VEC (T,A) *new_vec_ = NULL; \
\
if (len_) \
offsetof (VEC(T,A),base.vec), sizeof (T) \
PASS_MEM_STAT)); \
\
- new_vec_->base.num = len_; \
+ new_vec_->base.prefix.num = len_; \
memcpy (new_vec_->base.vec, vec_->vec, sizeof (T) * len_); \
} \
return new_vec_; \
&& VEC_OP(T,base,length) VEC_BASE(*vec_) <= (unsigned)size_, \
"grow", T, A); \
VEC_OP (T,A,reserve_exact) (vec_, \
- size_ - (int)(*vec_ ? VEC_BASE(*vec_)->num : 0) \
+ size_ - (int)(*vec_ ? VEC_BASE(*vec_)->prefix.num : 0) \
VEC_CHECK_PASS PASS_MEM_STAT); \
- VEC_BASE (*vec_)->num = size_; \
+ VEC_BASE (*vec_)->prefix.num = size_; \
} \
\
static inline void VEC_OP (T,A,safe_grow_cleared) \
sizeof (T) * (size_ - oldsize)); \
} \
\
+static inline void VEC_OP(T,A,safe_splice) \
+ (VEC(T,A) **dst_, VEC(T,base) *src_ VEC_CHECK_DECL MEM_STAT_DECL) \
+{ \
+ if (src_) \
+ { \
+ VEC_OP (T,A,reserve_exact) (dst_, src_->prefix.num \
+ VEC_CHECK_PASS MEM_STAT_INFO); \
+ \
+ VEC_OP (T,base,splice) (VEC_BASE (*dst_), src_ \
+ VEC_CHECK_PASS); \
+ } \
+} \
+ \
static inline T *VEC_OP (T,A,safe_push) \
(VEC(T,A) **vec_, const T obj_ VEC_CHECK_DECL MEM_STAT_DECL) \
{ \
OSDN Git Service
