Merge branch 'stclib:master' into modifiedHEADmodified

1 files changed, 154 insertions, 178 deletions

diff --git a/include/stc/cvec.h b/include/stc/cvec.h
index a1aa74b2..12cd6875 100644
--- a/include/stc/cvec.h
+++ b/include/stc/cvec.h
@@ -22,6 +22,7 @@
  */
 
 /*
+#define i_implement
 #include <stc/cstr.h>
 #include <stc/forward.h>
 
@@ -39,11 +40,11 @@ struct MyStruct {
 #include <stc/cvec.h>
 
 #define i_key int
-#define i_is_forward // forward declared
+#define i_is_forward
 #define i_tag i32
 #include <stc/cvec.h>
 
-int main() {
+int main(void) {
     cvec_i32 vec = {0};
     cvec_i32_push(&vec, 123);
     cvec_i32_drop(&vec);
@@ -57,9 +58,10 @@ int main() {
     cvec_str_drop(&svec);
 }
 */
-#include "ccommon.h"
+#include "priv/linkage.h"
 
 #ifndef CVEC_H_INCLUDED
+#include "ccommon.h"
 #include "forward.h"
 #include <stdlib.h>
 #include <string.h>
@@ -68,173 +70,172 @@ int main() {
 #define _it_ptr(it) (it.ref ? it.ref : it.end)
 #endif // CVEC_H_INCLUDED
 
-#ifndef _i_prefix
 #define _i_prefix cvec_
-#endif
 #include "priv/template.h"
 
 #ifndef i_is_forward
-   _cx_deftypes(_c_cvec_types, _cx_self, i_key);
+   _cx_DEFTYPES(_c_cvec_types, _cx_Self, i_key);
 #endif
 typedef i_keyraw _cx_raw;
-STC_API _cx_self        _cx_memb(_init)(void);
-STC_API void            _cx_memb(_drop)(_cx_self* self);
-STC_API void            _cx_memb(_clear)(_cx_self* self);
-STC_API bool            _cx_memb(_reserve)(_cx_self* self, intptr_t cap);
-STC_API bool            _cx_memb(_resize)(_cx_self* self, intptr_t size, i_key null);
-STC_API _cx_value*      _cx_memb(_push)(_cx_self* self, i_key value);
-STC_API _cx_iter        _cx_memb(_erase_range_p)(_cx_self* self, _cx_value* p1, _cx_value* p2);
-STC_API _cx_iter        _cx_memb(_insert_range)(_cx_self* self, _cx_value* pos,
-                                                const _cx_value* p1, const _cx_value* p2);
-STC_API _cx_iter        _cx_memb(_insert_uninit)(_cx_self* self, _cx_value* pos, const intptr_t n);
-#if !defined i_no_cmp || defined _i_has_eq
-STC_API _cx_iter        _cx_memb(_find_in)(_cx_iter it1, _cx_iter it2, _cx_raw raw);
+STC_API _cx_Self        _cx_MEMB(_init)(void);
+STC_API void            _cx_MEMB(_drop)(_cx_Self* self);
+STC_API void            _cx_MEMB(_clear)(_cx_Self* self);
+STC_API bool            _cx_MEMB(_reserve)(_cx_Self* self, intptr_t cap);
+STC_API bool            _cx_MEMB(_resize)(_cx_Self* self, intptr_t size, i_key null);
+STC_API _cx_iter        _cx_MEMB(_erase_n)(_cx_Self* self, intptr_t idx, intptr_t n);
+STC_API _cx_iter        _cx_MEMB(_insert_uninit)(_cx_Self* self, intptr_t idx, intptr_t n);
+#if defined _i_has_eq || defined _i_has_cmp
+STC_API _cx_iter        _cx_MEMB(_find_in)(_cx_iter it1, _cx_iter it2, _cx_raw raw);
 #endif
-#ifndef i_no_cmp
-STC_API int             _cx_memb(_value_cmp)(const _cx_value* x, const _cx_value* y);
-STC_API _cx_iter        _cx_memb(_binary_search_in)(_cx_iter it1, _cx_iter it2, _cx_raw raw, _cx_iter* lower_bound);
+#if defined _i_has_cmp
+STC_API int             _cx_MEMB(_value_cmp)(const _cx_value* x, const _cx_value* y);
+STC_API _cx_iter        _cx_MEMB(_binary_search_in)(_cx_iter it1, _cx_iter it2, _cx_raw raw, _cx_iter* lower_bound);
 #endif
-STC_INLINE void         _cx_memb(_value_drop)(_cx_value* val) { i_keydrop(val); }
+STC_INLINE void         _cx_MEMB(_value_drop)(_cx_value* val) { i_keydrop(val); }
+
+STC_INLINE _cx_value*   _cx_MEMB(_push)(_cx_Self* self, i_key value) {
+                            if (self->_len == self->_cap)
+                            if (!_cx_MEMB(_reserve)(self, self->_len*2 + 4))
+                                return NULL;
+                            _cx_value *v = self->data + self->_len++;
+                            *v = value;
+                            return v;
+                        }
 
 #if !defined i_no_emplace
-STC_API _cx_iter        _cx_memb(_emplace_range)(_cx_self* self, _cx_value* pos,
-                                                 const _cx_raw* p1, const _cx_raw* p2);
-STC_INLINE _cx_value*   _cx_memb(_emplace)(_cx_self* self, _cx_raw raw)
-                            { return _cx_memb(_push)(self, i_keyfrom(raw)); }
-STC_INLINE _cx_value*   _cx_memb(_emplace_back)(_cx_self* self, _cx_raw raw)
-                            { return _cx_memb(_push)(self, i_keyfrom(raw)); }
-STC_INLINE _cx_iter
-_cx_memb(_emplace_n)(_cx_self* self, const intptr_t idx, const _cx_raw arr[], const intptr_t n) {
-    return _cx_memb(_emplace_range)(self, self->data + idx, arr, arr + n);
+STC_API _cx_iter
+_cx_MEMB(_emplace_n)(_cx_Self* self, intptr_t idx, const _cx_raw raw[], intptr_t n);
+
+STC_INLINE _cx_value* _cx_MEMB(_emplace)(_cx_Self* self, _cx_raw raw) {
+    return _cx_MEMB(_push)(self, i_keyfrom(raw));
 }
-STC_INLINE _cx_iter
-_cx_memb(_emplace_at)(_cx_self* self, _cx_iter it, _cx_raw raw) {
-    return _cx_memb(_emplace_range)(self, _it_ptr(it), &raw, &raw + 1);
+STC_INLINE _cx_value* _cx_MEMB(_emplace_back)(_cx_Self* self, _cx_raw raw) {
+     return _cx_MEMB(_push)(self, i_keyfrom(raw));
+}
+STC_INLINE _cx_iter _cx_MEMB(_emplace_at)(_cx_Self* self, _cx_iter it, _cx_raw raw) {
+    return _cx_MEMB(_emplace_n)(self, _it_ptr(it) - self->data, &raw, 1);
 }
 #endif // !i_no_emplace
 
 #if !defined i_no_clone
-STC_API _cx_self        _cx_memb(_clone)(_cx_self cx);
-STC_API _cx_iter        _cx_memb(_copy_range)(_cx_self* self, _cx_value* pos,
-                                              const _cx_value* p1, const _cx_value* p2);
-STC_INLINE void         _cx_memb(_put_n)(_cx_self* self, const _cx_raw* raw, intptr_t n)
-                            { while (n--) _cx_memb(_push)(self, i_keyfrom(*raw++)); }
-STC_INLINE _cx_self     _cx_memb(_from_n)(const _cx_raw* raw, intptr_t n)
-                            { _cx_self cx = {0}; _cx_memb(_put_n)(&cx, raw, n); return cx; }
-STC_INLINE i_key        _cx_memb(_value_clone)(_cx_value val)
+STC_API _cx_Self        _cx_MEMB(_clone)(_cx_Self cx);
+STC_API _cx_iter        _cx_MEMB(_copy_n)(_cx_Self* self, intptr_t idx, const _cx_value arr[], intptr_t n);
+STC_INLINE void         _cx_MEMB(_put_n)(_cx_Self* self, const _cx_raw* raw, intptr_t n)
+                            { while (n--) _cx_MEMB(_push)(self, i_keyfrom(*raw++)); }
+STC_INLINE _cx_Self     _cx_MEMB(_from_n)(const _cx_raw* raw, intptr_t n)
+                            { _cx_Self cx = {0}; _cx_MEMB(_put_n)(&cx, raw, n); return cx; }
+STC_INLINE i_key        _cx_MEMB(_value_clone)(_cx_value val)
                             { return i_keyclone(val); }
-STC_INLINE void         _cx_memb(_copy)(_cx_self* self, const _cx_self* other) {
+STC_INLINE void         _cx_MEMB(_copy)(_cx_Self* self, const _cx_Self* other) {
                             if (self->data == other->data) return;
-                            _cx_memb(_clear)(self);
-                            _cx_memb(_copy_range)(self, self->data, other->data, 
-                                                  other->data + other->_len);
+                            _cx_MEMB(_clear)(self);
+                            _cx_MEMB(_copy_n)(self, 0, other->data, other->_len);
                         }
 #endif // !i_no_clone
 
-STC_INLINE intptr_t     _cx_memb(_size)(const _cx_self* self) { return self->_len; }
-STC_INLINE intptr_t     _cx_memb(_capacity)(const _cx_self* self) { return self->_cap; }
-STC_INLINE bool         _cx_memb(_empty)(const _cx_self* self) { return !self->_len; }
-STC_INLINE _cx_raw      _cx_memb(_value_toraw)(const _cx_value* val) { return i_keyto(val); }
-STC_INLINE _cx_value*   _cx_memb(_front)(const _cx_self* self) { return self->data; }
-STC_INLINE _cx_value*   _cx_memb(_back)(const _cx_self* self)
+STC_INLINE intptr_t     _cx_MEMB(_size)(const _cx_Self* self) { return self->_len; }
+STC_INLINE intptr_t     _cx_MEMB(_capacity)(const _cx_Self* self) { return self->_cap; }
+STC_INLINE bool         _cx_MEMB(_empty)(const _cx_Self* self) { return !self->_len; }
+STC_INLINE _cx_raw      _cx_MEMB(_value_toraw)(const _cx_value* val) { return i_keyto(val); }
+STC_INLINE _cx_value*   _cx_MEMB(_front)(const _cx_Self* self) { return self->data; }
+STC_INLINE _cx_value*   _cx_MEMB(_back)(const _cx_Self* self)
                             { return self->data + self->_len - 1; }
-STC_INLINE void         _cx_memb(_pop)(_cx_self* self)
-                            { assert(!_cx_memb(_empty)(self)); _cx_value* p = &self->data[--self->_len]; i_keydrop(p); }
-STC_INLINE _cx_value*   _cx_memb(_push_back)(_cx_self* self, i_key value)
-                            { return _cx_memb(_push)(self, value); }
-STC_INLINE void         _cx_memb(_pop_back)(_cx_self* self) { _cx_memb(_pop)(self); }
-
-STC_INLINE _cx_self
-_cx_memb(_with_size)(const intptr_t size, i_key null) {
-    _cx_self cx = _cx_memb(_init)();
-    _cx_memb(_resize)(&cx, size, null);
+STC_INLINE void         _cx_MEMB(_pop)(_cx_Self* self)
+                            { c_assert(self->_len); _cx_value* p = &self->data[--self->_len]; i_keydrop(p); }
+STC_INLINE _cx_value    _cx_MEMB(_pull)(_cx_Self* self)
+                            { c_assert(self->_len); return self->data[--self->_len]; }
+STC_INLINE _cx_value*   _cx_MEMB(_push_back)(_cx_Self* self, i_key value)
+                            { return _cx_MEMB(_push)(self, value); }
+STC_INLINE void         _cx_MEMB(_pop_back)(_cx_Self* self) { _cx_MEMB(_pop)(self); }
+
+STC_INLINE _cx_Self
+_cx_MEMB(_with_size)(const intptr_t size, i_key null) {
+    _cx_Self cx = _cx_MEMB(_init)();
+    _cx_MEMB(_resize)(&cx, size, null);
     return cx;
 }
 
-STC_INLINE _cx_self
-_cx_memb(_with_capacity)(const intptr_t cap) {
-    _cx_self cx = _cx_memb(_init)();
-    _cx_memb(_reserve)(&cx, cap);
+STC_INLINE _cx_Self
+_cx_MEMB(_with_capacity)(const intptr_t cap) {
+    _cx_Self cx = _cx_MEMB(_init)();
+    _cx_MEMB(_reserve)(&cx, cap);
     return cx;
 }
 
 STC_INLINE void
-_cx_memb(_shrink_to_fit)(_cx_self* self) {
-    _cx_memb(_reserve)(self, _cx_memb(_size)(self));
+_cx_MEMB(_shrink_to_fit)(_cx_Self* self) {
+    _cx_MEMB(_reserve)(self, _cx_MEMB(_size)(self));
 }
 
-
-STC_INLINE _cx_iter
-_cx_memb(_insert)(_cx_self* self, const intptr_t idx, i_key value) {
-    return _cx_memb(_insert_range)(self, self->data + idx, &value, &value + 1);
-}
 STC_INLINE _cx_iter
-_cx_memb(_insert_n)(_cx_self* self, const intptr_t idx, const _cx_value arr[], const intptr_t n) {
-    return _cx_memb(_insert_range)(self, self->data + idx, arr, arr + n);
+_cx_MEMB(_insert_n)(_cx_Self* self, const intptr_t idx, const _cx_value arr[], const intptr_t n) {
+    _cx_iter it = _cx_MEMB(_insert_uninit)(self, idx, n);
+    if (it.ref)
+        c_memcpy(it.ref, arr, n*c_sizeof *arr);
+    return it;
 }
 STC_INLINE _cx_iter
-_cx_memb(_insert_at)(_cx_self* self, _cx_iter it, i_key value) {
-    return _cx_memb(_insert_range)(self, _it_ptr(it), &value, &value + 1);
+_cx_MEMB(_insert_at)(_cx_Self* self, _cx_iter it, const _cx_value value) {
+    return _cx_MEMB(_insert_n)(self, _it_ptr(it) - self->data, &value, 1);
 }
 
 STC_INLINE _cx_iter
-_cx_memb(_erase_n)(_cx_self* self, const intptr_t idx, const intptr_t n) {
-    return _cx_memb(_erase_range_p)(self, self->data + idx, self->data + idx + n);
+_cx_MEMB(_erase_at)(_cx_Self* self, _cx_iter it) {
+    return _cx_MEMB(_erase_n)(self, it.ref - self->data, 1);
 }
 STC_INLINE _cx_iter
-_cx_memb(_erase_at)(_cx_self* self, _cx_iter it) {
-    return _cx_memb(_erase_range_p)(self, it.ref, it.ref + 1);
-}
-STC_INLINE _cx_iter
-_cx_memb(_erase_range)(_cx_self* self, _cx_iter i1, _cx_iter i2) {
-    return _cx_memb(_erase_range_p)(self, i1.ref, _it2_ptr(i1, i2));
+_cx_MEMB(_erase_range)(_cx_Self* self, _cx_iter i1, _cx_iter i2) {
+    return _cx_MEMB(_erase_n)(self, i1.ref - self->data, _it2_ptr(i1, i2) - i1.ref);
 }
 
 STC_INLINE const _cx_value*
-_cx_memb(_at)(const _cx_self* self, const intptr_t idx) {
-    assert(idx < self->_len); return self->data + idx;
+_cx_MEMB(_at)(const _cx_Self* self, const intptr_t idx) {
+    c_assert(idx < self->_len); return self->data + idx;
 }
 STC_INLINE _cx_value*
-_cx_memb(_at_mut)(_cx_self* self, const intptr_t idx) {
-    assert(idx < self->_len); return self->data + idx;
+_cx_MEMB(_at_mut)(_cx_Self* self, const intptr_t idx) {
+    c_assert(idx < self->_len); return self->data + idx;
 }
 
 
-STC_INLINE _cx_iter _cx_memb(_begin)(const _cx_self* self) { 
+STC_INLINE _cx_iter _cx_MEMB(_begin)(const _cx_Self* self) { 
     intptr_t n = self->_len; 
     return c_LITERAL(_cx_iter){n ? self->data : NULL, self->data + n};
 }
 
-STC_INLINE _cx_iter _cx_memb(_end)(const _cx_self* self) 
+STC_INLINE _cx_iter _cx_MEMB(_end)(const _cx_Self* self) 
     { return c_LITERAL(_cx_iter){NULL, self->data + self->_len}; }
 
-STC_INLINE void _cx_memb(_next)(_cx_iter* it) 
+STC_INLINE void _cx_MEMB(_next)(_cx_iter* it) 
     { if (++it->ref == it->end) it->ref = NULL; }
 
-STC_INLINE _cx_iter _cx_memb(_advance)(_cx_iter it, size_t n)
+STC_INLINE _cx_iter _cx_MEMB(_advance)(_cx_iter it, size_t n)
     { if ((it.ref += n) >= it.end) it.ref = NULL; return it; }
 
-STC_INLINE intptr_t _cx_memb(_index)(const _cx_self* self, _cx_iter it) 
+STC_INLINE intptr_t _cx_MEMB(_index)(const _cx_Self* self, _cx_iter it) 
     { return (it.ref - self->data); }
 
-#if !defined i_no_cmp || defined _i_has_eq
+STC_INLINE void _cx_MEMB(_adjust_end_)(_cx_Self* self, intptr_t n)
+    { self->_len += n; }
+
+#if defined _i_has_eq || defined _i_has_cmp
 
 STC_INLINE _cx_iter
-_cx_memb(_find)(const _cx_self* self, _cx_raw raw) {
-    return _cx_memb(_find_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw);
+_cx_MEMB(_find)(const _cx_Self* self, _cx_raw raw) {
+    return _cx_MEMB(_find_in)(_cx_MEMB(_begin)(self), _cx_MEMB(_end)(self), raw);
 }
 
 STC_INLINE const _cx_value*
-_cx_memb(_get)(const _cx_self* self, _cx_raw raw) {
-    return _cx_memb(_find)(self, raw).ref;
+_cx_MEMB(_get)(const _cx_Self* self, _cx_raw raw) {
+    return _cx_MEMB(_find)(self, raw).ref;
 }
 
 STC_INLINE _cx_value*
-_cx_memb(_get_mut)(const _cx_self* self, _cx_raw raw)
-    { return (_cx_value*) _cx_memb(_get)(self, raw); }
+_cx_MEMB(_get_mut)(const _cx_Self* self, _cx_raw raw)
+    { return (_cx_value*) _cx_MEMB(_get)(self, raw); }
 
 STC_INLINE bool
-_cx_memb(_eq)(const _cx_self* self, const _cx_self* other) {
+_cx_MEMB(_eq)(const _cx_Self* self, const _cx_Self* other) {
     if (self->_len != other->_len) return false;
     for (intptr_t i = 0; i < self->_len; ++i) {
         const _cx_raw _rx = i_keyto(self->data+i), _ry = i_keyto(other->data+i);
@@ -243,42 +244,42 @@ _cx_memb(_eq)(const _cx_self* self, const _cx_self* other) {
     return true;
 }
 #endif
-#ifndef i_no_cmp
+#if defined _i_has_cmp
 
 STC_INLINE _cx_iter
-_cx_memb(_binary_search)(const _cx_self* self, _cx_raw raw) {
+_cx_MEMB(_binary_search)(const _cx_Self* self, _cx_raw raw) {
     _cx_iter lower;
-    return _cx_memb(_binary_search_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw, &lower);
+    return _cx_MEMB(_binary_search_in)(_cx_MEMB(_begin)(self), _cx_MEMB(_end)(self), raw, &lower);
 }
 
 STC_INLINE _cx_iter
-_cx_memb(_lower_bound)(const _cx_self* self, _cx_raw raw) {
+_cx_MEMB(_lower_bound)(const _cx_Self* self, _cx_raw raw) {
     _cx_iter lower;
-    _cx_memb(_binary_search_in)(_cx_memb(_begin)(self), _cx_memb(_end)(self), raw, &lower);
+    _cx_MEMB(_binary_search_in)(_cx_MEMB(_begin)(self), _cx_MEMB(_end)(self), raw, &lower);
     return lower;
 }
 
 STC_INLINE void
-_cx_memb(_sort_range)(_cx_iter i1, _cx_iter i2, int(*cmp)(const _cx_value*, const _cx_value*)) {
+_cx_MEMB(_sort_range)(_cx_iter i1, _cx_iter i2, int(*cmp)(const _cx_value*, const _cx_value*)) {
     qsort(i1.ref, (size_t)(_it2_ptr(i1, i2) - i1.ref), sizeof(_cx_value),
           (int(*)(const void*, const void*)) cmp);
 }
 
 STC_INLINE void
-_cx_memb(_sort)(_cx_self* self) {
-    _cx_memb(_sort_range)(_cx_memb(_begin)(self), _cx_memb(_end)(self), _cx_memb(_value_cmp));
+_cx_MEMB(_sort)(_cx_Self* self) {
+    _cx_MEMB(_sort_range)(_cx_MEMB(_begin)(self), _cx_MEMB(_end)(self), _cx_MEMB(_value_cmp));
 }
-#endif // !c_no_cmp
+#endif // _i_has_cmp
 /* -------------------------- IMPLEMENTATION ------------------------- */
-#if defined(i_implement)
+#if defined(i_implement) || defined(i_static)
 
-STC_DEF _cx_self
-_cx_memb(_init)(void) {
-    return c_LITERAL(_cx_self){NULL};
+STC_DEF _cx_Self
+_cx_MEMB(_init)(void) {
+    return c_LITERAL(_cx_Self){NULL};
 }
 
 STC_DEF void
-_cx_memb(_clear)(_cx_self* self) {
+_cx_MEMB(_clear)(_cx_Self* self) {
     if (self->_cap) {
         for (_cx_value *p = self->data, *q = p + self->_len; p != q; ) {
             --q; i_keydrop(q);
@@ -288,15 +289,15 @@ _cx_memb(_clear)(_cx_self* self) {
 }
 
 STC_DEF void
-_cx_memb(_drop)(_cx_self* self) {
+_cx_MEMB(_drop)(_cx_Self* self) {
     if (self->_cap == 0)
         return;
-    _cx_memb(_clear)(self);
+    _cx_MEMB(_clear)(self);
     i_free(self->data);
 }
 
 STC_DEF bool
-_cx_memb(_reserve)(_cx_self* self, const intptr_t cap) {
+_cx_MEMB(_reserve)(_cx_Self* self, const intptr_t cap) {
     if (cap > self->_cap || (cap && cap == self->_len)) {
         _cx_value* d = (_cx_value*)i_realloc(self->data, cap*c_sizeof(i_key));
         if (!d)
@@ -308,8 +309,8 @@ _cx_memb(_reserve)(_cx_self* self, const intptr_t cap) {
 }
 
 STC_DEF bool
-_cx_memb(_resize)(_cx_self* self, const intptr_t len, i_key null) {
-    if (!_cx_memb(_reserve)(self, len))
+_cx_MEMB(_resize)(_cx_Self* self, const intptr_t len, i_key null) {
+    if (!_cx_MEMB(_reserve)(self, len))
         return false;
     const intptr_t n = self->_len;
     for (intptr_t i = len; i < n; ++i)
@@ -320,86 +321,61 @@ _cx_memb(_resize)(_cx_self* self, const intptr_t len, i_key null) {
     return true;
 }
 
-STC_DEF _cx_value*
-_cx_memb(_push)(_cx_self* self, i_key value) {
-    if (self->_len == self->_cap)
-        if (!_cx_memb(_reserve)(self, self->_len*3/2 + 4))
-            return NULL;
-    _cx_value *v = self->data + self->_len++;
-    *v = value;
-    return v;
-}
-
 STC_DEF _cx_iter
-_cx_memb(_insert_uninit)(_cx_self* self, _cx_value* pos, const intptr_t n) {
-    if (n) {
-        if (!pos) pos = self->data + self->_len;
-        const intptr_t idx = (pos - self->data);
-        if (self->_len + n > self->_cap) {
-            if (!_cx_memb(_reserve)(self, self->_len*3/2 + n))
-                return _cx_memb(_end)(self);
-            pos = self->data + idx;
-        }
-        c_memmove(pos + n, pos, (self->_len - idx)*c_sizeof *pos);
-        self->_len += n;
-    }
+_cx_MEMB(_insert_uninit)(_cx_Self* self, const intptr_t idx, const intptr_t n) {
+    if (self->_len + n > self->_cap)
+        if (!_cx_MEMB(_reserve)(self, self->_len*5/4 + n))
+            return _cx_MEMB(_end)(self);
+
+    _cx_value* pos = self->data + idx;
+    c_memmove(pos + n, pos, (self->_len - idx)*c_sizeof *pos);
+    self->_len += n;
     return c_LITERAL(_cx_iter){pos, self->data + self->_len};
 }
 
 STC_DEF _cx_iter
-_cx_memb(_insert_range)(_cx_self* self, _cx_value* pos,
-                        const _cx_value* p1, const _cx_value* p2) {
-    _cx_iter it = _cx_memb(_insert_uninit)(self, pos, (p2 - p1));
-    if (it.ref)
-        c_memcpy(it.ref, p1, (p2 - p1)*c_sizeof *p1);
-    return it;
-}
-
-STC_DEF _cx_iter
-_cx_memb(_erase_range_p)(_cx_self* self, _cx_value* p1, _cx_value* p2) {
-    intptr_t len = (p2 - p1);
-    _cx_value* p = p1, *end = self->data + self->_len;
-    for (; p != p2; ++p)
+_cx_MEMB(_erase_n)(_cx_Self* self, const intptr_t idx, const intptr_t len) {
+    _cx_value* d = self->data + idx, *p = d, *end = self->data + self->_len;
+    for (intptr_t i = 0; i < len; ++i, ++p)
         { i_keydrop(p); }
-    c_memmove(p1, p2, (end - p2)*c_sizeof *p1);
+    c_memmove(d, p, (end - p)*c_sizeof *d);
     self->_len -= len;
-    return c_LITERAL(_cx_iter){p2 == end ? NULL : p1, end - len};
+    return c_LITERAL(_cx_iter){p == end ? NULL : d, end - len};
 }
 
 #if !defined i_no_clone
-STC_DEF _cx_self
-_cx_memb(_clone)(_cx_self cx) {
-    _cx_self out = _cx_memb(_init)();
-    _cx_memb(_copy_range)(&out, out.data, cx.data, cx.data + cx._len);
+STC_DEF _cx_Self
+_cx_MEMB(_clone)(_cx_Self cx) {
+    _cx_Self out = _cx_MEMB(_init)();
+    _cx_MEMB(_copy_n)(&out, 0, cx.data, cx._len);
     return out;
 }
 
 STC_DEF _cx_iter
-_cx_memb(_copy_range)(_cx_self* self, _cx_value* pos,
-                      const _cx_value* p1, const _cx_value* p2) {
-    _cx_iter it = _cx_memb(_insert_uninit)(self, pos, (p2 - p1));
+_cx_MEMB(_copy_n)(_cx_Self* self, const intptr_t idx,
+                  const _cx_value arr[], const intptr_t n) {
+    _cx_iter it = _cx_MEMB(_insert_uninit)(self, idx, n);
     if (it.ref)
-        for (_cx_value* p = it.ref; p1 != p2; ++p1)
-            *p++ = i_keyclone((*p1));
+        for (_cx_value* p = it.ref, *q = p + n; p != q; ++arr)
+            *p++ = i_keyclone((*arr));
     return it;
 }
 #endif // !i_no_clone
 
 #if !defined i_no_emplace
 STC_DEF _cx_iter
-_cx_memb(_emplace_range)(_cx_self* self, _cx_value* pos,
-                         const _cx_raw* p1, const _cx_raw* p2) {
-    _cx_iter it = _cx_memb(_insert_uninit)(self, pos, (p2 - p1));
+_cx_MEMB(_emplace_n)(_cx_Self* self, const intptr_t idx, const _cx_raw raw[], intptr_t n) {
+    _cx_iter it = _cx_MEMB(_insert_uninit)(self, idx, n);
     if (it.ref)
-        for (_cx_value* p = it.ref; p1 != p2; ++p1)
-            *p++ = i_keyfrom((*p1));
+        for (_cx_value* p = it.ref; n--; ++raw, ++p)
+            *p = i_keyfrom((*raw));
     return it;
 }
 #endif // !i_no_emplace
+#if defined _i_has_eq || defined _i_has_cmp
 
-#if !defined i_no_cmp || defined _i_has_eq
 STC_DEF _cx_iter
-_cx_memb(_find_in)(_cx_iter i1, _cx_iter i2, _cx_raw raw) {
+_cx_MEMB(_find_in)(_cx_iter i1, _cx_iter i2, _cx_raw raw) {
     const _cx_value* p2 = _it2_ptr(i1, i2);
     for (; i1.ref != p2; ++i1.ref) {
         const _cx_raw r = i_keyto(i1.ref);
@@ -410,10 +386,10 @@ _cx_memb(_find_in)(_cx_iter i1, _cx_iter i2, _cx_raw raw) {
     return i2;
 }
 #endif
-#ifndef i_no_cmp
+#if defined _i_has_cmp
 
 STC_DEF _cx_iter
-_cx_memb(_binary_search_in)(_cx_iter i1, _cx_iter i2, const _cx_raw raw,
+_cx_MEMB(_binary_search_in)(_cx_iter i1, _cx_iter i2, const _cx_raw raw,
                             _cx_iter* lower_bound) {
     _cx_value* w[2] = {i1.ref, _it2_ptr(i1, i2)};
     _cx_iter mid = i1;
@@ -430,12 +406,12 @@ _cx_memb(_binary_search_in)(_cx_iter i1, _cx_iter i2, const _cx_raw raw,
     i1.ref = NULL; return i1;
 }
 
-STC_DEF int _cx_memb(_value_cmp)(const _cx_value* x, const _cx_value* y) {
+STC_DEF int _cx_MEMB(_value_cmp)(const _cx_value* x, const _cx_value* y) {
     const _cx_raw rx = i_keyto(x);
     const _cx_raw ry = i_keyto(y);
     return i_cmp((&rx), (&ry));
 }
-#endif // !c_no_cmp
+#endif // _i_has_cmp
 #endif // i_implement
 #define CVEC_H_INCLUDED
 #include "priv/template2.h"