ArgParser.cs

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using static GlobalState;

public static class GlobalState
{

    // Shared args
    public static string destDeviceOrIP = "";   // E.g. COM8, /dev/tty.SLAB_USBtoUART, 127.0.0.1, etc    
    public static UInt32 destTCPPort = 0;       // the port we'll connect to the device/emu on

    public static Command mainCommand = Command.NOT_SET;

    // Generic reusable args.
    public static UInt32 argAddr;
    public static UInt32 argSize;
    public static UInt32 argValue;
    public static UInt32 argMemcardNum;
    public static string argString = "";
    public static string argRegister = "";

    public static string argIP;               // argIP and argPort used for both local and remote params
    public static UInt32 argListenPort = 0;   // the listen port we'll use for bridge mode

    public static string argFileName;         // input or output file
    public static byte[] argFileRawBytes;     // auto-read file contents for input files

    // Older /fast /medi /slow do not need an okay from the PSX    
    public static SIOBaud pendingBuiltinSpeed = SIOBaud.DEFAULT;

    // Newer/custom speeds:

    public static bool useCustomBauds = false;
    public static UInt32 pendingPSXSpeed = 0;
    // If the PSX is already at 518400 for example, and the user
    // wants to drop down to 115200
    // - set the PC speed to match 518400 so it can communicate with the PSX
    // - tell the PSX to drop to 115200
    // - switch the PC over to 115200
    public static UInt32 pendingPCPreSpeed = 0;
    public static UInt32 pendingPCPostSpeed = 0;

    // Using Dan's FTDI mod
    public static bool enterFTDIMode = false;

    // Force gapped datel V2 model via SIO
    // (or force it off in the case of homebrew carts triggering auto detect)
    public static bool forceFlatMode = false;
    public static bool forceGappedMode = false;

    // Switch to 2-way monitor after e.g. .exe updload
    public static bool monitorComms = false;

    // user did like `nops /fast /exe something.exe /slow /m`
    // i.e. to upload quickly, then drop back to default comms speed to monitor
    public static bool switchBackToSlowModeWhenFinished = false;

    // Loaded the serial device or IP from comport.txt
    public static bool usingCachedComportOrIP = false;
}

public static class ArgParser
{

    // Lil' queue to simplify parsing different arg types
    // Pop from index 0, or rase an exception on unknown switches/commands
    public class ParserState
    {

        public List<string> remainingArgs = new List<string>();

        // store the '/exe' part of '/exe mything.exe'
        // to allow clearer debug logs
        public string lastArg = "";

        public ParserState(List<string> inArgs)
        {
            remainingArgs = inArgs;
        }

        public string Peek(bool storeLastArg = false)
        {
            if (Empty) return null;
            return remainingArgs[0];
        }

        public string Pop(bool storeLastArg = false)
        {
            if (Empty) return null;
            string ret = Peek();
            remainingArgs.RemoveAt(0);
            return ret;
        }

        public string StoredArg => lastArg;
        public bool Empty => remainingArgs.Count == 0;
        public int ArgsLeft => remainingArgs.Count;

    }

    /// <summary>
    /// Ensure the input args are vaguely sane
    /// - Make a list of args
    /// - Cross them off one by one as they're valid
    /// - Determine COM port
    /// - Extra args such as /monitor comms
    /// - Grab address values, filename etc		
    /// </summary>
    /// <param name="inArgs">Command line args</param>
    /// <returns>True on success</returns>
    public static bool VerifyArgs(string[] inArgs)
    {

        if (inArgs.Length == 0)
        {
            Header.PrintUsage(false);
            return false;
        }

        ParserState ps = new ParserState(inArgs.ToList());


        string upgradeWarning = "\nPlease note that NOPS now expects '/dest' or '/d' before the target serial/TCP device.\n\n"
        + "E.g.:\n"
        + "    /dest COM3             instead of:    COM3\n"
        + "    /d COM3                instead of:    COM3\n"
        + "    /dest /dev/ttyUSB1234  instead of:    /dev/ttyUSB1234\n\n"
        + "Once this is cached in comport.txt you can ignore it.\n";


        while (!ps.Empty)
        {

            string cmdStr = ps.Pop(true);

            // check if it's a known arg/switch
            Command newCommand = CommandExtensions.CommandFromString(cmdStr);

            if (newCommand == Command.NOT_SET)
            {
                return Utils.Error($"Unknown command: {cmdStr}\n{upgradeWarning}");
            }

            // We can only have one main command like /exe, /rom, /mcdn, etc
            // but we can have multiple switches like /fast /returntoslow /m, etc
            if (!newCommand.IsSecondary())
            {

                // we parsed a new command, but
                // do we already have a command?
                if (mainCommand != Command.NOT_SET)
                {
                    return Utils.Error($"Please specify only one main command, got {mainCommand.Text()} and {newCommand.Text()}");
                }

                mainCommand = newCommand;

            }

            switch (newCommand)
            {

                default:
                    break;

                //
                // Primary Args (main command like /rom, /exe, etc)
                //

                case Command.SEND_EXE:
                case Command.SEND_ROM:
                    if (!GetInputFileArgAndReadData(ps, ref argFileName, ref argFileRawBytes))
                    {
                        return false;
                    }
                    continue;

                case Command.SEND_BIN:
                    if (!GetInputFileArgAndReadData(ps, ref argFileName, ref argFileRawBytes))
                    {
                        return false;
                    }
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    continue;

                case Command.DUMP:
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    if (!GetHexSizeArg(ps, ref argSize))
                    {
                        return false;
                    }
                    if (!GetOutputFileArg(ps, ref argFileName))
                    {
                        return false;
                    }
                    continue;

                case Command.JUMP_JMP:
                case Command.JUMP_CALL:
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    continue;

                case Command.POKE8:
                case Command.POKE16:
                case Command.POKE32:
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    if (!GetHexValueArg(ps, ref argValue))
                    {
                        return false;
                    }
                    continue;

                case Command.WATCH:
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    if (!GetHexSizeArg(ps, ref argSize))
                    {
                        return false;
                    }
                    continue;

                case Command.RESET:
                case Command.PING:
                case Command.DEBUG:
                    // no args.
                    continue;

                case Command.BRIDGE:
                case Command.GDB:
                    if (!GetIPAndPortArg(ps, ref argIP, ref argListenPort))
                    {
                        return false;
                    }
                    continue;

                case Command.HALT:
                case Command.CONT:
                case Command.REGS:
                    // no args;
                    continue;

                case Command.SETREG:
                    if (!GetRegisterArg(ps, ref argRegister))
                    {
                        return false;
                    }
                    if (!GetHexValueArg(ps, ref argValue))
                    {
                        return false;
                    }
                    continue;

                case Command.HOOKREAD:
                case Command.HOOKWRITE:
                case Command.HOOKEXEC:
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    continue;

                case Command.UNHOOK:
                    // no args;
                    continue;


                case Command.MCUP:
                    if (!GetCardNumberArg(ps, ref argMemcardNum))
                    {
                        return false;
                    }
                    if (!GetInputFileArgAndReadData(ps, ref argFileName, ref argFileRawBytes))
                    {
                        return false;
                    }
                    continue;

                case Command.MCDOWN:
                    if (!GetCardNumberArg(ps, ref argMemcardNum))
                    {
                        return false;
                    }
                    if (!GetOutputFileArg(ps, ref argFileName))
                    {
                        return false;
                    }
                    continue;


                case Command.WIPEMEM:
                    if (!GetHexValueArg(ps, ref argValue))
                    {
                        return false;
                    }
                    if (!GetHexAddrArg(ps, ref argAddr))
                    {
                        return false;
                    }
                    continue;

                case Command.STDIN:
                case Command.TYPESTRING:
                    if (!GetStringArg(ps, ref argString))
                    {
                        return false;
                    }
                    continue;

                //
                // Secondary Args ( /fast /pcbaud /m, etc)
                //

                case Command.MONITOR:
                    monitorComms = true;
                    continue;

                case Command.DEST:
                    if (!GetTargetDeviceArg(ps, ref destDeviceOrIP, ref destTCPPort))
                    {
                        return false;
                    }
                    continue;

                case Command.FAST:
                    pendingBuiltinSpeed = SIOBaud.FAST;
                    continue;

                case Command.MEDI:
                    pendingBuiltinSpeed = SIOBaud.MEDI;
                    continue;

                case Command.SLOW:
                    pendingBuiltinSpeed = SIOBaud.DEFAULT;
                    continue;

                case Command.FTDI:
                    enterFTDIMode = true;
                    pendingBuiltinSpeed = SIOBaud.FTDI;
                    continue;

                case Command.RETURNTOSLOW:
                    switchBackToSlowModeWhenFinished = true;
                    continue;

                case Command.PSXBAUD:

                    if (!GetPSXBaudArg(ps, ref pendingPSXSpeed))
                    {
                        return false;
                    }
                    useCustomBauds = true;
                    continue;

                case Command.PCBAUD:

                    if (!GetPCBaudArg(ps, ref pendingPCPostSpeed))
                    {
                        return false;
                    }
                    useCustomBauds = true;
                    continue;

                case Command.PCPREBAUD:

                    if (!GetPCBaudArg(ps, ref pendingPCPreSpeed))
                    {
                        return false;
                    }
                    useCustomBauds = true;
                    continue;

                case Command.FLAT:
                    forceFlatMode = true;
                    continue;

                case Command.GAPS:
                    forceGappedMode = true;
                    continue;

                case Command.VERBOSE:
                    Log.SetLevel(LogType.Info | LogType.Warning | LogType.Error | LogType.Debug);
                    continue;

                case Command.NOMANIFEST:
                    GDBServer.DisableManifest();
                    continue;

            } // switch

        } // foreach arg

#if DebugArgs
        Log.WriteLine("__DEBUG__Argsleft: " + ps.remainingArgs.Count, LogType.Debug);
        Log.WriteLine("__DEBUG__TARGDEVICE: " + destDeviceOrIP, LogType.Debug);
        Log.WriteLine("__DEBUG__TARGPORT: " + destPortOrNone, LogType.Debug);
        Log.WriteLine("__DEBUG__IP:TARGETPORT: " + argIP + ":" + destPortOrNone, LogType.Debug);
        Log.WriteLine("__DEBUG__IP:LISTENPORT: " + argIP + ":" + argListenPort, LogType.Debug);
        Log.WriteLine("__DEBUG__PENDING_BUILTIN_SPEED: " + pendingBuiltinSpeed, LogType.Debug);
        Log.WriteLine("__DEBUG__NEGOTIATE_PSX_SPEED: " + negotiatePSXSpeed, LogType.Debug);
        Log.WriteLine("__DEBUG__PENDING_PSX_SPEED: " + pendingPSXSpeed, LogType.Debug);
        Log.WriteLine("__DEBUG__PENDING_PC_PRE_SPEED: " + pendingPCPreSpeed, LogType.Debug);
        Log.WriteLine("__DEBUG__PENDING_PC_POST_SPEED: " + pendingPCPostSpeed, LogType.Debug);
        Log.WriteLine("__DEBUG__FTDI: " + enterFTDIMode, LogType.Debug);
        Log.WriteLine("__DEBUG__COMMAND: " + mainCommand, LogType.Debug);
        Log.WriteLine("__DEBUG__ADDR: " + argAddr.ToString("X8"), LogType.Debug);
        Log.WriteLine("__DEBUG__VALUE: " + argValue.ToString("X8"), LogType.Debug);
        Log.WriteLine("__DEBUG__FILENAME: " + argFileName, LogType.Debug);
        Log.WriteLine("__DEBUG__INPUTFILE: " + inFile, LogType.Debug);
        Log.WriteLine("__DEBUG__stringArg: " + argString, LogType.Debug);
#endif

        // there shouldn't be any arguments left!
        // (noise on the console, or old style COMx)
        if (ps.remainingArgs.Count > 0)
        {

            for (int i = ps.remainingArgs.Count - 1; i >= 0; i--)
            {
                Utils.Error("Unknown arg! " + ps.remainingArgs[i]);
            }

            Log.WriteLine(upgradeWarning);

            return false;

        }

        // Quick warning:
        if (useCustomBauds && pendingBuiltinSpeed != SIOBaud.DEFAULT)
        {
            Utils.Error("Don't mix /fast /medi and /slow with /pcbaud /psxbaud");
            return false;
        }

        // Cache the com port, or load the cached value
        if (string.IsNullOrEmpty(destDeviceOrIP))
        {

            // no dest device, see if we have one cached in comport.txt

            string readVal = "";
            try
            {
                if (System.IO.File.Exists("comport.txt"))
                {
                    readVal = File.ReadAllText("comport.txt");
                }
            }
            catch (System.Exception e)
            {
                Log.WriteLine("Error checking for cached com port...\n" + e, LogType.Error);
            }

            if (ValidIPAndPort(readVal, ref destDeviceOrIP, ref destTCPPort))
            {
                Log.WriteLine($"Using address and port: {destDeviceOrIP}:{destTCPPort}");
            }
            else if (ValidTargetDevice(readVal, ref destDeviceOrIP))
            {
                Log.WriteLine($"Using device {destDeviceOrIP}");
            }
            else
            {
                return Utils.Error($"\nPlease specify a device or COM port in the format:\n    /dest {Utils.SampleCOMPortForEnvironment}\nor\n    /dest 127.0.0.1:1234\nor\n    /dest /dev/ttysomething\netc\n");
            }

            usingCachedComportOrIP = true;

        }
        else
        {

            // port was specified, cache it for later in comport.txt
            try
            {
                string savedTarget = destTCPPort != 0 ? (destDeviceOrIP + ":" + destTCPPort) : destDeviceOrIP;
                File.WriteAllText("comport.txt", savedTarget);
            }
            catch (System.Exception e)
            {
                Log.WriteLine("Error writing cached com port!\n" + e, LogType.Error);
            }

        }

        // Allow no command only if we're doing /monitor
        if (mainCommand == Command.NOT_SET && !monitorComms)
        {
            return Utils.Error("Please specify a command - e.g. /exe, /rom, /m etc!\n\n");
        }

        // All done
        return true;

    } //VerifyArgs


