1
2 /*
3 * Copyright (c) 2008, 2013, Oracle and/or its affiliates. All rights reserved.
4 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 *
6 * This code is free software; you can redistribute it and/or modify it
7 * under the terms of the GNU General Public License version 2 only, as
8 * published by the Free Software Foundation. Oracle designates this
9 * particular file as subject to the "Classpath" exception as provided
10 * by Oracle in the LICENSE file that accompanied this code.
11 *
12 * This code is distributed in the hope that it will be useful, but WITHOUT
13 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 * version 2 for more details (a copy is included in the LICENSE file that
16 * accompanied this code).
17 *
18 * You should have received a copy of the GNU General Public License version
19 * 2 along with this work; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 *
22 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
23 * or visit www.oracle.com if you need additional information or have any
24 * questions.
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 */
59 public void write(ClassFile classFile, File f) throws IOException {
60 try (FileOutputStream f_out = new FileOutputStream(f)) {
61 write(classFile, f_out);
62 }
63 }
64
65 /**
66 * Write a ClassFile data structure to a stream.
67 */
68 public void write(ClassFile classFile, OutputStream s) throws IOException {
69 this.classFile = classFile;
70 out.reset();
71 write();
72 out.writeTo(s);
73 }
74
75 protected void write() throws IOException {
76 writeHeader();
77 writeConstantPool();
78 writeAccessFlags(classFile.access_flags);
79 writeClassInfo();
80 writeFields();
81 writeMethods();
82 writeAttributes(classFile.attributes);
83 }
84
85 protected void writeHeader() {
86 out.writeInt(classFile.magic);
87 out.writeShort(classFile.minor_version);
88 out.writeShort(classFile.major_version);
89 }
90
91 protected void writeAccessFlags(AccessFlags flags) {
92 out.writeShort(flags.flags);
93 }
94
95 protected void writeAttributes(Attributes attributes) {
96 int size = attributes.size();
97 out.writeShort(size);
98 for (Attribute attr: attributes)
99 attributeWriter.write(attr, out);
100 }
101
102 protected void writeClassInfo() {
103 out.writeShort(classFile.this_class);
104 out.writeShort(classFile.super_class);
105 int[] interfaces = classFile.interfaces;
106 out.writeShort(interfaces.length);
107 for (int i: interfaces)
108 out.writeShort(i);
109 }
110
111 protected void writeDescriptor(Descriptor d) {
112 out.writeShort(d.index);
113 }
114
115 protected void writeConstantPool() {
116 ConstantPool pool = classFile.constant_pool;
117 int size = pool.size();
118 out.writeShort(size);
119 for (CPInfo cpInfo: pool.entries())
120 constantPoolWriter.write(cpInfo, out);
121 }
122
123 protected void writeFields() throws IOException {
124 Field[] fields = classFile.fields;
125 out.writeShort(fields.length);
126 for (Field f: fields)
127 writeField(f);
128 }
129
130 protected void writeField(Field f) throws IOException {
131 writeAccessFlags(f.access_flags);
132 out.writeShort(f.name_index);
133 writeDescriptor(f.descriptor);
134 writeAttributes(f.attributes);
135 }
136
137 protected void writeMethods() throws IOException {
138 Method[] methods = classFile.methods;
139 out.writeShort(methods.length);
140 for (Method m: methods) {
141 writeMethod(m);
142 }
143 }
144
145 protected void writeMethod(Method m) throws IOException {
146 writeAccessFlags(m.access_flags);
147 out.writeShort(m.name_index);
148 writeDescriptor(m.descriptor);
149 writeAttributes(m.attributes);
150 }
151
152 protected ClassFile classFile;
153 protected ClassOutputStream out;
154 protected AttributeWriter attributeWriter;
155 protected ConstantPoolWriter constantPoolWriter;
156
157 /**
158 * Subtype of ByteArrayOutputStream with the convenience methods of
159 * a DataOutputStream. Since ByteArrayOutputStream does not throw
160 * IOException, there are no exceptions from the additional
161 * convenience methods either,
162 */
163 protected static class ClassOutputStream extends ByteArrayOutputStream {
164 public ClassOutputStream() {
165 d = new DataOutputStream(this);
166 }
167
168 public void writeByte(int value) {
169 try {
170 d.writeByte(value);
171 } catch (IOException ignore) {
172 }
173 }
174
175 public void writeShort(int value) {
176 try {
177 d.writeShort(value);
178 } catch (IOException ignore) {
179 }
180 }
181
182 public void writeInt(int value) {
183 try {
184 d.writeInt(value);
185 } catch (IOException ignore) {
186 }
187 }
188
189 public void writeLong(long value) {
190 try {
191 d.writeLong(value);
192 } catch (IOException ignore) {
193 }
194 }
195
196 public void writeFloat(float value) {
197 try {
198 d.writeFloat(value);
199 } catch (IOException ignore) {
200 }
201 }
202
203 public void writeDouble(double value) {
204 try {
205 d.writeDouble(value);
206 } catch (IOException ignore) {
207 }
208 }
209
210 public void writeUTF(String value) {
211 try {
212 d.writeUTF(value);
213 } catch (IOException ignore) {
214 }
215 }
216
217 public void writeTo(ClassOutputStream s) {
218 try {
219 super.writeTo(s);
220 } catch (IOException ignore) {
221 }
222 }
223
224 private DataOutputStream d;
225 }
226
227 /**
228 * Writer for the entries in the constant pool.
229 */
230 protected static class ConstantPoolWriter
231 implements ConstantPool.Visitor<Integer,ClassOutputStream> {
232 protected int write(CPInfo info, ClassOutputStream out) {
233 out.writeByte(info.getTag());
234 return info.accept(this, out);
235 }
236
237 public Integer visitClass(CONSTANT_Class_info info, ClassOutputStream out) {
238 out.writeShort(info.name_index);
239 return 1;
240 }
241
242 public Integer visitDouble(CONSTANT_Double_info info, ClassOutputStream out) {
243 out.writeDouble(info.value);
244 return 2;
245 }
246
247 public Integer visitFieldref(CONSTANT_Fieldref_info info, ClassOutputStream out) {
248 writeRef(info, out);
249 return 1;
250 }
251
252 public Integer visitFloat(CONSTANT_Float_info info, ClassOutputStream out) {
253 out.writeFloat(info.value);
254 return 1;
255 }
256
257 public Integer visitInteger(CONSTANT_Integer_info info, ClassOutputStream out) {
258 out.writeInt(info.value);
259 return 1;
260 }
261
262 public Integer visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, ClassOutputStream out) {
263 writeRef(info, out);
264 return 1;
265 }
266
267 public Integer visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, ClassOutputStream out) {
268 out.writeShort(info.bootstrap_method_attr_index);
269 out.writeShort(info.name_and_type_index);
270 return 1;
271 }
272
273 public Integer visitLong(CONSTANT_Long_info info, ClassOutputStream out) {
274 out.writeLong(info.value);
275 return 2;
276 }
277
278 public Integer visitNameAndType(CONSTANT_NameAndType_info info, ClassOutputStream out) {
279 out.writeShort(info.name_index);
280 out.writeShort(info.type_index);
281 return 1;
282 }
283
284 public Integer visitMethodHandle(CONSTANT_MethodHandle_info info, ClassOutputStream out) {
285 out.writeByte(info.reference_kind.tag);
286 out.writeShort(info.reference_index);
287 return 1;
288 }
289
290 public Integer visitMethodType(CONSTANT_MethodType_info info, ClassOutputStream out) {
291 out.writeShort(info.descriptor_index);
292 return 1;
293 }
294
295 public Integer visitMethodref(CONSTANT_Methodref_info info, ClassOutputStream out) {
296 return writeRef(info, out);
297 }
298
299 public Integer visitString(CONSTANT_String_info info, ClassOutputStream out) {
300 out.writeShort(info.string_index);
301 return 1;
302 }
303
304 public Integer visitUtf8(CONSTANT_Utf8_info info, ClassOutputStream out) {
305 out.writeUTF(info.value);
306 return 1;
307 }
308
309 protected Integer writeRef(CPRefInfo info, ClassOutputStream out) {
310 out.writeShort(info.class_index);
311 out.writeShort(info.name_and_type_index);
312 return 1;
313 }
314 }
315
316 /**
317 * Writer for the different types of attribute.
318 */
319 protected static class AttributeWriter implements Attribute.Visitor<Void,ClassOutputStream> {
320 public void write(Attributes attributes, ClassOutputStream out) {
321 int size = attributes.size();
322 out.writeShort(size);
323 for (Attribute a: attributes)
324 write(a, out);
325 }
326
327 // Note: due to the use of shared resources, this method is not reentrant.
328 public void write(Attribute attr, ClassOutputStream out) {
329 out.writeShort(attr.attribute_name_index);
330 sharedOut.reset();
331 attr.accept(this, sharedOut);
332 out.writeInt(sharedOut.size());
333 sharedOut.writeTo(out);
334 }
335
336 protected ClassOutputStream sharedOut = new ClassOutputStream();
337 protected AnnotationWriter annotationWriter = new AnnotationWriter();
338
339 public Void visitDefault(DefaultAttribute attr, ClassOutputStream out) {
340 out.write(attr.info, 0, attr.info.length);
341 return null;
342 }
343
344 public Void visitAnnotationDefault(AnnotationDefault_attribute attr, ClassOutputStream out) {
345 annotationWriter.write(attr.default_value, out);
346 return null;
347 }
348
349 public Void visitBootstrapMethods(BootstrapMethods_attribute attr, ClassOutputStream out) {
350 out.writeShort(attr.bootstrap_method_specifiers.length);
351 for (BootstrapMethods_attribute.BootstrapMethodSpecifier bsm : attr.bootstrap_method_specifiers) {
352 out.writeShort(bsm.bootstrap_method_ref);
353 int bsm_args_count = bsm.bootstrap_arguments.length;
354 out.writeShort(bsm_args_count);
355 for (int i : bsm.bootstrap_arguments) {
356 out.writeShort(i);
357 }
358 }
359 return null;
360 }
361
362 public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, ClassOutputStream out) {
363 out.writeShort(attr.character_range_table.length);
364 for (CharacterRangeTable_attribute.Entry e: attr.character_range_table)
365 writeCharacterRangeTableEntry(e, out);
366 return null;
367 }
368
369 protected void writeCharacterRangeTableEntry(CharacterRangeTable_attribute.Entry entry, ClassOutputStream out) {
370 out.writeShort(entry.start_pc);
371 out.writeShort(entry.end_pc);
372 out.writeInt(entry.character_range_start);
373 out.writeInt(entry.character_range_end);
374 out.writeShort(entry.flags);
375 }
376
377 public Void visitCode(Code_attribute attr, ClassOutputStream out) {
378 out.writeShort(attr.max_stack);
379 out.writeShort(attr.max_locals);
380 out.writeInt(attr.code.length);
381 out.write(attr.code, 0, attr.code.length);
382 out.writeShort(attr.exception_table.length);
383 for (Code_attribute.Exception_data e: attr.exception_table)
384 writeExceptionTableEntry(e, out);
385 new AttributeWriter().write(attr.attributes, out);
386 return null;
387 }
388
389 protected void writeExceptionTableEntry(Code_attribute.Exception_data exception_data, ClassOutputStream out) {
390 out.writeShort(exception_data.start_pc);
391 out.writeShort(exception_data.end_pc);
392 out.writeShort(exception_data.handler_pc);
393 out.writeShort(exception_data.catch_type);
394 }
395
396 public Void visitCompilationID(CompilationID_attribute attr, ClassOutputStream out) {
397 out.writeShort(attr.compilationID_index);
398 return null;
399 }
400
401 public Void visitConstantValue(ConstantValue_attribute attr, ClassOutputStream out) {
402 out.writeShort(attr.constantvalue_index);
403 return null;
404 }
405
406 public Void visitDeprecated(Deprecated_attribute attr, ClassOutputStream out) {
407 return null;
408 }
409
410 public Void visitEnclosingMethod(EnclosingMethod_attribute attr, ClassOutputStream out) {
411 out.writeShort(attr.class_index);
412 out.writeShort(attr.method_index);
413 return null;
414 }
415
416 public Void visitExceptions(Exceptions_attribute attr, ClassOutputStream out) {
417 out.writeShort(attr.exception_index_table.length);
418 for (int i: attr.exception_index_table)
419 out.writeShort(i);
420 return null;
421 }
422
423 public Void visitInnerClasses(InnerClasses_attribute attr, ClassOutputStream out) {
424 out.writeShort(attr.classes.length);
425 for (InnerClasses_attribute.Info info: attr.classes)
426 writeInnerClassesInfo(info, out);
427 return null;
428 }
429
430 protected void writeInnerClassesInfo(InnerClasses_attribute.Info info, ClassOutputStream out) {
431 out.writeShort(info.inner_class_info_index);
432 out.writeShort(info.outer_class_info_index);
433 out.writeShort(info.inner_name_index);
434 writeAccessFlags(info.inner_class_access_flags, out);
435 }
436
437 public Void visitLineNumberTable(LineNumberTable_attribute attr, ClassOutputStream out) {
438 out.writeShort(attr.line_number_table.length);
439 for (LineNumberTable_attribute.Entry e: attr.line_number_table)
440 writeLineNumberTableEntry(e, out);
441 return null;
442 }
443
444 protected void writeLineNumberTableEntry(LineNumberTable_attribute.Entry entry, ClassOutputStream out) {
445 out.writeShort(entry.start_pc);
446 out.writeShort(entry.line_number);
447 }
448
449 public Void visitLocalVariableTable(LocalVariableTable_attribute attr, ClassOutputStream out) {
450 out.writeShort(attr.local_variable_table.length);
451 for (LocalVariableTable_attribute.Entry e: attr.local_variable_table)
452 writeLocalVariableTableEntry(e, out);
453 return null;
454 }
455
456 protected void writeLocalVariableTableEntry(LocalVariableTable_attribute.Entry entry, ClassOutputStream out) {
457 out.writeShort(entry.start_pc);
458 out.writeShort(entry.length);
459 out.writeShort(entry.name_index);
460 out.writeShort(entry.descriptor_index);
461 out.writeShort(entry.index);
462 }
463
464 public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, ClassOutputStream out) {
465 out.writeShort(attr.local_variable_table.length);
466 for (LocalVariableTypeTable_attribute.Entry e: attr.local_variable_table)
467 writeLocalVariableTypeTableEntry(e, out);
468 return null;
469 }
470
471 protected void writeLocalVariableTypeTableEntry(LocalVariableTypeTable_attribute.Entry entry, ClassOutputStream out) {
472 out.writeShort(entry.start_pc);
473 out.writeShort(entry.length);
474 out.writeShort(entry.name_index);
475 out.writeShort(entry.signature_index);
476 out.writeShort(entry.index);
477 }
478
479 public Void visitMethodParameters(MethodParameters_attribute attr, ClassOutputStream out) {
480 out.writeByte(attr.method_parameter_table.length);
481 for (MethodParameters_attribute.Entry e : attr.method_parameter_table) {
482 out.writeShort(e.name_index);
483 out.writeShort(e.flags);
484 }
485 return null;
486 }
487
488 public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {
489 annotationWriter.write(attr.annotations, out);
490 return null;
491 }
492
493 public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, ClassOutputStream out) {
494 annotationWriter.write(attr.annotations, out);
495 return null;
496 }
497
498 public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
499 annotationWriter.write(attr.annotations, out);
500 return null;
501 }
502
503 public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
504 annotationWriter.write(attr.annotations, out);
505 return null;
506 }
507
508 public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
509 out.writeByte(attr.parameter_annotations.length);
510 for (Annotation[] annos: attr.parameter_annotations)
511 annotationWriter.write(annos, out);
512 return null;
513 }
514
515 public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
516 out.writeByte(attr.parameter_annotations.length);
517 for (Annotation[] annos: attr.parameter_annotations)
518 annotationWriter.write(annos, out);
519 return null;
520 }
521
522 public Void visitSignature(Signature_attribute attr, ClassOutputStream out) {
523 out.writeShort(attr.signature_index);
524 return null;
525 }
526
527 public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, ClassOutputStream out) {
528 out.write(attr.debug_extension, 0, attr.debug_extension.length);
529 return null;
530 }
531
532 public Void visitSourceFile(SourceFile_attribute attr, ClassOutputStream out) {
533 out.writeShort(attr.sourcefile_index);
534 return null;
535 }
536
537 public Void visitSourceID(SourceID_attribute attr, ClassOutputStream out) {
538 out.writeShort(attr.sourceID_index);
539 return null;
540 }
541
542 public Void visitStackMap(StackMap_attribute attr, ClassOutputStream out) {
543 if (stackMapWriter == null)
544 stackMapWriter = new StackMapTableWriter();
545
546 out.writeShort(attr.entries.length);
547 for (stack_map_frame f: attr.entries)
548 stackMapWriter.write(f, out);
549 return null;
550 }
551
552 public Void visitStackMapTable(StackMapTable_attribute attr, ClassOutputStream out) {
553 if (stackMapWriter == null)
554 stackMapWriter = new StackMapTableWriter();
555
556 out.writeShort(attr.entries.length);
557 for (stack_map_frame f: attr.entries)
558 stackMapWriter.write(f, out);
559 return null;
560 }
561
562 public Void visitSynthetic(Synthetic_attribute attr, ClassOutputStream out) {
563 return null;
564 }
565
566 protected void writeAccessFlags(AccessFlags flags, ClassOutputStream p) {
567 sharedOut.writeShort(flags.flags);
568 }
569
570 protected StackMapTableWriter stackMapWriter;
571 }
572
573 /**
574 * Writer for the frames of StackMap and StackMapTable attributes.
575 */
576 protected static class StackMapTableWriter
577 implements stack_map_frame.Visitor<Void,ClassOutputStream> {
578
579 public void write(stack_map_frame frame, ClassOutputStream out) {
580 out.write(frame.frame_type);
581 frame.accept(this, out);
582 }
583
584 public Void visit_same_frame(same_frame frame, ClassOutputStream p) {
585 return null;
586 }
587
588 public Void visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame frame, ClassOutputStream out) {
589 writeVerificationTypeInfo(frame.stack[0], out);
590 return null;
591 }
592
593 public Void visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended frame, ClassOutputStream out) {
594 out.writeShort(frame.offset_delta);
595 writeVerificationTypeInfo(frame.stack[0], out);
596 return null;
597 }
598
599 public Void visit_chop_frame(chop_frame frame, ClassOutputStream out) {
600 out.writeShort(frame.offset_delta);
601 return null;
602 }
603
604 public Void visit_same_frame_extended(same_frame_extended frame, ClassOutputStream out) {
605 out.writeShort(frame.offset_delta);
606 return null;
607 }
608
609 public Void visit_append_frame(append_frame frame, ClassOutputStream out) {
610 out.writeShort(frame.offset_delta);
611 for (verification_type_info l: frame.locals)
612 writeVerificationTypeInfo(l, out);
613 return null;
614 }
615
616 public Void visit_full_frame(full_frame frame, ClassOutputStream out) {
617 out.writeShort(frame.offset_delta);
618 out.writeShort(frame.locals.length);
619 for (verification_type_info l: frame.locals)
620 writeVerificationTypeInfo(l, out);
621 out.writeShort(frame.stack.length);
622 for (verification_type_info s: frame.stack)
623 writeVerificationTypeInfo(s, out);
624 return null;
625 }
626
627 protected void writeVerificationTypeInfo(verification_type_info info,
628 ClassOutputStream out) {
629 out.write(info.tag);
630 switch (info.tag) {
631 case ITEM_Top:
632 case ITEM_Integer:
633 case ITEM_Float:
634 case ITEM_Long:
635 case ITEM_Double:
636 case ITEM_Null:
637 case ITEM_UninitializedThis:
638 break;
639
640 case ITEM_Object:
641 Object_variable_info o = (Object_variable_info) info;
642 out.writeShort(o.cpool_index);
643 break;
644
645 case ITEM_Uninitialized:
646 Uninitialized_variable_info u = (Uninitialized_variable_info) info;
647 out.writeShort(u.offset);
648 break;
649
650 default:
651 throw new Error();
652 }
653 }
654 }
655
656 /**
657 * Writer for annotations and the values they contain.
658 */
659 protected static class AnnotationWriter
660 implements Annotation.element_value.Visitor<Void,ClassOutputStream> {
661 public void write(Annotation[] annos, ClassOutputStream out) {
662 out.writeShort(annos.length);
663 for (Annotation anno: annos)
664 write(anno, out);
665 }
666
667 public void write(TypeAnnotation[] annos, ClassOutputStream out) {
668 out.writeShort(annos.length);
669 for (TypeAnnotation anno: annos)
670 write(anno, out);
671 }
672
673 public void write(Annotation anno, ClassOutputStream out) {
674 out.writeShort(anno.type_index);
675 out.writeShort(anno.element_value_pairs.length);
676 for (element_value_pair p: anno.element_value_pairs)
677 write(p, out);
678 }
679
680 public void write(TypeAnnotation anno, ClassOutputStream out) {
681 write(anno.position, out);
682 write(anno.annotation, out);
683 }
684
685 public void write(element_value_pair pair, ClassOutputStream out) {
686 out.writeShort(pair.element_name_index);
687 write(pair.value, out);
688 }
689
690 public void write(element_value ev, ClassOutputStream out) {
691 out.writeByte(ev.tag);
692 ev.accept(this, out);
693 }
694
695 public Void visitPrimitive(Primitive_element_value ev, ClassOutputStream out) {
696 out.writeShort(ev.const_value_index);
697 return null;
698 }
699
700 public Void visitEnum(Enum_element_value ev, ClassOutputStream out) {
701 out.writeShort(ev.type_name_index);
702 out.writeShort(ev.const_name_index);
703 return null;
704 }
705
706 public Void visitClass(Class_element_value ev, ClassOutputStream out) {
707 out.writeShort(ev.class_info_index);
708 return null;
709 }
710
711 public Void visitAnnotation(Annotation_element_value ev, ClassOutputStream out) {
712 write(ev.annotation_value, out);
713 return null;
714 }
715
716 public Void visitArray(Array_element_value ev, ClassOutputStream out) {
717 out.writeShort(ev.num_values);
718 for (element_value v: ev.values)
719 write(v, out);
720 return null;
721 }
722
723 // TODO: Move this to TypeAnnotation to be closer with similar logic?
724 private void write(TypeAnnotation.Position p, ClassOutputStream out) {
725 out.writeByte(p.type.targetTypeValue());
726 switch (p.type) {
727 // instanceof
728 case INSTANCEOF:
729 // new expression
730 case NEW:
731 // constructor/method reference receiver
732 case CONSTRUCTOR_REFERENCE:
733 case METHOD_REFERENCE:
734 out.writeShort(p.offset);
735 break;
736 // local variable
737 case LOCAL_VARIABLE:
738 // resource variable
739 case RESOURCE_VARIABLE:
740 int table_length = p.lvarOffset.length;
741 out.writeShort(table_length);
742 for (int i = 0; i < table_length; ++i) {
743 out.writeShort(1); // for table length
744 out.writeShort(p.lvarOffset[i]);
745 out.writeShort(p.lvarLength[i]);
746 out.writeShort(p.lvarIndex[i]);
747 }
748 break;
749 // exception parameter
750 case EXCEPTION_PARAMETER:
751 out.writeShort(p.exception_index);
752 break;
753 // method receiver
754 case METHOD_RECEIVER:
755 // Do nothing
756 break;
757 // type parameters
758 case CLASS_TYPE_PARAMETER:
759 case METHOD_TYPE_PARAMETER:
760 out.writeByte(p.parameter_index);
761 break;
762 // type parameters bounds
763 case CLASS_TYPE_PARAMETER_BOUND:
764 case METHOD_TYPE_PARAMETER_BOUND:
765 out.writeByte(p.parameter_index);
766 out.writeByte(p.bound_index);
767 break;
768 // class extends or implements clause
769 case CLASS_EXTENDS:
770 out.writeShort(p.type_index);
771 break;
772 // throws
773 case THROWS:
774 out.writeShort(p.type_index);
775 break;
776 // method parameter
777 case METHOD_FORMAL_PARAMETER:
778 out.writeByte(p.parameter_index);
779 break;
780 // type cast
781 case CAST:
782 // method/constructor/reference type argument
783 case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
784 case METHOD_INVOCATION_TYPE_ARGUMENT:
785 case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
786 case METHOD_REFERENCE_TYPE_ARGUMENT:
787 out.writeShort(p.offset);
788 out.writeByte(p.type_index);
789 break;
790 // We don't need to worry about these
791 case METHOD_RETURN:
792 case FIELD:
793 break;
794 case UNKNOWN:
795 throw new AssertionError("ClassWriter: UNKNOWN target type should never occur!");
796 default:
797 throw new AssertionError("ClassWriter: Unknown target type for position: " + p);
798 }
799
800 { // Append location data for generics/arrays.
801 // TODO: check for overrun?
802 out.writeByte((byte)p.location.size());
803 for (int i : TypeAnnotation.Position.getBinaryFromTypePath(p.location))
804 out.writeByte((byte)i);
805 }
806 }
807 }
808 }