public void BuildGraphFromNodes(List<SnapshotNode> snapshotNodeList)
{
// Instantiate SynchronizeData and GraphCompiler
SynchronizeData syncData = new SynchronizeData();
syncData.AddedNodes = snapshotNodeList;
GraphCompiler gc = GraphToDSCompiler.GraphCompiler.CreateInstance();
GraphBuilder gb = new GraphBuilder(syncData, gc);
gb.AddNodesToAST();
gb.MakeConnectionsForAddedNodes();
graph = gb.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);
}
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);
}
private void SynchronizeInternal(GraphToDSCompiler.SynchronizeData syncData, out string code)
{
Validity.Assert(null != runner);
Validity.Assert(null != graphCompiler);
if (syncData.AddedNodes.Count == 0 &&
syncData.ModifiedNodes.Count == 0 &&
syncData.RemovedNodes.Count == 0)
{
code = "";
ResetVMForDeltaExecution();
return;
}
else
{
System.Diagnostics.Debug.WriteLine("Begin SyncInternal: {0}", syncData);
GraphToDSCompiler.GraphBuilder g = new GraphBuilder(syncData, graphCompiler);
code = g.BuildGraphDAG();
System.Diagnostics.Debug.WriteLine("SyncInternal => " + code);
//List<string> deletedVars = new List<string>();
ResetVMForDeltaExecution();
//Synchronize the core configuration before compilation and execution.
if (syncCoreConfigurations)
{
SyncCoreConfigurations(runnerCore, executionOptions);
syncCoreConfigurations = false;
}
bool succeeded = CompileAndExecute(code);
if (succeeded)
{
graphCompiler.ResetPropertiesForNextExecution();
}
}
}
//
// TODO Jun: Re-evaluate the topsort implementation
//
static void DFSVisit(Node node, Dictionary <Node, int> nodeStateMap, List <Node> list, AST statementList)
{
nodeStateMap.Add(node, VISITING);
List <Node> nodes = node.GetChildren();
Dictionary <int, Node> nodeDic = node.GetChildrenWithIndices();
IEnumerable iter = nodes;
int j = 0;
foreach (Node nodeI in iter)
{
if (node is IdentNode && nodeI is LiteralNode)
{
BuildIdentToLiteralStatement(node, nodeI, statementList);
}
else if (node is IdentNode && nodeI is IdentNode)
{
BuildIdentToIdentStatement(node, nodeI, statementList);
}
else if (node is IdentNode && nodeI is Block)
{
Block blocknode = (Block)nodeI;
if (GraphBuilder.AnalyzeString(blocknode.Name) == SnapshotNodeType.Literal)
{
LiteralNode literal = new LiteralNode(blocknode.content, nodeI.Guid);
BuildIdentToLiteralStatement(node, literal, statementList);
}
else
{
j = BuildIdentToCodeBlockIdentStatement(node, nodeI, nodes, statementList, j);
}
}
else if (node is Operator && nodeI is Block)
{
j = BuildOperatorToBlockStatement(node, nodeI, nodeDic, statementList, j);
}
else if (node is Func && nodeI is Block)
{
j = BuildFuncToBlockStatement(node, nodeI, nodeDic, statementList, j);
}
else if (node is Func && nodeI is IdentNode)
{
j = BuildFuncToIdentStatement(node, nodeI, nodeDic, statementList, j);
}
else if (node is IdentNode && nodeI is Operator)
{
BuildIdentToOperatorStatement(node, statementList, nodeI);
}
else if (node is Operator && nodeI is Operator)
{
j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
}
else if (node is IdentNode && nodeI is Func)
{
BuildIdentToFuncStatement(node, nodeI, statementList);
}
else if (node is Func && nodeI is Func)
{
j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
}
else if (node is Operator && nodeI is Func)
{
j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
}
else if (node is Func && nodeI is Operator)
{
j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
}
else if ((node is Operator && nodeI is ArrayNode) || (node is Operator && nodeI is LiteralNode))
{
j = BuildOperatorToOperatorStatement(node, nodeI, nodeDic, statementList, j);
}
else if ((node is Func && nodeI is ArrayNode) || (node is Func && nodeI is LiteralNode))
{
j = BuildFuncToFuncStatement(node, nodeI, nodeDic, statementList, j);
}
else if ((node is Block && nodeI is Block))
{
BuildBlockToBlockStatement(node, nodeI, statementList);
}
else if ((node is Block && nodeI is Func))
{
BuildBlockToFuncStatement(node, nodeI, statementList);
}
else if ((node is Block && nodeI is Operator))
{
BuildBlockToFuncStatement(node, nodeI, statementList);
}
else if ((node is Block && nodeI is IdentNode))
{
BuildBlockToIdentStatement(node, nodeI, statementList);
}
/*Block to Operator*/
else if (node is Block && nodeI is Operator)
{
//BuildBlockToOperatorStatement(node, nodeI, statementList);
}
//else if ((node is Block && nodeI is Func))
//{
// BuildBlockToBlockStatement(node, nodeI, statementList);
//}
else
{
if (node is Operator)
{
if (nodes.IndexOf(nodeI, j) == 0)
{
Assignment a = (Assignment)statementList.GetNode(node.Guid);
((BinExprNode)a.right).left = nodeI;
++j;
}
else
{
Assignment a = (Assignment)statementList.GetNode(node.Guid);
((BinExprNode)a.right).right = nodeI;
}
}
else if (node is Func)
{
Assignment a = (Assignment)statementList.GetNode(node.Guid);
FunctionCall f = ((FunctionCall)a.right);
f.parameters[nodes.IndexOf(nodeI, j)] = nodeI;
j = 0;
}
}
if (IsNotVisited(nodeI, nodeStateMap))
{
DFSVisit(nodeI, nodeStateMap, list, statementList);
}
}
nodeStateMap[node] = VISITED;
list.Add(node);
}