/*

 * Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.

 * 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.

 */

package sun.invoke.anon;

/**

 * A visitor called by {@link ConstantPoolParser#parse(ConstantPoolVisitor)}

 * when a constant pool entry is parsed.

 * <p>

 * A visit* method is called when a constant pool entry is parsed.

 * The first argument is always the constant pool index.

 * The second argument is always the constant pool tag,

 * even for methods like {@link #visitUTF8(int, byte, String)} which only apply to one tag.

 * String arguments refer to Utf8 or NameAndType entries declared elsewhere,

 * and are always accompanied by the indexes of those entries.

 * <p>

 * The order of the calls to the visit* methods is not necessarily related

 * to the order of the entries in the constant pool.

 * If one entry has a reference to another entry, the latter (lower-level)

 * entry will be visited first.

 * <p>

 * The following table shows the relation between constant pool entry

 * types and the corresponding visit* methods:

 *

 * <table border=1 cellpadding=5 summary="constant pool visitor methods">

 * <tr><th>Tag(s)</th><th>Method</th></tr>

 * <tr>

 *   <td>{@link #CONSTANT_Utf8}</td>

 *   <td>{@link #visitUTF8(int, byte, String)}</td>

 * </tr><tr>

 *   <td>{@link #CONSTANT_Integer}, {@link #CONSTANT_Float},

 *       {@link #CONSTANT_Long}, {@link #CONSTANT_Double}</td>

 *   <td>{@link #visitConstantValue(int, byte, Object)}</td>

 * </tr><tr>

 *   <td>{@link #CONSTANT_String}, {@link #CONSTANT_Class}</td>

 *   <td>{@link #visitConstantString(int, byte, String, int)}</td>

 * </tr><tr>

 *   <td>{@link #CONSTANT_NameAndType}</td>

 *   <td>{@link #visitDescriptor(int, byte, String, String, int, int)}</td>

 * </tr><tr>

 *   <td>{@link #CONSTANT_Fieldref},

 *       {@link #CONSTANT_Methodref},

 *       {@link #CONSTANT_InterfaceMethodref}</td>

 *   <td>{@link #visitMemberRef(int, byte, String, String, String, int, int)}</td>

 * </tr>

 * </table>

 *

 * @see ConstantPoolPatch

 * @author Remi Forax

 * @author jrose

 */

public class ConstantPoolVisitor {

  /** Called each time an UTF8 constant pool entry is found.

   * @param index the constant pool index

   * @param tag always {@link #CONSTANT_Utf8}

   * @param utf8 string encoded in modified UTF-8 format passed as a {@code String}

   *

   * @see ConstantPoolPatch#putUTF8(int, String)

   */

  public void visitUTF8(int index, byte tag, String utf8) {

    // do nothing

  }

  /** Called for each constant pool entry that encodes an integer,

   *  a float, a long, or a double.

   *  Constant strings and classes are not managed by this method but

   *  by {@link #visitConstantString(int, byte, String, int)}.

   *

   * @param index the constant pool index

   * @param tag one of {@link #CONSTANT_Integer},

   *            {@link #CONSTANT_Float},

   *            {@link #CONSTANT_Long},

   *            or {@link #CONSTANT_Double}

   * @param value encoded value

   *

   * @see ConstantPoolPatch#putConstantValue(int, Object)

   */

  public void visitConstantValue(int index, byte tag, Object value) {

    // do nothing

  }

  /** Called for each constant pool entry that encodes a string or a class.

   * @param index the constant pool index

   * @param tag one of {@link #CONSTANT_String},

   *            {@link #CONSTANT_Class},

   * @param name string body or class name (using dot separator)

   * @param nameIndex the index of the Utf8 string for the name

   *

   * @see ConstantPoolPatch#putConstantValue(int, byte, Object)

   */

  public void visitConstantString(int index, byte tag,

                                  String name, int nameIndex) {

    // do nothing

  }

  /** Called for each constant pool entry that encodes a name and type.

   * @param index the constant pool index

   * @param tag always {@link #CONSTANT_NameAndType}

   * @param memberName a field or method name

   * @param signature the member signature

   * @param memberNameIndex index of the Utf8 string for the member name

   * @param signatureIndex index of the Utf8 string for the signature

   *

   * @see ConstantPoolPatch#putDescriptor(int, String, String)

   */

  public void visitDescriptor(int index, byte tag,

                              String memberName, String signature,

                              int memberNameIndex, int signatureIndex) {

    // do nothing

  }

  /** Called for each constant pool entry that encodes a field or method.

   * @param index the constant pool index

   * @param tag one of {@link #CONSTANT_Fieldref},

   *            or {@link #CONSTANT_Methodref},

   *            or {@link #CONSTANT_InterfaceMethodref}

   * @param className the class name (using dot separator)

   * @param memberName name of the field or method

   * @param signature the field or method signature

   * @param classNameIndex index of the Utf8 string for the class name

   * @param descriptorIndex index of the NameAndType descriptor constant

   *

   * @see ConstantPoolPatch#putMemberRef(int, byte, String, String, String)

   */

  public void visitMemberRef(int index, byte tag,

                             String className, String memberName, String signature,

                             int classNameIndex, int descriptorIndex) {

    // do nothing

  }

    public static final byte

      CONSTANT_None = 0,

      CONSTANT_Utf8 = 1,

      //CONSTANT_Unicode = 2,               /* unused */

      CONSTANT_Integer = 3,

      CONSTANT_Float = 4,

      CONSTANT_Long = 5,

      CONSTANT_Double = 6,

      CONSTANT_Class = 7,

      CONSTANT_String = 8,

      CONSTANT_Fieldref = 9,

      CONSTANT_Methodref = 10,

      CONSTANT_InterfaceMethodref = 11,

      CONSTANT_NameAndType = 12;

    private static String[] TAG_NAMES = {

        "Empty",

        "Utf8",

        null, //"Unicode",

        "Integer",

        "Float",

        "Long",

        "Double",

        "Class",

        "String",

        "Fieldref",

        "Methodref",

        "InterfaceMethodref",

        "NameAndType"

    };

    public static String tagName(byte tag) {

        String name = null;

        if ((tag & 0xFF) < TAG_NAMES.length)

            name = TAG_NAMES[tag];

        if (name == null)

            name = "Unknown#"+(tag&0xFF);

        return name;

    }

}