    static bool GetInputFileArgAndReadData(ParserState ps, ref string outFileName, ref byte[] outFileBytes)
    {

        if (ps.Empty)
        {
            return Utils.Error($"Out of args to read INPUT FILENAME for command {ps.StoredArg}");
        }

        outFileName = ps.Pop();

        try
        {
            outFileBytes = File.ReadAllBytes(outFileName);
        }
        catch (System.Exception e)
        {
            return Utils.Error($"Couldn't open INPUT FILENAME '{outFileName}' for command {ps.StoredArg}. Exception: {e}");
        }

        return true;

    }

    static bool GetOutputFileArg(ParserState ps, ref string outFileName)
    {
        if (ps.Empty)
        {
            return Utils.Error($"Out of args to read OUTPUT FILENAME for command {ps.StoredArg}");
        }
        outFileName = ps.Pop();
        return true;
    }

    static bool GetStringArg(ParserState ps, ref string outString)
    {
        if (ps.Empty)
        {
            return Utils.Error($"Out of args to read STRING ARG for command {ps.StoredArg}");
        }
        outString = ps.Pop();
        return true;
    }

    static bool GetRegisterArg(ParserState ps, ref string outReg)
    {
        if (ps.Empty)
        {
            return Utils.Error($"Specify a CPU REGISTER for command {ps.StoredArg}.");
        }
        // TODO: verify register validity?
        // TODO: settle on a format: R4 vs V0 vs $V0, etc        
        outReg = ps.Pop();
        return true;
    }

