/*
* Copyright (c) 2002, 2005, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package sun.tools.javap;
import java.util.*;
import java.io.*;
import static sun.tools.javap.RuntimeConstants.*;
/**
* Program to print information about class files
*
* @author Sucheta Dambalkar
*/
public class JavapPrinter {
JavapEnvironment env;
ClassData cls;
byte[] code;
String lP= "";
PrintWriter out;
public JavapPrinter(InputStream cname, PrintWriter out, JavapEnvironment env){
this.out = out;
this.cls = new ClassData(cname);
this.env = env;
}
/**
* Entry point to print class file information.
*/
public void print(){
printclassHeader();
printfields();
printMethods();
printend();
}
/**
* Print a description of the class (not members).
*/
public void printclassHeader(){
String srcName="";
if ((srcName = cls.getSourceName()) != "null") // requires debug info
out.println("Compiled from " + javaclassname(srcName));
if(cls.isInterface()) {
// The only useful access modifier of an interface is
// public; interfaces are always marked as abstract and
// cannot be final.
out.print((cls.isPublic()?"public ":"") +
"interface "+ javaclassname(cls.getClassName()));
}
else if(cls.isClass()) {
String []accflags = cls.getAccess();
printAccess(accflags);
out.print("class "+ javaclassname(cls.getClassName()));
if(cls.getSuperClassName() != null){
out.print(" extends " + javaclassname(cls.getSuperClassName()));
}
}
String []interfacelist = cls.getSuperInterfaces();
if(interfacelist.length > 0){
if(cls.isClass()) {
out.print(" implements ");
}
else if(cls.isInterface()){
out.print(" extends ");
}
for(int j = 0; j < interfacelist.length; j++){
out.print(javaclassname(interfacelist[j]));
if((j+1) < interfacelist.length) {
out.print(",");
}
}
}
// Print class attribute information.
if((env.showallAttr) || (env.showVerbose)){
printClassAttributes();
}
// Print verbose output.
if(env.showVerbose){
printverbosecls();
}
out.println("{");
}
/**
* Print verbose output.
*/
public void printverbosecls(){
out.println(" minor version: "+cls.getMinor_version());
out.println(" major version: "+cls.getMajor_version());
out.println(" Constant pool:");
printcp();
env.showallAttr = true;
}
/**
* Print class attribute information.
*/
public void printClassAttributes(){
out.println();
AttrData[] clsattrs = cls.getAttributes();
for(int i = 0; i < clsattrs.length; i++){
String clsattrname = clsattrs[i].getAttrName();
if(clsattrname.equals("SourceFile")){
out.println(" SourceFile: "+ cls.getSourceName());
}else if(clsattrname.equals("InnerClasses")){
printInnerClasses();
}else {
printAttrData(clsattrs[i]);
}
}
}
/**
* Print the fields
*/
public void printfields(){
FieldData[] fields = cls.getFields();
for(int f = 0; f < fields.length; f++){
String[] accflags = fields[f].getAccess();
if(checkAccess(accflags)){
if(!(env. showLineAndLocal || env.showDisassembled || env.showVerbose
|| env.showInternalSigs || env.showallAttr)){
out.print(" ");
}
printAccess(accflags);
out.println(fields[f].getType()+" " +fields[f].getName()+";");
if (env.showInternalSigs) {
out.println(" Signature: " + (fields[f].getInternalSig()));
}
// print field attribute information.
if (env.showallAttr){
printFieldAttributes(fields[f]);
}
if((env.showDisassembled) || (env.showLineAndLocal)){
out.println();
}
}
}
}
/* print field attribute information. */
public void printFieldAttributes(FieldData field){
Vector fieldattrs = field.getAttributes();
for(int j = 0; j < fieldattrs.size(); j++){
String fieldattrname = ((AttrData)fieldattrs.elementAt(j)).getAttrName();
if(fieldattrname.equals("ConstantValue")){
printConstantValue(field);
}else if (fieldattrname.equals("Deprecated")){
out.println("Deprecated: "+ field.isDeprecated());
}else if (fieldattrname.equals("Synthetic")){
out.println(" Synthetic: "+ field.isSynthetic());
}else {
printAttrData((AttrData)fieldattrs.elementAt(j));
}
}
out.println();
}
/**
* Print the methods
*/
public void printMethods(){
MethodData[] methods = cls.getMethods();
for(int m = 0; m < methods.length; m++){
String[] accflags = methods[m].getAccess();
if(checkAccess(accflags)){
if(!(env. showLineAndLocal || env.showDisassembled || env.showVerbose
|| env.showInternalSigs || env.showallAttr)){
out.print(" ");
}
printMethodSignature(methods[m], accflags);
printExceptions(methods[m]);
out.println(";");
// Print internal signature of method.
if (env.showInternalSigs){
out.println(" Signature: " + (methods[m].getInternalSig()));
}
//Print disassembled code.
if(env.showDisassembled && ! env.showallAttr) {
printcodeSequence(methods[m]);
printExceptionTable(methods[m]);
out.println();
}
// Print line and local variable attribute information.
if (env.showLineAndLocal) {
printLineNumTable(methods[m]);
printLocVarTable(methods[m]);
out.println();
}
// Print method attribute information.
if (env.showallAttr){
printMethodAttributes(methods[m]);
}
}
}
}
/**
* Print method signature.
*/
public void printMethodSignature(MethodData method, String[] accflags){
printAccess(accflags);
if((method.getName()).equals("<init>")){
out.print(javaclassname(cls.getClassName()));
out.print(method.getParameters());
}else if((method.getName()).equals("<clinit>")){
out.print("{}");
}else{
out.print(method.getReturnType()+" ");
out.print(method.getName());
out.print(method.getParameters());
}
}
/**
* print method attribute information.
*/
public void printMethodAttributes(MethodData method){
Vector methodattrs = method.getAttributes();
Vector codeattrs = method.getCodeAttributes();
for(int k = 0; k < methodattrs.size(); k++){
String methodattrname = ((AttrData)methodattrs.elementAt(k)).getAttrName();
if(methodattrname.equals("Code")){
printcodeSequence(method);
printExceptionTable(method);
for(int c = 0; c < codeattrs.size(); c++){
String codeattrname = ((AttrData)codeattrs.elementAt(c)).getAttrName();
if(codeattrname.equals("LineNumberTable")){
printLineNumTable(method);
}else if(codeattrname.equals("LocalVariableTable")){
printLocVarTable(method);
}else if(codeattrname.equals("StackMapTable")) {
// Java SE JSR 202 stack map tables
printStackMapTable(method);
}else if(codeattrname.equals("StackMap")) {
// Java ME CLDC stack maps
printStackMap(method);
} else {
printAttrData((AttrData)codeattrs.elementAt(c));
}
}
}else if(methodattrname.equals("Exceptions")){
out.println(" Exceptions: ");
printExceptions(method);
}else if (methodattrname.equals("Deprecated")){
out.println(" Deprecated: "+ method.isDeprecated());
}else if (methodattrname.equals("Synthetic")){
out.println(" Synthetic: "+ method.isSynthetic());
}else {
printAttrData((AttrData)methodattrs.elementAt(k));
}
}
out.println();
}
/**
* Print exceptions.
*/
public void printExceptions(MethodData method){
int []exc_index_table = method.get_exc_index_table();
if (exc_index_table != null) {
if(!(env. showLineAndLocal || env.showDisassembled || env.showVerbose
|| env.showInternalSigs || env.showallAttr)){
out.print(" ");
}
out.print(" throws ");
int k;
int l = exc_index_table.length;
for (k=0; k<l; k++) {
out.print(javaclassname(cls.getClassName(exc_index_table[k])));
if (k<l-1) out.print(", ");
}
}
}
/**
* Print code sequence.
*/
public void printcodeSequence(MethodData method){
code = method.getCode();
if(code != null){
out.println(" Code:");
if(env.showVerbose){
printVerboseHeader(method);
}
for (int pc=0; pc < code.length; ) {
out.print(" "+pc+":\t");
pc=pc+printInstr(pc);
out.println();
}
}
}
/**
* Print instructions.
*/
public int printInstr(int pc){
int opcode = getUbyte(pc);
int opcode2;
String mnem;
switch (opcode) {
case opc_nonpriv:
case opc_priv:
opcode2 = getUbyte(pc+1);
mnem=Tables.opcName((opcode<<8)+opcode2);
if (mnem==null)
// assume all (even nonexistent) priv and nonpriv instructions
// are 2 bytes long
mnem=Tables.opcName(opcode)+" "+opcode2;
out.print(mnem);
return 2;
case opc_wide: {
opcode2 = getUbyte(pc+1);
mnem=Tables.opcName((opcode<<8)+opcode2);
if (mnem==null) {
// nonexistent opcode - but we have to print something
out.print("bytecode "+opcode);
return 1;
}
out.print(mnem+" "+getUShort(pc+2));
if (opcode2==opc_iinc) {
out.print(", "+getShort(pc+4));
return 6;
}
return 4;
}
}
mnem=Tables.opcName(opcode);
if (mnem==null) {
// nonexistent opcode - but we have to print something
out.print("bytecode "+opcode);
return 1;
}
if (opcode>opc_jsr_w) {
// pseudo opcodes should be printed as bytecodes
out.print("bytecode "+opcode);
return 1;
}
out.print(Tables.opcName(opcode));
switch (opcode) {
case opc_aload: case opc_astore:
case opc_fload: case opc_fstore:
case opc_iload: case opc_istore:
case opc_lload: case opc_lstore:
case opc_dload: case opc_dstore:
case opc_ret:
out.print("\t"+getUbyte(pc+1));
return 2;
case opc_iinc:
out.print("\t"+getUbyte(pc+1)+", "+getbyte(pc+2));
return 3;
case opc_tableswitch:{
int tb=align(pc+1);
int default_skip = getInt(tb); /* default skip pamount */
int low = getInt(tb+4);
int high = getInt(tb+8);
int count = high - low;
out.print("{ //"+low+" to "+high);
for (int i = 0; i <= count; i++)
out.print( "\n\t\t" + (i+low) + ": "+lP+(pc+getInt(tb+12+4*i))+";");
out.print("\n\t\tdefault: "+lP+(default_skip + pc) + " }");
return tb-pc+16+count*4;
}
case opc_lookupswitch:{
int tb=align(pc+1);
int default_skip = getInt(tb);
int npairs = getInt(tb+4);
out.print("{ //"+npairs);
for (int i = 1; i <= npairs; i++)
out.print("\n\t\t"+getInt(tb+i*8)
+": "+lP+(pc+getInt(tb+4+i*8))+";"
);
out.print("\n\t\tdefault: "+lP+(default_skip + pc) + " }");
return tb-pc+(npairs+1)*8;
}
case opc_newarray:
int type=getUbyte(pc+1);
switch (type) {
case T_BOOLEAN:out.print(" boolean");break;
case T_BYTE: out.print(" byte"); break;
case T_CHAR: out.print(" char"); break;
case T_SHORT: out.print(" short"); break;
case T_INT: out.print(" int"); break;
case T_LONG: out.print(" long"); break;
case T_FLOAT: out.print(" float"); break;
case T_DOUBLE: out.print(" double"); break;
case T_CLASS: out.print(" class"); break;
default: out.print(" BOGUS TYPE:"+type);
}
return 2;
case opc_anewarray: {
int index = getUShort(pc+1);
out.print("\t#"+index+"; //");
PrintConstant(index);
return 3;
}
case opc_sipush:
out.print("\t"+getShort(pc+1));
return 3;
case opc_bipush:
out.print("\t"+getbyte(pc+1));
return 2;
case opc_ldc: {
int index = getUbyte(pc+1);
out.print("\t#"+index+"; //");
PrintConstant(index);
return 2;
}
case opc_ldc_w: case opc_ldc2_w:
case opc_instanceof: case opc_checkcast:
case opc_new:
case opc_putstatic: case opc_getstatic:
case opc_putfield: case opc_getfield:
case opc_invokevirtual:
case opc_invokespecial:
case opc_invokestatic: {
int index = getUShort(pc+1);
out.print("\t#"+index+"; //");
PrintConstant(index);
return 3;
}
case opc_invokeinterface: {
int index = getUShort(pc+1), nargs=getUbyte(pc+3);
out.print("\t#"+index+", "+nargs+"; //");
PrintConstant(index);
return 5;
}
case opc_multianewarray: {
int index = getUShort(pc+1), dimensions=getUbyte(pc+3);
out.print("\t#"+index+", "+dimensions+"; //");
PrintConstant(index);
return 4;
}
case opc_jsr: case opc_goto:
case opc_ifeq: case opc_ifge: case opc_ifgt:
case opc_ifle: case opc_iflt: case opc_ifne:
case opc_if_icmpeq: case opc_if_icmpne: case opc_if_icmpge:
case opc_if_icmpgt: case opc_if_icmple: case opc_if_icmplt:
case opc_if_acmpeq: case opc_if_acmpne:
case opc_ifnull: case opc_ifnonnull:
out.print("\t"+lP+(pc + getShort(pc+1)) );
return 3;
case opc_jsr_w:
case opc_goto_w:
out.print("\t"+lP+(pc + getInt(pc+1)));
return 5;
default:
return 1;
}
}
/**
* Print code attribute details.
*/
public void printVerboseHeader(MethodData method) {
int argCount = method.getArgumentlength();
if (!method.isStatic())
++argCount; // for 'this'
out.println(" Stack=" + method.getMaxStack()
+ ", Locals=" + method.getMaxLocals()
+ ", Args_size=" + argCount);
}
/**
* Print the exception table for this method code
*/
void printExceptionTable(MethodData method){//throws IOException
Vector exception_table = method.getexception_table();
if (exception_table.size() > 0) {
out.println(" Exception table:");
out.println(" from to target type");
for (int idx = 0; idx < exception_table.size(); ++idx) {
TrapData handler = (TrapData)exception_table.elementAt(idx);
printFixedWidthInt(handler.start_pc, 6);
printFixedWidthInt(handler.end_pc, 6);
printFixedWidthInt(handler.handler_pc, 6);
out.print(" ");
int catch_cpx = handler.catch_cpx;
if (catch_cpx == 0) {
out.println("any");
}else {
out.print("Class ");
out.println(cls.getClassName(catch_cpx));
out.println("");
}
}
}
}
/**
* Print LineNumberTable attribute information.
*/
public void printLineNumTable(MethodData method) {
int numlines = method.getnumlines();
Vector lin_num_tb = method.getlin_num_tb();
if( lin_num_tb.size() > 0){
out.println(" LineNumberTable: ");
for (int i=0; i<numlines; i++) {
LineNumData linnumtb_entry=(LineNumData)lin_num_tb.elementAt(i);
out.println(" line " + linnumtb_entry.line_number + ": "
+ linnumtb_entry.start_pc);
}
}
out.println();
}
/**
* Print LocalVariableTable attribute information.
*/
public void printLocVarTable(MethodData method){
int siz = method.getloc_var_tbsize();
if(siz > 0){
out.println(" LocalVariableTable: ");
out.print(" ");
out.println("Start Length Slot Name Signature");
}
Vector loc_var_tb = method.getloc_var_tb();
for (int i=0; i<siz; i++) {
LocVarData entry=(LocVarData)loc_var_tb.elementAt(i);
out.println(" "+entry.start_pc+" "+entry.length+" "+
entry.slot+" "+cls.StringValue(entry.name_cpx) +
" "+cls.StringValue(entry.sig_cpx));
}
out.println();
}
/**
* Print StackMap attribute information.
*/
public void printStackMap(MethodData method) {
StackMapData[] stack_map_tb = method.getStackMap();
int number_of_entries = stack_map_tb.length;
if (number_of_entries > 0) {
out.println(" StackMap: number_of_entries = " + number_of_entries);
for (StackMapData frame : stack_map_tb) {
frame.print(this);
}
}
out.println();
}
/**
* Print StackMapTable attribute information.
*/
public void printStackMapTable(MethodData method) {
StackMapTableData[] stack_map_tb = method.getStackMapTable();
int number_of_entries = stack_map_tb.length;
if (number_of_entries > 0) {
out.println(" StackMapTable: number_of_entries = " + number_of_entries);
for (StackMapTableData frame : stack_map_tb) {
frame.print(this);
}
}
out.println();
}
void printMap(String name, int[] map) {
out.print(name);
for (int i=0; i<map.length; i++) {
int fulltype = map[i];
int type = fulltype & 0xFF;
int argument = fulltype >> 8;
switch (type) {
case ITEM_Object:
out.print(" ");
PrintConstant(argument);
break;
case ITEM_NewObject:
out.print(" " + Tables.mapTypeName(type));
out.print(" " + argument);
break;
default:
out.print(" " + Tables.mapTypeName(type));
}
out.print( (i==(map.length-1)? ' ' : ','));
}
out.println("]");
}
/**
* Print ConstantValue attribute information.
*/
public void printConstantValue(FieldData field){
out.print(" Constant value: ");
int cpx = (field.getConstantValueIndex());
byte tag=0;
try {
tag=cls.getTag(cpx);
} catch (IndexOutOfBoundsException e) {
out.print("Error:");
return;
}
switch (tag) {
case CONSTANT_METHOD:
case CONSTANT_INTERFACEMETHOD:
case CONSTANT_FIELD: {
CPX2 x = (CPX2)(cls.getCpoolEntry(cpx));
if (x.cpx1 == cls.getthis_cpx()) {
// don't print class part for local references
cpx=x.cpx2;
}
}
}
out.print(cls.TagString(tag)+" "+ cls.StringValue(cpx));
}
/**
* Print InnerClass attribute information.
*/
public void printInnerClasses(){//throws ioexception
InnerClassData[] innerClasses = cls.getInnerClasses();
if(innerClasses != null){
if(innerClasses.length > 0){
out.print(" ");
out.println("InnerClass: ");
for(int i = 0 ; i < innerClasses.length; i++){
out.print(" ");
//access
String[] accflags = innerClasses[i].getAccess();
if(checkAccess(accflags)){
printAccess(accflags);
if (innerClasses[i].inner_name_index!=0) {
out.print("#"+innerClasses[i].inner_name_index+"= ");
}
out.print("#"+innerClasses[i].inner_class_info_index);
if (innerClasses[i].outer_class_info_index!=0) {
out.print(" of #"+innerClasses[i].outer_class_info_index);
}
out.print("; //");
if (innerClasses[i].inner_name_index!=0) {
out.print(cls.getName(innerClasses[i].inner_name_index)+"=");
}
PrintConstant(innerClasses[i].inner_class_info_index);
if (innerClasses[i].outer_class_info_index!=0) {
out.print(" of ");
PrintConstant(innerClasses[i].outer_class_info_index);
}
out.println();
}
}
}
}
}
/**
* Print constant pool information.
*/
public void printcp(){
int cpx = 1 ;
while (cpx < cls.getCpoolCount()) {
out.print("const #"+cpx+" = ");
cpx+=PrintlnConstantEntry(cpx);
}
out.println();
}
/**
* Print constant pool entry information.
*/
public int PrintlnConstantEntry(int cpx) {
int size=1;
byte tag=0;
try {
tag=cls.getTag(cpx);
} catch (IndexOutOfBoundsException e) {
out.println(" <Incorrect CP index>");
return 1;
}
out.print(cls.StringTag(cpx)+"\t");
Object x=cls.getCpoolEntryobj(cpx);
if (x==null) {
switch (tag) {
case CONSTANT_LONG:
case CONSTANT_DOUBLE:
size=2;
}
out.println("null;");
return size;
}
String str=cls.StringValue(cpx);
switch (tag) {
case CONSTANT_CLASS:
case CONSTANT_STRING:
out.println("#"+(((CPX)x).cpx)+";\t// "+str);
break;
case CONSTANT_FIELD:
case CONSTANT_METHOD:
case CONSTANT_INTERFACEMETHOD:
out.println("#"+((CPX2)x).cpx1+".#"+((CPX2)x).cpx2+";\t// "+str);
break;
case CONSTANT_NAMEANDTYPE:
out.println("#"+((CPX2)x).cpx1+":#"+((CPX2)x).cpx2+";// "+str);
break;
case CONSTANT_LONG:
case CONSTANT_DOUBLE:
size=2;
default:
out.println(str+";");
}
return size;
}
/**
* Checks access of class, field or method.
*/
public boolean checkAccess(String accflags[]){
boolean ispublic = false;
boolean isprotected = false;
boolean isprivate = false;
boolean ispackage = false;
for(int i= 0; i < accflags.length; i++){
if(accflags[i].equals("public")) ispublic = true;
else if (accflags[i].equals("protected")) isprotected = true;
else if (accflags[i].equals("private")) isprivate = true;
}
if(!(ispublic || isprotected || isprivate)) ispackage = true;
if((env.showAccess == env.PUBLIC) && (isprotected || isprivate || ispackage)) return false;
else if((env.showAccess == env.PROTECTED) && (isprivate || ispackage)) return false;
else if((env.showAccess == env.PACKAGE) && (isprivate)) return false;
else return true;
}
/**
* Prints access of class, field or method.
*/
public void printAccess(String []accflags){
for(int j = 0; j < accflags.length; j++){
out.print(accflags[j]+" ");
}
}
/**
* Print an integer so that it takes 'length' characters in
* the output. Temporary until formatting code is stable.
*/
public void printFixedWidthInt(long x, int length) {
CharArrayWriter baStream = new CharArrayWriter();
PrintWriter pStream = new PrintWriter(baStream);
pStream.print(x);
String str = baStream.toString();
for (int cnt = length - str.length(); cnt > 0; --cnt)
out.print(' ');
out.print(str);
}
protected int getbyte (int pc) {
return code[pc];
}
protected int getUbyte (int pc) {
return code[pc]&0xFF;
}
int getShort (int pc) {
return (code[pc]<<8) | (code[pc+1]&0xFF);
}
int getUShort (int pc) {
return ((code[pc]<<8) | (code[pc+1]&0xFF))&0xFFFF;
}
protected int getInt (int pc) {
return (getShort(pc)<<16) | (getShort(pc+2)&0xFFFF);
}
/**
* Print constant value at that index.
*/
void PrintConstant(int cpx) {
if (cpx==0) {
out.print("#0");
return;
}
byte tag=0;
try {
tag=cls.getTag(cpx);
} catch (IndexOutOfBoundsException e) {
out.print("#"+cpx);
return;
}
switch (tag) {
case CONSTANT_METHOD:
case CONSTANT_INTERFACEMETHOD:
case CONSTANT_FIELD: {
// CPX2 x=(CPX2)(cpool[cpx]);
CPX2 x = (CPX2)(cls.getCpoolEntry(cpx));
if (x.cpx1 == cls.getthis_cpx()) {
// don't print class part for local references
cpx=x.cpx2;
}
}
}
out.print(cls.TagString(tag)+" "+ cls.StringValue(cpx));
}
protected static int align (int n) {
return (n+3) & ~3 ;
}
public void printend(){
out.println("}");
out.println();
}
public String javaclassname(String name){
return name.replace('/','.');
}
/**
* Print attribute data in hex.
*/
public void printAttrData(AttrData attr){
byte []data = attr.getData();
int i = 0;
int j = 0;
out.print(" "+attr.getAttrName()+": ");
out.println("length = " + cls.toHex(attr.datalen));
out.print(" ");
while (i < data.length){
String databytestring = cls.toHex(data[i]);
if(databytestring.equals("0x")) out.print("00");
else if(databytestring.substring(2).length() == 1){
out.print("0"+databytestring.substring(2));
} else{
out.print(databytestring.substring(2));
}
j++;
if(j == 16) {
out.println();
out.print(" ");
j = 0;
}
else out.print(" ");
i++;
}
out.println();
}
}