https://openjdk.java.net/ 
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * This file is available under and governed by the GNU General Public
 * License version 2 only, as published by the Free Software Foundation.
 * However, the following notice accompanied the original version of this
 * file:
 *
 * ASM: a very small and fast Java bytecode manipulation framework
 * Copyright (c) 2000-2011 INRIA, France Telecom
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the copyright holders nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */
package jdk.internal.org.objectweb.asm;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;


A parser to make a ClassVisitor visit a ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS). This class parses the ClassFile content and calls the appropriate visit methods of a given ClassVisitor for each field, method and bytecode instruction encountered. 
Author:Eric Bruneton, Eugene Kuleshov
See Also:
/**
 * A parser to make a {@link ClassVisitor} visit a ClassFile structure, as defined in the Java
 * Virtual Machine Specification (JVMS). This class parses the ClassFile content and calls the
 * appropriate visit methods of a given {@link ClassVisitor} for each field, method and bytecode
 * instruction encountered.
 *
 * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html">JVMS 4</a>
 * @author Eric Bruneton
 * @author Eugene Kuleshov
 */
public class ClassReader {

    
A flag to skip the Code attributes. If this flag is set the Code attributes are neither parsed
nor visited.

/**
      * A flag to skip the Code attributes. If this flag is set the Code attributes are neither parsed
      * nor visited.
      */
    public static final int SKIP_CODE = 1;

    
A flag to skip the SourceFile, SourceDebugExtension, LocalVariableTable, LocalVariableTypeTable, LineNumberTable and MethodParameters attributes. If this flag is set these attributes are neither parsed nor visited (i.e. ClassVisitor.visitSource, MethodVisitor.visitLocalVariable, MethodVisitor.visitLineNumber and MethodVisitor.visitParameter are not called). 
/**
      * A flag to skip the SourceFile, SourceDebugExtension, LocalVariableTable,
      * LocalVariableTypeTable, LineNumberTable and MethodParameters attributes. If this flag is set
      * these attributes are neither parsed nor visited (i.e. {@link ClassVisitor#visitSource}, {@link
      * MethodVisitor#visitLocalVariable}, {@link MethodVisitor#visitLineNumber} and {@link
      * MethodVisitor#visitParameter} are not called).
      */
    public static final int SKIP_DEBUG = 2;

    
A flag to skip the StackMap and StackMapTable attributes. If this flag is set these attributes are neither parsed nor visited (i.e. MethodVisitor.visitFrame is not called). This flag is useful when the ClassWriter.COMPUTE_FRAMES option is used: it avoids visiting frames that will be ignored and recomputed from scratch. 
/**
      * A flag to skip the StackMap and StackMapTable attributes. If this flag is set these attributes
      * are neither parsed nor visited (i.e. {@link MethodVisitor#visitFrame} is not called). This flag
      * is useful when the {@link ClassWriter#COMPUTE_FRAMES} option is used: it avoids visiting frames
      * that will be ignored and recomputed from scratch.
      */
    public static final int SKIP_FRAMES = 4;

    
A flag to expand the stack map frames. By default stack map frames are visited in their
original format (i.e. "expanded" for classes whose version is less than V1_6, and "compressed"
for the other classes). If this flag is set, stack map frames are always visited in expanded
format (this option adds a decompression/compression step in ClassReader and ClassWriter which
degrades performance quite a lot).

/**
      * A flag to expand the stack map frames. By default stack map frames are visited in their
      * original format (i.e. "expanded" for classes whose version is less than V1_6, and "compressed"
      * for the other classes). If this flag is set, stack map frames are always visited in expanded
      * format (this option adds a decompression/compression step in ClassReader and ClassWriter which
      * degrades performance quite a lot).
      */
    public static final int EXPAND_FRAMES = 8;

    
A flag to expand the ASM specific instructions into an equivalent sequence of standard bytecode instructions. When resolving a forward jump it may happen that the signed 2 bytes offset reserved for it is not sufficient to store the bytecode offset. In this case the jump instruction is replaced with a temporary ASM specific instruction using an unsigned 2 bytes offset (see Label.resolve). This internal flag is used to re-read classes containing such instructions, in order to replace them with standard instructions. In addition, when this flag is used, goto_w and jsr_w are not converted into goto and jsr, to make sure that
infinite loops where a goto_w is replaced with a goto in ClassReader and converted back to a
goto_w in ClassWriter cannot occur.

/**
      * A flag to expand the ASM specific instructions into an equivalent sequence of standard bytecode
      * instructions. When resolving a forward jump it may happen that the signed 2 bytes offset
      * reserved for it is not sufficient to store the bytecode offset. In this case the jump
      * instruction is replaced with a temporary ASM specific instruction using an unsigned 2 bytes
      * offset (see {@link Label#resolve}). This internal flag is used to re-read classes containing
      * such instructions, in order to replace them with standard instructions. In addition, when this
      * flag is used, goto_w and jsr_w are <i>not</i> converted into goto and jsr, to make sure that
      * infinite loops where a goto_w is replaced with a goto in ClassReader and converted back to a
      * goto_w in ClassWriter cannot occur.
      */
    static final int EXPAND_ASM_INSNS = 256;

    
The size of the temporary byte array used to read class input streams chunk by chunk. 
/** The size of the temporary byte array used to read class input streams chunk by chunk. */
    private static final int INPUT_STREAM_DATA_CHUNK_SIZE = 4096;

    
A byte array containing the JVMS ClassFile structure to be parsed.

Deprecated:Use readByte(int) and the other read methods instead. This field will eventually be deleted.
/**
      * A byte array containing the JVMS ClassFile structure to be parsed.
      *
      * @deprecated Use {@link #readByte(int)} and the other read methods instead. This field will
      *     eventually be deleted.
      */
    @Deprecated
    // DontCheck(MemberName): can't be renamed (for backward binary compatibility).
    public final byte[] b;

    
A byte array containing the JVMS ClassFile structure to be parsed. The content of this array must not be modified. This field is intended for Attribute sub classes, and is normally not needed by class visitors.

NOTE: the ClassFile structure can start at any offset within this array, i.e. it does not necessarily start at offset 0. Use getItem and header to get correct ClassFile element offsets within this byte array. 
/**
      * A byte array containing the JVMS ClassFile structure to be parsed. <i>The content of this array
      * must not be modified. This field is intended for {@link Attribute} sub classes, and is normally
      * not needed by class visitors.</i>
      *
      * <p>NOTE: the ClassFile structure can start at any offset within this array, i.e. it does not
      * necessarily start at offset 0. Use {@link #getItem} and {@link #header} to get correct
      * ClassFile element offsets within this byte array.
      */
    final byte[] classFileBuffer;

    
The offset in bytes, in classFileBuffer, of each cp_info entry of the ClassFile's constant_pool array, plus one. In other words, the offset of constant pool entry i is
given by cpInfoOffsets[i] - 1, i.e. its cp_info's tag field is given by b[cpInfoOffsets[i] -
1].

/**
      * The offset in bytes, in {@link #classFileBuffer}, of each cp_info entry of the ClassFile's
      * constant_pool array, <i>plus one</i>. In other words, the offset of constant pool entry i is
      * given by cpInfoOffsets[i] - 1, i.e. its cp_info's tag field is given by b[cpInfoOffsets[i] -
      * 1].
      */
    private final int[] cpInfoOffsets;

    
The String objects corresponding to the CONSTANT_Utf8 constant pool items. This cache avoids
multiple parsing of a given CONSTANT_Utf8 constant pool item.

/**
      * The String objects corresponding to the CONSTANT_Utf8 constant pool items. This cache avoids
      * multiple parsing of a given CONSTANT_Utf8 constant pool item.
      */
    private final String[] constantUtf8Values;

    
The ConstantDynamic objects corresponding to the CONSTANT_Dynamic constant pool items. This
cache avoids multiple parsing of a given CONSTANT_Dynamic constant pool item.

/**
      * The ConstantDynamic objects corresponding to the CONSTANT_Dynamic constant pool items. This
      * cache avoids multiple parsing of a given CONSTANT_Dynamic constant pool item.
      */
    private final ConstantDynamic[] constantDynamicValues;

    
The start offsets in classFileBuffer of each element of the bootstrap_methods array (in the BootstrapMethods attribute). 
See Also:
/**
      * The start offsets in {@link #classFileBuffer} of each element of the bootstrap_methods array
      * (in the BootstrapMethods attribute).
      *
      * @see <a href="https://docs.oracle.com/javase/specs/jvms/se9/html/jvms-4.html#jvms-4.7.23">JVMS
      *     4.7.23</a>
      */
    private final int[] bootstrapMethodOffsets;

    
A conservative estimate of the maximum length of the strings contained in the constant pool of
the class.

/**
      * A conservative estimate of the maximum length of the strings contained in the constant pool of
      * the class.
      */
    private final int maxStringLength;

    
The offset in bytes of the ClassFile's access_flags field. 
/** The offset in bytes of the ClassFile's access_flags field. */
    public final int header;

    // -----------------------------------------------------------------------------------------------
    // Constructors
    // -----------------------------------------------------------------------------------------------

    
Constructs a new ClassReader object. 
Params:
  • classFile – the JVMS ClassFile structure to be read.
/**
      * Constructs a new {@link ClassReader} object.
      *
      * @param classFile the JVMS ClassFile structure to be read.
      */
    public ClassReader(final byte[] classFile) {
        this(classFile, 0, classFile.length);
    }

    
Constructs a new ClassReader object. 
Params:
  • classFileBuffer – a byte array containing the JVMS ClassFile structure to be read.
  • classFileOffset – the offset in byteBuffer of the first byte of the ClassFile to be read.
  • classFileLength – the length in bytes of the ClassFile to be read.
/**
      * Constructs a new {@link ClassReader} object.
      *
      * @param classFileBuffer a byte array containing the JVMS ClassFile structure to be read.
      * @param classFileOffset the offset in byteBuffer of the first byte of the ClassFile to be read.
      * @param classFileLength the length in bytes of the ClassFile to be read.
      */
    public ClassReader(
            final byte[] classFileBuffer,
            final int classFileOffset,
            final int classFileLength) { // NOPMD(UnusedFormalParameter) used for backward compatibility.
        this(classFileBuffer, classFileOffset, /* checkClassVersion = */ true);
    }

    
Constructs a new ClassReader object. This internal constructor must not be exposed
as a public API.

Params:
  • classFileBuffer – a byte array containing the JVMS ClassFile structure to be read.
  • classFileOffset – the offset in byteBuffer of the first byte of the ClassFile to be read.
  • checkClassVersion – whether to check the class version or not.
/**
      * Constructs a new {@link ClassReader} object. <i>This internal constructor must not be exposed
      * as a public API</i>.
      *
      * @param classFileBuffer a byte array containing the JVMS ClassFile structure to be read.
      * @param classFileOffset the offset in byteBuffer of the first byte of the ClassFile to be read.
      * @param checkClassVersion whether to check the class version or not.
      */
    ClassReader(
            final byte[] classFileBuffer, final int classFileOffset, final boolean checkClassVersion) {
        this.classFileBuffer = classFileBuffer;
        this.b = classFileBuffer;
        // Check the class' major_version. This field is after the magic and minor_version fields, which
        // use 4 and 2 bytes respectively.
        if (checkClassVersion && readShort(classFileOffset + 6) > Opcodes.V16) {
            throw new IllegalArgumentException(
                    "Unsupported class file major version " + readShort(classFileOffset + 6));
        }
        // Create the constant pool arrays. The constant_pool_count field is after the magic,
        // minor_version and major_version fields, which use 4, 2 and 2 bytes respectively.
        int constantPoolCount = readUnsignedShort(classFileOffset + 8);
        cpInfoOffsets = new int[constantPoolCount];
        constantUtf8Values = new String[constantPoolCount];
        // Compute the offset of each constant pool entry, as well as a conservative estimate of the
        // maximum length of the constant pool strings. The first constant pool entry is after the
        // magic, minor_version, major_version and constant_pool_count fields, which use 4, 2, 2 and 2
        // bytes respectively.
        int currentCpInfoIndex = 1;
        int currentCpInfoOffset = classFileOffset + 10;
        int currentMaxStringLength = 0;
        boolean hasBootstrapMethods = false;
        boolean hasConstantDynamic = false;
        // The offset of the other entries depend on the total size of all the previous entries.
        while (currentCpInfoIndex < constantPoolCount) {
            cpInfoOffsets[currentCpInfoIndex++] = currentCpInfoOffset + 1;
            int cpInfoSize;
            switch (classFileBuffer[currentCpInfoOffset]) {
                case Symbol.CONSTANT_FIELDREF_TAG:
                case Symbol.CONSTANT_METHODREF_TAG:
                case Symbol.CONSTANT_INTERFACE_METHODREF_TAG:
                case Symbol.CONSTANT_INTEGER_TAG:
                case Symbol.CONSTANT_FLOAT_TAG:
                case Symbol.CONSTANT_NAME_AND_TYPE_TAG:
                    cpInfoSize = 5;
                    break;
                case Symbol.CONSTANT_DYNAMIC_TAG:
                    cpInfoSize = 5;
                    hasBootstrapMethods = true;
                    hasConstantDynamic = true;
                    break;
                case Symbol.CONSTANT_INVOKE_DYNAMIC_TAG:
                    cpInfoSize = 5;
                    hasBootstrapMethods = true;
                    break;
                case Symbol.CONSTANT_LONG_TAG:
                case Symbol.CONSTANT_DOUBLE_TAG:
                    cpInfoSize = 9;
                    currentCpInfoIndex++;
                    break;
                case Symbol.CONSTANT_UTF8_TAG:
                    cpInfoSize = 3 + readUnsignedShort(currentCpInfoOffset + 1);
                    if (cpInfoSize > currentMaxStringLength) {
                        // The size in bytes of this CONSTANT_Utf8 structure provides a conservative estimate
                        // of the length in characters of the corresponding string, and is much cheaper to
                        // compute than this exact length.
                        currentMaxStringLength = cpInfoSize;
                    }
                    break;
                case Symbol.CONSTANT_METHOD_HANDLE_TAG:
                    cpInfoSize = 4;
                    break;
                case Symbol.CONSTANT_CLASS_TAG:
                case Symbol.CONSTANT_STRING_TAG:
                case Symbol.CONSTANT_METHOD_TYPE_TAG:
                case Symbol.CONSTANT_PACKAGE_TAG:
                case Symbol.CONSTANT_MODULE_TAG:
                    cpInfoSize = 3;
                    break;
                default:
                    throw new IllegalArgumentException();
            }
            currentCpInfoOffset += cpInfoSize;
        }
        maxStringLength = currentMaxStringLength;
        // The Classfile's access_flags field is just after the last constant pool entry.
        header = currentCpInfoOffset;

        // Allocate the cache of ConstantDynamic values, if there is at least one.
        constantDynamicValues = hasConstantDynamic ? new ConstantDynamic[constantPoolCount] : null;

        // Read the BootstrapMethods attribute, if any (only get the offset of each method).
        bootstrapMethodOffsets =
                hasBootstrapMethods ? readBootstrapMethodsAttribute(currentMaxStringLength) : null;
    }

    
Constructs a new ClassReader object. 
Params:
  • inputStream – an input stream of the JVMS ClassFile structure to be read. This input
    stream must contain nothing more than the ClassFile structure itself. It is read from its
    current position to its end.
Throws:
/**
      * Constructs a new {@link ClassReader} object.
      *
      * @param inputStream an input stream of the JVMS ClassFile structure to be read. This input
      *     stream must contain nothing more than the ClassFile structure itself. It is read from its
      *     current position to its end.
      * @throws IOException if a problem occurs during reading.
      */
    public ClassReader(final InputStream inputStream) throws IOException {
        this(readStream(inputStream, false));
    }

    
Constructs a new ClassReader object. 
Params:
Throws:
/**
      * Constructs a new {@link ClassReader} object.
      *
      * @param className the fully qualified name of the class to be read. The ClassFile structure is
      *     retrieved with the current class loader's {@link ClassLoader#getSystemResourceAsStream}.
      * @throws IOException if an exception occurs during reading.
      */
    public ClassReader(final String className) throws IOException {
        this(
                readStream(
                        ClassLoader.getSystemResourceAsStream(className.replace('.', '/') + ".class"), true));
    }

    
Reads the given input stream and returns its content as a byte array.

Params:
  • inputStream – an input stream.
  • close – true to close the input stream after reading.
Throws:
Returns:the content of the given input stream.
/**
      * Reads the given input stream and returns its content as a byte array.
      *
      * @param inputStream an input stream.
      * @param close true to close the input stream after reading.
      * @return the content of the given input stream.
      * @throws IOException if a problem occurs during reading.
      */
    private static byte[] readStream(final InputStream inputStream, final boolean close)
            throws IOException {
        if (inputStream == null) {
            throw new IOException("Class not found");
        }
        try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream()) {
            byte[] data = new byte[INPUT_STREAM_DATA_CHUNK_SIZE];
            int bytesRead;
            while ((bytesRead = inputStream.read(data, 0, data.length)) != -1) {
                outputStream.write(data, 0, bytesRead);
            }
            outputStream.flush();
            return outputStream.toByteArray();
        } finally {
            if (close) {
                inputStream.close();
            }
        }
    }

    // -----------------------------------------------------------------------------------------------
    // Accessors
    // -----------------------------------------------------------------------------------------------

    
Returns the class's access flags (see Opcodes). This value may not reflect Deprecated and Synthetic flags when bytecode is before 1.5 and those flags are represented by attributes. 
See Also:
Returns:the class access flags.
/**
      * Returns the class's access flags (see {@link Opcodes}). This value may not reflect Deprecated
      * and Synthetic flags when bytecode is before 1.5 and those flags are represented by attributes.
      *
      * @return the class access flags.
      * @see ClassVisitor#visit(int, int, String, String, String, String[])
      */
    public int getAccess() {
        return readUnsignedShort(header);
    }

    
Returns the internal name of the class (see Type.getInternalName()). 
See Also:
Returns:the internal class name.
/**
      * Returns the internal name of the class (see {@link Type#getInternalName()}).
      *
      * @return the internal class name.
      * @see ClassVisitor#visit(int, int, String, String, String, String[])
      */
    public String getClassName() {
        // this_class is just after the access_flags field (using 2 bytes).
        return readClass(header + 2, new char[maxStringLength]);
    }

    
Returns the internal of name of the super class (see Type.getInternalName()). For interfaces, the super class is Object. 
See Also:
Returns:the internal name of the super class, or null for Object class.
/**
      * Returns the internal of name of the super class (see {@link Type#getInternalName()}). For
      * interfaces, the super class is {@link Object}.
      *
      * @return the internal name of the super class, or {@literal null} for {@link Object} class.
      * @see ClassVisitor#visit(int, int, String, String, String, String[])
      */
    public String getSuperName() {
        // super_class is after the access_flags and this_class fields (2 bytes each).
        return readClass(header + 4, new char[maxStringLength]);
    }

    
Returns the internal names of the implemented interfaces (see Type.getInternalName()). 
See Also:
Returns:the internal names of the directly implemented interfaces. Inherited implemented
    interfaces are not returned.
/**
      * Returns the internal names of the implemented interfaces (see {@link Type#getInternalName()}).
      *
      * @return the internal names of the directly implemented interfaces. Inherited implemented
      *     interfaces are not returned.
      * @see ClassVisitor#visit(int, int, String, String, String, String[])
      */
    public String[] getInterfaces() {
        // interfaces_count is after the access_flags, this_class and super_class fields (2 bytes each).
        int currentOffset = header + 6;
        int interfacesCount = readUnsignedShort(currentOffset);
        String[] interfaces = new String[interfacesCount];
        if (interfacesCount > 0) {
            char[] charBuffer = new char[maxStringLength];
            for (int i = 0; i < interfacesCount; ++i) {
                currentOffset += 2;
                interfaces[i] = readClass(currentOffset, charBuffer);
            }
        }
        return interfaces;
    }

    // -----------------------------------------------------------------------------------------------
    // Public methods
    // -----------------------------------------------------------------------------------------------

    
Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this ClassReader. 
Params:
/**
      * Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this
      * {@link ClassReader}.
      *
      * @param classVisitor the visitor that must visit this class.
      * @param parsingOptions the options to use to parse this class. One or more of {@link
      *     #SKIP_CODE}, {@link #SKIP_DEBUG}, {@link #SKIP_FRAMES} or {@link #EXPAND_FRAMES}.
      */
    public void accept(final ClassVisitor classVisitor, final int parsingOptions) {
        accept(classVisitor, new Attribute[0], parsingOptions);
    }

    
Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this ClassReader. 
Params:
  • classVisitor – the visitor that must visit this class.
  • attributePrototypes – prototypes of the attributes that must be parsed during the visit of
    the class. Any attribute whose type is not equal to the type of one the prototypes will not
    be parsed: its byte array value will be passed unchanged to the ClassWriter. This may
    corrupt it if this value contains references to the constant pool, or has syntactic or
    semantic links with a class element that has been transformed by a class adapter between
    the reader and the writer.
  • parsingOptions – the options to use to parse this class. One or more of SKIP_CODE, SKIP_DEBUG, SKIP_FRAMES or EXPAND_FRAMES.
