/// <summary> /// Method contains member(s) /// </summary> /// <param name="currentmethodId">LIM method node's id</param> /// <returns>Return true if method contains member(s)</returns> private static bool CheckAnonyumousEmbeddedness(uint currentmethodId) { bool innerClass = false; if (MainDeclaration.Instance.ClassStack.Count > 0) { uint step = MainDeclaration.Instance.ClassStack.Peek().Id; while (true) { ListIterator <Base> i = MainDeclaration.Instance.RevEdges.constIteratorBegin(step, Types.EdgeKind.edkScope_HasMember); if (i.getValue() == null) { break; } step = i.getValue().Id; if (step == currentmethodId) { innerClass = true; break; } } } return(innerClass); }
/// <summary> /// Aggregate LLOC to the component /// </summary> /// <param name="NodeId">LIM node id</param> /// <param name="pathKey">Path hash code</param> /// <param name="line">Start line position</param> private static void AddLogicalLineOfComponent(uint NodeId, uint pathKey, uint line) { if (line > 0) { MainDeclaration.Instance.LLOCMap.Add(NodeId, pathKey, line); ListIterator <Base> itBegin = MainDeclaration.Instance.RevEdges.constIteratorBegin(NodeId, Types.EdgeKind.edkComponent_Contains); while (itBegin.getValue() != null) { AddLogicalLineOfComponent(itBegin.getValue().Id, pathKey, line); itBegin = itBegin.getNext(); } } }
public static ulong Calculate(Lim.Asg.Nodes.Logical.Scope limScope, ref List <Interval> intervals) { ulong TLOC = 0; if (limScope.Factory.getFilterState(limScope.Id) == Lim.Asg.Filter.FilterState.Filtered) { return(0); } // The root package does not have all the isContainedIn edges // So we calculate its TLOC by the sum of its child package's TLOC // Subpackages are not physically inside their parent Packages // ( unlike e.g. local or anonym classes inside other classes ) // So the TLOC of a Package is computed recursively if (Lim.Asg.Common.getIsPackage(limScope)) { ListIterator <Lim.Asg.Nodes.Logical.Member> subPackageIt = limScope.HasMemberListIteratorBegin; while (subPackageIt.getValue() != null) { Lim.Asg.Nodes.Logical.Member subPackage = subPackageIt.getValue(); if (!Lim.Asg.Common.getIsPackage(subPackage)) { subPackageIt = subPackageIt.getNext(); continue; } Lim.Asg.Nodes.Logical.Package _subPackage = subPackage as Lim.Asg.Nodes.Logical.Package; TLOC += Calculate(_subPackage, ref intervals); subPackageIt = subPackageIt.getNext(); } } ListIteratorAssocSourcePosition <File> sourcePositionInFileBeginIt = limScope.IsContainedInListIteratorAssocBegin; for (var fileIt = sourcePositionInFileBeginIt.getValue(); fileIt != null; fileIt = sourcePositionInFileBeginIt.getNext().getValue()) { var pos = sourcePositionInFileBeginIt.getAssocItem(); var i = new Interval { Key = limScope.Factory.StringTable.set(Lim.Asg.Common.GetFullPath(fileIt)), From = pos.Line, To = pos.EndLine }; intervals.Add(i); TLOC += i.To - i.From + 1; } return(TLOC); }
/// <summary> /// Check Root component node contains the actual component /// </summary> /// <returns></returns> private static bool GetAlreadyContain(Component node) { bool alreadyContain = false; ListIterator <Component> it = MainDeclaration.Instance.LimFactory.ComponentRootRef.ContainsListIteratorBegin; while (it.getValue() != null) { Component comp = it.getValue(); if (comp.Id == node.Id) { alreadyContain = true; break; } it = it.getNext(); } return(alreadyContain); }
private static void MergeTLLOC(ref Scope limScope, ref Dictionary <uint, HashSet <uint> > TLLOC_Scope) { if (MainDeclaration.Instance.LLOCMap.ContainsKey(limScope.Id)) { var TLLOC_ofScope = MainDeclaration.Instance.LLOCMap[limScope.Id]; MergePathLineMaps(ref TLLOC_Scope, ref TLLOC_ofScope); } ListIterator <Member> it = limScope.HasMemberListIteratorBegin; while (it.getValue() != null) { Member memberIt = it.getValue(); if (Lim.Asg.Common.getIsScope(memberIt)) { Scope memberItScope = memberIt as Scope; MergeTLLOC(ref memberItScope, ref TLLOC_Scope); } it = it.getNext(); } }
public static void fillCollectedMethodData(Method method, MethodInfo methodInfo) { method.NestingLevel = (ushort)methodInfo.NL; method.NestingLevelElseIf = (ushort)methodInfo.NLE; method.NumberOfBranches = (ushort)methodInfo.NOB; method.NumberOfStatements = (ushort)methodInfo.NOS; foreach (KeyValuePair <uint, bool> call in methodInfo.Calls) { if (call.Value) { MainDeclaration.Instance.LimFactory.setFiltered(call.Key); } Commons.Common.Safe_Edge(method, "Calls", call.Key); } foreach (KeyValuePair <uint, bool> throws in methodInfo.Throws) { if (throws.Value) { MainDeclaration.Instance.LimFactory.setFiltered(throws.Key); } Commons.Common.Safe_Edge(method, "Throws", throws.Key); } foreach (KeyValuePair <uint, bool> canThrows in methodInfo.CanThrow) { if (canThrows.Value) { MainDeclaration.Instance.LimFactory.setFiltered(canThrows.Key); } Commons.Common.Safe_Edge(method, "CanThrow", canThrows.Key); } foreach (KeyValuePair <uint, bool> instantiates in methodInfo.Instantiates) { if (instantiates.Value) { MainDeclaration.Instance.LimFactory.setFiltered(instantiates.Key); } Commons.Common.Safe_Edge(method, "Instantiates", instantiates.Key); } foreach (KeyValuePair <uint, bool> accessAttribute in methodInfo.AccessAttribute) { if (accessAttribute.Value) { MainDeclaration.Instance.LimFactory.setFiltered(accessAttribute.Key); } Commons.Common.Safe_Edge(method, "AccessesAttribute", accessAttribute.Key); } if (!method.ReturnsIsEmpty) { Lim.Asg.Nodes.Type.Type returnType = method.ReturnsListIteratorBegin.getValue(); if (returnType != null) { MainDeclaration.Instance.UsesStack.Peek().Remove(returnType.Id); } } if (!method.HasParameterIsEmpty) { ListIterator <Lim.Asg.Nodes.Logical.Parameter> paramIt = method.HasParameterListIteratorBegin; while (paramIt.getValue() != null) { MainDeclaration.Instance.UsesStack.Peek().Remove(paramIt.getValue().getHasType()); paramIt = paramIt.getNext(); } } IEnumerable <uint> _throws = methodInfo.Throws.Select(t => t.Key); IEnumerable <uint> _canThrows = methodInfo.CanThrow.Select(t => t.Key); IEnumerable <uint> _instantiates = methodInfo.Instantiates.Select(t => t.Key); Commons.Common.Remove(ref _throws); Commons.Common.Remove(ref _canThrows); Commons.Common.Remove(ref _instantiates); Commons.Common.AddUses(method); }