Add namespace import to BitArray

CMakeLists.txt

@@ -57,9 +57,9 @@ if("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
     set(COMPILE_OPTIONS "")
     set(LINK_OPTIONS "")
     set(LOG_LEVEL 2)
-    set(DEFINITIONS CORE_CHECK_MEMORY)
+    set(DEFINITIONS CORE_CHECK_MEMORY IMPORT_CORE)
 else()
-    set(DEFINITIONS ERROR_SIMULATOR CORE_CHECK_MEMORY)
+    set(DEFINITIONS ERROR_SIMULATOR CORE_CHECK_MEMORY IMPORT_CORE)
     if(CMAKE_C_COMPILER_ID STREQUAL "GNU")
         set(COMPILE_OPTIONS --coverage)
         set(LINK_OPTIONS gcov)

include/core/BitArray.h

@@ -15,13 +15,29 @@ static_assert(sizeof(CoreBitArray) == 16, "invalid bit array size");
 void coreCopyBitArray(CoreBitArray* a, const CoreBitArray* other);
 void coreMoveBitArray(CoreBitArray* a, CoreBitArray* other);
 void coreDestroyBitArray(CoreBitArray* a);
-CoreBitArray* coreBitArraySet(CoreBitArray* a, size_t index, u64 value);
-u64 coreBitArrayGet(const CoreBitArray* a, size_t index);
-size_t coreBitArrayBytes(const CoreBitArray* a);
-i64 coreBitArraySelect(const CoreBitArray* a, size_t index);
+CoreBitArray* coreSetBitsBitArray(CoreBitArray* a, size_t index, u64 value);
+u64 coreGetBitsBitArray(const CoreBitArray* a, size_t index);
+size_t coreGetBytesBitArray(const CoreBitArray* a);
+i64 coreSelectBitsBitArray(const CoreBitArray* a, size_t index);
 void coreResizeBitArray(CoreBitArray* a, size_t newLength, size_t newBits);
 void coreFillBitArray(CoreBitArray* a, u64 value);
 size_t coreToStringBitArray(const CoreBitArray* a, char* buffer, size_t n);
 void coreSwapBitArray(CoreBitArray* a, CoreBitArray* b);
 
+#ifdef IMPORT_CORE
+#define BitArray CoreBitArray
+#define BIT_ARRAY CORE_BIT_ARRAY
+#define copyBitArray coreCopyBitArray
+#define moveBitArray coreMoveBitArray
+#define destroyBitArray coreDestroyBitArray
+#define setBitsBitArray coreSetBitsBitArray
+#define getBitsBitArray coreGetBitsBitArray
+#define getBytesBitArray coreGetBytesBitArray
+#define selectBitsBitArray coreSelectBitsBitArray
+#define resizeBitArray coreResizeBitArray
+#define fillBitArray coreFillBitArray
+#define toStringBitArray coreToStringBitArray
+#define swapBitArray coreSwapBitArray
+#endif
+
 #endif

src/BitArray.c

@@ -45,51 +45,51 @@ static size_t getArrayLength(size_t length, size_t bits) {
     return roundUpDivide(length * bits, U64_BITS);
 }
 
-void coreCopyBitArray(CoreBitArray* a, const CoreBitArray* other) {
+void copyBitArray(BitArray* a, const BitArray* other) {
     if(a == other) {
         return;
     }
-    coreResizeBitArray(a, other->length, other->bits);
+    resizeBitArray(a, other->length, other->bits);
     size_t length = a->length;
     for(size_t i = 0; i < length; i++) {
-        coreBitArraySet(a, i, coreBitArrayGet(other, i));
+        setBitsBitArray(a, i, getBitsBitArray(other, i));
     }
 }
 
-void coreMoveBitArray(CoreBitArray* a, CoreBitArray* other) {
+void moveBitArray(BitArray* a, BitArray* other) {
     if(a == other) {
         return;
     }
-    coreSwapBitArray(a, other);
-    coreDestroyBitArray(other);
+    swapBitArray(a, other);
+    destroyBitArray(other);
 }
 
-void coreDestroyBitArray(CoreBitArray* a) {
+void destroyBitArray(BitArray* a) {
     coreFree(a->data);
     *a = CORE_BIT_ARRAY;
 }
 
-CoreBitArray* coreBitArraySet(CoreBitArray* a, size_t index, u64 value) {
+BitArray* setBitsBitArray(BitArray* a, size_t index, u64 value) {
     assert(a->data != nullptr);
     assert(index < a->length);
     setBits(a->data, index, a->bits, value);
     return a;
 }
 
-u64 coreBitArrayGet(const CoreBitArray* a, size_t index) {
+u64 getBitsBitArray(const BitArray* a, size_t index) {
     assert(a->data != nullptr);
     assert(index < a->length);
     return readBits(a->data, index, a->bits);
 }
 
-size_t coreBitArrayBytes(const CoreBitArray* a) {
+size_t getBytesBitArray(const BitArray* a) {
     if(a->length <= 0 || a->bits <= 0) {
         return 0;
     }
     return getArrayLength(a->length, a->bits) * sizeof(u64);
 }
 
-i64 coreBitArraySelect(const CoreBitArray* a, size_t index) {
+i64 selectBitsBitArray(const BitArray* a, size_t index) {
     if(index <= 0) {
         return -1;
     }
@@ -113,9 +113,9 @@ i64 coreBitArraySelect(const CoreBitArray* a, size_t index) {
     return -1;
 }
 
-void coreResizeBitArray(CoreBitArray* a, size_t newLength, size_t newBits) {
+void resizeBitArray(BitArray* a, size_t newLength, size_t newBits) {
     if(newLength == 0 || newBits == 0) {
-        coreDestroyBitArray(a);
+        destroyBitArray(a);
         return;
     } else if(newBits > 64) {
         newBits = 64;
@@ -126,7 +126,7 @@ void coreResizeBitArray(CoreBitArray* a, size_t newLength, size_t newBits) {
 
     size_t end = coreMinSize(a->length, newLength);
     for(size_t i = 0; i < end; i++) {
-        setBits(newData, i, newBits, coreBitArrayGet(a, i));
+        setBits(newData, i, newBits, getBitsBitArray(a, i));
     }
     for(size_t i = end; i < newLength; i++) {
         setBits(newData, i, newBits, 0);
@@ -137,32 +137,32 @@ void coreResizeBitArray(CoreBitArray* a, size_t newLength, size_t newBits) {
     a->bits = newBits & 0xFF;
 }
 
-void coreFillBitArray(CoreBitArray* a, u64 value) {
+void fillBitArray(BitArray* a, u64 value) {
     size_t length = a->length;
     for(size_t i = 0; i < length; i++) {
-        coreBitArraySet(a, i, value);
+        setBitsBitArray(a, i, value);
     }
 }
 
-size_t coreToStringBitArray(const CoreBitArray* a, char* buffer, size_t n) {
+size_t toStringBitArray(const BitArray* a, char* buffer, size_t n) {
     size_t w = 0;
     coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "["));
     size_t length = a->length;
     if(length > 0) {
         length--;
         for(size_t i = 0; i < length; i++) {
-            u64 v = coreBitArrayGet(a, i);
+            u64 v = getBitsBitArray(a, i);
             coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "%lu, ", v));
         }
-        u64 v = coreBitArrayGet(a, length);
+        u64 v = getBitsBitArray(a, length);
         coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "%lu", v));
     }
     coreStringAdd(&w, &buffer, &n, coreToString(buffer, n, "]"));
     return w;
 }
 
-void coreSwapBitArray(CoreBitArray* a, CoreBitArray* b) {
-    CoreBitArray tmp = *a;
+void swapBitArray(BitArray* a, BitArray* b) {
+    BitArray tmp = *a;
     *a = *b;
     *b = tmp;
 }

test/modules/BitArrayTests.c

@@ -2,181 +2,181 @@
 #include "core/BitArray.h"
 
 static void testSetRead() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 4, 3);
-    coreBitArraySet(&bits, 0, 1);
-    coreBitArraySet(&bits, 1, 2);
-    coreBitArraySet(&bits, 2, 3);
-    coreBitArraySet(&bits, 3, 4);
-    CORE_TEST_U64(1, coreBitArrayGet(&bits, 0));
-    CORE_TEST_U64(2, coreBitArrayGet(&bits, 1));
-    CORE_TEST_U64(3, coreBitArrayGet(&bits, 2));
-    CORE_TEST_U64(4, coreBitArrayGet(&bits, 3));
-    coreDestroyBitArray(&bits);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 4, 3);
+    setBitsBitArray(&bits, 0, 1);
+    setBitsBitArray(&bits, 1, 2);
+    setBitsBitArray(&bits, 2, 3);
+    setBitsBitArray(&bits, 3, 4);
+    CORE_TEST_U64(1, getBitsBitArray(&bits, 0));
+    CORE_TEST_U64(2, getBitsBitArray(&bits, 1));
+    CORE_TEST_U64(3, getBitsBitArray(&bits, 2));
+    CORE_TEST_U64(4, getBitsBitArray(&bits, 3));
+    destroyBitArray(&bits);
 }
 
 static void testBigSetRead() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 100, 13);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 100, 13);
     for(size_t i = 0; i < bits.length; i++) {
-        coreBitArraySet(&bits, i, i);
+        setBitsBitArray(&bits, i, i);
     }
     for(size_t i = 0; i < bits.length; i++) {
-        CORE_TEST_U64(i, coreBitArrayGet(&bits, i));
+        CORE_TEST_U64(i, getBitsBitArray(&bits, i));
     }
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&bits);
 }
 
 static void testRandomSetReadResize() {
     u64 data[100];
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 100, 13);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 100, 13);
     u64 seed = 534;
     for(int k = 0; k < 20; k++) {
         for(u64 i = 0; i < bits.length; i++) {
             seed = seed * 636455 + 53453;
-            coreBitArraySet(&bits, i, seed);
+            setBitsBitArray(&bits, i, seed);
             data[i] = seed & 0x1FFF;
         }
     }
     for(size_t i = 0; i < bits.length; i++) {
-        CORE_TEST_U64(data[i], coreBitArrayGet(&bits, i));
+        CORE_TEST_U64(data[i], getBitsBitArray(&bits, i));
     }
-    coreResizeBitArray(&bits, bits.length, bits.bits + 1u);
+    resizeBitArray(&bits, bits.length, bits.bits + 1u);
     CORE_TEST_U64(14, bits.bits);
     CORE_TEST_U64(100, bits.length);
     for(size_t i = 0; i < bits.length; i++) {
-        CORE_TEST_U64(data[i], coreBitArrayGet(&bits, i));
+        CORE_TEST_U64(data[i], getBitsBitArray(&bits, i));
     }
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&bits);
 }
 
 static void testCopy() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 4, 3);
