/// <summary>
/// Grabs a 32 bit hex value from standard input
/// </summary>
public static UInt32 ParseHexa(CommandMode inCommand, string inString)
{
string iLower = inString.ToLowerInvariant();
iLower = iLower.Replace(inCommand.command().ToLowerInvariant(), "");
#if DebugArgs
Console.WriteLine("Parsing hexa " + inString);
#endif
// Whatever's left should be the address
UInt32 outAddr = (UInt32)Convert.ToInt32(iLower, 16);
Console.Write(" - Parsed hexa: 0x" + outAddr.ToString("X8") + "\n");
return(outAddr);
}
/// <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>Are there any unprocessed args?</returns>
static bool VerifyArgs(string[] inArgs)
{
if (inArgs.Length == 0)
{
PrintUsage(false);
return(false);
}
// Thank you, linq <3
// We'll remove args as they're processed so they're not processed twice
// and extra args will be left over.
// ( we don't want extra args left over )
List <string> remainingArgs = inArgs.ToList();
// Specified a com port?
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
#endif
// Remove the arg for the com port: COM* or /dev/tty*
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string s = remainingArgs[i];
if (ValidPort(s))
{
argComPort = s;
remainingArgs.RemoveAt(i);
break;
}
}
// Cache the com port, or load the cached value
if (string.IsNullOrEmpty(argComPort))
{
try{
if (System.IO.File.Exists("comport.txt"))
{
argComPort = File.ReadAllText("comport.txt");
}
} catch (System.Exception e) {
Console.Write("Error checking for cached com port...\n" + e);
}
if (argComPort == "")
{
if (!ValidPort(argComPort))
{
// I think the GC can manage the hit on this one :)
return(Error("\nERROR! Please specify a device or COM port in the format: " + SampleCOMPortForEnvironment + "\ngot: " + argCommand));
}
}
else
{
usingCachedComPort = true;
}
}
else
{
// port was specified, cache it for alter
try{
File.WriteAllText("comport.txt", argComPort);
} catch (System.Exception e) {
Console.Write("Error writing cached com port!\n" + e);
}
}
// Are we using secondary args only? e.g. /fast /m
// in this case, there's no point processing the rest of the input
allArgsAreSecondary = true;
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string lower = remainingArgs[i].ToLowerInvariant();
if (lower == "/m")
{
monitorComms = true;
remainingArgs.RemoveAt(i);
}
else if (lower == "/fast")
{
enterFastMode = true;
remainingArgs.RemoveAt(i);
}
else if (lower == "/slow")
{
enterSlowMode = true;
remainingArgs.RemoveAt(i);
}
else
{
allArgsAreSecondary = false;
}
}
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__DEBUG__COM: " + argComPort);
Console.WriteLine("__DEBUG__FAST: " + enterFastMode);
Console.WriteLine("__DEBUG__FAST: " + enterSlowMode);
#endif
// Not really transferring anything, let's go
if (allArgsAreSecondary)
{
return(true);
}
// Outer loop: Does anything resemble an command? /dump, /poke, etc?
// Specified a command arg (or several for future-proofing)?
for (int paramIndex = remainingArgs.Count - 1; paramIndex >= 0; paramIndex--)
{
string param = remainingArgs[paramIndex].ToLowerInvariant();
// Inner loop: does it match any known commands?
// If so, check for sub params
// E.g. /dump <addr> <size>
// first one is uninitialised... ignore it
for (int argIndex = 1; argIndex < (int)CommandMode.COUNT; argIndex++)
{
CommandMode c = (CommandMode)argIndex;
if (param.ToLowerInvariant() == c.command())
{
// Set the current value and remove
// it from the list of available args
argCommand = c;
remainingArgs.RemoveAt(paramIndex);
// Now we've removed the /command, if there's
// an address after it, it will be remaningArgs[ arg ]
// Does the command require an address value?
if (argCommand.hasAttribute <NeedsAddressAttribute>())
{
// end of the array!
if (paramIndex >= remainingArgs.Count)
{
return(Error("Specify an address in the format 0x01234567\n"));
}
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires an address ");
#endif
// reassign it
param = remainingArgs[paramIndex].ToLowerInvariant();
// try and get the address argument
try{
argAddr = ParseHexa(argCommand, param);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify an address in the format 0x01234567"));
}
remainingArgs.RemoveAt(paramIndex);
satisfiedAddressRequirements = true;
}
// Do we need a register?
if (argCommand.hasAttribute <NeedsRegisterAttribute>())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a register ");
#endif
// reassign it
param = remainingArgs[paramIndex].ToLowerInvariant();
// TODO: verify register validity?
// TODO: settle on a format: R4 vs V0 vs $V0, etc
argRegister = param;
remainingArgs.RemoveAt(paramIndex);
satisfiedRegisterRequirements = true;
}
// On top of that... do we need a size? E.g. for dumping bios.
if (argCommand.hasAttribute <NeedsSizeAttribute>())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a size parameter ");
#endif
// reassign it
param = remainingArgs[paramIndex].ToLowerInvariant();
// try to get the size argument
try{
argSize = ParseHexa(argCommand, param);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify a size in the format 0x01234567"));
}
remainingArgs.RemoveAt(paramIndex);
satisfiedSizeRequirements = true;
}
// Do we need a value? 1 - 4 bytes
if (argCommand.hasAttribute <NeedsValueAttribute>())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a value parameter ");
#endif
// reassign it
param = remainingArgs[paramIndex].ToLowerInvariant();
// try to get the size argument
try{
argValue = ParseHexa(argCommand, param);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify a 1, 2 or 4 byte hex value"));
}
remainingArgs.RemoveAt(paramIndex);
satisfiedValueRequirements = true;
}
if (argCommand.hasAttribute <NeedsIPAttribute>())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires an IP/host parameter!");
#endif
//param = remainingArgs[paramIndex].ToLowerInvariant();
argIP = param;
remainingArgs.RemoveAt(paramIndex);
satisfiedIPRequirements = true;
}
if (argCommand.hasAttribute <NeedsPortAttribute>())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a local/remote port!");
#endif
if (remainingArgs.Count == 0)
{
return(Error("Need to specify a local TCP/IP port!"));
}
param = remainingArgs[paramIndex].ToLowerInvariant();
if (!UInt32.TryParse(param, out argPort))
{
return(Error("EXCEPTION: Couldn't parse a valid port number from \"" + param + "\""));
}
remainingArgs.RemoveAt(paramIndex);
satisfiedPortRequirements = true;
}
// Do we need a memcard number
if (argCommand.hasAttribute <NeedsCardNumberAttribute>())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a memcard parameter ");
#endif
// reassign it
param = remainingArgs[paramIndex].ToLowerInvariant();
argCard = UInt32.Parse(param);
/*
* // Working on something interesting here... hold tight.
* if ( _arg != "0" && _arg != "1" ){
* return Error( "EXCEPTION: memory card should be 0 or 1!" );
* } else {
* argCard = UInt32.Parse( _arg );
* }
*/
remainingArgs.RemoveAt(paramIndex);
satisfiedCardRequirement = true;
}
break; // outer loop to check new args
}
} // inner loop
} // outer loop
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__DEBUG__COM: " + argComPort);
Console.WriteLine("__DEBUG__COMMAND: " + argCommand);
Console.WriteLine("__DEBUG__ADDR: " + argAddr.ToString("X8"));
Console.WriteLine("__DEBUG__VALUE: " + argValue.ToString("X8"));
#endif
if (argCommand == CommandMode.NOT_SET)
{
return(Error("Please specify a command - e.g. /r, /e /b, etc!\n\n"));
}
// Do we need to load an .exe, .rom, data etc?
if (argCommand.hasAttribute <NeedsInputFileAttribute>())
{
// One of the args specifies a file?
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string fName = remainingArgs[i];
argFileName = fName;
try{
inFile = File.ReadAllBytes(fName);
} catch (System.Exception e) {
return(Error("Couldn't open input file " + fName + " Exception: " + e));
}
satisfiedInputFileRequirements = true;
remainingArgs.RemoveAt(i);
}
}
// Do we need to save somewhere?
if (argCommand.hasAttribute <NeedsOutputFileAttribute>())
{
// One of the args specifies a file?
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
argFileName = remainingArgs[i];
remainingArgs.RemoveAt(i);
satisfiedOutputFileRequirements = true;
}
}
// The /poke command for example doesn't require a filename
// so that requirement is considered satisfied.
if (!argCommand.hasAttribute <NeedsRegisterAttribute>())
{
satisfiedRegisterRequirements = true;
}
if (!argCommand.hasAttribute <NeedsAddressAttribute>())
{
satisfiedAddressRequirements = true;
}
if (!argCommand.hasAttribute <NeedsSizeAttribute>())
{
satisfiedSizeRequirements = true;
}
if (!argCommand.hasAttribute <NeedsValueAttribute>())
{
satisfiedValueRequirements = true;
}
if (!argCommand.hasAttribute <NeedsCardNumberAttribute>())
{
satisfiedCardRequirement = true;
}
if (!argCommand.hasAttribute <NeedsInputFileAttribute>())
{
satisfiedInputFileRequirements = true;
}
if (!argCommand.hasAttribute <NeedsOutputFileAttribute>())
{
satisfiedOutputFileRequirements = true;
}
if (!argCommand.hasAttribute <NeedsIPAttribute>())
{
satisfiedIPRequirements = true;
}
if (!argCommand.hasAttribute <NeedsPortAttribute>())
{
satisfiedPortRequirements = true;
}
// Missed something...
if (!satisfiedAddressRequirements)
{
return(Error("Did you specify an address or hex value? E.g. 0x23456788\n"));
}
if (!satisfiedSizeRequirements)
{
return(Error("Did you specify a size? E.g. 0x23456788\n"));
}
if (!satisfiedRegisterRequirements)
{
return(Error("Did you specify a register? E.g. a0"));
}
if (!satisfiedValueRequirements)
{
return(Error("Specify a 1-4 byte value in the format 0x01"));
}
if (!satisfiedCardRequirement)
{
return(Error("Specify memory card 0 or 1!"));
}
if (!satisfiedInputFileRequirements)
{
return(Error("Specify an input file!"));
}
if (!satisfiedOutputFileRequirements)
{
return(Error("Specify a filename to write to!"));
}
if (!satisfiedIPRequirements)
{
return(Error("Specify a remote host/ip!"));
}
if (!satisfiedPortRequirements)
{
return(Error("Specify a local or remote port!"));
}
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__DEBUG__FILENAME: " + argFileName);
Console.WriteLine("__DEBUG__INPUTFILE: " + inFile);
#endif
// there shouldn't be any arguments left!
// (noise on the console, etc)
if (remainingArgs.Count > 0)
{
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
Error("Unknown arg! " + remainingArgs[i]);
}
return(false);
}
// All done
return(true);
} //VerifyArgs
static UInt32 checkSum = 0; // in or out
static bool VerifyArgs(string[] inArgs)
{
// - Make a list of args
// - Remove them from the list when they've been processed
// 1 - Determine COM port
// 2 - Grab any /r /e /b commands
// 3 - Get the address value if required
// 4 - Get the other address value?
// 5 - File name!
//
if (inArgs.Length == 0)
{
PrintUsage(false);
return(false);
}
// Thank you, linq <3
// We'll remove args as they're processed so they're not processed twice
// and extra args will be left over.
List <string> remainingArgs = inArgs.ToList();
// Specified a com port?
#if DebugArgs
Console.WriteLine("__TEST__Argsleft: " + remainingArgs.Count);
#endif
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string s = remainingArgs[i];
Regex COM = new Regex(@"\b(COM(.*))\b", RegexOptions.IgnoreCase | RegexOptions.Singleline);
Match COMPORT = COM.Match(s);
Regex DEV = new Regex(@"\b(dev(.*))\b", RegexOptions.IgnoreCase | RegexOptions.Singleline);
Match NIXDEV = DEV.Match(s);
if (COMPORT.Success)
{
argComPort = s.ToUpperInvariant();
// Console.WriteLine( " - Using port " + argComPort );
remainingArgs.RemoveAt(i);
break;
}
else if (NIXDEV.Success)
{
argComPort = s;
remainingArgs.RemoveAt(i);
break;
}
}
if (argComPort == "")
{
return(Error("\nERROR! Please specify a COM port!"));
}
// going straight into monitor mode?
if (remainingArgs.Count == 1 && remainingArgs[0].ToLowerInvariant() == "/m")
{
return(true);
}
#if DebugArgs
Console.WriteLine("__TEST__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__TEST__COM: " + argComPort);
#endif
// Specified a command arg (or severay for future-proofing)?
for (int arg = remainingArgs.Count - 1; arg >= 0; arg--)
{
string argVal = remainingArgs[arg].ToLowerInvariant();
if (argVal == "/m")
{
#if DebugArgs
Console.WriteLine("__TEST__CommsMonitor Enabled: ");
#endif
monitorComms = true;
remainingArgs.RemoveAt(arg);
continue;
}
// first one is uninitialised... ignore it
for (int j = 1; j < (int)CommandMode.COUNT; j++)
{
CommandMode c = (CommandMode)j;
if (argVal.ToLowerInvariant() == c.command())
{
// Set the current value and remove
// it from the list of available args
argCommand = c;
needInputFile = c.needsInputFile();
needOutputFile = c.needsOutputFile();
remainingArgs.RemoveAt(arg);
// Now we've removed the /command, if there's
// an address after it, it will be remaningArgs[ arg ]
// end of the array!
if (arg >= remainingArgs.Count)
{
return(Error("Specify an address in the format 0x01234567\n"));
}
// found the command... do we need to find an address?
if (argCommand.needsAddress())
{
#if DebugArgs
Console.WriteLine("__TEST__Command " + c + " requires an address ");
#endif
// reassign it
argVal = remainingArgs[arg].ToLowerInvariant();
// try and get the address argument
try{
argAddr = ParseAddress(argCommand, argVal);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify an address in the format 0x01234567"));
}
remainingArgs.RemoveAt(arg);
satisfiedAddressRequirements = true;
}
// On top of that... do we need a size? E.g. for dumping bios.
if (argCommand.needsSize())
{
#if DebugArgs
Console.WriteLine("__TEST__Command " + c + " requires a size parameter ");
#endif
// reassign it
argVal = remainingArgs[arg].ToLowerInvariant();
// try to get the size argument
try{
argSize = ParseAddress(argCommand, argVal);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify a size in the format 0x01234567"));
}
remainingArgs.RemoveAt(arg);
satisfiedSizeRequirements = true;
}
break; // outer loop to check new args
}
} // inner loop
} // outer loop
#if DebugArgs
Console.WriteLine("__TEST__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__TEST__COM: " + argComPort);
Console.WriteLine("__TEST__COMMAND: " + argCommand);
Console.WriteLine("__TEST__ADDR: " + argAddr.ToString("X8"));
Console.WriteLine("__TEST__NEEDSADDR: " + argCommand.needsAddress());
Console.WriteLine("__TEST__NEEDSINPUT: " + argCommand.needsInputFile());
Console.WriteLine("__TEST__NEEDSOUTPUT: " + argCommand.needsOutputFile());
#endif
if (argCommand == CommandMode.NOT_SET)
{
return(Error("Please specify a command - e.g. /r, /e /b, etc!\n\n"));
}
if (!argCommand.needsAddress())
{
satisfiedAddressRequirements = true;
}
if (!argCommand.needsSize())
{
satisfiedSizeRequirements = true;
}
if (!satisfiedAddressRequirements)
{
return(Error("Did you specify an address? E.g. 0x23456788\n"));
}
if (!satisfiedSizeRequirements)
{
return(Error("Did you specify a size? E.g. 0x23456788\n"));
}
// We've parsed the arguments, the addresses and the COM port
// Finish up by finding the file, if necessary
if (!needInputFile && !needOutputFile)
{
satisfiedFileRequirements = true;
}
else
{
// One of the args specifies a file?
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string fName = remainingArgs[i];
if (needInputFile)
{
argFileName = fName;
try {
inFile = File.ReadAllBytes(fName);
} catch (System.Exception e) {
return(Error("Couldn't open input file " + fName + " Exception: " + e));
}
satisfiedFileRequirements = true;
remainingArgs.RemoveAt(i);
}
}
}
if (!satisfiedFileRequirements)
{
return(Error("Specify a filename!"));
}
#if DebugArgs
Console.WriteLine("__TEST__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__TEST__FILENAME: " + argFileName);
Console.WriteLine("__TEST__INPUTFILE: " + inFile);
//Console.WriteLine( "__TEST__OUTPUTFILE: " + argOutFile );
#endif
// there shouldn't be any arguments left!
if (remainingArgs.Count > 0)
{
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
Error("Unknown arg! " + remainingArgs[i]);
}
return(false);
}
// All done
return(true);
} //VerifyArgs
//static UInt32 checkSum = 0; // in or out
// Ensure the input is vaguely sane.
//
// - Make a list of args
// - Remove them from the list when they've been processed
// - Determine COM port
// - Grab any /r /e /b commands
// - Get the address value if required
// - Get the other address value?
// - File name!
//
static bool VerifyArgs(string[] inArgs)
{
if (inArgs.Length == 0)
{
PrintUsage(false);
return(false);
}
// Thank you, linq <3
// We'll remove args as they're processed so they're not processed twice
// and extra args will be left over.
List <string> remainingArgs = inArgs.ToList();
// Specified a com port?
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
#endif
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string s = remainingArgs[i];
if (ValidPort(s))
{
argComPort = s;
remainingArgs.RemoveAt(i);
break;
}
}
// Likewise get the "/FAST" parameter out of the way
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string s = remainingArgs[i].ToUpperInvariant();
if (s == "/FAST")
{
fastMode = true;
remainingArgs.RemoveAt(i);
}
}
if (argComPort == "")
{
try{
if (System.IO.File.Exists("comport.txt"))
{
argComPort = File.ReadAllText("comport.txt");
}
} catch (System.Exception e) {
Console.Write("Error checking for cached com port...\n" + e);
}
if (argComPort == "")
{
if (POSIXEnvironment)
{
return(Error("\nERROR! Please specify a device - e.g. /dev/ttyUSB0\n"));
}
else
{
return(Error("\nERROR! Please specify a COM port - e.g. COM8\n"));
}
}
else
{
usingCachedComPort = true;
}
}
else
{
try{
File.WriteAllText("comport.txt", argComPort);
} catch (System.Exception e) {
Console.Write("Error writing cached com port!\n" + e);
}
}
// is /m the last remaining arg?
if (remainingArgs.Count == 1 && remainingArgs[0].ToLowerInvariant() == "/m")
{
monitorComms = true;
return(true);
}
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__DEBUG__COM: " + argComPort);
Console.WriteLine("__DEBUG__FAST: " + fastMode);
#endif
// Specified a command arg (or severay for future-proofing)?
for (int arg = remainingArgs.Count - 1; arg >= 0; arg--)
{
string argVal = remainingArgs[arg].ToLowerInvariant();
if (argVal == "/m")
{
#if DebugArgs
Console.WriteLine("__DEBUG__CommsMonitor Enabled: ");
#endif
monitorComms = true;
remainingArgs.RemoveAt(arg);
continue;
}
// first one is uninitialised... ignore it
for (int j = 1; j < (int)CommandMode.COUNT; j++)
{
CommandMode c = (CommandMode)j;
if (argVal.ToLowerInvariant() == c.command())
{
// Set the current value and remove
// it from the list of available args
argCommand = c;
needInputFile = c.needsInputFile();
needOutputFile = c.needsOutputFile();
remainingArgs.RemoveAt(arg);
// On top of that... do we need a size? E.g. for dumping bios.
if (argCommand.needsRegister())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a register ");
#endif
// reassign it
argVal = remainingArgs[arg].ToLowerInvariant();
// TODO: verify it's a register, I guess.
argRegister = argVal;
remainingArgs.RemoveAt(arg);
satisfiedRegisterRequirements = true;
}
// Now we've removed the /command, if there's
// an address after it, it will be remaningArgs[ arg ]
// found the command... do we need to find an address?
if (argCommand.needsAddress())
{
// end of the array!
if (arg >= remainingArgs.Count)
{
return(Error("Specify an address in the format 0x01234567\n"));
}
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires an address ");
#endif
// reassign it
argVal = remainingArgs[arg].ToLowerInvariant();
// try and get the address argument
try{
argAddr = ParseAddress(argCommand, argVal);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify an address in the format 0x01234567"));
}
remainingArgs.RemoveAt(arg);
satisfiedAddressRequirements = true;
}
// On top of that... do we need a size? E.g. for dumping bios.
if (argCommand.needsSize())
{
#if DebugArgs
Console.WriteLine("__DEBUG__Command " + c + " requires a size parameter ");
#endif
// reassign it
argVal = remainingArgs[arg].ToLowerInvariant();
// try to get the size argument
try{
argSize = ParseAddress(argCommand, argVal);
} catch (System.Exception) {
return(Error("EXCEPTION: Specify a size in the format 0x01234567"));
}
remainingArgs.RemoveAt(arg);
satisfiedSizeRequirements = true;
}
break; // outer loop to check new args
}
} // inner loop
} // outer loop
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__DEBUG__COM: " + argComPort);
Console.WriteLine("__DEBUG__COMMAND: " + argCommand);
Console.WriteLine("__DEBUG__ADDR: " + argAddr.ToString("X8"));
Console.WriteLine("__DEBUG__NEEDSADDR: " + argCommand.needsAddress());
Console.WriteLine("__DEBUG__NEEDSINPUT: " + argCommand.needsInputFile());
Console.WriteLine("__DEBUG__NEEDSOUTPUT: " + argCommand.needsOutputFile());
#endif
if (argCommand == CommandMode.NOT_SET)
{
return(Error("Please specify a command - e.g. /r, /e /b, etc!\n\n"));
}
if (!argCommand.needsRegister())
{
satisfiedRegisterRequirements = true;
}
if (!argCommand.needsAddress())
{
satisfiedAddressRequirements = true;
}
if (!argCommand.needsSize())
{
satisfiedSizeRequirements = true;
}
if (!satisfiedAddressRequirements)
{
return(Error("Did you specify an address or hex value? E.g. 0x23456788\n"));
}
if (!satisfiedSizeRequirements)
{
return(Error("Did you specify a size? E.g. 0x23456788\n"));
}
if (!satisfiedRegisterRequirements)
{
return(Error("Did you specify a register? E.g. a0"));
}
// We've parsed the arguments, the addresses and the COM port
// Finish up by finding the file, if necessary
if (!needInputFile && !needOutputFile)
{
satisfiedFileRequirements = true;
}
else
{
// One of the args specifies a file?
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
string fName = remainingArgs[i];
if (needInputFile)
{
argFileName = fName;
try {
inFile = File.ReadAllBytes(fName);
} catch (System.Exception e) {
return(Error("Couldn't open input file " + fName + " Exception: " + e));
}
satisfiedFileRequirements = true;
remainingArgs.RemoveAt(i);
}
}
}
if (!satisfiedFileRequirements)
{
return(Error("Specify a filename!"));
}
#if DebugArgs
Console.WriteLine("__DEBUG__Argsleft: " + remainingArgs.Count);
Console.WriteLine("__DEBUG__FILENAME: " + argFileName);
Console.WriteLine("__DEBUG__INPUTFILE: " + inFile);
//Console.WriteLine( "__DEBUG__OUTPUTFILE: " + argOutFile );
#endif
// there shouldn't be any arguments left!
if (remainingArgs.Count > 0)
{
for (int i = remainingArgs.Count - 1; i >= 0; i--)
{
Error("Unknown arg! " + remainingArgs[i]);
}
return(false);
}
// All done
return(true);
} //VerifyArgs
