/*

 * Copyright (c) 1999, 2010, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Oracle designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Oracle in the LICENSE file that accompanied this code.

 *

 * This code 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 General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package com.sun.tools.javac.main;

import java.io.*;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.LinkedHashMap;

import java.util.Map;

import java.util.MissingResourceException;

import java.util.Queue;

import java.util.ResourceBundle;

import java.util.Set;

import java.util.logging.Handler;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.annotation.processing.Processor;

import javax.lang.model.SourceVersion;

import javax.tools.JavaFileManager;

import javax.tools.JavaFileObject;

import javax.tools.DiagnosticListener;

import com.sun.source.util.TaskEvent;

import com.sun.source.util.TaskListener;

import com.sun.tools.javac.file.JavacFileManager;

import com.sun.tools.javac.util.*;

import com.sun.tools.javac.code.*;

import com.sun.tools.javac.code.Symbol.*;

import com.sun.tools.javac.tree.*;

import com.sun.tools.javac.tree.JCTree.*;

import com.sun.tools.javac.parser.*;

import com.sun.tools.javac.comp.*;

import com.sun.tools.javac.jvm.*;

import com.sun.tools.javac.processing.*;

import static javax.tools.StandardLocation.CLASS_OUTPUT;

import static com.sun.tools.javac.main.OptionName.*;

import static com.sun.tools.javac.util.JCDiagnostic.DiagnosticFlag.*;

import static com.sun.tools.javac.util.ListBuffer.lb;

/** This class could be the main entry point for GJC when GJC is used as a

 *  component in a larger software system. It provides operations to

 *  construct a new compiler, and to run a new compiler on a set of source

 *  files.

 *

 *  <p><b>This is NOT part of any supported API.

 *  If you write code that depends on this, you do so at your own risk.

 *  This code and its internal interfaces are subject to change or

 *  deletion without notice.</b>

 */

public class JavaCompiler implements ClassReader.SourceCompleter {

    /** The context key for the compiler. */

    protected static final Context.Key<JavaCompiler> compilerKey =

        new Context.Key<JavaCompiler>();

    /** Get the JavaCompiler instance for this context. */

    public static JavaCompiler instance(Context context) {

        JavaCompiler instance = context.get(compilerKey);

        if (instance == null)

            instance = new JavaCompiler(context);

        return instance;

    }

    /** The current version number as a string.

     */

    public static String version() {

        return version("release");  // mm.nn.oo[-milestone]

    }

    /** The current full version number as a string.

     */

    public static String fullVersion() {

        return version("full"); // mm.mm.oo[-milestone]-build

    }

    private static final String versionRBName = "com.sun.tools.javac.resources.version";

    private static ResourceBundle versionRB;

    private static String version(String key) {

        if (versionRB == null) {

            try {

                versionRB = ResourceBundle.getBundle(versionRBName);

            } catch (MissingResourceException e) {

                return Log.getLocalizedString("version.not.available");

            }

        }

        try {

            return versionRB.getString(key);

        }

        catch (MissingResourceException e) {

            return Log.getLocalizedString("version.not.available");

        }

    }

    /**

     * Control how the compiler's latter phases (attr, flow, desugar, generate)

     * are connected. Each individual file is processed by each phase in turn,

     * but with different compile policies, you can control the order in which

     * each class is processed through its next phase.

     *

     * <p>Generally speaking, the compiler will "fail fast" in the face of

     * errors, although not aggressively so. flow, desugar, etc become no-ops

     * once any errors have occurred. No attempt is currently made to determine

     * if it might be safe to process a class through its next phase because

     * it does not depend on any unrelated errors that might have occurred.

     */

    protected static enum CompilePolicy {

        /**

         * Just attribute the parse trees.

         */

        ATTR_ONLY,

        /**

         * Just attribute and do flow analysis on the parse trees.

         * This should catch most user errors.

         */

        CHECK_ONLY,

        /**

         * Attribute everything, then do flow analysis for everything,

         * then desugar everything, and only then generate output.

         * This means no output will be generated if there are any

         * errors in any classes.

         */

        SIMPLE,

        /**

         * Groups the classes for each source file together, then process

         * each group in a manner equivalent to the {@code SIMPLE} policy.

         * This means no output will be generated if there are any

         * errors in any of the classes in a source file.

         */

        BY_FILE,

        /**

         * Completely process each entry on the todo list in turn.

         * -- this is the same for 1.5.

         * Means output might be generated for some classes in a compilation unit

         * and not others.

         */

