All Downloads are FREE. Search and download functionalities are using the official Maven repository.

src.jdk.jdeps.share.classes.com.sun.tools.javap.JavapTask Maven / Gradle / Ivy

Go to download

"nb-javac" is a patched version of OpenJDK "javac", i.e., the Java compiler. This has long been part of NetBeans, providing a highly tuned Java compiler specifically for the Java editor i.e., parsing and lexing for features such as syntax coloring, code completion.

There is a newer version: 17.0.0.0
Show newest version
/*
 * Copyright (c) 2007, 2021, 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.javap;

import java.io.EOFException;
import java.io.FileNotFoundException;
import java.io.FilterInputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.StringWriter;
import java.io.Writer;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.net.URLConnection;
import java.nio.file.NoSuchFileException;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Objects;
import java.util.ResourceBundle;
import java.util.Set;

import javax.lang.model.element.Modifier;
import javax.lang.model.element.NestingKind;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileManager.Location;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.StandardLocation;

import com.sun.tools.classfile.*;

/**
 *  "Main" class for javap, normally accessed from the command line
 *  via Main, or from JSR199 via DisassemblerTool.
 *
 *  

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. */ public class JavapTask implements DisassemblerTool.DisassemblerTask, Messages { public class BadArgs extends Exception { static final long serialVersionUID = 8765093759964640721L; BadArgs(String key, Object... args) { super(JavapTask.this.getMessage(key, args)); this.key = key; this.args = args; } BadArgs showUsage(boolean b) { showUsage = b; return this; } final String key; @SuppressWarnings("serial") // Array component type is not Serializable final Object[] args; boolean showUsage; } abstract static class Option { Option(boolean hasArg, String... aliases) { this.hasArg = hasArg; this.aliases = aliases; } boolean matches(String opt) { for (String a: aliases) { if (a.equals(opt)) return true; } return false; } boolean ignoreRest() { return false; } abstract void process(JavapTask task, String opt, String arg) throws BadArgs; final boolean hasArg; final String[] aliases; } static final Option[] recognizedOptions = { new Option(false, "-help", "--help", "-?", "-h") { @Override void process(JavapTask task, String opt, String arg) { task.options.help = true; } }, new Option(false, "-version") { @Override void process(JavapTask task, String opt, String arg) { task.options.version = true; } }, new Option(false, "-fullversion") { @Override void process(JavapTask task, String opt, String arg) { task.options.fullVersion = true; } }, new Option(false, "-v", "-verbose", "-all") { @Override void process(JavapTask task, String opt, String arg) { task.options.verbose = true; task.options.showDescriptors = true; task.options.showFlags = true; task.options.showAllAttrs = true; } }, new Option(false, "-l") { @Override void process(JavapTask task, String opt, String arg) { task.options.showLineAndLocalVariableTables = true; } }, new Option(false, "-public") { @Override void process(JavapTask task, String opt, String arg) { task.options.accessOptions.add(opt); task.options.showAccess = AccessFlags.ACC_PUBLIC; } }, new Option(false, "-protected") { @Override void process(JavapTask task, String opt, String arg) { task.options.accessOptions.add(opt); task.options.showAccess = AccessFlags.ACC_PROTECTED; } }, new Option(false, "-package") { @Override void process(JavapTask task, String opt, String arg) { task.options.accessOptions.add(opt); task.options.showAccess = 0; } }, new Option(false, "-p", "-private") { @Override void process(JavapTask task, String opt, String arg) { if (!task.options.accessOptions.contains("-p") && !task.options.accessOptions.contains("-private")) { task.options.accessOptions.add(opt); } task.options.showAccess = AccessFlags.ACC_PRIVATE; } }, new Option(false, "-c") { @Override void process(JavapTask task, String opt, String arg) { task.options.showDisassembled = true; } }, new Option(false, "-s") { @Override void process(JavapTask task, String opt, String arg) { task.options.showDescriptors = true; } }, new Option(false, "-sysinfo") { @Override void process(JavapTask task, String opt, String arg) { task.options.sysInfo = true; } }, new Option(false, "-XDdetails") { @Override void process(JavapTask task, String opt, String arg) { task.options.details = EnumSet.allOf(InstructionDetailWriter.Kind.class); } }, new Option(false, "-XDdetails:") { @Override boolean matches(String opt) { int sep = opt.indexOf(":"); return sep != -1 && super.matches(opt.substring(0, sep + 1)); } @Override void process(JavapTask task, String opt, String arg) throws BadArgs { int sep = opt.indexOf(":"); for (String v: opt.substring(sep + 1).split("[,: ]+")) { if (!handleArg(task, v)) throw task.new BadArgs("err.invalid.arg.for.option", v); } } boolean handleArg(JavapTask task, String arg) { if (arg.length() == 0) return true; if (arg.equals("all")) { task.options.details = EnumSet.allOf(InstructionDetailWriter.Kind.class); return true; } boolean on = true; if (arg.startsWith("-")) { on = false; arg = arg.substring(1); } for (InstructionDetailWriter.Kind k: InstructionDetailWriter.Kind.values()) { if (arg.equalsIgnoreCase(k.option)) { if (on) task.options.details.add(k); else task.options.details.remove(k); return true; } } return false; } }, new Option(false, "-constants") { @Override void process(JavapTask task, String opt, String arg) { task.options.showConstants = true; } }, new Option(false, "-XDinner") { @Override void process(JavapTask task, String opt, String arg) { task.options.showInnerClasses = true; } }, new Option(false, "-XDindent:") { @Override boolean matches(String opt) { int sep = opt.indexOf(":"); return sep != -1 && super.matches(opt.substring(0, sep + 1)); } @Override void process(JavapTask task, String opt, String arg) throws BadArgs { int sep = opt.indexOf(":"); try { int i = Integer.valueOf(opt.substring(sep + 1)); if (i > 0) // silently ignore invalid values task.options.indentWidth = i; } catch (NumberFormatException e) { } } }, new Option(false, "-XDtab:") { @Override boolean matches(String opt) { int sep = opt.indexOf(":"); return sep != -1 && super.matches(opt.substring(0, sep + 1)); } @Override void process(JavapTask task, String opt, String arg) throws BadArgs { int sep = opt.indexOf(":"); try { int i = Integer.valueOf(opt.substring(sep + 1)); if (i > 0) // silently ignore invalid values task.options.tabColumn = i; } catch (NumberFormatException e) { } } }, new Option(true, "--module", "-m") { @Override void process(JavapTask task, String opt, String arg) throws BadArgs { task.options.moduleName = arg; } }, // this option is processed by the launcher, and cannot be used when invoked via // an API like ToolProvider. It exists here to be documented in the command-line help. new Option(false, "-J") { @Override boolean matches(String opt) { return opt.startsWith("-J"); } @Override void process(JavapTask task, String opt, String arg) throws BadArgs { throw task.new BadArgs("err.only.for.launcher"); } } }; public JavapTask() { context = new Context(); context.put(Messages.class, this); options = Options.instance(context); attributeFactory = new Attribute.Factory(); } public JavapTask(Writer out, JavaFileManager fileManager, DiagnosticListener diagnosticListener) { this(); this.log = getPrintWriterForWriter(out); this.fileManager = fileManager; this.diagnosticListener = diagnosticListener; } public JavapTask(Writer out, JavaFileManager fileManager, DiagnosticListener diagnosticListener, Iterable options, Iterable classes) { this(out, fileManager, diagnosticListener); this.classes = new ArrayList<>(); for (String classname: classes) { Objects.requireNonNull(classname); this.classes.add(classname); } try { if (options != null) handleOptions(options, false); } catch (BadArgs e) { throw new IllegalArgumentException(e.getMessage()); } } public void setLocale(Locale locale) { if (locale == null) locale = Locale.getDefault(); task_locale = locale; } public void setLog(Writer log) { this.log = getPrintWriterForWriter(log); } public void setLog(OutputStream s) { setLog(getPrintWriterForStream(s)); } private static PrintWriter getPrintWriterForStream(OutputStream s) { return new PrintWriter(s == null ? System.err : s, true); } private static PrintWriter getPrintWriterForWriter(Writer w) { if (w == null) return getPrintWriterForStream(null); else if (w instanceof PrintWriter) return (PrintWriter) w; else return new PrintWriter(w, true); } public void setDiagnosticListener(DiagnosticListener dl) { diagnosticListener = dl; } public void setDiagnosticListener(OutputStream s) { setDiagnosticListener(getDiagnosticListenerForStream(s)); } private DiagnosticListener getDiagnosticListenerForStream(OutputStream s) { return getDiagnosticListenerForWriter(getPrintWriterForStream(s)); } private DiagnosticListener getDiagnosticListenerForWriter(Writer w) { final PrintWriter pw = getPrintWriterForWriter(w); return diagnostic -> { switch (diagnostic.getKind()) { case ERROR: pw.print(getMessage("err.prefix")); break; case WARNING: pw.print(getMessage("warn.prefix")); break; case NOTE: pw.print(getMessage("note.prefix")); break; } pw.print(" "); pw.println(diagnostic.getMessage(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 int run(String[] args) { try { try { handleOptions(args); // the following gives consistent behavior with javac if (classes == null || classes.size() == 0) { if (options.help || options.version || options.fullVersion) return EXIT_OK; else return EXIT_CMDERR; } return run(); } finally { if (defaultFileManager != null) { try { defaultFileManager.close(); defaultFileManager = null; } catch (IOException e) { throw new InternalError(e); } } } } catch (BadArgs e) { reportError(e.key, e.args); if (e.showUsage) { printLines(getMessage("main.usage.summary", progname)); } return EXIT_CMDERR; } catch (InternalError e) { Object[] e_args; if (e.getCause() == null) e_args = e.args; else { e_args = new Object[e.args.length + 1]; e_args[0] = e.getCause(); System.arraycopy(e.args, 0, e_args, 1, e.args.length); } reportError("err.internal.error", e_args); return EXIT_ABNORMAL; } finally { log.flush(); } } public void handleOptions(String[] args) throws BadArgs { handleOptions(Arrays.asList(args), true); } private void handleOptions(Iterable args, boolean allowClasses) throws BadArgs { if (log == null) { log = getPrintWriterForStream(System.out); if (diagnosticListener == null) diagnosticListener = getDiagnosticListenerForStream(System.err); } else { if (diagnosticListener == null) diagnosticListener = getDiagnosticListenerForWriter(log); } if (fileManager == null) fileManager = getDefaultFileManager(diagnosticListener, log); Iterator iter = args.iterator(); boolean noArgs = !iter.hasNext(); while (iter.hasNext()) { String arg = iter.next(); if (arg.startsWith("-")) handleOption(arg, iter); else if (allowClasses) { if (classes == null) classes = new ArrayList<>(); classes.add(arg); while (iter.hasNext()) classes.add(iter.next()); } else throw new BadArgs("err.unknown.option", arg).showUsage(true); } if (options.accessOptions.size() > 1) { StringBuilder sb = new StringBuilder(); for (String opt: options.accessOptions) { if (sb.length() > 0) sb.append(" "); sb.append(opt); } throw new BadArgs("err.incompatible.options", sb); } if ((classes == null || classes.size() == 0) && !(noArgs || options.help || options.version || options.fullVersion)) { throw new BadArgs("err.no.classes.specified"); } if (noArgs || options.help) showHelp(); if (options.version || options.fullVersion) showVersion(options.fullVersion); } private void handleOption(String name, Iterator rest) throws BadArgs { for (Option o: recognizedOptions) { if (o.matches(name)) { if (o.hasArg) { if (rest.hasNext()) o.process(this, name, rest.next()); else throw new BadArgs("err.missing.arg", name).showUsage(true); } else o.process(this, name, null); if (o.ignoreRest()) { while (rest.hasNext()) rest.next(); } return; } } try { if (fileManager.handleOption(name, rest)) return; } catch (IllegalArgumentException e) { throw new BadArgs("err.invalid.use.of.option", name).showUsage(true); } throw new BadArgs("err.unknown.option", name).showUsage(true); } public Boolean call() { return run() == 0; } public int run() { if (classes == null || classes.isEmpty()) { return EXIT_ERROR; } context.put(PrintWriter.class, log); ClassWriter classWriter = ClassWriter.instance(context); SourceWriter sourceWriter = SourceWriter.instance(context); sourceWriter.setFileManager(fileManager); if (options.moduleName != null) { try { moduleLocation = findModule(options.moduleName); if (moduleLocation == null) { reportError("err.cant.find.module", options.moduleName); return EXIT_ERROR; } } catch (IOException e) { reportError("err.cant.find.module.ex", options.moduleName, e); return EXIT_ERROR; } } int result = EXIT_OK; for (String className: classes) { try { result = writeClass(classWriter, className); } catch (ConstantPoolException e) { reportError("err.bad.constant.pool", className, e.getLocalizedMessage()); result = EXIT_ERROR; } catch (EOFException e) { reportError("err.end.of.file", className); result = EXIT_ERROR; } catch (FileNotFoundException | NoSuchFileException e) { reportError("err.file.not.found", e.getLocalizedMessage()); result = EXIT_ERROR; } catch (IOException e) { //e.printStackTrace(); Object msg = e.getLocalizedMessage(); if (msg == null) { msg = e; } reportError("err.ioerror", className, msg); result = EXIT_ERROR; } catch (OutOfMemoryError e) { reportError("err.nomem"); result = EXIT_ERROR; } catch (FatalError e) { Object msg = e.getLocalizedMessage(); if (msg == null) { msg = e; } reportError("err.fatal.err", msg); result = EXIT_ERROR; } catch (Throwable t) { StringWriter sw = new StringWriter(); PrintWriter pw = new PrintWriter(sw); t.printStackTrace(pw); pw.close(); reportError("err.crash", t.toString(), sw.toString()); result = EXIT_ABNORMAL; } } return result; } protected int writeClass(ClassWriter classWriter, String className) throws IOException, ConstantPoolException { JavaFileObject fo = open(className); if (fo == null) { reportError("err.class.not.found", className); return EXIT_ERROR; } ClassFileInfo cfInfo = read(fo); if (!className.endsWith(".class")) { if (cfInfo.cf.this_class == 0) { if (!className.equals("module-info")) { reportWarning("warn.unexpected.class", fo.getName(), className); } } else { String cfName = cfInfo.cf.getName(); if (!cfName.replaceAll("[/$]", ".").equals(className.replaceAll("[/$]", "."))) { reportWarning("warn.unexpected.class", fo.getName(), className); } } } write(cfInfo); if (options.showInnerClasses) { ClassFile cf = cfInfo.cf; Attribute a = cf.getAttribute(Attribute.InnerClasses); if (a instanceof InnerClasses_attribute) { InnerClasses_attribute inners = (InnerClasses_attribute) a; try { int result = EXIT_OK; for (int i = 0; i < inners.classes.length; i++) { int outerIndex = inners.classes[i].outer_class_info_index; ConstantPool.CONSTANT_Class_info outerClassInfo = cf.constant_pool.getClassInfo(outerIndex); String outerClassName = outerClassInfo.getName(); if (outerClassName.equals(cf.getName())) { int innerIndex = inners.classes[i].inner_class_info_index; ConstantPool.CONSTANT_Class_info innerClassInfo = cf.constant_pool.getClassInfo(innerIndex); String innerClassName = innerClassInfo.getName(); classWriter.println("// inner class " + innerClassName.replaceAll("[/$]", ".")); classWriter.println(); result = writeClass(classWriter, innerClassName); if (result != EXIT_OK) return result; } } return result; } catch (ConstantPoolException e) { reportError("err.bad.innerclasses.attribute", className); return EXIT_ERROR; } } else if (a != null) { reportError("err.bad.innerclasses.attribute", className); return EXIT_ERROR; } } return EXIT_OK; } protected JavaFileObject open(String className) throws IOException { // for compatibility, first see if it is a class name JavaFileObject fo = getClassFileObject(className); if (fo != null) return fo; // see if it is an inner class, by replacing dots to $, starting from the right String cn = className; int lastDot; while ((lastDot = cn.lastIndexOf(".")) != -1) { cn = cn.substring(0, lastDot) + "$" + cn.substring(lastDot + 1); fo = getClassFileObject(cn); if (fo != null) return fo; } if (!className.endsWith(".class")) return null; if (fileManager instanceof StandardJavaFileManager) { StandardJavaFileManager sfm = (StandardJavaFileManager) fileManager; try { fo = sfm.getJavaFileObjects(className).iterator().next(); if (fo != null && fo.getLastModified() != 0) { return fo; } } catch (IllegalArgumentException ignore) { } } // see if it is a URL, and if so, wrap it in just enough of a JavaFileObject // to suit javap's needs if (className.matches("^[A-Za-z]+:.*")) { try { final URI uri = new URI(className); final URL url = uri.toURL(); final URLConnection conn = url.openConnection(); conn.setUseCaches(false); return new JavaFileObject() { public Kind getKind() { return JavaFileObject.Kind.CLASS; } public boolean isNameCompatible(String simpleName, Kind kind) { throw new UnsupportedOperationException(); } public NestingKind getNestingKind() { throw new UnsupportedOperationException(); } public Modifier getAccessLevel() { throw new UnsupportedOperationException(); } public URI toUri() { return uri; } public String getName() { return uri.toString(); } public InputStream openInputStream() throws IOException { return conn.getInputStream(); } public OutputStream openOutputStream() throws IOException { throw new UnsupportedOperationException(); } public Reader openReader(boolean ignoreEncodingErrors) throws IOException { throw new UnsupportedOperationException(); } public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException { throw new UnsupportedOperationException(); } public Writer openWriter() throws IOException { throw new UnsupportedOperationException(); } public long getLastModified() { return conn.getLastModified(); } public boolean delete() { throw new UnsupportedOperationException(); } }; } catch (URISyntaxException | IOException ignore) { } } return null; } public static class ClassFileInfo { ClassFileInfo(JavaFileObject fo, ClassFile cf, byte[] digest, int size) { this.fo = fo; this.cf = cf; this.digest = digest; this.size = size; } public final JavaFileObject fo; public final ClassFile cf; public final byte[] digest; public final int size; } public ClassFileInfo read(JavaFileObject fo) throws IOException, ConstantPoolException { InputStream in = fo.openInputStream(); try { SizeInputStream sizeIn = null; MessageDigest md = null; if (options.sysInfo || options.verbose) { try { md = MessageDigest.getInstance("SHA-256"); } catch (NoSuchAlgorithmException ignore) { } in = new DigestInputStream(in, md); in = sizeIn = new SizeInputStream(in); } ClassFile cf = ClassFile.read(in, attributeFactory); byte[] digest = (md == null) ? null : md.digest(); int size = (sizeIn == null) ? -1 : sizeIn.size(); return new ClassFileInfo(fo, cf, digest, size); } finally { in.close(); } } public void write(ClassFileInfo info) { ClassWriter classWriter = ClassWriter.instance(context); if (options.sysInfo || options.verbose) { classWriter.setFile(info.fo.toUri()); classWriter.setLastModified(info.fo.getLastModified()); classWriter.setDigest("SHA-256", info.digest); classWriter.setFileSize(info.size); } classWriter.write(info.cf); } protected void setClassFile(ClassFile classFile) { ClassWriter classWriter = ClassWriter.instance(context); classWriter.setClassFile(classFile); } protected void setMethod(Method enclosingMethod) { ClassWriter classWriter = ClassWriter.instance(context); classWriter.setMethod(enclosingMethod); } protected void write(Attribute value) { AttributeWriter attrWriter = AttributeWriter.instance(context); ClassWriter classWriter = ClassWriter.instance(context); ClassFile cf = classWriter.getClassFile(); attrWriter.write(cf, value, cf.constant_pool); } protected void write(Attributes attrs) { AttributeWriter attrWriter = AttributeWriter.instance(context); ClassWriter classWriter = ClassWriter.instance(context); ClassFile cf = classWriter.getClassFile(); attrWriter.write(cf, attrs, cf.constant_pool); } protected void write(ConstantPool constant_pool) { ConstantWriter constantWriter = ConstantWriter.instance(context); constantWriter.writeConstantPool(constant_pool); } protected void write(ConstantPool constant_pool, int value) { ConstantWriter constantWriter = ConstantWriter.instance(context); constantWriter.write(value); } protected void write(ConstantPool.CPInfo value) { ConstantWriter constantWriter = ConstantWriter.instance(context); constantWriter.println(value); } protected void write(Field value) { ClassWriter classWriter = ClassWriter.instance(context); classWriter.writeField(value); } protected void write(Method value) { ClassWriter classWriter = ClassWriter.instance(context); classWriter.writeMethod(value); } private JavaFileManager getDefaultFileManager(final DiagnosticListener dl, PrintWriter log) { if (defaultFileManager == null) defaultFileManager = JavapFileManager.create(dl, log); return defaultFileManager; } private JavaFileObject getClassFileObject(String className) throws IOException { try { JavaFileObject fo; if (moduleLocation != null) { fo = fileManager.getJavaFileForInput(moduleLocation, className, JavaFileObject.Kind.CLASS); } else { fo = fileManager.getJavaFileForInput(StandardLocation.PLATFORM_CLASS_PATH, className, JavaFileObject.Kind.CLASS); if (fo == null) fo = fileManager.getJavaFileForInput(StandardLocation.CLASS_PATH, className, JavaFileObject.Kind.CLASS); } return fo; } catch (IllegalArgumentException e) { return null; } } private Location findModule(String moduleName) throws IOException { Location[] locns = { StandardLocation.UPGRADE_MODULE_PATH, StandardLocation.SYSTEM_MODULES, StandardLocation.MODULE_PATH }; for (Location segment: locns) { for (Set set: fileManager.listLocationsForModules(segment)) { Location result = null; for (Location l: set) { String name = fileManager.inferModuleName(l); if (name.equals(moduleName)) { if (result == null) result = l; else throw new IOException("multiple definitions found for " + moduleName); } } if (result != null) return result; } } return null; } private void showHelp() { printLines(getMessage("main.usage", progname)); for (Option o: recognizedOptions) { String name = o.aliases[0].replaceAll("^-+", "").replaceAll("-+", "_"); // there must always be at least one name if (name.startsWith("X") || name.equals("fullversion")) continue; printLines(getMessage("main.opt." + name)); } String[] fmOptions = { "--module-path", "--system", "--class-path", "-classpath", "-cp", "-bootclasspath", "--multi-release" }; for (String o: fmOptions) { if (fileManager.isSupportedOption(o) == -1) continue; String name = o.replaceAll("^-+", "").replaceAll("-+", "_"); printLines(getMessage("main.opt." + name)); } printLines(getMessage("main.usage.foot")); } private void showVersion(boolean full) { printLines(version(full ? "full" : "release")); } private void printLines(String msg) { log.println(msg.replace("\n", nl)); } private static final String nl = System.getProperty("line.separator"); private static final String versionRBName = "com.sun.tools.javap.resources.version"; private static ResourceBundle versionRB; private String version(String key) { // key=version: mm.nn.oo[-milestone] // key=full: mm.mm.oo[-milestone]-build if (versionRB == null) { try { versionRB = ResourceBundle.getBundle(versionRBName); } catch (MissingResourceException e) { return getMessage("version.resource.missing", System.getProperty("java.version")); } } try { return versionRB.getString(key); } catch (MissingResourceException e) { return getMessage("version.unknown", System.getProperty("java.version")); } } private void reportError(String key, Object... args) { diagnosticListener.report(createDiagnostic(Diagnostic.Kind.ERROR, key, args)); } private void reportNote(String key, Object... args) { diagnosticListener.report(createDiagnostic(Diagnostic.Kind.NOTE, key, args)); } private void reportWarning(String key, Object... args) { diagnosticListener.report(createDiagnostic(Diagnostic.Kind.WARNING, key, args)); } private Diagnostic createDiagnostic( final Diagnostic.Kind kind, final String key, final Object... args) { return new Diagnostic<>() { public Kind getKind() { return kind; } public JavaFileObject getSource() { return null; } public long getPosition() { return Diagnostic.NOPOS; } public long getStartPosition() { return Diagnostic.NOPOS; } public long getEndPosition() { return Diagnostic.NOPOS; } public long getLineNumber() { return Diagnostic.NOPOS; } public long getColumnNumber() { return Diagnostic.NOPOS; } public String getCode() { return key; } public String getMessage(Locale locale) { return JavapTask.this.getMessage(locale, key, args); } @Override public String toString() { return getClass().getName() + "[key=" + key + ",args=" + Arrays.asList(args) + "]"; } }; } public String getMessage(String key, Object... args) { return getMessage(task_locale, key, args); } public String getMessage(Locale locale, String key, Object... args) { if (bundles == null) { // could make this a HashMap> // and for efficiency, keep a hard reference to the bundle for the task // locale bundles = new HashMap<>(); } if (locale == null) locale = Locale.getDefault(); ResourceBundle b = bundles.get(locale); if (b == null) { try { b = ResourceBundle.getBundle("com.sun.tools.javap.resources.javap", locale); bundles.put(locale, b); } catch (MissingResourceException e) { throw new InternalError("Cannot find javap resource bundle for locale " + locale); } } try { return MessageFormat.format(b.getString(key), args); } catch (MissingResourceException e) { throw new InternalError(e, key); } } protected Context context; JavaFileManager fileManager; JavaFileManager defaultFileManager; PrintWriter log; DiagnosticListener diagnosticListener; List classes; Location moduleLocation; Options options; //ResourceBundle bundle; Locale task_locale; Map bundles; protected Attribute.Factory attributeFactory; private static final String progname = "javap"; private static class SizeInputStream extends FilterInputStream { SizeInputStream(InputStream in) { super(in); } int size() { return size; } @Override public int read(byte[] buf, int offset, int length) throws IOException { int n = super.read(buf, offset, length); if (n > 0) size += n; return n; } @Override public int read() throws IOException { int b = super.read(); size += 1; return b; } private int size; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy