/*

 * Copyright (c) 2004, 2008, 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.apt.main;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.PrintWriter;

import java.text.MessageFormat;

import java.util.ResourceBundle;

import java.util.MissingResourceException;

import java.util.StringTokenizer;

import java.util.Map;

import java.util.HashMap;

import java.util.Collections;

import java.net.URLClassLoader;

import java.net.URL;

import java.net.MalformedURLException;

import javax.tools.JavaFileManager;

import javax.tools.StandardLocation;

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

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

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

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

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

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

import com.sun.tools.apt.comp.AnnotationProcessingError;

import com.sun.tools.apt.comp.UsageMessageNeededException;

import com.sun.tools.apt.util.Bark;

import com.sun.mirror.apt.AnnotationProcessorFactory;

import static com.sun.tools.javac.file.Paths.pathToURLs;

/** This class provides a commandline interface to the apt build-time

 *  tool.

 *

 *  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>

 */

@SuppressWarnings("deprecation")

public class Main {

    /** For testing: enter any options you want to be set implicitly

     *  here.

     */

    static String[] forcedOpts = {

        // Preserve parameter names from class files if the class was

        // compiled with debug enabled

        "-XDsave-parameter-names"

    };

    /** The name of the compiler, for use in diagnostics.

     */

    String ownName;

    /** The writer to use for diagnostic output.

     */

    PrintWriter out;

    /** Instantiated factory to use in lieu of discovery process.

     */

    AnnotationProcessorFactory providedFactory = null;

    /** Map representing original command-line arguments.

     */

    Map<String,String> origOptions = new HashMap<String, String>();

    /** Classloader to use for finding factories.

     */

    ClassLoader aptCL = null;

    /** Result codes.

     */

    static final int

        EXIT_OK = 0,        // Compilation completed with no errors.

        EXIT_ERROR = 1,     // Completed but reported errors.

        EXIT_CMDERR = 2,    // Bad command-line arguments

        EXIT_SYSERR = 3,    // System error or resource exhaustion.

        EXIT_ABNORMAL = 4;  // Compiler terminated abnormally

    /** This class represents an option recognized by the main program

     */

    private class Option {

        /** Whether or not the option is used only aptOnly.

         */

        boolean aptOnly = false;

        /** Option string.

         */

        String name;

        /** Documentation key for arguments.

         */

        String argsNameKey;

        /** Documentation key for description.

         */

        String descrKey;

        /** Suffix option (-foo=bar or -foo:bar)

         */

        boolean hasSuffix;

        Option(String name, String argsNameKey, String descrKey) {

            this.name = name;

            this.argsNameKey = argsNameKey;

            this.descrKey = descrKey;

            char lastChar = name.charAt(name.length()-1);

            hasSuffix = lastChar == ':' || lastChar == '=';

        }

        Option(String name, String descrKey) {

            this(name, null, descrKey);

        }

        public String toString() {

            return name;

        }

        /** Does this option take a (separate) operand?

         */

        boolean hasArg() {

            return argsNameKey != null && !hasSuffix;

        }

        /** Does argument string match option pattern?

         *  @param arg        The command line argument string.

         */

        boolean matches(String arg) {

            return hasSuffix ? arg.startsWith(name) : arg.equals(name);

        }

        /** For javac-only options, print nothing.

         */

        void help() {

        }

        String helpSynopsis() {

            return name +

                (argsNameKey == null ? "" :

                 ((hasSuffix ? "" : " ") +

                  getLocalizedString(argsNameKey)));

        }

        /** Print a line of documentation describing this option, if non-standard.

         */

        void xhelp() {}

        /** Process the option (with arg). Return true if error detected.

         */

        boolean process(String option, String arg) {

            options.put(option, arg);

            return false;

        }

        /** Process the option (without arg). Return true if error detected.

         */

        boolean process(String option) {

            if (hasSuffix)

                return process(name, option.substring(name.length()));

            else

                return process(option, option);

        }

    };

    private class SharedOption extends Option {

        SharedOption(String name, String argsNameKey, String descrKey) {

            super(name, argsNameKey, descrKey);

        }

        SharedOption(String name, String descrKey) {

            super(name, descrKey);

        }

        void help() {

            String s = "  " + helpSynopsis();

            out.print(s);

            for (int j = s.length(); j < 29; j++) out.print(" ");

            Bark.printLines(out, getLocalizedString(descrKey));

        }

    }

    private class AptOption extends Option {

        AptOption(String name, String argsNameKey, String descrKey) {

            super(name, argsNameKey, descrKey);

            aptOnly = true;

        }

        AptOption(String name, String descrKey) {

            super(name, descrKey);

            aptOnly = true;

        }

        /** Print a line of documentation describing this option, if standard.

         */

        void help() {

            String s = "  " + helpSynopsis();

            out.print(s);

            for (int j = s.length(); j < 29; j++) out.print(" ");

            Bark.printLines(out, getLocalizedString(descrKey));

        }

    }

