1 /*

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

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package com.sun.tools.classfile;

    27 

    28 import java.io.DataOutputStream;

    29 import java.io.IOException;

    30 import java.io.OutputStream;

    31 import java.util.Iterator;

    32 

    33 /**

    34  * See JVMS, section 4.5.

    35  *

    36  *  <p><b>This is NOT part of any supported API.

    37  *  If you write code that depends on this, you do so at your own risk.

    38  *  This code and its internal interfaces are subject to change or

    39  *  deletion without notice.</b>

    40  */

    41 public class ConstantPool {

    42 

    43     public static class InvalidIndex extends ConstantPoolException {

    44         private static final long serialVersionUID = -4350294289300939730L;

    45         InvalidIndex(int index) {

    46             super(index);

    47         }

    48 

    49         @Override

    50         public String getMessage() {

    51             // i18n

    52             return "invalid index #" + index;

    53         }

    54     }

    55 

    56     public static class UnexpectedEntry extends ConstantPoolException {

    57         private static final long serialVersionUID = 6986335935377933211L;

    58         UnexpectedEntry(int index, int expected_tag, int found_tag) {

    59             super(index);

    60             this.expected_tag = expected_tag;

    61             this.found_tag = found_tag;

    62         }

    63 

    64         @Override

    65         public String getMessage() {

    66             // i18n?

    67             return "unexpected entry at #" + index + " -- expected tag " + expected_tag + ", found " + found_tag;

    68         }

    69 

    70         public final int expected_tag;

    71         public final int found_tag;

    72     }

    73 

    74     public static class InvalidEntry extends ConstantPoolException {

    75         private static final long serialVersionUID = 1000087545585204447L;

    76         InvalidEntry(int index, int tag) {

    77             super(index);

    78             this.tag = tag;

    79         }

    80 

    81         @Override

    82         public String getMessage() {

    83             // i18n?

    84             return "unexpected tag at #" + index + ": " + tag;

    85         }

    86 

    87         public final int tag;

    88     }

    89 

    90     public static class EntryNotFound extends ConstantPoolException {

    91         private static final long serialVersionUID = 2885537606468581850L;

    92         EntryNotFound(Object value) {

    93             super(-1);

    94             this.value = value;

    95         }

    96 

    97         @Override

    98         public String getMessage() {

    99             // i18n?

   100             return "value not found: " + value;

   101         }

   102 

   103         public final Object value;

   104     }

   105 

   106     public static final int CONSTANT_Utf8 = 1;

   107     public static final int CONSTANT_Integer = 3;

   108     public static final int CONSTANT_Float = 4;

   109     public static final int CONSTANT_Long = 5;

   110     public static final int CONSTANT_Double = 6;

   111     public static final int CONSTANT_Class = 7;

   112     public static final int CONSTANT_String = 8;

   113     public static final int CONSTANT_Fieldref = 9;

   114     public static final int CONSTANT_Methodref = 10;

   115     public static final int CONSTANT_InterfaceMethodref = 11;

   116     public static final int CONSTANT_NameAndType = 12;

   117     public static final int CONSTANT_MethodHandle = 15;

   118     public static final int CONSTANT_MethodType = 16;

   119     public static final int CONSTANT_InvokeDynamic = 18;

   120 

   121     public static enum RefKind {

   122         REF_getField(1, "getfield"),

   123         REF_getStatic(2, "getstatic"),

   124         REF_putField(3, "putfield"),

   125         REF_putStatic(4, "putstatic"),

   126         REF_invokeVirtual(5, "invokevirtual"),

   127         REF_invokeStatic(6, "invokestatic"),

   128         REF_invokeSpecial(7, "invokespecial"),

   129         REF_newInvokeSpecial(8, "newinvokespecial"),

   130         REF_invokeInterface(9, "invokeinterface");

   131 

   132         public final int tag;

   133         public final String name;

   134 

   135         RefKind(int tag, String name) {

   136             this.tag = tag;

   137             this.name = name;

   138         }

   139 

   140         static RefKind getRefkind(int tag) {

   141             switch(tag) {

   142                 case 1:

   143                     return REF_getField;

   144                 case 2:

   145                     return REF_getStatic;

   146                 case 3:

   147                     return REF_putField;

   148                 case 4:

   149                     return REF_putStatic;

   150                 case 5:

   151                     return REF_invokeVirtual;

   152                 case 6:

   153                     return REF_invokeStatic;

   154                 case 7:

   155                     return REF_invokeSpecial;

   156                 case 8:

   157                     return REF_newInvokeSpecial;

   158                 case 9:

   159                     return REF_invokeInterface;

   160                 default:

   161                     return null;

   162             }

   163         }

   164     }

   165 

   166     ConstantPool(ClassReader cr) throws IOException, InvalidEntry {

   167         int count = cr.readUnsignedShort();

   168         pool = new CPInfo[count];

   169         for (int i = 1; i < count; i++) {

   170             int tag = cr.readUnsignedByte();

   171             switch (tag) {

   172             case CONSTANT_Class:

   173                 pool[i] = new CONSTANT_Class_info(this, cr);

   174                 break;

   175 

   176             case CONSTANT_Double:

   177                 pool[i] = new CONSTANT_Double_info(cr);

   178                 i++;

   179                 break;

   180 

   181             case CONSTANT_Fieldref:

   182                 pool[i] = new CONSTANT_Fieldref_info(this, cr);

   183                 break;

   184 

   185             case CONSTANT_Float:

   186                 pool[i] = new CONSTANT_Float_info(cr);

   187                 break;

   188 

   189             case CONSTANT_Integer:

   190                 pool[i] = new CONSTANT_Integer_info(cr);

   191                 break;

   192 

   193             case CONSTANT_InterfaceMethodref:

   194                 pool[i] = new CONSTANT_InterfaceMethodref_info(this, cr);

   195                 break;

   196 

   197             case CONSTANT_InvokeDynamic:

   198                 pool[i] = new CONSTANT_InvokeDynamic_info(this, cr);

   199                 break;

   200 

   201             case CONSTANT_Long:

   202                 pool[i] = new CONSTANT_Long_info(cr);

   203                 i++;

   204                 break;

   205 

   206             case CONSTANT_MethodHandle:

   207                 pool[i] = new CONSTANT_MethodHandle_info(this, cr);

   208                 break;

   209 

   210             case CONSTANT_MethodType:

   211                 pool[i] = new CONSTANT_MethodType_info(this, cr);

   212                 break;

   213 

   214             case CONSTANT_Methodref:

   215                 pool[i] = new CONSTANT_Methodref_info(this, cr);

   216                 break;

   217 

   218             case CONSTANT_NameAndType:

   219                 pool[i] = new CONSTANT_NameAndType_info(this, cr);

   220                 break;

   221 

   222             case CONSTANT_String:

   223                 pool[i] = new CONSTANT_String_info(this, cr);

   224                 break;

   225 

   226             case CONSTANT_Utf8:

   227                 pool[i] = new CONSTANT_Utf8_info(cr);

   228                 break;

   229 

   230             default:

   231                 throw new InvalidEntry(i, tag);

   232             }

   233         }

   234     }

   235 

   236     public ConstantPool(CPInfo[] pool) {

   237         this.pool = pool;

   238     }

   239 

   240     public int size() {

   241         return pool.length;

   242     }

   243 

   244     public int byteLength() {

   245         int length = 2;

   246         for (int i = 1; i < size(); ) {

   247             CPInfo cpInfo = pool[i];

   248             length += cpInfo.byteLength();

   249             i += cpInfo.size();

   250         }

   251         return length;

   252     }

   253 

   254     public CPInfo get(int index) throws InvalidIndex {

   255         if (index <= 0 || index >= pool.length)

   256             throw new InvalidIndex(index);

   257         CPInfo info = pool[index];

   258         if (info == null) {

   259             // this occurs for indices referencing the "second half" of an

   260             // 8 byte constant, such as CONSTANT_Double or CONSTANT_Long

   261             throw new InvalidIndex(index);

   262         }

   263         return pool[index];

   264     }

   265 

   266     private CPInfo get(int index, int expected_type) throws InvalidIndex, UnexpectedEntry {

   267         CPInfo info = get(index);

   268         if (info.getTag() != expected_type)

   269             throw new UnexpectedEntry(index, expected_type, info.getTag());

   270         return info;

   271     }

   272 

   273     public CONSTANT_Utf8_info getUTF8Info(int index) throws InvalidIndex, UnexpectedEntry {

   274         return ((CONSTANT_Utf8_info) get(index, CONSTANT_Utf8));

   275     }

   276 

   277     public CONSTANT_Class_info getClassInfo(int index) throws InvalidIndex, UnexpectedEntry {

   278         return ((CONSTANT_Class_info) get(index, CONSTANT_Class));

   279     }

   280 

   281     public CONSTANT_NameAndType_info getNameAndTypeInfo(int index) throws InvalidIndex, UnexpectedEntry {

   282         return ((CONSTANT_NameAndType_info) get(index, CONSTANT_NameAndType));

   283     }

   284 

   285     public String getUTF8Value(int index) throws InvalidIndex, UnexpectedEntry {

   286         return getUTF8Info(index).value;

   287     }

   288 

   289     public int getUTF8Index(String value) throws EntryNotFound {

   290         for (int i = 1; i < pool.length; i++) {

   291             CPInfo info = pool[i];

   292             if (info instanceof CONSTANT_Utf8_info &&

   293                     ((CONSTANT_Utf8_info) info).value.equals(value))

   294                 return i;

   295         }

   296         throw new EntryNotFound(value);

   297     }

   298 

   299     public Iterable<CPInfo> entries() {

   300         return new Iterable<CPInfo>() {

   301             public Iterator<CPInfo> iterator() {

   302                 return new Iterator<CPInfo>() {

   303 

   304                     public boolean hasNext() {

   305                         return next < pool.length;

   306                     }

   307 

   308                     public CPInfo next() {

   309                         current = pool[next];

   310                         switch (current.getTag()) {

   311                             case CONSTANT_Double:

   312                             case CONSTANT_Long:

   313                                 next += 2;

   314                                 break;

   315                             default:

   316                                 next += 1;

   317                         }

   318                         return current;

   319                     }

   320 

   321                     public void remove() {

   322                         throw new UnsupportedOperationException();

   323                     }

   324 

   325                     private CPInfo current;

   326                     private int next = 1;

   327 

   328                 };

   329             }

   330         };

   331     }

   332 

   333     private CPInfo[] pool;

   334 

   335     public interface Visitor<R,P> {

   336         R visitClass(CONSTANT_Class_info info, P p);

   337         R visitDouble(CONSTANT_Double_info info, P p);

   338         R visitFieldref(CONSTANT_Fieldref_info info, P p);

   339         R visitFloat(CONSTANT_Float_info info, P p);

   340         R visitInteger(CONSTANT_Integer_info info, P p);

   341         R visitInterfaceMethodref(CONSTANT_InterfaceMethodref_info info, P p);

   342         R visitInvokeDynamic(CONSTANT_InvokeDynamic_info info, P p);

   343         R visitLong(CONSTANT_Long_info info, P p);

   344         R visitNameAndType(CONSTANT_NameAndType_info info, P p);

   345         R visitMethodref(CONSTANT_Methodref_info info, P p);

   346         R visitMethodHandle(CONSTANT_MethodHandle_info info, P p);

   347         R visitMethodType(CONSTANT_MethodType_info info, P p);

   348         R visitString(CONSTANT_String_info info, P p);

   349         R visitUtf8(CONSTANT_Utf8_info info, P p);

   350     }

   351 

   352     public static abstract class CPInfo {

   353         CPInfo() {

   354             this.cp = null;

   355         }

   356 

   357         CPInfo(ConstantPool cp) {

   358             this.cp = cp;

   359         }

   360 

   361         public abstract int getTag();

   362 

   363         /** The number of slots in the constant pool used by this entry.

   364          * 2 for CONSTANT_Double and CONSTANT_Long; 1 for everything else. */

   365         public int size() {

   366             return 1;

   367         }

   368 

   369         public abstract int byteLength();

   370 

   371         public abstract <R,D> R accept(Visitor<R,D> visitor, D data);

   372 

   373         protected final ConstantPool cp;

   374     }

   375 

   376     public static abstract class CPRefInfo extends CPInfo {

   377         protected CPRefInfo(ConstantPool cp, ClassReader cr, int tag) throws IOException {

   378             super(cp);

   379             this.tag = tag;

   380             class_index = cr.readUnsignedShort();

   381             name_and_type_index = cr.readUnsignedShort();

   382         }

   383 

   384         protected CPRefInfo(ConstantPool cp, int tag, int class_index, int name_and_type_index) {

   385             super(cp);

   386             this.tag = tag;

   387             this.class_index = class_index;

   388             this.name_and_type_index = name_and_type_index;

   389         }

   390 

   391         public int getTag() {

   392             return tag;

   393         }

   394 

   395         public int byteLength() {

   396             return 5;

   397         }

   398 

   399         public CONSTANT_Class_info getClassInfo() throws ConstantPoolException {

   400             return cp.getClassInfo(class_index);

   401         }

   402 

   403         public String getClassName() throws ConstantPoolException {

   404             return cp.getClassInfo(class_index).getName();

   405         }

   406 

   407         public CONSTANT_NameAndType_info getNameAndTypeInfo() throws ConstantPoolException {

   408             return cp.getNameAndTypeInfo(name_and_type_index);

   409         }

   410 

   411         public final int tag;

   412         public final int class_index;

   413         public final int name_and_type_index;

   414     }

   415 

   416     public static class CONSTANT_Class_info extends CPInfo {

   417         CONSTANT_Class_info(ConstantPool cp, ClassReader cr) throws IOException {

   418             super(cp);

   419             name_index = cr.readUnsignedShort();

   420         }

   421 

   422         public CONSTANT_Class_info(ConstantPool cp, int name_index) {

   423             super(cp);

   424             this.name_index = name_index;

   425         }

   426 

   427         public int getTag() {

   428             return CONSTANT_Class;

   429         }

   430 

   431         public int  byteLength() {

   432             return 3;

   433         }

   434 

   435         /**

   436          * Get the raw value of the class referenced by this constant pool entry.

   437          * This will either be the name of the class, in internal form, or a

   438          * descriptor for an array class.

   439          * @return the raw value of the class

   440          */

   441         public String getName() throws ConstantPoolException {

   442             return cp.getUTF8Value(name_index);

   443         }

   444 

   445         /**

   446          * If this constant pool entry identifies either a class or interface type,

   447          * or a possibly multi-dimensional array of a class of interface type,

   448          * return the name of the class or interface in internal form. Otherwise,

   449          * (i.e. if this is a possibly multi-dimensional array of a primitive type),

   450          * return null.

   451          * @return the base class or interface name

   452          */

   453         public String getBaseName() throws ConstantPoolException {

   454             String name = getName();

   455             if (name.startsWith("[")) {

   456                 int index = name.indexOf("[L");

   457                 if (index == -1)

   458                     return null;

   459                 return name.substring(index + 2, name.length() - 1);

   460             } else

   461                 return name;

   462         }

   463 

   464         public int getDimensionCount() throws ConstantPoolException {

   465             String name = getName();

   466             int count = 0;

   467             while (name.charAt(count) == '[')

   468                 count++;

   469             return count;

   470         }

   471 

   472         @Override

   473         public String toString() {

   474             return "CONSTANT_Class_info[name_index: " + name_index + "]";

   475         }

   476 

   477         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   478             return visitor.visitClass(this, data);

   479         }

   480 

   481         public final int name_index;

   482     }

   483 

   484     public static class CONSTANT_Double_info extends CPInfo {

   485         CONSTANT_Double_info(ClassReader cr) throws IOException {

   486             value = cr.readDouble();

   487         }

   488 

   489         public CONSTANT_Double_info(double value) {

   490             this.value = value;

   491         }

   492 

   493         public int getTag() {

   494             return CONSTANT_Double;

   495         }

   496 

   497         public int  byteLength() {

   498             return 9;

   499         }

   500 

   501         @Override

   502         public int size() {

   503             return 2;

   504         }

   505 

   506         @Override

   507         public String toString() {

   508             return "CONSTANT_Double_info[value: " + value + "]";

   509         }

   510 

   511         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   512             return visitor.visitDouble(this, data);

   513         }

   514 

   515         public final double value;

   516     }

   517 

   518     public static class CONSTANT_Fieldref_info extends CPRefInfo {

   519         CONSTANT_Fieldref_info(ConstantPool cp, ClassReader cr) throws IOException {

   520             super(cp, cr, CONSTANT_Fieldref);

   521         }

   522 

   523         public CONSTANT_Fieldref_info(ConstantPool cp, int class_index, int name_and_type_index) {

   524             super(cp, CONSTANT_Fieldref, class_index, name_and_type_index);

   525         }

   526 

   527         @Override

   528         public String toString() {

   529             return "CONSTANT_Fieldref_info[class_index: " + class_index + ", name_and_type_index: " + name_and_type_index + "]";

   530         }

   531 

   532         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   533             return visitor.visitFieldref(this, data);

   534         }

   535     }

   536 

   537     public static class CONSTANT_Float_info extends CPInfo {

   538         CONSTANT_Float_info(ClassReader cr) throws IOException {

   539             value = cr.readFloat();

   540         }

   541 

   542         public CONSTANT_Float_info(float value) {

   543             this.value = value;

   544         }

   545 

   546         public int getTag() {

   547             return CONSTANT_Float;

   548         }

   549 

   550         public int byteLength() {

   551             return 5;

   552         }

   553 

   554         @Override

   555         public String toString() {

   556             return "CONSTANT_Float_info[value: " + value + "]";

   557         }

   558 

   559         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   560             return visitor.visitFloat(this, data);

   561         }

   562 

   563         public final float value;

   564     }

   565 

   566     public static class CONSTANT_Integer_info extends CPInfo {

   567         CONSTANT_Integer_info(ClassReader cr) throws IOException {

   568             value = cr.readInt();

   569         }

   570 

   571         public CONSTANT_Integer_info(int value) {

   572             this.value = value;

   573         }

   574 

   575         public int getTag() {

   576             return CONSTANT_Integer;

   577         }

   578 

   579         public int byteLength() {

   580             return 5;

   581         }

   582 

   583         @Override

   584         public String toString() {

   585             return "CONSTANT_Integer_info[value: " + value + "]";

   586         }

   587 

   588         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   589             return visitor.visitInteger(this, data);

   590         }

   591 

   592         public final int value;

   593     }

   594 

   595     public static class CONSTANT_InterfaceMethodref_info extends CPRefInfo {

   596         CONSTANT_InterfaceMethodref_info(ConstantPool cp, ClassReader cr) throws IOException {

   597             super(cp, cr, CONSTANT_InterfaceMethodref);

   598         }

   599 

   600         public CONSTANT_InterfaceMethodref_info(ConstantPool cp, int class_index, int name_and_type_index) {

   601             super(cp, CONSTANT_InterfaceMethodref, class_index, name_and_type_index);

   602         }

   603 

   604         @Override

   605         public String toString() {

   606             return "CONSTANT_InterfaceMethodref_info[class_index: " + class_index + ", name_and_type_index: " + name_and_type_index + "]";

   607         }

   608 

   609         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   610             return visitor.visitInterfaceMethodref(this, data);

   611         }

   612     }

   613 

   614     public static class CONSTANT_InvokeDynamic_info extends CPInfo {

   615         CONSTANT_InvokeDynamic_info(ConstantPool cp, ClassReader cr) throws IOException {

   616             super(cp);

   617             bootstrap_method_attr_index = cr.readUnsignedShort();

   618             name_and_type_index = cr.readUnsignedShort();

   619         }

   620 

   621         public CONSTANT_InvokeDynamic_info(ConstantPool cp, int bootstrap_method_index, int name_and_type_index) {

   622             super(cp);

   623             this.bootstrap_method_attr_index = bootstrap_method_index;

   624             this.name_and_type_index = name_and_type_index;

   625         }

   626 

   627         public int getTag() {

   628             return CONSTANT_InvokeDynamic;

   629         }

   630 

   631         public int byteLength() {

   632             return 5;

   633         }

   634 

   635         @Override

   636         public String toString() {

   637             return "CONSTANT_InvokeDynamic_info[bootstrap_method_index: " + bootstrap_method_attr_index + ", name_and_type_index: " + name_and_type_index + "]";

   638         }

   639 

   640         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   641             return visitor.visitInvokeDynamic(this, data);

   642         }

   643 

   644         public CONSTANT_NameAndType_info getNameAndTypeInfo() throws ConstantPoolException {

   645             return cp.getNameAndTypeInfo(name_and_type_index);

   646         }

   647 

   648         public final int bootstrap_method_attr_index;

   649         public final int name_and_type_index;

   650     }

   651 

   652     public static class CONSTANT_Long_info extends CPInfo {

   653         CONSTANT_Long_info(ClassReader cr) throws IOException {

   654             value = cr.readLong();

   655         }

   656 

   657         public CONSTANT_Long_info(long value) {

   658             this.value = value;

   659         }

   660 

   661         public int getTag() {

   662             return CONSTANT_Long;

   663         }

   664 

   665         @Override

   666         public int size() {

   667             return 2;

   668         }

   669 

   670         public int byteLength() {

   671             return 9;

   672         }

   673 

   674         @Override

   675         public String toString() {

   676             return "CONSTANT_Long_info[value: " + value + "]";

   677         }

   678 

   679         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   680             return visitor.visitLong(this, data);

   681         }

   682 

   683         public final long value;

   684     }

   685 

   686     public static class CONSTANT_MethodHandle_info extends CPInfo {

   687         CONSTANT_MethodHandle_info(ConstantPool cp, ClassReader cr) throws IOException {

   688             super(cp);

   689             reference_kind =  RefKind.getRefkind(cr.readUnsignedByte());

   690             reference_index = cr.readUnsignedShort();

   691         }

   692 

   693         public CONSTANT_MethodHandle_info(ConstantPool cp, RefKind ref_kind, int member_index) {

   694             super(cp);

   695             this.reference_kind = ref_kind;

   696             this.reference_index = member_index;

   697         }

   698 

   699         public int getTag() {

   700             return CONSTANT_MethodHandle;

   701         }

   702 

   703         public int byteLength() {

   704             return 4;

   705         }

   706 

   707         @Override

   708         public String toString() {

   709             return "CONSTANT_MethodHandle_info[ref_kind: " + reference_kind + ", member_index: " + reference_index + "]";

   710         }

   711 

   712         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   713             return visitor.visitMethodHandle(this, data);

   714         }

   715 

   716         public CPRefInfo getCPRefInfo() throws ConstantPoolException {

   717             int expected = CONSTANT_Methodref;

   718             int actual = cp.get(reference_index).getTag();

   719             // allow these tag types also:

   720             switch (actual) {

   721                 case CONSTANT_Fieldref:

   722                 case CONSTANT_InterfaceMethodref:

   723                     expected = actual;

   724             }

   725             return (CPRefInfo) cp.get(reference_index, expected);

   726         }

   727 

   728         public final RefKind reference_kind;

   729         public final int reference_index;

   730     }

   731 

   732     public static class CONSTANT_MethodType_info extends CPInfo {

   733         CONSTANT_MethodType_info(ConstantPool cp, ClassReader cr) throws IOException {

   734             super(cp);

   735             descriptor_index = cr.readUnsignedShort();

   736         }

   737 

   738         public CONSTANT_MethodType_info(ConstantPool cp, int signature_index) {

   739             super(cp);

   740             this.descriptor_index = signature_index;

   741         }

   742 

   743         public int getTag() {

   744             return CONSTANT_MethodType;

   745         }

   746 

   747         public int byteLength() {

   748             return 3;

   749         }

   750 

   751         @Override

   752         public String toString() {

   753             return "CONSTANT_MethodType_info[signature_index: " + descriptor_index + "]";

   754         }

   755 

   756         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   757             return visitor.visitMethodType(this, data);

   758         }

   759 

   760         public String getType() throws ConstantPoolException {

   761             return cp.getUTF8Value(descriptor_index);

   762         }

   763 

   764         public final int descriptor_index;

   765     }

   766 

   767     public static class CONSTANT_Methodref_info extends CPRefInfo {

   768         CONSTANT_Methodref_info(ConstantPool cp, ClassReader cr) throws IOException {

   769             super(cp, cr, CONSTANT_Methodref);

   770         }

   771 

   772         public CONSTANT_Methodref_info(ConstantPool cp, int class_index, int name_and_type_index) {

   773             super(cp, CONSTANT_Methodref, class_index, name_and_type_index);

   774         }

   775 

   776         @Override

   777         public String toString() {

   778             return "CONSTANT_Methodref_info[class_index: " + class_index + ", name_and_type_index: " + name_and_type_index + "]";

   779         }

   780 

   781         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   782             return visitor.visitMethodref(this, data);

   783         }

   784     }

   785 

   786     public static class CONSTANT_NameAndType_info extends CPInfo {

   787         CONSTANT_NameAndType_info(ConstantPool cp, ClassReader cr) throws IOException {

   788             super(cp);

   789             name_index = cr.readUnsignedShort();

   790             type_index = cr.readUnsignedShort();

   791         }

   792 

   793         public CONSTANT_NameAndType_info(ConstantPool cp, int name_index, int type_index) {

   794             super(cp);

   795             this.name_index = name_index;

   796             this.type_index = type_index;

   797         }

   798 

   799         public int getTag() {

   800             return CONSTANT_NameAndType;

   801         }

   802 

   803         public int byteLength() {

   804             return 5;

   805         }

   806 

   807         public String getName() throws ConstantPoolException {

   808             return cp.getUTF8Value(name_index);

   809         }

   810 

   811         public String getType() throws ConstantPoolException {

   812             return cp.getUTF8Value(type_index);

   813         }

   814 

   815         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   816             return visitor.visitNameAndType(this, data);

   817         }

   818 

   819         @Override

   820         public String toString() {

   821             return "CONSTANT_NameAndType_info[name_index: " + name_index + ", type_index: " + type_index + "]";

   822         }

   823 

   824         public final int name_index;

   825         public final int type_index;

   826     }

   827 

   828     public static class CONSTANT_String_info extends CPInfo {

   829         CONSTANT_String_info(ConstantPool cp, ClassReader cr) throws IOException {

   830             super(cp);

   831             string_index = cr.readUnsignedShort();

   832         }

   833 

   834         public CONSTANT_String_info(ConstantPool cp, int string_index) {

   835             super(cp);

   836             this.string_index = string_index;

   837         }

   838 

   839         public int getTag() {

   840             return CONSTANT_String;

   841         }

   842 

   843         public int byteLength() {

   844             return 3;

   845         }

   846 

   847         public String getString() throws ConstantPoolException {

   848             return cp.getUTF8Value(string_index);

   849         }

   850 

   851         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   852             return visitor.visitString(this, data);

   853         }

   854 

   855         @Override

   856         public String toString() {

   857             return "CONSTANT_String_info[class_index: " + string_index + "]";

   858         }

   859 

   860         public final int string_index;

   861     }

   862 

   863     public static class CONSTANT_Utf8_info extends CPInfo {

   864         CONSTANT_Utf8_info(ClassReader cr) throws IOException {

   865             value = cr.readUTF();

   866         }

   867 

   868         public CONSTANT_Utf8_info(String value) {

   869             this.value = value;

   870         }

   871 

   872         public int getTag() {

   873             return CONSTANT_Utf8;

   874         }

   875 

   876         public int byteLength() {

   877             class SizeOutputStream extends OutputStream {

   878                 @Override

   879                 public void write(int b) {

   880                     size++;

   881                 }

   882                 int size;

   883             }

   884             SizeOutputStream sizeOut = new SizeOutputStream();

   885             DataOutputStream out = new DataOutputStream(sizeOut);

   886             try { out.writeUTF(value); } catch (IOException ignore) { }

   887             return 1 + sizeOut.size;

   888         }

   889 

   890         @Override

   891         public String toString() {

   892             if (value.length() < 32 && isPrintableAscii(value))

   893                 return "CONSTANT_Utf8_info[value: \"" + value + "\"]";

   894             else

   895                 return "CONSTANT_Utf8_info[value: (" + value.length() + " chars)]";

   896         }

   897 

   898         static boolean isPrintableAscii(String s) {

   899             for (int i = 0; i < s.length(); i++) {

   900                 char c = s.charAt(i);

   901                 if (c < 32 || c >= 127)

   902                     return false;

   903             }

   904             return true;

   905         }

   906 

   907         public <R, D> R accept(Visitor<R, D> visitor, D data) {

   908             return visitor.visitUtf8(this, data);

   909         }

   910 

   911         public final String value;

   912     }

   913 

   914 }