private IList <Node> evalVariableDeclration(Node node, ActivationFrame frame, Interpreter callback)
{
if (node.Instructions.Count == 2)
{
VariableNode variableNode = (VariableNode)node.Instructions[1];
frame.variableSet[variableNode.variableName] = variableNode;
}
else if (node.Instructions.Count > 2)
{
IList <Node> returnValue = EvaluateAssignments.evalVariableDeclWithAssignment(node, activationFrameStack, mainFunctionName, functionNodeMap);
if (returnValue.Count > 0)
{
execute(returnValue);
}
}
return(new List <>());
}
/*
* private class operatorBinding {
* public
* }
*/
public Interpreter(InstructionInvocation invocation)
{
if (!InstanceFieldsInitialized)
{
InitializeInstanceFields();
InstanceFieldsInitialized = true;
}
try
{
EvaluateAssignments.create(this);
IList <Node> inst = invocation.InstructionList;
activationFrameStack.push(new ActivationFrame("compliationUnit"));
functionNodeMap = invocation.FunctionNodeMap;
functionMap[NodeType.VariableReassignmentType] = (EvaluateAssignments::evalReassignment);
functionMap[NodeType.AssignmentType] = (EvaluateAssignments::evalAssignment);
functionMap[NodeType.PrimitiveType] = (EvaluatePrimitives::evalPrimitives);
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.CompliationUnitType] = ((n, activationFrame, callback) => evalCompilationUnit());
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.AddType] = ((n, activationFrame, callback) => evalAdd());
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.CommandType] = ((n, activationFrame, callback) => evalCommand(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.SummationType] = ((n, activationFrame, callback) => evalSummation());
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.FunctionaCallType] = ((n, activationFrame, callback) => evalFunctionCall(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.FunctionDeclType] = ((n, activationFrame, callback) => evalFunctionDecl(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.VariableType] = ((n, activationFrame, callback) => evalActivationFrame(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.BinaryType] = ((n, activationFrame, callback) => evalBinaryNode(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.StatementType] = ((n, activationFrame, callback) => evalStatement(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.ExpressionType] = ((n, activationFrame, callback) => evalStatement(n));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.FinalType] = ((n, activationFrame, callback) => evalFinal());
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.EvaluatableType] = ((n, activationFrame, callback) => evaluateEvauatable(n, activationFrame, callback));
//JAVA TO C# CONVERTER TODO TASK: Java lambdas satisfy functional interfaces, while .NET lambdas satisfy delegates - change the appropriate interface to a delegate:
functionMap[NodeType.UserDefinedFunctionReferenceType] = ((n, activationFrameStack, callback) => evalUserDefinedFunctionCall(n));
functionMap[NodeType.AggregateType] = (this::evaluateAggregate);
functionMap[NodeType.ReturnValueType] = (this::evalReturn);
functionMap[NodeType.BooleanType] = (this::evalBooleanNode);
functionMap[NodeType.BooleanOperatorType] = (this::evalBooleanOperator);
functionMap[NodeType.IfExprType] = (this::evalIfStatement);
functionMap[NodeType.WhileExpressionType] = (this::evalWhileExpression);
functionMap[NodeType.VariableDeclarationType] = (this::evalVariableDeclration);
//functionMap.put(NodeType.VariableDeclarationType, (n-> eval(n)));
//functionMap.put(NodeType.ReturnValueType , (n-> evalReassignment(n) ));
execute(inst);
}
catch (Exception ex)
{
JuliarLogger.log(ex);
}
}
public static IList <Node> evalVariableDeclWithAssignment(Node n, ActivationFrameStack activationFrameStack, string mainName, IDictionary <string, Node> functionNodeMap)
{
VariableDeclarationNode variableDeclarationNode = (VariableDeclarationNode)n;
IList <Node> instructionsToReturnAndExecute = new List <Node>();
IList <Node> instructions = variableDeclarationNode.Instructions;
KeywordNode keywordNode = variableDeclarationNode.KeyWordNode;
Node rightHandSide = null;
if (variableDeclarationNode.DeclarationWithAssignment)
{
if (!variableDeclarationNode.OperatorEqualSign)
{
throw new Exception("Invalid operator for expression");
}
rightHandSide = variableDeclarationNode.RightValue;
switch (rightHandSide.Type)
{
case LiteralType:
if (rightHandSide is LiteralNode)
{
LiteralNode literalNode = (LiteralNode)rightHandSide;
EvaluateAssignments <LiteralNode> literalNodeEvaluateAssignments = new EvaluateAssignments <LiteralNode>();
if (literalNodeEvaluateAssignments.canLiteralBeAssigned(keywordNode, literalNode))
{
if (instructions[1] is VariableNode)
{
VariableNode variableNode = (VariableNode)instructions[1];
if (activationFrameStack.peek().variableSet.ContainsKey(variableNode.variableName))
{
throw new Exception("Variable already declared");
}
else
{
activationFrameStack.peek().variableSet[variableNode.variableName] = rightHandSide;
}
}
}
}
break;
case FunctionaCallType:
instructionsToReturnAndExecute = EvaluateFunctionsCalls.evalFunctionCall(rightHandSide, activationFrameStack, mainName, functionNodeMap, interpreterCallback);
if (activationFrameStack.peek().parameterStack.Count > 0)
{
VariableNode variableNode = (VariableNode)instructions[1];
if (activationFrameStack.peek().variableSet.ContainsKey(variableNode.variableName))
{
throw new Exception("Variable already declared");
}
else
{
activationFrameStack.peek().variableSet[variableNode.variableName] = activationFrameStack.peek().parameterStack.Pop();
}
}
break;
}
}
return(instructionsToReturnAndExecute);
}
