JsonConfig: refactor to get rid of data-ffjson_*

src/modules/battery/battery.c

@@ -148,7 +148,7 @@ void ffDestroyBatteryOptions(FFBatteryOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseBatteryJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseBatteryJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_BATTERY_MODULE_NAME) != 0)
         return false;
@@ -156,29 +156,32 @@ bool ffParseBatteryJsonObject(FFinstance* instance, const char* type, JSONCData*
     FFBatteryOptions __attribute__((__cleanup__(ffDestroyBatteryOptions))) options;
     ffInitBatteryOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
-
-        #ifdef __linux__
-        if (strcasecmp(key, "dir") == 0)
+        json_object_object_foreach(module, key, val)
         {
-            ffStrbufSetS(&options.dir, data->ffjson_object_get_string(val));
-            continue;
-        }
-        #endif
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (strcasecmp(key, "temp") == 0)
-        {
-            options.temp = (bool) data->ffjson_object_get_boolean(val);
-            continue;
-        }
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            #ifdef __linux__
+            if (strcasecmp(key, "dir") == 0)
+            {
+                ffStrbufSetS(&options.dir, json_object_get_string(val));
+                continue;
+            }
+            #endif
+
+            if (strcasecmp(key, "temp") == 0)
+            {
+                options.temp = (bool) json_object_get_boolean(val);
+                continue;
+            }
+
+            ffPrintError(instance, FF_BATTERY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintBattery(instance, &options);

src/modules/battery/battery.h

@@ -9,6 +9,6 @@ bool ffParseBatteryCommandOptions(FFBatteryOptions* options, const char* key, co
 void ffDestroyBatteryOptions(FFBatteryOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseBatteryJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseBatteryJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/bios/bios.c

@@ -68,7 +68,7 @@ void ffDestroyBiosOptions(FFBiosOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseBiosJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseBiosJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_BIOS_MODULE_NAME) != 0)
         return false;
@@ -76,15 +76,18 @@ bool ffParseBiosJsonObject(FFinstance* instance, const char* type, JSONCData* da
     FFBiosOptions __attribute__((__cleanup__(ffDestroyBiosOptions))) options;
     ffInitBiosOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(instance, FF_BIOS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintBios(instance, &options);

src/modules/bios/bios.h

@@ -8,6 +8,6 @@ bool ffParseBiosCommandOptions(FFBiosOptions* options, const char* key, const ch
 void ffDestroyBiosOptions(FFBiosOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseBiosJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseBiosJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/bluetooth/bluetooth.c

@@ -89,7 +89,7 @@ void ffDestroyBluetoothOptions(FFBluetoothOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseBluetoothJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseBluetoothJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_BLUETOOTH_MODULE_NAME) != 0)
         return false;
@@ -97,21 +97,24 @@ bool ffParseBluetoothJsonObject(FFinstance* instance, const char* type, JSONCDat
     FFBluetoothOptions __attribute__((__cleanup__(ffDestroyBluetoothOptions))) options;
     ffInitBluetoothOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
-
-        if (strcasecmp(key, "showConnected") == 0)
+        json_object_object_foreach(module, key, val)
         {
-            options.showDisconnected = data->ffjson_object_get_boolean(val);
-            continue;
-        }
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        ffPrintError(instance, FF_BLUETOOTH_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
+
+            if (strcasecmp(key, "showConnected") == 0)
+            {
+                options.showDisconnected = json_object_get_boolean(val);
+                continue;
+            }
+
+            ffPrintError(instance, FF_BLUETOOTH_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintBluetooth(instance, &options);

src/modules/bluetooth/bluetooth.h

@@ -8,6 +8,6 @@ bool ffParseBluetoothCommandOptions(FFBluetoothOptions* options, const char* key
 void ffDestroyBluetoothOptions(FFBluetoothOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseBluetoothJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseBluetoothJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/board/board.c

@@ -66,7 +66,7 @@ void ffDestroyBoardOptions(FFBoardOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseBoardJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseBoardJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_BOARD_MODULE_NAME) != 0)
         return false;
@@ -74,15 +74,18 @@ bool ffParseBoardJsonObject(FFinstance* instance, const char* type, JSONCData* d
     FFBoardOptions __attribute__((__cleanup__(ffDestroyBoardOptions))) options;
     ffInitBoardOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_BOARD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(instance, FF_BOARD_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintBoard(instance, &options);

src/modules/board/board.h

@@ -8,6 +8,6 @@ bool ffParseBoardCommandOptions(FFBoardOptions* options, const char* key, const
 void ffDestroyBoardOptions(FFBoardOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseBoardJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseBoardJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/break/break.c

@@ -11,7 +11,7 @@ void ffPrintBreak(FFinstance* instance)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseBreakJsonObject(FFinstance* instance, const char* type, FF_MAYBE_UNUSED JSONCData* data, FF_MAYBE_UNUSED json_object* module)
+bool ffParseBreakJsonObject(FFinstance* instance, const char* type, FF_MAYBE_UNUSED json_object* module)
 {
     if (strcasecmp(type, FF_BREAK_MODULE_NAME) != 0)
         return false;

src/modules/break/break.h

@@ -5,6 +5,6 @@
 void ffPrintBreak(FFinstance* instance);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseBreakJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseBreakJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/brightness/brightness.c

@@ -80,7 +80,7 @@ void ffDestroyBrightnessOptions(FFBrightnessOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseBrightnessJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseBrightnessJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_BRIGHTNESS_MODULE_NAME) != 0)
         return false;
@@ -88,15 +88,18 @@ bool ffParseBrightnessJsonObject(FFinstance* instance, const char* type, JSONCDa
     FFBrightnessOptions __attribute__((__cleanup__(ffDestroyBrightnessOptions))) options;
     ffInitBrightnessOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_BRIGHTNESS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(instance, FF_BRIGHTNESS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintBrightness(instance, &options);

src/modules/brightness/brightness.h

@@ -8,6 +8,6 @@ bool ffParseBrightnessCommandOptions(FFBrightnessOptions* options, const char* k
 void ffDestroyBrightnessOptions(FFBrightnessOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseBrightnessJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseBrightnessJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/command/command.c

@@ -85,7 +85,7 @@ void ffDestroyCommandOptions(FFCommandOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseCommandJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseCommandJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_COMMAND_MODULE_NAME) != 0)
         return false;
@@ -93,27 +93,30 @@ bool ffParseCommandJsonObject(FFinstance* instance, const char* type, JSONCData*
     FFCommandOptions __attribute__((__cleanup__(ffDestroyCommandOptions))) options;
     ffInitCommandOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
-
-        if (strcasecmp(key, "shell") == 0)
+        json_object_object_foreach(module, key, val)
         {
-            ffStrbufSetS(&options.shell, data->ffjson_object_get_string(val));
-            continue;
-        }
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (strcasecmp(key, "text") == 0)
-        {
-            ffStrbufSetS(&options.text, data->ffjson_object_get_string(val));
-            continue;
-        }
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_COMMAND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            if (strcasecmp(key, "shell") == 0)
+            {
+                ffStrbufSetS(&options.shell, json_object_get_string(val));
+                continue;
+            }
+
+            if (strcasecmp(key, "text") == 0)
+            {
+                ffStrbufSetS(&options.text, json_object_get_string(val));
+                continue;
+            }
+
+            ffPrintError(instance, FF_COMMAND_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintCommand(instance, &options);

src/modules/command/command.h

@@ -8,6 +8,6 @@ bool ffParseCommandCommandOptions(FFCommandOptions* options, const char* key, co
 void ffDestroyCommandOptions(FFCommandOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseCommandJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseCommandJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/datetime/datetime.c

@@ -71,7 +71,7 @@ void ffDestroyDateTimeOptions(FFDateTimeOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseDateTimeJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseDateTimeJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_DATETIME_MODULE_NAME) != 0)
         return false;
@@ -79,15 +79,18 @@ bool ffParseDateTimeJsonObject(FFinstance* instance, const char* type, JSONCData
     FFDateTimeOptions __attribute__((__cleanup__(ffDestroyDateTimeOptions))) options;
     ffInitDateTimeOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_DATETIME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(instance, FF_DATETIME_DISPLAY_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintDateTime(instance, &options);

src/modules/datetime/datetime.h

@@ -8,6 +8,6 @@ bool ffParseDateTimeCommandOptions(FFDateTimeOptions* options, const char* key,
 void ffDestroyDateTimeOptions(FFDateTimeOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseDateTimeJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseDateTimeJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/display/display.c

@@ -159,7 +159,7 @@ void ffDestroyDisplayOptions(FFDisplayOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseDisplayJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseDisplayJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_DISPLAY_MODULE_NAME) != 0)
         return false;
@@ -167,43 +167,46 @@ bool ffParseDisplayJsonObject(FFinstance* instance, const char* type, JSONCData*
     FFDisplayOptions __attribute__((__cleanup__(ffDestroyDisplayOptions))) options;
     ffInitDisplayOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
-
-        if (strcasecmp(key, "compactType") == 0)
+        json_object_object_foreach(module, key, val)
         {
-            int value;
-            const char* error = ffJsonConfigParseEnum(data, val, &value, (FFKeyValuePair[]) {
-                { "none", FF_DISPLAY_COMPACT_TYPE_NONE },
-                { "original", FF_DISPLAY_COMPACT_TYPE_ORIGINAL_BIT },
-                { "scaled", FF_DISPLAY_COMPACT_TYPE_SCALED_BIT },
-                {},
-            });
-            if (error)
-                ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
-            else
-                options.compactType = (FFDisplayCompactType) value;
-            continue;
-        }
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (strcasecmp(key, "detectName") == 0)
-        {
-            options.detectName = data->ffjson_object_get_boolean(val);
-            continue;
-        }
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        if (strcasecmp(key, "preciseRefreshRate") == 0)
-        {
-            options.preciseRefreshRate = data->ffjson_object_get_boolean(val);
-            continue;
-        }
+            if (strcasecmp(key, "compactType") == 0)
+            {
+                int value;
+                const char* error = ffJsonConfigParseEnum(val, &value, (FFKeyValuePair[]) {
+                    { "none", FF_DISPLAY_COMPACT_TYPE_NONE },
+                    { "original", FF_DISPLAY_COMPACT_TYPE_ORIGINAL_BIT },
+                    { "scaled", FF_DISPLAY_COMPACT_TYPE_SCALED_BIT },
+                    {},
+                });
+                if (error)
+                    ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Invalid %s value: %s", key, error);
+                else
+                    options.compactType = (FFDisplayCompactType) value;
+                continue;
+            }
 
-        ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            if (strcasecmp(key, "detectName") == 0)
+            {
+                options.detectName = json_object_get_boolean(val);
+                continue;
+            }
+
+            if (strcasecmp(key, "preciseRefreshRate") == 0)
+            {
+                options.preciseRefreshRate = json_object_get_boolean(val);
+                continue;
+            }
+
+            ffPrintError(instance, FF_DISPLAY_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintDisplay(instance, &options);

src/modules/display/display.h

@@ -8,6 +8,6 @@ bool ffParseDisplayCommandOptions(FFDisplayOptions* options, const char* key, co
 void ffDestroyDisplayOptions(FFDisplayOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseDisplayJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseDisplayJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/host/host.c

@@ -77,7 +77,7 @@ void ffDestroyHostOptions(FFHostOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseHostJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseHostJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_HOST_MODULE_NAME) != 0)
         return false;
@@ -85,15 +85,18 @@ bool ffParseHostJsonObject(FFinstance* instance, const char* type, JSONCData* da
     FFHostOptions __attribute__((__cleanup__(ffDestroyHostOptions))) options;
     ffInitHostOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(instance, FF_HOST_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintHost(instance, &options);

src/modules/host/host.h

@@ -8,6 +8,6 @@ bool ffParseHostCommandOptions(FFHostOptions* options, const char* key, const ch
 void ffDestroyHostOptions(FFHostOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseHostJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseHostJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/jsonconfig/jsonconfig.c

@@ -1,71 +1,59 @@
 #include "modules/jsonconfig/jsonconfig.h"
-#include "common/config.h"
+#include "common/jsonconfig.h"
 #include "common/printing.h"
 
 #ifdef FF_HAVE_JSONC
 
 #include "common/io/io.h"
+#include "common/json.h"
 #include "modules/modules.h"
 
 #include <assert.h>
 
-static inline bool parseModuleJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+static inline bool parseModuleJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     return
-        ffParseTitleJsonObject(instance, type, data, module) ||
-        ffParseBatteryJsonObject(instance, type, data, module) ||
-        ffParseBiosJsonObject(instance, type, data, module) ||
-        ffParseBluetoothJsonObject(instance, type, data, module) ||
-        ffParseBoardJsonObject(instance, type, data, module) ||
-        ffParseBreakJsonObject(instance, type, data, module) ||
-        ffParseBrightnessJsonObject(instance, type, data, module) ||
-        ffParseCommandJsonObject(instance, type, data, module) ||
-        ffParseDateTimeJsonObject(instance, type, data, module) ||
-        ffParseDisplayJsonObject(instance, type, data, module) ||
-        ffParseHostJsonObject(instance, type, data, module) ||
-        ffParseKernelJsonObject(instance, type, data, module) ||
-        ffParseOSJsonObject(instance, type, data, module) ||
-        ffParseSeparatorJsonObject(instance, type, data, module) ||
+        ffParseTitleJsonObject(instance, type, module) ||
+        ffParseBatteryJsonObject(instance, type, module) ||
+        ffParseBiosJsonObject(instance, type, module) ||
+        ffParseBluetoothJsonObject(instance, type, module) ||
+        ffParseBoardJsonObject(instance, type, module) ||
+        ffParseBreakJsonObject(instance, type, module) ||
+        ffParseBrightnessJsonObject(instance, type, module) ||
+        ffParseCommandJsonObject(instance, type, module) ||
+        ffParseDateTimeJsonObject(instance, type, module) ||
+        ffParseDisplayJsonObject(instance, type, module) ||
+        ffParseHostJsonObject(instance, type, module) ||
+        ffParseKernelJsonObject(instance, type, module) ||
+        ffParseOSJsonObject(instance, type, module) ||
+        ffParseSeparatorJsonObject(instance, type, module) ||
         false;
 }
 
-typedef struct JsonConfigData
+static const char* parseModules(FFinstance* instance, json_object* modules)
 {
-    JSONCData data;
-    json_object* root;
-} JsonConfigData;
-
-static inline void wrapJsoncFree(JsonConfigData* jsonConfig)
-{
-    assert(jsonConfig);
-    if (jsonConfig->root)
-        jsonConfig->data.ffjson_object_put(jsonConfig->root);
-}
-
-static const char* parseModules(FFinstance* instance, JSONCData* data, json_object* modules)
-{
-    array_list* list = data->ffjson_object_get_array(modules);
+    array_list* list = json_object_get_array(modules);
     if (!list) return "modules must be an array of strings or objects";
 
     for (size_t idx = 0; idx < list->length; ++idx)
     {
         json_object* module = (json_object*) list->array[idx];
         const char* type = NULL;
-        if (data->ffjson_object_is_type(module, json_type_string))
+        if (json_object_is_type(module, json_type_string))
         {
-            type = data->ffjson_object_get_string(module);
+            type = json_object_get_string(module);
             module = NULL;
         }
-        else if (data->ffjson_object_is_type(module, json_type_object))
+        else if (json_object_is_type(module, json_type_object))
         {
-            json_object* object = data->ffjson_object_object_get(module, "type");
-            type = data->ffjson_object_get_string(object);
+            json_object* object = json_object_object_get(module, "type");
+            type = json_object_get_string(object);
             if (!type) return "module object must contain a type key";
         }
         else
             return "modules must be an array of strings or objects";
 
-        if(!parseModuleJsonObject(instance, type, data, module))
+        if(!parseModuleJsonObject(instance, type, module))
             return "Unknown module type";
     }
 
@@ -74,26 +62,8 @@ static const char* parseModules(FFinstance* instance, JSONCData* data, json_obje
 
 static const char* printJsonConfig(FFinstance* instance)
 {
-    FF_LIBRARY_LOAD(libjsonc, &instance->config.libJSONC, "dlopen libjson-c" FF_LIBRARY_EXTENSION" failed",
-        #ifdef _WIN32
-            "libjson-c-5" FF_LIBRARY_EXTENSION, -1
-        #else
-            "libjson-c" FF_LIBRARY_EXTENSION, 5
-        #endif
-    )
-    JsonConfigData __attribute__((__cleanup__(wrapJsoncFree))) jsonConfig = {};
-    JSONCData* data = &jsonConfig.data;
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_tokener_parse)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_is_type)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_array)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_boolean)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_double)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_int)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_string_len)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_string)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_get_object)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_object_get)
-    FF_LIBRARY_LOAD_SYMBOL_VAR_MESSAGE(libjsonc, *data, json_object_put)
+    if (!ffJsonLoadLibrary(instance))
+        return "Failed to load json-c library";
 
     FF_STRBUF_AUTO_DESTROY content;
     ffStrbufInit(&content);
@@ -106,11 +76,11 @@ static const char* printJsonConfig(FFinstance* instance)
         if (success) break;
     }
 
-    jsonConfig.root = data->ffjson_tokener_parse(content.chars);
-    if (!jsonConfig.root)
+    json_object* __attribute__((__cleanup__(wrapJsoncFree))) root = json_tokener_parse(content.chars);
+    if (!root)
         return "Failed to parse JSON config file";
 
-    lh_table* rootObject = data->ffjson_object_get_object(jsonConfig.root);
+    lh_table* rootObject = json_object_get_object(root);
     if (!rootObject)
         return "Invalid JSON config format. Root value must be an object";
 
@@ -118,11 +88,11 @@ static const char* printJsonConfig(FFinstance* instance)
     lh_foreach(rootObject, entry)
     {
         const char* key = (const char *)lh_entry_k(entry);
-        json_object* val = (struct json_object *)lh_entry_v(entry);
+        json_object* val = (json_object *)lh_entry_v(entry);
 
         if (strcmp(key, "modules") == 0)
         {
-            const char* error = parseModules(instance, data, val);
+            const char* error = parseModules(instance, val);
             if (error) return error;
         }
         else

src/modules/kernel/kernel.c

@@ -52,7 +52,7 @@ void ffDestroyKernelOptions(FFKernelOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseKernelJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseKernelJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_KERNEL_MODULE_NAME) != 0)
         return false;
@@ -60,15 +60,18 @@ bool ffParseKernelJsonObject(FFinstance* instance, const char* type, JSONCData*
     FFKernelOptions __attribute__((__cleanup__(ffDestroyKernelOptions))) options;
     ffInitKernelOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
 
-        ffPrintError(instance, FF_KERNEL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            ffPrintError(instance, FF_KERNEL_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintKernel(instance, &options);

src/modules/kernel/kernel.h

@@ -9,6 +9,6 @@ bool ffParseKernelCommandOptions(FFKernelOptions* options, const char* key, cons
 void ffDestroyKernelOptions(FFKernelOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseKernelJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseKernelJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/os/os.c

@@ -175,7 +175,7 @@ void ffDestroyOSOptions(FFOSOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseOSJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseOSJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_OS_MODULE_NAME) != 0)
         return false;
@@ -183,23 +183,26 @@ bool ffParseOSJsonObject(FFinstance* instance, const char* type, JSONCData* data
     FFOSOptions __attribute__((__cleanup__(ffDestroyOSOptions))) options;
     ffInitOSOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (ffJsonConfigParseModuleArgs(data, key, val, &options.moduleArgs))
-            continue;
-
-        #if defined(__linux__) || defined(__FreeBSD__)
-            if (strcasecmp(key, "file") == 0)
-            {
-                ffStrbufSetS(&options.file, data->ffjson_object_get_string(val));
+        json_object_object_foreach(module, key, val)
+        {
+            if (strcasecmp(key, "type") == 0)
                 continue;
-            }
-        #endif
 
-        ffPrintError(instance, FF_OS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+            if (ffJsonConfigParseModuleArgs(key, val, &options.moduleArgs))
+                continue;
+
+            #if defined(__linux__) || defined(__FreeBSD__)
+                if (strcasecmp(key, "file") == 0)
+                {
+                    ffStrbufSetS(&options.file, json_object_get_string(val));
+                    continue;
+                }
+            #endif
+
+            ffPrintError(instance, FF_OS_MODULE_NAME, 0, &options.moduleArgs, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintOS(instance, &options);

src/modules/os/os.h

@@ -9,6 +9,6 @@ bool ffParseOSCommandOptions(FFOSOptions* options, const char* key, const char*
 void ffDestroyOSOptions(FFOSOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseOSJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseOSJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/separator/separator.c

@@ -61,7 +61,7 @@ void ffDestroySeparatorOptions(FFSeparatorOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseSeparatorJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseSeparatorJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_SEPARATOR_MODULE_NAME) != 0)
         return false;
@@ -69,18 +69,21 @@ bool ffParseSeparatorJsonObject(FFinstance* instance, const char* type, JSONCDat
     FFSeparatorOptions __attribute__((__cleanup__(ffDestroySeparatorOptions))) options;
     ffInitSeparatorOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (strcasecmp(key, "string") == 0)
+        json_object_object_foreach(module, key, val)
         {
-            ffStrbufSetS(&options.string, data->ffjson_object_get_string(val));
-            continue;
-        }
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        ffPrintErrorString(instance, FF_SEPARATOR_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+            if (strcasecmp(key, "string") == 0)
+            {
+                ffStrbufSetS(&options.string, json_object_get_string(val));
+                continue;
+            }
+
+            ffPrintErrorString(instance, FF_SEPARATOR_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintSeparator(instance, &options);

src/modules/separator/separator.h

@@ -9,6 +9,6 @@ bool ffParseSeparatorCommandOptions(FFSeparatorOptions* options, const char* key
 void ffDestroySeparatorOptions(FFSeparatorOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseSeparatorJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseSeparatorJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif

src/modules/title/title.c

@@ -61,7 +61,7 @@ void ffDestroyTitleOptions(FFTitleOptions* options)
 }
 
 #ifdef FF_HAVE_JSONC
-bool ffParseTitleJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module)
+bool ffParseTitleJsonObject(FFinstance* instance, const char* type, json_object* module)
 {
     if (strcasecmp(type, FF_TITLE_MODULE_NAME) != 0)
         return false;
@@ -69,18 +69,21 @@ bool ffParseTitleJsonObject(FFinstance* instance, const char* type, JSONCData* d
     FFTitleOptions __attribute__((__cleanup__(ffDestroyTitleOptions))) options;
     ffInitTitleOptions(&options);
 
-    FF_JSON_OBJECT_OBJECT_FOREACH(data, module, key, val)
+    if (module)
     {
-        if (strcasecmp(key, "type") == 0)
-            continue;
-
-        if (strcasecmp(key, "fdqn") == 0)
+        json_object_object_foreach(module, key, val)
         {
-            options.fdqn = data->ffjson_object_get_boolean(val);
-            continue;
-        }
+            if (strcasecmp(key, "type") == 0)
+                continue;
 
-        ffPrintErrorString(instance, FF_TITLE_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+            if (strcasecmp(key, "fdqn") == 0)
+            {
+                options.fdqn = json_object_get_boolean(val);
+                continue;
+            }
+
+            ffPrintErrorString(instance, FF_TITLE_MODULE_NAME, 0, NULL, NULL, "Unknown JSON key %s", key);
+        }
     }
 
     ffPrintTitle(instance, &options);

src/modules/title/title.h

@@ -9,6 +9,6 @@ bool ffParseTitleCommandOptions(FFTitleOptions* options, const char* key, const
 void ffDestroyTitleOptions(FFTitleOptions* options);
 
 #ifdef FF_HAVE_JSONC
-#include "common/config.h"
-bool ffParseTitleJsonObject(FFinstance* instance, const char* type, JSONCData* data, json_object* module);
+#include "common/jsonconfig.h"
+bool ffParseTitleJsonObject(FFinstance* instance, const char* type, json_object* module);
 #endif