        BY_TODO;

        static CompilePolicy decode(String option) {

            if (option == null)

                return DEFAULT_COMPILE_POLICY;

            else if (option.equals("attr"))

                return ATTR_ONLY;

            else if (option.equals("check"))

                return CHECK_ONLY;

            else if (option.equals("simple"))

                return SIMPLE;

            else if (option.equals("byfile"))

                return BY_FILE;

            else if (option.equals("bytodo"))

                return BY_TODO;

            else

                return DEFAULT_COMPILE_POLICY;

        }

    }

    private static CompilePolicy DEFAULT_COMPILE_POLICY = CompilePolicy.BY_TODO;

    protected static enum ImplicitSourcePolicy {

        /** Don't generate or process implicitly read source files. */

        NONE,

        /** Generate classes for implicitly read source files. */

        CLASS,

        /** Like CLASS, but generate warnings if annotation processing occurs */

        UNSET;

        static ImplicitSourcePolicy decode(String option) {

            if (option == null)

                return UNSET;

            else if (option.equals("none"))

                return NONE;

            else if (option.equals("class"))

                return CLASS;

            else

                return UNSET;

        }

    }

    /** The log to be used for error reporting.

     */

    public Log log;

    /** Factory for creating diagnostic objects

     */

    JCDiagnostic.Factory diagFactory;

    /** The tree factory module.

     */

    protected TreeMaker make;

    /** The class reader.

     */

    protected ClassReader reader;

    /** The class writer.

     */

    protected ClassWriter writer;

    /** The module for the symbol table entry phases.

     */

    protected Enter enter;

    /** The symbol table.

     */

    protected Symtab syms;

    /** The language version.

     */

    protected Source source;

    /** The module for code generation.

     */

    protected Gen gen;

    /** The name table.

     */

    protected Names names;

    /** The attributor.

     */

    protected Attr attr;

    /** The attributor.

     */

    protected Check chk;

    /** The flow analyzer.

     */

    protected Flow flow;

    /** The type eraser.

     */

    protected TransTypes transTypes;

    /** The syntactic sugar desweetener.

     */

    protected Lower lower;

    /** The annotation annotator.

     */

    protected Annotate annotate;

    /** Force a completion failure on this name

     */

    protected final Name completionFailureName;

    /** Type utilities.

     */

    protected Types types;

    /** Access to file objects.

     */

    protected JavaFileManager fileManager;

    /** Factory for parsers.

     */

    protected ParserFactory parserFactory;

    /** Optional listener for progress events

     */

    protected TaskListener taskListener;

    /**

     * Annotation processing may require and provide a new instance

     * of the compiler to be used for the analyze and generate phases.

     */

    protected JavaCompiler delegateCompiler;

    /**

     * Flag set if any annotation processing occurred.

     **/

    protected boolean annotationProcessingOccurred;

    /**

     * Flag set if any implicit source files read.

     **/

    protected boolean implicitSourceFilesRead;

    protected Context context;

    /** Construct a new compiler using a shared context.

     */

