/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.bcel.Constants;
import org.apache.bcel.Repository;
import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.Code;
import org.apache.bcel.classfile.Constant;
import org.apache.bcel.classfile.ConstantClass;
import org.apache.bcel.classfile.ConstantPool;
import org.apache.bcel.classfile.ConstantUtf8;
import org.apache.bcel.classfile.JavaClass;
import org.apache.bcel.classfile.Method;
/**
* Read class file(s) and display its contents. The command line usage is:
*
* <pre>java listclass [-constants] [-code] [-brief] [-dependencies] [-nocontents] [-recurse] class... [-exclude <list>]</pre>
* where
* <ul>
* <li>{@code -code} List byte code of methods</li>
* <li>{@code -brief} List byte codes briefly</li>
* <li>{@code -constants} Print constants table (constant pool)</li>
* <li>{@code -recurse} Usually intended to be used along with
* {@code -dependencies} When this flag is set, listclass will also print information
* about all classes which the target class depends on.</li>
*
* <li>{@code -dependencies} Setting this flag makes listclass print a list of all
* classes which the target class depends on. Generated from getting all
* CONSTANT_Class constants from the constant pool.</li>
*
* <li>{@code -exclude} All non-flag arguments after this flag are added to an
* 'exclusion list'. Target classes are compared with the members of the
* exclusion list. Any target class whose fully qualified name begins with a
* name in the exclusion list will not be analyzed/listed. This is meant
* primarily when using both {@code -recurse} to exclude java, javax, and sun classes,
* and is recommended as otherwise the output from {@code -recurse} gets quite long and
* most of it is not interesting. Note that {@code -exclude} prevents listing of
* classes, it does not prevent class names from being printed in the
* {@code -dependencies} list.</li>
* <li>{@code -nocontents} Do not print JavaClass.toString() for the class. I added
* this because sometimes I'm only interested in dependency information.</li>
* </ul>
* <p>Here's a couple examples of how I typically use listclass:<br>
* <pre>java listclass -code MyClass</pre>
* Print information about the class and the byte code of the methods
* <pre>java listclass -nocontents -dependencies MyClass</pre>
* Print a list of all classes which MyClass depends on.
* <pre>java listclass -nocontents -recurse MyClass -exclude java. javax. sun.</pre>
* Print a recursive listing of all classes which MyClass depends on. Do not
* analyze classes beginning with "java.", "javax.", or "sun.".
* <pre>java listclass -nocontents -dependencies -recurse MyClass -exclude java.javax. sun.</pre>
* Print a recursive listing of dependency information for MyClass and its
* dependents. Do not analyze classes beginning with "java.", "javax.", or "sun."
* </p>
*
* <a href="mailto:twheeler@objectspace.com">Thomas Wheeler</A>
* @version $Id$
*/
public class listclass {
boolean code;
boolean constants;
boolean verbose;
boolean classdep;
boolean nocontents;
boolean recurse;
Map<String, String> listedClasses;
List<String> exclude_name;
public static void main(String[] argv) {
List<String> file_name = new ArrayList<String>();
List<String> exclude_name = new ArrayList<String>();
boolean code = false;
boolean constants = false;
boolean verbose = true;
boolean classdep = false;
boolean nocontents = false;
boolean recurse = false;
boolean exclude = false;
String name;
// Parse command line arguments.
for (String arg : argv) {
if (arg.charAt(0) == '-') { // command line switch
if (arg.equals("-constants")) {
constants = true;
} else if (arg.equals("-code")) {
code = true;
} else if (arg.equals("-brief")) {
verbose = false;
} else if (arg.equals("-dependencies")) {
classdep = true;
} else if (arg.equals("-nocontents")) {
nocontents = true;
} else if (arg.equals("-recurse")) {
recurse = true;
} else if (arg.equals("-exclude")) {
exclude = true;
} else if (arg.equals("-help")) {
System.out.println("Usage: java listclass [-constants] [-code] [-brief] " +
"[-dependencies] [-nocontents] [-recurse] class... " +
"[-exclude <list>]\n" +
"-constants Print constants table (constant pool)\n" +
"-code Dump byte code of methods\n" +
"-brief Brief listing\n" +
"-dependencies Show class dependencies\n" +
"-nocontents Do not print field/method information\n" +
"-recurse Recurse into dependent classes\n" +
"-exclude <list> Do not list classes beginning with " +
"strings in <list>");
System.exit(0);
} else {
System.err.println("Unknown switch " + arg + " ignored.");
}
} else { // add file name to list
if (exclude) {
exclude_name.add(arg);
} else {
file_name.add(arg);
}
}
}
if (file_name.size() == 0) {
System.err.println("list: No input files specified");
} else {
listclass listClass = new listclass(code, constants, verbose, classdep,
nocontents, recurse, exclude_name);
for (int i = 0; i < file_name.size(); i++) {
name = file_name.get(i);
listClass.list(name);
}
}
}
public listclass(boolean code, boolean constants, boolean verbose, boolean classdep,
boolean nocontents, boolean recurse, List<String> exclude_name) {
this.code = code;
this.constants = constants;
this.verbose = verbose;
this.classdep = classdep;
this.nocontents = nocontents;
this.recurse = recurse;
this.listedClasses = new HashMap<String, String>();
this.exclude_name = exclude_name;
}
/**
* Print the given class on screen
*/
public void list(String name) {
try {
JavaClass java_class;
if ((listedClasses.get(name) != null) || name.startsWith("[")) {
return;
}
for (int idx = 0; idx < exclude_name.size(); idx++) {
if (name.startsWith(exclude_name.get(idx))) {
return;
}
}
if (name.endsWith(".class")) {
java_class = new ClassParser(name).parse(); // May throw IOException
} else {
java_class = Repository.lookupClass(name);
}
if (nocontents) {
System.out.println(java_class.getClassName());
} else {
System.out.println(java_class); // Dump the contents
}
if (constants) {
System.out.println(java_class.getConstantPool());
}
if (code) {
printCode(java_class.getMethods(), verbose);
}
if (classdep) {
printClassDependencies(java_class.getConstantPool());
}
listedClasses.put(name, name);
if (recurse) {
String[] dependencies = getClassDependencies(java_class.getConstantPool());
for (String dependency : dependencies) {
list(dependency);
}
}
} catch (IOException e) {
System.out.println("Error loading class " + name + " (" + e.getMessage() + ")");
} catch (Exception e) {
System.out.println("Error processing class " + name + " (" + e.getMessage() + ")");
}
}
/**
* Dump the list of classes this class is dependent on
*/
public static void printClassDependencies(ConstantPool pool) {
System.out.println("Dependencies:");
for (String name : getClassDependencies(pool)) {
System.out.println("\t" + name);
}
}
public static String[] getClassDependencies(ConstantPool pool) {
String[] tempArray = new String[pool.getLength()];
int size = 0;
StringBuilder buf = new StringBuilder();
for (int idx = 0; idx < pool.getLength(); idx++) {
Constant c = pool.getConstant(idx);
if (c != null && c.getTag() == Constants.CONSTANT_Class) {
ConstantUtf8 c1 = (ConstantUtf8) pool.getConstant(((ConstantClass) c).getNameIndex());
buf.setLength(0);
buf.append(c1.getBytes());
for (int n = 0; n < buf.length(); n++) {
if (buf.charAt(n) == '/') {
buf.setCharAt(n, '.');
}
}
tempArray[size++] = buf.toString();
}
}
String[] dependencies = new String[size];
System.arraycopy(tempArray, 0, dependencies, 0, size);
return dependencies;
}
/**
* Dump the disassembled code of all methods in the class.
*/
public static void printCode(Method[] methods, boolean verbose) {
for (Method method : methods) {
System.out.println(method);
Code code = method.getCode();
if (code != null) {
System.out.println(code.toString(verbose));
}
}
}
}