/*

 * 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-2007 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 com.sun.xml.internal.ws.org.objectweb.asm;

/**

 * A {@link ClassVisitor} that generates classes in bytecode form. More

 * precisely this visitor generates a byte array conforming to the Java class

 * file format. It can be used alone, to generate a Java class "from scratch",

 * or with one or more {@link ClassReader ClassReader} and adapter class visitor

 * to generate a modified class from one or more existing Java classes.

 *

 * @author Eric Bruneton

 */

public class ClassWriter implements ClassVisitor {

    /**

     * Flag to automatically compute the maximum stack size and the maximum

     * number of local variables of methods. If this flag is set, then the

     * arguments of the {@link MethodVisitor#visitMaxs visitMaxs} method of the

     * {@link MethodVisitor} returned by the {@link #visitMethod visitMethod}

     * method will be ignored, and computed automatically from the signature and

     * the bytecode of each method.

     *

     * @see #ClassWriter(int)

     */

    public static final int COMPUTE_MAXS = 1;

    /**

     * Flag to automatically compute the stack map frames of methods from

     * scratch. If this flag is set, then the calls to the

     * {@link MethodVisitor#visitFrame} method are ignored, and the stack map

     * frames are recomputed from the methods bytecode. The arguments of the

     * {@link MethodVisitor#visitMaxs visitMaxs} method are also ignored and

     * recomputed from the bytecode. In other words, computeFrames implies

     * computeMaxs.

     *

     * @see #ClassWriter(int)

     */

    public static final int COMPUTE_FRAMES = 2;

    /**

     * The type of instructions without any argument.

     */

    static final int NOARG_INSN = 0;

    /**

     * The type of instructions with an signed byte argument.

     */

    static final int SBYTE_INSN = 1;

    /**

     * The type of instructions with an signed short argument.

     */

    static final int SHORT_INSN = 2;

    /**

     * The type of instructions with a local variable index argument.

     */

    static final int VAR_INSN = 3;

    /**

     * The type of instructions with an implicit local variable index argument.

     */

    static final int IMPLVAR_INSN = 4;

    /**

     * The type of instructions with a type descriptor argument.

     */

    static final int TYPE_INSN = 5;

    /**

     * The type of field and method invocations instructions.

     */

    static final int FIELDORMETH_INSN = 6;

    /**

     * The type of the INVOKEINTERFACE instruction.

     */

    static final int ITFMETH_INSN = 7;

    /**

     * The type of instructions with a 2 bytes bytecode offset label.

     */

    static final int LABEL_INSN = 8;

    /**

     * The type of instructions with a 4 bytes bytecode offset label.

     */

    static final int LABELW_INSN = 9;

    /**

     * The type of the LDC instruction.

     */

    static final int LDC_INSN = 10;

    /**

     * The type of the LDC_W and LDC2_W instructions.

     */

    static final int LDCW_INSN = 11;

    /**

     * The type of the IINC instruction.

     */

    static final int IINC_INSN = 12;

    /**

     * The type of the TABLESWITCH instruction.

     */

    static final int TABL_INSN = 13;

    /**

     * The type of the LOOKUPSWITCH instruction.

     */

    static final int LOOK_INSN = 14;

    /**

     * The type of the MULTIANEWARRAY instruction.

     */

    static final int MANA_INSN = 15;

    /**

     * The type of the WIDE instruction.

     */

    static final int WIDE_INSN = 16;

    /**

     * The instruction types of all JVM opcodes.

     */

    static final byte[] TYPE;

    /**

     * The type of CONSTANT_Class constant pool items.

     */

    static final int CLASS = 7;

    /**

     * The type of CONSTANT_Fieldref constant pool items.

     */

    static final int FIELD = 9;

    /**

     * The type of CONSTANT_Methodref constant pool items.

     */

    static final int METH = 10;

    /**

     * The type of CONSTANT_InterfaceMethodref constant pool items.

     */

    static final int IMETH = 11;

    /**

     * The type of CONSTANT_String constant pool items.

     */

    static final int STR = 8;

    /**

     * The type of CONSTANT_Integer constant pool items.

     */

    static final int INT = 3;

    /**

     * The type of CONSTANT_Float constant pool items.

     */

    static final int FLOAT = 4;

    /**

     * The type of CONSTANT_Long constant pool items.

     */

    static final int LONG = 5;

    /**

     * The type of CONSTANT_Double constant pool items.

     */

