duke@1: /* xdono@323: * Copyright 2005-2009 Sun Microsystems, Inc. All Rights Reserved. duke@1: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. duke@1: * duke@1: * This code is free software; you can redistribute it and/or modify it duke@1: * under the terms of the GNU General Public License version 2 only, as duke@1: * published by the Free Software Foundation. Sun designates this duke@1: * particular file as subject to the "Classpath" exception as provided duke@1: * by Sun in the LICENSE file that accompanied this code. duke@1: * duke@1: * This code is distributed in the hope that it will be useful, but WITHOUT duke@1: * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or duke@1: * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License duke@1: * version 2 for more details (a copy is included in the LICENSE file that duke@1: * accompanied this code). duke@1: * duke@1: * You should have received a copy of the GNU General Public License version duke@1: * 2 along with this work; if not, write to the Free Software Foundation, duke@1: * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. duke@1: * duke@1: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, duke@1: * CA 95054 USA or visit www.sun.com if you need additional information or duke@1: * have any questions. duke@1: */ duke@1: duke@1: package com.sun.tools.javac.processing; duke@1: jjg@50: jjg@50: import java.lang.reflect.*; jjg@50: import java.util.*; jjg@50: import java.util.regex.*; jjg@50: jjg@50: import java.net.URL; jjg@50: import java.io.Closeable; jjg@50: import java.io.File; jjg@50: import java.io.PrintWriter; jjg@50: import java.io.IOException; jjg@50: import java.net.MalformedURLException; duke@1: import java.io.StringWriter; duke@1: duke@1: import javax.annotation.processing.*; duke@1: import javax.lang.model.SourceVersion; duke@1: import javax.lang.model.element.AnnotationMirror; duke@1: import javax.lang.model.element.Element; duke@1: import javax.lang.model.element.TypeElement; duke@1: import javax.lang.model.element.PackageElement; duke@1: import javax.lang.model.util.*; duke@1: import javax.tools.JavaFileManager; duke@1: import javax.tools.StandardJavaFileManager; duke@1: import javax.tools.JavaFileObject; duke@1: import javax.tools.DiagnosticListener; jjg@50: jjg@310: import com.sun.source.util.AbstractTypeProcessor; jjg@50: import com.sun.source.util.TaskEvent; jjg@50: import com.sun.source.util.TaskListener; jjg@50: import com.sun.tools.javac.api.JavacTaskImpl; jjg@50: import com.sun.tools.javac.code.*; jjg@50: import com.sun.tools.javac.code.Symbol.*; jjg@50: import com.sun.tools.javac.file.JavacFileManager; jjg@50: import com.sun.tools.javac.jvm.*; jjg@50: import com.sun.tools.javac.main.JavaCompiler; jjg@310: import com.sun.tools.javac.main.JavaCompiler.CompileState; jjg@50: import com.sun.tools.javac.model.JavacElements; jjg@50: import com.sun.tools.javac.model.JavacTypes; jjg@50: import com.sun.tools.javac.parser.*; jjg@50: import com.sun.tools.javac.tree.*; jjg@50: import com.sun.tools.javac.tree.JCTree.*; jjg@50: import com.sun.tools.javac.util.Abort; jjg@50: import com.sun.tools.javac.util.Context; jjg@50: import com.sun.tools.javac.util.List; jjg@50: import com.sun.tools.javac.util.ListBuffer; jjg@50: import com.sun.tools.javac.util.Log; mcimadamore@136: import com.sun.tools.javac.util.JavacMessages; jjg@50: import com.sun.tools.javac.util.Name; jjg@113: import com.sun.tools.javac.util.Names; jjg@50: import com.sun.tools.javac.util.Options; jjg@50: duke@1: import static javax.tools.StandardLocation.*; duke@1: duke@1: /** duke@1: * Objects of this class hold and manage the state needed to support duke@1: * annotation processing. duke@1: * duke@1: *

This is NOT part of any API supported by Sun Microsystems. duke@1: * If you write code that depends on this, you do so at your own risk. duke@1: * This code and its internal interfaces are subject to change or duke@1: * deletion without notice. duke@1: */ duke@1: public class JavacProcessingEnvironment implements ProcessingEnvironment, Closeable { duke@1: Options options; duke@1: duke@1: private final boolean printProcessorInfo; duke@1: private final boolean printRounds; duke@1: private final boolean verbose; duke@1: private final boolean lint; duke@1: private final boolean procOnly; duke@1: private final boolean fatalErrors; jjg@310: private boolean foundTypeProcessors; duke@1: duke@1: private final JavacFiler filer; duke@1: private final JavacMessager messager; duke@1: private final JavacElements elementUtils; duke@1: private final JavacTypes typeUtils; duke@1: duke@1: /** duke@1: * Holds relevant state history of which processors have been duke@1: * used. duke@1: */ duke@1: private DiscoveredProcessors discoveredProcs; duke@1: duke@1: /** duke@1: * Map of processor-specific options. duke@1: */ duke@1: private final Map processorOptions; duke@1: duke@1: /** duke@1: */ duke@1: private final Set unmatchedProcessorOptions; duke@1: duke@1: /** duke@1: * Annotations implicitly processed and claimed by javac. duke@1: */ duke@1: private final Set platformAnnotations; duke@1: duke@1: /** duke@1: * Set of packages given on command line. duke@1: */ duke@1: private Set specifiedPackages = Collections.emptySet(); duke@1: duke@1: /** The log to be used for error reporting. duke@1: */ duke@1: Log log; duke@1: duke@1: /** duke@1: * Source level of the compile. duke@1: */ duke@1: Source source; duke@1: mcimadamore@136: /** mcimadamore@136: * JavacMessages object used for localization mcimadamore@136: */ mcimadamore@136: private JavacMessages messages; mcimadamore@136: duke@1: private Context context; duke@1: mcimadamore@136: public JavacProcessingEnvironment(Context context, Iterable processors) { duke@1: options = Options.instance(context); duke@1: this.context = context; duke@1: log = Log.instance(context); duke@1: source = Source.instance(context); duke@1: printProcessorInfo = options.get("-XprintProcessorInfo") != null; duke@1: printRounds = options.get("-XprintRounds") != null; duke@1: verbose = options.get("-verbose") != null; duke@1: lint = options.lint("processing"); duke@1: procOnly = options.get("-proc:only") != null || duke@1: options.get("-Xprint") != null; duke@1: fatalErrors = options.get("fatalEnterError") != null; duke@1: platformAnnotations = initPlatformAnnotations(); jjg@310: foundTypeProcessors = false; duke@1: duke@1: // Initialize services before any processors are initialzied duke@1: // in case processors use them. duke@1: filer = new JavacFiler(context); duke@1: messager = new JavacMessager(context, this); duke@1: elementUtils = new JavacElements(context); duke@1: typeUtils = new JavacTypes(context); duke@1: processorOptions = initProcessorOptions(context); duke@1: unmatchedProcessorOptions = initUnmatchedProcessorOptions(); mcimadamore@136: messages = JavacMessages.instance(context); duke@1: initProcessorIterator(context, processors); duke@1: } duke@1: duke@1: private Set initPlatformAnnotations() { duke@1: Set platformAnnotations = new HashSet(); duke@1: platformAnnotations.add("java.lang.Deprecated"); duke@1: platformAnnotations.add("java.lang.Override"); duke@1: platformAnnotations.add("java.lang.SuppressWarnings"); duke@1: platformAnnotations.add("java.lang.annotation.Documented"); duke@1: platformAnnotations.add("java.lang.annotation.Inherited"); duke@1: platformAnnotations.add("java.lang.annotation.Retention"); duke@1: platformAnnotations.add("java.lang.annotation.Target"); duke@1: return Collections.unmodifiableSet(platformAnnotations); duke@1: } duke@1: duke@1: private void initProcessorIterator(Context context, Iterable processors) { duke@1: Log log = Log.instance(context); duke@1: Iterator processorIterator; duke@1: duke@1: if (options.get("-Xprint") != null) { duke@1: try { duke@1: Processor processor = PrintingProcessor.class.newInstance(); duke@1: processorIterator = List.of(processor).iterator(); duke@1: } catch (Throwable t) { duke@1: AssertionError assertError = duke@1: new AssertionError("Problem instantiating PrintingProcessor."); duke@1: assertError.initCause(t); duke@1: throw assertError; duke@1: } duke@1: } else if (processors != null) { duke@1: processorIterator = processors.iterator(); duke@1: } else { duke@1: String processorNames = options.get("-processor"); duke@1: JavaFileManager fileManager = context.get(JavaFileManager.class); duke@1: try { duke@1: // If processorpath is not explicitly set, use the classpath. duke@1: ClassLoader processorCL = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH) duke@1: ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH) duke@1: : fileManager.getClassLoader(CLASS_PATH); duke@1: duke@1: /* duke@1: * If the "-processor" option is used, search the appropriate duke@1: * path for the named class. Otherwise, use a service duke@1: * provider mechanism to create the processor iterator. duke@1: */ duke@1: if (processorNames != null) { duke@1: processorIterator = new NameProcessIterator(processorNames, processorCL, log); duke@1: } else { duke@1: processorIterator = new ServiceIterator(processorCL, log); duke@1: } duke@1: } catch (SecurityException e) { duke@1: /* duke@1: * A security exception will occur if we can't create a classloader. duke@1: * Ignore the exception if, with hindsight, we didn't need it anyway duke@1: * (i.e. no processor was specified either explicitly, or implicitly, duke@1: * in service configuration file.) Otherwise, we cannot continue. duke@1: */ duke@1: processorIterator = handleServiceLoaderUnavailability("proc.cant.create.loader", e); duke@1: } duke@1: } duke@1: discoveredProcs = new DiscoveredProcessors(processorIterator); duke@1: } duke@1: duke@1: /** duke@1: * Returns an empty processor iterator if no processors are on the duke@1: * relevant path, otherwise if processors are present, logs an duke@1: * error. Called when a service loader is unavailable for some duke@1: * reason, either because a service loader class cannot be found duke@1: * or because a security policy prevents class loaders from being duke@1: * created. duke@1: * duke@1: * @param key The resource key to use to log an error message duke@1: * @param e If non-null, pass this exception to Abort duke@1: */ duke@1: private Iterator handleServiceLoaderUnavailability(String key, Exception e) { duke@1: JavaFileManager fileManager = context.get(JavaFileManager.class); duke@1: duke@1: if (fileManager instanceof JavacFileManager) { duke@1: StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager; duke@1: Iterable workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH) duke@1: ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH) duke@1: : standardFileManager.getLocation(CLASS_PATH); duke@1: duke@1: if (needClassLoader(options.get("-processor"), workingPath) ) duke@1: handleException(key, e); duke@1: duke@1: } else { duke@1: handleException(key, e); duke@1: } duke@1: duke@1: java.util.List pl = Collections.emptyList(); duke@1: return pl.iterator(); duke@1: } duke@1: duke@1: /** duke@1: * Handle a security exception thrown during initializing the duke@1: * Processor iterator. duke@1: */ duke@1: private void handleException(String key, Exception e) { duke@1: if (e != null) { duke@1: log.error(key, e.getLocalizedMessage()); duke@1: throw new Abort(e); duke@1: } else { duke@1: log.error(key); duke@1: throw new Abort(); duke@1: } duke@1: } duke@1: duke@1: /** duke@1: * Use a service loader appropriate for the platform to provide an duke@1: * iterator over annotations processors. If duke@1: * java.util.ServiceLoader is present use it, otherwise, use duke@1: * sun.misc.Service, otherwise fail if a loader is needed. duke@1: */ duke@1: private class ServiceIterator implements Iterator { duke@1: // The to-be-wrapped iterator. duke@1: private Iterator iterator; duke@1: private Log log; duke@1: duke@1: ServiceIterator(ClassLoader classLoader, Log log) { duke@1: Class loaderClass; duke@1: String loadMethodName; duke@1: boolean jusl; duke@1: duke@1: this.log = log; duke@1: try { duke@1: try { duke@1: loaderClass = Class.forName("java.util.ServiceLoader"); duke@1: loadMethodName = "load"; duke@1: jusl = true; duke@1: } catch (ClassNotFoundException cnfe) { duke@1: try { duke@1: loaderClass = Class.forName("sun.misc.Service"); duke@1: loadMethodName = "providers"; duke@1: jusl = false; duke@1: } catch (ClassNotFoundException cnfe2) { duke@1: // Fail softly if a loader is not actually needed. duke@1: this.iterator = handleServiceLoaderUnavailability("proc.no.service", duke@1: null); duke@1: return; duke@1: } duke@1: } duke@1: duke@1: // java.util.ServiceLoader.load or sun.misc.Service.providers duke@1: Method loadMethod = loaderClass.getMethod(loadMethodName, duke@1: Class.class, duke@1: ClassLoader.class); duke@1: duke@1: Object result = loadMethod.invoke(null, duke@1: Processor.class, duke@1: classLoader); duke@1: duke@1: // For java.util.ServiceLoader, we have to call another duke@1: // method to get the iterator. duke@1: if (jusl) { duke@1: Method m = loaderClass.getMethod("iterator"); duke@1: result = m.invoke(result); // serviceLoader.iterator(); duke@1: } duke@1: duke@1: // The result should now be an iterator. duke@1: this.iterator = (Iterator) result; duke@1: } catch (Throwable t) { duke@1: log.error("proc.service.problem"); duke@1: throw new Abort(t); duke@1: } duke@1: } duke@1: duke@1: public boolean hasNext() { duke@1: try { duke@1: return iterator.hasNext(); duke@1: } catch (Throwable t) { duke@1: if ("ServiceConfigurationError". duke@1: equals(t.getClass().getSimpleName())) { duke@1: log.error("proc.bad.config.file", t.getLocalizedMessage()); duke@1: } duke@1: throw new Abort(t); duke@1: } duke@1: } duke@1: duke@1: public Processor next() { duke@1: try { duke@1: return (Processor)(iterator.next()); duke@1: } catch (Throwable t) { duke@1: if ("ServiceConfigurationError". duke@1: equals(t.getClass().getSimpleName())) { duke@1: log.error("proc.bad.config.file", t.getLocalizedMessage()); duke@1: } else { duke@1: log.error("proc.processor.constructor.error", t.getLocalizedMessage()); duke@1: } duke@1: throw new Abort(t); duke@1: } duke@1: } duke@1: duke@1: public void remove() { duke@1: throw new UnsupportedOperationException(); duke@1: } duke@1: } duke@1: duke@1: duke@1: private static class NameProcessIterator implements Iterator { duke@1: Processor nextProc = null; duke@1: Iterator names; duke@1: ClassLoader processorCL; duke@1: Log log; duke@1: duke@1: NameProcessIterator(String names, ClassLoader processorCL, Log log) { duke@1: this.names = Arrays.asList(names.split(",")).iterator(); duke@1: this.processorCL = processorCL; duke@1: this.log = log; duke@1: } duke@1: duke@1: public boolean hasNext() { duke@1: if (nextProc != null) duke@1: return true; duke@1: else { duke@1: if (!names.hasNext()) duke@1: return false; duke@1: else { duke@1: String processorName = names.next(); duke@1: duke@1: Processor processor; duke@1: try { duke@1: try { duke@1: processor = duke@1: (Processor) (processorCL.loadClass(processorName).newInstance()); duke@1: } catch (ClassNotFoundException cnfe) { duke@1: log.error("proc.processor.not.found", processorName); duke@1: return false; duke@1: } catch (ClassCastException cce) { duke@1: log.error("proc.processor.wrong.type", processorName); duke@1: return false; duke@1: } catch (Exception e ) { duke@1: log.error("proc.processor.cant.instantiate", processorName); duke@1: return false; duke@1: } duke@1: } catch(Throwable t) { duke@1: throw new AnnotationProcessingError(t); duke@1: } duke@1: nextProc = processor; duke@1: return true; duke@1: } duke@1: duke@1: } duke@1: } duke@1: duke@1: public Processor next() { duke@1: if (hasNext()) { duke@1: Processor p = nextProc; duke@1: nextProc = null; duke@1: return p; duke@1: } else duke@1: throw new NoSuchElementException(); duke@1: } duke@1: duke@1: public void remove () { duke@1: throw new UnsupportedOperationException(); duke@1: } duke@1: } duke@1: duke@1: public boolean atLeastOneProcessor() { duke@1: return discoveredProcs.iterator().hasNext(); duke@1: } duke@1: duke@1: private Map initProcessorOptions(Context context) { duke@1: Options options = Options.instance(context); duke@1: Set keySet = options.keySet(); duke@1: Map tempOptions = new LinkedHashMap(); duke@1: duke@1: for(String key : keySet) { duke@1: if (key.startsWith("-A") && key.length() > 2) { duke@1: int sepIndex = key.indexOf('='); duke@1: String candidateKey = null; duke@1: String candidateValue = null; duke@1: duke@1: if (sepIndex == -1) duke@1: candidateKey = key.substring(2); duke@1: else if (sepIndex >= 3) { duke@1: candidateKey = key.substring(2, sepIndex); duke@1: candidateValue = (sepIndex < key.length()-1)? duke@1: key.substring(sepIndex+1) : null; duke@1: } duke@1: tempOptions.put(candidateKey, candidateValue); duke@1: } duke@1: } duke@1: duke@1: return Collections.unmodifiableMap(tempOptions); duke@1: } duke@1: duke@1: private Set initUnmatchedProcessorOptions() { duke@1: Set unmatchedProcessorOptions = new HashSet(); duke@1: unmatchedProcessorOptions.addAll(processorOptions.keySet()); duke@1: return unmatchedProcessorOptions; duke@1: } duke@1: duke@1: /** duke@1: * State about how a processor has been used by the tool. If a duke@1: * processor has been used on a prior round, its process method is duke@1: * called on all subsequent rounds, perhaps with an empty set of duke@1: * annotations to process. The {@code annotatedSupported} method duke@1: * caches the supported annotation information from the first (and duke@1: * only) getSupportedAnnotationTypes call to the processor. duke@1: */ duke@1: static class ProcessorState { duke@1: public Processor processor; duke@1: public boolean contributed; duke@1: private ArrayList supportedAnnotationPatterns; duke@1: private ArrayList supportedOptionNames; duke@1: duke@1: ProcessorState(Processor p, Log log, Source source, ProcessingEnvironment env) { duke@1: processor = p; duke@1: contributed = false; duke@1: duke@1: try { duke@1: processor.init(env); duke@1: duke@1: checkSourceVersionCompatibility(source, log); duke@1: duke@1: supportedAnnotationPatterns = new ArrayList(); duke@1: for (String importString : processor.getSupportedAnnotationTypes()) { duke@1: supportedAnnotationPatterns.add(importStringToPattern(importString, duke@1: processor, duke@1: log)); duke@1: } duke@1: duke@1: supportedOptionNames = new ArrayList(); duke@1: for (String optionName : processor.getSupportedOptions() ) { duke@1: if (checkOptionName(optionName, log)) duke@1: supportedOptionNames.add(optionName); duke@1: } duke@1: duke@1: } catch (Throwable t) { duke@1: throw new AnnotationProcessingError(t); duke@1: } duke@1: } duke@1: duke@1: /** duke@1: * Checks whether or not a processor's source version is duke@1: * compatible with the compilation source version. The duke@1: * processor's source version needs to be greater than or duke@1: * equal to the source version of the compile. duke@1: */ duke@1: private void checkSourceVersionCompatibility(Source source, Log log) { duke@1: SourceVersion procSourceVersion = processor.getSupportedSourceVersion(); duke@1: duke@1: if (procSourceVersion.compareTo(Source.toSourceVersion(source)) < 0 ) { duke@1: log.warning("proc.processor.incompatible.source.version", duke@1: procSourceVersion, duke@1: processor.getClass().getName(), duke@1: source.name); duke@1: } duke@1: } duke@1: duke@1: private boolean checkOptionName(String optionName, Log log) { duke@1: boolean valid = isValidOptionName(optionName); duke@1: if (!valid) duke@1: log.error("proc.processor.bad.option.name", duke@1: optionName, duke@1: processor.getClass().getName()); duke@1: return valid; duke@1: } duke@1: duke@1: public boolean annotationSupported(String annotationName) { duke@1: for(Pattern p: supportedAnnotationPatterns) { duke@1: if (p.matcher(annotationName).matches()) duke@1: return true; duke@1: } duke@1: return false; duke@1: } duke@1: duke@1: /** duke@1: * Remove options that are matched by this processor. duke@1: */ duke@1: public void removeSupportedOptions(Set unmatchedProcessorOptions) { duke@1: unmatchedProcessorOptions.removeAll(supportedOptionNames); duke@1: } duke@1: } duke@1: duke@1: // TODO: These two classes can probably be rewritten better... duke@1: /** duke@1: * This class holds information about the processors that have duke@1: * been discoverd so far as well as the means to discover more, if duke@1: * necessary. A single iterator should be used per round of duke@1: * annotation processing. The iterator first visits already duke@1: * discovered processors then fails over to the service provided duke@1: * mechanism if additional queries are made. duke@1: */ duke@1: class DiscoveredProcessors implements Iterable { duke@1: duke@1: class ProcessorStateIterator implements Iterator { duke@1: DiscoveredProcessors psi; duke@1: Iterator innerIter; duke@1: boolean onProcInterator; duke@1: duke@1: ProcessorStateIterator(DiscoveredProcessors psi) { duke@1: this.psi = psi; duke@1: this.innerIter = psi.procStateList.iterator(); duke@1: this.onProcInterator = false; duke@1: } duke@1: duke@1: public ProcessorState next() { duke@1: if (!onProcInterator) { duke@1: if (innerIter.hasNext()) duke@1: return innerIter.next(); duke@1: else duke@1: onProcInterator = true; duke@1: } duke@1: duke@1: if (psi.processorIterator.hasNext()) { duke@1: ProcessorState ps = new ProcessorState(psi.processorIterator.next(), duke@1: log, source, JavacProcessingEnvironment.this); duke@1: psi.procStateList.add(ps); duke@1: return ps; duke@1: } else duke@1: throw new NoSuchElementException(); duke@1: } duke@1: duke@1: public boolean hasNext() { duke@1: if (onProcInterator) duke@1: return psi.processorIterator.hasNext(); duke@1: else duke@1: return innerIter.hasNext() || psi.processorIterator.hasNext(); duke@1: } duke@1: duke@1: public void remove () { duke@1: throw new UnsupportedOperationException(); duke@1: } duke@1: duke@1: /** duke@1: * Run all remaining processors on the procStateList that duke@1: * have not already run this round with an empty set of duke@1: * annotations. duke@1: */ duke@1: public void runContributingProcs(RoundEnvironment re) { duke@1: if (!onProcInterator) { duke@1: Set emptyTypeElements = Collections.emptySet(); duke@1: while(innerIter.hasNext()) { duke@1: ProcessorState ps = innerIter.next(); duke@1: if (ps.contributed) duke@1: callProcessor(ps.processor, emptyTypeElements, re); duke@1: } duke@1: } duke@1: } duke@1: } duke@1: duke@1: Iterator processorIterator; duke@1: ArrayList procStateList; duke@1: duke@1: public ProcessorStateIterator iterator() { duke@1: return new ProcessorStateIterator(this); duke@1: } duke@1: duke@1: DiscoveredProcessors(Iterator processorIterator) { duke@1: this.processorIterator = processorIterator; duke@1: this.procStateList = new ArrayList(); duke@1: } duke@1: } duke@1: duke@1: private void discoverAndRunProcs(Context context, duke@1: Set annotationsPresent, duke@1: List topLevelClasses, duke@1: List packageInfoFiles) { duke@1: // Writer for -XprintRounds and -XprintProcessorInfo data duke@1: PrintWriter xout = context.get(Log.outKey); duke@1: duke@1: Map unmatchedAnnotations = duke@1: new HashMap(annotationsPresent.size()); duke@1: duke@1: for(TypeElement a : annotationsPresent) { duke@1: unmatchedAnnotations.put(a.getQualifiedName().toString(), duke@1: a); duke@1: } duke@1: duke@1: // Give "*" processors a chance to match duke@1: if (unmatchedAnnotations.size() == 0) duke@1: unmatchedAnnotations.put("", null); duke@1: duke@1: DiscoveredProcessors.ProcessorStateIterator psi = discoveredProcs.iterator(); duke@1: // TODO: Create proper argument values; need past round duke@1: // information to fill in this constructor. Note that the 1 duke@1: // st round of processing could be the last round if there duke@1: // were parse errors on the initial source files; however, we duke@1: // are not doing processing in that case. duke@1: duke@1: Set rootElements = new LinkedHashSet(); duke@1: rootElements.addAll(topLevelClasses); duke@1: rootElements.addAll(packageInfoFiles); duke@1: rootElements = Collections.unmodifiableSet(rootElements); duke@1: duke@1: RoundEnvironment renv = new JavacRoundEnvironment(false, duke@1: false, duke@1: rootElements, duke@1: JavacProcessingEnvironment.this); duke@1: duke@1: while(unmatchedAnnotations.size() > 0 && psi.hasNext() ) { duke@1: ProcessorState ps = psi.next(); duke@1: Set matchedNames = new HashSet(); duke@1: Set typeElements = new LinkedHashSet(); duke@1: for (String unmatchedAnnotationName : unmatchedAnnotations.keySet()) { duke@1: if (ps.annotationSupported(unmatchedAnnotationName) ) { duke@1: matchedNames.add(unmatchedAnnotationName); duke@1: TypeElement te = unmatchedAnnotations.get(unmatchedAnnotationName); duke@1: if (te != null) duke@1: typeElements.add(te); duke@1: } duke@1: } duke@1: duke@1: if (matchedNames.size() > 0 || ps.contributed) { jjg@310: foundTypeProcessors = foundTypeProcessors || (ps.processor instanceof AbstractTypeProcessor); duke@1: boolean processingResult = callProcessor(ps.processor, typeElements, renv); duke@1: ps.contributed = true; duke@1: ps.removeSupportedOptions(unmatchedProcessorOptions); duke@1: duke@1: if (printProcessorInfo || verbose) { duke@1: xout.println(Log.getLocalizedString("x.print.processor.info", duke@1: ps.processor.getClass().getName(), duke@1: matchedNames.toString(), duke@1: processingResult)); duke@1: } duke@1: duke@1: if (processingResult) { duke@1: unmatchedAnnotations.keySet().removeAll(matchedNames); duke@1: } duke@1: duke@1: } duke@1: } duke@1: unmatchedAnnotations.remove(""); duke@1: duke@1: if (lint && unmatchedAnnotations.size() > 0) { duke@1: // Remove annotations processed by javac duke@1: unmatchedAnnotations.keySet().removeAll(platformAnnotations); duke@1: if (unmatchedAnnotations.size() > 0) { duke@1: log = Log.instance(context); duke@1: log.warning("proc.annotations.without.processors", duke@1: unmatchedAnnotations.keySet()); duke@1: } duke@1: } duke@1: duke@1: // Run contributing processors that haven't run yet duke@1: psi.runContributingProcs(renv); duke@1: duke@1: // Debugging duke@1: if (options.get("displayFilerState") != null) duke@1: filer.displayState(); duke@1: } duke@1: duke@1: /** duke@1: * Computes the set of annotations on the symbol in question. duke@1: * Leave class public for external testing purposes. duke@1: */ duke@1: public static class ComputeAnnotationSet extends duke@1: ElementScanner6, Set> { duke@1: final Elements elements; duke@1: duke@1: public ComputeAnnotationSet(Elements elements) { duke@1: super(); duke@1: this.elements = elements; duke@1: } duke@1: duke@1: @Override duke@1: public Set visitPackage(PackageElement e, Set p) { duke@1: // Don't scan enclosed elements of a package duke@1: return p; duke@1: } duke@1: duke@1: @Override duke@1: public Set scan(Element e, Set p) { duke@1: for (AnnotationMirror annotationMirror : duke@1: elements.getAllAnnotationMirrors(e) ) { duke@1: Element e2 = annotationMirror.getAnnotationType().asElement(); duke@1: p.add((TypeElement) e2); duke@1: } duke@1: return super.scan(e, p); duke@1: } duke@1: } duke@1: duke@1: private boolean callProcessor(Processor proc, duke@1: Set tes, duke@1: RoundEnvironment renv) { duke@1: try { duke@1: return proc.process(tes, renv); duke@1: } catch (CompletionFailure ex) { duke@1: StringWriter out = new StringWriter(); duke@1: ex.printStackTrace(new PrintWriter(out)); jjg@12: log.error("proc.cant.access", ex.sym, ex.getDetailValue(), out.toString()); duke@1: return false; duke@1: } catch (Throwable t) { duke@1: throw new AnnotationProcessingError(t); duke@1: } duke@1: } duke@1: duke@1: duke@1: // TODO: internal catch clauses?; catch and rethrow an annotation duke@1: // processing error duke@1: public JavaCompiler doProcessing(Context context, duke@1: List roots, duke@1: List classSymbols, duke@1: Iterable pckSymbols) duke@1: throws IOException { duke@1: duke@1: log = Log.instance(context); duke@1: // Writer for -XprintRounds and -XprintProcessorInfo data duke@1: PrintWriter xout = context.get(Log.outKey); duke@1: TaskListener taskListener = context.get(TaskListener.class); duke@1: duke@1: duke@1: AnnotationCollector collector = new AnnotationCollector(); duke@1: duke@1: JavaCompiler compiler = JavaCompiler.instance(context); duke@1: compiler.todo.clear(); // free the compiler's resources duke@1: duke@1: int round = 0; duke@1: duke@1: // List annotationsPresentInSource = collector.findAnnotations(roots); duke@1: List topLevelClasses = getTopLevelClasses(roots); duke@1: duke@1: for (ClassSymbol classSym : classSymbols) duke@1: topLevelClasses = topLevelClasses.prepend(classSym); duke@1: List packageInfoFiles = duke@1: getPackageInfoFiles(roots); duke@1: duke@1: Set specifiedPackages = new LinkedHashSet(); duke@1: for (PackageSymbol psym : pckSymbols) duke@1: specifiedPackages.add(psym); duke@1: this.specifiedPackages = Collections.unmodifiableSet(specifiedPackages); duke@1: duke@1: // Use annotation processing to compute the set of annotations present duke@1: Set annotationsPresent = new LinkedHashSet(); duke@1: ComputeAnnotationSet annotationComputer = new ComputeAnnotationSet(elementUtils); duke@1: for (ClassSymbol classSym : topLevelClasses) duke@1: annotationComputer.scan(classSym, annotationsPresent); duke@1: for (PackageSymbol pkgSym : packageInfoFiles) duke@1: annotationComputer.scan(pkgSym, annotationsPresent); duke@1: duke@1: Context currentContext = context; duke@1: duke@1: int roundNumber = 0; duke@1: boolean errorStatus = false; duke@1: duke@1: runAround: duke@1: while(true) { duke@1: if (fatalErrors && compiler.errorCount() != 0) { duke@1: errorStatus = true; duke@1: break runAround; duke@1: } duke@1: duke@1: this.context = currentContext; duke@1: roundNumber++; duke@1: printRoundInfo(xout, roundNumber, topLevelClasses, annotationsPresent, false); duke@1: duke@1: if (taskListener != null) duke@1: taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND)); duke@1: duke@1: try { duke@1: discoverAndRunProcs(currentContext, annotationsPresent, topLevelClasses, packageInfoFiles); duke@1: } finally { duke@1: if (taskListener != null) duke@1: taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND)); duke@1: } duke@1: duke@1: /* duke@1: * Processors for round n have run to completion. Prepare duke@1: * for round (n+1) by checked for errors raised by duke@1: * annotation processors and then checking for syntax duke@1: * errors on any generated source files. duke@1: */ duke@1: if (messager.errorRaised()) { duke@1: errorStatus = true; duke@1: break runAround; duke@1: } else { duke@1: if (moreToDo()) { duke@1: // annotationsPresentInSource = List.nil(); duke@1: annotationsPresent = new LinkedHashSet(); duke@1: topLevelClasses = List.nil(); duke@1: packageInfoFiles = List.nil(); duke@1: jjg@113: compiler.close(false); duke@1: currentContext = contextForNextRound(currentContext, true); duke@1: duke@1: JavaFileManager fileManager = currentContext.get(JavaFileManager.class); duke@1: duke@1: List fileObjects = List.nil(); duke@1: for (JavaFileObject jfo : filer.getGeneratedSourceFileObjects() ) { duke@1: fileObjects = fileObjects.prepend(jfo); duke@1: } duke@1: duke@1: duke@1: compiler = JavaCompiler.instance(currentContext); duke@1: List parsedFiles = compiler.parseFiles(fileObjects); duke@1: roots = cleanTrees(roots).reverse(); duke@1: duke@1: duke@1: for (JCCompilationUnit unit : parsedFiles) duke@1: roots = roots.prepend(unit); duke@1: roots = roots.reverse(); duke@1: duke@1: // Check for errors after parsing duke@1: if (compiler.parseErrors()) { duke@1: errorStatus = true; duke@1: break runAround; duke@1: } else { duke@1: ListBuffer classes = enterNewClassFiles(currentContext); duke@1: compiler.enterTrees(roots); duke@1: duke@1: // annotationsPresentInSource = duke@1: // collector.findAnnotations(parsedFiles); duke@1: classes.appendList(getTopLevelClasses(parsedFiles)); duke@1: topLevelClasses = classes.toList(); duke@1: packageInfoFiles = getPackageInfoFiles(parsedFiles); duke@1: duke@1: annotationsPresent = new LinkedHashSet(); duke@1: for (ClassSymbol classSym : topLevelClasses) duke@1: annotationComputer.scan(classSym, annotationsPresent); duke@1: for (PackageSymbol pkgSym : packageInfoFiles) duke@1: annotationComputer.scan(pkgSym, annotationsPresent); duke@1: duke@1: updateProcessingState(currentContext, false); duke@1: } duke@1: } else duke@1: break runAround; // No new files duke@1: } duke@1: } duke@1: runLastRound(xout, roundNumber, errorStatus, taskListener); duke@1: jjg@113: compiler.close(false); duke@1: currentContext = contextForNextRound(currentContext, true); duke@1: compiler = JavaCompiler.instance(currentContext); duke@1: filer.newRound(currentContext, true); duke@1: filer.warnIfUnclosedFiles(); duke@1: warnIfUnmatchedOptions(); duke@1: duke@1: /* duke@1: * If an annotation processor raises an error in a round, duke@1: * that round runs to completion and one last round occurs. duke@1: * The last round may also occur because no more source or duke@1: * class files have been generated. Therefore, if an error duke@1: * was raised on either of the last *two* rounds, the compile duke@1: * should exit with a nonzero exit code. The current value of duke@1: * errorStatus holds whether or not an error was raised on the duke@1: * second to last round; errorRaised() gives the error status duke@1: * of the last round. duke@1: */ duke@1: errorStatus = errorStatus || messager.errorRaised(); duke@1: duke@1: duke@1: // Free resources duke@1: this.close(); duke@1: duke@1: if (taskListener != null) duke@1: taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING)); duke@1: duke@1: if (errorStatus) { duke@1: compiler.log.nerrors += messager.errorCount(); duke@1: if (compiler.errorCount() == 0) duke@1: compiler.log.nerrors++; jjg@310: } else if (procOnly && !foundTypeProcessors) { duke@1: compiler.todo.clear(); duke@1: } else { // Final compilation jjg@113: compiler.close(false); duke@1: currentContext = contextForNextRound(currentContext, true); jjg@308: this.context = currentContext; jjg@308: updateProcessingState(currentContext, true); duke@1: compiler = JavaCompiler.instance(currentContext); jjg@310: if (procOnly && foundTypeProcessors) jjg@310: compiler.shouldStopPolicy = CompileState.FLOW; duke@1: duke@1: if (true) { duke@1: compiler.enterTrees(cleanTrees(roots)); duke@1: } else { duke@1: List fileObjects = List.nil(); duke@1: for (JCCompilationUnit unit : roots) duke@1: fileObjects = fileObjects.prepend(unit.getSourceFile()); duke@1: roots = null; duke@1: compiler.enterTrees(compiler.parseFiles(fileObjects.reverse())); duke@1: } duke@1: } duke@1: duke@1: return compiler; duke@1: } duke@1: duke@1: // Call the last round of annotation processing duke@1: private void runLastRound(PrintWriter xout, duke@1: int roundNumber, duke@1: boolean errorStatus, duke@1: TaskListener taskListener) throws IOException { duke@1: roundNumber++; duke@1: List noTopLevelClasses = List.nil(); duke@1: Set noAnnotations = Collections.emptySet(); duke@1: printRoundInfo(xout, roundNumber, noTopLevelClasses, noAnnotations, true); duke@1: duke@1: Set emptyRootElements = Collections.emptySet(); // immutable duke@1: RoundEnvironment renv = new JavacRoundEnvironment(true, duke@1: errorStatus, duke@1: emptyRootElements, duke@1: JavacProcessingEnvironment.this); duke@1: if (taskListener != null) duke@1: taskListener.started(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND)); duke@1: duke@1: try { duke@1: discoveredProcs.iterator().runContributingProcs(renv); duke@1: } finally { duke@1: if (taskListener != null) duke@1: taskListener.finished(new TaskEvent(TaskEvent.Kind.ANNOTATION_PROCESSING_ROUND)); duke@1: } duke@1: } duke@1: duke@1: private void updateProcessingState(Context currentContext, boolean lastRound) { duke@1: filer.newRound(currentContext, lastRound); duke@1: messager.newRound(currentContext); duke@1: duke@1: elementUtils.setContext(currentContext); duke@1: typeUtils.setContext(currentContext); duke@1: } duke@1: duke@1: private void warnIfUnmatchedOptions() { duke@1: if (!unmatchedProcessorOptions.isEmpty()) { duke@1: log.warning("proc.unmatched.processor.options", unmatchedProcessorOptions.toString()); duke@1: } duke@1: } duke@1: duke@1: private void printRoundInfo(PrintWriter xout, duke@1: int roundNumber, duke@1: List topLevelClasses, duke@1: Set annotationsPresent, duke@1: boolean lastRound) { duke@1: if (printRounds || verbose) { duke@1: xout.println(Log.getLocalizedString("x.print.rounds", duke@1: roundNumber, duke@1: "{" + topLevelClasses.toString(", ") + "}", duke@1: annotationsPresent, duke@1: lastRound)); duke@1: } duke@1: } duke@1: duke@1: private ListBuffer enterNewClassFiles(Context currentContext) { duke@1: ClassReader reader = ClassReader.instance(currentContext); jjg@113: Names names = Names.instance(currentContext); duke@1: ListBuffer list = new ListBuffer(); duke@1: duke@1: for (Map.Entry entry : filer.getGeneratedClasses().entrySet()) { duke@1: Name name = names.fromString(entry.getKey()); duke@1: JavaFileObject file = entry.getValue(); duke@1: if (file.getKind() != JavaFileObject.Kind.CLASS) duke@1: throw new AssertionError(file); duke@1: ClassSymbol cs = reader.enterClass(name, file); duke@1: list.append(cs); duke@1: } duke@1: return list; duke@1: } duke@1: duke@1: /** duke@1: * Free resources related to annotation processing. duke@1: */ duke@1: public void close() { duke@1: filer.close(); duke@1: discoveredProcs = null; duke@1: } duke@1: duke@1: private List getTopLevelClasses(List units) { duke@1: List classes = List.nil(); duke@1: for (JCCompilationUnit unit : units) { duke@1: for (JCTree node : unit.defs) { duke@1: if (node.getTag() == JCTree.CLASSDEF) { duke@1: classes = classes.prepend(((JCClassDecl) node).sym); duke@1: } duke@1: } duke@1: } duke@1: return classes.reverse(); duke@1: } duke@1: duke@1: private List getPackageInfoFiles(List units) { duke@1: List packages = List.nil(); duke@1: for (JCCompilationUnit unit : units) { duke@1: boolean isPkgInfo = unit.sourcefile.isNameCompatible("package-info", duke@1: JavaFileObject.Kind.SOURCE); duke@1: if (isPkgInfo) { duke@1: packages = packages.prepend(unit.packge); duke@1: } duke@1: } duke@1: return packages.reverse(); duke@1: } duke@1: duke@1: private Context contextForNextRound(Context context, boolean shareNames) duke@1: throws IOException duke@1: { duke@1: Context next = new Context(); duke@1: duke@1: Options options = Options.instance(context); duke@1: assert options != null; duke@1: next.put(Options.optionsKey, options); duke@1: duke@1: PrintWriter out = context.get(Log.outKey); duke@1: assert out != null; duke@1: next.put(Log.outKey, out); duke@1: duke@1: if (shareNames) { jjg@113: Names names = Names.instance(context); duke@1: assert names != null; jjg@113: next.put(Names.namesKey, names); duke@1: } duke@1: mcimadamore@184: DiagnosticListener dl = context.get(DiagnosticListener.class); duke@1: if (dl != null) duke@1: next.put(DiagnosticListener.class, dl); duke@1: duke@1: TaskListener tl = context.get(TaskListener.class); duke@1: if (tl != null) duke@1: next.put(TaskListener.class, tl); duke@1: duke@1: JavaFileManager jfm = context.get(JavaFileManager.class); duke@1: assert jfm != null; duke@1: next.put(JavaFileManager.class, jfm); duke@1: if (jfm instanceof JavacFileManager) { duke@1: ((JavacFileManager)jfm).setContext(next); duke@1: } duke@1: jjg@113: Names names = Names.instance(context); duke@1: assert names != null; jjg@113: next.put(Names.namesKey, names); duke@1: duke@1: Keywords keywords = Keywords.instance(context); duke@1: assert(keywords != null); duke@1: next.put(Keywords.keywordsKey, keywords); duke@1: duke@1: JavaCompiler oldCompiler = JavaCompiler.instance(context); duke@1: JavaCompiler nextCompiler = JavaCompiler.instance(next); duke@1: nextCompiler.initRound(oldCompiler); duke@1: duke@1: JavacTaskImpl task = context.get(JavacTaskImpl.class); duke@1: if (task != null) { duke@1: next.put(JavacTaskImpl.class, task); duke@1: task.updateContext(next); duke@1: } duke@1: duke@1: context.clear(); duke@1: return next; duke@1: } duke@1: duke@1: /* duke@1: * Called retroactively to determine if a class loader was required, duke@1: * after we have failed to create one. duke@1: */ duke@1: private boolean needClassLoader(String procNames, Iterable workingpath) { duke@1: if (procNames != null) duke@1: return true; duke@1: duke@1: String procPath; duke@1: URL[] urls = new URL[1]; duke@1: for(File pathElement : workingpath) { duke@1: try { duke@1: urls[0] = pathElement.toURI().toURL(); duke@1: if (ServiceProxy.hasService(Processor.class, urls)) duke@1: return true; duke@1: } catch (MalformedURLException ex) { duke@1: throw new AssertionError(ex); duke@1: } duke@1: catch (ServiceProxy.ServiceConfigurationError e) { duke@1: log.error("proc.bad.config.file", e.getLocalizedMessage()); duke@1: return true; duke@1: } duke@1: } duke@1: duke@1: return false; duke@1: } duke@1: duke@1: private class AnnotationCollector extends TreeScanner { duke@1: List path = List.nil(); duke@1: static final boolean verbose = false; duke@1: List annotations = List.nil(); duke@1: duke@1: public List findAnnotations(List nodes) { duke@1: annotations = List.nil(); duke@1: scan(nodes); duke@1: List found = annotations; duke@1: annotations = List.nil(); duke@1: return found.reverse(); duke@1: } duke@1: duke@1: public void scan(JCTree node) { duke@1: if (node == null) duke@1: return; duke@1: Symbol sym = TreeInfo.symbolFor(node); duke@1: if (sym != null) duke@1: path = path.prepend(node); duke@1: super.scan(node); duke@1: if (sym != null) duke@1: path = path.tail; duke@1: } duke@1: duke@1: public void visitAnnotation(JCAnnotation node) { duke@1: annotations = annotations.prepend(node); duke@1: if (verbose) { duke@1: StringBuilder sb = new StringBuilder(); duke@1: for (JCTree tree : path.reverse()) { duke@1: System.err.print(sb); duke@1: System.err.println(TreeInfo.symbolFor(tree)); duke@1: sb.append(" "); duke@1: } duke@1: System.err.print(sb); duke@1: System.err.println(node); duke@1: } duke@1: } duke@1: } duke@1: duke@1: private static List cleanTrees(List nodes) { duke@1: for (T node : nodes) duke@1: treeCleaner.scan(node); duke@1: return nodes; duke@1: } duke@1: duke@1: private static TreeScanner treeCleaner = new TreeScanner() { duke@1: public void scan(JCTree node) { duke@1: super.scan(node); duke@1: if (node != null) duke@1: node.type = null; duke@1: } duke@1: public void visitTopLevel(JCCompilationUnit node) { duke@1: node.packge = null; duke@1: super.visitTopLevel(node); duke@1: } duke@1: public void visitClassDef(JCClassDecl node) { duke@1: node.sym = null; duke@1: super.visitClassDef(node); duke@1: } duke@1: public void visitMethodDef(JCMethodDecl node) { duke@1: node.sym = null; duke@1: super.visitMethodDef(node); duke@1: } duke@1: public void visitVarDef(JCVariableDecl node) { duke@1: node.sym = null; duke@1: super.visitVarDef(node); duke@1: } duke@1: public void visitNewClass(JCNewClass node) { duke@1: node.constructor = null; duke@1: super.visitNewClass(node); duke@1: } duke@1: public void visitAssignop(JCAssignOp node) { duke@1: node.operator = null; duke@1: super.visitAssignop(node); duke@1: } duke@1: public void visitUnary(JCUnary node) { duke@1: node.operator = null; duke@1: super.visitUnary(node); duke@1: } duke@1: public void visitBinary(JCBinary node) { duke@1: node.operator = null; duke@1: super.visitBinary(node); duke@1: } duke@1: public void visitSelect(JCFieldAccess node) { duke@1: node.sym = null; duke@1: super.visitSelect(node); duke@1: } duke@1: public void visitIdent(JCIdent node) { duke@1: node.sym = null; duke@1: super.visitIdent(node); duke@1: } jjg@308: public void visitApply(JCMethodInvocation node) { jjg@308: scan(node.typeargs); jjg@308: super.visitApply(node); jjg@308: } duke@1: }; duke@1: duke@1: duke@1: private boolean moreToDo() { duke@1: return filer.newFiles(); duke@1: } duke@1: duke@1: /** duke@1: * {@inheritdoc} duke@1: * duke@1: * Command line options suitable for presenting to annotation duke@1: * processors. "-Afoo=bar" should be "-Afoo" => "bar". duke@1: */ duke@1: public Map getOptions() { duke@1: return processorOptions; duke@1: } duke@1: duke@1: public Messager getMessager() { duke@1: return messager; duke@1: } duke@1: duke@1: public Filer getFiler() { duke@1: return filer; duke@1: } duke@1: duke@1: public JavacElements getElementUtils() { duke@1: return elementUtils; duke@1: } duke@1: duke@1: public JavacTypes getTypeUtils() { duke@1: return typeUtils; duke@1: } duke@1: duke@1: public SourceVersion getSourceVersion() { duke@1: return Source.toSourceVersion(source); duke@1: } duke@1: duke@1: public Locale getLocale() { mcimadamore@136: return messages.getCurrentLocale(); duke@1: } duke@1: duke@1: public Set getSpecifiedPackages() { duke@1: return specifiedPackages; duke@1: } duke@1: duke@1: // Borrowed from DocletInvoker and apt duke@1: // TODO: remove from apt's Main duke@1: /** duke@1: * Utility method for converting a search path string to an array duke@1: * of directory and JAR file URLs. duke@1: * duke@1: * @param path the search path string duke@1: * @return the resulting array of directory and JAR file URLs duke@1: */ duke@1: public static URL[] pathToURLs(String path) { duke@1: StringTokenizer st = new StringTokenizer(path, File.pathSeparator); duke@1: URL[] urls = new URL[st.countTokens()]; duke@1: int count = 0; duke@1: while (st.hasMoreTokens()) { duke@1: URL url = fileToURL(new File(st.nextToken())); duke@1: if (url != null) { duke@1: urls[count++] = url; duke@1: } duke@1: } duke@1: if (urls.length != count) { duke@1: URL[] tmp = new URL[count]; duke@1: System.arraycopy(urls, 0, tmp, 0, count); duke@1: urls = tmp; duke@1: } duke@1: return urls; duke@1: } duke@1: duke@1: /** duke@1: * Returns the directory or JAR file URL corresponding to the specified duke@1: * local file name. duke@1: * duke@1: * @param file the File object duke@1: * @return the resulting directory or JAR file URL, or null if unknown duke@1: */ duke@1: private static URL fileToURL(File file) { duke@1: String name; duke@1: try { duke@1: name = file.getCanonicalPath(); duke@1: } catch (IOException e) { duke@1: name = file.getAbsolutePath(); duke@1: } duke@1: name = name.replace(File.separatorChar, '/'); duke@1: if (!name.startsWith("/")) { duke@1: name = "/" + name; duke@1: } duke@1: // If the file does not exist, then assume that it's a directory duke@1: if (!file.isFile()) { duke@1: name = name + "/"; duke@1: } duke@1: try { duke@1: return new URL("file", "", name); duke@1: } catch (MalformedURLException e) { duke@1: throw new IllegalArgumentException("file"); duke@1: } duke@1: } duke@1: duke@1: duke@1: duke@1: private static final Pattern allMatches = Pattern.compile(".*"); duke@1: duke@1: private static final Pattern noMatches = Pattern.compile("(\\P{all})+"); duke@1: /** duke@1: * Convert import-style string to regex matching that string. If duke@1: * the string is a valid import-style string, return a regex that duke@1: * won't match anything. duke@1: */ duke@1: // TODO: remove version in Apt.java duke@1: public static Pattern importStringToPattern(String s, Processor p, Log log) { duke@1: if (s.equals("*")) { duke@1: return allMatches; duke@1: } else { duke@1: String t = s; duke@1: boolean star = false; duke@1: duke@1: /* duke@1: * Validate string from factory is legal. If the string duke@1: * has more than one asterisks or the asterisks does not duke@1: * appear as the last character (preceded by a period), duke@1: * the string is not legal. duke@1: */ duke@1: duke@1: boolean valid = true; duke@1: int index = t.indexOf('*'); duke@1: if (index != -1) { duke@1: // '*' must be last character... duke@1: if (index == t.length() -1) { duke@1: // ... and preceeding character must be '.' duke@1: if ( index-1 >= 0 ) { duke@1: valid = t.charAt(index-1) == '.'; duke@1: // Strip off ".*$" for identifier checks duke@1: t = t.substring(0, t.length()-2); duke@1: } duke@1: } else duke@1: valid = false; duke@1: } duke@1: duke@1: // Verify string is off the form (javaId \.)+ or javaId duke@1: if (valid) { duke@1: String[] javaIds = t.split("\\.", t.length()+2); duke@1: for(String javaId: javaIds) duke@1: valid &= SourceVersion.isIdentifier(javaId); duke@1: } duke@1: duke@1: if (!valid) { duke@1: log.warning("proc.malformed.supported.string", s, p.getClass().getName()); duke@1: return noMatches; // won't match any valid identifier duke@1: } duke@1: duke@1: String s_prime = s.replaceAll("\\.", "\\\\."); duke@1: duke@1: if (s_prime.endsWith("*")) { duke@1: s_prime = s_prime.substring(0, s_prime.length() - 1) + ".+"; duke@1: } duke@1: duke@1: return Pattern.compile(s_prime); duke@1: } duke@1: } duke@1: duke@1: /** duke@1: * For internal use by Sun Microsystems only. This method will be duke@1: * removed without warning. duke@1: */ duke@1: public Context getContext() { duke@1: return context; duke@1: } duke@1: duke@1: public String toString() { duke@1: return "javac ProcessingEnvironment"; duke@1: } duke@1: duke@1: public static boolean isValidOptionName(String optionName) { duke@1: for(String s : optionName.split("\\.", -1)) { duke@1: if (!SourceVersion.isIdentifier(s)) duke@1: return false; duke@1: } duke@1: return true; duke@1: } duke@1: }