Global: make FFinstance instance a global variable

As discussed in https://github.com/fastfetch-cli/fastfetch/discussions/473

src/common/bar.c

@@ -3,7 +3,7 @@
 
 // green, yellow, red: print the color on nth (0~9) block
 // set its value == 10 means the color will not be printed
-void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red)
+void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red)
 {
     assert(green <= 10 && yellow <= 10 && red <= 10);
 
@@ -15,14 +15,14 @@ void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
     percent = (uint8_t)(percent + 5) / 10;
     assert(percent <= 10);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         ffStrbufAppendS(buffer, "\033[97m[ ");
     else
         ffStrbufAppendS(buffer, "[ ");
 
     for (uint8_t i = 0; i < percent; ++i)
     {
-        if(!instance->config.pipe)
+        if(!instance.config.pipe)
         {
             if (i == green)
                 ffStrbufAppendS(buffer, "\033[32m");
@@ -36,13 +36,13 @@ void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
 
     if (percent < 10)
     {
-        if(!instance->config.pipe)
+        if(!instance.config.pipe)
             ffStrbufAppendS(buffer, "\033[97m");
         for (uint8_t i = percent; i < 10; ++i)
             ffStrbufAppendS(buffer, "-");
     }
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         ffStrbufAppendS(buffer, "\033[97m ]" FASTFETCH_TEXT_MODIFIER_RESET);
     else
         ffStrbufAppendS(buffer, " ]");
@@ -57,16 +57,16 @@ void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
 // [green, 100]: print green
 // [yellow, green): print yellow
 // [0, yellow): PRINT RED
-void ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses)
+void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses)
 {
     assert(green <= 100 && yellow <= 100);
 
-    bool colored = !!(instance->config.percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
+    bool colored = !!(instance.config.percentType & FF_PERCENTAGE_TYPE_NUM_COLOR_BIT);
 
     if (parentheses)
         ffStrbufAppendC(buffer, '(');
 
-    if (colored && !instance->config.pipe)
+    if (colored && !instance.config.pipe)
     {
         if(green < yellow)
         {
@@ -89,7 +89,7 @@ void ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent,
     }
     ffStrbufAppendF(buffer, "%u%%", (unsigned) percent);
 
-    if (colored && !instance->config.pipe)
+    if (colored && !instance.config.pipe)
     {
         ffStrbufAppendS(buffer, FASTFETCH_TEXT_MODIFIER_RESET);
     }

src/common/bar.h

@@ -13,7 +13,7 @@ enum
     FF_PERCENTAGE_TYPE_NUM_COLOR_BIT = 1 << 3,
 };
 
-void ffAppendPercentBar(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red);
-void ffAppendPercentNum(FFinstance* instance, FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses);
+void ffAppendPercentBar(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, uint8_t red);
+void ffAppendPercentNum(FFstrbuf* buffer, uint8_t percent, uint8_t green, uint8_t yellow, bool parentheses);
 
 #endif

src/common/dbus.c

@@ -5,9 +5,9 @@
 #include "common/thread.h"
 #include "util/stringUtils.h"
 
-static bool loadLibSymbols(const FFinstance* instance, FFDBusLibrary* lib)
+static bool loadLibSymbols(FFDBusLibrary* lib)
 {
-    FF_LIBRARY_LOAD(dbus, &instance->config.libDBus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_LOAD(dbus, &instance.config.libDBus, false, "libdbus-1" FF_LIBRARY_EXTENSION, 4);
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_bus_get, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_new_method_call, false)
     FF_LIBRARY_LOAD_SYMBOL_PTR(dbus, lib, dbus_message_iter_init, false)
@@ -28,7 +28,7 @@ static bool loadLibSymbols(const FFinstance* instance, FFDBusLibrary* lib)
     return true;
 }
 
-static const FFDBusLibrary* loadLib(const FFinstance* instance)
+static const FFDBusLibrary* loadLib(void)
 {
     static FFDBusLibrary lib;
     static bool loaded = false;
@@ -40,16 +40,16 @@ static const FFDBusLibrary* loadLib(const FFinstance* instance)
     if(!loaded)
     {
         loaded = true;
-        loadSuccess = loadLibSymbols(instance, &lib);
+        loadSuccess = loadLibSymbols(&lib);
     }
 
     ffThreadMutexUnlock(&mutex);
     return loadSuccess ? &lib : NULL;
 }
 
-const char* ffDBusLoadData(const FFinstance* instance, DBusBusType busType, FFDBusData* data)
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data)
 {
-    data->lib = loadLib(instance);
+    data->lib = loadLib();
     if(data->lib == NULL)
         return "Failed to load DBus library";
 

src/common/dbus.h

@@ -45,7 +45,7 @@ typedef struct FFDBusData
     DBusConnection* connection;
 } FFDBusData;
 
-const char* ffDBusLoadData(const FFinstance* instance, DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
+const char* ffDBusLoadData(DBusBusType busType, FFDBusData* data); //Returns an error message or NULL on success
 bool ffDBusGetValue(FFDBusData* dbus, DBusMessageIter* iter, FFstrbuf* result);
 bool ffDBusGetBool(FFDBusData* dbus, DBusMessageIter* iter, bool* result);
 bool ffDBusGetByte(FFDBusData* dbus, DBusMessageIter* iter, uint8_t* result);

src/common/init.c

@@ -17,6 +17,8 @@
 
 #include "modules/modules.h"
 
+FFinstance instance; // Global singleton
+
 static void initState(FFstate* state)
 {
     state->logoWidth = 0;
@@ -28,119 +30,119 @@ static void initState(FFstate* state)
     state->configDoc = NULL;
 }
 
-static void defaultConfig(FFinstance* instance)
+static void defaultConfig(void)
 {
-    ffInitLogoOptions(&instance->config.logo);
+    ffInitLogoOptions(&instance.config.logo);
 
-    ffStrbufInit(&instance->config.colorKeys);
-    ffStrbufInit(&instance->config.colorTitle);
-    ffStrbufInitS(&instance->config.keyValueSeparator, ": ");
+    ffStrbufInit(&instance.config.colorKeys);
+    ffStrbufInit(&instance.config.colorTitle);
+    ffStrbufInitS(&instance.config.keyValueSeparator, ": ");
 
     #if defined(__linux__) || defined(__FreeBSD__)
-    ffStrbufInit(&instance->config.playerName);
-    ffStrbufInit(&instance->config.osFile);
+    ffStrbufInit(&instance.config.playerName);
+    ffStrbufInit(&instance.config.osFile);
     #endif
 
-    instance->config.showErrors = false;
-    instance->config.recache = false;
-    instance->config.allowSlowOperations = false;
-    instance->config.pipe = !isatty(STDOUT_FILENO);
-    instance->config.disableLinewrap = !instance->config.pipe;
-    instance->config.hideCursor = !instance->config.pipe;
-    instance->config.escapeBedrock = true;
-    instance->config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
-    instance->config.multithreading = true;
-    instance->config.stat = false;
-    instance->config.noBuffer = false;
+    instance.config.showErrors = false;
+    instance.config.recache = false;
+    instance.config.allowSlowOperations = false;
+    instance.config.pipe = !isatty(STDOUT_FILENO);
+    instance.config.disableLinewrap = !instance.config.pipe;
+    instance.config.hideCursor = !instance.config.pipe;
+    instance.config.escapeBedrock = true;
+    instance.config.binaryPrefixType = FF_BINARY_PREFIX_TYPE_IEC;
+    instance.config.multithreading = true;
+    instance.config.stat = false;
+    instance.config.noBuffer = false;
 
-    ffInitTitleOptions(&instance->config.title);
-    ffInitOSOptions(&instance->config.os);
-    ffInitHostOptions(&instance->config.host);
-    ffInitBiosOptions(&instance->config.bios);
-    ffInitBoardOptions(&instance->config.board);
-    ffInitBrightnessOptions(&instance->config.brightness);
-    ffInitChassisOptions(&instance->config.chassis);
-    ffInitCommandOptions(&instance->config.command);
-    ffInitCustomOptions(&instance->config.custom);
-    ffInitKernelOptions(&instance->config.kernel);
-    ffInitUptimeOptions(&instance->config.uptime);
-    ffInitProcessesOptions(&instance->config.processes);
-    ffInitPackagesOptions(&instance->config.packages);
-    ffInitShellOptions(&instance->config.shell);
-    ffInitDisplayOptions(&instance->config.display);
-    ffInitDEOptions(&instance->config.de);
-    ffInitWMOptions(&instance->config.wm);
-    ffInitWMThemeOptions(&instance->config.wmTheme);
-    ffInitThemeOptions(&instance->config.theme);
-    ffInitIconsOptions(&instance->config.icons);
-    ffInitFontOptions(&instance->config.font);
-    ffInitCursorOptions(&instance->config.cursor);
-    ffInitTerminalOptions(&instance->config.terminal);
-    ffInitTerminalFontOptions(&instance->config.terminalFont);
-    ffInitCPUOptions(&instance->config.cpu);
-    ffInitCPUUsageOptions(&instance->config.cpuUsage);
-    ffInitGPUOptions(&instance->config.gpu);
-    ffInitMemoryOptions(&instance->config.memory);
-    ffInitSwapOptions(&instance->config.swap);
-    ffInitDiskOptions(&instance->config.disk);
-    ffInitBatteryOptions(&instance->config.battery);
-    ffInitPowerAdapterOptions(&instance->config.powerAdapter);
-    ffInitLMOptions(&instance->config.lm);
-    ffInitLocaleOptions(&instance->config.locale);
-    ffInitLocalIpOptions(&instance->config.localIP);
-    ffInitPublicIpOptions(&instance->config.publicIP);
-    ffInitWeatherOptions(&instance->config.weather);
-    ffInitWifiOptions(&instance->config.wifi);
-    ffInitPlayerOptions(&instance->config.player);
-    ffInitMediaOptions(&instance->config.media);
-    ffInitDateTimeOptions(&instance->config.dateTime);
-    ffInitVulkanOptions(&instance->config.vulkan);
-    ffInitWallpaperOptions(&instance->config.wallpaper);
-    ffInitOpenGLOptions(&instance->config.openGL);
-    ffInitOpenCLOptions(&instance->config.openCL);
-    ffInitUsersOptions(&instance->config.users);
-    ffInitBluetoothOptions(&instance->config.bluetooth);
-    ffInitSoundOptions(&instance->config.sound);
-    ffInitSeparatorOptions(&instance->config.separator);
-    ffInitGamepadOptions(&instance->config.gamepad);
-    ffInitColorsOptions(&instance->config.colors);
+    ffInitTitleOptions(&instance.config.title);
+    ffInitOSOptions(&instance.config.os);
+    ffInitHostOptions(&instance.config.host);
+    ffInitBiosOptions(&instance.config.bios);
+    ffInitBoardOptions(&instance.config.board);
+    ffInitBrightnessOptions(&instance.config.brightness);
+    ffInitChassisOptions(&instance.config.chassis);
+    ffInitCommandOptions(&instance.config.command);
+    ffInitCustomOptions(&instance.config.custom);
+    ffInitKernelOptions(&instance.config.kernel);
+    ffInitUptimeOptions(&instance.config.uptime);
+    ffInitProcessesOptions(&instance.config.processes);
+    ffInitPackagesOptions(&instance.config.packages);
+    ffInitShellOptions(&instance.config.shell);
+    ffInitDisplayOptions(&instance.config.display);
+    ffInitDEOptions(&instance.config.de);
+    ffInitWMOptions(&instance.config.wm);
+    ffInitWMThemeOptions(&instance.config.wmTheme);
+    ffInitThemeOptions(&instance.config.theme);
+    ffInitIconsOptions(&instance.config.icons);
+    ffInitFontOptions(&instance.config.font);
+    ffInitCursorOptions(&instance.config.cursor);
+    ffInitTerminalOptions(&instance.config.terminal);
+    ffInitTerminalFontOptions(&instance.config.terminalFont);
+    ffInitCPUOptions(&instance.config.cpu);
+    ffInitCPUUsageOptions(&instance.config.cpuUsage);
+    ffInitGPUOptions(&instance.config.gpu);
+    ffInitMemoryOptions(&instance.config.memory);
+    ffInitSwapOptions(&instance.config.swap);
+    ffInitDiskOptions(&instance.config.disk);
+    ffInitBatteryOptions(&instance.config.battery);
+    ffInitPowerAdapterOptions(&instance.config.powerAdapter);
+    ffInitLMOptions(&instance.config.lm);
+    ffInitLocaleOptions(&instance.config.locale);
+    ffInitLocalIpOptions(&instance.config.localIP);
+    ffInitPublicIpOptions(&instance.config.publicIP);
+    ffInitWeatherOptions(&instance.config.weather);
+    ffInitWifiOptions(&instance.config.wifi);
+    ffInitPlayerOptions(&instance.config.player);
+    ffInitMediaOptions(&instance.config.media);
+    ffInitDateTimeOptions(&instance.config.dateTime);
+    ffInitVulkanOptions(&instance.config.vulkan);
+    ffInitWallpaperOptions(&instance.config.wallpaper);
+    ffInitOpenGLOptions(&instance.config.openGL);
+    ffInitOpenCLOptions(&instance.config.openCL);
+    ffInitUsersOptions(&instance.config.users);
+    ffInitBluetoothOptions(&instance.config.bluetooth);
+    ffInitSoundOptions(&instance.config.sound);
+    ffInitSeparatorOptions(&instance.config.separator);
+    ffInitGamepadOptions(&instance.config.gamepad);
+    ffInitColorsOptions(&instance.config.colors);
 
-    ffStrbufInit(&instance->config.libPCI);
-    ffStrbufInit(&instance->config.libVulkan);
-    ffStrbufInit(&instance->config.libWayland);
-    ffStrbufInit(&instance->config.libXcbRandr);
-    ffStrbufInit(&instance->config.libXcb);
-    ffStrbufInit(&instance->config.libXrandr);
-    ffStrbufInit(&instance->config.libX11);
-    ffStrbufInit(&instance->config.libGIO);
-    ffStrbufInit(&instance->config.libDConf);
-    ffStrbufInit(&instance->config.libDBus);
-    ffStrbufInit(&instance->config.libXFConf);
-    ffStrbufInit(&instance->config.libSQLite3);
-    ffStrbufInit(&instance->config.librpm);
-    ffStrbufInit(&instance->config.libImageMagick);
-    ffStrbufInit(&instance->config.libZ);
-    ffStrbufInit(&instance->config.libChafa);
-    ffStrbufInit(&instance->config.libEGL);
-    ffStrbufInit(&instance->config.libGLX);
-    ffStrbufInit(&instance->config.libOSMesa);
-    ffStrbufInit(&instance->config.libOpenCL);
-    ffStrbufInit(&instance->config.libfreetype);
-    ffStrbufInit(&instance->config.libPulse);
-    ffStrbufInit(&instance->config.libnm);
+    ffStrbufInit(&instance.config.libPCI);
+    ffStrbufInit(&instance.config.libVulkan);
+    ffStrbufInit(&instance.config.libWayland);
+    ffStrbufInit(&instance.config.libXcbRandr);
+    ffStrbufInit(&instance.config.libXcb);
+    ffStrbufInit(&instance.config.libXrandr);
+    ffStrbufInit(&instance.config.libX11);
+    ffStrbufInit(&instance.config.libGIO);
+    ffStrbufInit(&instance.config.libDConf);
+    ffStrbufInit(&instance.config.libDBus);
+    ffStrbufInit(&instance.config.libXFConf);
+    ffStrbufInit(&instance.config.libSQLite3);
+    ffStrbufInit(&instance.config.librpm);
+    ffStrbufInit(&instance.config.libImageMagick);
+    ffStrbufInit(&instance.config.libZ);
+    ffStrbufInit(&instance.config.libChafa);
+    ffStrbufInit(&instance.config.libEGL);
+    ffStrbufInit(&instance.config.libGLX);
+    ffStrbufInit(&instance.config.libOSMesa);
+    ffStrbufInit(&instance.config.libOpenCL);
+    ffStrbufInit(&instance.config.libfreetype);
+    ffStrbufInit(&instance.config.libPulse);
+    ffStrbufInit(&instance.config.libnm);
 
-    instance->config.percentType = 1;
+    instance.config.percentType = 1;
 }
 
-void ffInitInstance(FFinstance* instance)
+void ffInitInstance(void)
 {
     #ifdef WIN32
         //https://learn.microsoft.com/en-us/cpp/c-runtime-library/reference/setlocale-wsetlocale?source=recommendations&view=msvc-170#utf-8-support
         setlocale(LC_ALL, ".UTF8");
     #endif
 
-    initState(&instance->state);
-    defaultConfig(instance);
+    initState(&instance.state);
+    defaultConfig();
 }
 
 #if defined(FF_HAVE_THREADS) && !(defined(__APPLE__) || defined(_WIN32) || defined(__ANDROID__))
@@ -149,19 +151,19 @@ void ffInitInstance(FFinstance* instance)
 
 #define FF_START_DETECTION_THREADS
 
-FF_THREAD_ENTRY_DECL_WRAPPER(ffConnectDisplayServer, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectQt, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK2, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK3, FFinstance*)
-FF_THREAD_ENTRY_DECL_WRAPPER(ffDetectGTK4, FFinstance*)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffConnectDisplayServer)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectQt)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectGTK2)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectGTK3)
+FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(ffDetectGTK4)
 
