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); }
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; }