String adjustVarargs(AccessFlags flags, String params) {
if (flags.is(ACC_VARARGS) && !options.compat) {
int i = params.lastIndexOf("[]");
if (i > 0) return params.substring(0, i) + "..." + params.substring(i + 2);
}
return params;
}
protected void writeField(Field f) {
if (!options.checkAccess(f.access_flags)) return;
AccessFlags flags = f.access_flags;
writeModifiers(flags.getFieldModifiers());
Signature_attribute sigAttr = getSignature(f.attributes);
if (sigAttr == null) print(getFieldType(f.descriptor));
else {
try {
Type t = sigAttr.getParsedSignature().getType(constant_pool);
print(t);
} catch (ConstantPoolException e) {
// report error?
// fall back on non-generic descriptor
print(getFieldType(f.descriptor));
}
}
print(" ");
print(getFieldName(f));
if (options.showConstants && !options.compat) { // BUG 4111861 print static final field contents
Attribute a = f.attributes.get(Attribute.ConstantValue);
if (a instanceof ConstantValue_attribute) {
print(" = ");
ConstantValue_attribute cv = (ConstantValue_attribute) a;
print(getConstantValue(f.descriptor, cv.constantvalue_index));
}
}
print(";");
println();
indent(+1);
if (options.showInternalSignatures) println("Signature: " + getValue(f.descriptor));
if (options.verbose && !options.compat) writeList("flags: ", flags.getFieldFlags(), NEWLINE);
if (options.showAllAttrs) {
for (Attribute attr : f.attributes) attrWriter.write(f, attr, constant_pool);
println();
}
indent(-1);
if (options.showDisassembled || options.showLineAndLocalVariableTables) println();
}
protected void writeMethod(Method m) {
if (!options.checkAccess(m.access_flags)) return;
method = m;
AccessFlags flags = m.access_flags;
Descriptor d;
Type.MethodType methodType;
List<? extends Type> methodExceptions;
Signature_attribute sigAttr = getSignature(m.attributes);
if (sigAttr == null) {
d = m.descriptor;
methodType = null;
methodExceptions = null;
} else {
Signature methodSig = sigAttr.getParsedSignature();
d = methodSig;
try {
methodType = (Type.MethodType) methodSig.getType(constant_pool);
methodExceptions = methodType.throwsTypes;
if (methodExceptions != null && methodExceptions.size() == 0) methodExceptions = null;
} catch (ConstantPoolException e) {
// report error?
// fall back on standard descriptor
methodType = null;
methodExceptions = null;
}
}
writeModifiers(flags.getMethodModifiers());
if (methodType != null) {
writeListIfNotEmpty("<", methodType.typeParamTypes, "> ");
}
if (getName(m).equals("<init>")) {
print(getJavaName(classFile));
print(getParameterTypes(d, flags));
} else if (getName(m).equals("<clinit>")) {
print("{}");
} else {
print(getReturnType(d));
print(" ");
print(getName(m));
print(getParameterTypes(d, flags));
}
Attribute e_attr = m.attributes.get(Attribute.Exceptions);
if (e_attr != null) { // if there are generic exceptions, there must be erased exceptions
if (e_attr instanceof Exceptions_attribute) {
Exceptions_attribute exceptions = (Exceptions_attribute) e_attr;
print(" throws ");
if (methodExceptions != null) { // use generic list if available
writeList("", methodExceptions, "");
} else {
for (int i = 0; i < exceptions.number_of_exceptions; i++) {
if (i > 0) print(", ");
print(getJavaException(exceptions, i));
}
}
} else {
report("Unexpected or invalid value for Exceptions attribute");
}
}
println(";");
indent(+1);
if (options.showInternalSignatures) {
println("Signature: " + getValue(m.descriptor));
}
if (options.verbose && !options.compat) {
writeList("flags: ", flags.getMethodFlags(), NEWLINE);
}
Code_attribute code = null;
Attribute c_attr = m.attributes.get(Attribute.Code);
if (c_attr != null) {
if (c_attr instanceof Code_attribute) code = (Code_attribute) c_attr;
else report("Unexpected or invalid value for Code attribute");
}
if (options.showDisassembled && !options.showAllAttrs) {
if (code != null) {
println("Code:");
codeWriter.writeInstrs(code);
codeWriter.writeExceptionTable(code);
}
}
if (options.showLineAndLocalVariableTables) {
if (code != null) {
attrWriter.write(code, code.attributes.get(Attribute.LineNumberTable), constant_pool);
attrWriter.write(code, code.attributes.get(Attribute.LocalVariableTable), constant_pool);
}
}
if (options.showAllAttrs) {
Attribute[] attrs = m.attributes.attrs;
for (Attribute attr : attrs) attrWriter.write(m, attr, constant_pool);
}
indent(-1);
// set pendingNewline to write a newline before the next method (if any)
// if a separator is desired
setPendingNewline(
options.showDisassembled
|| options.showAllAttrs
|| options.showInternalSignatures
|| options.showLineAndLocalVariableTables
|| options.verbose);
}
public void write(ClassFile cf) {
setClassFile(cf);
if ((options.sysInfo || options.verbose) && !options.compat) {
if (uri != null) {
if (uri.getScheme().equals("file")) println("Classfile " + uri.getPath());
else println("Classfile " + uri);
}
indent(+1);
if (lastModified != -1) {
Date lm = new Date(lastModified);
DateFormat df = DateFormat.getDateInstance();
if (size > 0) {
println("Last modified " + df.format(lm) + "; size " + size + " bytes");
} else {
println("Last modified " + df.format(lm));
}
} else if (size > 0) {
println("Size " + size + " bytes");
}
if (digestName != null && digest != null) {
StringBuilder sb = new StringBuilder();
for (byte b : digest) sb.append(String.format("%02x", b));
println(digestName + " checksum " + sb);
}
}
Attribute sfa = cf.getAttribute(Attribute.SourceFile);
if (sfa instanceof SourceFile_attribute) {
println("Compiled from \"" + getSourceFile((SourceFile_attribute) sfa) + "\"");
}
if ((options.sysInfo || options.verbose) && !options.compat) {
indent(-1);
}
String name = getJavaName(classFile);
AccessFlags flags = cf.access_flags;
writeModifiers(flags.getClassModifiers());
if (classFile.isClass()) print("class ");
else if (classFile.isInterface()) print("interface ");
print(name);
Signature_attribute sigAttr = getSignature(cf.attributes);
if (sigAttr == null) {
// use info from class file header
if (classFile.isClass() && classFile.super_class != 0) {
String sn = getJavaSuperclassName(cf);
print(" extends ");
print(sn);
}
for (int i = 0; i < classFile.interfaces.length; i++) {
print(i == 0 ? (classFile.isClass() ? " implements " : " extends ") : ",");
print(getJavaInterfaceName(classFile, i));
}
} else {
try {
Type t = sigAttr.getParsedSignature().getType(constant_pool);
// The signature parser cannot disambiguate between a
// FieldType and a ClassSignatureType that only contains a superclass type.
if (t instanceof Type.ClassSigType) print(getJavaName(t.toString()));
else {
print(" extends ");
print(getJavaName(t.toString()));
}
} catch (ConstantPoolException e) {
print(report(e));
}
}
if (options.verbose) {
println();
indent(+1);
attrWriter.write(cf, cf.attributes, constant_pool);
println("minor version: " + cf.minor_version);
println("major version: " + cf.major_version);
if (!options.compat) writeList("flags: ", flags.getClassFlags(), NEWLINE);
indent(-1);
constantWriter.writeConstantPool();
} else {
print(" ");
}
println("{");
indent(+1);
writeFields();
writeMethods();
indent(-1);
println("}");
}
