removed APIs that would index the array after modifying its address

that pattern can fail on some compilers because a stale array address
is indexed after the array is resized.

Author: garettbass

include/array.h

@@ -41,14 +41,17 @@ extern "C" {
         #ifndef free
             extern void free(void* ptr);
         #endif
-        return size ? (realloc(ptr, size)) : (free(ptr),NULL);
+        return size ? (realloc(ptr, size)) : (free(ptr),(void*)NULL);
     }
 #endif
 
 
 //------------------------------------------------------------------------------
 
 
+#define array_t(T) T*
+
+
 // void array_alloc(T*& a, size_t capacity, void (*destructor)(T* begin, T* end))
 #define array_alloc(a, capacity, destructor) \
     (_array_alloc(_array_ptr((a)), (capacity) * _array_stride((a)), (array_allocator), (_array_destructor_t)(destructor)))
@@ -157,78 +160,38 @@ An assertion will fail if the array is empty.
 @hideinitializer **/
 
 
-// T& array_append(T*& a)
-#define array_append(a) \
-    ((a)[ _array_append(_array_ptr((a)), _array_stride((a))) / _array_stride((a)) ])
+// void array_append(T*& array, T value)
+#define array_append(a, v) \
+    ( _array_append(_array_ptr((a)), _array_stride((a))), array_back(a) = v )
 /**< Appends a single element to the dynamic array, allocating additional
-storage if necessary.  The appended element is uninitialized.  Returns a
-reference to the appended element.
+storage if necessary.
 
 @code{.c}
     array_t(int) ia = NULL;
     array_alloc(ia, 16, NULL);
     // ...
-    array_append(ia) = 123; // assign value 123 to ia[0]
+    array_append(ia, 123);
     assert(ia[0] == 123);
 @endcode
 @hideinitializer **/
 
 
-// T* array_append_n(T*& a, size_t count)
-#define array_append_n(a, count) \
-    ((a) + _array_append(_array_ptr((a)), _array_offset((a), (count))) / _array_stride((a)))
-/**< Appends count elements to the dynamic array, allocating additional storage
-if necessary.  Appended elements are uninitialized.  Returns a pointer to the
-first appended element.
-
-@code{.c}
-    array_t(int) ia = NULL;
-    array_alloc(ia, 16, NULL);
-    // ...
-    const size_t count = 3;
-    int* itr = array_append_n(ia, count);
-    int* end = itr + count;
-    for (; itr < end; ++itr) { *itr = 0; }
-@endcode
-@hideinitializer **/
-
-
-// T& array_insert(T*& a, size_t index)
-#define array_insert(a, index) \
-    ((a)[ _array_insert(_array_ptr((a)), _array_offset((a), (index)), _array_stride((a))) / _array_stride((a)) ])
+// void array_insert(T*& a, size_t index, T value)
+#define array_insert(a, index, v) \
+    ( _array_insert(_array_ptr((a)), _array_offset((a), (index)), _array_stride((a))), (a)[index] = v )
 /**< Inserts a single element at the provided index, allocating additional
-storage if necessary.  The inserted element is uninitialized.  Returns a
-reference to the inserted element.
+storage if necessary.
 
 @code{.c}
     array_t(int) ia = NULL;
     array_alloc(ia, 16, NULL);
     // ...
-    array_insert(ia, 1) = 123; // assign value 123 to ia[0]
+    array_insert(ia, 1, 123);
     assert(ia[1] == 123);
 @endcode
 @hideinitializer **/
 
 
-// T* array_insert_n(T*& a, sizet index, size_t count)
-#define array_insert_n(a, index, count) \
-    ((a) + _array_insert(_array_ptr((a)), _array_offset((a), (index)), _array_offset((a), (count))) / _array_stride((a)))
-/**< Inserts count elements into the dynamic array starting at index and
-allocating additional storage if necessary.  Appended elements are
-uninitialized.  Returns a pointer to the first appended element.
-
-@code{.c}
-    array_t(int) ia = NULL;
-    array_alloc(ia, 16, NULL);
-    // ...
-    const size_t count = 3;
-    int* itr = array_insert_n(ia, 0, count);
-    int* end = itr + count;
-    for (; itr < end; ++itr) { *itr = 0; }
-@endcode
-@hideinitializer **/
-
-
 // void array_remove(T*& a, size_t index)
 #define array_remove(a, index) \
     (_array_remove(_array_ptr((a)), _array_offset((a), (index)), _array_stride((a))))