/**
      * Makes the given visitor visit the JVMS ClassFile structure passed to the constructor of this
      * {@link ClassReader}.
      *
      * @param classVisitor the visitor that must visit this class.
      * @param attributePrototypes prototypes of the attributes that must be parsed during the visit of
      *     the class. Any attribute whose type is not equal to the type of one the prototypes will not
      *     be parsed: its byte array value will be passed unchanged to the ClassWriter. <i>This may
      *     corrupt it if this value contains references to the constant pool, or has syntactic or
      *     semantic links with a class element that has been transformed by a class adapter between
      *     the reader and the writer</i>.
      * @param parsingOptions the options to use to parse this class. One or more of {@link
      *     #SKIP_CODE}, {@link #SKIP_DEBUG}, {@link #SKIP_FRAMES} or {@link #EXPAND_FRAMES}.
      */
    @SuppressWarnings("deprecation")
    public void accept(
            final ClassVisitor classVisitor,
            final Attribute[] attributePrototypes,
            final int parsingOptions) {
        Context context = new Context();
        context.attributePrototypes = attributePrototypes;
        context.parsingOptions = parsingOptions;
        context.charBuffer = new char[maxStringLength];

        // Read the access_flags, this_class, super_class, interface_count and interfaces fields.
        char[] charBuffer = context.charBuffer;
        int currentOffset = header;
        int accessFlags = readUnsignedShort(currentOffset);
        String thisClass = readClass(currentOffset + 2, charBuffer);
        String superClass = readClass(currentOffset + 4, charBuffer);
        String[] interfaces = new String[readUnsignedShort(currentOffset + 6)];
        currentOffset += 8;
        for (int i = 0; i < interfaces.length; ++i) {
            interfaces[i] = readClass(currentOffset, charBuffer);
            currentOffset += 2;
        }

        // Read the class attributes (the variables are ordered as in Section 4.7 of the JVMS).
        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
        // - The offset of the InnerClasses attribute, or 0.
        int innerClassesOffset = 0;
        // - The offset of the EnclosingMethod attribute, or 0.
        int enclosingMethodOffset = 0;
        // - The string corresponding to the Signature attribute, or null.
        String signature = null;
        // - The string corresponding to the SourceFile attribute, or null.
        String sourceFile = null;
        // - The string corresponding to the SourceDebugExtension attribute, or null.
        String sourceDebugExtension = null;
        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
        int runtimeVisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
        int runtimeInvisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
        int runtimeVisibleTypeAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
        int runtimeInvisibleTypeAnnotationsOffset = 0;
        // - The offset of the Module attribute, or 0.
        int moduleOffset = 0;
        // - The offset of the ModulePackages attribute, or 0.
        int modulePackagesOffset = 0;
        // - The string corresponding to the ModuleMainClass attribute, or null.
        String moduleMainClass = null;
        // - The string corresponding to the NestHost attribute, or null.
        String nestHostClass = null;
        // - The offset of the NestMembers attribute, or 0.
        int nestMembersOffset = 0;
        // - The offset of the PermittedSubclasses attribute, or 0
        int permittedSubclassesOffset = 0;
        // - The offset of the Record attribute, or 0.
        int recordOffset = 0;
        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
        Attribute attributes = null;

        int currentAttributeOffset = getFirstAttributeOffset();
        for (int i = readUnsignedShort(currentAttributeOffset - 2); i > 0; --i) {
            // Read the attribute_info's attribute_name and attribute_length fields.
            String attributeName = readUTF8(currentAttributeOffset, charBuffer);
            int attributeLength = readInt(currentAttributeOffset + 2);
            currentAttributeOffset += 6;
            // The tests are sorted in decreasing frequency order (based on frequencies observed on
            // typical classes).
            if (Constants.SOURCE_FILE.equals(attributeName)) {
                sourceFile = readUTF8(currentAttributeOffset, charBuffer);
            } else if (Constants.INNER_CLASSES.equals(attributeName)) {
                innerClassesOffset = currentAttributeOffset;
            } else if (Constants.ENCLOSING_METHOD.equals(attributeName)) {
                enclosingMethodOffset = currentAttributeOffset;
            } else if (Constants.NEST_HOST.equals(attributeName)) {
                nestHostClass = readClass(currentAttributeOffset, charBuffer);
            } else if (Constants.NEST_MEMBERS.equals(attributeName)) {
                nestMembersOffset = currentAttributeOffset;
            } else if (Constants.PERMITTED_SUBCLASSES.equals(attributeName)) {
                permittedSubclassesOffset = currentAttributeOffset;
            } else if (Constants.SIGNATURE.equals(attributeName)) {
                signature = readUTF8(currentAttributeOffset, charBuffer);
            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleAnnotationsOffset = currentAttributeOffset;
            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleTypeAnnotationsOffset = currentAttributeOffset;
            } else if (Constants.DEPRECATED.equals(attributeName)) {
                accessFlags |= Opcodes.ACC_DEPRECATED;
            } else if (Constants.SYNTHETIC.equals(attributeName)) {
                accessFlags |= Opcodes.ACC_SYNTHETIC;
            } else if (Constants.SOURCE_DEBUG_EXTENSION.equals(attributeName)) {
                sourceDebugExtension =
                        readUtf(currentAttributeOffset, attributeLength, new char[attributeLength]);
            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleAnnotationsOffset = currentAttributeOffset;
            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleTypeAnnotationsOffset = currentAttributeOffset;
            } else if (Constants.RECORD.equals(attributeName)) {
                recordOffset = currentAttributeOffset;
                accessFlags |= Opcodes.ACC_RECORD;
            } else if (Constants.MODULE.equals(attributeName)) {
                moduleOffset = currentAttributeOffset;
            } else if (Constants.MODULE_MAIN_CLASS.equals(attributeName)) {
                moduleMainClass = readClass(currentAttributeOffset, charBuffer);
            } else if (Constants.MODULE_PACKAGES.equals(attributeName)) {
                modulePackagesOffset = currentAttributeOffset;
            } else if (!Constants.BOOTSTRAP_METHODS.equals(attributeName)) {
                // The BootstrapMethods attribute is read in the constructor.
                Attribute attribute =
                        readAttribute(
                                attributePrototypes,
                                attributeName,
                                currentAttributeOffset,
                                attributeLength,
                                charBuffer,
                                -1,
                                null);
                attribute.nextAttribute = attributes;
                attributes = attribute;
            }
            currentAttributeOffset += attributeLength;
        }

        // Visit the class declaration. The minor_version and major_version fields start 6 bytes before
        // the first constant pool entry, which itself starts at cpInfoOffsets[1] - 1 (by definition).
        classVisitor.visit(
                readInt(cpInfoOffsets[1] - 7), accessFlags, thisClass, signature, superClass, interfaces);

        // Visit the SourceFile and SourceDebugExtenstion attributes.
        if ((parsingOptions & SKIP_DEBUG) == 0
                && (sourceFile != null || sourceDebugExtension != null)) {
            classVisitor.visitSource(sourceFile, sourceDebugExtension);
        }

        // Visit the Module, ModulePackages and ModuleMainClass attributes.
        if (moduleOffset != 0) {
            readModuleAttributes(
                    classVisitor, context, moduleOffset, modulePackagesOffset, moduleMainClass);
        }

        // Visit the NestHost attribute.
        if (nestHostClass != null) {
            classVisitor.visitNestHost(nestHostClass);
        }

        // Visit the EnclosingMethod attribute.
        if (enclosingMethodOffset != 0) {
            String className = readClass(enclosingMethodOffset, charBuffer);
            int methodIndex = readUnsignedShort(enclosingMethodOffset + 2);
            String name = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex], charBuffer);
            String type = methodIndex == 0 ? null : readUTF8(cpInfoOffsets[methodIndex] + 2, charBuffer);
            classVisitor.visitOuterClass(className, name, type);
        }

        // Visit the RuntimeVisibleAnnotations attribute.
        if (runtimeVisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleAnnotations attribute.
        if (runtimeInvisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                classVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeVisibleTypeAnnotations attribute.
        if (runtimeVisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                classVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleTypeAnnotations attribute.
        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                classVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the non standard attributes.
        while (attributes != null) {
            // Copy and reset the nextAttribute field so that it can also be used in ClassWriter.
            Attribute nextAttribute = attributes.nextAttribute;
            attributes.nextAttribute = null;
            classVisitor.visitAttribute(attributes);
            attributes = nextAttribute;
        }

        // Visit the NestedMembers attribute.
        if (nestMembersOffset != 0) {
            int numberOfNestMembers = readUnsignedShort(nestMembersOffset);
            int currentNestMemberOffset = nestMembersOffset + 2;
            while (numberOfNestMembers-- > 0) {
                classVisitor.visitNestMember(readClass(currentNestMemberOffset, charBuffer));
                currentNestMemberOffset += 2;
            }
        }

        // Visit the PermittedSubclasses attribute.
        if (permittedSubclassesOffset != 0) {
            int numberOfPermittedSubclasses = readUnsignedShort(permittedSubclassesOffset);
            int currentPermittedSubclassOffset = permittedSubclassesOffset + 2;
            while (numberOfPermittedSubclasses-- > 0) {
                classVisitor.visitPermittedSubclassExperimental(
                        readClass(currentPermittedSubclassOffset, charBuffer));
                currentPermittedSubclassOffset += 2;
            }
        }

        // Visit the InnerClasses attribute.
        if (innerClassesOffset != 0) {
            int numberOfClasses = readUnsignedShort(innerClassesOffset);
            int currentClassesOffset = innerClassesOffset + 2;
            while (numberOfClasses-- > 0) {
                classVisitor.visitInnerClass(
                        readClass(currentClassesOffset, charBuffer),
                        readClass(currentClassesOffset + 2, charBuffer),
                        readUTF8(currentClassesOffset + 4, charBuffer),
                        readUnsignedShort(currentClassesOffset + 6));
                currentClassesOffset += 8;
            }
        }

        // Visit Record components.
        if (recordOffset != 0) {
            int recordComponentsCount = readUnsignedShort(recordOffset);
            recordOffset += 2;
            while (recordComponentsCount-- > 0) {
                recordOffset = readRecordComponent(classVisitor, context, recordOffset);
            }
        }

        // Visit the fields and methods.
        int fieldsCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (fieldsCount-- > 0) {
            currentOffset = readField(classVisitor, context, currentOffset);
        }
        int methodsCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (methodsCount-- > 0) {
            currentOffset = readMethod(classVisitor, context, currentOffset);
        }

        // Visit the end of the class.
        classVisitor.visitEnd();
    }

    // ----------------------------------------------------------------------------------------------
    // Methods to parse modules, fields and methods
    // ----------------------------------------------------------------------------------------------

    
Reads the Module, ModulePackages and ModuleMainClass attributes and visit them.

Params:
  • classVisitor – the current class visitor
  • context – information about the class being parsed.
  • moduleOffset – the offset of the Module attribute (excluding the attribute_info's
    attribute_name_index and attribute_length fields).
  • modulePackagesOffset – the offset of the ModulePackages attribute (excluding the
    attribute_info's attribute_name_index and attribute_length fields), or 0.
  • moduleMainClass – the string corresponding to the ModuleMainClass attribute, or 
    null.
/**
      * Reads the Module, ModulePackages and ModuleMainClass attributes and visit them.
      *
      * @param classVisitor the current class visitor
      * @param context information about the class being parsed.
      * @param moduleOffset the offset of the Module attribute (excluding the attribute_info's
      *     attribute_name_index and attribute_length fields).
      * @param modulePackagesOffset the offset of the ModulePackages attribute (excluding the
      *     attribute_info's attribute_name_index and attribute_length fields), or 0.
      * @param moduleMainClass the string corresponding to the ModuleMainClass attribute, or {@literal
      *     null}.
      */
    private void readModuleAttributes(
            final ClassVisitor classVisitor,
            final Context context,
            final int moduleOffset,
            final int modulePackagesOffset,
            final String moduleMainClass) {
        char[] buffer = context.charBuffer;

        // Read the module_name_index, module_flags and module_version_index fields and visit them.
        int currentOffset = moduleOffset;
        String moduleName = readModule(currentOffset, buffer);
        int moduleFlags = readUnsignedShort(currentOffset + 2);
        String moduleVersion = readUTF8(currentOffset + 4, buffer);
        currentOffset += 6;
        ModuleVisitor moduleVisitor = classVisitor.visitModule(moduleName, moduleFlags, moduleVersion);
        if (moduleVisitor == null) {
            return;
        }

        // Visit the ModuleMainClass attribute.
        if (moduleMainClass != null) {
            moduleVisitor.visitMainClass(moduleMainClass);
        }

        // Visit the ModulePackages attribute.
        if (modulePackagesOffset != 0) {
            int packageCount = readUnsignedShort(modulePackagesOffset);
            int currentPackageOffset = modulePackagesOffset + 2;
            while (packageCount-- > 0) {
                moduleVisitor.visitPackage(readPackage(currentPackageOffset, buffer));
                currentPackageOffset += 2;
            }
        }

        // Read the 'requires_count' and 'requires' fields.
        int requiresCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (requiresCount-- > 0) {
            // Read the requires_index, requires_flags and requires_version fields and visit them.
            String requires = readModule(currentOffset, buffer);
            int requiresFlags = readUnsignedShort(currentOffset + 2);
            String requiresVersion = readUTF8(currentOffset + 4, buffer);
            currentOffset += 6;
            moduleVisitor.visitRequire(requires, requiresFlags, requiresVersion);
        }

        // Read the 'exports_count' and 'exports' fields.
        int exportsCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (exportsCount-- > 0) {
            // Read the exports_index, exports_flags, exports_to_count and exports_to_index fields
            // and visit them.
            String exports = readPackage(currentOffset, buffer);
            int exportsFlags = readUnsignedShort(currentOffset + 2);
            int exportsToCount = readUnsignedShort(currentOffset + 4);
            currentOffset += 6;
            String[] exportsTo = null;
            if (exportsToCount != 0) {
                exportsTo = new String[exportsToCount];
                for (int i = 0; i < exportsToCount; ++i) {
                    exportsTo[i] = readModule(currentOffset, buffer);
                    currentOffset += 2;
                }
            }
            moduleVisitor.visitExport(exports, exportsFlags, exportsTo);
        }

        // Reads the 'opens_count' and 'opens' fields.
        int opensCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (opensCount-- > 0) {
            // Read the opens_index, opens_flags, opens_to_count and opens_to_index fields and visit them.
            String opens = readPackage(currentOffset, buffer);
            int opensFlags = readUnsignedShort(currentOffset + 2);
            int opensToCount = readUnsignedShort(currentOffset + 4);
            currentOffset += 6;
            String[] opensTo = null;
            if (opensToCount != 0) {
                opensTo = new String[opensToCount];
                for (int i = 0; i < opensToCount; ++i) {
                    opensTo[i] = readModule(currentOffset, buffer);
                    currentOffset += 2;
                }
            }
            moduleVisitor.visitOpen(opens, opensFlags, opensTo);
        }

        // Read the 'uses_count' and 'uses' fields.
        int usesCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (usesCount-- > 0) {
            moduleVisitor.visitUse(readClass(currentOffset, buffer));
            currentOffset += 2;
        }

        // Read the  'provides_count' and 'provides' fields.
        int providesCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (providesCount-- > 0) {
            // Read the provides_index, provides_with_count and provides_with_index fields and visit them.
            String provides = readClass(currentOffset, buffer);
            int providesWithCount = readUnsignedShort(currentOffset + 2);
            currentOffset += 4;
            String[] providesWith = new String[providesWithCount];
            for (int i = 0; i < providesWithCount; ++i) {
                providesWith[i] = readClass(currentOffset, buffer);
                currentOffset += 2;
            }
            moduleVisitor.visitProvide(provides, providesWith);
        }

        // Visit the end of the module attributes.
        moduleVisitor.visitEnd();
    }

    
Reads a record component and visit it.

Params:
  • classVisitor – the current class visitor
  • context – information about the class being parsed.
  • recordComponentOffset – the offset of the current record component.
Returns:the offset of the first byte following the record component.
/**
      * Reads a record component and visit it.
      *
      * @param classVisitor the current class visitor
      * @param context information about the class being parsed.
      * @param recordComponentOffset the offset of the current record component.
      * @return the offset of the first byte following the record component.
      */
    private int readRecordComponent(
            final ClassVisitor classVisitor, final Context context, final int recordComponentOffset) {
        char[] charBuffer = context.charBuffer;

        int currentOffset = recordComponentOffset;
        String name = readUTF8(currentOffset, charBuffer);
        String descriptor = readUTF8(currentOffset + 2, charBuffer);
        currentOffset += 4;

        // Read the record component attributes (the variables are ordered as in Section 4.7 of the
        // JVMS).

        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
        // - The string corresponding to the Signature attribute, or null.
        String signature = null;
        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
        int runtimeVisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
        int runtimeInvisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
        int runtimeVisibleTypeAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
        int runtimeInvisibleTypeAnnotationsOffset = 0;
        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
        Attribute attributes = null;

        int attributesCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (attributesCount-- > 0) {
            // Read the attribute_info's attribute_name and attribute_length fields.
            String attributeName = readUTF8(currentOffset, charBuffer);
            int attributeLength = readInt(currentOffset + 2);
            currentOffset += 6;
            // The tests are sorted in decreasing frequency order (based on frequencies observed on
            // typical classes).
            if (Constants.SIGNATURE.equals(attributeName)) {
                signature = readUTF8(currentOffset, charBuffer);
            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleTypeAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleTypeAnnotationsOffset = currentOffset;
            } else {
                Attribute attribute =
                        readAttribute(
                                context.attributePrototypes,
                                attributeName,
                                currentOffset,
                                attributeLength,
                                charBuffer,
                                -1,
                                null);
                attribute.nextAttribute = attributes;
                attributes = attribute;
            }
            currentOffset += attributeLength;
        }

        RecordComponentVisitor recordComponentVisitor =
                classVisitor.visitRecordComponent(name, descriptor, signature);
        if (recordComponentVisitor == null) {
            return currentOffset;
        }

        // Visit the RuntimeVisibleAnnotations attribute.
        if (runtimeVisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                recordComponentVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleAnnotations attribute.
        if (runtimeInvisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                recordComponentVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeVisibleTypeAnnotations attribute.
        if (runtimeVisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                recordComponentVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleTypeAnnotations attribute.
        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                recordComponentVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the non standard attributes.
        while (attributes != null) {
            // Copy and reset the nextAttribute field so that it can also be used in FieldWriter.
            Attribute nextAttribute = attributes.nextAttribute;
            attributes.nextAttribute = null;
            recordComponentVisitor.visitAttribute(attributes);
            attributes = nextAttribute;
        }

        // Visit the end of the field.
        recordComponentVisitor.visitEnd();
        return currentOffset;
    }

    
Reads a JVMS field_info structure and makes the given visitor visit it.

Params:
  • classVisitor – the visitor that must visit the field.
  • context – information about the class being parsed.
  • fieldInfoOffset – the start offset of the field_info structure.
Returns:the offset of the first byte following the field_info structure.
/**
      * Reads a JVMS field_info structure and makes the given visitor visit it.
      *
      * @param classVisitor the visitor that must visit the field.
      * @param context information about the class being parsed.
      * @param fieldInfoOffset the start offset of the field_info structure.
      * @return the offset of the first byte following the field_info structure.
      */
    private int readField(
            final ClassVisitor classVisitor, final Context context, final int fieldInfoOffset) {
        char[] charBuffer = context.charBuffer;

        // Read the access_flags, name_index and descriptor_index fields.
        int currentOffset = fieldInfoOffset;
        int accessFlags = readUnsignedShort(currentOffset);
        String name = readUTF8(currentOffset + 2, charBuffer);
        String descriptor = readUTF8(currentOffset + 4, charBuffer);
        currentOffset += 6;

        // Read the field attributes (the variables are ordered as in Section 4.7 of the JVMS).
        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
        // - The value corresponding to the ConstantValue attribute, or null.
        Object constantValue = null;
        // - The string corresponding to the Signature attribute, or null.
        String signature = null;
        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
        int runtimeVisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
        int runtimeInvisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
        int runtimeVisibleTypeAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
        int runtimeInvisibleTypeAnnotationsOffset = 0;
        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
        Attribute attributes = null;

        int attributesCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (attributesCount-- > 0) {
            // Read the attribute_info's attribute_name and attribute_length fields.
            String attributeName = readUTF8(currentOffset, charBuffer);
            int attributeLength = readInt(currentOffset + 2);
            currentOffset += 6;
            // The tests are sorted in decreasing frequency order (based on frequencies observed on
            // typical classes).
            if (Constants.CONSTANT_VALUE.equals(attributeName)) {
                int constantvalueIndex = readUnsignedShort(currentOffset);
                constantValue = constantvalueIndex == 0 ? null : readConst(constantvalueIndex, charBuffer);
            } else if (Constants.SIGNATURE.equals(attributeName)) {
                signature = readUTF8(currentOffset, charBuffer);
            } else if (Constants.DEPRECATED.equals(attributeName)) {
                accessFlags |= Opcodes.ACC_DEPRECATED;
            } else if (Constants.SYNTHETIC.equals(attributeName)) {
                accessFlags |= Opcodes.ACC_SYNTHETIC;
            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleTypeAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleTypeAnnotationsOffset = currentOffset;
            } else {
                Attribute attribute =
                        readAttribute(
                                context.attributePrototypes,
                                attributeName,
                                currentOffset,
                                attributeLength,
                                charBuffer,
                                -1,
                                null);
                attribute.nextAttribute = attributes;
                attributes = attribute;
            }
            currentOffset += attributeLength;
        }

        // Visit the field declaration.
        FieldVisitor fieldVisitor =
                classVisitor.visitField(accessFlags, name, descriptor, signature, constantValue);
        if (fieldVisitor == null) {
            return currentOffset;
        }

        // Visit the RuntimeVisibleAnnotations attribute.
        if (runtimeVisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                fieldVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleAnnotations attribute.
        if (runtimeInvisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                fieldVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeVisibleTypeAnnotations attribute.
        if (runtimeVisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                fieldVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleTypeAnnotations attribute.
        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                fieldVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the non standard attributes.
        while (attributes != null) {
            // Copy and reset the nextAttribute field so that it can also be used in FieldWriter.
            Attribute nextAttribute = attributes.nextAttribute;
            attributes.nextAttribute = null;
            fieldVisitor.visitAttribute(attributes);
            attributes = nextAttribute;
        }

        // Visit the end of the field.
        fieldVisitor.visitEnd();
        return currentOffset;
    }

    
Reads a JVMS method_info structure and makes the given visitor visit it.

Params:
  • classVisitor – the visitor that must visit the method.
  • context – information about the class being parsed.
  • methodInfoOffset – the start offset of the method_info structure.
Returns:the offset of the first byte following the method_info structure.
/**
      * Reads a JVMS method_info structure and makes the given visitor visit it.
      *
      * @param classVisitor the visitor that must visit the method.
      * @param context information about the class being parsed.
      * @param methodInfoOffset the start offset of the method_info structure.
      * @return the offset of the first byte following the method_info structure.
      */
    private int readMethod(
            final ClassVisitor classVisitor, final Context context, final int methodInfoOffset) {
        char[] charBuffer = context.charBuffer;

        // Read the access_flags, name_index and descriptor_index fields.
        int currentOffset = methodInfoOffset;
        context.currentMethodAccessFlags = readUnsignedShort(currentOffset);
        context.currentMethodName = readUTF8(currentOffset + 2, charBuffer);
        context.currentMethodDescriptor = readUTF8(currentOffset + 4, charBuffer);
        currentOffset += 6;

        // Read the method attributes (the variables are ordered as in Section 4.7 of the JVMS).
        // Attribute offsets exclude the attribute_name_index and attribute_length fields.
        // - The offset of the Code attribute, or 0.
        int codeOffset = 0;
        // - The offset of the Exceptions attribute, or 0.
        int exceptionsOffset = 0;
        // - The strings corresponding to the Exceptions attribute, or null.
        String[] exceptions = null;
        // - Whether the method has a Synthetic attribute.
        boolean synthetic = false;
        // - The constant pool index contained in the Signature attribute, or 0.
        int signatureIndex = 0;
        // - The offset of the RuntimeVisibleAnnotations attribute, or 0.
        int runtimeVisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleAnnotations attribute, or 0.
        int runtimeInvisibleAnnotationsOffset = 0;
        // - The offset of the RuntimeVisibleParameterAnnotations attribute, or 0.
        int runtimeVisibleParameterAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleParameterAnnotations attribute, or 0.
        int runtimeInvisibleParameterAnnotationsOffset = 0;
        // - The offset of the RuntimeVisibleTypeAnnotations attribute, or 0.
        int runtimeVisibleTypeAnnotationsOffset = 0;
        // - The offset of the RuntimeInvisibleTypeAnnotations attribute, or 0.
        int runtimeInvisibleTypeAnnotationsOffset = 0;
        // - The offset of the AnnotationDefault attribute, or 0.
        int annotationDefaultOffset = 0;
        // - The offset of the MethodParameters attribute, or 0.
        int methodParametersOffset = 0;
        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
        Attribute attributes = null;

        int attributesCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (attributesCount-- > 0) {
            // Read the attribute_info's attribute_name and attribute_length fields.
            String attributeName = readUTF8(currentOffset, charBuffer);
            int attributeLength = readInt(currentOffset + 2);
            currentOffset += 6;
            // The tests are sorted in decreasing frequency order (based on frequencies observed on
            // typical classes).
            if (Constants.CODE.equals(attributeName)) {
                if ((context.parsingOptions & SKIP_CODE) == 0) {
                    codeOffset = currentOffset;
                }
            } else if (Constants.EXCEPTIONS.equals(attributeName)) {
                exceptionsOffset = currentOffset;
                exceptions = new String[readUnsignedShort(exceptionsOffset)];
                int currentExceptionOffset = exceptionsOffset + 2;
                for (int i = 0; i < exceptions.length; ++i) {
                    exceptions[i] = readClass(currentExceptionOffset, charBuffer);
                    currentExceptionOffset += 2;
                }
            } else if (Constants.SIGNATURE.equals(attributeName)) {
                signatureIndex = readUnsignedShort(currentOffset);
            } else if (Constants.DEPRECATED.equals(attributeName)) {
                context.currentMethodAccessFlags |= Opcodes.ACC_DEPRECATED;
            } else if (Constants.RUNTIME_VISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleTypeAnnotationsOffset = currentOffset;
            } else if (Constants.ANNOTATION_DEFAULT.equals(attributeName)) {
                annotationDefaultOffset = currentOffset;
            } else if (Constants.SYNTHETIC.equals(attributeName)) {
                synthetic = true;
                context.currentMethodAccessFlags |= Opcodes.ACC_SYNTHETIC;
            } else if (Constants.RUNTIME_INVISIBLE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleTypeAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_VISIBLE_PARAMETER_ANNOTATIONS.equals(attributeName)) {
                runtimeVisibleParameterAnnotationsOffset = currentOffset;
            } else if (Constants.RUNTIME_INVISIBLE_PARAMETER_ANNOTATIONS.equals(attributeName)) {
                runtimeInvisibleParameterAnnotationsOffset = currentOffset;
            } else if (Constants.METHOD_PARAMETERS.equals(attributeName)) {
                methodParametersOffset = currentOffset;
            } else {
                Attribute attribute =
                        readAttribute(
                                context.attributePrototypes,
                                attributeName,
                                currentOffset,
                                attributeLength,
                                charBuffer,
                                -1,
                                null);
                attribute.nextAttribute = attributes;
                attributes = attribute;
            }
            currentOffset += attributeLength;
        }

        // Visit the method declaration.
        MethodVisitor methodVisitor =
                classVisitor.visitMethod(
                        context.currentMethodAccessFlags,
                        context.currentMethodName,
                        context.currentMethodDescriptor,
                        signatureIndex == 0 ? null : readUtf(signatureIndex, charBuffer),
                        exceptions);
        if (methodVisitor == null) {
            return currentOffset;
        }

        // If the returned MethodVisitor is in fact a MethodWriter, it means there is no method
        // adapter between the reader and the writer. In this case, it might be possible to copy
        // the method attributes directly into the writer. If so, return early without visiting
        // the content of these attributes.
        if (methodVisitor instanceof MethodWriter) {
            MethodWriter methodWriter = (MethodWriter) methodVisitor;
            if (methodWriter.canCopyMethodAttributes(
                    this,
                    synthetic,
                    (context.currentMethodAccessFlags & Opcodes.ACC_DEPRECATED) != 0,
                    readUnsignedShort(methodInfoOffset + 4),
                    signatureIndex,
                    exceptionsOffset)) {
                methodWriter.setMethodAttributesSource(methodInfoOffset, currentOffset - methodInfoOffset);
                return currentOffset;
            }
        }

        // Visit the MethodParameters attribute.
        if (methodParametersOffset != 0 && (context.parsingOptions & SKIP_DEBUG) == 0) {
            int parametersCount = readByte(methodParametersOffset);
            int currentParameterOffset = methodParametersOffset + 1;
            while (parametersCount-- > 0) {
                // Read the name_index and access_flags fields and visit them.
                methodVisitor.visitParameter(
                        readUTF8(currentParameterOffset, charBuffer),
                        readUnsignedShort(currentParameterOffset + 2));
                currentParameterOffset += 4;
            }
        }

        // Visit the AnnotationDefault attribute.
        if (annotationDefaultOffset != 0) {
            AnnotationVisitor annotationVisitor = methodVisitor.visitAnnotationDefault();
            readElementValue(annotationVisitor, annotationDefaultOffset, null, charBuffer);
            if (annotationVisitor != null) {
                annotationVisitor.visitEnd();
            }
        }

        // Visit the RuntimeVisibleAnnotations attribute.
        if (runtimeVisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                methodVisitor.visitAnnotation(annotationDescriptor, /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleAnnotations attribute.
        if (runtimeInvisibleAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                methodVisitor.visitAnnotation(annotationDescriptor, /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeVisibleTypeAnnotations attribute.
        if (runtimeVisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeVisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeVisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                methodVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ true),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeInvisibleTypeAnnotations attribute.
        if (runtimeInvisibleTypeAnnotationsOffset != 0) {
            int numAnnotations = readUnsignedShort(runtimeInvisibleTypeAnnotationsOffset);
            int currentAnnotationOffset = runtimeInvisibleTypeAnnotationsOffset + 2;
            while (numAnnotations-- > 0) {
                // Parse the target_type, target_info and target_path fields.
                currentAnnotationOffset = readTypeAnnotationTarget(context, currentAnnotationOffset);
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                currentAnnotationOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentAnnotationOffset =
                        readElementValues(
                                methodVisitor.visitTypeAnnotation(
                                        context.currentTypeAnnotationTarget,
                                        context.currentTypeAnnotationTargetPath,
                                        annotationDescriptor,
                                        /* visible = */ false),
                                currentAnnotationOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }

        // Visit the RuntimeVisibleParameterAnnotations attribute.
        if (runtimeVisibleParameterAnnotationsOffset != 0) {
            readParameterAnnotations(
                    methodVisitor, context, runtimeVisibleParameterAnnotationsOffset, /* visible = */ true);
        }

        // Visit the RuntimeInvisibleParameterAnnotations attribute.
        if (runtimeInvisibleParameterAnnotationsOffset != 0) {
            readParameterAnnotations(
                    methodVisitor,
                    context,
                    runtimeInvisibleParameterAnnotationsOffset,
                    /* visible = */ false);
        }

        // Visit the non standard attributes.
        while (attributes != null) {
            // Copy and reset the nextAttribute field so that it can also be used in MethodWriter.
            Attribute nextAttribute = attributes.nextAttribute;
            attributes.nextAttribute = null;
            methodVisitor.visitAttribute(attributes);
            attributes = nextAttribute;
        }

        // Visit the Code attribute.
        if (codeOffset != 0) {
            methodVisitor.visitCode();
            readCode(methodVisitor, context, codeOffset);
        }

        // Visit the end of the method.
        methodVisitor.visitEnd();
        return currentOffset;
    }

    // ----------------------------------------------------------------------------------------------
    // Methods to parse a Code attribute
    // ----------------------------------------------------------------------------------------------

    
Reads a JVMS 'Code' attribute and makes the given visitor visit it.

Params:
  • methodVisitor – the visitor that must visit the Code attribute.
  • context – information about the class being parsed.
  • codeOffset – the start offset in classFileBuffer of the Code attribute, excluding its attribute_name_index and attribute_length fields.
/**
      * Reads a JVMS 'Code' attribute and makes the given visitor visit it.
      *
      * @param methodVisitor the visitor that must visit the Code attribute.
      * @param context information about the class being parsed.
      * @param codeOffset the start offset in {@link #classFileBuffer} of the Code attribute, excluding
      *     its attribute_name_index and attribute_length fields.
      */
    private void readCode(
            final MethodVisitor methodVisitor, final Context context, final int codeOffset) {
        int currentOffset = codeOffset;

        // Read the max_stack, max_locals and code_length fields.
        final byte[] classBuffer = classFileBuffer;
        final char[] charBuffer = context.charBuffer;
        final int maxStack = readUnsignedShort(currentOffset);
        final int maxLocals = readUnsignedShort(currentOffset + 2);
        final int codeLength = readInt(currentOffset + 4);
        currentOffset += 8;

        // Read the bytecode 'code' array to create a label for each referenced instruction.
        final int bytecodeStartOffset = currentOffset;
        final int bytecodeEndOffset = currentOffset + codeLength;
        final Label[] labels = context.currentMethodLabels = new Label[codeLength + 1];
        while (currentOffset < bytecodeEndOffset) {
            final int bytecodeOffset = currentOffset - bytecodeStartOffset;
            final int opcode = classBuffer[currentOffset] & 0xFF;
            switch (opcode) {
                case Opcodes.NOP:
                case Opcodes.ACONST_NULL:
                case Opcodes.ICONST_M1:
                case Opcodes.ICONST_0:
                case Opcodes.ICONST_1:
                case Opcodes.ICONST_2:
                case Opcodes.ICONST_3:
                case Opcodes.ICONST_4:
                case Opcodes.ICONST_5:
                case Opcodes.LCONST_0:
                case Opcodes.LCONST_1:
                case Opcodes.FCONST_0:
                case Opcodes.FCONST_1:
                case Opcodes.FCONST_2:
                case Opcodes.DCONST_0:
                case Opcodes.DCONST_1:
                case Opcodes.IALOAD:
                case Opcodes.LALOAD:
                case Opcodes.FALOAD:
                case Opcodes.DALOAD:
                case Opcodes.AALOAD:
                case Opcodes.BALOAD:
                case Opcodes.CALOAD:
                case Opcodes.SALOAD:
                case Opcodes.IASTORE:
                case Opcodes.LASTORE:
                case Opcodes.FASTORE:
                case Opcodes.DASTORE:
                case Opcodes.AASTORE:
                case Opcodes.BASTORE:
                case Opcodes.CASTORE:
                case Opcodes.SASTORE:
                case Opcodes.POP:
                case Opcodes.POP2:
                case Opcodes.DUP:
                case Opcodes.DUP_X1:
                case Opcodes.DUP_X2:
                case Opcodes.DUP2:
                case Opcodes.DUP2_X1:
                case Opcodes.DUP2_X2:
                case Opcodes.SWAP:
                case Opcodes.IADD:
                case Opcodes.LADD:
                case Opcodes.FADD:
                case Opcodes.DADD:
                case Opcodes.ISUB:
                case Opcodes.LSUB:
                case Opcodes.FSUB:
                case Opcodes.DSUB:
                case Opcodes.IMUL:
                case Opcodes.LMUL:
                case Opcodes.FMUL:
                case Opcodes.DMUL:
                case Opcodes.IDIV:
                case Opcodes.LDIV:
                case Opcodes.FDIV:
                case Opcodes.DDIV:
                case Opcodes.IREM:
                case Opcodes.LREM:
                case Opcodes.FREM:
                case Opcodes.DREM:
                case Opcodes.INEG:
                case Opcodes.LNEG:
                case Opcodes.FNEG:
                case Opcodes.DNEG:
                case Opcodes.ISHL:
                case Opcodes.LSHL:
                case Opcodes.ISHR:
                case Opcodes.LSHR:
                case Opcodes.IUSHR:
                case Opcodes.LUSHR:
                case Opcodes.IAND:
                case Opcodes.LAND:
                case Opcodes.IOR:
                case Opcodes.LOR:
                case Opcodes.IXOR:
                case Opcodes.LXOR:
                case Opcodes.I2L:
                case Opcodes.I2F:
                case Opcodes.I2D:
                case Opcodes.L2I:
                case Opcodes.L2F:
                case Opcodes.L2D:
                case Opcodes.F2I:
                case Opcodes.F2L:
                case Opcodes.F2D:
                case Opcodes.D2I:
                case Opcodes.D2L:
                case Opcodes.D2F:
                case Opcodes.I2B:
                case Opcodes.I2C:
                case Opcodes.I2S:
                case Opcodes.LCMP:
                case Opcodes.FCMPL:
                case Opcodes.FCMPG:
                case Opcodes.DCMPL:
                case Opcodes.DCMPG:
                case Opcodes.IRETURN:
                case Opcodes.LRETURN:
                case Opcodes.FRETURN:
                case Opcodes.DRETURN:
                case Opcodes.ARETURN:
                case Opcodes.RETURN:
                case Opcodes.ARRAYLENGTH:
                case Opcodes.ATHROW:
                case Opcodes.MONITORENTER:
                case Opcodes.MONITOREXIT:
                case Constants.ILOAD_0:
                case Constants.ILOAD_1:
                case Constants.ILOAD_2:
                case Constants.ILOAD_3:
                case Constants.LLOAD_0:
                case Constants.LLOAD_1:
                case Constants.LLOAD_2:
                case Constants.LLOAD_3:
                case Constants.FLOAD_0:
                case Constants.FLOAD_1:
                case Constants.FLOAD_2:
                case Constants.FLOAD_3:
                case Constants.DLOAD_0:
                case Constants.DLOAD_1:
                case Constants.DLOAD_2:
                case Constants.DLOAD_3:
                case Constants.ALOAD_0:
                case Constants.ALOAD_1:
                case Constants.ALOAD_2:
                case Constants.ALOAD_3:
                case Constants.ISTORE_0:
                case Constants.ISTORE_1:
                case Constants.ISTORE_2:
                case Constants.ISTORE_3:
                case Constants.LSTORE_0:
                case Constants.LSTORE_1:
                case Constants.LSTORE_2:
                case Constants.LSTORE_3:
                case Constants.FSTORE_0:
                case Constants.FSTORE_1:
                case Constants.FSTORE_2:
                case Constants.FSTORE_3:
                case Constants.DSTORE_0:
                case Constants.DSTORE_1:
                case Constants.DSTORE_2:
                case Constants.DSTORE_3:
                case Constants.ASTORE_0:
                case Constants.ASTORE_1:
                case Constants.ASTORE_2:
                case Constants.ASTORE_3:
                    currentOffset += 1;
                    break;
                case Opcodes.IFEQ:
                case Opcodes.IFNE:
                case Opcodes.IFLT:
                case Opcodes.IFGE:
                case Opcodes.IFGT:
                case Opcodes.IFLE:
                case Opcodes.IF_ICMPEQ:
                case Opcodes.IF_ICMPNE:
                case Opcodes.IF_ICMPLT:
                case Opcodes.IF_ICMPGE:
                case Opcodes.IF_ICMPGT:
                case Opcodes.IF_ICMPLE:
                case Opcodes.IF_ACMPEQ:
                case Opcodes.IF_ACMPNE:
                case Opcodes.GOTO:
                case Opcodes.JSR:
                case Opcodes.IFNULL:
                case Opcodes.IFNONNULL:
                    createLabel(bytecodeOffset + readShort(currentOffset + 1), labels);
                    currentOffset += 3;
                    break;
                case Constants.ASM_IFEQ:
                case Constants.ASM_IFNE:
                case Constants.ASM_IFLT:
                case Constants.ASM_IFGE:
                case Constants.ASM_IFGT:
                case Constants.ASM_IFLE:
                case Constants.ASM_IF_ICMPEQ:
                case Constants.ASM_IF_ICMPNE:
                case Constants.ASM_IF_ICMPLT:
                case Constants.ASM_IF_ICMPGE:
                case Constants.ASM_IF_ICMPGT:
                case Constants.ASM_IF_ICMPLE:
                case Constants.ASM_IF_ACMPEQ:
                case Constants.ASM_IF_ACMPNE:
                case Constants.ASM_GOTO:
                case Constants.ASM_JSR:
                case Constants.ASM_IFNULL:
                case Constants.ASM_IFNONNULL:
                    createLabel(bytecodeOffset + readUnsignedShort(currentOffset + 1), labels);
                    currentOffset += 3;
                    break;
                case Constants.GOTO_W:
                case Constants.JSR_W:
                case Constants.ASM_GOTO_W:
                    createLabel(bytecodeOffset + readInt(currentOffset + 1), labels);
                    currentOffset += 5;
                    break;
                case Constants.WIDE:
                    switch (classBuffer[currentOffset + 1] & 0xFF) {
                        case Opcodes.ILOAD:
                        case Opcodes.FLOAD:
                        case Opcodes.ALOAD:
                        case Opcodes.LLOAD:
                        case Opcodes.DLOAD:
                        case Opcodes.ISTORE:
                        case Opcodes.FSTORE:
                        case Opcodes.ASTORE:
                        case Opcodes.LSTORE:
                        case Opcodes.DSTORE:
                        case Opcodes.RET:
                            currentOffset += 4;
                            break;
                        case Opcodes.IINC:
                            currentOffset += 6;
                            break;
                        default:
                            throw new IllegalArgumentException();
                    }
                    break;
                case Opcodes.TABLESWITCH:
                    // Skip 0 to 3 padding bytes.
                    currentOffset += 4 - (bytecodeOffset & 3);
                    // Read the default label and the number of table entries.
                    createLabel(bytecodeOffset + readInt(currentOffset), labels);
                    int numTableEntries = readInt(currentOffset + 8) - readInt(currentOffset + 4) + 1;
                    currentOffset += 12;
                    // Read the table labels.
                    while (numTableEntries-- > 0) {
                        createLabel(bytecodeOffset + readInt(currentOffset), labels);
                        currentOffset += 4;
                    }
                    break;
                case Opcodes.LOOKUPSWITCH:
                    // Skip 0 to 3 padding bytes.
                    currentOffset += 4 - (bytecodeOffset & 3);
                    // Read the default label and the number of switch cases.
                    createLabel(bytecodeOffset + readInt(currentOffset), labels);
                    int numSwitchCases = readInt(currentOffset + 4);
                    currentOffset += 8;
                    // Read the switch labels.
                    while (numSwitchCases-- > 0) {
                        createLabel(bytecodeOffset + readInt(currentOffset + 4), labels);
                        currentOffset += 8;
                    }
                    break;
                case Opcodes.ILOAD:
                case Opcodes.LLOAD:
                case Opcodes.FLOAD:
                case Opcodes.DLOAD:
                case Opcodes.ALOAD:
                case Opcodes.ISTORE:
                case Opcodes.LSTORE:
                case Opcodes.FSTORE:
                case Opcodes.DSTORE:
                case Opcodes.ASTORE:
                case Opcodes.RET:
                case Opcodes.BIPUSH:
                case Opcodes.NEWARRAY:
                case Opcodes.LDC:
                    currentOffset += 2;
                    break;
                case Opcodes.SIPUSH:
                case Constants.LDC_W:
                case Constants.LDC2_W:
                case Opcodes.GETSTATIC:
                case Opcodes.PUTSTATIC:
                case Opcodes.GETFIELD:
                case Opcodes.PUTFIELD:
                case Opcodes.INVOKEVIRTUAL:
                case Opcodes.INVOKESPECIAL:
                case Opcodes.INVOKESTATIC:
                case Opcodes.NEW:
                case Opcodes.ANEWARRAY:
                case Opcodes.CHECKCAST:
                case Opcodes.INSTANCEOF:
                case Opcodes.IINC:
                    currentOffset += 3;
                    break;
                case Opcodes.INVOKEINTERFACE:
                case Opcodes.INVOKEDYNAMIC:
                    currentOffset += 5;
                    break;
                case Opcodes.MULTIANEWARRAY:
                    currentOffset += 4;
                    break;
                default:
                    throw new IllegalArgumentException();
            }
        }

        // Read the 'exception_table_length' and 'exception_table' field to create a label for each
        // referenced instruction, and to make methodVisitor visit the corresponding try catch blocks.
        int exceptionTableLength = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (exceptionTableLength-- > 0) {
            Label start = createLabel(readUnsignedShort(currentOffset), labels);
            Label end = createLabel(readUnsignedShort(currentOffset + 2), labels);
            Label handler = createLabel(readUnsignedShort(currentOffset + 4), labels);
            String catchType = readUTF8(cpInfoOffsets[readUnsignedShort(currentOffset + 6)], charBuffer);
            currentOffset += 8;
            methodVisitor.visitTryCatchBlock(start, end, handler, catchType);
        }

        // Read the Code attributes to create a label for each referenced instruction (the variables
        // are ordered as in Section 4.7 of the JVMS). Attribute offsets exclude the
        // attribute_name_index and attribute_length fields.
        // - The offset of the current 'stack_map_frame' in the StackMap[Table] attribute, or 0.
        // Initially, this is the offset of the first 'stack_map_frame' entry. Then this offset is
        // updated after each stack_map_frame is read.
        int stackMapFrameOffset = 0;
        // - The end offset of the StackMap[Table] attribute, or 0.
        int stackMapTableEndOffset = 0;
        // - Whether the stack map frames are compressed (i.e. in a StackMapTable) or not.
        boolean compressedFrames = true;
        // - The offset of the LocalVariableTable attribute, or 0.
        int localVariableTableOffset = 0;
        // - The offset of the LocalVariableTypeTable attribute, or 0.
        int localVariableTypeTableOffset = 0;
        // - The offset of each 'type_annotation' entry in the RuntimeVisibleTypeAnnotations
        // attribute, or null.
        int[] visibleTypeAnnotationOffsets = null;
        // - The offset of each 'type_annotation' entry in the RuntimeInvisibleTypeAnnotations
        // attribute, or null.
        int[] invisibleTypeAnnotationOffsets = null;
        // - The non standard attributes (linked with their {@link Attribute#nextAttribute} field).
        //   This list in the <i>reverse order</i> or their order in the ClassFile structure.
        Attribute attributes = null;

        int attributesCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (attributesCount-- > 0) {
            // Read the attribute_info's attribute_name and attribute_length fields.
            String attributeName = readUTF8(currentOffset, charBuffer);
            int attributeLength = readInt(currentOffset + 2);
            currentOffset += 6;
            if (Constants.LOCAL_VARIABLE_TABLE.equals(attributeName)) {
                if ((context.parsingOptions & SKIP_DEBUG) == 0) {
                    localVariableTableOffset = currentOffset;
                    // Parse the attribute to find the corresponding (debug only) labels.
                    int currentLocalVariableTableOffset = currentOffset;
                    int localVariableTableLength = readUnsignedShort(currentLocalVariableTableOffset);
                    currentLocalVariableTableOffset += 2;
                    while (localVariableTableLength-- > 0) {
                        int startPc = readUnsignedShort(currentLocalVariableTableOffset);
                        createDebugLabel(startPc, labels);
                        int length = readUnsignedShort(currentLocalVariableTableOffset + 2);
                        createDebugLabel(startPc + length, labels);
                        // Skip the name_index, descriptor_index and index fields (2 bytes each).
                        currentLocalVariableTableOffset += 10;
                    }
                }
            } else if (Constants.LOCAL_VARIABLE_TYPE_TABLE.equals(attributeName)) {
                localVariableTypeTableOffset = currentOffset;
                // Here we do not extract the labels corresponding to the attribute content. We assume they
                // are the same or a subset of those of the LocalVariableTable attribute.
            } else if (Constants.LINE_NUMBER_TABLE.equals(attributeName)) {
                if ((context.parsingOptions & SKIP_DEBUG) == 0) {
                    // Parse the attribute to find the corresponding (debug only) labels.
                    int currentLineNumberTableOffset = currentOffset;
                    int lineNumberTableLength = readUnsignedShort(currentLineNumberTableOffset);
                    currentLineNumberTableOffset += 2;
                    while (lineNumberTableLength-- > 0) {
                        int startPc = readUnsignedShort(currentLineNumberTableOffset);
                        int lineNumber = readUnsignedShort(currentLineNumberTableOffset + 2);
                        currentLineNumberTableOffset += 4;
                        createDebugLabel(startPc, labels);
                        labels[startPc].addLineNumber(lineNumber);
                    }
                }
            } else if (Constants.RUNTIME_VISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                visibleTypeAnnotationOffsets =
                        readTypeAnnotations(methodVisitor, context, currentOffset, /* visible = */ true);
                // Here we do not extract the labels corresponding to the attribute content. This would
                // require a full parsing of the attribute, which would need to be repeated when parsing
                // the bytecode instructions (see below). Instead, the content of the attribute is read one
                // type annotation at a time (i.e. after a type annotation has been visited, the next type
                // annotation is read), and the labels it contains are also extracted one annotation at a
                // time. This assumes that type annotations are ordered by increasing bytecode offset.
            } else if (Constants.RUNTIME_INVISIBLE_TYPE_ANNOTATIONS.equals(attributeName)) {
                invisibleTypeAnnotationOffsets =
                        readTypeAnnotations(methodVisitor, context, currentOffset, /* visible = */ false);
                // Same comment as above for the RuntimeVisibleTypeAnnotations attribute.
            } else if (Constants.STACK_MAP_TABLE.equals(attributeName)) {
                if ((context.parsingOptions & SKIP_FRAMES) == 0) {
                    stackMapFrameOffset = currentOffset + 2;
                    stackMapTableEndOffset = currentOffset + attributeLength;
                }
                // Here we do not extract the labels corresponding to the attribute content. This would
                // require a full parsing of the attribute, which would need to be repeated when parsing
                // the bytecode instructions (see below). Instead, the content of the attribute is read one
                // frame at a time (i.e. after a frame has been visited, the next frame is read), and the
                // labels it contains are also extracted one frame at a time. Thanks to the ordering of
                // frames, having only a "one frame lookahead" is not a problem, i.e. it is not possible to
                // see an offset smaller than the offset of the current instruction and for which no Label
                // exist. Except for UNINITIALIZED type offsets. We solve this by parsing the stack map
                // table without a full decoding (see below).
            } else if ("StackMap".equals(attributeName)) {
                if ((context.parsingOptions & SKIP_FRAMES) == 0) {
                    stackMapFrameOffset = currentOffset + 2;
                    stackMapTableEndOffset = currentOffset + attributeLength;
                    compressedFrames = false;
                }
                // IMPORTANT! Here we assume that the frames are ordered, as in the StackMapTable attribute,
                // although this is not guaranteed by the attribute format. This allows an incremental
                // extraction of the labels corresponding to this attribute (see the comment above for the
                // StackMapTable attribute).
            } else {
                Attribute attribute =
                        readAttribute(
                                context.attributePrototypes,
                                attributeName,
                                currentOffset,
                                attributeLength,
                                charBuffer,
                                codeOffset,
                                labels);
                attribute.nextAttribute = attributes;
                attributes = attribute;
            }
            currentOffset += attributeLength;
        }

        // Initialize the context fields related to stack map frames, and generate the first
        // (implicit) stack map frame, if needed.
        final boolean expandFrames = (context.parsingOptions & EXPAND_FRAMES) != 0;
        if (stackMapFrameOffset != 0) {
            // The bytecode offset of the first explicit frame is not offset_delta + 1 but only
            // offset_delta. Setting the implicit frame offset to -1 allows us to use of the
            // "offset_delta + 1" rule in all cases.
            context.currentFrameOffset = -1;
            context.currentFrameType = 0;
            context.currentFrameLocalCount = 0;
            context.currentFrameLocalCountDelta = 0;
            context.currentFrameLocalTypes = new Object[maxLocals];
            context.currentFrameStackCount = 0;
            context.currentFrameStackTypes = new Object[maxStack];
            if (expandFrames) {
                computeImplicitFrame(context);
            }
            // Find the labels for UNINITIALIZED frame types. Instead of decoding each element of the
            // stack map table, we look for 3 consecutive bytes that "look like" an UNINITIALIZED type
            // (tag ITEM_Uninitialized, offset within bytecode bounds, NEW instruction at this offset).
            // We may find false positives (i.e. not real UNINITIALIZED types), but this should be rare,
            // and the only consequence will be the creation of an unneeded label. This is better than
            // creating a label for each NEW instruction, and faster than fully decoding the whole stack
            // map table.
            for (int offset = stackMapFrameOffset; offset < stackMapTableEndOffset - 2; ++offset) {
                if (classBuffer[offset] == Frame.ITEM_UNINITIALIZED) {
                    int potentialBytecodeOffset = readUnsignedShort(offset + 1);
                    if (potentialBytecodeOffset >= 0
                            && potentialBytecodeOffset < codeLength
                            && (classBuffer[bytecodeStartOffset + potentialBytecodeOffset] & 0xFF)
                                    == Opcodes.NEW) {
                        createLabel(potentialBytecodeOffset, labels);
                    }
                }
            }
        }
        if (expandFrames && (context.parsingOptions & EXPAND_ASM_INSNS) != 0) {
            // Expanding the ASM specific instructions can introduce F_INSERT frames, even if the method
            // does not currently have any frame. These inserted frames must be computed by simulating the
            // effect of the bytecode instructions, one by one, starting from the implicit first frame.
            // For this, MethodWriter needs to know maxLocals before the first instruction is visited. To
            // ensure this, we visit the implicit first frame here (passing only maxLocals - the rest is
            // computed in MethodWriter).
            methodVisitor.visitFrame(Opcodes.F_NEW, maxLocals, null, 0, null);
        }

        // Visit the bytecode instructions. First, introduce state variables for the incremental parsing
        // of the type annotations.

        // Index of the next runtime visible type annotation to read (in the
        // visibleTypeAnnotationOffsets array).
        int currentVisibleTypeAnnotationIndex = 0;
        // The bytecode offset of the next runtime visible type annotation to read, or -1.
        int currentVisibleTypeAnnotationBytecodeOffset =
                getTypeAnnotationBytecodeOffset(visibleTypeAnnotationOffsets, 0);
        // Index of the next runtime invisible type annotation to read (in the
        // invisibleTypeAnnotationOffsets array).
        int currentInvisibleTypeAnnotationIndex = 0;
        // The bytecode offset of the next runtime invisible type annotation to read, or -1.
        int currentInvisibleTypeAnnotationBytecodeOffset =
                getTypeAnnotationBytecodeOffset(invisibleTypeAnnotationOffsets, 0);

        // Whether a F_INSERT stack map frame must be inserted before the current instruction.
        boolean insertFrame = false;

        // The delta to subtract from a goto_w or jsr_w opcode to get the corresponding goto or jsr
        // opcode, or 0 if goto_w and jsr_w must be left unchanged (i.e. when expanding ASM specific
        // instructions).
        final int wideJumpOpcodeDelta =
                (context.parsingOptions & EXPAND_ASM_INSNS) == 0 ? Constants.WIDE_JUMP_OPCODE_DELTA : 0;

        currentOffset = bytecodeStartOffset;
        while (currentOffset < bytecodeEndOffset) {
            final int currentBytecodeOffset = currentOffset - bytecodeStartOffset;

            // Visit the label and the line number(s) for this bytecode offset, if any.
            Label currentLabel = labels[currentBytecodeOffset];
            if (currentLabel != null) {
                currentLabel.accept(methodVisitor, (context.parsingOptions & SKIP_DEBUG) == 0);
            }

            // Visit the stack map frame for this bytecode offset, if any.
            while (stackMapFrameOffset != 0
                    && (context.currentFrameOffset == currentBytecodeOffset
                            || context.currentFrameOffset == -1)) {
                // If there is a stack map frame for this offset, make methodVisitor visit it, and read the
                // next stack map frame if there is one.
                if (context.currentFrameOffset != -1) {
                    if (!compressedFrames || expandFrames) {
                        methodVisitor.visitFrame(
                                Opcodes.F_NEW,
                                context.currentFrameLocalCount,
                                context.currentFrameLocalTypes,
                                context.currentFrameStackCount,
                                context.currentFrameStackTypes);
                    } else {
                        methodVisitor.visitFrame(
                                context.currentFrameType,
                                context.currentFrameLocalCountDelta,
                                context.currentFrameLocalTypes,
                                context.currentFrameStackCount,
                                context.currentFrameStackTypes);
                    }
                    // Since there is already a stack map frame for this bytecode offset, there is no need to
                    // insert a new one.
                    insertFrame = false;
                }
                if (stackMapFrameOffset < stackMapTableEndOffset) {
                    stackMapFrameOffset =
                            readStackMapFrame(stackMapFrameOffset, compressedFrames, expandFrames, context);
                } else {
                    stackMapFrameOffset = 0;
                }
            }

            // Insert a stack map frame for this bytecode offset, if requested by setting insertFrame to
            // true during the previous iteration. The actual frame content is computed in MethodWriter.
            if (insertFrame) {
                if ((context.parsingOptions & EXPAND_FRAMES) != 0) {
                    methodVisitor.visitFrame(Constants.F_INSERT, 0, null, 0, null);
                }
                insertFrame = false;
            }

            // Visit the instruction at this bytecode offset.
            int opcode = classBuffer[currentOffset] & 0xFF;
            switch (opcode) {
                case Opcodes.NOP:
                case Opcodes.ACONST_NULL:
                case Opcodes.ICONST_M1:
                case Opcodes.ICONST_0:
                case Opcodes.ICONST_1:
                case Opcodes.ICONST_2:
                case Opcodes.ICONST_3:
                case Opcodes.ICONST_4:
                case Opcodes.ICONST_5:
                case Opcodes.LCONST_0:
                case Opcodes.LCONST_1:
                case Opcodes.FCONST_0:
                case Opcodes.FCONST_1:
                case Opcodes.FCONST_2:
                case Opcodes.DCONST_0:
                case Opcodes.DCONST_1:
                case Opcodes.IALOAD:
                case Opcodes.LALOAD:
                case Opcodes.FALOAD:
                case Opcodes.DALOAD:
                case Opcodes.AALOAD:
                case Opcodes.BALOAD:
                case Opcodes.CALOAD:
                case Opcodes.SALOAD:
                case Opcodes.IASTORE:
                case Opcodes.LASTORE:
                case Opcodes.FASTORE:
                case Opcodes.DASTORE:
                case Opcodes.AASTORE:
                case Opcodes.BASTORE:
                case Opcodes.CASTORE:
                case Opcodes.SASTORE:
                case Opcodes.POP:
                case Opcodes.POP2:
                case Opcodes.DUP:
                case Opcodes.DUP_X1:
                case Opcodes.DUP_X2:
                case Opcodes.DUP2:
                case Opcodes.DUP2_X1:
                case Opcodes.DUP2_X2:
                case Opcodes.SWAP:
                case Opcodes.IADD:
                case Opcodes.LADD:
                case Opcodes.FADD:
                case Opcodes.DADD:
                case Opcodes.ISUB:
                case Opcodes.LSUB:
                case Opcodes.FSUB:
                case Opcodes.DSUB:
                case Opcodes.IMUL:
                case Opcodes.LMUL:
                case Opcodes.FMUL:
                case Opcodes.DMUL:
                case Opcodes.IDIV:
                case Opcodes.LDIV:
                case Opcodes.FDIV:
                case Opcodes.DDIV:
                case Opcodes.IREM:
                case Opcodes.LREM:
                case Opcodes.FREM:
                case Opcodes.DREM:
                case Opcodes.INEG:
                case Opcodes.LNEG:
                case Opcodes.FNEG:
                case Opcodes.DNEG:
                case Opcodes.ISHL:
                case Opcodes.LSHL:
                case Opcodes.ISHR:
                case Opcodes.LSHR:
                case Opcodes.IUSHR:
                case Opcodes.LUSHR:
                case Opcodes.IAND:
                case Opcodes.LAND:
                case Opcodes.IOR:
                case Opcodes.LOR:
                case Opcodes.IXOR:
                case Opcodes.LXOR:
                case Opcodes.I2L:
                case Opcodes.I2F:
                case Opcodes.I2D:
                case Opcodes.L2I:
                case Opcodes.L2F:
                case Opcodes.L2D:
                case Opcodes.F2I:
                case Opcodes.F2L:
                case Opcodes.F2D:
                case Opcodes.D2I:
                case Opcodes.D2L:
                case Opcodes.D2F:
                case Opcodes.I2B:
                case Opcodes.I2C:
                case Opcodes.I2S:
                case Opcodes.LCMP:
                case Opcodes.FCMPL:
                case Opcodes.FCMPG:
                case Opcodes.DCMPL:
                case Opcodes.DCMPG:
                case Opcodes.IRETURN:
                case Opcodes.LRETURN:
                case Opcodes.FRETURN:
                case Opcodes.DRETURN:
                case Opcodes.ARETURN:
                case Opcodes.RETURN:
                case Opcodes.ARRAYLENGTH:
                case Opcodes.ATHROW:
                case Opcodes.MONITORENTER:
                case Opcodes.MONITOREXIT:
                    methodVisitor.visitInsn(opcode);
                    currentOffset += 1;
                    break;
                case Constants.ILOAD_0:
                case Constants.ILOAD_1:
                case Constants.ILOAD_2:
                case Constants.ILOAD_3:
                case Constants.LLOAD_0:
                case Constants.LLOAD_1:
                case Constants.LLOAD_2:
                case Constants.LLOAD_3:
                case Constants.FLOAD_0:
                case Constants.FLOAD_1:
                case Constants.FLOAD_2:
                case Constants.FLOAD_3:
                case Constants.DLOAD_0:
                case Constants.DLOAD_1:
                case Constants.DLOAD_2:
                case Constants.DLOAD_3:
                case Constants.ALOAD_0:
                case Constants.ALOAD_1:
                case Constants.ALOAD_2:
                case Constants.ALOAD_3:
                    opcode -= Constants.ILOAD_0;
                    methodVisitor.visitVarInsn(Opcodes.ILOAD + (opcode >> 2), opcode & 0x3);
                    currentOffset += 1;
                    break;
                case Constants.ISTORE_0:
                case Constants.ISTORE_1:
                case Constants.ISTORE_2:
                case Constants.ISTORE_3:
                case Constants.LSTORE_0:
                case Constants.LSTORE_1:
                case Constants.LSTORE_2:
                case Constants.LSTORE_3:
                case Constants.FSTORE_0:
                case Constants.FSTORE_1:
                case Constants.FSTORE_2:
                case Constants.FSTORE_3:
                case Constants.DSTORE_0:
                case Constants.DSTORE_1:
                case Constants.DSTORE_2:
                case Constants.DSTORE_3:
                case Constants.ASTORE_0:
                case Constants.ASTORE_1:
                case Constants.ASTORE_2:
                case Constants.ASTORE_3:
                    opcode -= Constants.ISTORE_0;
                    methodVisitor.visitVarInsn(Opcodes.ISTORE + (opcode >> 2), opcode & 0x3);
                    currentOffset += 1;
                    break;
                case Opcodes.IFEQ:
                case Opcodes.IFNE:
                case Opcodes.IFLT:
                case Opcodes.IFGE:
                case Opcodes.IFGT:
                case Opcodes.IFLE:
                case Opcodes.IF_ICMPEQ:
                case Opcodes.IF_ICMPNE:
                case Opcodes.IF_ICMPLT:
                case Opcodes.IF_ICMPGE:
                case Opcodes.IF_ICMPGT:
                case Opcodes.IF_ICMPLE:
                case Opcodes.IF_ACMPEQ:
                case Opcodes.IF_ACMPNE:
                case Opcodes.GOTO:
                case Opcodes.JSR:
                case Opcodes.IFNULL:
                case Opcodes.IFNONNULL:
                    methodVisitor.visitJumpInsn(
                            opcode, labels[currentBytecodeOffset + readShort(currentOffset + 1)]);
                    currentOffset += 3;
                    break;
                case Constants.GOTO_W:
                case Constants.JSR_W:
                    methodVisitor.visitJumpInsn(
                            opcode - wideJumpOpcodeDelta,
                            labels[currentBytecodeOffset + readInt(currentOffset + 1)]);
                    currentOffset += 5;
                    break;
                case Constants.ASM_IFEQ:
                case Constants.ASM_IFNE:
                case Constants.ASM_IFLT:
                case Constants.ASM_IFGE:
                case Constants.ASM_IFGT:
                case Constants.ASM_IFLE:
                case Constants.ASM_IF_ICMPEQ:
                case Constants.ASM_IF_ICMPNE:
                case Constants.ASM_IF_ICMPLT:
                case Constants.ASM_IF_ICMPGE:
                case Constants.ASM_IF_ICMPGT:
                case Constants.ASM_IF_ICMPLE:
                case Constants.ASM_IF_ACMPEQ:
                case Constants.ASM_IF_ACMPNE:
                case Constants.ASM_GOTO:
                case Constants.ASM_JSR:
                case Constants.ASM_IFNULL:
                case Constants.ASM_IFNONNULL:
                    {
                        // A forward jump with an offset > 32767. In this case we automatically replace ASM_GOTO
                        // with GOTO_W, ASM_JSR with JSR_W and ASM_IFxxx <l> with IFNOTxxx <L> GOTO_W <l> L:...,
                        // where IFNOTxxx is the "opposite" opcode of ASMS_IFxxx (e.g. IFNE for ASM_IFEQ) and
                        // where <L> designates the instruction just after the GOTO_W.
                        // First, change the ASM specific opcodes ASM_IFEQ ... ASM_JSR, ASM_IFNULL and
                        // ASM_IFNONNULL to IFEQ ... JSR, IFNULL and IFNONNULL.
                        opcode =
                                opcode < Constants.ASM_IFNULL
                                        ? opcode - Constants.ASM_OPCODE_DELTA
                                        : opcode - Constants.ASM_IFNULL_OPCODE_DELTA;
                        Label target = labels[currentBytecodeOffset + readUnsignedShort(currentOffset + 1)];
                        if (opcode == Opcodes.GOTO || opcode == Opcodes.JSR) {
                            // Replace GOTO with GOTO_W and JSR with JSR_W.
                            methodVisitor.visitJumpInsn(opcode + Constants.WIDE_JUMP_OPCODE_DELTA, target);
                        } else {
                            // Compute the "opposite" of opcode. This can be done by flipping the least
                            // significant bit for IFNULL and IFNONNULL, and similarly for IFEQ ... IF_ACMPEQ
                            // (with a pre and post offset by 1).
                            opcode = opcode < Opcodes.GOTO ? ((opcode + 1) ^ 1) - 1 : opcode ^ 1;
                            Label endif = createLabel(currentBytecodeOffset + 3, labels);
                            methodVisitor.visitJumpInsn(opcode, endif);
                            methodVisitor.visitJumpInsn(Constants.GOTO_W, target);
                            // endif designates the instruction just after GOTO_W, and is visited as part of the
                            // next instruction. Since it is a jump target, we need to insert a frame here.
                            insertFrame = true;
                        }
                        currentOffset += 3;
                        break;
                    }
                case Constants.ASM_GOTO_W:
                    // Replace ASM_GOTO_W with GOTO_W.
                    methodVisitor.visitJumpInsn(
                            Constants.GOTO_W, labels[currentBytecodeOffset + readInt(currentOffset + 1)]);
                    // The instruction just after is a jump target (because ASM_GOTO_W is used in patterns
                    // IFNOTxxx <L> ASM_GOTO_W <l> L:..., see MethodWriter), so we need to insert a frame
                    // here.
                    insertFrame = true;
                    currentOffset += 5;
                    break;
                case Constants.WIDE:
                    opcode = classBuffer[currentOffset + 1] & 0xFF;
                    if (opcode == Opcodes.IINC) {
                        methodVisitor.visitIincInsn(
                                readUnsignedShort(currentOffset + 2), readShort(currentOffset + 4));
                        currentOffset += 6;
                    } else {
                        methodVisitor.visitVarInsn(opcode, readUnsignedShort(currentOffset + 2));
                        currentOffset += 4;
                    }
                    break;
                case Opcodes.TABLESWITCH:
                    {
                        // Skip 0 to 3 padding bytes.
                        currentOffset += 4 - (currentBytecodeOffset & 3);
                        // Read the instruction.
                        Label defaultLabel = labels[currentBytecodeOffset + readInt(currentOffset)];
                        int low = readInt(currentOffset + 4);
                        int high = readInt(currentOffset + 8);
                        currentOffset += 12;
                        Label[] table = new Label[high - low + 1];
                        for (int i = 0; i < table.length; ++i) {
                            table[i] = labels[currentBytecodeOffset + readInt(currentOffset)];
                            currentOffset += 4;
                        }
                        methodVisitor.visitTableSwitchInsn(low, high, defaultLabel, table);
                        break;
                    }
                case Opcodes.LOOKUPSWITCH:
                    {
                        // Skip 0 to 3 padding bytes.
                        currentOffset += 4 - (currentBytecodeOffset & 3);
                        // Read the instruction.
                        Label defaultLabel = labels[currentBytecodeOffset + readInt(currentOffset)];
                        int numPairs = readInt(currentOffset + 4);
                        currentOffset += 8;
                        int[] keys = new int[numPairs];
                        Label[] values = new Label[numPairs];
                        for (int i = 0; i < numPairs; ++i) {
                            keys[i] = readInt(currentOffset);
                            values[i] = labels[currentBytecodeOffset + readInt(currentOffset + 4)];
                            currentOffset += 8;
                        }
                        methodVisitor.visitLookupSwitchInsn(defaultLabel, keys, values);
                        break;
                    }
                case Opcodes.ILOAD:
                case Opcodes.LLOAD:
                case Opcodes.FLOAD:
                case Opcodes.DLOAD:
                case Opcodes.ALOAD:
                case Opcodes.ISTORE:
                case Opcodes.LSTORE:
                case Opcodes.FSTORE:
                case Opcodes.DSTORE:
                case Opcodes.ASTORE:
                case Opcodes.RET:
                    methodVisitor.visitVarInsn(opcode, classBuffer[currentOffset + 1] & 0xFF);
                    currentOffset += 2;
                    break;
                case Opcodes.BIPUSH:
                case Opcodes.NEWARRAY:
                    methodVisitor.visitIntInsn(opcode, classBuffer[currentOffset + 1]);
                    currentOffset += 2;
                    break;
                case Opcodes.SIPUSH:
                    methodVisitor.visitIntInsn(opcode, readShort(currentOffset + 1));
                    currentOffset += 3;
                    break;
                case Opcodes.LDC:
                    methodVisitor.visitLdcInsn(readConst(classBuffer[currentOffset + 1] & 0xFF, charBuffer));
                    currentOffset += 2;
                    break;
                case Constants.LDC_W:
                case Constants.LDC2_W:
                    methodVisitor.visitLdcInsn(readConst(readUnsignedShort(currentOffset + 1), charBuffer));
                    currentOffset += 3;
                    break;
                case Opcodes.GETSTATIC:
                case Opcodes.PUTSTATIC:
                case Opcodes.GETFIELD:
                case Opcodes.PUTFIELD:
                case Opcodes.INVOKEVIRTUAL:
                case Opcodes.INVOKESPECIAL:
                case Opcodes.INVOKESTATIC:
                case Opcodes.INVOKEINTERFACE:
                    {
                        int cpInfoOffset = cpInfoOffsets[readUnsignedShort(currentOffset + 1)];
                        int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 2)];
                        String owner = readClass(cpInfoOffset, charBuffer);
                        String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
                        String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
                        if (opcode < Opcodes.INVOKEVIRTUAL) {
                            methodVisitor.visitFieldInsn(opcode, owner, name, descriptor);
                        } else {
                            boolean isInterface =
                                    classBuffer[cpInfoOffset - 1] == Symbol.CONSTANT_INTERFACE_METHODREF_TAG;
                            methodVisitor.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
                        }
                        if (opcode == Opcodes.INVOKEINTERFACE) {
                            currentOffset += 5;
                        } else {
                            currentOffset += 3;
                        }
                        break;
                    }
                case Opcodes.INVOKEDYNAMIC:
                    {
                        int cpInfoOffset = cpInfoOffsets[readUnsignedShort(currentOffset + 1)];
                        int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 2)];
                        String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
                        String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
                        int bootstrapMethodOffset = bootstrapMethodOffsets[readUnsignedShort(cpInfoOffset)];
                        Handle handle =
                                (Handle) readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
                        Object[] bootstrapMethodArguments =
                                new Object[readUnsignedShort(bootstrapMethodOffset + 2)];
                        bootstrapMethodOffset += 4;
                        for (int i = 0; i < bootstrapMethodArguments.length; i++) {
                            bootstrapMethodArguments[i] =
                                    readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
                            bootstrapMethodOffset += 2;
                        }
                        methodVisitor.visitInvokeDynamicInsn(
                                name, descriptor, handle, bootstrapMethodArguments);
                        currentOffset += 5;
                        break;
                    }
                case Opcodes.NEW:
                case Opcodes.ANEWARRAY:
                case Opcodes.CHECKCAST:
                case Opcodes.INSTANCEOF:
                    methodVisitor.visitTypeInsn(opcode, readClass(currentOffset + 1, charBuffer));
                    currentOffset += 3;
                    break;
                case Opcodes.IINC:
                    methodVisitor.visitIincInsn(
                            classBuffer[currentOffset + 1] & 0xFF, classBuffer[currentOffset + 2]);
                    currentOffset += 3;
                    break;
                case Opcodes.MULTIANEWARRAY:
                    methodVisitor.visitMultiANewArrayInsn(
                            readClass(currentOffset + 1, charBuffer), classBuffer[currentOffset + 3] & 0xFF);
                    currentOffset += 4;
                    break;
                default:
                    throw new AssertionError();
            }

            // Visit the runtime visible instruction annotations, if any.
            while (visibleTypeAnnotationOffsets != null
                    && currentVisibleTypeAnnotationIndex < visibleTypeAnnotationOffsets.length
                    && currentVisibleTypeAnnotationBytecodeOffset <= currentBytecodeOffset) {
                if (currentVisibleTypeAnnotationBytecodeOffset == currentBytecodeOffset) {
                    // Parse the target_type, target_info and target_path fields.
                    int currentAnnotationOffset =
                            readTypeAnnotationTarget(
                                    context, visibleTypeAnnotationOffsets[currentVisibleTypeAnnotationIndex]);
                    // Parse the type_index field.
                    String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                    currentAnnotationOffset += 2;
                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
                    readElementValues(
                            methodVisitor.visitInsnAnnotation(
                                    context.currentTypeAnnotationTarget,
                                    context.currentTypeAnnotationTargetPath,
                                    annotationDescriptor,
                                    /* visible = */ true),
                            currentAnnotationOffset,
                            /* named = */ true,
                            charBuffer);
                }
                currentVisibleTypeAnnotationBytecodeOffset =
                        getTypeAnnotationBytecodeOffset(
                                visibleTypeAnnotationOffsets, ++currentVisibleTypeAnnotationIndex);
            }

            // Visit the runtime invisible instruction annotations, if any.
            while (invisibleTypeAnnotationOffsets != null
                    && currentInvisibleTypeAnnotationIndex < invisibleTypeAnnotationOffsets.length
                    && currentInvisibleTypeAnnotationBytecodeOffset <= currentBytecodeOffset) {
                if (currentInvisibleTypeAnnotationBytecodeOffset == currentBytecodeOffset) {
                    // Parse the target_type, target_info and target_path fields.
                    int currentAnnotationOffset =
                            readTypeAnnotationTarget(
                                    context, invisibleTypeAnnotationOffsets[currentInvisibleTypeAnnotationIndex]);
                    // Parse the type_index field.
                    String annotationDescriptor = readUTF8(currentAnnotationOffset, charBuffer);
                    currentAnnotationOffset += 2;
                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
                    readElementValues(
                            methodVisitor.visitInsnAnnotation(
                                    context.currentTypeAnnotationTarget,
                                    context.currentTypeAnnotationTargetPath,
                                    annotationDescriptor,
                                    /* visible = */ false),
                            currentAnnotationOffset,
                            /* named = */ true,
                            charBuffer);
                }
                currentInvisibleTypeAnnotationBytecodeOffset =
                        getTypeAnnotationBytecodeOffset(
                                invisibleTypeAnnotationOffsets, ++currentInvisibleTypeAnnotationIndex);
            }
        }
        if (labels[codeLength] != null) {
            methodVisitor.visitLabel(labels[codeLength]);
        }

        // Visit LocalVariableTable and LocalVariableTypeTable attributes.
        if (localVariableTableOffset != 0 && (context.parsingOptions & SKIP_DEBUG) == 0) {
            // The (start_pc, index, signature_index) fields of each entry of the LocalVariableTypeTable.
            int[] typeTable = null;
            if (localVariableTypeTableOffset != 0) {
                typeTable = new int[readUnsignedShort(localVariableTypeTableOffset) * 3];
                currentOffset = localVariableTypeTableOffset + 2;
                int typeTableIndex = typeTable.length;
                while (typeTableIndex > 0) {
                    // Store the offset of 'signature_index', and the value of 'index' and 'start_pc'.
                    typeTable[--typeTableIndex] = currentOffset + 6;
                    typeTable[--typeTableIndex] = readUnsignedShort(currentOffset + 8);
                    typeTable[--typeTableIndex] = readUnsignedShort(currentOffset);
                    currentOffset += 10;
                }
            }
            int localVariableTableLength = readUnsignedShort(localVariableTableOffset);
            currentOffset = localVariableTableOffset + 2;
            while (localVariableTableLength-- > 0) {
                int startPc = readUnsignedShort(currentOffset);
                int length = readUnsignedShort(currentOffset + 2);
                String name = readUTF8(currentOffset + 4, charBuffer);
                String descriptor = readUTF8(currentOffset + 6, charBuffer);
                int index = readUnsignedShort(currentOffset + 8);
                currentOffset += 10;
                String signature = null;
                if (typeTable != null) {
                    for (int i = 0; i < typeTable.length; i += 3) {
                        if (typeTable[i] == startPc && typeTable[i + 1] == index) {
                            signature = readUTF8(typeTable[i + 2], charBuffer);
                            break;
                        }
                    }
                }
                methodVisitor.visitLocalVariable(
                        name, descriptor, signature, labels[startPc], labels[startPc + length], index);
            }
        }

        // Visit the local variable type annotations of the RuntimeVisibleTypeAnnotations attribute.
        if (visibleTypeAnnotationOffsets != null) {
            for (int typeAnnotationOffset : visibleTypeAnnotationOffsets) {
                int targetType = readByte(typeAnnotationOffset);
                if (targetType == TypeReference.LOCAL_VARIABLE
                        || targetType == TypeReference.RESOURCE_VARIABLE) {
                    // Parse the target_type, target_info and target_path fields.
                    currentOffset = readTypeAnnotationTarget(context, typeAnnotationOffset);
                    // Parse the type_index field.
                    String annotationDescriptor = readUTF8(currentOffset, charBuffer);
                    currentOffset += 2;
                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
                    readElementValues(
                            methodVisitor.visitLocalVariableAnnotation(
                                    context.currentTypeAnnotationTarget,
                                    context.currentTypeAnnotationTargetPath,
                                    context.currentLocalVariableAnnotationRangeStarts,
                                    context.currentLocalVariableAnnotationRangeEnds,
                                    context.currentLocalVariableAnnotationRangeIndices,
                                    annotationDescriptor,
                                    /* visible = */ true),
                            currentOffset,
                            /* named = */ true,
                            charBuffer);
                }
            }
        }

        // Visit the local variable type annotations of the RuntimeInvisibleTypeAnnotations attribute.
        if (invisibleTypeAnnotationOffsets != null) {
            for (int typeAnnotationOffset : invisibleTypeAnnotationOffsets) {
                int targetType = readByte(typeAnnotationOffset);
                if (targetType == TypeReference.LOCAL_VARIABLE
                        || targetType == TypeReference.RESOURCE_VARIABLE) {
                    // Parse the target_type, target_info and target_path fields.
                    currentOffset = readTypeAnnotationTarget(context, typeAnnotationOffset);
                    // Parse the type_index field.
                    String annotationDescriptor = readUTF8(currentOffset, charBuffer);
                    currentOffset += 2;
                    // Parse num_element_value_pairs and element_value_pairs and visit these values.
                    readElementValues(
                            methodVisitor.visitLocalVariableAnnotation(
                                    context.currentTypeAnnotationTarget,
                                    context.currentTypeAnnotationTargetPath,
                                    context.currentLocalVariableAnnotationRangeStarts,
                                    context.currentLocalVariableAnnotationRangeEnds,
                                    context.currentLocalVariableAnnotationRangeIndices,
                                    annotationDescriptor,
                                    /* visible = */ false),
                            currentOffset,
                            /* named = */ true,
                            charBuffer);
                }
            }
        }

        // Visit the non standard attributes.
        while (attributes != null) {
            // Copy and reset the nextAttribute field so that it can also be used in MethodWriter.
            Attribute nextAttribute = attributes.nextAttribute;
            attributes.nextAttribute = null;
            methodVisitor.visitAttribute(attributes);
            attributes = nextAttribute;
        }

        // Visit the max stack and max locals values.
        methodVisitor.visitMaxs(maxStack, maxLocals);
    }

    
Returns the label corresponding to the given bytecode offset. The default implementation of
this method creates a label for the given offset if it has not been already created.

Params:
  • bytecodeOffset – a bytecode offset in a method.
  • labels – the already created labels, indexed by their offset. If a label already exists
    for bytecodeOffset this method must not create a new one. Otherwise it must store the new
    label in this array.
Returns:a non null Label, which must be equal to labels[bytecodeOffset].
/**
      * Returns the label corresponding to the given bytecode offset. The default implementation of
      * this method creates a label for the given offset if it has not been already created.
      *
      * @param bytecodeOffset a bytecode offset in a method.
      * @param labels the already created labels, indexed by their offset. If a label already exists
      *     for bytecodeOffset this method must not create a new one. Otherwise it must store the new
      *     label in this array.
      * @return a non null Label, which must be equal to labels[bytecodeOffset].
      */
    protected Label readLabel(final int bytecodeOffset, final Label[] labels) {
        if (labels[bytecodeOffset] == null) {
            labels[bytecodeOffset] = new Label();
        }
        return labels[bytecodeOffset];
    }

    
Creates a label without the Label.FLAG_DEBUG_ONLY flag set, for the given bytecode offset. The label is created with a call to readLabel and its Label.FLAG_DEBUG_ONLY flag is cleared. 
Params:
  • bytecodeOffset – a bytecode offset in a method.
  • labels – the already created labels, indexed by their offset.
Returns:a Label without the Label.FLAG_DEBUG_ONLY flag set.
/**
      * Creates a label without the {@link Label#FLAG_DEBUG_ONLY} flag set, for the given bytecode
      * offset. The label is created with a call to {@link #readLabel} and its {@link
      * Label#FLAG_DEBUG_ONLY} flag is cleared.
      *
      * @param bytecodeOffset a bytecode offset in a method.
      * @param labels the already created labels, indexed by their offset.
      * @return a Label without the {@link Label#FLAG_DEBUG_ONLY} flag set.
      */
    private Label createLabel(final int bytecodeOffset, final Label[] labels) {
        Label label = readLabel(bytecodeOffset, labels);
        label.flags &= ~Label.FLAG_DEBUG_ONLY;
        return label;
    }

    
Creates a label with the Label.FLAG_DEBUG_ONLY flag set, if there is no already existing label for the given bytecode offset (otherwise does nothing). The label is created with a call to readLabel. 
Params:
  • bytecodeOffset – a bytecode offset in a method.
  • labels – the already created labels, indexed by their offset.
/**
      * Creates a label with the {@link Label#FLAG_DEBUG_ONLY} flag set, if there is no already
      * existing label for the given bytecode offset (otherwise does nothing). The label is created
      * with a call to {@link #readLabel}.
      *
      * @param bytecodeOffset a bytecode offset in a method.
      * @param labels the already created labels, indexed by their offset.
      */
    private void createDebugLabel(final int bytecodeOffset, final Label[] labels) {
        if (labels[bytecodeOffset] == null) {
            readLabel(bytecodeOffset, labels).flags |= Label.FLAG_DEBUG_ONLY;
        }
    }

    // ----------------------------------------------------------------------------------------------
    // Methods to parse annotations, type annotations and parameter annotations
    // ----------------------------------------------------------------------------------------------

    
Parses a Runtime[In]VisibleTypeAnnotations attribute to find the offset of each type_annotation
entry it contains, to find the corresponding labels, and to visit the try catch block
annotations.

Params:
  • methodVisitor – the method visitor to be used to visit the try catch block annotations.
  • context – information about the class being parsed.
  • runtimeTypeAnnotationsOffset – the start offset of a Runtime[In]VisibleTypeAnnotations
    attribute, excluding the attribute_info's attribute_name_index and attribute_length fields.
  • visible – true if the attribute to parse is a RuntimeVisibleTypeAnnotations attribute,
    false it is a RuntimeInvisibleTypeAnnotations attribute.
Returns:the start offset of each entry of the Runtime[In]VisibleTypeAnnotations_attribute's
    'annotations' array field.
/**
      * Parses a Runtime[In]VisibleTypeAnnotations attribute to find the offset of each type_annotation
      * entry it contains, to find the corresponding labels, and to visit the try catch block
      * annotations.
      *
      * @param methodVisitor the method visitor to be used to visit the try catch block annotations.
      * @param context information about the class being parsed.
      * @param runtimeTypeAnnotationsOffset the start offset of a Runtime[In]VisibleTypeAnnotations
      *     attribute, excluding the attribute_info's attribute_name_index and attribute_length fields.
      * @param visible true if the attribute to parse is a RuntimeVisibleTypeAnnotations attribute,
      *     false it is a RuntimeInvisibleTypeAnnotations attribute.
      * @return the start offset of each entry of the Runtime[In]VisibleTypeAnnotations_attribute's
      *     'annotations' array field.
      */
    private int[] readTypeAnnotations(
            final MethodVisitor methodVisitor,
            final Context context,
            final int runtimeTypeAnnotationsOffset,
            final boolean visible) {
        char[] charBuffer = context.charBuffer;
        int currentOffset = runtimeTypeAnnotationsOffset;
        // Read the num_annotations field and create an array to store the type_annotation offsets.
        int[] typeAnnotationsOffsets = new int[readUnsignedShort(currentOffset)];
        currentOffset += 2;
        // Parse the 'annotations' array field.
        for (int i = 0; i < typeAnnotationsOffsets.length; ++i) {
            typeAnnotationsOffsets[i] = currentOffset;
            // Parse the type_annotation's target_type and the target_info fields. The size of the
            // target_info field depends on the value of target_type.
            int targetType = readInt(currentOffset);
            switch (targetType >>> 24) {
                case TypeReference.LOCAL_VARIABLE:
                case TypeReference.RESOURCE_VARIABLE:
                    // A localvar_target has a variable size, which depends on the value of their table_length
                    // field. It also references bytecode offsets, for which we need labels.
                    int tableLength = readUnsignedShort(currentOffset + 1);
                    currentOffset += 3;
                    while (tableLength-- > 0) {
                        int startPc = readUnsignedShort(currentOffset);
                        int length = readUnsignedShort(currentOffset + 2);
                        // Skip the index field (2 bytes).
                        currentOffset += 6;
                        createLabel(startPc, context.currentMethodLabels);
                        createLabel(startPc + length, context.currentMethodLabels);
                    }
                    break;
                case TypeReference.CAST:
                case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
                case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT:
                case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
                case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT:
                    currentOffset += 4;
                    break;
                case TypeReference.CLASS_EXTENDS:
                case TypeReference.CLASS_TYPE_PARAMETER_BOUND:
                case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
                case TypeReference.THROWS:
                case TypeReference.EXCEPTION_PARAMETER:
                case TypeReference.INSTANCEOF:
                case TypeReference.NEW:
                case TypeReference.CONSTRUCTOR_REFERENCE:
                case TypeReference.METHOD_REFERENCE:
                    currentOffset += 3;
                    break;
                case TypeReference.CLASS_TYPE_PARAMETER:
                case TypeReference.METHOD_TYPE_PARAMETER:
                case TypeReference.METHOD_FORMAL_PARAMETER:
                case TypeReference.FIELD:
                case TypeReference.METHOD_RETURN:
                case TypeReference.METHOD_RECEIVER:
                default:
                    // TypeReference type which can't be used in Code attribute, or which is unknown.
                    throw new IllegalArgumentException();
            }
            // Parse the rest of the type_annotation structure, starting with the target_path structure
            // (whose size depends on its path_length field).
            int pathLength = readByte(currentOffset);
            if ((targetType >>> 24) == TypeReference.EXCEPTION_PARAMETER) {
                // Parse the target_path structure and create a corresponding TypePath.
                TypePath path = pathLength == 0 ? null : new TypePath(classFileBuffer, currentOffset);
                currentOffset += 1 + 2 * pathLength;
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentOffset, charBuffer);
                currentOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentOffset =
                        readElementValues(
                                methodVisitor.visitTryCatchAnnotation(
                                        targetType & 0xFFFFFF00, path, annotationDescriptor, visible),
                                currentOffset,
                                /* named = */ true,
                                charBuffer);
            } else {
                // We don't want to visit the other target_type annotations, so we just skip them (which
                // requires some parsing because the element_value_pairs array has a variable size). First,
                // skip the target_path structure:
                currentOffset += 3 + 2 * pathLength;
                // Then skip the num_element_value_pairs and element_value_pairs fields (by reading them
                // with a null AnnotationVisitor).
                currentOffset =
                        readElementValues(
                                /* annotationVisitor = */ null, currentOffset, /* named = */ true, charBuffer);
            }
        }
        return typeAnnotationsOffsets;
    }

    
Returns the bytecode offset corresponding to the specified JVMS 'type_annotation' structure, or
-1 if there is no such type_annotation of if it does not have a bytecode offset.

Params:
  • typeAnnotationOffsets – the offset of each 'type_annotation' entry in a Runtime[In]VisibleTypeAnnotations attribute, or null.
  • typeAnnotationIndex – the index a 'type_annotation' entry in typeAnnotationOffsets.
Returns:bytecode offset corresponding to the specified JVMS 'type_annotation' structure, or -1
    if there is no such type_annotation of if it does not have a bytecode offset.
/**
      * Returns the bytecode offset corresponding to the specified JVMS 'type_annotation' structure, or
      * -1 if there is no such type_annotation of if it does not have a bytecode offset.
      *
      * @param typeAnnotationOffsets the offset of each 'type_annotation' entry in a
      *     Runtime[In]VisibleTypeAnnotations attribute, or {@literal null}.
      * @param typeAnnotationIndex the index a 'type_annotation' entry in typeAnnotationOffsets.
      * @return bytecode offset corresponding to the specified JVMS 'type_annotation' structure, or -1
      *     if there is no such type_annotation of if it does not have a bytecode offset.
      */
    private int getTypeAnnotationBytecodeOffset(
            final int[] typeAnnotationOffsets, final int typeAnnotationIndex) {
        if (typeAnnotationOffsets == null
                || typeAnnotationIndex >= typeAnnotationOffsets.length
                || readByte(typeAnnotationOffsets[typeAnnotationIndex]) < TypeReference.INSTANCEOF) {
            return -1;
        }
        return readUnsignedShort(typeAnnotationOffsets[typeAnnotationIndex] + 1);
    }

    
Parses the header of a JVMS type_annotation structure to extract its target_type, target_info
and target_path (the result is stored in the given context), and returns the start offset of
the rest of the type_annotation structure.

Params:
  • context – information about the class being parsed. This is where the extracted
    target_type and target_path must be stored.
  • typeAnnotationOffset – the start offset of a type_annotation structure.
Returns:the start offset of the rest of the type_annotation structure.
/**
      * Parses the header of a JVMS type_annotation structure to extract its target_type, target_info
      * and target_path (the result is stored in the given context), and returns the start offset of
      * the rest of the type_annotation structure.
      *
      * @param context information about the class being parsed. This is where the extracted
      *     target_type and target_path must be stored.
      * @param typeAnnotationOffset the start offset of a type_annotation structure.
      * @return the start offset of the rest of the type_annotation structure.
      */
    private int readTypeAnnotationTarget(final Context context, final int typeAnnotationOffset) {
        int currentOffset = typeAnnotationOffset;
        // Parse and store the target_type structure.
        int targetType = readInt(typeAnnotationOffset);
        switch (targetType >>> 24) {
            case TypeReference.CLASS_TYPE_PARAMETER:
            case TypeReference.METHOD_TYPE_PARAMETER:
            case TypeReference.METHOD_FORMAL_PARAMETER:
                targetType &= 0xFFFF0000;
                currentOffset += 2;
                break;
            case TypeReference.FIELD:
            case TypeReference.METHOD_RETURN:
            case TypeReference.METHOD_RECEIVER:
                targetType &= 0xFF000000;
                currentOffset += 1;
                break;
            case TypeReference.LOCAL_VARIABLE:
            case TypeReference.RESOURCE_VARIABLE:
                targetType &= 0xFF000000;
                int tableLength = readUnsignedShort(currentOffset + 1);
                currentOffset += 3;
                context.currentLocalVariableAnnotationRangeStarts = new Label[tableLength];
                context.currentLocalVariableAnnotationRangeEnds = new Label[tableLength];
                context.currentLocalVariableAnnotationRangeIndices = new int[tableLength];
                for (int i = 0; i < tableLength; ++i) {
                    int startPc = readUnsignedShort(currentOffset);
                    int length = readUnsignedShort(currentOffset + 2);
                    int index = readUnsignedShort(currentOffset + 4);
                    currentOffset += 6;
                    context.currentLocalVariableAnnotationRangeStarts[i] =
                            createLabel(startPc, context.currentMethodLabels);
                    context.currentLocalVariableAnnotationRangeEnds[i] =
                            createLabel(startPc + length, context.currentMethodLabels);
                    context.currentLocalVariableAnnotationRangeIndices[i] = index;
                }
                break;
            case TypeReference.CAST:
            case TypeReference.CONSTRUCTOR_INVOCATION_TYPE_ARGUMENT:
            case TypeReference.METHOD_INVOCATION_TYPE_ARGUMENT:
            case TypeReference.CONSTRUCTOR_REFERENCE_TYPE_ARGUMENT:
            case TypeReference.METHOD_REFERENCE_TYPE_ARGUMENT:
                targetType &= 0xFF0000FF;
                currentOffset += 4;
                break;
            case TypeReference.CLASS_EXTENDS:
            case TypeReference.CLASS_TYPE_PARAMETER_BOUND:
            case TypeReference.METHOD_TYPE_PARAMETER_BOUND:
            case TypeReference.THROWS:
            case TypeReference.EXCEPTION_PARAMETER:
                targetType &= 0xFFFFFF00;
                currentOffset += 3;
                break;
            case TypeReference.INSTANCEOF:
            case TypeReference.NEW:
            case TypeReference.CONSTRUCTOR_REFERENCE:
            case TypeReference.METHOD_REFERENCE:
                targetType &= 0xFF000000;
                currentOffset += 3;
                break;
            default:
                throw new IllegalArgumentException();
        }
        context.currentTypeAnnotationTarget = targetType;
        // Parse and store the target_path structure.
        int pathLength = readByte(currentOffset);
        context.currentTypeAnnotationTargetPath =
                pathLength == 0 ? null : new TypePath(classFileBuffer, currentOffset);
        // Return the start offset of the rest of the type_annotation structure.
        return currentOffset + 1 + 2 * pathLength;
    }

    
Reads a Runtime[In]VisibleParameterAnnotations attribute and makes the given visitor visit it.

Params:
  • methodVisitor – the visitor that must visit the parameter annotations.
  • context – information about the class being parsed.
  • runtimeParameterAnnotationsOffset – the start offset of a
    Runtime[In]VisibleParameterAnnotations attribute, excluding the attribute_info's
    attribute_name_index and attribute_length fields.
  • visible – true if the attribute to parse is a RuntimeVisibleParameterAnnotations
    attribute, false it is a RuntimeInvisibleParameterAnnotations attribute.
/**
      * Reads a Runtime[In]VisibleParameterAnnotations attribute and makes the given visitor visit it.
      *
      * @param methodVisitor the visitor that must visit the parameter annotations.
      * @param context information about the class being parsed.
      * @param runtimeParameterAnnotationsOffset the start offset of a
      *     Runtime[In]VisibleParameterAnnotations attribute, excluding the attribute_info's
      *     attribute_name_index and attribute_length fields.
      * @param visible true if the attribute to parse is a RuntimeVisibleParameterAnnotations
      *     attribute, false it is a RuntimeInvisibleParameterAnnotations attribute.
      */
    private void readParameterAnnotations(
            final MethodVisitor methodVisitor,
            final Context context,
            final int runtimeParameterAnnotationsOffset,
            final boolean visible) {
        int currentOffset = runtimeParameterAnnotationsOffset;
        int numParameters = classFileBuffer[currentOffset++] & 0xFF;
        methodVisitor.visitAnnotableParameterCount(numParameters, visible);
        char[] charBuffer = context.charBuffer;
        for (int i = 0; i < numParameters; ++i) {
            int numAnnotations = readUnsignedShort(currentOffset);
            currentOffset += 2;
            while (numAnnotations-- > 0) {
                // Parse the type_index field.
                String annotationDescriptor = readUTF8(currentOffset, charBuffer);
                currentOffset += 2;
                // Parse num_element_value_pairs and element_value_pairs and visit these values.
                currentOffset =
                        readElementValues(
                                methodVisitor.visitParameterAnnotation(i, annotationDescriptor, visible),
                                currentOffset,
                                /* named = */ true,
                                charBuffer);
            }
        }
    }

    
Reads the element values of a JVMS 'annotation' structure and makes the given visitor visit
them. This method can also be used to read the values of the JVMS 'array_value' field of an
annotation's 'element_value'.

Params:
  • annotationVisitor – the visitor that must visit the values.
  • annotationOffset – the start offset of an 'annotation' structure (excluding its type_index
    field) or of an 'array_value' structure.
  • named – if the annotation values are named or not. This should be true to parse the values
    of a JVMS 'annotation' structure, and false to parse the JVMS 'array_value' of an
    annotation's element_value.
  • charBuffer – the buffer used to read strings in the constant pool.
Returns:the end offset of the JVMS 'annotation' or 'array_value' structure.
/**
      * Reads the element values of a JVMS 'annotation' structure and makes the given visitor visit
      * them. This method can also be used to read the values of the JVMS 'array_value' field of an
      * annotation's 'element_value'.
      *
      * @param annotationVisitor the visitor that must visit the values.
      * @param annotationOffset the start offset of an 'annotation' structure (excluding its type_index
      *     field) or of an 'array_value' structure.
      * @param named if the annotation values are named or not. This should be true to parse the values
      *     of a JVMS 'annotation' structure, and false to parse the JVMS 'array_value' of an
      *     annotation's element_value.
      * @param charBuffer the buffer used to read strings in the constant pool.
      * @return the end offset of the JVMS 'annotation' or 'array_value' structure.
      */
    private int readElementValues(
            final AnnotationVisitor annotationVisitor,
            final int annotationOffset,
            final boolean named,
            final char[] charBuffer) {
        int currentOffset = annotationOffset;
        // Read the num_element_value_pairs field (or num_values field for an array_value).
        int numElementValuePairs = readUnsignedShort(currentOffset);
        currentOffset += 2;
        if (named) {
            // Parse the element_value_pairs array.
            while (numElementValuePairs-- > 0) {
                String elementName = readUTF8(currentOffset, charBuffer);
                currentOffset =
                        readElementValue(annotationVisitor, currentOffset + 2, elementName, charBuffer);
            }
        } else {
            // Parse the array_value array.
            while (numElementValuePairs-- > 0) {
                currentOffset =
                        readElementValue(annotationVisitor, currentOffset, /* named = */ null, charBuffer);
            }
        }
        if (annotationVisitor != null) {
            annotationVisitor.visitEnd();
        }
        return currentOffset;
    }

    
Reads a JVMS 'element_value' structure and makes the given visitor visit it.

Params:
  • annotationVisitor – the visitor that must visit the element_value structure.
  • elementValueOffset – the start offset in classFileBuffer of the element_value structure to be read.
  • elementName – the name of the element_value structure to be read, or null.
  • charBuffer – the buffer used to read strings in the constant pool.
Returns:the end offset of the JVMS 'element_value' structure.
/**
      * Reads a JVMS 'element_value' structure and makes the given visitor visit it.
      *
      * @param annotationVisitor the visitor that must visit the element_value structure.
      * @param elementValueOffset the start offset in {@link #classFileBuffer} of the element_value
      *     structure to be read.
      * @param elementName the name of the element_value structure to be read, or {@literal null}.
      * @param charBuffer the buffer used to read strings in the constant pool.
      * @return the end offset of the JVMS 'element_value' structure.
      */
    private int readElementValue(
            final AnnotationVisitor annotationVisitor,
            final int elementValueOffset,
            final String elementName,
            final char[] charBuffer) {
        int currentOffset = elementValueOffset;
        if (annotationVisitor == null) {
            switch (classFileBuffer[currentOffset] & 0xFF) {
                case 'e': // enum_const_value
                    return currentOffset + 5;
                case '@': // annotation_value
                    return readElementValues(null, currentOffset + 3, /* named = */ true, charBuffer);
                case '[': // array_value
                    return readElementValues(null, currentOffset + 1, /* named = */ false, charBuffer);
                default:
                    return currentOffset + 3;
            }
        }
        switch (classFileBuffer[currentOffset++] & 0xFF) {
            case 'B': // const_value_index, CONSTANT_Integer
                annotationVisitor.visit(
                        elementName, (byte) readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]));
                currentOffset += 2;
                break;
            case 'C': // const_value_index, CONSTANT_Integer
                annotationVisitor.visit(
                        elementName, (char) readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]));
                currentOffset += 2;
                break;
            case 'D': // const_value_index, CONSTANT_Double
            case 'F': // const_value_index, CONSTANT_Float
            case 'I': // const_value_index, CONSTANT_Integer
            case 'J': // const_value_index, CONSTANT_Long
                annotationVisitor.visit(
                        elementName, readConst(readUnsignedShort(currentOffset), charBuffer));
                currentOffset += 2;
                break;
            case 'S': // const_value_index, CONSTANT_Integer
                annotationVisitor.visit(
                        elementName, (short) readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]));
                currentOffset += 2;
                break;

            case 'Z': // const_value_index, CONSTANT_Integer
                annotationVisitor.visit(
                        elementName,
                        readInt(cpInfoOffsets[readUnsignedShort(currentOffset)]) == 0
                                ? Boolean.FALSE
                                : Boolean.TRUE);
                currentOffset += 2;
                break;
            case 's': // const_value_index, CONSTANT_Utf8
                annotationVisitor.visit(elementName, readUTF8(currentOffset, charBuffer));
                currentOffset += 2;
                break;
            case 'e': // enum_const_value
                annotationVisitor.visitEnum(
                        elementName,
                        readUTF8(currentOffset, charBuffer),
                        readUTF8(currentOffset + 2, charBuffer));
                currentOffset += 4;
                break;
            case 'c': // class_info
                annotationVisitor.visit(elementName, Type.getType(readUTF8(currentOffset, charBuffer)));
                currentOffset += 2;
                break;
            case '@': // annotation_value
                currentOffset =
                        readElementValues(
                                annotationVisitor.visitAnnotation(elementName, readUTF8(currentOffset, charBuffer)),
                                currentOffset + 2,
                                true,
                                charBuffer);
                break;
            case '[': // array_value
                int numValues = readUnsignedShort(currentOffset);
                currentOffset += 2;
                if (numValues == 0) {
                    return readElementValues(
                            annotationVisitor.visitArray(elementName),
                            currentOffset - 2,
                            /* named = */ false,
                            charBuffer);
                }
                switch (classFileBuffer[currentOffset] & 0xFF) {
                    case 'B':
                        byte[] byteValues = new byte[numValues];
                        for (int i = 0; i < numValues; i++) {
                            byteValues[i] = (byte) readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, byteValues);
                        break;
                    case 'Z':
                        boolean[] booleanValues = new boolean[numValues];
                        for (int i = 0; i < numValues; i++) {
                            booleanValues[i] = readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]) != 0;
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, booleanValues);
                        break;
                    case 'S':
                        short[] shortValues = new short[numValues];
                        for (int i = 0; i < numValues; i++) {
                            shortValues[i] = (short) readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, shortValues);
                        break;
                    case 'C':
                        char[] charValues = new char[numValues];
                        for (int i = 0; i < numValues; i++) {
                            charValues[i] = (char) readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, charValues);
                        break;
                    case 'I':
                        int[] intValues = new int[numValues];
                        for (int i = 0; i < numValues; i++) {
                            intValues[i] = readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, intValues);
                        break;
                    case 'J':
                        long[] longValues = new long[numValues];
                        for (int i = 0; i < numValues; i++) {
                            longValues[i] = readLong(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]);
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, longValues);
                        break;
                    case 'F':
                        float[] floatValues = new float[numValues];
                        for (int i = 0; i < numValues; i++) {
                            floatValues[i] =
                                    Float.intBitsToFloat(
                                            readInt(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]));
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, floatValues);
                        break;
                    case 'D':
                        double[] doubleValues = new double[numValues];
                        for (int i = 0; i < numValues; i++) {
                            doubleValues[i] =
                                    Double.longBitsToDouble(
                                            readLong(cpInfoOffsets[readUnsignedShort(currentOffset + 1)]));
                            currentOffset += 3;
                        }
                        annotationVisitor.visit(elementName, doubleValues);
                        break;
                    default:
                        currentOffset =
                                readElementValues(
                                        annotationVisitor.visitArray(elementName),
                                        currentOffset - 2,
                                        /* named = */ false,
                                        charBuffer);
                        break;
                }
                break;
            default:
                throw new IllegalArgumentException();
        }
        return currentOffset;
    }

    // ----------------------------------------------------------------------------------------------
    // Methods to parse stack map frames
    // ----------------------------------------------------------------------------------------------

    
