34 import com.sun.tools.classfile.CharacterRangeTable_attribute.Entry;
35 import com.sun.tools.classfile.Code_attribute;
36 import com.sun.tools.classfile.CompilationID_attribute;
37 import com.sun.tools.classfile.ConstantPool;
38 import com.sun.tools.classfile.ConstantPoolException;
39 import com.sun.tools.classfile.ConstantValue_attribute;
40 import com.sun.tools.classfile.DefaultAttribute;
41 import com.sun.tools.classfile.Deprecated_attribute;
42 import com.sun.tools.classfile.EnclosingMethod_attribute;
43 import com.sun.tools.classfile.Exceptions_attribute;
44 import com.sun.tools.classfile.InnerClasses_attribute;
45 import com.sun.tools.classfile.InnerClasses_attribute.Info;
46 import com.sun.tools.classfile.LineNumberTable_attribute;
47 import com.sun.tools.classfile.LocalVariableTable_attribute;
48 import com.sun.tools.classfile.LocalVariableTypeTable_attribute;
49 import com.sun.tools.classfile.MethodParameters_attribute;
50 import com.sun.tools.classfile.Module_attribute;
51 import com.sun.tools.classfile.ModuleHashes_attribute;
52 import com.sun.tools.classfile.ModuleMainClass_attribute;
53 import com.sun.tools.classfile.ModulePackages_attribute;
54 import com.sun.tools.classfile.ModuleTarget_attribute;
55 import com.sun.tools.classfile.ModuleVersion_attribute;
56 import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;
57 import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;
58 import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;
59 import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;
60 import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;
61 import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;
62 import com.sun.tools.classfile.Signature_attribute;
63 import com.sun.tools.classfile.SourceDebugExtension_attribute;
64 import com.sun.tools.classfile.SourceFile_attribute;
65 import com.sun.tools.classfile.SourceID_attribute;
66 import com.sun.tools.classfile.StackMapTable_attribute;
67 import com.sun.tools.classfile.StackMap_attribute;
68 import com.sun.tools.classfile.Synthetic_attribute;
69
70 import static com.sun.tools.classfile.AccessFlags.*;
71
72 import com.sun.tools.javac.util.Assert;
73 import com.sun.tools.javac.util.StringUtils;
74
75 /*
220 if ((e.flags & CharacterRangeTable_attribute.CRT_BRANCH_FALSE) != 0)
221 print(", branch-false");
222 println();
223 }
224 indent(-1);
225 return null;
226 }
227
228 @Override
229 public Void visitCode(Code_attribute attr, Void ignore) {
230 codeWriter.write(attr, constant_pool);
231 return null;
232 }
233
234 @Override
235 public Void visitCompilationID(CompilationID_attribute attr, Void ignore) {
236 constantWriter.write(attr.compilationID_index);
237 return null;
238 }
239
240 private String getJavaPackage(ModulePackages_attribute attr, int index) {
241 try {
242 return getJavaName(attr.getPackage(index, constant_pool));
243 } catch (ConstantPoolException e) {
244 return report(e);
245 }
246 }
247
248 @Override
249 public Void visitModulePackages(ModulePackages_attribute attr, Void ignore) {
250 println("ModulePackages: ");
251 indent(+1);
252 for (int i = 0; i < attr.packages_count; i++) {
253 print("#" + attr.packages_index[i]);
254 tab();
255 println("// " + getJavaPackage(attr, i));
256 }
257 indent(-1);
258 return null;
259 }
260
261 @Override
262 public Void visitConstantValue(ConstantValue_attribute attr, Void ignore) {
263 print("ConstantValue: ");
264 constantWriter.write(attr.constantvalue_index);
265 println();
266 return null;
267 }
268
269 @Override
270 public Void visitDeprecated(Deprecated_attribute attr, Void ignore) {
271 println("Deprecated: true");
272 return null;
273 }
274
275 @Override
276 public Void visitEnclosingMethod(EnclosingMethod_attribute attr, Void ignore) {
277 print("EnclosingMethod: #" + attr.class_index + ".#" + attr.method_index);
278 tab();
279 print("// " + getJavaClassName(attr));
280 if (attr.method_index != 0)
305 indent(+1);
306 print("throws ");
307 for (int i = 0; i < attr.number_of_exceptions; i++) {
308 if (i > 0)
309 print(", ");
310 print(getJavaException(attr, i));
311 }
312 println();
313 indent(-1);
314 return null;
315 }
316
317 private String getJavaException(Exceptions_attribute attr, int index) {
318 try {
319 return getJavaName(attr.getException(index, constant_pool));
320 } catch (ConstantPoolException e) {
321 return report(e);
322 }
323 }
324
325 @Override
326 public Void visitModuleHashes(ModuleHashes_attribute attr, Void ignore) {
327 println("ModuleHashes:");
328 indent(+1);
329 print("algorithm #" + attr.algorithm_index);
330 tab();
331 println("// " + getAlgorithm(attr));
332 for (ModuleHashes_attribute.Entry e : attr.hashes_table) {
333 print("#" + e.module_name_index);
334 tab();
335 println("// " + getModuleName(e));
336 println("hash_length: " + e.hash.length);
337 println("hash: [" + toHex(e.hash) + "]");
338 }
339 indent(-1);
340 return null;
341 }
342
343 private String getAlgorithm(ModuleHashes_attribute attr) {
344 try {
345 return constant_pool.getUTF8Value(attr.algorithm_index);
346 } catch (ConstantPoolException e) {
347 return report(e);
348 }
349 }
350
351 private String getModuleName(ModuleHashes_attribute.Entry entry) {
352 try {
353 return constant_pool.getUTF8Value(entry.module_name_index);
354 } catch (ConstantPoolException e) {
355 return report(e);
356 }
357 }
358
359 @Override
360 public Void visitInnerClasses(InnerClasses_attribute attr, Void ignore) {
361 boolean first = true;
362 for (Info info : attr.classes) {
363 //access
364 AccessFlags access_flags = info.inner_class_access_flags;
365 if (options.checkAccess(access_flags)) {
366 if (first) {
367 writeInnerClassHeader();
368 first = false;
369 }
370 for (String name: access_flags.getInnerClassModifiers())
371 print(name + " ");
372 if (info.inner_name_index != 0) {
373 print("#" + info.inner_name_index + "= ");
374 }
375 print("#" + info.inner_class_info_index);
376 if (info.outer_class_info_index != 0) {
377 print(" of #" + info.outer_class_info_index);
432 }
433 indent(-1);
434 return null;
435 }
436
437 @Override
438 public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, Void ignore) {
439 println("LocalVariableTypeTable:");
440 indent(+1);
441 println("Start Length Slot Name Signature");
442 for (LocalVariableTypeTable_attribute.Entry entry : attr.local_variable_table) {
443 println(String.format("%5d %7d %5d %5s %s",
444 entry.start_pc, entry.length, entry.index,
445 constantWriter.stringValue(entry.name_index),
446 constantWriter.stringValue(entry.signature_index)));
447 }
448 indent(-1);
449 return null;
450 }
451
452 @Override
453 public Void visitModuleMainClass(ModuleMainClass_attribute attr, Void ignore) {
454 print("ModuleMainClass: #" + attr.main_class_index);
455 tab();
456 print("// " + getJavaClassName(attr));
457 println();
458 return null;
459 }
460
461 private String getJavaClassName(ModuleMainClass_attribute a) {
462 try {
463 return getJavaName(a.getMainClassName(constant_pool));
464 } catch (ConstantPoolException e) {
465 return report(e);
466 }
467 }
468
469 private static final String format = "%-31s%s";
470
471 @Override
472 public Void visitMethodParameters(MethodParameters_attribute attr,
473 Void ignore) {
474 final String header = String.format(format, "Name", "Flags");
475 println("MethodParameters:");
476 indent(+1);
477 println(header);
478 for (MethodParameters_attribute.Entry entry :
479 attr.method_parameter_table) {
480 String namestr =
481 entry.name_index != 0 ?
482 constantWriter.stringValue(entry.name_index) : "<no name>";
483 String flagstr =
484 (0 != (entry.flags & ACC_FINAL) ? "final " : "") +
485 (0 != (entry.flags & ACC_MANDATED) ? "mandated " : "") +
486 (0 != (entry.flags & ACC_SYNTHETIC) ? "synthetic" : "");
487 println(String.format(format, namestr, flagstr));
488 }
489 indent(-1);
490 return null;
491 }
492
493 @Override
494 public Void visitModule(Module_attribute attr, Void ignore) {
495 println("Module:");
496 indent(+1);
497
498 print(attr.module_name);
499 tab();
500 println("// " + constantWriter.stringValue(attr.module_name));
501
502 print(String.format("%x", attr.module_flags));
503 tab();
504 print("// ");
505 if ((attr.module_flags & Module_attribute.ACC_OPEN) != 0)
506 print(" ACC_OPEN");
507 if ((attr.module_flags & Module_attribute.ACC_MANDATED) != 0)
508 print(" ACC_MANDATED");
509 if ((attr.module_flags & Module_attribute.ACC_SYNTHETIC) != 0)
510 print(" ACC_SYNTHETIC");
511 println();
512
513 printRequiresTable(attr);
514 printExportsTable(attr);
515 printOpensTable(attr);
516 printUsesTable(attr);
517 printProvidesTable(attr);
518 indent(-1);
519 return null;
520 }
521
522 protected void printRequiresTable(Module_attribute attr) {
523 Module_attribute.RequiresEntry[] entries = attr.requires;
524 print(entries.length);
525 tab();
526 println("// " + "requires");
527 indent(+1);
528 for (Module_attribute.RequiresEntry e: entries) {
529 print("#" + e.requires_index + "," + String.format("%x", e.requires_flags));
530 tab();
531 print("// " + constantWriter.stringValue(e.requires_index));
532 if ((e.requires_flags & Module_attribute.ACC_TRANSITIVE) != 0)
533 print(" ACC_TRANSITIVE");
534 if ((e.requires_flags & Module_attribute.ACC_STATIC_PHASE) != 0)
535 print(" ACC_STATIC_PHASE");
536 if ((e.requires_flags & Module_attribute.ACC_SYNTHETIC) != 0)
537 print(" ACC_SYNTHETIC");
538 if ((e.requires_flags & Module_attribute.ACC_MANDATED) != 0)
539 print(" ACC_MANDATED");
540 println();
541 }
542 indent(-1);
543 }
544
545 protected void printExportsTable(Module_attribute attr) {
546 Module_attribute.ExportsEntry[] entries = attr.exports;
547 print(entries.length);
548 tab();
549 println("// exports");
550 indent(+1);
551 for (Module_attribute.ExportsEntry e: entries) {
552 printExportOpenEntry(e.exports_index, e.exports_flags, e.exports_to_index);
553 }
554 indent(-1);
555 }
556
557 protected void printOpensTable(Module_attribute attr) {
558 Module_attribute.OpensEntry[] entries = attr.opens;
559 print(entries.length);
560 tab();
610 println("// " + "provides");
611 indent(+1);
612 for (Module_attribute.ProvidesEntry e: entries) {
613 print("#" + e.provides_index);
614 tab();
615 print("// ");
616 print(constantWriter.stringValue(e.provides_index));
617 println(" with ... " + e.with_count);
618 indent(+1);
619 for (int with : e.with_index) {
620 print("#" + with);
621 tab();
622 println("// ... with " + constantWriter.stringValue(with));
623 }
624 indent(-1);
625 }
626 indent(-1);
627 }
628
629 @Override
630 public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, Void ignore) {
631 println("RuntimeVisibleAnnotations:");
632 indent(+1);
633 for (int i = 0; i < attr.annotations.length; i++) {
634 print(i + ": ");
635 annotationWriter.write(attr.annotations[i]);
636 println();
637 }
638 indent(-1);
639 return null;
640 }
641
642 @Override
643 public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, Void ignore) {
644 println("RuntimeInvisibleAnnotations:");
645 indent(+1);
646 for (int i = 0; i < attr.annotations.length; i++) {
647 print(i + ": ");
648 annotationWriter.write(attr.annotations[i]);
649 println();
912
913 case StackMapTable_attribute.verification_type_info.ITEM_Object:
914 return "CP";
915
916 case StackMapTable_attribute.verification_type_info.ITEM_Uninitialized:
917 return "uninitialized";
918
919 default:
920 report("unrecognized verification_type_info tag: " + tag);
921 return "[tag:" + tag + "]";
922 }
923 }
924 }
925
926 @Override
927 public Void visitSynthetic(Synthetic_attribute attr, Void ignore) {
928 println("Synthetic: true");
929 return null;
930 }
931
932 @Override
933 public Void visitModuleTarget(ModuleTarget_attribute attr, Void ignore) {
934 println("ModuleTarget:");
935 indent(+1);
936 print("os_name: #" + attr.os_name_index);
937 if (attr.os_name_index != 0) {
938 tab();
939 print("// " + getOSName(attr));
940 }
941 println();
942 print("os_arch: #" + attr.os_arch_index);
943 if (attr.os_arch_index != 0) {
944 tab();
945 print("// " + getOSArch(attr));
946 }
947 println();
948 print("os_version: #" + attr.os_version_index);
949 if (attr.os_version_index != 0) {
950 tab();
951 print("// " + getOSVersion(attr));
952 }
953 println();
954 indent(-1);
955 return null;
956 }
957
958 private String getOSName(ModuleTarget_attribute attr) {
959 try {
960 return constant_pool.getUTF8Value(attr.os_name_index);
961 } catch (ConstantPoolException e) {
962 return report(e);
963 }
964 }
965
966 private String getOSArch(ModuleTarget_attribute attr) {
967 try {
968 return constant_pool.getUTF8Value(attr.os_arch_index);
969 } catch (ConstantPoolException e) {
970 return report(e);
971 }
972 }
973
974 private String getOSVersion(ModuleTarget_attribute attr) {
975 try {
976 return constant_pool.getUTF8Value(attr.os_version_index);
977 } catch (ConstantPoolException e) {
978 return report(e);
979 }
980 }
981
982 @Override
983 public Void visitModuleVersion(ModuleVersion_attribute attr, Void ignore) {
984 print("ModuleVersion: #" + attr.version_index);
985 indent(+1);
986 tab();
987 println("// " + getVersion(attr));
988 indent(-1);
989 return null;
990 }
991
992 private String getVersion(ModuleVersion_attribute attr) {
993 try {
994 return constant_pool.getUTF8Value(attr.version_index);
995 } catch (ConstantPoolException e) {
996 return report(e);
997 }
998 }
999
1000 static String getJavaName(String name) {
1001 return name.replace('/', '.');
1002 }
1003
1004 String toHex(byte b, int w) {
1005 return toHex(b & 0xff, w);
1006 }
1007
1008 static String toHex(int i) {
1009 return StringUtils.toUpperCase(Integer.toString(i, 16));
1010 }
1011
1012 static String toHex(int i, int w) {
1013 String s = StringUtils.toUpperCase(Integer.toHexString(i));
1014 while (s.length() < w)
1015 s = "0" + s;
1016 return StringUtils.toUpperCase(s);
1017 }
1018
1019 static String toHex(byte[] ba) {
|
34 import com.sun.tools.classfile.CharacterRangeTable_attribute.Entry;
35 import com.sun.tools.classfile.Code_attribute;
36 import com.sun.tools.classfile.CompilationID_attribute;
37 import com.sun.tools.classfile.ConstantPool;
38 import com.sun.tools.classfile.ConstantPoolException;
39 import com.sun.tools.classfile.ConstantValue_attribute;
40 import com.sun.tools.classfile.DefaultAttribute;
41 import com.sun.tools.classfile.Deprecated_attribute;
42 import com.sun.tools.classfile.EnclosingMethod_attribute;
43 import com.sun.tools.classfile.Exceptions_attribute;
44 import com.sun.tools.classfile.InnerClasses_attribute;
45 import com.sun.tools.classfile.InnerClasses_attribute.Info;
46 import com.sun.tools.classfile.LineNumberTable_attribute;
47 import com.sun.tools.classfile.LocalVariableTable_attribute;
48 import com.sun.tools.classfile.LocalVariableTypeTable_attribute;
49 import com.sun.tools.classfile.MethodParameters_attribute;
50 import com.sun.tools.classfile.Module_attribute;
51 import com.sun.tools.classfile.ModuleHashes_attribute;
52 import com.sun.tools.classfile.ModuleMainClass_attribute;
53 import com.sun.tools.classfile.ModulePackages_attribute;
54 import com.sun.tools.classfile.ModuleResolution_attribute;
55 import com.sun.tools.classfile.ModuleTarget_attribute;
56 import com.sun.tools.classfile.RuntimeInvisibleAnnotations_attribute;
57 import com.sun.tools.classfile.RuntimeInvisibleParameterAnnotations_attribute;
58 import com.sun.tools.classfile.RuntimeInvisibleTypeAnnotations_attribute;
59 import com.sun.tools.classfile.RuntimeVisibleAnnotations_attribute;
60 import com.sun.tools.classfile.RuntimeVisibleParameterAnnotations_attribute;
61 import com.sun.tools.classfile.RuntimeVisibleTypeAnnotations_attribute;
62 import com.sun.tools.classfile.Signature_attribute;
63 import com.sun.tools.classfile.SourceDebugExtension_attribute;
64 import com.sun.tools.classfile.SourceFile_attribute;
65 import com.sun.tools.classfile.SourceID_attribute;
66 import com.sun.tools.classfile.StackMapTable_attribute;
67 import com.sun.tools.classfile.StackMap_attribute;
68 import com.sun.tools.classfile.Synthetic_attribute;
69
70 import static com.sun.tools.classfile.AccessFlags.*;
71
72 import com.sun.tools.javac.util.Assert;
73 import com.sun.tools.javac.util.StringUtils;
74
75 /*
220 if ((e.flags & CharacterRangeTable_attribute.CRT_BRANCH_FALSE) != 0)
221 print(", branch-false");
222 println();
223 }
224 indent(-1);
225 return null;
226 }
227
228 @Override
229 public Void visitCode(Code_attribute attr, Void ignore) {
230 codeWriter.write(attr, constant_pool);
231 return null;
232 }
233
234 @Override
235 public Void visitCompilationID(CompilationID_attribute attr, Void ignore) {
236 constantWriter.write(attr.compilationID_index);
237 return null;
238 }
239
240 @Override
241 public Void visitConstantValue(ConstantValue_attribute attr, Void ignore) {
242 print("ConstantValue: ");
243 constantWriter.write(attr.constantvalue_index);
244 println();
245 return null;
246 }
247
248 @Override
249 public Void visitDeprecated(Deprecated_attribute attr, Void ignore) {
250 println("Deprecated: true");
251 return null;
252 }
253
254 @Override
255 public Void visitEnclosingMethod(EnclosingMethod_attribute attr, Void ignore) {
256 print("EnclosingMethod: #" + attr.class_index + ".#" + attr.method_index);
257 tab();
258 print("// " + getJavaClassName(attr));
259 if (attr.method_index != 0)
284 indent(+1);
285 print("throws ");
286 for (int i = 0; i < attr.number_of_exceptions; i++) {
287 if (i > 0)
288 print(", ");
289 print(getJavaException(attr, i));
290 }
291 println();
292 indent(-1);
293 return null;
294 }
295
296 private String getJavaException(Exceptions_attribute attr, int index) {
297 try {
298 return getJavaName(attr.getException(index, constant_pool));
299 } catch (ConstantPoolException e) {
300 return report(e);
301 }
302 }
303
304
305 @Override
306 public Void visitInnerClasses(InnerClasses_attribute attr, Void ignore) {
307 boolean first = true;
308 for (Info info : attr.classes) {
309 //access
310 AccessFlags access_flags = info.inner_class_access_flags;
311 if (options.checkAccess(access_flags)) {
312 if (first) {
313 writeInnerClassHeader();
314 first = false;
315 }
316 for (String name: access_flags.getInnerClassModifiers())
317 print(name + " ");
318 if (info.inner_name_index != 0) {
319 print("#" + info.inner_name_index + "= ");
320 }
321 print("#" + info.inner_class_info_index);
322 if (info.outer_class_info_index != 0) {
323 print(" of #" + info.outer_class_info_index);
378 }
379 indent(-1);
380 return null;
381 }
382
383 @Override
384 public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, Void ignore) {
385 println("LocalVariableTypeTable:");
386 indent(+1);
387 println("Start Length Slot Name Signature");
388 for (LocalVariableTypeTable_attribute.Entry entry : attr.local_variable_table) {
389 println(String.format("%5d %7d %5d %5s %s",
390 entry.start_pc, entry.length, entry.index,
391 constantWriter.stringValue(entry.name_index),
392 constantWriter.stringValue(entry.signature_index)));
393 }
394 indent(-1);
395 return null;
396 }
397
398 private String getJavaClassName(ModuleMainClass_attribute a) {
399 try {
400 return getJavaName(a.getMainClassName(constant_pool));
401 } catch (ConstantPoolException e) {
402 return report(e);
403 }
404 }
405
406 private static final String format = "%-31s%s";
407
408 @Override
409 public Void visitMethodParameters(MethodParameters_attribute attr,
410 Void ignore) {
411 final String header = String.format(format, "Name", "Flags");
412 println("MethodParameters:");
413 indent(+1);
414 println(header);
415 for (MethodParameters_attribute.Entry entry :
416 attr.method_parameter_table) {
417 String namestr =
418 entry.name_index != 0 ?
419 constantWriter.stringValue(entry.name_index) : "<no name>";
420 String flagstr =
421 (0 != (entry.flags & ACC_FINAL) ? "final " : "") +
422 (0 != (entry.flags & ACC_MANDATED) ? "mandated " : "") +
423 (0 != (entry.flags & ACC_SYNTHETIC) ? "synthetic" : "");
424 println(String.format(format, namestr, flagstr));
425 }
426 indent(-1);
427 return null;
428 }
429
430 @Override
431 public Void visitModule(Module_attribute attr, Void ignore) {
432 println("Module:");
433 indent(+1);
434
435 print("#" + attr.module_name);
436 print(",");
437 print(String.format("%x", attr.module_flags));
438 tab();
439 print("// " + constantWriter.stringValue(attr.module_name));
440 if ((attr.module_flags & Module_attribute.ACC_OPEN) != 0)
441 print(" ACC_OPEN");
442 if ((attr.module_flags & Module_attribute.ACC_MANDATED) != 0)
443 print(" ACC_MANDATED");
444 if ((attr.module_flags & Module_attribute.ACC_SYNTHETIC) != 0)
445 print(" ACC_SYNTHETIC");
446 println();
447 print("#" + attr.module_version_index);
448 if (attr.module_version_index != 0) {
449 tab();
450 print("// " + constantWriter.stringValue(attr.module_version_index));
451 }
452 println();
453
454 printRequiresTable(attr);
455 printExportsTable(attr);
456 printOpensTable(attr);
457 printUsesTable(attr);
458 printProvidesTable(attr);
459 indent(-1);
460 return null;
461 }
462
463 protected void printRequiresTable(Module_attribute attr) {
464 Module_attribute.RequiresEntry[] entries = attr.requires;
465 print(entries.length);
466 tab();
467 println("// " + "requires");
468 indent(+1);
469 for (Module_attribute.RequiresEntry e: entries) {
470 print("#" + e.requires_index + "," + String.format("%x", e.requires_flags));
471 tab();
472 print("// " + constantWriter.stringValue(e.requires_index));
473 if ((e.requires_flags & Module_attribute.ACC_TRANSITIVE) != 0)
474 print(" ACC_TRANSITIVE");
475 if ((e.requires_flags & Module_attribute.ACC_STATIC_PHASE) != 0)
476 print(" ACC_STATIC_PHASE");
477 if ((e.requires_flags & Module_attribute.ACC_SYNTHETIC) != 0)
478 print(" ACC_SYNTHETIC");
479 if ((e.requires_flags & Module_attribute.ACC_MANDATED) != 0)
480 print(" ACC_MANDATED");
481 println();
482 print("#" + e.requires_version_index);
483 if (e.requires_version_index != 0) {
484 tab();
485 print("// " + constantWriter.stringValue(e.requires_version_index));
486 }
487 println();
488 }
489 indent(-1);
490 }
491
492 protected void printExportsTable(Module_attribute attr) {
493 Module_attribute.ExportsEntry[] entries = attr.exports;
494 print(entries.length);
495 tab();
496 println("// exports");
497 indent(+1);
498 for (Module_attribute.ExportsEntry e: entries) {
499 printExportOpenEntry(e.exports_index, e.exports_flags, e.exports_to_index);
500 }
501 indent(-1);
502 }
503
504 protected void printOpensTable(Module_attribute attr) {
505 Module_attribute.OpensEntry[] entries = attr.opens;
506 print(entries.length);
507 tab();
557 println("// " + "provides");
558 indent(+1);
559 for (Module_attribute.ProvidesEntry e: entries) {
560 print("#" + e.provides_index);
561 tab();
562 print("// ");
563 print(constantWriter.stringValue(e.provides_index));
564 println(" with ... " + e.with_count);
565 indent(+1);
566 for (int with : e.with_index) {
567 print("#" + with);
568 tab();
569 println("// ... with " + constantWriter.stringValue(with));
570 }
571 indent(-1);
572 }
573 indent(-1);
574 }
575
576 @Override
577 public Void visitModuleHashes(ModuleHashes_attribute attr, Void ignore) {
578 println("ModuleHashes:");
579 indent(+1);
580 print("algorithm: #" + attr.algorithm_index);
581 tab();
582 println("// " + getAlgorithm(attr));
583 print(attr.hashes_table_length);
584 tab();
585 println("// hashes");
586 for (ModuleHashes_attribute.Entry e : attr.hashes_table) {
587 print("#" + e.module_name_index);
588 tab();
589 println("// " + getModuleName(e));
590 println("hash_length: " + e.hash.length);
591 println("hash: [" + toHex(e.hash) + "]");
592 }
593 indent(-1);
594 return null;
595 }
596
597 private String getAlgorithm(ModuleHashes_attribute attr) {
598 try {
599 return constant_pool.getUTF8Value(attr.algorithm_index);
600 } catch (ConstantPoolException e) {
601 return report(e);
602 }
603 }
604
605 private String getModuleName(ModuleHashes_attribute.Entry entry) {
606 try {
607 int utf8Index = constant_pool.getModuleInfo(entry.module_name_index).name_index;
608 return constant_pool.getUTF8Value(utf8Index);
609 } catch (ConstantPoolException e) {
610 return report(e);
611 }
612 }
613
614 @Override
615 public Void visitModuleMainClass(ModuleMainClass_attribute attr, Void ignore) {
616 print("ModuleMainClass: #" + attr.main_class_index);
617 tab();
618 print("// " + getJavaClassName(attr));
619 println();
620 return null;
621 }
622
623 @Override
624 public Void visitModulePackages(ModulePackages_attribute attr, Void ignore) {
625 println("ModulePackages: ");
626 indent(+1);
627 for (int i = 0; i < attr.packages_count; i++) {
628 print("#" + attr.packages_index[i]);
629 tab();
630 println("// " + getJavaPackage(attr, i));
631 }
632 indent(-1);
633 return null;
634 }
635
636 private String getJavaPackage(ModulePackages_attribute attr, int index) {
637 try {
638 return getJavaName(attr.getPackage(index, constant_pool));
639 } catch (ConstantPoolException e) {
640 return report(e);
641 }
642 }
643
644 @Override
645 public Void visitModuleResolution(ModuleResolution_attribute attr, Void ignore) {
646 println("ModuleResolution:");
647 indent(+1);
648 print(String.format("%x", attr.resolution_flags));
649 tab();
650 print("// ");
651 int flags = attr.resolution_flags;
652 if ((flags & ModuleResolution_attribute.DO_NOT_RESOLVE_BY_DEFAULT) != 0)
653 print(" DO_NOT_RESOLVE_BY_DEFAULT");
654 if ((flags & ModuleResolution_attribute.WARN_DEPRECATED) != 0)
655 print(" WARN_DEPRECATED");
656 if ((flags & ModuleResolution_attribute.WARN_DEPRECATED_FOR_REMOVAL) != 0)
657 print(" WARN_DEPRECATED_FOR_REMOVAL");
658 if ((flags & ModuleResolution_attribute.WARN_INCUBATING) != 0)
659 print(" WARN_INCUBATING");
660 println();
661 indent(-1);
662 return null;
663 }
664
665 @Override
666 public Void visitModuleTarget(ModuleTarget_attribute attr, Void ignore) {
667 println("ModuleTarget:");
668 indent(+1);
669 print("os_name: #" + attr.os_name_index);
670 if (attr.os_name_index != 0) {
671 tab();
672 print("// " + getOSName(attr));
673 }
674 println();
675 print("os_arch: #" + attr.os_arch_index);
676 if (attr.os_arch_index != 0) {
677 tab();
678 print("// " + getOSArch(attr));
679 }
680 println();
681 print("os_version: #" + attr.os_version_index);
682 if (attr.os_version_index != 0) {
683 tab();
684 print("// " + getOSVersion(attr));
685 }
686 println();
687 indent(-1);
688 return null;
689 }
690
691 private String getOSName(ModuleTarget_attribute attr) {
692 try {
693 return constant_pool.getUTF8Value(attr.os_name_index);
694 } catch (ConstantPoolException e) {
695 return report(e);
696 }
697 }
698
699 private String getOSArch(ModuleTarget_attribute attr) {
700 try {
701 return constant_pool.getUTF8Value(attr.os_arch_index);
702 } catch (ConstantPoolException e) {
703 return report(e);
704 }
705 }
706
707 private String getOSVersion(ModuleTarget_attribute attr) {
708 try {
709 return constant_pool.getUTF8Value(attr.os_version_index);
710 } catch (ConstantPoolException e) {
711 return report(e);
712 }
713 }
714
715 @Override
716 public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, Void ignore) {
717 println("RuntimeVisibleAnnotations:");
718 indent(+1);
719 for (int i = 0; i < attr.annotations.length; i++) {
720 print(i + ": ");
721 annotationWriter.write(attr.annotations[i]);
722 println();
723 }
724 indent(-1);
725 return null;
726 }
727
728 @Override
729 public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, Void ignore) {
730 println("RuntimeInvisibleAnnotations:");
731 indent(+1);
732 for (int i = 0; i < attr.annotations.length; i++) {
733 print(i + ": ");
734 annotationWriter.write(attr.annotations[i]);
735 println();
998
999 case StackMapTable_attribute.verification_type_info.ITEM_Object:
1000 return "CP";
1001
1002 case StackMapTable_attribute.verification_type_info.ITEM_Uninitialized:
1003 return "uninitialized";
1004
1005 default:
1006 report("unrecognized verification_type_info tag: " + tag);
1007 return "[tag:" + tag + "]";
1008 }
1009 }
1010 }
1011
1012 @Override
1013 public Void visitSynthetic(Synthetic_attribute attr, Void ignore) {
1014 println("Synthetic: true");
1015 return null;
1016 }
1017
1018 static String getJavaName(String name) {
1019 return name.replace('/', '.');
1020 }
1021
1022 String toHex(byte b, int w) {
1023 return toHex(b & 0xff, w);
1024 }
1025
1026 static String toHex(int i) {
1027 return StringUtils.toUpperCase(Integer.toString(i, 16));
1028 }
1029
1030 static String toHex(int i, int w) {
1031 String s = StringUtils.toUpperCase(Integer.toHexString(i));
1032 while (s.length() < w)
1033 s = "0" + s;
1034 return StringUtils.toUpperCase(s);
1035 }
1036
1037 static String toHex(byte[] ba) {
|