Feature/remove json from config (#70)

* config: uses plain struct instead of json object

* utils: changed functions to use string_view

* remove cereal includes from avocado core

* config: moved json parser to platform/windows package

Author: JaCzekanski

premake5.lua

@@ -48,6 +48,15 @@ filter "options:ubsan"
 	buildoptions {"-fsanitize=undefined"}
 	linkoptions {"-fsanitize=undefined"}
 
+newoption {
+	trigger = "time-trace",
+	description = "Build with -ftime-trace (clang only)"
+}
+filter "options:time-trace"
+	buildoptions {"-ftime-trace"}
+	linkoptions {"-ftime-trace"}
+
+
 filter {}
 	language "c++"
 	cppdialect "C++17"

src/bios/functions.cpp

@@ -9,22 +9,20 @@
 
 namespace bios {
 
-Function::Function(const std::string& prototype, std::function<bool(System* sys)> callback) : callback(callback) {
+Function::Function(std::string_view prototype, std::function<bool(System* sys)> callback) : callback(callback) {
     auto argStart = prototype.find('(');
     auto argEnd = prototype.find(')');
 
-    assert(argStart != std::string::npos && argEnd != std::string::npos);
-    std::string sArgs = prototype.substr(argStart + 1, argEnd - argStart - 1);
-    std::vector<std::string> args = split(sArgs, ", ");  // TODO: do trimming
+    assert(argStart != std::string_view::npos && argEnd != std::string_view::npos);
+    auto sArgs = prototype.substr(argStart + 1, argEnd - argStart - 1);
+    auto args = split(sArgs, ", ");
 
-    std::string sFuncName = prototype.substr(0, argStart);
-
-    this->name = sFuncName.c_str();
+    this->name = prototype.substr(0, argStart);
     for (auto sArg : args) {
         sArg = trim(sArg);
         auto delim = sArg.find_last_of(' ');
 
-        if (delim == std::string::npos) {
+        if (delim == std::string_view::npos) {
             throw std::runtime_error(fmt::format("{} -> Invalid parameter without type", prototype));
         }
 
@@ -363,7 +361,7 @@ const std::unordered_map<uint8_t, Function> B0 = {
 };
 
 const std::unordered_map<uint8_t, Function> C0 = {
-    //
+
     {0x00, {"EnqueueTimerAndVblankIrqs(int priority)"}},
     {0x01, {"EnqueueSyscallHandler(int priority)"}},
     {0x02, {"SysEnqIntRP(int priority, void* struc)"}},  // ;bugged, use with care
@@ -399,7 +397,7 @@ const std::unordered_map<uint8_t, Function> C0 = {
 const std::array<std::unordered_map<uint8_t, Function>, 3> tables = {{A0, B0, C0}};
 
 const std::unordered_map<uint8_t, Function> SYSCALL = {
-    //
+
     {0x00, {"NoFunction()"}},          {0x01, {"EnterCriticalSection()"}},
     {0x02, {"ExitCriticalSection()"}}, {0x03, {"ChangeThreadSubFunction(int addr)"}},
     {0x04, {"DeliverEvent()"}},

src/bios/functions.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <cstdint>
 #include <functional>
-#include <string>
+#include <string_view>
 #include <unordered_map>
 #include <vector>
 
@@ -18,15 +18,15 @@ enum class Type {
 
 struct Arg {
     Type type;
-    std::string name;
+    std::string_view name;
 };
 
 struct Function {
-    std::string name;
+    std::string_view name;
     std::vector<Arg> args;
     std::function<bool(System* sys)> callback;
 
-    Function(const std::string& prototype, std::function<bool(System* sys)> callback = nullptr);
+    Function(std::string_view prototype, std::function<bool(System* sys)> callback = nullptr);
 };
 
 extern const std::unordered_map<uint8_t, Function> A0;

src/config.cpp

@@ -1,12 +1,9 @@
 #include "config.h"
 #include <fmt/core.h>
-#include "utils/file.h"
-
-const char* CONFIG_NAME = "config.json";
 
 namespace DefaultKeyBindings {
 // clang-format off
-json none() {
+KeyBindings none() {
     return {
         {"dpad_up",    ""},
         {"dpad_right", ""},
@@ -36,7 +33,7 @@ json none() {
     };
 }
 
-json keyboard_wadx() {
+KeyBindings keyboard_wadx() {
     return {
         {"dpad_up",    "keyboard|Up"},
         {"dpad_right", "keyboard|Right"},
@@ -65,7 +62,7 @@ json keyboard_wadx() {
         {"r_left",     ""},
     };
 }
-json keyboard_numpad() {
+KeyBindings keyboard_numpad() {
     return {
         {"dpad_up",    "keyboard|Up"},
         {"dpad_right", "keyboard|Right"},
@@ -95,7 +92,7 @@ json keyboard_numpad() {
     };
 }
 
-json controller(int n) {
+KeyBindings controller(int n) {
     auto C = [n](const char* key) {
         return fmt::format("controller{}|{}", n, key);
     };
@@ -128,7 +125,7 @@ json controller(int n) {
     };
 }
 
-json mouse() {
+KeyBindings mouse() {
     return {
         {"dpad_up",    ""},
         {"dpad_right", ""},
@@ -160,103 +157,5 @@ json mouse() {
 // clang-format on
 }  // namespace DefaultKeyBindings
 
-// clang-format off
-const json defaultConfig = {
-	{"bios", ""},
-	{"extension", ""},
-	{"iso", ""},
-    {"controller", {
-        {"1", {
-            {"type", ControllerType::analog},
-            {"keys", DefaultKeyBindings::keyboard_numpad()}
-        }},
-        {"2", {
-            {"type", ControllerType::none},
-            {"keys", DefaultKeyBindings::none()}
-        }}
-    }},
-    {"options", {
-        {"graphics", {
-            {"rendering_mode", RenderingMode::software},
-            {"widescreen", false},
-            {"forceWidescreen", false},
-            {"resolution", {
-                {"width", 640u},
-                {"height", 480u}
-            }},
-            {"vsync", false},
-            {"forceNtsc", false},
-        }},
-        {"sound", {
-            {"enabled", true},
-        }},
-        {"emulator", {
-            {"preserveState", true},
-            {"timeTravel", true},
-        }},
-    }},
-    {"debug", {
-        {"log", {
-            { "bios",  0u },
-            { "cdrom", 0u },
-            { "controller", 0u },
-            { "dma", 0u },
-            { "gpu", 0u },
-            { "gte", 0u },
-            { "mdec", 0u },
-            { "memoryCard", 0u },
-            { "spu", 0u },
-            { "system", 1u },
-        }}
-    }},
-    {"memoryCard", {
-        {"1", "data/memory/card1.mcr"},
-        {"2", ""}
-    }},
-    {"gui", {
-        {"lastPath", ""},
-    }},
-};
-// clang-format on
-
-json config = defaultConfig;
-
-json fixObject(json oldconfig, json newconfig) {
-    for (auto oldField = oldconfig.begin(); oldField != oldconfig.end(); ++oldField) {
-        auto newField = newconfig.find(oldField.key());
-
-        // Add nonexisting fields
-        if (newField == newconfig.end()) {
-            newconfig.emplace(oldField.key(), oldField.value());
-            continue;
-        }
-
-        // Repair these with invalid types
-        if (newField.value().type() != oldField.value().type()) {
-            newconfig[oldField.key()] = oldField.value();
-            continue;
-        }
-
-        // If field is an object or an array - fix it recursively
-        if (newField.value().is_object() || newField.value().is_array()) {
-            newconfig[oldField.key()] = fixObject(oldField.value(), newField.value());
-        }
-    }
-    return newconfig;
-}
-
-void saveConfigFile(const char* configName) { putFileContents(configName, config.dump(4)); }
-
-void loadConfigFile(const char* configName) {
-    auto file = getFileContents(configName);
-    if (file.empty()) {
-        saveConfigFile(configName);
-        return;
-    }
-    nlohmann::json newconfig = json::parse(file.begin(), file.end());
-
-    // Add missing and repair invalid fields
-    config = fixObject(config, newconfig);
-}
-
-bool isEmulatorConfigured() { return !config["bios"].get<std::string>().empty(); }
+const avocado_config_t defaultConfig;
+avocado_config_t config = defaultConfig;

src/config.h

@@ -1,6 +1,6 @@
 #pragma once
-#include <nlohmann/json.hpp>
 #include <string>
+#include <unordered_map>
 #include "device/controller/controller_type.h"
 #include "device/gpu/rendering_mode.h"
 #include "utils/event.h"
@@ -10,20 +10,87 @@
 #define printf(...) __android_log_print(ANDROID_LOG_DEBUG, "AVOCADO", __VA_ARGS__);
 #endif
 
-using json = nlohmann::json;
+using KeyBindings = std::unordered_map<std::string, std::string>;
 
 namespace DefaultKeyBindings {
-json none();
-json keyboard_wadx();
-json keyboard_numpad();
-json mouse();
-json controller(int n);
+KeyBindings none();
+KeyBindings keyboard_wadx();
+KeyBindings keyboard_numpad();
+KeyBindings mouse();
+KeyBindings controller(int n);
 }  // namespace DefaultKeyBindings
 
-extern const char* CONFIG_NAME;
-extern const nlohmann::json defaultConfig;
-extern nlohmann::json config;
-void saveConfigFile(const char* configName);
-void loadConfigFile(const char* configName);
+struct avocado_config_t {
+    std::string bios = "";
+    std::string extension = "";
+    std::string iso = "";
 
-bool isEmulatorConfigured();
+    struct {
+        ControllerType type;
+        KeyBindings keys;
+    } controller[2]{
+        {
+            ControllerType::analog,
+            DefaultKeyBindings::keyboard_numpad(),
+        },
+        {
+            ControllerType::none,
+            DefaultKeyBindings::none(),
+        },
+    };
+
+    struct {
+        struct {
+            RenderingMode renderingMode = RenderingMode::software;
+            bool widescreen = false;
+            bool forceWidescreen = false;
+            struct {
+                unsigned int width = 640;
+                unsigned int height = 480;
+            } resolution;
+            bool vsync = false;
+            bool forceNtsc = false;
+        } graphics;
+
+        struct {
+            bool enabled = true;
+        } sound;
+
+        struct {
+            bool preserveState = true;
+            bool timeTravel = false;
+        } emulator;
+
+    } options;
+
+    struct {
+        struct {
+            int bios = 0;
+            int cdrom = 0;
+            int controller = 0;
+            int dma = 0;
+            int gpu = 0;
+            int gte = 0;
+            int mdec = 0;
+            int memoryCard = 0;
+            int spu = 0;
+            int system = 1;
+        } log;
+    } debug;
+
+    struct {
+        std::string path;
+    } memoryCard[2]{
+        {"data/memory/card1.mcr"},  //
+        {""},                       //
+    };
+
+    struct {
+        std::string lastPath = "";
+    } gui;
+
+    // Methods
+    bool isEmulatorConfigured() const { return !bios.empty(); }
+};
+
+extern avocado_config_t config;

src/cpu/gte/gte.cpp

@@ -17,8 +17,8 @@ constexpr std::array<uint8_t, 0x101> GTE::generateUnrTable() {
 }
 
 void GTE::reload() {
-    widescreenHack = config["options"]["graphics"]["forceWidescreen"];
-    logging = config["debug"]["log"]["gte"].get<int>();
+    widescreenHack = config.options.graphics.forceWidescreen;
+    logging = config.debug.log.gte;
 }
 
 uint32_t GTE::read(uint8_t n) {

src/device/cdrom/cdrom.cpp

@@ -12,7 +12,7 @@ namespace device {
 namespace cdrom {
 
 CDROM::CDROM(System* sys) : sys(sys) {
-    verbose = config["debug"]["log"]["cdrom"];
+    verbose = config.debug.log.cdrom;
     disc = std::make_unique<disc::Empty>();
 }
 

src/device/controller/controller.cpp

@@ -54,7 +54,7 @@ Controller::~Controller() { bus.unlistenAll(busToken); }
 void Controller::reload() {
     auto createDevice = [](int num) -> std::unique_ptr<peripherals::AbstractDevice> {
         num += 1;
-        ControllerType type = config["controller"][std::to_string(num)]["type"];
+        ControllerType type = config.controller[num - 1].type;
         if (type == ControllerType::digital) {
             return std::make_unique<peripherals::DigitalController>(num);
         } else if (type == ControllerType::analog) {

src/device/controller/controller_type.h

@@ -1,11 +1,7 @@
 #pragma once
-#include "utils/json_enum.h"
-
 enum class ControllerType {
     none,
     digital,
     analog,
     mouse,
-};
-
-JSON_ENUM(ControllerType);
+};