/* * Copyright (c) 1994, 2004, 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 sun.tools.javac; import sun.tools.java.*;import sun.tools.util.CommandLine;// JCOVimport sun.tools.asm.Assembler;// end JCOV import java.util.*;import java.io.*;import java.text.MessageFormat; /** * Main program of the Java compiler * * WARNING: The contents of this source file are not part of any * supported API.  Code that depends on them does so at its own risk: * they are subject to change or removal without notice. * * @deprecated As of J2SE 1.3, the preferred way to compile Java * language sources is by using the new compiler, * com.sun.tools.javac.Main. */@Deprecatedpublicclass Main implements Constants {    /**     * Name of the program.     */    String program;     /**     * The stream where error message are printed.     */    OutputStream out;     /**     * Constructor.     */    public Main(OutputStream out, String program) {        this.out = out;        this.program = program;    }     /**     * Exit status.     * We introduce a separate integer status variable, and do not alter the     * convention that 'compile' returns a boolean true upon a successful     * compilation with no errors.  (JavaTest relies on this.)     */     public static final int EXIT_OK = 0;        // Compilation completed with no errors.    public static final int EXIT_ERROR = 1;     // Compilation completed but reported errors.    public static final int EXIT_CMDERR = 2;    // Bad command-line arguments and/or switches.    public static final int EXIT_SYSERR = 3;    // System error or resource exhaustion.    public static final int EXIT_ABNORMAL = 4;  // Compiler terminated abnormally.     private int exitStatus;     public int getExitStatus() {        return exitStatus;    }     public boolean compilationPerformedSuccessfully() {        return exitStatus == EXIT_OK || exitStatus == EXIT_ERROR;    }     public boolean compilationReportedErrors () {        return exitStatus != EXIT_OK;    }     /**     * Output a message.     */    private void output(String msg) {        PrintStream out =            this.out instanceof PrintStream ? (PrintStream)this.out                                            : new PrintStream(this.out, true);        out.println(msg);    }     /**     * Top level error message.  This method is called when the     * environment could not be set up yet.     */    private void error(String msg) {        exitStatus = EXIT_CMDERR;        output(getText(msg));    }     private void error(String msg, String arg1) {        exitStatus = EXIT_CMDERR;        output(getText(msg, arg1));    }     private void error(String msg, String arg1, String arg2) {        exitStatus = EXIT_CMDERR;        output(getText(msg, arg1, arg2));    }     /**     * Print usage message and make exit status an error.     * Note: 'javac' invoked without any arguments is considered     * be an error.     */    public void usage_error() {        error("main.usage", program);    }     private static ResourceBundle messageRB;     /**     * Initialize ResourceBundle     */    static void initResource() {        try {            messageRB =                ResourceBundle.getBundle("sun.tools.javac.resources.javac");        } catch (MissingResourceException e) {            throw new Error("Fatal: Resource for javac is missing");        }    }     /**     * get and format message string from resource     */    public static String getText(String key) {        return getText(key, (String)null);    }     public static String getText(String key, int num) {        return getText(key, Integer.toString(num));    }     public static String getText(String key, String fixed) {        return getText(key, fixed, null);    }     public static String getText(String key, String fixed1, String fixed2) {        return getText(key, fixed1, fixed2, null);    }     public static String getText(String key, String fixed1,                                 String fixed2, String fixed3) {        if (messageRB == null) {            initResource();        }        try {            String message = messageRB.getString(key);            return MessageFormat.format(message, fixed1, fixed2, fixed3);        } catch (MissingResourceException e) {            if (fixed1 == null)  fixed1 = "null";            if (fixed2 == null)  fixed2 = "null";            if (fixed3 == null)  fixed3 = "null";            String message = "JAVAC MESSAGE FILE IS BROKEN: key={0}, arguments={1}, {2}, {3}";            return MessageFormat.format(message, key, fixed1, fixed2, fixed3);        }    }     // What major and minor version numbers to use for the -target flag.    // This should grow every time the minor version number accepted by    // the VM is incremented.    private static final String[] releases =      { "1.1", "1.2", "1.3", "1.4" };    private static final short[] majorVersions =  {    45,    46,    47,    48 };    private static final short[] minorVersions =  {     3,     0,     0,     0 };     /**     * Run the compiler     */    public synchronized boolean compile(String argv[]) {        String sourcePathArg = null;        String classPathArg = null;        String sysClassPathArg = null;        String extDirsArg = null;        boolean verbosePath = false;         String targetArg = null;        short majorVersion = JAVA_DEFAULT_VERSION;        short minorVersion = JAVA_DEFAULT_MINOR_VERSION;         File destDir = null;//JCOV        File covFile = null;        String optJcov = "-Xjcov";        String optJcovFile = "-Xjcov:file=";//end JCOV        int flags = F_WARNINGS | F_DEBUG_LINES | F_DEBUG_SOURCE;        long tm = System.currentTimeMillis();        Vector v = new Vector();        boolean nowrite = false;        String props = null;        String encoding = null;         // These flags are used to make sure conflicting -O and -g        // options aren't given.        String prior_g = null;        String prior_O = null;         exitStatus = EXIT_OK;         // Pre-process command line for @file arguments        try {            argv = CommandLine.parse(argv);        } catch (FileNotFoundException e) {            error("javac.err.cant.read", e.getMessage());            System.exit(1);        } catch (IOException e) {            e.printStackTrace();            System.exit(1);        }         // Parse arguments        for (int i = 0 ; i < argv.length ; i++) {            if (argv[i].equals("-g")) {                if (prior_g!=null && !(prior_g.equals("-g")))                   error("main.conflicting.options", prior_g, "-g");                prior_g = "-g";                flags |= F_DEBUG_LINES;                flags |= F_DEBUG_VARS;                flags |= F_DEBUG_SOURCE;            } else if (argv[i].equals("-g:none")) {                if (prior_g!=null && !(prior_g.equals("-g:none")))                   error("main.conflicting.options", prior_g, "-g:none");                prior_g = "-g:none";                flags &= ~F_DEBUG_LINES;                flags &= ~F_DEBUG_VARS;                flags &= ~F_DEBUG_SOURCE;            } else if (argv[i].startsWith("-g:")) {                // We choose to have debugging options conflict even                // if they amount to the same thing (for example,                // -g:source,lines and -g:lines,source).  However, multiple                // debugging options are allowed if they are textually                // identical.                if (prior_g!=null && !(prior_g.equals(argv[i])))                   error("main.conflicting.options", prior_g, argv[i]);                prior_g = argv[i];                String args = argv[i].substring("-g:".length());                flags &= ~F_DEBUG_LINES;                flags &= ~F_DEBUG_VARS;                flags &= ~F_DEBUG_SOURCE;                while (true) {                    if (args.startsWith("lines")) {                        flags |= F_DEBUG_LINES;                        args = args.substring("lines".length());                    } else if (args.startsWith("vars")) {                        flags |= F_DEBUG_VARS;                        args = args.substring("vars".length());                    } else if (args.startsWith("source")) {                        flags |= F_DEBUG_SOURCE;                        args = args.substring("source".length());                    } else {                        error("main.bad.debug.option",argv[i]);                        usage_error();                        return false;  // Stop processing now                    }                    if (args.length() == 0) break;                    if (args.startsWith(","))                        args = args.substring(",".length());                }            } else if (argv[i].equals("-O")) {                // -O is accepted for backward compatibility, but                // is no longer effective.  Use the undocumented                // -XO option to get the old behavior.                if (prior_O!=null && !(prior_O.equals("-O")))                    error("main.conflicting.options", prior_O, "-O");                prior_O = "-O";            } else if (argv[i].equals("-nowarn")) {                flags &= ~F_WARNINGS;            } else if (argv[i].equals("-deprecation")) {                flags |= F_DEPRECATION;            } else if (argv[i].equals("-verbose")) {                flags |= F_VERBOSE;            } else if (argv[i].equals("-nowrite")) {                nowrite = true;            } else if (argv[i].equals("-classpath")) {                if ((i + 1) < argv.length) {                    if (classPathArg!=null) {                       error("main.option.already.seen","-classpath");                    }                    classPathArg = argv[++i];                } else {                    error("main.option.requires.argument","-classpath");                    usage_error();                    return false;  // Stop processing now                }            } else if (argv[i].equals("-sourcepath")) {                if ((i + 1) < argv.length) {                    if (sourcePathArg != null) {                        error("main.option.already.seen","-sourcepath");                    }                    sourcePathArg = argv[++i];                } else {                    error("main.option.requires.argument","-sourcepath");                    usage_error();                    return false;  // Stop processing now                }            } else if (argv[i].equals("-sysclasspath")) {                if ((i + 1) < argv.length) {                    if (sysClassPathArg != null) {                        error("main.option.already.seen","-sysclasspath");                    }                    sysClassPathArg = argv[++i];                } else {                    error("main.option.requires.argument","-sysclasspath");                    usage_error();                    return false;  // Stop processing now                }            } else if (argv[i].equals("-bootclasspath")) {                if ((i + 1) < argv.length) {                    if (sysClassPathArg != null) {                        error("main.option.already.seen","-bootclasspath");                    }                    sysClassPathArg = argv[++i];                } else {                    error("main.option.requires.argument","-bootclasspath");                    usage_error();                    return false;  // Stop processing now                }            } else if (argv[i].equals("-extdirs")) {                if ((i + 1) < argv.length) {                    if (extDirsArg != null) {                        error("main.option.already.seen","-extdirs");                    }                    extDirsArg = argv[++i];                } else {                    error("main.option.requires.argument","-extdirs");                    usage_error();                    return false;  // Stop processing now                }            } else if (argv[i].equals("-encoding")) {                if ((i + 1) < argv.length) {                    if (encoding!=null)                       error("main.option.already.seen","-encoding");                    encoding = argv[++i];                } else {                    error("main.option.requires.argument","-encoding");                    usage_error();                    return false; // Stop processing now                }            } else if (argv[i].equals("-target")) {                if ((i + 1) < argv.length) {                    if (targetArg!=null)                       error("main.option.already.seen","-target");                    targetArg = argv[++i];                    int j;                    for (j=0; j<releases.length; j++) {                        if (releases[j].equals(targetArg)) {                            majorVersion = majorVersions[j];                            minorVersion = minorVersions[j];                            break;                        }                    }                    if (j==releases.length) {                        error("main.unknown.release",targetArg);                        usage_error();                        return false; // Stop processing now                    }                } else {                    error("main.option.requires.argument","-target");                    usage_error();                    return false; // Stop processing now                }            } else if (argv[i].equals("-d")) {                if ((i + 1) < argv.length) {                    if (destDir!=null)                       error("main.option.already.seen","-d");                    destDir = new File(argv[++i]);                    if (!destDir.exists()) {                        error("main.no.such.directory",destDir.getPath());                        usage_error();                        return false; // Stop processing now                    }                } else {                    error("main.option.requires.argument","-d");                    usage_error();                    return false; // Stop processing now                }// JCOV            } else if (argv[i].equals(optJcov)) {                    flags |= F_COVERAGE;                    flags &= ~F_OPT;                    flags &= ~F_OPT_INTERCLASS;            } else if ((argv[i].startsWith(optJcovFile)) &&                       (argv[i].length() > optJcovFile.length())) {                    covFile = new File(argv[i].substring(optJcovFile.length()));                    flags &= ~F_OPT;                    flags &= ~F_OPT_INTERCLASS;                    flags |= F_COVERAGE;                    flags |= F_COVDATA;// end JCOV            } else if (argv[i].equals("-XO")) {                // This is what -O used to be.  Now undocumented.                if (prior_O!=null && !(prior_O.equals("-XO")))                   error("main.conflicting.options", prior_O, "-XO");                prior_O = "-XO";                flags |= F_OPT;            } else if (argv[i].equals("-Xinterclass")) {                if (prior_O!=null && !(prior_O.equals("-Xinterclass")))                   error("main.conflicting.options", prior_O, "-Xinterclass");                prior_O = "-Xinterclass";                flags |= F_OPT;                flags |= F_OPT_INTERCLASS;                flags |= F_DEPENDENCIES;            } else if (argv[i].equals("-Xdepend")) {                flags |= F_DEPENDENCIES;            } else if (argv[i].equals("-Xdebug")) {                flags |= F_DUMP;            // Unadvertised option used by JWS.  The non-X version should            // be removed, but we'll leave it in until we find out for            // sure that no one still depends on that option syntax.            } else if (argv[i].equals("-xdepend") || argv[i].equals("-Xjws")) {                flags |= F_PRINT_DEPENDENCIES;                // change the default output in this case:                if (out == System.err) {                    out = System.out;                }            } else if (argv[i].equals("-Xstrictdefault")) {                // Make strict floating point the default                flags |= F_STRICTDEFAULT;            } else if (argv[i].equals("-Xverbosepath")) {                verbosePath = true;            } else if (argv[i].equals("-Xstdout")) {                out = System.out;            } else if (argv[i].equals("-X")) {                error("main.unsupported.usage");                return false; // Stop processing now            } else if (argv[i].equals("-Xversion1.2")) {                // Inform the compiler that it need not target VMs                // earlier than version 1.2.  This option is here                // for testing purposes only.  It is deliberately                // kept orthogonal to the -target option in 1.2.0                // for the sake of stability.  These options will                // be merged in a future release.                flags |= F_VERSION12;            } else if (argv[i].endsWith(".java")) {                v.addElement(argv[i]);            } else {                error("main.no.such.option",argv[i]);                usage_error();                return false; // Stop processing now            }        }        if (v.size() == 0 || exitStatus == EXIT_CMDERR) {            usage_error();            return false;        }         // Create our Environment.        BatchEnvironment env = BatchEnvironment.create(out,                                                       sourcePathArg,                                                       classPathArg,                                                       sysClassPathArg,                                                       extDirsArg);        if (verbosePath) {            output(getText("main.path.msg",                           env.sourcePath.toString(),                           env.binaryPath.toString()));        }         env.flags |= flags;        env.majorVersion = majorVersion;        env.minorVersion = minorVersion;// JCOV        env.covFile = covFile;// end JCOV        env.setCharacterEncoding(encoding);         // Preload the "out of memory" error string just in case we run        // out of memory during the compile.        String noMemoryErrorString = getText("main.no.memory");        String stackOverflowErrorString = getText("main.stack.overflow");         env.error(0, "warn.class.is.deprecated", "sun.tools.javac.Main");         try {

Lines 1–500 of 751. Load more