-    coreBitArraySet(&bits, 0, 1);
-    coreBitArraySet(&bits, 1, 2);
-    coreBitArraySet(&bits, 2, 3);
-    coreBitArraySet(&bits, 3, 4);
-    CoreBitArray copy = CORE_BIT_ARRAY;
-    coreCopyBitArray(&copy, &bits);
-    coreCopyBitArray(&copy, &copy);
-    CORE_TEST_U64(1, coreBitArrayGet(&copy, 0));
-    CORE_TEST_U64(2, coreBitArrayGet(&copy, 1));
-    CORE_TEST_U64(3, coreBitArrayGet(&copy, 2));
-    CORE_TEST_U64(4, coreBitArrayGet(&copy, 3));
-    coreDestroyBitArray(&copy);
-    coreDestroyBitArray(&bits);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 4, 3);
+    setBitsBitArray(&bits, 0, 1);
+    setBitsBitArray(&bits, 1, 2);
+    setBitsBitArray(&bits, 2, 3);
+    setBitsBitArray(&bits, 3, 4);
+    BitArray copy = BIT_ARRAY;
+    copyBitArray(&copy, &bits);
+    copyBitArray(&copy, &copy);
+    CORE_TEST_U64(1, getBitsBitArray(&copy, 0));
+    CORE_TEST_U64(2, getBitsBitArray(&copy, 1));
+    CORE_TEST_U64(3, getBitsBitArray(&copy, 2));
+    CORE_TEST_U64(4, getBitsBitArray(&copy, 3));
+    destroyBitArray(&copy);
+    destroyBitArray(&bits);
 }
 
 static void testSelect() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 90, 1);