@@ -266,7 +229,7 @@ to the array's destructor if it is not NULL.
 // T* array_begin(T* array)
 #define array_begin(a) (a)
 /**< Returns a pointer to the first element of the array, or NULL if the array
-is empty or NULL.
+is NULL.
 @hideinitializer **/
 
 
@@ -458,6 +421,7 @@ void _array_reserve(_array_t* a, const size_t capacity) {
     _array_assert((*a), "array uninitialized");
     if (_array_capacity(a) < capacity) {
         _array_grow(a, _array_ceilpow2(capacity));
+        _array_assert(_array_capacity(a) >= capacity, "_array_grow() failed");
     }
 }
 
@@ -598,9 +562,4 @@ void _array_clear(_array_t* const a) {
 
 #if __cplusplus
 } // extern "C"
-#endif // __cplusplus
-
-
-#if array_inline
-#include "array.inl"
-#endif
+#endif // __cplusplus

src/tests.c

@@ -25,7 +25,7 @@ void destructed_element_count_destructor(int* begin, int* end) {
 
 
 int main(int argc, const char* argv[]) {
-    int* a = NULL;
+    array_t(int) a = NULL;
     test(array_size(a) == 0);
     test(array_capacity(a) == 0);
 
@@ -34,28 +34,28 @@ int main(int argc, const char* argv[]) {
     test(array_capacity(a) == 0);
 
 
-    int* a0 = &array_append(a); *a0 = 1;
+    array_append(a, 1);
     test(array_size(a) == 1);
     test(array_capacity(a) >= 1);
     test(a[0] == 1);
 
 
-    array_append(a) = 2;
+    array_append(a, 2);
     test(array_size(a) == 2);
     test(array_capacity(a) >= 2);
     test(a[0] == 1);
     test(a[1] == 2);
 
 
-    array_append(a) = 3;
+    array_append(a, 3);
     test(array_size(a) == 3);
     test(array_capacity(a) >= 3);
     test(a[0] == 1);
     test(a[1] == 2);
     test(a[2] == 3);
 
 
-    array_insert(a,0) = 0;
+    array_insert(a, 0, 0);
     test(array_size(a) == 4);
     test(array_capacity(a) >= 4);
     test(a[0] == 0);
@@ -64,7 +64,7 @@ int main(int argc, const char* argv[]) {
     test(a[3] == 3);
 
 
-    array_reserve(a,16);
+    array_reserve(a, 16);
     test(array_size(a) == 4);
     test(array_capacity(a) == 16);
     test(a[0] == 0);
@@ -82,7 +82,7 @@ int main(int argc, const char* argv[]) {
     test(a[3] == 3);
 
 
-    array_remove(a,0);
+    array_remove(a, 0);
     test(array_size(a) == 3);
     test(array_capacity(a) == 4);
     test(a[0] == 1);
@@ -108,18 +108,29 @@ int main(int argc, const char* argv[]) {
     destructed_element_count = 0;
 
 
+    array_append(a, 0);
+    array_append(a, 1);
+    array_append(a, 2);
+    test(array_size(a) == 3);
+    test(array_capacity(a) >= 3);
+    test(destructed_element_count == 0);
+
+
     array_free(a);
     test(a == NULL);
     test(array_size(a) == 0);
     test(array_capacity(a) == 0);
+    test(destructed_element_count == 3);
+    destructed_element_count = 0;
 
 
     enum { TEST_LENGTH = 1024 };
 
 
     array_alloc(a, 0, destructed_element_count_destructor);
     for (int i = 0; i < TEST_LENGTH; ++i) {
-        array_append(a) = i;
+        array_append(a, i);
+        test(a[i] == i);
     }
     test(array_size(a) == TEST_LENGTH);
     test(array_capacity(a) >= TEST_LENGTH);
@@ -152,7 +163,7 @@ int main(int argc, const char* argv[]) {
 
     array_alloc(a, 0, destructed_element_count_destructor);
     for (int i = 0; i < TEST_LENGTH; ++i) {
-        array_insert(a,0) = i;
+        array_insert(a, 0, i);
     }
     test(array_size(a) == TEST_LENGTH);
     test(array_capacity(a) >= TEST_LENGTH);
@@ -165,6 +176,5 @@ int main(int argc, const char* argv[]) {
     test(array_capacity(a) == 0);
 
 
-    puts("array.h: passed tests");
-    return 0;
+    puts("array tests passed");
 }