| /* |
| * 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; |
| // JCOV |
| import 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. |
| */ |
| @Deprecated |
| public |
| class 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 { |
| // Parse all input files |
| for (Enumeration e = v.elements() ; e.hasMoreElements() ;) { |
| File file = new File((String)e.nextElement()); |
| try { |
| env.parseFile(new ClassFile(file)); |
| } catch (FileNotFoundException ee) { |
| env.error(0, "cant.read", file.getPath()); |
| exitStatus = EXIT_CMDERR; |
| } |
| } |
| |
| // Do a post-read check on all newly-parsed classes, |
| // after they have all been read. |
| for (Enumeration e = env.getClasses() ; e.hasMoreElements() ; ) { |
| ClassDeclaration c = (ClassDeclaration)e.nextElement(); |
| if (c.getStatus() == CS_PARSED) { |
| if (c.getClassDefinition().isLocal()) |
| continue; |
| try { |
| c.getClassDefinition(env); |
| } catch (ClassNotFound ee) { |
| } |
| } |
| } |
| |
| // compile all classes that need compilation |
| ByteArrayOutputStream buf = new ByteArrayOutputStream(4096); |
| boolean done; |
| |
| do { |
| done = true; |
| env.flushErrors(); |
| for (Enumeration e = env.getClasses() ; e.hasMoreElements() ; ) { |
| ClassDeclaration c = (ClassDeclaration)e.nextElement(); |
| SourceClass src; |
| |
| switch (c.getStatus()) { |
| case CS_UNDEFINED: |
| if (!env.dependencies()) { |
| break; |
| } |
| // fall through |
| |
| case CS_SOURCE: |
| if (tracing) |
| env.dtEvent("Main.compile (SOURCE): loading, " + c); |
| done = false; |
| env.loadDefinition(c); |
| if (c.getStatus() != CS_PARSED) { |
| if (tracing) |
| env.dtEvent("Main.compile (SOURCE): not parsed, " + c); |
| break; |
| } |
| // fall through |
| |
| case CS_PARSED: |
| if (c.getClassDefinition().isInsideLocal()) { |
| // the enclosing block will check this one |
| if (tracing) |
| env.dtEvent("Main.compile (PARSED): skipping local class, " + c); |
| continue; |
| } |
| done = false; |
| if (tracing) env.dtEvent("Main.compile (PARSED): checking, " + c); |
| src = (SourceClass)c.getClassDefinition(env); |
| src.check(env); |
| c.setDefinition(src, CS_CHECKED); |
| // fall through |
| |
| case CS_CHECKED: |
| src = (SourceClass)c.getClassDefinition(env); |
| // bail out if there were any errors |
| if (src.getError()) { |
| if (tracing) |
| env.dtEvent("Main.compile (CHECKED): bailing out on error, " + c); |
| c.setDefinition(src, CS_COMPILED); |
| break; |
| } |
| done = false; |
| buf.reset(); |
| if (tracing) |
| env.dtEvent("Main.compile (CHECKED): compiling, " + c); |
| src.compile(buf); |
| c.setDefinition(src, CS_COMPILED); |
| src.cleanup(env); |
| |
| if (src.getNestError() || nowrite) { |
| continue; |
| } |
| |
| String pkgName = c.getName().getQualifier().toString().replace('.', File.separatorChar); |
| String className = c.getName().getFlatName().toString().replace('.', SIGC_INNERCLASS) + ".class"; |
| |
| File file; |
| if (destDir != null) { |
| if (pkgName.length() > 0) { |
| file = new File(destDir, pkgName); |
| if (!file.exists()) { |
| file.mkdirs(); |
| } |
| file = new File(file, className); |
| } else { |
| file = new File(destDir, className); |
| } |
| } else { |
| ClassFile classfile = (ClassFile)src.getSource(); |
| if (classfile.isZipped()) { |
| env.error(0, "cant.write", classfile.getPath()); |
| exitStatus = EXIT_CMDERR; |
| continue; |
| } |
| file = new File(classfile.getPath()); |
| file = new File(file.getParent(), className); |
| } |
| |
| // Create the file |
| try { |
| FileOutputStream out = new FileOutputStream(file.getPath()); |
| buf.writeTo(out); |
| out.close(); |
| |
| if (env.verbose()) { |
| output(getText("main.wrote", file.getPath())); |
| } |
| } catch (IOException ee) { |
| env.error(0, "cant.write", file.getPath()); |
| exitStatus = EXIT_CMDERR; |
| } |
| |
| // Print class dependencies if requested (-xdepend) |
| if (env.print_dependencies()) { |
| src.printClassDependencies(env); |
| } |
| } |
| } |
| } while (!done); |
| } catch (OutOfMemoryError ee) { |
| // The compiler has run out of memory. Use the error string |
| // which we preloaded. |
| env.output(noMemoryErrorString); |
| exitStatus = EXIT_SYSERR; |
| return false; |
| } catch (StackOverflowError ee) { |
| env.output(stackOverflowErrorString); |
| exitStatus = EXIT_SYSERR; |
| return false; |
| } catch (Error ee) { |
| // We allow the compiler to take an exception silently if a program |
| // error has previously been detected. Presumably, this makes the |
| // compiler more robust in the face of bad error recovery. |
| if (env.nerrors == 0 || env.dump()) { |
| ee.printStackTrace(); |
| env.error(0, "fatal.error"); |
| exitStatus = EXIT_ABNORMAL; |
| } |
| } catch (Exception ee) { |
| if (env.nerrors == 0 || env.dump()) { |
| ee.printStackTrace(); |
| env.error(0, "fatal.exception"); |
| exitStatus = EXIT_ABNORMAL; |
| } |
| } |
| |
| int ndepfiles = env.deprecationFiles.size(); |
| if (ndepfiles > 0 && env.warnings()) { |
| int ndeps = env.ndeprecations; |
| Object file1 = env.deprecationFiles.elementAt(0); |
| if (env.deprecation()) { |
| if (ndepfiles > 1) { |
| env.error(0, "warn.note.deprecations", |
| new Integer(ndepfiles), new Integer(ndeps)); |
| } else { |
| env.error(0, "warn.note.1deprecation", |
| file1, new Integer(ndeps)); |
| } |
| } else { |
| if (ndepfiles > 1) { |
| env.error(0, "warn.note.deprecations.silent", |
| new Integer(ndepfiles), new Integer(ndeps)); |
| } else { |
| env.error(0, "warn.note.1deprecation.silent", |
| file1, new Integer(ndeps)); |
| } |
| } |
| } |
| |
| env.flushErrors(); |
| env.shutdown(); |
| |
| boolean status = true; |
| if (env.nerrors > 0) { |
| String msg = ""; |
| if (env.nerrors > 1) { |
| msg = getText("main.errors", env.nerrors); |
| } else { |
| msg = getText("main.1error"); |
| } |
| if (env.nwarnings > 0) { |
| if (env.nwarnings > 1) { |
| msg += ", " + getText("main.warnings", env.nwarnings); |
| } else { |
| msg += ", " + getText("main.1warning"); |
| } |
| } |
| output(msg); |
| if (exitStatus == EXIT_OK) { |
| // Allow EXIT_CMDERR or EXIT_ABNORMAL to take precedence. |
| exitStatus = EXIT_ERROR; |
| } |
| status = false; |
| } else { |
| if (env.nwarnings > 0) { |
| if (env.nwarnings > 1) { |
| output(getText("main.warnings", env.nwarnings)); |
| } else { |
| output(getText("main.1warning")); |
| } |
| } |
| } |
| //JCOV |
| if (env.covdata()) { |
| Assembler CovAsm = new Assembler(); |
| CovAsm.GenJCov(env); |
| } |
| // end JCOV |
| |
| // We're done |
| if (env.verbose()) { |
| tm = System.currentTimeMillis() - tm; |
| output(getText("main.done_in", Long.toString(tm))); |
| } |
| |
| return status; |
| } |
| |
| /** |
| * Main program |
| */ |
| public static void main(String argv[]) { |
| OutputStream out = System.err; |
| |
| // This is superceeded by the -Xstdout option, but we leave |
| // in the old property check for compatibility. |
| if (Boolean.getBoolean("javac.pipe.output")) { |
| out = System.out; |
| } |
| |
| Main compiler = new Main(out, "javac"); |
| System.exit(compiler.compile(argv) ? 0 : compiler.exitStatus); |
| } |
| } |