-void startDetectionThreads(FFinstance* instance)
+void startDetectionThreads(void)
 {
-    ffThreadDetach(ffThreadCreate(ffConnectDisplayServerThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectQtThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK2ThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK3ThreadMain, instance));
-    ffThreadDetach(ffThreadCreate(ffDetectGTK4ThreadMain, instance));
+    ffThreadDetach(ffThreadCreate(ffConnectDisplayServerThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectQtThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK2ThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK3ThreadMain, NULL));
+    ffThreadDetach(ffThreadCreate(ffDetectGTK4ThreadMain, NULL));
 }
 
 #endif //FF_HAVE_THREADS
@@ -169,7 +171,7 @@ void startDetectionThreads(FFinstance* instance)
 static volatile bool ffDisableLinewrap = true;
 static volatile bool ffHideCursor = true;
 
-static void resetConsole()
+static void resetConsole(void)
 {
     if(ffDisableLinewrap)
         fputs("\033[?7h", stdout);
@@ -198,18 +200,18 @@ static void exitSignalHandler(int signal)
 }
 #endif
 
-void ffStart(FFinstance* instance)
+void ffStart(void)
 {
     #ifdef FF_START_DETECTION_THREADS
-        if(instance->config.multithreading)
-            startDetectionThreads(instance);
+        if(instance.config.multithreading)
+            startDetectionThreads();
     #endif
 
-    ffDisableLinewrap = instance->config.disableLinewrap && !instance->config.pipe;
-    ffHideCursor = instance->config.hideCursor && !instance->config.pipe;
+    ffDisableLinewrap = instance.config.disableLinewrap && !instance.config.pipe;
+    ffHideCursor = instance.config.hideCursor && !instance.config.pipe;
 
     #ifdef _WIN32
-    if (!instance->config.noBuffer) setvbuf(stdout, NULL, _IOFBF, 4096);
+    if (!instance.config.noBuffer) setvbuf(stdout, NULL, _IOFBF, 4096);
     SetConsoleCtrlHandler(consoleHandler, TRUE);
     HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
     DWORD mode = 0;
@@ -217,7 +219,7 @@ void ffStart(FFinstance* instance)
     SetConsoleMode(hStdout, mode | ENABLE_PROCESSED_OUTPUT | ENABLE_VIRTUAL_TERMINAL_PROCESSING);
     SetConsoleOutputCP(CP_UTF8);
     #else
-    if (instance->config.noBuffer) setvbuf(stdout, NULL, _IONBF, 0);
+    if (instance.config.noBuffer) setvbuf(stdout, NULL, _IONBF, 0);
     struct sigaction action = { .sa_handler = exitSignalHandler };
     sigaction(SIGINT, &action, NULL);
     sigaction(SIGTERM, &action, NULL);
@@ -225,7 +227,7 @@ void ffStart(FFinstance* instance)
     #endif
 
     //reset everything to default before we start printing
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
     if(ffHideCursor)
@@ -234,121 +236,121 @@ void ffStart(FFinstance* instance)
     if(ffDisableLinewrap)
         fputs("\033[?7l", stdout);
 
-    ffLogoPrint(instance);
+    ffLogoPrint();
 }
 