Computes the implicit frame of the method currently being parsed (as defined in the given Context) and stores it in the given context. 
Params:
  • context – information about the class being parsed.
/**
      * Computes the implicit frame of the method currently being parsed (as defined in the given
      * {@link Context}) and stores it in the given context.
      *
      * @param context information about the class being parsed.
      */
    private void computeImplicitFrame(final Context context) {
        String methodDescriptor = context.currentMethodDescriptor;
        Object[] locals = context.currentFrameLocalTypes;
        int numLocal = 0;
        if ((context.currentMethodAccessFlags & Opcodes.ACC_STATIC) == 0) {
            if ("<init>".equals(context.currentMethodName)) {
                locals[numLocal++] = Opcodes.UNINITIALIZED_THIS;
            } else {
                locals[numLocal++] = readClass(header + 2, context.charBuffer);
            }
        }
        // Parse the method descriptor, one argument type descriptor at each iteration. Start by
        // skipping the first method descriptor character, which is always '('.
        int currentMethodDescritorOffset = 1;
        while (true) {
            int currentArgumentDescriptorStartOffset = currentMethodDescritorOffset;
            switch (methodDescriptor.charAt(currentMethodDescritorOffset++)) {
                case 'Z':
                case 'C':
                case 'B':
                case 'S':
                case 'I':
                    locals[numLocal++] = Opcodes.INTEGER;
                    break;
                case 'F':
                    locals[numLocal++] = Opcodes.FLOAT;
                    break;
                case 'J':
                    locals[numLocal++] = Opcodes.LONG;
                    break;
                case 'D':
                    locals[numLocal++] = Opcodes.DOUBLE;
                    break;
                case '[':
                    while (methodDescriptor.charAt(currentMethodDescritorOffset) == '[') {
                        ++currentMethodDescritorOffset;
                    }
                    if (methodDescriptor.charAt(currentMethodDescritorOffset) == 'L') {
                        ++currentMethodDescritorOffset;
                        while (methodDescriptor.charAt(currentMethodDescritorOffset) != ';') {
                            ++currentMethodDescritorOffset;
                        }
                    }
                    locals[numLocal++] =
                            methodDescriptor.substring(
                                    currentArgumentDescriptorStartOffset, ++currentMethodDescritorOffset);
                    break;
                case 'L':
                    while (methodDescriptor.charAt(currentMethodDescritorOffset) != ';') {
                        ++currentMethodDescritorOffset;
                    }
                    locals[numLocal++] =
                            methodDescriptor.substring(
                                    currentArgumentDescriptorStartOffset + 1, currentMethodDescritorOffset++);
                    break;
                default:
                    context.currentFrameLocalCount = numLocal;
                    return;
            }
        }
    }

    
