Apply new formatting

include/core/Vector.h

@@ -6,55 +6,55 @@
 #define VECTOR_OP2(name) name *r, const name *a
 #define VECTOR_OP3(name) VECTOR_OP2(name), const name* b
 
-#define VECTOR_TYPE(type, Type)                                                \
-    typedef union {                                                            \
-        type data[2];                                                          \
-        struct {                                                               \
-            type x, y;                                                         \
-        };                                                                     \
-    } Type##2;                                                                 \
-    typedef union {                                                            \
-        type data[3];                                                          \
-        struct {                                                               \
-            type x, y, z;                                                      \
-        };                                                                     \
-        Type##2 xy;                                                            \
-    } Type##3;                                                                 \
-    typedef union {                                                            \
-        type data[4];                                                          \
-        struct {                                                               \
-            type x, y, z, w;                                                   \
-        };                                                                     \
-        struct {                                                               \
-            Type##2 xy, zw;                                                    \
-        };                                                                     \
-        Type##3 xyz;                                                           \
+#define VECTOR_TYPE(type, Type) \
+    typedef union {             \
+        type data[2];           \
+        struct {                \
+            type x, y;          \
+        };                      \
+    } Type##2;                  \
+    typedef union {             \
+        type data[3];           \
+        struct {                \
+            type x, y, z;       \
+        };                      \
+        Type##2 xy;             \
+    } Type##3;                  \
+    typedef union {             \
+        type data[4];           \
+        struct {                \
+            type x, y, z, w;    \
+        };                      \
+        struct {                \
+            Type##2 xy, zw;     \
+        };                      \
+        Type##3 xyz;            \
     } Type##4
 
 VECTOR_TYPE(float, Vector);
 VECTOR_TYPE(int, IntVector);
 
-#define DEFINE_VECTOR(N, name, sname, type)                                    \
-    name* addSet##sname(VECTOR_OP2(name));                                     \
-    name* add##sname(VECTOR_OP3(name));                                        \
-    name* subSet##sname(VECTOR_OP2(name));                                     \
-    name* sub##sname(VECTOR_OP3(name));                                        \
-    name* mulSet##sname(VECTOR_OP2(name));                                     \
-    name* mul##sname(VECTOR_OP3(name));                                        \
-    name* divSet##sname(VECTOR_OP2(name));                                     \
-    name* div##sname(VECTOR_OP3(name));                                        \
-    name* mulSet##sname##F(name* r, type f);                                   \
-    name* mul##sname##F(name* r, const name* a, type f);                       \
-    name* divSet##sname##F(name* r, type f);                                   \
-    name* div##sname##F(name* r, const name* a, type f);                       \
-    name* invertSet##sname(name* r);                                           \
-    name* invert##sname(name* r, const name* a);                               \
+#define DEFINE_VECTOR(N, name, sname, type)                        \
+    name* addSet##sname(VECTOR_OP2(name));                         \
+    name* add##sname(VECTOR_OP3(name));                            \
+    name* subSet##sname(VECTOR_OP2(name));                         \
+    name* sub##sname(VECTOR_OP3(name));                            \
+    name* mulSet##sname(VECTOR_OP2(name));                         \
+    name* mul##sname(VECTOR_OP3(name));                            \
+    name* divSet##sname(VECTOR_OP2(name));                         \
+    name* div##sname(VECTOR_OP3(name));                            \
+    name* mulSet##sname##F(name* r, type f);                       \
+    name* mul##sname##F(name* r, const name* a, type f);           \
+    name* divSet##sname##F(name* r, type f);                       \
+    name* div##sname##F(name* r, const name* a, type f);           \
+    name* invertSet##sname(name* r);                               \
+    name* invert##sname(name* r, const name* a);                   \
     size_t toString##sname(const name* a, char* buffer, size_t n);
 
-#define DEFINE_FVECTOR(N, name)                                                \
-    float dotV##N(const name* a, const name* b);                               \
-    float squareLengthV##N(const name* a);                                     \
-    float lengthV##N(const name* a);                                           \
+#define DEFINE_FVECTOR(N, name)                  \
+    float dotV##N(const name* a, const name* b); \
+    float squareLengthV##N(const name* a);       \
+    float lengthV##N(const name* a);             \
     name* normalizeV##N(name* r);
 
 DEFINE_VECTOR(2, Vector2, V2, float)
@@ -70,8 +70,8 @@ DEFINE_VECTOR(4, IntVector4, IV4, int)
 Vector3* angles(Vector3* r, float lengthAngle, float widthAngle);
 Vector3* cross(VECTOR_OP3(Vector3));
 
-#define DEFINE_VECTOR_CONVERSION(a, nameA, b, nameB)                           \
-    a* convert##nameB(a* r, const b* c);                                       \
+#define DEFINE_VECTOR_CONVERSION(a, nameA, b, nameB) \
+    a* convert##nameB(a* r, const b* c);             \
     b* convert##nameA(b* r, const a* c)
 
 DEFINE_VECTOR_CONVERSION(Vector2, V2, IntVector2, IV2);
@@ -86,10 +86,10 @@ DEFINE_VECTOR_CONVERSION(Vector4, V4, IntVector4, IV4);
 #define INT_VECTOR4 ((IntVector4){0})
 
 #define SELECT_VECTOR(_1, _2, _3, _4, name, ...) name
-#define V(...)                                                                 \
+#define V(...) \
     ((SELECT_VECTOR(__VA_ARGS__, Vector4, Vector3, Vector2, 0)){{__VA_ARGS__}})
-#define IV(...)                                                                \
-    ((SELECT_VECTOR(__VA_ARGS__, IntVector4, IntVector3, IntVector2, 0)){      \
+#define IV(...)                                                           \
+    ((SELECT_VECTOR(__VA_ARGS__, IntVector4, IntVector3, IntVector2, 0)){ \
         {__VA_ARGS__}})
 
 #endif

performance/Main.c

@@ -11,7 +11,7 @@ HASHMAP_SOURCE(int, int, Int)
 static i64 testSearch(const HashMapInt* m) {
     i64 nanos = getNanos();
     volatile int sum = 0;
-    for(int i = 0; i < 10000; i++) {
+    for(int i = 0; i < 10'000; i++) {
         for(int k = -5000; k < 5000; k++) {
             const int* s = searchHashMapKeyInt(m, i + k);
             if(s != nullptr) {
@@ -36,7 +36,7 @@ static i64 testEmptySearch(const HashMapInt* m) {
 
 static void fillOrder(HashMapInt* m) {
     i64 nanos = getNanos();
-    for(int i = 0; i < 10000; i++) {
+    for(int i = 0; i < 10'000; i++) {
         *putHashMapKeyInt(m, i) = i * i;
     }
     printf("Fill Order: %" PRId64 "ns\n", getNanos() - nanos);
@@ -46,8 +46,8 @@ static void fillChaos(HashMapInt* m) {
     i64 nanos = getNanos();
     Random random;
     initRandom(&random, 0);
-    for(int i = 0; i < 10000; i++) {
-        int r = randomI32(&random, 0, 10000);
+    for(int i = 0; i < 10'000; i++) {
+        int r = randomI32(&random, 0, 10'000);
         *putHashMapKeyInt(m, r) = r * r;
     }
     printf("Fill Chaos: %" PRId64 "ns\n", getNanos() - nanos);

src/BitArray.c

@@ -121,7 +121,7 @@ void setBitLength(BitArray* a, size_t newLength, size_t newBits) {
     }
     coreFree(a->data);
     a->data = newData;
-    a->length = newLength & 0xFFFFFFFFFFFFFF;
+    a->length = newLength & 0xFF'FFFF'FFFF'FFFF;
     a->bits = newBits & 0xFF;
 }
 

src/Box.c

@@ -50,7 +50,8 @@ void growBox(Box* box, const Vector3* growth) {
 }
 
 size_t toStringBox(const Box* box, char* buffer, size_t n) {
-    return toString(buffer, n, "Box([%.3f, %.3f, %.3f], [%.3f, %.3f, %.3f])",
-                    (double)box->min.x, (double)box->min.y, (double)box->min.z,
-                    (double)box->max.x, (double)box->max.y, (double)box->max.z);
+    return toString(
+        buffer, n, "Box([%.3f, %.3f, %.3f], [%.3f, %.3f, %.3f])",
+        (double)box->min.x, (double)box->min.y, (double)box->min.z,
+        (double)box->max.x, (double)box->max.y, (double)box->max.z);
 }

src/Frustum.c

@@ -12,8 +12,9 @@ void initFrustum(Frustum* f, float fieldOfView, float nearClip, float farClip) {
     float diff = 1.0f / (nearClip - farClip);
     f->projection.data[0] = V(0.0f, 0.0f, 0.0f, 0.0f);
     f->projection.data[1] = V(0.0f, 1.0f / f->tan, 0.0f, 0.0f);
-    f->projection.data[2] = V(0.0f, 0.0f, (nearClip + farClip) * diff,
-                              (2.0f * nearClip * farClip) * diff);
+    f->projection.data[2] =
+        V(0.0f, 0.0f, (nearClip + farClip) * diff,
+          (2.0f * nearClip * farClip) * diff);
     f->projection.data[3] = V(0.0f, 0.0f, -1.0f, 0.0f);
 }
 
@@ -23,9 +24,9 @@ const Matrix* updateProjection(Frustum* f, const IntVector2* size) {
     return &f->projection;
 }
 
-void updateFrustumPlanes(Frustum* f, const Vector3* pos, const Vector3* right,
-                         const Vector3* up, const Vector3* front,
-                         const IntVector2* size) {
+void updateFrustumPlanes(
+    Frustum* f, const Vector3* pos, const Vector3* right, const Vector3* up,
+    const Vector3* front, const IntVector2* size) {
     float aspect = (float)size->x / (float)size->y;
 
     float hNearHeight = f->tan * f->nearClip;

src/HashMap.c

@@ -3,7 +3,7 @@
 size_t hashString(const char* key) {
     size_t h = 0;
     while(*key != '\0') {
-        h = 2120251889lu * h + (size_t)(*(key++));
+        h = 2'120'251'889lu * h + (size_t)(*(key++));
     }
     return h;
 }

src/Logger.c

@@ -15,8 +15,9 @@ const char* getShortFileName(const char* s) {
     return r;
 }
 
-void printLog(LogLevel l, const char* file, int line, const char* prefix,
-              const char* tag, const char* format, ...) {
+void printLog(
+    LogLevel l, const char* file, int line, const char* prefix, const char* tag,
+    const char* format, ...) {
     if(logLevel < l) {
         return;
     }

src/Plane.c

@@ -14,7 +14,7 @@ float signedDistance(const Plane* p, const Vector3* v) {
 }
 
 size_t toStringPlane(const Plane* p, char* buffer, size_t n) {
-    return toString(buffer, n, "(%.3f x + %.3f y + %.3f z + %.3f)",
-                    (double)p->abc.x, (double)p->abc.y, (double)p->abc.z,
-                    (double)p->d);
+    return toString(
+        buffer, n, "(%.3f x + %.3f y + %.3f z + %.3f)", (double)p->abc.x,
+        (double)p->abc.y, (double)p->abc.z, (double)p->d);
 }

src/Quaternion.c

@@ -3,7 +3,9 @@
 #include "core/Generic.h"
 #include "core/ToString.h"
 
-Quaternion* axisAngleQ(Quaternion* q, const Vector3* axis, float angle) {
+typedef Quaternion Q;
+
+Q* axisAngleQ(Q* q, const Vector3* axis, float angle) {
     q->v.xyz = *axis;
     normalize(&q->v.xyz);
     angle *= 0.5f;
@@ -12,15 +14,14 @@ Quaternion* axisAngleQ(Quaternion* q, const Vector3* axis, float angle) {
     return q;
 }
 
-Quaternion* lerpQ(Quaternion* q, const Quaternion* a, float f,
-                  const Quaternion* b) {
+Q* lerpQ(Q* q, const Q* a, float f, const Q* b) {
     add(&q->v, mul(&a->v, 1.0f - f), mul(&b->v, f));
     float iLength = 1.0f / length(&q->v);
     mulSet(&q->v, iLength);
     return q;
 }
 
-Quaternion* mulSetQ(Quaternion* q, const Quaternion* o) {
+Q* mulSetQ(Q* q, const Q* o) {
     float dot = dot(&q->v.xyz, &o->v.xyz);
     add(&q->v.xyz, mul(&o->v.xyz, q->v.w),
         add(mul(&q->v.xyz, o->v.w), cross(&q->v.xyz, &o->v.xyz)));
@@ -28,13 +29,13 @@ Quaternion* mulSetQ(Quaternion* q, const Quaternion* o) {
     return q;
 }
 
-Quaternion* mulQ(Quaternion* q, const Quaternion* a, const Quaternion* b) {
+Q* mulQ(Q* q, const Q* a, const Q* b) {
     *q = *a;
     mulSetQ(q, b);
     return q;
 }
 
-Vector3* mulQV3(Vector3* r, const Quaternion* q, const Vector3* v) {
+Vector3* mulQV3(Vector3* r, const Q* q, const Vector3* v) {
     Vector3 qv;
     add(&qv, mul(v, q->v.w), cross(&q->v.xyz, v));
     add(r, mul(&q->v.xyz, dot(&q->v.xyz, v)),
@@ -42,8 +43,8 @@ Vector3* mulQV3(Vector3* r, const Quaternion* q, const Vector3* v) {
     return r;
 }
 
-size_t toStringQ(const Quaternion* q, char* buffer, size_t n) {
-    return toString(buffer, n, "(%.3f i + %.3f j + %.3f k + %.3f)",
-                    (double)q->v.x, (double)q->v.y, (double)q->v.z,
-                    (double)q->v.w);
+size_t toStringQ(const Q* q, char* buffer, size_t n) {
+    return toString(
+        buffer, n, "(%.3f i + %.3f j + %.3f k + %.3f)", (double)q->v.x,
+        (double)q->v.y, (double)q->v.z, (double)q->v.w);
 }

src/Random.c

@@ -11,7 +11,7 @@ void initRandom(Random* r, u32 seed) {
 }
 
 static void update(Random* r) {
-    static const u32 map[2] = {0, 0x8EBFD028};
+    static const u32 map[2] = {0, 0x8EBF'D028};
     static const size_t LENGTH = ARRAY_LENGTH(r->data);
     for(size_t i = 0; i < LENGTH - M; i++) {
         r->data[i] = r->data[i + M] ^ (r->data[i] >> 1) ^ map[r->data[i] & 1];
@@ -30,8 +30,8 @@ static u32 next(Random* r) {
         update(r);
     }
     u32 u = r->data[r->index++];
-    u ^= (u << 7) & 0x2B5B2500;
-    u ^= (u << 15) & 0xDB8B0000;
+    u ^= (u << 7) & 0x2B5B'2500;
+    u ^= (u << 15) & 0xDB8B'0000;
     u ^= (u >> 16);
     return u;
 }

src/ReadLine.c

@@ -155,8 +155,8 @@ static bool handleControlKey(char c) {
 }
 
 static void copyHistory() {
-    currentBuffer = history[(historyIndex - historyOffset + HISTORY_LENGTH) %
-                            HISTORY_LENGTH];
+    currentBuffer = history
+        [(historyIndex - historyOffset + HISTORY_LENGTH) % HISTORY_LENGTH];
     move = 0;
     cursorMove = 0;
 }
@@ -242,7 +242,7 @@ static int loop(void* data) {
     while(running) {
         handleChars();
         refreshLine("wusi> ");
-        struct timespec t = {.tv_nsec = 1000000};
+        struct timespec t = {.tv_nsec = 1'000'000};
         thrd_sleep(&t, nullptr);
     }
     return 0;
@@ -267,8 +267,9 @@ bool startReadLine(void) {
         LOG_ERROR("cannot init buffer mutex");
         stopReadLine();
         return true;
-    } else if(THREAD_INIT_FAIL ||
-              thrd_create(&readThread, loop, nullptr) != thrd_success) {
+    } else if(
+        THREAD_INIT_FAIL ||
+        thrd_create(&readThread, loop, nullptr) != thrd_success) {
         LOG_ERROR("cannot start read thread");
         stopReadLine();
         return true;

src/Test.c

@@ -42,8 +42,8 @@ void finalizeTests(void) {
         Result* r = results + i;
         bool c = r->successTests == r->tests;
         fputs(c ? TERMINAL_GREEN : TERMINAL_RED, stdout);
-        printf("%s - %d / %d tests succeeded", r->file, r->successTests,
-               r->tests);
+        printf(
+            "%s - %d / %d tests succeeded", r->file, r->successTests, r->tests);
         puts(TERMINAL_RESET);
         free(r->file);
     }
@@ -63,20 +63,21 @@ static bool addToResult(const char* file, bool comparison) {
     return false;
 }
 
-#define TEST_SUCCESS(result)                                                   \
-    file = getShortFileName(file);                                             \
-    if(addToResult(file, result)) {                                            \
-        return true;                                                           \
+#define TEST_SUCCESS(result)        \
+    file = getShortFileName(file);  \
+    if(addToResult(file, result)) { \
+        return true;                \
     }
 
-#define TEST_NAMED_COMPARE(name, type, format)                                 \
-    bool test##name(TEST_ARGS, type wanted, type actual) {                     \
-        TEST_SUCCESS(wanted == actual)                                         \
-        fputs(TERMINAL_RED, stdout);                                           \
-        printf("%s:%d - expected '" format "' got '" format "'", file, line,   \
-               wanted, actual);                                                \
-        puts(TERMINAL_RESET);                                                  \
-        return false;                                                          \
+#define TEST_NAMED_COMPARE(name, type, format)                            \
+    bool test##name(TEST_ARGS, type wanted, type actual) {                \
+        TEST_SUCCESS(wanted == actual)                                    \
+        fputs(TERMINAL_RED, stdout);                                      \
+        printf(                                                           \
+            "%s:%d - expected '" format "' got '" format "'", file, line, \
+            wanted, actual);                                              \
+        puts(TERMINAL_RESET);                                             \
+        return false;                                                     \
     }
 
 TEST_NAMED_COMPARE(Int, int, "%d")
@@ -98,8 +99,9 @@ bool testFloat(TEST_ARGS, float wanted, float actual, float error) {
     diff = diff < 0.0f ? -diff : diff;
     TEST_SUCCESS(diff <= error)
     fputs(TERMINAL_RED, stdout);
-    printf("%s:%d - expected '%.3f' got '%.3f'", file, line, (double)wanted,
-           (double)actual);
+    printf(
+        "%s:%d - expected '%.3f' got '%.3f'", file, line, (double)wanted,
+        (double)actual);
     puts(TERMINAL_RESET);
     return false;
 }
@@ -120,8 +122,8 @@ bool testNotNull(TEST_ARGS, const void* actual) {
     return false;
 }
 
-bool testVectorN(TEST_ARGS, const float* wanted, const float* actual,
-                 size_t n) {
+bool testVectorN(
+    TEST_ARGS, const float* wanted, const float* actual, size_t n) {
     for(size_t i = 0; i < n; i++) {
         if(!testFloat(file, line, wanted[i], actual[i], 0.01f)) {
             return false;

src/Utility.c

@@ -89,6 +89,7 @@ static const u8 CANARY[16] = {0xDE, 0xAD, 0xBE, 0xEF, 0xDE, 0xAD, 0xBE, 0xEF,
 
 struct MemoryInfo;
 typedef struct MemoryInfo MemoryInfo;
+
 struct MemoryInfo {
     MemoryInfo* next;
     MemoryInfo* previous;
@@ -97,11 +98,12 @@ struct MemoryInfo {
     char buffer[64 - 2 * sizeof(void*) - sizeof(size_t) - sizeof(int)];
     char canary[sizeof(CANARY)];
 };
+
 static_assert(sizeof(MemoryInfo) == 80, "memory info has invalid size");
 static MemoryInfo* headMemoryInfo = nullptr;
 
-static void addMemoryInfo(MemoryInfo* info, const char* file, int line,
-                          size_t n) {
+static void addMemoryInfo(
+    MemoryInfo* info, const char* file, int line, size_t n) {
     info->next = nullptr;
     info->previous = nullptr;
     info->size = n;

src/Vector.c

@@ -40,107 +40,107 @@ V3* cross(V3* r, const V3* a, const V3* b) {
 #define DOT_OP(i) length += a->data[i] * b->data[i];
 #define FLOAT_CAST_OP(i) r->data[i] = (float)a->data[i];
 #define INT_CAST_OP(i) r->data[i] = (int)a->data[i];
-#define DO2(OP)                                                                \
-    OP(0);                                                                     \
+#define DO2(OP) \
+    OP(0);      \
     OP(1)
-#define DO3(OP)                                                                \
-    DO2(OP);                                                                   \
+#define DO3(OP) \
+    DO2(OP);    \
     OP(2)
-#define DO4(OP)                                                                \
-    DO3(OP);                                                                   \
+#define DO4(OP) \
+    DO3(OP);    \
     OP(3)
 
-#define VECTOR_IMPL(T, N, FT)                                                  \
-    T* addSet##T(T* r, const T* a) {                                           \
-        return add##T(r, r, a);                                                \
-    }                                                                          \
-                                                                               \
-    T* add##T(T* r, const T* a, const T* b) {                                  \
-        DO##N(ADD_OP);                                                         \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    T* subSet##T(T* r, const T* a) {                                           \
-        return sub##T(r, r, a);                                                \
-    }                                                                          \
-                                                                               \
-    T* sub##T(T* r, const T* a, const T* b) {                                  \
-        DO##N(SUB_OP);                                                         \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    T* mulSet##T(T* r, const T* a) {                                           \
-        return mul##T(r, r, a);                                                \
-    }                                                                          \
-                                                                               \
-    T* mul##T(T* r, const T* a, const T* b) {                                  \
-        DO##N(MUL_OP);                                                         \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    T* divSet##T(T* r, const T* a) {                                           \
-        return div##T(r, r, a);                                                \
-    }                                                                          \
-                                                                               \
-    T* div##T(T* r, const T* a, const T* b) {                                  \
-        DO##N(DIV_OP);                                                         \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    T* mulSet##T##F(T* r, FT f) {                                              \
-        return mul##T##F(r, r, f);                                             \
-    }                                                                          \
-                                                                               \
-    T* mul##T##F(T* r, const T* a, FT f) {                                     \
-        DO##N(MUL_F_OP);                                                       \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    T* divSet##T##F(T* r, FT f) {                                              \
-        return div##T##F(r, r, f);                                             \
-    }                                                                          \
-                                                                               \
-    T* div##T##F(T* r, const T* a, FT f) {                                     \
-        DO##N(DIV_F_OP);                                                       \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    T* invertSet##T(T* r) {                                                    \
-        return invert##T(r, r);                                                \
-    }                                                                          \
-                                                                               \
-    T* invert##T(T* r, const T* a) {                                           \
-        DO##N(INVERT_OP);                                                      \
-        return r;                                                              \
+#define VECTOR_IMPL(T, N, FT)                 \
+    T* addSet##T(T* r, const T* a) {          \
+        return add##T(r, r, a);               \
+    }                                         \
+                                              \
+    T* add##T(T* r, const T* a, const T* b) { \
+        DO##N(ADD_OP);                        \
+        return r;                             \
+    }                                         \
+                                              \
+    T* subSet##T(T* r, const T* a) {          \
+        return sub##T(r, r, a);               \
+    }                                         \
+                                              \
+    T* sub##T(T* r, const T* a, const T* b) { \
+        DO##N(SUB_OP);                        \
+        return r;                             \
+    }                                         \
+                                              \
+    T* mulSet##T(T* r, const T* a) {          \
+        return mul##T(r, r, a);               \
+    }                                         \
+                                              \
+    T* mul##T(T* r, const T* a, const T* b) { \
+        DO##N(MUL_OP);                        \
+        return r;                             \
+    }                                         \
+                                              \
+    T* divSet##T(T* r, const T* a) {          \
+        return div##T(r, r, a);               \
+    }                                         \
+                                              \
+    T* div##T(T* r, const T* a, const T* b) { \
+        DO##N(DIV_OP);                        \
+        return r;                             \
+    }                                         \
+                                              \
+    T* mulSet##T##F(T* r, FT f) {             \
+        return mul##T##F(r, r, f);            \
+    }                                         \
+                                              \
+    T* mul##T##F(T* r, const T* a, FT f) {    \
+        DO##N(MUL_F_OP);                      \
+        return r;                             \
+    }                                         \
+                                              \
+    T* divSet##T##F(T* r, FT f) {             \
+        return div##T##F(r, r, f);            \
+    }                                         \
+                                              \
+    T* div##T##F(T* r, const T* a, FT f) {    \
+        DO##N(DIV_F_OP);                      \
+        return r;                             \
+    }                                         \
+                                              \
+    T* invertSet##T(T* r) {                   \
+        return invert##T(r, r);               \
+    }                                         \
+                                              \
+    T* invert##T(T* r, const T* a) {          \
+        DO##N(INVERT_OP);                     \
+        return r;                             \
     }
 
-#define VECTOR_IMPL_FLOAT(T, N, CN)                                            \
-    float dot##T(const T* a, const T* b) {                                     \
-        float length = 0;                                                      \
-        DO##N(DOT_OP);                                                         \
-        return length;                                                         \
-    }                                                                          \
-                                                                               \
-    float squareLength##T(const T* a) {                                        \
-        return dot##T(a, a);                                                   \
-    }                                                                          \
-                                                                               \
-    float length##T(const T* a) {                                              \
-        return sqrtf(squareLength##T(a));                                      \
-    }                                                                          \
-                                                                               \
-    T* normalize##T(T* r) {                                                    \
-        return mulSet##T##F(r, 1.0f / length##T(r));                           \
-    }                                                                          \
-                                                                               \
-    T* convertI##T(T* r, const CN* a) {                                        \
-        DO##N(FLOAT_CAST_OP);                                                  \
-        return r;                                                              \
-    }                                                                          \
-                                                                               \
-    CN* convert##T(CN* r, const T* a) {                                        \
-        DO##N(INT_CAST_OP);                                                    \
-        return r;                                                              \
+#define VECTOR_IMPL_FLOAT(T, N, CN)                  \
+    float dot##T(const T* a, const T* b) {           \
+        float length = 0;                            \
+        DO##N(DOT_OP);                               \
+        return length;                               \
+    }                                                \
+                                                     \
+    float squareLength##T(const T* a) {              \
+        return dot##T(a, a);                         \
+    }                                                \
+                                                     \
+    float length##T(const T* a) {                    \
+        return sqrtf(squareLength##T(a));            \
+    }                                                \
+                                                     \
+    T* normalize##T(T* r) {                          \
+        return mulSet##T##F(r, 1.0f / length##T(r)); \
+    }                                                \
+                                                     \
+    T* convertI##T(T* r, const CN* a) {              \
+        DO##N(FLOAT_CAST_OP);                        \
+        return r;                                    \
+    }                                                \
+                                                     \
+    CN* convert##T(CN* r, const T* a) {              \
+        DO##N(INT_CAST_OP);                          \
+        return r;                                    \
     }
 
 VECTOR_IMPL(V2, 2, float)
@@ -158,13 +158,15 @@ size_t toStringV2(const V2* a, char* buffer, size_t n) {
 }
 
 size_t toStringV3(const V3* a, char* buffer, size_t n) {
-    return toString(buffer, n, "[%.3f, %.3f, %.3f]", (double)a->x, (double)a->y,
-                    (double)a->z);
+    return toString(
+        buffer, n, "[%.3f, %.3f, %.3f]", (double)a->x, (double)a->y,
+        (double)a->z);
 }
 
 size_t toStringV4(const V4* a, char* buffer, size_t n) {
-    return toString(buffer, n, "[%.3f, %.3f, %.3f, %.3f]", (double)a->x,
-                    (double)a->y, (double)a->z, (double)a->w);
+    return toString(
+        buffer, n, "[%.3f, %.3f, %.3f, %.3f]", (double)a->x, (double)a->y,
+        (double)a->z, (double)a->w);
 }
 
 size_t toStringIV2(const IV2* a, char* buffer, size_t n) {

test/Main.c

@@ -67,7 +67,7 @@ int main(int argAmount, const char** args) {
     LOG_DEBUG("You won't see this!");
     logLevel = LOG_DEBUG;
 
-    unsigned int data = 123456789;
+    unsigned int data = 123'456'789;
     setExitHandler(onExit, &data);
 
     EXIT(1);

test/modules/BitArrayTests.c

@@ -34,7 +34,7 @@ static void testRandomSetReadResize() {
     u64 seed = 534;
     for(int k = 0; k < 20; k++) {
         for(u64 i = 0; i < bits.length; i++) {
-            seed = seed * 636455 + 53453;
+            seed = seed * 636'455 + 53'453;
             setBits(&bits, i, seed);
             data[i] = seed & 0x1FFF;
         }

test/modules/BufferTests.c

@@ -7,7 +7,7 @@ static const size_t SIZE_TYPES =
 void testBuffer(bool light) {
     Buffer buffer;
     initBuffer(&buffer);
-    size_t limit = light ? 1000 : 100000;
+    size_t limit = light ? 1000 : 100'000;
     for(size_t i = 0; i < limit; i++) {
         addTypedBufferData(&buffer, int, 5);
         addTypedBufferData(&buffer, long, 51);

test/modules/FrustumTests.c

@@ -15,8 +15,8 @@ static void testToString() {
 static void testPointIsInside() {
     Frustum f;
     initFrustum(&f, R60, 0.1f, 1000.0f);
-    updateFrustumPlanes(&f, &V(0, 0, 0), &V(1, 0, 0), &V(0, 1, 0), &V(0, 0, 1),
-                        &IV(200, 100));
+    updateFrustumPlanes(
+        &f, &V(0, 0, 0), &V(1, 0, 0), &V(0, 1, 0), &V(0, 0, 1), &IV(200, 100));
 
     TEST_TRUE(isInsideFrustum(&f, &V(0, 0, 5)));
     TEST_FALSE(isInsideFrustum(&f, &V(0, 0, 1004)));
@@ -31,8 +31,8 @@ static void testSphereIsInside() {
     IntVector2 size = {{200, 100}};
     Frustum f;
     initFrustum(&f, R60, 0.1f, 1000.0f);
-    updateFrustumPlanes(&f, &V(0, 0, 0), &V(1, 0, 0), &V(0, 1, 0), &V(0, 0, 1),
-                        &size);
+    updateFrustumPlanes(
+        &f, &V(0, 0, 0), &V(1, 0, 0), &V(0, 1, 0), &V(0, 0, 1), &size);
 
     TEST_TRUE(isInsideFrustumRadius(&f, &V(0, 0, 5), 3));
     TEST_FALSE(isInsideFrustumRadius(&f, &V(0, 0, 1004), 3));
@@ -57,11 +57,12 @@ static void testUpdateProjection() {
     const Matrix* m = updateProjection(&f, &IV(400, 300));
     char buffer[128];
     toStringMatrix(m, buffer, sizeof(buffer));
-    TEST_STRING("[[1.299, 0.000, 0.000, 0.000], "
-                "[0.000, 1.732, 0.000, 0.000], "
-                "[0.000, 0.000, -1.000, -0.200], "
-                "[0.000, 0.000, -1.000, 0.000]]",
-                buffer);
+    TEST_STRING(
+        "[[1.299, 0.000, 0.000, 0.000], "
+        "[0.000, 1.732, 0.000, 0.000], "
+        "[0.000, 0.000, -1.000, -0.200], "
+        "[0.000, 0.000, -1.000, 0.000]]",
+        buffer);
 }
 
 void testFrustum() {

test/modules/HashMapTests.c

@@ -116,7 +116,7 @@ static void testClearEmpty() {
 }
 
 static void testOverflow(bool light) {
-    size_t limit = light ? 10000 : 100000;
+    size_t limit = light ? 10'000 : 100'000;
     HashMapSize map = getTestSizeMap();
     for(size_t i = 0; i < limit; i++) {
         *putHashMapKeySize(&map, i) = i;
@@ -130,21 +130,21 @@ static void testOverflow(bool light) {
 static void testToString() {
     HashMapSize map = getTestSizeMap();
     char buffer[128];
-    size_t n = toStringHashMapSize(&map, buffer, sizeof(buffer), toStringSize,
-                                   toStringSize);
+    size_t n = toStringHashMapSize(
+        &map, buffer, sizeof(buffer), toStringSize, toStringSize);
     TEST_SIZE(29, n);
     TEST_STRING("[2 = 4, 1 = 3, 3 = 5, 0 = 20]", buffer);
 
     clearHashMapSize(&map);
     *putHashMapKeySize(&map, 1) = 3;
-    n = toStringHashMapSize(&map, buffer, sizeof(buffer), toStringSize,
-                            toStringSize);
+    n = toStringHashMapSize(
+        &map, buffer, sizeof(buffer), toStringSize, toStringSize);
     TEST_SIZE(7, n);
     TEST_STRING("[1 = 3]", buffer);
 
     clearHashMapSize(&map);
-    n = toStringHashMapSize(&map, buffer, sizeof(buffer), toStringSize,
-                            toStringSize);
+    n = toStringHashMapSize(
+        &map, buffer, sizeof(buffer), toStringSize, toStringSize);
     TEST_SIZE(2, n);
     TEST_STRING("[]", buffer);
 
@@ -176,8 +176,8 @@ static void testInvalidPut() {
     initHashMapSize(&map);
 
     char buffer[128];
-    toStringHashMapSize(&map, buffer, sizeof(buffer), toStringSize,
-                        toStringSize);
+    toStringHashMapSize(
+        &map, buffer, sizeof(buffer), toStringSize, toStringSize);
     TEST_STRING("[]", buffer);
 
     *putHashMapKeySize(&map, 0) = 3;
@@ -185,8 +185,8 @@ static void testInvalidPut() {
     if(TEST_NOT_NULL(v)) {
         TEST_SIZE(3, *v);
     }
-    toStringHashMapSize(&map, buffer, sizeof(buffer), toStringSize,
-                        toStringSize);
+    toStringHashMapSize(
+        &map, buffer, sizeof(buffer), toStringSize, toStringSize);
     TEST_STRING("[0 = 3]", buffer);
 
     clearHashMapSize(&map);

test/modules/ListTests.c

@@ -64,7 +64,7 @@ static void testClear() {
 }
 
 static void testBigAdd(bool light) {
-    size_t limit = light ? 10000 : 100000;
+    size_t limit = light ? 10'000 : 100'000;
     ListSize list;
     initListSize(&list);
     for(size_t i = 0; i < limit; i++) {

test/modules/MatrixTests.c

@@ -80,9 +80,10 @@ static void testTranslateTo() {
     }
     translateMatrixTo(&m, &V(6.0f, 8.0f, 9.0f));
     toStringMatrix(&m, buffer, sizeof(buffer));
-    TEST_STRING("[[1.000, 0.000, 0.000, 6.000], [0.000, 1.000, 0.000, 8.000], "
-                "[0.000, 0.000, 1.000, 9.000], [0.000, 0.000, 0.000, 1.000]]",
-                buffer);
+    TEST_STRING(
+        "[[1.000, 0.000, 0.000, 6.000], [0.000, 1.000, 0.000, 8.000], "
+        "[0.000, 0.000, 1.000, 9.000], [0.000, 0.000, 0.000, 1.000]]",
+        buffer);
 }
 
 static void testCombination() {

test/modules/RandomTests.c

@@ -2,7 +2,7 @@
 #include "core/Random.h"
 
 static void testAverage(bool light) {
-    int limit = light ? 100000 : 1000000;
+    int limit = light ? 100'000 : 1'000'000;
     Random r;
     initRandom(&r, 553);
     float sum = 0;
@@ -15,7 +15,7 @@ static void testAverage(bool light) {
 }
 
 static void testCoin(bool light) {
-    int limit = light ? 100000 : 1000000;
+    int limit = light ? 100'000 : 1'000'000;
     Random r;
     initRandom(&r, 5533);
     int c[2] = {0, 0};
@@ -26,7 +26,7 @@ static void testCoin(bool light) {
 }
 
 static void testDistribution(bool light) {
-    size_t limit = light ? 100000 : 1000000;
+    size_t limit = light ? 100'000 : 1'000'000;
     Random r;
     initRandom(&r, 553);
     int c[102] = {0};
@@ -41,7 +41,7 @@ static void testDistribution(bool light) {
 }
 
 static void testFloatAverage(bool light) {
-    int limit = light ? 100000 : 1000000;
+    int limit = light ? 100'000 : 1'000'000;
     Random r;
     initRandom(&r, 553);
     float sum = 0;
@@ -53,7 +53,7 @@ static void testFloatAverage(bool light) {
 }
 
 static void testFloatCoin(bool light) {
-    int limit = light ? 100000 : 1000000;
+    int limit = light ? 100'000 : 1'000'000;
     Random r;
     initRandom(&r, 5534);
     int c[2] = {0, 0};
@@ -64,7 +64,7 @@ static void testFloatCoin(bool light) {
 }
 
 static void testFloatDistribution(bool light) {
-    int limit = light ? 100000 : 1000000;
+    int limit = light ? 100'000 : 1'000'000;
     Random r;
     initRandom(&r, 553);
     int c[102] = {0};
@@ -80,9 +80,9 @@ static void testFloatDistribution(bool light) {
 
 static void testRandomI32() {
     Random r;
-    initRandom(&r, 56346);
+    initRandom(&r, 56'346);
     int c[7] = {0};
-    for(int i = 0; i < 10000; i++) {
+    for(int i = 0; i < 10'000; i++) {
         i32 index = randomI32(&r, -2, 3) + 3;
         if(TEST_TRUE(index >= 0 && index < 7)) {
             c[index]++;

test/modules/ReadLineTests.c

@@ -6,7 +6,7 @@
 #include "core/ReadLine.h"
 
 static void sleepMillis(int millis) {
-    struct timespec t = {.tv_nsec = millis * 1000000};
+    struct timespec t = {.tv_nsec = millis * 1'000'000};
     thrd_sleep(&t, nullptr);
 }
 

test/modules/SpinLockTests.c

@@ -13,7 +13,7 @@ typedef struct {
 
 static int incrementMutexCounter(void* p) {
     MutexCounter* mcp = (MutexCounter*)p;
-    for(int i = 0; i < 20000; i++) {
+    for(int i = 0; i < 20'000; i++) {
         mtx_lock(&mcp->m);
         mcp->counter++;
         mtx_unlock(&mcp->m);
@@ -31,7 +31,7 @@ static void testMutex() {
     thrd_create(t + 1, incrementMutexCounter, &mc);
     thrd_join(t[0], nullptr);
     thrd_join(t[1], nullptr);
-    TEST_INT(40000, mc.counter);
+    TEST_INT(40'000, mc.counter);
 
     n += getNanos();
     printf("%" PRId64 "ns Mutex\n", n);
@@ -44,7 +44,7 @@ typedef struct {
 
 static int incrementSpinLockCounter(void* p) {
     SpinLockCounter* mcp = (SpinLockCounter*)p;
-    for(int i = 0; i < 20000; i++) {
+    for(int i = 0; i < 20'000; i++) {
         lockSpinLock(&mcp->s);
         mcp->counter++;
         unlockSpinLock(&mcp->s);
@@ -62,7 +62,7 @@ static void testSpinLockLoop() {
     thrd_create(t + 1, incrementSpinLockCounter, &sc);
     thrd_join(t[0], nullptr);
     thrd_join(t[1], nullptr);
-    TEST_INT(40000, sc.counter);
+    TEST_INT(40'000, sc.counter);
 
     n += getNanos();
     printf("%" PRId64 "ns SpinLock\n", n);

test/modules/UtilityTests.c

@@ -10,9 +10,9 @@ static void testPopCount() {
     TEST_U64(2, popCount(0x6));
     TEST_U64(7, popCount(0x7F));
     TEST_U64(3, popCount(0x2A));
-    TEST_U64(32, popCount(0xFFFFFFFF));
-    TEST_U64(64, popCount(0xFFFFFFFFFFFFFFFF));
-    TEST_U64(44, popCount(0xFFFF0FFFFFFF));
+    TEST_U64(32, popCount(0xFFFF'FFFF));
+    TEST_U64(64, popCount(0xFFFF'FFFF'FFFF'FFFF));
+    TEST_U64(44, popCount(0xFFFF'0FFF'FFFF));
 }
 
 static void testZeroRellocate() {
@@ -132,7 +132,7 @@ static void outOfMemory(void*) {
 
 void testInvalidAllocate(void) {
     setOutOfMemoryHandler(outOfMemory, nullptr);
-    coreAllocate(0xFFFFFFFFFFF);
+    coreAllocate(0xFFF'FFFF'FFFF);
     TEST_TRUE(false);
     finalizeTests();
     EXIT(0);
@@ -142,7 +142,7 @@ void testInvalidReallocate(void) {
     setOutOfMemoryHandler(outOfMemory, nullptr);
     void* p = coreAllocate(0xFF);
     printMemoryReport();
-    coreReallocate(p, 0xFFFFFFFFFFF);
+    coreReallocate(p, 0xFFF'FFFF'FFFF);
     TEST_TRUE(false);
     finalizeTests();
     EXIT(0);

test/modules/VectorTests.c

@@ -88,13 +88,13 @@ static void testCross() {
 }
 
 static void testSetAdd() {
-#define X(T)                                                                   \
-    {                                                                          \
-        T v = *C##T(0, 0, 0, 0);                                               \
-        addSet(&v, C##T(1, 2, 3, 4));                                          \
-        TEST_##T(C##T(1, 2, 3, 4), &v);                                        \
-        addSet(&v, C##T(2, 3, 4, 5));                                          \
-        TEST_##T(C##T(3, 5, 7, 9), &v);                                        \
+#define X(T)                            \
+    {                                   \
+        T v = *C##T(0, 0, 0, 0);        \
+        addSet(&v, C##T(1, 2, 3, 4));   \
+        TEST_##T(C##T(1, 2, 3, 4), &v); \
+        addSet(&v, C##T(2, 3, 4, 5));   \
+        TEST_##T(C##T(3, 5, 7, 9), &v); \
     }
     TESTS
 #undef X
@@ -106,13 +106,13 @@ static void testAdd() {
 }
 
 static void testSetSub() {
-#define X(T)                                                                   \
-    {                                                                          \
-        T v = *C##T(0, 0, 0, 0);                                               \
-        subSet(&v, C##T(1, 2, 3, 4));                                          \
-        TEST_##T(C##T(-1, -2, -3, -4), &v);                                    \
-        subSet(&v, C##T(2, 3, 4, 5));                                          \
-        TEST_##T(C##T(-3, -5, -7, -9), &v);                                    \
+#define X(T)                                \
+    {                                       \
+        T v = *C##T(0, 0, 0, 0);            \
+        subSet(&v, C##T(1, 2, 3, 4));       \
+        TEST_##T(C##T(-1, -2, -3, -4), &v); \
+        subSet(&v, C##T(2, 3, 4, 5));       \
+        TEST_##T(C##T(-3, -5, -7, -9), &v); \
     }
     TESTS
 #undef X
@@ -124,13 +124,13 @@ static void testSub() {
 }
 
 static void testSetMul() {
-#define X(T)                                                                   \
-    {                                                                          \
-        T v = *C##T(1, 2, 3, 4);                                               \
-        mulSet(&v, 3);                                                         \
-        TEST_##T(C##T(3, 6, 9, 12), &v);                                       \
-        mulSet(&v, -2);                                                        \
-        TEST_##T(C##T(-6, -12, -18, -24), &v);                                 \
+#define X(T)                                   \
+    {                                          \
+        T v = *C##T(1, 2, 3, 4);               \
+        mulSet(&v, 3);                         \
+        TEST_##T(C##T(3, 6, 9, 12), &v);       \
+        mulSet(&v, -2);                        \
+        TEST_##T(C##T(-6, -12, -18, -24), &v); \
     }
     TESTS
 #undef X
@@ -141,13 +141,13 @@ static void testMul() {
 }
 
 static void testSetMulVector() {
-#define X(T)                                                                   \
-    {                                                                          \
-        T v = *C##T(1, 2, 3, 4);                                               \
-        mulSet(&v, C##T(2, 1, 3, 4));                                          \
-        TEST_##T(C##T(2, 2, 9, 16), &v);                                       \
-        mulSet(&v, C##T(-3, 4, -2, -2));                                       \
-        TEST_##T(C##T(-6, 8, -18, -32), &v);                                   \
+#define X(T)                                 \
+    {                                        \
+        T v = *C##T(1, 2, 3, 4);             \
+        mulSet(&v, C##T(2, 1, 3, 4));        \
+        TEST_##T(C##T(2, 2, 9, 16), &v);     \
+        mulSet(&v, C##T(-3, 4, -2, -2));     \
+        TEST_##T(C##T(-6, 8, -18, -32), &v); \
     }
     TESTS
 #undef X
@@ -159,13 +159,13 @@ static void testMulVector() {
 }
 
 static void testSetDiv() {
-#define X(T)                                                                   \
-    {                                                                          \
-        T v = *C##T(18, 36, 9, 27);                                            \
-        divSet(&v, 3);                                                         \
-        TEST_##T(C##T(6, 12, 3, 9), &v);                                       \
-        divSet(&v, -3);                                                        \
-        TEST_##T(C##T(-2, -4, -1, -3), &v);                                    \
+#define X(T)                                \
+    {                                       \
+        T v = *C##T(18, 36, 9, 27);         \
+        divSet(&v, 3);                      \
+        TEST_##T(C##T(6, 12, 3, 9), &v);    \
+        divSet(&v, -3);                     \
+        TEST_##T(C##T(-2, -4, -1, -3), &v); \
     }
     TESTS
 #undef X
@@ -176,13 +176,13 @@ static void testDiv() {
 }
 
 static void testSetDivVector() {
-#define X(T)                                                                   \
-    {                                                                          \
-        T v = *C##T(12, 4, 6, 8);                                              \
-        divSet(&v, C##T(2, 1, 3, 4));                                          \
-        TEST_##T(C##T(6, 4, 2, 2), &v);                                        \
-        divSet(&v, C##T(-3, 4, -2, -1));                                       \
-        TEST_##T(C##T(-2, 1, -1, -2), &v);                                     \
+#define X(T)                               \
+    {                                      \
+        T v = *C##T(12, 4, 6, 8);          \
+        divSet(&v, C##T(2, 1, 3, 4));      \
+        TEST_##T(C##T(6, 4, 2, 2), &v);    \
+        divSet(&v, C##T(-3, 4, -2, -1));   \
+        TEST_##T(C##T(-2, 1, -1, -2), &v); \
     }
     TESTS
 #undef X

test/modules/ViewTests.c

@@ -33,11 +33,12 @@ static void testUpdateMatrix() {
     char buffer[128];
     toStringMatrix(m, buffer, sizeof(buffer));
 
-    TEST_STRING("[[0.000, 0.000, 0.000, -0.000], "
-                "[0.000, 0.000, 0.000, -0.000], "
-                "[0.000, 0.000, 0.000, -0.000], "
-                "[0.000, 0.000, 0.000, 1.000]]",
-                buffer);
+    TEST_STRING(
+        "[[0.000, 0.000, 0.000, -0.000], "
+        "[0.000, 0.000, 0.000, -0.000], "
+        "[0.000, 0.000, 0.000, -0.000], "
+        "[0.000, 0.000, 0.000, 1.000]]",
+        buffer);
 }
 
 void testView() {