public Iterable<JavaFileObject> list(
Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
// System.out.println("list(" + location + ',' + packageName + ',' + kinds + ',' + recurse +
// ')');
return fileManager.list(location, packageName, kinds, recurse);
}
public Iterable<JavaFileObject> list(
Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
return standardJavaFileManager.list(location, packageName, kinds, recurse);
}
void createSymbols() throws IOException {
Set<String> legacy = getLegacyPackages();
Set<String> legacyProprietary = getLegacyPackages();
Set<String> documented = new HashSet<String>();
Set<PackageSymbol> packages =
((JavacProcessingEnvironment) processingEnv).getSpecifiedPackages();
String jarName = processingEnv.getOptions().get("com.sun.tools.javac.sym.Jar");
if (jarName == null)
throw new RuntimeException("Must use -Acom.sun.tools.javac.sym.Jar=LOCATION_OF_JAR");
String destName = processingEnv.getOptions().get("com.sun.tools.javac.sym.Dest");
if (destName == null)
throw new RuntimeException("Must use -Acom.sun.tools.javac.sym.Dest=LOCATION_OF_JAR");
for (PackageSymbol psym : packages) {
String name = psym.getQualifiedName().toString();
legacyProprietary.remove(name);
documented.add(name);
}
JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null);
Location jarLocation = StandardLocation.locationFor(jarName);
File jarFile = new File(jarName);
fm.setLocation(jarLocation, List.of(jarFile));
fm.setLocation(StandardLocation.CLASS_PATH, List.<File>nil());
fm.setLocation(StandardLocation.SOURCE_PATH, List.<File>nil());
{
ArrayList<File> bootClassPath = new ArrayList<File>();
bootClassPath.add(jarFile);
for (File path : fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH)) {
if (!new File(path.getName()).equals(new File("rt.jar"))) bootClassPath.add(path);
}
System.err.println("Using boot class path = " + bootClassPath);
fm.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
}
// System.out.println(fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH));
File destDir = new File(destName);
if (!destDir.exists())
if (!destDir.mkdirs()) throw new RuntimeException("Could not create " + destDir);
fm.setLocation(StandardLocation.CLASS_OUTPUT, List.of(destDir));
Set<String> hiddenPackages = new HashSet<String>();
Set<String> crisp = new HashSet<String>();
List<String> options = List.of("-XDdev");
// options = options.prepend("-doe");
// options = options.prepend("-verbose");
JavacTaskImpl task = (JavacTaskImpl) tool.getTask(null, fm, null, options, null, null);
com.sun.tools.javac.main.JavaCompiler compiler =
com.sun.tools.javac.main.JavaCompiler.instance(task.getContext());
ClassReader reader = ClassReader.instance(task.getContext());
ClassWriter writer = ClassWriter.instance(task.getContext());
Symtab syms = Symtab.instance(task.getContext());
Attribute.Compound proprietary =
new Attribute.Compound(
syms.proprietaryType, List.<Pair<Symbol.MethodSymbol, Attribute>>nil());
Type.moreInfo = true;
Pool pool = new Pool();
for (JavaFileObject file : fm.list(jarLocation, "", EnumSet.of(CLASS), true)) {
String className = fm.inferBinaryName(jarLocation, file);
int index = className.lastIndexOf('.');
String pckName = index == -1 ? "" : className.substring(0, index);
boolean addLegacyAnnotation = false;
if (documented.contains(pckName)) {
if (!legacy.contains(pckName)) crisp.add(pckName);
// System.out.println("Documented: " + className);
} else if (legacyProprietary.contains(pckName)) {
addLegacyAnnotation = true;
// System.out.println("Legacy proprietary: " + className);
} else {
// System.out.println("Hidden " + className);
hiddenPackages.add(pckName);
continue;
}
TypeSymbol sym = (TypeSymbol) compiler.resolveIdent(className);
if (sym.kind != Kinds.TYP) {
if (className.indexOf('$') < 0) {
System.err.println("Ignoring (other) " + className + " : " + sym);
System.err.println(" " + sym.getClass().getSimpleName() + " " + sym.type);
}
continue;
}
sym.complete();
if (sym.getEnclosingElement().getKind() != ElementKind.PACKAGE) {
System.err.println("Ignoring (bad) " + sym.getQualifiedName());
continue;
}
ClassSymbol cs = (ClassSymbol) sym;
if (addLegacyAnnotation) {
cs.attributes_field =
(cs.attributes_field == null)
? List.of(proprietary)
: cs.attributes_field.prepend(proprietary);
}
writeClass(pool, cs, writer);
}
if (false) {
for (String pckName : crisp) System.out.println("Crisp: " + pckName);
for (String pckName : hiddenPackages) System.out.println("Hidden: " + pckName);
for (String pckName : legacyProprietary) System.out.println("Legacy proprietary: " + pckName);
for (String pckName : documented) System.out.println("Documented: " + pckName);
}
}
private List<JavaFileObject> findInside(
Location location, String packageName, Set<JavaFileObject.Kind> kinds, boolean lookForFile)
throws IOException {
Iterable<? extends File> path = getLocation(location);
if (path == null) return Collections.emptyList();
String subdirectory = packageName.replace('.', '/');
List<JavaFileObject> results = null;
for (File directory : path) {
VirtualFile dir = LocalFileSystem.getInstance().findFileByIoFile(directory);
if (dir == null) continue;
if (!dir.isDirectory()) {
dir = JarFileSystem.getInstance().getJarRootForLocalFile(dir);
if (dir == null) continue;
}
VirtualFile virtualFile =
StringUtil.isEmptyOrSpaces(subdirectory) ? dir : dir.findFileByRelativePath(subdirectory);
if (virtualFile == null) continue;
VirtualFile[] children;
if (lookForFile) {
if (!virtualFile.isDirectory()) {
children = new VirtualFile[] {virtualFile};
} else continue;
} else {
children = virtualFile.getChildren();
}
for (VirtualFile child : children) {
JavaFileObject.Kind kind = getKind("." + child.getExtension());
if (kinds == null || kinds.contains(kind)) {
if (results == null) results = new SmartList<JavaFileObject>();
if (kind == JavaFileObject.Kind.SOURCE && child.getFileSystem() instanceof JarFileSystem)
continue; // for some reasdon javac looks for java files inside jar
// use VFS to read content inside .jar
String childPath = child.getPath();
JavaFileObject fileObject =
!childPath.contains("!/")
? new JavaIoFile(new File(childPath), kind, myEncoding)
: new JavaVirtualFile(child, kind);
results.add(fileObject);
}
}
}
List<JavaFileObject> ret = results == null ? Collections.<JavaFileObject>emptyList() : results;
if (LOG.isDebugEnabled()) {
// for testing consistency
Collection c = (Collection) myStandardFileManager.list(location, packageName, kinds, false);
Collection<JavaFileObject> sup = new HashSet(c);
assert sup.size() == c.size();
assert new HashSet(c).equals(sup);
THashSet<JavaFileObject> s =
new THashSet<JavaFileObject>(
new TObjectHashingStrategy<JavaFileObject>() {
public int computeHashCode(JavaFileObject object) {
return object.getName().hashCode();
}
public boolean equals(JavaFileObject o1, JavaFileObject o2) {
return o1.getKind() == o2.getKind() && o1.toUri().equals(o2.toUri());
}
});
s.addAll(ret);
s.removeAll(sup);
if (ret.size() != sup.size()) {
assert false : "our implementation differs from javac'";
}
}
return ret;
}