/**
* 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));
}
}
}
/**
* Returns all related classes
*
* @param start
* @return
*/
private static Collection<Class<?>> getAllRelatedClasses(Class<?> start) {
List<Class<?>> rval = new ArrayList<Class<?>>();
JavaClass lookupClass;
// In case the class fails, return empty.
try {
lookupClass = Repository.lookupClass(start);
} catch (ClassNotFoundException e) {
e.printStackTrace();
return rval;
}
ConstantPool constantPool = lookupClass.getConstantPool();
int length = constantPool.getLength();
for (int i = 0; i < length; i++) {
Constant constant = constantPool.getConstant(i);
if (constant instanceof ConstantClass) {
ConstantClass cc = (ConstantClass) constant;
ConstantUtf8 constant2 = (ConstantUtf8) constantPool.getConstant(cc.getNameIndex());
// In case a subclass fails, skip, but print warning.
try {
String toLoad = constant2.getBytes().replace('/', '.');
if (toLoad.contains("[")) continue;
Class<?> forName = Class.forName(toLoad);
rval.add(forName);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
}
return rval;
}
public void visitConstantClass(ConstantClass constant) {
constant.accept(visitor);
}
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(", ");
}
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
+ " <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> "
+ arg_types;
file.println(
"<P><TT>"
+ ret_type
+ " "
+ ref
+ arg_types
+ " </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
}
/** @param cp */
public void resolveCPool(ConstantPool cp) {
Constant[] ca = cp.getConstantPool();
cpoolArry = new int[cpoolUsed.size()];
cpoolComments = new String[ca.length];
// System.out.println(clazz.getClassName()+" cpool "+cpoolUsed);
for (int i = 0; i < ca.length; ++i) {
Constant co = ca[i];
Integer idx = new Integer(i);
// pos is the new position in the reduced constant pool
// idx is the position in the 'original' unresolved cpool
int pos = cpoolUsed.indexOf(idx);
if (pos != -1) {
boolean isInterface = false;
// System.out.println("cpool@"+pos+" = orig_cp@"+i+" "+co);
switch (co.getTag()) {
case Constants.CONSTANT_Integer:
cpoolArry[pos] = ((ConstantInteger) co).getBytes();
cpoolComments[pos] = "Integer";
break;
case Constants.CONSTANT_Long:
long lval = ((ConstantLong) co).getBytes();
// store LOW, HIGH words in this order
int loW = (new Long(0xFFFFFFFF & lval)).intValue();
int hiW = (new Long(lval >>> 32)).intValue();
cpoolArry[pos] = hiW;
cpoolArry[pos + 1] = loW;
cpoolComments[pos] = "Long: " + lval;
cpoolComments[pos + 1] = "";
break;
case Constants.CONSTANT_Float:
float fval = ((ConstantFloat) co).getBytes();
cpoolArry[pos] = Float.floatToRawIntBits(fval);
cpoolComments[pos] = "Float: " + fval;
break;
case Constants.CONSTANT_Double:
double dval = ((ConstantDouble) co).getBytes();
long d_lval = Double.doubleToRawLongBits(dval);
// store LOW, HIGH words in this order
int d_loW = (new Long(0xFFFFFFFF & d_lval)).intValue();
int d_hiW = (new Long(d_lval >>> 32)).intValue();
cpoolArry[pos] = d_hiW;
cpoolArry[pos + 1] = d_loW;
cpoolComments[pos] = "Double: " + dval;
cpoolComments[pos + 1] = "";
break;
case Constants.CONSTANT_String:
String str = ((ConstantString) co).getBytes(cp);
StringInfo si = StringInfo.getStringInfo(str);
cpoolArry[pos] = StringInfo.stringTableAddress + si.getAddress();
cpoolComments[pos] = "String: " + si.getSaveString();
break;
case Constants.CONSTANT_Class:
String clname = ((ConstantClass) co).getBytes(cp).replace('/', '.');
JopClassInfo clinfo = (JopClassInfo) appInfo.cliMap.get(clname);
if (clinfo == null) {
cpoolComments[pos] = "Problem with class: " + clname;
String type = clname.substring(clname.length() - 2);
if (type.charAt(0) == '[') {
switch (type.charAt(1)) {
case 'Z':
cpoolArry[pos] = 4;
break;
case 'C':
cpoolArry[pos] = 5;
break;
case 'F':
cpoolArry[pos] = 6;
break;
case 'D':
cpoolArry[pos] = 7;
break;
case 'B':
cpoolArry[pos] = 8;
break;
case 'S':
cpoolArry[pos] = 9;
break;
case 'I':
cpoolArry[pos] = 10;
break;
case 'J':
cpoolArry[pos] = 11;
break;
default:; // all other types are missing...
}
}
// System.out.println(cpoolComments[pos]+" "+type+" "+cpoolArry[pos]);
continue;
}
cpoolArry[pos] = clinfo.classRefAddress;
cpoolComments[pos] = "Class: " + clname;
break;
case Constants.CONSTANT_InterfaceMethodref:
isInterface = true;
case Constants.CONSTANT_Methodref:
// find the class for this method
int mclidx;
if (isInterface) {
mclidx = ((ConstantInterfaceMethodref) co).getClassIndex();
} else {
mclidx = ((ConstantMethodref) co).getClassIndex();
}
ConstantClass mcl = (ConstantClass) cp.getConstant(mclidx);
// the method has "/" instead of ".", fix that
// now get the signature too...
String mclname = mcl.getBytes(cp).replace('/', '.');
int sigidx;
if (isInterface) {
sigidx = ((ConstantInterfaceMethodref) co).getNameAndTypeIndex();
} else {
sigidx = ((ConstantMethodref) co).getNameAndTypeIndex();
}
ConstantNameAndType signt = (ConstantNameAndType) cp.getConstant(sigidx);
String sigstr = signt.getName(cp) + signt.getSignature(cp);
// now find the address of the method struct!
JopClassInfo clinf = (JopClassInfo) appInfo.cliMap.get(mclname);
if (clinf == null) {
// probably a reference to Native - a class that
// is NOT present in the application.
// we could avoid this by not adding method refs to
// Native in our reduced cpool.
cpoolArry[pos] = 0;
cpoolComments[pos] = "static " + mclname + "." + sigstr;
break;
}
JopMethodInfo minf;
if (isInterface) {
minf = clinf.getITMethodInfo(sigstr);
} else {
minf = clinf.getVTMethodInfo(sigstr);
}
if (minf == null) {
System.out.println(
"Error: Method " + clinf.clazz.getClassName() + '.' + sigstr + " not found.");
System.out.println("Invoked by " + clazz.getClassName());
for (int xxx = 0; xxx < clinf.clvt.len; ++xxx) {
System.out.println(clinf.clvt.key[xxx]);
}
System.exit(1);
}
if (minf.getMethod().isStatic()
||
// <init> and privat methods are called with invokespecial
// which mapps in jvm.asm to invokestatic
minf.getMethod().isPrivate()
|| sigstr.charAt(0) == '<') {
// for static methods a direct pointer to the
// method struct
cpoolArry[pos] = minf.structAddress;
cpoolComments[pos] =
"static, special or private " + clinf.clazz.getClassName() + "." + minf.methodId;
} else {
// as Flavius correctly comments:
// TODO: CHANGE THIS TO A MORE CONSISTENT FORMAT...
// extract the objref! for some reason the microcode
// needs -1 here...weird
// that's for simple virtual methods
int vpos = minf.vtindex;
String comment = "virtual";
// TODO: is kind of redundant search as we've already
// searched the IT table with getVTMethodInfo()
// TODO: do we handle different interfaces with same
// method id correct? (see buildIT)
if (isInterface) {
comment = "interface";
for (int j = 0; j < listIT.size(); ++j) {
IT it = (IT) listIT.get(j);
if (it.key.equals(minf.methodId)) {
vpos = j;
break;
}
}
// offest in interface table
// index plus number of arguments (without this!)
cpoolArry[pos] = (vpos << 8) + (minf.margs - 1);
} else {
// offest in method table
// (index*2) plus number of arguments (without
// this!)
cpoolArry[pos] = (vpos * ClassStructConstants.METH_STR << 8) + (minf.margs - 1);
}
cpoolComments[pos] =
comment
+ " index: "
+ vpos
+ " args: "
+ minf.margs
+ " "
+ clinf.clazz.getClassName()
+ "."
+ minf.methodId;
}
break;
case Constants.CONSTANT_Fieldref:
throw new Error("Fieldref should not be used anymore");
// int fidx = ((ConstantFieldref) co).getClassIndex();
// ConstantClass fcl = (ConstantClass) cp.getConstant(fidx);
// String fclname = fcl.getBytes(cp).replace('/', '.');
// // got the class name
// sigidx = ((ConstantFieldref) co).getNameAndTypeIndex();
// signt = (ConstantNameAndType) cp.getConstant(sigidx);
// sigstr = signt.getName(cp) + signt.getSignature(cp);
// clinf = (JopClassInfo) appInfo.cliMap.get(fclname);
// int j;
// String comment = "";
// boolean found = false;
// while (!found) {
// for (j = 0; j < clinf.clft.len; ++j) {
// if (clinf.clft.key[j].equals(sigstr)) {
// found = true;
// if (clinf.clft.isStatic[j]) {
// comment = "static ";
// }
// // for static fields a direct pointer to the
// // static field
// cpoolArry[pos] = clinf.clft.idx[j];
// cpoolComments[pos] = comment
// + clinf.clazz.getClassName() + "."
// + sigstr;
// break;
// }
// }
// if (!found) {
// clinf = (JopClassInfo) clinf.superClass;
// if (clinf == null) {
// System.out.println("Error: field " + fclname
// + "." + sigstr + " not found!");
// break;
// }
// }
// }
// break;
default:
System.out.println("TODO: cpool@" + pos + " = orig_cp@" + i + " " + co);
cpoolComments[pos] = "Problem with: " + co;
}
}
}
}
/** 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);
}
}