    static final int DOUBLE = 6;

    /**

     * The type of CONSTANT_NameAndType constant pool items.

     */

    static final int NAME_TYPE = 12;

    /**

     * The type of CONSTANT_Utf8 constant pool items.

     */

    static final int UTF8 = 1;

    /**

     * Normal type Item stored in the ClassWriter {@link ClassWriter#typeTable},

     * instead of the constant pool, in order to avoid clashes with normal

     * constant pool items in the ClassWriter constant pool's hash table.

     */

    static final int TYPE_NORMAL = 13;

    /**

     * Uninitialized type Item stored in the ClassWriter

     * {@link ClassWriter#typeTable}, instead of the constant pool, in order to

     * avoid clashes with normal constant pool items in the ClassWriter constant

     * pool's hash table.

     */

    static final int TYPE_UNINIT = 14;

    /**

     * Merged type Item stored in the ClassWriter {@link ClassWriter#typeTable},

     * instead of the constant pool, in order to avoid clashes with normal

     * constant pool items in the ClassWriter constant pool's hash table.

     */

    static final int TYPE_MERGED = 15;

    /**

     * The class reader from which this class writer was constructed, if any.

     */

    ClassReader cr;

    /**

     * Minor and major version numbers of the class to be generated.

     */

    int version;

    /**

     * Index of the next item to be added in the constant pool.

     */

    int index;

    /**

     * The constant pool of this class.

     */

    final ByteVector pool;

    /**

     * The constant pool's hash table data.

     */

    Item[] items;

    /**

     * The threshold of the constant pool's hash table.

     */

    int threshold;

    /**

     * A reusable key used to look for items in the {@link #items} hash table.

     */

    final Item key;

    /**

     * A reusable key used to look for items in the {@link #items} hash table.

     */

    final Item key2;

    /**

     * A reusable key used to look for items in the {@link #items} hash table.

     */

    final Item key3;

    /**

     * A type table used to temporarily store internal names that will not

     * necessarily be stored in the constant pool. This type table is used by

     * the control flow and data flow analysis algorithm used to compute stack

     * map frames from scratch. This array associates to each index <tt>i</tt>

     * the Item whose index is <tt>i</tt>. All Item objects stored in this

     * array are also stored in the {@link #items} hash table. These two arrays

     * allow to retrieve an Item from its index or, conversely, to get the index

     * of an Item from its value. Each Item stores an internal name in its

     * {@link Item#strVal1} field.

     */

    Item[] typeTable;

    /**

     * Number of elements in the {@link #typeTable} array.

     */

    private short typeCount;

    /**

     * The access flags of this class.

     */

    private int access;

    /**

     * The constant pool item that contains the internal name of this class.

     */

    private int name;

    /**

     * The internal name of this class.

     */

    String thisName;

    /**

     * The constant pool item that contains the signature of this class.

     */

    private int signature;

    /**

     * The constant pool item that contains the internal name of the super class

     * of this class.

     */

    private int superName;

    /**

     * Number of interfaces implemented or extended by this class or interface.

     */

    private int interfaceCount;

    /**

     * The interfaces implemented or extended by this class or interface. More

     * precisely, this array contains the indexes of the constant pool items

     * that contain the internal names of these interfaces.

     */

    private int[] interfaces;

    /**

     * The index of the constant pool item that contains the name of the source

     * file from which this class was compiled.

     */

    private int sourceFile;

    /**

     * The SourceDebug attribute of this class.

     */

    private ByteVector sourceDebug;

    /**

     * The constant pool item that contains the name of the enclosing class of

     * this class.

     */

    private int enclosingMethodOwner;

    /**

     * The constant pool item that contains the name and descriptor of the

     * enclosing method of this class.

     */

    private int enclosingMethod;

    /**

     * The runtime visible annotations of this class.

     */

    private AnnotationWriter anns;

    /**

     * The runtime invisible annotations of this class.

     */

    private AnnotationWriter ianns;

    /**

     * The non standard attributes of this class.

     */

    private Attribute attrs;

    /**

     * The number of entries in the InnerClasses attribute.

     */

    private int innerClassesCount;

    /**

     * The InnerClasses attribute.

     */

    private ByteVector innerClasses;

    /**

     * The fields of this class. These fields are stored in a linked list of

     * {@link FieldWriter} objects, linked to each other by their

     * {@link FieldWriter#next} field. This field stores the first element of

     * this list.

     */