    static bool GetHexAddrArg(ParserState ps, ref UInt32 outAddr)
    {

        string errorString = $"Need an ADDRESS param in the format 0x123456 for command {ps.lastArg}";

        if (ps.Empty)
        {
            return Utils.Error(errorString);
        }

        string val = ps.Pop();

        if (!ParseHexa(val, ref outAddr))
        {
            return Utils.Error(errorString);
        }

        return true;
    }

    static bool GetHexSizeArg(ParserState ps, ref UInt32 outSize)
    {

        string errorString = $"Need a SIZE param in the format 0x123456 for command {ps.lastArg}";

        if (ps.Empty)
        {
            return Utils.Error(errorString);
        }

        string val = ps.Pop();

        if (!ParseHexa(val, ref outSize))
        {
            return Utils.Error(errorString);
        }

        return true;
    }

    static bool GetHexValueArg(ParserState ps, ref UInt32 outSize)
    {

        string errorString = $"Need a HEX VALUE param in the format 0x123456 for command {ps.lastArg}";

        if (ps.Empty)
        {
            return Utils.Error(errorString);
        }

        string val = ps.Pop();

        if (!ParseHexa(val, ref outSize))
        {
            return Utils.Error(errorString);
        }

        return true;
    }

    static bool GetIPAndPortArg(ParserState ps, ref string outIP, ref UInt32 outPort)
    {

        if (ps.Empty)
        {
            return Utils.Error($"Out of args to read IP:PORT for command {ps.StoredArg}. E.g. e.g. 192.168.0.7:1234");
        }

        string ipPortStr = ps.Pop();

        if (!ValidIPAndPort(ipPortStr, ref outIP, ref outPort))
        {
            return Utils.Error($"Specify an IP:PORT combo for command {ps.StoredArg}");
        }

        return true;
    }

