import java.util.*;
import java.io.*;
aspect ConstantPool {
  public static final byte ConstantPool.CONSTANT_Class              = 7;
  public static final byte ConstantPool.CONSTANT_Fieldref           = 9;
  public static final byte ConstantPool.CONSTANT_Methodref          = 10;
  public static final byte ConstantPool.CONSTANT_InterfaceMethodref = 11;
  public static final byte ConstantPool.CONSTANT_String             = 8;
  public static final byte ConstantPool.CONSTANT_Integer            = 3;
  public static final byte ConstantPool.CONSTANT_Float              = 4;
  public static final byte ConstantPool.CONSTANT_Long               = 5;
  public static final byte ConstantPool.CONSTANT_Double             = 6;
  public static final byte ConstantPool.CONSTANT_NameAndType        = 12;
  public static final byte ConstantPool.CONSTANT_Utf8               = 1;

  inh lazy int CPInfo.pos();
  eq ConstantPool.getCPInfo(int i).pos() {
    if(i == 0) 
      return 1;
    else 
      return getCPInfo(i - 1).pos() + getCPInfo(i - 1).size();
  }
  
  syn int CPInfo.size() = 1;
  eq ConstantLong.size() = 2;
  eq ConstantDouble.size() = 2;

  syn lazy int ConstantPool.addClass(String name) {
    name = name.replace('.', '/');
    for (int i = 0; i<getNumCPInfo(); i++)
      if (getCPInfo(i).isClass(name))
        return getCPInfo(i).pos();
    ConstantClass clazz = new ConstantClass(name);
    addCPInfo(clazz);
    clazz.toString();
    return clazz.pos();
  }

  syn lazy int ConstantPool.addFieldref(String classname, String name, String type) {
    for (int i = 0; i < getNumCPInfo(); i++)
      if (getCPInfo(i).isFieldref(classname, name, type))
        return getCPInfo(i).pos();
    ConstantFieldref cpinfo = new ConstantFieldref(classname, name, type);
    cpinfo = new ConstantFieldref(classname, name, type);
    addCPInfo(cpinfo);
    cpinfo.toString();
    return cpinfo.pos(); 
  }

  syn lazy int ConstantPool.addMethodref(String classname, String name, String desc) {
    for (int i=0; i<getNumCPInfo(); i++)
      if (getCPInfo(i).isMethodref(classname, name, desc))
        return getCPInfo(i).pos();
    ConstantMethodref cpinfo = new ConstantMethodref(classname, name, desc);
    addCPInfo(cpinfo);
    cpinfo.toString();
    return cpinfo.pos(); 
  }

  syn lazy int ConstantPool.addInterfaceMethodref(String classname, String name, String desc) {
    for (int i=0; i<getNumCPInfo(); i++)
      if (getCPInfo(i).isInterfaceMethodref(classname, name, desc))
        return getCPInfo(i).pos();
    ConstantInterfaceMethodref cpinfo = new ConstantInterfaceMethodref(classname, name, desc);
    addCPInfo(cpinfo);
    cpinfo.toString();
    return cpinfo.pos(); 
  }

  syn lazy int ConstantPool.addNameAndType(String name, String type) {
    for (int i=0; i<getNumCPInfo(); i++)
      if (getCPInfo(i).isNameAndType(name, type))
        return getCPInfo(i).pos();
    ConstantNameAndType cpinfo = new ConstantNameAndType(name, type);
    addCPInfo(cpinfo);
    cpinfo.toString();
    return cpinfo.pos(); 
  }

  syn lazy int ConstantPool.addUtf8(String name) {
    for (int i=0; i<getNumCPInfo(); i++)
      if (getCPInfo(i).isUtf8(name))
        return getCPInfo(i).pos();
    ConstantUtf8 utf8 = new ConstantUtf8(name);
    addCPInfo(utf8);
    return utf8.pos();
  }

  syn lazy int ConstantPool.addConstant(String val) {
    for (int i=0; i<getNumCPInfo(); i++)
      if (getCPInfo(i).isString(val))
        return getCPInfo(i).pos();
    ConstantString constant = new ConstantString(val);
    addCPInfo(constant);
    constant.toString();
    return constant.pos();
  }

  private HashMap ConstantPool.intConstants = new HashMap();
  public int ConstantPool.addConstant(int val) {
    Map map = intConstants;
    Object key = new Integer(val);
    if(!map.containsKey(key)) {
      CPInfo info = new ConstantInteger(val);
      addCPInfo(info);
      map.put(key, info);
      return info.pos();
    }
    CPInfo info = (CPInfo)map.get(key);
    return info.pos();
  }

  private HashMap ConstantPool.floatConstants = new HashMap();
  public int ConstantPool.addConstant(float val) {
    Map map = floatConstants;
    Object key = new Float(val);
    if(!map.containsKey(key)) {
      CPInfo info = new ConstantFloat(val);
      addCPInfo(info);
      map.put(key, info);
      return info.pos();
    }
    CPInfo info = (CPInfo)map.get(key);
    return info.pos();
  }

  private HashMap ConstantPool.longConstants = new HashMap();
  public int ConstantPool.addConstant(long val) {
    Map map = longConstants;
    Object key = new Long(val);
    if(!map.containsKey(key)) {
      CPInfo info = new ConstantLong(val);
      addCPInfo(info);
      map.put(key, info);
      return info.pos();
    }
    CPInfo info = (CPInfo)map.get(key);
    return info.pos();
  }

  private HashMap ConstantPool.doubleConstants = new HashMap();
  public int ConstantPool.addConstant(double val) {
    Map map = doubleConstants;
    Object key = new Double(val);
    if(!map.containsKey(key)) {
      CPInfo info = new ConstantDouble(val);
      addCPInfo(info);
      map.put(key, info);
      return info.pos();
    }
    CPInfo info = (CPInfo)map.get(key);
    return info.pos();
  }

  syn boolean CPInfo.isClass(String name) = false;
  eq ConstantClass.isClass(String name) = name.equals(getname());

  syn boolean CPInfo.isFieldref(String classname, String name, String type) = false;
  eq ConstantFieldref.isFieldref(String classname, String name, String type) =
    classname.equals(getclassname()) && name.equals(getname()) && type.equals(gettype());

  syn boolean CPInfo.isMethodref(String classname, String name, String desc) = false;
  eq ConstantMethodref.isMethodref(String classname, String name, String desc) =
    classname.equals(getclassname()) && name.equals(getname()) && desc.equals(getdesc());

  syn boolean CPInfo.isInterfaceMethodref(String classname, String name, String desc) = false;
  eq ConstantInterfaceMethodref.isInterfaceMethodref(String classname, String name, String desc) =
    classname.equals(getclassname()) && name.equals(getname()) && desc.equals(getdesc());

  syn boolean CPInfo.isNameAndType(String name, String type) = false;
  eq ConstantNameAndType.isNameAndType(String name, String type) =
    name.equals(getname()) && type.equals(gettype());

  syn boolean CPInfo.isUtf8(String name) = false;
  eq ConstantUtf8.isUtf8(String name) = name.equals(getname());

  syn boolean CPInfo.isString(String val) = false;
  eq ConstantString.isString(String val) = val.equals(getval());

  syn boolean CPInfo.isInteger(int val) = false;
  eq ConstantInteger.isInteger(int val) = val == getval();

  syn boolean CPInfo.isFloat(float val) = false;
  eq ConstantFloat.isFloat(float val) = val == getval();

  syn boolean CPInfo.isLong(long val) = false;
  eq ConstantLong.isLong(long val) = val == getval();

  syn boolean CPInfo.isDouble(double val) = false;
  eq ConstantDouble.isDouble(double val) = val == getval();

  inh int CPInfo.addUtf8(String name);  
  eq ConstantPool.getCPInfo().addUtf8(String name) = addUtf8(name);

  inh int CPInfo.addClass(String name);
  eq ConstantPool.getCPInfo().addClass(String name) = addClass(name);

  inh int CPInfo.addNameAndType(String name, String type);
  eq ConstantPool.getCPInfo().addNameAndType(String name, String type) = addNameAndType(name, type);

  public String ConstantClass.toString() {
    return pos() + " ConstantClass: tag " + ConstantPool.CONSTANT_Class + ", name_index: " + addUtf8(getname());
  }

  public String ConstantFieldref.toString() {
    return pos() + " ConstantFieldref: tag " + ConstantPool.CONSTANT_Fieldref + ", class_index: " + addClass(getclassname()) + ", name_and_type_index: " + addNameAndType(getname(), gettype());
  }

  public String ConstantMethodref.toString() {
    return pos() + " ConstantMethodref: tag " + ConstantPool.CONSTANT_Methodref + ", class_index: " + addClass(getclassname()) + ", name_and_type_index: " + addNameAndType(getname(), getdesc());
  }

  public String ConstantInterfaceMethodref.toString() {
    return pos() + " ConstantInterfaceMethodref: tag " + ConstantPool.CONSTANT_InterfaceMethodref + ", class_index: " + addClass(getclassname()) + ", name_and_type_index: " + addNameAndType(getname(), getdesc());
  }

  public String ConstantNameAndType.toString() {
    return pos() + " NameAndType: tag " + ConstantPool.CONSTANT_NameAndType + ", name_index: " + addUtf8(getname()) + ", descriptor_index: " + addUtf8(gettype());
  }

  public String ConstantUtf8.toString() {
    return pos() + " ConstantUtf8: tag " + ConstantPool.CONSTANT_Utf8 + ", length: " + getname().length() + ", bytes: " + getname();
  }

  public String ConstantString.toString() {
    return pos() + " ConstantString: tag " + ConstantPool.CONSTANT_String + ", string_index: " + addUtf8(getval());
  }

  public String ConstantInteger.toString() {
    return pos() + " ConstantInteger: tag " + ConstantPool.CONSTANT_Integer + ", bytes: " + getval();
  }

  public String ConstantFloat.toString() {
    return pos() + " ConstantFloat: tag " + ConstantPool.CONSTANT_Float + ", bytes: " + getval();
  }

  public String ConstantLong.toString() {
    return pos() + " ConstantLong: tag " + ConstantPool.CONSTANT_Long + ", bytes: " + getval();
  }

  public String ConstantDouble.toString() {
    return pos() + " ConstantDouble: tag " + ConstantPool.CONSTANT_Double + ", bytes: " + getval();
  }

}