    FieldWriter firstField;

    /**

     * The fields of this class. These fields are stored in a linked list of

     * {@link FieldWriter} objects, linked to each other by their

     * {@link FieldWriter#next} field. This field stores the last element of

     * this list.

     */

    FieldWriter lastField;

    /**

     * The methods of this class. These methods are stored in a linked list of

     * {@link MethodWriter} objects, linked to each other by their

     * {@link MethodWriter#next} field. This field stores the first element of

     * this list.

     */

    MethodWriter firstMethod;

    /**

     * The methods of this class. These methods are stored in a linked list of

     * {@link MethodWriter} objects, linked to each other by their

     * {@link MethodWriter#next} field. This field stores the last element of

     * this list.

     */

    MethodWriter lastMethod;

    /**

     * <tt>true</tt> if the maximum stack size and number of local variables

     * must be automatically computed.

     */

    private final boolean computeMaxs;

    /**

     * <tt>true</tt> if the stack map frames must be recomputed from scratch.

     */

    private final boolean computeFrames;

    /**

     * <tt>true</tt> if the stack map tables of this class are invalid. The

     * {@link MethodWriter#resizeInstructions} method cannot transform existing

     * stack map tables, and so produces potentially invalid classes when it is

     * executed. In this case the class is reread and rewritten with the

     * {@link #COMPUTE_FRAMES} option (the resizeInstructions method can resize

     * stack map tables when this option is used).

     */

    boolean invalidFrames;

    // ------------------------------------------------------------------------

    // Static initializer

    // ------------------------------------------------------------------------

    /**

     * Computes the instruction types of JVM opcodes.

     */

    static {

        int i;

        byte[] b = new byte[220];

        String s = "AAAAAAAAAAAAAAAABCKLLDDDDDEEEEEEEEEEEEEEEEEEEEAAAAAAAADD"

                + "DDDEEEEEEEEEEEEEEEEEEEEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"

                + "AAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAIIIIIIIIIIIIIIIIDNOAA"

                + "AAAAGGGGGGGHAFBFAAFFAAQPIIJJIIIIIIIIIIIIIIIIII";

        for (i = 0; i < b.length; ++i) {

            b[i] = (byte) (s.charAt(i) - 'A');

        }

        TYPE = b;

        // code to generate the above string

        //

        // // SBYTE_INSN instructions

        // b[Constants.NEWARRAY] = SBYTE_INSN;

        // b[Constants.BIPUSH] = SBYTE_INSN;

        //

        // // SHORT_INSN instructions

        // b[Constants.SIPUSH] = SHORT_INSN;

        //

        // // (IMPL)VAR_INSN instructions

        // b[Constants.RET] = VAR_INSN;

        // for (i = Constants.ILOAD; i <= Constants.ALOAD; ++i) {

        // b[i] = VAR_INSN;

        // }

        // for (i = Constants.ISTORE; i <= Constants.ASTORE; ++i) {

        // b[i] = VAR_INSN;

        // }

        // for (i = 26; i <= 45; ++i) { // ILOAD_0 to ALOAD_3

        // b[i] = IMPLVAR_INSN;

        // }

        // for (i = 59; i <= 78; ++i) { // ISTORE_0 to ASTORE_3

        // b[i] = IMPLVAR_INSN;

        // }

        //

        // // TYPE_INSN instructions

        // b[Constants.NEW] = TYPE_INSN;

        // b[Constants.ANEWARRAY] = TYPE_INSN;

        // b[Constants.CHECKCAST] = TYPE_INSN;

        // b[Constants.INSTANCEOF] = TYPE_INSN;

        //

        // // (Set)FIELDORMETH_INSN instructions

        // for (i = Constants.GETSTATIC; i <= Constants.INVOKESTATIC; ++i) {

        // b[i] = FIELDORMETH_INSN;

        // }

        // b[Constants.INVOKEINTERFACE] = ITFMETH_INSN;

        //

        // // LABEL(W)_INSN instructions

        // for (i = Constants.IFEQ; i <= Constants.JSR; ++i) {

        // b[i] = LABEL_INSN;

        // }

        // b[Constants.IFNULL] = LABEL_INSN;

        // b[Constants.IFNONNULL] = LABEL_INSN;

        // b[200] = LABELW_INSN; // GOTO_W

        // b[201] = LABELW_INSN; // JSR_W