-void ffFinish(FFinstance* instance)
+void ffFinish(void)
 {
-    if(instance->config.logo.printRemaining)
-        ffLogoPrintRemaining(instance);
+    if(instance.config.logo.printRemaining)
+        ffLogoPrintRemaining();
 
     resetConsole();
 }
 
-static void destroyConfig(FFinstance* instance)
+static void destroyConfig(void)
 {
-    ffDestroyLogoOptions(&instance->config.logo);
+    ffDestroyLogoOptions(&instance.config.logo);
 
-    ffStrbufDestroy(&instance->config.colorKeys);
-    ffStrbufDestroy(&instance->config.colorTitle);
-    ffStrbufDestroy(&instance->config.keyValueSeparator);
+    ffStrbufDestroy(&instance.config.colorKeys);
+    ffStrbufDestroy(&instance.config.colorTitle);
+    ffStrbufDestroy(&instance.config.keyValueSeparator);
 
     #if defined(__linux__) || defined(__FreeBSD__)
-    ffStrbufDestroy(&instance->config.playerName);
-    ffStrbufDestroy(&instance->config.osFile);
+    ffStrbufDestroy(&instance.config.playerName);
+    ffStrbufDestroy(&instance.config.osFile);
     #endif
 
-    ffDestroyTitleOptions(&instance->config.title);
-    ffDestroyOSOptions(&instance->config.os);
-    ffDestroyHostOptions(&instance->config.host);
-    ffDestroyBiosOptions(&instance->config.bios);
-    ffDestroyBoardOptions(&instance->config.board);
-    ffDestroyBrightnessOptions(&instance->config.brightness);
-    ffDestroyChassisOptions(&instance->config.chassis);
-    ffDestroyCommandOptions(&instance->config.command);
-    ffDestroyCustomOptions(&instance->config.custom);
-    ffDestroyKernelOptions(&instance->config.kernel);
-    ffDestroyUptimeOptions(&instance->config.uptime);
-    ffDestroyProcessesOptions(&instance->config.processes);
-    ffDestroyPackagesOptions(&instance->config.packages);
-    ffDestroyShellOptions(&instance->config.shell);
-    ffDestroyDisplayOptions(&instance->config.display);
-    ffDestroyDEOptions(&instance->config.de);
-    ffDestroyWMOptions(&instance->config.wm);
-    ffDestroyWMThemeOptions(&instance->config.wmTheme);
-    ffDestroyThemeOptions(&instance->config.theme);
-    ffDestroyIconsOptions(&instance->config.icons);
-    ffDestroyFontOptions(&instance->config.font);
-    ffDestroyCursorOptions(&instance->config.cursor);
-    ffDestroyTerminalOptions(&instance->config.terminal);
-    ffDestroyTerminalFontOptions(&instance->config.terminalFont);
-    ffDestroyCPUOptions(&instance->config.cpu);
-    ffDestroyCPUUsageOptions(&instance->config.cpuUsage);
-    ffDestroyGPUOptions(&instance->config.gpu);
-    ffDestroyMemoryOptions(&instance->config.memory);
-    ffDestroySwapOptions(&instance->config.swap);
-    ffDestroyDiskOptions(&instance->config.disk);
-    ffDestroyBatteryOptions(&instance->config.battery);
-    ffDestroyPowerAdapterOptions(&instance->config.powerAdapter);
-    ffDestroyLMOptions(&instance->config.lm);
-    ffDestroyLocaleOptions(&instance->config.locale);
-    ffDestroyLocalIpOptions(&instance->config.localIP);
-    ffDestroyPublicIpOptions(&instance->config.publicIP);
-    ffDestroyWallpaperOptions(&instance->config.wallpaper);
-    ffDestroyWeatherOptions(&instance->config.weather);
-    ffDestroyWifiOptions(&instance->config.wifi);
-    ffDestroyPlayerOptions(&instance->config.player);
-    ffDestroyMediaOptions(&instance->config.media);
-    ffDestroyDateTimeOptions(&instance->config.dateTime);
-    ffDestroyVulkanOptions(&instance->config.vulkan);
-    ffDestroyOpenGLOptions(&instance->config.openGL);
-    ffDestroyOpenCLOptions(&instance->config.openCL);
-    ffDestroyUsersOptions(&instance->config.users);
-    ffDestroyBluetoothOptions(&instance->config.bluetooth);
-    ffDestroySeparatorOptions(&instance->config.separator);
-    ffDestroySoundOptions(&instance->config.sound);
-    ffDestroyGamepadOptions(&instance->config.gamepad);
-    ffDestroyColorsOptions(&instance->config.colors);
+    ffDestroyTitleOptions(&instance.config.title);
+    ffDestroyOSOptions(&instance.config.os);
+    ffDestroyHostOptions(&instance.config.host);
+    ffDestroyBiosOptions(&instance.config.bios);
+    ffDestroyBoardOptions(&instance.config.board);
+    ffDestroyBrightnessOptions(&instance.config.brightness);
+    ffDestroyChassisOptions(&instance.config.chassis);
+    ffDestroyCommandOptions(&instance.config.command);
+    ffDestroyCustomOptions(&instance.config.custom);
+    ffDestroyKernelOptions(&instance.config.kernel);
+    ffDestroyUptimeOptions(&instance.config.uptime);
+    ffDestroyProcessesOptions(&instance.config.processes);
+    ffDestroyPackagesOptions(&instance.config.packages);
+    ffDestroyShellOptions(&instance.config.shell);
+    ffDestroyDisplayOptions(&instance.config.display);
+    ffDestroyDEOptions(&instance.config.de);
+    ffDestroyWMOptions(&instance.config.wm);
+    ffDestroyWMThemeOptions(&instance.config.wmTheme);
+    ffDestroyThemeOptions(&instance.config.theme);
+    ffDestroyIconsOptions(&instance.config.icons);
+    ffDestroyFontOptions(&instance.config.font);
+    ffDestroyCursorOptions(&instance.config.cursor);
+    ffDestroyTerminalOptions(&instance.config.terminal);
+    ffDestroyTerminalFontOptions(&instance.config.terminalFont);
+    ffDestroyCPUOptions(&instance.config.cpu);
+    ffDestroyCPUUsageOptions(&instance.config.cpuUsage);
+    ffDestroyGPUOptions(&instance.config.gpu);
+    ffDestroyMemoryOptions(&instance.config.memory);
+    ffDestroySwapOptions(&instance.config.swap);
+    ffDestroyDiskOptions(&instance.config.disk);
+    ffDestroyBatteryOptions(&instance.config.battery);
+    ffDestroyPowerAdapterOptions(&instance.config.powerAdapter);
+    ffDestroyLMOptions(&instance.config.lm);
+    ffDestroyLocaleOptions(&instance.config.locale);
+    ffDestroyLocalIpOptions(&instance.config.localIP);
+    ffDestroyPublicIpOptions(&instance.config.publicIP);
+    ffDestroyWallpaperOptions(&instance.config.wallpaper);
+    ffDestroyWeatherOptions(&instance.config.weather);
+    ffDestroyWifiOptions(&instance.config.wifi);
+    ffDestroyPlayerOptions(&instance.config.player);
+    ffDestroyMediaOptions(&instance.config.media);
+    ffDestroyDateTimeOptions(&instance.config.dateTime);
+    ffDestroyVulkanOptions(&instance.config.vulkan);
+    ffDestroyOpenGLOptions(&instance.config.openGL);
+    ffDestroyOpenCLOptions(&instance.config.openCL);
+    ffDestroyUsersOptions(&instance.config.users);
+    ffDestroyBluetoothOptions(&instance.config.bluetooth);
+    ffDestroySeparatorOptions(&instance.config.separator);
+    ffDestroySoundOptions(&instance.config.sound);
+    ffDestroyGamepadOptions(&instance.config.gamepad);
+    ffDestroyColorsOptions(&instance.config.colors);
 
-    ffStrbufDestroy(&instance->config.libPCI);
-    ffStrbufDestroy(&instance->config.libVulkan);
-    ffStrbufDestroy(&instance->config.libWayland);
-    ffStrbufDestroy(&instance->config.libXcbRandr);
-    ffStrbufDestroy(&instance->config.libXcb);
-    ffStrbufDestroy(&instance->config.libXrandr);
-    ffStrbufDestroy(&instance->config.libX11);
-    ffStrbufDestroy(&instance->config.libGIO);
-    ffStrbufDestroy(&instance->config.libDConf);
-    ffStrbufDestroy(&instance->config.libDBus);
-    ffStrbufDestroy(&instance->config.libXFConf);
-    ffStrbufDestroy(&instance->config.libSQLite3);
-    ffStrbufDestroy(&instance->config.librpm);
-    ffStrbufDestroy(&instance->config.libImageMagick);
-    ffStrbufDestroy(&instance->config.libZ);
-    ffStrbufDestroy(&instance->config.libChafa);
-    ffStrbufDestroy(&instance->config.libEGL);
-    ffStrbufDestroy(&instance->config.libGLX);
-    ffStrbufDestroy(&instance->config.libOSMesa);
-    ffStrbufDestroy(&instance->config.libOpenCL);
-    ffStrbufDestroy(&instance->config.libfreetype);
-    ffStrbufDestroy(&instance->config.libPulse);
-    ffStrbufDestroy(&instance->config.libnm);
+    ffStrbufDestroy(&instance.config.libPCI);
+    ffStrbufDestroy(&instance.config.libVulkan);
+    ffStrbufDestroy(&instance.config.libWayland);
+    ffStrbufDestroy(&instance.config.libXcbRandr);
+    ffStrbufDestroy(&instance.config.libXcb);
+    ffStrbufDestroy(&instance.config.libXrandr);
+    ffStrbufDestroy(&instance.config.libX11);
+    ffStrbufDestroy(&instance.config.libGIO);
+    ffStrbufDestroy(&instance.config.libDConf);
+    ffStrbufDestroy(&instance.config.libDBus);
+    ffStrbufDestroy(&instance.config.libXFConf);
+    ffStrbufDestroy(&instance.config.libSQLite3);
+    ffStrbufDestroy(&instance.config.librpm);
+    ffStrbufDestroy(&instance.config.libImageMagick);
+    ffStrbufDestroy(&instance.config.libZ);
+    ffStrbufDestroy(&instance.config.libChafa);
+    ffStrbufDestroy(&instance.config.libEGL);
+    ffStrbufDestroy(&instance.config.libGLX);
+    ffStrbufDestroy(&instance.config.libOSMesa);
+    ffStrbufDestroy(&instance.config.libOpenCL);
+    ffStrbufDestroy(&instance.config.libfreetype);
+    ffStrbufDestroy(&instance.config.libPulse);
+    ffStrbufDestroy(&instance.config.libnm);
 }
 
