public void InterpreterAndLet1()
{
NodeRefererEntry rootNode = interpretAndReturnRootnode("(let [value 4 i 1 read2 (shl value (+ i 1))] read2)");
ImmutableNodeReferer result = rootNode.entry.interpretationResult;
Assert.AreEqual(result.valueInt, 16);
}
public void execute(PrimitiveInterpretationContext context, ImmutableNodeReferer node)
{
long registerIdxA = node.children[1].valueInt;
long registerIdxB = node.children[2].valueInt;
// fetch registers
long valueA = context.registers[registerIdxA].valueInt;
long valueB = context.registers[registerIdxB].valueInt;
switch (comparisionType)
{
case EnumComparisionType.NEQ_INT:
context.conditionFlag = valueA != valueB;
break;
case EnumComparisionType.EQ_INT:
context.conditionFlag = valueA == valueB;
break;
case EnumComparisionType.G_INT:
context.conditionFlag = valueA > valueB;
break;
case EnumComparisionType.GE_INT:
context.conditionFlag = valueA >= valueB;
break;
}
}
public void dispatchExit(HiddenFunctionId hiddenFunctionId, ImmutableNodeReferer resultOfCall)
{
if (!privateEnabledTimingInstrumentation)
{
return;
}
sw.Stop();
double ticks = sw.ElapsedTicks;
long elapsedNs = (long)((ticks / Stopwatch.Frequency) * 1000000000);
Instrumentation instrumentation = countersDictionary[hiddenFunctionId];
if (instrumentation.toIgnoreCounter == 0)
{
instrumentation.statisticsCalltimeSumInNs += elapsedNs;
instrumentation.statisticsCalltimeMaxInNs = Math.Max(elapsedNs, instrumentation.statisticsCalltimeMaxInNs);
// needs special handling for the case when it's the first call
if (instrumentation.callcounter == 1)
{
instrumentation.statisticsCalltimeMinInNs = elapsedNs;
}
else
{
instrumentation.statisticsCalltimeMinInNs = Math.Min(elapsedNs, instrumentation.statisticsCalltimeMinInNs);
}
}
}
public void interpreterShr1()
{
NodeRefererEntry rootNode = interpretAndReturnRootnode("(shr 4 2)");
ImmutableNodeReferer result = rootNode.entry.interpretationResult;
Assert.AreEqual(result.valueInt, 1);
}
public void interpreterIfFalse1()
{
NodeRefererEntry rootNode = interpretAndReturnRootnode("(if 0 42 5)");
ImmutableNodeReferer result = rootNode.entry.interpretationResult;
Assert.AreEqual(result.valueInt, 5);
}
public void interpret(ContextType interpretationContext, ImmutableNodeReferer node, IList <ImmutableNodeReferer> arguments, IList <string> argumentNames)
{
// is just a small layer over interpret2
Ensure.ensureHard(arguments.Count <= argumentNames.Count);
interpret2(interpretationContext, node, arguments, argumentNames);
}
public void updateFunctionBody(HiddenFunctionId functionId, ImmutableNodeReferer body)
{
if (!functiondescriptorByFunctionId.ContainsKey(functionId))
{
functiondescriptorByFunctionId[functionId] = new FunctionDescriptor();
}
functiondescriptorByFunctionId[functionId].body = body;
}
public void memoize(IList <ImmutableNodeReferer> parameters, ImmutableNodeReferer result)
{
ParameterResultPair createdPair = new ParameterResultPair();
createdPair.parameters = parameters;
createdPair.result = result;
parameterResultPairs.Add(createdPair);
}
// tests if a functioncall to an defined function can be made
//
// creates providers and surrogates, then an callee and called function
public void InterpreterFunctioninvocation1()
{
FunctionalInterpretationContext functionalContext = new FunctionalInterpretationContext();
FunctionalInterpreter functionalInterpreter = new FunctionalInterpreter();
functionalInterpreter.tracer = new NullFunctionalInterpreterTracer();
FunctionalInterpreterSurrogate interpreterSurrogate = new FunctionalInterpreterSurrogate(functionalInterpreter, functionalContext);
// dispatcher which dispatches hidden function calls to the interpreter
SurrogateProvider surrogateProvider = new SurrogateProvider();
// dispatcher which can shadow calls (to the surrogate provider)
ShadowableHiddenDispatcher shadowableHiddenDispatcher = new ShadowableHiddenDispatcher(surrogateProvider);
// dispatcher which calls another dispatcher and a number of observers,
// which is in this case our instrumentation observer
InstrumentationHiddenDispatcher instrHiddenDispatcher = new InstrumentationHiddenDispatcher(shadowableHiddenDispatcher);
ArgumentBasedDispatcher publicDispatcherByArguments = new ArgumentBasedDispatcher(instrHiddenDispatcher);
PublicCallDispatcher callDispatcher = new PublicCallDispatcher(publicDispatcherByArguments);
// all calls the functional interpreter makes to an user defined function are dispatched with this
functionalContext.publicFnRegistryAndDispatcher = new PublicFunctionRegistryAndDispatcher(callDispatcher);
Functional.ParseTreeElement parseTree = Functional.parseRecursive("3");
NodeRefererEntry rootnodeCalled = FunctionalToParseTreeTranslator.translateRecursive(parseTree);
{ // set descriptor to route all public function id's 0 to hidden function id 0
ArgumentBasedDispatcher.FunctionDescriptor fnDescriptor = new ArgumentBasedDispatcher.FunctionDescriptor();
fnDescriptor.wildcardHiddenFunctionId = HiddenFunctionId.make(0);
publicDispatcherByArguments.setFunctionDescriptor(PublicFunctionId.make(0), fnDescriptor);
}
surrogateProvider.updateSurrogateByFunctionId(HiddenFunctionId.make(0), interpreterSurrogate);
interpreterSurrogate.updateFunctionBody(HiddenFunctionId.make(0), rootnodeCalled.entry);
interpreterSurrogate.updateParameterNames(HiddenFunctionId.make(0), new List <string>());
callDispatcher.setFunctionId("a", PublicFunctionId.make(0)); // bind function name "a" to public function id 0
functionalContext.publicFnRegistryAndDispatcher.addFunction("a"); // register so the dispatcher used by the interpreter knows that the function exists
Functional.ParseTreeElement parseTree2 = Functional.parseRecursive("(a)");
NodeRefererEntry rootnodeCallee = FunctionalToParseTreeTranslator.translateRecursive(parseTree2);
functionalInterpreter.interpret(functionalContext, rootnodeCallee.entry, new List <ImmutableNodeReferer>(), new List <string>());
ImmutableNodeReferer result = rootnodeCallee.entry.interpretationResult;
Assert.AreEqual(result.valueInt, 3);
}
public static ImmutableNodeReferer translateRecursiveInternal(Functional.ParseTreeElement entry, ImmutableNodeReferer parent)
{
if (entry.type == Functional.ParseTreeElement.EnumType.SCOPE)
{
ImmutableNodeReferer resultNode = ImmutableNodeReferer.makeBranch();
Functional.ScopeParseTreeElement castedEntry = (Functional.ScopeParseTreeElement)entry;
foreach (Functional.ParseTreeElement iterationChildren in castedEntry.children)
{
ImmutableNodeReferer translatedNode = translateRecursiveInternal(iterationChildren, resultNode);
resultNode.children = resultNode.children.Add(translatedNode);
}
return(resultNode);
}
else if (entry.type == Functional.ParseTreeElement.EnumType.IDENTIFIER)
{
Functional.IdentifierParseTreeElement castedEntry = (Functional.IdentifierParseTreeElement)entry;
return(ImmutableNodeRefererManipulatorHelper.makeString(castedEntry.identifier));
}
else if (entry.type == Functional.ParseTreeElement.EnumType.NUMBER)
{
Functional.NumberParseTreeElement castedEntry = (Functional.NumberParseTreeElement)entry;
switch (castedEntry.numberType)
{
case Functional.NumberParseTreeElement.EnumNumberType.FLOAT:
return(ImmutableNodeReferer.makeNonbranch(ValueNode.makeAtomic(Variant.makeFloat(castedEntry.valueFloat))));
case Functional.NumberParseTreeElement.EnumNumberType.INTEGER:
return(ImmutableNodeReferer.makeNonbranch(ValueNode.makeAtomic(Variant.makeInt(castedEntry.valueInt))));
}
throw new Exception("Internal error!"); // hard internal error
}
else if (entry.type == Functional.ParseTreeElement.EnumType.ARRAY)
{
// an array gets transated to an branch with array as the operation
ImmutableNodeReferer resultNode = ImmutableNodeReferer.makeBranch();
resultNode.children = resultNode.children.Add(ImmutableNodeRefererManipulatorHelper.makeString("array")); // pseudo operation "array" which indicates an array
Functional.ArrayParseTreeElement castedEntry = (Functional.ArrayParseTreeElement)entry;
foreach (Functional.ParseTreeElement iterationChildren in castedEntry.children)
{
ImmutableNodeReferer translatedNode = translateRecursiveInternal(iterationChildren, resultNode);
resultNode.children = resultNode.children.Add(translatedNode);
}
return(resultNode);
}
else
{
throw new Exception("Not supported parse node!");
}
}
// call for more convinience
public ImmutableNodeReferer dispatchCallByFunctionName(string functionname, IList <Variant> argumentVariants)
{
IList <ImmutableNodeReferer> arguments = new List <ImmutableNodeReferer>(argumentVariants.Count);
for (int i = 0; i < argumentVariants.Count; i++)
{
arguments[i] = ImmutableNodeReferer.makeNonbranch(ValueNode.makeAtomic(argumentVariants[i]));
}
return(publicDispatcherByArguments.dispatch(functionIdByFunctionname[functionname], arguments));
}
public void InterpreterVariableLookup()
{
FunctionalInterpretationContext functionalContext = new FunctionalInterpretationContext();
NodeRefererEntry rootNode = interpretAndReturnRootnode("a", new List <ImmutableNodeReferer> {
ImmutableNodeReferer.makeNonbranch(ValueNode.makeAtomic(Variant.makeInt(42)))
}, new List <String> {
"a"
});
ImmutableNodeReferer result = rootNode.entry.interpretationResult;
Assert.AreEqual(result.valueInt, 42);
}
// TODO< move to helper >
static string getNativeString(ImmutableNodeReferer node)
{
ensureNodeIsDatatype(node.children[0], "string");
char[] charArray = new char[node.children.Length - 1];
for (int i = 0; i < node.children.Length - 1; i++)
{
charArray[i] = (char)node.children[i + 1].valueInt;
}
return(new string(charArray));
}
public ImmutableNodeReferer dispatch(HiddenFunctionId hiddenFunctionId, IList <ImmutableNodeReferer> arguments)
{
for (int i = dispatchObservers.Count - 1; i >= 0; i--)
{
dispatchObservers[i].dispatchEnter(hiddenFunctionId, arguments);
}
ImmutableNodeReferer result = chainDispatcher.dispatch(hiddenFunctionId, arguments);
for (int i = 0; i < dispatchObservers.Count; i++)
{
dispatchObservers[i].dispatchExit(hiddenFunctionId, result);
}
return(result);
}
public bool checkParametersEqual(IList <ImmutableNodeReferer> parameters)
{
if (parameters.Count != this.parameters.Count)
{
return(false);
}
for (int i = 0; i < parameters.Count; i++)
{
if (!ImmutableNodeReferer.checkEquality(parameters[i], this.parameters[i]))
{
return(false);
}
}
return(true);
}
public ImmutableNodeReferer tryDispatch(HiddenFunctionId hiddenFunctionId, IList <ImmutableNodeReferer> arguments, out bool wasShadowed)
{
wasShadowed = false;
if (hiddenFunctionId != functionId)
{
return(null);
}
ImmutableNodeReferer lookupResult = lookup.tryLookup(arguments);
if (lookupResult == null)
{
return(null);
}
wasShadowed = true;
return(lookupResult);
}
public void execute(PrimitiveInterpretationContext context, ImmutableNodeReferer node)
{
Ensure.ensure(node.children.Length >= 1 + 1); // arguments have to be at least op + target
int numberOfArgs = node.children.Length - 1 - 1;
long accumulator = 1;
for (int argIdx = 0; argIdx < numberOfArgs; argIdx++)
{
long registerIdxIteration = node.children[1 + argIdx].valueInt;
accumulator *= context.registers[registerIdxIteration].valueInt;
}
long registerIdxDest = node.children[node.children.Length - 1].valueInt;
context.registers[registerIdxDest].valueInt = accumulator;
context.ip++;
}
static void agentTest0()
{
ImmutableNodeReferer orginalArray = ImmutableNodeRefererManipulatorHelper.makeImmutableNodeRefererForArray(new List <Variant> {
Variant.makeInt(5), Variant.makeInt(2), Variant.makeInt(7)
});
StochasticBag stochasticBag = new StochasticBag();
stochasticBag.propabilities = new List <float> {
0.2f, 0.6f, 0.2f
};
Random random = new Random();
for (int i = 0; i < 15; i++)
{
Console.WriteLine("choice={0}", stochasticBag.getValueByUniformRandomVariable((float)random.NextDouble()));
// TODO< manipulate array and print to console >
}
int deb = 0;
}
public void conditionPathTaken(int conditionId, ImmutableNodeReferer node, bool branch)
{
}
public void sequenceResult(int sequenceId, ImmutableNodeReferer result)
{
throw new NotImplementedException();
}
void recursiveInterpret(FunctionalInterpretationContext interpretationContext, ImmutableNodeReferer node)
{
if (!node.isBranch)
{
// it's it's own result
node.interpretationResult = node;
return;
}
// if we are here it must be an branch which must be executable
// figure out if it is a native function call or a registered function call or a variable
// if it is a string then this means that it indicates an variablename and not an call
if (!node.children[0].isBranch && node.children[0].type == ValueNode.EnumType.STRING_DATATYPE && node.children[0].valueString == "string")
{
string variableName = getNativeString(node);
Ensure.ensure(interpretationContext.existsVariableByName(variableName));
node.interpretationResult = interpretationContext.getVariableByName(variableName);
return;
}
// was the result of the node already set in the node
// used if we return an nonatomic result
bool interpretationResultOfNodeIsAlreadySet = false;
string operationName = getNativeString(node.children[0]);
bool isSequence = operationName == "seq";
bool isLet = operationName == "let";
bool isCondition = operationName == "if";
bool isSpecial = isSequence || isLet || isCondition;
string callName = "";
if (!isSpecial)
{
callName = operationName;
if (
isNativeCallValid(callName) ||
interpretationContext.publicFnRegistryAndDispatcher.existsFunction(callName)
)
{
// nothing by purpose
}
else
{
throw new Exception("INTERPRETATIONEXCEPTION name \"" + operationName + "\"is not a native function call or a registered function call or a variable");
}
}
int callId = -1, sequenceId = -1, conditionId = -1; // illegal
if (isSequence)
{
sequenceId = tracer.sequenceEnter(node);
}
else if (isLet)
{
// nothing by purpose
}
else if (isCondition)
{
conditionId = tracer.conditionEnter(node);
}
else
{
Ensure.ensureHard(!isSpecial);
callId = tracer.callEnter(callName, node);
}
// is null if the result initialization is dependent on the callName
Variant?interpretationResult = null;
bool isFirstArgument = true;
primitiveCalcResultForAdditionalArgumentType primitiveCalcResultForAdditionalArgument = delegate(Variant argument) {
if (isFirstArgument)
{
isFirstArgument = false;
interpretationResult = argument;
return;
}
{ // scope just for the null mess of interpretationResult
Variant interpretationResultTemp = interpretationResult.Value;
tryToWidenArithmeticType(ref interpretationResultTemp, argument.type);
interpretationResult = interpretationResultTemp;
}
Variant castedArgument = hardCastVariantTo(argument, interpretationResult.Value.type);
if (callName == "+")
{
if (castedArgument.type == Variant.EnumType.FLOAT)
{
interpretationResult = Variant.makeFloat(interpretationResult.Value.valueFloat + castedArgument.valueFloat);
}
else if (castedArgument.type == Variant.EnumType.INT)
{
interpretationResult = Variant.makeInt(interpretationResult.Value.valueInt + castedArgument.valueInt);
}
}
else if (callName == "-")
{
if (castedArgument.type == Variant.EnumType.FLOAT)
{
interpretationResult = Variant.makeFloat(interpretationResult.Value.valueFloat - castedArgument.valueFloat);
}
else if (castedArgument.type == Variant.EnumType.INT)
{
interpretationResult = Variant.makeInt(interpretationResult.Value.valueInt - castedArgument.valueInt);
}
}
else if (callName == "*")
{
if (castedArgument.type == Variant.EnumType.FLOAT)
{
interpretationResult = Variant.makeFloat(interpretationResult.Value.valueFloat * castedArgument.valueFloat);
}
else if (castedArgument.type == Variant.EnumType.INT)
{
interpretationResult = Variant.makeInt(interpretationResult.Value.valueInt * castedArgument.valueInt);
}
}
else if (callName == "/")
{
if (castedArgument.type == Variant.EnumType.FLOAT)
{
Ensure.ensure(castedArgument.valueFloat != 0.0);
interpretationResult = Variant.makeFloat(interpretationResult.Value.valueFloat / castedArgument.valueFloat);
}
else if (castedArgument.type == Variant.EnumType.INT)
{
Ensure.ensure(castedArgument.valueInt != 0);
interpretationResult = Variant.makeInt(interpretationResult.Value.valueInt / castedArgument.valueInt);
}
}
};
if (isLet)
{
Ensure.ensure(node.children.Length == 1 + 2); // let and variableAssignmentNode an executionNode
ImmutableNodeReferer variableAssignmentArrayNode = node.children[1];
ImmutableNodeReferer executionNode = node.children[2];
Ensure.ensure(variableAssignmentArrayNode.isBranch);
Ensure.ensure(variableAssignmentArrayNode.children.Length != 0);
Ensure.ensure(getNativeString(variableAssignmentArrayNode.children[0]) == "array");
Ensure.ensure((variableAssignmentArrayNode.children.Length - 1) % 2 == 0); // array minus the array prefix must have a length divisable by two
int numberOfAssingments = (variableAssignmentArrayNode.children.Length - 1) / 2;
for (int assigmentI = 0; assigmentI < numberOfAssingments; assigmentI++)
{
string assignmentVariableName = getNativeString(variableAssignmentArrayNode.children[(1 + assigmentI * 2)]);
ImmutableNodeReferer assignmentNode = variableAssignmentArrayNode.children[(1 + assigmentI * 2) + 1];
// for it to be calculated
recursiveInterpret(interpretationContext, assignmentNode);
// try to assign the variable
Ensure.ensure(!interpretationContext.existsVariableByName(assignmentVariableName));
interpretationContext.assignVariable(assignmentVariableName, assignmentNode.interpretationResult);
}
// execute the execution node
recursiveInterpret(interpretationContext, executionNode);
// transfer result
node.interpretationResult = executionNode.interpretationResult;
}
else if (isCondition)
{
Ensure.ensure(node.children.Length == 1 + 3); // "if" and conditionNode and true tode and false node
ImmutableNodeReferer conditionNode = node.children[1];
ImmutableNodeReferer trueBranchNode = node.children[2];
ImmutableNodeReferer falseBranchNode = node.children[3];
// execute the condition node
recursiveInterpret(interpretationContext, conditionNode);
Ensure.ensure(conditionNode.interpretationResult != null);
Ensure.ensure(!conditionNode.isBranch);
Ensure.ensure(conditionNode.type == ValueNode.EnumType.VALUE);
Ensure.ensure(conditionNode.value.type == Variant.EnumType.INT); // int which gets interpreted as bool
long conditionInt = conditionNode.value.valueInt;
Ensure.ensure(conditionInt == 0 || conditionInt == 1); // is it a valid boolean value
bool conditionBool = conditionInt == 1;
tracer.conditionCondition(conditionId, conditionNode, conditionNode.interpretationResult);
tracer.conditionPathTaken(conditionId, conditionNode, conditionBool);
if (conditionBool)
{
recursiveInterpret(interpretationContext, trueBranchNode);
node.interpretationResult = trueBranchNode.interpretationResult;
}
else
{
recursiveInterpret(interpretationContext, falseBranchNode);
node.interpretationResult = falseBranchNode.interpretationResult;
}
}
else
{
// force all arguments to be calculated
for (int argIdx = 0; argIdx < node.children.Length - 1; argIdx++)
{
ImmutableNodeReferer argumentNode = node.children[argIdx + 1];
if (isSequence)
{
tracer.sequenceElement(sequenceId, argumentNode);
}
recursiveInterpret(interpretationContext, argumentNode);
}
}
if (isSequence)
{
tracer.sequenceResult(sequenceId, node.children[node.children.Length - 1].interpretationResult);
tracer.sequenceExit(sequenceId);
}
else if (isCondition)
{
tracer.conditionExit(conditionId);
}
else if (!isSpecial)
{
if (isArithmetic(callName))
{
// process arguments
for (int argIdx = 0; argIdx < node.children.Length - 1; argIdx++)
{
ImmutableNodeReferer argumentValueNode = node.children[argIdx + 1].interpretationResult;
primitiveCalcResultForAdditionalArgument(argumentValueNode.value);
tracer.callArgument(callId, node.children[argIdx + 1], argumentValueNode, argIdx);
}
}
else if (isBasicMathFunctionWithOneParameter(callName))
{
Ensure.ensure(node.children.Length == 1 + 1 /* one arguments*/);
ImmutableNodeReferer valueNode = node.children[1 + 0].interpretationResult;
Ensure.ensure(isCastableTo(valueNode.value, Variant.EnumType.FLOAT));
Variant castedValueVariant = hardCastVariantTo(valueNode.value, Variant.EnumType.FLOAT);
double resultValue = 0.0;
switch (callName)
{
case "exp":
resultValue = Math.Exp(castedValueVariant.valueFloat);
break;
case "sin":
resultValue = Math.Sin(castedValueVariant.valueFloat);
break;
case "asin":
resultValue = Math.Asin(castedValueVariant.valueFloat);
break;
case "cos":
resultValue = Math.Cos(castedValueVariant.valueFloat);
break;
case "acos":
resultValue = Math.Acos(castedValueVariant.valueFloat);
break;
case "tan":
resultValue = Math.Tan(castedValueVariant.valueFloat);
break;
case "atan":
resultValue = Math.Atan(castedValueVariant.valueFloat);
break;
default:
throw new Exception("INTERNALERROR interpreter internal error");
}
interpretationResult = Variant.makeFloat(resultValue);
tracer.callArgument(callId, node.children[1 + 0], valueNode, 0);
}
else if (callName == "shl" || callName == "shr" || callName == "bAnd" || callName == "bOr") // shift
{
Ensure.ensure(node.children.Length == 1 + 2 /* two arguments*/);
ImmutableNodeReferer leftNode = node.children[1 + 0].interpretationResult;
ImmutableNodeReferer rightNode = node.children[1 + 1].interpretationResult;
long leftValue = leftNode.value.valueInt;
long rightValue = rightNode.value.valueInt;
long result = 0;
if (callName == "shl")
{
result = leftValue << (int)rightValue;
}
else if (callName == "shr")
{
result = leftValue >> (int)rightValue;
}
else if (callName == "bAnd")
{
result = leftValue & rightValue;
}
else if (callName == "bOr")
{
result = leftValue | rightValue;
}
// else should never happen
interpretationResult = Variant.makeInt(result);
tracer.callArgument(callId, node.children[1 + 0], leftNode, 0);
tracer.callArgument(callId, node.children[1 + 1], rightNode, 1);
}
else if (interpretationContext.publicFnRegistryAndDispatcher.existsFunction(callName))
{
// a function was invoked
IList <ImmutableNodeReferer> invokeParameters = new List <ImmutableNodeReferer>();
// collect invoke parameters
for (int i = 0; i < node.children.Length - 1; i++)
{
invokeParameters.Add(node.children[1 + 0].interpretationResult);
}
ImmutableNodeReferer calleeResult = interpretationContext.publicFnRegistryAndDispatcher.dispatchCall(callName, invokeParameters);
node.interpretationResult = calleeResult;
interpretationResultOfNodeIsAlreadySet = true;
}
else
{
throw new Exception("INTERNALERRROR"); // hard internal error because the case should be handled, because we already made sure that the callName is valid
}
if (!interpretationResultOfNodeIsAlreadySet)
{
node.interpretationResult = ImmutableNodeReferer.makeNonbranch(ValueNode.makeAtomic(interpretationResult.Value));
}
tracer.callResult(callId, node.interpretationResult);
tracer.callExit(callId);
}
}
public void execute(PrimitiveInterpretationContext context, ImmutableNodeReferer node)
{
Ensure.ensure(node.children[1].valueInt >= 0);// TODO< ensure >
context.ip = (int)node.children[1].valueInt;
}
protected override void interpret2(FunctionalInterpretationContext interpretationContext, ImmutableNodeReferer node, IList <ImmutableNodeReferer> arguments, IList <string> argumentNames)
{
resetVariablesToParameters(interpretationContext, arguments, argumentNames);
tracer.interpreterEnter(node, arguments);
recursiveInterpret(interpretationContext, node);
tracer.interpreterExit();
}
// TODO< move to helper >
static void ensureNodeIsDatatype(ImmutableNodeReferer node, string datatype)
{
Ensure.ensure(node.type == ValueNode.EnumType.STRING_DATATYPE && node.valueString == datatype);
}
public void assignVariable(string name, ImmutableNodeReferer node)
{
Ensure.ensureHard(!existsVariableByName(name));
valuesByName.Add(name, node);
}
public void conditionCondition(int conditionId, ImmutableNodeReferer node, ImmutableNodeReferer value)
{
}
public void callArgument(int callId, ImmutableNodeReferer node, ImmutableNodeReferer value, int idx)
{
}
public void arrayInsert1()
{
var orginal = NodeRefererEntryManipulationHelper.makeImmutableArray(new List <Variant>());
var insertedArray = NodeRefererEntryManipulationHelper.arrayInsert(orginal, 0, ImmutableNodeReferer.makeNonbranch(ValueNode.makeAtomic(Variant.makeInt(42))));
Assert.AreEqual(insertedArray.entry.children[0].valueInt, 42);
}
protected override void interpret2(PrimitiveInterpretationContext interpretationContext, ImmutableNodeReferer node, IList <ImmutableNodeReferer> arguments, IList <string> argumentNames)
{
switch (node.children[0].type)
{
case ValueNode.EnumType.INSTR_CMP_NEQ_INT:
instructionCmpNeqInteger.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_CMP_EQ_INT:
instructionCmpEqInteger.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_CMP_G_INT:
instructionCmpGInteger.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_CMP_GE_INT:
instructionCmpGeInteger.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_GOTO:
instructionGoto.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_ADD_INT:
instructionAddInteger.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_SUB_INT:
instructionSubInteger.execute(interpretationContext, node);
return;
case ValueNode.EnumType.INSTR_MUL_INT:
instructionMulInteger.execute(interpretationContext, node);
return;
}
}
protected abstract void interpret2(ContextType interpretationContext, ImmutableNodeReferer node, IList <ImmutableNodeReferer> arguments, IList <string> argumentNames);
