public void EvaluateContext(ScriptExecutionContext scriptExecutionContext)
{
// Set the target object
// Or the temp object
if (m_TargetExpression != null)
{
m_ActionTarget =
scriptExecutionContext.Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(m_TargetExpression,
scriptExecutionContext);
}
else
{
if (m_ReferenceTargetId == -1)
{
m_ActionTarget = scriptExecutionContext.CurrentScriptEvent.Owner;
}
else
{
m_ActionTarget = scriptExecutionContext.LocalState.Ref[m_ReferenceTargetId];
}
}
// Evaluate the expressions
for (int i = 0; i < m_Parameters.Length; i++)
{
m_Parameters[i] =
scriptExecutionContext.Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(m_Expressions[i],
scriptExecutionContext);
}
}
public void OnEnter(ScriptExecutionContext context)
{
if (m_ExpressionTarget != null)
{
object obj = context.Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(m_ExpressionTarget, context);
object value = context.Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(m_AssignmentExpression,
context);
PropertySetBinding setter =
context.Vm.HostBridge.TypeBindingTable.GetPropertySetById(m_PropertySetMethodId, obj.GetType());
setter.InvokeSet(obj, value);
}
else
{
object obj = context.CurrentScriptEvent.Owner;
if (m_RefIndex >= 0)
obj = context.LocalState.Ref[m_RefIndex];
if (m_RefIndex == -2)
obj = context.CurrentScriptEvent.EventParameter;
object value = context.Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(m_AssignmentExpression,
context);
PropertySetBinding setter =
context.Vm.HostBridge.TypeBindingTable.GetPropertySetById(m_PropertySetMethodId, obj.GetType());
setter.InvokeSet(obj, value);
}
}
public void OnEnter(ScriptExecutionContext context)
{
if (m_Operand == TokenType.GlobalVariableAccess)
{
if (m_OperatorType == TokenType.Increment)
context.Vm.GlobalState.Var[m_Index] += m_Value;
if (m_OperatorType == TokenType.Decrement)
context.Vm.GlobalState.Var[m_Index] -= m_Value;
return;
}
if (m_Operand == TokenType.LocalVariableAccess)
{
if (m_OperatorType == TokenType.Increment)
context.LocalState.Var[m_Index] += m_Value;
if (m_OperatorType == TokenType.Decrement)
context.LocalState.Var[m_Index] -= m_Value;
return;
}
throw new Exception("Invalid operand type");
}
public ScriptResult Update(ScriptExecutionContext context)
{
if (m_Milliseconds <= 0)
return ScriptResult.Continue;
m_Milliseconds -= context.DeltaMs;
return ScriptResult.Yield;
}
public ScriptResult Run(ScriptExecutionContext context)
{
IActionNode currentNode = CurrentExecutingActionNode;
while (currentNode != null)
{
// First time run
if (m_HasRunCurrentNodeOnEnter == false)
{
// Check if anything needs to be added to the jump stack before entering
if (currentNode.Recall)
{
if (currentNode.Next != null)
m_JumpStack.Push(currentNode.Next);
}
currentNode.OnEnter(context);
m_HasRunCurrentNodeOnEnter = true;
}
ScriptResult scriptResult = currentNode.Update(context);
if (scriptResult == ScriptResult.Continue)
{
IActionNode next = currentNode.Next; // Note: this save and load is important for conditionals
currentNode.OnExit(context); // To obtain the correct branch and to then be correctly restored
currentNode = next; // for any yeiding or continuation.
// If the current node is null check the jump stack
if (currentNode == null)
{
if (m_JumpStack.Count > 0)
currentNode = m_JumpStack.Pop();
}
CurrentExecutingActionNode = currentNode;
}
if (scriptResult == ScriptResult.ChangedNode)
return scriptResult;
if (scriptResult == ScriptResult.Ok)
return scriptResult;
if (scriptResult == ScriptResult.Yield)
return scriptResult;
if (scriptResult == ScriptResult.EndProcess)
return scriptResult;
if (scriptResult == ScriptResult.Return)
{
CurrentExecutingActionNode = RootNode;
m_JumpStack.Clear();
return ScriptResult.Yield;
}
}
return ScriptResult.Ok; // Script completed
}
public void OnEnter(ScriptExecutionContext context)
{
IActionNode currentBlock = m_BlockRoot;
while (currentBlock != null)
{
m_ExecutionList.Add(currentBlock);
currentBlock.OnEnter(context);
currentBlock = currentBlock.Next;
}
}
public void OnExit(ScriptExecutionContext context)
{
IActionNode currentBlock = m_BlockRoot;
while (currentBlock != null)
{
currentBlock.OnExit(context);
currentBlock = currentBlock.Next;
}
Debug.Assert(m_ExecutionList.Count == 0);
}
public void OnEnter(ScriptExecutionContext context)
{
var value = context.Vm.HostBridge.ExpressionEvaluator.Evaluate<String>(m_Expression, context);
if (m_DestScope == VariableScope.Global)
{
context.Vm.GlobalState.Str[m_DestIndex] = value;
}
else
{
context.LocalState.Str[m_DestIndex] = value;
}
}
public ScriptResult Update(ScriptExecutionContext context)
{
var customer = CustomActionContext.ActionTarget as Customer;
Console.WriteLine("Update Custom Action");
if (customer == null)
{
Console.WriteLine("Target is not a customer");
}
else
{
Console.WriteLine("Source :" + customer.Name);
}
return ScriptResult.Continue;
}
public CompiledScript(List<ScriptNode> nodes, Object scriptOwner)
{
if (nodes == null)
throw new ArgumentNullException("nodes");
if (nodes.Count == 0)
throw new ArgumentException("Process list must contain at least one ScriptNode");
LocalState = new LocalState();
this.Nodes = nodes;
ActiveNodes = new Stack<ScriptNode>();
ScriptOwner = scriptOwner;
m_Context = new ScriptExecutionContext(this, LocalState);
QueuedEvents = new List<QueuedScriptletEvent>(4);
Restart();
}
public ScriptResult Update(ScriptExecutionContext context)
{
for (int i = 0; i < m_ExecutionList.Count; i++)
{
IActionNode currentCommand = m_ExecutionList[i];
if (currentCommand.Update(context) == ScriptResult.Continue)
{
m_ExecutionList.Remove(currentCommand);
i--;
}
}
if (m_ExecutionList.Count > 0)
return ScriptResult.Yield;
return ScriptResult.Continue;
}
public ScriptResult Update(ScriptExecutionContext context)
{
var customer = CustomActionContext.ActionTarget as Customer;
if (customer == null)
{
Console.WriteLine("Target is not a customer");
return ScriptResult.Continue;
}
var parameter = CustomActionContext.Parameters[0] as String;
var parameter2 = CustomActionContext.Parameters[1];
Console.WriteLine("Update Custom Action");
Console.WriteLine("Source :" + customer.Name);
Console.WriteLine("Parameter 1 :" + parameter);
Console.WriteLine("Parameter 2 :" + parameter2);
return ScriptResult.Continue;
}
public void OnEnter(ScriptExecutionContext context)
{
string value = m_SourceValue;
if (value == null)
{
if (m_SourceScope == VariableScope.Global)
value = context.Vm.GlobalState.Str[m_SourceIndex];
if (m_SourceScope == VariableScope.Local)
value = context.LocalState.Str[m_SourceIndex];
}
if (m_DestScope == VariableScope.Global)
{
context.Vm.GlobalState.Str[m_DestIndex] = value;
}
else
{
context.LocalState.Str[m_DestIndex] = value;
}
}
public void AssertEquality(Expression exp1, Expression exp2, Nullable<double> expectedResult = null)
{
Trace.WriteLine("");
Assert.IsTrue(exp1.ReturnType == exp2.ReturnType);
for (int i = 0; i < exp1.Instructions.Count; i++)
{
Trace.WriteLine(exp1.Instructions[i].TokenType);
}
Trace.WriteLine("");
for (int i = 0; i < exp2.Instructions.Count; i++)
{
Trace.WriteLine(exp2.Instructions[i].TokenType);
}
Assert.IsTrue(exp1.Instructions.Count == exp2.Instructions.Count);
for (int i = 0; i < exp2.Instructions.Count; i++)
{
Trace.WriteLine(String.Format("Comp: {0} to {1}",exp1.Instructions[i].TokenType,exp2.Instructions[i].TokenType));
Assert.IsTrue(exp1.Instructions[i].TokenType == exp2.Instructions[i].TokenType);
//Assert.IsTrue(exp1.Instructions[i].TokenValue == exp2.Instructions[i].TokenValue);
}
var context = new ScriptExecutionContext(null ,new LocalState());
context.Vm = m_Vm;
Trace.WriteLine("Eval A");
var r1 = m_Vm.HostBridge.ExpressionEvaluator.EvaluateDouble(exp1, context);
Trace.WriteLine("Eval B");
var r2 = m_Vm.HostBridge.ExpressionEvaluator.EvaluateDouble(exp1, context);
Assert.IsTrue(r1 == r2);
if (expectedResult != null)
Assert.IsTrue(r1 == expectedResult.Value);
}
public void Test026()
{
// Mixed fix
Trace.WriteLine("Exp2");
var input = @"GetCustomer(0).CustomAction();";
var exp2 = m_Vm.ParseExpression(input, true);
Assert.IsTrue(exp2.ReturnType == GossipType.Action);
Trace.WriteLine("Exp2:Done!");
// Allready Normalized
Trace.WriteLine("Exp1");
var normalInput = @".CustomAction(GetCustomer(0))";
var exp1 = m_Vm.ParseExpression(normalInput, false);
Trace.WriteLine("Exp1:Done!");
Assert.IsTrue(exp1.ReturnType == GossipType.Action);
var context = new ScriptExecutionContext( null, new LocalState());
context.Vm = m_Vm;
Trace.WriteLine("Eval A");
var r1 = m_Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(exp1, context);
Assert.IsTrue(r1 == GetCustomer(0));
}
public void Test024()
{
// Allready Normalized
Trace.WriteLine("Exp1");
var normalInput = @".Method3(.Id(GetCustomer(1)), 5, .Account(GetCustomer(1))) - 1;";
var exp1 = m_Vm.ParseExpression(normalInput, false);
Trace.WriteLine("Exp1:Done!");
Assert.IsTrue(exp1.ReturnType == GossipType.Number);
var context = new ScriptExecutionContext(null, new LocalState());
context.Vm = m_Vm;
Trace.WriteLine("Eval A");
var r1 = m_Vm.HostBridge.ExpressionEvaluator.EvaluateDouble(exp1, context);
Assert.IsTrue(r1 == 3);
// Mixed fix
Trace.WriteLine("Exp2");
var input = @"GetCustomer(1).Account.Method3(5, GetCustomer(1).Id) - 1;";
var exp2 = m_Vm.ParseExpression(input, true);
Trace.WriteLine("Exp2:Done!");
AssertEquality(exp1, exp2, 3);
}
public void OnExit(ScriptExecutionContext context)
{
// throw new NotImplementedException();
}
public ScriptResult OnStart(ScriptExecutionContext context)
{
if (OnStartEvent == null)
return ScriptResult.Ok;
return OnStartEvent.Run(context);
}
public ScriptResult OnInterrupt(ScriptExecutionContext context)
{
if (OnInterruptEvent == null)
return ScriptResult.Ok;
ScriptResult result = OnInterruptEvent.Run(context);
if (result == ScriptResult.Ok)
OnInterruptEvent.Restart();
return result;
}
public void OnExit(ScriptExecutionContext context)
{
Console.WriteLine("Exit Custom Action");
}
public void RaiseEvent(EventBinding binding, ScriptExecutionContext context)
{
foreach (ScriptEvent scriptEvent in OnCustomEvents)
{
if (scriptEvent.CustomEventId == binding.Id)
{
scriptEvent.Run(context);
return;
}
}
}
public void OnEnter(ScriptExecutionContext context)
{
context.LocalState.Var[m_Index] = m_Value;
}
public void OnExit(ScriptExecutionContext context)
{
m_CustomActionContext.EvaluateContext(context);
m_CustomActionNode.CustomActionContext = m_CustomActionContext;
m_CustomActionNode.OnExit(context);
}
public ScriptResult Update(ScriptExecutionContext context)
{
m_CustomActionContext.EvaluateContext(context);
m_CustomActionNode.CustomActionContext = m_CustomActionContext;
return m_CustomActionNode.Update(context);
}
public void OnExit(ScriptExecutionContext context)
{
// NOOP
}
public void OnEnter(ScriptExecutionContext context)
{
context.Vm.HostBridge.ExpressionEvaluator.EvaluateExpression(m_Expression, context);
}
public ScriptResult Update(ScriptExecutionContext context)
{
return ScriptResult.Continue;
}
public void OnEnter(ScriptExecutionContext context)
{
// No op
}
public ScriptResult Update(ScriptExecutionContext context)
{
return ScriptResult.EndProcess;
}
public void OnEnter(ScriptExecutionContext context)
{
var value = context.Vm.HostBridge.ExpressionEvaluator.Evaluate<Object>(m_Expression, context);
context.LocalState.Ref[m_Index] = value;
}
