/// <inheritdoc />
public override DispatchResult Execute(ExecutionContext context, CilInstruction instruction)
{
var stack = context.ProgramState.Stack;
// Pop arguments.
var lengthValue = (ICliValue)stack.Pop();
var sourceAddress = (ICliValue)stack.Pop();
var destinationAddress = (ICliValue)stack.Pop();
// Interpret arguments.
if (!(destinationAddress is IPointerValue destinationPointer) || !(sourceAddress is IPointerValue sourcePointer))
{
return(DispatchResult.InvalidProgram());
}
if (!lengthValue.IsKnown)
{
throw new DispatchException("Number of bytes to copy is unknown.");
}
int length = lengthValue.InterpretAsI4().I32;
// Copy data.
Span <byte> data = stackalloc byte[length];
Span <byte> bitmask = stackalloc byte[length];
sourcePointer.ReadBytes(0, data, bitmask);
destinationPointer.WriteBytes(0, data, bitmask);
return(base.Execute(context, instruction));
}
/// <inheritdoc />
protected override DispatchResult Execute(ExecutionContext context, CilInstruction instruction,
FValue left, FValue right)
{
left.F64 *= right.F64;
context.ProgramState.Stack.Push(left);
return(DispatchResult.Success());
}
/// <inheritdoc />
public override DispatchResult Execute(ExecutionContext context, CilInstruction instruction)
{
var environment = context.GetService <ICilRuntimeEnvironment>();
var variables = new IVariable[1];
if (environment.Architecture.GetWrittenVariables(instruction, variables) != 1)
{
throw new DispatchException(
$"Architecture returned an incorrect number of variables being written by instruction {instruction}.");
}
switch (variables[0])
{
case CilVariable cilVariable:
var value = environment.CliMarshaller.ToCtsValue(
(ICliValue)context.ProgramState.Stack.Pop(),
cilVariable.Variable.VariableType);
context.ProgramState.Variables[variables[0]] = value;
return(base.Execute(context, instruction));
default:
return(DispatchResult.InvalidProgram());
}
}
private static DispatchResult FindMinimumDistanced(DispatchResult[] Results, ref int Index)
{
DispatchResult minResult = new DispatchResult()
{
Hit = false, Distance = Number.MaxValue
};
for (int i = 0; i < Results.Length; ++i)
{
if (!Results[i].Hit)
{
continue;
}
if (minResult.Distance < Results[i].Distance)
{
continue;
}
minResult = Results[i];
Index = i;
}
return(minResult);
}
public void Will_Trap_And_Cache_AmbiguousMatch(string methodName)
{
Dispatcher dispatcher = Dispatcher.For(
typeof(Ambig),
typeof(Ambig).GetMethod(methodName));
Assert.AreEqual(2, dispatcher.DispatchTableSize);
DispatchResult result = dispatcher.Dispatch(new Ambig(), new B(), new B());
Assert.IsFalse(result.Success);
Assert.IsTrue(result.AmbiguousMatch);
Assert.IsTrue(result.IsDynamicInvoke);
if (methodName == "FF")
{
DispatchResult <int> typedResult = result.Typed <int>();
Assert.IsTrue(typedResult.AmbiguousMatch);
Assert.AreEqual(0, typedResult.ReturnValue);
Assert.IsTrue(typedResult.IsDynamicInvoke);
}
Assert.AreEqual(3, dispatcher.DispatchTableSize);
result = dispatcher.Dispatch(new Ambig(), new B(), new B());
Assert.IsFalse(result.IsDynamicInvoke);
}
/// <inheritdoc />
protected override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction,
IntegerValue value, int shiftCount)
{
value.RightShift(shiftCount, instruction.OpCode.Code == CilCode.Shr);
context.ProgramState.Stack.Push((ICliValue)value);
return(DispatchResult.Success());
}
/// <inheritdoc />
protected override DispatchResult Execute(ExecutionContext context, CilInstruction instruction,
IntegerValue value, int shiftCount)
{
value.LeftShift(shiftCount);
context.ProgramState.Stack.Push(value);
return(DispatchResult.Success());
}
/// <inheritdoc />
public DispatchResult Execute(CilExecutionContext context, CilInstruction instruction)
{
var environment = context.GetService <ICilRuntimeEnvironment>();
// If the containing method is expected to return a value, the stack should contain exactly one value,
// and no values otherwise.
int popCount = environment.Architecture.GetStackPopCount(instruction);
if (context.ProgramState.Stack.Size != popCount)
{
return(DispatchResult.InvalidProgram());
}
// Pop result.
if (popCount == 1)
{
context.Result.ReturnValue = context.ProgramState.Stack.Pop();
}
return(new DispatchResult
{
HasTerminated = true
});
}
/// <inheritdoc />
public override DispatchResult Execute(ExecutionContext context, CilInstruction instruction)
{
var stack = context.ProgramState.Stack;
// Pop arguments.
var valueValue = (ICliValue)stack.Pop();
var indexValue = (ICliValue)stack.Pop();
var arrayValue = (ICliValue)stack.Pop();
// Check if both array and index are known.
if (!arrayValue.IsKnown)
{
throw new DispatchException($"Destination array value for instruction at offset IL_{instruction.Offset:X4} is unknown.");
}
if (!indexValue.IsKnown)
{
throw new DispatchException($"Index for instruction at offset IL_{instruction.Offset:X4} is unknown.");
}
// Expect an int32 or a native int for index, and extract its value.
if (indexValue.CliValueType != CliValueType.Int32 && indexValue.CliValueType != CliValueType.NativeInt)
{
return(DispatchResult.InvalidProgram());
}
int index = indexValue.InterpretAsI4().I32;
// Expect an O value with a .NET array in it.
switch (arrayValue)
{
case OValue {
IsZero: { Value : TrileanValue.True }
} :
// Pushed array object is null.
return(new DispatchResult(new NullReferenceException()));
private void DispatchRequestInternal(Request request, string networkName)
{
DispatchResult result = DispatchResult.Expired;
if (request.Behavior.Expiration == null ||
request.Behavior.Expiration >= DateTime.Now)
{
try
{
result = manager.requestDispatcher.Dispatch(request, networkName);
}
catch (Exception)
{
//Any Exception should fail the dispatch request
result = DispatchResult.Failed;
}
if (result == DispatchResult.Failed)
{
if (!manager.connectionMonitor.IsConnected)
{
return;
}
manager.deadLetterQueue.Enqueue(request);
}
}
manager.requestQueue.Remove(request);
if (manager.RequestDispatched != null)
{
manager.RequestDispatched(this, new RequestDispatchedEventArgs(request, result));
}
}
public static HttpStatusCode ToHttpStatusCode(this DispatchResult result)
{
switch (result)
{
case DispatchResult.UrlMismatch:
return(HttpStatusCode.NotFound);
case DispatchResult.ArgsMismatch:
return(HttpStatusCode.NotAcceptable);
case DispatchResult.MethodNotAllowed:
return(HttpStatusCode.MethodNotAllowed);
case DispatchResult.NotAuthenticated:
return(HttpStatusCode.Unauthorized);
case DispatchResult.NotAuthorized:
return(HttpStatusCode.Forbidden);
case DispatchResult.Ambiguous:
return(HttpStatusCode.Ambiguous);
case DispatchResult.Success:
return(HttpStatusCode.OK);
default:
throw AssertionHelper.Fail();
}
}
/// <inheritdoc />
public override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction)
{
var stack = context.ProgramState.Stack;
// Pop arguments.
var indexValue = stack.Pop();
var arrayValue = stack.Pop();
// Check if both array and index are known.
if (!arrayValue.IsKnown || !indexValue.IsKnown)
{
stack.Push(GetUnknownElementValue(context, instruction));
return(base.Execute(context, instruction));
}
// Expect an int32 or a native int for index, and extract its value.
if (indexValue.CliValueType != CliValueType.Int32 && indexValue.CliValueType != CliValueType.NativeInt)
{
return(DispatchResult.InvalidProgram());
}
int index = indexValue.InterpretAsI4().I32;
// Obtain element.
ICliValue elementValue;
switch (arrayValue)
{
case OValue {
IsZero: { Value : TrileanValue.True }
} :
// Pushed array object is null.
return(new DispatchResult(new NullReferenceException()));
/// <inheritdoc />
public DispatchResult Execute(ExecutionContext context, CilInstruction instruction)
{
var result = VerifyCondition(context, instruction);
int newOffset;
if (result.IsKnown)
{
if (result)
{
newOffset = ((ICilLabel)instruction.Operand).Offset;
}
else
{
newOffset = instruction.Offset + instruction.Size;
}
}
else
{
// TODO: dispatch event, allowing the user to handle unknown branch conditions.
throw new DispatchException("Branch condition could not be evaluated.");
}
var stack = context.ProgramState.Stack;
for (int i = 0; i < ArgumentCount; i++)
{
stack.Pop();
}
context.ProgramState.ProgramCounter = newOffset;
return(DispatchResult.Success());
}
private void SendMessageProcessingFailedIfNeeded(MessageDispatch dispatch, DispatchResult dispatchResult, TransportMessage failingTransportMessage = null)
{
if (dispatchResult.Errors.Count == 0 || dispatchResult.Errors.All(error => error is DomainException))
{
return;
}
if (failingTransportMessage == null)
{
failingTransportMessage = ToTransportMessage(dispatch.Message, MessageId.NextId());
}
string jsonMessage;
try
{
jsonMessage = JsonConvert.SerializeObject(dispatch.Message);
}
catch (Exception ex)
{
jsonMessage = string.Format("Unable to serialize message :{0}{1}", System.Environment.NewLine, ex);
}
var errorMessages = dispatchResult.Errors.Select(error => error.ToString());
var errorMessage = string.Join(System.Environment.NewLine + System.Environment.NewLine, errorMessages);
var messageProcessingFailed = new MessageProcessingFailed(failingTransportMessage, jsonMessage, errorMessage, SystemDateTime.UtcNow, dispatchResult.ErrorHandlerTypes.Select(x => x.FullName).ToArray());
var peers = _directory.GetPeersHandlingMessage(messageProcessingFailed);
SendTransportMessage(ToTransportMessage(messageProcessingFailed, MessageId.NextId()), peers);
}
/// <inheritdoc />
public override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction)
{
var environment = context.GetService <ICilRuntimeEnvironment>();
var factory = environment.Module.CorLibTypeFactory;
var stack = context.ProgramState.Stack;
var valueValue = stack.Pop();
var pointerValue = (IPointerValue)stack.Pop();
var marshaller = environment.CliMarshaller;
switch (instruction.OpCode.Code)
{
case CilCode.Stind_I:
if (pointerValue.Is32Bit)
{
pointerValue.WriteInteger32(0, valueValue.InterpretAsI4());
}
else
{
pointerValue.WriteInteger64(0, valueValue.InterpretAsI8());
}
break;
case CilCode.Stind_I1:
pointerValue.WriteInteger8(0,
(Integer8Value)marshaller.ToCtsValue(valueValue.InterpretAsI1(), factory.SByte));
break;
case CilCode.Stind_I2:
pointerValue.WriteInteger16(0,
(Integer16Value)marshaller.ToCtsValue(valueValue.InterpretAsI2(), factory.Int16));
break;
case CilCode.Stind_I4:
pointerValue.WriteInteger32(0,
(Integer32Value)marshaller.ToCtsValue(valueValue.InterpretAsI4(), factory.Int32));
break;
case CilCode.Stind_I8:
pointerValue.WriteInteger64(0,
(Integer64Value)marshaller.ToCtsValue(valueValue.InterpretAsI8(), factory.Int64));
break;
case CilCode.Stind_R4:
pointerValue.WriteFloat32(0,
(Float32Value)marshaller.ToCtsValue(valueValue.InterpretAsR4(), factory.Single));
break;
case CilCode.Stind_R8:
pointerValue.WriteFloat64(0,
(Float64Value)marshaller.ToCtsValue(valueValue.InterpretAsR8(), factory.Double));
break;
default:
return(DispatchResult.InvalidProgram());
}
return(base.Execute(context, instruction));
}
public static bool Raycast(Info Info, ref Result Result)
{
Vector2 endPoint = Info.Origin + (Info.Direction * Info.Distance);
DispatchResult[] results = new DispatchResult[Info.Scene.Bodies.Length];
for (int i = 0; i < Info.Scene.Bodies.Length; ++i)
{
Body body = Info.Scene.Bodies[i];
results[i] = DispatchShape(body, Info, endPoint);
}
int index = -1;
DispatchResult minResult = FindMinimumDistanced(results, ref index);
if (!minResult.Hit)
{
return(false);
}
Result.Body = Info.Scene.Bodies[index];
Result.Point = minResult.Point;
return(true);
}
/// <inheritdoc />
protected override DispatchResult Execute(ExecutionContext context, CilInstruction instruction,
IntegerValue left, IntegerValue right)
{
left.Add(right);
context.ProgramState.Stack.Push(left);
return DispatchResult.Success();
}
/// <inheritdoc />
protected override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction,
IntegerValue left, IntegerValue right)
{
left.Xor(right);
context.ProgramState.Stack.Push((ICliValue)left);
return(DispatchResult.Success());
}
/// <summary>
/// Converts the provided trilean to an I4 stack value, pushes it onto the stack and returns the success
/// dispatcher result.
/// </summary>
/// <param name="context">The current execution context.</param>
/// <param name="result">The trilean value.</param>
/// <returns>The dispatch result.</returns>
protected static DispatchResult ConvertToI4AndReturnSuccess(CilExecutionContext context, Trilean result)
{
var i4Result = new I4Value(result.ToBooleanOrFalse() ? 1 : 0, 0xFFFFFFFEu | (result.IsKnown ? 1u : 0u));
context.ProgramState.Stack.Push(i4Result);
return(DispatchResult.Success());
}
/// <inheritdoc />
public override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction)
{
var environment = context.GetService <ICilRuntimeEnvironment>();
var variables = new IVariable[1];
if (environment.Architecture.GetReadVariables(instruction, variables) != 1)
{
throw new DispatchException(
$"Architecture returned an incorrect number of variables being read from instruction {instruction}.");
}
switch (variables[0])
{
case CilParameter parameter:
var value = environment.CliMarshaller.ToCliValue(
context.ProgramState.Variables[variables[0]],
parameter.Parameter.ParameterType);
context.ProgramState.Stack.Push(value);
return(base.Execute(context, instruction));
default:
return(DispatchResult.InvalidProgram());
}
}
public void FailsWhenNoFactoryTypeIsNull()
{
Request r = new Request();
RequestDispatcher dispatcher = new RequestDispatcher();
DispatchResult result = dispatcher.Dispatch(r, "Network");
}
private static DispatchResult TestLineIntersectsLine(Vector2 Line1StartPoint, Vector2 Line1EndPoint, Vector2 Line2StartPoint, Vector2 Line2EndPoint)
{
DispatchResult result = new DispatchResult();
result.Hit = TestLineIntersectsLine(Line1StartPoint, Line1EndPoint, Line2StartPoint, Line2EndPoint, out result.Distance, out result.Point);
return(result);
}
private void Dispatch(IMessage message, MessageContext context, MessageDispatcher dispatcher = null)
{
_dispatchResult = null;
var dispatch = new MessageDispatch(context, message, (x, r) => _dispatchResult = r);
(dispatcher ?? _messageDispatcher).Dispatch(dispatch);
}
public void Will_Not_Try_To_Invoke_MultiMethod_Recursively()
{
Dispatcher dispatcher = Dispatcher.For(typeof(Morph), multiMethod);
DispatchResult result = dispatcher.Dispatch(morph, new Morph());
Assert.IsFalse(result.Success);
Assert.IsTrue(result.NoMatch);
}
/// <inheritdoc />
protected override DispatchResult Execute(CilExecutionContext context, CilInstruction instruction,
FValue left, FValue right)
{
// ReSharper disable once CompareOfFloatsByEqualityOperator
var i4Result = new I4Value(left.F64 == right.F64 ? 1 : 0);
context.ProgramState.Stack.Push(i4Result);
return(DispatchResult.Success());
}
public void Will_Return_NoMatch_If_Method_Target_Is_Null()
{
Dispatcher dispatcher = Dispatcher.For(typeof(Circle), multiMethod);
DispatchResult result = dispatcher.Dispatch(null, new Rectangle());
Assert.IsTrue(result.NoMatch);
Assert.IsFalse(result.IsDynamicInvoke);
}
public void Will_Return_NoMatch_If_Method_Argument_Is_Null()
{
Dispatcher dispatcher = Dispatcher.For(typeof(Circle), multiMethod);
DispatchResult result = dispatcher.Dispatch(new Circle(), new object[] { null });
Assert.IsTrue(result.NoMatch);
Assert.IsFalse(result.IsDynamicInvoke);
}
private static DispatchResult ExecuteDefault(ExecutionContext context, IntegerValue value, IntegerValue left)
{
if (value.IsNonZero.IsUnknown)
{
value.MarkFullyUnknown();
}
context.ProgramState.Stack.Push(left);
return(DispatchResult.Success());
}
public void Will_Not_Automatically_Register_Methods_With_Interface_Parameters_In_Cache()
{
Dispatcher dispatcher = Dispatcher.For(typeof(Circle), multiMethod);
// protected new string Intersect(IShape shape)
DispatchResult result = dispatcher.Dispatch(circle, new Morph());
Assert.IsTrue(result.IsDynamicInvoke);
}
/// <inheritdoc />
public DispatchResult Execute(CilExecutionContext context, CilInstruction instruction)
{
var(left, right) = BinaryOperationHelper.PopBinaryOperationArguments(context);
var result = (left, right) switch
{
(IntegerValue a, IntegerValue b) => Execute(context, instruction, a, b),
(FValue a, FValue b) => Execute(context, instruction, a, b),
(OValue a, OValue b) => Execute(context, instruction, a, b),
_ => DispatchResult.InvalidProgram(),
};
/// <summary>
/// It creates an RequestDispatchedEventArgs for the given request and result.
/// It is used by the RequestDispatched event, fired during the dispatch process.
/// </summary>
/// <param name="request">Request tried to be dispatched.</param>
/// <param name="result">Dispatch process result.</param>
public RequestDispatchedEventArgs(Request request, DispatchResult result)
{
this.request = request;
this.result = result;
}
