private static ExecutionResult applyStatementToObject(ParsedStatement statement, ObjectInfo obj)
{
FieldInfo field;
if (obj.Fields.TryGetValue(statement.Specifier, out field))
{
return(applyStatementToObjectField(statement, obj, field));
}
PropertyInfo property;
if (obj.Properties.TryGetValue(statement.Specifier, out property))
{
return(applyStatementToObjectProperty(statement, obj, property));
}
MethodInfo method;
if (obj.Methods.TryGetValue(statement.Specifier, out method))
{
return(applyStatementToObjectMethod(statement, obj, method));
}
return(new ExecutionResult()
{
Error = new KeyNotFoundException(
$"Could not find member '{statement.Specifier}' on object '{statement.Object}'"),
Failed = true
});
}
private static ExecutionResult execute(ParsedStatement statement)
{
ObjectInfo obj;
if (!_registered.TryGetValue(statement.Object, out obj))
{
return(new ExecutionResult()
{
Error = new ArgumentException($"Unknown object '{statement.Object}'"),
Failed = true
});
}
return(applyStatementToObject(statement, obj));
}
public static ExecutionResult Execute(string statement)
{
var matches = compiledCommandRegex.Match(statement);
if (matches.Groups.Count < 4)
{
return(new ExecutionResult
{
Failed = true,
Error = new ArgumentException($"Invalid command syntax - syntax is 'Object.Specifier [Arguments]'")
});
}
ParsedStatement parsedStatement = new ParsedStatement(matches);
return(execute(parsedStatement));
}
private static unsafe void Main(string[] args)
{
var statement = new ParsedStatement("$Label: mov rax, 11 ; comment");
//GetInput();
//byte[] bytes = ParseInput();
//var builder = new UnmanagedMethodBuilder();
//builder.WrapWithMethodStub();
//builder.SetBytes(bytes);
//UnmanagedSpan<byte> method = builder.FinalizeAsBytes();
//IntPtr ptr = Marshal.GetFunctionPointerForDelegate((MsgBox)MessageBoxW);
//var del = Marshal.GetDelegateForFunctionPointer<Func>(new IntPtr(method.AsPointer()));
//del(ptr, "Called from runtime generated method pointer", "Hello World!");
}
private void WriteStatement(ParsedStatement statement)
{
TestContext.Out.Write(statement.Value);
}
private async Task AssertResult()
{
ParsedStatement results = await PostStatement_ReturnsResult();
}
private void WriteStatement(ParsedStatement statement)
{
WriteOutput(statement.Value);
}
private static ExecutionResult applyStatementToObjectMethod(ParsedStatement statement,
ObjectInfo obj,
MethodInfo method)
{
ParameterInfo[] methodParams = method.GetParameters();
if (statement.Arguments.Length != methodParams.Length)
{
return(new ExecutionResult()
{
Error = new ArgumentException($"Invalid number of arguments, got: {statement.Arguments.Length}, " +
$"expected: {method.GetParameters().Length}"),
Failed = true
});
}
List <object> args = new List <object>();
for (int i = 0; i < statement.Arguments.Length; i++)
{
var param = methodParams[i];
if (param.ParameterType == typeof(float))
{
float value;
if (!parseArg(statement.Arguments[i], out value))
{
return(new ExecutionResult()
{
Error = new FormatException($"Value '{statement.Arguments[i]}' was not a float"),
Failed = true
});
}
args.Add(value);
}
else if (param.ParameterType == typeof(int))
{
int value;
if (!parseArg(statement.Arguments[i], out value))
{
return(new ExecutionResult()
{
Error = new FormatException($"Value '{statement.Arguments[i]}' was not an int"),
Failed = true
});
}
args.Add(value);
}
else if (param.ParameterType == typeof(bool))
{
bool value;
if (!parseArg(statement.Arguments[i], out value))
{
return(new ExecutionResult()
{
Error = new FormatException($"Value '{statement.Arguments[i]}' was not a bool"),
Failed = true
});
}
args.Add(value);
}
else if (param.ParameterType == typeof(string))
{
args.Add(statement.Arguments[i]);
}
}
var result = method.Invoke(obj.Instance, args.ToArray());
return(new ExecutionResult()
{
Failed = false,
Message = result != null?result.ToString() : ""
});
}
private static ExecutionResult applyStatementToObjectProperty(ParsedStatement statement,
ObjectInfo obj,
PropertyInfo property)
{
if (statement.Arguments.Length > 1)
{
return(new ExecutionResult()
{
Error = new ArgumentException($"One argument needed, {statement.Arguments.Length} given"),
Failed = true
});
}
if (property.PropertyType == typeof(float))
{
float value;
if (!parseArg(statement.Arguments[0], out value))
{
return(new ExecutionResult()
{
Error = new FormatException($"Value '{statement.Arguments[0]}' was not a float"),
Failed = true
});
}
property.SetValue(obj.Instance, value);
}
else if (property.PropertyType == typeof(int))
{
int value;
if (!parseArg(statement.Arguments[0], out value))
{
return(new ExecutionResult()
{
Error = new FormatException($"Value '{statement.Arguments[0]}' was not an int"),
Failed = true
});
}
property.SetValue(obj.Instance, value);
}
else if (property.PropertyType == typeof(bool))
{
bool value;
if (!parseArg(statement.Arguments[0], out value))
{
return(new ExecutionResult()
{
Error = new FormatException($"Value '{statement.Arguments[0]}' was not a bool"),
Failed = true
});
}
property.SetValue(obj.Instance, value);
}
else if (property.PropertyType == typeof(string))
{
property.SetValue(obj.Instance, statement.Arguments[0]);
}
return(new ExecutionResult()
{
Failed = false,
Message = $"Set {statement.Object}.{statement.Specifier} to {statement.Arguments[0]}"
});
}
