duke@1: /*
xdono@54: * Copyright 2005-2008 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.api;
duke@1:
duke@1: import java.io.File;
duke@1: import java.io.IOException;
duke@1: import java.util.*;
duke@1: import java.util.concurrent.atomic.AtomicBoolean;
duke@1:
duke@1: import javax.annotation.processing.Processor;
duke@1: import javax.lang.model.element.Element;
duke@1: import javax.lang.model.element.TypeElement;
duke@1: import javax.lang.model.type.TypeMirror;
duke@1: import javax.tools.*;
duke@1:
duke@1: import com.sun.source.tree.*;
duke@1: import com.sun.source.util.*;
duke@1: import com.sun.tools.javac.code.*;
duke@1: import com.sun.tools.javac.code.Symbol.*;
duke@1: import com.sun.tools.javac.comp.*;
jjg@50: import com.sun.tools.javac.file.JavacFileManager;
duke@1: import com.sun.tools.javac.main.*;
duke@1: import com.sun.tools.javac.model.*;
duke@1: import com.sun.tools.javac.parser.Parser;
duke@1: import com.sun.tools.javac.parser.Scanner;
duke@1: import com.sun.tools.javac.tree.*;
duke@1: import com.sun.tools.javac.tree.JCTree.*;
duke@1: import com.sun.tools.javac.util.*;
duke@1: import com.sun.tools.javac.util.List;
duke@1: import com.sun.tools.javac.main.JavaCompiler;
duke@1:
duke@1: /**
duke@1: * Provides access to functionality specific to the Sun Java Compiler, javac.
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
duke@1: * risk. This code and its internal interfaces are subject to change
duke@1: * or deletion without notice.
duke@1: *
duke@1: * @author Peter von der Ahé
duke@1: * @author Jonathan Gibbons
duke@1: */
duke@1: public class JavacTaskImpl extends JavacTask {
duke@1: private JavacTool tool;
duke@1: private Main compilerMain;
duke@1: private JavaCompiler compiler;
duke@1: private String[] args;
duke@1: private Context context;
duke@1: private List fileObjects;
duke@1: private Map notYetEntered;
duke@1: private ListBuffer> genList;
duke@1: private TaskListener taskListener;
duke@1: private AtomicBoolean used = new AtomicBoolean();
duke@1: private Iterable extends Processor> processors;
duke@1:
duke@1: private Integer result = null;
duke@1:
duke@1: JavacTaskImpl(JavacTool tool,
duke@1: Main compilerMain,
duke@1: String[] args,
duke@1: Context context,
duke@1: List fileObjects) {
duke@1: this.tool = tool;
duke@1: this.compilerMain = compilerMain;
duke@1: this.args = args;
duke@1: this.context = context;
duke@1: this.fileObjects = fileObjects;
duke@1: // null checks
duke@1: compilerMain.getClass();
duke@1: args.getClass();
duke@1: context.getClass();
duke@1: fileObjects.getClass();
duke@1: }
duke@1:
duke@1: JavacTaskImpl(JavacTool tool,
duke@1: Main compilerMain,
duke@1: Iterable flags,
duke@1: Context context,
duke@1: Iterable classes,
duke@1: Iterable extends JavaFileObject> fileObjects) {
duke@1: this(tool, compilerMain, toArray(flags, classes), context, toList(fileObjects));
duke@1: }
duke@1:
duke@1: static private String[] toArray(Iterable flags, Iterable classes) {
duke@1: ListBuffer result = new ListBuffer();
duke@1: if (flags != null)
duke@1: for (String flag : flags)
duke@1: result.append(flag);
duke@1: if (classes != null)
duke@1: for (String cls : classes)
duke@1: result.append(cls);
duke@1: return result.toArray(new String[result.length()]);
duke@1: }
duke@1:
duke@1: static private List toList(Iterable extends JavaFileObject> fileObjects) {
duke@1: if (fileObjects == null)
duke@1: return List.nil();
duke@1: ListBuffer result = new ListBuffer();
duke@1: for (JavaFileObject fo : fileObjects)
duke@1: result.append(fo);
duke@1: return result.toList();
duke@1: }
duke@1:
duke@1: public Boolean call() {
duke@1: if (!used.getAndSet(true)) {
duke@1: beginContext();
duke@1: try {
duke@1: compilerMain.setFatalErrors(true);
duke@1: result = compilerMain.compile(args, context, fileObjects, processors);
duke@1: } finally {
duke@1: endContext();
duke@1: }
duke@1: compilerMain = null;
duke@1: args = null;
duke@1: context = null;
duke@1: fileObjects = null;
duke@1: return result == 0;
duke@1: } else {
duke@1: throw new IllegalStateException("multiple calls to method 'call'");
duke@1: }
duke@1: }
duke@1:
duke@1: public void setProcessors(Iterable extends Processor> processors) {
duke@1: processors.getClass(); // null check
duke@1: // not mt-safe
duke@1: if (used.get())
duke@1: throw new IllegalStateException();
duke@1: this.processors = processors;
duke@1: }
duke@1:
duke@1: public void setLocale(Locale locale) {
duke@1: // locale argument is ignored, see RFE 6443132
duke@1: if (used.get())
duke@1: throw new IllegalStateException();
duke@1: }
duke@1:
duke@1: private void prepareCompiler() throws IOException {
duke@1: if (!used.getAndSet(true)) {
duke@1: beginContext();
duke@1: compilerMain.setOptions(Options.instance(context));
duke@1: compilerMain.filenames = new ListBuffer();
duke@1: List filenames = compilerMain.processArgs(CommandLine.parse(args));
duke@1: if (!filenames.isEmpty())
duke@1: throw new IllegalArgumentException("Malformed arguments " + filenames.toString(" "));
duke@1: compiler = JavaCompiler.instance(context);
duke@1: // force the use of the scanner that captures Javadoc comments
duke@1: com.sun.tools.javac.parser.DocCommentScanner.Factory.preRegister(context);
duke@1: compiler.keepComments = true;
duke@1: compiler.genEndPos = true;
duke@1: // NOTE: this value will be updated after annotation processing
duke@1: compiler.initProcessAnnotations(processors);
duke@1: notYetEntered = new HashMap();
duke@1: for (JavaFileObject file: fileObjects)
duke@1: notYetEntered.put(file, null);
duke@1: genList = new ListBuffer>();
duke@1: // endContext will be called when all classes have been generated
duke@1: // TODO: should handle the case after each phase if errors have occurred
duke@1: args = null;
duke@1: }
duke@1: }
duke@1:
duke@1: private void beginContext() {
duke@1: context.put(JavacTaskImpl.class, this);
duke@1: if (context.get(TaskListener.class) != null)
duke@1: context.put(TaskListener.class, (TaskListener)null);
duke@1: if (taskListener != null)
duke@1: context.put(TaskListener.class, wrap(taskListener));
duke@1: tool.beginContext(context);
duke@1: }
duke@1: // where
duke@1: private TaskListener wrap(final TaskListener tl) {
duke@1: tl.getClass(); // null check
duke@1: return new TaskListener() {
duke@1: public void started(TaskEvent e) {
duke@1: try {
duke@1: tl.started(e);
duke@1: } catch (Throwable t) {
duke@1: throw new ClientCodeException(t);
duke@1: }
duke@1: }
duke@1:
duke@1: public void finished(TaskEvent e) {
duke@1: try {
duke@1: tl.finished(e);
duke@1: } catch (Throwable t) {
duke@1: throw new ClientCodeException(t);
duke@1: }
duke@1: }
duke@1:
duke@1: };
duke@1: }
duke@1:
duke@1: private void endContext() {
duke@1: tool.endContext();
duke@1: }
duke@1:
duke@1: /**
duke@1: * Construct a JavaFileObject from the given file.
duke@1: *
duke@1: * TODO: this method is useless here
duke@1: *
duke@1: * @param file a file
duke@1: * @return a JavaFileObject from the standard file manager.
duke@1: */
duke@1: public JavaFileObject asJavaFileObject(File file) {
duke@1: JavacFileManager fm = (JavacFileManager)context.get(JavaFileManager.class);
duke@1: return fm.getRegularFile(file);
duke@1: }
duke@1:
duke@1: public void setTaskListener(TaskListener taskListener) {
duke@1: this.taskListener = taskListener;
duke@1: }
duke@1:
duke@1: /**
duke@1: * Parse the specified files returning a list of abstract syntax trees.
duke@1: *
duke@1: * @throws java.io.IOException TODO
duke@1: * @return a list of abstract syntax trees
duke@1: */
duke@1: public Iterable extends CompilationUnitTree> parse() throws IOException {
duke@1: try {
duke@1: prepareCompiler();
duke@1: List units = compiler.parseFiles(fileObjects);
duke@1: for (JCCompilationUnit unit: units) {
duke@1: JavaFileObject file = unit.getSourceFile();
duke@1: if (notYetEntered.containsKey(file))
duke@1: notYetEntered.put(file, unit);
duke@1: }
duke@1: return units;
duke@1: }
duke@1: finally {
duke@1: parsed = true;
duke@1: if (compiler != null && compiler.log != null)
duke@1: compiler.log.flush();
duke@1: }
duke@1: }
duke@1:
duke@1: private boolean parsed = false;
duke@1:
duke@1: /**
duke@1: * Translate all the abstract syntax trees to elements.
duke@1: *
duke@1: * @throws IOException TODO
duke@1: * @return a list of elements corresponding to the top level
duke@1: * classes in the abstract syntax trees
duke@1: */
duke@1: public Iterable extends TypeElement> enter() throws IOException {
duke@1: return enter(null);
duke@1: }
duke@1:
duke@1: /**
duke@1: * Translate the given abstract syntax trees to elements.
duke@1: *
duke@1: * @param trees a list of abstract syntax trees.
duke@1: * @throws java.io.IOException TODO
duke@1: * @return a list of elements corresponding to the top level
duke@1: * classes in the abstract syntax trees
duke@1: */
duke@1: public Iterable extends TypeElement> enter(Iterable extends CompilationUnitTree> trees)
duke@1: throws IOException
duke@1: {
duke@1: prepareCompiler();
duke@1:
duke@1: ListBuffer roots = null;
duke@1:
duke@1: if (trees == null) {
duke@1: // If there are still files which were specified to be compiled
duke@1: // (i.e. in fileObjects) but which have not yet been entered,
duke@1: // then we make sure they have been parsed and add them to the
duke@1: // list to be entered.
duke@1: if (notYetEntered.size() > 0) {
duke@1: if (!parsed)
duke@1: parse(); // TODO would be nice to specify files needed to be parsed
duke@1: for (JavaFileObject file: fileObjects) {
duke@1: JCCompilationUnit unit = notYetEntered.remove(file);
duke@1: if (unit != null) {
duke@1: if (roots == null)
duke@1: roots = new ListBuffer();
duke@1: roots.append(unit);
duke@1: }
duke@1: }
duke@1: notYetEntered.clear();
duke@1: }
duke@1: }
duke@1: else {
duke@1: for (CompilationUnitTree cu : trees) {
duke@1: if (cu instanceof JCCompilationUnit) {
duke@1: if (roots == null)
duke@1: roots = new ListBuffer();
duke@1: roots.append((JCCompilationUnit)cu);
duke@1: notYetEntered.remove(cu.getSourceFile());
duke@1: }
duke@1: else
duke@1: throw new IllegalArgumentException(cu.toString());
duke@1: }
duke@1: }
duke@1:
duke@1: if (roots == null)
duke@1: return List.nil();
duke@1:
duke@1: try {
duke@1: List units = compiler.enterTrees(roots.toList());
duke@1:
duke@1: if (notYetEntered.isEmpty())
duke@1: compiler = compiler.processAnnotations(units);
duke@1:
duke@1: ListBuffer elements = new ListBuffer();
duke@1: for (JCCompilationUnit unit : units) {
duke@1: for (JCTree node : unit.defs)
duke@1: if (node.getTag() == JCTree.CLASSDEF)
duke@1: elements.append(((JCTree.JCClassDecl) node).sym);
duke@1: }
duke@1: return elements.toList();
duke@1: }
duke@1: finally {
duke@1: compiler.log.flush();
duke@1: }
duke@1: }
duke@1:
duke@1: /**
duke@1: * Complete all analysis.
duke@1: * @throws IOException TODO
duke@1: */
duke@1: @Override
duke@1: public Iterable extends Element> analyze() throws IOException {
duke@1: return analyze(null);
duke@1: }
duke@1:
duke@1: /**
duke@1: * Complete all analysis on the given classes.
duke@1: * This can be used to ensure that all compile time errors are reported.
duke@1: * The classes must have previously been returned from {@link #enter}.
duke@1: * If null is specified, all outstanding classes will be analyzed.
duke@1: *
duke@1: * @param classes a list of class elements
duke@1: */
duke@1: // This implementation requires that we open up privileges on JavaCompiler.
duke@1: // An alternative implementation would be to move this code to JavaCompiler and
duke@1: // wrap it here
duke@1: public Iterable extends Element> analyze(Iterable extends TypeElement> classes) throws IOException {
duke@1: enter(null); // ensure all classes have been entered
duke@1:
duke@1: final ListBuffer results = new ListBuffer();
duke@1: try {
duke@1: if (classes == null) {
duke@1: handleFlowResults(compiler.flow(compiler.attribute(compiler.todo)), results);
duke@1: } else {
duke@1: Filter f = new Filter() {
duke@1: public void process(Env env) {
duke@1: handleFlowResults(compiler.flow(compiler.attribute(env)), results);
duke@1: }
duke@1: };
duke@1: f.run(compiler.todo, classes);
duke@1: }
duke@1: } finally {
duke@1: compiler.log.flush();
duke@1: }
duke@1: return results;
duke@1: }
duke@1: // where
duke@1: private void handleFlowResults(List> list, ListBuffer elems) {
duke@1: for (Env env: list) {
duke@1: switch (env.tree.getTag()) {
duke@1: case JCTree.CLASSDEF:
duke@1: JCClassDecl cdef = (JCClassDecl) env.tree;
duke@1: if (cdef.sym != null)
duke@1: elems.append(cdef.sym);
duke@1: break;
duke@1: case JCTree.TOPLEVEL:
duke@1: JCCompilationUnit unit = (JCCompilationUnit) env.tree;
duke@1: if (unit.packge != null)
duke@1: elems.append(unit.packge);
duke@1: break;
duke@1: }
duke@1: }
duke@1: genList.appendList(list);
duke@1: }
duke@1:
duke@1:
duke@1: /**
duke@1: * Generate code.
duke@1: * @throws IOException TODO
duke@1: */
duke@1: @Override
duke@1: public Iterable extends JavaFileObject> generate() throws IOException {
duke@1: return generate(null);
duke@1: }
duke@1:
duke@1: /**
duke@1: * Generate code corresponding to the given classes.
duke@1: * The classes must have previously been returned from {@link #enter}.
duke@1: * If there are classes outstanding to be analyzed, that will be done before
duke@1: * any classes are generated.
duke@1: * If null is specified, code will be generated for all outstanding classes.
duke@1: *
duke@1: * @param classes a list of class elements
duke@1: */
duke@1: public Iterable extends JavaFileObject> generate(Iterable extends TypeElement> classes) throws IOException {
duke@1: final ListBuffer results = new ListBuffer();
duke@1: try {
duke@1: analyze(null); // ensure all classes have been parsed, entered, and analyzed
duke@1:
duke@1: if (classes == null) {
duke@1: compiler.generate(compiler.desugar(genList.toList()), results);
duke@1: genList.clear();
duke@1: }
duke@1: else {
duke@1: Filter f = new Filter() {
duke@1: public void process(Env env) {
duke@1: compiler.generate(compiler.desugar(List.of(env)), results);
duke@1: }
duke@1: };
duke@1: f.run(genList, classes);
duke@1: }
duke@1: if (genList.isEmpty()) {
duke@1: compiler.reportDeferredDiagnostics();
duke@1: compiler.log.flush();
duke@1: endContext();
duke@1: }
duke@1: }
duke@1: finally {
duke@1: compiler.log.flush();
duke@1: }
duke@1: return results;
duke@1: }
duke@1:
duke@1: public TypeMirror getTypeMirror(Iterable extends Tree> path) {
duke@1: // TODO: Should complete attribution if necessary
duke@1: Tree last = null;
duke@1: for (Tree node : path)
duke@1: last = node;
duke@1: return ((JCTree)last).type;
duke@1: }
duke@1:
duke@1: public JavacElements getElements() {
duke@1: if (context == null)
duke@1: throw new IllegalStateException();
duke@1: return JavacElements.instance(context);
duke@1: }
duke@1:
duke@1: public JavacTypes getTypes() {
duke@1: if (context == null)
duke@1: throw new IllegalStateException();
duke@1: return JavacTypes.instance(context);
duke@1: }
duke@1:
duke@1: public Iterable extends Tree> pathFor(CompilationUnitTree unit, Tree node) {
duke@1: return TreeInfo.pathFor((JCTree) node, (JCTree.JCCompilationUnit) unit).reverse();
duke@1: }
duke@1:
duke@1: abstract class Filter {
duke@1: void run(ListBuffer> list, Iterable extends TypeElement> classes) {
duke@1: Set set = new HashSet();
duke@1: for (TypeElement item: classes)
duke@1: set.add(item);
duke@1:
duke@1: List> defer = List.>nil();
duke@1: while (list.nonEmpty()) {
duke@1: Env env = list.next();
duke@1: ClassSymbol csym = env.enclClass.sym;
duke@1: if (csym != null && set.contains(csym.outermostClass()))
duke@1: process(env);
duke@1: else
duke@1: defer = defer.prepend(env);
duke@1: }
duke@1:
duke@1: for (List> l = defer; l.nonEmpty(); l = l.tail)
duke@1: list.prepend(l.head);
duke@1: }
duke@1:
duke@1: abstract void process(Env env);
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: /**
duke@1: * For internal use by Sun Microsystems only. This method will be
duke@1: * removed without warning.
duke@1: */
duke@1: public void updateContext(Context newContext) {
duke@1: context = newContext;
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 Type parseType(String expr, TypeElement scope) {
duke@1: if (expr == null || expr.equals(""))
duke@1: throw new IllegalArgumentException();
duke@1: compiler = JavaCompiler.instance(context);
duke@1: JavaFileObject prev = compiler.log.useSource(null);
duke@1: Scanner.Factory scannerFactory = Scanner.Factory.instance(context);
duke@1: Parser.Factory parserFactory = Parser.Factory.instance(context);
duke@1: Attr attr = Attr.instance(context);
duke@1: try {
duke@1: Scanner scanner = scannerFactory.newScanner((expr+"\u0000").toCharArray(),
duke@1: expr.length());
duke@1: Parser parser = parserFactory.newParser(scanner, false, false);
duke@1: JCTree tree = parser.type();
duke@1: return attr.attribType(tree, (Symbol.TypeSymbol)scope);
duke@1: } finally {
duke@1: compiler.log.useSource(prev);
duke@1: }
duke@1: }
duke@1:
duke@1: }