    /** A nonstandard or extended (-X) option

     */

    private class XOption extends Option {

        XOption(String name, String argsNameKey, String descrKey) {

            super(name, argsNameKey, descrKey);

        }

        XOption(String name, String descrKey) {

            this(name, null, descrKey);

        }

        void help() {}

        void xhelp() {}

    };

    /** A nonstandard or extended (-X) option

     */

    private class AptXOption extends Option {

        AptXOption(String name, String argsNameKey, String descrKey) {

            super(name, argsNameKey, descrKey);

            aptOnly = true;

        }

        AptXOption(String name, String descrKey) {

            this(name, null, descrKey);

        }

        void xhelp() {

            String s = "  " + helpSynopsis();

            out.print(s);

            for (int j = s.length(); j < 29; j++) out.print(" ");

            Log.printLines(out, getLocalizedString(descrKey));

        }

    };

    /** A hidden (implementor) option

     */

    private class HiddenOption extends Option {

        HiddenOption(String name) {

            super(name, null, null);

        }

        HiddenOption(String name, String argsNameKey) {

            super(name, argsNameKey, null);

        }

        void help() {}

        void xhelp() {}

    };

    private class AptHiddenOption extends HiddenOption {

        AptHiddenOption(String name) {

            super(name);

            aptOnly = true;

        }

        AptHiddenOption(String name, String argsNameKey) {

            super(name, argsNameKey);

            aptOnly = true;

        }

    }