    static bool GetTargetDeviceArg(ParserState ps, ref string outDeviceOrIP, ref UInt32 outPortOrNone)
    {

        if (ps.Empty)
        {
            return Utils.Error($"Need to specify a target device for /dest like COM3, COM5, IP:PORT, /dev/ttysomething, etc");
        }

        string dev = ps.Pop();

        if (ValidIPAndPort(dev, ref outDeviceOrIP, ref outPortOrNone))
        {
            // 127.0.0.1:1234 etc            
            return true;
        }
        else if (ValidTargetDevice(dev, ref destDeviceOrIP))
        {
            // COM5 or /dev/uart_thing/
            return true;
        }

        return Utils.Error($"Need to specify a target device for /dest like COM3, COM5, IP:PORT, /dev/ttysomething, etc");

    }

    static bool GetCardNumberArg(ParserState ps, ref UInt32 outCardNumber)
    {

        if (ps.Empty)
        {
            return Utils.Error($"Out of args to read MEMORY CARD NUMBER for command {ps.StoredArg}. E.g. 0 or 1");
        }

        string cardNum = ps.Pop();

        if (cardNum != "0" && cardNum != "1")
        {
            return Utils.Error($"Need a MEMORY CARD NUMBER for command {ps.StoredArg}. E.g. 0 or 1");
        }

        outCardNumber = UInt32.Parse(cardNum);
        return true;

    }

