ConstantHTML xref

View Javadoc

    1   /*
    2    * Copyright  2000-2004 The Apache Software Foundation
    3    *
    4    *  Licensed under the Apache License, Version 2.0 (the "License");
    5    *  you may not use this file except in compliance with the License.
    6    *  You may obtain a copy of the License at
    7    *
    8    *      http://www.apache.org/licenses/LICENSE-2.0
    9    *
    10   *  Unless required by applicable law or agreed to in writing, software
    11   *  distributed under the License is distributed on an "AS IS" BASIS,
    12   *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   *  See the License for the specific language governing permissions and
    14   *  limitations under the License.
    15   *
    16   */
    17  package org.apache.bcel.util;
    18
    19  import java.io.FileOutputStream;
    20  import java.io.IOException;
    21  import java.io.PrintWriter;
    22  import org.apache.bcel.classfile.Constant;
    23  import org.apache.bcel.classfile.ConstantClass;
    24  import org.apache.bcel.classfile.ConstantFieldref;
    25  import org.apache.bcel.classfile.ConstantInterfaceMethodref;
    26  import org.apache.bcel.classfile.ConstantMethodref;
    27  import org.apache.bcel.classfile.ConstantNameAndType;
    28  import org.apache.bcel.classfile.ConstantPool;
    29  import org.apache.bcel.classfile.ConstantString;
    30  import org.apache.bcel.classfile.Method;
    31  import org.apache.bcel.classfile.Utility;
    32
    33  /***
    34   * Convert constant pool into HTML file.
    35   *
    36   * @version $Id: ConstantHTML.java 386056 2006-03-15 11:31:56Z tcurdt $
    37   * @author  <A HREF="mailto:m.dahm@gmx.de">M. Dahm</A>
    38   *
    39   */
    40  final class ConstantHTML implements org.apache.bcel.Constants {
    41
    42      private String class_name; // name of current class
    43      privateong> String class_package; // name of package
    44      private ConstantPool constant_pool; // reference to constant pool
    45      private PrintWriter file; // file to write to
    46      private String[] constant_ref; // String to return for cp[i]
    47      private Constant[] constants; // The constants in the cp
    48      private Method[] methods;
    49
    50
    51      ConstantHTML(String dir, String class_name, String class_package, Method[] methods,/package-summary.html">ConstantHTML(String dir, String class_name, String class_package, Method[] methods,
    52              ConstantPool constant_pool) throws IOException {
    53          this.class_name = class_name;
    54          this.class_package</strong> = class_package;
    55          this.constant_pool = constant_pool;
    56          this.methods = methods;
    57          constants = constant_pool.getConstantPool();
    58          file = new PrintWriter(new FileOutputStream(dir + class_name + "_cp.html"));
    59          constant_ref = new String[constants.length];
    60          constant_ref[0] = "&lt;unknown&gt;";
    61          file.println("<HTML><BODY BGCOLOR=\"#C0C0C0\"><TABLE BORDER=0>");
    62          // Loop through constants, constants[0] is reserved
    63          for (int i = 1; i < constants.length; i++) {
    64              if (i % 2 == 0) {
    65                  file.print("<TR BGCOLOR=\"#C0C0C0\"><TD>");
    66              } else {
    67                  file.print("<TR BGCOLOR=\"#A0A0A0\"><TD>");
    68              }
    69              if (constants[i] != null) {
    70                  writeConstant(i);
    71              }
    72              file.print("</TD></TR>\n");
    73          }
    74          file.println("</TABLE></BODY></HTML>");
    75          file.close();
    76      }
    77
    78
    79      String referenceConstant( int index ) {
    80          return constant_ref[index];
    81      }
    82
    83
    84      private void writeConstant( int index ) {
    85          byte tag = constants[index].getTag();
    86          int class_index, name_index;
    87          String ref;
    88          // The header is always the same
    89          file.println("<H4> <A NAME=cp" + index + ">" + index + "</A> " + CONSTANT_NAMES[tag]
    90                  + "</H4>");
    91          /* For every constant type get the needed parameters and print them appropiately
    92           */
    93          switch (tag) {
    94              case CONSTANT_InterfaceMethodref:
    95              case CONSTANT_Methodref:
    96                  // Get class_index and name_and_type_index, depending on type
    97                  if (tag == CONSTANT_Methodref) {
    98                      ConstantMethodref c = (ConstantMethodref) constant_pool.getConstant(index,
    99                              CONSTANT_Methodref);
    100                     class_index = c.getClassIndex();
    101                     name_index = c.getNameAndTypeIndex();
    102                 } else {
    103                     ConstantInterfaceMethodref c1 = (ConstantInterfaceMethodref) constant_pool
    104                             .getConstant(index, CONSTANT_InterfaceMethodref);
    105                     class_index = c1.getClassIndex();
    106                     name_index = c1.getNameAndTypeIndex();
    107                 }
    108                 // Get method name and its class
    109                 String method_name = constant_pool.constantToString(name_index,
    110                         CONSTANT_NameAndType);
    111                 String html_method_name = Class2HTML.toHTML(method_name);
    112                 // Partially compacted class name, i.e., / -> .
    113                 String method_class = constant_pool.constantToString(class_index, CONSTANT_Class);
    114                 String short_method_class = Utility.compactClassName(method_class); // I.e., remove java.lang.
    115                 short_method_class = Utility.compactClassName(method_class); // I.e., remove java.lang.
    116                 short_method_g>class = Utility.compactClassName(short_method_class, class_package
    117                         + ".", true); // Remove class package prefix
    118                 // Get method signature
    119                 ConstantNameAndType c2 = (ConstantNameAndType) constant_pool.getConstant(
    120                         name_index, CONSTANT_NameAndType);
    121                 String signature = constant_pool.constantToString(c2.getSignatureIndex(),
    122                         CONSTANT_Utf8);
    123                 // Get array of strings containing the argument types
    124                 String[] args = Utility.methodSignatureArgumentTypes(signature, false);
    125                 // Get return type string
    126                 String type = Utility.methodSignatureReturnType(signature, false);
    127                 String ret_type = Class2HTML.referenceType(type);
    128                 StringBuffer buf = new StringBuffer("(");
    129                 for (int i = 0; i < args.length; i++) {
    130                     buf.append(Class2HTML.referenceType(args[i]));
    131                     if (i < args.length - 1) {
    132                         buf.append(",&nbsp;");
    133                     }
    134                 }
    135                 buf.append(")");
    136                 String arg_types = buf.toString();
    137                 if (method_class.equals(class_name)) {
    138                     ref = "<A HREF=\"" + class_name + "_code.html#method"
    139                             + getMethodNumber(method_name + signature) + "\" TARGET=Code>"
    140                             + html_method_name + "</A>";
    141                 } else {
    142                     ref = "<A HREF=\"" + method_class + ".html" + "\" TARGET=_top>"
    143                             + short_method_class + "</A>." + html_method_name;
    144                 }
    145                 constant_ref[index] = ret_type + "&nbsp;<A HREF=\"" + class_name + "_cp.html#cp"
    146                         + class_index + "\" TARGET=Constants>" + short_method_class
    147                         + "</A>.<A HREF=\"" + class_name + "_cp.html#cp" + index
    148                         + "\" TARGET=ConstantPool>" + html_method_name + "</A>&nbsp;" + arg_types;
    149                 file.println("<P><TT>" + ret_type + "&nbsp;" + ref + arg_types
    150                         + "&nbsp;</TT>\n<UL>" + "<LI><A HREF=\"#cp" + class_index
    151                         + "\">Class index(" + class_index + ")</A>\n" + "<LI><A HREF=\"#cp"
    152                         + name_index + "\">NameAndType index(" + name_index + ")</A></UL>");
    153                 break;
    154             case CONSTANT_Fieldref:
    155                 // Get class_index and name_and_type_index
    156                 ConstantFieldref c3 = (ConstantFieldref) constant_pool.getConstant(index,
    157                         CONSTANT_Fieldref);
    158                 class_index = c3.getClassIndex();
    159                 name_index = c3.getNameAndTypeIndex();
    160                 // Get method name and its class (compacted)
    161                 String field_class = constant_pool.constantToString(class_index, CONSTANT_Class);
    162                 String short_field_class = Utility.compactClassName(field_class); // I.e., remove java.lang.
    163                 short_field_class = Utility.compactClassName(short_field_class,
    164                         class_package + ".", true); // Remove class package prefix
    165                 String field_name = constant_pool
    166                         .constantToString(name_index, CONSTANT_NameAndType);
    167                 if (field_class.equals(class_name)) {
    168                     ref = "<A HREF=\"" + field_class + "_methods.html#field" + field_name
    169                             + "\" TARGET=Methods>" + field_name + "</A>";
    170                 } else {
    171                     ref = "<A HREF=\"" + field_class + ".html\" TARGET=_top>" + short_field_class
    172                             + "</A>." + field_name + "\n";
    173                 }
    174                 constant_ref[index] = "<A HREF=\"" + class_name + "_cp.html#cp" + class_index
    175                         + "\" TARGET=Constants>" + short_field_class + "</A>.<A HREF=\""
    176                         + class_name + "_cp.html#cp" + index + "\" TARGET=ConstantPool>"
    177                         + field_name + "</A>";
    178                 file.println("<P><TT>" + ref + "</TT><BR>\n" + "<UL>" + "<LI><A HREF=\"#cp"
    179                         + class_index + "\">Class(" + class_index + ")</A><BR>\n"
    180                         + "<LI><A HREF=\"#cp" + name_index + "\">NameAndType(" + name_index
    181                         + ")</A></UL>");
    182                 break;
    183             case CONSTANT_Class:
    184                 ConstantClass c4 = (ConstantClass) constant_pool.getConstant(index, CONSTANT_Class);
    185                 name_index = c4.getNameIndex();
    186                 String class_name2 = constant_pool.constantToString(index, tag); // / -> .
    187                 String short_class_name = Utility.compactClassName(class_name2); // I.e., remove java.lang.
    188                 short_class_name = Utility.compactClassName(short_class_name, class_package + ".",
    189                         true); // Remove class package prefix
    190                 ref = "<A HREF=\"" + class_name2 + ".html\" TARGET=_top>" + short_class_name
    191                         + "</A>";
    192                 constant_ref[index] = "<A HREF=\"" + class_name + "_cp.html#cp" + index
    193                         + "\" TARGET=ConstantPool>" + short_class_name + "</A>";
    194                 file.println("<P><TT>" + ref + "</TT><UL>" + "<LI><A HREF=\"#cp" + name_index
    195                         + "\">Name index(" + name_index + ")</A></UL>\n");
    196                 break;
    197             case CONSTANT_String:
    198                 ConstantString c5 = (ConstantString) constant_pool.getConstant(index,
    199                         CONSTANT_String);
    200                 name_index = c5.getStringIndex();
    201                 String str = Class2HTML.toHTML(constant_pool.constantToString(index, tag));
    202                 file.println("<P><TT>" + str + "</TT><UL>" + "<LI><A HREF=\"#cp" + name_index
    203                         + "\">Name index(" + name_index + ")</A></UL>\n");
    204                 break;
    205             case CONSTANT_NameAndType:
    206                 ConstantNameAndType c6 = (ConstantNameAndType) constant_pool.getConstant(index,
    207                         CONSTANT_NameAndType);
    208                 name_index = c6.getNameIndex();
    209                 int signature_index = c6.getSignatureIndex();
    210                 file.println("<P><TT>"
    211                         + Class2HTML.toHTML(constant_pool.constantToString(index, tag))
    212                         + "</TT><UL>" + "<LI><A HREF=\"#cp" + name_index + "\">Name index("
    213                         + name_index + ")</A>\n" + "<LI><A HREF=\"#cp" + signature_index
    214                         + "\">Signature index(" + signature_index + ")</A></UL>\n");
    215                 break;
    216             default:
    217                 file
    218                         .println("<P><TT>"
    219                                 + Class2HTML.toHTML(constant_pool.constantToString(index, tag))
    220                                 + "</TT>\n");
    221         } // switch
    222     }
    223
    224
    225     private final int getMethodNumber( String str ) {
    226         for (int i = 0; i < methods.length; i++) {
    227             String cmp = methods[i].getName() + methods[i].getSignature();
    228             if (cmp.equals(str)) {
    229                 return i;
    230             }
    231         }
    232         return -1;
    233     }
    234 }