    private Option[] recognizedOptions = {

        new Option("-g",                                        "opt.g"),

        new Option("-g:none",                                   "opt.g.none") {

            boolean process(String option) {

                options.put("-g:", "none");

                return false;

            }

        },

        new Option("-g:{lines,vars,source}",                    "opt.g.lines.vars.source") {

            boolean matches(String s) {

                return s.startsWith("-g:");

            }

            boolean process(String option) {

                String suboptions = option.substring(3);

                options.put("-g:", suboptions);

                // enter all the -g suboptions as "-g:suboption"

                for (StringTokenizer t = new StringTokenizer(suboptions, ","); t.hasMoreTokens(); ) {

                    String tok = t.nextToken();

                    String opt = "-g:" + tok;

                    options.put(opt, opt);

                }

                return false;

            }

        },

        new XOption("-Xlint",                                   "opt.Xlint"),

        new XOption("-Xlint:{"

                    + "all,"

                    + "cast,deprecation,divzero,empty,unchecked,fallthrough,path,serial,finally,overrides,"

                    + "-cast,-deprecation,-divzero,-empty,-unchecked,-fallthrough,-path,-serial,-finally,-overrides,"

                    + "none}",

                                                                "opt.Xlint.suboptlist") {

            boolean matches(String s) {

                return s.startsWith("-Xlint:");

            }

            boolean process(String option) {

                String suboptions = option.substring(7);

                options.put("-Xlint:", suboptions);

                // enter all the -Xlint suboptions as "-Xlint:suboption"

                for (StringTokenizer t = new StringTokenizer(suboptions, ","); t.hasMoreTokens(); ) {

                    String tok = t.nextToken();

                    String opt = "-Xlint:" + tok;

                    options.put(opt, opt);

                }

                return false;

            }

        },

        new Option("-nowarn",                                   "opt.nowarn"),

        new Option("-verbose",                                  "opt.verbose"),

        // -deprecation is retained for command-line backward compatibility

        new Option("-deprecation",                              "opt.deprecation") {

                boolean process(String option) {

                    options.put("-Xlint:deprecation", option);

                    return false;

                }

            },

        new SharedOption("-classpath",     "opt.arg.path",      "opt.classpath"),

        new SharedOption("-cp",            "opt.arg.path",      "opt.classpath") {

            boolean process(String option, String arg) {

                return super.process("-classpath", arg);

            }

        },

        new Option("-sourcepath",          "opt.arg.path",      "opt.sourcepath"),

        new Option("-bootclasspath",       "opt.arg.path",      "opt.bootclasspath") {

            boolean process(String option, String arg) {

                options.remove("-Xbootclasspath/p:");

                options.remove("-Xbootclasspath/a:");

                return super.process(option, arg);

            }

        },

        new XOption("-Xbootclasspath/p:",  "opt.arg.path", "opt.Xbootclasspath.p"),

        new XOption("-Xbootclasspath/a:",  "opt.arg.path", "opt.Xbootclasspath.a"),

        new XOption("-Xbootclasspath:",    "opt.arg.path", "opt.bootclasspath") {

            boolean process(String option, String arg) {

                options.remove("-Xbootclasspath/p:");

                options.remove("-Xbootclasspath/a:");

                return super.process("-bootclasspath", arg);

            }

        },

        new Option("-extdirs",             "opt.arg.dirs",      "opt.extdirs"),

        new XOption("-Djava.ext.dirs=",    "opt.arg.dirs",      "opt.extdirs") {

            boolean process(String option, String arg) {

                return super.process("-extdirs", arg);

            }

        },

        new Option("-endorseddirs",        "opt.arg.dirs",      "opt.endorseddirs"),

        new XOption("-Djava.endorsed.dirs=","opt.arg.dirs",     "opt.endorseddirs") {

            boolean process(String option, String arg) {

                return super.process("-endorseddirs", arg);

            }

        },

        new Option("-proc:{none, only}",                        "opt.proc.none.only") {

            public boolean matches(String s) {

                return s.equals("-proc:none") || s.equals("-proc:only");

            }

        },

        new Option("-processor",        "opt.arg.class",        "opt.processor"),

        new Option("-processorpath",    "opt.arg.path",         "opt.processorpath"),

        new SharedOption("-d",          "opt.arg.path", "opt.d"),

        new SharedOption("-s",          "opt.arg.path", "opt.s"),

        new Option("-encoding",         "opt.arg.encoding",     "opt.encoding"),

        new SharedOption("-source",             "opt.arg.release",      "opt.source") {

            boolean process(String option, String operand) {

                Source source = Source.lookup(operand);

                if (source == null) {

                    error("err.invalid.source", operand);

                    return true;

                } else if (source.compareTo(Source.JDK1_5) > 0) {

                    error("err.unsupported.source.version", operand);

                    return true;

                }

                return super.process(option, operand);

            }

        },

        new Option("-target",           "opt.arg.release",      "opt.target") {

            boolean process(String option, String operand) {

                Target target = Target.lookup(operand);

                if (target == null) {

                    error("err.invalid.target", operand);

                    return true;

                } else if (target.compareTo(Target.JDK1_5) > 0) {

                    error("err.unsupported.target.version", operand);

                    return true;

                }

                return super.process(option, operand);

            }

        },

        new AptOption("-version",               "opt.version") {

            boolean process(String option) {

                Bark.printLines(out, ownName + " " + JavaCompiler.version());

                return super.process(option);

            }

        },

        new HiddenOption("-fullversion"),

        new AptOption("-help",                                  "opt.help") {

            boolean process(String option) {

                Main.this.help();

                return super.process(option);

            }

        },

        new SharedOption("-X",                                  "opt.X") {

            boolean process(String option) {

                Main.this.xhelp();

                return super.process(option);

            }

        },

        // This option exists only for the purpose of documenting itself.

        // It's actually implemented by the launcher.

        new AptOption("-J",             "opt.arg.flag",         "opt.J") {

            String helpSynopsis() {

                hasSuffix = true;

                return super.helpSynopsis();

            }

            boolean process(String option) {

                throw new AssertionError

                    ("the -J flag should be caught by the launcher.");

            }

        },

        new SharedOption("-A",          "opt.proc.flag",        "opt.A") {

                String helpSynopsis() {

                    hasSuffix = true;

                    return super.helpSynopsis();

                }

                boolean matches(String arg) {

                    return arg.startsWith("-A");

                }

                boolean hasArg() {

                    return false;

                }

                boolean process(String option) {

                    return process(option, option);

                }

            },

        new AptOption("-nocompile",     "opt.nocompile"),

        new AptOption("-print",         "opt.print"),

        new AptOption("-factorypath", "opt.arg.path", "opt.factorypath"),

        new AptOption("-factory",     "opt.arg.class", "opt.factory"),

        new AptXOption("-XListAnnotationTypes", "opt.XListAnnotationTypes"),

        new AptXOption("-XListDeclarations",    "opt.XListDeclarations"),

        new AptXOption("-XPrintAptRounds",      "opt.XPrintAptRounds"),

        new AptXOption("-XPrintFactoryInfo",    "opt.XPrintFactoryInfo"),

        /*

         * Option to treat both classes and source files as

         * declarations that can be given on the command line and

         * processed as the result of an apt round.

         */

        new AptXOption("-XclassesAsDecls", "opt.XClassesAsDecls"),

        // new Option("-moreinfo",                                      "opt.moreinfo") {

        new HiddenOption("-moreinfo") {

            boolean process(String option) {

                Type.moreInfo = true;

                return super.process(option);

            }

        },

        // treat warnings as errors

        new HiddenOption("-Werror"),

        // use complex inference from context in the position of a method call argument

        new HiddenOption("-complexinference"),

        // prompt after each error

        // new Option("-prompt",                                        "opt.prompt"),

        new HiddenOption("-prompt"),

        // dump stack on error

        new HiddenOption("-doe"),

        // display warnings for generic unchecked and unsafe operations

        new HiddenOption("-warnunchecked") {

            boolean process(String option) {

                options.put("-Xlint:unchecked", option);

                return false;

            }

        },