Reads a JVMS 'stack_map_frame' structure and stores the result in the given Context object. This method can also be used to read a full_frame structure, excluding its frame_type field (this is used to parse the legacy StackMap attributes). 
Params:
  • stackMapFrameOffset – the start offset in classFileBuffer of the stack_map_frame_value structure to be read, or the start offset of a full_frame structure (excluding its frame_type field).
  • compressed – true to read a 'stack_map_frame' structure, false to read a 'full_frame'
    structure without its frame_type field.
  • expand – if the stack map frame must be expanded. See EXPAND_FRAMES.
  • context – where the parsed stack map frame must be stored.
Returns:the end offset of the JVMS 'stack_map_frame' or 'full_frame' structure.
/**
      * Reads a JVMS 'stack_map_frame' structure and stores the result in the given {@link Context}
      * object. This method can also be used to read a full_frame structure, excluding its frame_type
      * field (this is used to parse the legacy StackMap attributes).
      *
      * @param stackMapFrameOffset the start offset in {@link #classFileBuffer} of the
      *     stack_map_frame_value structure to be read, or the start offset of a full_frame structure
      *     (excluding its frame_type field).
      * @param compressed true to read a 'stack_map_frame' structure, false to read a 'full_frame'
      *     structure without its frame_type field.
      * @param expand if the stack map frame must be expanded. See {@link #EXPAND_FRAMES}.
      * @param context where the parsed stack map frame must be stored.
      * @return the end offset of the JVMS 'stack_map_frame' or 'full_frame' structure.
      */
    private int readStackMapFrame(
            final int stackMapFrameOffset,
            final boolean compressed,
            final boolean expand,
            final Context context) {
        int currentOffset = stackMapFrameOffset;
        final char[] charBuffer = context.charBuffer;
        final Label[] labels = context.currentMethodLabels;
        int frameType;
        if (compressed) {
            // Read the frame_type field.
            frameType = classFileBuffer[currentOffset++] & 0xFF;
        } else {
            frameType = Frame.FULL_FRAME;
            context.currentFrameOffset = -1;
        }
        int offsetDelta;
        context.currentFrameLocalCountDelta = 0;
        if (frameType < Frame.SAME_LOCALS_1_STACK_ITEM_FRAME) {
            offsetDelta = frameType;
            context.currentFrameType = Opcodes.F_SAME;
            context.currentFrameStackCount = 0;
        } else if (frameType < Frame.RESERVED) {
            offsetDelta = frameType - Frame.SAME_LOCALS_1_STACK_ITEM_FRAME;
            currentOffset =
                    readVerificationTypeInfo(
                            currentOffset, context.currentFrameStackTypes, 0, charBuffer, labels);
            context.currentFrameType = Opcodes.F_SAME1;
            context.currentFrameStackCount = 1;
        } else if (frameType >= Frame.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
            offsetDelta = readUnsignedShort(currentOffset);
            currentOffset += 2;
            if (frameType == Frame.SAME_LOCALS_1_STACK_ITEM_FRAME_EXTENDED) {
                currentOffset =
                        readVerificationTypeInfo(
                                currentOffset, context.currentFrameStackTypes, 0, charBuffer, labels);
                context.currentFrameType = Opcodes.F_SAME1;
                context.currentFrameStackCount = 1;
            } else if (frameType >= Frame.CHOP_FRAME && frameType < Frame.SAME_FRAME_EXTENDED) {
                context.currentFrameType = Opcodes.F_CHOP;
                context.currentFrameLocalCountDelta = Frame.SAME_FRAME_EXTENDED - frameType;
                context.currentFrameLocalCount -= context.currentFrameLocalCountDelta;
                context.currentFrameStackCount = 0;
            } else if (frameType == Frame.SAME_FRAME_EXTENDED) {
                context.currentFrameType = Opcodes.F_SAME;
                context.currentFrameStackCount = 0;
            } else if (frameType < Frame.FULL_FRAME) {
                int local = expand ? context.currentFrameLocalCount : 0;
                for (int k = frameType - Frame.SAME_FRAME_EXTENDED; k > 0; k--) {
                    currentOffset =
                            readVerificationTypeInfo(
                                    currentOffset, context.currentFrameLocalTypes, local++, charBuffer, labels);
                }
                context.currentFrameType = Opcodes.F_APPEND;
                context.currentFrameLocalCountDelta = frameType - Frame.SAME_FRAME_EXTENDED;
                context.currentFrameLocalCount += context.currentFrameLocalCountDelta;
                context.currentFrameStackCount = 0;
            } else {
                final int numberOfLocals = readUnsignedShort(currentOffset);
                currentOffset += 2;
                context.currentFrameType = Opcodes.F_FULL;
                context.currentFrameLocalCountDelta = numberOfLocals;
                context.currentFrameLocalCount = numberOfLocals;
                for (int local = 0; local < numberOfLocals; ++local) {
                    currentOffset =
                            readVerificationTypeInfo(
                                    currentOffset, context.currentFrameLocalTypes, local, charBuffer, labels);
                }
                final int numberOfStackItems = readUnsignedShort(currentOffset);
                currentOffset += 2;
                context.currentFrameStackCount = numberOfStackItems;
                for (int stack = 0; stack < numberOfStackItems; ++stack) {
                    currentOffset =
                            readVerificationTypeInfo(
                                    currentOffset, context.currentFrameStackTypes, stack, charBuffer, labels);
                }
            }
        } else {
            throw new IllegalArgumentException();
        }
        context.currentFrameOffset += offsetDelta + 1;
        createLabel(context.currentFrameOffset, labels);
        return currentOffset;
    }

    
