/** Create a new round. */
private Round(
Round prev, Set<JavaFileObject> newSourceFiles, Map<String, JavaFileObject> newClassFiles) {
this(prev.nextContext(), prev.number + 1, prev.nMessagerErrors, prev.compiler.log.nwarnings);
this.genClassFiles = prev.genClassFiles;
List<JCCompilationUnit> parsedFiles = compiler.parseFiles(newSourceFiles);
roots = cleanTrees(prev.roots).appendList(parsedFiles);
// Check for errors after parsing
if (unrecoverableError()) return;
enterClassFiles(genClassFiles);
List<ClassSymbol> newClasses = enterClassFiles(newClassFiles);
genClassFiles.putAll(newClassFiles);
enterTrees(roots);
if (unrecoverableError()) return;
topLevelClasses =
join(getTopLevelClasses(parsedFiles), getTopLevelClassesFromClasses(newClasses));
packageInfoFiles =
join(getPackageInfoFiles(parsedFiles), getPackageInfoFilesFromClasses(newClasses));
findAnnotationsPresent();
}
static {
map.put(Tree.Kind.BOOLEAN_LITERAL, Boolean.class);
map.put(Tree.Kind.CHAR_LITERAL, Character.class);
map.put(Tree.Kind.STRING_LITERAL, String.class);
map.put(Tree.Kind.INT_LITERAL, Integer.class);
map.put(Tree.Kind.LONG_LITERAL, Long.class);
map.put(Tree.Kind.FLOAT_LITERAL, Float.class);
map.put(Tree.Kind.DOUBLE_LITERAL, Double.class);
}
public Void visitLiteral(LiteralTree tree, Void ignore) {
System.err.println(tree);
Class expect = map.get(tree.getKind());
if (!check(tree.getValue(), expect)) {
System.err.println("tree: " + tree);
System.err.println("expected class: " + expect);
if (tree.getValue() != null)
System.err.println("actual class: " + tree.getValue().getClass());
throw new AssertionError("unexpected value for literal");
}
return null;
}
private Map<String, String> initProcessorOptions(Context context) {
Options options = Options.instance(context);
Set<String> keySet = options.keySet();
Map<String, String> tempOptions = new LinkedHashMap<String, String>();
for (String key : keySet) {
if (key.startsWith("-A") && key.length() > 2) {
int sepIndex = key.indexOf('=');
String candidateKey = null;
String candidateValue = null;
if (sepIndex == -1) candidateKey = key.substring(2);
else if (sepIndex >= 3) {
candidateKey = key.substring(2, sepIndex);
candidateValue = (sepIndex < key.length() - 1) ? key.substring(sepIndex + 1) : null;
}
tempOptions.put(candidateKey, candidateValue);
}
}
return Collections.unmodifiableMap(tempOptions);
}
/** Enter a set of generated class files. */
private List<ClassSymbol> enterClassFiles(Map<String, JavaFileObject> classFiles) {
ClassReader reader = ClassReader.instance(context);
Names names = Names.instance(context);
List<ClassSymbol> list = List.nil();
for (Map.Entry<String, JavaFileObject> entry : classFiles.entrySet()) {
Name name = names.fromString(entry.getKey());
JavaFileObject file = entry.getValue();
if (file.getKind() != JavaFileObject.Kind.CLASS) throw new AssertionError(file);
ClassSymbol cs;
if (isPkgInfo(file, JavaFileObject.Kind.CLASS)) {
Name packageName = Convert.packagePart(name);
PackageSymbol p = reader.enterPackage(packageName);
if (p.package_info == null)
p.package_info = reader.enterClass(Convert.shortName(name), p);
cs = p.package_info;
if (cs.classfile == null) cs.classfile = file;
} else cs = reader.enterClass(name, file);
list = list.prepend(cs);
}
return list.reverse();
}
private String getValue(AnnotationMirror am) {
Map<? extends ExecutableElement, ? extends AnnotationValue> map = am.getElementValues();
if (map.size() != 1) throw new IllegalArgumentException();
AnnotationValue v = map.values().iterator().next();
return (String) v.getValue();
}
private void discoverAndRunProcs(
Context context,
Set<TypeElement> annotationsPresent,
List<ClassSymbol> topLevelClasses,
List<PackageSymbol> packageInfoFiles) {
Map<String, TypeElement> unmatchedAnnotations =
new HashMap<String, TypeElement>(annotationsPresent.size());
for (TypeElement a : annotationsPresent) {
unmatchedAnnotations.put(a.getQualifiedName().toString(), a);
}
// Give "*" processors a chance to match
if (unmatchedAnnotations.size() == 0) unmatchedAnnotations.put("", null);
DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator();
// TODO: Create proper argument values; need past round
// information to fill in this constructor. Note that the 1
// st round of processing could be the last round if there
// were parse errors on the initial source files; however, we
// are not doing processing in that case.
Set<Element> rootElements = new LinkedHashSet<Element>();
rootElements.addAll(topLevelClasses);
rootElements.addAll(packageInfoFiles);
rootElements = Collections.unmodifiableSet(rootElements);
RoundEnvironment renv =
new JavacRoundEnvironment(false, false, rootElements, JavacProcessingEnvironment.this);
while (unmatchedAnnotations.size() > 0 && psi.hasNext()) {
ProcessorState ps = psi.next();
Set<String> matchedNames = new HashSet<String>();
Set<TypeElement> typeElements = new LinkedHashSet<TypeElement>();
for (Map.Entry<String, TypeElement> entry : unmatchedAnnotations.entrySet()) {
String unmatchedAnnotationName = entry.getKey();
if (ps.annotationSupported(unmatchedAnnotationName)) {
matchedNames.add(unmatchedAnnotationName);
TypeElement te = entry.getValue();
if (te != null) typeElements.add(te);
}
}
if (matchedNames.size() > 0 || ps.contributed) {
boolean processingResult = callProcessor(ps.processor, typeElements, renv);
ps.contributed = true;
ps.removeSupportedOptions(unmatchedProcessorOptions);
if (printProcessorInfo || verbose) {
log.printNoteLines(
"x.print.processor.info",
ps.processor.getClass().getName(),
matchedNames.toString(),
processingResult);
}
if (processingResult) {
unmatchedAnnotations.keySet().removeAll(matchedNames);
}
}
}
unmatchedAnnotations.remove("");
if (lint && unmatchedAnnotations.size() > 0) {
// Remove annotations processed by javac
unmatchedAnnotations.keySet().removeAll(platformAnnotations);
if (unmatchedAnnotations.size() > 0) {
log = Log.instance(context);
log.warning("proc.annotations.without.processors", unmatchedAnnotations.keySet());
}
}
// Run contributing processors that haven't run yet
psi.runContributingProcs(renv);
// Debugging
if (options.isSet("displayFilerState")) filer.displayState();
}
private Set<String> initUnmatchedProcessorOptions() {
Set<String> unmatchedProcessorOptions = new HashSet<String>();
unmatchedProcessorOptions.addAll(processorOptions.keySet());
return unmatchedProcessorOptions;
}