private StructureNode CreateNode(string name, int id)
{
Block b = new Block(null, name);
StructureNode node = new StructureNode(b, id);
return(node);
}
private void mHex_SelectionLengthChanged(object pSender, EventArgs pArgs)
{
if (mHex.SelectionLength == 0)
{
MainForm.PropertyForm.Properties.SelectedObject = null;
}
else
{
StructureNode match = null;
foreach (TreeNode node in MainForm.StructureForm.Tree.Nodes)
{
var realNode = (StructureNode)node;
long start = SelectionStart + hexBoxBytes.Offset;
if (start == realNode.Data.Offset && SelectionLength == realNode.Data.Count)
{
match = realNode;
break;
}
}
MainForm.StructureForm.Tree.SelectedNode = match;
MainForm.PropertyForm.Properties.SelectedObject =
new StructureSegment(GetHexBoxSelectedBytes(), MainForm.Locale);
}
}
public Loop(StructureNode header, StructureNode latch, HashSet<StructureNode> loopNodes, StructureNode follow)
{
this.Header = header;
this.Latch = latch;
this.Nodes = loopNodes;
this.Follow = follow;
}
public void Initialize(bool initData)
{
if (initData)
{
var tableCollectionNode = new StructureNode {
Text = "Tables", Tag = Current.Project.DataTableCollection
};
_rootNode.Nodes.Add(tableCollectionNode);
AddAllTableNodes(tableCollectionNode);
tableCollectionNode.IsExpanded = true;
if (null != _doc.SelectedTable)
{
var selTableNode = FindTableNode(tableCollectionNode, _doc.SelectedTable);
if (selTableNode != null)
{
selTableNode.IsSelected = true;
}
}
}
if (_view != null)
{
_view.Initialize(_rootNode.Nodes);
}
}
private void TagLoopNode(StructureNode node)
{
node.Loop = this;
if (node.Conditional == null)
return;
if (node.Conditional.Follow != null)
return;
}
public void CreateWithCfgNode()
{
StructureNode node = CreateNode("foo", 1);
Interval i = new Interval(1, node);
// Assert.AreSame(node, i.Header);
Assert.AreEqual(1, i.Nodes.Count);
}
private void DumpNodes(StructureNode node, int depth = 0)
{
Debug.WriteLine($"{depth:D2} " + String.Join("", Enumerable.Repeat(" ", depth)) +
node.DisplayText);
foreach (var structureNode in node.Children)
{
DumpNodes(structureNode, depth + 1);
}
}
public void DeferRendering(StructureNode predecessor, StructureNode node, AbsynStatementEmitter emitter)
{
foreach (NodeEmitter ne in nodesToRender)
{
if (ne.Node == node)
return;
}
nodesToRender.Enqueue(new NodeEmitter(predecessor, node, emitter));
}
public EditingSession InitializeEditingSession(StructureNode structureNode)
{
var toolboxItem = new ToolboxManager().GetToolboxItemByCode(structureNode.WidgetTypeCode);
var toolboxItemNativeType = new CmsPageContentActivator().GetToolboxItemNativeType(toolboxItem);
var defaultForm = new ConfiguratorCmsPageContentBuilder().GenerateDefaultForm(toolboxItemNativeType, FormStyle.Edit);
var runtime = new FormsRuntime();
return(runtime.EditingSession(defaultForm, toolboxItemNativeType, structureNode.Parameters));
}
public override void GenerateCode(AbsynCodeGenerator codeGen, StructureNode node, StructureNode latchNode, AbsynStatementEmitter emitter)
{
codeGen.EmitLinearBlockStatements(node, emitter);
if (node == latchNode)
return;
var exp = codeGen.BranchCondition(node);
var ifStm = EmitIfCondition(exp, this, emitter);
var succ = FirstBranch(node);
var emitThen = new AbsynStatementEmitter(ifStm.Then);
if (node.UnstructType == UnstructuredType.JumpInOutLoop)
{
codeGen.DeferRendering(node, succ, emitThen);
codeGen.GenerateCode(SecondBranch(node), latchNode, emitter);
}
else
{
if (Follow == null)
throw new NotSupportedException("Null condfollow");
codeGen.PushFollow(Follow);
if (node.Conditional is IfThenElse)
{
codeGen.IncompleteNodes.Add(node);
}
if (codeGen.IsVisited(succ) || (node.Loop != null && succ == node.Loop.Follow))
codeGen.EmitGotoAndForceLabel(node, succ, emitThen);
else
codeGen.GenerateCode(succ, latchNode, emitThen);
if (node.Conditional is IfThenElse)
{
codeGen.IncompleteNodes.Remove(node);
succ = node.Then;
AbsynStatementEmitter emitElse = new AbsynStatementEmitter(ifStm.Else);
if (codeGen.IsVisited(succ))
codeGen.EmitGotoAndForceLabel(node, succ, emitElse);
else
codeGen.GenerateCode(succ, latchNode, emitElse);
if (HasSingleIfThenElseStatement(ifStm.Then))
{
ifStm.InvertCondition();
}
}
codeGen.PopFollow();
codeGen.GenerateCode(Follow, latchNode, emitter);
}
}
public void GenerateCode(AbsynCodeGenerator codeGen, StructureNode node, StructureNode latchNode, AbsynStatementEmitter emitter)
{
if (Follow != null)
codeGen.PushFollow(Follow);
GenerateCodeInner(codeGen, node, emitter);
if (Follow != null)
{
codeGen.PopFollow();
codeGen.GenerateCode(Follow, latchNode, emitter);
}
}
public void EndNode(bool expand)
{
if (subNodes.Count > 0)
{
StructureNode node = subNodes.Pop();
int length = packet.Position - node.Data.Offset;
node.UpdateData(packet.GetSegment(node.Data.Offset, length));
if (expand)
{
node.Expand();
}
}
}
public CmsPageContent ApplyNewStructure(StructureNode node)
{
return(new CmsPageContent
{
Id = node.Id,
Order = node.Order,
PlacementContentPlaceHolderId = node.PlacementContentPlaceHolderId,
PlacementLayoutBuilderId = node.PlacementLayoutBuilderId,
Parameters = node.Parameters,
WidgetTypeCode = node.WidgetTypeCode,
AllContent = node.ChildNodes.Select(ApplyNewStructure).ToList()
});
}
private TextBlock GetNodeLabel(StructureNode _sn)
{
TextBlock tb = new TextBlock();
tb.Text = _sn.ToSimpleString();
tb.FontSize = 10;
tb.Foreground = new SolidColorBrush(Colors.Black);
tb.HorizontalAlignment = System.Windows.HorizontalAlignment.Left;
tb.VerticalAlignment = System.Windows.VerticalAlignment.Top;
return(tb);
}
public StructureNode Tranverse(Stack <Node> nodes = null)
{
var data = new StructureNode();
data.Id = RootId;
data.Pid = RootPid;
data.Data = RootData;
data.Sort = 0;
if (nodes == null)
{
data.Children = new Queue <StructureNode>(NewQueue(ChildrenNodes));
}
return(data);
}
public void StartNode(string name)
{
var node = new StructureNode(name, packet.GetReadSegment(0));
if (subNodes.Count > 0)
{
subNodes.Peek().Nodes.Add(node);
}
else
{
tree.Nodes.Add(node);
}
subNodes.Push(node);
}
public void FindNoLoopInInterval()
{
ProcedureBuilder m = new ProcedureBuilder();
m.Return();
StructureNode node = new StructureNode(m.Procedure.ControlGraph.Blocks[1], 3);
node.Order = 0;
Interval interval = new Interval(1, node);
var nodesInInterval = interval.FindIntervalNodes(0);
SccLoopFinder finder = new SccLoopFinder(interval, nodesInInterval);
var loopNodes = finder.FindLoop();
Assert.AreEqual(0, loopNodes.Count);
}
public void CreateWithIntervalNode()
{
StructureNode node1 = CreateNode("node1", 1);
StructureNode node2 = CreateNode("node2", 2);
Interval i1 = new Interval(1, node1);
Interval i2 = new Interval(2, node2);
StructureNode node3 = CreateNode("node3", 3);
i2.AddNode(node3);
Interval i = new Interval(3, i1);
i.AddNode(i2);
Assert.AreEqual(2, i.Nodes.Count);
}
private StructureNode GetPageStructure(CmsPageContent content)
{
var sn = new StructureNode
{
Id = content.Id,
Order = content.Order,
Parameters = content.Parameters,
PlacementContentPlaceHolderId = content.PlacementContentPlaceHolderId,
PlacementLayoutBuilderId = content.PlacementLayoutBuilderId,
WidgetTypeCode = content.WidgetTypeCode,
ChildNodes = content.AllContent.Select(GetPageStructure).ToList()
};
return(sn);
}
private Conditional CreateConditional(StructureNode node, StructureNode follow)
{
if (node.BlockType == BlockTerminationType.Multiway)
{
var c = new Case(follow);
var cf = new CaseFinder(node, follow);
cf.SetCaseHead(node);
return c;
}
else if (node.Else == follow)
return new IfThen(follow);
else if (node.Then == follow)
return new IfElse(follow);
else
return new IfThenElse(follow);
}
public void FindNoLoopInInterval()
{
ProcedureBuilder m = new ProcedureBuilder();
m.Return();
StructureNode node = new StructureNode(m.Procedure.ControlGraph.Blocks[1], 3);
node.Order = 0;
Interval interval = new Interval(1, node);
var nodesInInterval = interval.FindIntervalNodes(0);
SccLoopFinder finder = new SccLoopFinder(interval, nodesInInterval);
var loopNodes = finder.FindLoop();
Assert.AreEqual(0, loopNodes.Count);
}
private static void GetNodesPerLevel(StructureNode _node, int _level_index, ref Dictionary <int, List <StructureNode> > nodes_per_level)
{
if (nodes_per_level == null)
{
nodes_per_level = new Dictionary <int, List <StructureNode> >();
}
if (_node == null)
{
return;
}
if (!(nodes_per_level.ContainsKey(_level_index)))
{
nodes_per_level.Add(_level_index, new List <StructureNode>());
}
nodes_per_level[_level_index].Add(_node);
// re-order the children nodes to put the ones w most children near the middle
List <StructureNode> ascending = _node.ChildrenNodes.OrderBy(x => x.ChildrenNodes.Count).ToList();
List <StructureNode> children_ordered = new List <StructureNode>();
for (int i = 0; i < ascending.Count; i++)
{
if (i < 2)
{
children_ordered.Add(ascending[i]);
}
else
{
children_ordered.Insert(i / 2, ascending[i]);
}
}
// recursion
foreach (StructureNode sN in children_ordered)
{
GetNodesPerLevel(sN, _level_index + 1, ref nodes_per_level);
}
}
public void EmitGotoAndForceLabel(StructureNode node, StructureNode succ, AbsynStatementEmitter emitter)
{
if (node == null)
throw new InvalidOperationException("A goto must have a starting point.");
if (node.Loop != null)
{
if (node.Loop.Follow == succ)
{
emitter.EmitBreak();
return;
}
if (node.Loop.Header == succ)
{
emitter.EmitContinue();
return;
}
}
succ.ForceLabel = true;
emitter.EmitGoto(succ);
}
private Ellipse GetNodeVis(StructureNode _sn)
{
Ellipse el = new Ellipse();
el.Width = 24;
el.Height = 24;
el.Stroke = new SolidColorBrush(Colors.Black);
if (_sn.ParentNode == null)
{
el.StrokeThickness = 2;
}
else
{
el.StrokeThickness = 1;
}
if (_sn.ChildrenNodes == null || _sn.ChildrenNodes.Count == 0)
{
el.Fill = new SolidColorBrush(Colors.White);
}
else
{
el.Fill = new SolidColorBrush(Colors.Gray);
}
el.Effect =
new System.Windows.Media.Effects.DropShadowEffect
{
Color = Colors.Black,
BlurRadius = 3,
Direction = 315,
ShadowDepth = 3,
Opacity = 0.5
};
return(el);
}
public void SetLoopStamps()
{
StructureNode n1 = NewNode("n1");
StructureNode n2 = NewNode("n2");
StructureNode n3 = NewNode("n3");
n1.AddEdgeTo(n2);
n2.AddEdgeTo(n3);
n3.AddEdgeTo(n2);
int time = 1;
List <StructureNode> postOrder = new List <StructureNode>();
n1.SetLoopStamps(ref time, postOrder);
Assert.AreEqual(0, n1.InEdges.Count);
Assert.AreEqual(2, n2.InEdges.Count);
Assert.IsTrue(n2.InEdges.Contains(n1));
Assert.IsTrue(n2.InEdges.Contains(n3));
Assert.AreEqual(1, n3.InEdges.Count);
Assert.IsTrue(n3.InEdges.Contains(n2));
Assert.AreSame(n3, postOrder[0]);
Assert.AreSame(n2, postOrder[1]);
Assert.AreSame(n1, postOrder[2]);
}
/// <summary>
/// Recursively associates the <paramref name="node"/> and its descendants with
/// the case statement defined by head. The recursion ends when the follow node
/// of the head node is encountered.
/// </summary>
/// <param name="node"></param>
public void SetCaseHead(StructureNode node)
{
Debug.Assert(node.CaseHead == null);
visited.Add(node);
// don't tag this node if it is the case header under investigation
if (node != head)
node.CaseHead = head;
// if this is a nested case header, then its member nodes will already have been
// tagged so skip straight to its follow
if (node.BlockType == BlockTerminationType.Multiway && node != head)
{
if (!visited.Contains(node.Conditional.Follow) &&
node.Conditional.Follow != follow)
{
SetCaseHead(node.Conditional.Follow);
}
}
else
{
// traverse each child of this node that:
// i) isn't on a back-edge,
// ii) hasn't already been traversed in a case tagging traversal and,
// iii) isn't the follow node.
foreach (StructureNode succ in node.OutEdges)
{
if (!node.HasBackEdgeTo(succ) &&
!visited.Contains(succ) &&
succ != follow)
{
SetCaseHead(succ);
}
}
}
}
protected override void GenerateCodeInner(AbsynCodeGenerator codeGen, StructureNode node, AbsynStatementEmitter emitter)
{
codeGen.EmitLinearBlockStatements(node, emitter);
var loopBody = new List<AbsynStatement>();
var bodyNode = (node.Else == node.Loop.Follow)
? node.Then
: node.Else;
var bodyEmitter = new AbsynStatementEmitter(loopBody);
codeGen.GenerateCode(bodyNode, node.Loop.Latch, bodyEmitter);
bodyEmitter.StripDeclarations = true;
codeGen.EmitLinearBlockStatements(node, bodyEmitter);
emitter.EmitWhile(node, codeGen.BranchCondition(node), loopBody);
}
public void GenerateCode(
StructureNode node,
StructureNode latchNode,
AbsynStatementEmitter emitter)
{
if (followStack.Contains(node) && followStack.Peek() == node)
return;
if (IsVisited(node))
return;
visited.Add(node);
if (NeedsLabel(node))
GenerateLabel(node,emitter);
if (node.IsLoopHeader())
{
node.Loop.GenerateCode(this, node, latchNode, emitter);
}
else if (node.Conditional != null)
{
node.Conditional.GenerateCode(this, node, latchNode, emitter);
}
else
{
EmitLinearBlockStatements(node, emitter);
if (EndsWithReturnInstruction(node))
{
emitter.EmitStatement(node.Instructions.Last);
return;
}
if (node.IsLatchNode())
return;
if (node.OutEdges.Count == 1)
{
StructureNode succ = node.OutEdges[0];
if (ShouldJumpFromSequentialNode(node, succ))
EmitGotoAndForceLabel(node, succ, emitter);
else
GenerateCode(succ, latchNode, emitter);
}
}
}
public void ConfigureNode(StructureNode structureNode)
{
this.node = structureNode;
OverrideSpriteColor();
}
public PreTestedLoop(StructureNode header, StructureNode latch, HashSet<StructureNode> loopNodes, StructureNode follow)
: base(header, latch, loopNodes, follow)
{
}
protected abstract void GenerateCodeInner(AbsynCodeGenerator codeGen, StructureNode node, AbsynStatementEmitter emitter);
private PreviewNode Write(StructureNode pageStructure)
{
var friendlyName = string.Empty;
if (pageStructure.WidgetTypeCode != null)
{
friendlyName = pageStructure.WidgetTypeCode;
//friendlyName = new ToolboxManager().GetToolboxItemByCode(pageStructure.WidgetTypeCode).FriendlyName;
}
var previewNode = new PreviewNode
{
ContentId = pageStructure.Id,
Type = NodeType.Element,
Parameters = pageStructure.Parameters,
PreviewNodeId = ToGuid(_seq++),
FriendlyName = friendlyName
};
var isRow = "ConfiguratorRow" == pageStructure.WidgetTypeCode;
if (isRow)
{
previewNode.ChildNodes.Add(new PreviewNode {
Type = NodeType.Html, Html = "<div class='row'>"
});
if (!pageStructure.Parameters.ContainsKey("NumColumns"))
{
return(previewNode);
}
var numColumnsRaw = pageStructure.Parameters["NumColumns"];
int columnCount;
var isNum = Int32.TryParse(numColumnsRaw, out columnCount);
if (!isNum)
{
return(previewNode);
}
for (int i = 0; i < columnCount; i++)
{
var i1 = i;
previewNode.ChildNodes.Add(new PreviewNode
{
Type = NodeType.Html,
Html = "<div class='col'>",
PreviewNodeId = ToGuid(_seq++)
});
var newSubstitution = new PreviewNode
{
Type = NodeType.LayoutSubtitution,
PlaceHolderId = i1.ToString(),
PreviewNodeId = ToGuid(_seq++)
};
previewNode.ChildNodes.Add(newSubstitution);
var nodesToPreview =
pageStructure.ChildNodes.Where(x => x.PlacementContentPlaceHolderId == i1.ToString());
newSubstitution.ChildNodes = nodesToPreview.Select(Write).ToList();
previewNode.ChildNodes.Add(new PreviewNode
{
Type = NodeType.Html,
Html = "</div>",
PreviewNodeId = ToGuid(_seq++)
});
}
previewNode.ChildNodes.Add(new PreviewNode
{
Type = NodeType.Html,
Html = "</div>",
PreviewNodeId = ToGuid(_seq++)
});
}
else
{
previewNode.UseClientRenderer = true;
}
return(previewNode);
//PlaceHolderId = pageStructure.
// FriendlyName = pageStructure.WidgetTypeCode
//ChildNodes = pageStructure.ChildNodes.Select(Write).ToList()
}
public void EmitLinearBlockStatements(StructureNode node, AbsynStatementEmitter emitter)
{
foreach (Statement stm in node.Instructions)
{
if (stm.Instruction.IsControlFlow)
return;
emitter.EmitStatement(stm);
}
}
private bool EndsWithReturnInstruction(StructureNode node)
{
if (node.Instructions.Count == 0)
return false;
return node.Instructions.Last.Instruction is ReturnInstruction;
}
public Expression BranchCondition(StructureNode node)
{
if (node.Instructions.Count == 0)
throw new InvalidOperationException(string.Format("Node {0} must have at least one instruction.", node.Name));
Branch branch = (Branch) node.Instructions.Last.Instruction;
return branch.Condition;
}
private bool AllPredecessorsVisited(StructureNode node)
{
foreach (StructureNode pred in node.InEdges)
if (!IsVisited(pred))
return false;
return true;
}
public void PushFollow(StructureNode followNode)
{
followStack.Push(followNode);
}
private void GenerateLabel(StructureNode node, AbsynStatementEmitter emitter)
{
emitter.EmitLabel(node);
}
protected override void GenerateCodeInner(AbsynCodeGenerator codeGen, StructureNode node, AbsynStatementEmitter emitter)
{
List<AbsynStatement> loopBody = new List<AbsynStatement>();
AbsynStatementEmitter bodyEmitter = new AbsynStatementEmitter(loopBody);
if (node.Conditional != null)
{
node.Conditional.GenerateCode(codeGen, node, Latch, bodyEmitter);
}
else
{
codeGen.EmitLinearBlockStatements(node, bodyEmitter);
if (node.OutEdges.Count != 1)
throw new NotSupportedException(string.Format("Expected top of PostTestedLoop {0} to have only 1 out edge, but found {1} out edges.", node.Name, node.OutEdges.Count));
codeGen.GenerateCode(node.OutEdges[0], Latch, bodyEmitter);
}
emitter.EmitForever(node, loopBody);
}
public Loop(StructureNode header, StructureNode latch, HashSet<StructureNode> loopNodes)
{
this.Header = header;
this.Latch = latch;
this.Nodes = loopNodes;
}
public bool IsVisited(StructureNode succ)
{
return visited.Contains(succ);
}
private string PostDom(StructureNode node)
{
return(string.Format("{0} PD> {1}", node.Block.Name, node.ImmPDom.Block.Name));
}
public void IsVisited(StructureNode succ, bool flag)
{
if (flag)
visited.Add(succ);
else
visited.Remove(succ);
}
public NodeEmitter(StructureNode pred, StructureNode node, AbsynStatementEmitter emitter)
{
this.Predecessor = pred;
this.Node = node;
this.Emitter = emitter;
}
public void ConfigureNode(StructureNode structureNode)
{
this.node = structureNode;
OverrideSpriteColor();
node.RemoveCollisions();
}
public CaseFinder(StructureNode head, StructureNode follow)
{
this.head = head;
this.follow = follow;
}
public bool Contains(StructureNode node)
{
return nodes.Contains(node);
}
private List<StructureNode> nodes = new List<StructureNode>(); // nodes of the interval
public Interval(int intervalID, StructureNode headerNode)
: base(intervalID, BlockTerminationType.IntervalNode)
{
AddNode(headerNode);
}
private bool ShouldJumpFromSequentialNode(StructureNode node, StructureNode succ)
{
if (IsVisited(succ))
{
return (followStack.Count == 0 || followStack.Peek() != succ);
}
return false;
}
public void AddNode(StructureNode node)
{
nodes.Add(node);
node.Interval = this;
}
private bool NeedsLabel(StructureNode node)
{
if (node.ForceLabel)
return true;
if (node.InEdges.Count == 1)
return false;
foreach (StructureNode pred in node.InEdges)
{
if (IsVisited(pred) && !IncompleteNodes.Contains(pred))
continue;
if (node.IsLoopHeader() && node.IsAncestorOf(pred))
continue;
return true;
}
return false;
}
