1 /*
   2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   3  *
   4  * This code is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU General Public License version 2 only, as
   6  * published by the Free Software Foundation.  Oracle designates this
   7  * particular file as subject to the "Classpath" exception as provided
   8  * by Oracle in the LICENSE file that accompanied this code.
   9  *
  10  * This code is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  13  * version 2 for more details (a copy is included in the LICENSE file that
  14  * accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License version
  17  * 2 along with this work; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  19  *
  20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  21  * or visit www.oracle.com if you need additional information or have any
  22  * questions.
  23  */
  24 
  25 /*
  26  * This file is available under and governed by the GNU General Public
  27  * License version 2 only, as published by the Free Software Foundation.
  28  * However, the following notice accompanied the original version of this
  29  * file:
  30  *
  31  * ASM: a very small and fast Java bytecode manipulation framework
  32  * Copyright (c) 2000-2011 INRIA, France Telecom
  33  * All rights reserved.
  34  *
  35  * Redistribution and use in source and binary forms, with or without
  36  * modification, are permitted provided that the following conditions
  37  * are met:
  38  * 1. Redistributions of source code must retain the above copyright
  39  *    notice, this list of conditions and the following disclaimer.
  40  * 2. Redistributions in binary form must reproduce the above copyright
  41  *    notice, this list of conditions and the following disclaimer in the
  42  *    documentation and/or other materials provided with the distribution.
  43  * 3. Neither the name of the copyright holders nor the names of its
  44  *    contributors may be used to endorse or promote products derived from
  45  *    this software without specific prior written permission.
  46  *
  47  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  48  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  49  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  50  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  51  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  52  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  53  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  54  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  55  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  56  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  57  * THE POSSIBILITY OF SUCH DAMAGE.
  58  */
  59 package jdk.internal.org.objectweb.asm;
  60 
  61 import java.io.IOException;
  62 import java.io.InputStream;
  63 
  64 /**
  65  * A Java class parser to make a {@link ClassVisitor} visit an existing class.
  66  * This class parses a byte array conforming to the Java class file format and
  67  * calls the appropriate visit methods of a given class visitor for each field,
  68  * method and bytecode instruction encountered.
  69  *
  70  * @author Eric Bruneton
  71  * @author Eugene Kuleshov
  72  */
  73 public class ClassReader {
  74 
  75     /**
  76      * Flag to skip method code. If this class is set <code>CODE</code>
  77      * attribute won't be visited. This can be used, for example, to retrieve
  78      * annotations for methods and method parameters.
  79      */
  80     public static final int SKIP_CODE = 1;
  81 
  82     /**
  83      * Flag to skip the debug information in the class. If this flag is set the
  84      * debug information of the class is not visited, i.e. the
  85      * {@link MethodVisitor#visitLocalVariable visitLocalVariable} and
  86      * {@link MethodVisitor#visitLineNumber visitLineNumber} methods will not be
  87      * called.
  88      */
  89     public static final int SKIP_DEBUG = 2;
  90 
  91     /**
  92      * Flag to skip the stack map frames in the class. If this flag is set the
  93      * stack map frames of the class is not visited, i.e. the
  94      * {@link MethodVisitor#visitFrame visitFrame} method will not be called.
  95      * This flag is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is
  96      * used: it avoids visiting frames that will be ignored and recomputed from
  97      * scratch in the class writer.
  98      */
  99     public static final int SKIP_FRAMES = 4;
 100 
 101     /**
 102      * Flag to expand the stack map frames. By default stack map frames are
 103      * visited in their original format (i.e. "expanded" for classes whose
 104      * version is less than V1_6, and "compressed" for the other classes). If
 105      * this flag is set, stack map frames are always visited in expanded format
 106      * (this option adds a decompression/recompression step in ClassReader and
 107      * ClassWriter which degrades performances quite a lot).
 108      */
 109     public static final int EXPAND_FRAMES = 8;
 110 
 111     /**
 112      * Flag to expand the ASM pseudo instructions into an equivalent sequence of
 113      * standard bytecode instructions. When resolving a forward jump it may
 114      * happen that the signed 2 bytes offset reserved for it is not sufficient
 115      * to store the bytecode offset. In this case the jump instruction is
 116      * replaced with a temporary ASM pseudo instruction using an unsigned 2
 117      * bytes offset (see Label#resolve). This internal flag is used to re-read
 118      * classes containing such instructions, in order to replace them with
 119      * standard instructions. In addition, when this flag is used, GOTO_W and
 120      * JSR_W are <i>not</i> converted into GOTO and JSR, to make sure that
 121      * infinite loops where a GOTO_W is replaced with a GOTO in ClassReader and
 122      * converted back to a GOTO_W in ClassWriter cannot occur.
 123      */
 124     static final int EXPAND_ASM_INSNS = 256;
 125 
 126     /**
 127      * The class to be parsed. <i>The content of this array must not be
 128      * modified. This field is intended for {@link Attribute} sub classes, and
 129      * is normally not needed by class generators or adapters.</i>
 130      */
 131     public final byte[] b;
 132 
 133     /**
 134      * The start index of each constant pool item in {@link #b b}, plus one. The
 135      * one byte offset skips the constant pool item tag that indicates its type.
 136      */
 137     private final int[] items;
 138 
 139     /**
 140      * The String objects corresponding to the CONSTANT_Utf8 items. This cache
 141      * avoids multiple parsing of a given CONSTANT_Utf8 constant pool item,
 142      * which GREATLY improves performances (by a factor 2 to 3). This caching
 143      * strategy could be extended to all constant pool items, but its benefit
 144      * would not be so great for these items (because they are much less
 145      * expensive to parse than CONSTANT_Utf8 items).
 146      */
 147     private final String[] strings;
 148 
 149     /**
 150      * Maximum length of the strings contained in the constant pool of the
 151      * class.
 152      */
 153     private final int maxStringLength;
 154 
 155     /**
 156      * Start index of the class header information (access, name...) in
 157      * {@link #b b}.
 158      */
 159     public final int header;
 160 
 161     // ------------------------------------------------------------------------
 162     // Constructors
 163     // ------------------------------------------------------------------------
 164 
 165     /**
 166      * Constructs a new {@link ClassReader} object.
 167      *
 168      * @param b
 169      *            the bytecode of the class to be read.
 170      */
 171     public ClassReader(final byte[] b) {
 172         this(b, 0, b.length);
 173     }
 174 
 175     /**
 176      * Constructs a new {@link ClassReader} object.
 177      *
 178      * @param b
 179      *            the bytecode of the class to be read.
 180      * @param off
 181      *            the start offset of the class data.
 182      * @param len
 183      *            the length of the class data.
 184      */
 185     public ClassReader(final byte[] b, final int off, final int len) {
 186         this.b = b;
 187         // checks the class version
 188         if (readShort(off + 6) > Opcodes.V11) {
 189             throw new IllegalArgumentException();
 190         }
 191         // parses the constant pool
 192         items = new int[readUnsignedShort(off + 8)];
 193         int n = items.length;
 194         strings = new String[n];
 195         int max = 0;
 196         int index = off + 10;
 197         for (int i = 1; i < n; ++i) {
 198             items[i] = index + 1;
 199             int size;
 200             switch (b[index]) {
 201             case ClassWriter.FIELD:
 202             case ClassWriter.METH:
 203             case ClassWriter.IMETH:
 204             case ClassWriter.INT:
 205             case ClassWriter.FLOAT:
 206             case ClassWriter.NAME_TYPE:
 207             case ClassWriter.INDY:
 208                 size = 5;
 209                 break;
 210             case ClassWriter.LONG:
 211             case ClassWriter.DOUBLE:
 212                 size = 9;
 213                 ++i;
 214                 break;
 215             case ClassWriter.UTF8:
 216                 size = 3 + readUnsignedShort(index + 1);
 217                 if (size > max) {
 218                     max = size;
 219                 }
 220                 break;
 221             case ClassWriter.HANDLE:
 222                 size = 4;
 223                 break;
 224             // case ClassWriter.CLASS:
 225             // case ClassWriter.STR:
 226             // case ClassWriter.MTYPE
 227             // case ClassWriter.PACKAGE:
 228             // case ClassWriter.MODULE:
 229             default:
 230                 size = 3;
 231                 break;
 232             }
 233             index += size;
 234         }
 235         maxStringLength = max;
 236         // the class header information starts just after the constant pool
 237         header = index;
 238     }
 239 
 240     /**
 241      * Returns the class's access flags (see {@link Opcodes}). This value may
 242      * not reflect Deprecated and Synthetic flags when bytecode is before 1.5
 243      * and those flags are represented by attributes.
 244      *
 245      * @return the class access flags
 246      *
 247      * @see ClassVisitor#visit(int, int, String, String, String, String[])
 248      */
 249     public int getAccess() {
 250         return readUnsignedShort(header);
 251     }
 252 
 253     /**
 254      * Returns the internal name of the class (see
 255      * {@link Type#getInternalName() getInternalName}).
 256      *
 257      * @return the internal class name
 258      *
 259      * @see ClassVisitor#visit(int, int, String, String, String, String[])
 260      */
 261     public String getClassName() {
 262         return readClass(header + 2, new char[maxStringLength]);
 263     }
 264 
 265     /**
 266      * Returns the internal of name of the super class (see
 267      * {@link Type#getInternalName() getInternalName}). For interfaces, the
 268      * super class is {@link Object}.
 269      *
 270      * @return the internal name of super class, or <tt>null</tt> for
 271      *         {@link Object} class.
 272      *
 273      * @see ClassVisitor#visit(int, int, String, String, String, String[])
 274      */
 275     public String getSuperName() {
 276         return readClass(header + 4, new char[maxStringLength]);
 277     }
 278 
 279     /**
 280      * Returns the internal names of the class's interfaces (see
 281      * {@link Type#getInternalName() getInternalName}).
 282      *
 283      * @return the array of internal names for all implemented interfaces or
 284      *         <tt>null</tt>.
 285      *
 286      * @see ClassVisitor#visit(int, int, String, String, String, String[])
 287      */
 288     public String[] getInterfaces() {
 289         int index = header + 6;
 290         int n = readUnsignedShort(index);
 291         String[] interfaces = new String[n];
 292         if (n > 0) {
 293             char[] buf = new char[maxStringLength];
 294             for (int i = 0; i < n; ++i) {
 295                 index += 2;
 296                 interfaces[i] = readClass(index, buf);
 297             }
 298         }
 299         return interfaces;
 300     }
 301 
 302     /**
 303      * Copies the constant pool data into the given {@link ClassWriter}. Should
 304      * be called before the {@link #accept(ClassVisitor,int)} method.
 305      *
 306      * @param classWriter
 307      *            the {@link ClassWriter} to copy constant pool into.
 308      */
 309     void copyPool(final ClassWriter classWriter) {
 310         char[] buf = new char[maxStringLength];
 311         int ll = items.length;
 312         Item[] items2 = new Item[ll];
 313         for (int i = 1; i < ll; i++) {
 314             int index = items[i];
 315             int tag = b[index - 1];
 316             Item item = new Item(i);
 317             int nameType;
 318             switch (tag) {
 319             case ClassWriter.FIELD:
 320             case ClassWriter.METH:
 321             case ClassWriter.IMETH:
 322                 nameType = items[readUnsignedShort(index + 2)];
 323                 item.set(tag, readClass(index, buf), readUTF8(nameType, buf),
 324                         readUTF8(nameType + 2, buf));
 325                 break;
 326             case ClassWriter.INT:
 327                 item.set(readInt(index));
 328                 break;
 329             case ClassWriter.FLOAT:
 330                 item.set(Float.intBitsToFloat(readInt(index)));
 331                 break;
 332             case ClassWriter.NAME_TYPE:
 333                 item.set(tag, readUTF8(index, buf), readUTF8(index + 2, buf),
 334                         null);
 335                 break;
 336             case ClassWriter.LONG:
 337                 item.set(readLong(index));
 338                 ++i;
 339                 break;
 340             case ClassWriter.DOUBLE:
 341                 item.set(Double.longBitsToDouble(readLong(index)));
 342                 ++i;
 343                 break;
 344             case ClassWriter.UTF8: {
 345                 String s = strings[i];
 346                 if (s == null) {
 347                     index = items[i];
 348                     s = strings[i] = readUTF(index + 2,
 349                             readUnsignedShort(index), buf);
 350                 }
 351                 item.set(tag, s, null, null);
 352                 break;
 353             }
 354             case ClassWriter.HANDLE: {
 355                 int fieldOrMethodRef = items[readUnsignedShort(index + 1)];
 356                 nameType = items[readUnsignedShort(fieldOrMethodRef + 2)];
 357                 item.set(ClassWriter.HANDLE_BASE + readByte(index),
 358                         readClass(fieldOrMethodRef, buf),
 359                         readUTF8(nameType, buf), readUTF8(nameType + 2, buf));
 360                 break;
 361             }
 362             case ClassWriter.INDY:
 363                 if (classWriter.bootstrapMethods == null) {
 364                     copyBootstrapMethods(classWriter, items2, buf);
 365                 }
 366                 nameType = items[readUnsignedShort(index + 2)];
 367                 item.set(readUTF8(nameType, buf), readUTF8(nameType + 2, buf),
 368                         readUnsignedShort(index));
 369                 break;
 370             // case ClassWriter.STR:
 371             // case ClassWriter.CLASS:
 372             // case ClassWriter.MTYPE:
 373             // case ClassWriter.MODULE:
 374             // case ClassWriter.PACKAGE:
 375             default:
 376                 item.set(tag, readUTF8(index, buf), null, null);
 377                 break;
 378             }
 379 
 380             int index2 = item.hashCode % items2.length;
 381             item.next = items2[index2];
 382             items2[index2] = item;
 383         }
 384 
 385         int off = items[1] - 1;
 386         classWriter.pool.putByteArray(b, off, header - off);
 387         classWriter.items = items2;
 388         classWriter.threshold = (int) (0.75d * ll);
 389         classWriter.index = ll;
 390     }
 391 
 392     /**
 393      * Copies the bootstrap method data into the given {@link ClassWriter}.
 394      * Should be called before the {@link #accept(ClassVisitor,int)} method.
 395      *
 396      * @param classWriter
 397      *            the {@link ClassWriter} to copy bootstrap methods into.
 398      */
 399     private void copyBootstrapMethods(final ClassWriter classWriter,
 400             final Item[] items, final char[] c) {
 401         // finds the "BootstrapMethods" attribute
 402         int u = getAttributes();
 403         boolean found = false;
 404         for (int i = readUnsignedShort(u); i > 0; --i) {
 405             String attrName = readUTF8(u + 2, c);
 406             if ("BootstrapMethods".equals(attrName)) {
 407                 found = true;
 408                 break;
 409             }
 410             u += 6 + readInt(u + 4);
 411         }
 412         if (!found) {
 413             return;
 414         }
 415         // copies the bootstrap methods in the class writer
 416         int boostrapMethodCount = readUnsignedShort(u + 8);
 417         for (int j = 0, v = u + 10; j < boostrapMethodCount; j++) {
 418             int position = v - u - 10;
 419             int hashCode = readConst(readUnsignedShort(v), c).hashCode();
 420             for (int k = readUnsignedShort(v + 2); k > 0; --k) {
 421                 hashCode ^= readConst(readUnsignedShort(v + 4), c).hashCode();
 422                 v += 2;
 423             }
 424             v += 4;
 425             Item item = new Item(j);
 426             item.set(position, hashCode & 0x7FFFFFFF);
 427             int index = item.hashCode % items.length;
 428             item.next = items[index];
 429             items[index] = item;
 430         }
 431         int attrSize = readInt(u + 4);
 432         ByteVector bootstrapMethods = new ByteVector(attrSize + 62);
 433         bootstrapMethods.putByteArray(b, u + 10, attrSize - 2);
 434         classWriter.bootstrapMethodsCount = boostrapMethodCount;
 435         classWriter.bootstrapMethods = bootstrapMethods;
 436     }
 437 
 438     /**
 439      * Constructs a new {@link ClassReader} object.
 440      *
 441      * @param is
 442      *            an input stream from which to read the class.
 443      * @throws IOException
 444      *             if a problem occurs during reading.
 445      */
 446     public ClassReader(final InputStream is) throws IOException {
 447         this(readClass(is, false));
 448     }
 449 
 450     /**
 451      * Constructs a new {@link ClassReader} object.
 452      *
 453      * @param name
 454      *            the binary qualified name of the class to be read.
 455      * @throws IOException
 456      *             if an exception occurs during reading.
 457      */
 458     public ClassReader(final String name) throws IOException {
 459         this(readClass(
 460                 ClassLoader.getSystemResourceAsStream(name.replace('.', '/')
 461                         + ".class"), true));
 462     }
 463 
 464     /**
 465      * Reads the bytecode of a class.
 466      *
 467      * @param is
 468      *            an input stream from which to read the class.
 469      * @param close
 470      *            true to close the input stream after reading.
 471      * @return the bytecode read from the given input stream.
 472      * @throws IOException
 473      *             if a problem occurs during reading.
 474      */
 475     private static byte[] readClass(final InputStream is, boolean close)
 476             throws IOException {
 477         if (is == null) {
 478             throw new IOException("Class not found");
 479         }
 480         try {
 481             byte[] b = new byte[is.available()];
 482             int len = 0;
 483             while (true) {
 484                 int n = is.read(b, len, b.length - len);
 485                 if (n == -1) {
 486                     if (len < b.length) {
 487                         byte[] c = new byte[len];
 488                         System.arraycopy(b, 0, c, 0, len);
 489                         b = c;
 490                     }
 491                     return b;
 492                 }
 493                 len += n;
 494                 if (len == b.length) {
 495                     int last = is.read();
 496                     if (last < 0) {
 497                         return b;
 498                     }
 499                     byte[] c = new byte[b.length + 1000];
 500                     System.arraycopy(b, 0, c, 0, len);
 501                     c[len++] = (byte) last;
 502                     b = c;
 503                 }
 504             }
 505         } finally {
 506             if (close) {
 507                 is.close();
 508             }
 509         }
 510     }
 511 
 512     // ------------------------------------------------------------------------
 513     // Public methods
 514     // ------------------------------------------------------------------------
 515 
 516     /**
 517      * Makes the given visitor visit the Java class of this {@link ClassReader}
 518      * . This class is the one specified in the constructor (see
 519      * {@link #ClassReader(byte[]) ClassReader}).
 520      *
 521      * @param classVisitor
 522      *            the visitor that must visit this class.
 523      * @param flags
 524      *            option flags that can be used to modify the default behavior
 525      *            of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}
 526      *            , {@link #SKIP_FRAMES}, {@link #SKIP_CODE}.
 527      */
 528     public void accept(final ClassVisitor classVisitor, final int flags) {
 529         accept(classVisitor, new Attribute[0], flags);
 530     }
 531 
 532     /**
 533      * Makes the given visitor visit the Java class of this {@link ClassReader}.
 534      * This class is the one specified in the constructor (see
 535      * {@link #ClassReader(byte[]) ClassReader}).
 536      *
 537      * @param classVisitor
 538      *            the visitor that must visit this class.
 539      * @param attrs
 540      *            prototypes of the attributes that must be parsed during the
 541      *            visit of the class. Any attribute whose type is not equal to
 542      *            the type of one the prototypes will not be parsed: its byte
 543      *            array value will be passed unchanged to the ClassWriter.
 544      *            <i>This may corrupt it if this value contains references to
 545      *            the constant pool, or has syntactic or semantic links with a
 546      *            class element that has been transformed by a class adapter
 547      *            between the reader and the writer</i>.
 548      * @param flags
 549      *            option flags that can be used to modify the default behavior
 550      *            of this class. See {@link #SKIP_DEBUG}, {@link #EXPAND_FRAMES}
 551      *            , {@link #SKIP_FRAMES}, {@link #SKIP_CODE}.
 552      */
 553     public void accept(final ClassVisitor classVisitor,
 554             final Attribute[] attrs, final int flags) {
 555         int u = header; // current offset in the class file
 556         char[] c = new char[maxStringLength]; // buffer used to read strings
 557 
 558         Context context = new Context();
 559         context.attrs = attrs;
 560         context.flags = flags;
 561         context.buffer = c;
 562 
 563         // reads the class declaration
 564         int access = readUnsignedShort(u);
 565         String name = readClass(u + 2, c);
 566         String superClass = readClass(u + 4, c);
 567         String[] interfaces = new String[readUnsignedShort(u + 6)];
 568         u += 8;
 569         for (int i = 0; i < interfaces.length; ++i) {
 570             interfaces[i] = readClass(u, c);
 571             u += 2;
 572         }
 573 
 574         // reads the class attributes
 575         String signature = null;
 576         String sourceFile = null;
 577         String sourceDebug = null;
 578         String enclosingOwner = null;
 579         String enclosingName = null;
 580         String enclosingDesc = null;
 581         String moduleMainClass = null;
 582         int anns = 0;
 583         int ianns = 0;
 584         int tanns = 0;
 585         int itanns = 0;
 586         int innerClasses = 0;
 587         int module = 0;
 588         int packages = 0;
 589         Attribute attributes = null;
 590 
 591         u = getAttributes();
 592         for (int i = readUnsignedShort(u); i > 0; --i) {
 593             String attrName = readUTF8(u + 2, c);
 594             // tests are sorted in decreasing frequency order
 595             // (based on frequencies observed on typical classes)
 596             if ("SourceFile".equals(attrName)) {
 597                 sourceFile = readUTF8(u + 8, c);
 598             } else if ("InnerClasses".equals(attrName)) {
 599                 innerClasses = u + 8;
 600             } else if ("EnclosingMethod".equals(attrName)) {
 601                 enclosingOwner = readClass(u + 8, c);
 602                 int item = readUnsignedShort(u + 10);
 603                 if (item != 0) {
 604                     enclosingName = readUTF8(items[item], c);
 605                     enclosingDesc = readUTF8(items[item] + 2, c);
 606                 }
 607             } else if ("Signature".equals(attrName)) {
 608                 signature = readUTF8(u + 8, c);
 609             } else if ("RuntimeVisibleAnnotations".equals(attrName)) {
 610                 anns = u + 8;
 611             } else if ("RuntimeVisibleTypeAnnotations".equals(attrName)) {
 612                 tanns = u + 8;
 613             } else if ("Deprecated".equals(attrName)) {
 614                 access |= Opcodes.ACC_DEPRECATED;
 615             } else if ("Synthetic".equals(attrName)) {
 616                 access |= Opcodes.ACC_SYNTHETIC
 617                         | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
 618             } else if ("SourceDebugExtension".equals(attrName)) {
 619                 int len = readInt(u + 4);
 620                 sourceDebug = readUTF(u + 8, len, new char[len]);
 621             } else if ("RuntimeInvisibleAnnotations".equals(attrName)) {
 622                 ianns = u + 8;
 623             } else if ("RuntimeInvisibleTypeAnnotations".equals(attrName)) {
 624                 itanns = u + 8;
 625             } else if ("Module".equals(attrName)) {
 626                 module = u + 8;
 627             } else if ("ModuleMainClass".equals(attrName)) {
 628                 moduleMainClass = readClass(u + 8, c);
 629             } else if ("ModulePackages".equals(attrName)) {
 630                 packages = u + 10;
 631             } else if ("BootstrapMethods".equals(attrName)) {
 632                 int[] bootstrapMethods = new int[readUnsignedShort(u + 8)];
 633                 for (int j = 0, v = u + 10; j < bootstrapMethods.length; j++) {
 634                     bootstrapMethods[j] = v;
 635                     v += 2 + readUnsignedShort(v + 2) << 1;
 636                 }
 637                 context.bootstrapMethods = bootstrapMethods;
 638             } else {
 639                 Attribute attr = readAttribute(attrs, attrName, u + 8,
 640                         readInt(u + 4), c, -1, null);
 641                 if (attr != null) {
 642                     attr.next = attributes;
 643                     attributes = attr;
 644                 }
 645             }
 646             u += 6 + readInt(u + 4);
 647         }
 648 
 649         // visits the class declaration
 650         classVisitor.visit(readInt(items[1] - 7), access, name, signature,
 651                 superClass, interfaces);
 652 
 653         // visits the source and debug info
 654         if ((flags & SKIP_DEBUG) == 0
 655                 && (sourceFile != null || sourceDebug != null)) {
 656             classVisitor.visitSource(sourceFile, sourceDebug);
 657         }
 658 
 659         // visits the module info and associated attributes
 660         if (module != 0) {
 661             readModule(classVisitor, context, module,
 662                     moduleMainClass, packages);
 663         }
 664 
 665         // visits the outer class
 666         if (enclosingOwner != null) {
 667             classVisitor.visitOuterClass(enclosingOwner, enclosingName,
 668                     enclosingDesc);
 669         }
 670 
 671         // visits the class annotations and type annotations
 672         if (anns != 0) {
 673             for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) {
 674                 v = readAnnotationValues(v + 2, c, true,
 675                         classVisitor.visitAnnotation(readUTF8(v, c), true));
 676             }
 677         }
 678         if (ianns != 0) {
 679             for (int i = readUnsignedShort(ianns), v = ianns + 2; i > 0; --i) {
 680                 v = readAnnotationValues(v + 2, c, true,
 681                         classVisitor.visitAnnotation(readUTF8(v, c), false));
 682             }
 683         }
 684         if (tanns != 0) {
 685             for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) {
 686                 v = readAnnotationTarget(context, v);
 687                 v = readAnnotationValues(v + 2, c, true,
 688                         classVisitor.visitTypeAnnotation(context.typeRef,
 689                                 context.typePath, readUTF8(v, c), true));
 690             }
 691         }
 692         if (itanns != 0) {
 693             for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) {
 694                 v = readAnnotationTarget(context, v);
 695                 v = readAnnotationValues(v + 2, c, true,
 696                         classVisitor.visitTypeAnnotation(context.typeRef,
 697                                 context.typePath, readUTF8(v, c), false));
 698             }
 699         }
 700 
 701         // visits the attributes
 702         while (attributes != null) {
 703             Attribute attr = attributes.next;
 704             attributes.next = null;
 705             classVisitor.visitAttribute(attributes);
 706             attributes = attr;
 707         }
 708 
 709         // visits the inner classes
 710         if (innerClasses != 0) {
 711             int v = innerClasses + 2;
 712             for (int i = readUnsignedShort(innerClasses); i > 0; --i) {
 713                 classVisitor.visitInnerClass(readClass(v, c),
 714                         readClass(v + 2, c), readUTF8(v + 4, c),
 715                         readUnsignedShort(v + 6));
 716                 v += 8;
 717             }
 718         }
 719 
 720         // visits the fields and methods
 721         u = header + 10 + 2 * interfaces.length;
 722         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 723             u = readField(classVisitor, context, u);
 724         }
 725         u += 2;
 726         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 727             u = readMethod(classVisitor, context, u);
 728         }
 729 
 730         // visits the end of the class
 731         classVisitor.visitEnd();
 732     }
 733 
 734     /**
 735      * Reads the module attribute and visit it.
 736      *
 737      * @param classVisitor
 738      *           the current class visitor
 739      * @param context
 740      *           information about the class being parsed.
 741      * @param u
 742      *           start offset of the module attribute in the class file.
 743      * @param mainClass
 744      *           name of the main class of a module or null.
 745      * @param packages
 746      *           start offset of the concealed package attribute.
 747      */
 748     private void readModule(final ClassVisitor classVisitor,
 749             final Context context, int u,
 750             final String mainClass, int packages) {
 751 
 752         char[] buffer = context.buffer;
 753 
 754         // reads module name, flags and version
 755         String name = readModule(u, buffer);
 756         int flags = readUnsignedShort(u + 2);
 757         String version = readUTF8(u + 4, buffer);
 758         u += 6;
 759 
 760         ModuleVisitor mv = classVisitor.visitModule(name, flags, version);
 761         if (mv == null) {
 762             return;
 763         }
 764 
 765         // module attributes (main class, packages)
 766         if (mainClass != null) {
 767             mv.visitMainClass(mainClass);
 768         }
 769 
 770         if (packages != 0) {
 771             for (int i = readUnsignedShort(packages - 2); i > 0; --i) {
 772                 String packaze = readPackage(packages, buffer);
 773                 mv.visitPackage(packaze);
 774                 packages += 2;
 775             }
 776         }
 777 
 778         // reads requires
 779         u += 2;
 780         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 781             String module = readModule(u, buffer);
 782             int access = readUnsignedShort(u + 2);
 783             String requireVersion = readUTF8(u + 4, buffer);
 784             mv.visitRequire(module, access, requireVersion);
 785             u += 6;
 786         }
 787 
 788         // reads exports
 789         u += 2;
 790         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 791             String export = readPackage(u, buffer);
 792             int access = readUnsignedShort(u + 2);
 793             int exportToCount = readUnsignedShort(u + 4);
 794             u += 6;
 795             String[] tos = null;
 796             if (exportToCount != 0) {
 797                 tos = new String[exportToCount];
 798                 for (int j = 0; j < tos.length; ++j) {
 799                     tos[j] = readModule(u, buffer);
 800                     u += 2;
 801                 }
 802             }
 803             mv.visitExport(export, access, tos);
 804         }
 805 
 806         // reads opens
 807         u += 2;
 808         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 809             String open = readPackage(u, buffer);
 810             int access = readUnsignedShort(u + 2);
 811             int openToCount = readUnsignedShort(u + 4);
 812             u += 6;
 813             String[] tos = null;
 814             if (openToCount != 0) {
 815                 tos = new String[openToCount];
 816                 for (int j = 0; j < tos.length; ++j) {
 817                     tos[j] = readModule(u, buffer);
 818                     u += 2;
 819                 }
 820             }
 821             mv.visitOpen(open, access, tos);
 822         }
 823 
 824         // read uses
 825         u += 2;
 826         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 827             mv.visitUse(readClass(u, buffer));
 828             u += 2;
 829         }
 830 
 831         // read provides
 832         u += 2;
 833         for (int i = readUnsignedShort(u - 2); i > 0; --i) {
 834             String service = readClass(u, buffer);
 835             int provideWithCount = readUnsignedShort(u + 2);
 836             u += 4;
 837             String[] withs = new String[provideWithCount];
 838             for (int j = 0; j < withs.length; ++j) {
 839                 withs[j] = readClass(u, buffer);
 840                 u += 2;
 841             }
 842             mv.visitProvide(service, withs);
 843         }
 844 
 845         mv.visitEnd();
 846     }
 847 
 848     /**
 849      * Reads a field and makes the given visitor visit it.
 850      *
 851      * @param classVisitor
 852      *            the visitor that must visit the field.
 853      * @param context
 854      *            information about the class being parsed.
 855      * @param u
 856      *            the start offset of the field in the class file.
 857      * @return the offset of the first byte following the field in the class.
 858      */
 859     private int readField(final ClassVisitor classVisitor,
 860             final Context context, int u) {
 861         // reads the field declaration
 862         char[] c = context.buffer;
 863         int access = readUnsignedShort(u);
 864         String name = readUTF8(u + 2, c);
 865         String desc = readUTF8(u + 4, c);
 866         u += 6;
 867 
 868         // reads the field attributes
 869         String signature = null;
 870         int anns = 0;
 871         int ianns = 0;
 872         int tanns = 0;
 873         int itanns = 0;
 874         Object value = null;
 875         Attribute attributes = null;
 876 
 877         for (int i = readUnsignedShort(u); i > 0; --i) {
 878             String attrName = readUTF8(u + 2, c);
 879             // tests are sorted in decreasing frequency order
 880             // (based on frequencies observed on typical classes)
 881             if ("ConstantValue".equals(attrName)) {
 882                 int item = readUnsignedShort(u + 8);
 883                 value = item == 0 ? null : readConst(item, c);
 884             } else if ("Signature".equals(attrName)) {
 885                 signature = readUTF8(u + 8, c);
 886             } else if ("Deprecated".equals(attrName)) {
 887                 access |= Opcodes.ACC_DEPRECATED;
 888             } else if ("Synthetic".equals(attrName)) {
 889                 access |= Opcodes.ACC_SYNTHETIC
 890                         | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
 891             } else if ("RuntimeVisibleAnnotations".equals(attrName)) {
 892                 anns = u + 8;
 893             } else if ("RuntimeVisibleTypeAnnotations".equals(attrName)) {
 894                 tanns = u + 8;
 895             } else if ("RuntimeInvisibleAnnotations".equals(attrName)) {
 896                 ianns = u + 8;
 897             } else if ("RuntimeInvisibleTypeAnnotations".equals(attrName)) {
 898                 itanns = u + 8;
 899             } else {
 900                 Attribute attr = readAttribute(context.attrs, attrName, u + 8,
 901                         readInt(u + 4), c, -1, null);
 902                 if (attr != null) {
 903                     attr.next = attributes;
 904                     attributes = attr;
 905                 }
 906             }
 907             u += 6 + readInt(u + 4);
 908         }
 909         u += 2;
 910 
 911         // visits the field declaration
 912         FieldVisitor fv = classVisitor.visitField(access, name, desc,
 913                 signature, value);
 914         if (fv == null) {
 915             return u;
 916         }
 917 
 918         // visits the field annotations and type annotations
 919         if (anns != 0) {
 920             for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) {
 921                 v = readAnnotationValues(v + 2, c, true,
 922                         fv.visitAnnotation(readUTF8(v, c), true));
 923             }
 924         }
 925         if (ianns != 0) {
 926             for (int i = readUnsignedShort(ianns), v = ianns + 2; i > 0; --i) {
 927                 v = readAnnotationValues(v + 2, c, true,
 928                         fv.visitAnnotation(readUTF8(v, c), false));
 929             }
 930         }
 931         if (tanns != 0) {
 932             for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) {
 933                 v = readAnnotationTarget(context, v);
 934                 v = readAnnotationValues(v + 2, c, true,
 935                         fv.visitTypeAnnotation(context.typeRef,
 936                                 context.typePath, readUTF8(v, c), true));
 937             }
 938         }
 939         if (itanns != 0) {
 940             for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) {
 941                 v = readAnnotationTarget(context, v);
 942                 v = readAnnotationValues(v + 2, c, true,
 943                         fv.visitTypeAnnotation(context.typeRef,
 944                                 context.typePath, readUTF8(v, c), false));
 945             }
 946         }
 947 
 948         // visits the field attributes
 949         while (attributes != null) {
 950             Attribute attr = attributes.next;
 951             attributes.next = null;
 952             fv.visitAttribute(attributes);
 953             attributes = attr;
 954         }
 955 
 956         // visits the end of the field
 957         fv.visitEnd();
 958 
 959         return u;
 960     }
 961 
 962     /**
 963      * Reads a method and makes the given visitor visit it.
 964      *
 965      * @param classVisitor
 966      *            the visitor that must visit the method.
 967      * @param context
 968      *            information about the class being parsed.
 969      * @param u
 970      *            the start offset of the method in the class file.
 971      * @return the offset of the first byte following the method in the class.
 972      */
 973     private int readMethod(final ClassVisitor classVisitor,
 974             final Context context, int u) {
 975         // reads the method declaration
 976         char[] c = context.buffer;
 977         context.access = readUnsignedShort(u);
 978         context.name = readUTF8(u + 2, c);
 979         context.desc = readUTF8(u + 4, c);
 980         u += 6;
 981 
 982         // reads the method attributes
 983         int code = 0;
 984         int exception = 0;
 985         String[] exceptions = null;
 986         String signature = null;
 987         int methodParameters = 0;
 988         int anns = 0;
 989         int ianns = 0;
 990         int tanns = 0;
 991         int itanns = 0;
 992         int dann = 0;
 993         int mpanns = 0;
 994         int impanns = 0;
 995         int firstAttribute = u;
 996         Attribute attributes = null;
 997 
 998         for (int i = readUnsignedShort(u); i > 0; --i) {
 999             String attrName = readUTF8(u + 2, c);
1000             // tests are sorted in decreasing frequency order
1001             // (based on frequencies observed on typical classes)
1002             if ("Code".equals(attrName)) {
1003                 if ((context.flags & SKIP_CODE) == 0) {
1004                     code = u + 8;
1005                 }
1006             } else if ("Exceptions".equals(attrName)) {
1007                 exceptions = new String[readUnsignedShort(u + 8)];
1008                 exception = u + 10;
1009                 for (int j = 0; j < exceptions.length; ++j) {
1010                     exceptions[j] = readClass(exception, c);
1011                     exception += 2;
1012                 }
1013             } else if ("Signature".equals(attrName)) {
1014                 signature = readUTF8(u + 8, c);
1015             } else if ("Deprecated".equals(attrName)) {
1016                 context.access |= Opcodes.ACC_DEPRECATED;
1017             } else if ("RuntimeVisibleAnnotations".equals(attrName)) {
1018                 anns = u + 8;
1019             } else if ("RuntimeVisibleTypeAnnotations".equals(attrName)) {
1020                 tanns = u + 8;
1021             } else if ("AnnotationDefault".equals(attrName)) {
1022                 dann = u + 8;
1023             } else if ("Synthetic".equals(attrName)) {
1024                 context.access |= Opcodes.ACC_SYNTHETIC
1025                         | ClassWriter.ACC_SYNTHETIC_ATTRIBUTE;
1026             } else if ("RuntimeInvisibleAnnotations".equals(attrName)) {
1027                 ianns = u + 8;
1028             } else if ("RuntimeInvisibleTypeAnnotations".equals(attrName)) {
1029                 itanns = u + 8;
1030             } else if ("RuntimeVisibleParameterAnnotations".equals(attrName)) {
1031                 mpanns = u + 8;
1032             } else if ("RuntimeInvisibleParameterAnnotations".equals(attrName)) {
1033                 impanns = u + 8;
1034             } else if ("MethodParameters".equals(attrName)) {
1035                 methodParameters = u + 8;
1036             } else {
1037                 Attribute attr = readAttribute(context.attrs, attrName, u + 8,
1038                         readInt(u + 4), c, -1, null);
1039                 if (attr != null) {
1040                     attr.next = attributes;
1041                     attributes = attr;
1042                 }
1043             }
1044             u += 6 + readInt(u + 4);
1045         }
1046         u += 2;
1047 
1048         // visits the method declaration
1049         MethodVisitor mv = classVisitor.visitMethod(context.access,
1050                 context.name, context.desc, signature, exceptions);
1051         if (mv == null) {
1052             return u;
1053         }
1054 
1055         /*
1056          * if the returned MethodVisitor is in fact a MethodWriter, it means
1057          * there is no method adapter between the reader and the writer. If, in
1058          * addition, the writer's constant pool was copied from this reader
1059          * (mw.cw.cr == this), and the signature and exceptions of the method
1060          * have not been changed, then it is possible to skip all visit events
1061          * and just copy the original code of the method to the writer (the
1062          * access, name and descriptor can have been changed, this is not
1063          * important since they are not copied as is from the reader).
1064          */
1065         if (mv instanceof MethodWriter) {
1066             MethodWriter mw = (MethodWriter) mv;
1067             if (mw.cw.cr == this && signature == mw.signature) {
1068                 boolean sameExceptions = false;
1069                 if (exceptions == null) {
1070                     sameExceptions = mw.exceptionCount == 0;
1071                 } else if (exceptions.length == mw.exceptionCount) {
1072                     sameExceptions = true;
1073                     for (int j = exceptions.length - 1; j >= 0; --j) {
1074                         exception -= 2;
1075                         if (mw.exceptions[j] != readUnsignedShort(exception)) {
1076                             sameExceptions = false;
1077                             break;
1078                         }
1079                     }
1080                 }
1081                 if (sameExceptions) {
1082                     /*
1083                      * we do not copy directly the code into MethodWriter to
1084                      * save a byte array copy operation. The real copy will be
1085                      * done in ClassWriter.toByteArray().
1086                      */
1087                     mw.classReaderOffset = firstAttribute;
1088                     mw.classReaderLength = u - firstAttribute;
1089                     return u;
1090                 }
1091             }
1092         }
1093 
1094         // visit the method parameters
1095         if (methodParameters != 0) {
1096             for (int i = b[methodParameters] & 0xFF, v = methodParameters + 1; i > 0; --i, v = v + 4) {
1097                 mv.visitParameter(readUTF8(v, c), readUnsignedShort(v + 2));
1098             }
1099         }
1100 
1101         // visits the method annotations
1102         if (dann != 0) {
1103             AnnotationVisitor dv = mv.visitAnnotationDefault();
1104             readAnnotationValue(dann, c, null, dv);
1105             if (dv != null) {
1106                 dv.visitEnd();
1107             }
1108         }
1109         if (anns != 0) {
1110             for (int i = readUnsignedShort(anns), v = anns + 2; i > 0; --i) {
1111                 v = readAnnotationValues(v + 2, c, true,
1112                         mv.visitAnnotation(readUTF8(v, c), true));
1113             }
1114         }
1115         if (ianns != 0) {
1116             for (int i = readUnsignedShort(ianns), v = ianns + 2; i > 0; --i) {
1117                 v = readAnnotationValues(v + 2, c, true,
1118                         mv.visitAnnotation(readUTF8(v, c), false));
1119             }
1120         }
1121         if (tanns != 0) {
1122             for (int i = readUnsignedShort(tanns), v = tanns + 2; i > 0; --i) {
1123                 v = readAnnotationTarget(context, v);
1124                 v = readAnnotationValues(v + 2, c, true,
1125                         mv.visitTypeAnnotation(context.typeRef,
1126                                 context.typePath, readUTF8(v, c), true));
1127             }
1128         }
1129         if (itanns != 0) {
1130             for (int i = readUnsignedShort(itanns), v = itanns + 2; i > 0; --i) {
1131                 v = readAnnotationTarget(context, v);
1132                 v = readAnnotationValues(v + 2, c, true,
1133                         mv.visitTypeAnnotation(context.typeRef,
1134                                 context.typePath, readUTF8(v, c), false));
1135             }
1136         }
1137         if (mpanns != 0) {
1138             readParameterAnnotations(mv, context, mpanns, true);
1139         }
1140         if (impanns != 0) {
1141             readParameterAnnotations(mv, context, impanns, false);
1142         }
1143 
1144         // visits the method attributes
1145         while (attributes != null) {
1146             Attribute attr = attributes.next;
1147             attributes.next = null;
1148             mv.visitAttribute(attributes);
1149             attributes = attr;
1150         }
1151 
1152         // visits the method code
1153         if (code != 0) {
1154             mv.visitCode();
1155             readCode(mv, context, code);
1156         }
1157 
1158         // visits the end of the method
1159         mv.visitEnd();
1160 
1161         return u;
1162     }
1163 
1164     /**
1165      * Reads the bytecode of a method and makes the given visitor visit it.
1166      *
1167      * @param mv
1168      *            the visitor that must visit the method's code.
1169      * @param context
1170      *            information about the class being parsed.
1171      * @param u
1172      *            the start offset of the code attribute in the class file.
1173      */
1174     private void readCode(final MethodVisitor mv, final Context context, int u) {
1175         // reads the header
1176         byte[] b = this.b;
1177         char[] c = context.buffer;
1178         int maxStack = readUnsignedShort(u);
1179         int maxLocals = readUnsignedShort(u + 2);
1180         int codeLength = readInt(u + 4);
1181         u += 8;
1182 
1183         // reads the bytecode to find the labels
1184         int codeStart = u;
1185         int codeEnd = u + codeLength;
1186         Label[] labels = context.labels = new Label[codeLength + 2];
1187         createLabel(codeLength + 1, labels);
1188         while (u < codeEnd) {
1189             int offset = u - codeStart;
1190             int opcode = b[u] & 0xFF;
1191             switch (ClassWriter.TYPE[opcode]) {
1192             case ClassWriter.NOARG_INSN:
1193             case ClassWriter.IMPLVAR_INSN:
1194                 u += 1;
1195                 break;
1196             case ClassWriter.LABEL_INSN:
1197                 createLabel(offset + readShort(u + 1), labels);
1198                 u += 3;
1199                 break;
1200             case ClassWriter.ASM_LABEL_INSN:
1201                 createLabel(offset + readUnsignedShort(u + 1), labels);
1202                 u += 3;
1203                 break;
1204             case ClassWriter.LABELW_INSN:
1205             case ClassWriter.ASM_LABELW_INSN:
1206                 createLabel(offset + readInt(u + 1), labels);
1207                 u += 5;
1208                 break;
1209             case ClassWriter.WIDE_INSN:
1210                 opcode = b[u + 1] & 0xFF;
1211                 if (opcode == Opcodes.IINC) {
1212                     u += 6;
1213                 } else {
1214                     u += 4;
1215                 }
1216                 break;
1217             case ClassWriter.TABL_INSN:
1218                 // skips 0 to 3 padding bytes
1219                 u = u + 4 - (offset & 3);
1220                 // reads instruction
1221                 createLabel(offset + readInt(u), labels);
1222                 for (int i = readInt(u + 8) - readInt(u + 4) + 1; i > 0; --i) {
1223                     createLabel(offset + readInt(u + 12), labels);
1224                     u += 4;
1225                 }
1226                 u += 12;
1227                 break;
1228             case ClassWriter.LOOK_INSN:
1229                 // skips 0 to 3 padding bytes
1230                 u = u + 4 - (offset & 3);
1231                 // reads instruction
1232                 createLabel(offset + readInt(u), labels);
1233                 for (int i = readInt(u + 4); i > 0; --i) {
1234                     createLabel(offset + readInt(u + 12), labels);
1235                     u += 8;
1236                 }
1237                 u += 8;
1238                 break;
1239             case ClassWriter.VAR_INSN:
1240             case ClassWriter.SBYTE_INSN:
1241             case ClassWriter.LDC_INSN:
1242                 u += 2;
1243                 break;
1244             case ClassWriter.SHORT_INSN:
1245             case ClassWriter.LDCW_INSN:
1246             case ClassWriter.FIELDORMETH_INSN:
1247             case ClassWriter.TYPE_INSN:
1248             case ClassWriter.IINC_INSN:
1249                 u += 3;
1250                 break;
1251             case ClassWriter.ITFMETH_INSN:
1252             case ClassWriter.INDYMETH_INSN:
1253                 u += 5;
1254                 break;
1255             // case MANA_INSN:
1256             default:
1257                 u += 4;
1258                 break;
1259             }
1260         }
1261 
1262         // reads the try catch entries to find the labels, and also visits them
1263         for (int i = readUnsignedShort(u); i > 0; --i) {
1264             Label start = createLabel(readUnsignedShort(u + 2), labels);
1265             Label end = createLabel(readUnsignedShort(u + 4), labels);
1266             Label handler = createLabel(readUnsignedShort(u + 6), labels);
1267             String type = readUTF8(items[readUnsignedShort(u + 8)], c);
1268             mv.visitTryCatchBlock(start, end, handler, type);
1269             u += 8;
1270         }
1271         u += 2;
1272 
1273         // reads the code attributes
1274         int[] tanns = null; // start index of each visible type annotation
1275         int[] itanns = null; // start index of each invisible type annotation
1276         int tann = 0; // current index in tanns array
1277         int itann = 0; // current index in itanns array
1278         int ntoff = -1; // next visible type annotation code offset
1279         int nitoff = -1; // next invisible type annotation code offset
1280         int varTable = 0;
1281         int varTypeTable = 0;
1282         boolean zip = true;
1283         boolean unzip = (context.flags & EXPAND_FRAMES) != 0;
1284         int stackMap = 0;
1285         int stackMapSize = 0;
1286         int frameCount = 0;
1287         Context frame = null;
1288         Attribute attributes = null;
1289 
1290         for (int i = readUnsignedShort(u); i > 0; --i) {
1291             String attrName = readUTF8(u + 2, c);
1292             if ("LocalVariableTable".equals(attrName)) {
1293                 if ((context.flags & SKIP_DEBUG) == 0) {
1294                     varTable = u + 8;
1295                     for (int j = readUnsignedShort(u + 8), v = u; j > 0; --j) {
1296                         int label = readUnsignedShort(v + 10);
1297                         createDebugLabel(label, labels);
1298                         label += readUnsignedShort(v + 12);
1299                         createDebugLabel(label, labels);
1300                         v += 10;
1301                     }
1302                 }
1303             } else if ("LocalVariableTypeTable".equals(attrName)) {
1304                 varTypeTable = u + 8;
1305             } else if ("LineNumberTable".equals(attrName)) {
1306                 if ((context.flags & SKIP_DEBUG) == 0) {
1307                     for (int j = readUnsignedShort(u + 8), v = u; j > 0; --j) {
1308                         int label = readUnsignedShort(v + 10);
1309                         createDebugLabel(label, labels);
1310                         Label l = labels[label];
1311                         while (l.line > 0) {
1312                             if (l.next == null) {
1313                                 l.next = new Label();
1314                             }
1315                             l = l.next;
1316                         }
1317                         l.line = readUnsignedShort(v + 12);
1318                         v += 4;
1319                     }
1320                 }
1321             } else if ("RuntimeVisibleTypeAnnotations".equals(attrName)) {
1322                 tanns = readTypeAnnotations(mv, context, u + 8, true);
1323                 ntoff = tanns.length == 0 || readByte(tanns[0]) < 0x43 ? -1
1324                         : readUnsignedShort(tanns[0] + 1);
1325             } else if ("RuntimeInvisibleTypeAnnotations".equals(attrName)) {
1326                 itanns = readTypeAnnotations(mv, context, u + 8, false);
1327                 nitoff = itanns.length == 0 || readByte(itanns[0]) < 0x43 ? -1
1328                         : readUnsignedShort(itanns[0] + 1);
1329             } else if ("StackMapTable".equals(attrName)) {
1330                 if ((context.flags & SKIP_FRAMES) == 0) {
1331                     stackMap = u + 10;
1332                     stackMapSize = readInt(u + 4);
1333                     frameCount = readUnsignedShort(u + 8);
1334                 }
1335                 /*
1336                  * here we do not extract the labels corresponding to the
1337                  * attribute content. This would require a full parsing of the
1338                  * attribute, which would need to be repeated in the second
1339                  * phase (see below). Instead the content of the attribute is
1340                  * read one frame at a time (i.e. after a frame has been
1341                  * visited, the next frame is read), and the labels it contains
1342                  * are also extracted one frame at a time. Thanks to the
1343                  * ordering of frames, having only a "one frame lookahead" is
1344                  * not a problem, i.e. it is not possible to see an offset
1345                  * smaller than the offset of the current insn and for which no
1346                  * Label exist.
1347                  */
1348                 /*
1349                  * This is not true for UNINITIALIZED type offsets. We solve
1350                  * this by parsing the stack map table without a full decoding
1351                  * (see below).
1352                  */
1353             } else if ("StackMap".equals(attrName)) {
1354                 if ((context.flags & SKIP_FRAMES) == 0) {
1355                     zip = false;
1356                     stackMap = u + 10;
1357                     stackMapSize = readInt(u + 4);
1358                     frameCount = readUnsignedShort(u + 8);
1359                 }
1360                 /*
1361                  * IMPORTANT! here we assume that the frames are ordered, as in
1362                  * the StackMapTable attribute, although this is not guaranteed
1363                  * by the attribute format.
1364                  */
1365             } else {
1366                 for (int j = 0; j < context.attrs.length; ++j) {
1367                     if (context.attrs[j].type.equals(attrName)) {
1368                         Attribute attr = context.attrs[j].read(this, u + 8,
1369                                 readInt(u + 4), c, codeStart - 8, labels);
1370                         if (attr != null) {
1371                             attr.next = attributes;
1372                             attributes = attr;
1373                         }
1374                     }
1375                 }
1376             }
1377             u += 6 + readInt(u + 4);
1378         }
1379         u += 2;
1380 
1381         // generates the first (implicit) stack map frame
1382         if (stackMap != 0) {
1383             /*
1384              * for the first explicit frame the offset is not offset_delta + 1
1385              * but only offset_delta; setting the implicit frame offset to -1
1386              * allow the use of the "offset_delta + 1" rule in all cases
1387              */
1388             frame = context;
1389             frame.offset = -1;
1390             frame.mode = 0;
1391             frame.localCount = 0;
1392             frame.localDiff = 0;
1393             frame.stackCount = 0;
1394             frame.local = new Object[maxLocals];
1395             frame.stack = new Object[maxStack];
1396             if (unzip) {
1397                 getImplicitFrame(context);
1398             }
1399             /*
1400              * Finds labels for UNINITIALIZED frame types. Instead of decoding
1401              * each element of the stack map table, we look for 3 consecutive
1402              * bytes that "look like" an UNINITIALIZED type (tag 8, offset
1403              * within code bounds, NEW instruction at this offset). We may find
1404              * false positives (i.e. not real UNINITIALIZED types), but this
1405              * should be rare, and the only consequence will be the creation of
1406              * an unneeded label. This is better than creating a label for each
1407              * NEW instruction, and faster than fully decoding the whole stack
1408              * map table.
1409              */
1410             for (int i = stackMap; i < stackMap + stackMapSize - 2; ++i) {
1411                 if (b[i] == 8) { // UNINITIALIZED FRAME TYPE
1412                     int v = readUnsignedShort(i + 1);
1413                     if (v >= 0 && v < codeLength) {
1414                         if ((b[codeStart + v] & 0xFF) == Opcodes.NEW) {
1415                             createLabel(v, labels);
1416                         }
1417                     }
1418                 }
1419             }
1420         }
1421         if ((context.flags & EXPAND_ASM_INSNS) != 0
1422             && (context.flags & EXPAND_FRAMES) != 0) {
1423             // Expanding the ASM pseudo instructions can introduce F_INSERT
1424             // frames, even if the method does not currently have any frame.
1425             // Also these inserted frames must be computed by simulating the
1426             // effect of the bytecode instructions one by one, starting from the
1427             // first one and the last existing frame (or the implicit first
1428             // one). Finally, due to the way MethodWriter computes this (with
1429             // the compute = INSERTED_FRAMES option), MethodWriter needs to know
1430             // maxLocals before the first instruction is visited. For all these
1431             // reasons we always visit the implicit first frame in this case
1432             // (passing only maxLocals - the rest can be and is computed in
1433             // MethodWriter).
1434             mv.visitFrame(Opcodes.F_NEW, maxLocals, null, 0, null);
1435         }
1436 
1437         // visits the instructions
1438         int opcodeDelta = (context.flags & EXPAND_ASM_INSNS) == 0 ? -33 : 0;
1439         boolean insertFrame = false;
1440         u = codeStart;
1441         while (u < codeEnd) {
1442             int offset = u - codeStart;
1443 
1444             // visits the label and line number for this offset, if any
1445             Label l = labels[offset];
1446             if (l != null) {
1447                 Label next = l.next;
1448                 l.next = null;
1449                 mv.visitLabel(l);
1450                 if ((context.flags & SKIP_DEBUG) == 0 && l.line > 0) {
1451                     mv.visitLineNumber(l.line, l);
1452                     while (next != null) {
1453                         mv.visitLineNumber(next.line, l);
1454                         next = next.next;
1455                     }
1456                 }
1457             }
1458 
1459             // visits the frame for this offset, if any
1460             while (frame != null
1461                     && (frame.offset == offset || frame.offset == -1)) {
1462                 // if there is a frame for this offset, makes the visitor visit
1463                 // it, and reads the next frame if there is one.
1464                 if (frame.offset != -1) {
1465                     if (!zip || unzip) {
1466                         mv.visitFrame(Opcodes.F_NEW, frame.localCount,
1467                                 frame.local, frame.stackCount, frame.stack);
1468                     } else {
1469                         mv.visitFrame(frame.mode, frame.localDiff, frame.local,
1470                                 frame.stackCount, frame.stack);
1471                     }
1472                     // if there is already a frame for this offset, there is no
1473                     // need to insert a new one.
1474                     insertFrame = false;
1475                 }
1476                 if (frameCount > 0) {
1477                     stackMap = readFrame(stackMap, zip, unzip, frame);
1478                     --frameCount;
1479                 } else {
1480                     frame = null;
1481                 }
1482             }
1483             // inserts a frame for this offset, if requested by setting
1484             // insertFrame to true during the previous iteration. The actual
1485             // frame content will be computed in MethodWriter.
1486             if (insertFrame) {
1487                 mv.visitFrame(ClassWriter.F_INSERT, 0, null, 0, null);
1488                 insertFrame = false;
1489             }
1490 
1491             // visits the instruction at this offset
1492             int opcode = b[u] & 0xFF;
1493             switch (ClassWriter.TYPE[opcode]) {
1494             case ClassWriter.NOARG_INSN:
1495                 mv.visitInsn(opcode);
1496                 u += 1;
1497                 break;
1498             case ClassWriter.IMPLVAR_INSN:
1499                 if (opcode > Opcodes.ISTORE) {
1500                     opcode -= 59; // ISTORE_0
1501                     mv.visitVarInsn(Opcodes.ISTORE + (opcode >> 2),
1502                             opcode & 0x3);
1503                 } else {
1504                     opcode -= 26; // ILOAD_0
1505                     mv.visitVarInsn(Opcodes.ILOAD + (opcode >> 2), opcode & 0x3);
1506                 }
1507                 u += 1;
1508                 break;
1509             case ClassWriter.LABEL_INSN:
1510                 mv.visitJumpInsn(opcode, labels[offset + readShort(u + 1)]);
1511                 u += 3;
1512                 break;
1513             case ClassWriter.LABELW_INSN:
1514                 mv.visitJumpInsn(opcode + opcodeDelta, labels[offset
1515                         + readInt(u + 1)]);
1516                 u += 5;
1517                 break;
1518             case ClassWriter.ASM_LABEL_INSN: {
1519                 // changes temporary opcodes 202 to 217 (inclusive), 218
1520                 // and 219 to IFEQ ... JSR (inclusive), IFNULL and
1521                 // IFNONNULL
1522                 opcode = opcode < 218 ? opcode - 49 : opcode - 20;
1523                 Label target = labels[offset + readUnsignedShort(u + 1)];
1524                 // replaces GOTO with GOTO_W, JSR with JSR_W and IFxxx
1525                 // <l> with IFNOTxxx <L> GOTO_W <l> L:..., where IFNOTxxx is
1526                 // the "opposite" opcode of IFxxx (i.e., IFNE for IFEQ)
1527                 // and where <L> designates the instruction just after
1528                 // the GOTO_W.
1529                 if (opcode == Opcodes.GOTO || opcode == Opcodes.JSR) {
1530                     mv.visitJumpInsn(opcode + 33, target);
1531                 } else {
1532                     opcode = opcode <= 166 ? ((opcode + 1) ^ 1) - 1
1533                             : opcode ^ 1;
1534                     Label endif = createLabel(offset + 3, labels);
1535                     mv.visitJumpInsn(opcode, endif);
1536                     mv.visitJumpInsn(200, target); // GOTO_W
1537                     // endif designates the instruction just after GOTO_W,
1538                     // and is visited as part of the next instruction. Since
1539                     // it is a jump target, we need to insert a frame here.
1540                     insertFrame = true;
1541                 }
1542                 u += 3;
1543                 break;
1544             }
1545             case ClassWriter.ASM_LABELW_INSN: {
1546                 // replaces the pseudo GOTO_W instruction with a real one.
1547                 mv.visitJumpInsn(200, labels[offset + readInt(u + 1)]);
1548                 // The instruction just after is a jump target (because pseudo
1549                 // GOTO_W are used in patterns IFNOTxxx <L> GOTO_W <l> L:...,
1550                 // see MethodWriter), so we need to insert a frame here.
1551                 insertFrame = true;
1552                 u += 5;
1553                 break;
1554             }
1555             case ClassWriter.WIDE_INSN:
1556                 opcode = b[u + 1] & 0xFF;
1557                 if (opcode == Opcodes.IINC) {
1558                     mv.visitIincInsn(readUnsignedShort(u + 2), readShort(u + 4));
1559                     u += 6;
1560                 } else {
1561                     mv.visitVarInsn(opcode, readUnsignedShort(u + 2));
1562                     u += 4;
1563                 }
1564                 break;
1565             case ClassWriter.TABL_INSN: {
1566                 // skips 0 to 3 padding bytes
1567                 u = u + 4 - (offset & 3);
1568                 // reads instruction
1569                 int label = offset + readInt(u);
1570                 int min = readInt(u + 4);
1571                 int max = readInt(u + 8);
1572                 Label[] table = new Label[max - min + 1];
1573                 u += 12;
1574                 for (int i = 0; i < table.length; ++i) {
1575                     table[i] = labels[offset + readInt(u)];
1576                     u += 4;
1577                 }
1578                 mv.visitTableSwitchInsn(min, max, labels[label], table);
1579                 break;
1580             }
1581             case ClassWriter.LOOK_INSN: {
1582                 // skips 0 to 3 padding bytes
1583                 u = u + 4 - (offset & 3);
1584                 // reads instruction
1585                 int label = offset + readInt(u);
1586                 int len = readInt(u + 4);
1587                 int[] keys = new int[len];
1588                 Label[] values = new Label[len];
1589                 u += 8;
1590                 for (int i = 0; i < len; ++i) {
1591                     keys[i] = readInt(u);
1592                     values[i] = labels[offset + readInt(u + 4)];
1593                     u += 8;
1594                 }
1595                 mv.visitLookupSwitchInsn(labels[label], keys, values);
1596                 break;
1597             }
1598             case ClassWriter.VAR_INSN:
1599                 mv.visitVarInsn(opcode, b[u + 1] & 0xFF);
1600                 u += 2;
1601                 break;
1602             case ClassWriter.SBYTE_INSN:
1603                 mv.visitIntInsn(opcode, b[u + 1]);
1604                 u += 2;
1605                 break;
1606             case ClassWriter.SHORT_INSN:
1607                 mv.visitIntInsn(opcode, readShort(u + 1));
1608                 u += 3;
1609                 break;
1610             case ClassWriter.LDC_INSN:
1611                 mv.visitLdcInsn(readConst(b[u + 1] & 0xFF, c));
1612                 u += 2;
1613                 break;
1614             case ClassWriter.LDCW_INSN:
1615                 mv.visitLdcInsn(readConst(readUnsignedShort(u + 1), c));
1616                 u += 3;
1617                 break;
1618             case ClassWriter.FIELDORMETH_INSN:
1619             case ClassWriter.ITFMETH_INSN: {
1620                 int cpIndex = items[readUnsignedShort(u + 1)];
1621                 boolean itf = b[cpIndex - 1] == ClassWriter.IMETH;
1622                 String iowner = readClass(cpIndex, c);
1623                 cpIndex = items[readUnsignedShort(cpIndex + 2)];
1624                 String iname = readUTF8(cpIndex, c);
1625                 String idesc = readUTF8(cpIndex + 2, c);
1626                 if (opcode < Opcodes.INVOKEVIRTUAL) {
1627                     mv.visitFieldInsn(opcode, iowner, iname, idesc);
1628                 } else {
1629                     mv.visitMethodInsn(opcode, iowner, iname, idesc, itf);
1630                 }
1631                 if (opcode == Opcodes.INVOKEINTERFACE) {
1632                     u += 5;
1633                 } else {
1634                     u += 3;
1635                 }
1636                 break;
1637             }
1638             case ClassWriter.INDYMETH_INSN: {
1639                 int cpIndex = items[readUnsignedShort(u + 1)];
1640                 int bsmIndex = context.bootstrapMethods[readUnsignedShort(cpIndex)];
1641                 Handle bsm = (Handle) readConst(readUnsignedShort(bsmIndex), c);
1642                 int bsmArgCount = readUnsignedShort(bsmIndex + 2);
1643                 Object[] bsmArgs = new Object[bsmArgCount];
1644                 bsmIndex += 4;
1645                 for (int i = 0; i < bsmArgCount; i++) {
1646                     bsmArgs[i] = readConst(readUnsignedShort(bsmIndex), c);
1647                     bsmIndex += 2;
1648                 }
1649                 cpIndex = items[readUnsignedShort(cpIndex + 2)];
1650                 String iname = readUTF8(cpIndex, c);
1651                 String idesc = readUTF8(cpIndex + 2, c);
1652                 mv.visitInvokeDynamicInsn(iname, idesc, bsm, bsmArgs);
1653                 u += 5;
1654                 break;
1655             }
1656             case ClassWriter.TYPE_INSN:
1657                 mv.visitTypeInsn(opcode, readClass(u + 1, c));
1658                 u += 3;
1659                 break;
1660             case ClassWriter.IINC_INSN:
1661                 mv.visitIincInsn(b[u + 1] & 0xFF, b[u + 2]);
1662                 u += 3;
1663                 break;
1664             // case MANA_INSN:
1665             default:
1666                 mv.visitMultiANewArrayInsn(readClass(u + 1, c), b[u + 3] & 0xFF);
1667                 u += 4;
1668                 break;
1669             }
1670 
1671             // visit the instruction annotations, if any
1672             while (tanns != null && tann < tanns.length && ntoff <= offset) {
1673                 if (ntoff == offset) {
1674                     int v = readAnnotationTarget(context, tanns[tann]);
1675                     readAnnotationValues(v + 2, c, true,
1676                             mv.visitInsnAnnotation(context.typeRef,
1677                                     context.typePath, readUTF8(v, c), true));
1678                 }
1679                 ntoff = ++tann >= tanns.length || readByte(tanns[tann]) < 0x43 ? -1
1680                         : readUnsignedShort(tanns[tann] + 1);
1681             }
1682             while (itanns != null && itann < itanns.length && nitoff <= offset) {
1683                 if (nitoff == offset) {
1684                     int v = readAnnotationTarget(context, itanns[itann]);
1685                     readAnnotationValues(v + 2, c, true,
1686                             mv.visitInsnAnnotation(context.typeRef,
1687                                     context.typePath, readUTF8(v, c), false));
1688                 }
1689                 nitoff = ++itann >= itanns.length
1690                         || readByte(itanns[itann]) < 0x43 ? -1
1691                         : readUnsignedShort(itanns[itann] + 1);
1692             }
1693         }
1694         if (labels[codeLength] != null) {
1695             mv.visitLabel(labels[codeLength]);
1696         }
1697 
1698         // visits the local variable tables
1699         if ((context.flags & SKIP_DEBUG) == 0 && varTable != 0) {
1700             int[] typeTable = null;
1701             if (varTypeTable != 0) {
1702                 u = varTypeTable + 2;
1703                 typeTable = new int[readUnsignedShort(varTypeTable) * 3];
1704                 for (int i = typeTable.length; i > 0;) {
1705                     typeTable[--i] = u + 6; // signature
1706                     typeTable[--i] = readUnsignedShort(u + 8); // index
1707                     typeTable[--i] = readUnsignedShort(u); // start
1708                     u += 10;
1709                 }
1710             }
1711             u = varTable + 2;
1712             for (int i = readUnsignedShort(varTable); i > 0; --i) {
1713                 int start = readUnsignedShort(u);
1714                 int length = readUnsignedShort(u + 2);
1715                 int index = readUnsignedShort(u + 8);
1716                 String vsignature = null;
1717                 if (typeTable != null) {
1718                     for (int j = 0; j < typeTable.length; j += 3) {
1719                         if (typeTable[j] == start && typeTable[j + 1] == index) {
1720                             vsignature = readUTF8(typeTable[j + 2], c);
1721                             break;
1722                         }
1723                     }
1724                 }
1725                 mv.visitLocalVariable(readUTF8(u + 4, c), readUTF8(u + 6, c),
1726                         vsignature, labels[start], labels[start + length],
1727                         index);
1728                 u += 10;
1729             }
1730         }
1731 
1732         // visits the local variables type annotations
1733         if (tanns != null) {
1734             for (int i = 0; i < tanns.length; ++i) {
1735                 if ((readByte(tanns[i]) >> 1) == (0x40 >> 1)) {
1736                     int v = readAnnotationTarget(context, tanns[i]);
1737                     v = readAnnotationValues(v + 2, c, true,
1738                             mv.visitLocalVariableAnnotation(context.typeRef,
1739                                     context.typePath, context.start,
1740                                     context.end, context.index, readUTF8(v, c),
1741                                     true));
1742                 }
1743             }
1744         }
1745         if (itanns != null) {
1746             for (int i = 0; i < itanns.length; ++i) {
1747                 if ((readByte(itanns[i]) >> 1) == (0x40 >> 1)) {
1748                     int v = readAnnotationTarget(context, itanns[i]);
1749                     v = readAnnotationValues(v + 2, c, true,
1750                             mv.visitLocalVariableAnnotation(context.typeRef,
1751                                     context.typePath, context.start,
1752                                     context.end, context.index, readUTF8(v, c),
1753                                     false));
1754                 }
1755             }
1756         }
1757 
1758         // visits the code attributes
1759         while (attributes != null) {
1760             Attribute attr = attributes.next;
1761             attributes.next = null;
1762             mv.visitAttribute(attributes);
1763             attributes = attr;
1764         }
1765 
1766         // visits the max stack and max locals values
1767         mv.visitMaxs(maxStack, maxLocals);
1768     }
1769 
1770     /**
1771      * Parses a type annotation table to find the labels, and to visit the try
1772      * catch block annotations.
1773      *
1774      * @param u
1775      *            the start offset of a type annotation table.
1776      * @param mv
1777      *            the method visitor to be used to visit the try catch block
1778      *            annotations.
1779      * @param context
1780      *            information about the class being parsed.
1781      * @param visible
1782      *            if the type annotation table to parse contains runtime visible
1783      *            annotations.
1784      * @return the start offset of each type annotation in the parsed table.
1785      */
1786     private int[] readTypeAnnotations(final MethodVisitor mv,
1787             final Context context, int u, boolean visible) {
1788         char[] c = context.buffer;
1789         int[] offsets = new int[readUnsignedShort(u)];
1790         u += 2;
1791         for (int i = 0; i < offsets.length; ++i) {
1792             offsets[i] = u;
1793             int target = readInt(u);
1794             switch (target >>> 24) {
1795             case 0x00: // CLASS_TYPE_PARAMETER
1796             case 0x01: // METHOD_TYPE_PARAMETER
1797             case 0x16: // METHOD_FORMAL_PARAMETER
1798                 u += 2;
1799                 break;
1800             case 0x13: // FIELD
1801             case 0x14: // METHOD_RETURN
1802             case 0x15: // METHOD_RECEIVER
1803                 u += 1;
1804                 break;
1805             case 0x40: // LOCAL_VARIABLE
1806             case 0x41: // RESOURCE_VARIABLE
1807                 for (int j = readUnsignedShort(u + 1); j > 0; --j) {
1808                     int start = readUnsignedShort(u + 3);
1809                     int length = readUnsignedShort(u + 5);
1810                     createLabel(start, context.labels);
1811                     createLabel(start + length, context.labels);
1812                     u += 6;
1813                 }
1814                 u += 3;
1815                 break;
1816             case 0x47: // CAST
1817             case 0x48: // CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
1818             case 0x49: // METHOD_INVOCATION_TYPE_ARGUMENT
1819             case 0x4A: // CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
1820             case 0x4B: // METHOD_REFERENCE_TYPE_ARGUMENT
1821                 u += 4;
1822                 break;
1823             // case 0x10: // CLASS_EXTENDS
1824             // case 0x11: // CLASS_TYPE_PARAMETER_BOUND
1825             // case 0x12: // METHOD_TYPE_PARAMETER_BOUND
1826             // case 0x17: // THROWS
1827             // case 0x42: // EXCEPTION_PARAMETER
1828             // case 0x43: // INSTANCEOF
1829             // case 0x44: // NEW
1830             // case 0x45: // CONSTRUCTOR_REFERENCE
1831             // case 0x46: // METHOD_REFERENCE
1832             default:
1833                 u += 3;
1834                 break;
1835             }
1836             int pathLength = readByte(u);
1837             if ((target >>> 24) == 0x42) {
1838                 TypePath path = pathLength == 0 ? null : new TypePath(b, u);
1839                 u += 1 + 2 * pathLength;
1840                 u = readAnnotationValues(u + 2, c, true,
1841                         mv.visitTryCatchAnnotation(target, path,
1842                                 readUTF8(u, c), visible));
1843             } else {
1844                 u = readAnnotationValues(u + 3 + 2 * pathLength, c, true, null);
1845             }
1846         }
1847         return offsets;
1848     }
1849 
1850     /**
1851      * Parses the header of a type annotation to extract its target_type and
1852      * target_path (the result is stored in the given context), and returns the
1853      * start offset of the rest of the type_annotation structure (i.e. the
1854      * offset to the type_index field, which is followed by
1855      * num_element_value_pairs and then the name,value pairs).
1856      *
1857      * @param context
1858      *            information about the class being parsed. This is where the
1859      *            extracted target_type and target_path must be stored.
1860      * @param u
1861      *            the start offset of a type_annotation structure.
1862      * @return the start offset of the rest of the type_annotation structure.
1863      */
1864     private int readAnnotationTarget(final Context context, int u) {
1865         int target = readInt(u);
1866         switch (target >>> 24) {
1867         case 0x00: // CLASS_TYPE_PARAMETER
1868         case 0x01: // METHOD_TYPE_PARAMETER
1869         case 0x16: // METHOD_FORMAL_PARAMETER
1870             target &= 0xFFFF0000;
1871             u += 2;
1872             break;
1873         case 0x13: // FIELD
1874         case 0x14: // METHOD_RETURN
1875         case 0x15: // METHOD_RECEIVER
1876             target &= 0xFF000000;
1877             u += 1;
1878             break;
1879         case 0x40: // LOCAL_VARIABLE
1880         case 0x41: { // RESOURCE_VARIABLE
1881             target &= 0xFF000000;
1882             int n = readUnsignedShort(u + 1);
1883             context.start = new Label[n];
1884             context.end = new Label[n];
1885             context.index = new int[n];
1886             u += 3;
1887             for (int i = 0; i < n; ++i) {
1888                 int start = readUnsignedShort(u);
1889                 int length = readUnsignedShort(u + 2);
1890                 context.start[i] = createLabel(start, context.labels);
1891                 context.end[i] = createLabel(start + length, context.labels);
1892                 context.index[i] = readUnsignedShort(u + 4);
1893                 u += 6;
1894             }
1895             break;
1896         }
1897         case 0x47: // CAST
1898         case 0x48: // CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT
1899         case 0x49: // METHOD_INVOCATION_TYPE_ARGUMENT
1900         case 0x4A: // CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT
1901         case 0x4B: // METHOD_REFERENCE_TYPE_ARGUMENT
1902             target &= 0xFF0000FF;
1903             u += 4;
1904             break;
1905         // case 0x10: // CLASS_EXTENDS
1906         // case 0x11: // CLASS_TYPE_PARAMETER_BOUND
1907         // case 0x12: // METHOD_TYPE_PARAMETER_BOUND
1908         // case 0x17: // THROWS
1909         // case 0x42: // EXCEPTION_PARAMETER
1910         // case 0x43: // INSTANCEOF
1911         // case 0x44: // NEW
1912         // case 0x45: // CONSTRUCTOR_REFERENCE
1913         // case 0x46: // METHOD_REFERENCE
1914         default:
1915             target &= (target >>> 24) < 0x43 ? 0xFFFFFF00 : 0xFF000000;
1916             u += 3;
1917             break;
1918         }
1919         int pathLength = readByte(u);
1920         context.typeRef = target;
1921         context.typePath = pathLength == 0 ? null : new TypePath(b, u);
1922         return u + 1 + 2 * pathLength;
1923     }
1924 
1925     /**
1926      * Reads parameter annotations and makes the given visitor visit them.
1927      *
1928      * @param mv
1929      *            the visitor that must visit the annotations.
1930      * @param context
1931      *            information about the class being parsed.
1932      * @param v
1933      *            start offset in {@link #b b} of the annotations to be read.
1934      * @param visible
1935      *            <tt>true</tt> if the annotations to be read are visible at
1936      *            runtime.
1937      */
1938     private void readParameterAnnotations(final MethodVisitor mv,
1939             final Context context, int v, final boolean visible) {
1940         int i;
1941         int n = b[v++] & 0xFF;
1942         // workaround for a bug in javac (javac compiler generates a parameter
1943         // annotation array whose size is equal to the number of parameters in
1944         // the Java source file, while it should generate an array whose size is
1945         // equal to the number of parameters in the method descriptor - which
1946         // includes the synthetic parameters added by the compiler). This work-
1947         // around supposes that the synthetic parameters are the first ones.
1948         int synthetics = Type.getArgumentTypes(context.desc).length - n;
1949         AnnotationVisitor av;
1950         for (i = 0; i < synthetics; ++i) {
1951             // virtual annotation to detect synthetic parameters in MethodWriter
1952             av = mv.visitParameterAnnotation(i, "Ljava/lang/Synthetic;", false);
1953             if (av != null) {
1954                 av.visitEnd();
1955             }
1956         }
1957         char[] c = context.buffer;
1958         for (; i < n + synthetics; ++i) {
1959             int j = readUnsignedShort(v);
1960             v += 2;
1961             for (; j > 0; --j) {
1962                 av = mv.visitParameterAnnotation(i, readUTF8(v, c), visible);
1963                 v = readAnnotationValues(v + 2, c, true, av);
1964             }
1965         }
1966     }
1967 
1968     /**
1969      * Reads the values of an annotation and makes the given visitor visit them.
1970      *
1971      * @param v
1972      *            the start offset in {@link #b b} of the values to be read
1973      *            (including the unsigned short that gives the number of
1974      *            values).
1975      * @param buf
1976      *            buffer to be used to call {@link #readUTF8 readUTF8},
1977      *            {@link #readClass(int,char[]) readClass} or {@link #readConst
1978      *            readConst}.
1979      * @param named
1980      *            if the annotation values are named or not.
1981      * @param av
1982      *            the visitor that must visit the values.
1983      * @return the end offset of the annotation values.
1984      */
1985     private int readAnnotationValues(int v, final char[] buf,
1986             final boolean named, final AnnotationVisitor av) {
1987         int i = readUnsignedShort(v);
1988         v += 2;
1989         if (named) {
1990             for (; i > 0; --i) {
1991                 v = readAnnotationValue(v + 2, buf, readUTF8(v, buf), av);
1992             }
1993         } else {
1994             for (; i > 0; --i) {
1995                 v = readAnnotationValue(v, buf, null, av);
1996             }
1997         }
1998         if (av != null) {
1999             av.visitEnd();
2000         }
2001         return v;
2002     }
2003 
2004     /**
2005      * Reads a value of an annotation and makes the given visitor visit it.
2006      *
2007      * @param v
2008      *            the start offset in {@link #b b} of the value to be read
2009      *            (<i>not including the value name constant pool index</i>).
2010      * @param buf
2011      *            buffer to be used to call {@link #readUTF8 readUTF8},
2012      *            {@link #readClass(int,char[]) readClass} or {@link #readConst
2013      *            readConst}.
2014      * @param name
2015      *            the name of the value to be read.
2016      * @param av
2017      *            the visitor that must visit the value.
2018      * @return the end offset of the annotation value.
2019      */
2020     private int readAnnotationValue(int v, final char[] buf, final String name,
2021             final AnnotationVisitor av) {
2022         int i;
2023         if (av == null) {
2024             switch (b[v] & 0xFF) {
2025             case 'e': // enum_const_value
2026                 return v + 5;
2027             case '@': // annotation_value
2028                 return readAnnotationValues(v + 3, buf, true, null);
2029             case '[': // array_value
2030                 return readAnnotationValues(v + 1, buf, false, null);
2031             default:
2032                 return v + 3;
2033             }
2034         }
2035         switch (b[v++] & 0xFF) {
2036         case 'I': // pointer to CONSTANT_Integer
2037         case 'J': // pointer to CONSTANT_Long
2038         case 'F': // pointer to CONSTANT_Float
2039         case 'D': // pointer to CONSTANT_Double
2040             av.visit(name, readConst(readUnsignedShort(v), buf));
2041             v += 2;
2042             break;
2043         case 'B': // pointer to CONSTANT_Byte
2044             av.visit(name, (byte) readInt(items[readUnsignedShort(v)]));
2045             v += 2;
2046             break;
2047         case 'Z': // pointer to CONSTANT_Boolean
2048             av.visit(name,
2049                     readInt(items[readUnsignedShort(v)]) == 0 ? Boolean.FALSE
2050                             : Boolean.TRUE);
2051             v += 2;
2052             break;
2053         case 'S': // pointer to CONSTANT_Short
2054             av.visit(name, (short) readInt(items[readUnsignedShort(v)]));
2055             v += 2;
2056             break;
2057         case 'C': // pointer to CONSTANT_Char
2058             av.visit(name, (char) readInt(items[readUnsignedShort(v)]));
2059             v += 2;
2060             break;
2061         case 's': // pointer to CONSTANT_Utf8
2062             av.visit(name, readUTF8(v, buf));
2063             v += 2;
2064             break;
2065         case 'e': // enum_const_value
2066             av.visitEnum(name, readUTF8(v, buf), readUTF8(v + 2, buf));
2067             v += 4;
2068             break;
2069         case 'c': // class_info
2070             av.visit(name, Type.getType(readUTF8(v, buf)));
2071             v += 2;
2072             break;
2073         case '@': // annotation_value
2074             v = readAnnotationValues(v + 2, buf, true,
2075                     av.visitAnnotation(name, readUTF8(v, buf)));
2076             break;
2077         case '[': // array_value
2078             int size = readUnsignedShort(v);
2079             v += 2;
2080             if (size == 0) {
2081                 return readAnnotationValues(v - 2, buf, false,
2082                         av.visitArray(name));
2083             }
2084             switch (this.b[v++] & 0xFF) {
2085             case 'B':
2086                 byte[] bv = new byte[size];
2087                 for (i = 0; i < size; i++) {
2088                     bv[i] = (byte) readInt(items[readUnsignedShort(v)]);
2089                     v += 3;
2090                 }
2091                 av.visit(name, bv);
2092                 --v;
2093                 break;
2094             case 'Z':
2095                 boolean[] zv = new boolean[size];
2096                 for (i = 0; i < size; i++) {
2097                     zv[i] = readInt(items[readUnsignedShort(v)]) != 0;
2098                     v += 3;
2099                 }
2100                 av.visit(name, zv);
2101                 --v;
2102                 break;
2103             case 'S':
2104                 short[] sv = new short[size];
2105                 for (i = 0; i < size; i++) {
2106                     sv[i] = (short) readInt(items[readUnsignedShort(v)]);
2107                     v += 3;
2108                 }
2109                 av.visit(name, sv);
2110                 --v;
2111                 break;
2112             case 'C':
2113                 char[] cv = new char[size];
2114                 for (i = 0; i < size; i++) {
2115                     cv[i] = (char) readInt(items[readUnsignedShort(v)]);
2116                     v += 3;
2117                 }
2118                 av.visit(name, cv);
2119                 --v;
2120                 break;
2121             case 'I':
2122                 int[] iv = new int[size];
2123                 for (i = 0; i < size; i++) {
2124                     iv[i] = readInt(items[readUnsignedShort(v)]);
2125                     v += 3;
2126                 }
2127                 av.visit(name, iv);
2128                 --v;
2129                 break;
2130             case 'J':
2131                 long[] lv = new long[size];
2132                 for (i = 0; i < size; i++) {
2133                     lv[i] = readLong(items[readUnsignedShort(v)]);
2134                     v += 3;
2135                 }
2136                 av.visit(name, lv);
2137                 --v;
2138                 break;
2139             case 'F':
2140                 float[] fv = new float[size];
2141                 for (i = 0; i < size; i++) {
2142                     fv[i] = Float
2143                             .intBitsToFloat(readInt(items[readUnsignedShort(v)]));
2144                     v += 3;
2145                 }
2146                 av.visit(name, fv);
2147                 --v;
2148                 break;
2149             case 'D':
2150                 double[] dv = new double[size];
2151                 for (i = 0; i < size; i++) {
2152                     dv[i] = Double
2153                             .longBitsToDouble(readLong(items[readUnsignedShort(v)]));
2154                     v += 3;
2155                 }
2156                 av.visit(name, dv);
2157                 --v;
2158                 break;
2159             default:
2160                 v = readAnnotationValues(v - 3, buf, false, av.visitArray(name));
2161             }
2162         }
2163         return v;
2164     }
2165 
2166     /**
2167      * Computes the implicit frame of the method currently being parsed (as
2168      * defined in the given {@link Context}) and stores it in the given context.
2169      *
2170      * @param frame
2171      *            information about the class being parsed.
2172      */
2173     private void getImplicitFrame(final Context frame) {
2174         String desc = frame.desc;
2175         Object[] locals = frame.local;
2176         int local = 0;
2177         if ((frame.access & Opcodes.ACC_STATIC) == 0) {
2178             if ("<init>".equals(frame.name)) {
2179                 locals[local++] = Opcodes.UNINITIALIZED_THIS;
2180             } else {
2181                 locals[local++] = readClass(header + 2, frame.buffer);
2182             }
2183         }
2184         int i = 1;
2185         loop: while (true) {
2186             int j = i;
2187             switch (desc.charAt(i++)) {
2188             case 'Z':
2189             case 'C':
2190             case 'B':
2191             case 'S':
2192             case 'I':
2193                 locals[local++] = Opcodes.INTEGER;
2194                 break;
2195             case 'F':
2196                 locals[local++] = Opcodes.FLOAT;
2197                 break;
2198             case 'J':
2199                 locals[local++] = Opcodes.LONG;
2200                 break;
2201             case 'D':
2202                 locals[local++] = Opcodes.DOUBLE;
2203                 break;
2204             case '[':
2205                 while (desc.charAt(i) == '[') {
2206                     ++i;
2207                 }
2208                 if (desc.charAt(i) == 'L') {
2209                     ++i;
2210                     while (desc.charAt(i) != ';') {
2211                         ++i;
2212                     }
2213                 }
2214                 locals[local++] = desc.substring(j, ++i);
2215                 break;
2216             case 'L':
2217                 while (desc.charAt(i) != ';') {
2218                     ++i;
2219                 }
2220                 locals[local++] = desc.substring(j + 1, i++);
2221                 break;
2222             default:
2223                 break loop;
2224             }
2225         }
2226         frame.localCount = local;
2227     }
2228 
2229     /**
2230      * Reads a stack map frame and stores the result in the given
2231      * {@link Context} object.
2232      *
2233      * @param stackMap
2234      *            the start offset of a stack map frame in the class file.
2235      * @param zip
2236      *            if the stack map frame at stackMap is compressed or not.
2237      * @param unzip
2238      *            if the stack map frame must be uncompressed.
2239      * @param frame
2240      *            where the parsed stack map frame must be stored.
2241      * @return the offset of the first byte following the parsed frame.
2242      */
2243     private int readFrame(int stackMap, boolean zip, boolean unzip,
2244             Context frame) {
2245         char[] c = frame.buffer;
2246         Label[] labels = frame.labels;
2247         int tag;
2248         int delta;
2249         if (zip) {
2250             tag = b[stackMap++] & 0xFF;
2251         } else {
2252             tag = MethodWriter.FULL_FRAME;
2253             frame.offset = -1;
2254         }
2255         frame.localDiff = 0;
2256         if (tag < MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME) {
2257             delta = tag;
2258             frame.mode = Opcodes.F_SAME;
2259             frame.stackCount = 0;
2260         } else if (tag < MethodWriter.RESERVED) {
2261             delta = tag - MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME;
2262             stackMap = readFrameType(frame.stack, 0, stackMap, c, labels);
2263             frame.mode = Opcodes.F_SAME1;
2264             frame.stackCount = 1;
2265         } else {
2266             delta = readUnsignedShort(stackMap);
2267             stackMap += 2;
2268             if (tag == MethodWriter.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
2269                 stackMap = readFrameType(frame.stack, 0, stackMap, c, labels);
2270                 frame.mode = Opcodes.F_SAME1;
2271                 frame.stackCount = 1;
2272             } else if (tag >= MethodWriter.CHOP_FRAME
2273                     && tag < MethodWriter.SAME_FRAME_EXTENDED) {
2274                 frame.mode = Opcodes.F_CHOP;
2275                 frame.localDiff = MethodWriter.SAME_FRAME_EXTENDED - tag;
2276                 frame.localCount -= frame.localDiff;
2277                 frame.stackCount = 0;
2278             } else if (tag == MethodWriter.SAME_FRAME_EXTENDED) {
2279                 frame.mode = Opcodes.F_SAME;
2280                 frame.stackCount = 0;
2281             } else if (tag < MethodWriter.FULL_FRAME) {
2282                 int local = unzip ? frame.localCount : 0;
2283                 for (int i = tag - MethodWriter.SAME_FRAME_EXTENDED; i > 0; i--) {
2284                     stackMap = readFrameType(frame.local, local++, stackMap, c,
2285                             labels);
2286                 }
2287                 frame.mode = Opcodes.F_APPEND;
2288                 frame.localDiff = tag - MethodWriter.SAME_FRAME_EXTENDED;
2289                 frame.localCount += frame.localDiff;
2290                 frame.stackCount = 0;
2291             } else { // if (tag == FULL_FRAME) {
2292                 frame.mode = Opcodes.F_FULL;
2293                 int n = readUnsignedShort(stackMap);
2294                 stackMap += 2;
2295                 frame.localDiff = n;
2296                 frame.localCount = n;
2297                 for (int local = 0; n > 0; n--) {
2298                     stackMap = readFrameType(frame.local, local++, stackMap, c,
2299                             labels);
2300                 }
2301                 n = readUnsignedShort(stackMap);
2302                 stackMap += 2;
2303                 frame.stackCount = n;
2304                 for (int stack = 0; n > 0; n--) {
2305                     stackMap = readFrameType(frame.stack, stack++, stackMap, c,
2306                             labels);
2307                 }
2308             }
2309         }
2310         frame.offset += delta + 1;
2311         createLabel(frame.offset, labels);
2312         return stackMap;
2313     }
2314 
2315     /**
2316      * Reads a stack map frame type and stores it at the given index in the
2317      * given array.
2318      *
2319      * @param frame
2320      *            the array where the parsed type must be stored.
2321      * @param index
2322      *            the index in 'frame' where the parsed type must be stored.
2323      * @param v
2324      *            the start offset of the stack map frame type to read.
2325      * @param buf
2326      *            a buffer to read strings.
2327      * @param labels
2328      *            the labels of the method currently being parsed, indexed by
2329      *            their offset. If the parsed type is an Uninitialized type, a
2330      *            new label for the corresponding NEW instruction is stored in
2331      *            this array if it does not already exist.
2332      * @return the offset of the first byte after the parsed type.
2333      */
2334     private int readFrameType(final Object[] frame, final int index, int v,
2335             final char[] buf, final Label[] labels) {
2336         int type = b[v++] & 0xFF;
2337         switch (type) {
2338         case 0:
2339             frame[index] = Opcodes.TOP;
2340             break;
2341         case 1:
2342             frame[index] = Opcodes.INTEGER;
2343             break;
2344         case 2:
2345             frame[index] = Opcodes.FLOAT;
2346             break;
2347         case 3:
2348             frame[index] = Opcodes.DOUBLE;
2349             break;
2350         case 4:
2351             frame[index] = Opcodes.LONG;
2352             break;
2353         case 5:
2354             frame[index] = Opcodes.NULL;
2355             break;
2356         case 6:
2357             frame[index] = Opcodes.UNINITIALIZED_THIS;
2358             break;
2359         case 7: // Object
2360             frame[index] = readClass(v, buf);
2361             v += 2;
2362             break;
2363         default: // Uninitialized
2364             frame[index] = createLabel(readUnsignedShort(v), labels);
2365             v += 2;
2366         }
2367         return v;
2368     }
2369 
2370     /**
2371      * Returns the label corresponding to the given offset. The default
2372      * implementation of this method creates a label for the given offset if it
2373      * has not been already created.
2374      *
2375      * @param offset
2376      *            a bytecode offset in a method.
2377      * @param labels
2378      *            the already created labels, indexed by their offset. If a
2379      *            label already exists for offset this method must not create a
2380      *            new one. Otherwise it must store the new label in this array.
2381      * @return a non null Label, which must be equal to labels[offset].
2382      */
2383     protected Label readLabel(int offset, Label[] labels) {
2384         if (labels[offset] == null) {
2385             labels[offset] = new Label();
2386         }
2387         return labels[offset];
2388     }
2389 
2390     /**
2391      * Creates a label without the Label.DEBUG flag set, for the given offset.
2392      * The label is created with a call to {@link #readLabel} and its
2393      * Label.DEBUG flag is cleared.
2394      *
2395      * @param offset
2396      *            a bytecode offset in a method.
2397      * @param labels
2398      *            the already created labels, indexed by their offset.
2399      * @return a Label without the Label.DEBUG flag set.
2400      */
2401     private Label createLabel(int offset, Label[] labels) {
2402       Label label = readLabel(offset, labels);
2403       label.status &= ~Label.DEBUG;
2404       return label;
2405     }
2406 
2407     /**
2408      * Creates a label with the Label.DEBUG flag set, if there is no already
2409      * existing label for the given offset (otherwise does nothing). The label
2410      * is created with a call to {@link #readLabel}.
2411      *
2412      * @param offset
2413      *            a bytecode offset in a method.
2414      * @param labels
2415      *            the already created labels, indexed by their offset.
2416      */
2417     private void createDebugLabel(int offset, Label[] labels) {
2418         if (labels[offset] == null) {
2419             readLabel(offset, labels).status |= Label.DEBUG;
2420         }
2421     }
2422 
2423     /**
2424      * Returns the start index of the attribute_info structure of this class.
2425      *
2426      * @return the start index of the attribute_info structure of this class.
2427      */
2428     private int getAttributes() {
2429         // skips the header
2430         int u = header + 8 + readUnsignedShort(header + 6) * 2;
2431         // skips fields and methods
2432         for (int i = readUnsignedShort(u); i > 0; --i) {
2433             for (int j = readUnsignedShort(u + 8); j > 0; --j) {
2434                 u += 6 + readInt(u + 12);
2435             }
2436             u += 8;
2437         }
2438         u += 2;
2439         for (int i = readUnsignedShort(u); i > 0; --i) {
2440             for (int j = readUnsignedShort(u + 8); j > 0; --j) {
2441                 u += 6 + readInt(u + 12);
2442             }
2443             u += 8;
2444         }
2445         // the attribute_info structure starts just after the methods
2446         return u + 2;
2447     }
2448 
2449     /**
2450      * Reads an attribute in {@link #b b}.
2451      *
2452      * @param attrs
2453      *            prototypes of the attributes that must be parsed during the
2454      *            visit of the class. Any attribute whose type is not equal to
2455      *            the type of one the prototypes is ignored (i.e. an empty
2456      *            {@link Attribute} instance is returned).
2457      * @param type
2458      *            the type of the attribute.
2459      * @param off
2460      *            index of the first byte of the attribute's content in
2461      *            {@link #b b}. The 6 attribute header bytes, containing the
2462      *            type and the length of the attribute, are not taken into
2463      *            account here (they have already been read).
2464      * @param len
2465      *            the length of the attribute's content.
2466      * @param buf
2467      *            buffer to be used to call {@link #readUTF8 readUTF8},
2468      *            {@link #readClass(int,char[]) readClass} or {@link #readConst
2469      *            readConst}.
2470      * @param codeOff
2471      *            index of the first byte of code's attribute content in
2472      *            {@link #b b}, or -1 if the attribute to be read is not a code
2473      *            attribute. The 6 attribute header bytes, containing the type
2474      *            and the length of the attribute, are not taken into account
2475      *            here.
2476      * @param labels
2477      *            the labels of the method's code, or <tt>null</tt> if the
2478      *            attribute to be read is not a code attribute.
2479      * @return the attribute that has been read, or <tt>null</tt> to skip this
2480      *         attribute.
2481      */
2482     private Attribute readAttribute(final Attribute[] attrs, final String type,
2483             final int off, final int len, final char[] buf, final int codeOff,
2484             final Label[] labels) {
2485         for (int i = 0; i < attrs.length; ++i) {
2486             if (attrs[i].type.equals(type)) {
2487                 return attrs[i].read(this, off, len, buf, codeOff, labels);
2488             }
2489         }
2490         return new Attribute(type).read(this, off, len, null, -1, null);
2491     }
2492 
2493     // ------------------------------------------------------------------------
2494     // Utility methods: low level parsing
2495     // ------------------------------------------------------------------------
2496 
2497     /**
2498      * Returns the number of constant pool items in {@link #b b}.
2499      *
2500      * @return the number of constant pool items in {@link #b b}.
2501      */
2502     public int getItemCount() {
2503         return items.length;
2504     }
2505 
2506     /**
2507      * Returns the start index of the constant pool item in {@link #b b}, plus
2508      * one. <i>This method is intended for {@link Attribute} sub classes, and is
2509      * normally not needed by class generators or adapters.</i>
2510      *
2511      * @param item
2512      *            the index a constant pool item.
2513      * @return the start index of the constant pool item in {@link #b b}, plus
2514      *         one.
2515      */
2516     public int getItem(final int item) {
2517         return items[item];
2518     }
2519 
2520     /**
2521      * Returns the maximum length of the strings contained in the constant pool
2522      * of the class.
2523      *
2524      * @return the maximum length of the strings contained in the constant pool
2525      *         of the class.
2526      */
2527     public int getMaxStringLength() {
2528         return maxStringLength;
2529     }
2530 
2531     /**
2532      * Reads a byte value in {@link #b b}. <i>This method is intended for
2533      * {@link Attribute} sub classes, and is normally not needed by class
2534      * generators or adapters.</i>
2535      *
2536      * @param index
2537      *            the start index of the value to be read in {@link #b b}.
2538      * @return the read value.
2539      */
2540     public int readByte(final int index) {
2541         return b[index] & 0xFF;
2542     }
2543 
2544     /**
2545      * Reads an unsigned short value in {@link #b b}. <i>This method is intended
2546      * for {@link Attribute} sub classes, and is normally not needed by class
2547      * generators or adapters.</i>
2548      *
2549      * @param index
2550      *            the start index of the value to be read in {@link #b b}.
2551      * @return the read value.
2552      */
2553     public int readUnsignedShort(final int index) {
2554         byte[] b = this.b;
2555         return ((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF);
2556     }
2557 
2558     /**
2559      * Reads a signed short value in {@link #b b}. <i>This method is intended
2560      * for {@link Attribute} sub classes, and is normally not needed by class
2561      * generators or adapters.</i>
2562      *
2563      * @param index
2564      *            the start index of the value to be read in {@link #b b}.
2565      * @return the read value.
2566      */
2567     public short readShort(final int index) {
2568         byte[] b = this.b;
2569         return (short) (((b[index] & 0xFF) << 8) | (b[index + 1] & 0xFF));
2570     }
2571 
2572     /**
2573      * Reads a signed int value in {@link #b b}. <i>This method is intended for
2574      * {@link Attribute} sub classes, and is normally not needed by class
2575      * generators or adapters.</i>
2576      *
2577      * @param index
2578      *            the start index of the value to be read in {@link #b b}.
2579      * @return the read value.
2580      */
2581     public int readInt(final int index) {
2582         byte[] b = this.b;
2583         return ((b[index] & 0xFF) << 24) | ((b[index + 1] & 0xFF) << 16)
2584                 | ((b[index + 2] & 0xFF) << 8) | (b[index + 3] & 0xFF);
2585     }
2586 
2587     /**
2588      * Reads a signed long value in {@link #b b}. <i>This method is intended for
2589      * {@link Attribute} sub classes, and is normally not needed by class
2590      * generators or adapters.</i>
2591      *
2592      * @param index
2593      *            the start index of the value to be read in {@link #b b}.
2594      * @return the read value.
2595      */
2596     public long readLong(final int index) {
2597         long l1 = readInt(index);
2598         long l0 = readInt(index + 4) & 0xFFFFFFFFL;
2599         return (l1 << 32) | l0;
2600     }
2601 
2602     /**
2603      * Reads an UTF8 string constant pool item in {@link #b b}. <i>This method
2604      * is intended for {@link Attribute} sub classes, and is normally not needed
2605      * by class generators or adapters.</i>
2606      *
2607      * @param index
2608      *            the start index of an unsigned short value in {@link #b b},
2609      *            whose value is the index of an UTF8 constant pool item.
2610      * @param buf
2611      *            buffer to be used to read the item. This buffer must be
2612      *            sufficiently large. It is not automatically resized.
2613      * @return the String corresponding to the specified UTF8 item.
2614      */
2615     public String readUTF8(int index, final char[] buf) {
2616         int item = readUnsignedShort(index);
2617         if (index == 0 || item == 0) {
2618             return null;
2619         }
2620         String s = strings[item];
2621         if (s != null) {
2622             return s;
2623         }
2624         index = items[item];
2625         return strings[item] = readUTF(index + 2, readUnsignedShort(index), buf);
2626     }
2627 
2628     /**
2629      * Reads UTF8 string in {@link #b b}.
2630      *
2631      * @param index
2632      *            start offset of the UTF8 string to be read.
2633      * @param utfLen
2634      *            length of the UTF8 string to be read.
2635      * @param buf
2636      *            buffer to be used to read the string. This buffer must be
2637      *            sufficiently large. It is not automatically resized.
2638      * @return the String corresponding to the specified UTF8 string.
2639      */
2640     private String readUTF(int index, final int utfLen, final char[] buf) {
2641         int endIndex = index + utfLen;
2642         byte[] b = this.b;
2643         int strLen = 0;
2644         int c;
2645         int st = 0;
2646         char cc = 0;
2647         while (index < endIndex) {
2648             c = b[index++];
2649             switch (st) {
2650             case 0:
2651                 c = c & 0xFF;
2652                 if (c < 0x80) { // 0xxxxxxx
2653                     buf[strLen++] = (char) c;
2654                 } else if (c < 0xE0 && c > 0xBF) { // 110x xxxx 10xx xxxx
2655                     cc = (char) (c & 0x1F);
2656                     st = 1;
2657                 } else { // 1110 xxxx 10xx xxxx 10xx xxxx
2658                     cc = (char) (c & 0x0F);
2659                     st = 2;
2660                 }
2661                 break;
2662 
2663             case 1: // byte 2 of 2-byte char or byte 3 of 3-byte char
2664                 buf[strLen++] = (char) ((cc << 6) | (c & 0x3F));
2665                 st = 0;
2666                 break;
2667 
2668             case 2: // byte 2 of 3-byte char
2669                 cc = (char) ((cc << 6) | (c & 0x3F));
2670                 st = 1;
2671                 break;
2672             }
2673         }
2674         return new String(buf, 0, strLen);
2675     }
2676 
2677     /**
2678      * Read a stringish constant item (CONSTANT_Class, CONSTANT_String,
2679      * CONSTANT_MethodType, CONSTANT_Module or CONSTANT_Package
2680      * @param index
2681      * @param buf
2682      * @return
2683      */
2684     private String readStringish(final int index, final char[] buf) {
2685         // computes the start index of the item in b
2686         // and reads the CONSTANT_Utf8 item designated by
2687         // the first two bytes of this item
2688         return readUTF8(items[readUnsignedShort(index)], buf);
2689     }
2690 
2691     /**
2692      * Reads a class constant pool item in {@link #b b}. <i>This method is
2693      * intended for {@link Attribute} sub classes, and is normally not needed by
2694      * class generators or adapters.</i>
2695      *
2696      * @param index
2697      *            the start index of an unsigned short value in {@link #b b},
2698      *            whose value is the index of a class constant pool item.
2699      * @param buf
2700      *            buffer to be used to read the item. This buffer must be
2701      *            sufficiently large. It is not automatically resized.
2702      * @return the String corresponding to the specified class item.
2703      */
2704     public String readClass(final int index, final char[] buf) {
2705         return readStringish(index, buf);
2706     }
2707 
2708     /**
2709      * Reads a module constant pool item in {@link #b b}. <i>This method is
2710      * intended for {@link Attribute} sub classes, and is normally not needed by
2711      * class generators or adapters.</i>
2712      *
2713      * @param index
2714      *            the start index of an unsigned short value in {@link #b b},
2715      *            whose value is the index of a module constant pool item.
2716      * @param buf
2717      *            buffer to be used to read the item. This buffer must be
2718      *            sufficiently large. It is not automatically resized.
2719      * @return the String corresponding to the specified module item.
2720      */
2721     public String readModule(final int index, final char[] buf) {
2722         return readStringish(index, buf);
2723     }
2724 
2725     /**
2726      * Reads a module constant pool item in {@link #b b}. <i>This method is
2727      * intended for {@link Attribute} sub classes, and is normally not needed by
2728      * class generators or adapters.</i>
2729      *
2730      * @param index
2731      *            the start index of an unsigned short value in {@link #b b},
2732      *            whose value is the index of a module constant pool item.
2733      * @param buf
2734      *            buffer to be used to read the item. This buffer must be
2735      *            sufficiently large. It is not automatically resized.
2736      * @return the String corresponding to the specified module item.
2737      */
2738     public String readPackage(final int index, final char[] buf) {
2739         return readStringish(index, buf);
2740     }
2741 
2742     /**
2743      * Reads a numeric or string constant pool item in {@link #b b}. <i>This
2744      * method is intended for {@link Attribute} sub classes, and is normally not
2745      * needed by class generators or adapters.</i>
2746      *
2747      * @param item
2748      *            the index of a constant pool item.
2749      * @param buf
2750      *            buffer to be used to read the item. This buffer must be
2751      *            sufficiently large. It is not automatically resized.
2752      * @return the {@link Integer}, {@link Float}, {@link Long}, {@link Double},
2753      *         {@link String}, {@link Type} or {@link Handle} corresponding to
2754      *         the given constant pool item.
2755      */
2756     public Object readConst(final int item, final char[] buf) {
2757         int index = items[item];
2758         switch (b[index - 1]) {
2759         case ClassWriter.INT:
2760             return readInt(index);
2761         case ClassWriter.FLOAT:
2762             return Float.intBitsToFloat(readInt(index));
2763         case ClassWriter.LONG:
2764             return readLong(index);
2765         case ClassWriter.DOUBLE:
2766             return Double.longBitsToDouble(readLong(index));
2767         case ClassWriter.CLASS:
2768             return Type.getObjectType(readUTF8(index, buf));
2769         case ClassWriter.STR:
2770             return readUTF8(index, buf);
2771         case ClassWriter.MTYPE:
2772             return Type.getMethodType(readUTF8(index, buf));
2773         default: // case ClassWriter.HANDLE_BASE + [1..9]:
2774             int tag = readByte(index);
2775             int[] items = this.items;
2776             int cpIndex = items[readUnsignedShort(index + 1)];
2777             boolean itf = b[cpIndex - 1] == ClassWriter.IMETH;
2778             String owner = readClass(cpIndex, buf);
2779             cpIndex = items[readUnsignedShort(cpIndex + 2)];
2780             String name = readUTF8(cpIndex, buf);
2781             String desc = readUTF8(cpIndex + 2, buf);
2782             return new Handle(tag, owner, name, desc, itf);
2783         }
2784     }
2785 }