Reads a JVMS 'verification_type_info' structure and stores it at the given index in the given
array.

Params:
  • verificationTypeInfoOffset – the start offset of the 'verification_type_info' structure to
    read.
  • frame – the array where the parsed type must be stored.
  • index – the index in 'frame' where the parsed type must be stored.
  • charBuffer – the buffer used to read strings in the constant pool.
  • labels – the labels of the method currently being parsed, indexed by their offset. If the
    parsed type is an ITEM_Uninitialized, a new label for the corresponding NEW instruction is
    stored in this array if it does not already exist.
Returns:the end offset of the JVMS 'verification_type_info' structure.
/**
      * Reads a JVMS 'verification_type_info' structure and stores it at the given index in the given
      * array.
      *
      * @param verificationTypeInfoOffset the start offset of the 'verification_type_info' structure to
      *     read.
      * @param frame the array where the parsed type must be stored.
      * @param index the index in 'frame' where the parsed type must be stored.
      * @param charBuffer the buffer used to read strings in the constant pool.
      * @param labels the labels of the method currently being parsed, indexed by their offset. If the
      *     parsed type is an ITEM_Uninitialized, a new label for the corresponding NEW instruction is
      *     stored in this array if it does not already exist.
      * @return the end offset of the JVMS 'verification_type_info' structure.
      */
    private int readVerificationTypeInfo(
            final int verificationTypeInfoOffset,
            final Object[] frame,
            final int index,
            final char[] charBuffer,
            final Label[] labels) {
        int currentOffset = verificationTypeInfoOffset;
        int tag = classFileBuffer[currentOffset++] & 0xFF;
        switch (tag) {
            case Frame.ITEM_TOP:
                frame[index] = Opcodes.TOP;
                break;
            case Frame.ITEM_INTEGER:
                frame[index] = Opcodes.INTEGER;
                break;
            case Frame.ITEM_FLOAT:
                frame[index] = Opcodes.FLOAT;
                break;
            case Frame.ITEM_DOUBLE:
                frame[index] = Opcodes.DOUBLE;
                break;
            case Frame.ITEM_LONG:
                frame[index] = Opcodes.LONG;
                break;
            case Frame.ITEM_NULL:
                frame[index] = Opcodes.NULL;
                break;
            case Frame.ITEM_UNINITIALIZED_THIS:
                frame[index] = Opcodes.UNINITIALIZED_THIS;
                break;
            case Frame.ITEM_OBJECT:
                frame[index] = readClass(currentOffset, charBuffer);
                currentOffset += 2;
                break;
            case Frame.ITEM_UNINITIALIZED:
                frame[index] = createLabel(readUnsignedShort(currentOffset), labels);
                currentOffset += 2;
                break;
            default:
                throw new IllegalArgumentException();
        }
        return currentOffset;
    }

    // ----------------------------------------------------------------------------------------------
    // Methods to parse attributes
    // ----------------------------------------------------------------------------------------------

    