-    coreFillBitArray(&bits, 0);
-    coreBitArraySet(&bits, 0, 1);
-    coreBitArraySet(&bits, 5, 1);
-    coreBitArraySet(&bits, 20, 1);
-    coreBitArraySet(&bits, 31, 1);
-    coreBitArraySet(&bits, 32, 1);
-    coreBitArraySet(&bits, 33, 1);
-    coreBitArraySet(&bits, 60, 1);
-    CORE_TEST_I64(-1, coreBitArraySelect(&bits, 0));
-    CORE_TEST_I64(0, coreBitArraySelect(&bits, 1));
-    CORE_TEST_I64(5, coreBitArraySelect(&bits, 2));
-    CORE_TEST_I64(20, coreBitArraySelect(&bits, 3));
-    CORE_TEST_I64(31, coreBitArraySelect(&bits, 4));
-    CORE_TEST_I64(32, coreBitArraySelect(&bits, 5));
-    CORE_TEST_I64(33, coreBitArraySelect(&bits, 6));
-    CORE_TEST_I64(60, coreBitArraySelect(&bits, 7));
-    CORE_TEST_I64(-1, coreBitArraySelect(&bits, 8));
-    coreDestroyBitArray(&bits);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 90, 1);
+    fillBitArray(&bits, 0);
+    setBitsBitArray(&bits, 0, 1);
+    setBitsBitArray(&bits, 5, 1);
+    setBitsBitArray(&bits, 20, 1);
+    setBitsBitArray(&bits, 31, 1);
+    setBitsBitArray(&bits, 32, 1);
+    setBitsBitArray(&bits, 33, 1);
+    setBitsBitArray(&bits, 60, 1);
+    CORE_TEST_I64(-1, selectBitsBitArray(&bits, 0));
+    CORE_TEST_I64(0, selectBitsBitArray(&bits, 1));
+    CORE_TEST_I64(5, selectBitsBitArray(&bits, 2));
+    CORE_TEST_I64(20, selectBitsBitArray(&bits, 3));
+    CORE_TEST_I64(31, selectBitsBitArray(&bits, 4));
+    CORE_TEST_I64(32, selectBitsBitArray(&bits, 5));
+    CORE_TEST_I64(33, selectBitsBitArray(&bits, 6));
+    CORE_TEST_I64(60, selectBitsBitArray(&bits, 7));
+    CORE_TEST_I64(-1, selectBitsBitArray(&bits, 8));
+    destroyBitArray(&bits);
 }
 
 static void testToString1() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 4, 3);
