1 /*
2 * Copyright (c) 2008, 2020, 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
27 package com.sun.tools.classfile;
28
29 import java.io.ByteArrayOutputStream;
30 import java.io.DataOutputStream;
31 import java.io.File;
32 import java.io.FileOutputStream;
33 import java.io.IOException;
34 import java.io.OutputStream;
35
36 import static com.sun.tools.classfile.Annotation.*;
37 import static com.sun.tools.classfile.ConstantPool.*;
38 import static com.sun.tools.classfile.StackMapTable_attribute.*;
39 import static com.sun.tools.classfile.StackMapTable_attribute.verification_type_info.*;
40
41 /**
42 * Write a ClassFile data structure to a file or stream.
43 *
44 * <p><b>This is NOT part of any supported API.
45 * If you write code that depends on this, you do so at your own risk.
46 * This code and its internal interfaces are subject to change or
47 * deletion without notice.</b>
48 */
49 public class ClassWriter {
50 public ClassWriter() {
51 attributeWriter = new AttributeWriter();
52 constantPoolWriter = new ConstantPoolWriter();
53 out = new ClassOutputStream();
54 }
55
56 /**
57 * Write a ClassFile data structure to a file.
58 * @param classFile the classfile object to be written
59 * @param f the file
60 * @throws IOException if an error occurs while writing the file
61 */
62 public void write(ClassFile classFile, File f) throws IOException {
63 try (FileOutputStream f_out = new FileOutputStream(f)) {
64 write(classFile, f_out);
65 }
66 }
67
68 /**
69 * Write a ClassFile data structure to a stream.
70 * @param classFile the classfile object to be written
71 * @param s the stream
72 * @throws IOException if an error occurs while writing the file
73 */
74 public void write(ClassFile classFile, OutputStream s) throws IOException {
75 this.classFile = classFile;
76 out.reset();
77 write();
78 out.writeTo(s);
79 }
80
81 protected void write() throws IOException {
82 writeHeader();
83 writeConstantPool();
84 writeAccessFlags(classFile.access_flags);
85 writeClassInfo();
86 writeFields();
87 writeMethods();
88 writeAttributes(classFile.attributes);
89 }
90
91 protected void writeHeader() {
92 out.writeInt(classFile.magic);
93 out.writeShort(classFile.minor_version);
94 out.writeShort(classFile.major_version);
95 }
96
97 protected void writeAccessFlags(AccessFlags flags) {
98 out.writeShort(flags.flags);
99 }
100
101 protected void writeAttributes(Attributes attributes) {
102 int size = attributes.size();
103 out.writeShort(size);
104 for (Attribute attr: attributes)
105 attributeWriter.write(attr, out);
106 }
107
108 protected void writeClassInfo() {
109 out.writeShort(classFile.this_class);
110 out.writeShort(classFile.super_class);
111 int[] interfaces = classFile.interfaces;
112 out.writeShort(interfaces.length);
113 for (int i: interfaces)
114 out.writeShort(i);
115 }
116
117 protected void writeDescriptor(Descriptor d) {
118 out.writeShort(d.index);
119 }
120
121 protected void writeConstantPool() {
122 ConstantPool pool = classFile.constant_pool;
123 int size = pool.size();
124 out.writeShort(size);
125 for (CPInfo cpInfo: pool.entries())
126 constantPoolWriter.write(cpInfo, out);
127 }
128
129 protected void writeFields() throws IOException {
130 Field[] fields = classFile.fields;
131 out.writeShort(fields.length);
132 for (Field f: fields)
133 writeField(f);
134 }
135
136 protected void writeField(Field f) throws IOException {
137 writeAccessFlags(f.access_flags);
138 out.writeShort(f.name_index);
139 writeDescriptor(f.descriptor);
140 writeAttributes(f.attributes);
141 }
142
143 protected void writeMethods() throws IOException {
144 Method[] methods = classFile.methods;
145 out.writeShort(methods.length);
146 for (Method m: methods) {
147 writeMethod(m);
148 }
149 }
150
151 protected void writeMethod(Method m) throws IOException {
152 writeAccessFlags(m.access_flags);
153 out.writeShort(m.name_index);
154 writeDescriptor(m.descriptor);
155 writeAttributes(m.attributes);
156 }
157
158 protected ClassFile classFile;
159 protected ClassOutputStream out;
160 protected AttributeWriter attributeWriter;
161 protected ConstantPoolWriter constantPoolWriter;
162
163 /**
164 * Subtype of ByteArrayOutputStream with the convenience methods of
165 * a DataOutputStream. Since ByteArrayOutputStream does not throw
166 * IOException, there are no exceptions from the additional
167 * convenience methods either,
168 */
169 protected static class ClassOutputStream extends ByteArrayOutputStream {
170 public ClassOutputStream() {
171 d = new DataOutputStream(this);
172 }
173
174 public void writeByte(int value) {
175 try {
176 d.writeByte(value);
177 } catch (IOException ignore) {
178 }
179 }
180
181 public void writeShort(int value) {
182 try {
183 d.writeShort(value);
184 } catch (IOException ignore) {
185 }
186 }
187
188 public void writeInt(int value) {
189 try {
190 d.writeInt(value);
191 } catch (IOException ignore) {
192 }
193 }
194
195 public void writeLong(long value) {
196 try {
197 d.writeLong(value);
198 } catch (IOException ignore) {
199 }
200 }
201
202 public void writeFloat(float value) {
203 try {
204 d.writeFloat(value);
205 } catch (IOException ignore) {
206 }
207 }
208
209 public void writeDouble(double value) {
210 try {
211 d.writeDouble(value);
212 } catch (IOException ignore) {
213 }
214 }
215
216 public void writeUTF(String value) {
217 try {
218 d.writeUTF(value);
219 } catch (IOException ignore) {
220 }
221 }
222
223 public void writeTo(ClassOutputStream s) {
224 try {
225 super.writeTo(s);
226 } catch (IOException ignore) {
227 }
228 }
229
230 private final DataOutputStream d;
231 }
232
233 /**
234 * Writer for the entries in the constant pool.
235 */
236 protected static class ConstantPoolWriter
237 implements ConstantPool.Visitor<Integer,ClassOutputStream> {
238 protected int write(CPInfo info, ClassOutputStream out) {
239 out.writeByte(info.getTag());
240 return info.accept(this, out);
241 }
242
243 @Override
244 public Integer visitClass(CONSTANT_Class_info info, ClassOutputStream out) {
245 out.writeShort(info.name_index);
246 return 1;
247 }
248
249 @Override
250 public Integer visitDouble(CONSTANT_Double_info info, ClassOutputStream out) {
251 out.writeDouble(info.value);
252 return 2;
253 }
254
255 @Override
256 public Integer visitFieldref(CONSTANT_Fieldref_info info, ClassOutputStream out) {
257 writeRef(info, out);
258 return 1;
259 }
260
261 @Override
262 public Integer visitFloat(CONSTANT_Float_info info, ClassOutputStream out) {
263 out.writeFloat(info.value);
264 return 1;
265 }
266
267 @Override
268 public Integer visitInteger(CONSTANT_Integer_info info, ClassOutputStream out) {
269 out.writeInt(info.value);
270 return 1;
271 }
272
273 @Override
274 public Integer visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, ClassOutputStream out) {
275 writeRef(info, out);
276 return 1;
277 }
278
279 @Override
280 public Integer visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, ClassOutputStream out) {
281 out.writeShort(info.bootstrap_method_attr_index);
282 out.writeShort(info.name_and_type_index);
283 return 1;
284 }
285
286 public Integer visitDynamicConstant(CONSTANT_Dynamic_info info, ClassOutputStream out) {
287 out.writeShort(info.bootstrap_method_attr_index);
288 out.writeShort(info.name_and_type_index);
289 return 1;
290 }
291
292 @Override
293 public Integer visitLong(CONSTANT_Long_info info, ClassOutputStream out) {
294 out.writeLong(info.value);
295 return 2;
296 }
297
298 @Override
299 public Integer visitMethodHandle(CONSTANT_MethodHandle_info info, ClassOutputStream out) {
300 out.writeByte(info.reference_kind.tag);
301 out.writeShort(info.reference_index);
302 return 1;
303 }
304
305 @Override
306 public Integer visitMethodType(CONSTANT_MethodType_info info, ClassOutputStream out) {
307 out.writeShort(info.descriptor_index);
308 return 1;
309 }
310
311 @Override
312 public Integer visitMethodref(CONSTANT_Methodref_info info, ClassOutputStream out) {
313 return writeRef(info, out);
314 }
315
316 @Override
317 public Integer visitModule(CONSTANT_Module_info info, ClassOutputStream out) {
318 out.writeShort(info.name_index);
319 return 1;
320 }
321
322 @Override
323 public Integer visitNameAndType(CONSTANT_NameAndType_info info, ClassOutputStream out) {
324 out.writeShort(info.name_index);
325 out.writeShort(info.type_index);
326 return 1;
327 }
328
329 @Override
330 public Integer visitPackage(CONSTANT_Package_info info, ClassOutputStream out) {
331 out.writeShort(info.name_index);
332 return 1;
333 }
334
335 @Override
336 public Integer visitString(CONSTANT_String_info info, ClassOutputStream out) {
337 out.writeShort(info.string_index);
338 return 1;
339 }
340
341 @Override
342 public Integer visitUtf8(CONSTANT_Utf8_info info, ClassOutputStream out) {
343 out.writeUTF(info.value);
344 return 1;
345 }
346
347 protected Integer writeRef(CPRefInfo info, ClassOutputStream out) {
348 out.writeShort(info.class_index);
349 out.writeShort(info.name_and_type_index);
350 return 1;
351 }
352 }
353
354 /**
355 * Writer for the different types of attribute.
356 */
357 protected static class AttributeWriter implements Attribute.Visitor<Void,ClassOutputStream> {
358 public void write(Attributes attributes, ClassOutputStream out) {
359 int size = attributes.size();
360 out.writeShort(size);
361 for (Attribute a: attributes)
362 write(a, out);
363 }
364
365 public void write(Attribute attr, ClassOutputStream out) {
366 out.writeShort(attr.attribute_name_index);
367 ClassOutputStream nestedOut = new ClassOutputStream();
368 attr.accept(this, nestedOut);
369 out.writeInt(nestedOut.size());
370 nestedOut.writeTo(out);
371 }
372
373 protected AnnotationWriter annotationWriter = new AnnotationWriter();
374
375 @Override
376 public Void visitDefault(DefaultAttribute attr, ClassOutputStream out) {
377 out.write(attr.info, 0, attr.info.length);
378 return null;
379 }
380
381 @Override
382 public Void visitAnnotationDefault(AnnotationDefault_attribute attr, ClassOutputStream out) {
383 annotationWriter.write(attr.default_value, out);
384 return null;
385 }
386
387 @Override
388 public Void visitBootstrapMethods(BootstrapMethods_attribute attr, ClassOutputStream out) {
389 out.writeShort(attr.bootstrap_method_specifiers.length);
390 for (BootstrapMethods_attribute.BootstrapMethodSpecifier bsm : attr.bootstrap_method_specifiers) {
391 out.writeShort(bsm.bootstrap_method_ref);
392 int bsm_args_count = bsm.bootstrap_arguments.length;
393 out.writeShort(bsm_args_count);
394 for (int i : bsm.bootstrap_arguments) {
395 out.writeShort(i);
396 }
397 }
398 return null;
399 }
400
401 @Override
402 public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, ClassOutputStream out) {
403 out.writeShort(attr.character_range_table.length);
404 for (CharacterRangeTable_attribute.Entry e: attr.character_range_table)
405 writeCharacterRangeTableEntry(e, out);
406 return null;
407 }
408
409 protected void writeCharacterRangeTableEntry(CharacterRangeTable_attribute.Entry entry, ClassOutputStream out) {
410 out.writeShort(entry.start_pc);
411 out.writeShort(entry.end_pc);
412 out.writeInt(entry.character_range_start);
413 out.writeInt(entry.character_range_end);
414 out.writeShort(entry.flags);
415 }
416
417 @Override
418 public Void visitCode(Code_attribute attr, ClassOutputStream out) {
419 out.writeShort(attr.max_stack);
420 out.writeShort(attr.max_locals);
421 out.writeInt(attr.code.length);
422 out.write(attr.code, 0, attr.code.length);
423 out.writeShort(attr.exception_table.length);
424 for (Code_attribute.Exception_data e: attr.exception_table)
425 writeExceptionTableEntry(e, out);
426 new AttributeWriter().write(attr.attributes, out);
427 return null;
428 }
429
430 protected void writeExceptionTableEntry(Code_attribute.Exception_data exception_data, ClassOutputStream out) {
431 out.writeShort(exception_data.start_pc);
432 out.writeShort(exception_data.end_pc);
433 out.writeShort(exception_data.handler_pc);
434 out.writeShort(exception_data.catch_type);
435 }
436
437 @Override
438 public Void visitCompilationID(CompilationID_attribute attr, ClassOutputStream out) {
439 out.writeShort(attr.compilationID_index);
440 return null;
441 }
442
443 @Override
444 public Void visitConstantValue(ConstantValue_attribute attr, ClassOutputStream out) {
445 out.writeShort(attr.constantvalue_index);
446 return null;
447 }
448
449 @Override
450 public Void visitDeprecated(Deprecated_attribute attr, ClassOutputStream out) {
451 return null;
452 }
453
454 @Override
455 public Void visitEnclosingMethod(EnclosingMethod_attribute attr, ClassOutputStream out) {
456 out.writeShort(attr.class_index);
457 out.writeShort(attr.method_index);
458 return null;
459 }
460
461 @Override
462 public Void visitExceptions(Exceptions_attribute attr, ClassOutputStream out) {
463 out.writeShort(attr.exception_index_table.length);
464 for (int i: attr.exception_index_table)
465 out.writeShort(i);
466 return null;
467 }
468
469 @Override
470 public Void visitInnerClasses(InnerClasses_attribute attr, ClassOutputStream out) {
471 out.writeShort(attr.classes.length);
472 for (InnerClasses_attribute.Info info: attr.classes)
473 writeInnerClassesInfo(info, out);
474 return null;
475 }
476
477 protected void writeInnerClassesInfo(InnerClasses_attribute.Info info, ClassOutputStream out) {
478 out.writeShort(info.inner_class_info_index);
479 out.writeShort(info.outer_class_info_index);
480 out.writeShort(info.inner_name_index);
481 writeAccessFlags(info.inner_class_access_flags, out);
482 }
483
484 @Override
485 public Void visitLineNumberTable(LineNumberTable_attribute attr, ClassOutputStream out) {
486 out.writeShort(attr.line_number_table.length);
487 for (LineNumberTable_attribute.Entry e: attr.line_number_table)
488 writeLineNumberTableEntry(e, out);
489 return null;
490 }
491
492 protected void writeLineNumberTableEntry(LineNumberTable_attribute.Entry entry, ClassOutputStream out) {
493 out.writeShort(entry.start_pc);
494 out.writeShort(entry.line_number);
495 }
496
497 @Override
498 public Void visitLocalVariableTable(LocalVariableTable_attribute attr, ClassOutputStream out) {
499 out.writeShort(attr.local_variable_table.length);
500 for (LocalVariableTable_attribute.Entry e: attr.local_variable_table)
501 writeLocalVariableTableEntry(e, out);
502 return null;
503 }
504
505 protected void writeLocalVariableTableEntry(LocalVariableTable_attribute.Entry entry, ClassOutputStream out) {
506 out.writeShort(entry.start_pc);
507 out.writeShort(entry.length);
508 out.writeShort(entry.name_index);
509 out.writeShort(entry.descriptor_index);
510 out.writeShort(entry.index);
511 }
512
513 @Override
514 public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, ClassOutputStream out) {
515 out.writeShort(attr.local_variable_table.length);
516 for (LocalVariableTypeTable_attribute.Entry e: attr.local_variable_table)
517 writeLocalVariableTypeTableEntry(e, out);
518 return null;
519 }
520
521 protected void writeLocalVariableTypeTableEntry(LocalVariableTypeTable_attribute.Entry entry, ClassOutputStream out) {
522 out.writeShort(entry.start_pc);
523 out.writeShort(entry.length);
524 out.writeShort(entry.name_index);
525 out.writeShort(entry.signature_index);
526 out.writeShort(entry.index);
527 }
528
529 @Override
530 public Void visitNestHost(NestHost_attribute attr, ClassOutputStream out) {
531 out.writeShort(attr.top_index);
532 return null;
533 }
534
535 @Override
536 public Void visitMethodParameters(MethodParameters_attribute attr, ClassOutputStream out) {
537 out.writeByte(attr.method_parameter_table.length);
538 for (MethodParameters_attribute.Entry e : attr.method_parameter_table) {
539 out.writeShort(e.name_index);
540 out.writeShort(e.flags);
541 }
542 return null;
543 }
544
545 @Override
546 public Void visitModule(Module_attribute attr, ClassOutputStream out) {
547 out.writeShort(attr.module_name);
548 out.writeShort(attr.module_flags);
549 out.writeShort(attr.module_version_index);
550
551 out.writeShort(attr.requires.length);
552 for (Module_attribute.RequiresEntry e: attr.requires) {
553 out.writeShort(e.requires_index);
554 out.writeShort(e.requires_flags);
555 out.writeShort(e.requires_version_index);
556 }
557
558 out.writeShort(attr.exports.length);
559 for (Module_attribute.ExportsEntry e: attr.exports) {
560 out.writeShort(e.exports_index);
561 out.writeShort(e.exports_flags);
562 out.writeShort(e.exports_to_index.length);
563 for (int index: e.exports_to_index)
564 out.writeShort(index);
565 }
566
567 out.writeShort(attr.opens.length);
568 for (Module_attribute.OpensEntry e: attr.opens) {
569 out.writeShort(e.opens_index);
570 out.writeShort(e.opens_flags);
571 out.writeShort(e.opens_to_index.length);
572 for (int index: e.opens_to_index)
573 out.writeShort(index);
574 }
575
576 out.writeShort(attr.uses_index.length);
577 for (int index: attr.uses_index) {
578 out.writeShort(index);
579 }
580
581 out.writeShort(attr.provides.length);
582 for (Module_attribute.ProvidesEntry e: attr.provides) {
583 out.writeShort(e.provides_index);
584 out.writeShort(e.with_count);
585 for (int with : e.with_index) {
586 out.writeShort(with);
587 }
588 }
589
590 return null;
591 }
592
593 @Override
594 public Void visitModuleHashes(ModuleHashes_attribute attr, ClassOutputStream out) {
595 out.writeShort(attr.algorithm_index);
596 out.writeShort(attr.hashes_table.length);
597 for (ModuleHashes_attribute.Entry e: attr.hashes_table) {
598 out.writeShort(e.module_name_index);
599 out.writeShort(e.hash.length);
600 for (byte b: e.hash) {
601 out.writeByte(b);
602 }
603 }
604 return null;
605 }
606
607 @Override
608 public Void visitModuleMainClass(ModuleMainClass_attribute attr, ClassOutputStream out) {
609 out.writeShort(attr.main_class_index);
610 return null;
611 }
612
613 @Override
614 public Void visitModulePackages(ModulePackages_attribute attr, ClassOutputStream out) {
615 out.writeShort(attr.packages_count);
616 for (int i: attr.packages_index)
617 out.writeShort(i);
618 return null;
619 }
620
621 @Override
622 public Void visitModuleResolution(ModuleResolution_attribute attr, ClassOutputStream out) {
623 out.writeShort(attr.resolution_flags);
624 return null;
625 }
626
627 @Override
628 public Void visitModuleTarget(ModuleTarget_attribute attr, ClassOutputStream out) {
629 out.writeShort(attr.target_platform_index);
630 return null;
631 }
632
633 @Override
634 public Void visitNestMembers(NestMembers_attribute attr, ClassOutputStream out) {
635 out.writeShort(attr.members_indexes.length);
636 for (int i : attr.members_indexes) {
637 out.writeShort(i);
638 }
639 return null;
640 }
641
642 @Override
643 public Void visitRecord(Record_attribute attr, ClassOutputStream out) {
644 out.writeShort(attr.component_count);
645 for (Record_attribute.ComponentInfo info: attr.component_info_arr) {
646 out.writeShort(info.name_index);
647 out.writeShort(info.descriptor.index);
648 int size = info.attributes.size();
649 out.writeShort(size);
650 for (Attribute componentAttr: info.attributes)
651 write(componentAttr, out);
652 }
653 return null;
654 }
655
656 @Override
657 public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, ClassOutputStream out) {
658 annotationWriter.write(attr.annotations, out);
659 return null;
660 }
661
662 @Override
663 public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
664 out.writeByte(attr.parameter_annotations.length);
665 for (Annotation[] annos: attr.parameter_annotations)
666 annotationWriter.write(annos, out);
667 return null;
668 }
669
670 @Override
671 public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
672 annotationWriter.write(attr.annotations, out);
673 return null;
674 }
675
676 @Override
677 public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {
678 annotationWriter.write(attr.annotations, out);
679 return null;
680 }
681
682 @Override
683 public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
684 out.writeByte(attr.parameter_annotations.length);
685 for (Annotation[] annos: attr.parameter_annotations)
686 annotationWriter.write(annos, out);
687 return null;
688 }
689
690 @Override
691 public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
692 annotationWriter.write(attr.annotations, out);
693 return null;
694 }
695
696 @Override
697 public Void visitPermittedSubclasses(PermittedSubclasses_attribute attr, ClassOutputStream out) {
698 int n = attr.subtypes.length;
699 out.writeShort(n);
700 for (int i = 0 ; i < n ; i++) {
701 out.writeShort(attr.subtypes[i]);
702 }
703 return null;
704 }
705
706 @Override
707 public Void visitSignature(Signature_attribute attr, ClassOutputStream out) {
708 out.writeShort(attr.signature_index);
709 return null;
710 }
711
712 @Override
713 public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, ClassOutputStream out) {
714 out.write(attr.debug_extension, 0, attr.debug_extension.length);
715 return null;
716 }
717
718 @Override
719 public Void visitSourceFile(SourceFile_attribute attr, ClassOutputStream out) {
720 out.writeShort(attr.sourcefile_index);
721 return null;
722 }
723
724 @Override
725 public Void visitSourceID(SourceID_attribute attr, ClassOutputStream out) {
726 out.writeShort(attr.sourceID_index);
727 return null;
728 }
729
730 @Override
731 public Void visitStackMap(StackMap_attribute attr, ClassOutputStream out) {
732 if (stackMapWriter == null)
733 stackMapWriter = new StackMapTableWriter();
734
735 out.writeShort(attr.entries.length);
736 for (stack_map_frame f: attr.entries)
737 stackMapWriter.write(f, out);
738 return null;
739 }
740
741 @Override
742 public Void visitStackMapTable(StackMapTable_attribute attr, ClassOutputStream out) {
743 if (stackMapWriter == null)
744 stackMapWriter = new StackMapTableWriter();
745
746 out.writeShort(attr.entries.length);
747 for (stack_map_frame f: attr.entries)
748 stackMapWriter.write(f, out);
749 return null;
750 }
751
752 @Override
753 public Void visitSynthetic(Synthetic_attribute attr, ClassOutputStream out) {
754 return null;
755 }
756
757 @Override
758 public Void visitPreload(Preload_attribute attr, ClassOutputStream out) {
759 out.writeShort(attr.value_class_info_index.length);
760 for (int index: attr.value_class_info_index)
761 out.writeShort(index);
762 return null;
763 }
764
765 protected void writeAccessFlags(AccessFlags flags, ClassOutputStream out) {
766 out.writeShort(flags.flags);
767 }
768
769 protected StackMapTableWriter stackMapWriter;
770 }
771
772 /**
773 * Writer for the frames of StackMap and StackMapTable attributes.
774 */
775 protected static class StackMapTableWriter
776 implements stack_map_frame.Visitor<Void,ClassOutputStream> {
777
778 public void write(stack_map_frame frame, ClassOutputStream out) {
779 out.write(frame.frame_type);
780 frame.accept(this, out);
781 }
782
783 @Override
784 public Void visit_same_frame(same_frame frame, ClassOutputStream p) {
785 return null;
786 }
787
788 @Override
789 public Void visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame frame, ClassOutputStream out) {
790 writeVerificationTypeInfo(frame.stack[0], out);
791 return null;
792 }
793
794 @Override
795 public Void visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended frame, ClassOutputStream out) {
796 out.writeShort(frame.offset_delta);
797 writeVerificationTypeInfo(frame.stack[0], out);
798 return null;
799 }
800
801 @Override
802 public Void visit_chop_frame(chop_frame frame, ClassOutputStream out) {
803 out.writeShort(frame.offset_delta);
804 return null;
805 }
806
807 @Override
808 public Void visit_same_frame_extended(same_frame_extended frame, ClassOutputStream out) {
809 out.writeShort(frame.offset_delta);
810 return null;
811 }
812
813 @Override
814 public Void visit_append_frame(append_frame frame, ClassOutputStream out) {
815 out.writeShort(frame.offset_delta);
816 for (verification_type_info l: frame.locals)
817 writeVerificationTypeInfo(l, out);
818 return null;
819 }
820
821 @Override
822 public Void visit_full_frame(full_frame frame, ClassOutputStream out) {
823 out.writeShort(frame.offset_delta);
824 out.writeShort(frame.locals.length);
825 for (verification_type_info l: frame.locals)
826 writeVerificationTypeInfo(l, out);
827 out.writeShort(frame.stack.length);
828 for (verification_type_info s: frame.stack)
829 writeVerificationTypeInfo(s, out);
830 return null;
831 }
832
833 protected void writeVerificationTypeInfo(verification_type_info info,
834 ClassOutputStream out) {
835 out.write(info.tag);
836 switch (info.tag) {
837 case ITEM_Top:
838 case ITEM_Integer:
839 case ITEM_Float:
840 case ITEM_Long:
841 case ITEM_Double:
842 case ITEM_Null:
843 case ITEM_UninitializedThis:
844 break;
845
846 case ITEM_Object:
847 Object_variable_info o = (Object_variable_info) info;
848 out.writeShort(o.cpool_index);
849 break;
850
851 case ITEM_Uninitialized:
852 Uninitialized_variable_info u = (Uninitialized_variable_info) info;
853 out.writeShort(u.offset);
854 break;
855
856 default:
857 throw new Error();
858 }
859 }
860 }
861
862 /**
863 * Writer for annotations and the values they contain.
864 */
865 protected static class AnnotationWriter
866 implements Annotation.element_value.Visitor<Void,ClassOutputStream> {
867 public void write(Annotation[] annos, ClassOutputStream out) {
868 out.writeShort(annos.length);
869 for (Annotation anno: annos)
870 write(anno, out);
871 }
872
873 public void write(TypeAnnotation[] annos, ClassOutputStream out) {
874 out.writeShort(annos.length);
875 for (TypeAnnotation anno: annos)
876 write(anno, out);
877 }
878
879 public void write(Annotation anno, ClassOutputStream out) {
880 out.writeShort(anno.type_index);
881 out.writeShort(anno.element_value_pairs.length);
882 for (element_value_pair p: anno.element_value_pairs)
883 write(p, out);
884 }
885
886 public void write(TypeAnnotation anno, ClassOutputStream out) {
887 write(anno.position, out);
888 write(anno.annotation, out);
889 }
890
891 public void write(element_value_pair pair, ClassOutputStream out) {
892 out.writeShort(pair.element_name_index);
893 write(pair.value, out);
894 }
895
896 public void write(element_value ev, ClassOutputStream out) {
897 out.writeByte(ev.tag);
898 ev.accept(this, out);
899 }
900
901 @Override
902 public Void visitPrimitive(Primitive_element_value ev, ClassOutputStream out) {
903 out.writeShort(ev.const_value_index);
904 return null;
905 }
906
907 @Override
908 public Void visitEnum(Enum_element_value ev, ClassOutputStream out) {
909 out.writeShort(ev.type_name_index);
910 out.writeShort(ev.const_name_index);
911 return null;
912 }
913
914 @Override
915 public Void visitClass(Class_element_value ev, ClassOutputStream out) {
916 out.writeShort(ev.class_info_index);
917 return null;
918 }
919
920 @Override
921 public Void visitAnnotation(Annotation_element_value ev, ClassOutputStream out) {
922 write(ev.annotation_value, out);
923 return null;
924 }
925
926 @Override
927 public Void visitArray(Array_element_value ev, ClassOutputStream out) {
928 out.writeShort(ev.num_values);
929 for (element_value v: ev.values)
930 write(v, out);
931 return null;
932 }
933
934 // TODO: Move this to TypeAnnotation to be closer with similar logic?
935 private void write(TypeAnnotation.Position p, ClassOutputStream out) {
936 out.writeByte(p.type.targetTypeValue());
937 switch (p.type) {
938 // instanceof
939 case INSTANCEOF:
940 // new expression
941 case NEW:
942 // constructor/method reference receiver
943 case CONSTRUCTOR_REFERENCE:
944 case METHOD_REFERENCE:
945 out.writeShort(p.offset);
946 break;
947 // local variable
948 case LOCAL_VARIABLE:
949 // resource variable
950 case RESOURCE_VARIABLE:
951 int table_length = p.lvarOffset.length;
952 out.writeShort(table_length);
953 for (int i = 0; i < table_length; ++i) {
954 out.writeShort(1); // for table length
955 out.writeShort(p.lvarOffset[i]);
956 out.writeShort(p.lvarLength[i]);
957 out.writeShort(p.lvarIndex[i]);
958 }
959 break;
960 // exception parameter
961 case EXCEPTION_PARAMETER:
962 out.writeShort(p.exception_index);
963 break;
964 // method receiver
965 case METHOD_RECEIVER:
966 // Do nothing
967 break;
968 // type parameters
969 case CLASS_TYPE_PARAMETER:
970 case METHOD_TYPE_PARAMETER:
971 out.writeByte(p.parameter_index);
972 break;
973 // type parameters bounds
974 case CLASS_TYPE_PARAMETER_BOUND:
975 case METHOD_TYPE_PARAMETER_BOUND:
976 out.writeByte(p.parameter_index);
977 out.writeByte(p.bound_index);
978 break;
979 // class extends or implements clause
980 case CLASS_EXTENDS:
981 out.writeShort(p.type_index);
982 break;
983 // throws
984 case THROWS:
985 out.writeShort(p.type_index);
986 break;
987 // method parameter
988 case METHOD_FORMAL_PARAMETER:
989 out.writeByte(p.parameter_index);
990 break;
991 // type cast
992 case CAST:
993 // method/constructor/reference type argument
994 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
995 case METHOD_INVOCATION_TYPE_ARGUMENT:
996 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
997 case METHOD_REFERENCE_TYPE_ARGUMENT:
998 out.writeShort(p.offset);
999 out.writeByte(p.type_index);
1000 break;
1001 // We don't need to worry about these
1002 case METHOD_RETURN:
1003 case FIELD:
1004 break;
1005 case UNKNOWN:
1006 throw new AssertionError("ClassWriter: UNKNOWN target type should never occur!");
1007 default:
1008 throw new AssertionError("ClassWriter: Unknown target type for position: " + p);
1009 }
1010
1011 { // Append location data for generics/arrays.
1012 // TODO: check for overrun?
1013 out.writeByte((byte)p.location.size());
1014 for (int i : TypeAnnotation.Position.getBinaryFromTypePath(p.location))
1015 out.writeByte((byte)i);
1016 }
1017 }
1018 }
1019 }