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