1 /*
2 * Copyright (c) 2007, 2014, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.tools.javap;
27
28 import java.io.EOFException;
29 import java.io.FileNotFoundException;
30 import java.io.FilterInputStream;
31 import java.io.InputStream;
32 import java.io.IOException;
33 import java.io.OutputStream;
34 import java.io.PrintWriter;
35 import java.io.Reader;
36 import java.io.StringWriter;
37 import java.io.Writer;
38 import java.net.URI;
39 import java.net.URISyntaxException;
40 import java.net.URL;
41 import java.net.URLConnection;
42 import java.nio.file.NoSuchFileException;
43 import java.security.DigestInputStream;
44 import java.security.MessageDigest;
45 import java.security.NoSuchAlgorithmException;
46 import java.text.MessageFormat;
47 import java.util.ArrayList;
48 import java.util.Arrays;
49 import java.util.EnumSet;
50 import java.util.HashMap;
51 import java.util.Iterator;
52 import java.util.List;
53 import java.util.Locale;
54 import java.util.Map;
55 import java.util.MissingResourceException;
56 import java.util.Objects;
57 import java.util.ResourceBundle;
58
59 import javax.lang.model.element.Modifier;
60 import javax.lang.model.element.NestingKind;
61 import javax.tools.Diagnostic;
62 import javax.tools.DiagnosticListener;
63 import javax.tools.JavaFileManager;
64 import javax.tools.JavaFileObject;
65 import javax.tools.StandardJavaFileManager;
66 import javax.tools.StandardLocation;
67
68 import com.sun.tools.classfile.*;
69 import com.sun.tools.javac.util.DefinedBy;
70 import com.sun.tools.javac.util.DefinedBy.Api;
71
72 /**
73 * "Main" class for javap, normally accessed from the command line
74 * via Main, or from JSR199 via DisassemblerTool.
75 *
76 * <p><b>This is NOT part of any supported API.
77 * If you write code that depends on this, you do so at your own risk.
78 * This code and its internal interfaces are subject to change or
79 * deletion without notice.</b>
80 */
81 public class JavapTask implements DisassemblerTool.DisassemblerTask, Messages {
82 public class BadArgs extends Exception {
83 static final long serialVersionUID = 8765093759964640721L;
84 BadArgs(String key, Object... args) {
85 super(JavapTask.this.getMessage(key, args));
86 this.key = key;
87 this.args = args;
88 }
89
90 BadArgs showUsage(boolean b) {
91 showUsage = b;
92 return this;
93 }
94
95 final String key;
96 final Object[] args;
97 boolean showUsage;
98 }
99
100 static abstract class Option {
101 Option(boolean hasArg, String... aliases) {
102 this.hasArg = hasArg;
103 this.aliases = aliases;
104 }
105
106 boolean matches(String opt) {
107 for (String a: aliases) {
108 if (a.equals(opt))
109 return true;
110 }
111 return false;
112 }
113
114 boolean ignoreRest() {
115 return false;
116 }
117
118 abstract void process(JavapTask task, String opt, String arg) throws BadArgs;
119
120 final boolean hasArg;
121 final String[] aliases;
122 }
123
124 static final Option[] recognizedOptions = {
125
126 new Option(false, "-help", "--help", "-?") {
127 void process(JavapTask task, String opt, String arg) {
128 task.options.help = true;
129 }
130 },
131
132 new Option(false, "-version") {
133 void process(JavapTask task, String opt, String arg) {
134 task.options.version = true;
135 }
136 },
137
138 new Option(false, "-fullversion") {
139 void process(JavapTask task, String opt, String arg) {
140 task.options.fullVersion = true;
141 }
142 },
143
144 new Option(false, "-v", "-verbose", "-all") {
145 void process(JavapTask task, String opt, String arg) {
146 task.options.verbose = true;
147 task.options.showDescriptors = true;
148 task.options.showFlags = true;
149 task.options.showAllAttrs = true;
150 }
151 },
152
153 new Option(false, "-l") {
154 void process(JavapTask task, String opt, String arg) {
155 task.options.showLineAndLocalVariableTables = true;
156 }
157 },
158
159 new Option(false, "-public") {
160 void process(JavapTask task, String opt, String arg) {
161 task.options.accessOptions.add(opt);
162 task.options.showAccess = AccessFlags.ACC_PUBLIC;
163 }
164 },
165
166 new Option(false, "-protected") {
167 void process(JavapTask task, String opt, String arg) {
168 task.options.accessOptions.add(opt);
169 task.options.showAccess = AccessFlags.ACC_PROTECTED;
170 }
171 },
172
173 new Option(false, "-package") {
174 void process(JavapTask task, String opt, String arg) {
175 task.options.accessOptions.add(opt);
176 task.options.showAccess = 0;
177 }
178 },
179
180 new Option(false, "-p", "-private") {
181 void process(JavapTask task, String opt, String arg) {
182 if (!task.options.accessOptions.contains("-p") &&
183 !task.options.accessOptions.contains("-private")) {
184 task.options.accessOptions.add(opt);
185 }
186 task.options.showAccess = AccessFlags.ACC_PRIVATE;
187 }
188 },
189
190 new Option(false, "-c") {
191 void process(JavapTask task, String opt, String arg) {
192 task.options.showDisassembled = true;
193 }
194 },
195
196 new Option(false, "-s") {
197 void process(JavapTask task, String opt, String arg) {
198 task.options.showDescriptors = true;
199 }
200 },
201
202 new Option(false, "-sysinfo") {
203 void process(JavapTask task, String opt, String arg) {
204 task.options.sysInfo = true;
205 }
206 },
207
208 new Option(false, "-XDdetails") {
209 void process(JavapTask task, String opt, String arg) {
210 task.options.details = EnumSet.allOf(InstructionDetailWriter.Kind.class);
211 }
212
213 },
214
215 new Option(false, "-XDdetails:") {
216 @Override
217 boolean matches(String opt) {
218 int sep = opt.indexOf(":");
219 return sep != -1 && super.matches(opt.substring(0, sep + 1));
220 }
221
222 void process(JavapTask task, String opt, String arg) throws BadArgs {
223 int sep = opt.indexOf(":");
224 for (String v: opt.substring(sep + 1).split("[,: ]+")) {
225 if (!handleArg(task, v))
226 throw task.new BadArgs("err.invalid.arg.for.option", v);
227 }
228 }
229
230 boolean handleArg(JavapTask task, String arg) {
231 if (arg.length() == 0)
232 return true;
233
234 if (arg.equals("all")) {
235 task.options.details = EnumSet.allOf(InstructionDetailWriter.Kind.class);
236 return true;
237 }
238
239 boolean on = true;
240 if (arg.startsWith("-")) {
241 on = false;
242 arg = arg.substring(1);
243 }
244
245 for (InstructionDetailWriter.Kind k: InstructionDetailWriter.Kind.values()) {
246 if (arg.equalsIgnoreCase(k.option)) {
247 if (on)
248 task.options.details.add(k);
249 else
250 task.options.details.remove(k);
251 return true;
252 }
253 }
254 return false;
255 }
256 },
257
258 new Option(false, "-constants") {
259 void process(JavapTask task, String opt, String arg) {
260 task.options.showConstants = true;
261 }
262 },
263
264 new Option(false, "-XDinner") {
265 void process(JavapTask task, String opt, String arg) {
266 task.options.showInnerClasses = true;
267 }
268 },
269
270 new Option(false, "-XDindent:") {
271 @Override
272 boolean matches(String opt) {
273 int sep = opt.indexOf(":");
274 return sep != -1 && super.matches(opt.substring(0, sep + 1));
275 }
276
277 void process(JavapTask task, String opt, String arg) throws BadArgs {
278 int sep = opt.indexOf(":");
279 try {
280 int i = Integer.valueOf(opt.substring(sep + 1));
281 if (i > 0) // silently ignore invalid values
282 task.options.indentWidth = i;
283 } catch (NumberFormatException e) {
284 }
285 }
286 },
287
288 new Option(false, "-XDtab:") {
289 @Override
290 boolean matches(String opt) {
291 int sep = opt.indexOf(":");
292 return sep != -1 && super.matches(opt.substring(0, sep + 1));
293 }
294
295 void process(JavapTask task, String opt, String arg) throws BadArgs {
296 int sep = opt.indexOf(":");
297 try {
298 int i = Integer.valueOf(opt.substring(sep + 1));
299 if (i > 0) // silently ignore invalid values
300 task.options.tabColumn = i;
301 } catch (NumberFormatException e) {
302 }
303 }
304 }
305
306 };
307
308 public JavapTask() {
309 context = new Context();
310 context.put(Messages.class, this);
311 options = Options.instance(context);
312 attributeFactory = new Attribute.Factory();
313 }
314
315 public JavapTask(Writer out,
316 JavaFileManager fileManager,
317 DiagnosticListener<? super JavaFileObject> diagnosticListener) {
318 this();
319 this.log = getPrintWriterForWriter(out);
320 this.fileManager = fileManager;
321 this.diagnosticListener = diagnosticListener;
322 }
323
324 public JavapTask(Writer out,
325 JavaFileManager fileManager,
326 DiagnosticListener<? super JavaFileObject> diagnosticListener,
327 Iterable<String> options,
328 Iterable<String> classes) {
329 this(out, fileManager, diagnosticListener);
330
331 this.classes = new ArrayList<>();
332 for (String classname: classes) {
333 Objects.requireNonNull(classname);
334 this.classes.add(classname);
335 }
336
337 try {
338 if (options != null)
339 handleOptions(options, false);
340 } catch (BadArgs e) {
341 throw new IllegalArgumentException(e.getMessage());
342 }
343 }
344
345 public void setLocale(Locale locale) {
346 if (locale == null)
347 locale = Locale.getDefault();
348 task_locale = locale;
349 }
350
351 public void setLog(Writer log) {
352 this.log = getPrintWriterForWriter(log);
353 }
354
355 public void setLog(OutputStream s) {
356 setLog(getPrintWriterForStream(s));
357 }
358
359 private static PrintWriter getPrintWriterForStream(OutputStream s) {
360 return new PrintWriter(s == null ? System.err : s, true);
361 }
362
363 private static PrintWriter getPrintWriterForWriter(Writer w) {
364 if (w == null)
365 return getPrintWriterForStream(null);
366 else if (w instanceof PrintWriter)
367 return (PrintWriter) w;
368 else
369 return new PrintWriter(w, true);
370 }
371
372 public void setDiagnosticListener(DiagnosticListener<? super JavaFileObject> dl) {
373 diagnosticListener = dl;
374 }
375
376 public void setDiagnosticListener(OutputStream s) {
377 setDiagnosticListener(getDiagnosticListenerForStream(s));
378 }
379
380 private DiagnosticListener<JavaFileObject> getDiagnosticListenerForStream(OutputStream s) {
381 return getDiagnosticListenerForWriter(getPrintWriterForStream(s));
382 }
383
384 private DiagnosticListener<JavaFileObject> getDiagnosticListenerForWriter(Writer w) {
385 final PrintWriter pw = getPrintWriterForWriter(w);
386 return new DiagnosticListener<JavaFileObject> () {
387 @DefinedBy(Api.COMPILER)
388 public void report(Diagnostic<? extends JavaFileObject> diagnostic) {
389 switch (diagnostic.getKind()) {
390 case ERROR:
391 pw.print(getMessage("err.prefix"));
392 break;
393 case WARNING:
394 pw.print(getMessage("warn.prefix"));
395 break;
396 case NOTE:
397 pw.print(getMessage("note.prefix"));
398 break;
399 }
400 pw.print(" ");
401 pw.println(diagnostic.getMessage(null));
402 }
403 };
404 }
405
406 /** Result codes.
407 */
408 static final int
409 EXIT_OK = 0, // Compilation completed with no errors.
410 EXIT_ERROR = 1, // Completed but reported errors.
411 EXIT_CMDERR = 2, // Bad command-line arguments
412 EXIT_SYSERR = 3, // System error or resource exhaustion.
413 EXIT_ABNORMAL = 4; // Compiler terminated abnormally
414
415 int run(String[] args) {
416 try {
417 try {
418 handleOptions(args);
419
420 // the following gives consistent behavior with javac
421 if (classes == null || classes.size() == 0) {
422 if (options.help || options.version || options.fullVersion)
423 return EXIT_OK;
424 else
425 return EXIT_CMDERR;
426 }
427
428 return run();
429 } finally {
430 if (defaultFileManager != null) {
431 try {
432 defaultFileManager.close();
433 defaultFileManager = null;
434 } catch (IOException e) {
435 throw new InternalError(e);
436 }
437 }
438 }
439 } catch (BadArgs e) {
440 reportError(e.key, e.args);
441 if (e.showUsage) {
442 printLines(getMessage("main.usage.summary", progname));
443 }
444 return EXIT_CMDERR;
445 } catch (InternalError e) {
446 Object[] e_args;
447 if (e.getCause() == null)
448 e_args = e.args;
449 else {
450 e_args = new Object[e.args.length + 1];
451 e_args[0] = e.getCause();
452 System.arraycopy(e.args, 0, e_args, 1, e.args.length);
453 }
454 reportError("err.internal.error", e_args);
455 return EXIT_ABNORMAL;
456 } finally {
457 log.flush();
458 }
459 }
460
461 public void handleOptions(String[] args) throws BadArgs {
462 handleOptions(Arrays.asList(args), true);
463 }
464
465 private void handleOptions(Iterable<String> args, boolean allowClasses) throws BadArgs {
466 if (log == null) {
467 log = getPrintWriterForStream(System.out);
468 if (diagnosticListener == null)
469 diagnosticListener = getDiagnosticListenerForStream(System.err);
470 } else {
471 if (diagnosticListener == null)
472 diagnosticListener = getDiagnosticListenerForWriter(log);
473 }
474
475
476 if (fileManager == null)
477 fileManager = getDefaultFileManager(diagnosticListener, log);
478
479 Iterator<String> iter = args.iterator();
480 boolean noArgs = !iter.hasNext();
481
482 while (iter.hasNext()) {
483 String arg = iter.next();
484 if (arg.startsWith("-"))
485 handleOption(arg, iter);
486 else if (allowClasses) {
487 if (classes == null)
488 classes = new ArrayList<>();
489 classes.add(arg);
490 while (iter.hasNext())
491 classes.add(iter.next());
492 } else
493 throw new BadArgs("err.unknown.option", arg).showUsage(true);
494 }
495
496 if (options.accessOptions.size() > 1) {
497 StringBuilder sb = new StringBuilder();
498 for (String opt: options.accessOptions) {
499 if (sb.length() > 0)
500 sb.append(" ");
501 sb.append(opt);
502 }
503 throw new BadArgs("err.incompatible.options", sb);
504 }
505
506 if ((classes == null || classes.size() == 0) &&
507 !(noArgs || options.help || options.version || options.fullVersion)) {
508 throw new BadArgs("err.no.classes.specified");
509 }
510
511 if (noArgs || options.help)
512 showHelp();
513
514 if (options.version || options.fullVersion)
515 showVersion(options.fullVersion);
516 }
517
518 private void handleOption(String name, Iterator<String> rest) throws BadArgs {
519 for (Option o: recognizedOptions) {
520 if (o.matches(name)) {
521 if (o.hasArg) {
522 if (rest.hasNext())
523 o.process(this, name, rest.next());
524 else
525 throw new BadArgs("err.missing.arg", name).showUsage(true);
526 } else
527 o.process(this, name, null);
528
529 if (o.ignoreRest()) {
530 while (rest.hasNext())
531 rest.next();
532 }
533 return;
534 }
535 }
536
537 try {
538 if (fileManager.handleOption(name, rest))
539 return;
540 } catch (IllegalArgumentException e) {
541 throw new BadArgs("err.invalid.use.of.option", name).showUsage(true);
542 }
543
544 throw new BadArgs("err.unknown.option", name).showUsage(true);
545 }
546
547 public Boolean call() {
548 return run() == 0;
549 }
550
551 public int run() {
552 if (classes == null || classes.isEmpty()) {
553 return EXIT_ERROR;
554 }
555
556 context.put(PrintWriter.class, log);
557 ClassWriter classWriter = ClassWriter.instance(context);
558 SourceWriter sourceWriter = SourceWriter.instance(context);
559 sourceWriter.setFileManager(fileManager);
560
561 int result = EXIT_OK;
562
563 for (String className: classes) {
564 try {
565 result = writeClass(classWriter, className);
566 } catch (ConstantPoolException e) {
567 reportError("err.bad.constant.pool", className, e.getLocalizedMessage());
568 result = EXIT_ERROR;
569 } catch (EOFException e) {
570 reportError("err.end.of.file", className);
571 result = EXIT_ERROR;
572 } catch (FileNotFoundException | NoSuchFileException e) {
573 reportError("err.file.not.found", e.getLocalizedMessage());
574 result = EXIT_ERROR;
575 } catch (IOException e) {
576 //e.printStackTrace();
577 Object msg = e.getLocalizedMessage();
578 if (msg == null) {
579 msg = e;
580 }
581 reportError("err.ioerror", className, msg);
582 result = EXIT_ERROR;
583 } catch (OutOfMemoryError e) {
584 reportError("err.nomem");
585 result = EXIT_ERROR;
586 } catch (Throwable t) {
587 StringWriter sw = new StringWriter();
588 PrintWriter pw = new PrintWriter(sw);
589 t.printStackTrace(pw);
590 pw.close();
591 reportError("err.crash", t.toString(), sw.toString());
592 result = EXIT_ABNORMAL;
593 }
594 }
595
596 return result;
597 }
598
599 protected int writeClass(ClassWriter classWriter, String className)
600 throws IOException, ConstantPoolException {
601 JavaFileObject fo = open(className);
602 if (fo == null) {
603 reportError("err.class.not.found", className);
604 return EXIT_ERROR;
605 }
606
607 ClassFileInfo cfInfo = read(fo);
608 if (!className.endsWith(".class")) {
609 String cfName = cfInfo.cf.getName();
610 if (!cfName.replaceAll("[/$]", ".").equals(className.replaceAll("[/$]", "."))) {
611 reportWarning("warn.unexpected.class", className, cfName.replace('/', '.'));
612 }
613 }
614 write(cfInfo);
615
616 if (options.showInnerClasses) {
617 ClassFile cf = cfInfo.cf;
618 Attribute a = cf.getAttribute(Attribute.InnerClasses);
619 if (a instanceof InnerClasses_attribute) {
620 InnerClasses_attribute inners = (InnerClasses_attribute) a;
621 try {
622 int result = EXIT_OK;
623 for (int i = 0; i < inners.classes.length; i++) {
624 int outerIndex = inners.classes[i].outer_class_info_index;
625 ConstantPool.CONSTANT_Class_info outerClassInfo = cf.constant_pool.getClassInfo(outerIndex);
626 String outerClassName = outerClassInfo.getName();
627 if (outerClassName.equals(cf.getName())) {
628 int innerIndex = inners.classes[i].inner_class_info_index;
629 ConstantPool.CONSTANT_Class_info innerClassInfo = cf.constant_pool.getClassInfo(innerIndex);
630 String innerClassName = innerClassInfo.getName();
631 classWriter.println("// inner class " + innerClassName.replaceAll("[/$]", "."));
632 classWriter.println();
633 result = writeClass(classWriter, innerClassName);
634 if (result != EXIT_OK) return result;
635 }
636 }
637 return result;
638 } catch (ConstantPoolException e) {
639 reportError("err.bad.innerclasses.attribute", className);
640 return EXIT_ERROR;
641 }
642 } else if (a != null) {
643 reportError("err.bad.innerclasses.attribute", className);
644 return EXIT_ERROR;
645 }
646 }
647
648 return EXIT_OK;
649 }
650
651 protected JavaFileObject open(String className) throws IOException {
652 // for compatibility, first see if it is a class name
653 JavaFileObject fo = getClassFileObject(className);
654 if (fo != null)
655 return fo;
656
657 // see if it is an inner class, by replacing dots to $, starting from the right
658 String cn = className;
659 int lastDot;
660 while ((lastDot = cn.lastIndexOf(".")) != -1) {
661 cn = cn.substring(0, lastDot) + "$" + cn.substring(lastDot + 1);
662 fo = getClassFileObject(cn);
663 if (fo != null)
664 return fo;
665 }
666
667 if (!className.endsWith(".class"))
668 return null;
669
670 if (fileManager instanceof StandardJavaFileManager) {
671 StandardJavaFileManager sfm = (StandardJavaFileManager) fileManager;
672 try {
673 fo = sfm.getJavaFileObjects(className).iterator().next();
674 if (fo != null && fo.getLastModified() != 0) {
675 return fo;
676 }
677 } catch (IllegalArgumentException ignore) {
678 }
679 }
680
681 // see if it is a URL, and if so, wrap it in just enough of a JavaFileObject
682 // to suit javap's needs
683 if (className.matches("^[A-Za-z]+:.*")) {
684 try {
685 final URI uri = new URI(className);
686 final URL url = uri.toURL();
687 final URLConnection conn = url.openConnection();
688 conn.setUseCaches(false);
689 return new JavaFileObject() {
690 @DefinedBy(Api.COMPILER)
691 public Kind getKind() {
692 return JavaFileObject.Kind.CLASS;
693 }
694
695 @DefinedBy(Api.COMPILER)
696 public boolean isNameCompatible(String simpleName, Kind kind) {
697 throw new UnsupportedOperationException();
698 }
699
700 @DefinedBy(Api.COMPILER)
701 public NestingKind getNestingKind() {
702 throw new UnsupportedOperationException();
703 }
704
705 @DefinedBy(Api.COMPILER)
706 public Modifier getAccessLevel() {
707 throw new UnsupportedOperationException();
708 }
709
710 @DefinedBy(Api.COMPILER)
711 public URI toUri() {
712 return uri;
713 }
714
715 @DefinedBy(Api.COMPILER)
716 public String getName() {
717 return uri.toString();
718 }
719
720 @DefinedBy(Api.COMPILER)
721 public InputStream openInputStream() throws IOException {
722 return conn.getInputStream();
723 }
724
725 @DefinedBy(Api.COMPILER)
726 public OutputStream openOutputStream() throws IOException {
727 throw new UnsupportedOperationException();
728 }
729
730 @DefinedBy(Api.COMPILER)
731 public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
732 throw new UnsupportedOperationException();
733 }
734
735 @DefinedBy(Api.COMPILER)
736 public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
737 throw new UnsupportedOperationException();
738 }
739
740 @DefinedBy(Api.COMPILER)
741 public Writer openWriter() throws IOException {
742 throw new UnsupportedOperationException();
743 }
744
745 @DefinedBy(Api.COMPILER)
746 public long getLastModified() {
747 return conn.getLastModified();
748 }
749
750 @DefinedBy(Api.COMPILER)
751 public boolean delete() {
752 throw new UnsupportedOperationException();
753 }
754
755 };
756 } catch (URISyntaxException | IOException ignore) {
757 }
758 }
759
760 return null;
761 }
762
763 public static class ClassFileInfo {
764 ClassFileInfo(JavaFileObject fo, ClassFile cf, byte[] digest, int size) {
765 this.fo = fo;
766 this.cf = cf;
767 this.digest = digest;
768 this.size = size;
769 }
770 public final JavaFileObject fo;
771 public final ClassFile cf;
772 public final byte[] digest;
773 public final int size;
774 }
775
776 public ClassFileInfo read(JavaFileObject fo) throws IOException, ConstantPoolException {
777 InputStream in = fo.openInputStream();
778 try {
779 SizeInputStream sizeIn = null;
780 MessageDigest md = null;
781 if (options.sysInfo || options.verbose) {
782 try {
783 md = MessageDigest.getInstance("MD5");
784 } catch (NoSuchAlgorithmException ignore) {
785 }
786 in = new DigestInputStream(in, md);
787 in = sizeIn = new SizeInputStream(in);
788 }
789
790 ClassFile cf = ClassFile.read(in, attributeFactory);
791 byte[] digest = (md == null) ? null : md.digest();
792 int size = (sizeIn == null) ? -1 : sizeIn.size();
793 return new ClassFileInfo(fo, cf, digest, size);
794 } finally {
795 in.close();
796 }
797 }
798
799 public void write(ClassFileInfo info) {
800 ClassWriter classWriter = ClassWriter.instance(context);
801 if (options.sysInfo || options.verbose) {
802 classWriter.setFile(info.fo.toUri());
803 classWriter.setLastModified(info.fo.getLastModified());
804 classWriter.setDigest("MD5", info.digest);
805 classWriter.setFileSize(info.size);
806 }
807
808 classWriter.write(info.cf);
809 }
810
811 protected void setClassFile(ClassFile classFile) {
812 ClassWriter classWriter = ClassWriter.instance(context);
813 classWriter.setClassFile(classFile);
814 }
815
816 protected void setMethod(Method enclosingMethod) {
817 ClassWriter classWriter = ClassWriter.instance(context);
818 classWriter.setMethod(enclosingMethod);
819 }
820
821 protected void write(Attribute value) {
822 AttributeWriter attrWriter = AttributeWriter.instance(context);
823 ClassWriter classWriter = ClassWriter.instance(context);
824 ClassFile cf = classWriter.getClassFile();
825 attrWriter.write(cf, value, cf.constant_pool);
826 }
827
828 protected void write(Attributes attrs) {
829 AttributeWriter attrWriter = AttributeWriter.instance(context);
830 ClassWriter classWriter = ClassWriter.instance(context);
831 ClassFile cf = classWriter.getClassFile();
832 attrWriter.write(cf, attrs, cf.constant_pool);
833 }
834
835 protected void write(ConstantPool constant_pool) {
836 ConstantWriter constantWriter = ConstantWriter.instance(context);
837 constantWriter.writeConstantPool(constant_pool);
838 }
839
840 protected void write(ConstantPool constant_pool, int value) {
841 ConstantWriter constantWriter = ConstantWriter.instance(context);
842 constantWriter.write(value);
843 }
844
845 protected void write(ConstantPool.CPInfo value) {
846 ConstantWriter constantWriter = ConstantWriter.instance(context);
847 constantWriter.println(value);
848 }
849
850 protected void write(Field value) {
851 ClassWriter classWriter = ClassWriter.instance(context);
852 classWriter.writeField(value);
853 }
854
855 protected void write(Method value) {
856 ClassWriter classWriter = ClassWriter.instance(context);
857 classWriter.writeMethod(value);
858 }
859
860 private JavaFileManager getDefaultFileManager(final DiagnosticListener<? super JavaFileObject> dl, PrintWriter log) {
861 if (defaultFileManager == null)
862 defaultFileManager = JavapFileManager.create(dl, log);
863 return defaultFileManager;
864 }
865
866 private JavaFileObject getClassFileObject(String className) throws IOException {
867 try {
868 JavaFileObject fo;
869 fo = fileManager.getJavaFileForInput(StandardLocation.PLATFORM_CLASS_PATH, className, JavaFileObject.Kind.CLASS);
870 if (fo == null)
871 fo = fileManager.getJavaFileForInput(StandardLocation.CLASS_PATH, className, JavaFileObject.Kind.CLASS);
872 return fo;
873 } catch (IllegalArgumentException e) {
874 return null;
875 }
876 }
877
878 private void showHelp() {
879 printLines(getMessage("main.usage", progname));
880 for (Option o: recognizedOptions) {
881 String name = o.aliases[0].substring(1); // there must always be at least one name
882 if (name.startsWith("X") || name.equals("fullversion") || name.equals("h") || name.equals("verify"))
883 continue;
884 printLines(getMessage("main.opt." + name));
885 }
886 String[] fmOptions = { "-classpath", "-cp", "-bootclasspath" };
887 for (String o: fmOptions) {
888 if (fileManager.isSupportedOption(o) == -1)
889 continue;
890 String name = o.substring(1);
891 printLines(getMessage("main.opt." + name));
892 }
893
894 }
895
896 private void showVersion(boolean full) {
897 printLines(version(full ? "full" : "release"));
898 }
899
900 private void printLines(String msg) {
901 log.println(msg.replace("\n", nl));
902 }
903
904 private static final String nl = System.getProperty("line.separator");
905
906 private static final String versionRBName = "com.sun.tools.javap.resources.version";
907 private static ResourceBundle versionRB;
908
909 private String version(String key) {
910 // key=version: mm.nn.oo[-milestone]
911 // key=full: mm.mm.oo[-milestone]-build
912 if (versionRB == null) {
913 try {
914 versionRB = ResourceBundle.getBundle(versionRBName);
915 } catch (MissingResourceException e) {
916 return getMessage("version.resource.missing", System.getProperty("java.version"));
917 }
918 }
919 try {
920 return versionRB.getString(key);
921 }
922 catch (MissingResourceException e) {
923 return getMessage("version.unknown", System.getProperty("java.version"));
924 }
925 }
926
927 private void reportError(String key, Object... args) {
928 diagnosticListener.report(createDiagnostic(Diagnostic.Kind.ERROR, key, args));
929 }
930
931 private void reportNote(String key, Object... args) {
932 diagnosticListener.report(createDiagnostic(Diagnostic.Kind.NOTE, key, args));
933 }
934
935 private void reportWarning(String key, Object... args) {
936 diagnosticListener.report(createDiagnostic(Diagnostic.Kind.WARNING, key, args));
937 }
938
939 private Diagnostic<JavaFileObject> createDiagnostic(
940 final Diagnostic.Kind kind, final String key, final Object... args) {
941 return new Diagnostic<JavaFileObject>() {
942 @DefinedBy(Api.COMPILER)
943 public Kind getKind() {
944 return kind;
945 }
946
947 @DefinedBy(Api.COMPILER)
948 public JavaFileObject getSource() {
949 return null;
950 }
951
952 @DefinedBy(Api.COMPILER)
953 public long getPosition() {
954 return Diagnostic.NOPOS;
955 }
956
957 @DefinedBy(Api.COMPILER)
958 public long getStartPosition() {
959 return Diagnostic.NOPOS;
960 }
961
962 @DefinedBy(Api.COMPILER)
963 public long getEndPosition() {
964 return Diagnostic.NOPOS;
965 }
966
967 @DefinedBy(Api.COMPILER)
968 public long getLineNumber() {
969 return Diagnostic.NOPOS;
970 }
971
972 @DefinedBy(Api.COMPILER)
973 public long getColumnNumber() {
974 return Diagnostic.NOPOS;
975 }
976
977 @DefinedBy(Api.COMPILER)
978 public String getCode() {
979 return key;
980 }
981
982 @DefinedBy(Api.COMPILER)
983 public String getMessage(Locale locale) {
984 return JavapTask.this.getMessage(locale, key, args);
985 }
986
987 @Override
988 public String toString() {
989 return getClass().getName() + "[key=" + key + ",args=" + Arrays.asList(args) + "]";
990 }
991
992 };
993
994 }
995
996 public String getMessage(String key, Object... args) {
997 return getMessage(task_locale, key, args);
998 }
999
1000 public String getMessage(Locale locale, String key, Object... args) {
1001 if (bundles == null) {
1002 // could make this a HashMap<Locale,SoftReference<ResourceBundle>>
1003 // and for efficiency, keep a hard reference to the bundle for the task
1004 // locale
1005 bundles = new HashMap<>();
1006 }
1007
1008 if (locale == null)
1009 locale = Locale.getDefault();
1010
1011 ResourceBundle b = bundles.get(locale);
1012 if (b == null) {
1013 try {
1014 b = ResourceBundle.getBundle("com.sun.tools.javap.resources.javap", locale);
1015 bundles.put(locale, b);
1016 } catch (MissingResourceException e) {
1017 throw new InternalError("Cannot find javap resource bundle for locale " + locale);
1018 }
1019 }
1020
1021 try {
1022 return MessageFormat.format(b.getString(key), args);
1023 } catch (MissingResourceException e) {
1024 throw new InternalError(e, key);
1025 }
1026 }
1027
1028 protected Context context;
1029 JavaFileManager fileManager;
1030 JavaFileManager defaultFileManager;
1031 PrintWriter log;
1032 DiagnosticListener<? super JavaFileObject> diagnosticListener;
1033 List<String> classes;
1034 Options options;
1035 //ResourceBundle bundle;
1036 Locale task_locale;
1037 Map<Locale, ResourceBundle> bundles;
1038 protected Attribute.Factory attributeFactory;
1039
1040 private static final String progname = "javap";
1041
1042 private static class SizeInputStream extends FilterInputStream {
1043 SizeInputStream(InputStream in) {
1044 super(in);
1045 }
1046
1047 int size() {
1048 return size;
1049 }
1050
1051 @Override
1052 public int read(byte[] buf, int offset, int length) throws IOException {
1053 int n = super.read(buf, offset, length);
1054 if (n > 0)
1055 size += n;
1056 return n;
1057 }
1058
1059 @Override
1060 public int read() throws IOException {
1061 int b = super.read();
1062 size += 1;
1063 return b;
1064 }
1065
1066 private int size;
1067 }
1068 }