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); }