public override void ReverseAccept(VisitNode visit)
{
if (visit(this) && Parent != null)
{
Parent.ReverseAccept(visit);
}
}
private static void ParseInput(string[] lines, FloorPlan floorPlan, List <VisitNode> placesToVisit)
{
for (int y = 0; y < lines.Length; y++)
{
string line = lines[y];
for (int x = 0; x < line.Length; x++)
{
switch (line[x])
{
case '.':
// do nothing
break;
case '#':
floorPlan.RecordObstruction(x, y);
break;
default:
int positionSeq = Convert.ToInt32(line[x].ToString());
VisitNode place = new VisitNode();
place.IsStartPosition = positionSeq == 0;
place.PositionNumber = positionSeq;
place.XPosition = x;
place.YPosition = y;
placesToVisit.Add(place);
break;
}
}
}
}
private void TraverseTreePostOrder(TreeNode node, Link parentLink, VisitNode visit)
{
foreach (var link in node.GetSublinks(parentLink))
{
var subnode = link.OtherNode(node);
TraverseTreePostOrder(subnode, link, visit);
}
visit(node, parentLink);
}
public void BuildAnonymousMethod <T>(T node, VisitNode <T> visit)
where T : AnonymousFunctionExpressionSyntax
{
MainDeclaration.Instance.RoslynWatch.Start();
IMethodSymbol symbol = MainDeclaration.Instance.Model.GetSymbolInfo(node).Symbol as IMethodSymbol;
MainDeclaration.Instance.RoslynWatch.Stop();
Method limNode = null;
if (symbol != null)
{
var anonymousObjectMemberDeclaration = node.GetParent <AnonymousObjectMemberDeclaratorSyntax>();
limNode = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol, anonymousObjectMemberDeclaration == null);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id, _map[node], limNode.Id);
node.CreateCommentNode(symbol);
limNode.Name = _crossEdgeFiller.GetOrCreateNode <Csharp.Asg.Nodes.Expression.AnonymousFunctionExpressionSyntax>(node).Identifier;
var temp = MainDeclaration.Instance.MethodStack.Pop();
Scope parent = (Scope)MainDeclaration.Instance.LimFactory.getRef(MainDeclaration.Instance.MethodStack.Peek().Id);
MainDeclaration.Instance.MethodStack.Push(temp);
limNode.MangledName = parent.MangledName + "." + limNode.Name;
if (anonymousObjectMemberDeclaration != null)
{
Commons.Common.Safe_Edge(parent, "HasMember", limNode.Id);
}
limNode.DemangledName = limNode.MangledName;
limNode.IsCompilerGenerated = true;
}
else
{
//TODO write warning/error
return;
}
visit(node as T);
if (MainDeclaration.Instance.MethodStack.Count > 1)
{
Utils.Info.MethodInfo mi = MainDeclaration.Instance.MethodStack.Pop();
if (node.Body.Kind() == SyntaxKind.Block)
{
mi = Commons.Common.FillMethodMetrics(node.Body, mi);
}
else
{
mi.NOB = 1;
mi.NOS = 1;
}
Commons.Common.FillFromMethodStack(mi);
}
limNode.SetCLOC(node);
}
public override void Accept(VisitNode visit)
{
if (visit(this))
{
if (_childs != null)
{
foreach (var childNode in _childs)
{
childNode.Accept(visit);
}
}
}
}
/// <summary>
/// Breadth-first walk of the tree
/// </summary>
/// <param name="visit">Visit type delegate</param>
public void WalkTree(VisitNode visitNode, VisitEdge visitEdge)
{
Queue <Node> walkingQueue = new Queue <Node>();
for (walkingQueue.Enqueue(this.RootNode); walkingQueue.Count > 0;)
{
var currentNode = walkingQueue.Dequeue();
visitNode((int)currentNode.Label);
foreach (var edge in currentNode.Edges)
{
walkingQueue.Enqueue(edge.Value.EndNode);
visitEdge((int)currentNode.Label, (int)edge.Value.EndNode.Label, edge.Value.Start, NormalizeEndValue(edge.Value.End));
}
}
}
private void VisitTransitiveClosure(
Queue <NodeId> queue,
VisitationTracker visitedNodes,
VisitNode visitNodeDependencies,
VisitNode visitNodeDependents,
bool dependencies,
bool dependents)
{
Contract.Assert(visitNodeDependencies == null || dependencies);
Contract.Assert(visitNodeDependents == null || dependents);
while (queue.Count != 0)
{
var node = queue.Dequeue();
if (dependencies)
{
if (visitNodeDependencies == null || visitNodeDependencies(node))
{
foreach (Edge inEdge in m_dataflowGraph.GetIncomingEdges(node))
{
if (visitedNodes.MarkVisited(inEdge.OtherNode))
{
queue.Enqueue(inEdge.OtherNode);
}
}
}
}
if (dependents)
{
if (visitNodeDependents == null || visitNodeDependents(node))
{
foreach (Edge outEdge in m_dataflowGraph.GetOutgoingEdges(node))
{
if (visitedNodes.MarkVisited(outEdge.OtherNode))
{
queue.Enqueue(outEdge.OtherNode);
}
}
}
}
}
}
/// <summary>
/// Visits the transitive dependencies of the node
/// </summary>
public void VisitTransitiveDependencies(
NodeId startNode,
VisitationTracker visitedNodes,
VisitNode visitNode)
{
using (var queueWrapper = m_nodeQueuePool.GetInstance())
{
var queue = queueWrapper.Instance;
AddIfNotVisited(queue, startNode, visitedNodes);
VisitTransitiveClosure(
queue,
visitedNodes,
visitNodeDependents: null,
visitNodeDependencies: visitNode,
dependencies: true,
dependents: false);
}
}
/// <summary>
/// Visits the transitive reachable nodes of the given nodes
/// </summary>
public void VisitTransitiveReachableNodes(
IEnumerable <NodeId> startNodes,
VisitationTracker visitedNodes,
VisitNode visitNodeDependencies,
VisitNode visitNodeDependents)
{
using (var queueWrapper = m_nodeQueuePool.GetInstance())
{
var queue = queueWrapper.Instance;
AddIfNotVisited(queue, startNodes, visitedNodes);
VisitTransitiveClosure(
queue,
visitedNodes,
visitNodeDependencies: visitNodeDependencies,
visitNodeDependents: visitNodeDependents,
dependencies: true,
dependents: true);
}
}
private void VisitNamedType <T>(BaseTypeDeclarationSyntax node, VisitNode <T> visitor)
where T : CSharpSyntaxNode
{
MainDeclaration.Instance.RoslynWatch.Start();
INamedTypeSymbol symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop();
Class limNode = SymbolBuilder.BuildDispatch <Class, INamedTypeSymbol>(symbol);
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id, _map[node], limNode.Id);
node.CreateCommentNode(symbol);
visitor(node as T);
if (MainDeclaration.Instance.ClassStack.Count > 0)
{
Commons.Common.FillFromClassStack();
}
limNode.SetCLOC(node);
}
private void visitMethod <T>(BaseMethodDeclarationSyntax node, VisitNode <T> visitor)
where T : CSharpSyntaxNode
{
MainDeclaration.Instance.RoslynWatch.Start( );
var symbol = MainDeclaration.Instance.Model.GetDeclaredSymbol(node);
MainDeclaration.Instance.RoslynWatch.Stop( );
HalsteadAnalyzer halsteadAnalyzer = new HalsteadAnalyzer();
var halstedMetrics = halsteadAnalyzer.Calculate(node);
var limNode = SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol);
limNode.TotalOperands = halstedMetrics.TotalOperands;
limNode.TotalOperators = halstedMetrics.TotalOperators;
limNode.DistinctOperands = halstedMetrics.DistinctOperands;
limNode.DistinctOperators = halstedMetrics.DistinctOperators;
if (symbol.OverriddenMethod != null)
{
if (symbol.OverriddenMethod.IsInMetadata( ))
{
MainDeclaration.Instance
.OverrideRelations.AddOverride(
( Method )symbol.OverriddenMethod.ConvertToLimNode( ),
limNode
);
}
else
{
SyntaxNode dummyNode;
var asd = symbol.OverriddenMethod.GetDefinition(out dummyNode);
if (asd != null && asd.Kind == symbol.OverriddenMethod.Kind)
{
var overriddenMethodSymbol = ( Method )asd.ConvertToLimNode( );
MainDeclaration.Instance
.OverrideRelations.AddOverride(
overriddenMethodSymbol,
limNode
);
}
}
}
if (symbol.ContainingType.TypeKind == TypeKind.Interface)
{
Commons.Common.ChangeRealizationLevel(limNode);
}
if (symbol.PartialImplementationPart != null)
{
Commons.Common.ChangeRealizationLevel(limNode);
var method = symbol.PartialImplementationPart.IsGenericMethod
? SymbolBuilder.BuildDispatch <MethodGeneric, IMethodSymbol>(symbol.PartialImplementationPart)
: SymbolBuilder.BuildDispatch <Method, IMethodSymbol>(symbol.PartialImplementationPart);
method.NumberOfBranches = 0;
limNode.setDeclares(method.Id);
Commons.Common.FillFromMethodStack(MainDeclaration.Instance.MethodStack.Pop( ));
}
if (node.Kind( ) == SyntaxKind.ConstructorDeclaration)
{
var init = (( ConstructorDeclarationSyntax )node).Initializer;
if (init != null)
{
MainDeclaration.Instance.RoslynWatch.Start( );
var calleeSymbol = MainDeclaration.Instance.Model.GetSymbolInfo(init).Symbol;
MainDeclaration.Instance.RoslynWatch.Stop( );
if (calleeSymbol != null)
{
SyntaxNode calledCtor;
calleeSymbol.GetDefinition(out calledCtor);
EdgeBuilder.CreateMethodCallEdge(symbol, calleeSymbol);
if (calledCtor != null && calledCtor.Kind( ) == SyntaxKind.ConstructorDeclaration)
{
// if the called constructor doesn't exist in the code e.x.: default constructor
_crossEdgeFiller.ConstructorCallFiller(( ConstructorDeclarationSyntax )calledCtor, init);
}
}
}
}
MainDeclaration.Instance.LimOrigin.addCompIdCsharpIdLimIdToMap(MainDeclaration.Instance.Component.Id,
_map[node], limNode.Id);
node.CreateCommentNode(symbol);
visitor(node as T);
if (MainDeclaration.Instance.MethodStack.Count > 0)
{
Commons.Common.SetMetrics(node);
}
limNode.SetCLOC(node);
}
private void deletePotentialFloatingBlocks(int index3d, int chunkX, int chunkY, int chunkZ)
{
curVisitedNodes.Clear();
//blockAccessor.SetBlock(61, new BlockPos(dx + chunkX * chunksize, dy + chunkY * chunksize, dz + chunkZ * chunksize));
int baseX = chunkX * chunksize;
int baseY = chunkY * chunksize;
int baseZ = chunkZ * chunksize;
int dx = index3d % chunksize;
int dy = index3d / chunksize / chunksize;
int dz = (index3d / chunksize) % chunksize;
VisitNode basenode = new VisitNode(baseX + dx, baseY + dy, baseZ + dz);
if (chunkVisitedNodes.Contains(basenode))
{
return;
}
Queue <VisitNode> toVisit = new Queue <VisitNode>();
toVisit.Enqueue(basenode);
int foundBlocks = 0;
while (toVisit.Count > 0)
{
VisitNode node = toVisit.Dequeue();
foundBlocks++;
curVisitedNodes.Add(node);
for (int faceIndex = 0; faceIndex < BlockFacing.ALLFACES.Length; faceIndex++)
{
Vec3i vec = BlockFacing.ALLFACES[faceIndex].Normali;
VisitNode nnode = new VisitNode(node.X + vec.X, node.Y + vec.Y, node.Z + vec.Z);
if (curVisitedNodes.Contains(nnode))
{
continue;
}
if (chunkVisitedNodes.Contains(nnode))
{
return;
}
if (blockAccessor.GetBlockId(nnode.X, nnode.Y, nnode.Z) != 0)
{
toVisit.Enqueue(nnode);
}
}
if (curVisitedNodes.Count > 20)
{
foreach (var val in curVisitedNodes)
{
chunkVisitedNodes.Add(val);
}
return;
}
}
// We found a free floating section of blocks that's less that 10 blocks
if (curVisitedNodes.Count < 20)
{
foreach (VisitNode fnode in curVisitedNodes)
{
blockAccessor.SetBlock(0, new BlockPos(fnode.X, fnode.Y, fnode.Z));
}
}
}
/// <summary>
/// Breadth-first walk of the tree
/// </summary>
/// <param name="visit">Visit type delegate</param>
public void WalkTree(VisitNode visitNode, VisitEdge visitEdge)
{
Queue<Node> walkingQueue = new Queue<Node>();
for (walkingQueue.Enqueue(this.RootNode); walkingQueue.Count > 0; )
{
var currentNode = walkingQueue.Dequeue();
visitNode((int)currentNode.Label);
foreach (var edge in currentNode.Edges)
{
walkingQueue.Enqueue(edge.Value.EndNode);
visitEdge((int)currentNode.Label, (int)edge.Value.EndNode.Label, edge.Value.Start, NormalizeEndValue(edge.Value.End));
}
}
}
