private void ElseIfStatementsEnter(XmlNode node) { var conditionNode = new CFGBlock { AstEntryNode = node }; var trueNode = new CFGBlock(); var currentScope = scopeHandler.GetIfStmt(); TaggedEdge <CFGBlock, EdgeTag> toCurrentConditionNode; if (currentScope.ElseifBlock != null) { toCurrentConditionNode = new TaggedEdge <CFGBlock, EdgeTag>(currentScope.ElseifBlock, conditionNode, new EdgeTag(EdgeType.False)); } else { toCurrentConditionNode = new TaggedEdge <CFGBlock, EdgeTag>(currentScope.EntryBlock, conditionNode, new EdgeTag(EdgeType.False)); } var toTrueNodeEdge = new TaggedEdge <CFGBlock, EdgeTag>(conditionNode, trueNode, new EdgeTag(EdgeType.True)); Graph.AddVerticesAndEdge(toCurrentConditionNode); currentScope.ElseifBlock = conditionNode; Graph.AddVerticesAndEdge(toTrueNodeEdge); DoNotVisitChildren(Conditional.GetCondNode(node)); CurrentBlock = trueNode; }
private void graphviz_FormatDoorEdge(object sender, FormatEdgeEventArgs <int, TaggedEdge <int, string> > e) { //Take tag from TaggedEdge and add as label on edge in serialized view TaggedEdge <int, string> edge = e.Edge; var edgeFormattor = e.EdgeFormatter; //If there is a door on this edge, override with this tag var doorHere = model.DoorAndClueManager.GetDoorsForEdge(edge); string edgeTag = edge.Tag; if (doorHere.Count() > 0) { edgeTag = ""; foreach (var door in doorHere) { edgeTag += door.Id + "+"; } } edgeFormattor.Label = new QuickGraph.Graphviz.Dot.GraphvizEdgeLabel(); edgeFormattor.Label.Value = edgeTag; }
public override void Step( int state, GssNode <int, EmptyGssData> stack, int position, TaggedEdge <int, string> currentTransition) { var token = currentTransition.Tag; switch (token) { case "a": Push(1, 0); break; case "b": if (stack.Symbol == 0) { Pop(1); } break; case "s": Accept(1); break; case "e": Skip(1); break; case "k": Accept(2); //Finish(); break; } }
/// <summary> /// Сгененерировать изображение графа. /// </summary> /// <param name="map"> НКМ. </param> /// <returns> Путь до изображение графа. </returns> public string GenerateGraphImage(Core.Models.FuzzyCognitiveMap map) { var g = new AdjacencyGraph <string, TaggedEdge <string, string> >(); foreach (var concept in map.Concepts) { g.AddVertex(concept.Name); } foreach (var link in map.ConceptsLinks) { var edge = new TaggedEdge <string, string>(link.From.Name, link.To.Name, link.Value.ToString(CultureInfo.InvariantCulture)); g.AddEdge(edge); } var graphViz = new GraphvizAlgorithm <string, TaggedEdge <string, string> >(g, @".\", GraphvizImageType.Png); graphViz.FormatVertex += FormatVertex; graphViz.FormatEdge += FormatEdge; var imagePath = graphViz.Generate(new FileDotEngine(), GraphName); return(imagePath); }
private CFGTaintInfo AnalyzeNode(TaggedEdge <CFGBlock, EdgeTag> edge) { var oldTaint = Taints[edge.Target]; // IN: // ∪ TAINT_OUT( l') // (l'~>l) var newInTaint = oldTaint.In.Merge(Taints[edge.Source].Out[edge.Tag.EdgeType]); // OUT: // ( TAINT_IN(l) \ KILL(l) ) ∪ GEN(l) ImmutableDictionary <EdgeType, ImmutableVariableStorage> newOutTaint; if (edge.Target.AstEntryNode == null) { newOutTaint = ImmutableDictionary <EdgeType, ImmutableVariableStorage> .Empty.Add(EdgeType.Normal, newInTaint); } else { //var blockTaintAnalyzer = new TaintBlockVisitor(null, newInTaint); //var astTraverser = new XmlTraverser(); //astTraverser.AddVisitor(blockTaintAnalyzer); //astTraverser.Traverse(edge.Target.AstEntryNode); var newOut = _blockAnalyzer.Analyze(edge.Target.AstEntryNode, newInTaint); var newOutWithCondSani = _conditionTaintAnalyser.AnalyzeCond(edge.Target.AstEntryNode, newOut); newOutTaint = newOutWithCondSani.ToImmutableDictionary(); } return(new CFGTaintInfo(newInTaint, newOutTaint)); }
public void generateUndirectedGraph(int FedID, string networkName) { string sqlStmt = "SELECT a.node_id, b.elementid, b.elementtype, b.name, b.body_major_axis_centroid from " + DBOperation.formatTabName(networkName) + "_node$ a, " + "bimrl_element_" + FedID.ToString("X4") + " b where a.node_name = b.elementid"; OracleCommand command = new OracleCommand(sqlStmt, DBOperation.DBConn); try { // Populate Dict with node information (with basic information from BIMRL_ELEMENT) OracleDataReader reader = command.ExecuteReader(); while (reader.Read()) { int nodeID = reader.GetInt32(0); string elemID = reader.GetString(1); string elemType = reader.GetString(2); string name = string.Empty; if (!reader.IsDBNull(3)) { name = reader.GetString(3); } Point3D centroid = null; if (!reader.IsDBNull(4)) { SdoGeometry sdogeom = reader.GetValue(4) as SdoGeometry; centroid = new Point3D(sdogeom.SdoPoint.XD.Value, sdogeom.SdoPoint.YD.Value, sdogeom.SdoPoint.ZD.Value); } NodeDict.Add(nodeID, new Tuple <string, string, string, Point3D>(elemID, elemType, name, centroid)); ElemIDToNodeIDDict.Add(elemID, nodeID); } reader.Dispose(); // generate the graph sqlStmt = "Select link_id, start_node_id, end_node_id from " + DBOperation.formatTabName(networkName) + "_link$ where active='Y'"; command.CommandText = sqlStmt; reader = command.ExecuteReader(); while (reader.Read()) { int linkID = reader.GetInt32(0); int startNode = reader.GetInt32(1); int endNode = reader.GetInt32(2); var edge = new TaggedEdge <int, int>(startNode, endNode, linkID); graph.AddVerticesAndEdge(edge); } reader.Dispose(); command.Dispose(); } catch (OracleException e) { string excStr = "%%Error - " + e.Message + "\n\t" + sqlStmt; refBimrlCommon.StackPushError(excStr); command.Dispose(); } catch (SystemException e) { string excStr = "%%Error - " + e.Message + "\n\t" + sqlStmt; refBimrlCommon.StackPushError(excStr); throw; } }
/// <summary> /// Removes route (edge) cost from the costs collection /// </summary> /// <returns>bool indicating success</returns> /// <param name="e">Route (edge)</param> public bool RemoveCost(TaggedEdge <Fief, string> e) { // remove cost bool success = costs.Remove(e); return(success); }
public void Equals() { var tag1 = new TestObject(1); var tag2 = new TestObject(2); var edge1 = new TaggedEdge <int, TestObject>(1, 2, tag1); var edge2 = new TaggedEdge <int, TestObject>(1, 2, tag1); var edge3 = new TaggedEdge <int, TestObject>(1, 2, tag2); var edge4 = new TaggedEdge <int, TestObject>(1, 2, null); Assert.AreEqual(edge1, edge1); Assert.AreNotEqual(edge1, edge2); Assert.AreNotEqual(edge2, edge1); Assert.IsFalse(edge1.Equals(edge2)); Assert.IsFalse(edge2.Equals(edge1)); Assert.AreNotEqual(edge1, edge3); Assert.AreNotEqual(edge3, edge1); Assert.IsFalse(edge1.Equals(edge3)); Assert.IsFalse(edge3.Equals(edge1)); Assert.AreNotEqual(edge1, edge4); Assert.AreNotEqual(edge4, edge1); Assert.IsFalse(edge1.Equals(edge4)); Assert.IsFalse(edge4.Equals(edge1)); Assert.AreNotEqual(edge1, null); Assert.IsFalse(edge1.Equals(null)); }
private void ElseIfStatementsExit(XmlNode node) { var currentScope = scopeHandler.GetIfStmt(); var toEndEdge = new TaggedEdge <CFGBlock, EdgeTag>(CurrentBlock, currentScope.EndBlock, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(toEndEdge); }
public void TagChanged() { var edge = new TaggedEdge <int, TestObject>(1, 2, null); int changeCount = 0; edge.TagChanged += (sender, args) => ++ changeCount; edge.Tag = null; Assert.AreEqual(0, changeCount); var tag1 = new TestObject(1); edge.Tag = tag1; Assert.AreEqual(1, changeCount); edge.Tag = tag1; Assert.AreEqual(1, changeCount); var tag2 = new TestObject(2); edge.Tag = tag2; Assert.AreEqual(2, changeCount); edge.Tag = tag1; Assert.AreEqual(3, changeCount); }
private void AddToAllCycles(IEnumerable <TaggedEdge <int, string> > path, TaggedEdge <int, string> backEdge) { var connectionList = path.Select(edge => new Connection(edge.Source, edge.Target)).ToList(); connectionList.Add(new Connection(backEdge.Source, backEdge.Target)); allCycles.Add(connectionList); }
private Edge <CFGBlock> ConnectBlocks(CFGBlock source, CFGBlock target, EdgeType edgeType) { var edge = new TaggedEdge <CFGBlock, EdgeTag>(source, target, new EdgeTag(edgeType)); Graph.AddEdge(edge); return(edge); }
/// <summary> /// Creates new route (edge) /// </summary> /// <returns>TaggedEdge</returns> /// <param name="s">Source hex (Fief)</param> /// <param name="t">Target hex (Fief)</param> /// <param name="tag">String tag for route</param> public TaggedEdge <Fief, string> CreateEdge(Fief s, Fief t, string tag) { // create route Trace.WriteLine("The edge tag is: " + tag); TaggedEdge <Fief, string> myEdge = new TaggedEdge <Fief, string>(s, t, tag); return(myEdge); }
public results AddDirectedEdge(string source, string target, double weight) { var edge = new TaggedEdge <string, string>(source, target, weight.ToString()); Graph.AddEdge(edge); return(this); }
public bool Analyze(TaggedEdge <CFGBlock, EdgeTag> edge) { var oldRes = ReachingSetDictionary[edge.Target]; var newRes = AnalyzeNode(edge); return(MonotonicChange(oldRes, newRes)); }
private CFGBlock ConnectNewBlockTo(CFGBlock block, EdgeType edgeType) { var newBlock = new CFGBlock(); var edge = new TaggedEdge <CFGBlock, EdgeTag>(block, newBlock, new EdgeTag(edgeType)); Graph.AddVerticesAndEdge(edge); return(newBlock); }
public Door(TaggedEdge <int, string> doorEdge, Connection connectionReducedMap, Connection connectionFullMap, string id, int index, int numberOfCluesRequired) { Id = id; this.doorEdge = doorEdge; this.index = index; NumCluesRequired = numberOfCluesRequired; DoorConnectionFullMap = connectionFullMap; DoorConnectionReducedMap = connectionReducedMap; }
public MapSplitter(IEnumerable <TaggedEdge <int, string> > edges, TaggedEdge <int, string> edgeToSplitOn, int originVertex) { this.map = new UndirectedGraph <int, TaggedEdge <int, string> >(); map.AddVerticesAndEdgeRange(edges); this.edgesToSplitOn = new List <TaggedEdge <int, string> >(new TaggedEdge <int, string>[] { edgeToSplitOn }); this.originVertex = originVertex; Process(); }
public void TagGetSet874() { TaggedEdge<int, int> taggedEdge; taggedEdge = new TaggedEdge<int, int>(0, 0, 0); this.TagGetSet<int, int>(taggedEdge, int.MinValue); Assert.IsNotNull((object)taggedEdge); Assert.AreEqual<int>(int.MinValue, taggedEdge.Tag); Assert.AreEqual<int>(0, ((Edge<int>)taggedEdge).Source); Assert.AreEqual<int>(0, ((Edge<int>)taggedEdge).Target); }
public void ObjectToString() { var edge1 = new TaggedEdge <int, TestObject>(1, 2, null); var edge2 = new TaggedEdge <int, TestObject>(1, 2, new TestObject(42)); var edge3 = new TaggedEdge <int, TestObject>(2, 1, null); Assert.AreEqual("1 -> 2 (no tag)", edge1.ToString()); Assert.AreEqual("1 -> 2 (42)", edge2.ToString()); Assert.AreEqual("2 -> 1 (no tag)", edge3.ToString()); }
private ReachingSet AnalyzeNode(TaggedEdge <CFGBlock, EdgeTag> edge) { if (ReachingSetDictionary[edge.Source] == null) { ReachingSetDictionary = ReachingSetDictionary.SetItem(edge.Source, new ReachingSet()); } if (ReachingSetDictionary[edge.Target] == null) { ReachingSetDictionary = ReachingSetDictionary.SetItem(edge.Target, new ReachingSet()); } var node = edge.Target; // IN: // U RD_OUT(l') // (l'~>l) ReachingSetDictionary = ReachingSetDictionary.SetItem(node, ReachingSetDictionary[node].AddInVarRange(ReachingSetDictionary[edge.Source].DefinedOutVars, true)); // OUT: // (RD_IN(l) \ kill(l)) U gen(l) var Out = ReachingSetDictionary[node]; Out = Out.AddOutVarRange(ReachingSetDictionary[node].DefinedInVars); XmlTraverser xmlTraverser = new XmlTraverser(); CFGASTNodeVisitor nodeVisitor = new CFGASTNodeVisitor(); xmlTraverser.AddVisitor(nodeVisitor); if (node.AstEntryNode != null) { var nodeToTraverse = Conditional.HasConditionNode(node.AstEntryNode) ? Conditional.GetCondNode(node.AstEntryNode) : node.AstEntryNode; xmlTraverser.Traverse(nodeToTraverse); foreach (var currNode in nodeVisitor.NodesOfInterest) { var varNode = AstNodeInfo.GetVarNameXmlNode(currNode); ValueInfo varInfo = new ValueInfo() { Block = node }; varInfo = VariableInfoComposer.AnalyzeBlock(varInfo); var gs = new Variable(AstNodeInfo.GetVarNameXmlNode(currNode).Name, VariableScope.Unknown); gs = gs.AddVarInfo(varInfo); Out = Out.AddOutVar(varNode.InnerText, gs); } } ReachingSetDictionary = ReachingSetDictionary.SetItem(node, ReachingSetDictionary[node].AddOutVarRange(Out.DefinedOutVars)); return(ReachingSetDictionary[node]); }
public void AddRoomConnectionIfNotExists(int startRoom, int endRoom) { TaggedEdge <int, string> possibleEdge = null; baseGraph.TryGetEdge(startRoom, endRoom, out possibleEdge); if (possibleEdge != null) { AddRoomConnection(startRoom, endRoom); } }
public TaggedEdge <int, String> GetEdgeBetweenRooms(int startRoom, int endRoom) { TaggedEdge <int, string> possibleEdge = null; baseGraph.TryGetEdge(startRoom, endRoom, out possibleEdge); if (possibleEdge != null) { return(possibleEdge); } throw new ApplicationException("Edge not in map"); }
private static void graphviz_FormatEdge(object sender, FormatEdgeEventArgs <int, TaggedEdge <int, string> > e) { //Take tag from TaggedEdge and add as label on edge in serialized view TaggedEdge <int, string> edge = e.Edge; var edgeFormattor = e.EdgeFormatter; string edgeTag = edge.Tag; edgeFormattor.Label = new QuickGraph.Graphviz.Dot.GraphvizEdgeLabel(); edgeFormattor.Label.Value = edgeTag; }
protected LinkedList <Connector> GetPath(Connector stop) { // get graph var graph = new AdjacencyGraph <Connector, TaggedEdge <Connector, double> >(); var costs = new Dictionary <Edge <Connector>, double>(); //var list = new List<Connector>(WorkingConnectors); // get vertexes foreach (Connector connector in WorkingConnectors) { graph.AddVertex(connector); } // get edges for (int i = 0; i < WorkingConnectors.Count; i++) { for (int j = 0; j < WorkingConnectors.Count; j++) { if (i != j && WorkingConnectors[i].CanAccess(WorkingConnectors[j])) { var edge = new TaggedEdge <Connector, double>(WorkingConnectors[i], WorkingConnectors[j], Message.Time(WorkingConnectors[i], WorkingConnectors[j])); graph.AddVerticesAndEdge(edge); costs.Add(edge, Message.Time(WorkingConnectors[i], WorkingConnectors[j])); //Console.WriteLine(WorkingConnectors[i].ID + " " + WorkingConnectors[j].ID); } } } var edgeCost = AlgorithmExtensions.GetIndexer(costs); var tryGetPath = graph.ShortestPathsDijkstra(edgeCost, this); // get path IEnumerable <TaggedEdge <Connector, double> > epath; if (!tryGetPath(stop, out epath)) { // can't get path return(null); } // convert path to linked list var path = epath.ToList(); var result = new LinkedList <Connector>(); foreach (TaggedEdge <Connector, double> edge in path) { result.AddLast(edge.Source); } result.AddLast(stop); return(result); }
public bool Analyze(TaggedEdge <CFGBlock, EdgeTag> edge) { var oldTaint = Taints[edge.Target]; var newTaint = AnalyzeNode(edge); if (MonotonicChange(oldTaint, newTaint)) { _taints[edge.Target] = newTaint; return(true); } return(false); }
public bool Analyze(TaggedEdge<CFGBlock, EdgeTag> edge) { var oldTaint = Taints[edge.Target]; var newTaint = AnalyzeNode(edge); if (MonotonicChange(oldTaint, newTaint)) { _taints[edge.Target] = newTaint; return true; } return false; }
public bool Analyze(TaggedEdge <CFGBlock, EdgeTag> edge) { var didAnyChange = false; foreach (var cfgAnalysis in _analyses) { if (cfgAnalysis.Value.Analyze(edge)) { didAnyChange = true; } } return(didAnyChange); }
private void buildGraph(Leaf parentVertex) { foreach (var childVertex in parentVertex.Children) { var edge = new TaggedEdge <Leaf, string>( parentVertex, childVertex, childVertex.Parent.Name); graph.AddVerticesAndEdge(edge); buildGraph(childVertex); } }
private void buildGraph(Leaf parentVertex) { foreach (var childVertex in parentVertex.Children) { var edge = new TaggedEdge<Leaf, string>( parentVertex, childVertex, childVertex.ParentLink.AttributeName); graph.AddVerticesAndEdge(edge); buildGraph(childVertex); } }
private void SwitchCaseStatementEnter(XmlNode node) { var conditionNode = new CFGBlock(); var trueNode = new CFGBlock(); conditionNode.AstEntryNode = node; var currentScope = (SwitchScope)scopeHandler.GetInnermostLoop(); TaggedEdge <CFGBlock, EdgeTag> toCurrentConditionNode; if (CurrentBlock == currentScope.EntryBlock) { toCurrentConditionNode = new TaggedEdge <CFGBlock, EdgeTag>(CurrentBlock, conditionNode, new EdgeTag(EdgeType.Normal)); } else { if (currentScope.CurrentCondition != null) { toCurrentConditionNode = new TaggedEdge <CFGBlock, EdgeTag>(currentScope.CurrentCondition, conditionNode, new EdgeTag(EdgeType.False)); } else { toCurrentConditionNode = new TaggedEdge <CFGBlock, EdgeTag>(currentScope.EntryBlock, conditionNode, new EdgeTag(EdgeType.Normal)); } } var toTrueNodeEdge = new TaggedEdge <CFGBlock, EdgeTag>(conditionNode, trueNode, new EdgeTag(EdgeType.True)); if (Case.IsDefaultCase(node)) { currentScope.DefaultBlock = conditionNode; currentScope.DefaultTrueBlock = trueNode; } else { Graph.AddVerticesAndEdge(toCurrentConditionNode); currentScope.CurrentCondition = conditionNode; } Graph.AddVerticesAndEdge(toTrueNodeEdge); if (!CurrentBlock.BreaksOutOfScope && CurrentBlock != currentScope.EntryBlock) { var fallthrough = new TaggedEdge <CFGBlock, EdgeTag>(CurrentBlock, trueNode, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(fallthrough); } CurrentBlock = trueNode; DoNotVisitChildren(Conditional.GetCondNode(node)); }
public void AddingClusterEdge() { var graph = new AdjacencyGraph <int, IEdge <int> >(); var clusteredGraph = new ClusteredAdjacencyGraph <int, IEdge <int> >(graph); ClusteredAdjacencyGraph <int, IEdge <int> > cluster1 = clusteredGraph.AddCluster(); cluster1.AddVertex(5); cluster1.AddVertex(6); var edge = new TaggedEdge <int, int>(5, 6, 1); cluster1.AddEdge(edge); Assert.IsTrue(ContainsEdgeParent(clusteredGraph, edge)); }
public void RemovingClustEdgeTest1() { var graph = new AdjacencyGraph <int, IEdge <int> >(); var clusteredGraph = new ClusteredAdjacencyGraph <int, IEdge <int> >(graph); var cluster1 = clusteredGraph.AddCluster(); var cluster2 = cluster1.AddCluster(); var cluster3 = cluster2.AddCluster(); cluster3.AddVertex(5); cluster3.AddVertex(6); var edge = new TaggedEdge <int, int>(5, 6, 1); cluster1.RemoveEdge(edge); Assert.IsFalse(ContainsEdgeParent(cluster2, edge)); }
private static void testGraph() { //see graph.png TaggedEdge<string, float>[] edges = new TaggedEdge<string, float>[] { new TaggedEdge<string, float>("1", "2", 7), new TaggedEdge<string, float>("1", "3", 9), new TaggedEdge<string, float>("1", "6", 14), new TaggedEdge<string, float>("2", "3", 10), new TaggedEdge<string, float>("2", "4", 15), new TaggedEdge<string, float>("3", "6", 2), new TaggedEdge<string, float>("3", "4", 11), new TaggedEdge<string, float>("4", "5", 6), new TaggedEdge<string, float>("5", "6", 9) }; var graph = edges.ToGraph<string, TaggedEdge<string, float>>(); Dictionary<string, Dictionary<string, double>> costMatrix; var paths = graph.FindAllPaths(x => x.Tag, out costMatrix); var vertices = graph.GetVertices<string, TaggedEdge<string, float>>(); Console.WriteLine("Possible paths:"); foreach (var v1 in vertices) { foreach (var v2 in vertices) { var path = paths[v1][v2]; var cost = costMatrix.Contains(v1, v2) ? costMatrix[v1][v2]: Double.NaN; Console.Write("{0} => {1}: Cost {2}. Edges:", v1, v2, cost.ToString().PadLeft(3)); foreach (var edge in path) { Console.Write("({0} => {1}) ", edge.Source, edge.Destination); } Console.WriteLine(); } } }
private void IfStatementExit(XmlNode node) { var currentIfBlock = scopeHandler.GetIfStmt(); var endIfNode = currentIfBlock.EndBlock; //Graph.AddVertex(endIfNode); if (currentIfBlock.IsFalseNodeSet()) { if (!currentIfBlock.FalseNode.BreaksOutOfScope) { var falseToEndEdge = new TaggedEdge<CFGBlock, EdgeTag>(currentIfBlock.FalseNode, endIfNode, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(falseToEndEdge); } } else if (currentIfBlock.ElseifBlock != null) { if (!currentIfBlock.ElseifBlock.BreaksOutOfScope) { var falseToEndEdge = new TaggedEdge<CFGBlock, EdgeTag>(currentIfBlock.ElseifBlock, endIfNode, new EdgeTag(EdgeType.False)); Graph.AddEdge(falseToEndEdge); } } else { var falseEdge = new TaggedEdge<CFGBlock, EdgeTag>(currentIfBlock.IfConditionNode, endIfNode, new EdgeTag(EdgeType.False)); Graph.AddEdge(falseEdge); currentIfBlock.TrueNode = CurrentBlock; } if (!currentIfBlock.TrueNode.BreaksOutOfScope) { var trueToEndEdge = new TaggedEdge<CFGBlock, EdgeTag>(currentIfBlock.TrueNode, endIfNode, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(trueToEndEdge); } scopeHandler.PopIfStmt(); CurrentBlock = endIfNode; }
protected void BuildCompleteGraph() { this.completeGraph = new BidirectionalGraph<ConfigurationBase, TaggedEdge<ConfigurationBase, string>>(); Stack<ConfigurationBase> searchStack = new Stack<ConfigurationBase>(); searchStack.Push(this.InitialStep); while (searchStack.Count > 0) { if (completeGraph.VertexCount > Classes.Ultility.Ultility.SIMULATION_BOUND) { return; } if (CancelRequested) { return; } ConfigurationBase currentStep = searchStack.Pop(); List<ConfigurationBase> list = this.MakeOneMove(currentStep); foreach (ConfigurationBase step in list) { if (this.completeGraph.ContainsVertex(step)) { TaggedEdge<ConfigurationBase, string> edge = null; foreach (TaggedEdge<ConfigurationBase, string> outEdge in completeGraph.OutEdges(currentStep)) { if (outEdge.Tag == step.Event) { //duplicate edge is found edge = outEdge; break; } } if (edge == null) { edge = new TaggedEdge<ConfigurationBase, string>(currentStep, step, step.Event); this.completeGraph.AddEdge(edge); } } else { TaggedEdge<ConfigurationBase, string> edge = new TaggedEdge<ConfigurationBase, string>(currentStep, step, step.Event); this.completeGraph.AddVerticesAndEdge(edge); //this.completeGraph.AddVertex(step); searchStack.Push(step); } } } }
private Edge<CFGBlock> ConnectBlocks(CFGBlock source, CFGBlock target, EdgeType edgeType) { var edge = new TaggedEdge<CFGBlock, EdgeTag>(source, target, new EdgeTag(edgeType)); Graph.AddEdge(edge); return edge; }
private IEnumerable<Objective> GetObjectivesBehindLockedEdge(TaggedEdge<int, string> foundEdge) { MapSplitter splitMap = new MapSplitter(mapNoCycles.mapNoCycles.Edges, foundEdge, startVertex); //Lists of all clues in vertices which are in the locked tree var newlyLockedObjectiveLists = objectiveRoomMap.Where(kv => splitMap.RoomComponentIndex(kv.Key) == splitMap.NonOriginComponentIndex).Select(kv => kv.Value); //Flattened to one long list return newlyLockedObjectiveLists.SelectMany(o => o); }
private void SwitchStatementEnter(XmlNode node) { if (CurrentBlock.BreaksOutOfScope) { CurrentBlock = new CFGBlock(); Graph.AddVertex(CurrentBlock); } var switchScope = new SwitchScope(new CFGBlock() { AstEntryNode = node }, new CFGBlock()); var edgeToSwitch = new TaggedEdge<CFGBlock, EdgeTag>(CurrentBlock, switchScope.SwitchStartNode, new EdgeTag(EdgeType.Normal)); Graph.AddVerticesAndEdge(edgeToSwitch); Graph.AddVertex(switchScope.EndBlock); CurrentBlock = switchScope.SwitchStartNode; scopeHandler.EnterLoop(switchScope); DoNotVisitChildren(Conditional.GetCondNode(node)); }
private CFGBlock ConnectNewBlockTo(CFGBlock block, EdgeType edgeType) { var newBlock = new CFGBlock(); var edge = new TaggedEdge<CFGBlock, EdgeTag>(block, newBlock, new EdgeTag(edgeType)); Graph.AddVerticesAndEdge(edge); return newBlock; }
public List<Door> GetDoorsForEdge(TaggedEdge<int, string> edgeToFind) { var toRet = new List<Door>(); foreach (var door in doorMap) { if (door.Value.DoorEdge == edgeToFind) { toRet.Add(door.Value); } } return toRet; }
private void SwitchCaseStatementEnter(XmlNode node) { var conditionNode = new CFGBlock(); var trueNode = new CFGBlock(); conditionNode.AstEntryNode = node; var currentScope = (SwitchScope)scopeHandler.GetInnermostLoop(); TaggedEdge<CFGBlock, EdgeTag> toCurrentConditionNode; if (CurrentBlock == currentScope.EntryBlock) { toCurrentConditionNode = new TaggedEdge<CFGBlock, EdgeTag>(CurrentBlock, conditionNode, new EdgeTag(EdgeType.Normal)); } else { if(currentScope.CurrentCondition != null) toCurrentConditionNode = new TaggedEdge<CFGBlock, EdgeTag>(currentScope.CurrentCondition, conditionNode, new EdgeTag(EdgeType.False)); else toCurrentConditionNode = new TaggedEdge<CFGBlock, EdgeTag>(currentScope.EntryBlock, conditionNode, new EdgeTag(EdgeType.Normal)); } var toTrueNodeEdge = new TaggedEdge<CFGBlock, EdgeTag>(conditionNode, trueNode, new EdgeTag(EdgeType.True)); if (Case.IsDefaultCase(node)) { currentScope.DefaultBlock = conditionNode; currentScope.DefaultTrueBlock = trueNode; } else { Graph.AddVerticesAndEdge(toCurrentConditionNode); currentScope.CurrentCondition = conditionNode; } Graph.AddVerticesAndEdge(toTrueNodeEdge); if (!CurrentBlock.BreaksOutOfScope && CurrentBlock != currentScope.EntryBlock) { var fallthrough = new TaggedEdge<CFGBlock, EdgeTag>(CurrentBlock, trueNode, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(fallthrough); } CurrentBlock = trueNode; DoNotVisitChildren(Conditional.GetCondNode(node)); }
private void SwitchStatementExit(XmlNode node) { var currScope = (SwitchScope)scopeHandler.CurrentScope; // Get last inserted block and connect to end CFGBlock lastBlock; if (currScope.DefaultBlock != null && currScope.CurrentCondition == null) { // Special case: Switch with only default case var toDefault = new TaggedEdge<CFGBlock, EdgeTag>(currScope.SwitchStartNode, currScope.DefaultBlock, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(toDefault); lastBlock = currScope.DefaultTrueBlock; } else if (currScope.CurrentCondition == null) { // Special case: Empty switch lastBlock = CurrentBlock; } else if (currScope.DefaultBlock != null) { var toDefault = new TaggedEdge<CFGBlock, EdgeTag>(currScope.CurrentCondition, currScope.DefaultBlock, new EdgeTag(EdgeType.False)); Graph.AddEdge(toDefault); lastBlock = currScope.DefaultTrueBlock; } else { var endCondEdge = new TaggedEdge<CFGBlock, EdgeTag>(currScope.CurrentCondition, currScope.EndBlock, new EdgeTag(EdgeType.False)); lastBlock = CurrentBlock; Graph.AddEdge(endCondEdge); } // Only create edge to end if the break/continue has not already done so if (!CurrentBlock.BreaksOutOfScope) { var endTrueEdge = new TaggedEdge<CFGBlock, EdgeTag>(lastBlock, currScope.EndBlock, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(endTrueEdge); } CurrentBlock = currScope.EndBlock; scopeHandler.LeaveLoop(); }
private void ElseIfStatementsEnter(XmlNode node) { var conditionNode = new CFGBlock { AstEntryNode = node }; var trueNode = new CFGBlock(); var currentScope = scopeHandler.GetIfStmt(); TaggedEdge<CFGBlock, EdgeTag> toCurrentConditionNode; if (currentScope.ElseifBlock != null) toCurrentConditionNode = new TaggedEdge<CFGBlock, EdgeTag>(currentScope.ElseifBlock, conditionNode, new EdgeTag(EdgeType.False)); else toCurrentConditionNode = new TaggedEdge<CFGBlock, EdgeTag>(currentScope.EntryBlock, conditionNode, new EdgeTag(EdgeType.False)); var toTrueNodeEdge = new TaggedEdge<CFGBlock, EdgeTag>(conditionNode, trueNode, new EdgeTag(EdgeType.True)); Graph.AddVerticesAndEdge(toCurrentConditionNode); currentScope.ElseifBlock = conditionNode; Graph.AddVerticesAndEdge(toTrueNodeEdge); DoNotVisitChildren(Conditional.GetCondNode(node)); CurrentBlock = trueNode; }
private void ElseIfStatementsExit(XmlNode node) { var currentScope = scopeHandler.GetIfStmt(); var toEndEdge = new TaggedEdge<CFGBlock, EdgeTag>(CurrentBlock, currentScope.EndBlock, new EdgeTag(EdgeType.Normal)); Graph.AddEdge(toEndEdge); }
private void ElseStatementsEnter(XmlNode node) { var ifblock = (IfScope)scopeHandler.CurrentScope; if(ifblock.ElseifBlock == null) ifblock.TrueNode = CurrentBlock; var falseNode = new CFGBlock(); TaggedEdge<CFGBlock, EdgeTag> newEdge; if (ifblock.ElseifBlock == null) { newEdge = new TaggedEdge<CFGBlock, EdgeTag>(ifblock.IfConditionNode, falseNode, new EdgeTag(EdgeType.False)); } else { newEdge = new TaggedEdge<CFGBlock, EdgeTag>(ifblock.ElseifBlock, falseNode, new EdgeTag(EdgeType.False)); } Graph.AddVerticesAndEdge(newEdge); CurrentBlock = falseNode; }
private CFGTaintInfo AnalyzeNode(TaggedEdge<CFGBlock, EdgeTag> edge) { var oldTaint = Taints[edge.Target]; // IN: // ∪ TAINT_OUT( l') // (l'~>l) var newInTaint = oldTaint.In.Merge(Taints[edge.Source].Out[edge.Tag.EdgeType]); // OUT: // ( TAINT_IN(l) \ KILL(l) ) ∪ GEN(l) ImmutableDictionary<EdgeType, ImmutableVariableStorage> newOutTaint; if (edge.Target.AstEntryNode == null) { newOutTaint = ImmutableDictionary<EdgeType, ImmutableVariableStorage>.Empty.Add(EdgeType.Normal, newInTaint); } else { //var blockTaintAnalyzer = new TaintBlockVisitor(null, newInTaint); //var astTraverser = new XmlTraverser(); //astTraverser.AddVisitor(blockTaintAnalyzer); //astTraverser.Traverse(edge.Target.AstEntryNode); var newOut =_blockAnalyzer.Analyze(edge.Target.AstEntryNode, newInTaint); var newOutWithCondSani = _conditionTaintAnalyser.AnalyzeCond(edge.Target.AstEntryNode, newOut); newOutTaint = newOutWithCondSani.ToImmutableDictionary(); } return new CFGTaintInfo(newInTaint, newOutTaint); }
private void ForStatementEnter(XmlNode node) { CFGBlock forLoopInit = new CFGBlock(); if (!CurrentBlock.BreaksOutOfScope) { forLoopInit = ConnectNewBlockTo(CurrentBlock, EdgeType.Normal); } forLoopInit.AstEntryNode = ForLoop.GetInitNode(node); DoNotVisitChildren(forLoopInit.AstEntryNode); CFGBlock conditionBlock = ConnectNewBlockTo(forLoopInit, EdgeType.Normal); conditionBlock.AstEntryNode = node; DoNotVisitChildren(Conditional.GetCondNode(node)); CFGBlock loopUpdateBlock = new CFGBlock { AstEntryNode = ForLoop.GetLoopNode(node) }; DoNotVisitChildren(loopUpdateBlock.AstEntryNode); var edge = new TaggedEdge<CFGBlock, EdgeTag>(loopUpdateBlock, conditionBlock, new EdgeTag(EdgeType.Normal)); Graph.AddVerticesAndEdge(edge); CFGBlock loopBodyBlock = ConnectNewBlockTo(conditionBlock, EdgeType.True); CFGBlock loopDoneBlock = ConnectNewBlockTo(conditionBlock, EdgeType.False); var loopScope = new LoopScope(forLoopInit) { LoopConditionBlock = loopUpdateBlock, LoopBodyStartBlock = loopBodyBlock, LoopUpdateBlock = loopUpdateBlock, ContinueDestination = loopUpdateBlock, EndBlock = loopDoneBlock }; scopeHandler.EnterLoop(loopScope); CurrentBlock = loopBodyBlock; }