Move game argument parsing to WinMain level

Separate Syringe arguments from target game arguments at the earliest
stage by splitting on `--` delimiter in `GetArguments()`. This prevents
the shell argument parser from interpreting game arguments, allowing
them to be passed through as-is to the target process.

Changes:
- Add `Arguments` struct containing both Syringe and game arguments
- Split command line on ` -- ` in `GetArguments()` before parsing
- Remove `--` delimiter handling from `parse_command_line()`
- Remove `game_arguments` field from `argument_set` struct
- Convert game arguments directly from wide string to UTF-8
- Preserve exact game argument formatting without shell interpretation

Signed-off-by: 舰队的偶像-岛风酱 <frg2089@outlook.com>

Author: frg2089

Main.cpp

@@ -8,11 +8,29 @@
 #include <commctrl.h>
 #include <shellapi.h>
 
-std::vector<std::string> GetArguments()
+struct Arguments {
+    std::vector<std::string> syringe_args;
+    std::string game_args;
+};
+
+Arguments GetArguments()
 {
+    std::wstring wszSyringeArgs;
+    std::wstring wszGameArgs;
+    std::wstring lpCmdLine = GetCommandLineW();
+    auto separator = lpCmdLine.find(L" -- ");
+    if (separator == std::wstring::npos) {
+        wszSyringeArgs = lpCmdLine.substr(0, separator);
+        wszGameArgs = lpCmdLine.substr(separator + 4);
+    }
+    else {
+        wszSyringeArgs = lpCmdLine;
+        wszGameArgs = L"";
+    }
+
     // Get argc, argv in wide chars
     int argc = 0;
-    LPWSTR* argvW = CommandLineToArgvW(GetCommandLineW(), &argc);
+    LPWSTR* argvW = CommandLineToArgvW(wszSyringeArgs.c_str(), &argc);
 
     // Convert to UTF-8. Skip the first argument as it contains the path to Syringe itself
     std::vector<std::string> argv(argc - 1);
@@ -25,10 +43,18 @@ std::vector<std::string> GetArguments()
 
     LocalFree(argvW);
 
-    return argv;
+
+    int len = WideCharToMultiByte(CP_UTF8, 0, wszGameArgs.c_str(), -1, nullptr, 0, nullptr, nullptr);
+    std::string gameArgs = std::string(len - 1, '\0');
+    WideCharToMultiByte(CP_UTF8, 0, wszGameArgs.c_str(), -1, gameArgs.data(), len, nullptr, nullptr);
+
+    return {
+        argv,
+        gameArgs,
+    };
 }
 
-int Run(const std::vector<std::string>& arguments)
+int Run(const Arguments& arguments)
 {
     constexpr auto const VersionString = "SyringeEx " SYRINGEEX_VER_TEXT ", based on Syringe 0.7.2.0";
 
@@ -39,14 +65,14 @@ int Run(const std::vector<std::string>& arguments)
     Log::WriteLine(VersionString);
     Log::WriteLine("===============");
     Log::WriteLine();
-    Log::WriteLine("WinMain: arguments = \"%.*s\"", printable(arguments));
+    Log::WriteLine("WinMain: arguments = \"%.*s\"", printable(arguments.syringe_args));
 
     auto failure = "Could not load executable.";
     auto exit_code = ERROR_ERRORS_ENCOUNTERED;
 
     try
     {
-        auto const command = parse_command_line(arguments);
+        auto const command = parse_command_line(arguments.syringe_args);
 
         Log::WriteLine(
             "WinMain: Trying to load executable file \"%.*s\"...",
@@ -62,10 +88,10 @@ int Run(const std::vector<std::string>& arguments)
 
         Log::WriteLine(
             "WinMain: SyringeDebugger::Run(\"%.*s\");",
-            printable(command.game_arguments));
+            printable(arguments.game_args));
         Log::WriteLine();
 
-        Debugger.Run(command.game_arguments);
+        Debugger.Run(arguments.game_args);
         Log::WriteLine("WinMain: SyringeDebugger::Run finished.");
         Log::WriteLine("WinMain: Exiting on success.");
         return ERROR_SUCCESS;

Support.h

@@ -32,7 +32,6 @@ inline auto parse_command_line(const std::vector<std::string>& arguments)
     {
         std::vector<std::string> syringe_arguments;
         std::string executable_name;
-        std::string game_arguments;
     };
 
     if (arguments.empty())
@@ -43,8 +42,6 @@ inline auto parse_command_line(const std::vector<std::string>& arguments)
     // First non-flag argument becomes executable name
     bool exe_found = false;
 
-    bool exe_arguments = false;
-
     for (const auto& arg : arguments)
     {
         // executable name: first argument not starting with '-'
@@ -59,32 +56,16 @@ inline auto parse_command_line(const std::vector<std::string>& arguments)
             continue;
         }
 
-        if (arg == "--")
-        {
-            exe_arguments = true;
-            continue;
-        }
-
-        if (exe_arguments)
-        {
-            // game arguments
-            ret.game_arguments += " ";
-            ret.game_arguments += arg;
-        }
+        // Syringe arguments
+        if (arg.starts_with("-i=\"") && arg.ends_with('"'))
+            ret.syringe_arguments.push_back("-i=" + arg.substr(4, arg.length() - 5));
         else
-        {
-            // Syringe arguments
-            if (arg.starts_with("-i=\"") && arg.ends_with('"'))
-                ret.syringe_arguments.push_back("-i=" + arg.substr(4, arg.length() - 5));            
-            else 
-                ret.syringe_arguments.push_back(arg);
-        }
+            ret.syringe_arguments.push_back(arg);
     }
 
     if (!exe_found || ret.executable_name.empty())
         throw invalid_command_arguments{};
 
-    ret.game_arguments = ret.game_arguments.substr(1);
 
     return ret;
 }