src/share/classes/com/sun/tools/apt/main/Main.java

/*
 * Copyright 2004-2006 Sun Microsystems, Inc.  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.  Sun designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 * CA 95054 USA or visit www.sun.com if you need additional information or
 * have any questions.
 */

package com.sun.tools.apt.main;

import java.io.File;
import java.io.FileOutputStream;
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.util.Collection;

import java.net.URLClassLoader;
import java.net.URL;
import java.io.File;
import java.net.MalformedURLException;

import com.sun.tools.javac.util.Paths;
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;

/** This class provides a commandline interface to the apt build-time
 *  tool.
 *
 *  <p><b>This is NOT part of any API supported by Sun Microsystems.
 *  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 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;
            }
        },

        new HiddenOption("-Xswitchcheck") {
            boolean process(String option) {
                options.put("-Xlint:switchcheck", option);
                return false;
            }
        },

        // generate trace output for subtyping operations
        new HiddenOption("-debugsubtyping"),

        new XOption("-Xmaxerrs",        "opt.arg.number",       "opt.maxerrs"),
        new XOption("-Xmaxwarns",       "opt.arg.number",       "opt.maxwarns"),
        new XOption("-Xstdout",         "opt.arg.file",         "opt.Xstdout") {
            boolean process(String option, String arg) {
                try {
                    out = new PrintWriter(new FileWriter(arg), true);
                } catch (java.io.IOException e) {
                    error("err.error.writing.file", arg, e);
                    return true;
                }
                return super.process(option, arg);
            }
        },

        new XOption("-Xprint",                                  "opt.print"),

        new XOption("-XprintRounds",                            "opt.printRounds"),

        new XOption("-XprintProcessorInfo",                     "opt.printProcessorInfo"),


        /* -O is a no-op, accepted for backward compatibility. */
        new HiddenOption("-O"),

        /* -Xjcov produces tables to support the code coverage tool jcov. */
        new HiddenOption("-Xjcov"),

        /* This is a back door to the compiler's option table.
         * -Dx=y sets the option x to the value y.
         * -Dx sets the option x to the value x.
         */
        new HiddenOption("-XD") {
            String s;
            boolean matches(String s) {
                this.s = s;
                return s.startsWith(name);
            }
            boolean process(String option) {
                s = s.substring(name.length());
                int eq = s.indexOf('=');
                String key = (eq < 0) ? s : s.substring(0, eq);
                String value = (eq < 0) ? s : s.substring(eq+1);
                options.put(key, value);
                return false;
            }
        },

        new HiddenOption("sourcefile") {
                String s;
                boolean matches(String s) {
                    this.s = s;
                    return s.endsWith(".java") ||
                        (options.get("-XclassesAsDecls") != null);
                }
                boolean process(String option) {
                    if (s.endsWith(".java")) {
                        if (!sourceFileNames.contains(s))
                            sourceFileNames.add(s);
                    } else if (options.get("-XclassesAsDecls") != null) {
                        classFileNames.add(s);
                    }
                    return false;
                }
            },
    };

    /**
     * Construct a compiler instance.
     */
    public Main(String name) {
        this(name, new PrintWriter(System.err, true));
    }

    /**
     * Construct a compiler instance.
     */
    public Main(String name, PrintWriter out) {
        this.ownName = name;
        this.out = out;
    }

    /** A table of all options that's passed to the JavaCompiler constructor.  */
    private Options options = null;

    /** The list of source files to process
     */
    java.util.List<String> sourceFileNames = new java.util.LinkedList<String>();

    /** The list of class files to process
     */
    java.util.List<String> classFileNames = new java.util.LinkedList<String>();

    /** List of top level names of generated source files from most recent apt round.
     */
    java.util.Set<String> genSourceFileNames = new java.util.LinkedHashSet<String>();

    /** List of names of generated class files from most recent apt round.
     */
    java.util.Set<String> genClassFileNames  = new java.util.LinkedHashSet<String>();

    /**
     * List of all the generated source file names across all apt rounds.
     */
    java.util.Set<String> aggregateGenSourceFileNames = new java.util.LinkedHashSet<String>();

    /**
     * List of all the generated class file names across all apt rounds.
     */
    java.util.Set<String> aggregateGenClassFileNames  = new java.util.LinkedHashSet<String>();

    /**
     * List of all the generated file names across all apt rounds.
     */
    java.util.Set<java.io.File> aggregateGenFiles = new java.util.LinkedHashSet<java.io.File>();

    /**
     * Set of all factories that have provided a processor on some apt round.
     */
    java.util.Set<Class<? extends AnnotationProcessorFactory> > productiveFactories  =
        new java.util.LinkedHashSet<Class<? extends AnnotationProcessorFactory> >();



    /** Print a string that explains usage.
     */
    void help() {
        Bark.printLines(out, getLocalizedString("msg.usage.header", ownName));
        for (int i=0; i < recognizedOptions.length; i++) {
            recognizedOptions[i].help();
        }
        Bark.printLines(out, getLocalizedString("msg.usage.footer"));
        out.println();
    }

    /** Print a string that explains usage for X options.
     */
    void xhelp() {
        for (int i=0; i<recognizedOptions.length; i++) {
            recognizedOptions[i].xhelp();
        }
        out.println();
        Bark.printLines(out, getLocalizedString("msg.usage.nonstandard.footer"));
    }

    /** Report a usage error.
     */
    void error(String key, Object... args) {
        warning(key, args);
        help();
    }

    /** Report a warning.
     */
    void warning(String key, Object... args) {
        Bark.printLines(out, ownName + ": "
                       + getLocalizedString(key, args));
    }

    /** Process command line arguments: store all command line options
     *  in `options' table and return all source filenames.
     *  @param args    The array of command line arguments.
     */
    protected java.util.List<String> processArgs(String[] flags) {
        int ac = 0;
        while (ac < flags.length) {
            String flag = flags[ac];
            ac++;

            int j;
            for (j=0; j < recognizedOptions.length; j++)
                if (recognizedOptions[j].matches(flag))
                    break;

            if (j == recognizedOptions.length) {
                error("err.invalid.flag", flag);
                return null;
            }

            Option option = recognizedOptions[j];
            if (option.hasArg()) {
                if (ac == flags.length) {
                    error("err.req.arg", flag);
                    return null;
                }
                String operand = flags[ac];
                ac++;
                if (option.process(flag, operand))
                    return null;
            } else {
                if (option.process(flag))
                    return null;
            }
        }

        String sourceString = options.get("-source");
        Source source = (sourceString != null)
            ? Source.lookup(sourceString)
            : Source.JDK1_5; // JDK 5 is the latest supported source version
        String targetString = options.get("-target");
        Target target = (targetString != null)
            ? Target.lookup(targetString)
            : Target.JDK1_5; // JDK 5 is the latest supported source version
        // We don't check source/target consistency for CLDC, as J2ME
        // profiles are not aligned with J2SE targets; moreover, a
        // single CLDC target may have many profiles.  In addition,
        // this is needed for the continued functioning of the JSR14
        // prototype.
        if (Character.isDigit(target.name.charAt(0)) &&
            target.compareTo(source.requiredTarget()) < 0) {
            if (targetString != null) {
                if (sourceString == null) {
                    warning("warn.target.default.source.conflict",
                            targetString,
                            source.requiredTarget().name);
                } else {
                    warning("warn.source.target.conflict",
                            sourceString,
                            source.requiredTarget().name);
                }
                return null;
            } else {
                options.put("-target", source.requiredTarget().name);
            }
        }
        return sourceFileNames;
    }

    /** Programmatic interface for main function.
     * @param args    The command line parameters.
     */
    public int compile(String[] args, AnnotationProcessorFactory factory) {
        int returnCode = 0;
        providedFactory = factory;

        Context context = new Context();
        options = Options.instance(context);
        Bark bark;

        /*
         * Process the command line options to create the intial
         * options data.  This processing is at least partially reused
         * by any recursive apt calls.
         */

        // For testing: assume all arguments in forcedOpts are
        // prefixed to command line arguments.
        processArgs(forcedOpts);


        /*
         * A run of apt only gets passed the most recently generated
         * files; the initial run of apt gets passed the files from
         * the command line.
         */

        java.util.List<String> origFilenames;
        try {
            // assign args the result of parse to capture results of
            // '@file' expansion
            origFilenames = processArgs((args=CommandLine.parse(args)));
            if (origFilenames == null) {
                return EXIT_CMDERR;
            } else if (origFilenames.size() == 0) {
                // it is allowed to compile nothing if just asking for help
                if (options.get("-help") != null ||
                    options.get("-X") != null)
                    return EXIT_OK;
            }
        } catch (java.io.FileNotFoundException e) {
            Bark.printLines(out, ownName + ": " +
                           getLocalizedString("err.file.not.found",
                                              e.getMessage()));
            return EXIT_SYSERR;
        } catch (IOException ex) {
            ioMessage(ex);
            return EXIT_SYSERR;
        } catch (OutOfMemoryError ex) {
            resourceMessage(ex);
            return EXIT_SYSERR;
        } catch (StackOverflowError ex) {
            resourceMessage(ex);
            return EXIT_SYSERR;
        } catch (FatalError ex) {
            feMessage(ex);
            return EXIT_SYSERR;
        } catch (sun.misc.ServiceConfigurationError sce) {
            sceMessage(sce);
            return EXIT_ABNORMAL;
        } catch (Throwable ex) {
            bugMessage(ex);
            return EXIT_ABNORMAL;
        }


        boolean firstRound = true;
        boolean needSourcePath = false;
        boolean needClassPath  = false;
        boolean classesAsDecls = options.get("-XclassesAsDecls") != null;

        /*
         * Create augumented classpath and sourcepath values.
         *
         * If any of the prior apt rounds generated any new source
         * files, the n'th apt round (and any javac invocation) has the
         * source destination path ("-s path") as the last element of
         * the "-sourcepath" to the n'th call.
         *
         * If any of the prior apt rounds generated any new class files,
         * the n'th apt round (and any javac invocation) has the class
         * destination path ("-d path") as the last element of the
         * "-classpath" to the n'th call.
         */
        String augmentedSourcePath = "";
        String augmentedClassPath = "";
        String baseClassPath = "";

        try {
            /*
             * Record original options for future annotation processor
             * invocations.
             */
            origOptions = new HashMap<String, String>(options.size());
            for(String s: options.keySet()) {
                String value;
                if (s.equals(value = options.get(s)))
                    origOptions.put(s, (String)null);
                else
                    origOptions.put(s, value);
            }
            origOptions = Collections.unmodifiableMap(origOptions);

            {
                // Note: it might be necessary to check for an empty
                // component ("") of the source path or class path
                Paths paths = Paths.instance(context);

                String sourceDest = options.get("-s");
                if (paths.sourcePath() != null) {
                    for(File f: paths.sourcePath())
                        augmentedSourcePath += (f + File.pathSeparator);
                    augmentedSourcePath += (sourceDest == null)?".":sourceDest;
                } else {
                    augmentedSourcePath = ".";

                    if (sourceDest != null)
                        augmentedSourcePath += (File.pathSeparator + sourceDest);
                }

                String classDest = options.get("-d");
                if (paths.userClassPath() != null) {
                    for(File f: paths.userClassPath())
                        baseClassPath += (f + File.pathSeparator);
                    // put baseClassPath into map to handle any
                    // value needed for the classloader
                    options.put("-classpath", baseClassPath);

                    augmentedClassPath = baseClassPath + ((classDest == null)?".":classDest);
                } else {
                    baseClassPath = ".";
                    if (classDest != null)
                        augmentedClassPath = baseClassPath + (File.pathSeparator + classDest);
                }
                assert options.get("-classpath") != null;
            }

            /*
             * Create base and augmented class loaders
             */
            ClassLoader augmentedAptCL = null;
            {
            /*
             * Use a url class loader to look for classes on the
             * user-specified class path. Prepend computed bootclass
             * path, which includes extdirs, to the URLClassLoader apt
             * uses.
             */
                String aptclasspath = "";
                Paths paths = Paths.instance(context);
                String bcp = "";
                Collection<File> bootclasspath = paths.bootClassPath();

                if (bootclasspath != null) {
                    for(File f: bootclasspath)
                        bcp += (f + File.pathSeparator);
                }

                // If the factory path is set, use that path
                if (providedFactory == null)
                    aptclasspath = options.get("-factorypath");
                if (aptclasspath == null)
                    aptclasspath = options.get("-classpath");

                assert aptclasspath != null;
                aptclasspath = (bcp + aptclasspath);
                aptCL = new URLClassLoader(pathToURLs(aptclasspath));

                if (providedFactory == null &&
                    options.get("-factorypath") != null) // same CL even if new class files written
                    augmentedAptCL = aptCL;
                else {
                    // Create class loader in case new class files are
                    // written
                    augmentedAptCL = new URLClassLoader(pathToURLs(augmentedClassPath.
                                                                   substring(baseClassPath.length())),
                                                        aptCL);
                }
            }

            int round = 0; // For -XPrintAptRounds
            do {
                round++;

                Context newContext = new Context();
                Options newOptions = Options.instance(newContext); // creates a new context
                newOptions.putAll(options);

                // populate with old options... don't bother reparsing command line, etc.

                // if genSource files, must add destination to source path
                if (genSourceFileNames.size() > 0 && !firstRound) {
                    newOptions.put("-sourcepath", augmentedSourcePath);
                    needSourcePath = true;
                }
                aggregateGenSourceFileNames.addAll(genSourceFileNames);
                sourceFileNames.addAll(genSourceFileNames);
                genSourceFileNames.clear();

                // Don't really need to track this; just have to add -d
                // "foo" to class path if any class files are generated
                if (genClassFileNames.size() > 0) {
                    newOptions.put("-classpath", augmentedClassPath);
                    aptCL = augmentedAptCL;
                    needClassPath = true;
                }
                aggregateGenClassFileNames.addAll(genClassFileNames);
                classFileNames.addAll(genClassFileNames);
                genClassFileNames.clear();

                options = newOptions;

                if (options.get("-XPrintAptRounds") != null) {
                    out.println("apt Round : " + round);
                    out.println("filenames: " + sourceFileNames);
                    if (classesAsDecls)
                        out.println("classnames: " + classFileNames);
                    out.println("options: " + options);
                }

                returnCode = compile(args, newContext);
                firstRound = false;

                // Check for reported errors before continuing
                bark = Bark.instance(newContext);
            } while(((genSourceFileNames.size() != 0 ) ||
                     (classesAsDecls && genClassFileNames.size() != 0)) &&
                    bark.nerrors == 0);
        } catch (UsageMessageNeededException umne) {
            help();
            return EXIT_CMDERR; // will cause usage message to be printed
        }

        /*
         * Do not compile if a processor has reported an error or if
         * there are no source files to process.  A more sophisticated
         * test would also fail for syntax errors caught by javac.
         */
        if (options.get("-nocompile") == null &&
            options.get("-print")     == null &&
            bark.nerrors == 0 &&
            (origFilenames.size() > 0 || aggregateGenSourceFileNames.size() > 0 )) {
            /*
             * Need to create new argument string for calling javac:
             * 1. apt specific arguments (e.g. -factory) must be stripped out
             * 2. proper settings for sourcepath and classpath must be used
             * 3. generated class names must be added
             * 4. class file names as declarations must be removed
             */

            int newArgsLength = args.length +
                (needSourcePath?1:0) +
                (needClassPath?1:0) +
                aggregateGenSourceFileNames.size();

            // Null out apt-specific options and don't copy over into
            // newArgs. This loop should be a lot faster; the options
            // array should be replaced with a better data structure
            // which includes a map from strings to options.
            //
            // If treating classes as declarations, must strip out
            // class names from the javac argument list
            argLoop:
            for(int i = 0; i < args.length; i++) {
                int matchPosition = -1;

                // "-A" by itself is recognized by apt but not javac
                if (args[i] != null && args[i].equals("-A")) {
                    newArgsLength--;
                    args[i] = null;
                    continue argLoop;
                } else {
                    optionLoop:
                    for(int j = 0; j < recognizedOptions.length; j++) {
                        if (args[i] != null && recognizedOptions[j].matches(args[i])) {
                            matchPosition = j;
                            break optionLoop;
                        }
                    }

                    if (matchPosition != -1) {
                        Option op = recognizedOptions[matchPosition];
                        if (op.aptOnly) {
                            newArgsLength--;
                            args[i] = null;
                            if (op.hasArg()) {
                                newArgsLength--;
                                args[i+1] = null;
                            }
                        } else {
                            if (op.hasArg()) { // skip over next string
                                i++;
                                continue argLoop;
                            }

                            if ((options.get("-XclassesAsDecls") != null) &&
                                (matchPosition == (recognizedOptions.length-1)) ){
                                // Remove class file names from
                                // consideration by javac.
                                if (! args[i].endsWith(".java")) {
                                    newArgsLength--;
                                    args[i] = null;
                                }
                            }
                        }
                    }
                }
            }

            String newArgs[] = new String[newArgsLength];

            int j = 0;
            for(int i=0; i < args.length; i++) {
                if (args[i] != null)
                    newArgs[j++] = args[i];
            }

            if (needClassPath)
                newArgs[j++] = "-XD-classpath=" + augmentedClassPath;

            if (needSourcePath) {
                newArgs[j++] = "-XD-sourcepath=" + augmentedSourcePath;

                for(String s: aggregateGenSourceFileNames)
                    newArgs[j++] = s;
            }

            returnCode = com.sun.tools.javac.Main.compile(newArgs);
        }

        return returnCode;
    }

    /** Programmatic interface for main function.
     * @param args    The command line parameters.
     */
    int compile(String[] args, Context context) {
        boolean assertionsEnabled = false;
        assert assertionsEnabled = true;
        if (!assertionsEnabled) {
            // Bark.printLines(out, "fatal error: assertions must be enabled when running javac");
            // return EXIT_ABNORMAL;
        }
        int exitCode = EXIT_OK;

        JavaCompiler comp = null;
        try {
            context.put(Bark.outKey, out);

            comp = JavaCompiler.instance(context);
            if (comp == null)
                return EXIT_SYSERR;

            java.util.List<String> nameList = new java.util.LinkedList<String>();
            nameList.addAll(sourceFileNames);
            if (options.get("-XclassesAsDecls") != null)
                nameList.addAll(classFileNames);

            List<Symbol.ClassSymbol> cs
                = comp.compile(List.from(nameList.toArray(new String[0])),
                               origOptions,
                               aptCL,
                               providedFactory,
                               productiveFactories,
                               aggregateGenFiles);

            /*
             * If there aren't new source files, we shouldn't bother
             *  running javac if there were errors.
             *
             * If there are new files, we should try running javac in
             * case there were typing errors.
             *
             */

            if (comp.errorCount() != 0 ||
                options.get("-Werror") != null && comp.warningCount() != 0)
                return EXIT_ERROR;
        } catch (IOException ex) {
            ioMessage(ex);
            return EXIT_SYSERR;
        } catch (OutOfMemoryError ex) {
            resourceMessage(ex);
            return EXIT_SYSERR;
        } catch (StackOverflowError ex) {
            resourceMessage(ex);
            return EXIT_SYSERR;
        } catch (FatalError ex) {
            feMessage(ex);
            return EXIT_SYSERR;
        } catch (UsageMessageNeededException umne) {
            help();
            return EXIT_CMDERR; // will cause usage message to be printed
        } catch (AnnotationProcessingError ex) {
            apMessage(ex);
            return EXIT_ABNORMAL;
        } catch (sun.misc.ServiceConfigurationError sce) {
            sceMessage(sce);
            return EXIT_ABNORMAL;
        } catch (Throwable ex) {
            bugMessage(ex);
            return EXIT_ABNORMAL;
        } finally {
            if (comp != null) {
                comp.close();
                genSourceFileNames.addAll(comp.getSourceFileNames());
                genClassFileNames.addAll(comp.getClassFileNames());
            }
            sourceFileNames = new java.util.LinkedList<String>();
            classFileNames  = new java.util.LinkedList<String>();
        }
        return exitCode;
    }

    /** Print a message reporting an internal error.
     */
    void bugMessage(Throwable ex) {
        Bark.printLines(out, getLocalizedString("msg.bug",
                                               JavaCompiler.version()));
        ex.printStackTrace(out);
    }

    /** Print a message reporting an fatal error.
     */
    void apMessage(AnnotationProcessingError ex) {
        Bark.printLines(out, getLocalizedString("misc.Problem"));
        ex.getCause().printStackTrace(out);
    }

    /** Print a message about sun.misc.Service problem.
     */
    void sceMessage(sun.misc.ServiceConfigurationError ex) {
        Bark.printLines(out, getLocalizedString("misc.SunMiscService"));
        ex.printStackTrace(out);
    }

    /** Print a message reporting an fatal error.
     */
    void feMessage(Throwable ex) {
        Bark.printLines(out, ex.toString());
    }

    /** Print a message reporting an input/output error.
     */
    void ioMessage(Throwable ex) {
        Bark.printLines(out, getLocalizedString("msg.io"));
        ex.printStackTrace(out);
    }

    /** Print a message reporting an out-of-resources error.
     */
    void resourceMessage(Throwable ex) {
        Bark.printLines(out, getLocalizedString("msg.resource"));
        ex.printStackTrace(out);
    }

    /* ************************************************************************
     * Internationalization
     *************************************************************************/

    /** Find a localized string in the resource bundle.
     *  @param key     The key for the localized string.
     */
    private static String getLocalizedString(String key, Object... args) {
        return getText(key, args);
    }

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

    private static final String aptRB =
        "com.sun.tools.apt.resources.apt";

    private static ResourceBundle messageRBjavac;
    private static ResourceBundle messageRBapt;

    /** Initialize ResourceBundle.
     */
    private static void initResource() {
        try {
            messageRBapt   = ResourceBundle.getBundle(aptRB);
            messageRBjavac = ResourceBundle.getBundle(javacRB);
        } catch (MissingResourceException e) {
            Error x = new FatalError("Fatal Error: Resource for apt or javac is missing");
            x.initCause(e);
            throw x;
        }
    }

    /** Get and format message string from resource.
     */
    private static String getText(String key, Object... _args) {
        String[] args = new String[_args.length];
        for (int i=0; i<_args.length; i++) {
            args[i] = "" + _args[i];
        }
        if (messageRBapt == null || messageRBjavac == null )
            initResource();
        try {
            return MessageFormat.format(messageRBapt.getString("apt." + key),
                                        (Object[]) args);
        } catch (MissingResourceException e) {
            try {
                return MessageFormat.format(messageRBjavac.getString("javac." + key),
                                            (Object[]) args);
            } catch (MissingResourceException f) {
                String msg = "apt or javac message file broken: key={0} "
                    + "arguments={1}, {2}";
                return MessageFormat.format(msg, (Object[]) args);
            }
        }
    }

    // Borrowed from DocletInvoker
    /**
     * Utility method for converting a search path string to an array
     * of directory and JAR file URLs.
     *
     * @param path the search path string
     * @return the resulting array of directory and JAR file URLs
     */
    static URL[] pathToURLs(String path) {
        StringTokenizer st = new StringTokenizer(path, File.pathSeparator);
        URL[] urls = new URL[st.countTokens()];
        int count = 0;
        while (st.hasMoreTokens()) {
            URL url = fileToURL(new File(st.nextToken()));
            if (url != null) {
                urls[count++] = url;
            }
        }
        if (urls.length != count) {
            URL[] tmp = new URL[count];
            System.arraycopy(urls, 0, tmp, 0, count);
            urls = tmp;
        }
        return urls;
    }

    /**
     * Returns the directory or JAR file URL corresponding to the specified
     * local file name.
     *
     * @param file the File object
     * @return the resulting directory or JAR file URL, or null if unknown
     */
    static URL fileToURL(File file) {
        String name;
        try {
            name = file.getCanonicalPath();
        } catch (IOException e) {
            name = file.getAbsolutePath();
        }
        name = name.replace(File.separatorChar, '/');
        if (!name.startsWith("/")) {
            name = "/" + name;
        }
        // If the file does not exist, then assume that it's a directory
        if (!file.isFile()) {
            name = name + "/";
        }
        try {
            return new URL("file", "", name);
        } catch (MalformedURLException e) {
            throw new IllegalArgumentException("file");
        }
    }
}