Refactor CLI argument parsing to use -- delimiter

[frg2089]

The reason for this change is to improve the command-line argument parsing method by adopting the standard -- delimiter syntax commonly used in Unix/Linux systems.

Why Change?

Old Approach

Syringe.exe game.exe -i=mod.dll --args="-CD. -SPAWN"

• Used --args= flag to pass game arguments
• Required wrapping game arguments in quotes as a single string
• Less intuitive syntax and prone to confusion

New Approach

Syringe.exe game.exe -i=mod.dll -- -CD. -SPAWN

• Uses -- as delimiter, which is a standard convention in Unix/Linux
• All arguments after -- are passed directly to the target program
• Clearer syntax that aligns with common command-line tool conventions

Technical Details

In the parse_command_line function in Support.h:

1. When -- is encountered, the exe_arguments flag is set to true
2. All subsequent arguments are appended to the game_arguments string
3. Finally, substr(1) removes the leading extra space

Advantages

• Follows POSIX standard conventions (used by tools like git, docker, etc.)
• Arguments don't require additional quotes, reducing error potential
• Simpler code without special --args= flag handling
• Easier to understand and maintain

---

Where is issues?

[Metadorius]

One critical issue: you're parsing then un-parsing the arguments by concatenating them back, not necessarily with the same delimiters. Can you guarantee this won't fuck up anything? No. Should you be doing this? Also no. The arguments to be passed to the injected process must be passed as-is, without any intermediate processing. Treat everything past -- as a black box.

[Metadorius]

Then I am also not sure on the real benefit. While unconventional, what other drawbacks does passing --args="-args” have?

[Metadorius]

Then I am also not sure on the real benefit. While unconventional, what other drawbacks does passing --args="-args" have?

Haven't heard from you on this.

I've also seen both -- and --args= in the wild.

Current pre-parsing step is inelegant of a solution to be honest. Ideally you'd call some builtin function to get an offset of the -- and truncate this way, and pass the rest verbatim, but from my research there's just no proper builtins for this.

[frg2089]

Just to align with intuition.

And I have already implemented obtaining the complete command line string.

--a -- --b c d e 'g "h ' i" s

I am not familiar with C++, so my string splitting logic might be flawed.

In C# it would be expressed as:

string raw = Environment.CommandLine;
string[] arr = raw.Split(" -- ", 2);
string syringeArgs = arr[0];
string gamemdArgs = arg.Length >= 2 ? arg[1] : string.Empty;

[Metadorius]

Yeah I've seen, verbatim argument passing is a good change

my biggest complaint right now is the fact that you have to manually parse in order to get the position of the arg. and the C# example doesn't account for " and escaping for example. this has potential for bugs and seems overly complicated for something that should be very simple.

I think you can agree that the previous approach was much simpler, just parse a string argument and pass it to launched exe.