public SootField grabField(String fieldSignature) { String cname = signatureToClass(fieldSignature); String fname = signatureToSubsignature(fieldSignature); if (!containsClass(cname)) { return null; } SootClass c = getSootClass(cname); return c.getFieldUnsafe(fname); }
public SootMethod grabMethod(String methodSignature) { String cname = signatureToClass(methodSignature); String mname = signatureToSubsignature(methodSignature); if (!containsClass(cname)) { return null; } SootClass c = getSootClass(cname); return c.getMethodUnsafe(mname); }
private void constantForName(String cls, SootMethod src, Stmt srcUnit) { if (cls.length() > 0 && cls.charAt(0) == '[') { if (cls.length() > 1 && cls.charAt(1) == 'L' && cls.charAt(cls.length() - 1) == ';') { cls = cls.substring(2, cls.length() - 1); constantForName(cls, src, srcUnit); } } else { if (!Scene.v().containsClass(cls)) { if (options.verbose()) { logger.warn("Class " + cls + " is" + " a dynamic class, and you did not specify" + " it as such; graph will be incomplete!"); } } else { SootClass sootcls = Scene.v().getSootClass(cls); if (!sootcls.isPhantomClass()) { if (!sootcls.isApplicationClass()) { sootcls.setLibraryClass(); } for (SootMethod clinit : EntryPoints.v().clinitsOf(sootcls)) { addEdge(src, srcUnit, clinit, Kind.CLINIT); } } } } }
@Override final public void caseStringConstant(StringConstant sc) { AllocNode stringConstant; if (pag.getOpts().string_constants() || Scene.v().containsClass(sc.value) || (sc.value.length() > 0 && sc.value.charAt(0) == '[')) { stringConstant = pag.makeStringConstantNode(sc.value); } else { stringConstant = pag.makeAllocNode(PointsToAnalysis.STRING_NODE, rtStringType, null); } VarNode stringConstantLocal = pag.makeGlobalVarNode(stringConstant, rtStringType); pag.addEdge(stringConstant, stringConstantLocal); setResult(stringConstantLocal); }
if (!Scene.v().containsClass(constant)) { if (options.verbose()) { logger.debug("" + "Warning: Class " + constant + " is" + " a dynamic class, and you did not specify"
private Set<SootMethod> inferSource(String source, int lineNumber) { String className = source.substring(0, source.lastIndexOf(".")); String methodName = source.substring(source.lastIndexOf(".") + 1); if (!Scene.v().containsClass(className)) { Scene.v().addBasicClass(className, SootClass.BODIES); Scene.v().loadBasicClasses(); if (!Scene.v().containsClass(className)) { throw new RuntimeException("Trace file refers to unknown class: " + className);
/** * Adds the given class to the Scene. This method does not handle any dependencies such as invalidating the hierarchy. The * class is neither marked as application class, nor library class. * * @param c * The class to add */ protected void addClassSilent(SootClass c) { if (c.isInScene()) { throw new RuntimeException("already managed: " + c.getName()); } if (containsClass(c.getName())) { throw new RuntimeException("duplicate class: " + c.getName()); } classes.add(c); nameToClass.put(c.getName(), c.getType()); c.getType().setSootClass(c); c.setInScene(true); // Phantom classes are not really part of the hierarchy anyway, so // we can keep the old one if (!c.isPhantom) { modifyHierarchy(); } }
/** * Returns a (possibly not yet resolved) SootClass to be used in references to a class. If/when the class is resolved, it * will be resolved into this SootClass. */ public SootClass makeClassRef(String className) { if (Scene.v().containsClass(className)) { return Scene.v().getSootClass(className); } SootClass newClass; newClass = new SootClass(className); newClass.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(newClass); return newClass; }
if (!Scene.v().containsClass(sootTypeName)) { if (st instanceof PrimType || st instanceof VoidType || systemAnnotationNames.contains(sootTypeName)) {
/** * @apilevel internal */ private SootClass sootClass_compute() { if(!Scene.v().isIncrementalBuild()) { return refined_EmitJimpleRefinements_ClassDecl_sootClass(); } if(Scene.v().containsClass(jvmName())) { Scene.v().removeClass(Scene.v().getSootClass(jvmName())); } SootClass sc = null; if(options().verbose()) System.out.println("Creating from source " + jvmName()); sc = new SootClass(jvmName()); sc.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(sc); return sc; } /**
if(Scene.v().containsClass(jvmName())) { SootClass cl = Scene.v().getSootClass(jvmName());
private void constantForName( String cls, SootMethod src, Stmt srcUnit ) { if( cls.length() > 0 && cls.charAt(0) == '[' ) { if( cls.length() > 1 && cls.charAt(1) == 'L' && cls.charAt(cls.length()-1) == ';' ) { cls = cls.substring(2,cls.length()-1); constantForName( cls, src, srcUnit ); } } else { if( !Scene.v().containsClass( cls ) ) { if( options.verbose() ) { G.v().out.println( "Warning: Class "+cls+" is"+ " a dynamic class, and you did not specify"+ " it as such; graph will be incomplete!" ); } } else { SootClass sootcls = Scene.v().getSootClass( cls ); if( !sootcls.isApplicationClass() ) { sootcls.setLibraryClass(); } for (SootMethod clinit : EntryPoints.v().clinitsOf(sootcls)) { addEdge( src, srcUnit, clinit, Kind.CLINIT ); } } } }
private SootField grabField(String fieldSignature) { String cname = signatureToClass( fieldSignature ); String fname = signatureToSubsignature( fieldSignature ); if( !containsClass(cname) ) return null; SootClass c = getSootClass(cname); if( !c.declaresField( fname ) ) return null; return c.getField( fname ); }
private SootField grabField(String fieldSignature) { String cname = signatureToClass( fieldSignature ); String fname = signatureToSubsignature( fieldSignature ); if( !containsClass(cname) ) return null; SootClass c = getSootClass(cname); if( !c.declaresField( fname ) ) return null; return c.getField( fname ); }
private SootMethod grabMethod(String methodSignature) { String cname = signatureToClass( methodSignature ); String mname = signatureToSubsignature( methodSignature ); if( !containsClass(cname) ) return null; SootClass c = getSootClass(cname); if( !c.declaresMethod( mname ) ) return null; return c.getMethod( mname ); }
private SootMethod grabMethod(String methodSignature) { String cname = signatureToClass( methodSignature ); String mname = signatureToSubsignature( methodSignature ); if( !containsClass(cname) ) return null; SootClass c = getSootClass(cname); if( !c.declaresMethod( mname ) ) return null; return c.getMethod( mname ); }
public void addClass(SootClass c) { if(c.isInScene()) throw new RuntimeException("already managed: "+c.getName()); if(containsClass(c.getName())) throw new RuntimeException("duplicate class: "+c.getName()); classes.add(c); c.setLibraryClass(); nameToClass.put(c.getName(), c.getType()); c.getType().setSootClass(c); c.setInScene(true); modifyHierarchy(); }
public void addClass(SootClass c) { if(c.isInScene()) throw new RuntimeException("already managed: "+c.getName()); if(containsClass(c.getName())) throw new RuntimeException("duplicate class: "+c.getName()); classes.add(c); c.setLibraryClass(); nameToClass.put(c.getName(), c.getType()); c.getType().setSootClass(c); c.setInScene(true); modifyHierarchy(); }
/** Returns a (possibly not yet resolved) SootClass to be used in references * to a class. If/when the class is resolved, it will be resolved into this * SootClass. * */ public SootClass makeClassRef(String className) { if(Scene.v().containsClass(className)) return Scene.v().getSootClass(className); SootClass newClass; newClass = new SootClass(className); newClass.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(newClass); return newClass; }
/** Returns a (possibly not yet resolved) SootClass to be used in references * to a class. If/when the class is resolved, it will be resolved into this * SootClass. * */ public SootClass makeClassRef(String className) { if(Scene.v().containsClass(className)) return Scene.v().getSootClass(className); SootClass newClass; newClass = new SootClass(className); newClass.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(newClass); return newClass; }