-static void destroyState(FFinstance* instance)
+static void destroyState(void)
 {
-    ffPlatformDestroy(&instance->state.platform);
-    yyjson_doc_free(instance->state.configDoc);
+    ffPlatformDestroy(&instance.state.platform);
+    yyjson_doc_free(instance.state.configDoc);
 }
 
-void ffDestroyInstance(FFinstance* instance)
+void ffDestroyInstance(void)
 {
-    destroyConfig(instance);
-    destroyState(instance);
+    destroyConfig();
+    destroyState();
 }
 
 //Must be in a file compiled with the libfastfetch target, because the FF_HAVE* macros are not defined for the executable targets
-void ffListFeatures()
+void ffListFeatures(void)
 {
     fputs(
         #ifdef FF_HAVE_THREADS

src/common/jsonconfig.c

@@ -65,154 +65,154 @@ const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair p
         return "Invalid enum value type; must be a string or integer";
 }
 
-static inline bool tryModule(FFinstance* instance, const char* type, yyjson_val* module, const char* moduleName, void (*const f)(FFinstance *instance, yyjson_val *module))
+static inline bool tryModule(const char* type, yyjson_val* module, const char* moduleName, void (*const f)(yyjson_val *module))
 {
     if (ffStrEqualsIgnCase(type, moduleName))
     {
-        f(instance, module);
+        f(module);
         return true;
     }
     return false;
 }
 
-static bool parseModuleJsonObject(FFinstance* instance, const char* type, yyjson_val* module)
+static bool parseModuleJsonObject(const char* type, yyjson_val* module)
 {
     switch (toupper(type[0]))
     {
         case 'B': {
             return
-                tryModule(instance, type, module, FF_BATTERY_MODULE_NAME, ffParseBatteryJsonObject) ||
-                tryModule(instance, type, module, FF_BIOS_MODULE_NAME, ffParseBiosJsonObject) ||
-                tryModule(instance, type, module, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothJsonObject) ||
-                tryModule(instance, type, module, FF_BOARD_MODULE_NAME, ffParseBoardJsonObject) ||
-                tryModule(instance, type, module, FF_BREAK_MODULE_NAME, ffParseBreakJsonObject) ||
-                tryModule(instance, type, module, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessJsonObject) ||
+                tryModule(type, module, FF_BATTERY_MODULE_NAME, ffParseBatteryJsonObject) ||
+                tryModule(type, module, FF_BIOS_MODULE_NAME, ffParseBiosJsonObject) ||
+                tryModule(type, module, FF_BLUETOOTH_MODULE_NAME, ffParseBluetoothJsonObject) ||
+                tryModule(type, module, FF_BOARD_MODULE_NAME, ffParseBoardJsonObject) ||
+                tryModule(type, module, FF_BREAK_MODULE_NAME, ffParseBreakJsonObject) ||
+                tryModule(type, module, FF_BRIGHTNESS_MODULE_NAME, ffParseBrightnessJsonObject) ||
                 false;
         }
 
         case 'C': {
             return
-                tryModule(instance, type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) ||
-                tryModule(instance, type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) ||
-                tryModule(instance, type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) ||
-                tryModule(instance, type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) ||
-                tryModule(instance, type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) ||
-                tryModule(instance, type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) ||
-                tryModule(instance, type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) ||
+                tryModule(type, module, FF_CHASSIS_MODULE_NAME, ffParseChassisJsonObject) ||
+                tryModule(type, module, FF_CPU_MODULE_NAME, ffParseCPUJsonObject) ||
+                tryModule(type, module, FF_CPUUSAGE_MODULE_NAME, ffParseCPUUsageJsonObject) ||
+                tryModule(type, module, FF_COMMAND_MODULE_NAME, ffParseCommandJsonObject) ||
+                tryModule(type, module, FF_COLORS_MODULE_NAME, ffParseColorsJsonObject) ||
+                tryModule(type, module, FF_CURSOR_MODULE_NAME, ffParseCursorJsonObject) ||
+                tryModule(type, module, FF_CUSTOM_MODULE_NAME, ffParseCustomJsonObject) ||
                 false;
         }
 
         case 'D': {
             return
-                tryModule(instance, type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) ||
-                tryModule(instance, type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) ||
-                tryModule(instance, type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) ||
-                tryModule(instance, type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) ||
+                tryModule(type, module, FF_DATETIME_MODULE_NAME, ffParseDateTimeJsonObject) ||
+                tryModule(type, module, FF_DISPLAY_MODULE_NAME, ffParseDisplayJsonObject) ||
+                tryModule(type, module, FF_DISK_MODULE_NAME, ffParseDiskJsonObject) ||
+                tryModule(type, module, FF_DE_MODULE_NAME, ffParseDEJsonObject) ||
                 false;
         }
 
         case 'F': {
             return
-                tryModule(instance, type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) ||
+                tryModule(type, module, FF_FONT_MODULE_NAME, ffParseFontJsonObject) ||
                 false;
         }
 
         case 'G': {
             return
-                tryModule(instance, type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) ||
-                tryModule(instance, type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) ||
+                tryModule(type, module, FF_GAMEPAD_MODULE_NAME, ffParseGamepadJsonObject) ||
+                tryModule(type, module, FF_GPU_MODULE_NAME, ffParseGPUJsonObject) ||
                 false;
         }
 
         case 'H': {
             return
-                tryModule(instance, type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) ||
+                tryModule(type, module, FF_HOST_MODULE_NAME, ffParseHostJsonObject) ||
                 false;
         }
 
         case 'I': {
             return
-                tryModule(instance, type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) ||
+                tryModule(type, module, FF_ICONS_MODULE_NAME, ffParseIconsJsonObject) ||
                 false;
         }
 
         case 'K': {
             return
-                tryModule(instance, type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) ||
+                tryModule(type, module, FF_KERNEL_MODULE_NAME, ffParseKernelJsonObject) ||
                 false;
         }
 
         case 'L': {
             return
-                tryModule(instance, type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) ||
-                tryModule(instance, type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) ||
-                tryModule(instance, type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) ||
+                tryModule(type, module, FF_LM_MODULE_NAME, ffParseLMJsonObject) ||
+                tryModule(type, module, FF_LOCALE_MODULE_NAME, ffParseLocaleJsonObject) ||
+                tryModule(type, module, FF_LOCALIP_MODULE_NAME, ffParseLocalIpJsonObject) ||
                 false;
         }
 
         case 'M': {
             return
-                tryModule(instance, type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) ||
-                tryModule(instance, type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) ||
+                tryModule(type, module, FF_MEDIA_MODULE_NAME, ffParseMediaJsonObject) ||
+                tryModule(type, module, FF_MEMORY_MODULE_NAME, ffParseMemoryJsonObject) ||
                 false;
         }
 
         case 'O': {
             return
-                tryModule(instance, type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) ||
-                tryModule(instance, type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) ||
-                tryModule(instance, type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) ||
+                tryModule(type, module, FF_OPENCL_MODULE_NAME, ffParseOpenCLJsonObject) ||
+                tryModule(type, module, FF_OPENGL_MODULE_NAME, ffParseOpenGLJsonObject) ||
+                tryModule(type, module, FF_OS_MODULE_NAME, ffParseOSJsonObject) ||
                 false;
         }
 
         case 'P': {
             return
-                tryModule(instance, type, module, FF_PACKAGES_MODULE_NAME, ffParsePackagesJsonObject) ||
-                tryModule(instance, type, module, FF_PLAYER_MODULE_NAME, ffParsePlayerJsonObject) ||
-                tryModule(instance, type, module, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterJsonObject) ||
-                tryModule(instance, type, module, FF_PROCESSES_MODULE_NAME, ffParseProcessesJsonObject) ||
-                tryModule(instance, type, module, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpJsonObject) ||
+                tryModule(type, module, FF_PACKAGES_MODULE_NAME, ffParsePackagesJsonObject) ||
+                tryModule(type, module, FF_PLAYER_MODULE_NAME, ffParsePlayerJsonObject) ||
+                tryModule(type, module, FF_POWERADAPTER_MODULE_NAME, ffParsePowerAdapterJsonObject) ||
+                tryModule(type, module, FF_PROCESSES_MODULE_NAME, ffParseProcessesJsonObject) ||
+                tryModule(type, module, FF_PUBLICIP_MODULE_NAME, ffParsePublicIpJsonObject) ||
                 false;
         }
 
         case 'S': {
             return
-                tryModule(instance, type, module, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorJsonObject) ||
-                tryModule(instance, type, module, FF_SHELL_MODULE_NAME, ffParseShellJsonObject) ||
-                tryModule(instance, type, module, FF_SOUND_MODULE_NAME, ffParseSoundJsonObject) ||
-                tryModule(instance, type, module, FF_SWAP_MODULE_NAME, ffParseSwapJsonObject) ||
+                tryModule(type, module, FF_SEPARATOR_MODULE_NAME, ffParseSeparatorJsonObject) ||
+                tryModule(type, module, FF_SHELL_MODULE_NAME, ffParseShellJsonObject) ||
+                tryModule(type, module, FF_SOUND_MODULE_NAME, ffParseSoundJsonObject) ||
+                tryModule(type, module, FF_SWAP_MODULE_NAME, ffParseSwapJsonObject) ||
                 false;
         }
 
         case 'T': {
             return
-                tryModule(instance, type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) ||
-                tryModule(instance, type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) ||
-                tryModule(instance, type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) ||
-                tryModule(instance, type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) ||
+                tryModule(type, module, FF_TERMINAL_MODULE_NAME, ffParseTerminalJsonObject) ||
+                tryModule(type, module, FF_TERMINALFONT_MODULE_NAME, ffParseTerminalFontJsonObject) ||
+                tryModule(type, module, FF_TITLE_MODULE_NAME, ffParseTitleJsonObject) ||
+                tryModule(type, module, FF_THEME_MODULE_NAME, ffParseThemeJsonObject) ||
                 false;
         }
 
         case 'U': {
             return
-                tryModule(instance, type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) ||
-                tryModule(instance, type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) ||
+                tryModule(type, module, FF_UPTIME_MODULE_NAME, ffParseUptimeJsonObject) ||
+                tryModule(type, module, FF_USERS_MODULE_NAME, ffParseUsersJsonObject) ||
                 false;
         }
 
         case 'V': {
             return
-                tryModule(instance, type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) ||
+                tryModule(type, module, FF_VULKAN_MODULE_NAME, ffParseVulkanJsonObject) ||
                 false;
         }
 
         case 'W': {
             return
-                tryModule(instance, type, module, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperJsonObject) ||
-                tryModule(instance, type, module, FF_WEATHER_MODULE_NAME, ffParseWeatherJsonObject) ||
-                tryModule(instance, type, module, FF_WM_MODULE_NAME, ffParseWMJsonObject) ||
-                tryModule(instance, type, module, FF_WIFI_MODULE_NAME, ffParseWifiJsonObject) ||
-                tryModule(instance, type, module, FF_WMTHEME_MODULE_NAME, ffParseWMThemeJsonObject) ||
+                tryModule(type, module, FF_WALLPAPER_MODULE_NAME, ffParseWallpaperJsonObject) ||
+                tryModule(type, module, FF_WEATHER_MODULE_NAME, ffParseWeatherJsonObject) ||
+                tryModule(type, module, FF_WM_MODULE_NAME, ffParseWMJsonObject) ||
+                tryModule(type, module, FF_WIFI_MODULE_NAME, ffParseWifiJsonObject) ||
+                tryModule(type, module, FF_WMTHEME_MODULE_NAME, ffParseWMThemeJsonObject) ||
                 false;
         }
 
@@ -221,9 +221,9 @@ static bool parseModuleJsonObject(FFinstance* instance, const char* type, yyjson
     }
 }
 
-static const char* printJsonConfig(FFinstance* instance)
+static const char* printJsonConfig(void)
 {
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -238,7 +238,7 @@ static const char* printJsonConfig(FFinstance* instance)
     yyjson_arr_foreach(modules, idx, max, item)
     {
         uint64_t ms = 0;
-        if(__builtin_expect(instance->config.stat, false))
+        if(__builtin_expect(instance.config.stat, false))
             ms = ffTimeGetTick();
 
         yyjson_val* module = item;
@@ -255,32 +255,32 @@ static const char* printJsonConfig(FFinstance* instance)
         else
             return "modules must be an array of strings or objects";
 
-        if(!parseModuleJsonObject(instance, type, module))
+        if(!parseModuleJsonObject(type, module))
             return "Unknown module type";
 
-        if(__builtin_expect(instance->config.stat, false))
+        if(__builtin_expect(instance.config.stat, false))
         {
             char str[32];
             int len = snprintf(str, sizeof str, "%" PRIu64 "ms", ffTimeGetTick() - ms);
-            if(instance->config.pipe)
+            if(instance.config.pipe)
                 puts(str);
             else
                 printf("\033[s\033[1A\033[9999999C\033[%dD%s\033[u", len, str); // Save; Up 1; Right 9999999; Left <len>; Print <str>; Load
         }
 
         #if defined(_WIN32)
-        if (!instance->config.noBuffer) fflush(stdout);
+        if (!instance.config.noBuffer) fflush(stdout);
         #endif
     }
 
     return NULL;
 }
 
-const char* ffParseGeneralJsonConfig(FFinstance* instance)
+const char* ffParseGeneralJsonConfig(void)
 {
-    FFconfig* config = &instance->config;
+    FFconfig* config = &instance.config;
 
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -321,11 +321,11 @@ const char* ffParseGeneralJsonConfig(FFinstance* instance)
     return NULL;
 }
 
-const char* ffParseDisplayJsonConfig(FFinstance* instance)
+const char* ffParseDisplayJsonConfig(void)
 {
-    FFconfig* config = &instance->config;
+    FFconfig* config = &instance.config;
 
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -391,11 +391,11 @@ const char* ffParseDisplayJsonConfig(FFinstance* instance)
     return NULL;
 }
 
-const char* ffParseLibraryJsonConfig(FFinstance* instance)
+const char* ffParseLibraryJsonConfig(void)
 {
-    FFconfig* config = &instance->config;
+    FFconfig* config = &instance.config;
 
-    yyjson_val* const root = yyjson_doc_get_root(instance->state.configDoc);
+    yyjson_val* const root = yyjson_doc_get_root(instance.state.configDoc);
     assert(root);
 
     if (!yyjson_is_obj(root))
@@ -464,9 +464,9 @@ const char* ffParseLibraryJsonConfig(FFinstance* instance)
     return NULL;
 }
 
-void ffPrintJsonConfig(FFinstance* instance)
+void ffPrintJsonConfig(void)
 {
-    const char* error = printJsonConfig(instance);
+    const char* error = printJsonConfig();
     if (error)
-        ffPrintErrorString(instance, "JsonConfig", 0, NULL, NULL, "%s", error);
+        ffPrintErrorString("JsonConfig", 0, NULL, NULL, "%s", error);
 }

src/common/jsonconfig.h

@@ -4,7 +4,7 @@
 
 bool ffJsonConfigParseModuleArgs(const char* key, yyjson_val* val, FFModuleArgs* moduleArgs);
 const char* ffJsonConfigParseEnum(yyjson_val* val, int* result, FFKeyValuePair pairs[]);
-void ffPrintJsonConfig(FFinstance* instance);
-const char* ffParseGeneralJsonConfig(FFinstance* instance);
-const char* ffParseDisplayJsonConfig(FFinstance* instance);
-const char* ffParseLibraryJsonConfig(FFinstance* instance);
+void ffPrintJsonConfig();
+const char* ffParseGeneralJsonConfig();
+const char* ffParseDisplayJsonConfig();
+const char* ffParseLibraryJsonConfig();

src/common/printing.c

@@ -2,21 +2,21 @@
 #include "common/printing.h"
 #include "util/textModifier.h"
 
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor)
+void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor)
 {
-    ffLogoPrintLine(instance);
+    ffLogoPrintLine();
 
     //This is used by --set-keyless, in this case we wan't neither the module name nor the separator
     if(moduleName == NULL)
         return;
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
     {
         fputs(FASTFETCH_TEXT_MODIFIER_RESET FASTFETCH_TEXT_MODIFIER_BOLT, stdout);
         if(customKeyColor != NULL && customKeyColor->length > 0)
             ffPrintColor(customKeyColor);
         else
-            ffPrintColor(&instance->config.colorKeys);
+            ffPrintColor(&instance.config.colorKeys);
     }
 
     //NULL check is required for modules with custom keys, e.g. disk with the folder path
@@ -36,64 +36,64 @@ void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t mod
         ffPrintUserString(key.chars);
     }
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
-    ffStrbufWriteTo(&instance->config.keyValueSeparator, stdout);
+    ffStrbufWriteTo(&instance.config.keyValueSeparator, stdout);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 }
 
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments)
 {
     FF_STRBUF_AUTO_DESTROY buffer = ffStrbufCreateA(256);
     ffParseFormatString(&buffer, format, numArgs, arguments);
 
     if(buffer.length > 0)
     {
-        ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat, customKeyColor);
+        ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor);
         ffPrintUserString(buffer.chars);
         putchar('\n');
     }
 }
 
