jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/main/Main.java@07599bd780ca (annotated)

src/share/classes/com/sun/tools/javac/main/Main.java@07599bd780ca (annotated)

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

Sat, 19 Nov 2011 15:54:04 -0800

author: jjh
date: Sat, 19 Nov 2011 15:54:04 -0800
changeset 1140: 07599bd780ca
parent 1136: ae361e7f435a
child 1157: 3809292620c9
permissions: -rw-r--r--

7110611: compiler message file broken for javac -fullversion
Reviewed-by: jjg

 /*
  * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.tools.javac.main;
 import java.io.File;
 import java.io.IOException;
 import java.io.PrintWriter;
 import java.net.URL;
 import java.security.DigestInputStream;
 import java.security.MessageDigest;
 import java.util.Collection;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import javax.tools.JavaFileManager;
 import javax.tools.JavaFileObject;
 import javax.annotation.processing.Processor;
 import com.sun.tools.javac.code.Source;
 import com.sun.tools.javac.file.CacheFSInfo;
 import com.sun.tools.javac.file.JavacFileManager;
 import com.sun.tools.javac.jvm.Target;
 import com.sun.tools.javac.main.JavacOption.Option;
 import com.sun.tools.javac.main.RecognizedOptions.OptionHelper;
 import com.sun.tools.javac.util.*;
 import com.sun.tools.javac.util.Log.WriterKind;
 import com.sun.tools.javac.util.Log.PrefixKind;
 import com.sun.tools.javac.processing.AnnotationProcessingError;
 import static com.sun.tools.javac.main.OptionName.*;
 /** This class provides a commandline interface to the GJC compiler.
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public class Main {
     /** The name of the compiler, for use in diagnostics.
      */
     String ownName;
     /** The writer to use for diagnostic output.
      */
     PrintWriter out;
     /** The log to use for diagnostic output.
      */
     Log log;
     /**
      * If true, certain errors will cause an exception, such as command line
      * arg errors, or exceptions in user provided code.
      */
     boolean apiMode;
     /** Result codes.
      */
     public enum Result {
         OK(0),        // Compilation completed with no errors.
         ERROR(1),     // Completed but reported errors.
         CMDERR(2),    // Bad command-line arguments
         SYSERR(3),    // System error or resource exhaustion.
         ABNORMAL(4);  // Compiler terminated abnormally
         Result(int exitCode) {
             this.exitCode = exitCode;
         }
         public boolean isOK() {
             return (exitCode == 0);
         }
         public final int exitCode;
     }
     private Option[] recognizedOptions = RecognizedOptions.getJavaCompilerOptions(new OptionHelper() {
         public void setOut(PrintWriter out) {
             Main.this.out = out;
             Main.this.log.setWriters(out);
         }
         public void error(String key, Object... args) {
             Main.this.error(key, args);
         }
         public void printVersion() {
             log.printLines(PrefixKind.JAVAC, "version", ownName,  JavaCompiler.version());
         }
         public void printFullVersion() {
             log.printLines(PrefixKind.JAVAC, "fullVersion", ownName,  JavaCompiler.fullVersion());
         }
         public void printHelp() {
             help();
         }
         public void printXhelp() {
             xhelp();
         }
         public void addFile(File f) {
             filenames.add(f);
         }
         public void addClassName(String s) {
             classnames.append(s);
         }
     });
     /**
      * 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
      */
     public Set<File> filenames = null; // XXX sb protected
     /** List of class files names passed on the command line
      */
     public ListBuffer<String> classnames = null; // XXX sb protected
     /** Print a string that explains usage.
      */
     void help() {
         log.printLines(PrefixKind.JAVAC, "msg.usage.header", ownName);
         for (int i=0; i<recognizedOptions.length; i++) {
             recognizedOptions[i].help(log);
         }
         log.printNewline();
     }
     /** Print a string that explains usage for X options.
      */
     void xhelp() {
         for (int i=0; i<recognizedOptions.length; i++) {
             recognizedOptions[i].xhelp(log);
         }
         log.printNewline();
         log.printLines(PrefixKind.JAVAC, "msg.usage.nonstandard.footer");
     }
     /** Report a usage error.
      */
     void error(String key, Object... args) {
         if (apiMode) {
             String msg = log.localize(PrefixKind.JAVAC, key, args);
             throw new PropagatedException(new IllegalStateException(msg));
         }
         warning(key, args);
         log.printLines(PrefixKind.JAVAC, "msg.usage", ownName);
     }
     /** Report a warning.
      */
     void warning(String key, Object... args) {
         log.printRawLines(ownName + ": " + log.localize(PrefixKind.JAVAC, key, args));
     }
     public Option getOption(String flag) {
         for (Option option : recognizedOptions) {
             if (option.matches(flag))
                 return option;
         }
         return null;
     }
     public void setOptions(Options options) {
         if (options == null)
             throw new NullPointerException();
         this.options = options;
     }
     public void setAPIMode(boolean apiMode) {
         this.apiMode = apiMode;
     }
     /** Process command line arguments: store all command line options
      *  in `options' table and return all source filenames.
      *  @param flags    The array of command line arguments.
      */
     public Collection<File> processArgs(String[] flags) { // XXX sb protected
         int ac = 0;
         while (ac < flags.length) {
             String flag = flags[ac];
             ac++;
             Option option = null;
             if (flag.length() > 0) {
                 // quick hack to speed up file processing:
                 // if the option does not begin with '-', there is no need to check
                 // most of the compiler options.
                 int firstOptionToCheck = flag.charAt(0) == '-' ? 0 : recognizedOptions.length-1;
                 for (int j=firstOptionToCheck; j<recognizedOptions.length; j++) {
                     if (recognizedOptions[j].matches(flag)) {
                         option = recognizedOptions[j];
                         break;
                     }
                 }
             }
             if (option == null) {
                 error("err.invalid.flag", flag);
                 return null;
             }
             if (option.hasArg()) {
                 if (ac == flags.length) {
                     error("err.req.arg", flag);
                     return null;
                 }
                 String operand = flags[ac];
                 ac++;
                 if (option.process(options, flag, operand))
                     return null;
             } else {
                 if (option.process(options, flag))
                     return null;
             }
         }
         if (!checkDirectory(D))
             return null;
         if (!checkDirectory(S))
             return null;
         String sourceString = options.get(SOURCE);
         Source source = (sourceString != null)
             ? Source.lookup(sourceString)
             : Source.DEFAULT;
         String targetString = options.get(TARGET);
         Target target = (targetString != null)
             ? Target.lookup(targetString)
             : Target.DEFAULT;
         // 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))) {
             if (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 {
                     target = source.requiredTarget();
                     options.put("-target", target.name);
                 }
             } else {
                 if (targetString == null && !source.allowGenerics()) {
                     target = Target.JDK1_4;
                     options.put("-target", target.name);
                 }
             }
         }
         // handle this here so it works even if no other options given
         String showClass = options.get("showClass");
         if (showClass != null) {
             if (showClass.equals("showClass")) // no value given for option
                 showClass = "com.sun.tools.javac.Main";
             showClass(showClass);
         }
         options.notifyListeners();
         return filenames;
     }
     // where
         private boolean checkDirectory(OptionName optName) {
             String value = options.get(optName);
             if (value == null)
                 return true;
             File file = new File(value);
             if (!file.exists()) {
                 error("err.dir.not.found", value);
                 return false;
             }
             if (!file.isDirectory()) {
                 error("err.file.not.directory", value);
                 return false;
             }
             return true;
         }
     /** Programmatic interface for main function.
      * @param args    The command line parameters.
      */
     public Result compile(String[] args) {
         Context context = new Context();
         JavacFileManager.preRegister(context); // can't create it until Log has been set up
         Result result = compile(args, context);
         if (fileManager instanceof JavacFileManager) {
             // A fresh context was created above, so jfm must be a JavacFileManager
             ((JavacFileManager)fileManager).close();
         }
         return result;
     }
     public Result compile(String[] args, Context context) {
         return compile(args, context, List.<JavaFileObject>nil(), null);
     }
     /** Programmatic interface for main function.
      * @param args    The command line parameters.
      */
     public Result compile(String[] args,
                        Context context,
                        List<JavaFileObject> fileObjects,
                        Iterable<? extends Processor> processors)
     {
         context.put(Log.outKey, out);
         log = Log.instance(context);
         if (options == null)
             options = Options.instance(context); // creates a new one
         filenames = new LinkedHashSet<File>();
         classnames = new ListBuffer<String>();
         JavaCompiler comp = null;
         /*
          * TODO: Logic below about what is an acceptable command line
          * should be updated to take annotation processing semantics
          * into account.
          */
         try {
             if (args.length == 0 && fileObjects.isEmpty()) {
                 help();
                 return Result.CMDERR;
             }
             Collection<File> files;
             try {
                 files = processArgs(CommandLine.parse(args));
                 if (files == null) {
                     // null signals an error in options, abort
                     return Result.CMDERR;
                 } else if (files.isEmpty() && fileObjects.isEmpty() && classnames.isEmpty()) {
                     // it is allowed to compile nothing if just asking for help or version info
                     if (options.isSet(HELP)
                         || options.isSet(X)
                         || options.isSet(VERSION)
                         || options.isSet(FULLVERSION))
                         return Result.OK;
                     if (JavaCompiler.explicitAnnotationProcessingRequested(options)) {
                         error("err.no.source.files.classes");
                     } else {
                         error("err.no.source.files");
                     }
                     return Result.CMDERR;
                 }
             } catch (java.io.FileNotFoundException e) {
                 warning("err.file.not.found", e.getMessage());
                 return Result.SYSERR;
             }
             boolean forceStdOut = options.isSet("stdout");
             if (forceStdOut) {
                 log.flush();
                 out = new PrintWriter(System.out, true);
                 log.setWriters(out);
             }
             // allow System property in following line as a Mustang legacy
             boolean batchMode = (options.isUnset("nonBatchMode")
                         && System.getProperty("nonBatchMode") == null);
             if (batchMode)
                 CacheFSInfo.preRegister(context);
             fileManager = context.get(JavaFileManager.class);
             comp = JavaCompiler.instance(context);
             if (comp == null) return Result.SYSERR;
             if (!files.isEmpty()) {
                 // add filenames to fileObjects
                 comp = JavaCompiler.instance(context);
                 List<JavaFileObject> otherFiles = List.nil();
                 JavacFileManager dfm = (JavacFileManager)fileManager;
                 for (JavaFileObject fo : dfm.getJavaFileObjectsFromFiles(files))
                     otherFiles = otherFiles.prepend(fo);
                 for (JavaFileObject fo : otherFiles)
                     fileObjects = fileObjects.prepend(fo);
             }
             comp.compile(fileObjects,
                          classnames.toList(),
                          processors);
             if (log.expectDiagKeys != null) {
                 if (log.expectDiagKeys.isEmpty()) {
                     log.printRawLines("all expected diagnostics found");
                     return Result.OK;
                 } else {
                     log.printRawLines("expected diagnostic keys not found: " + log.expectDiagKeys);
                     return Result.ERROR;
                 }
             }
             if (comp.errorCount() != 0)
                 return Result.ERROR;
         } catch (IOException ex) {
             ioMessage(ex);
             return Result.SYSERR;
         } catch (OutOfMemoryError ex) {
             resourceMessage(ex);
             return Result.SYSERR;
         } catch (StackOverflowError ex) {
             resourceMessage(ex);
             return Result.SYSERR;
         } catch (FatalError ex) {
             feMessage(ex);
             return Result.SYSERR;
         } catch (AnnotationProcessingError ex) {
             if (apiMode)
                 throw new RuntimeException(ex.getCause());
             apMessage(ex);
             return Result.SYSERR;
         } catch (ClientCodeException ex) {
             // as specified by javax.tools.JavaCompiler#getTask
             // and javax.tools.JavaCompiler.CompilationTask#call
             throw new RuntimeException(ex.getCause());
         } catch (PropagatedException ex) {
             throw ex.getCause();
         } catch (Throwable ex) {
             // Nasty.  If we've already reported an error, compensate
             // for buggy compiler error recovery by swallowing thrown
             // exceptions.
             if (comp == null || comp.errorCount() == 0 ||
                 options == null || options.isSet("dev"))
                 bugMessage(ex);
             return Result.ABNORMAL;
         } finally {
             if (comp != null) {
                 try {
                     comp.close();
                 } catch (ClientCodeException ex) {
                     throw new RuntimeException(ex.getCause());
                 }
             }
             filenames = null;
             options = null;
         }
         return Result.OK;
     }
     /** Print a message reporting an internal error.
      */
     void bugMessage(Throwable ex) {
         log.printLines(PrefixKind.JAVAC, "msg.bug", JavaCompiler.version());
         ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
     }
     /** Print a message reporting a fatal error.
      */
     void feMessage(Throwable ex) {
         log.printRawLines(ex.getMessage());
         if (ex.getCause() != null && options.isSet("dev")) {
             ex.getCause().printStackTrace(log.getWriter(WriterKind.NOTICE));
         }
     }
     /** Print a message reporting an input/output error.
      */
     void ioMessage(Throwable ex) {
         log.printLines(PrefixKind.JAVAC, "msg.io");
         ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
     }
     /** Print a message reporting an out-of-resources error.
      */
     void resourceMessage(Throwable ex) {
         log.printLines(PrefixKind.JAVAC, "msg.resource");
         ex.printStackTrace(log.getWriter(WriterKind.NOTICE));
     }
     /** Print a message reporting an uncaught exception from an
      * annotation processor.
      */
     void apMessage(AnnotationProcessingError ex) {
         log.printLines("msg.proc.annotation.uncaught.exception");
         ex.getCause().printStackTrace(log.getWriter(WriterKind.NOTICE));
     }
     /** Display the location and checksum of a class. */
     void showClass(String className) {
         PrintWriter pw = log.getWriter(WriterKind.NOTICE);
         pw.println("javac: show class: " + className);
         URL url = getClass().getResource('/' + className.replace('.', '/') + ".class");
         if (url == null)
             pw.println("  class not found");
         else {
             pw.println("  " + url);
             try {
                 final String algorithm = "MD5";
                 byte[] digest;
                 MessageDigest md = MessageDigest.getInstance(algorithm);
                 DigestInputStream in = new DigestInputStream(url.openStream(), md);
                 try {
                     byte[] buf = new byte[8192];
                     int n;
                     do { n = in.read(buf); } while (n > 0);
                     digest = md.digest();
                 } finally {
                     in.close();
                 }
                 StringBuilder sb = new StringBuilder();
                 for (byte b: digest)
                     sb.append(String.format("%02x", b));
                 pw.println("  " + algorithm + " checksum: " + sb);
             } catch (Exception e) {
                 pw.println("  cannot compute digest: " + e);
             }
         }
     }
     private JavaFileManager fileManager;
     /* ************************************************************************
      * Internationalization
      *************************************************************************/
 //    /** Find a localized string in the resource bundle.
 //     *  @param key     The key for the localized string.
 //     */
 //    public static String getLocalizedString(String key, Object... args) { // FIXME sb private
 //        try {
 //            if (messages == null)
 //                messages = new JavacMessages(javacBundleName);
 //            return messages.getLocalizedString("javac." + key, args);
 //        }
 //        catch (MissingResourceException e) {
 //            throw new Error("Fatal Error: Resource for javac is missing", e);
 //        }
 //    }
 //
 //    public static void useRawMessages(boolean enable) {
 //        if (enable) {
 //            messages = new JavacMessages(javacBundleName) {
 //                    @Override
 //                    public String getLocalizedString(String key, Object... args) {
 //                        return key;
 //                    }
 //                };
 //        } else {
 //            messages = new JavacMessages(javacBundleName);
 //        }
 //    }
     public static final String javacBundleName =
         "com.sun.tools.javac.resources.javac";
 //
 //    private static JavacMessages messages;
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/main/Main.java@07599bd780ca (annotated)

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