    public JavaCompiler(final Context context) {

        this.context = context;

        context.put(compilerKey, this);

        // if fileManager not already set, register the JavacFileManager to be used

        if (context.get(JavaFileManager.class) == null)

            JavacFileManager.preRegister(context);

        names = Names.instance(context);

        log = Log.instance(context);

        diagFactory = JCDiagnostic.Factory.instance(context);

        reader = ClassReader.instance(context);

        make = TreeMaker.instance(context);

        writer = ClassWriter.instance(context);

        enter = Enter.instance(context);

        todo = Todo.instance(context);

        fileManager = context.get(JavaFileManager.class);

        parserFactory = ParserFactory.instance(context);

        try {

            // catch completion problems with predefineds

            syms = Symtab.instance(context);

        } catch (CompletionFailure ex) {

            // inlined Check.completionError as it is not initialized yet

            log.error("cant.access", ex.sym, ex.getDetailValue());

            if (ex instanceof ClassReader.BadClassFile)

                throw new Abort();

        }

        source = Source.instance(context);

        attr = Attr.instance(context);

        chk = Check.instance(context);

        gen = Gen.instance(context);

        flow = Flow.instance(context);

        transTypes = TransTypes.instance(context);

        lower = Lower.instance(context);

        annotate = Annotate.instance(context);

        types = Types.instance(context);

        taskListener = context.get(TaskListener.class);

        reader.sourceCompleter = this;

        Options options = Options.instance(context);

        verbose       = options.isSet(VERBOSE);

        sourceOutput  = options.isSet(PRINTSOURCE); // used to be -s

        stubOutput    = options.isSet("-stubs");

        relax         = options.isSet("-relax");

        printFlat     = options.isSet("-printflat");

        attrParseOnly = options.isSet("-attrparseonly");

        encoding      = options.get(ENCODING);

        lineDebugInfo = options.isUnset(G_CUSTOM) ||

                        options.isSet(G_CUSTOM, "lines");

        genEndPos     = options.isSet(XJCOV) ||

                        context.get(DiagnosticListener.class) != null;

        devVerbose    = options.isSet("dev");

        processPcks   = options.isSet("process.packages");

        werror        = options.isSet(WERROR);

        verboseCompilePolicy = options.isSet("verboseCompilePolicy");

        if (attrParseOnly)

            compilePolicy = CompilePolicy.ATTR_ONLY;

        else

            compilePolicy = CompilePolicy.decode(options.get("compilePolicy"));

        implicitSourcePolicy = ImplicitSourcePolicy.decode(options.get("-implicit"));

        completionFailureName =

            options.isSet("failcomplete")

            ? names.fromString(options.get("failcomplete"))

            : null;

        shouldStopPolicy =

            options.isSet("shouldStopPolicy")

            ? CompileState.valueOf(options.get("shouldStopPolicy"))

            : null;

        if (options.isUnset("oldDiags"))

            log.setDiagnosticFormatter(RichDiagnosticFormatter.instance(context));

    }

    /* Switches:

     */

    /** Verbose output.

     */

    public boolean verbose;

    /** Emit plain Java source files rather than class files.

     */

    public boolean sourceOutput;

    /** Emit stub source files rather than class files.

     */

    public boolean stubOutput;

    /** Generate attributed parse tree only.

     */

    public boolean attrParseOnly;

    /** Switch: relax some constraints for producing the jsr14 prototype.

     */

    boolean relax;

    /** Debug switch: Emit Java sources after inner class flattening.

     */

    public boolean printFlat;

    /** The encoding to be used for source input.

     */

    public String encoding;

    /** Generate code with the LineNumberTable attribute for debugging

     */

    public boolean lineDebugInfo;

    /** Switch: should we store the ending positions?

     */

    public boolean genEndPos;

    /** Switch: should we debug ignored exceptions

     */

    protected boolean devVerbose;

    /** Switch: should we (annotation) process packages as well

     */

    protected boolean processPcks;

    /** Switch: treat warnings as errors

     */

    protected boolean werror;

    /** Switch: is annotation processing requested explitly via

     * CompilationTask.setProcessors?

     */

    protected boolean explicitAnnotationProcessingRequested = false;

    /**

     * The policy for the order in which to perform the compilation

     */

    protected CompilePolicy compilePolicy;

    /**

     * The policy for what to do with implicitly read source files

     */

    protected ImplicitSourcePolicy implicitSourcePolicy;

    /**

     * Report activity related to compilePolicy

     */

    public boolean verboseCompilePolicy;

    /**

     * Policy of how far to continue processing. null means until first

     * error.

     */

    public CompileState shouldStopPolicy;

    /** A queue of all as yet unattributed classes.

     */

    public Todo todo;

    /** Ordered list of compiler phases for each compilation unit. */

    public enum CompileState {

        PARSE(1),

        ENTER(2),

        PROCESS(3),

        ATTR(4),

        FLOW(5),

        TRANSTYPES(6),

        LOWER(7),

        GENERATE(8);

        CompileState(int value) {

            this.value = value;

        }

        boolean isDone(CompileState other) {

            return value >= other.value;

        }

        private int value;

    };

    /** Partial map to record which compiler phases have been executed

     * for each compilation unit. Used for ATTR and FLOW phases.

     */

    protected class CompileStates extends HashMap<Env<AttrContext>,CompileState> {

        private static final long serialVersionUID = 1812267524140424433L;

        boolean isDone(Env<AttrContext> env, CompileState cs) {

            CompileState ecs = get(env);

            return ecs != null && ecs.isDone(cs);

        }

    }

    private CompileStates compileStates = new CompileStates();

    /** The set of currently compiled inputfiles, needed to ensure

     *  we don't accidentally overwrite an input file when -s is set.

     *  initialized by `compile'.

     */

    protected Set<JavaFileObject> inputFiles = new HashSet<JavaFileObject>();

    protected boolean shouldStop(CompileState cs) {

        if (shouldStopPolicy == null)