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
```

src/common/impl/binary_linux.c

@@ -2,12 +2,12 @@
 
 #if defined(FF_HAVE_ELF) || defined(__sun) || (defined(__FreeBSD__) && !defined(__DragonFly__)) || defined(__OpenBSD__) || defined(__NetBSD__)
 
-#include "common/io.h"
-#include "common/library.h"
-#include "common/stringUtils.h"
+#    include "common/io.h"
+#    include "common/library.h"
+#    include "common/stringUtils.h"
 
-#include <libelf.h> // #1254
-#include <fcntl.h>
+#    include <libelf.h> // #1254
+#    include <fcntl.h>
 
 /**
  * Structure to hold dynamically loaded libelf function pointers
@@ -36,15 +36,15 @@ struct FFElfData {
  *
  * The function supports both 32-bit and 64-bit ELF formats.
  */
-const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength)
-{
+const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
     // Initialize libelf if not already done
-    if (!elfData.inited)
-    {
+    if (!elfData.inited) {
         elfData.inited = true;
         FF_LIBRARY_LOAD_MESSAGE(libelf, "libelf" FF_LIBRARY_EXTENSION, 1);
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_version)
-        if (elfData.ffelf_version(EV_CURRENT) == EV_NONE) return "elf_version() failed";
+        if (elfData.ffelf_version(EV_CURRENT) == EV_NONE) {
+            return "elf_version() failed";
+        }
 
         // Load all required libelf functions
         FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libelf, elfData, elf_begin)
@@ -59,56 +59,69 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
         libelf = NULL;
     }
 
-    if (elfData.ffelf_end == NULL)
+    if (elfData.ffelf_end == NULL) {
         return "load libelf failed";
+    }
 
     // Open the ELF file
     FF_AUTO_CLOSE_FD int fd = open(elfFile, O_RDONLY | O_CLOEXEC);
-    if (fd < 0) return "open() failed";
+    if (fd < 0) {
+        return "open() failed";
+    }
 
     Elf* elf = elfData.ffelf_begin(fd, ELF_C_READ, NULL);
-    if (elf == NULL) return "elf_begin() failed";
+    if (elf == NULL) {
+        return "elf_begin() failed";
+    }
 
     // Get the section header string table index
     size_t shstrndx = 0;
-    if (elfData.ffelf_getshdrstrndx(elf, &shstrndx) < 0)
-    {
+    if (elfData.ffelf_getshdrstrndx(elf, &shstrndx) < 0) {
         elfData.ffelf_end(elf);
         return "elf_getshdrstrndx() failed";
     }
 
     // Iterate through all sections, looking for .rodata which contains string literals
     Elf_Scn* scn = NULL;
-    while ((scn = elfData.ffelf_nextscn(elf, scn)) != NULL)
-    {
+    while ((scn = elfData.ffelf_nextscn(elf, scn)) != NULL) {
         // Try 64-bit section header first, then 32-bit if that fails
         Elf64_Shdr* shdr64 = elfData.ffelf64_getshdr(scn);
         Elf32_Shdr* shdr32 = NULL;
-        if (shdr64 == NULL)
-        {
+        if (shdr64 == NULL) {
             shdr32 = elfData.ffelf32_getshdr(scn);
-            if (shdr32 == NULL) continue;
+            if (shdr32 == NULL) {
+                continue;
+            }
         }
 
         // Get the section name and check if it's .rodata
         const char* name = elfData.ffelf_strptr(elf, shstrndx, shdr64 ? shdr64->sh_name : shdr32->sh_name);
-        if (name == NULL || !ffStrEquals(name, ".rodata")) continue;
+        if (name == NULL || !ffStrEquals(name, ".rodata")) {
+            continue;
+        }
 
         // Get the section data
         Elf_Data* data = elfData.ffelf_getdata(scn, NULL);
-        if (data == NULL) continue;
+        if (data == NULL) {
+            continue;
+        }
 
         // Scan the section for string literals
-        for (size_t off = 0; off < data->d_size; ++off)
-        {
+        for (size_t off = 0; off < data->d_size; ++off) {
             const char* p = (const char*) data->d_buf + off;
-            if (*p == '\0') continue;
+            if (*p == '\0') {
+                continue;
+            }
             uint32_t len = (uint32_t) strlen(p);
-            if (len < minLength) continue;
+            if (len < minLength) {
+                continue;
+            }
             // Only process printable ASCII characters
             if (*p >= ' ' && *p <= '~') // Ignore control characters
             {
-                if (!cb(p, len, userdata)) break;
+                if (!cb(p, len, userdata)) {
+                    break;
+                }
             }
             off += len;
         }
@@ -125,8 +138,7 @@ const char* ffBinaryExtractStrings(const char* elfFile, bool (*cb)(const char* s
 /**
  * Fallback implementation when libelf is not available
  */
-const char* ffBinaryExtractStrings(const char* file, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength)
-{
+const char* ffBinaryExtractStrings(const char* file, bool (*cb)(const char* str, uint32_t len, void* userdata), void* userdata, uint32_t minLength) {
     FF_UNUSED(file, cb, userdata, minLength);
     return "Fastfetch was built without libelf support";
 }