https://openjdk.java.net/ 
/*
 * 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 ConstantPoolParser.parse(ConstantPoolVisitor) when a constant pool entry is parsed. 
 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 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. 

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.


The following table shows the relation between constant pool entry
types and the corresponding visit* methods:



Tag(s)Method



  CONSTANT_Utf8
  visitUTF8(int, byte, String)


  CONSTANT_Integer, CONSTANT_Float, CONSTANT_Long, CONSTANT_Double
  visitConstantValue(int, byte, Object)


  CONSTANT_String, CONSTANT_Class
  visitConstantString(int, byte, String, int)


  CONSTANT_NameAndType
  visitDescriptor(int, byte, String, String, int, int)


  CONSTANT_Fieldref, CONSTANT_Methodref, CONSTANT_InterfaceMethodref
  visitMemberRef(int, byte, String, String, String, int, int)





Author:Remi Forax, jrose
See Also:
/**
 * 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.

Params:
  • index – the constant pool index
  • tag – always CONSTANT_Utf8
  • utf8 – string encoded in modified UTF-8 format passed as a String
See Also:
/** 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 visitConstantString(int, byte, String, int). 
Params:
See Also:
/** 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.

Params:
  • index – the constant pool index
  • tag – one of CONSTANT_String, CONSTANT_Class,
  • name – string body or class name (using dot separator)
  • nameIndex – the index of the Utf8 string for the name
See Also:
/** 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.

Params:
  • index – the constant pool index
  • tag – always CONSTANT_NameAndType
  • memberName – a field or method name
  • signature – the member signature
  • memberNameIndex – index of the Utf8 string for the member name
  • signatureIndex – index of the Utf8 string for the signature
See Also:
/** 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.

Params:
  • index – the constant pool index
  • tag – one of CONSTANT_Fieldref, or CONSTANT_Methodref, or CONSTANT_InterfaceMethodref
  • className – the class name (using dot separator)
  • memberName – name of the field or method
  • signature – the field or method signature
  • classNameIndex – index of the Utf8 string for the class name
  • descriptorIndex – index of the NameAndType descriptor constant
See Also:
/** 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;
    }
}