Implement raw command-line parsing for -- delimiter

Parse the raw command line string to properly detect the `--` separator
before argument splitting. This ensures that quoted arguments containing
the `--` delimiter are handled correctly and not mistakenly treated as
separators.

The previous approach used `CommandLineToArgvW` which splits arguments
before parsing, making it impossible to distinguish between a quoted
`--` in an argument and the actual separator.

Changes:
- Add `FindSeparator()` to locate `--` in raw command line with proper
  quote and escape handling
- Modify `GetArguments()` to split raw command line at separator
- Remove `--` handling from `parse_command_line()` since it's now
  done earlier
- Return separate `syringe_args` and `game_args` from `GetArguments()`

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

Author: frg2089

Main.cpp

@@ -8,11 +8,61 @@
 #include <commctrl.h>
 #include <shellapi.h>
 
-std::vector<std::string> GetArguments()
+struct Arguments
 {
+    std::vector<std::string> syringe_args;
+    std::string game_args;
+};
+
+size_t FindSeparator(const std::wstring& cmdLine)
+{
+    bool inQuotes = false;
+    size_t len = cmdLine.length();
+    for (size_t i = 0; i < len; ++i)
+    {
+        if (cmdLine[i] == L'\\' && i + 1 < len && cmdLine[i + 1] == L'"')
+        {
+            i += 1;
+            continue;
+        }
+        
+        if (cmdLine[i] == L'"')
+        {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        
+        if (!inQuotes && cmdLine[i] == L' ')
+        {
+            if (i + 3 < len && cmdLine[i + 1] == L'-' && cmdLine[i + 2] == L'-' && cmdLine[i + 3] == L' ')
+            {
+                return i;
+            }
+        }
+    }
+    return std::wstring::npos;
+}
+
+Arguments GetArguments()
+{
+    std::wstring wszSyringeArgs;
+    std::wstring wszGameArgs;
+    std::wstring lpCmdLine = GetCommandLineW();
+    auto separator = FindSeparator(lpCmdLine);
+    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 +75,17 @@ 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 +96,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 +119,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;
@@ -84,7 +141,7 @@ int Run(const std::vector<std::string>& arguments)
     {
         MessageBoxA(
             nullptr, "Syringe cannot be run like that.\n\n"
-            "Usage:\nSyringe.exe <exe name> [-i=<injectedfile.dll> ...] [-- <arguments>]",
+                     "Usage:\nSyringe.exe <exe name> [-i=<injectedfile.dll> ...] [-- <arguments>]",
             VersionString, MB_OK | MB_ICONINFORMATION);
 
         Log::WriteLine(

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;
 }