-void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments)
 {
-    ffPrintFormatString(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, &moduleArgs->outputFormat, numArgs, arguments);
+    ffPrintFormatString(moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, &moduleArgs->outputFormat, numArgs, arguments);
 }
 
-static void printError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, va_list arguments)
+static void printError(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, va_list arguments)
 {
-    if(!instance->config.showErrors)
+    if(!instance.config.showErrors)
         return;
 
-    ffPrintLogoAndKey(instance, moduleName, moduleIndex, customKeyFormat, customKeyColor);
+    ffPrintLogoAndKey(moduleName, moduleIndex, customKeyFormat, customKeyColor);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_ERROR, stdout);
 
     vprintf(message, arguments);
 
-    if(!instance->config.pipe)
+    if(!instance.config.pipe)
         fputs(FASTFETCH_TEXT_MODIFIER_RESET, stdout);
 
     putchar('\n');
 }
 
-void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...)
+void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...)
 {
     va_list arguments;
     va_start(arguments, message);
-    printError(instance, moduleName, moduleIndex, customKeyFormat, customKeyColor, message, arguments);
+    printError(moduleName, moduleIndex, customKeyFormat, customKeyColor, message, arguments);
     va_end(arguments);
 }
 
-void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
+void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...)
 {
     va_list arguments;
     va_start(arguments, message);
-    printError(instance, moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, message, arguments);
+    printError(moduleName, moduleIndex, &moduleArgs->key, &moduleArgs->keyColor, message, arguments);
     va_end(arguments);
 }
 