Returns the offset in classFileBuffer of the first ClassFile's 'attributes' array field entry. 
Returns:the offset in classFileBuffer of the first ClassFile's 'attributes' array field entry.
/**
      * Returns the offset in {@link #classFileBuffer} of the first ClassFile's 'attributes' array
      * field entry.
      *
      * @return the offset in {@link #classFileBuffer} of the first ClassFile's 'attributes' array
      *     field entry.
      */
    final int getFirstAttributeOffset() {
        // Skip the access_flags, this_class, super_class, and interfaces_count fields (using 2 bytes
        // each), as well as the interfaces array field (2 bytes per interface).
        int currentOffset = header + 8 + readUnsignedShort(header + 6) * 2;

        // Read the fields_count field.
        int fieldsCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        // Skip the 'fields' array field.
        while (fieldsCount-- > 0) {
            // Invariant: currentOffset is the offset of a field_info structure.
            // Skip the access_flags, name_index and descriptor_index fields (2 bytes each), and read the
            // attributes_count field.
            int attributesCount = readUnsignedShort(currentOffset + 6);
            currentOffset += 8;
            // Skip the 'attributes' array field.
            while (attributesCount-- > 0) {
                // Invariant: currentOffset is the offset of an attribute_info structure.
                // Read the attribute_length field (2 bytes after the start of the attribute_info) and skip
                // this many bytes, plus 6 for the attribute_name_index and attribute_length fields
                // (yielding the total size of the attribute_info structure).
                currentOffset += 6 + readInt(currentOffset + 2);
            }
        }

        // Skip the methods_count and 'methods' fields, using the same method as above.
        int methodsCount = readUnsignedShort(currentOffset);
        currentOffset += 2;
        while (methodsCount-- > 0) {
            int attributesCount = readUnsignedShort(currentOffset + 6);
            currentOffset += 8;
            while (attributesCount-- > 0) {
                currentOffset += 6 + readInt(currentOffset + 2);
            }
        }

        // Skip the ClassFile's attributes_count field.
        return currentOffset + 2;
    }

    
