Chore: run clang-format

```bash
find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.cpp" -o -name "*.hpp" \) ! -path "src/3rdparty/*" -print0 | xargs -0 clang-format -i
```

Author: CarterLi

src/common/FFPlatform.h

@@ -3,17 +3,15 @@
 #include "common/FFstrbuf.h"
 #include "common/FFlist.h"
 
-typedef struct FFPlatformSysinfo
-{
+typedef struct FFPlatformSysinfo {
     FFstrbuf name;
     FFstrbuf release;
     FFstrbuf version;
     FFstrbuf architecture;
     uint32_t pageSize;
 } FFPlatformSysinfo;
 
-typedef struct FFPlatform
-{
+typedef struct FFPlatform {
     FFstrbuf homeDir;  // Trailing slash included
     FFstrbuf cacheDir; // Trailing slash included
     FFlist configDirs; // List of FFstrbuf, trailing slash included
@@ -22,11 +20,11 @@ typedef struct FFPlatform
     FFstrbuf cwd;      // Trailing slash included
 
     uint32_t pid;
-    #ifndef _WIN32
+#ifndef _WIN32
     uint32_t uid;
-    #else
+#else
     FFstrbuf sid;
-    #endif
+#endif
     FFstrbuf userName;
     FFstrbuf fullUserName;
     FFstrbuf hostName;

src/common/FFcheckmacros.h

@@ -1,37 +1,37 @@
 #pragma once
 
 #ifdef _MSC_VER
-    #include <sal.h>
+#    include <sal.h>
 #endif
 
 #if defined(__has_attribute) && __has_attribute(__warn_unused_result__)
-    #define FF_C_NODISCARD __attribute__((__warn_unused_result__))
+#    define FF_C_NODISCARD __attribute__((__warn_unused_result__))
 #elif defined(_MSC_VER)
-    #define FF_C_NODISCARD _Check_return_
+#    define FF_C_NODISCARD _Check_return_
 #else
-    #define FF_C_NODISCARD
+#    define FF_C_NODISCARD
 #endif
 
 #if defined(__has_attribute) && __has_attribute(__format__)
-    #define FF_C_PRINTF(formatStrIndex, argsStartIndex) __attribute__((__format__ (printf, formatStrIndex, argsStartIndex)))
+#    define FF_C_PRINTF(formatStrIndex, argsStartIndex) __attribute__((__format__(printf, formatStrIndex, argsStartIndex)))
 #else
-    #define FF_C_PRINTF(formatStrIndex, argsStartIndex)
+#    define FF_C_PRINTF(formatStrIndex, argsStartIndex)
 #endif
 
 #if defined(__has_attribute) && __has_attribute(__format__)
-    #define FF_C_SCANF(formatStrIndex, argsStartIndex) __attribute__((__format__ (scanf, formatStrIndex, argsStartIndex)))
+#    define FF_C_SCANF(formatStrIndex, argsStartIndex) __attribute__((__format__(scanf, formatStrIndex, argsStartIndex)))
 #else
-    #define FF_C_SCANF(formatStrIndex, argsStartIndex)
+#    define FF_C_SCANF(formatStrIndex, argsStartIndex)
 #endif
 
 #if defined(__has_attribute) && __has_attribute(__nonnull__)
-    #define FF_C_NONNULL(argIndex, ...) __attribute__((__nonnull__(argIndex, ##__VA_ARGS__)))
+#    define FF_C_NONNULL(argIndex, ...) __attribute__((__nonnull__(argIndex, ##__VA_ARGS__)))
 #else
-    #define FF_C_NONNULL(argIndex, ...)
+#    define FF_C_NONNULL(argIndex, ...)
 #endif
 
 #if defined(__has_attribute) && __has_attribute(__returns_nonnull__)
-    #define FF_C_RETURNS_NONNULL __attribute__((__returns_nonnull__))
+#    define FF_C_RETURNS_NONNULL __attribute__((__returns_nonnull__))
 #else
-    #define FF_C_RETURNS_NONNULL
+#    define FF_C_RETURNS_NONNULL
 #endif

src/common/FFlist.h

@@ -9,8 +9,7 @@
 
 #define FF_LIST_DEFAULT_ALLOC 16
 
-typedef struct FFlist
-{
+typedef struct FFlist {
     uint8_t* data;
     uint32_t elementSize;
     uint32_t length;
@@ -24,121 +23,110 @@ bool ffListShift(FFlist* list, void* result);
 // Removes the last element, and copy its value to `*result`
 bool ffListPop(FFlist* list, void* result);
 
-static inline void ffListInit(FFlist* list, uint32_t elementSize)
-{
+static inline void ffListInit(FFlist* list, uint32_t elementSize) {
     assert(elementSize > 0);
     list->elementSize = elementSize;
     list->capacity = 0;
     list->length = 0;
     list->data = NULL;
 }
 
-static inline void ffListInitA(FFlist* list, uint32_t elementSize, uint32_t capacity)
-{
+static inline void ffListInitA(FFlist* list, uint32_t elementSize, uint32_t capacity) {
     ffListInit(list, elementSize);
     list->capacity = capacity;
-    list->data = __builtin_expect(capacity == 0, 0) ? NULL : (uint8_t*) malloc((size_t)list->capacity * list->elementSize);
+    list->data = __builtin_expect(capacity == 0, 0) ? NULL : (uint8_t*) malloc((size_t) list->capacity * list->elementSize);
 }
 
-static inline FFlist ffListCreate(uint32_t elementSize)
-{
+static inline FFlist ffListCreate(uint32_t elementSize) {
     FFlist result;
     ffListInit(&result, elementSize);
     return result;
 }
 
-static inline void* ffListGet(const FFlist* list, uint32_t index)
-{
+static inline void* ffListGet(const FFlist* list, uint32_t index) {
     assert(list->capacity > index);
     return list->data + (index * list->elementSize);
 }
 
-FF_C_NODISCARD static inline uint32_t ffListFirstIndexComp(const FFlist* list, void* compElement, bool(*compFunc)(const void*, const void*))
-{
-    for(uint32_t i = 0; i < list->length; i++)
-    {
-        if(compFunc(ffListGet(list, i), compElement))
+FF_C_NODISCARD static inline uint32_t ffListFirstIndexComp(const FFlist* list, void* compElement, bool (*compFunc)(const void*, const void*)) {
+    for (uint32_t i = 0; i < list->length; i++) {
+        if (compFunc(ffListGet(list, i), compElement)) {
             return i;
+        }
     }
 
     return list->length;
 }
 
-static inline bool ffListContains(const FFlist* list, void* compElement, bool(*compFunc)(const void*, const void*))
-{
+static inline bool ffListContains(const FFlist* list, void* compElement, bool (*compFunc)(const void*, const void*)) {
     return ffListFirstIndexComp(list, compElement, compFunc) != list->length;
 }
 
-static inline void ffListSort(FFlist* list, int(*compar)(const void*, const void*))
-{
+static inline void ffListSort(FFlist* list, int (*compar)(const void*, const void*)) {
     qsort(list->data, list->length, list->elementSize, compar);
 }
 
 // Move the contents of `src` into `list`, and left `src` empty
-static inline void ffListInitMove(FFlist* list, FFlist* src)
-{
-    if (src)
-    {
+static inline void ffListInitMove(FFlist* list, FFlist* src) {
+    if (src) {
         list->elementSize = src->elementSize;
         list->capacity = src->capacity;
         list->length = src->length;
         list->data = src->data;
         ffListInit(src, list->elementSize);
-    }
-    else
-    {
+    } else {
         ffListInit(list, 0);
     }
 }
 
-static inline void ffListDestroy(FFlist* list)
-{
-    if (!list->data) return;
+static inline void ffListDestroy(FFlist* list) {
+    if (!list->data) {
+        return;
+    }
 
-    //Avoid free-after-use. These 3 assignments are cheap so don't remove them
+    // Avoid free-after-use. These 3 assignments are cheap so don't remove them
     list->capacity = list->length = 0;
     free(list->data);
     list->data = NULL;
 }
 
-static inline void ffListClear(FFlist* list)
-{
+static inline void ffListClear(FFlist* list) {
     list->length = 0;
 }
 
-static inline void ffListReserve(FFlist* list, uint32_t newCapacity)
-{
-    if (__builtin_expect(newCapacity <= list->capacity, false))
+static inline void ffListReserve(FFlist* list, uint32_t newCapacity) {
+    if (__builtin_expect(newCapacity <= list->capacity, false)) {
         return;
+    }
 
     list->data = (uint8_t*) realloc(list->data, (size_t) newCapacity * list->elementSize);
     list->capacity = newCapacity;
 }
 
-#define FF_LIST_FOR_EACH(itemType, itemVarName, listVar) \
-    assert(sizeof(itemType) == (listVar).elementSize); \
-    for(itemType* itemVarName = (itemType*)(listVar).data; \
-        itemVarName - (itemType*)(listVar).data < (intptr_t)(listVar).length; \
+#define FF_LIST_FOR_EACH(itemType, itemVarName, listVar)                        \
+    assert(sizeof(itemType) == (listVar).elementSize);                          \
+    for (itemType* itemVarName = (itemType*) (listVar).data;                    \
+        itemVarName - (itemType*) (listVar).data < (intptr_t) (listVar).length; \
         ++itemVarName)
 
 #define FF_LIST_AUTO_DESTROY FFlist __attribute__((__cleanup__(ffListDestroy)))
 
-#define FF_LIST_GET(itemType, listVar, index) \
-    ({ \
+#define FF_LIST_GET(itemType, listVar, index)              \
+    ({                                                     \
         assert(sizeof(itemType) == (listVar).elementSize); \
-        assert((listVar).capacity > (index)); \
-        (itemType*)(listVar).data + (index); \
+        assert((listVar).capacity > (index));              \
+        (itemType*) (listVar).data + (index);              \
     })
 
-#define FF_LIST_ADD(itemType, listVar) \
-    ({ \
+#define FF_LIST_ADD(itemType, listVar)                     \
+    ({                                                     \
         assert(sizeof(itemType) == (listVar).elementSize); \
-        (itemType*) ffListAdd(&(listVar)); \
+        (itemType*) ffListAdd(&(listVar));                 \
     })
 
 #define FF_LIST_FIRST(itemType, listVar) FF_LIST_GET(itemType, listVar, 0)
-#define FF_LIST_LAST(itemType, listVar) \
-    ({ \
-        assert((listVar).length > 0); \
+#define FF_LIST_LAST(itemType, listVar)                         \
+    ({                                                          \
+        assert((listVar).length > 0);                           \
         FF_LIST_GET(itemType, listVar, ((listVar).length - 1)); \
     })