/// <summary> /// Transforms Node to the Final ProtoAST form /// </summary> /// <returns></returns> public List<AssociativeNode> ToGraphIR(AST graph, GraphCompiler graphCompiler) { GraphNodeToASTGenerator astGen = new GraphNodeToASTGenerator(graph, graphCompiler); astGen.AddNodesToAST(); List<ProtoCore.AST.AssociativeAST.AssociativeNode> irGraph = astGen.SplitAST(); return irGraph; }
private void InitRunner(Options options) { graphCompiler = GraphToDSCompiler.GraphCompiler.CreateInstance(); graphCompiler.SetCore(GraphUtilities.GetCore()); runner = new ProtoScriptTestRunner(); executionOptions = options; InitOptions(); InitCore(); taskQueue = new Queue <Task>(); workerThread = new Thread(new ThreadStart(TaskExecMethod)); workerThread.IsBackground = true; workerThread.Start(); staticContext = new ProtoCore.CompileTime.Context(); }
public void TestDivision01() { GraphToDSCompiler.GraphCompiler gc = GraphToDSCompiler.GraphCompiler.CreateInstance(); gc.CreateOperatorNode(1, "/"); object o1 = 10; gc.CreateLiteralNode(2, o1); object o2 = 11; gc.CreateLiteralNode(3, o2); gc.ConnectNodes(2, 0, 1, 0); gc.ConnectNodes(3, 0, 1, 1); string mmx = gc.GetGraph2String(); mmx = mmx.Trim(); ExecutionMirror mirror = thisTest.RunScriptSource(mmx); Obj o = mirror.GetValue("temp20001"); Assert.IsTrue((Double)o.Payload == (10 / 11)); }
/*Tron*/ public List<SnapshotNode> PrintCodeForSelectedNodes(GraphCompiler originalGC, List<SnapshotNode> inputs) { this.AddNodesToAST(); this.MakeConnectionsForAddedNodes(); bool removeFromRemovedNodes = true; this.RemoveNodes(removeFromRemovedNodes); this.UpdateModifiedNodes(); //List<string> code = this.gc.PrintGraph_NodeToCode(); List<SnapshotNode> code = this.gc.ToCode(this.gc.Graph, originalGC, inputs); gc.UpdateDirtyFlags(nodesToModify); return code; }
public GraphNodeToASTGenerator(AST graph, GraphCompiler gc) { this.graph = graph; this.gc = gc; }
/**/ public List<uint> ConnectionToUID(List<Connection> input) { List<uint> result = new List<uint>(); foreach (Connection inputConnection in input) { result.Add(inputConnection.OtherNode); } return result; } /*Tron: Use for node to code function *For each connected component of the graph, generate a respective string of code */ public List<SnapshotNode> ToCode(AST graph, GraphCompiler originalGC, List<SnapshotNode> inputs) { List<SnapshotNode> result = new List<SnapshotNode>(); List<Node> li = TopSort.sort(graph); tguid = 20000; List<string> listIslands = new List<string>(); List<Node> islandNodes = new List<Node>(); int countIslands = 0; statementList = new AST(); ModifiedStmtGuidList.Clear(); List<string> importIslands = new List<string>(); IEnumerable iter = li; List<Node> islandNodeList = new List<Node>(); //List<List<Node>> listing = new List<List<Node>>(); List<Node> listing = new List<Node>(); foreach (Node node in iter) { if (node != null) { if (node is ImportNode) { importIslands.Add(node.ToScript() + ProtoCore.DSASM.Constants.termline); } else if (node.IsIsland) { countIslands++; if (node is ArrayNode) { BuildArrayNodeStatement(node, statementList); if (!islandNodes.Contains(node)) islandNodes.Add(node); string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline; if (!listIslands.Contains(island)) listIslands.Add(island); } else if (node is LiteralNode) { BuildLiteralNodeStatement(node, statementList); string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline; if (!listIslands.Contains(island)) listIslands.Add(island); } else if (node is Func) { BuildFunctionCallStatement(node, statementList); string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline; if (!listIslands.Contains(island)) listIslands.Add(island); } else if (node is Operator) { BuildOperatorStatement(node, statementList); string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline; if (!listIslands.Contains(island)) listIslands.Add(island); } else if (node is Block) { BuildBlockStatement(node, statementList); islandNodes.Add(node); //string island = statementList.GetNode(node.Guid).ToScript() + ProtoCore.DSASM.Constants.termline; //if (!listIslands.Contains(island)) // listIslands.Add(island); } else if (node is IdentNode) { // comment Jun: // An island identifier node is handled by emitting a null as its rhs statementList.AddNode(node); string contents = statementList.GetNode(node.Guid).ToScript() + "=" + ProtoCore.DSASM.Literal.Null + ProtoCore.DSASM.Constants.termline; listIslands.Add(contents); } else { statementList.AddNode(node); string island = node.ToScript() + ProtoCore.DSASM.Constants.termline; if (!listIslands.Contains(island)) listIslands.Add(island); } islandNodeList.Add(node); listing = listing.ToList().Union<Node>(BuildStatement(node, statementList)).ToList(); HandleNewNode(node); } else if (node.IsLeaf) { if (node is ArrayNode) { BuildArrayNodeStatement(node, statementList); } else if (node is LiteralNode) { BuildLiteralNodeStatement(node, statementList); } else if (node is Func) { BuildFunctionCallStatement(node, statementList); } else if (node is Operator) { BuildOperatorStatement(node, statementList); } else if (node is Block) { BuildBlockStatement(node, statementList); } else if (node is IdentNode) { statementList.AddNode(node); string contents = statementList.GetNode(node.Guid).ToScript() + "=" + ProtoCore.DSASM.Literal.Null + ProtoCore.DSASM.Constants.termline; listIslands.Add(contents); } HandleNewNode(node); } else if (node.IsRoot && !node.IsIsland) { if (node is Operator) { BuildOperatorStatement(node, statementList); } else if (node is Func) { BuildFunctionCallStatement(node, statementList); } else if (node is Block) { BuildBlockStatement(node, statementList); } //liststat = BuildStatement(node, statementList); //finalScript=finalScript.Union(BuildStatement(node, statementList)).ToList(); //comment out for NodeToCode function //listing.Add(BuildStatement(node, statementList)); listing = BuildStatement(node, statementList); HandleNewNode(node); } else if (node is Operator) { BuildOperatorStatement(node, statementList); HandleNewNode(node); } else if (node is Func) { BuildFunctionCallStatement(node, statementList); HandleNewNode(node); } else if (node is ArrayNode) { BuildArrayNodeStatement(node, statementList); HandleNewNode(node); } else if (node is LiteralNode) { BuildLiteralNodeStatement(node, statementList); HandleNewNode(node); } else if (node is Block) { BuildBlockStatement(node, statementList); listing = BuildStatement(node, statementList); HandleNewNode(node); } } } StringBuilder builder = new StringBuilder(); foreach (string island in importIslands)// Loop through all strings { builder.Append(island); // Append string to StringBuilder } foreach (string island in listIslands) // Loop through all strings { builder.Append(island); // Append string to StringBuilder } /*N2C*/ #region get connected components of the graph List<Node> nodeToCodeInputList = new List<Node>(); List<List<Node>> listingAlternate = new List<List<Node>>(); List<List<Node>> listingAlt2 = new List<List<Node>>(); if (nodeToCodeUIDs.Count != 0) { foreach (uint nodeID in nodeToCodeUIDs) { if (graph.GetNode(nodeID) != null) { nodeToCodeInputList.Add(graph.GetNode(nodeID)); } else { if (this.codeBlockUIDMap[nodeID] != null) { foreach (KeyValuePair<int, uint> pair in this.codeBlockUIDMap[nodeID]) { nodeToCodeInputList.Add(graph.GetNode(pair.Value)); } } } } //listingAlternate = GetConnectedComponents(nodeToCodeInputList, graph); listingAlt2 = GetConnectedComponents_02(nodeToCodeInputList, graph); } #endregion //foreach (List<Node> n1 in listing) //{ // foreach (Node n2 in n1) // if (!finalScript.Contains(n2)) // finalScript.Add(n2); // else // { // finalScript.Remove(n2); // finalScript.Add(n2); // } //} listing = SortCodeBlocks(listing); List<List<Node>> finalList = new List<List<Node>>(); foreach (List<Node> l1 in listingAlt2) { List<Node> temp = new List<Node>(); foreach (Node n1 in l1) foreach (Node listingNode in listing) if (listingNode.Guid == n1.Guid) temp.Add(listingNode); if (temp.Count != 0) finalList.Add(temp); } islandNodeList = islandNodeList.Union(islandNodes).ToList(); //islandNodeList = SortCodeBlocks(islandNodeList); //if (islandNodeList.Count != 0) // finalList.Add(islandNodeList); #region generate code and snapshot node uint id = 0; foreach (List<Node> nodeList in finalList) { string output = ""; List<Node> tempList = SortCodeBlocks(nodeList); //tempList.Reverse(); foreach (Node node in tempList) { if (nodeToCodeUIDs.Contains(node.Guid)) { if (node.ToCode() != null) output += node.ToCode().Replace(";", "") + ProtoCore.DSASM.Constants.termline; } else { foreach (KeyValuePair<uint, Dictionary<int, uint>> pair in this.codeBlockUIDMap) { if (pair.Value.ContainsValue(node.Guid)) { output += node.ToCode().Replace(";", "") + ProtoCore.DSASM.Constants.termline; //ensure only one semicolon at the end of a statement, by request from UI } } } } output = output.TrimEnd('\n'); SnapshotNode ssn = new SnapshotNode(); ssn.Id = id++; ssn.Content = output; ssn.Type = SnapshotNodeType.CodeBlock; ssn.InputList = new List<Connection>(); foreach (SnapshotNode inputNode in inputs) { foreach (Node subTreeNode in nodeList) { if (inputNode.Id == subTreeNode.Guid) { foreach (Connection c1 in inputNode.InputList) { if (!IsInternalConnection(c1, this)) //the connection is not internal, return it back to UI { Connection newInputConnection = new Connection(); newInputConnection.OtherNode = c1.OtherNode; newInputConnection.OtherIndex = c1.OtherIndex; newInputConnection.IsImplicit = c1.IsImplicit; string[] tokens = graph.GetNode(c1.OtherNode).Name.Split('='); newInputConnection.LocalName = tokens[0]; ssn.InputList.Add(newInputConnection); } } } else if (codeBlockUIDMap.ContainsKey(inputNode.Id)) //inputNode was split { if (codeBlockUIDMap[inputNode.Id].ContainsValue(subTreeNode.Guid)) { foreach (Connection c1 in inputNode.InputList) { if (!IsInternalConnection(c1, this)) { int indexSlot = 0; foreach (KeyValuePair<int, uint> pair in codeBlockUIDMap[inputNode.Id]) { if (pair.Value == subTreeNode.Guid) indexSlot = pair.Key; } if (c1.OtherIndex == indexSlot) { Connection newInputConnection = new Connection(); newInputConnection.OtherNode = c1.OtherNode; newInputConnection.OtherIndex = c1.OtherIndex; foreach (KeyValuePair<uint, Dictionary<int, uint>> pair in originalGC.codeBlockUIDMap) { if (pair.Value.ContainsValue(c1.OtherNode)) //this means if the other node was split, return the original Id that was sent to us by the UI { newInputConnection.OtherNode = pair.Key; newInputConnection.OtherIndex = pair.Value.First(x => x.Value == c1.OtherNode).Key; } } newInputConnection.IsImplicit = c1.IsImplicit; string[] tokens = graph.GetNode(c1.OtherNode).Name.Split('='); newInputConnection.LocalName = tokens[0]; ssn.InputList.Add(newInputConnection); } } } } } } } ssn.OutputList = new List<Connection>(); foreach (SnapshotNode inputNode in inputs) { foreach (Node subTreeNode in nodeList) { //if (subTreeNode.Name.Split('=')[0] == outputCnt.LocalName) if (inputNode.Id == subTreeNode.Guid) { foreach (Connection c1 in inputNode.OutputList) { if (!IsInternalConnection(c1, this)) { Connection newOutputConnection = new Connection(); newOutputConnection.OtherNode = c1.OtherNode; newOutputConnection.OtherIndex = c1.OtherIndex; newOutputConnection.IsImplicit = c1.IsImplicit; newOutputConnection.LocalName = c1.LocalName; ssn.OutputList.Add(newOutputConnection); } } } else if (codeBlockUIDMap.ContainsKey(inputNode.Id)) //inputNode was split { if (codeBlockUIDMap[inputNode.Id].ContainsValue(subTreeNode.Guid)) { foreach (Connection c1 in inputNode.OutputList) { if (!IsInternalConnection(c1, this)) { int indexSlot = 0; foreach (KeyValuePair<int, uint> pair in codeBlockUIDMap[inputNode.Id]) { if (pair.Value == subTreeNode.Guid) { indexSlot = pair.Key; break; } } if (c1.LocalIndex == indexSlot) { Connection newOutputConnection = new Connection(); newOutputConnection.OtherNode = c1.OtherNode; newOutputConnection.OtherIndex = c1.OtherIndex; foreach (KeyValuePair<uint, Dictionary<int, uint>> pair in originalGC.codeBlockUIDMap) { if (pair.Value.ContainsValue(c1.OtherNode)) //this means if the other node was split, return the original Id that was sent to us by the UI { newOutputConnection.OtherNode = pair.Key; newOutputConnection.OtherIndex = pair.Value.First(x => x.Value == c1.OtherNode).Key; } } newOutputConnection.IsImplicit = c1.IsImplicit; newOutputConnection.LocalName = c1.LocalName; ssn.OutputList.Add(newOutputConnection); } } } } } } } result.Add(ssn); } #endregion #region remove _temp_xxx name //Dictionary<string, string> tempReplaceValue = new Dictionary<string, string>(); //for (int i = 0; i < result.Count; i++) //{ // SnapshotNode ssn = result[i]; // string[] statements = ssn.Content.Split(';'); // for (int j = 0; j < statements.Length; j++) // { // string statement = statements[j]; // string lhsTempName = statement.Split('=')[0].Replace("\n", "").Trim(); // foreach (Node astNode in graph.nodeList) // { // if (astNode.Name.Split('=')[0].Trim() == lhsTempName && lhsTempName.StartsWith("_temp_")) // { // //this means in the ast there is some statement _temp_abc = something // //which means the _temp_xxx is generated, not typed in by users // tempReplaceValue.Add(lhsTempName, statement.Split('=')[1].Replace("\n", "").Trim()); // } // } // } //} //for (int i = 0; i < result.Count; i++) //{ // SnapshotNode ssn = result[i]; // foreach (KeyValuePair<string, string> pair in tempReplaceValue) // { // ssn.Content.Replace(pair.Key, pair.Value); // } //} #endregion #region replace _temp_ name with more elegant name //int tempId = 0; //for (int i = 0; i < result.Count; i++) //{ // SnapshotNode ssn = result[i]; // string[] statements = ssn.Content.Split(';'); // for (int j = 0; j < statements.Length; j++) // { // string statement = statements[j]; // string lhsTempName = statement.Split('=')[0].Replace("\n", "").Trim(); // foreach (Node astNode in graph.nodeList) // { // if (astNode.Name.Split('=')[0].Trim() == lhsTempName && lhsTempName.StartsWith("_temp_")) // { // string newTempName = "temp_" + tempId++; // for (int k = 0; k < result.Count; k++) // { // result[k].Content = result[k].Content.Replace(lhsTempName, newTempName); // } // } // } // if (statement.Split('=').Length > 1) // { // string rhsTempName = statement.Split('=')[1].Replace("\n", "").Trim(); // foreach (Node astNode in graph.nodeList) // { // if (astNode.Name.Split('=')[0].Trim() == rhsTempName && rhsTempName.StartsWith("_temp_")) // { // string newTempName = "temp_" + tempId++; // for (int k = 0; k < result.Count; k++) // { // result[k].Content = result[k].Content.Replace(rhsTempName, newTempName); // } // } // } // } // } //} #endregion #region return to original input connections for (int i = 0; i < result.Count; i++) { SnapshotNode ssn = result[i]; for (int j = 0; j < ssn.InputList.Count; j++) { Connection inputConnection = ssn.InputList[j]; foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap) { foreach (KeyValuePair<int, uint> kvp2 in kvp.Value) { if (kvp2.Value == inputConnection.OtherNode) { Connection oldInputConnection = new Connection(); oldInputConnection.OtherNode = kvp.Key; oldInputConnection.OtherIndex = inputConnection.OtherIndex; oldInputConnection.IsImplicit = inputConnection.IsImplicit; oldInputConnection.LocalName = inputConnection.LocalName; oldInputConnection.LocalIndex = inputConnection.LocalIndex; ssn.InputList.Remove(inputConnection); ssn.InputList.Insert(j, oldInputConnection); } } } } for (int j = 0; j < ssn.OutputList.Count; j++) { Connection outputConnection = ssn.OutputList[j]; foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap) { foreach (KeyValuePair<int, uint> kvp2 in kvp.Value) { if (kvp2.Value == outputConnection.OtherNode) { Connection oldInputConnection = new Connection(); oldInputConnection.OtherNode = kvp.Key; oldInputConnection.OtherIndex = outputConnection.OtherIndex; oldInputConnection.IsImplicit = outputConnection.IsImplicit; oldInputConnection.LocalName = outputConnection.LocalName; oldInputConnection.LocalIndex = outputConnection.LocalIndex; ssn.OutputList.Remove(outputConnection); ssn.OutputList.Insert(j, oldInputConnection); } } } } } #endregion /*Chirag's foreach (var value in finalScript) { if (nodeToCodeUIDs.Contains((value as Node).Guid)) if (value.ToCode() != null) liststat += value.ToCode() + ProtoCore.DSASM.Constants.termline; } liststat = builder.ToString() + liststat; //liststat += builder.ToString(); //GraphUtilities.runningUID = GraphToDSCompiler.Constants.UIDStart; //result.AddRange(liststat.Split(';')); */ UpdateAddedNodesInModifiedNameList(); return result; }
private bool IsInternalConnection(Connection c1, GraphCompiler oriGC) { bool result = false; if (nodeToCodeUIDs.Contains(c1.OtherNode)) { result = true; } else { foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in oriGC.codeBlockUIDMap) { if (nodeToCodeUIDs.Contains(kvp.Key) && kvp.Value.ContainsValue(c1.OtherNode)) result = true; } } return result; }
private void InitRunner(Options options) { graphCompiler = GraphToDSCompiler.GraphCompiler.CreateInstance(); graphCompiler.SetCore(GraphUtilities.GetCore()); runner = new ProtoScriptTestRunner(); executionOptions = options; InitOptions(); InitCore(); taskQueue = new Queue<Task>(); workerThread = new Thread(new ThreadStart(TaskExecMethod)); workerThread.IsBackground = true; workerThread.Start(); staticContext = new ProtoCore.CompileTime.Context(); terminating = false; changeSetComputer = new ChangeSetComputer(runnerCore); changeSetApplier = new ChangeSetApplier(); }
public LiveRunner(Configuration configuration) { this.configuration = configuration; graphCompiler = GraphCompiler.CreateInstance(); graphCompiler.SetCore(GraphUtilities.GetCore()); runner = new ProtoScriptTestRunner(); InitCore(); taskQueue = new Queue<Task>(); workerThread = new Thread(new ThreadStart(TaskExecMethod)); workerThread.IsBackground = true; workerThread.Start(); staticContext = new ProtoCore.CompileTime.Context(); terminating = false; changeSetComputer = new ChangeSetComputer(runnerCore); changeSetApplier = new ChangeSetApplier(); }