1 /*
2 * Copyright (c) 2022, 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 package jdk.internal.classfile.impl;
26
27 import java.lang.classfile.Annotation;
28 import java.lang.classfile.Attribute;
29 import java.lang.classfile.AttributeMapper;
30 import java.lang.classfile.AttributedElement;
31 import java.lang.classfile.BufWriter;
32 import java.lang.classfile.ClassReader;
33 import java.lang.classfile.attribute.*;
34 import java.util.List;
35
36 import static java.lang.classfile.Attributes.*;
37
38 public sealed abstract class AbstractAttributeMapper<T extends Attribute<T>>
39 implements AttributeMapper<T> {
40
41 private final String name;
42 private final AttributeMapper.AttributeStability stability;
43 private final boolean allowMultiple;
44
45 protected abstract void writeBody(BufWriter buf, T attr);
46
47 public AbstractAttributeMapper(String name, AttributeMapper.AttributeStability stability) {
48 this(name, stability, false);
49 }
50
51 public AbstractAttributeMapper(String name,
52 AttributeMapper.AttributeStability stability,
53 boolean allowMultiple) {
54 this.name = name;
55 this.stability = stability;
56 this.allowMultiple = allowMultiple;
57 }
58
59 @Override
60 public final String name() {
61 return name;
62 }
63
64 @Override
65 public final void writeAttribute(BufWriter buf, T attr) {
66 buf.writeIndex(buf.constantPool().utf8Entry(name));
67 buf.writeInt(0);
68 int start = buf.size();
69 writeBody(buf, attr);
70 int written = buf.size() - start;
71 buf.patchInt(start - 4, 4, written);
72 }
73
74 @Override
75 public AttributeMapper.AttributeStability stability() {
76 return stability;
77 }
78
79 @Override
80 public boolean allowMultiple() {
81 return allowMultiple;
82 }
83
84 @Override
85 public String toString() {
86 return String.format("AttributeMapper[name=%s, allowMultiple=%b, stability=%s]",
87 name, allowMultiple, stability());
88 }
89
90 public static final class AnnotationDefaultMapper extends AbstractAttributeMapper<AnnotationDefaultAttribute> {
91 public static final AnnotationDefaultMapper INSTANCE = new AnnotationDefaultMapper();
92
93 private AnnotationDefaultMapper() {
94 super(NAME_ANNOTATION_DEFAULT, AttributeStability.CP_REFS);
95 }
96
97 @Override
98 public AnnotationDefaultAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
99 return new BoundAttribute.BoundAnnotationDefaultAttr(cf, this, p);
100 }
101
102 @Override
103 protected void writeBody(BufWriter buf, AnnotationDefaultAttribute attr) {
104 attr.defaultValue().writeTo(buf);
105 }
106 }
107
108 public static final class BootstrapMethodsMapper extends AbstractAttributeMapper<BootstrapMethodsAttribute> {
109 public static final BootstrapMethodsMapper INSTANCE = new BootstrapMethodsMapper();
110
111 private BootstrapMethodsMapper() {
112 super(NAME_BOOTSTRAP_METHODS, AttributeStability.CP_REFS);
113 }
114
115 @Override
116 public BootstrapMethodsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
117 return new BoundAttribute.BoundBootstrapMethodsAttribute(cf, this, p);
118 }
119
120 @Override
121 protected void writeBody(BufWriter buf, BootstrapMethodsAttribute attr) {
122 buf.writeList(attr.bootstrapMethods());
123 }
124 }
125
126 public static final class CharacterRangeTableMapper extends AbstractAttributeMapper<CharacterRangeTableAttribute> {
127 public static final CharacterRangeTableMapper INSTANCE = new CharacterRangeTableMapper();
128
129 private CharacterRangeTableMapper() {
130 super(NAME_CHARACTER_RANGE_TABLE, AttributeStability.LABELS, true);
131 }
132
133 @Override
134 public CharacterRangeTableAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
135 return new BoundAttribute.BoundCharacterRangeTableAttribute(cf, this, p);
136 }
137
138 @Override
139 protected void writeBody(BufWriter buf, CharacterRangeTableAttribute attr) {
140 List<CharacterRangeInfo> ranges = attr.characterRangeTable();
141 buf.writeU2(ranges.size());
142 for (CharacterRangeInfo info : ranges) {
143 buf.writeU2(info.startPc());
144 buf.writeU2(info.endPc());
145 buf.writeInt(info.characterRangeStart());
146 buf.writeInt(info.characterRangeEnd());
147 buf.writeU2(info.flags());
148 }
149 }
150 }
151
152 public static final class CodeMapper extends AbstractAttributeMapper<CodeAttribute> {
153 public static final CodeMapper INSTANCE = new CodeMapper();
154
155 private CodeMapper() {
156 super(NAME_CODE, AttributeStability.CP_REFS);
157 }
158
159 @Override
160 public CodeAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
161 return new CodeImpl(e, cf, this, p);
162 }
163
164 @Override
165 protected void writeBody(BufWriter buf, CodeAttribute attr) {
166 throw new UnsupportedOperationException("Code attribute does not support direct write");
167 }
168 }
169
170 public static final class CompilationIDMapper extends AbstractAttributeMapper<CompilationIDAttribute> {
171 public static final CompilationIDMapper INSTANCE = new CompilationIDMapper();
172
173 private CompilationIDMapper() {
174 super(NAME_COMPILATION_ID, AttributeStability.CP_REFS);
175 }
176
177 @Override
178 public CompilationIDAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
179 return new BoundAttribute.BoundCompilationIDAttribute(cf, this, p);
180 }
181
182 @Override
183 protected void writeBody(BufWriter buf, CompilationIDAttribute attr) {
184 buf.writeIndex(attr.compilationId());
185 }
186 }
187
188 public static final class ConstantValueMapper extends AbstractAttributeMapper<ConstantValueAttribute> {
189 public static final ConstantValueMapper INSTANCE = new ConstantValueMapper();
190
191 private ConstantValueMapper() {
192 super(NAME_CONSTANT_VALUE, AttributeStability.CP_REFS);
193 }
194
195 @Override
196 public ConstantValueAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
197 return new BoundAttribute.BoundConstantValueAttribute(cf, this, p);
198 }
199
200 @Override
201 protected void writeBody(BufWriter buf, ConstantValueAttribute attr) {
202 buf.writeIndex(attr.constant());
203 }
204 }
205
206 public static final class DeprecatedMapper extends AbstractAttributeMapper<DeprecatedAttribute> {
207 public static final DeprecatedMapper INSTANCE = new DeprecatedMapper();
208
209 private DeprecatedMapper() {
210 super(NAME_DEPRECATED, AttributeStability.STATELESS, true);
211 }
212
213 @Override
214 public DeprecatedAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
215 return new BoundAttribute.BoundDeprecatedAttribute(cf, this, p);
216 }
217
218 @Override
219 protected void writeBody(BufWriter buf, DeprecatedAttribute attr) {
220 // empty
221 }
222 }
223
224 public static final class EnclosingMethodMapper extends AbstractAttributeMapper<EnclosingMethodAttribute> {
225 public static final EnclosingMethodMapper INSTANCE = new EnclosingMethodMapper();
226
227 private EnclosingMethodMapper() {
228 super(NAME_ENCLOSING_METHOD, AttributeStability.CP_REFS);
229 }
230
231 @Override
232 public EnclosingMethodAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
233 return new BoundAttribute.BoundEnclosingMethodAttribute(cf, this, p);
234 }
235
236 @Override
237 protected void writeBody(BufWriter buf, EnclosingMethodAttribute attr) {
238 buf.writeIndex(attr.enclosingClass());
239 buf.writeIndexOrZero(attr.enclosingMethod().orElse(null));
240 }
241 }
242
243 public static final class ExceptionsMapper extends AbstractAttributeMapper<ExceptionsAttribute> {
244 public static final ExceptionsMapper INSTANCE = new ExceptionsMapper();
245
246 private ExceptionsMapper() {
247 super(NAME_EXCEPTIONS, AttributeStability.CP_REFS);
248 }
249
250 @Override
251 public ExceptionsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
252 return new BoundAttribute.BoundExceptionsAttribute(cf, this, p);
253 }
254
255 @Override
256 protected void writeBody(BufWriter buf, ExceptionsAttribute attr) {
257 buf.writeListIndices(attr.exceptions());
258 }
259 }
260
261 public static final class InnerClassesMapper extends AbstractAttributeMapper<InnerClassesAttribute> {
262 public static final InnerClassesMapper INSTANCE = new InnerClassesMapper();
263
264 private InnerClassesMapper() {
265 super(NAME_INNER_CLASSES, AttributeStability.CP_REFS);
266 }
267
268 @Override
269 public InnerClassesAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
270 return new BoundAttribute.BoundInnerClassesAttribute(cf, this, p);
271 }
272
273 @Override
274 protected void writeBody(BufWriter buf, InnerClassesAttribute attr) {
275 List<InnerClassInfo> classes = attr.classes();
276 buf.writeU2(classes.size());
277 for (InnerClassInfo ic : classes) {
278 buf.writeIndex(ic.innerClass());
279 buf.writeIndexOrZero(ic.outerClass().orElse(null));
280 buf.writeIndexOrZero(ic.innerName().orElse(null));
281 buf.writeU2(ic.flagsMask());
282 }
283 }
284 }
285
286 public static final class LineNumberTableMapper extends AbstractAttributeMapper<LineNumberTableAttribute> {
287 public static final LineNumberTableMapper INSTANCE = new LineNumberTableMapper();
288
289 private LineNumberTableMapper() {
290 super(NAME_LINE_NUMBER_TABLE, AttributeStability.LABELS, true);
291 }
292
293 @Override
294 public LineNumberTableAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
295 return new BoundAttribute.BoundLineNumberTableAttribute(cf, this, p);
296 }
297
298 @Override
299 protected void writeBody(BufWriter buf, LineNumberTableAttribute attr) {
300 List<LineNumberInfo> lines = attr.lineNumbers();
301 buf.writeU2(lines.size());
302 for (LineNumberInfo line : lines) {
303 buf.writeU2(line.startPc());
304 buf.writeU2(line.lineNumber());
305 }
306 }
307 }
308
309 public static final class LoadableDescriptorsMapper extends AbstractAttributeMapper<LoadableDescriptorsAttribute> {
310 public static final LoadableDescriptorsMapper INSTANCE = new LoadableDescriptorsMapper();
311
312 private LoadableDescriptorsMapper() {
313 super(NAME_LOADABLE_DESCRIPTORS, AttributeStability.CP_REFS);
314 }
315
316 @Override
317 public LoadableDescriptorsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
318 return new BoundAttribute.BoundLoadableDescriptorsAttribute(cf, this, p);
319 }
320
321 @Override
322 protected void writeBody(BufWriter buf, LoadableDescriptorsAttribute attr) {
323 buf.writeListIndices(attr.loadableDescriptors());
324 }
325 }
326
327 public static final class LocalVariableTableMapper extends AbstractAttributeMapper<LocalVariableTableAttribute> {
328 public static final LocalVariableTableMapper INSTANCE = new LocalVariableTableMapper();
329
330 private LocalVariableTableMapper() {
331 super(NAME_LOCAL_VARIABLE_TABLE, AttributeStability.LABELS, true);
332 }
333
334 @Override
335 public LocalVariableTableAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
336 return new BoundAttribute.BoundLocalVariableTableAttribute(e, cf, this, p);
337 }
338
339 @Override
340 protected void writeBody(BufWriter buf, LocalVariableTableAttribute attr) {
341 List<LocalVariableInfo> infos = attr.localVariables();
342 buf.writeU2(infos.size());
343 for (LocalVariableInfo info : infos) {
344 buf.writeU2(info.startPc());
345 buf.writeU2(info.length());
346 buf.writeIndex(info.name());
347 buf.writeIndex(info.type());
348 buf.writeU2(info.slot());
349 }
350 }
351 }
352
353 public static final class LocalVariableTypeTableMapper extends AbstractAttributeMapper<LocalVariableTypeTableAttribute> {
354 public static final LocalVariableTypeTableMapper INSTANCE = new LocalVariableTypeTableMapper();
355
356 private LocalVariableTypeTableMapper() {
357 super(NAME_LOCAL_VARIABLE_TYPE_TABLE, AttributeStability.LABELS, true);
358 }
359
360 @Override
361 public LocalVariableTypeTableAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
362 return new BoundAttribute.BoundLocalVariableTypeTableAttribute(e, cf, this, p);
363 }
364
365 @Override
366 protected void writeBody(BufWriter buf, LocalVariableTypeTableAttribute attr) {
367 List<LocalVariableTypeInfo> infos = attr.localVariableTypes();
368 buf.writeU2(infos.size());
369 for (LocalVariableTypeInfo info : infos) {
370 buf.writeU2(info.startPc());
371 buf.writeU2(info.length());
372 buf.writeIndex(info.name());
373 buf.writeIndex(info.signature());
374 buf.writeU2(info.slot());
375 }
376 }
377 }
378
379 public static final class MethodParametersMapper extends AbstractAttributeMapper<MethodParametersAttribute> {
380 public static final MethodParametersMapper INSTANCE = new MethodParametersMapper();
381
382 private MethodParametersMapper() {
383 super(NAME_METHOD_PARAMETERS, AttributeStability.CP_REFS);
384 }
385
386 @Override
387 public MethodParametersAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
388 return new BoundAttribute.BoundMethodParametersAttribute(cf, this, p);
389 }
390
391 @Override
392 protected void writeBody(BufWriter buf, MethodParametersAttribute attr) {
393 List<MethodParameterInfo> parameters = attr.parameters();
394 buf.writeU1(parameters.size());
395 for (MethodParameterInfo info : parameters) {
396 buf.writeIndexOrZero(info.name().orElse(null));
397 buf.writeU2(info.flagsMask());
398 }
399 }
400 }
401
402 public static final class ModuleMapper extends AbstractAttributeMapper<ModuleAttribute> {
403 public static final ModuleMapper INSTANCE = new ModuleMapper();
404
405 private ModuleMapper() {
406 super(NAME_MODULE, AttributeStability.CP_REFS);
407 }
408
409 @Override
410 public ModuleAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
411 return new BoundAttribute.BoundModuleAttribute(cf, this, p);
412 }
413
414 @Override
415 protected void writeBody(BufWriter buf, ModuleAttribute attr) {
416 buf.writeIndex(attr.moduleName());
417 buf.writeU2(attr.moduleFlagsMask());
418 buf.writeIndexOrZero(attr.moduleVersion().orElse(null));
419 buf.writeU2(attr.requires().size());
420 for (ModuleRequireInfo require : attr.requires()) {
421 buf.writeIndex(require.requires());
422 buf.writeU2(require.requiresFlagsMask());
423 buf.writeIndexOrZero(require.requiresVersion().orElse(null));
424 }
425 buf.writeU2(attr.exports().size());
426 for (ModuleExportInfo export : attr.exports()) {
427 buf.writeIndex(export.exportedPackage());
428 buf.writeU2(export.exportsFlagsMask());
429 buf.writeListIndices(export.exportsTo());
430 }
431 buf.writeU2(attr.opens().size());
432 for (ModuleOpenInfo open : attr.opens()) {
433 buf.writeIndex(open.openedPackage());
434 buf.writeU2(open.opensFlagsMask());
435 buf.writeListIndices(open.opensTo());
436 }
437 buf.writeListIndices(attr.uses());
438 buf.writeU2(attr.provides().size());
439 for (ModuleProvideInfo provide : attr.provides()) {
440 buf.writeIndex(provide.provides());
441 buf.writeListIndices(provide.providesWith());
442 }
443 }
444 }
445
446 public static final class ModuleHashesMapper extends AbstractAttributeMapper<ModuleHashesAttribute> {
447 public static final ModuleHashesMapper INSTANCE = new ModuleHashesMapper();
448
449 private ModuleHashesMapper() {
450 super(NAME_MODULE_HASHES, AttributeStability.CP_REFS);
451 }
452
453 @Override
454 public ModuleHashesAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
455 return new BoundAttribute.BoundModuleHashesAttribute(cf, this, p);
456 }
457
458 @Override
459 protected void writeBody(BufWriter buf, ModuleHashesAttribute attr) {
460 buf.writeIndex(attr.algorithm());
461 List<ModuleHashInfo> hashes = attr.hashes();
462 buf.writeU2(hashes.size());
463 for (ModuleHashInfo hash : hashes) {
464 buf.writeIndex(hash.moduleName());
465 buf.writeU2(hash.hash().length);
466 buf.writeBytes(hash.hash());
467 }
468 }
469 }
470
471 public static final class ModuleMainClassMapper extends AbstractAttributeMapper<ModuleMainClassAttribute> {
472 public static final ModuleMainClassMapper INSTANCE = new ModuleMainClassMapper();
473
474 private ModuleMainClassMapper() {
475 super(NAME_MODULE_MAIN_CLASS, AttributeStability.CP_REFS);
476 }
477
478 @Override
479 public ModuleMainClassAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
480 return new BoundAttribute.BoundModuleMainClassAttribute(cf, this, p);
481 }
482
483 @Override
484 protected void writeBody(BufWriter buf, ModuleMainClassAttribute attr) {
485 buf.writeIndex(attr.mainClass());
486 }
487 }
488
489 public static final class ModulePackagesMapper extends AbstractAttributeMapper<ModulePackagesAttribute> {
490 public static final ModulePackagesMapper INSTANCE = new ModulePackagesMapper();
491
492 private ModulePackagesMapper() {
493 super(NAME_MODULE_PACKAGES, AttributeStability.CP_REFS);
494 }
495
496 @Override
497 public ModulePackagesAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
498 return new BoundAttribute.BoundModulePackagesAttribute(cf, this, p);
499 }
500
501 @Override
502 protected void writeBody(BufWriter buf, ModulePackagesAttribute attr) {
503 buf.writeListIndices(attr.packages());
504 }
505 }
506
507 public static final class ModuleResolutionMapper extends AbstractAttributeMapper<ModuleResolutionAttribute> {
508 public static final ModuleResolutionMapper INSTANCE = new ModuleResolutionMapper();
509
510 private ModuleResolutionMapper() {
511 super(NAME_MODULE_RESOLUTION, AttributeStability.STATELESS);
512 }
513
514 @Override
515 public ModuleResolutionAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
516 return new BoundAttribute.BoundModuleResolutionAttribute(cf, this, p);
517 }
518
519 @Override
520 protected void writeBody(BufWriter buf, ModuleResolutionAttribute attr) {
521 buf.writeU2(attr.resolutionFlags());
522 }
523 }
524
525 public static final class ModuleTargetMapper extends AbstractAttributeMapper<ModuleTargetAttribute> {
526 public static final ModuleTargetMapper INSTANCE = new ModuleTargetMapper();
527
528 private ModuleTargetMapper() {
529 super(NAME_MODULE_TARGET, AttributeStability.CP_REFS);
530 }
531
532 @Override
533 public ModuleTargetAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
534 return new BoundAttribute.BoundModuleTargetAttribute(cf, this, p);
535 }
536
537 @Override
538 protected void writeBody(BufWriter buf, ModuleTargetAttribute attr) {
539 buf.writeIndex(attr.targetPlatform());
540 }
541 }
542
543 public static final class NestHostMapper extends AbstractAttributeMapper<NestHostAttribute> {
544 public static final NestHostMapper INSTANCE = new NestHostMapper();
545
546 private NestHostMapper() {
547 super(NAME_NEST_HOST, AttributeStability.CP_REFS);
548 }
549
550 @Override
551 public NestHostAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
552 return new BoundAttribute.BoundNestHostAttribute(cf, this, p);
553 }
554
555 @Override
556 protected void writeBody(BufWriter buf, NestHostAttribute attr) {
557 buf.writeIndex(attr.nestHost());
558 }
559 }
560
561 public static final class NestMembersMapper extends AbstractAttributeMapper<NestMembersAttribute> {
562 public static final NestMembersMapper INSTANCE = new NestMembersMapper();
563
564 private NestMembersMapper() {
565 super(NAME_NEST_MEMBERS, AttributeStability.CP_REFS);
566 }
567
568 @Override
569 public NestMembersAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
570 return new BoundAttribute.BoundNestMembersAttribute(cf, this, p);
571 }
572
573 @Override
574 protected void writeBody(BufWriter buf, NestMembersAttribute attr) {
575 buf.writeListIndices(attr.nestMembers());
576 }
577 }
578
579 public static final class PermittedSubclassesMapper extends AbstractAttributeMapper<PermittedSubclassesAttribute> {
580 public static final PermittedSubclassesMapper INSTANCE = new PermittedSubclassesMapper();
581
582 private PermittedSubclassesMapper() {
583 super(NAME_PERMITTED_SUBCLASSES, AttributeStability.CP_REFS);
584 }
585
586 @Override
587 public PermittedSubclassesAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
588 return new BoundAttribute.BoundPermittedSubclassesAttribute(cf, this, p);
589 }
590
591 @Override
592 protected void writeBody(BufWriter buf, PermittedSubclassesAttribute attr) {
593 buf.writeListIndices(attr.permittedSubclasses());
594 }
595 }
596
597 public static final class RecordMapper extends AbstractAttributeMapper<RecordAttribute> {
598 public static final RecordMapper INSTANCE = new RecordMapper();
599
600 private RecordMapper() {
601 super(NAME_RECORD, AttributeStability.CP_REFS);
602 }
603
604 @Override
605 public RecordAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
606 return new BoundAttribute.BoundRecordAttribute(cf, this, p);
607 }
608
609 @Override
610 protected void writeBody(BufWriter buf, RecordAttribute attr) {
611 List<RecordComponentInfo> components = attr.components();
612 buf.writeU2(components.size());
613 for (RecordComponentInfo info : components) {
614 buf.writeIndex(info.name());
615 buf.writeIndex(info.descriptor());
616 buf.writeList(info.attributes());
617 }
618 }
619 }
620
621 public static final class RuntimeInvisibleAnnotationsMapper extends AbstractAttributeMapper<RuntimeInvisibleAnnotationsAttribute> {
622 public static final RuntimeInvisibleAnnotationsMapper INSTANCE = new RuntimeInvisibleAnnotationsMapper();
623
624 private RuntimeInvisibleAnnotationsMapper() {
625 super(NAME_RUNTIME_INVISIBLE_ANNOTATIONS, AttributeStability.CP_REFS);
626 }
627
628 @Override
629 public RuntimeInvisibleAnnotationsAttribute readAttribute(AttributedElement enclosing, ClassReader cf, int pos) {
630 return new BoundAttribute.BoundRuntimeInvisibleAnnotationsAttribute(cf, pos);
631 }
632
633 @Override
634 protected void writeBody(BufWriter buf, RuntimeInvisibleAnnotationsAttribute attr) {
635 buf.writeList(attr.annotations());
636 }
637 }
638
639 public static final class RuntimeInvisibleParameterAnnotationsMapper extends AbstractAttributeMapper<RuntimeInvisibleParameterAnnotationsAttribute> {
640 public static final RuntimeInvisibleParameterAnnotationsMapper INSTANCE = new RuntimeInvisibleParameterAnnotationsMapper();
641
642 private RuntimeInvisibleParameterAnnotationsMapper() {
643 super(NAME_RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS, AttributeStability.CP_REFS);
644 }
645
646 @Override
647 public RuntimeInvisibleParameterAnnotationsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
648 return new BoundAttribute.BoundRuntimeInvisibleParameterAnnotationsAttribute(cf, this, p);
649 }
650
651 @Override
652 protected void writeBody(BufWriter buf, RuntimeInvisibleParameterAnnotationsAttribute attr) {
653 List<List<Annotation>> lists = attr.parameterAnnotations();
654 buf.writeU1(lists.size());
655 for (List<Annotation> list : lists)
656 buf.writeList(list);
657 }
658 }
659
660 public static final class RuntimeInvisibleTypeAnnotationsMapper extends AbstractAttributeMapper<RuntimeInvisibleTypeAnnotationsAttribute> {
661 public static final RuntimeInvisibleTypeAnnotationsMapper INSTANCE = new RuntimeInvisibleTypeAnnotationsMapper();
662
663 private RuntimeInvisibleTypeAnnotationsMapper() {
664 super(NAME_RUNTIME_INVISIBLE_TYPE_ANNOTATIONS, AttributeStability.UNSTABLE);
665 }
666
667 @Override
668 public RuntimeInvisibleTypeAnnotationsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
669 return new BoundAttribute.BoundRuntimeInvisibleTypeAnnotationsAttribute(e, cf, this, p);
670 }
671
672 @Override
673 protected void writeBody(BufWriter buf, RuntimeInvisibleTypeAnnotationsAttribute attr) {
674 buf.writeList(attr.annotations());
675 }
676 }
677
678 public static final class RuntimeVisibleAnnotationsMapper extends AbstractAttributeMapper<RuntimeVisibleAnnotationsAttribute> {
679 public static final RuntimeVisibleAnnotationsMapper INSTANCE = new RuntimeVisibleAnnotationsMapper();
680
681 private RuntimeVisibleAnnotationsMapper() {
682 super(NAME_RUNTIME_VISIBLE_ANNOTATIONS, AttributeStability.CP_REFS);
683 }
684
685 @Override
686 public RuntimeVisibleAnnotationsAttribute readAttribute(AttributedElement enclosing, ClassReader cf, int pos) {
687 return new BoundAttribute.BoundRuntimeVisibleAnnotationsAttribute(cf, pos);
688 }
689
690 @Override
691 protected void writeBody(BufWriter buf, RuntimeVisibleAnnotationsAttribute attr) {
692 buf.writeList(attr.annotations());
693 }
694 }
695
696 public static final class RuntimeVisibleParameterAnnotationsMapper extends AbstractAttributeMapper<RuntimeVisibleParameterAnnotationsAttribute> {
697 public static final RuntimeVisibleParameterAnnotationsMapper INSTANCE = new RuntimeVisibleParameterAnnotationsMapper();
698
699 private RuntimeVisibleParameterAnnotationsMapper() {
700 super(NAME_RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS, AttributeStability.CP_REFS);
701 }
702
703 @Override
704 public RuntimeVisibleParameterAnnotationsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
705 return new BoundAttribute.BoundRuntimeVisibleParameterAnnotationsAttribute(cf, this, p);
706 }
707
708 @Override
709 protected void writeBody(BufWriter buf, RuntimeVisibleParameterAnnotationsAttribute attr) {
710 List<List<Annotation>> lists = attr.parameterAnnotations();
711 buf.writeU1(lists.size());
712 for (List<Annotation> list : lists)
713 buf.writeList(list);
714 }
715 }
716
717 public static final class RuntimeVisibleTypeAnnotationsMapper extends AbstractAttributeMapper<RuntimeVisibleTypeAnnotationsAttribute> {
718 public static final RuntimeVisibleTypeAnnotationsMapper INSTANCE = new RuntimeVisibleTypeAnnotationsMapper();
719
720 private RuntimeVisibleTypeAnnotationsMapper() {
721 super(NAME_RUNTIME_VISIBLE_TYPE_ANNOTATIONS, AttributeStability.UNSTABLE);
722 }
723
724 @Override
725 public RuntimeVisibleTypeAnnotationsAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
726 return new BoundAttribute.BoundRuntimeVisibleTypeAnnotationsAttribute(e, cf, this, p);
727 }
728
729 @Override
730 protected void writeBody(BufWriter buf, RuntimeVisibleTypeAnnotationsAttribute attr) {
731 buf.writeList(attr.annotations());
732 }
733 }
734
735 public static final class SignatureMapper extends AbstractAttributeMapper<SignatureAttribute> {
736 public static final SignatureMapper INSTANCE = new SignatureMapper();
737
738 private SignatureMapper() {
739 super(NAME_SIGNATURE, AttributeStability.CP_REFS);
740 }
741
742 @Override
743 public SignatureAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
744 return new BoundAttribute.BoundSignatureAttribute(cf, this, p);
745 }
746
747 @Override
748 protected void writeBody(BufWriter buf, SignatureAttribute attr) {
749 buf.writeIndex(attr.signature());
750 }
751 }
752
753 public static final class SourceDebugExtensionMapper extends AbstractAttributeMapper<SourceDebugExtensionAttribute> {
754 public static final SourceDebugExtensionMapper INSTANCE = new SourceDebugExtensionMapper();
755
756 private SourceDebugExtensionMapper() {
757 super(NAME_SOURCE_DEBUG_EXTENSION, AttributeStability.STATELESS);
758 }
759
760 @Override
761 public SourceDebugExtensionAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
762 return new BoundAttribute.BoundSourceDebugExtensionAttribute(cf, this, p);
763 }
764
765 @Override
766 protected void writeBody(BufWriter buf, SourceDebugExtensionAttribute attr) {
767 buf.writeBytes(attr.contents());
768 }
769 }
770
771 public static final class SourceFileMapper extends AbstractAttributeMapper<SourceFileAttribute> {
772 public static final SourceFileMapper INSTANCE = new SourceFileMapper();
773
774 private SourceFileMapper() {
775 super(NAME_SOURCE_FILE, AttributeStability.CP_REFS);
776 }
777
778 @Override
779 public SourceFileAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
780 return new BoundAttribute.BoundSourceFileAttribute(cf, this, p);
781 }
782
783 @Override
784 protected void writeBody(BufWriter buf, SourceFileAttribute attr) {
785 buf.writeIndex(attr.sourceFile());
786 }
787 }
788
789 public static final class SourceIDMapper extends AbstractAttributeMapper<SourceIDAttribute> {
790 public static final SourceIDMapper INSTANCE = new SourceIDMapper();
791
792 private SourceIDMapper() {
793 super(NAME_SOURCE_ID, AttributeStability.CP_REFS);
794 }
795
796 @Override
797 public SourceIDAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
798 return new BoundAttribute.BoundSourceIDAttribute(cf, this, p);
799 }
800
801 @Override
802 protected void writeBody(BufWriter buf, SourceIDAttribute attr) {
803 buf.writeIndex(attr.sourceId());
804 }
805 }
806
807 public static final class StackMapTableMapper extends AbstractAttributeMapper<StackMapTableAttribute> {
808 public static final StackMapTableMapper INSTANCE = new StackMapTableMapper();
809
810 private StackMapTableMapper() {
811 super(NAME_STACK_MAP_TABLE, AttributeStability.LABELS);
812 }
813
814 @Override
815 public StackMapTableAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
816 return new BoundAttribute.BoundStackMapTableAttribute((CodeImpl)e, cf, this, p);
817 }
818
819 @Override
820 protected void writeBody(BufWriter b, StackMapTableAttribute attr) {
821 StackMapDecoder.writeFrames(b, attr.entries());
822 }
823 }
824
825 public static final class SyntheticMapper extends AbstractAttributeMapper<SyntheticAttribute> {
826 public static final SyntheticMapper INSTANCE = new SyntheticMapper();
827
828 private SyntheticMapper() {
829 super(NAME_SYNTHETIC, AttributeStability.STATELESS, true);
830 }
831
832 @Override
833 public SyntheticAttribute readAttribute(AttributedElement e, ClassReader cf, int p) {
834 return new BoundAttribute.BoundSyntheticAttribute(cf, this, p);
835 }
836
837 @Override
838 protected void writeBody(BufWriter buf, SyntheticAttribute attr) {
839 // empty
840 }
841 }
842 }