/// <summary>
/// Given a graph, rewrite is given the heuristics of this pattern class
/// </summary>
/// <param name="graph"></param>
/// <returns></returns>
public List<SnapshotNode> RewriteFromPattern(List<SnapshotNode> graph)
{
List<SnapshotNode> n=new List<SnapshotNode>();
foreach (SnapshotNode c in graph)
n.Add(c);
foreach (SnapshotNode node in n)
{
if (node.Type == SnapshotNodeType.Function)
{
string[] functionQualifers = node.Content.Split(';');
switch (functionQualifers[1])
{
case "Math.Sin":
case "Math.Cos":
case "Math.Tan":
SnapshotNode ssn = new SnapshotNode((uint)(node.Id * 100), node.Type, "Math.dll;Math.RadiansToDegrees; ");
List<Connection> inp = new List<Connection>();
foreach (Connection c in node.InputList)
inp.Add(c);
ssn.InputList = inp;
ssn.OutputList = new List<Connection>();
graph.Add(ssn);
Connection connection = new Connection();
connection.OtherNode = ssn.Id;
connection.LocalIndex = 0;
connection.OtherIndex = 0;
int num = graph.IndexOf(node);
graph[num].InputList.Clear();
graph[num].InputList.Add(connection);
break;
default: break;
}
}
}
return graph;
}
public static List<SnapshotNode> NodeToCodeBlocks(List<SnapshotNode> inputs, GraphToDSCompiler.GraphCompiler originalGC)
{
List<SnapshotNode> codeBlocks = new List<SnapshotNode>();
GraphToDSCompiler.GraphCompiler newGC = GraphCompiler.CreateInstance();
newGC.SetCore(core);
GraphToDSCompiler.SynchronizeData newSyncData = new SynchronizeData();
newSyncData.AddedNodes = inputs;
newSyncData.ModifiedNodes = new List<SnapshotNode>();
newSyncData.RemovedNodes = new List<uint>();
GraphToDSCompiler.GraphBuilder GB = new GraphBuilder(newSyncData, newGC);
#region fix connection for multi-line CBN
/*for multi-line code blocks*/
List<Node> completeList = originalGC.Graph.nodeList;
List<uint> originalNodeUIDList = new List<uint>();
foreach (Node oriGcNode in completeList)
{
originalNodeUIDList.Add(oriGcNode.Guid);
}
GB.AddNodesToAST();
//List<SnapshotNode> inputsCopy = new List<SnapshotNode>(inputs);
for (int i = 0; i < inputs.Count; i++)
{
SnapshotNode inputSnapshotNode = inputs[i];
for (int j = 0; j < inputSnapshotNode.InputList.Count; j++)
{
Connection inputConnection = inputSnapshotNode.InputList[j];
if (!originalNodeUIDList.Contains(inputConnection.OtherNode))
{
Connection correctedInputConnection = new Connection();
correctedInputConnection.LocalName = inputConnection.LocalName;
correctedInputConnection.LocalIndex = inputConnection.LocalIndex;
correctedInputConnection.IsImplicit = inputConnection.IsImplicit;
correctedInputConnection.OtherIndex = inputConnection.OtherIndex;
if (newGC.codeBlockUIDMap.ContainsKey(inputConnection.OtherNode))
{
correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex];
}
else
{
correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex];
}
inputSnapshotNode.InputList.Remove(inputConnection);
inputSnapshotNode.InputList.Insert(j, correctedInputConnection);
}
}
for (int j = 0; j < inputSnapshotNode.OutputList.Count; j++)
{
Connection outputConnection = inputSnapshotNode.OutputList[j];
if (!originalNodeUIDList.Contains(outputConnection.OtherNode)) // if the other node is split
{
Connection correctedInputConnection = new Connection();
correctedInputConnection.LocalName = outputConnection.LocalName;
correctedInputConnection.LocalIndex = outputConnection.LocalIndex;
correctedInputConnection.IsImplicit = outputConnection.IsImplicit;
correctedInputConnection.OtherIndex = outputConnection.OtherIndex;
if (newGC.codeBlockUIDMap.ContainsKey(outputConnection.OtherNode))
{
correctedInputConnection.OtherNode = newGC.GetUidOfRHSIdentifierInCodeBlock(
outputConnection.OtherNode, outputConnection.OtherIndex, outputConnection.LocalName);
//correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex];
}
else
{
correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex];
}
inputSnapshotNode.OutputList.Remove(outputConnection);
inputSnapshotNode.OutputList.Insert(j, correctedInputConnection);
}
}
}
GB.nodesToAdd = inputs;
GB.MakeConnectionsForAddedNodes_NodeToCode(GB.nodesToAdd);
newGC.PrintGraph();
#endregion
//GB.BuildGraphForCodeBlock();
List<uint> nodesToBeAdded = new List<uint>();
List<Node> nodesToBeReplaced = new List<Node>();
//adding children node from the originalGC to the newGC needed for the newGC to generate code
foreach (Node n in completeList)
{
foreach (Node child in n.GetChildren())
{
if (newGC.Graph.GetNode(child.Guid) != null)
{
if (child.Name != newGC.Graph.GetNode(child.Guid).Name)
{
nodesToBeReplaced.Add(child);
}
}
}
}
foreach (uint n in nodesToBeAdded)
{
Node n1 = completeList.FirstOrDefault(q => q.Guid == n);
//n1.children.Clear();
nodesToBeReplaced.Add(n1);
//newSyncData.RemovedNodes.Add(n);
}
List<uint> nodeToCodeUIDs = new List<uint>();
foreach (SnapshotNode ssn in inputs)
nodeToCodeUIDs.Add(ssn.Id);
newGC.nodeToCodeUIDs = nodeToCodeUIDs;
/*create output snapshot nodes*/
List<Connection> inputNodeInputConnections = new List<Connection>();
List<Connection> inputNodeOutputConnections = new List<Connection>();
foreach (SnapshotNode ssn in inputs)
{
foreach (Connection inputConnection in ssn.InputList)
{
if (!nodeToCodeUIDs.Contains(inputConnection.OtherNode))
inputNodeInputConnections.Add(inputConnection);
}
foreach (Connection outputConnection in ssn.OutputList)
{
if (!nodeToCodeUIDs.Contains(outputConnection.OtherNode))
inputNodeOutputConnections.Add(outputConnection);
}
}
newGC.ReplaceNodesFromAList(nodesToBeReplaced);
newSyncData.AddedNodes = new List<SnapshotNode>();
newSyncData.ModifiedNodes = new List<SnapshotNode>();
newSyncData.RemovedNodes = new List<uint>();
GB = new GraphBuilder(newSyncData, newGC);
//string result = GB.BuildGraphDAG();
List<SnapshotNode> nodeToCodeBlocks = GB.PrintCodeForSelectedNodes(originalGC, inputs);
/*for now, only connected nodes are supported: return all connections that are not internal connections (connections between the selected nodes)*/
//uint id = 0;
//foreach (string content in toCode)
//{
// SnapshotNode ssn = new SnapshotNode();
// ssn.Type = SnapshotNodeType.CodeBlock;
// ssn.Content = content;
// ssn.Id = id++;
// ssn.InputList = new List<Connection>();
// //stupid stub
// foreach (Connection inputConnection in inputNodeInputConnections)
// {
// Connection newInputConnection = new Connection();
// newInputConnection.OtherNode = inputConnection.OtherNode;
// newInputConnection.OtherIndex = inputConnection.OtherIndex;
// newInputConnection.IsImplicit = inputConnection.IsImplicit;
// string[] tokens = newGC.Graph.GetNode(inputConnection.OtherNode).Name.Split('=');
// newInputConnection.LocalName = tokens[0];
// ssn.InputList.Add(newInputConnection);
// }
// //ssn.InputList = inputNodeInputConnections;
// ssn.OutputList = new List<Connection>();
// foreach (Connection outputConnection in inputNodeOutputConnections)
// {
// Connection newOutputConnection = new Connection();
// newOutputConnection.OtherNode = outputConnection.OtherNode;
// newOutputConnection.OtherIndex = outputConnection.OtherIndex;
// newOutputConnection.IsImplicit = outputConnection.IsImplicit;
// //string[] tokens = originalGC.Graph.GetNode(outputConnection.OtherNode).Name.Split('=');
// newOutputConnection.LocalName = outputConnection.LocalName;
// ssn.OutputList.Add(newOutputConnection);
// }
// //ssn.OutputList = inputNodeOutputConnections;
// codeBlocks.Add(ssn);
//}
/*update the original GC*/
foreach (SnapshotNode inputNode in inputs)
{
if (originalNodeUIDList.Contains(inputNode.Id))
originalGC.RemoveNodes(inputNode.Id, false);
else
{
foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap)
{
if (kvp.Value.ContainsValue(inputNode.Id))
{
originalGC.RemoveNodes(kvp.Key, false);
}
}
}
}
foreach (Node node in newGC.Graph.nodeList)
{
node.Name = node.Name.TrimEnd(';') + ";";
}
originalGC.Graph.nodeList.Union<Node>(newGC.Graph.nodeList);
//originalGC = newGC;
/**/
return nodeToCodeBlocks;
//return codeBlocks;
}
/// <summary>
/// This is called to Parse individual assignment statements in Codeblock nodes in GraphUI
/// and return the resulting ProtoAST node
/// </summary>
/// <param name="statement"></param>
public static ProtoCore.AST.Node Parse(string statement, out ProtoCore.AST.AssociativeAST.CodeBlockNode commentNode)
{
commentNode = null;
BuildCore(true);
Validity.Assert(core != null);
Validity.Assert(statement != null);
if (string.IsNullOrEmpty(statement))
return null;
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(statement));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, core);
p.Parse();
commentNode = p.commentNode;
return p.root;
}
public static bool Parse(Guid nodeGUID, ref string code,
out List<ProtoCore.AST.Node> parsedNodes,
out IEnumerable<ProtoCore.BuildData.ErrorEntry> errors,
out IEnumerable<ProtoCore.BuildData.WarningEntry> warnings,
List<String> unboundIdentifiers,
out List<String> tempIdentifiers)
{
tempIdentifiers = new List<string>();
List<String> compiledCode = new List<String>();
parsedNodes = null;
//-----------------------------------------------------------------------------------
//--------------------------------Correct the code-----------------------------------
//-----------------------------------------------------------------------------------
// Use the compile expression to format the code by adding the required %t temp vars
// needed for non assignment statements
CompileExpression(code, out compiledCode);
string codeToParse = "";
for (int i = 0; i < compiledCode.Count; i++)
{
string tempVariableName = string.Format("temp_{0}_", i) + nodeGUID.ToString().Replace("-", "_");
tempIdentifiers.Add(tempVariableName);
string singleExpression = compiledCode[i];
singleExpression = singleExpression.Replace("%t", tempVariableName);
codeToParse += singleExpression;
}
code = codeToParse;
//Catch the errors thrown by compile expression, namely function modiferstack and class decl found
if (core.BuildStatus.ErrorCount > 0)
{
errors = core.BuildStatus.Errors;
warnings = core.BuildStatus.Warnings;
parsedNodes = null;
return false;
}
// Parse and compile the code to get the result AST nodes as well as
// any errors or warnings that were caught by the comiler
ProtoCore.BuildStatus buildStatus;
var tempUnboundIdentifiers = new Dictionary<int, List<VariableLine>>();
List<ProtoCore.AST.Node> nodeList = new List<ProtoCore.AST.Node>();
ParseCodeBlockNodeStatements(codeToParse, out tempUnboundIdentifiers, out nodeList, out buildStatus);
errors = buildStatus.Errors;
warnings = buildStatus.Warnings;
//Get the unboundIdentifiers from the warnings
foreach (KeyValuePair<int, List<VariableLine>> kvp in tempUnboundIdentifiers)
{
foreach (VariableLine vl in kvp.Value)
{
if (!unboundIdentifiers.Contains(vl.variable))
{
unboundIdentifiers.Add(vl.variable);
}
}
}
// Assign the 'out' variables
// Use the parse function to get the parsed nodes to return to the
// user
if (nodeList != null)
{
parsedNodes = new List<ProtoCore.AST.Node>();
ProtoCore.AST.AssociativeAST.CodeBlockNode cNode;
parsedNodes = ParserUtils.GetAstNodes(Parse(codeToParse, out cNode));
}
else
{
parsedNodes = null;
}
return true;
}
public static List<ProtoCore.AST.Node> ParseCodeBlock(string code)
{
Validity.Assert(code != null);
if (string.IsNullOrEmpty(code))
return null;
// TODO: Change the logic to ignore Import statements in this case using parser - pratapa
// Check if this will work with modifier blocks as well
/*string[] stmts = code.Split(';');
string source = "";
for (int i=0; i < stmts.Length; ++i)
{
if (!stmts[i].Contains("import"))
source += stmts[i] + ";";
}*/
ProtoCore.Options options = new ProtoCore.Options();
ProtoCore.Core core = new ProtoCore.Core(options);
core.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(core));
core.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(core));
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(code));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, core);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
Validity.Assert(cbn != null);
return p.GetParsedASTList(cbn);
}
private static List<Connection> ProcessConnectionLists(string[] f)
{
List<Connection> lc = new List<Connection>();
for (int i = 0; i < f.Length - 1; i++)
{
Connection con = new Connection();
string[] c = f[i].Split(ConnectionDataMemberMarker);
con.OtherNode = uint.Parse(c[0]);
con.LocalIndex = Int32.Parse(c[1]);
con.OtherIndex = Int32.Parse(c[2]);
con.LocalName = c[3];
lc.Add(con);
}
return lc;
}
public void ConnectTo(uint connectToUid, int localIndex, int otherIndex, bool isConnectingFromInputSlot, bool isImplicit, string name = "")
{
Connection connection = new Connection();
connection.LocalIndex = localIndex;
connection.LocalName = name;
connection.OtherIndex = otherIndex;
connection.OtherNode = connectToUid;
connection.IsImplicit = isImplicit;
if (isConnectingFromInputSlot)
{
InputList.Add(connection);
}
else
{
OutputList.Add(connection);
}
}
public void TestDeltaExecution03()
{
//===========================================================================
// Creates:
// driver node a = 10
// driver node b= 20
// and using '+' operator node and assign it to idetifier
//===========================================================================
ILiveRunner liveRunner = new ProtoScript.Runners.Obsolete.LiveRunner();
//===========================================================================
// Build the driver node a=10
//===========================================================================
GraphToDSCompiler.SynchronizeData data = new GraphToDSCompiler.SynchronizeData();
uint uidDriver1 = 1;
uint uidDriver2 = 2;
uint uidOp1 = 3;
uint uidIdent1 = 4;
Connection k1 = new Connection();
k1.LocalIndex = 0;// output slot
k1.OtherIndex = 0;// input slot
k1.OtherNode = uidOp1;
k1.LocalName = "a";
Connection k2 = new Connection();
k2.LocalIndex = 0;
k2.OtherIndex = 1;
k2.OtherNode = uidOp1;
k2.LocalName = "b";
Connection k4 = new Connection();
k4.LocalIndex = 0;
k4.OtherIndex = 0;
k4.OtherNode = uidDriver1;
Connection k5 = new Connection();
k5.LocalIndex = 1;
k5.OtherIndex = 0;
k5.OtherNode = uidDriver2;
Connection k6 = new Connection();
k6.LocalIndex = 0;
k6.OtherIndex = 0;
k6.OtherNode = uidIdent1;
Connection k7 = new Connection();
k7.LocalIndex = 0;
k7.OtherIndex = 0;
k7.OtherNode = uidOp1;
SnapshotNode n1 = new SnapshotNode(uidDriver1, SnapshotNodeType.CodeBlock, "a=10;");
n1.OutputList.Add(k1);
SnapshotNode n2 = new SnapshotNode(uidDriver2, SnapshotNodeType.CodeBlock, "b=20;");
n2.OutputList.Add(k2);
SnapshotNode n3 = new SnapshotNode(uidOp1, SnapshotNodeType.Function, ";+;double,double;temp");
n3.InputList.Add(k4);
n3.InputList.Add(k5);
n3.OutputList.Add(k6);
SnapshotNode n4 = new SnapshotNode(uidIdent1, SnapshotNodeType.Identifier, "A");
n4.InputList.Add(k7);
data.AddedNodes.Add(n1);
data.AddedNodes.Add(n2);
data.AddedNodes.Add(n3);
data.AddedNodes.Add(n4);
//===========================================================================
// Compile the current graph
//===========================================================================
liveRunner.UpdateGraph(data);
//===========================================================================
// Verify the value of Identifier
//===========================================================================
ProtoCore.Mirror.RuntimeMirror mirror = liveRunner.QueryNodeValue(uidIdent1);
Assert.IsTrue(mirror.GetData().GetStackValue().opdata == 30);
}
public void TestDeltaExecution01()
{
//===========================================================================
// Creates:
// a = 10
//
// Adds:
// b = 20
//===========================================================================
ILiveRunner liveRunner = new ProtoScript.Runners.Obsolete.LiveRunner();
//===========================================================================
// Build the first snapshot nodes a = 10
//===========================================================================
GraphToDSCompiler.SynchronizeData data = new GraphToDSCompiler.SynchronizeData();
uint uidIdent = 1;
uint uidLiteral = 2;
Connection k1 = new Connection();
k1.LocalIndex = 0;
k1.OtherIndex = 0;
k1.OtherNode = uidLiteral;
Connection k2 = new Connection();
k2.LocalIndex = 0;
k2.OtherIndex = 0;
k2.OtherNode = uidIdent;
SnapshotNode n1 = new SnapshotNode(uidIdent, SnapshotNodeType.Identifier, "a");
n1.InputList.Add(k1);
SnapshotNode n2 = new SnapshotNode(uidLiteral, SnapshotNodeType.Literal, "10");
n2.OutputList.Add(k2);
data.AddedNodes.Add(n1);
data.AddedNodes.Add(n2);
//===========================================================================
// Compile the current graph
//===========================================================================
liveRunner.UpdateGraph(data);
//===========================================================================
// Build the first snapshot nodes b = 10
//===========================================================================
uint uidIdent2 = 10;
uint uidLiteral2 = 20;
data = new GraphToDSCompiler.SynchronizeData();
k1 = new Connection();
k1.LocalIndex = 0;
k1.OtherIndex = 0;
k1.OtherNode = uidLiteral2;
k2 = new Connection();
k2.LocalIndex = 0;
k2.OtherIndex = 0;
k2.OtherNode = uidIdent2;
n1 = new SnapshotNode(uidIdent2, SnapshotNodeType.Identifier, "b");
n1.InputList.Add(k1);
n2 = new SnapshotNode(uidLiteral2, SnapshotNodeType.Literal, "20");
n2.OutputList.Add(k2);
data.AddedNodes.Add(n1);
data.AddedNodes.Add(n2);
//===========================================================================
// Compile the current graph and added graph
//===========================================================================
liveRunner.UpdateGraph(data);
//===========================================================================
// Verify the value of 'a'
//===========================================================================
ProtoCore.Mirror.RuntimeMirror mirror = liveRunner.QueryNodeValue(uidIdent);
Assert.IsTrue(mirror.GetData().GetStackValue().opdata == 10);
//===========================================================================
// Verify the value of 'b'
//===========================================================================
mirror = liveRunner.QueryNodeValue(uidIdent2);
Assert.IsTrue(mirror.GetData().GetStackValue().opdata == 20);
}
public static List<SnapshotNode> NodeToCodeBlocks(List<SnapshotNode> inputs, GraphToDSCompiler.GraphCompiler originalGC)
{
List<SnapshotNode> codeBlocks = new List<SnapshotNode>();
GraphToDSCompiler.GraphCompiler newGC = GraphCompiler.CreateInstance();
newGC.SetCore(core);
GraphToDSCompiler.SynchronizeData newSyncData = new SynchronizeData();
newSyncData.AddedNodes = inputs;
newSyncData.ModifiedNodes = new List<SnapshotNode>();
newSyncData.RemovedNodes = new List<uint>();
GraphToDSCompiler.GraphBuilder GB = new GraphBuilder(newSyncData, newGC);
#region fix connection for multi-line CBN
/*for multi-line code blocks*/
List<Node> completeList = originalGC.Graph.nodeList;
List<uint> originalNodeUIDList = new List<uint>();
foreach (Node oriGcNode in completeList)
{
originalNodeUIDList.Add(oriGcNode.Guid);
}
GB.AddNodesToAST();
//List<SnapshotNode> inputsCopy = new List<SnapshotNode>(inputs);
for (int i = 0; i < inputs.Count; i++)
{
SnapshotNode inputSnapshotNode = inputs[i];
for (int j = 0; j < inputSnapshotNode.InputList.Count; j++)
{
Connection inputConnection = inputSnapshotNode.InputList[j];
if (!originalNodeUIDList.Contains(inputConnection.OtherNode))
{
Connection correctedInputConnection = new Connection();
correctedInputConnection.LocalName = inputConnection.LocalName;
correctedInputConnection.LocalIndex = inputConnection.LocalIndex;
correctedInputConnection.IsImplicit = inputConnection.IsImplicit;
correctedInputConnection.OtherIndex = inputConnection.OtherIndex;
if (newGC.codeBlockUIDMap.ContainsKey(inputConnection.OtherNode))
{
correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex];
}
else
{
correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex];
}
inputSnapshotNode.InputList.Remove(inputConnection);
inputSnapshotNode.InputList.Insert(j, correctedInputConnection);
}
}
for (int j = 0; j < inputSnapshotNode.OutputList.Count; j++)
{
Connection outputConnection = inputSnapshotNode.OutputList[j];
if (!originalNodeUIDList.Contains(outputConnection.OtherNode)) // if the other node is split
{
Connection correctedInputConnection = new Connection();
correctedInputConnection.LocalName = outputConnection.LocalName;
correctedInputConnection.LocalIndex = outputConnection.LocalIndex;
correctedInputConnection.IsImplicit = outputConnection.IsImplicit;
correctedInputConnection.OtherIndex = outputConnection.OtherIndex;
if (newGC.codeBlockUIDMap.ContainsKey(outputConnection.OtherNode))
{
correctedInputConnection.OtherNode = newGC.GetUidOfRHSIdentifierInCodeBlock(
outputConnection.OtherNode, outputConnection.OtherIndex, outputConnection.LocalName);
//correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex];
}
else
{
correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex];
}
inputSnapshotNode.OutputList.Remove(outputConnection);
inputSnapshotNode.OutputList.Insert(j, correctedInputConnection);
}
}
}
GB.nodesToAdd = inputs;
GB.MakeConnectionsForAddedNodes_NodeToCode(GB.nodesToAdd);
newGC.PrintGraph();
#endregion
//GB.BuildGraphForCodeBlock();
List<uint> nodesToBeAdded = new List<uint>();
List<Node> nodesToBeReplaced = new List<Node>();
//adding children node from the originalGC to the newGC needed for the newGC to generate code
foreach (Node n in completeList)
{
foreach (Node child in n.GetChildren())
{
if (newGC.Graph.GetNode(child.Guid) != null)
{
if (child.Name != newGC.Graph.GetNode(child.Guid).Name)
{
nodesToBeReplaced.Add(child);
}
}
}
}
foreach (uint n in nodesToBeAdded)
{
Node n1 = completeList.FirstOrDefault(q => q.Guid == n);
//n1.children.Clear();
nodesToBeReplaced.Add(n1);
//newSyncData.RemovedNodes.Add(n);
}
List<uint> nodeToCodeUIDs = new List<uint>();
foreach (SnapshotNode ssn in inputs)
nodeToCodeUIDs.Add(ssn.Id);
newGC.nodeToCodeUIDs = nodeToCodeUIDs;
/*create output snapshot nodes*/
List<Connection> inputNodeInputConnections = new List<Connection>();
List<Connection> inputNodeOutputConnections = new List<Connection>();
foreach (SnapshotNode ssn in inputs)
{
foreach (Connection inputConnection in ssn.InputList)
{
if (!nodeToCodeUIDs.Contains(inputConnection.OtherNode))
inputNodeInputConnections.Add(inputConnection);
}
foreach (Connection outputConnection in ssn.OutputList)
{
if (!nodeToCodeUIDs.Contains(outputConnection.OtherNode))
inputNodeOutputConnections.Add(outputConnection);
}
}
newGC.ReplaceNodesFromAList(nodesToBeReplaced);
newSyncData.AddedNodes = new List<SnapshotNode>();
newSyncData.ModifiedNodes = new List<SnapshotNode>();
newSyncData.RemovedNodes = new List<uint>();
GB = new GraphBuilder(newSyncData, newGC);
//string result = GB.BuildGraphDAG();
List<SnapshotNode> nodeToCodeBlocks = GB.PrintCodeForSelectedNodes(originalGC, inputs);
/*for now, only connected nodes are supported: return all connections that are not internal connections (connections between the selected nodes)*/
//uint id = 0;
//foreach (string content in toCode)
//{
// SnapshotNode ssn = new SnapshotNode();
// ssn.Type = SnapshotNodeType.CodeBlock;
// ssn.Content = content;
// ssn.Id = id++;
// ssn.InputList = new List<Connection>();
// //stupid stub
// foreach (Connection inputConnection in inputNodeInputConnections)
// {
// Connection newInputConnection = new Connection();
// newInputConnection.OtherNode = inputConnection.OtherNode;
// newInputConnection.OtherIndex = inputConnection.OtherIndex;
// newInputConnection.IsImplicit = inputConnection.IsImplicit;
// string[] tokens = newGC.Graph.GetNode(inputConnection.OtherNode).Name.Split('=');
// newInputConnection.LocalName = tokens[0];
// ssn.InputList.Add(newInputConnection);
// }
// //ssn.InputList = inputNodeInputConnections;
// ssn.OutputList = new List<Connection>();
// foreach (Connection outputConnection in inputNodeOutputConnections)
// {
// Connection newOutputConnection = new Connection();
// newOutputConnection.OtherNode = outputConnection.OtherNode;
// newOutputConnection.OtherIndex = outputConnection.OtherIndex;
// newOutputConnection.IsImplicit = outputConnection.IsImplicit;
// //string[] tokens = originalGC.Graph.GetNode(outputConnection.OtherNode).Name.Split('=');
// newOutputConnection.LocalName = outputConnection.LocalName;
// ssn.OutputList.Add(newOutputConnection);
// }
// //ssn.OutputList = inputNodeOutputConnections;
// codeBlocks.Add(ssn);
//}
/*update the original GC*/
foreach (SnapshotNode inputNode in inputs)
{
if (originalNodeUIDList.Contains(inputNode.Id))
originalGC.RemoveNodes(inputNode.Id, false);
else
{
foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap)
{
if (kvp.Value.ContainsValue(inputNode.Id))
{
originalGC.RemoveNodes(kvp.Key, false);
}
}
}
}
foreach (Node node in newGC.Graph.nodeList)
{
node.Name = node.Name.TrimEnd(';') + ";";
}
originalGC.Graph.nodeList.Union<Node>(newGC.Graph.nodeList);
//originalGC = newGC;
/**/
return nodeToCodeBlocks;
//return codeBlocks;
}
public static List<SnapshotNode> NodeToCodeBlocks(List<SnapshotNode> inputs, GraphToDSCompiler.GraphCompiler originalGC)
{
List<SnapshotNode> codeBlocks = new List<SnapshotNode>();
GraphToDSCompiler.GraphCompiler newGC = GraphCompiler.CreateInstance();
newGC.SetCore(compileState);
GraphToDSCompiler.SynchronizeData newSyncData = new SynchronizeData();
newSyncData.AddedNodes = inputs;
newSyncData.ModifiedNodes = new List<SnapshotNode>();
newSyncData.RemovedNodes = new List<uint>();
GraphToDSCompiler.GraphBuilder GB = new GraphBuilder(newSyncData, newGC);
#region fix connection for multi-line CBN
/*for multi-line code blocks*/
List<Node> completeList = originalGC.Graph.nodeList;
List<uint> originalNodeUIDList = new List<uint>();
foreach (Node oriGcNode in completeList)
{
originalNodeUIDList.Add(oriGcNode.Guid);
}
GB.AddNodesToAST();
//List<SnapshotNode> inputsCopy = new List<SnapshotNode>(inputs);
for (int i = 0; i < inputs.Count; i++)
{
SnapshotNode inputSnapshotNode = inputs[i];
for (int j = 0; j < inputSnapshotNode.InputList.Count; j++)
{
Connection inputConnection = inputSnapshotNode.InputList[j];
if (!originalNodeUIDList.Contains(inputConnection.OtherNode))
{
Connection correctedInputConnection = new Connection();
correctedInputConnection.LocalName = inputConnection.LocalName;
correctedInputConnection.LocalIndex = inputConnection.LocalIndex;
correctedInputConnection.IsImplicit = inputConnection.IsImplicit;
correctedInputConnection.OtherIndex = inputConnection.OtherIndex;
if (newGC.codeBlockUIDMap.ContainsKey(inputConnection.OtherNode))
{
correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex];
}
else
{
correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[inputConnection.OtherNode][inputConnection.OtherIndex];
}
inputSnapshotNode.InputList.Remove(inputConnection);
inputSnapshotNode.InputList.Insert(j, correctedInputConnection);
}
}
for (int j = 0; j < inputSnapshotNode.OutputList.Count; j++)
{
Connection outputConnection = inputSnapshotNode.OutputList[j];
if (!originalNodeUIDList.Contains(outputConnection.OtherNode)) // if the other node is split
{
Connection correctedInputConnection = new Connection();
correctedInputConnection.LocalName = outputConnection.LocalName;
correctedInputConnection.LocalIndex = outputConnection.LocalIndex;
correctedInputConnection.IsImplicit = outputConnection.IsImplicit;
correctedInputConnection.OtherIndex = outputConnection.OtherIndex;
if (newGC.codeBlockUIDMap.ContainsKey(outputConnection.OtherNode))
{
correctedInputConnection.OtherNode = newGC.GetUidOfRHSIdentifierInCodeBlock(
outputConnection.OtherNode, outputConnection.OtherIndex, outputConnection.LocalName);
//correctedInputConnection.OtherNode = newGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex];
}
else
{
correctedInputConnection.OtherNode = originalGC.codeBlockUIDMap[outputConnection.OtherNode][outputConnection.OtherIndex];
}
inputSnapshotNode.OutputList.Remove(outputConnection);
inputSnapshotNode.OutputList.Insert(j, correctedInputConnection);
}
}
}
GB.nodesToAdd = inputs;
GB.MakeConnectionsForAddedNodes_NodeToCode(GB.nodesToAdd);
newGC.PrintGraph();
#endregion
//GB.BuildGraphForCodeBlock();
List<uint> nodesToBeAdded = new List<uint>();
List<Node> nodesToBeReplaced = new List<Node>();
//adding children node from the originalGC to the newGC needed for the newGC to generate code
foreach (Node n in completeList)
{
foreach (Node child in n.GetChildren())
{
if (newGC.Graph.GetNode(child.Guid) != null)
{
if (child.Name != newGC.Graph.GetNode(child.Guid).Name)
{
nodesToBeReplaced.Add(child);
}
}
}
}
foreach (uint n in nodesToBeAdded)
{
Node n1 = completeList.FirstOrDefault(q => q.Guid == n);
//n1.children.Clear();
nodesToBeReplaced.Add(n1);
//newSyncData.RemovedNodes.Add(n);
}
List<uint> nodeToCodeUIDs = new List<uint>();
foreach (SnapshotNode ssn in inputs)
nodeToCodeUIDs.Add(ssn.Id);
newGC.nodeToCodeUIDs = nodeToCodeUIDs;
/*create output snapshot nodes*/
List<Connection> inputNodeInputConnections = new List<Connection>();
List<Connection> inputNodeOutputConnections = new List<Connection>();
foreach (SnapshotNode ssn in inputs)
{
foreach (Connection inputConnection in ssn.InputList)
{
if (!nodeToCodeUIDs.Contains(inputConnection.OtherNode))
inputNodeInputConnections.Add(inputConnection);
}
foreach (Connection outputConnection in ssn.OutputList)
{
if (!nodeToCodeUIDs.Contains(outputConnection.OtherNode))
inputNodeOutputConnections.Add(outputConnection);
}
}
newGC.ReplaceNodesFromAList(nodesToBeReplaced);
newSyncData.AddedNodes = new List<SnapshotNode>();
newSyncData.ModifiedNodes = new List<SnapshotNode>();
newSyncData.RemovedNodes = new List<uint>();
GB = new GraphBuilder(newSyncData, newGC);
//string result = GB.BuildGraphDAG();
List<SnapshotNode> nodeToCodeBlocks = GB.PrintCodeForSelectedNodes(originalGC, inputs);
/*for now, only connected nodes are supported: return all connections that are not internal connections (connections between the selected nodes)*/
//uint id = 0;
//foreach (string content in toCode)
//{
// SnapshotNode ssn = new SnapshotNode();
// ssn.Type = SnapshotNodeType.CodeBlock;
// ssn.Content = content;
// ssn.Id = id++;
// ssn.InputList = new List<Connection>();
// //stupid stub
// foreach (Connection inputConnection in inputNodeInputConnections)
// {
// Connection newInputConnection = new Connection();
// newInputConnection.OtherNode = inputConnection.OtherNode;
// newInputConnection.OtherIndex = inputConnection.OtherIndex;
// newInputConnection.IsImplicit = inputConnection.IsImplicit;
// string[] tokens = newGC.Graph.GetNode(inputConnection.OtherNode).Name.Split('=');
// newInputConnection.LocalName = tokens[0];
// ssn.InputList.Add(newInputConnection);
// }
// //ssn.InputList = inputNodeInputConnections;
// ssn.OutputList = new List<Connection>();
// foreach (Connection outputConnection in inputNodeOutputConnections)
// {
// Connection newOutputConnection = new Connection();
// newOutputConnection.OtherNode = outputConnection.OtherNode;
// newOutputConnection.OtherIndex = outputConnection.OtherIndex;
// newOutputConnection.IsImplicit = outputConnection.IsImplicit;
// //string[] tokens = originalGC.Graph.GetNode(outputConnection.OtherNode).Name.Split('=');
// newOutputConnection.LocalName = outputConnection.LocalName;
// ssn.OutputList.Add(newOutputConnection);
// }
// //ssn.OutputList = inputNodeOutputConnections;
// codeBlocks.Add(ssn);
//}
/*update the original GC*/
foreach (SnapshotNode inputNode in inputs)
{
if (originalNodeUIDList.Contains(inputNode.Id))
originalGC.RemoveNodes(inputNode.Id, false);
else
{
foreach (KeyValuePair<uint, Dictionary<int, uint>> kvp in originalGC.codeBlockUIDMap)
{
if (kvp.Value.ContainsValue(inputNode.Id))
{
originalGC.RemoveNodes(kvp.Key, false);
}
}
}
}
foreach (Node node in newGC.Graph.nodeList)
{
node.Name = node.Name.TrimEnd(';') + ";";
}
originalGC.Graph.nodeList.Union<Node>(newGC.Graph.nodeList);
//originalGC = newGC;
/**/
return nodeToCodeBlocks;
//return codeBlocks;
}
/// <summary>
/// This is called to Parse individual assignment statements in Codeblock nodes in GraphUI
/// and return the resulting ProtoAST node
/// </summary>
/// <param name="statement"></param>
public static ProtoCore.AST.Node Parse(string statement, out ProtoCore.AST.AssociativeAST.CodeBlockNode commentNode)
{
commentNode = null;
BuildCompileState(true);
Validity.Assert(compileState != null);
Validity.Assert(statement != null);
if (string.IsNullOrEmpty(statement))
return null;
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(statement));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState);
p.Parse();
commentNode = p.commentNode;
return p.root;
}
public static List<ProtoCore.AST.Node> ParseCodeBlock(string code)
{
Validity.Assert(code != null);
if (string.IsNullOrEmpty(code))
return null;
// TODO: Change the logic to ignore Import statements in this case using parser - pratapa
// Check if this will work with modifier blocks as well
/*string[] stmts = code.Split(';');
string source = "";
for (int i=0; i < stmts.Length; ++i)
{
if (!stmts[i].Contains("import"))
source += stmts[i] + ";";
}*/
ProtoLanguage.CompileOptions options = new ProtoLanguage.CompileOptions();
ProtoLanguage.CompileStateTracker compileState = new ProtoLanguage.CompileStateTracker(options);
//compileState.Executives.Add(ProtoCore.Language.kAssociative, new ProtoAssociative.Executive(compileState));
//compileState.Executives.Add(ProtoCore.Language.kImperative, new ProtoImperative.Executive(compileState));
System.IO.MemoryStream memstream = new System.IO.MemoryStream(System.Text.Encoding.UTF8.GetBytes(code));
ProtoCore.DesignScriptParser.Scanner s = new ProtoCore.DesignScriptParser.Scanner(memstream);
ProtoCore.DesignScriptParser.Parser p = new ProtoCore.DesignScriptParser.Parser(s, compileState);
p.Parse();
ProtoCore.AST.AssociativeAST.CodeBlockNode cbn = p.root as ProtoCore.AST.AssociativeAST.CodeBlockNode;
Validity.Assert(cbn != null);
return p.GetParsedASTList(cbn);
}
/**/
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 EstablishExplicitOutputConnection(VisualNode startNode, Connection connection, List<IVisualNode> modifiedNodes)
{
VisualNode endNode = nodeCollection[connection.OtherNode] as VisualNode;
List<uint> startSlotIds = (startNode as VisualNode).GetSlotIdsByName(SlotType.Output, connection.LocalName);
uint startSlotId = startSlotIds.Last();
uint endSlotId = endNode.GetInputSlot(connection.OtherIndex);
Slot outputSlot = GetSlot(startSlotId) as Slot;
Slot inputSlot = GetSlot(endSlotId) as Slot;
edgeController.CreateLinkingEdge(outputSlot, inputSlot);
(startNode as VisualNode).HandleNewConnection(startSlotId);
endNode.HandleNewConnection(endSlotId);
modifiedNodes.Add(startNode);
modifiedNodes.Add(endNode);
}
private void EstablishExplicitInputConnection(VisualNode endNode, Connection connection, List<IVisualNode> modifiedNodes)
{
VisualNode startNode = (VisualNode)nodeCollection[connection.OtherNode];
uint startSlotId = startNode.GetOutputSlot(connection.OtherIndex);
uint endSlotId = endNode.GetInputSlot(connection.LocalIndex);
Slot outputSlot = GetSlot(startSlotId) as Slot;
Slot inputSlot = GetSlot(endSlotId) as Slot;
edgeController.CreateLinkingEdge(outputSlot, inputSlot);
startNode.HandleNewConnection(startSlotId);
endNode.HandleNewConnection(endSlotId);
modifiedNodes.Add(startNode);
modifiedNodes.Add(endNode);
}
private Connection CreateConnectionStructure(uint otherNodeId, int otherIndex, int localIndex, string localName, bool isImplicit)
{
Connection connection = new Connection();
connection.IsImplicit = isImplicit;
connection.LocalIndex = localIndex;
connection.LocalName = localName;
connection.OtherIndex = otherIndex;
connection.OtherNode = otherNodeId;
return connection;
}