-    coreBitArraySet(&bits, 0, 1);
-    coreBitArraySet(&bits, 1, 2);
-    coreBitArraySet(&bits, 2, 3);
-    coreBitArraySet(&bits, 3, 4);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 4, 3);
+    setBitsBitArray(&bits, 0, 1);
+    setBitsBitArray(&bits, 1, 2);
+    setBitsBitArray(&bits, 2, 3);
+    setBitsBitArray(&bits, 3, 4);
     char buffer[128];
-    size_t n = coreToStringBitArray(&bits, buffer, sizeof(buffer));
+    size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
     CORE_TEST_SIZE(12, n);
     CORE_TEST_STRING("[1, 2, 3, 4]", buffer);
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&bits);
 }
 
 static void testToString2() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 1, 3);
-    coreBitArraySet(&bits, 0, 1);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 1, 3);
+    setBitsBitArray(&bits, 0, 1);
     char buffer[128];
-    size_t n = coreToStringBitArray(&bits, buffer, sizeof(buffer));
+    size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
     CORE_TEST_SIZE(3, n);
     CORE_TEST_STRING("[1]", buffer);
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&bits);
 }
 
 static void testToString3() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
+    BitArray bits = BIT_ARRAY;
     char buffer[128];
-    size_t n = coreToStringBitArray(&bits, buffer, sizeof(buffer));
+    size_t n = toStringBitArray(&bits, buffer, sizeof(buffer));
     CORE_TEST_SIZE(2, n);
     CORE_TEST_STRING("[]", buffer);
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&bits);
 }
 
 static void testResizeExact() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    CORE_TEST_U64(0, coreBitArrayBytes(&bits));