src/common/printing.h

@@ -6,11 +6,11 @@
 #include "fastfetch.h"
 #include "common/format.h"
 
-void ffPrintLogoAndKey(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor);
-void ffPrintFormatString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
-void ffPrintFormat(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
-FF_C_PRINTF(6, 7) void ffPrintErrorString(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...);
-FF_C_PRINTF(5, 6) void ffPrintError(FFinstance* instance, const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
+void ffPrintLogoAndKey(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor);
+void ffPrintFormatString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const FFstrbuf* format, uint32_t numArgs, const FFformatarg* arguments);
+void ffPrintFormat(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, uint32_t numArgs, const FFformatarg* arguments);
+FF_C_PRINTF(5, 6) void ffPrintErrorString(const char* moduleName, uint8_t moduleIndex, const FFstrbuf* customKeyFormat, const FFstrbuf* customKeyColor, const char* message, ...);
+FF_C_PRINTF(4, 5) void ffPrintError(const char* moduleName, uint8_t moduleIndex, const FFModuleArgs* moduleArgs, const char* message, ...);
 void ffPrintColor(const FFstrbuf* colorValue);
 void ffPrintCharTimes(char c, uint32_t times);
 void ffPrintUserString(const char* str);

src/common/properties.c

@@ -144,9 +144,9 @@ done:
     return true;
 }
 
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+bool ffParsePropFileHomeValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateF("%s/%s", instance->state.platform.homeDir.chars, relativeFile);
+    FF_STRBUF_AUTO_DESTROY absolutePath = ffStrbufCreateF("%s/%s", instance.state.platform.homeDir.chars, relativeFile);
     return ffParsePropFileValues(absolutePath.chars, numQueries, queries);
 }
 