Reads the BootstrapMethods attribute to compute the offset of each bootstrap method.

Params:
  • maxStringLength – a conservative estimate of the maximum length of the strings contained
    in the constant pool of the class.
Returns:the offsets of the bootstrap methods.
/**
      * Reads the BootstrapMethods attribute to compute the offset of each bootstrap method.
      *
      * @param maxStringLength a conservative estimate of the maximum length of the strings contained
      *     in the constant pool of the class.
      * @return the offsets of the bootstrap methods.
      */
    private int[] readBootstrapMethodsAttribute(final int maxStringLength) {
        char[] charBuffer = new char[maxStringLength];
        int currentAttributeOffset = getFirstAttributeOffset();
        int[] currentBootstrapMethodOffsets = null;
        for (int i = readUnsignedShort(currentAttributeOffset - 2); i > 0; --i) {
            // Read the attribute_info's attribute_name and attribute_length fields.
            String attributeName = readUTF8(currentAttributeOffset, charBuffer);
            int attributeLength = readInt(currentAttributeOffset + 2);
            currentAttributeOffset += 6;
            if (Constants.BOOTSTRAP_METHODS.equals(attributeName)) {
                // Read the num_bootstrap_methods field and create an array of this size.
                currentBootstrapMethodOffsets = new int[readUnsignedShort(currentAttributeOffset)];
                // Compute and store the offset of each 'bootstrap_methods' array field entry.
                int currentBootstrapMethodOffset = currentAttributeOffset + 2;
                for (int j = 0; j < currentBootstrapMethodOffsets.length; ++j) {
                    currentBootstrapMethodOffsets[j] = currentBootstrapMethodOffset;
                    // Skip the bootstrap_method_ref and num_bootstrap_arguments fields (2 bytes each),
                    // as well as the bootstrap_arguments array field (of size num_bootstrap_arguments * 2).
                    currentBootstrapMethodOffset +=
                            4 + readUnsignedShort(currentBootstrapMethodOffset + 2) * 2;
                }
                return currentBootstrapMethodOffsets;
            }
            currentAttributeOffset += attributeLength;
        }
        throw new IllegalArgumentException();
    }

    
