1 /*
   2  * Copyright (c) 2008, 2020, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 
  27 package com.sun.tools.classfile;
  28 
  29 import java.io.ByteArrayOutputStream;
  30 import java.io.DataOutputStream;
  31 import java.io.File;
  32 import java.io.FileOutputStream;
  33 import java.io.IOException;
  34 import java.io.OutputStream;
  35 
  36 import static com.sun.tools.classfile.Annotation.*;
  37 import static com.sun.tools.classfile.ConstantPool.*;
  38 import static com.sun.tools.classfile.StackMapTable_attribute.*;
  39 import static com.sun.tools.classfile.StackMapTable_attribute.verification_type_info.*;
  40 
  41 /**
  42  * Write a ClassFile data structure to a file or stream.
  43  *
  44  *  <p><b>This is NOT part of any supported API.
  45  *  If you write code that depends on this, you do so at your own risk.
  46  *  This code and its internal interfaces are subject to change or
  47  *  deletion without notice.</b>
  48  */
  49 public class ClassWriter {
  50     public ClassWriter() {
  51         attributeWriter = new AttributeWriter();
  52         constantPoolWriter = new ConstantPoolWriter();
  53         out = new ClassOutputStream();
  54     }
  55 
  56     /**
  57      * Write a ClassFile data structure to a file.
  58      * @param classFile the classfile object to be written
  59      * @param f the file
  60      * @throws IOException if an error occurs while writing the file
  61      */
  62     public void write(ClassFile classFile, File f) throws IOException {
  63         try (FileOutputStream f_out = new FileOutputStream(f)) {
  64             write(classFile, f_out);
  65         }
  66     }
  67 
  68     /**
  69      * Write a ClassFile data structure to a stream.
  70      * @param classFile the classfile object to be written
  71      * @param s the stream
  72      * @throws IOException if an error occurs while writing the file
  73      */
  74     public void write(ClassFile classFile, OutputStream s) throws IOException {
  75         this.classFile = classFile;
  76         out.reset();
  77         write();
  78         out.writeTo(s);
  79     }
  80 
  81     protected void write() throws IOException {
  82         writeHeader();
  83         writeConstantPool();
  84         writeAccessFlags(classFile.access_flags);
  85         writeClassInfo();
  86         writeFields();
  87         writeMethods();
  88         writeAttributes(classFile.attributes);
  89     }
  90 
  91     protected void writeHeader() {
  92         out.writeInt(classFile.magic);
  93         out.writeShort(classFile.minor_version);
  94         out.writeShort(classFile.major_version);
  95     }
  96 
  97     protected void writeAccessFlags(AccessFlags flags) {
  98         out.writeShort(flags.flags);
  99     }
 100 
 101     protected void writeAttributes(Attributes attributes) {
 102         int size = attributes.size();
 103         out.writeShort(size);
 104         for (Attribute attr: attributes)
 105             attributeWriter.write(attr, out);
 106     }
 107 
 108     protected void writeClassInfo() {
 109         out.writeShort(classFile.this_class);
 110         out.writeShort(classFile.super_class);
 111         int[] interfaces = classFile.interfaces;
 112         out.writeShort(interfaces.length);
 113         for (int i: interfaces)
 114             out.writeShort(i);
 115     }
 116 
 117     protected void writeDescriptor(Descriptor d) {
 118         out.writeShort(d.index);
 119     }
 120 
 121     protected void writeConstantPool() {
 122         ConstantPool pool = classFile.constant_pool;
 123         int size = pool.size();
 124         out.writeShort(size);
 125         for (CPInfo cpInfo: pool.entries())
 126             constantPoolWriter.write(cpInfo, out);
 127     }
 128 
 129     protected void writeFields() throws IOException {
 130         Field[] fields = classFile.fields;
 131         out.writeShort(fields.length);
 132         for (Field f: fields)
 133             writeField(f);
 134     }
 135 
 136     protected void writeField(Field f) throws IOException {
 137         writeAccessFlags(f.access_flags);
 138         out.writeShort(f.name_index);
 139         writeDescriptor(f.descriptor);
 140         writeAttributes(f.attributes);
 141     }
 142 
 143     protected void writeMethods() throws IOException {
 144         Method[] methods = classFile.methods;
 145         out.writeShort(methods.length);
 146         for (Method m: methods) {
 147             writeMethod(m);
 148         }
 149     }
 150 
 151     protected void writeMethod(Method m) throws IOException {
 152         writeAccessFlags(m.access_flags);
 153         out.writeShort(m.name_index);
 154         writeDescriptor(m.descriptor);
 155         writeAttributes(m.attributes);
 156     }
 157 
 158     protected ClassFile classFile;
 159     protected ClassOutputStream out;
 160     protected AttributeWriter attributeWriter;
 161     protected ConstantPoolWriter constantPoolWriter;
 162 
 163     /**
 164      * Subtype of ByteArrayOutputStream with the convenience methods of
 165      * a DataOutputStream. Since ByteArrayOutputStream does not throw
 166      * IOException, there are no exceptions from the additional
 167      * convenience methods either,
 168      */
 169     protected static class ClassOutputStream extends ByteArrayOutputStream {
 170         public ClassOutputStream() {
 171             d = new DataOutputStream(this);
 172         }
 173 
 174         public void writeByte(int value) {
 175             try {
 176                 d.writeByte(value);
 177             } catch (IOException ignore) {
 178             }
 179         }
 180 
 181         public void writeShort(int value) {
 182             try {
 183                 d.writeShort(value);
 184             } catch (IOException ignore) {
 185             }
 186         }
 187 
 188         public void writeInt(int value) {
 189             try {
 190                 d.writeInt(value);
 191             } catch (IOException ignore) {
 192             }
 193         }
 194 
 195         public void writeLong(long value) {
 196             try {
 197                 d.writeLong(value);
 198             } catch (IOException ignore) {
 199             }
 200         }
 201 
 202         public void writeFloat(float value) {
 203             try {
 204                 d.writeFloat(value);
 205             } catch (IOException ignore) {
 206             }
 207         }
 208 
 209         public void writeDouble(double value) {
 210             try {
 211                 d.writeDouble(value);
 212             } catch (IOException ignore) {
 213             }
 214         }
 215 
 216         public void writeUTF(String value) {
 217             try {
 218                 d.writeUTF(value);
 219             } catch (IOException ignore) {
 220             }
 221         }
 222 
 223         public void writeTo(ClassOutputStream s) {
 224             try {
 225                 super.writeTo(s);
 226             } catch (IOException ignore) {
 227             }
 228         }
 229 
 230         private final DataOutputStream d;
 231     }
 232 
 233     /**
 234      * Writer for the entries in the constant pool.
 235      */
 236     protected static class ConstantPoolWriter
 237            implements ConstantPool.Visitor<Integer,ClassOutputStream> {
 238         protected int write(CPInfo info, ClassOutputStream out) {
 239             out.writeByte(info.getTag());
 240             return info.accept(this, out);
 241         }
 242 
 243         @Override
 244         public Integer visitClass(CONSTANT_Class_info info, ClassOutputStream out) {
 245             out.writeShort(info.name_index);
 246             return 1;
 247         }
 248 
 249         @Override
 250         public Integer visitDouble(CONSTANT_Double_info info, ClassOutputStream out) {
 251             out.writeDouble(info.value);
 252             return 2;
 253         }
 254 
 255         @Override
 256         public Integer visitFieldref(CONSTANT_Fieldref_info info, ClassOutputStream out) {
 257             writeRef(info, out);
 258             return 1;
 259         }
 260 
 261         @Override
 262         public Integer visitFloat(CONSTANT_Float_info info, ClassOutputStream out) {
 263             out.writeFloat(info.value);
 264             return 1;
 265         }
 266 
 267         @Override
 268         public Integer visitInteger(CONSTANT_Integer_info info, ClassOutputStream out) {
 269             out.writeInt(info.value);
 270             return 1;
 271         }
 272 
 273         @Override
 274         public Integer visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, ClassOutputStream out) {
 275             writeRef(info, out);
 276             return 1;
 277         }
 278 
 279         @Override
 280         public Integer visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, ClassOutputStream out) {
 281             out.writeShort(info.bootstrap_method_attr_index);
 282             out.writeShort(info.name_and_type_index);
 283             return 1;
 284         }
 285 
 286         public Integer visitDynamicConstant(CONSTANT_Dynamic_info info, ClassOutputStream out) {
 287             out.writeShort(info.bootstrap_method_attr_index);
 288             out.writeShort(info.name_and_type_index);
 289             return 1;
 290         }
 291 
 292         @Override
 293         public Integer visitLong(CONSTANT_Long_info info, ClassOutputStream out) {
 294             out.writeLong(info.value);
 295             return 2;
 296         }
 297 
 298         @Override
 299         public Integer visitMethodHandle(CONSTANT_MethodHandle_info info, ClassOutputStream out) {
 300             out.writeByte(info.reference_kind.tag);
 301             out.writeShort(info.reference_index);
 302             return 1;
 303         }
 304 
 305         @Override
 306         public Integer visitMethodType(CONSTANT_MethodType_info info, ClassOutputStream out) {
 307             out.writeShort(info.descriptor_index);
 308             return 1;
 309         }
 310 
 311         @Override
 312         public Integer visitMethodref(CONSTANT_Methodref_info info, ClassOutputStream out) {
 313             return writeRef(info, out);
 314         }
 315 
 316         @Override
 317         public Integer visitModule(CONSTANT_Module_info info, ClassOutputStream out) {
 318             out.writeShort(info.name_index);
 319             return 1;
 320         }
 321 
 322         @Override
 323         public Integer visitNameAndType(CONSTANT_NameAndType_info info, ClassOutputStream out) {
 324             out.writeShort(info.name_index);
 325             out.writeShort(info.type_index);
 326             return 1;
 327         }
 328 
 329         @Override
 330         public Integer visitPackage(CONSTANT_Package_info info, ClassOutputStream out) {
 331             out.writeShort(info.name_index);
 332             return 1;
 333         }
 334 
 335         @Override
 336         public Integer visitString(CONSTANT_String_info info, ClassOutputStream out) {
 337             out.writeShort(info.string_index);
 338             return 1;
 339         }
 340 
 341         @Override
 342         public Integer visitUtf8(CONSTANT_Utf8_info info, ClassOutputStream out) {
 343             out.writeUTF(info.value);
 344             return 1;
 345         }
 346 
 347         protected Integer writeRef(CPRefInfo info, ClassOutputStream out) {
 348             out.writeShort(info.class_index);
 349             out.writeShort(info.name_and_type_index);
 350             return 1;
 351         }
 352     }
 353 
 354     /**
 355      * Writer for the different types of attribute.
 356      */
 357     protected static class AttributeWriter implements Attribute.Visitor<Void,ClassOutputStream> {
 358         public void write(Attributes attributes, ClassOutputStream out) {
 359             int size = attributes.size();
 360             out.writeShort(size);
 361             for (Attribute a: attributes)
 362                 write(a, out);
 363         }
 364 
 365         public void write(Attribute attr, ClassOutputStream out) {
 366             out.writeShort(attr.attribute_name_index);
 367             ClassOutputStream nestedOut = new ClassOutputStream();
 368             attr.accept(this, nestedOut);
 369             out.writeInt(nestedOut.size());
 370             nestedOut.writeTo(out);
 371         }
 372 
 373         protected AnnotationWriter annotationWriter = new AnnotationWriter();
 374 
 375         @Override
 376         public Void visitDefault(DefaultAttribute attr, ClassOutputStream out) {
 377             out.write(attr.info, 0, attr.info.length);
 378             return null;
 379         }
 380 
 381         @Override
 382         public Void visitAnnotationDefault(AnnotationDefault_attribute attr, ClassOutputStream out) {
 383             annotationWriter.write(attr.default_value, out);
 384             return null;
 385         }
 386 
 387         @Override
 388         public Void visitBootstrapMethods(BootstrapMethods_attribute attr, ClassOutputStream out) {
 389             out.writeShort(attr.bootstrap_method_specifiers.length);
 390             for (BootstrapMethods_attribute.BootstrapMethodSpecifier bsm : attr.bootstrap_method_specifiers) {
 391                 out.writeShort(bsm.bootstrap_method_ref);
 392                 int bsm_args_count = bsm.bootstrap_arguments.length;
 393                 out.writeShort(bsm_args_count);
 394                 for (int i : bsm.bootstrap_arguments) {
 395                     out.writeShort(i);
 396                 }
 397             }
 398             return null;
 399         }
 400 
 401         @Override
 402         public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr, ClassOutputStream out) {
 403             out.writeShort(attr.character_range_table.length);
 404             for (CharacterRangeTable_attribute.Entry e: attr.character_range_table)
 405                 writeCharacterRangeTableEntry(e, out);
 406             return null;
 407         }
 408 
 409         protected void writeCharacterRangeTableEntry(CharacterRangeTable_attribute.Entry entry, ClassOutputStream out) {
 410             out.writeShort(entry.start_pc);
 411             out.writeShort(entry.end_pc);
 412             out.writeInt(entry.character_range_start);
 413             out.writeInt(entry.character_range_end);
 414             out.writeShort(entry.flags);
 415         }
 416 
 417         @Override
 418         public Void visitCode(Code_attribute attr, ClassOutputStream out) {
 419             out.writeShort(attr.max_stack);
 420             out.writeShort(attr.max_locals);
 421             out.writeInt(attr.code.length);
 422             out.write(attr.code, 0, attr.code.length);
 423             out.writeShort(attr.exception_table.length);
 424             for (Code_attribute.Exception_data e: attr.exception_table)
 425                 writeExceptionTableEntry(e, out);
 426             new AttributeWriter().write(attr.attributes, out);
 427             return null;
 428         }
 429 
 430         protected void writeExceptionTableEntry(Code_attribute.Exception_data exception_data, ClassOutputStream out) {
 431             out.writeShort(exception_data.start_pc);
 432             out.writeShort(exception_data.end_pc);
 433             out.writeShort(exception_data.handler_pc);
 434             out.writeShort(exception_data.catch_type);
 435         }
 436 
 437         @Override
 438         public Void visitCompilationID(CompilationID_attribute attr, ClassOutputStream out) {
 439             out.writeShort(attr.compilationID_index);
 440             return null;
 441         }
 442 
 443         @Override
 444         public Void visitConstantValue(ConstantValue_attribute attr, ClassOutputStream out) {
 445             out.writeShort(attr.constantvalue_index);
 446             return null;
 447         }
 448 
 449         @Override
 450         public Void visitDeprecated(Deprecated_attribute attr, ClassOutputStream out) {
 451             return null;
 452         }
 453 
 454         @Override
 455         public Void visitEnclosingMethod(EnclosingMethod_attribute attr, ClassOutputStream out) {
 456             out.writeShort(attr.class_index);
 457             out.writeShort(attr.method_index);
 458             return null;
 459         }
 460 
 461         @Override
 462         public Void visitExceptions(Exceptions_attribute attr, ClassOutputStream out) {
 463             out.writeShort(attr.exception_index_table.length);
 464             for (int i: attr.exception_index_table)
 465                 out.writeShort(i);
 466             return null;
 467         }
 468 
 469         @Override
 470         public Void visitInnerClasses(InnerClasses_attribute attr, ClassOutputStream out) {
 471             out.writeShort(attr.classes.length);
 472             for (InnerClasses_attribute.Info info: attr.classes)
 473                 writeInnerClassesInfo(info, out);
 474             return null;
 475         }
 476 






 477         protected void writeInnerClassesInfo(InnerClasses_attribute.Info info, ClassOutputStream out) {
 478             out.writeShort(info.inner_class_info_index);
 479             out.writeShort(info.outer_class_info_index);
 480             out.writeShort(info.inner_name_index);
 481             writeAccessFlags(info.inner_class_access_flags, out);
 482         }
 483 
 484         @Override
 485         public Void visitLineNumberTable(LineNumberTable_attribute attr, ClassOutputStream out) {
 486             out.writeShort(attr.line_number_table.length);
 487             for (LineNumberTable_attribute.Entry e: attr.line_number_table)
 488                 writeLineNumberTableEntry(e, out);
 489             return null;
 490         }
 491 
 492         protected void writeLineNumberTableEntry(LineNumberTable_attribute.Entry entry, ClassOutputStream out) {
 493             out.writeShort(entry.start_pc);
 494             out.writeShort(entry.line_number);
 495         }
 496 
 497         @Override
 498         public Void visitLocalVariableTable(LocalVariableTable_attribute attr, ClassOutputStream out) {
 499             out.writeShort(attr.local_variable_table.length);
 500             for (LocalVariableTable_attribute.Entry e: attr.local_variable_table)
 501                 writeLocalVariableTableEntry(e, out);
 502             return null;
 503         }
 504 
 505         protected void writeLocalVariableTableEntry(LocalVariableTable_attribute.Entry entry, ClassOutputStream out) {
 506             out.writeShort(entry.start_pc);
 507             out.writeShort(entry.length);
 508             out.writeShort(entry.name_index);
 509             out.writeShort(entry.descriptor_index);
 510             out.writeShort(entry.index);
 511         }
 512 
 513         @Override
 514         public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr, ClassOutputStream out) {
 515             out.writeShort(attr.local_variable_table.length);
 516             for (LocalVariableTypeTable_attribute.Entry e: attr.local_variable_table)
 517                 writeLocalVariableTypeTableEntry(e, out);
 518             return null;
 519         }
 520 
 521         protected void writeLocalVariableTypeTableEntry(LocalVariableTypeTable_attribute.Entry entry, ClassOutputStream out) {
 522             out.writeShort(entry.start_pc);
 523             out.writeShort(entry.length);
 524             out.writeShort(entry.name_index);
 525             out.writeShort(entry.signature_index);
 526             out.writeShort(entry.index);
 527         }
 528 
 529         @Override
 530         public Void visitNestHost(NestHost_attribute attr, ClassOutputStream out) {
 531             out.writeShort(attr.top_index);
 532             return null;
 533         }
 534 
 535         @Override
 536         public Void visitMethodParameters(MethodParameters_attribute attr, ClassOutputStream out) {
 537             out.writeByte(attr.method_parameter_table.length);
 538             for (MethodParameters_attribute.Entry e : attr.method_parameter_table) {
 539                 out.writeShort(e.name_index);
 540                 out.writeShort(e.flags);
 541             }
 542             return null;
 543         }
 544 
 545         @Override
 546         public Void visitModule(Module_attribute attr, ClassOutputStream out) {
 547             out.writeShort(attr.module_name);
 548             out.writeShort(attr.module_flags);
 549             out.writeShort(attr.module_version_index);
 550 
 551             out.writeShort(attr.requires.length);
 552             for (Module_attribute.RequiresEntry e: attr.requires) {
 553                 out.writeShort(e.requires_index);
 554                 out.writeShort(e.requires_flags);
 555                 out.writeShort(e.requires_version_index);
 556             }
 557 
 558             out.writeShort(attr.exports.length);
 559             for (Module_attribute.ExportsEntry e: attr.exports) {
 560                 out.writeShort(e.exports_index);
 561                 out.writeShort(e.exports_flags);
 562                 out.writeShort(e.exports_to_index.length);
 563                 for (int index: e.exports_to_index)
 564                     out.writeShort(index);
 565             }
 566 
 567             out.writeShort(attr.opens.length);
 568             for (Module_attribute.OpensEntry e: attr.opens) {
 569                 out.writeShort(e.opens_index);
 570                 out.writeShort(e.opens_flags);
 571                 out.writeShort(e.opens_to_index.length);
 572                 for (int index: e.opens_to_index)
 573                     out.writeShort(index);
 574             }
 575 
 576             out.writeShort(attr.uses_index.length);
 577             for (int index: attr.uses_index) {
 578                 out.writeShort(index);
 579             }
 580 
 581             out.writeShort(attr.provides.length);
 582             for (Module_attribute.ProvidesEntry e: attr.provides) {
 583                 out.writeShort(e.provides_index);
 584                 out.writeShort(e.with_count);
 585                 for (int with : e.with_index) {
 586                     out.writeShort(with);
 587                 }
 588             }
 589 
 590             return null;
 591         }
 592 
 593         @Override
 594         public Void visitModuleHashes(ModuleHashes_attribute attr, ClassOutputStream out) {
 595             out.writeShort(attr.algorithm_index);
 596             out.writeShort(attr.hashes_table.length);
 597             for (ModuleHashes_attribute.Entry e: attr.hashes_table) {
 598                 out.writeShort(e.module_name_index);
 599                 out.writeShort(e.hash.length);
 600                 for (byte b: e.hash) {
 601                     out.writeByte(b);
 602                 }
 603             }
 604             return null;
 605         }
 606 
 607         @Override
 608         public Void visitModuleMainClass(ModuleMainClass_attribute attr, ClassOutputStream out) {
 609             out.writeShort(attr.main_class_index);
 610             return null;
 611         }
 612 
 613         @Override
 614         public Void visitModulePackages(ModulePackages_attribute attr, ClassOutputStream out) {
 615             out.writeShort(attr.packages_count);
 616             for (int i: attr.packages_index)
 617                 out.writeShort(i);
 618             return null;
 619         }
 620 
 621         @Override
 622         public Void visitModuleResolution(ModuleResolution_attribute attr, ClassOutputStream out) {
 623             out.writeShort(attr.resolution_flags);
 624             return null;
 625         }
 626 
 627         @Override
 628         public Void visitModuleTarget(ModuleTarget_attribute attr, ClassOutputStream out) {
 629             out.writeShort(attr.target_platform_index);
 630             return null;
 631         }
 632 
 633         @Override
 634         public Void visitNestMembers(NestMembers_attribute attr, ClassOutputStream out) {
 635             out.writeShort(attr.members_indexes.length);
 636             for (int i : attr.members_indexes) {
 637                 out.writeShort(i);
 638             }
 639             return null;
 640         }
 641 
 642         @Override
 643         public Void visitRecord(Record_attribute attr, ClassOutputStream out) {
 644             out.writeShort(attr.component_count);
 645             for (Record_attribute.ComponentInfo info: attr.component_info_arr) {
 646                 out.writeShort(info.name_index);
 647                 out.writeShort(info.descriptor.index);
 648                 int size = info.attributes.size();
 649                 out.writeShort(size);
 650                 for (Attribute componentAttr: info.attributes)
 651                     write(componentAttr, out);
 652             }
 653             return null;
 654         }
 655 
 656         @Override
 657         public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr, ClassOutputStream out) {
 658             annotationWriter.write(attr.annotations, out);
 659             return null;
 660         }
 661 
 662         @Override
 663         public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
 664             out.writeByte(attr.parameter_annotations.length);
 665             for (Annotation[] annos: attr.parameter_annotations)
 666                 annotationWriter.write(annos, out);
 667             return null;
 668         }
 669 
 670         @Override
 671         public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
 672             annotationWriter.write(attr.annotations, out);
 673             return null;
 674         }
 675 
 676         @Override
 677         public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr, ClassOutputStream out) {
 678             annotationWriter.write(attr.annotations, out);
 679             return null;
 680         }
 681 
 682         @Override
 683         public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr, ClassOutputStream out) {
 684             out.writeByte(attr.parameter_annotations.length);
 685             for (Annotation[] annos: attr.parameter_annotations)
 686                 annotationWriter.write(annos, out);
 687             return null;
 688         }
 689 
 690         @Override
 691         public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr, ClassOutputStream out) {
 692             annotationWriter.write(attr.annotations, out);
 693             return null;
 694         }
 695 
 696         @Override
 697         public Void visitPermittedSubclasses(PermittedSubclasses_attribute attr, ClassOutputStream out) {
 698             int n = attr.subtypes.length;
 699             out.writeShort(n);
 700             for (int i = 0 ; i < n ; i++) {
 701                 out.writeShort(attr.subtypes[i]);
 702             }
 703             return null;
 704         }
 705 
 706         @Override
 707         public Void visitSignature(Signature_attribute attr, ClassOutputStream out) {
 708             out.writeShort(attr.signature_index);
 709             return null;
 710         }
 711 
 712         @Override
 713         public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr, ClassOutputStream out) {
 714             out.write(attr.debug_extension, 0, attr.debug_extension.length);
 715             return null;
 716         }
 717 
 718         @Override
 719         public Void visitSourceFile(SourceFile_attribute attr, ClassOutputStream out) {
 720             out.writeShort(attr.sourcefile_index);
 721             return null;
 722         }
 723 
 724         @Override
 725         public Void visitSourceID(SourceID_attribute attr, ClassOutputStream out) {
 726             out.writeShort(attr.sourceID_index);
 727             return null;
 728         }
 729 
 730         @Override
 731         public Void visitStackMap(StackMap_attribute attr, ClassOutputStream out) {
 732             if (stackMapWriter == null)
 733                 stackMapWriter = new StackMapTableWriter();
 734 
 735             out.writeShort(attr.entries.length);
 736             for (stack_map_frame f: attr.entries)
 737                 stackMapWriter.write(f, out);
 738             return null;
 739         }
 740 
 741         @Override
 742         public Void visitStackMapTable(StackMapTable_attribute attr, ClassOutputStream out) {
 743             if (stackMapWriter == null)
 744                 stackMapWriter = new StackMapTableWriter();
 745 
 746             out.writeShort(attr.entries.length);
 747             for (stack_map_frame f: attr.entries)
 748                 stackMapWriter.write(f, out);
 749             return null;
 750         }
 751 
 752         @Override
 753         public Void visitSynthetic(Synthetic_attribute attr, ClassOutputStream out) {
 754             return null;
 755         }
 756 
 757         protected void writeAccessFlags(AccessFlags flags, ClassOutputStream out) {
 758             out.writeShort(flags.flags);
 759         }
 760 
 761         protected StackMapTableWriter stackMapWriter;
 762     }
 763 
 764     /**
 765      * Writer for the frames of StackMap and StackMapTable attributes.
 766      */
 767     protected static class StackMapTableWriter
 768             implements stack_map_frame.Visitor<Void,ClassOutputStream> {
 769 
 770         public void write(stack_map_frame frame, ClassOutputStream out) {
 771             out.write(frame.frame_type);
 772             frame.accept(this, out);
 773         }
 774 
 775         @Override
 776         public Void visit_same_frame(same_frame frame, ClassOutputStream p) {
 777             return null;
 778         }
 779 
 780         @Override
 781         public Void visit_same_locals_1_stack_item_frame(same_locals_1_stack_item_frame frame, ClassOutputStream out) {
 782             writeVerificationTypeInfo(frame.stack[0], out);
 783             return null;
 784         }
 785 
 786         @Override
 787         public Void visit_same_locals_1_stack_item_frame_extended(same_locals_1_stack_item_frame_extended frame, ClassOutputStream out) {
 788             out.writeShort(frame.offset_delta);
 789             writeVerificationTypeInfo(frame.stack[0], out);
 790             return null;
 791         }
 792 
 793         @Override
 794         public Void visit_chop_frame(chop_frame frame, ClassOutputStream out) {
 795             out.writeShort(frame.offset_delta);
 796             return null;
 797         }
 798 
 799         @Override
 800         public Void visit_same_frame_extended(same_frame_extended frame, ClassOutputStream out) {
 801             out.writeShort(frame.offset_delta);
 802             return null;
 803         }
 804 
 805         @Override
 806         public Void visit_append_frame(append_frame frame, ClassOutputStream out) {
 807             out.writeShort(frame.offset_delta);
 808             for (verification_type_info l: frame.locals)
 809                 writeVerificationTypeInfo(l, out);
 810             return null;
 811         }
 812 
 813         @Override
 814         public Void visit_full_frame(full_frame frame, ClassOutputStream out) {
 815             out.writeShort(frame.offset_delta);
 816             out.writeShort(frame.locals.length);
 817             for (verification_type_info l: frame.locals)
 818                 writeVerificationTypeInfo(l, out);
 819             out.writeShort(frame.stack.length);
 820             for (verification_type_info s: frame.stack)
 821                 writeVerificationTypeInfo(s, out);
 822             return null;
 823         }
 824 
 825         protected void writeVerificationTypeInfo(verification_type_info info,
 826                 ClassOutputStream out)  {
 827             out.write(info.tag);
 828             switch (info.tag) {
 829             case ITEM_Top:
 830             case ITEM_Integer:
 831             case ITEM_Float:
 832             case ITEM_Long:
 833             case ITEM_Double:
 834             case ITEM_Null:
 835             case ITEM_UninitializedThis:
 836                 break;
 837 
 838             case ITEM_Object:
 839                 Object_variable_info o = (Object_variable_info) info;
 840                 out.writeShort(o.cpool_index);
 841                 break;
 842 
 843             case ITEM_Uninitialized:
 844                 Uninitialized_variable_info u = (Uninitialized_variable_info) info;
 845                 out.writeShort(u.offset);
 846                 break;
 847 
 848             default:
 849                 throw new Error();
 850             }
 851         }
 852     }
 853 
 854     /**
 855      * Writer for annotations and the values they contain.
 856      */
 857     protected static class AnnotationWriter
 858             implements Annotation.element_value.Visitor<Void,ClassOutputStream> {
 859         public void write(Annotation[] annos, ClassOutputStream out) {
 860             out.writeShort(annos.length);
 861             for (Annotation anno: annos)
 862                 write(anno, out);
 863         }
 864 
 865         public void write(TypeAnnotation[] annos, ClassOutputStream out) {
 866             out.writeShort(annos.length);
 867             for (TypeAnnotation anno: annos)
 868                 write(anno, out);
 869         }
 870 
 871         public void write(Annotation anno, ClassOutputStream out) {
 872             out.writeShort(anno.type_index);
 873             out.writeShort(anno.element_value_pairs.length);
 874             for (element_value_pair p: anno.element_value_pairs)
 875                 write(p, out);
 876         }
 877 
 878         public void write(TypeAnnotation anno, ClassOutputStream out) {
 879             write(anno.position, out);
 880             write(anno.annotation, out);
 881         }
 882 
 883         public void write(element_value_pair pair, ClassOutputStream out) {
 884             out.writeShort(pair.element_name_index);
 885             write(pair.value, out);
 886         }
 887 
 888         public void write(element_value ev, ClassOutputStream out) {
 889             out.writeByte(ev.tag);
 890             ev.accept(this, out);
 891         }
 892 
 893         @Override
 894         public Void visitPrimitive(Primitive_element_value ev, ClassOutputStream out) {
 895             out.writeShort(ev.const_value_index);
 896             return null;
 897         }
 898 
 899         @Override
 900         public Void visitEnum(Enum_element_value ev, ClassOutputStream out) {
 901             out.writeShort(ev.type_name_index);
 902             out.writeShort(ev.const_name_index);
 903             return null;
 904         }
 905 
 906         @Override
 907         public Void visitClass(Class_element_value ev, ClassOutputStream out) {
 908             out.writeShort(ev.class_info_index);
 909             return null;
 910         }
 911 
 912         @Override
 913         public Void visitAnnotation(Annotation_element_value ev, ClassOutputStream out) {
 914             write(ev.annotation_value, out);
 915             return null;
 916         }
 917 
 918         @Override
 919         public Void visitArray(Array_element_value ev, ClassOutputStream out) {
 920             out.writeShort(ev.num_values);
 921             for (element_value v: ev.values)
 922                 write(v, out);
 923             return null;
 924         }
 925 
 926         // TODO: Move this to TypeAnnotation to be closer with similar logic?
 927         private void write(TypeAnnotation.Position p, ClassOutputStream out) {
 928             out.writeByte(p.type.targetTypeValue());
 929             switch (p.type) {
 930             // instanceof
 931             case INSTANCEOF:
 932             // new expression
 933             case NEW:
 934             // constructor/method reference receiver
 935             case CONSTRUCTOR_REFERENCE:
 936             case METHOD_REFERENCE:
 937                 out.writeShort(p.offset);
 938                 break;
 939             // local variable
 940             case LOCAL_VARIABLE:
 941             // resource variable
 942             case RESOURCE_VARIABLE:
 943                 int table_length = p.lvarOffset.length;
 944                 out.writeShort(table_length);
 945                 for (int i = 0; i < table_length; ++i) {
 946                     out.writeShort(1);  // for table length
 947                     out.writeShort(p.lvarOffset[i]);
 948                     out.writeShort(p.lvarLength[i]);
 949                     out.writeShort(p.lvarIndex[i]);
 950                 }
 951                 break;
 952             // exception parameter
 953             case EXCEPTION_PARAMETER:
 954                 out.writeShort(p.exception_index);
 955                 break;
 956             // method receiver
 957             case METHOD_RECEIVER:
 958                 // Do nothing
 959                 break;
 960             // type parameters
 961             case CLASS_TYPE_PARAMETER:
 962             case METHOD_TYPE_PARAMETER:
 963                 out.writeByte(p.parameter_index);
 964                 break;
 965             // type parameters bounds
 966             case CLASS_TYPE_PARAMETER_BOUND:
 967             case METHOD_TYPE_PARAMETER_BOUND:
 968                 out.writeByte(p.parameter_index);
 969                 out.writeByte(p.bound_index);
 970                 break;
 971             // class extends or implements clause
 972             case CLASS_EXTENDS:
 973                 out.writeShort(p.type_index);
 974                 break;
 975             // throws
 976             case THROWS:
 977                 out.writeShort(p.type_index);
 978                 break;
 979             // method parameter
 980             case METHOD_FORMAL_PARAMETER:
 981                 out.writeByte(p.parameter_index);
 982                 break;
 983             // type cast
 984             case CAST:
 985             // method/constructor/reference type argument
 986             case CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
 987             case METHOD_INVOCATION_TYPE_ARGUMENT:
 988             case CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
 989             case METHOD_REFERENCE_TYPE_ARGUMENT:
 990                 out.writeShort(p.offset);
 991                 out.writeByte(p.type_index);
 992                 break;
 993             // We don't need to worry about these
 994             case METHOD_RETURN:
 995             case FIELD:
 996                 break;
 997             case UNKNOWN:
 998                 throw new AssertionError("ClassWriter: UNKNOWN target type should never occur!");
 999             default:
1000                 throw new AssertionError("ClassWriter: Unknown target type for position: " + p);
1001             }
1002 
1003             { // Append location data for generics/arrays.
1004                 // TODO: check for overrun?
1005                 out.writeByte((byte)p.location.size());
1006                 for (int i : TypeAnnotation.Position.getBinaryFromTypePath(p.location))
1007                     out.writeByte((byte)i);
1008             }
1009         }
1010     }
1011 }
--- EOF ---