Here is the code for ImportsDumper using BCEL.
You will need BCEL library from http://bcel.sourceforge.net/
Is there a way in JDE to find the fully qualified
name of the class file for a given java buffer file name ?
May be a lisp guru can hook this up to the compilation-finish-hook
and update the imports list after succesful compile (!?)
Save it to BCELImportsDumper.java, compile and run...
//**/ import de.fub.bytecode.classfile.*; /*
import de.fub.bytecode.classfile.ClassParser;
import de.fub.bytecode.classfile.Constant;
import de.fub.bytecode.classfile.ConstantCP;
import de.fub.bytecode.classfile.ConstantClass;
import de.fub.bytecode.classfile.ConstantFieldref;
import de.fub.bytecode.classfile.ConstantInterfaceMethodref;
import de.fub.bytecode.classfile.ConstantMethodref;
import de.fub.bytecode.classfile.ConstantNameAndType;
import de.fub.bytecode.classfile.ConstantPool;
import de.fub.bytecode.classfile.ConstantUtf8;
import de.fub.bytecode.classfile.JavaClass;
import de.fub.bytecode.classfile.Utility;
//**/
//**/ import java.io.*; /*
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
//**/
//**/ import java.util.*; /*
import java.util.Iterator;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
//**/
/**
* A simple utility to dump imports.
* @author Sandip Chitale ([EMAIL PROTECTED])
*/
public class BCELImportsDumper {
public static void main(String args[]) {
if ( args.length == 0 ) {
usage();
System.exit(0);
}
dump(args);
// uncomment the following to make the program pause...
/*
try {
System.in.read();
} catch (Throwable t){
}
*/
System.exit(0);
}
public static void dump(String args[]) {
SortedSet normalizedFileList = new TreeSet();
SortedSet rootClassFileNameSet = new TreeSet();
// Build the rootClassFileNameSet
for (int i = 0; i < args.length; i++) {
if (!args[i].endsWith(".class")) {
System.out.println(args[i] + " does not look like a
.class file.
Skipping...");
continue;
}
File potentialClassFile = new File(args[i]);
if (!potentialClassFile.isFile() ) {
System.out.println(args[i] + " does not look like a
file. Skipping...");
continue;
}
String rootClassFileName = args[i];
if ( rootClassFileName.indexOf("$") != -1 ) {
rootClassFileName = rootClassFileName.substring(0,
rootClassFileName.indexOf("$")) + ".class";
}
rootClassFileNameSet.add(rootClassFileName);
}
// Now process each file in the Set
Iterator iter = rootClassFileNameSet.iterator();
while ( iter.hasNext() ) {
String aRootClassFileName = (String) iter.next();
dumpImports(aRootClassFileName);
}
}
private static SortedSet getCandidateFiles(File aDir, String
aRootClassFileName)
{
SortedSet candidateFiles = new TreeSet();
// Add the main file
candidateFiles.add(aRootClassFileName);
// Strip .class and add a $
aRootClassFileName = aRootClassFileName.substring(0,
aRootClassFileName.length() - 6);
// Now get the list of files in the dir
String fileInDir[] = aDir.list();
for (int i = 0; i < fileInDir.length; i++) {
String aFileName = aDir.getPath() + File.separatorChar +
fileInDir[i];
if ( !aFileName.endsWith(".class") ) {
continue;
}
File aFile = new File(aFileName);
if ( !aFile.isFile() ) {
continue;
}
if ( aFileName.startsWith(aRootClassFileName)) {
candidateFiles.add(aFileName);
}
}
return candidateFiles;
}
private static void usage()
{
System.out.println("Usage: java BCELImportsDumper <classfiles list>");
}
private static void dumpImports(String aRootClassFileName)
{
aRootClassFileName = new
File(aRootClassFileName).getAbsolutePath().replace('/',
File.separatorChar).replace('\\', File.separatorChar);
File aFile = new File(aRootClassFileName);
try {
aFile = aFile.getCanonicalFile();
} catch (IOException e) {
}
aRootClassFileName = aFile.getPath();
File aDir = new File(aRootClassFileName).getParentFile();
SortedSet candidateFiles = getCandidateFiles(aDir, aRootClassFileName);
System.out.println("// imports for " + aRootClassFileName);
SortedSet imports = new TreeSet();
Iterator iter = candidateFiles.iterator();
while ( iter.hasNext()) {
String fileName = (String) iter.next();
try {
ClassParser cp = new ClassParser(fileName);
JavaClass jc = cp.parse();
String jcClassName = jc.getClassName();
String jcPackageName = jc.getPackageName();
Constant[] constants =
jc.getConstantPool().getConstantPool();
for (int i = 0; i < constants.length; i++) {
if (constants[i] instanceof ConstantClass) {
addImport(jcClassName,
jcPackageName,
((ConstantUtf8)
constants[((ConstantClass)constants[i]).getNameIndex()]).getBytes().replace(
'/', '.')
, imports);
continue;
}
if (constants[i] instanceof ConstantFieldref) {
String fieldType = ((ConstantUtf8)
constants[
((ConstantNameAndType) constants[
((ConstantCP)constants[i]).getNameAndTypeIndex()
]).getSignatureIndex()
]).getBytes();
addImport(jcClassName,
jcPackageName,
Utility.methodSignatureReturnType(fieldType, false),
imports);
continue;
}
if (constants[i] instanceof ConstantMethodref
||
constants[i] instanceof
ConstantInterfaceMethodref
) {
String sig = ((ConstantUtf8) constants[
((ConstantNameAndType) constants[
((ConstantCP)constants[i]).getNameAndTypeIndex()
]).getSignatureIndex()
]).getBytes();
String[] args =
Utility.methodSignatureArgumentTypes(sig, false);
for (int j = 0; j < args.length; j++) {
addImport(jcClassName,
jcPackageName,
args[j],
imports);
}
addImport(jcClassName,
jcPackageName,
Utility.methodSignatureReturnType(sig, false),
imports);
}
}
} catch (ClassFormatError e) {
System.out.println("Illegal .class file. Could not
parse !" + e);
} catch (IOException ioe) {
System.out.println("Error opening class file. " + ioe);
}
}
boolean firstTime = true;
String prevPackageName = null;
Iterator importsIter = imports.iterator();
while (importsIter.hasNext()) {
String packageName = "";
String className = (String) importsIter.next();
if (className.indexOf('.') > 0) {
packageName = className.substring(0,
className.lastIndexOf('.'));
}
if (packageName.length() > 0 &&
!packageName.equals(prevPackageName)) {
if (firstTime) {
firstTime = false;
} else
{
System.out.println("//**/");
}
System.out.println("//**/ imp" + "ort " + packageName
+ ".*; /*");
}
System.out.println("imp" + "ort " + className + ";");
prevPackageName = packageName;
}
if (!firstTime) {
System.out.println("//**/");
}
}
private static void addImport(String jcClassName, String jcPackageName,
String importName, SortedSet imports)
{
if (importName.endsWith("[]")) {
while (importName.endsWith("[]")) {
importName = importName.substring(0,
importName.length() - 2);
}
}
if (importName.equals(jcClassName)) {
return;
}
int lastDot = importName.lastIndexOf(".");
if (lastDot != -1) {
String importPackageName = importName.substring(0, lastDot);
if (importPackageName.equals("java.lang")) {
return;
}
if (importPackageName.equals(jcPackageName)) {
return;
}
}
if (
importName.equals("boolean") ||
importName.equals("byte") ||
importName.equals("char") ||
importName.equals("double") ||
importName.equals("float") ||
importName.equals("int") ||
importName.equals("long") ||
importName.equals("short") ||
importName.equals("void")
) {
return;
}
imports.add(importName);
}
}
> I have developed some code which dumps the imports using
> slightly modified version of Chuck McManis's dumClass
> utilities.
>
> http://www.mcmanis.com/~cmcmanis/java/dump/index.html
>
> However BCEL http://sourceforge.net/projects/bcel/
> or IBM's Byte Code Toolkit could be used instead.
>
>
>
> HTH,
> sandip
>
> Sandip V. Chitale 150, Almaden Blvd
> work: (408) 535 1791 ext: 791 San Jose, CA, USA
> email: [EMAIL PROTECTED] 8th floor, Cube 831
> web: http://L064-5440.blazesoft.com
>
>
