1 /*

     2  * Copyright (c) 2008, 2016, 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 visitMethodParameters(MethodParameters_attribute attr, ClassOutputStream out) {

   527             out.writeByte(attr.method_parameter_table.length);

   528             for (MethodParameters_attribute.Entry e : attr.method_parameter_table) {

   529                 out.writeShort(e.name_index);

   530                 out.writeShort(e.flags);

   531             }

   532             return null;

   533         }

   534 

   535         @Override

   536         public Void visitModule(Module_attribute attr, ClassOutputStream out) {

   537             out.writeShort(attr.module_name);

   538             out.writeShort(attr.module_flags);

   539             out.writeShort(attr.module_version_index);

   540 

   541             out.writeShort(attr.requires.length);

   542             for (Module_attribute.RequiresEntry e: attr.requires) {

   543                 out.writeShort(e.requires_index);

   544                 out.writeShort(e.requires_flags);

   545                 out.writeShort(e.requires_version_index);

   546             }

   547 

   548             out.writeShort(attr.exports.length);

   549             for (Module_attribute.ExportsEntry e: attr.exports) {

   550                 out.writeShort(e.exports_index);

   551                 out.writeShort(e.exports_flags);

   552                 out.writeShort(e.exports_to_index.length);

   553                 for (int index: e.exports_to_index)

   554                     out.writeShort(index);

   555             }

   556 

   557             out.writeShort(attr.opens.length);

   558             for (Module_attribute.OpensEntry e: attr.opens) {

   559                 out.writeShort(e.opens_index);

   560                 out.writeShort(e.opens_flags);

   561                 out.writeShort(e.opens_to_index.length);

   562                 for (int index: e.opens_to_index)

   563                     out.writeShort(index);

   564             }

   565 

   566             out.writeShort(attr.uses_index.length);

   567             for (int index: attr.uses_index) {

   568                 out.writeShort(index);

   569             }

   570 

   571             out.writeShort(attr.provides.length);

   572             for (Module_attribute.ProvidesEntry e: attr.provides) {

   573                 out.writeShort(e.provides_index);

   574                 out.writeShort(e.with_count);

   575                 for (int with : e.with_index) {

   576                     out.writeShort(with);

   577                 }

   578             }

   579 

   580             return null;

   581         }

   582 

   583         @Override

   584         public Void visitModuleHashes(ModuleHashes_attribute attr, ClassOutputStream out) {

   585             out.writeShort(attr.algorithm_index);

   586             out.writeShort(attr.hashes_table.length);

   587             for (ModuleHashes_attribute.Entry e: attr.hashes_table) {

   588                 out.writeShort(e.module_name_index);

   589                 out.writeShort(e.hash.length);

   590                 for (byte b: e.hash) {

   591                     out.writeByte(b);

   592                 }

   593             }

   594             return null;

   595         }

   596 

   597         @Override

   598         public Void visitModuleMainClass(ModuleMainClass_attribute attr, ClassOutputStream out) {

   599             out.writeShort(attr.main_class_index);

   600             return null;

   601         }

   602 

   603         @Override

   604         public Void visitModulePackages(ModulePackages_attribute attr, ClassOutputStream out) {

   605             out.writeShort(attr.packages_count);

   606             for (int i: attr.packages_index)

   607                 out.writeShort(i);

   608             return null;

   609         }

   610 

   611         @Override

   612         public Void visitModuleResolution(ModuleResolution_attribute attr, ClassOutputStream out) {

   613             out.writeShort(attr.resolution_flags);

   614             return null;

   615         }

   616 

   617         @Override

   618         public Void visitModuleTarget(ModuleTarget_attribute attr, ClassOutputStream out) {

   619             out.writeShort(attr.target_platform_index);

   620             return null;

   621         }

   622 

   623         @Override

   624         public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, ClassOutputStream out) {

   625             annotationWriter.write(attr.annotations, out);

   626             return null;

   627         }

   628 

   629         @Override

   630         public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, ClassOutputStream out) {

   631             out.writeByte(attr.parameter_annotations.length);

   632             for (Annotation[] annos: attr.parameter_annotations)

   633                 annotationWriter.write(annos, out);

   634             return null;

   635         }

   636 

   637         @Override

   638         public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, ClassOutputStream out) {

   639             annotationWriter.write(attr.annotations, out);

   640             return null;

   641         }

   642 

   643         @Override

   644         public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {

   645             annotationWriter.write(attr.annotations, out);

   646             return null;

   647         }

   648 

   649         @Override

   650         public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {

   651             out.writeByte(attr.parameter_annotations.length);

   652             for (Annotation[] annos: attr.parameter_annotations)

   653                 annotationWriter.write(annos, out);

   654             return null;

   655         }

   656 

   657         @Override

   658         public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, ClassOutputStream out) {

   659             annotationWriter.write(attr.annotations, out);

   660             return null;

   661         }

   662 

   663         @Override

   664         public Void visitSignature(Signature_attribute attr, ClassOutputStream out) {

   665             out.writeShort(attr.signature_index);

   666             return null;

   667         }

   668 

   669         @Override

   670         public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, ClassOutputStream out) {

   671             out.write(attr.debug_extension, 0, attr.debug_extension.length);

   672             return null;

   673         }

   674 

   675         @Override

   676         public Void visitSourceFile(SourceFile_attribute attr, ClassOutputStream out) {

   677             out.writeShort(attr.sourcefile_index);

   678             return null;

   679         }

   680 

   681         @Override

   682         public Void visitSourceID(SourceID_attribute attr, ClassOutputStream out) {

   683             out.writeShort(attr.sourceID_index);

   684             return null;

   685         }

   686 

   687         @Override

   688         public Void visitStackMap(StackMap_attribute attr, ClassOutputStream out) {

   689             if (stackMapWriter == null)

   690                 stackMapWriter = new StackMapTableWriter();

   691 

   692             out.writeShort(attr.entries.length);

   693             for (stack_map_frame f: attr.entries)

   694                 stackMapWriter.write(f, out);

   695             return null;

   696         }

   697 

   698         @Override

   699         public Void visitStackMapTable(StackMapTable_attribute attr, ClassOutputStream out) {

   700             if (stackMapWriter == null)

   701                 stackMapWriter = new StackMapTableWriter();

   702 

   703             out.writeShort(attr.entries.length);

   704             for (stack_map_frame f: attr.entries)

   705                 stackMapWriter.write(f, out);

   706             return null;

   707         }

   708 

   709         @Override

   710         public Void visitSynthetic(Synthetic_attribute attr, ClassOutputStream out) {

   711             return null;

   712         }

   713 

   714         protected void writeAccessFlags(AccessFlags flags, ClassOutputStream p) {

   715             sharedOut.writeShort(flags.flags);

   716         }

   717 

   718         protected StackMapTableWriter stackMapWriter;

   719     }

   720 

   721     /**

   722      * Writer for the frames of StackMap and StackMapTable attributes.

   723      */

   724     protected static class StackMapTableWriter

   725             implements stack_map_frame.Visitor<Void,ClassOutputStream> {

   726 

   727         public void write(stack_map_frame frame, ClassOutputStream out) {

   728             out.write(frame.frame_type);

   729             frame.accept(this, out);

   730         }

   731 

   732         @Override

   733         public Void visit_same_frame(same_frame frame, ClassOutputStream p) {

   734             return null;

   735         }

   736 

   737         @Override

   738         public Void visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame frame, ClassOutputStream out) {

   739             writeVerificationTypeInfo(frame.stack[0], out);

   740             return null;

   741         }

   742 

   743         @Override

   744         public Void visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended frame, ClassOutputStream out) {

   745             out.writeShort(frame.offset_delta);

   746             writeVerificationTypeInfo(frame.stack[0], out);

   747             return null;

   748         }

   749 

   750         @Override

   751         public Void visit_chop_frame(chop_frame frame, ClassOutputStream out) {

   752             out.writeShort(frame.offset_delta);

   753             return null;

   754         }

   755 

   756         @Override

   757         public Void visit_same_frame_extended(same_frame_extended frame, ClassOutputStream out) {

   758             out.writeShort(frame.offset_delta);

   759             return null;

   760         }

   761 

   762         @Override

   763         public Void visit_append_frame(append_frame frame, ClassOutputStream out) {

   764             out.writeShort(frame.offset_delta);

   765             for (verification_type_info l: frame.locals)

   766                 writeVerificationTypeInfo(l, out);

   767             return null;

   768         }

   769 

   770         @Override

   771         public Void visit_full_frame(full_frame frame, ClassOutputStream out) {

   772             out.writeShort(frame.offset_delta);

   773             out.writeShort(frame.locals.length);

   774             for (verification_type_info l: frame.locals)

   775                 writeVerificationTypeInfo(l, out);

   776             out.writeShort(frame.stack.length);

   777             for (verification_type_info s: frame.stack)

   778                 writeVerificationTypeInfo(s, out);

   779             return null;

   780         }

   781 

   782         protected void writeVerificationTypeInfo(verification_type_info info,

   783                 ClassOutputStream out)  {

   784             out.write(info.tag);

   785             switch (info.tag) {

   786             case ITEM_Top:

   787             case ITEM_Integer:

   788             case ITEM_Float:

   789             case ITEM_Long:

   790             case ITEM_Double:

   791             case ITEM_Null:

   792             case ITEM_UninitializedThis:

   793                 break;

   794 

   795             case ITEM_Object:

   796                 Object_variable_info o = (Object_variable_info) info;

   797                 out.writeShort(o.cpool_index);

   798                 break;

   799 

   800             case ITEM_Uninitialized:

   801                 Uninitialized_variable_info u = (Uninitialized_variable_info) info;

   802                 out.writeShort(u.offset);

   803                 break;

   804 

   805             default:

   806                 throw new Error();

   807             }

   808         }

   809     }

   810 

   811     /**

   812      * Writer for annotations and the values they contain.

   813      */

   814     protected static class AnnotationWriter

   815             implements Annotation.element_value.Visitor<Void,ClassOutputStream> {

   816         public void write(Annotation[] annos, ClassOutputStream out) {

   817             out.writeShort(annos.length);

   818             for (Annotation anno: annos)

   819                 write(anno, out);

   820         }

   821 

   822         public void write(TypeAnnotation[] annos, ClassOutputStream out) {

   823             out.writeShort(annos.length);

   824             for (TypeAnnotation anno: annos)

   825                 write(anno, out);

   826         }

   827 

   828         public void write(Annotation anno, ClassOutputStream out) {

   829             out.writeShort(anno.type_index);

   830             out.writeShort(anno.element_value_pairs.length);

   831             for (element_value_pair p: anno.element_value_pairs)

   832                 write(p, out);

   833         }

   834 

   835         public void write(TypeAnnotation anno, ClassOutputStream out) {

   836             write(anno.position, out);

   837             write(anno.annotation, out);

   838         }

   839 

   840         public void write(element_value_pair pair, ClassOutputStream out) {

   841             out.writeShort(pair.element_name_index);

   842             write(pair.value, out);

   843         }

   844 

   845         public void write(element_value ev, ClassOutputStream out) {

   846             out.writeByte(ev.tag);

   847             ev.accept(this, out);

   848         }

   849 

   850         @Override

   851         public Void visitPrimitive(Primitive_element_value ev, ClassOutputStream out) {

   852             out.writeShort(ev.const_value_index);

   853             return null;

   854         }

   855 

   856         @Override

   857         public Void visitEnum(Enum_element_value ev, ClassOutputStream out) {

   858             out.writeShort(ev.type_name_index);

   859             out.writeShort(ev.const_name_index);

   860             return null;

   861         }

   862 

   863         @Override

   864         public Void visitClass(Class_element_value ev, ClassOutputStream out) {

   865             out.writeShort(ev.class_info_index);

   866             return null;

   867         }

   868 

   869         @Override

   870         public Void visitAnnotation(Annotation_element_value ev, ClassOutputStream out) {

   871             write(ev.annotation_value, out);

   872             return null;

   873         }

   874 

   875         @Override

   876         public Void visitArray(Array_element_value ev, ClassOutputStream out) {

   877             out.writeShort(ev.num_values);

   878             for (element_value v: ev.values)

   879                 write(v, out);

   880             return null;

   881         }

   882 

   883         // TODO: Move this to TypeAnnotation to be closer with similar logic?

   884         private void write(TypeAnnotation.Position p, ClassOutputStream out) {

   885             out.writeByte(p.type.targetTypeValue());

   886             switch (p.type) {

   887             // instanceof

   888             case INSTANCEOF:

   889             // new expression

   890             case NEW:

   891             // constructor/method reference receiver

   892             case CONSTRUCTOR_REFERENCE:

   893             case METHOD_REFERENCE:

   894                 out.writeShort(p.offset);

   895                 break;

   896             // local variable

   897             case LOCAL_VARIABLE:

   898             // resource variable

   899             case RESOURCE_VARIABLE:

   900                 int table_length = p.lvarOffset.length;

   901                 out.writeShort(table_length);

   902                 for (int i = 0; i < table_length; ++i) {

   903                     out.writeShort(1);  // for table length

   904                     out.writeShort(p.lvarOffset[i]);

   905                     out.writeShort(p.lvarLength[i]);

   906                     out.writeShort(p.lvarIndex[i]);

   907                 }

   908                 break;

   909             // exception parameter

   910             case EXCEPTION_PARAMETER:

   911                 out.writeShort(p.exception_index);

   912                 break;

   913             // method receiver

   914             case METHOD_RECEIVER:

   915                 // Do nothing

   916                 break;

   917             // type parameters

   918             case CLASS_TYPE_PARAMETER:

   919             case METHOD_TYPE_PARAMETER:

   920                 out.writeByte(p.parameter_index);

   921                 break;

   922             // type parameters bounds

   923             case CLASS_TYPE_PARAMETER_BOUND:

   924             case METHOD_TYPE_PARAMETER_BOUND:

   925                 out.writeByte(p.parameter_index);

   926                 out.writeByte(p.bound_index);

   927                 break;

   928             // class extends or implements clause

   929             case CLASS_EXTENDS:

   930                 out.writeShort(p.type_index);

   931                 break;

   932             // throws

   933             case THROWS:

   934                 out.writeShort(p.type_index);

   935                 break;

   936             // method parameter

   937             case METHOD_FORMAL_PARAMETER:

   938                 out.writeByte(p.parameter_index);

   939                 break;

   940             // type cast

   941             case CAST:

   942             // method/constructor/reference type argument

   943             case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:

   944             case METHOD_INVOCATION_TYPE_ARGUMENT:

   945             case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:

   946             case METHOD_REFERENCE_TYPE_ARGUMENT:

   947                 out.writeShort(p.offset);

   948                 out.writeByte(p.type_index);

   949                 break;

   950             // We don't need to worry about these

   951             case METHOD_RETURN:

   952             case FIELD:

   953                 break;

   954             case UNKNOWN:

   955                 throw new AssertionError("ClassWriter: UNKNOWN target type should never occur!");

   956             default:

   957                 throw new AssertionError("ClassWriter: Unknown target type for position: " + p);

   958             }

   959 

   960             { // Append location data for generics/arrays.

   961                 // TODO: check for overrun?

   962                 out.writeByte((byte)p.location.size());

   963                 for (int i : TypeAnnotation.Position.getBinaryFromTypePath(p.location))

   964                     out.writeByte((byte)i);

   965             }

   966         }

   967     }

   968 }