+    BitArray bits = BIT_ARRAY;
+    CORE_TEST_U64(0, getBytesBitArray(&bits));
     // the size in bytes matches the internal storage type
     size_t elements = sizeof(u64);
-    coreResizeBitArray(&bits, elements, 8);
+    resizeBitArray(&bits, elements, 8);
     for(size_t i = 0; i < elements; i++) {
-        coreBitArraySet(&bits, i, i);
+        setBitsBitArray(&bits, i, i);
     }
     for(size_t i = 0; i < elements; i++) {
-        CORE_TEST_U64(i, coreBitArrayGet(&bits, i));
+        CORE_TEST_U64(i, getBitsBitArray(&bits, i));
     }
-    CORE_TEST_U64(sizeof(u64), coreBitArrayBytes(&bits));
-    coreDestroyBitArray(&bits);
+    CORE_TEST_U64(sizeof(u64), getBytesBitArray(&bits));
+    destroyBitArray(&bits);
 }
 
 static void testMove() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 8, 8);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 8, 8);
     for(size_t i = 0; i < bits.length; i++) {
-        coreBitArraySet(&bits, i, i);
+        setBitsBitArray(&bits, i, i);
     }
-    CoreBitArray m = CORE_BIT_ARRAY;
-    coreMoveBitArray(&m, &bits);
-    coreMoveBitArray(&m, &m);
+    BitArray m = BIT_ARRAY;
+    moveBitArray(&m, &bits);
+    moveBitArray(&m, &m);
     CORE_TEST_U64(8, m.length);
     for(size_t i = 0; i < m.length; i++) {
-        CORE_TEST_U64(i, coreBitArrayGet(&m, i));
+        CORE_TEST_U64(i, getBitsBitArray(&m, i));
     }
-    coreDestroyBitArray(&m);
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&m);
+    destroyBitArray(&bits);
 }
 
 static void testInvalidArgument() {
-    CoreBitArray bits = CORE_BIT_ARRAY;
-    coreResizeBitArray(&bits, 0, 5);
+    BitArray bits = BIT_ARRAY;
+    resizeBitArray(&bits, 0, 5);
     CORE_TEST_SIZE(0, bits.length);
     CORE_TEST_SIZE(0, bits.bits);
-    coreResizeBitArray(&bits, 5, 0);
+    resizeBitArray(&bits, 5, 0);
     CORE_TEST_SIZE(0, bits.length);
     CORE_TEST_SIZE(0, bits.bits);
-    coreResizeBitArray(&bits, 0, 0);
+    resizeBitArray(&bits, 0, 0);
     CORE_TEST_SIZE(0, bits.length);
     CORE_TEST_SIZE(0, bits.bits);
-    coreResizeBitArray(&bits, 1, 65);
+    resizeBitArray(&bits, 1, 65);
     CORE_TEST_SIZE(1, bits.length);
     CORE_TEST_SIZE(64, bits.bits);
-    coreResizeBitArray(&bits, 5, 68);
+    resizeBitArray(&bits, 5, 68);
     CORE_TEST_SIZE(5, bits.length);
     CORE_TEST_SIZE(64, bits.bits);
-    coreDestroyBitArray(&bits);
+    destroyBitArray(&bits);
 }
 
 void coreTestBitArray() {