Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 2004 Ondrej Lhotak
   *
   * This library is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
   * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 package soot;
 import java.io.File;
 import java.util.List;
 import java.util.Set;
 
Provides utility methods to retrieve an input stream for a class name, given a classfile, or jimple or baf output files.
 
 public class SourceLocator
 {
     public SourceLocatorSingletons.Global g ) {}
     public static SourceLocator v() { return G.v().soot_SourceLocator(); }
 
     protected Set<ClassLoaderadditionalClassLoaders = new HashSet<ClassLoader>();
 	protected Set<StringclassesToLoad;
    
    
Given a class name, uses the soot-class-path to return a ClassSource for the given class.
 
 	public ClassSource getClassSource(String className
     {
 		if(==null) {
 			for(SootClass c: Scene.v().getApplicationClasses()) {
 			}
 		}
     	
         if == null ) {
              = explodeClassPath(Scene.v().getSootClassPath());
         }
         if == null ) {
             setupClassProviders();
         }
         for (ClassProvider cp : ) {
 	        	ClassSource ret = cp.find(className);
 	            ifret != null ) return ret;
         }
         for(final ClassLoader cl) {
             	ClassSource ret = new ClassProvider() {
 					
 					public ClassSource find(String className) {
 				        String fileName = className.replace('.''/') + ".class";
 						InputStream stream = cl.getResourceAsStream(fileName);
 						if(stream==nullreturn null;
 						return new CoffiClassSource(classNamestream);
 					}
 
             	}.find(className);
 	            ifret != null ) return ret;
         }
         if(className.startsWith("soot.rtlib.tamiflex.")) {
 	        String fileName = className.replace('.''/') + ".class";
         	InputStream stream = getClass().getClassLoader().getResourceAsStream(fileName);
         	if(stream!=null) {
 				return new CoffiClassSource(classNamestream);
         	}
         }
         return null;
     }
     
     public void additionalClassLoader(ClassLoader c) {
     }
 
     private void setupClassProviders() {
          = new LinkedList<ClassProvider>();
                .add(new CoffiClassProvider());
    }
    public void setClassProvidersList<ClassProviderclassProviders ) {
        this. = classProviders;
    }
    private List<StringclassPath;
    public List<StringclassPath() { return ; }
    public void invalidateClassPath() {
         = null;
    }
    private List<StringsourcePath;
    public List<StringsourcePath() {
        if == null ) {
             = new ArrayList<String>();
            for (String dir : ) {
                if( !isJar(dir) ) .add(dir);
            }
        }
        return ;
    }
    private boolean isJar(String path) {
	File f = new File(path);	
	if(f.isFile() && f.canRead()) { 		
	    if(path.endsWith("zip") || path.endsWith("jar")) {
		return true;
	    } else {
		G.v()..println("Warning: the following soot-classpath entry is not a supported archive file (must be .zip or .jar): " + path);
	    }
	}  
	return false;
    }
    public List<StringgetClassesUnder(String aPath) {
        List<StringfileNames = new ArrayList<String>();
	if (isJar(aPath)) {
	    List inputExtensions = new ArrayList(2);
            inputExtensions.add(".class");
            inputExtensions.add(".jimple");
            inputExtensions.add(".java");
	    try {
		ZipFile archive = new ZipFile(aPath);
		for (Enumeration entries = archive.entries(); 
		     entries.hasMoreElements(); ) {
		    ZipEntry entry = (ZipEntryentries.nextElement();
		    String entryName = entry.getName();
		    int extensionIndex = entryName.lastIndexOf('.');
		    if (extensionIndex >= 0) {
			String entryExtension = entryName.substring(extensionIndex);
			if (inputExtensions.contains(entryExtension)) {
			    entryName = entryName.substring(0, extensionIndex);
			    entryName = entryName.replace('/''.');
			    fileNames.add(entryName);
			}
		    }
		}
	    } catch(IOException e) {
		G.v()..println("Error reading " + aPath + ": " 
				  + e.toString());
	    }
else {
	    File file = new File(aPath);
	    File[] files = file.listFiles();
	    if (files == null) {
		files = new File[1];
		files[0] = file;
	    }
	    for (File element : files) {
		if (element.isDirectory()) {
		    List<Stringl =
					aPath + . + element.getName());
		    Iterator<Stringit = l.iterator();
		    while (it.hasNext()) {
			String s = it.next();
			fileNames.add(element.getName() + "." + s);
		    }
else {
		    String fileName = element.getName();
		    if (fileName.endsWith(".class")) {
			int index = fileName.lastIndexOf(".class");
			fileNames.add(fileName.substring(0, index));
		    }
		    if (fileName.endsWith(".jimple")) {
			int index = fileName.lastIndexOf(".jimple");
			fileNames.add(fileName.substring(0, index));
		    }
		    if (fileName.endsWith(".java")) {
			int index = fileName.lastIndexOf(".java");
			fileNames.add(fileName.substring(0, index));
		    }
		}
	    }
	}
        return fileNames;
    }
    public String getFileNameFor(SootClass cint rep) {
        if (rep == .)
            return null;
        StringBuffer b = new StringBuffer();
        if( !Options.v().output_jar() ) {
            b.append(getOutputDir());
        }
        if ((b.length() > 0) && (b.charAt(b.length() - 1) != .))
            b.append(.);
        if (rep != .) {
            if(rep == .) {
                b.append(c.getName().replace('.'.));
            } else if(rep == .) {
                b.append(c.getName().replace('.''_'));
                b.append("_Maker");
            } else {
                b.append(c.getName());
            }
            b.append(getExtensionFor(rep));
            return b.toString();
        }
        return getDavaFilenameFor(cb);
    }
    
		b.append("dava");
        b.append(.);
        {
            String classPath = b.toString() + "classes";
            File dir = new File(classPath);
            if (!dir.exists())
                try {
                    dir.mkdirs();
                } catch (SecurityException se) {
                    G.v()..println("Unable to create " + classPath);
                    throw new CompilationDeathException(.);
                }
        }
        b.append("src");
        b.append(.);
        String fixedPackageName = c.getJavaPackageName();
        if (fixedPackageName.equals("") == false) {
            b.append(fixedPackageName.replace('.'.));
            b.append(.);
        }
        {
            String path = b.toString();
            File dir = new File(path);
            if (!dir.exists())
                try {
                    dir.mkdirs();
                } catch (SecurityException se) {
                    G.v()..println("Unable to create " + path);
                    throw new CompilationDeathException(.);
                }
        }
        b.append(c.getShortJavaStyleName());
        b.append(".java");
        return b.toString();
	}
    /* This is called after sootClassPath has been defined. */
    public Set<StringclassesInDynamicPackage(String str) {
        HashSet<Stringset = new HashSet<String>(0);
        StringTokenizer strtok = new StringTokenizer(
                Scene.v().getSootClassPath(), String.valueOf(.));
        while (strtok.hasMoreTokens()) {
            String path = strtok.nextToken();
            // For jimple files
            List<Stringl = getClassesUnder(path);
            for (String filename : l) {
                if (filename.startsWith(str))
                    set.add(filename);
            }
            // For class files;
            path = path + .;
            StringTokenizer tokenizer = new StringTokenizer(str".");
            while (tokenizer.hasMoreTokens()) {
                path = path + tokenizer.nextToken();
                if (tokenizer.hasMoreTokens())
                    path = path + .;
            }
            l = getClassesUnder(path);
            for (String string : l)
				set.add(str + "." + string);
        }
        return set;
    }
    public String getExtensionFor(int rep) {
        switch (rep) {
            case .:      return ".baf";
            case .:        return ".b";
            case .:   return ".jimple";
            case .:     return ".jimp";
            case .:  return ".shimple";
            case .:    return ".shimp";
            case .:    return ".grimp";
            case .:  return ".grimple";
            case .:    return ".class";
            case .:     return ".java";
            case .:   return ".jasmin";
            case .:      return ".xml";
            case .return ".java";
            default:
                throw new RuntimeException();
        }
    }
    public String getOutputDir() {
        String ret = Options.v().output_dir();
        ifret.length() == 0 ) ret = "sootOutput";
        File dir = new File(ret);
        if (!dir.exists()) {
            try {
                if( !Options.v().output_jar() ) {
                    dir.mkdirs();
                }
            } catch (SecurityException se) {
                G.v()..println("Unable to create " + ret);
                throw new CompilationDeathException(.);
            }
        }
        return ret;
    }

    
