public void addScopedEntity(CAstNode construct, CAstEntity child) { if (!scopedEntities.containsKey(construct)) { Collection<CAstEntity> set = HashSetFactory.make(1); scopedEntities.put(construct, set); } scopedEntities.get(construct).add(child); } }
@Override public Collection<IField> getDeclaredStaticFields() { Set<IField> result = HashSetFactory.make(); for (IField F : declaredFields.values()) { if (F.isStatic()) { result.add(F); } } return result; }
static Collection<Annotation> getAnnotations(Collection<org.jf.dexlib2.iface.Annotation> as, ClassLoaderReference clr) { Collection<Annotation> result = HashSetFactory.make(); for(org.jf.dexlib2.iface.Annotation a : as) { result.add(getAnnotation(a, clr)); } return result; }
@Override public Collection<IField> getDeclaredInstanceFields() { Set<IField> result = HashSetFactory.make(); for (IField F : declaredFields.values()) { if (!F.isStatic()) { result.add(F); } } return result; }
@Override public Iterator<ModuleEntry> getEntries() { HashSet<ModuleEntry> result = HashSetFactory.make(); for (Enumeration e = file.entries(); e.hasMoreElements();) { ZipEntry Z = (ZipEntry) e.nextElement(); result.add(createEntry(Z)); } return result.iterator(); }
@Override public Collection<IField> getAllFields() { Collection<IField> result = HashSetFactory.make(); result.addAll(getAllInstanceFields()); result.addAll(getAllStaticFields()); return result; }
@Override public IClassLoader[] getLoaders() { Set<IClassLoader> loaders = HashSetFactory.make(); for (ClassLoaderReference loaderReference : analysisScope.getLoaders()) { loaders.add(getLoader(loaderReference)); } return loaders.toArray(new IClassLoader[0]); }
private static Set<CodeElement> getStaticFieldAccessCodeElts(SSAFieldAccessInstruction inst) { Set<CodeElement> elts = HashSetFactory.make(); final FieldReference fieldRef = inst.getDeclaredField(); elts.add(new StaticFieldElement(fieldRef)); // TODO: what about tainting the declaring class? return elts; }
@Override public Set<CGNode> getNodes(MethodReference m) { Set<CGNode> result = HashSetFactory.make(); for (CGNode x : cg.getNodes(m)) { if (containsNode(x)) { result.add(x); } } return result; }
@Override public Iterator<T> getSuccNodes(T N) { Collection<T> succs = HashSetFactory.make(); for (U label : nodeToSuccLabels.get(N)) { succs.addAll(Iterator2Collection.toSet(getSuccNodes(N, label))); } return succs.iterator(); }
@Override public Iterator<T> getSuccNodes(T N) { Collection<T> succs = HashSetFactory.make(); for (U label : nodeToSuccLabels.get(N)) { succs.addAll(Iterator2Collection.toSet(getSuccNodes(N, label))); } return succs.iterator(); }
/** * Compute the set of {@link PointerKey}s that represent pointers that instruction s may read. */ public Set<PointerKey> getRef(CGNode n, ExtendedHeapModel h, PointerAnalysis<T> pa, SSAInstruction s, HeapExclusions hexcl) { if (s == null) { throw new IllegalArgumentException("s is null"); } Set<PointerKey> result = HashSetFactory.make(2); RefVisitor v = makeRefVisitor(n, result, pa, h); s.visit(v); return hexcl == null ? result : hexcl.filter(result); }
/** * Get all non-constructor, non-class-initializer methods declared by a class */ private static Collection<IMethod> getDeclaredNormalMethods(IClass cls) { Collection<IMethod> result = HashSetFactory.make(); for (IMethod m : cls.getDeclaredMethods()) { if (!m.isInit() && !m.isClinit()) { result.add(m); } } return result; }
@Override public Collection<? extends IMethod> getAllMethods() { Collection<IMethod> result = HashSetFactory.make(); result.addAll(getDeclaredMethods()); if (getSuperclass() != null) { result.addAll(getSuperclass().getAllMethods()); } return result; }
public static CrossLanguageClassHierarchy make(AnalysisScope scope, ClassLoaderFactory factory) throws ClassHierarchyException { Set<Language> languages = scope.getBaseLanguages(); Map<Atom, IClassHierarchy> hierarchies = HashMapFactory.make(); for (Language L : languages) { Set<Language> ll = HashSetFactory.make(L.getDerivedLanguages()); ll.add(L); hierarchies.put(L.getName(), ClassHierarchyFactory.make(scope, factory, ll)); } return new CrossLanguageClassHierarchy(scope, factory, hierarchies); }
public void addAllCallbacks(Set<Function<Object, Object>> callback) { if (!hasAllCallbacks(callbacks)) { if (callbacks == null) { callbacks = HashSetFactory.make(1); } callbacks.addAll(callback); for (CGNode p : Iterator2Iterable.make(getCallGraph().getPredNodes(this))) { ((AstCGNode) p).addAllCallbacks(callback); } } }
@Override public Collection<IClass> getAllImplementedInterfaces() { HashSet<IClass> result = HashSetFactory.make(2); for (TypeReference ref : getClassLoader().getLanguage().getArrayInterfaces()) { IClass klass = loader.lookupClass(ref.getName()); if (klass != null) { result.add(klass); } } return result; }
private Set<ISinkPoint> calculateSinkPoints(StaticFieldSinkSpec sinkSpec) { Set<ISinkPoint> points = HashSetFactory.make(); ICFGSupergraph graph = (ICFGSupergraph) ctx.graph; for (CGNode node : ctx.cg.getNodes(sinkSpec.getMethod().getReference())) { points.add(new StaticFieldSinkPoint(sinkSpec, graph.getICFG() .getExit(node))); } return points; }
private Set<Pair<String,Integer>> map(Set<Pair<CGNode, NewSiteReference>> sites) { Set<Pair<String,Integer>> result = HashSetFactory.make(); for(Pair<CGNode,NewSiteReference> s : sites) { result.add(Pair.make(s.fst.getMethod().toString(), s.snd.getProgramCounter())); } return result; }
@Override public Iterator<MethodReference> getPredNodes(MethodReference N) { Set<MethodReference> pred = HashSetFactory.make(10); MethodReference methodReference = N; for (CGNode cgNode : cg.getNodes(methodReference)) for (CGNode p : Iterator2Iterable.make(cg.getPredNodes(cgNode))) pred.add(p.getMethod().getReference()); return pred.iterator(); }