    static bool GetPSXBaudArg(ParserState ps, ref UInt32 outBaud)
    {

        string errorString = $"Need a PSX BAUD RATE for command {ps.StoredArg}. E.g. 115200";

        if (ps.Empty)
        {
            return Utils.Error(errorString);
        }

        string baudStr = ps.Pop();

        UInt32 parsedSpeed = 0;
        if (!UInt32.TryParse(baudStr, out parsedSpeed))
        {
            return Utils.Error(errorString);
        }

        bool isValid = PSXBauds.IsValidPSXBaud(parsedSpeed);

        if (!isValid)
        {
            string baudsError = PSXBauds.GetBaudsErrorString();
            return Utils.Error(baudsError);
        }

        outBaud = parsedSpeed;
        return true;
    }

    static bool GetPCBaudArg(ParserState ps, ref UInt32 outBaud)
    {

        string errorString = $"Need a PC BAUD RATE for command {ps.StoredArg}. E.g. 115200";

        if (ps.Empty)
        {
            return Utils.Error(errorString);
        }

        string baudStr = ps.Pop();

        UInt32 parsedSpeed = 0;
        if (!UInt32.TryParse(baudStr, out parsedSpeed))
        {
            return Utils.Error(errorString);
        }

        outBaud = parsedSpeed;
        return true;


    }

    /// <summary>
    /// Grabs a 32 bit hex value from a string
    /// Annoyingly required to bridge UInt32.TryParse
    /// freaking out at "0x"
    /// </summary>		
    public static bool ParseHexa(string inString, ref UInt32 outVal)
    {
        try
        {
            // Whatever's left should be the address
            outVal = (UInt32)Convert.ToInt32(inString, 16);
        }
        catch (Exception)
        {
            return false;
        }
        Log.Write(" - Parsed hexa: 0x" + outVal.ToString("X8") + "\n", LogType.Debug);

        return true;

    }

    /// <summary>
    /// Check if we have something in the format addr:port or ip:port
    /// Hint: just lookin' for that ":"
    /// </summary>
    /// <param name="inAddress"></param>
    /// <returns>yay or nay</returns>
    /// TODO: this will not play nice with ipv6
    public static bool ValidIPAndPort(string inAddress, ref string outAddr, ref UInt32 outPort)
    {

        // no separator, move on
        if (inAddress.IndexOf(":") == -1) return false;

        string[] parts = inAddress.Split(':');

        // too many bits
        if (parts.Length != 2) return false;

        if (parts[0].Length == 0) return false;
        if (parts[1].Length == 0) return false;

        // what about the start bit
        // is it 4 numbers separated by 3 dots?

        string[] bytes = parts[0].Split('.');
        if (bytes.Length != 4) return false;

        for (int i = 0; i < 4; i++)
        {
            if (!UInt32.TryParse(bytes[i], out _))
            {
                return false;
            }
        }

        // First bit looks like an IP
        // Does the last bit look like a uint?

        try
        {
            outPort = UInt32.Parse(parts[1]);
        }
        catch (System.Exception)
        {
            return false;
        }

        outAddr = parts[0];

        // Guess it's valid
        return true;

    }

    /// <summary>
    /// Verify that the port argument is (potentially) valid
    /// </summary>
    /// <param name="inDevice">COM5, /dev/ttyUSB0, etc</param>
    /// <returns>Does it look potentially valid?</returns>
    public static bool ValidTargetDevice(string inDevice, ref string outTargetDevice)
    {

        switch (Utils.CurrentOS)
        {

            // A windowsy sort of affair
            default:
                if (inDevice.ToUpperInvariant().StartsWith("COM"))
                    goto yay;
                break;

            // Mac
            case PlatformID.MacOSX:
                if (inDevice.ToLowerInvariant().StartsWith("/dev/cu") | inDevice.ToLowerInvariant().StartsWith("/dev/tty"))
                    goto yay;
                break;

            // Some kinda POSIXy environment
            // Allow any tty device as *nix users could be using all sorts of pipes n redirects
            case (PlatformID)128:
            case PlatformID.Unix:
                if (inDevice.ToLowerInvariant().StartsWith("/dev/tty"))
                    goto yay;
                break;

        }

        // nay
        return false;

    yay:;
        outTargetDevice = inDevice;
        return true;

    }


}