src/common/properties.h

@@ -14,7 +14,7 @@ typedef struct FFpropquery
 bool ffParsePropLine(const char* line, const char* start, FFstrbuf* buffer);
 bool ffParsePropLines(const char* lines, const char* start, FFstrbuf* buffer);
 bool ffParsePropFileValues(const char* filename, uint32_t numQueries, FFpropquery* queries);
-bool ffParsePropFileHomeValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
+bool ffParsePropFileHomeValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
 bool ffParsePropFileListValues(const FFlist* list, const char* relativeFile, uint32_t numQueries, FFpropquery* queries);
 
 static inline bool ffParsePropFile(const char* filename, const char* start, FFstrbuf* buffer)
@@ -22,9 +22,9 @@ static inline bool ffParsePropFile(const char* filename, const char* start, FFst
     return ffParsePropFileValues(filename, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileHome(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileHome(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileHomeValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileHomeValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
 static inline bool ffParsePropFileList(const FFlist* list, const char* relativeFile, const char* start, FFstrbuf* buffer)
@@ -32,24 +32,24 @@ static inline bool ffParsePropFileList(const FFlist* list, const char* relativeF
     return ffParsePropFileListValues(list, relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileConfigValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+static inline bool ffParsePropFileConfigValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    return ffParsePropFileListValues(&instance->state.platform.configDirs, relativeFile, numQueries, queries);
+    return ffParsePropFileListValues(&instance.state.platform.configDirs, relativeFile, numQueries, queries);
 }
 
-static inline bool ffParsePropFileConfig(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileConfig(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileConfigValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileConfigValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
-static inline bool ffParsePropFileDataValues(const FFinstance* instance, const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
+static inline bool ffParsePropFileDataValues(const char* relativeFile, uint32_t numQueries, FFpropquery* queries)
 {
-    return ffParsePropFileListValues(&instance->state.platform.dataDirs, relativeFile, numQueries, queries);
+    return ffParsePropFileListValues(&instance.state.platform.dataDirs, relativeFile, numQueries, queries);
 }
 
-static inline bool ffParsePropFileData(const FFinstance* instance, const char* relativeFile, const char* start, FFstrbuf* buffer)
+static inline bool ffParsePropFileData(const char* relativeFile, const char* start, FFstrbuf* buffer)
 {
-    return ffParsePropFileDataValues(instance, relativeFile, 1, (FFpropquery[]){{start, buffer}});
+    return ffParsePropFileDataValues(relativeFile, 1, (FFpropquery[]){{start, buffer}});
 }
 
 #endif

src/common/settings.c

@@ -97,9 +97,9 @@ typedef struct GSettingsData
     GVariantGetters variantGetters;
 } GSettingsData;
 
-static const GSettingsData* getGSettingsData(const FFinstance* instance)
+static const GSettingsData* getGSettingsData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance->config.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_DATA_LOAD_INIT(GSettingsData, instance.config.libGIO, "libgio-2.0" FF_LIBRARY_EXTENSION, 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_source_lookup)
     FF_LIBRARY_DATA_LOAD_SYMBOL(g_settings_schema_has_key)
@@ -123,9 +123,9 @@ static const GSettingsData* getGSettingsData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
-    const GSettingsData* data = getGSettingsData(instance);
+    const GSettingsData* data = getGSettingsData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -152,9 +152,9 @@ FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaN
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_GIO
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type)
 {
-    FF_UNUSED(instance, schemaName, path, key, type)
+    FF_UNUSED(schemaName, path, key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_GIO
@@ -170,9 +170,9 @@ typedef struct DConfData
     DConfClient* client;
 } DConfData;
 
-static const DConfData* getDConfData(const FFinstance* instance)
+static const DConfData* getDConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance->config.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
+    FF_LIBRARY_DATA_LOAD_INIT(DConfData, instance.config.libDConf, "libdconf" FF_LIBRARY_EXTENSION, 2);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_read_full)
     FF_LIBRARY_DATA_LOAD_SYMBOL(dconf_client_new)
@@ -191,9 +191,9 @@ static const DConfData* getDConfData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
 {
-    const DConfData* data = getDConfData(instance);
+    const DConfData* data = getDConfData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -209,23 +209,23 @@ FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvari
     return getGVariantValue(variant, type, &data->variantGetters);
 }
 #else //FF_HAVE_DCONF
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type)
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type)
 {
-    FF_UNUSED(instance, key, type)
+    FF_UNUSED(key, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_DCONF
 
-FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
+FFvariant ffSettingsGet(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type)
 {
-    FFvariant gsettings = ffSettingsGetGSettings(instance, gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
+    FFvariant gsettings = ffSettingsGetGSettings(gsettingsSchemaName, gsettingsPath, gsettingsKey, type);
 
     if(
         (type == FF_VARIANT_TYPE_BOOL && gsettings.boolValueSet) ||
         (type != FF_VARIANT_TYPE_BOOL && gsettings.strValue != NULL)
     ) return gsettings;
 
-    return ffSettingsGetDConf(instance, dconfKey, type);
+    return ffSettingsGetDConf(dconfKey, type);
 }
 
 #ifdef FF_HAVE_XFCONF
@@ -241,9 +241,9 @@ typedef struct XFConfData
     FF_LIBRARY_SYMBOL(xfconf_init)
 } XFConfData;
 
-static const XFConfData* getXFConfData(const FFinstance* instance)
+static const XFConfData* getXFConfData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance->config.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
+    FF_LIBRARY_DATA_LOAD_INIT(XFConfData, instance.config.libXFConf, "libxfconf-0" FF_LIBRARY_EXTENSION, 4);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_get)
     FF_LIBRARY_DATA_LOAD_SYMBOL(xfconf_channel_has_property)
@@ -258,9 +258,9 @@ static const XFConfData* getXFConfData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
 {
-    const XFConfData* data = getXFConfData(instance);
+    const XFConfData* data = getXFConfData();
     if(data == NULL)
         return FF_VARIANT_NULL;
 
@@ -281,9 +281,9 @@ FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelNam
     return FF_VARIANT_NULL;
 }
 #else //FF_HAVE_XFCONF
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type)
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type)
 {
-    FF_UNUSED(instance, channelName, propertyName, type)
+    FF_UNUSED(channelName, propertyName, type)
     return FF_VARIANT_NULL;
 }
 #endif //FF_HAVE_XFCONF
@@ -303,9 +303,9 @@ typedef struct SQLiteData
     FF_LIBRARY_SYMBOL(sqlite3_close)
 } SQLiteData;
 
-static const SQLiteData* getSQLiteData(const FFinstance* instance)
+static const SQLiteData* getSQLiteData(void)
 {
-    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance->config.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
+    FF_LIBRARY_DATA_LOAD_INIT(SQLiteData, instance.config.libSQLite3, "libsqlite3" FF_LIBRARY_EXTENSION, 1);
 
     FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_open_v2)
     FF_LIBRARY_DATA_LOAD_SYMBOL(sqlite3_prepare_v2)
@@ -319,12 +319,12 @@ static const SQLiteData* getSQLiteData(const FFinstance* instance)
     FF_LIBRARY_DATA_LOAD_RETURN
 }
 
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
 {
     if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
         return 0;
 
-    const SQLiteData* data = getSQLiteData(instance);
+    const SQLiteData* data = getSQLiteData();
     if(data == NULL)
         return 0;
 
@@ -354,12 +354,12 @@ int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, cons
     return result;
 }
 
-bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result)
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result)
 {
     if(!ffPathExists(dbPath, FF_PATHTYPE_FILE))
         return false;
 
-    const SQLiteData* data = getSQLiteData(instance);
+    const SQLiteData* data = getSQLiteData();
     if(data == NULL)
         return false;
 
@@ -389,14 +389,14 @@ bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath,
     return true;
 }
 #else //FF_HAVE_SQLITE3
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query)
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query)
 {
-    FF_UNUSED(instance, dbPath, query)
+    FF_UNUSED(dbPath, query)
     return 0;
 }
-bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result)
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result)
 {
-    FF_UNUSED(instance, dbPath, query, result)
+    FF_UNUSED(dbPath, query, result)
     return false;
 }
 #endif //FF_HAVE_SQLITE3

src/common/settings.h

@@ -25,13 +25,13 @@ typedef union FFvariant
 
 #define FF_VARIANT_NULL ((FFvariant){.strValue = NULL})
 
-FFvariant ffSettingsGetDConf(const FFinstance* instance, const char* key, FFvarianttype type);
-FFvariant ffSettingsGetGSettings(const FFinstance* instance, const char* schemaName, const char* path, const char* key, FFvarianttype type);
-FFvariant ffSettingsGet(const FFinstance* instance, const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
-FFvariant ffSettingsGetXFConf(const FFinstance* instance, const char* channelName, const char* propertyName, FFvarianttype type);
+FFvariant ffSettingsGetDConf(const char* key, FFvarianttype type);
+FFvariant ffSettingsGetGSettings(const char* schemaName, const char* path, const char* key, FFvarianttype type);
+FFvariant ffSettingsGet(const char* dconfKey, const char* gsettingsSchemaName, const char* gsettingsPath, const char* gsettingsKey, FFvarianttype type);
+FFvariant ffSettingsGetXFConf(const char* channelName, const char* propertyName, FFvarianttype type);
 
-int ffSettingsGetSQLite3Int(const FFinstance* instance, const char* dbPath, const char* query);
-bool ffSettingsGetSQLite3String(const FFinstance* instance, const char* dbPath, const char* query, FFstrbuf* result);
+int ffSettingsGetSQLite3Int(const char* dbPath, const char* query);
+bool ffSettingsGetSQLite3String(const char* dbPath, const char* query, FFstrbuf* result);
 
 #ifdef __ANDROID__
 bool ffSettingsGetAndroidProperty(const char* propName, FFstrbuf* result);

src/common/thread.h

@@ -19,6 +19,7 @@
             return (FFThreadType)_beginthreadex(NULL, 0, func, data, 0, NULL);
         }
         #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static __stdcall unsigned fn ## ThreadMain (void* data) { fn((paramType)data); return 0; }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(fn) static __stdcall unsigned fn ## ThreadMain () { fn(); return 0; }
         static inline void ffThreadDetach(FFThreadType thread) { CloseHandle(thread); }
         static inline void ffThreadJoin(FFThreadType thread) { WaitForSingleObject(thread, 0xffffffff /*INFINITE*/); }
     #else
@@ -34,6 +35,7 @@
             return newThread;
         }
         #define FF_THREAD_ENTRY_DECL_WRAPPER(fn, paramType) static void* fn ## ThreadMain (void* data) { fn((paramType)data); return NULL; }
+        #define FF_THREAD_ENTRY_DECL_WRAPPER_NOPARAM(fn) static void* fn ## ThreadMain () { fn(); return NULL; }
         static inline void ffThreadDetach(FFThreadType thread) { pthread_detach(thread); }
         static inline void ffThreadJoin(FFThreadType thread) { pthread_join(thread, NULL); }
     #endif