1 /*
2 * Copyright (c) 2007, 2026, 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.lang.classfile.AccessFlags;
29 import java.lang.classfile.Attributes;
30 import java.lang.classfile.ClassFile;
31 import java.lang.classfile.ClassHierarchyResolver;
32 import java.lang.classfile.ClassModel;
33 import java.lang.classfile.ClassSignature;
34 import java.lang.classfile.FieldModel;
35 import java.lang.classfile.MethodModel;
36 import java.lang.classfile.MethodSignature;
37 import java.lang.classfile.Signature;
38 import java.lang.classfile.attribute.CodeAttribute;
39 import java.lang.classfile.attribute.SignatureAttribute;
40 import java.lang.classfile.constantpool.ClassEntry;
41 import java.lang.classfile.constantpool.ConstantValueEntry;
42 import java.lang.classfile.constantpool.PoolEntry;
43 import java.lang.constant.ClassDesc;
44 import java.lang.reflect.AccessFlag;
45 import java.lang.reflect.ClassFileFormatVersion;
46 import java.lang.reflect.Modifier;
47 import java.net.URI;
48 import java.text.DateFormat;
49 import java.util.ArrayList;
50 import java.util.Collection;
51 import java.util.Date;
52 import java.util.EnumSet;
53 import java.util.LinkedHashSet;
54 import java.util.List;
55 import java.util.Locale;
56 import java.util.Set;
57
58 import static java.lang.classfile.ClassFile.*;
59
60 /*
61 * The main javap class to write the contents of a class file as text.
62 *
63 * <p><b>This is NOT part of any supported API.
64 * If you write code that depends on this, you do so at your own risk.
65 * This code and its internal interfaces are subject to change or
66 * deletion without notice.</b>
67 */
68 public class ClassWriter extends BasicWriter {
69 static ClassWriter instance(Context context) {
70 ClassWriter instance = context.get(ClassWriter.class);
71 if (instance == null)
72 instance = new ClassWriter(context);
73 return instance;
74 }
75
76 protected ClassWriter(Context context) {
77 super(context);
78 context.put(ClassWriter.class, this);
79 options = Options.instance(context);
80 attrWriter = AttributeWriter.instance(context);
81 codeWriter = CodeWriter.instance(context);
82 constantWriter = ConstantWriter.instance(context);
83 sigPrinter = new SignaturePrinter(options.verbose);
84 }
85
86 void setDigest(String name, byte[] digest) {
87 this.digestName = name;
88 this.digest = digest;
89 }
90
91 void setFile(URI uri) {
92 this.uri = uri;
93 }
94
95 void setFileSize(int size) {
96 this.size = size;
97 }
98
99 void setLastModified(long lastModified) {
100 this.lastModified = lastModified;
101 }
102
103 protected ClassModel getClassModel() {
104 return classModel;
105 }
106
107 protected void setClassFile(ClassModel cm) {
108 classModel = cm;
109 }
110
111 protected MethodModel getMethod() {
112 return method;
113 }
114
115 protected void setMethod(MethodModel m) {
116 method = m;
117 }
118
119 protected ClassFileFormatVersion cffv() {
120 var major = classModel.majorVersion();
121 if (major < JAVA_1_VERSION || major > ClassFile.latestMajorVersion())
122 // something not representable by CFFV, let's fall back
123 return ClassFileFormatVersion.latest();
124 if (major >= JAVA_12_VERSION && classModel.minorVersion() != 0) {
125 // preview versions aren't explicitly supported, but latest is good enough for now
126 return ClassFileFormatVersion.latest();
127 }
128 return ClassFileFormatVersion.fromMajor(major);
129 }
130
131 public boolean write(ClassModel cm) {
132 errorReported = false;
133 setClassFile(cm);
134
135 if (options.sysInfo || options.verbose) {
136 if (uri != null) {
137 if (uri.getScheme().equals("file"))
138 println("Classfile " + uri.getPath());
139 else
140 println("Classfile " + uri);
141 }
142 indent(+1);
143 if (lastModified != -1) {
144 Date lm = new Date(lastModified);
145 DateFormat df = DateFormat.getDateInstance();
146 if (size > 0) {
147 println("Last modified " + df.format(lm) + "; size " + size
148 + " bytes");
149 } else {
150 println("Last modified " + df.format(lm));
151 }
152 } else if (size > 0) {
153 println("Size " + size + " bytes");
154 }
155 if (digestName != null && digest != null) {
156 StringBuilder sb = new StringBuilder();
157 for (byte b: digest)
158 sb.append(String.format("%02x", b));
159 println(digestName + " checksum " + sb);
160 }
161 }
162
163 cm.findAttribute(Attributes.sourceFile()).ifPresent(sfa ->
164 println("Compiled from \"" + sfa.sourceFile().stringValue() + "\""));
165
166 if (options.sysInfo || options.verbose) {
167 indent(-1);
168 }
169
170 writeModifiers(getClassModifiers(cm.flags()));
171
172 if ((classModel.flags().flagsMask() & ACC_MODULE) != 0) {
173 var attr = classModel.findAttribute(Attributes.module());
174 if (attr.isPresent()) {
175 var modAttr = attr.get();
176 if ((modAttr.moduleFlagsMask() & ACC_OPEN) != 0) {
177 print("open ");
178 }
179 print("module ");
180 print(() -> modAttr.moduleName().name().stringValue());
181 if (modAttr.moduleVersion().isPresent()) {
182 print("@");
183 print(() -> modAttr.moduleVersion().get().stringValue());
184 }
185 } else {
186 // fallback for malformed class files
187 print("class ");
188 print(() -> getJavaName(classModel.thisClass().asInternalName()));
189 }
190 } else {
191 if ((classModel.flags().flagsMask() & ACC_INTERFACE) == 0)
192 print("class ");
193 else
194 print("interface ");
195
196 print(() -> getJavaName(classModel.thisClass().asInternalName()));
197 }
198
199 try {
200 var sigAttr = classModel.findAttribute(Attributes.signature()).orElse(null);
201 if (sigAttr == null) {
202 // use info from class file header
203 if ((classModel.flags().flagsMask() & ACC_INTERFACE) == 0
204 && classModel.superclass().isPresent()) {
205 String sn = getJavaName(classModel.superclass().get().asInternalName());
206 if (!sn.equals("java.lang.Object")) {
207 print(" extends ");
208 print(sn);
209 }
210 }
211 var interfaces = classModel.interfaces();
212 for (int i = 0; i < interfaces.size(); i++) {
213 print(i == 0 ? ((classModel.flags().flagsMask() & ACC_INTERFACE) == 0
214 ? " implements " : " extends ") : ",");
215 print(getJavaName(interfaces.get(i).asInternalName()));
216 }
217 } else {
218 var t = sigAttr.asClassSignature();
219 print(sigPrinter.print(t, (classModel.flags().flagsMask() & ACC_INTERFACE) != 0));
220 }
221 } catch (IllegalArgumentException e) {
222 report(e);
223 }
224
225 if (options.verbose) {
226 println();
227 indent(+1);
228 println("minor version: " + classModel.minorVersion());
229 println("major version: " + classModel.majorVersion());
230 writeList(String.format("flags: (0x%04x) ", cm.flags().flagsMask()),
231 getClassFlags(cm.flags()), "\n");
232 print("this_class: #");print(() -> classModel.thisClass().index());
233 tab();
234 print(() -> "// " + classModel.thisClass().asInternalName());
235 println();
236 print("super_class: #");print(() -> classModel.superclass()
237 .map(ClassEntry::index).orElse(0));
238 try {
239 if (classModel.superclass().isPresent()) {
240 tab();
241 print(() -> "// " + classModel.superclass().get().asInternalName());
242 }
243 } catch (IllegalArgumentException e) {
244 report(e);
245 }
246 println();
247 print("interfaces: ");print(() -> classModel.interfaces().size());
248 print(", fields: " + classModel.fields().size());
249 print(", methods: " + classModel.methods().size());
250 println(", attributes: " + classModel.attributes().size());
251 indent(-1);
252 constantWriter.writeConstantPool();
253 } else {
254 print(" ");
255 }
256
257 println("{");
258 indent(+1);
259 if ((cm.flags().flagsMask() & ACC_MODULE) != 0 && !options.verbose) {
260 writeDirectives();
261 }
262 writeFields();
263 writeMethods();
264 indent(-1);
265 println("}");
266
267 if (options.verbose) {
268 attrWriter.write(classModel.attributes(), cffv());
269 }
270
271 if (options.verify) {
272 var vErrors = VERIFIER.verify(classModel);
273 if (!vErrors.isEmpty()) {
274 println();
275 for (var ve : vErrors) {
276 println(ve.getMessage());
277 }
278 errorReported = true;
279 }
280 }
281 return !errorReported;
282 }
283 // where
284
285 private static final ClassFile VERIFIER = ClassFile.of(ClassHierarchyResolverOption.of(
286 ClassHierarchyResolver.defaultResolver().orElse(new ClassHierarchyResolver() {
287 @Override
288 public ClassHierarchyInfo getClassInfo(ClassDesc classDesc) {
289 // mark all unresolved classes as interfaces to exclude them from assignability verification
290 return ClassHierarchyInfo.ofInterface();
291 }
292 })));
293
294 final SignaturePrinter sigPrinter;
295
296 public static record SignaturePrinter(boolean verbose) {
297
298 public String print(ClassSignature cs, boolean isInterface) {
299 var sb = new StringBuilder();
300 print(sb, cs.typeParameters());
301 if (isInterface) {
302 String sep = " extends ";
303 for (var is : cs.superinterfaceSignatures()) {
304 sb.append(sep);
305 print(sb, is);
306 sep = ", ";
307 }
308 } else {
309 if (cs.superclassSignature() != null
310 && (verbose || !isObject(cs.superclassSignature()))) {
311 sb.append(" extends ");
312 print(sb, cs.superclassSignature());
313 }
314 String sep = " implements ";
315 for (var is : cs.superinterfaceSignatures()) {
316 sb.append(sep);
317 print(sb, is);
318 sep = ", ";
319 }
320 }
321 return sb.toString();
322 }
323
324 public String print(Signature sig) {
325 var sb = new StringBuilder();
326 print(sb, sig);
327 return sb.toString();
328 }
329
330 public String printTypeParams(List<Signature.TypeParam> tps) {
331 var sb = new StringBuilder();
332 print(sb, tps);
333 return sb.toString();
334 }
335
336 public String printList(String prefix, List<? extends Signature> args,
337 String postfix) {
338 var sb = new StringBuilder();
339 sb.append(prefix);
340 String sep = "";
341 for (var arg : args) {
342 sb.append(sep);
343 print(sb, arg);
344 sep = ", ";
345 }
346 return sb.append(postfix).toString();
347 }
348
349 private boolean isObject(Signature sig) {
350 return (sig instanceof Signature.ClassTypeSig cts)
351 && cts.outerType().isEmpty()
352 && cts.className().equals("java/lang/Object")
353 && (cts.typeArgs().isEmpty());
354 }
355
356 private void print(StringBuilder sb, List<Signature.TypeParam> tps) {
357 if (!tps.isEmpty()) {
358 sb.append('<');
359 String sep = "";
360 for (var tp : tps) {
361 sb.append(sep).append(tp.identifier());
362 sep = " extends ";
363 if (tp.classBound().isPresent()
364 && (verbose || !isObject(tp.classBound().get()))) {
365 sb.append(sep);
366 print(sb, tp.classBound().get());
367 sep = " & ";
368 }
369 for (var bound: tp.interfaceBounds()) {
370 sb.append(sep);
371 print(sb, bound);
372 sep = " & ";
373 }
374 sep = ", ";
375 }
376 sb.append('>');
377 }
378 }
379
380 private void print(StringBuilder sb, Signature sig) {
381 if (sig instanceof Signature.BaseTypeSig bts) {
382 sb.append(ClassDesc.ofDescriptor("" + bts.baseType()).displayName());
383 } else if (sig instanceof Signature.ClassTypeSig cts) {
384 if (cts.outerType().isPresent()) {
385 print(sb, cts.outerType().get());
386 sb.append(".");
387 }
388 sb.append(getJavaName(cts.className()));
389 if (!cts.typeArgs().isEmpty()) {
390 String sep = "";
391 sb.append('<');
392 for (var ta : cts.typeArgs()) {
393 sb.append(sep);
394 print(sb, ta);
395 sep = ", ";
396 }
397 sb.append('>');
398 }
399 } else if (sig instanceof Signature.TypeVarSig tvs) {
400 sb.append(tvs.identifier());
401 } else if (sig instanceof Signature.ArrayTypeSig ats) {
402 print(sb, ats.componentSignature());
403 sb.append("[]");
404 }
405 }
406
407 private void print(StringBuilder sb, Signature.TypeArg ta) {
408 switch (ta) {
409 case Signature.TypeArg.Unbounded _ -> sb.append('?');
410 case Signature.TypeArg.Bounded bta -> {
411 switch (bta.wildcardIndicator()) {
412 case NONE -> print(sb, bta.boundType());
413 case EXTENDS -> {
414 sb.append("? extends ");
415 print(sb, bta.boundType());
416 }
417 case SUPER -> {
418 sb.append("? super ");
419 print(sb, bta.boundType());
420 }
421 }
422 }
423 }
424 }
425 }
426
427 protected void writeFields() {
428 for (var f: classModel.fields()) {
429 writeField(f);
430 }
431 }
432
433 protected void writeField(FieldModel f) {
434 if (!options.checkAccess(f.flags().flagsMask()))
435 return;
436
437 var flags = f.flags();
438 writeModifiers(getModifiers(flagsReportUnknown(flags, cffv())));
439 print(() -> sigPrinter.print(
440 f.findAttribute(Attributes.signature())
441 .map(SignatureAttribute::asTypeSignature)
442 .orElseGet(() -> Signature.of(f.fieldTypeSymbol()))));
443 print(" ");
444 print(() -> f.fieldName().stringValue());
445 if (options.showConstants) {
446 var a = f.findAttribute(Attributes.constantValue());
447 if (a.isPresent()) {
448 print(" = ");
449 var cv = a.get();
450 print(() -> getConstantValue(f.fieldTypeSymbol(), cv.constant()));
451 }
452 }
453 print(";");
454 println();
455
456 indent(+1);
457
458 boolean showBlank = false;
459
460 if (options.showDescriptors) {
461 print("descriptor: ");println(() -> f.fieldType().stringValue());
462 }
463
464 if (options.verbose)
465 writeList(String.format("flags: (0x%04x) ", flags.flagsMask()),
466 flagsReportUnknown(flags, cffv()).stream().map(fl -> "ACC_" + fl.name()).toList(),
467 "\n");
468
469 if (options.showAllAttrs) {
470 attrWriter.write(f.attributes(), cffv());
471 showBlank = true;
472 }
473
474 indent(-1);
475
476 if (showBlank || options.showDisassembled || options.showLineAndLocalVariableTables)
477 println();
478 }
479
480 protected void writeMethods() {
481 for (MethodModel m: classModel.methods())
482 writeMethod(m);
483 setPendingNewline(false);
484 }
485
486 private static final int DEFAULT_ALLOWED_MAJOR_VERSION = 52;
487 private static final int DEFAULT_ALLOWED_MINOR_VERSION = 0;
488
489 protected void writeMethod(MethodModel m) {
490 if (!options.checkAccess(m.flags().flagsMask()))
491 return;
492
493 method = m;
494
495 int flags = m.flags().flagsMask();
496
497 var modifiers = getModifiers(flagsReportUnknown(m.flags(), cffv()));
498
499 String name = "???";
500 try {
501 name = m.methodName().stringValue();
502 } catch (IllegalArgumentException e) {
503 report(e);
504 }
505
506 if ((classModel.flags().flagsMask() & ACC_INTERFACE) != 0 &&
507 ((flags & ACC_ABSTRACT) == 0) && !name.equals("<clinit>")) {
508 if (classModel.majorVersion() > DEFAULT_ALLOWED_MAJOR_VERSION ||
509 (classModel.majorVersion() == DEFAULT_ALLOWED_MAJOR_VERSION
510 && classModel.minorVersion() >= DEFAULT_ALLOWED_MINOR_VERSION)) {
511 if ((flags & (ACC_STATIC | ACC_PRIVATE)) == 0) {
512 modifiers.add("default");
513 }
514 }
515 }
516 writeModifiers(modifiers);
517
518 try {
519 var sigAttr = m.findAttribute(Attributes.signature());
520 MethodSignature d;
521 if (sigAttr.isEmpty()) {
522 d = MethodSignature.parseFrom(m.methodType().stringValue());
523 } else {
524 d = sigAttr.get().asMethodSignature();
525 }
526
527 if (!d.typeParameters().isEmpty()) {
528 print(sigPrinter.printTypeParams(d.typeParameters()) + " ");
529 }
530 switch (name) {
531 case "<init>":
532 print(getJavaName(classModel.thisClass().asInternalName()));
533 print(getJavaParameterTypes(d, flags));
534 break;
535 case "<clinit>":
536 print("{}");
537 break;
538 default:
539 print(getJavaName(sigPrinter.print(d.result())));
540 print(" ");
541 print(name);
542 print(getJavaParameterTypes(d, flags));
543 break;
544 }
545
546 var e_attr = m.findAttribute(Attributes.exceptions());
547 // if there are generic exceptions, there must be erased exceptions
548 if (e_attr.isPresent()) {
549 var exceptions = e_attr.get();
550 print(" throws ");
551 if (d != null && !d.throwableSignatures().isEmpty()) { // use generic list if available
552 print(() -> sigPrinter.printList("", d.throwableSignatures(), ""));
553 } else {
554 var exNames = exceptions.exceptions();
555 for (int i = 0; i < exNames.size(); i++) {
556 if (i > 0)
557 print(", ");
558 int ii = i;
559 print(() -> getJavaName(exNames.get(ii).asInternalName()));
560 }
561 }
562 }
563 } catch (IllegalArgumentException e) {
564 report(e);
565 }
566
567 println(";");
568
569 indent(+1);
570
571 if (options.showDescriptors) {
572 print("descriptor: ");println(() -> m.methodType().stringValue());
573 }
574
575 if (options.verbose) {
576 StringBuilder sb = new StringBuilder();
577 String sep = "";
578 sb.append(String.format("flags: (0x%04x) ", flags));
579 for (var f : flagsReportUnknown(m.flags(), cffv())) {
580 sb.append(sep).append("ACC_").append(f.name());
581 sep = ", ";
582 }
583 println(sb.toString());
584 }
585
586 var code = (CodeAttribute)m.code().orElse(null);
587
588 if (options.showAllAttrs) {
589 attrWriter.write(m.attributes(), cffv());
590 } else if (code != null && options.showDisassembled) {
591 codeWriter.writeMinimal(code);
592 }
593
594 indent(-1);
595
596 // set pendingNewline to write a newline before the next method (if any)
597 // if a separator is desired
598 setPendingNewline(
599 options.showDisassembled ||
600 options.showAllAttrs ||
601 options.showDescriptors ||
602 options.showLineAndLocalVariableTables ||
603 options.verbose);
604 }
605
606 void writeModifiers(Collection<String> items) {
607 for (Object item: items) {
608 print(item);
609 print(" ");
610 }
611 }
612
613 public static final int ACC_TRANSITIVE = 0x0020;
614 public static final int ACC_STATIC_PHASE = 0x0040;
615
616 void writeDirectives() {
617 var attr = classModel.findAttribute(Attributes.module());
618 if (attr.isEmpty())
619 return;
620
621 var m = attr.get();
622 for (var entry: m.requires()) {
623 print("requires");
624 if ((entry.requiresFlagsMask() & ACC_STATIC_PHASE) != 0)
625 print(" static");
626 if ((entry.requiresFlagsMask() & ACC_TRANSITIVE) != 0)
627 print(" transitive");
628 print(" ");
629 String mname;
630 print(entry.requires().name().stringValue());
631 println(";");
632 }
633
634 for (var entry: m.exports()) {
635 print("exports");
636 print(" ");
637 print(entry.exportedPackage().name().stringValue().replace('/', '.'));
638 boolean first = true;
639 for (var mod: entry.exportsTo()) {
640 if (first) {
641 println(" to");
642 indent(+1);
643 first = false;
644 } else {
645 println(",");
646 }
647 print(mod.name().stringValue());
648 }
649 println(";");
650 if (!first)
651 indent(-1);
652 }
653
654 for (var entry: m.opens()) {
655 print("opens");
656 print(" ");
657 print(entry.openedPackage().name().stringValue().replace('/', '.'));
658 boolean first = true;
659 for (var mod: entry.opensTo()) {
660 if (first) {
661 println(" to");
662 indent(+1);
663 first = false;
664 } else {
665 println(",");
666 }
667 print(mod.name().stringValue());
668 }
669 println(";");
670 if (!first)
671 indent(-1);
672 }
673
674 for (var entry: m.uses()) {
675 print("uses ");
676 print(entry.asInternalName().replace('/', '.'));
677 println(";");
678 }
679
680 for (var entry: m.provides()) {
681 print("provides ");
682 print(entry.provides().asInternalName().replace('/', '.'));
683 boolean first = true;
684 for (var ce: entry.providesWith()) {
685 if (first) {
686 println(" with");
687 indent(+1);
688 first = false;
689 } else {
690 println(",");
691 }
692 print(ce.asInternalName().replace('/', '.'));
693 }
694 println(";");
695 if (!first)
696 indent(-1);
697 }
698 }
699
700 void writeList(String prefix, Collection<?> items, String suffix) {
701 print(prefix);
702 String sep = "";
703 for (Object item: items) {
704 print(sep);
705 print(item);
706 sep = ", ";
707 }
708 print(suffix);
709 }
710
711 void writeListIfNotEmpty(String prefix, List<?> items, String suffix) {
712 if (items != null && items.size() > 0)
713 writeList(prefix, items, suffix);
714 }
715
716 String adjustVarargs(int flags, String params) {
717 if ((flags & ACC_VARARGS) != 0) {
718 int i = params.lastIndexOf("[]");
719 if (i > 0)
720 return params.substring(0, i) + "..." + params.substring(i+2);
721 }
722
723 return params;
724 }
725
726 String getJavaParameterTypes(MethodSignature d, int flags) {
727 return getJavaName(adjustVarargs(flags,
728 sigPrinter.printList("(", d.arguments(), ")")));
729 }
730
731 static String getJavaName(String name) {
732 return name.replace('/', '.');
733 }
734
735 /**
736 * Get the value of an entry in the constant pool as a Java constant.
737 * Characters and booleans are represented by CONSTANT_Intgere entries.
738 * Character and string values are processed to escape characters outside
739 * the basic printable ASCII set.
740 * @param d the descriptor, giving the expected type of the constant
741 * @param index the index of the value in the constant pool
742 * @return a printable string containing the value of the constant.
743 */
744 String getConstantValue(ClassDesc d, ConstantValueEntry cpInfo) {
745 switch (cpInfo.tag()) {
746 case PoolEntry.TAG_INTEGER: {
747 var val = (Integer)cpInfo.constantValue();
748 switch (d.descriptorString()) {
749 case "C":
750 // character
751 return getConstantCharValue((char)val.intValue());
752 case "Z":
753 // boolean
754 return String.valueOf(val == 1);
755 default:
756 // other: assume integer
757 return String.valueOf(val);
758 }
759 }
760 case PoolEntry.TAG_STRING:
761 return getConstantStringValue(cpInfo.constantValue().toString());
762 default:
763 return constantWriter.stringValue(cpInfo);
764 }
765 }
766
767 private String getConstantCharValue(char c) {
768 StringBuilder sb = new StringBuilder();
769 sb.append('\'');
770 sb.append(esc(c, '\''));
771 sb.append('\'');
772 return sb.toString();
773 }
774
775 private String getConstantStringValue(String s) {
776 StringBuilder sb = new StringBuilder();
777 sb.append("\"");
778 for (int i = 0; i < s.length(); i++) {
779 sb.append(esc(s.charAt(i), '"'));
780 }
781 sb.append("\"");
782 return sb.toString();
783 }
784
785 private String esc(char c, char quote) {
786 if (32 <= c && c <= 126 && c != quote && c != '\\')
787 return String.valueOf(c);
788 else switch (c) {
789 case '\b': return "\\b";
790 case '\n': return "\\n";
791 case '\t': return "\\t";
792 case '\f': return "\\f";
793 case '\r': return "\\r";
794 case '\\': return "\\\\";
795 case '\'': return "\\'";
796 case '\"': return "\\\"";
797 default: return String.format("\\u%04x", (int) c);
798 }
799 }
800
801 private Set<String> getClassModifiers(AccessFlags flags) {
802 var flagSet = flagsReportUnknown(flags, cffv());
803 Set<AccessFlag> set;
804 if (flagSet.contains(AccessFlag.INTERFACE)) {
805 set = EnumSet.copyOf(flagSet);
806 set.remove(AccessFlag.ABSTRACT);
807 } else {
808 set = flagSet;
809 }
810 return getModifiers(set);
811 }
812
813 private static Set<String> getModifiers(Set<AccessFlag> flags) {
814 Set<String> s = new LinkedHashSet<>();
815 for (var f : flags)
816 if (f.sourceModifier()) s.add(f == AccessFlag.STRICT ? "strictfp" : f.name().toLowerCase(Locale.ROOT));
817 return s;
818 }
819
820 private Set<String> getClassFlags(AccessFlags flags) {
821 return getFlags(flags.flagsMask(), flagsReportUnknown(flags, cffv()));
822 }
823
824 private static Set<String> getFlags(int mask, Set<AccessFlag> flags) {
825 Set<String> s = new LinkedHashSet<>();
826 for (var f: flags) {
827 s.add("ACC_" + f.name());
828 mask = mask & ~f.mask();
829 }
830 while (mask != 0) {
831 int bit = Integer.highestOneBit(mask);
832 s.add("0x" + Integer.toHexString(bit));
833 mask = mask & ~bit;
834 }
835 return s;
836 }
837
838 private final Options options;
839 private final AttributeWriter attrWriter;
840 private final CodeWriter codeWriter;
841 private final ConstantWriter constantWriter;
842 private ClassModel classModel;
843 private URI uri;
844 private long lastModified;
845 private String digestName;
846 private byte[] digest;
847 private int size;
848 private MethodModel method;
849 }