void dump(DataOutput o) throws IOException { o.writeByte(tag); }
String debugToString() { return toString(); } // so we can remove this method when not debugging
- abstract Object key() throws ClassGen.ClassReadExn; // be careful using this, it drags in a bunch of code
+ abstract Object key() throws ClassFile.ClassReadExn; // be careful using this, it drags in a bunch of code
}
class IntEnt extends Ent {
}
private String fixme() { throw new Error("fixme"); }
- Object key() throws ClassGen.ClassReadExn {
+ Object key() throws ClassFile.ClassReadExn {
switch(tag) {
case 7: return Type.instance(((Utf8Ent)e1).s);
case 8: return (((Utf8Ent)e1).s);
case 9: {
NameAndTypeKey nt = (NameAndTypeKey) e2.key();
Type t = Type.instance(nt.type);
- if(t == null) throw new ClassGen.ClassReadExn("invalid type descriptor");
- return new FieldRef((Type.Class)e1.key(), nt.name, t);
+ if(t == null) throw new ClassFile.ClassReadExn("invalid type descriptor");
+ return ((Type.Class)e1.key()).field(nt.name, t);
}
case 10: case 11: {
NameAndTypeKey nt = (NameAndTypeKey) e2.key();
if (e1.key() == null) throw new Error(e1.tag + " => " + e1.key());
- return new MethodRef((Type.Class)e1.key(), "methodname", Type.VOID, new Type[0]); // FIXME FIXME
+ return ((Type.Class)e1.key()).method("methodname", Type.VOID, new Type[0]); // FIXME FIXME
}
case 12: {
return new NameAndTypeKey(((Utf8Ent)e1).s, ((Utf8Ent)e2).s);
return ent.n;
}
- public final Type getType(int index) throws ClassGen.ClassReadExn {
+ public final Type getType(int index) throws ClassFile.ClassReadExn {
Ent e = getByIndex(index);
if (e instanceof Utf8Ent) return Type.instance(((Utf8Ent)e).s);
else return (Type)e.key();
public final Ent addNameAndType(String name, String descriptor) { return add(new NameAndTypeKey(name, descriptor)); }
public final Ent addUtf8(String s) { return add(new Utf8Key(s)); }
- public final Ent add(Object o) {
+ public final Ent add(Object o) { return add(o, false); }
+ public final Ent add(Object o, boolean invokeInterface) {
if(state == SEALED) throw new IllegalStateException("constant pool is sealed");
Ent ent = get(o);
ce.e1 = addUtf8(key.name);
ce.e2 = addUtf8(key.type);
ent = ce;
- } else if(o instanceof ClassGen.FieldOrMethodRef) {
- ClassGen.FieldOrMethodRef key = (ClassGen.FieldOrMethodRef) o;
- int tag = o instanceof FieldRef ? 9 : o instanceof MethodRef ? 10 : o instanceof MethodRef.I ? 11 : 0;
+ } else if(o instanceof Type.Class.Member) {
+ Type.Class.Member key = (Type.Class.Member) o;
+ int tag = invokeInterface ? 11 : o instanceof Type.Class.Field ? 9 : o instanceof Type.Class.Method ? 10 : 0;
if(tag == 0) throw new Error("should never happen");
CPRefEnt ce = new CPRefEnt(tag);
- ce.e1 = add(key.klass);
- ce.e2 = addNameAndType(key.name, key.descriptor);
+ ce.e1 = add(key.getDeclaringClass());
+ ce.e2 = addNameAndType(key.name, key.getDescriptor());
ent = ce;
} else {
throw new IllegalArgumentException("Unknown type passed to add");
}
int spaces = ent instanceof LongEnt ? 2 : 1;
- if(usedSlots + spaces > 65536) throw new ClassGen.Exn("constant pool full");
+ if(usedSlots + spaces > 65536) throw new ClassFile.Exn("constant pool full");
ent.n = state == OPEN ? 1 : usedSlots; // refcount or index
}
}
- CPGen(DataInput in) throws ClassGen.ClassReadExn, IOException {
+ CPGen(DataInput in) throws ClassFile.ClassReadExn, IOException {
usedSlots = in.readUnsignedShort();
- if(usedSlots==0) throw new ClassGen.ClassReadExn("invalid used slots");
+ if(usedSlots==0) throw new ClassFile.ClassReadExn("invalid used slots");
// these are to remember the CPRefEnt e1 and e2s we have to fix up
int[] e1s = new int[usedSlots];
switch(tag) {
case 7: // Object Type
case 8: // String
- case 9: // FieldRef
- case 10: // MethodRef
+ case 9: // Type.Class.Field
+ case 10: // Type.Class.Method
case 11: // Instance Method Ref
case 12: // NameAndType
{
break;
}
default:
- throw new ClassGen.ClassReadExn("invalid cp ent tag");
+ throw new ClassFile.ClassReadExn("invalid cp ent tag");
}
entriesByIndex[index] = e;
if (e instanceof LongEnt) index++;
}
if (!(e instanceof CPRefEnt)) continue;
CPRefEnt ce = (CPRefEnt) e;
- if(e1s[i] == 0 || e1s[i] >= usedSlots) throw new ClassGen.ClassReadExn("invalid cp index");
+ if(e1s[i] == 0 || e1s[i] >= usedSlots) throw new ClassFile.ClassReadExn("invalid cp index");
ce.e1 = entriesByIndex[e1s[i]];
- if(ce.e1 == null) throw new ClassGen.ClassReadExn("invalid cp index");
+ if(ce.e1 == null) throw new ClassFile.ClassReadExn("invalid cp index");
if(ce.tag != 7 && ce.tag != 8) {
- if(e2s[i] == 0 || e2s[i] >= usedSlots) throw new ClassGen.ClassReadExn("invalid cp index");
+ if(e2s[i] == 0 || e2s[i] >= usedSlots) throw new ClassFile.ClassReadExn("invalid cp index");
ce.e2 = entriesByIndex[e2s[i]];
- if(ce.e2 == null) throw new ClassGen.ClassReadExn("invalid cp index");
+ if(ce.e2 == null) throw new ClassFile.ClassReadExn("invalid cp index");
}
switch(ce.tag) {
case 7:
case 8:
- if(!(ce.e1 instanceof Utf8Ent)) throw new ClassGen.ClassReadExn("expected a utf8 ent");
+ if(!(ce.e1 instanceof Utf8Ent)) throw new ClassFile.ClassReadExn("expected a utf8 ent");
break;
case 9:
case 10:
case 11:
if(!(ce.e1 instanceof CPRefEnt) || ((CPRefEnt)ce.e1).tag != 7)
- throw new ClassGen.ClassReadExn("expected a type ent");
+ throw new ClassFile.ClassReadExn("expected a type ent");
if(!(ce.e2 instanceof CPRefEnt) || ((CPRefEnt)ce.e2).tag != 12)
- throw new ClassGen.ClassReadExn("expected a name and type ent");
+ throw new ClassFile.ClassReadExn("expected a name and type ent");
break;
case 12:
- if(!(ce.e1 instanceof Utf8Ent)) throw new ClassGen.ClassReadExn("expected a utf8 ent");
- if(!(ce.e2 instanceof Utf8Ent)) throw new ClassGen.ClassReadExn("expected a utf8 ent");
+ if(!(ce.e1 instanceof Utf8Ent)) throw new ClassFile.ClassReadExn("expected a utf8 ent");
+ if(!(ce.e2 instanceof Utf8Ent)) throw new ClassFile.ClassReadExn("expected a utf8 ent");
break;
}
}