1 /*
2 * Copyright (c) 2008, 2017, 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 @Override
287 public Integer visitLong(CONSTANT_Long_info info, ClassOutputStream out) {
288 out.writeLong(info.value);
289 return 2;
290 }
291
292 @Override
293 public Integer visitMethodHandle(CONSTANT_MethodHandle_info info, ClassOutputStream out) {
294 out.writeByte(info.reference_kind.tag);
295 out.writeShort(info.reference_index);
296 return 1;
297 }
298
299 @Override
300 public Integer visitMethodType(CONSTANT_MethodType_info info, ClassOutputStream out) {
301 out.writeShort(info.descriptor_index);
302 return 1;
303 }
304
305 @Override
306 public Integer visitMethodref(CONSTANT_Methodref_info info, ClassOutputStream out) {
307 return writeRef(info, out);
308 }
309
310 @Override
311 public Integer visitModule(CONSTANT_Module_info info, ClassOutputStream out) {
312 out.writeShort(info.name_index);
313 return 1;
314 }
315
316 @Override
317 public Integer visitNameAndType(CONSTANT_NameAndType_info info, ClassOutputStream out) {
318 out.writeShort(info.name_index);
319 out.writeShort(info.type_index);
320 return 1;
321 }
322
323 @Override
324 public Integer visitPackage(CONSTANT_Package_info info, ClassOutputStream out) {
325 out.writeShort(info.name_index);
326 return 1;
327 }
328
329 @Override
330 public Integer visitString(CONSTANT_String_info info, ClassOutputStream out) {
331 out.writeShort(info.string_index);
332 return 1;
333 }
334
335 @Override
336 public Integer visitUtf8(CONSTANT_Utf8_info info, ClassOutputStream out) {
337 out.writeUTF(info.value);
338 return 1;
339 }
340
341 protected Integer writeRef(CPRefInfo info, ClassOutputStream out) {
342 out.writeShort(info.class_index);
343 out.writeShort(info.name_and_type_index);
344 return 1;
345 }
346 }
347
348 /**
349 * Writer for the different types of attribute.
350 */
351 protected static class AttributeWriter implements Attribute.Visitor<Void,ClassOutputStream> {
352 public void write(Attributes attributes, ClassOutputStream out) {
353 int size = attributes.size();
354 out.writeShort(size);
355 for (Attribute a: attributes)
356 write(a, out);
357 }
358
359 // Note: due to the use of shared resources, this method is not reentrant.
360 public void write(Attribute attr, ClassOutputStream out) {
361 out.writeShort(attr.attribute_name_index);
362 sharedOut.reset();
363 attr.accept(this, sharedOut);
364 out.writeInt(sharedOut.size());
365 sharedOut.writeTo(out);
366 }
367
368 protected ClassOutputStream sharedOut = new ClassOutputStream();
369 protected AnnotationWriter annotationWriter = new AnnotationWriter();
370
371 @Override
372 public Void visitDefault(DefaultAttribute attr, ClassOutputStream out) {
373 out.write(attr.info, 0, attr.info.length);
374 return null;
375 }
376
377 @Override
378 public Void visitAnnotationDefault(AnnotationDefault_attribute attr, ClassOutputStream out) {
379 annotationWriter.write(attr.default_value, out);
380 return null;
381 }
382
383 @Override
384 public Void visitBootstrapMethods(BootstrapMethods_attribute attr, ClassOutputStream out) {
385 out.writeShort(attr.bootstrap_method_specifiers.length);
386 for (BootstrapMethods_attribute.BootstrapMethodSpecifier bsm : attr.bootstrap_method_specifiers) {
387 out.writeShort(bsm.bootstrap_method_ref);
388 int bsm_args_count = bsm.bootstrap_arguments.length;
389 out.writeShort(bsm_args_count);
390 for (int i : bsm.bootstrap_arguments) {
391 out.writeShort(i);
392 }
393 }
394 return null;
395 }
396
397 @Override
398 public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, ClassOutputStream out) {
399 out.writeShort(attr.character_range_table.length);
400 for (CharacterRangeTable_attribute.Entry e: attr.character_range_table)
401 writeCharacterRangeTableEntry(e, out);
402 return null;
403 }
404
405 protected void writeCharacterRangeTableEntry(CharacterRangeTable_attribute.Entry entry, ClassOutputStream out) {
406 out.writeShort(entry.start_pc);
407 out.writeShort(entry.end_pc);
408 out.writeInt(entry.character_range_start);
409 out.writeInt(entry.character_range_end);
410 out.writeShort(entry.flags);
411 }
412
413 @Override
414 public Void visitCode(Code_attribute attr, ClassOutputStream out) {
415 out.writeShort(attr.max_stack);
416 out.writeShort(attr.max_locals);
417 out.writeInt(attr.code.length);
418 out.write(attr.code, 0, attr.code.length);
419 out.writeShort(attr.exception_table.length);
420 for (Code_attribute.Exception_data e: attr.exception_table)
421 writeExceptionTableEntry(e, out);
422 new AttributeWriter().write(attr.attributes, out);
423 return null;
424 }
425
426 protected void writeExceptionTableEntry(Code_attribute.Exception_data exception_data, ClassOutputStream out) {
427 out.writeShort(exception_data.start_pc);
428 out.writeShort(exception_data.end_pc);
429 out.writeShort(exception_data.handler_pc);
430 out.writeShort(exception_data.catch_type);
431 }
432
433 @Override
434 public Void visitCompilationID(CompilationID_attribute attr, ClassOutputStream out) {
435 out.writeShort(attr.compilationID_index);
436 return null;
437 }
438
439 @Override
440 public Void visitConstantValue(ConstantValue_attribute attr, ClassOutputStream out) {
441 out.writeShort(attr.constantvalue_index);
442 return null;
443 }
444
445 @Override
446 public Void visitDeprecated(Deprecated_attribute attr, ClassOutputStream out) {
447 return null;
448 }
449
450 @Override
451 public Void visitEnclosingMethod(EnclosingMethod_attribute attr, ClassOutputStream out) {
452 out.writeShort(attr.class_index);
453 out.writeShort(attr.method_index);
454 return null;
455 }
456
457 @Override
458 public Void visitExceptions(Exceptions_attribute attr, ClassOutputStream out) {
459 out.writeShort(attr.exception_index_table.length);
460 for (int i: attr.exception_index_table)
461 out.writeShort(i);
462 return null;
463 }
464
465 @Override
466 public Void visitInnerClasses(InnerClasses_attribute attr, ClassOutputStream out) {
467 out.writeShort(attr.classes.length);
468 for (InnerClasses_attribute.Info info: attr.classes)
469 writeInnerClassesInfo(info, out);
470 return null;
471 }
472
473 protected void writeInnerClassesInfo(InnerClasses_attribute.Info info, ClassOutputStream out) {
474 out.writeShort(info.inner_class_info_index);
475 out.writeShort(info.outer_class_info_index);
476 out.writeShort(info.inner_name_index);
477 writeAccessFlags(info.inner_class_access_flags, out);
478 }
479
480 @Override
481 public Void visitLineNumberTable(LineNumberTable_attribute attr, ClassOutputStream out) {
482 out.writeShort(attr.line_number_table.length);
483 for (LineNumberTable_attribute.Entry e: attr.line_number_table)
484 writeLineNumberTableEntry(e, out);
485 return null;
486 }
487
488 protected void writeLineNumberTableEntry(LineNumberTable_attribute.Entry entry, ClassOutputStream out) {
489 out.writeShort(entry.start_pc);
490 out.writeShort(entry.line_number);
491 }
492
493 @Override
494 public Void visitLocalVariableTable(LocalVariableTable_attribute attr, ClassOutputStream out) {
495 out.writeShort(attr.local_variable_table.length);
496 for (LocalVariableTable_attribute.Entry e: attr.local_variable_table)
497 writeLocalVariableTableEntry(e, out);
498 return null;
499 }
500
501 protected void writeLocalVariableTableEntry(LocalVariableTable_attribute.Entry entry, ClassOutputStream out) {
502 out.writeShort(entry.start_pc);
503 out.writeShort(entry.length);
504 out.writeShort(entry.name_index);
505 out.writeShort(entry.descriptor_index);
506 out.writeShort(entry.index);
507 }
508
509 @Override
510 public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, ClassOutputStream out) {
511 out.writeShort(attr.local_variable_table.length);
512 for (LocalVariableTypeTable_attribute.Entry e: attr.local_variable_table)
513 writeLocalVariableTypeTableEntry(e, out);
514 return null;
515 }
516
517 protected void writeLocalVariableTypeTableEntry(LocalVariableTypeTable_attribute.Entry entry, ClassOutputStream out) {
518 out.writeShort(entry.start_pc);
519 out.writeShort(entry.length);
520 out.writeShort(entry.name_index);
521 out.writeShort(entry.signature_index);
522 out.writeShort(entry.index);
523 }
524
525 @Override
526 public Void visitMemberOfNest(MemberOfNest_attribute attr, ClassOutputStream out) {
527 out.writeShort(attr.top_index);
528 return null;
529 }
530
531 @Override
532 public Void visitMethodParameters(MethodParameters_attribute attr, ClassOutputStream out) {
533 out.writeByte(attr.method_parameter_table.length);
534 for (MethodParameters_attribute.Entry e : attr.method_parameter_table) {
535 out.writeShort(e.name_index);
536 out.writeShort(e.flags);
537 }
538 return null;
539 }
540
541 @Override
542 public Void visitModule(Module_attribute attr, ClassOutputStream out) {
543 out.writeShort(attr.module_name);
544 out.writeShort(attr.module_flags);
545 out.writeShort(attr.module_version_index);
546
547 out.writeShort(attr.requires.length);
548 for (Module_attribute.RequiresEntry e: attr.requires) {
549 out.writeShort(e.requires_index);
550 out.writeShort(e.requires_flags);
551 out.writeShort(e.requires_version_index);
552 }
553
554 out.writeShort(attr.exports.length);
555 for (Module_attribute.ExportsEntry e: attr.exports) {
556 out.writeShort(e.exports_index);
557 out.writeShort(e.exports_flags);
558 out.writeShort(e.exports_to_index.length);
559 for (int index: e.exports_to_index)
560 out.writeShort(index);
561 }
562
563 out.writeShort(attr.opens.length);
564 for (Module_attribute.OpensEntry e: attr.opens) {
565 out.writeShort(e.opens_index);
566 out.writeShort(e.opens_flags);
567 out.writeShort(e.opens_to_index.length);
568 for (int index: e.opens_to_index)
569 out.writeShort(index);
570 }
571
572 out.writeShort(attr.uses_index.length);
573 for (int index: attr.uses_index) {
574 out.writeShort(index);
575 }
576
577 out.writeShort(attr.provides.length);
578 for (Module_attribute.ProvidesEntry e: attr.provides) {
579 out.writeShort(e.provides_index);
580 out.writeShort(e.with_count);
581 for (int with : e.with_index) {
582 out.writeShort(with);
583 }
584 }
585
586 return null;
587 }
588
589 @Override
590 public Void visitModuleHashes(ModuleHashes_attribute attr, ClassOutputStream out) {
591 out.writeShort(attr.algorithm_index);
592 out.writeShort(attr.hashes_table.length);
593 for (ModuleHashes_attribute.Entry e: attr.hashes_table) {
594 out.writeShort(e.module_name_index);
595 out.writeShort(e.hash.length);
596 for (byte b: e.hash) {
597 out.writeByte(b);
598 }
599 }
600 return null;
601 }
602
603 @Override
604 public Void visitModuleMainClass(ModuleMainClass_attribute attr, ClassOutputStream out) {
605 out.writeShort(attr.main_class_index);
606 return null;
607 }
608
609 @Override
610 public Void visitModulePackages(ModulePackages_attribute attr, ClassOutputStream out) {
611 out.writeShort(attr.packages_count);
612 for (int i: attr.packages_index)
613 out.writeShort(i);
614 return null;
615 }
616
617 @Override
618 public Void visitModuleResolution(ModuleResolution_attribute attr, ClassOutputStream out) {
619 out.writeShort(attr.resolution_flags);
620 return null;
621 }
622
623 @Override
624 public Void visitModuleTarget(ModuleTarget_attribute attr, ClassOutputStream out) {
625 out.writeShort(attr.target_platform_index);
626 return null;
627 }
628
629 @Override
630 public Void visitNestMembers(NestMembers_attribute attr, ClassOutputStream out) {
631 out.writeShort(attr.members_indexes.length);
632 for (int i : attr.members_indexes) {
633 out.writeShort(i);
634 }
635 return null;
636 }
637
638 @Override
639 public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, ClassOutputStream out) {
640 annotationWriter.write(attr.annotations, out);
641 return null;
642 }
643
644 @Override
645 public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
646 out.writeByte(attr.parameter_annotations.length);
647 for (Annotation[] annos: attr.parameter_annotations)
648 annotationWriter.write(annos, out);
649 return null;
650 }
651
652 @Override
653 public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
654 annotationWriter.write(attr.annotations, out);
655 return null;
656 }
657
658 @Override
659 public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {
660 annotationWriter.write(attr.annotations, out);
661 return null;
662 }
663
664 @Override
665 public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
666 out.writeByte(attr.parameter_annotations.length);
667 for (Annotation[] annos: attr.parameter_annotations)
668 annotationWriter.write(annos, out);
669 return null;
670 }
671
672 @Override
673 public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
674 annotationWriter.write(attr.annotations, out);
675 return null;
676 }
677
678 @Override
679 public Void visitSignature(Signature_attribute attr, ClassOutputStream out) {
680 out.writeShort(attr.signature_index);
681 return null;
682 }
683
684 @Override
685 public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, ClassOutputStream out) {
686 out.write(attr.debug_extension, 0, attr.debug_extension.length);
687 return null;
688 }
689
690 @Override
691 public Void visitSourceFile(SourceFile_attribute attr, ClassOutputStream out) {
692 out.writeShort(attr.sourcefile_index);
693 return null;
694 }
695
696 @Override
697 public Void visitSourceID(SourceID_attribute attr, ClassOutputStream out) {
698 out.writeShort(attr.sourceID_index);
699 return null;
700 }
701
702 @Override
703 public Void visitStackMap(StackMap_attribute attr, ClassOutputStream out) {
704 if (stackMapWriter == null)
705 stackMapWriter = new StackMapTableWriter();
706
707 out.writeShort(attr.entries.length);
708 for (stack_map_frame f: attr.entries)
709 stackMapWriter.write(f, out);
710 return null;
711 }
712
713 @Override
714 public Void visitStackMapTable(StackMapTable_attribute attr, ClassOutputStream out) {
715 if (stackMapWriter == null)
716 stackMapWriter = new StackMapTableWriter();
717
718 out.writeShort(attr.entries.length);
719 for (stack_map_frame f: attr.entries)
720 stackMapWriter.write(f, out);
721 return null;
722 }
723
724 @Override
725 public Void visitSynthetic(Synthetic_attribute attr, ClassOutputStream out) {
726 return null;
727 }
728
729 protected void writeAccessFlags(AccessFlags flags, ClassOutputStream p) {
730 sharedOut.writeShort(flags.flags);
731 }
732
733 protected StackMapTableWriter stackMapWriter;
734 }
735
736 /**
737 * Writer for the frames of StackMap and StackMapTable attributes.
738 */
739 protected static class StackMapTableWriter
740 implements stack_map_frame.Visitor<Void,ClassOutputStream> {
741
742 public void write(stack_map_frame frame, ClassOutputStream out) {
743 out.write(frame.frame_type);
744 frame.accept(this, out);
745 }
746
747 @Override
748 public Void visit_same_frame(same_frame frame, ClassOutputStream p) {
749 return null;
750 }
751
752 @Override
753 public Void visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame frame, ClassOutputStream out) {
754 writeVerificationTypeInfo(frame.stack[0], out);
755 return null;
756 }
757
758 @Override
759 public Void visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended frame, ClassOutputStream out) {
760 out.writeShort(frame.offset_delta);
761 writeVerificationTypeInfo(frame.stack[0], out);
762 return null;
763 }
764
765 @Override
766 public Void visit_chop_frame(chop_frame frame, ClassOutputStream out) {
767 out.writeShort(frame.offset_delta);
768 return null;
769 }
770
771 @Override
772 public Void visit_same_frame_extended(same_frame_extended frame, ClassOutputStream out) {
773 out.writeShort(frame.offset_delta);
774 return null;
775 }
776
777 @Override
778 public Void visit_append_frame(append_frame frame, ClassOutputStream out) {
779 out.writeShort(frame.offset_delta);
780 for (verification_type_info l: frame.locals)
781 writeVerificationTypeInfo(l, out);
782 return null;
783 }
784
785 @Override
786 public Void visit_full_frame(full_frame frame, ClassOutputStream out) {
787 out.writeShort(frame.offset_delta);
788 out.writeShort(frame.locals.length);
789 for (verification_type_info l: frame.locals)
790 writeVerificationTypeInfo(l, out);
791 out.writeShort(frame.stack.length);
792 for (verification_type_info s: frame.stack)
793 writeVerificationTypeInfo(s, out);
794 return null;
795 }
796
797 protected void writeVerificationTypeInfo(verification_type_info info,
798 ClassOutputStream out) {
799 out.write(info.tag);
800 switch (info.tag) {
801 case ITEM_Top:
802 case ITEM_Integer:
803 case ITEM_Float:
804 case ITEM_Long:
805 case ITEM_Double:
806 case ITEM_Null:
807 case ITEM_UninitializedThis:
808 break;
809
810 case ITEM_Object:
811 Object_variable_info o = (Object_variable_info) info;
812 out.writeShort(o.cpool_index);
813 break;
814
815 case ITEM_Uninitialized:
816 Uninitialized_variable_info u = (Uninitialized_variable_info) info;
817 out.writeShort(u.offset);
818 break;
819
820 default:
821 throw new Error();
822 }
823 }
824 }
825
826 /**
827 * Writer for annotations and the values they contain.
828 */
829 protected static class AnnotationWriter
830 implements Annotation.element_value.Visitor<Void,ClassOutputStream> {
831 public void write(Annotation[] annos, ClassOutputStream out) {
832 out.writeShort(annos.length);
833 for (Annotation anno: annos)
834 write(anno, out);
835 }
836
837 public void write(TypeAnnotation[] annos, ClassOutputStream out) {
838 out.writeShort(annos.length);
839 for (TypeAnnotation anno: annos)
840 write(anno, out);
841 }
842
843 public void write(Annotation anno, ClassOutputStream out) {
844 out.writeShort(anno.type_index);
845 out.writeShort(anno.element_value_pairs.length);
846 for (element_value_pair p: anno.element_value_pairs)
847 write(p, out);
848 }
849
850 public void write(TypeAnnotation anno, ClassOutputStream out) {
851 write(anno.position, out);
852 write(anno.annotation, out);
853 }
854
855 public void write(element_value_pair pair, ClassOutputStream out) {
856 out.writeShort(pair.element_name_index);
857 write(pair.value, out);
858 }
859
860 public void write(element_value ev, ClassOutputStream out) {
861 out.writeByte(ev.tag);
862 ev.accept(this, out);
863 }
864
865 @Override
866 public Void visitPrimitive(Primitive_element_value ev, ClassOutputStream out) {
867 out.writeShort(ev.const_value_index);
868 return null;
869 }
870
871 @Override
872 public Void visitEnum(Enum_element_value ev, ClassOutputStream out) {
873 out.writeShort(ev.type_name_index);
874 out.writeShort(ev.const_name_index);
875 return null;
876 }
877
878 @Override
879 public Void visitClass(Class_element_value ev, ClassOutputStream out) {
880 out.writeShort(ev.class_info_index);
881 return null;
882 }
883
884 @Override
885 public Void visitAnnotation(Annotation_element_value ev, ClassOutputStream out) {
886 write(ev.annotation_value, out);
887 return null;
888 }
889
890 @Override
891 public Void visitArray(Array_element_value ev, ClassOutputStream out) {
892 out.writeShort(ev.num_values);
893 for (element_value v: ev.values)
894 write(v, out);
895 return null;
896 }
897
898 // TODO: Move this to TypeAnnotation to be closer with similar logic?
899 private void write(TypeAnnotation.Position p, ClassOutputStream out) {
900 out.writeByte(p.type.targetTypeValue());
901 switch (p.type) {
902 // instanceof
903 case INSTANCEOF:
904 // new expression
905 case NEW:
906 // constructor/method reference receiver
907 case CONSTRUCTOR_REFERENCE:
908 case METHOD_REFERENCE:
909 out.writeShort(p.offset);
910 break;
911 // local variable
912 case LOCAL_VARIABLE:
913 // resource variable
914 case RESOURCE_VARIABLE:
915 int table_length = p.lvarOffset.length;
916 out.writeShort(table_length);
917 for (int i = 0; i < table_length; ++i) {
918 out.writeShort(1); // for table length
919 out.writeShort(p.lvarOffset[i]);
920 out.writeShort(p.lvarLength[i]);
921 out.writeShort(p.lvarIndex[i]);
922 }
923 break;
924 // exception parameter
925 case EXCEPTION_PARAMETER:
926 out.writeShort(p.exception_index);
927 break;
928 // method receiver
929 case METHOD_RECEIVER:
930 // Do nothing
931 break;
932 // type parameters
933 case CLASS_TYPE_PARAMETER:
934 case METHOD_TYPE_PARAMETER:
935 out.writeByte(p.parameter_index);
936 break;
937 // type parameters bounds
938 case CLASS_TYPE_PARAMETER_BOUND:
939 case METHOD_TYPE_PARAMETER_BOUND:
940 out.writeByte(p.parameter_index);
941 out.writeByte(p.bound_index);
942 break;
943 // class extends or implements clause
944 case CLASS_EXTENDS:
945 out.writeShort(p.type_index);
946 break;
947 // throws
948 case THROWS:
949 out.writeShort(p.type_index);
950 break;
951 // method parameter
952 case METHOD_FORMAL_PARAMETER:
953 out.writeByte(p.parameter_index);
954 break;
955 // type cast
956 case CAST:
957 // method/constructor/reference type argument
958 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
959 case METHOD_INVOCATION_TYPE_ARGUMENT:
960 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
961 case METHOD_REFERENCE_TYPE_ARGUMENT:
962 out.writeShort(p.offset);
963 out.writeByte(p.type_index);
964 break;
965 // We don't need to worry about these
966 case METHOD_RETURN:
967 case FIELD:
968 break;
969 case UNKNOWN:
970 throw new AssertionError("ClassWriter: UNKNOWN target type should never occur!");
971 default:
972 throw new AssertionError("ClassWriter: Unknown target type for position: " + p);
973 }
974
975 { // Append location data for generics/arrays.
976 // TODO: check for overrun?
977 out.writeByte((byte)p.location.size());
978 for (int i : TypeAnnotation.Position.getBinaryFromTypePath(p.location))
979 out.writeByte((byte)i);
980 }
981 }
982 }
983 }