From cc252447d52434af019d094cff82993e955c270f Mon Sep 17 00:00:00 2001
From: momo5502 <mauriceheumann@gmail.com>
Date: Sat, 18 Jan 2025 12:39:29 +0100
Subject: [PATCH] Multiple fixes

---
 src/common/utils/string.hpp                   | 58 ++++++++++++-------
 src/gdb-stub/async_handler.cpp                |  3 +
 src/gdb-stub/gdb_stub.cpp                     |  4 +-
 .../debugging/x64_gdb_stub_handler.hpp        |  3 +-
 4 files changed, 45 insertions(+), 23 deletions(-)

diff --git a/src/common/utils/string.hpp b/src/common/utils/string.hpp
index 13bf4ab0..7a3cb30c 100644
--- a/src/common/utils/string.hpp
+++ b/src/common/utils/string.hpp
@@ -2,7 +2,6 @@
 #include <span>
 #include <string>
 #include <cstddef>
-#include <sstream>
 #include <cwctype>
 #include <algorithm>
 
@@ -47,49 +46,66 @@ namespace utils::string
         return to_lower(std::move(str));
     }
 
-    template <typename Integer>
-        requires(std::is_integral_v<Integer>)
-    std::string to_hex_string(const Integer& i)
+    inline char to_nibble(std::byte value, const bool uppercase = false)
     {
-        std::stringstream stream{};
-        stream << std::hex << i;
-        return stream.str();
+        value = value & static_cast<std::byte>(0xF);
+
+        if (value <= static_cast<std::byte>(9))
+        {
+            return static_cast<char>('0' + static_cast<char>(value));
+        }
+
+        return static_cast<char>((uppercase ? 'A' : 'a') + (static_cast<char>(value) - 0xA));
     }
 
-    inline std::string to_hex_string(const void* data, const size_t size)
+    inline std::pair<char, char> to_hex(const std::byte value, const bool uppercase = false)
     {
-        std::stringstream stream{};
-        stream << std::hex;
+        return {to_nibble(value >> 4, uppercase), to_nibble(value, uppercase)};
+    }
+
+    inline std::string to_hex_string(const void* data, const size_t size, const bool uppercase = false)
+    {
+        std::string result{};
+        result.reserve(size * 2);
 
         for (size_t i = 0; i < size; ++i)
         {
-            const auto value = static_cast<const uint8_t*>(data)[i];
-            stream << value;
+            const auto value = static_cast<const std::byte*>(data)[i];
+            const auto [high, low] = to_hex(value, uppercase);
+            result.push_back(high);
+            result.push_back(low);
         }
 
-        return stream.str();
+        return result;
     }
 
-    inline std::string to_hex_string(const std::span<std::byte> data)
+    template <typename Integer>
+        requires(std::is_integral_v<Integer>)
+    std::string to_hex_string(const Integer& i, const bool uppercase = false)
     {
-        return to_hex_string(data.data(), data.size());
+        return to_hex_string(&i, sizeof(Integer), uppercase);
     }
 
-    inline uint8_t parse_nibble(const char nibble)
+    inline std::string to_hex_string(const std::span<std::byte> data, const bool uppercase = false)
+    {
+        return to_hex_string(data.data(), data.size(), uppercase);
+    }
+
+    inline std::byte parse_nibble(const char nibble)
     {
         const auto lower = char_to_lower(nibble);
 
         if (lower >= '0' && lower <= '9')
         {
-            return static_cast<uint8_t>(lower - '0');
+            return static_cast<std::byte>(lower - '0');
         }
 
         if (lower >= 'a' && lower <= 'f')
         {
-            return static_cast<uint8_t>(lower - 'a');
+            return static_cast<std::byte>(lower - 'a');
         }
 
-        return 0;
+        return static_cast<std::byte>(0);
     }
 
     inline std::vector<std::byte> from_hex_string(const std::string_view str)
@@ -97,13 +113,13 @@ namespace utils::string
         const auto size = str.size() / 2;
 
         std::vector<std::byte> data{};
-        data.resize(size);
+        data.reserve(size);
 
         for (size_t i = 0; i < size; ++i)
         {
             const auto high = parse_nibble(str[i * 2 + 0]);
             const auto low = parse_nibble(str[i * 2 + 1]);
-            const auto value = static_cast<std::byte>((high << 4) | low);
+            const auto value = (high << 4) | low;
 
             data.push_back(value);
         }
diff --git a/src/gdb-stub/async_handler.cpp b/src/gdb-stub/async_handler.cpp
index 4af41429..9560a3b3 100644
--- a/src/gdb-stub/async_handler.cpp
+++ b/src/gdb-stub/async_handler.cpp
@@ -9,6 +9,9 @@ namespace gdb_stub
         : handler_(std::move(h))
     {
         this->stop_ = false;
+        this->runner_ = std::thread([this] {
+            this->work(); //
+        });
     }
 
     async_handler::~async_handler()
diff --git a/src/gdb-stub/gdb_stub.cpp b/src/gdb-stub/gdb_stub.cpp
index 0ff6053b..ad643428 100644
--- a/src/gdb-stub/gdb_stub.cpp
+++ b/src/gdb-stub/gdb_stub.cpp
@@ -212,7 +212,7 @@ namespace gdb_stub
                                   const std::string& payload)
         {
             size_t reg{};
-            rt_assert(sscanf_s(payload.c_str(), "%zx", &reg) == 3);
+            rt_assert(sscanf_s(payload.c_str(), "%zx", &reg) == 1);
 
             std::vector<std::byte> data{};
             data.resize(handler.get_max_register_size());
@@ -368,10 +368,12 @@ namespace gdb_stub
                 async.run();
                 process_action(connection, handler.run());
                 async.pause();
+                connection.send_reply("S05");
                 break;
 
             case 's':
                 process_action(connection, handler.singlestep());
+                connection.send_reply("S05");
                 break;
 
             case 'q':
diff --git a/src/windows-emulator/debugging/x64_gdb_stub_handler.hpp b/src/windows-emulator/debugging/x64_gdb_stub_handler.hpp
index e5e147cc..fa4a15a7 100644
--- a/src/windows-emulator/debugging/x64_gdb_stub_handler.hpp
+++ b/src/windows-emulator/debugging/x64_gdb_stub_handler.hpp
@@ -103,7 +103,8 @@ class x64_gdb_stub_handler : public gdb_stub::gdb_stub_handler
 
     size_t get_max_register_size() override
     {
-        return 256 / 8;
+        // return 256 / 8;
+        return 64 / 8;
     }
 
     bool read_register(const size_t reg, void* data, const size_t max_length) override