/**
   * Override this method to create you own classes on the fly. The name contains the special token
   * $$BCEL$$. Everything before that token is consddered to be a package name. You can encode you
   * own arguments into the subsequent string. You must regard however not to use any "illegal"
   * characters, i.e., characters that may not appear in a Java class name too<br>
   * The default implementation interprets the string as a encoded compressed Java class, unpacks
   * and decodes it with the Utility.decode() method, and parses the resulting byte array and
   * returns the resulting JavaClass object.
   *
   * @param class_name compressed byte code with "$$BCEL$$" in it
   */
  protected JavaClass createClass(String class_name) {
    int index = class_name.indexOf("$$BCEL$$");
    String real_name = class_name.substring(index + 8);

    JavaClass clazz = null;
    try {
      byte[] bytes = Utility.decode(real_name, true);
      ClassParser parser = new ClassParser(new ByteArrayInputStream(bytes), "foo");

      clazz = parser.parse();
    } catch (Throwable e) {
      e.printStackTrace();
      return null;
    }

    // Adapt the class name to the passed value
    ConstantPool cp = clazz.getConstantPool();

    ConstantClass cl =
        (ConstantClass) cp.getConstant(clazz.getClassNameIndex(), Constants.CONSTANT_Class);
    ConstantUtf8 name = (ConstantUtf8) cp.getConstant(cl.getNameIndex(), Constants.CONSTANT_Utf8);
    name.setBytes(class_name.replace('.', '/'));

    return clazz;
  }
  /**
   * Initialize with given array of constants.
   *
   * @param c array of given constants, new ones will be appended
   */
  public ConstantPoolGen(Constant[] cs) {
    if (cs.length > size) {
      size = cs.length;
      constants = new Constant[size];
    }

    System.arraycopy(cs, 0, constants, 0, cs.length);

    if (cs.length > 0) index = cs.length;

    for (int i = 1; i < index; i++) {
      Constant c = constants[i];

      if (c instanceof ConstantString) {
        ConstantString s = (ConstantString) c;
        ConstantUtf8 u8 = (ConstantUtf8) constants[s.getStringIndex()];

        string_table.put(u8.getBytes(), new Index(i));
      } else if (c instanceof ConstantClass) {
        ConstantClass s = (ConstantClass) c;
        ConstantUtf8 u8 = (ConstantUtf8) constants[s.getNameIndex()];

        class_table.put(u8.getBytes(), new Index(i));
      } else if (c instanceof ConstantNameAndType) {
        ConstantNameAndType n = (ConstantNameAndType) c;
        ConstantUtf8 u8 = (ConstantUtf8) constants[n.getNameIndex()];
        ConstantUtf8 u8_2 = (ConstantUtf8) constants[n.getSignatureIndex()];

        n_a_t_table.put(u8.getBytes() + NAT_DELIM + u8_2.getBytes(), new Index(i));
      } else if (c instanceof ConstantUtf8) {
        ConstantUtf8 u = (ConstantUtf8) c;

        utf8_table.put(u.getBytes(), new Index(i));
      } else if (c instanceof ConstantCP) {
        ConstantCP m = (ConstantCP) c;
        ConstantClass clazz = (ConstantClass) constants[m.getClassIndex()];
        ConstantNameAndType n = (ConstantNameAndType) constants[m.getNameAndTypeIndex()];

        ConstantUtf8 u8 = (ConstantUtf8) constants[clazz.getNameIndex()];
        String class_name = u8.getBytes().replace('/', '.');

        u8 = (ConstantUtf8) constants[n.getNameIndex()];
        String method_name = u8.getBytes();

        u8 = (ConstantUtf8) constants[n.getSignatureIndex()];
        String signature = u8.getBytes();

        String delim = METHODREF_DELIM;

        if (c instanceof ConstantInterfaceMethodref) delim = IMETHODREF_DELIM;
        else if (c instanceof ConstantFieldref) delim = FIELDREF_DELIM;

        cp_table.put(class_name + delim + method_name + delim + signature, new Index(i));
      }
    }
  }
  private void writeConstant(int index) {
    byte tag = constants[index].getTag();
    int class_index, name_index;
    String ref;

    // The header is always the same
    file.println("<H4> <A NAME=cp" + index + ">" + index + "</A> " + CONSTANT_NAMES[tag] + "</H4>");

    /* For every constant type get the needed parameters and print them appropiately
     */
    switch (tag) {
      case CONSTANT_InterfaceMethodref:
      case CONSTANT_Methodref:
        // Get class_index and name_and_type_index, depending on type
        if (tag == CONSTANT_Methodref) {
          ConstantMethodref c =
              (ConstantMethodref) constant_pool.getConstant(index, CONSTANT_Methodref);
          class_index = c.getClassIndex();
          name_index = c.getNameAndTypeIndex();
        } else {
          ConstantInterfaceMethodref c1 =
              (ConstantInterfaceMethodref)
                  constant_pool.getConstant(index, CONSTANT_InterfaceMethodref);
          class_index = c1.getClassIndex();
          name_index = c1.getNameAndTypeIndex();
        }

        // Get method name and its class
        String method_name = constant_pool.constantToString(name_index, CONSTANT_NameAndType);
        String html_method_name = Class2HTML.toHTML(method_name);

        // Partially compacted class name, i.e., / -> .
        String method_class = constant_pool.constantToString(class_index, CONSTANT_Class);
        String short_method_class =
            Utility.compactClassName(method_class); // I.e., remove java.lang.
        short_method_class = Utility.compactClassName(method_class); // I.e., remove java.lang.
        short_method_class =
            Utility.compactClassName(
                short_method_class, class_package + ".", true); // Remove class package prefix

        // Get method signature
        ConstantNameAndType c2 =
            (ConstantNameAndType) constant_pool.getConstant(name_index, CONSTANT_NameAndType);
        String signature = constant_pool.constantToString(c2.getSignatureIndex(), CONSTANT_Utf8);
        // Get array of strings containing the argument types
        String[] args = Utility.methodSignatureArgumentTypes(signature, false);

        // Get return type string
        String type = Utility.methodSignatureReturnType(signature, false);
        String ret_type = Class2HTML.referenceType(type);

        StringBuffer buf = new StringBuffer("(");
        for (int i = 0; i < args.length; i++) {
          buf.append(Class2HTML.referenceType(args[i]));
          if (i < args.length - 1) buf.append(",&nbsp;");
        }
        buf.append(")");

        String arg_types = buf.toString();

        if (method_class.equals(class_name)) // Method is local to class
        ref =
              "<A HREF=\""
                  + class_name
                  + "_code.html#method"
                  + getMethodNumber(method_name + signature)
                  + "\" TARGET=Code>"
                  + html_method_name
                  + "</A>";
        else
          ref =
              "<A HREF=\""
                  + method_class
                  + ".html"
                  + "\" TARGET=_top>"
                  + short_method_class
                  + "</A>."
                  + html_method_name;

        constant_ref[index] =
            ret_type
                + "&nbsp;<A HREF=\""
                + class_name
                + "_cp.html#cp"
                + class_index
                + "\" TARGET=Constants>"
                + short_method_class
                + "</A>.<A HREF=\""
                + class_name
                + "_cp.html#cp"
                + index
                + "\" TARGET=ConstantPool>"
                + html_method_name
                + "</A>&nbsp;"
                + arg_types;

        file.println(
            "<P><TT>"
                + ret_type
                + "&nbsp;"
                + ref
                + arg_types
                + "&nbsp;</TT>\n<UL>"
                + "<LI><A HREF=\"#cp"
                + class_index
                + "\">Class index("
                + class_index
                + ")</A>\n"
                + "<LI><A HREF=\"#cp"
                + name_index
                + "\">NameAndType index("
                + name_index
                + ")</A></UL>");
        break;

      case CONSTANT_Fieldref:
        // Get class_index and name_and_type_index
        ConstantFieldref c3 =
            (ConstantFieldref) constant_pool.getConstant(index, CONSTANT_Fieldref);
        class_index = c3.getClassIndex();
        name_index = c3.getNameAndTypeIndex();

        // Get method name and its class (compacted)
        String field_class = constant_pool.constantToString(class_index, CONSTANT_Class);
        String short_field_class = Utility.compactClassName(field_class); // I.e., remove java.lang.
        short_field_class =
            Utility.compactClassName(
                short_field_class, class_package + ".", true); // Remove class package prefix

        String field_name = constant_pool.constantToString(name_index, CONSTANT_NameAndType);

        if (field_class.equals(class_name)) // Field is local to class
        ref =
              "<A HREF=\""
                  + field_class
                  + "_methods.html#field"
                  + field_name
                  + "\" TARGET=Methods>"
                  + field_name
                  + "</A>";
        else
          ref =
              "<A HREF=\""
                  + field_class
                  + ".html\" TARGET=_top>"
                  + short_field_class
                  + "</A>."
                  + field_name
                  + "\n";

        constant_ref[index] =
            "<A HREF=\""
                + class_name
                + "_cp.html#cp"
                + class_index
                + "\" TARGET=Constants>"
                + short_field_class
                + "</A>.<A HREF=\""
                + class_name
                + "_cp.html#cp"
                + index
                + "\" TARGET=ConstantPool>"
                + field_name
                + "</A>";

        file.println(
            "<P><TT>"
                + ref
                + "</TT><BR>\n"
                + "<UL>"
                + "<LI><A HREF=\"#cp"
                + class_index
                + "\">Class("
                + class_index
                + ")</A><BR>\n"
                + "<LI><A HREF=\"#cp"
                + name_index
                + "\">NameAndType("
                + name_index
                + ")</A></UL>");
        break;

      case CONSTANT_Class:
        ConstantClass c4 = (ConstantClass) constant_pool.getConstant(index, CONSTANT_Class);
        name_index = c4.getNameIndex();
        String class_name2 = constant_pool.constantToString(index, tag); // / -> .
        String short_class_name = Utility.compactClassName(class_name2); // I.e., remove java.lang.
        short_class_name =
            Utility.compactClassName(
                short_class_name, class_package + ".", true); // Remove class package prefix

        ref = "<A HREF=\"" + class_name2 + ".html\" TARGET=_top>" + short_class_name + "</A>";
        constant_ref[index] =
            "<A HREF=\""
                + class_name
                + "_cp.html#cp"
                + index
                + "\" TARGET=ConstantPool>"
                + short_class_name
                + "</A>";

        file.println(
            "<P><TT>"
                + ref
                + "</TT><UL>"
                + "<LI><A HREF=\"#cp"
                + name_index
                + "\">Name index("
                + name_index
                + ")</A></UL>\n");
        break;

      case CONSTANT_String:
        ConstantString c5 = (ConstantString) constant_pool.getConstant(index, CONSTANT_String);
        name_index = c5.getStringIndex();

        String str = Class2HTML.toHTML(constant_pool.constantToString(index, tag));

        file.println(
            "<P><TT>"
                + str
                + "</TT><UL>"
                + "<LI><A HREF=\"#cp"
                + name_index
                + "\">Name index("
                + name_index
                + ")</A></UL>\n");
        break;

      case CONSTANT_NameAndType:
        ConstantNameAndType c6 =
            (ConstantNameAndType) constant_pool.getConstant(index, CONSTANT_NameAndType);
        name_index = c6.getNameIndex();
        int signature_index = c6.getSignatureIndex();

        file.println(
            "<P><TT>"
                + Class2HTML.toHTML(constant_pool.constantToString(index, tag))
                + "</TT><UL>"
                + "<LI><A HREF=\"#cp"
                + name_index
                + "\">Name index("
                + name_index
                + ")</A>\n"
                + "<LI><A HREF=\"#cp"
                + signature_index
                + "\">Signature index("
                + signature_index
                + ")</A></UL>\n");
        break;

      default:
        file.println(
            "<P><TT>" + Class2HTML.toHTML(constant_pool.constantToString(index, tag)) + "</TT>\n");
    } // switch
  }
  /** Import constant from another ConstantPool and return new index. */
  public int addConstant(Constant c, ConstantPoolGen cp) {
    Constant[] constants = cp.getConstantPool().getConstantPool();

    switch (c.getTag()) {
      case Constants.CONSTANT_String:
        {
          ConstantString s = (ConstantString) c;
          ConstantUtf8 u8 = (ConstantUtf8) constants[s.getStringIndex()];

          return addString(u8.getBytes());
        }

      case Constants.CONSTANT_Class:
        {
          ConstantClass s = (ConstantClass) c;
          ConstantUtf8 u8 = (ConstantUtf8) constants[s.getNameIndex()];

          return addClass(u8.getBytes());
        }

      case Constants.CONSTANT_NameAndType:
        {
          ConstantNameAndType n = (ConstantNameAndType) c;
          ConstantUtf8 u8 = (ConstantUtf8) constants[n.getNameIndex()];
          ConstantUtf8 u8_2 = (ConstantUtf8) constants[n.getSignatureIndex()];

          return addNameAndType(u8.getBytes(), u8_2.getBytes());
        }

      case Constants.CONSTANT_Utf8:
        return addUtf8(((ConstantUtf8) c).getBytes());

      case Constants.CONSTANT_Double:
        return addDouble(((ConstantDouble) c).getBytes());

      case Constants.CONSTANT_Float:
        return addFloat(((ConstantFloat) c).getBytes());

      case Constants.CONSTANT_Long:
        return addLong(((ConstantLong) c).getBytes());

      case Constants.CONSTANT_Integer:
        return addInteger(((ConstantInteger) c).getBytes());

      case Constants.CONSTANT_InterfaceMethodref:
      case Constants.CONSTANT_Methodref:
      case Constants.CONSTANT_Fieldref:
        {
          ConstantCP m = (ConstantCP) c;
          ConstantClass clazz = (ConstantClass) constants[m.getClassIndex()];
          ConstantNameAndType n = (ConstantNameAndType) constants[m.getNameAndTypeIndex()];
          ConstantUtf8 u8 = (ConstantUtf8) constants[clazz.getNameIndex()];
          String class_name = u8.getBytes().replace('/', '.');

          u8 = (ConstantUtf8) constants[n.getNameIndex()];
          String name = u8.getBytes();

          u8 = (ConstantUtf8) constants[n.getSignatureIndex()];
          String signature = u8.getBytes();

          switch (c.getTag()) {
            case Constants.CONSTANT_InterfaceMethodref:
              return addInterfaceMethodref(class_name, name, signature);

            case Constants.CONSTANT_Methodref:
              return addMethodref(class_name, name, signature);

            case Constants.CONSTANT_Fieldref:
              return addFieldref(class_name, name, signature);

            default: // Never reached
              throw new RuntimeException("Unknown constant type " + c);
          }
        }

      default: // Never reached
        throw new RuntimeException("Unknown constant type " + c);
    }
  }