Explodes a class path into a list of individual class path entries.
    protected List<StringexplodeClassPathString classPath ) {
        List<Stringret = new ArrayList<String>();
        StringTokenizer tokenizer = 
            new StringTokenizer(classPath.);
        whiletokenizer.hasMoreTokens() ) {
            String originalDir = tokenizer.nextToken();
            String canonicalDir;
            try {
                canonicalDir = new File(originalDir).getCanonicalPath();
                ret.add(canonicalDir);
            } catchIOException e ) {
                throw new CompilationDeathException"Couldn't resolve classpath entry "+originalDir+": "+e );
            }
        }
        return ret;
    }
    public static class FoundFile {
        FoundFileZipFile zipFileZipEntry entry ) {
            this. = zipFile;
            this. = entry;
        }
        FoundFileFile file ) {
            this. = file;
        }
        public File file;
        public ZipFile zipFile;
        public ZipEntry entry;
        public InputStream inputStream() {
            try {
                if != null ) return new FileInputStream();
                return doJDKBugWorkaround(.getInputStream(),
                        .getSize());
            } catchIOException e ) {
                throw new RuntimeException"Caught IOException "+e );
            }
        }
    }
    private static InputStream doJDKBugWorkaround(InputStream islong sizethrows IOException {
	int sz = (intsize;
	byte[] buf = new byte[sz];					
				    
	final int N = 1024;
	int ln = 0;
	int count = 0;
	while (sz > 0 &&  
	       (ln = is.read(bufcount, Math.min(Nsz))) != -1) {
	    count += ln;
	    sz -= ln;
	}
	return  new ByteArrayInputStream(buf);		
    }


    
Searches for a file with the given name in the exploded classPath.
    public FoundFile lookupInClassPathString fileName ) {
        for (String dir : ) {
            FoundFile ret;
            if(isJar(dir)) {
                ret = lookupInJar(dirfileName);
            } else {
                ret = lookupInDir(dirfileName);
            }
            ifret != null ) return ret;
        }
        return null;
    }
    private FoundFile lookupInDir(String dirString fileName) {
        File f = new Filedir+.+fileName );
        iff.canRead() ) {
            return new FoundFile(f);
        }
        return null;
    }
    private FoundFile lookupInJar(String jarString fileName) {
        try {
            ZipFile jarFile = new ZipFile(jar);
            ZipEntry entry = jarFile.getEntry(fileName);
            ifentry == null ) return null;
            return new FoundFile(jarFileentry);
        } catchIOException e ) {
            throw new RuntimeException"Caught IOException "+e+" looking in jar file "+jar+" for file "+fileName );
        }
    }
        return ;
    }
    public void setSourceToClassMap(HashMap<StringStringmap){
         = map;
    }
    public void addToSourceToClassMap(String keyString val) {
        .put(keyval);
    }
    
Returns the name of the class in which the (possibly inner) class className appears.
    public String getSourceForClassString className ) {
        String javaClassName = className;
        if (className.indexOf("$") != -1) {
            // class is an inner class and will be in
            // Outer of Outer$Inner
            javaClassName = className.substring(0, className.indexOf("$"));
            //System.out.println("cut off inner class: look for: "+javaClassName);
        }
        // always do this because an inner class could be in a class
        // thats in the map
        if ( != null) {
            //System.out.println("in source map: "+sourceToClassMap);
            if (.get(javaClassName) != null) {
                javaClassName = .get(javaClassName);
            }
        }
        return javaClassName;
    }
New to GrepCode? Check out our FAQ X