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