//=========== PARSING ============
#region Parsing
/**<summary>Parses the command line arguments. This is basically the console entry point.</summary>*/
public static void ParseCommand(string[] args)
{
Log(ConsoleColor.White, "Starting TConvert...");
for (int i = 0; i < args.Length && !error; i++)
{
ArgTypes argType = ParseArgument(args[i]);
passedArgs |= argType;
if (argType >= ArgTypes.Extract && argType <= ArgTypes.Script)
{
argMode = argType;
}
if (argType != ArgTypes.Path || lastArg == ArgTypes.Log)
{
lastArg = argType;
}
}
// Show a help message when there's no input
if (args.Length == 0)
{
ProcessHelp();
}
if (!error)
{
ProcessCommand();
}
else if (!silent)
{
WriteLog();
}
Environment.ExitCode = (error ? 1 : 0);
}
/**<summary>Logs that a mode has already been specified.</summary>*/
private static void LogModeAlreadySpecified(ArgTypes argType)
{
LogError("TConvert mode already specified as " +
Options[argMode].Name + " " + Options[argMode].OptionsToString() + ". " +
"Cannot specify option " + Options[argType].Name + " (" +
Options[argType].OptionsToString() + ").");
}
private ushort getArgUshort(ArgTypes type, uint minVer)
{
if (argType != type || version < minVer)
{
throw new InvalidOperationException();
}
return((ushort)arg);
}
private void setArgType(ArgTypes value)
{
if (!Enum.IsDefined(ArgType.GetType(), value))
{
throw new ArgumentOutOfRangeException("value");
}
argType = value;
}
private void setArgUint(ArgTypes type, uint value)
{
if (argType != type)
{
throw new InvalidOperationException();
}
arg = value;
}
private void setArgUshort(ArgTypes type, uint minVer, ushort value)
{
if (argType != type || version < minVer)
{
throw new InvalidOperationException();
}
arg = value;
}
private uint getArgUint(ArgTypes type)
{
if (argType != type)
{
throw new InvalidOperationException();
}
return((uint)arg);
}
public Builder AddArgType <T>(string paramName, string paramDescription, Func <string, string> identityModifier = null)
{
ParamNames.Add(paramName);
ParamDescriptions.Add(paramDescription);
ArgTypes.Add(typeof(T).TypeHandle);
OverrideFuncs.Add(null);
IdentityModifierFuncs.Add(identityModifier);
return(this);
}
public Builder AddArgType(string paramName, string paramDescription, Type paramType, Func <string, IServiceProvider, Task <object> > overrideFunc = null)
{
ParamNames.Add(paramName);
ParamDescriptions.Add(paramDescription);
ArgTypes.Add(paramType.TypeHandle);
// ReSharper disable once PossibleNullReferenceException
OverrideFuncs.Add(overrideFunc.Invoke);
IdentityModifierFuncs.Add(null);
return(this);
}
private Delegate GetOrAddFactory(ArgTypes key, Func <ArgTypes, Delegate> func)
{
lock (_argsFactories)
{
if (!_argsFactories.TryGetValue(key, out Delegate factory))
{
factory = func(key);
_argsFactories.Add(key, factory);
}
return(factory);
}
}
/// <summary>
/// Executes this event executor. Returns true if the event execution was successful,
/// or false if the given arg set is missing any values required for this event listener
/// to execute
/// </summary>
/// <param name="args">ArgSet containing all arguments the event was executed with</param>
/// <returns>True if the event listener executed successfully, or false otherwise</returns>
public bool Execute(EventArgSet args)
{
var values = ArgTypes.Select(p => args.GetArg(p)).ToArray();
if (values.Contains(null))
{
return(false);
}
else if (values.Length == 0)
{
Listener.Invoke(Controller, null);
}
else
{
Listener.Invoke(Controller, values);
}
return(true);
}
public bool Equals([AllowNull] InsCacheEntry aOther)
{
// Check for null and compare run-time types.
if (aOther is null || GetType() != aOther.GetType())
{
return(false);
}
var p = aOther;
if (ArgTypes.Length != p.ArgTypes.Length ||
ArgRefTypes.Length != p.ArgRefTypes.Length)
{
return(false);
}
return
(InsAsmName == p.InsAsmName &&
ArgTypes.SequenceEqual(p.ArgTypes) &&
ArgRefTypes.SequenceEqual(p.ArgRefTypes));
}
/// <summary>
/// Tokenizes string for processing.
/// </summary>
/// <param name="str">String to be processed.</param>
/// <param name="type">Argument type. [Cut, Words, Lines]</param>
public ArgInterpreter(string str, ArgTypes type = ArgTypes.Words)
{
Tokens = new List <string>();
if (string.IsNullOrEmpty(str))
{
return;
}
switch (type)
{
case ArgTypes.Cut:
var m = Regex.Match(str, @"\s*([^ ]+)\s*(.*)", RegexOptions.Singleline);
Tokens.Add(m.Groups[1].Value);
Tokens.Add(m.Groups[2].Value);
break;
case ArgTypes.Words:
Tokens.AddRange(Regex.Split(str.Trim(), @"\s +"));
break;
case ArgTypes.Lines:
Tokens.AddRange(Regex.Split(str.Trim(), @"\r?\n|\n?\r"));
break;
}
}
public int Count(ArgTypes Type = ArgTypes.Raw)
{
return(Fetch(Type).Length);
}
public ParsedArg[] Fetch(ArgTypes Type = ArgTypes.Raw)
{
return(Parsed.Where(o => (o.Type & Type) == Type).ToArray());
}
public ParsedArg(string Value, string Raw, ArgTypes Type = ArgTypes.Raw)
{
this.Value = Value;
this.Raw = Raw;
this.Type = Type;
}
public void PostParse()
{
bool Ignore = false;
for (int i = 0; i < Raw.Count; i++)
{
if (Ignore)
{
Ignore = false; continue;
}
string r = Raw[i];
string s = sRaw[i];
if (r == s && Operators.Contains(s))
{
if (s == ">" || s == ">>")
{
Overwrite = s == ">";
RegisterArg(r, s, ArgTypes.Operator);
string pValue = Raw.Count > i + 1 ? Raw[i + 1].ToLower() : "";
string spValue = sRaw.Count > i + 1 ? sRaw[i + 1].ToLower() : "";
Arguments.Add(pValue);
ArgTypes Also = (pValue.Length != spValue.Length) ? ArgTypes.Quoted : 0;
CaptureOutput = true;
OutputFile = RegisterArg(Environment.ExpandEnvironmentVariables(pValue), spValue, ArgTypes.Output | Also);
break;
}
}
if (ParsePR)
{
Match Param = FindParam.Match(s);
if (Param.Success)
{
string pName = Param.Groups[1].Value.ToLower();
string pValue = Raw.Count > i + 1 ? Raw[i + 1].ToLower() : "";
string spValue = sRaw.Count > i + 1 ? sRaw[i + 1].ToLower() : "";
if (Parameters.ContainsKey(pName))
{
Parameters[pName] = pValue;
}
Ignore = true;
RegisterArg(pName, s, ArgTypes.ParamName);
RegisterArg(pValue, spValue, ArgTypes.ParamValue);
continue;
}
}
if (ParseSW)
{
Match Switch = FindSwitch.Match(s);
if (Switch.Success)
{
string sName = Switch.Groups[1].Value.ToLower();
if (Switches.ContainsKey(sName))
{
Switches[sName] = true;
}
RegisterArg(sName, s, ArgTypes.Switch);
continue;
}
}
Arguments.Add(r);
ArgTypes Additional = (r.Length != s.Length) ? ArgTypes.Quoted : 0;
if (Additional == 0 && FixEmpty.IsMatch(r))
{
r = "";
}
RegisterArg(Environment.ExpandEnvironmentVariables(r), s, ArgTypes.Raw | Additional);
}
}
public ParsedArg RegisterArg(string Value, string Raw, ArgTypes Type = ArgTypes.Raw)
{
return(RegisterArg(new ParsedArg(Value, Raw, Type)));
}
/**<summary>Logs that an option has already been used.</summary>*/
private static void LogOptionAlreadySpecified(ArgTypes argType)
{
LogError(Options[argMode].Name + " option (" +
Options[argMode].OptionsToString() + ") already specified.");
}
public override string ToString()
=> $"{Name}({string.Join(",",ArgTypes.Select(a=>a.ToString()))}):{ReturnType}";
