private IList <Node> evaluateAggregate(Node node, ActivationFrame frame, Interpreter callback) { SummationType summationType = (SummationType)node.Instructions[0]; IList <Node> list = node.Instructions; int size = list.Count; int sum = 0; IList <VariableNode> listOfVariableNodes = new List <VariableNode>(); for (int i = 1; i < size; i++) { if (node.Instructions[i] is VariableNode) { listOfVariableNodes.Add((VariableNode)node.Instructions[i]); } else { string value = ((FinalNode)list[i].Instructions[0]).dataString(); sum += Convert.ToInt32(value); } } if (listOfVariableNodes.Count > 0) { sum += aggregateVariable(listOfVariableNodes, frame); } FinalNode returnNode = new FinalNode(); returnNode.DataString = sum; frame.pushReturnNode(returnNode); return(new List <>()); }
public virtual void evaluateExpressionStack() { Node @operator = null; if (operatorStack.Count == 0) { throw new Exception("not operators on stack"); } @operator = operatorStack.Pop(); //TODO ensure the type is accurate. //assert false : "this needs to fail until i fix it"; if (@operator.Type.Equals(NodeType.EqualEqualType) && operandStack.Count >= 2) { NodeImpl r = (NodeImpl)operandStack.Pop(); NodeImpl l = (NodeImpl)operandStack.Pop(); ActivationFrame frame = activationFrameStack.peek(); object rReal = r.getRealValue(frame); object lreal = l.getRealValue(frame); bool equalEqualEval = rReal.Equals(lreal); BooleanNode booleanNode = new BooleanNode(); FinalNode finalNode = new FinalNode(); finalNode.DataString = equalEqualEval; booleanNode.addInst(finalNode); operandStack.Push(booleanNode); } }
public virtual void pushOperatorStack(Node node) { if (operatorStack.Count == 0) { operatorStack.Push(node); } else { FinalNode currentOperand = (FinalNode)operatorStack.Peek(); int currentNodePrecedence = getOperatorPrecedenceValue(currentOperand); int newNodePrecedence = getOperatorPrecedenceValue((FinalNode)node); SrEval eval = operatorPrecedenceTable.shiftReduceOperationTable[currentNodePrecedence][newNodePrecedence]; if (eval == SrEval.Shift) { operatorStack.Push(node); return; } if (eval == SrEval.Reduce) { if (operandStack.Count >= 2) { Node rValue = operandStack.Pop(); Node lValue = operandStack.Pop(); Node operation = operatorStack.Pop(); evalBooleanOperation(operation, lValue, rValue); // Need to Evaluate the operation. // Create a new node? } } } }
private int aggregateVariable(IList <VariableNode> variableNodeList, ActivationFrame frame) { int sum = 0; for (int i = 0; i < variableNodeList.Count; i++) { Node v = frame.variableSet[variableNodeList[i].variableName]; FinalNode finalNode = null; if (v is FinalNode && v.Instructions.Count == 0) { finalNode = (FinalNode)v; } if (v is PrimitiveNode) { PrimitiveNode primitiveNode = (PrimitiveNode)v; finalNode = (FinalNode)primitiveNode.Instructions[0]; } if (finalNode != null) { sum += Convert.ToInt32(finalNode.dataString()); } } return(sum); }
public override Node visitEndLine(JuliarParser.EndLineContext ctx) { FinalNode finalNode = new FinalNode(); new IterateOverContext(this, ctx, this, finalNode); return(finalNode); }
public virtual bool canLiteralBeAssigned <T>(KeywordNode keyword, T t) where T : NodeImpl { if (keyword.Instructions[0] is FinalNode) { FinalNode finalNode = (FinalNode)keyword.Instructions[0]; string dataType = finalNode.dataString(); string rvalueDataString = ((FinalNode)t.Instructions.get(0)).dataString(); switch (finalNode.IntegralType) { case jinteger: { try { Convert.ToInt32(rvalueDataString); } catch (NumberFormatException) { throw new Exception("invalid r-Value"); } return(true); } } } return(false); }
internal PropertyPathWalker(string path, bool isDatacontextBound) { _path = path; _isDataContextBound = isDatacontextBound; if (_isDataContextBound) { _firstNode = new DependencyPropertyNode(FrameworkElement.DataContextProperty); } ParsePath(_path, out IPropertyPathNode head, out IPropertyPathNode tail); if (_firstNode == null) { _firstNode = head ?? new StandardPropertyPathNode(); } else { _firstNode.Next = head; } FinalNode = tail ?? _firstNode; FinalNode.Listen(this); }
public static string sysExec(Node argumentNode) { if (argumentNode is FinalNode) { FinalNode finalNode = (FinalNode)argumentNode; return(com.juliar.pal.Primitives.sysExec(finalNode.dataString())); } return(""); }
private static string fileOpen(Node argumentNode) { if (argumentNode is FinalNode) { FinalNode finalNode = (FinalNode)argumentNode; return(sysFileOpen(finalNode.dataString())); } return(""); }
public static bool canPrimitiveValueBeAssignedToVar(VariableDeclarationNode lvalue, PrimitiveNode rvalue) { FinalNode rvalueTerminal = (FinalNode)rvalue.Instructions[0]; VariableNode variableNode; if (juserDefined == lvalue.IntegralType) { variableNode = lvalue.UserDefinedNode.VariableNode; } else { variableNode = (VariableNode)lvalue.Instructions[1]; } string data = rvalueTerminal.dataString(); try { switch (variableNode.IntegralType) { case jinteger: return(true); case jdouble: return(true); case jfloat: return(true); case jlong: return(true); case jstring: return(true); case jobject: return(false); case jboolean: return(Convert.ToBoolean(data)); case juserDefined: return(true); default: return(false); } } catch (NumberFormatException) { return(false); } }
private IList <Node> evalIfStatement(Node node, ActivationFrame frame, Interpreter callback) { IList <Node> instructionList = node.Instructions; int size = instructionList.Count; IList <Node> trueExpressions = new List <Node>(); BooleanNode booleanNode = getBooleanExpressionNode(instructionList, size, trueExpressions); if (booleanNode != null && booleanNode.Instructions.Count == 1) { FinalNode finalNode = (FinalNode)booleanNode.Instructions[0]; if (finalNode.IntegralType == IntegralType.jboolean) { bool? @bool = Convert.ToBoolean(finalNode.dataString()); if (@bool) { return(trueExpressions); } } } else if (booleanNode != null && booleanNode.Instructions.Count > 0) { Node currentValue = frame.popNode(); frame.pushReturnNode(null); bool?booleanResult = false; evalBooleanNode(booleanNode, frame, callback); if (frame.peekReturnNode() != null && frame.peekReturnNode() is BooleanNode) { Node booleanEvalReturnNode = frame.popNode(); FinalNode result = getFinalNodeFromAnyNode(booleanEvalReturnNode); booleanResult = Convert.ToBoolean(result.dataString()); } // TODO - FINISH THIS if (booleanResult && frame.peekReturnNode() != null) { Node returnNode = frame.popNode(); if (returnNode is BreakExprNode) { IList <Node> returnList = new List <Node>(); returnList.Add(returnNode); return(new List <>()); } } frame.pushReturnNode(currentValue); } return(new List <>()); }
public FinalNode RecreateChildrenAsFinal() { ActiveChild curr = this.LastChild; FinalNode newCurr = null; while (curr != null) { newCurr = new FinalNode(curr.Info, curr.Child, newCurr); curr = curr.PrevChild; } return(newCurr); }
public static IList <Node> evalPrimitives(Node n, ActivationFrame activationFrame, Interpreter calback) { string functionName = ((FinalNode)n.Instructions[0]).dataString(); FinalNode finalNode = new FinalNode(); switch (functionName) { case "print": printLine(activationFrame, functionName, n.Instructions[2]); break; case "__getByteFromString": getByteFromString(activationFrame, n.Instructions[1], n.Instructions[2]); break; case "printLine": printLine(activationFrame, functionName, n.Instructions[1]); break; case "fileOpen": string data = fileOpen(n.Instructions[2]); finalNode.DataString = data; finalNode.VariableTypeByIntegralType = IntegralType.jstring; activationFrame.pushReturnNode(finalNode); //activationFrame.returnNode = finalNode; break; case "sysExec": string ex = sysExec(n.Instructions[2]); finalNode.DataString = ex; finalNode.VariableTypeByIntegralType = IntegralType.jstring; activationFrame.pushReturnNode(finalNode); //activationFrame.returnNode = finalNode; break; case "availableMemory": long value = availableMemory(); finalNode.DataString = value; finalNode.VariableTypeByIntegralType = IntegralType.jlong; activationFrame.pushReturnNode(finalNode); //activationFrame.returnNode = finalNode; break; default: JuliarLogger.log("function " + functionName + " does not exist"); break; } return(new List <>()); }
public static void commandInstance(CommandNode commandNode, ActivationFrame activationFrame, VariableDeclarationNode variableToAssignTo) { IList <Node> slotList = new List <Node>(); slotList.Add(commandNode); interpreterCallback.execute(slotList); FinalNode variableNameTerminalNode = (FinalNode)variableToAssignTo.Instructions[1].Instructions[0]; string variableName = variableNameTerminalNode.dataString(); if (activationFrame.variableSet.ContainsKey(variableName)) { activationFrame.variableSet.Remove(variableName); } activationFrame.variableSet[variableName] = activationFrame.peekReturnNode(); //activationFrame.returnNode = null; }
protected void Teardown() { // Only dispose the dispatcher if it was created here. if (_hasLocalDispatcher) { // We are here because the FinalNode's ExitBehavior is running on the Dispatcher. // Attempting to dispose of the Dispatcher from the final executable using the Dispatcher's // own thread will cause the Dispatcher to kill (abort) it's thread. // That thread abort can be avoided by giving the Dispatcher cleanup to a different thread, // which allows the currently executing ExitBehavior to finish cleanly first. Task.Factory.StartNew(() => { LogService.Log(LogType, LogMessageType.Debug, GetType().Name, "Waiting for local dispatcher '" + Name + "' to be empty."); _dispatcher.WaitUntilDone(); LogService.Log(LogType, LogMessageType.Debug, GetType().Name, "'" + Name + "' is disposing."); // We are now completely done with the dispatcher. _dispatcher.Dispose(); _dispatcher = null; }); } try { _finishedEvent.Dispose(); } catch (ObjectDisposedException) { // reset event was disposed } //Dispose the UML nodes DisposeNodes(InitialNode); if (FinalNode != null) { // THIS MAY BE A PROBLEM if SimpleDispatcher is made to dispose IExecutables after executing them. FinalNode.Dispose(); } Dispose(); }
private int getOperatorPrecedenceValue(FinalNode node) { int precedence = -1; string dataString = node.dataString(); switch (dataString) { case "*": case "/": case "%": precedence = 7; break; case "+": case "-": precedence = 0; break; case "(": precedence = 9; break; case ")": precedence = 10; break; case "==": precedence = 13; break; case "&&": precedence = 14; break; case "||": precedence = 15; break; } return(precedence); }
private static void getByteFromString(ActivationFrame activationFrame, Node argumentNode, Node index) { string variableName = ((VariableNode)argumentNode).variableName; object variable = activationFrame.variableSet[variableName]; if (variable is FinalNode) { char[] array = sysGetByteFromString(((FinalNode)variable).dataString()); FinalNode finalNode = new FinalNode(); string argTwoVariableName = ((VariableNode)index).variableName; object argTwo = activationFrame.variableSet[argTwoVariableName]; FinalNode argumentTwo = null; if (argTwo is PrimitiveNode) { argumentTwo = (FinalNode)activationFrame.variableSet[argTwoVariableName].Instructions[0]; } else if (argTwo is FinalNode) { argumentTwo = (FinalNode)activationFrame.variableSet[argTwoVariableName]; } assert(argumentTwo != null ? argumentTwo.dataString() : null) != null; int parsedIndex = Convert.ToInt32(argumentTwo.dataString()); if (parsedIndex > array.Length) { throw new Exception("\r\nJuliar runtime exception - Index out of bounds accessing variable - '" + variableName + "'"); } if (parsedIndex < array.Length) { finalNode.DataString = array[parsedIndex]; activationFrame.pushReturnNode(finalNode); //activationFrame.returnNode = finalNode; } } }
public static void primitiveInstance(PrimitiveNode primitiveNode, ActivationFrame activationFrame, VariableDeclarationNode variableToAssignTo) { if (canPrimitiveValueBeAssignedToVar(variableToAssignTo, primitiveNode)) { string variableName; if (variableToAssignTo.IntegralType == juserDefined) { variableName = variableToAssignTo.UserDefinedNode.FullyQualifiedVariableName; } else { FinalNode variableNameTerminalNode = (FinalNode)variableToAssignTo.Instructions[1].Instructions[0]; variableName = variableNameTerminalNode.dataString(); } if (activationFrame.variableSet.ContainsKey(variableName)) { activationFrame.variableSet.Remove(variableName); } activationFrame.variableSet[variableName] = primitiveNode; } }
private IList <Node> evalBooleanNode(Node node, ActivationFrame frame, Interpreter callback) { Node variableType = node.Instructions[0]; if (node is BooleanOperatorNode) { // ((BooleanOperatorNode)node).evaluateExpression( frame , this); } try { Node lvalue = null; if (variableType is VariableNode) { string variableName = ((VariableNode)node.Instructions[0]).variableName; lvalue = frame.variableSet[variableName]; } else { lvalue = variableType; } bool isEqualEqual; Node rvalue = null; // This is ugly code. Need to find a better way to // handle these cases. // Multiple ifs will only cause confusion. FinalNode updatedLvalue = null; /* * if (node.getInstructions().size() == 1) { * //lvalue must be a single boolean expression * if (lvalue instanceof FinalNode) { * BooleanNode booleanNode = new BooleanNode(); * booleanNode.addInst(lvalue); * frame.pushReturnNode( booleanNode ); * return new ArrayList<>(); * } * * if (lvalue instanceof PrimitiveNode) { * updatedLvalue = (FinalNode) lvalue.getInstructions().get(0); * } * * } else if (node.getInstructions().size() > 1) { * //if (booleanOperatorNode.getInstructions().get(0) instanceof EqualEqualSignNode) { * //isEqualEqual; * //} * rvalue = node.getInstructions().get(2); * FinalNode updatedRvalue = null; * if (rvalue != null && rvalue instanceof PrimitiveNode) { * updatedRvalue = (FinalNode) rvalue.getInstructions().get(0); * } * * if (updatedLvalue != null) { * lvalue = updatedLvalue; * } * * if (updatedRvalue != null) { * rvalue = updatedRvalue; * } * * isEqualEqual = getFinalNodeFromAnyNode( lvalue) .dataString().equals( getFinalNodeFromAnyNode(rvalue).dataString()); * //else if (booleanOperatorNode.getInstructions().get(0) instanceof ) * FinalNode finalNode = new FinalNode(); * finalNode.setDataString(isEqualEqual); * * BooleanNode booleanNode = new BooleanNode(); * booleanNode.addInst(finalNode); * * frame.pushReturnNode( booleanNode ); * return new ArrayList<>(); * } */ } catch (Exception ex) { JuliarLogger.log(ex.Message); } return(new List <>()); }
public ActiveChild(T info, FinalNode child, ActiveChild prevChild) : base(info) { this.Child = child; this.PrevChild = prevChild; }
public FinalNode(T info, FinalNode child, FinalNode nextChild) : base(info) { this.Child = child; this.NextChild = nextChild; }
private static void printLine(ActivationFrame activationFrame, string functionName, Node argumentNode) { FinalNode finalNode = null; if (argumentNode == null) { if (activationFrame.peekReturnNode() != null) { //argumentNode = activationFrame.returnNode; argumentNode = activationFrame.popNode(); } } switch (argumentNode.Type) { case LiteralType: finalNode = (FinalNode)argumentNode.Instructions[0]; break; case VariableType: string variableName = ((VariableNode)argumentNode).variableName; Node tempVariableNode = activationFrame.variableSet[variableName]; if (tempVariableNode == null) { // a variable has been declared and not initazlized finalNode = new FinalNode(); break; } if (tempVariableNode is VariableNode) { string name = ((VariableNode)tempVariableNode).variableName; if (activationFrame.variableSet.ContainsKey(name)) { finalNode = (FinalNode)activationFrame.variableSet[name].Instructions[0]; } } else { printLine(activationFrame, functionName, tempVariableNode); return; } break; case FinalType: finalNode = (FinalNode)argumentNode; break; } if (finalNode == null) { dumpFrameVariables(activationFrame); Debug.Assert(finalNode != null, "the final node cannot be null"); } string stringToPrint = finalNode.dataString(); if (functionName.Equals("printLine")) { sysPrintLine(stringToPrint); return; } if (functionName.Equals("print")) { sysPrint(stringToPrint); return; } }
/// <summary/> public Material() { Nodes = new MaterialNodeCollection(); FinalNode = new FinalNode(); }
/// <summary> /// Распарсить XMI файл и создать объекты соответствующих классов /// </summary> /// <param name="diagram">Исходная диаграмма</param> /// <param name="hasJoinOrFork">Имеется ли join\fork</param> /// <returns></returns> public bool Parse(Diagram diagram, ref bool hasJoinOrFork) { xmlFile = diagram.doc; XmlNodeList xPackagedList; try { xPackagedList = xmlFile.GetElementsByTagName("packagedElement"); } catch (NullReferenceException) { //Console.WriteLine("[x] Тег packagedElement не найден"); return(false); } // получим корневой элемент XmlNode xRoot = FindActivePackageEl(xPackagedList); if (xRoot == null) { //Console.WriteLine("[x] Вид диаграммы не AD"); return(false); } var attr = xRoot.Attributes["xsi:type"]; if (attr == null) { //Console.WriteLine("[x] Не удалось распарсить xmi файл"); return(false); } if (!attr.Value.Equals("uml:Activity")) { //Console.WriteLine("[x] Вид диаграммы не AD"); return(false); } // пройтись по всем тегам и создать объекты foreach (XmlNode node in xRoot.ChildNodes) { var elAttr = node.Attributes["xsi:type"]; if (elAttr == null) { continue; } if (elAttr.Value == "uml:OpaqueAction" || elAttr.Value == "uml:InitialNode" || elAttr.Value == "uml:ActivityFinalNode" || elAttr.Value == "uml:FlowFinalNode" || elAttr.Value == "uml:DecisionNode" || elAttr.Value == "uml:MergeNode" || elAttr.Value == "uml:ForkNode" || elAttr.Value == "uml:JoinNode") { DiagramElement nodeFromXMI = null; switch (elAttr.Value) { // активность case "uml:OpaqueAction": nodeFromXMI = new ActivityNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]), AttrAdapter(node.Attributes["name"])); nodeFromXMI.setType(ElementType.ACTIVITY); adNodesList.addLast(nodeFromXMI); break; // узел инициализации case "uml:InitialNode": nodeFromXMI = new InitialNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"])); nodeFromXMI.setType(ElementType.INITIAL_NODE); adNodesList.addLast(nodeFromXMI); break; // конечное состояние case "uml:ActivityFinalNode": case "uml:FlowFinalNode": nodeFromXMI = new FinalNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"])); nodeFromXMI.setType(ElementType.FINAL_NODE); adNodesList.addLast(nodeFromXMI); break; // условный переход case "uml:DecisionNode": nodeFromXMI = new DecisionNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"]), AttrAdapter(node.Attributes["question"])); nodeFromXMI.setType(ElementType.DECISION); adNodesList.addLast(nodeFromXMI); break; // узел слияния case "uml:MergeNode": nodeFromXMI = new MergeNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"])); nodeFromXMI.setType(ElementType.MERGE); adNodesList.addLast(nodeFromXMI); break; // разветвитель case "uml:ForkNode": nodeFromXMI = new ForkNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"])); nodeFromXMI.setType(ElementType.FORK); adNodesList.addLast(nodeFromXMI); hasJoinOrFork = true; break; // синхронизатор case "uml:JoinNode": nodeFromXMI = new JoinNode(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["inPartition"])); nodeFromXMI.setType(ElementType.JOIN); adNodesList.addLast(nodeFromXMI); hasJoinOrFork = true; break; } // добавляем ид входящих и выходящих переходов if (nodeFromXMI != null) { string idsIn = node.Attributes["incoming"]?.Value; string idsOut = node.Attributes["outgoing"]?.Value; nodeFromXMI.addIn(idsIn ?? ""); nodeFromXMI.addOut(idsOut ?? ""); } } // создаем переход else if (node.Attributes["xsi:type"].Value.Equals("uml:ControlFlow")) { // находим подпись перехода var markNode = node.ChildNodes[1]; string mark = markNode.Attributes["value"].Value.Trim(); // если подпись является "yes", значит это подпись по умолчанию ControlFlow temp = new ControlFlow(node.Attributes["xmi:id"].Value, mark.Equals("true") ? "" : mark); temp.setType(ElementType.FLOW); temp.setSrc(AttrAdapter(node.Attributes["source"])); temp.setTarget(AttrAdapter(node.Attributes["target"])); adNodesList.addLast(temp); } // создаем дорожку else if (node.Attributes["xsi:type"].Value.Equals("uml:ActivityPartition")) { Swimlane temp = new Swimlane(node.Attributes["xmi:id"].Value, AttrAdapter(node.Attributes["name"])) { ChildCount = node.Attributes["node"] == null ? 0 : node.Attributes["node"].Value.Split().Length }; temp.setType(ElementType.SWIMLANE); if (temp.Name != "") { diagram.Actors.Add(temp); } adNodesList.addLast(temp); } // неизвестный элемент else { var unknownNode = new UnknownNode(node.Attributes["xmi:id"].Value); unknownNode.setType(ElementType.UNKNOWN); unknownNodes.Add(unknownNode); } } XmlNode coordRoot = null; try { coordRoot = xmlFile.GetElementsByTagName("plane")[0]; } catch (NullReferenceException) { //Console.WriteLine("[x] Тег packagedElement не найден"); } if (coordRoot != null) { FindCoordinates(coordRoot, diagram); } for (int i = 0; i < adNodesList.size(); i++) { var node = adNodesList.get(i); if (node is DiagramElement) { var nodeFromXMI = (DiagramElement)node; switch (nodeFromXMI.getType()) { case ElementType.FINAL_NODE: if (nodeFromXMI.inSize() == 0) { // ошибка ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_IN], MistakeAdapter.toString(MISTAKES.NO_IN), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_IN); } break; case ElementType.INITIAL_NODE: if (nodeFromXMI.outSize() == 0) { // ошибка ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_OUT], MistakeAdapter.toString(MISTAKES.NO_OUT), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_OUT); } break; default: if (nodeFromXMI.inSize() == 0 || nodeFromXMI.outSize() == 0) { // ошибка if (nodeFromXMI.inSize() == 0) { ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_IN], MistakeAdapter.toString(MISTAKES.NO_IN), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_IN); } if (nodeFromXMI.outSize() == 0) { ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.NO_OUT], MistakeAdapter.toString(MISTAKES.NO_OUT), new ADNodesList.ADNode(nodeFromXMI), ALL_MISTAKES.NO_OUT); } } break; } } } // ошибка - тип элемента не принадлежит AD foreach (var node in unknownNodes) { ADMistakeFactory.createMistake(MistakesSeriousness.mistakes[MISTAKES.FORBIDDEN_ELEMENT], MistakeAdapter.toString(MISTAKES.FORBIDDEN_ELEMENT), node, ALL_MISTAKES.FORBIDDEN_ELEMENT); } return(true); }
public IntegralTypeNode(FinalNode terminalNode, string name) { objectData = terminalNode; integralName = name; }
public static IList <Node> evalFunctionCall(Node node, ActivationFrameStack activationFrame, string mainFunctionName, IDictionary <string, Node> functionNodeMap, Interpreter callback) { FunctionCallNode functionCallNode = (FunctionCallNode)node; string functionToCall = functionCallNode.functionName(); //ActivationFrame evalFrame = activationFrameStack.pop(); bool isPrimitive = EvaluatePrimitives.evalIfPrimitive(node, activationFrame.peek(), callback); //activationFrameStack.push( evalFrame ); if (isPrimitive) { return(new List <>()); } // main should only be called from the compliationUnit if (functionCallNode.Equals(mainFunctionName)) { return(new List <>()); } FunctionDeclNode functionDeclNode = (FunctionDeclNode)functionNodeMap[functionToCall]; if (functionDeclNode != null) { ActivationFrame frame = new ActivationFrame(); frame.frameName = functionToCall; IList <VariableNode> sourceVariables = new List <VariableNode>(); IList <VariableDeclarationNode> targetVariables = new List <VariableDeclarationNode>(); foreach (Node v in node.Instructions) { if (v is VariableNode) { sourceVariables.Add((VariableNode)v); } } foreach (Node v in functionDeclNode.Instructions) { if (v is VariableDeclarationNode) { targetVariables.Add((VariableDeclarationNode)v); } } if (sourceVariables.Count != targetVariables.Count) { throw new Exception("Source and target variable count do not match"); } // since the function that is getting called can reference the variable using the // formal parameters of the function this code will match the calling functions data // with the target calling functions variable name. for (int i = 0; i < sourceVariables.Count; i++) { VariableNode variableNode = (VariableNode)targetVariables[0].Instructions[1]; if (variableNode.integralTypeNode == sourceVariables[i].integralTypeNode) { frame.variableSet[variableNode.variableName] = activationFrame.peek().variableSet[sourceVariables[i].variableName]; } else { throw new Exception("data types are not the same"); } } activationFrame.push(frame); IList <Node> statements = getFunctionStatements(functionDeclNode.Instructions); callback.execute(statements); activationFrame.pop(); //activationFrame.push(frame); //execute(functionDeclNode.getInstructions()); return(new List <Node>()); } else { FinalNode primitiveArg = new FinalNode(); primitiveArg.DataString = functionToCall; PrimitiveNode primitiveNode = new PrimitiveNode(); primitiveNode.addInst(primitiveArg); foreach (Node primArgs in node.Instructions) { if (primArgs is VariableNode || primArgs is IntegralTypeNode) { primitiveNode.addInst(primArgs); } } return(EvaluatePrimitives.evalPrimitives(primitiveNode, activationFrame.peek(), callback)); } }