Reads a non standard JVMS 'attribute' structure in classFileBuffer. 
Params:
  • attributePrototypes – prototypes of the attributes that must be parsed during the visit of
    the class. Any attribute whose type is not equal to the type of one the prototypes will not
    be parsed: its byte array value will be passed unchanged to the ClassWriter.
  • type – the type of the attribute.
  • offset – the start offset of the JVMS 'attribute' structure in classFileBuffer. The 6 attribute header bytes (attribute_name_index and attribute_length) are not taken into account here.
  • length – the length of the attribute's content (excluding the 6 attribute header bytes).
  • charBuffer – the buffer to be used to read strings in the constant pool.
  • codeAttributeOffset – the start offset of the enclosing Code attribute in classFileBuffer, or -1 if the attribute to be read is not a code attribute. The 6 attribute header bytes (attribute_name_index and attribute_length) are not taken into account here.
  • labels – the labels of the method's code, or null if the attribute to be read is not a code attribute.
Returns:the attribute that has been read.
/**
      * Reads a non standard JVMS 'attribute' structure in {@link #classFileBuffer}.
      *
      * @param attributePrototypes prototypes of the attributes that must be parsed during the visit of
      *     the class. Any attribute whose type is not equal to the type of one the prototypes will not
      *     be parsed: its byte array value will be passed unchanged to the ClassWriter.
      * @param type the type of the attribute.
      * @param offset the start offset of the JVMS 'attribute' structure in {@link #classFileBuffer}.
      *     The 6 attribute header bytes (attribute_name_index and attribute_length) are not taken into
      *     account here.
      * @param length the length of the attribute's content (excluding the 6 attribute header bytes).
      * @param charBuffer the buffer to be used to read strings in the constant pool.
      * @param codeAttributeOffset the start offset of the enclosing Code attribute in {@link
      *     #classFileBuffer}, or -1 if the attribute to be read is not a code attribute. The 6
      *     attribute header bytes (attribute_name_index and attribute_length) are not taken into
      *     account here.
      * @param labels the labels of the method's code, or {@literal null} if the attribute to be read
      *     is not a code attribute.
      * @return the attribute that has been read.
      */
    private Attribute readAttribute(
            final Attribute[] attributePrototypes,
            final String type,
            final int offset,
            final int length,
            final char[] charBuffer,
            final int codeAttributeOffset,
            final Label[] labels) {
        for (Attribute attributePrototype : attributePrototypes) {
            if (attributePrototype.type.equals(type)) {
                return attributePrototype.read(
                        this, offset, length, charBuffer, codeAttributeOffset, labels);
            }
        }
        return new Attribute(type).read(this, offset, length, null, -1, null);
    }

    // -----------------------------------------------------------------------------------------------
    // Utility methods: low level parsing
    // -----------------------------------------------------------------------------------------------

    
Returns the number of entries in the class's constant pool table.

Returns:the number of entries in the class's constant pool table.
/**
      * Returns the number of entries in the class's constant pool table.
      *
      * @return the number of entries in the class's constant pool table.
      */
    public int getItemCount() {
        return cpInfoOffsets.length;
    }

    
Returns the start offset in this ClassReader of a JVMS 'cp_info' structure (i.e. a constant pool entry), plus one. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • constantPoolEntryIndex – the index a constant pool entry in the class's constant pool
    table.
Returns:the start offset in this ClassReader of the corresponding JVMS 'cp_info' structure, plus one.
/**
      * Returns the start offset in this {@link ClassReader} of a JVMS 'cp_info' structure (i.e. a
      * constant pool entry), plus one. <i>This method is intended for {@link Attribute} sub classes,
      * and is normally not needed by class generators or adapters.</i>
      *
      * @param constantPoolEntryIndex the index a constant pool entry in the class's constant pool
      *     table.
      * @return the start offset in this {@link ClassReader} of the corresponding JVMS 'cp_info'
      *     structure, plus one.
      */
    public int getItem(final int constantPoolEntryIndex) {
        return cpInfoOffsets[constantPoolEntryIndex];
    }

    
Returns a conservative estimate of the maximum length of the strings contained in the class's
constant pool table.

Returns:a conservative estimate of the maximum length of the strings contained in the class's
    constant pool table.
/**
      * Returns a conservative estimate of the maximum length of the strings contained in the class's
      * constant pool table.
      *
      * @return a conservative estimate of the maximum length of the strings contained in the class's
      *     constant pool table.
      */
    public int getMaxStringLength() {
        return maxStringLength;
    }

    
Reads a byte value in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of the value to be read in this ClassReader.
Returns:the read value.
/**
      * Reads a byte value in this {@link ClassReader}. <i>This method is intended for {@link
      * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
      *
      * @param offset the start offset of the value to be read in this {@link ClassReader}.
      * @return the read value.
      */
    public int readByte(final int offset) {
        return classFileBuffer[offset] & 0xFF;
    }

    
Reads an unsigned short value in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start index of the value to be read in this ClassReader.
Returns:the read value.
/**
      * Reads an unsigned short value in this {@link ClassReader}. <i>This method is intended for
      * {@link Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
      *
      * @param offset the start index of the value to be read in this {@link ClassReader}.
      * @return the read value.
      */
    public int readUnsignedShort(final int offset) {
        byte[] classBuffer = classFileBuffer;
        return ((classBuffer[offset] & 0xFF) << 8) | (classBuffer[offset + 1] & 0xFF);
    }

    
Reads a signed short value in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of the value to be read in this ClassReader.
Returns:the read value.
/**
      * Reads a signed short value in this {@link ClassReader}. <i>This method is intended for {@link
      * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
      *
      * @param offset the start offset of the value to be read in this {@link ClassReader}.
      * @return the read value.
      */
    public short readShort(final int offset) {
        byte[] classBuffer = classFileBuffer;
        return (short) (((classBuffer[offset] & 0xFF) << 8) | (classBuffer[offset + 1] & 0xFF));
    }

    
Reads a signed int value in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of the value to be read in this ClassReader.
Returns:the read value.
/**
      * Reads a signed int value in this {@link ClassReader}. <i>This method is intended for {@link
      * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
      *
      * @param offset the start offset of the value to be read in this {@link ClassReader}.
      * @return the read value.
      */
    public int readInt(final int offset) {
        byte[] classBuffer = classFileBuffer;
        return ((classBuffer[offset] & 0xFF) << 24)
                | ((classBuffer[offset + 1] & 0xFF) << 16)
                | ((classBuffer[offset + 2] & 0xFF) << 8)
                | (classBuffer[offset + 3] & 0xFF);
    }

    
Reads a signed long value in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of the value to be read in this ClassReader.
Returns:the read value.
/**
      * Reads a signed long value in this {@link ClassReader}. <i>This method is intended for {@link
      * Attribute} sub classes, and is normally not needed by class generators or adapters.</i>
      *
      * @param offset the start offset of the value to be read in this {@link ClassReader}.
      * @return the read value.
      */
    public long readLong(final int offset) {
        long l1 = readInt(offset);
        long l0 = readInt(offset + 4) & 0xFFFFFFFFL;
        return (l1 << 32) | l0;
    }

    
Reads a CONSTANT_Utf8 constant pool entry in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of an unsigned short value in this ClassReader, whose value is the index of a CONSTANT_Utf8 entry in the class's constant pool table.
  • charBuffer – the buffer to be used to read the string. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified CONSTANT_Utf8 entry.
/**
      * Reads a CONSTANT_Utf8 constant pool entry in this {@link ClassReader}. <i>This method is
      * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
      * adapters.</i>
      *
      * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
      *     value is the index of a CONSTANT_Utf8 entry in the class's constant pool table.
      * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified CONSTANT_Utf8 entry.
      */
    // DontCheck(AbbreviationAsWordInName): can't be renamed (for backward binary compatibility).
    public String readUTF8(final int offset, final char[] charBuffer) {
        int constantPoolEntryIndex = readUnsignedShort(offset);
        if (offset == 0 || constantPoolEntryIndex == 0) {
            return null;
        }
        return readUtf(constantPoolEntryIndex, charBuffer);
    }

    
Reads a CONSTANT_Utf8 constant pool entry in classFileBuffer. 
Params:
  • constantPoolEntryIndex – the index of a CONSTANT_Utf8 entry in the class's constant pool
    table.
  • charBuffer – the buffer to be used to read the string. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified CONSTANT_Utf8 entry.
/**
      * Reads a CONSTANT_Utf8 constant pool entry in {@link #classFileBuffer}.
      *
      * @param constantPoolEntryIndex the index of a CONSTANT_Utf8 entry in the class's constant pool
      *     table.
      * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified CONSTANT_Utf8 entry.
      */
    final String readUtf(final int constantPoolEntryIndex, final char[] charBuffer) {
        String value = constantUtf8Values[constantPoolEntryIndex];
        if (value != null) {
            return value;
        }
        int cpInfoOffset = cpInfoOffsets[constantPoolEntryIndex];
        return constantUtf8Values[constantPoolEntryIndex] =
                readUtf(cpInfoOffset + 2, readUnsignedShort(cpInfoOffset), charBuffer);
    }

    
Reads an UTF8 string in classFileBuffer. 
Params:
  • utfOffset – the start offset of the UTF8 string to be read.
  • utfLength – the length of the UTF8 string to be read.
  • charBuffer – the buffer to be used to read the string. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified UTF8 string.
/**
      * Reads an UTF8 string in {@link #classFileBuffer}.
      *
      * @param utfOffset the start offset of the UTF8 string to be read.
      * @param utfLength the length of the UTF8 string to be read.
      * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified UTF8 string.
      */
    private String readUtf(final int utfOffset, final int utfLength, final char[] charBuffer) {
        int currentOffset = utfOffset;
        int endOffset = currentOffset + utfLength;
        int strLength = 0;
        byte[] classBuffer = classFileBuffer;
        while (currentOffset < endOffset) {
            int currentByte = classBuffer[currentOffset++];
            if ((currentByte & 0x80) == 0) {
                charBuffer[strLength++] = (char) (currentByte & 0x7F);
            } else if ((currentByte & 0xE0) == 0xC0) {
                charBuffer[strLength++] =
                        (char) (((currentByte & 0x1F) << 6) + (classBuffer[currentOffset++] & 0x3F));
            } else {
                charBuffer[strLength++] =
                        (char)
                                (((currentByte & 0xF) << 12)
                                        + ((classBuffer[currentOffset++] & 0x3F) << 6)
                                        + (classBuffer[currentOffset++] & 0x3F));
            }
        }
        return new String(charBuffer, 0, strLength);
    }

    
Reads a CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType, CONSTANT_Module or CONSTANT_Package constant pool entry in classFileBuffer. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of an unsigned short value in classFileBuffer, whose value is the index of a CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType, CONSTANT_Module or CONSTANT_Package entry in class's constant pool table.
  • charBuffer – the buffer to be used to read the item. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified constant pool entry.
/**
      * Reads a CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType, CONSTANT_Module or
      * CONSTANT_Package constant pool entry in {@link #classFileBuffer}. <i>This method is intended
      * for {@link Attribute} sub classes, and is normally not needed by class generators or
      * adapters.</i>
      *
      * @param offset the start offset of an unsigned short value in {@link #classFileBuffer}, whose
      *     value is the index of a CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType,
      *     CONSTANT_Module or CONSTANT_Package entry in class's constant pool table.
      * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified constant pool entry.
      */
    private String readStringish(final int offset, final char[] charBuffer) {
        // Get the start offset of the cp_info structure (plus one), and read the CONSTANT_Utf8 entry
        // designated by the first two bytes of this cp_info.
        return readUTF8(cpInfoOffsets[readUnsignedShort(offset)], charBuffer);
    }

    
Reads a CONSTANT_Class constant pool entry in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of an unsigned short value in this ClassReader, whose value is the index of a CONSTANT_Class entry in class's constant pool table.
  • charBuffer – the buffer to be used to read the item. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified CONSTANT_Class entry.
/**
      * Reads a CONSTANT_Class constant pool entry in this {@link ClassReader}. <i>This method is
      * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
      * adapters.</i>
      *
      * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
      *     value is the index of a CONSTANT_Class entry in class's constant pool table.
      * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified CONSTANT_Class entry.
      */
    public String readClass(final int offset, final char[] charBuffer) {
        return readStringish(offset, charBuffer);
    }

    
Reads a CONSTANT_Module constant pool entry in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of an unsigned short value in this ClassReader, whose value is the index of a CONSTANT_Module entry in class's constant pool table.
  • charBuffer – the buffer to be used to read the item. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified CONSTANT_Module entry.
/**
      * Reads a CONSTANT_Module constant pool entry in this {@link ClassReader}. <i>This method is
      * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
      * adapters.</i>
      *
      * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
      *     value is the index of a CONSTANT_Module entry in class's constant pool table.
      * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified CONSTANT_Module entry.
      */
    public String readModule(final int offset, final char[] charBuffer) {
        return readStringish(offset, charBuffer);
    }

    
Reads a CONSTANT_Package constant pool entry in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • offset – the start offset of an unsigned short value in this ClassReader, whose value is the index of a CONSTANT_Package entry in class's constant pool table.
  • charBuffer – the buffer to be used to read the item. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the String corresponding to the specified CONSTANT_Package entry.
/**
      * Reads a CONSTANT_Package constant pool entry in this {@link ClassReader}. <i>This method is
      * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
      * adapters.</i>
      *
      * @param offset the start offset of an unsigned short value in this {@link ClassReader}, whose
      *     value is the index of a CONSTANT_Package entry in class's constant pool table.
      * @param charBuffer the buffer to be used to read the item. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the String corresponding to the specified CONSTANT_Package entry.
      */
    public String readPackage(final int offset, final char[] charBuffer) {
        return readStringish(offset, charBuffer);
    }

    
Reads a CONSTANT_Dynamic constant pool entry in classFileBuffer. 
Params:
  • constantPoolEntryIndex – the index of a CONSTANT_Dynamic entry in the class's constant
    pool table.
  • charBuffer – the buffer to be used to read the string. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the ConstantDynamic corresponding to the specified CONSTANT_Dynamic entry.
/**
      * Reads a CONSTANT_Dynamic constant pool entry in {@link #classFileBuffer}.
      *
      * @param constantPoolEntryIndex the index of a CONSTANT_Dynamic entry in the class's constant
      *     pool table.
      * @param charBuffer the buffer to be used to read the string. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the ConstantDynamic corresponding to the specified CONSTANT_Dynamic entry.
      */
    private ConstantDynamic readConstantDynamic(
            final int constantPoolEntryIndex, final char[] charBuffer) {
        ConstantDynamic constantDynamic = constantDynamicValues[constantPoolEntryIndex];
        if (constantDynamic != null) {
            return constantDynamic;
        }
        int cpInfoOffset = cpInfoOffsets[constantPoolEntryIndex];
        int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 2)];
        String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
        String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
        int bootstrapMethodOffset = bootstrapMethodOffsets[readUnsignedShort(cpInfoOffset)];
        Handle handle = (Handle) readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
        Object[] bootstrapMethodArguments = new Object[readUnsignedShort(bootstrapMethodOffset + 2)];
        bootstrapMethodOffset += 4;
        for (int i = 0; i < bootstrapMethodArguments.length; i++) {
            bootstrapMethodArguments[i] = readConst(readUnsignedShort(bootstrapMethodOffset), charBuffer);
            bootstrapMethodOffset += 2;
        }
        return constantDynamicValues[constantPoolEntryIndex] =
                new ConstantDynamic(name, descriptor, handle, bootstrapMethodArguments);
    }

    
Reads a numeric or string constant pool entry in this ClassReader. This method is intended for Attribute sub classes, and is normally not needed by class generators or adapters.

Params:
  • constantPoolEntryIndex – the index of a CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long,
    CONSTANT_Double, CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType,
    CONSTANT_MethodHandle or CONSTANT_Dynamic entry in the class's constant pool.
  • charBuffer – the buffer to be used to read strings. This buffer must be sufficiently
    large. It is not automatically resized.
Returns:the Integer, Float, Long, Double, String, Type, Handle or ConstantDynamic corresponding to the specified constant pool entry.
/**
      * Reads a numeric or string constant pool entry in this {@link ClassReader}. <i>This method is
      * intended for {@link Attribute} sub classes, and is normally not needed by class generators or
      * adapters.</i>
      *
      * @param constantPoolEntryIndex the index of a CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long,
      *     CONSTANT_Double, CONSTANT_Class, CONSTANT_String, CONSTANT_MethodType,
      *     CONSTANT_MethodHandle or CONSTANT_Dynamic entry in the class's constant pool.
      * @param charBuffer the buffer to be used to read strings. This buffer must be sufficiently
      *     large. It is not automatically resized.
      * @return the {@link Integer}, {@link Float}, {@link Long}, {@link Double}, {@link String},
      *     {@link Type}, {@link Handle} or {@link ConstantDynamic} corresponding to the specified
      *     constant pool entry.
      */
    public Object readConst(final int constantPoolEntryIndex, final char[] charBuffer) {
        int cpInfoOffset = cpInfoOffsets[constantPoolEntryIndex];
        switch (classFileBuffer[cpInfoOffset - 1]) {
            case Symbol.CONSTANT_INTEGER_TAG:
                return readInt(cpInfoOffset);
            case Symbol.CONSTANT_FLOAT_TAG:
                return Float.intBitsToFloat(readInt(cpInfoOffset));
            case Symbol.CONSTANT_LONG_TAG:
                return readLong(cpInfoOffset);
            case Symbol.CONSTANT_DOUBLE_TAG:
                return Double.longBitsToDouble(readLong(cpInfoOffset));
            case Symbol.CONSTANT_CLASS_TAG:
                return Type.getObjectType(readUTF8(cpInfoOffset, charBuffer));
            case Symbol.CONSTANT_STRING_TAG:
                return readUTF8(cpInfoOffset, charBuffer);
            case Symbol.CONSTANT_METHOD_TYPE_TAG:
                return Type.getMethodType(readUTF8(cpInfoOffset, charBuffer));
            case Symbol.CONSTANT_METHOD_HANDLE_TAG:
                int referenceKind = readByte(cpInfoOffset);
                int referenceCpInfoOffset = cpInfoOffsets[readUnsignedShort(cpInfoOffset + 1)];
                int nameAndTypeCpInfoOffset = cpInfoOffsets[readUnsignedShort(referenceCpInfoOffset + 2)];
                String owner = readClass(referenceCpInfoOffset, charBuffer);
                String name = readUTF8(nameAndTypeCpInfoOffset, charBuffer);
                String descriptor = readUTF8(nameAndTypeCpInfoOffset + 2, charBuffer);
                boolean isInterface =
                        classFileBuffer[referenceCpInfoOffset - 1] == Symbol.CONSTANT_INTERFACE_METHODREF_TAG;
                return new Handle(referenceKind, owner, name, descriptor, isInterface);
            case Symbol.CONSTANT_DYNAMIC_TAG:
                return readConstantDynamic(constantPoolEntryIndex, charBuffer);
            default:
                throw new IllegalArgumentException();
        }
    }
}