/* gnu.classpath.tools.gjdoc.RootDocImpl
Copyright (C) 2001, 2007 Free Software Foundation, Inc.
This file is part of GNU Classpath.
GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.
GNU Classpath 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 for more details.
You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING. If not, write to the
Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
package gnu.classpath.tools.gjdoc;
import com.sun.javadoc.*;
import java.util.*;
import java.io.*;
import java.lang.reflect.*;
public class RootDocImpl
extends DocImpl
implements GjdocRootDoc {
private ErrorReporter reporter = new ErrorReporter();
private RandomAccessFile rawCommentCache;
/**
* All options and their corresponding values which are not recognized
* by Gjdoc. These are passed to the Doclet as "custom options".
* Each element in this array is again a String array, with the
* option name as first element (including prefix dash) and possible
* option values as following elements.
*/
private String[][] customOptionArr;
/**
* All source files explicitly specified on the command line.
*
* @contains File
*/
private List specifiedSourceFiles = new LinkedList();
/**
* The names of all packages explicitly specified on the
* command line.
*
* @contains String
*/
private Set specifiedPackageNames = new LinkedHashSet();
/**
* Stores all classes specified by the user: those given by
* individual class names on the command line, and those
* contained in the packages given on the command line.
*
* @contains ClassDocImpl
*/
private List classesList = new LinkedList(); //new LinkedList();
/**
* Stores all classes loaded in the course of preparing
* the documentation data. Maps the fully qualified name
* of a class to its ClassDocImpl representation.
*
* @contains String->ClassDocImpl
*/
private Map classDocMap = new HashMap();
/**
* Stores all packages loaded in the course of preparing
* the documentation data. Maps the package name
* to its PackageDocImpl representation.
*
* @contains String->PackageDocImpl
*/
private Map packageDocMap = new HashMap();
/**
* All classes specified by the user, both those explicitly
* individually specified on the command line and those contained
* in packages specified on the command line (as Array for quick
* retrieval by Doclet). This is created from classesList after
* all classes have been loaded.
*/
private ClassDocImpl[] classes;
/**
* All classes which were individually specified on the command
* line (as Array for quick retrieval by Doclet). This is created
* from specifiedClassNames after all classes have been loaded.
*/
private List specifiedClasses;
/**
* All packages which were specified on the command line (as Array
* for quick retrieval by Doclet). This is created from
* specifiedPackageNames after all classes have been loaded.
*/
private Set specifiedPackages;
/**
* Temporarily stores a list of classes which are referenced
* by classes already loaded and which still have to be
* resolved.
*/
private List scheduledClasses=new LinkedList();
private List sourcePath;
private String sourceEncoding;
private Parser parser = new Parser();
private Set unlocatableReportedSet = new HashSet();
private Set inaccessibleReportedSet = new HashSet();
//--------------------------------------------------------------------------
//
// Implementation of RootDoc interface
//
//--------------------------------------------------------------------------
/**
* Return classes and interfaces to be documented.
*/
public ClassDoc[] classes() { return classes; }
/**
* Return a ClassDoc object for the specified class/interface
* name.
*
* @return a ClassDoc object describing the given class, or
* <code>null</code> if no corresponding ClassDoc object
* has been constructed.
*/
public ClassDoc classNamed(String qualifiedName) {
return (ClassDoc)classDocMap.get(qualifiedName);
}
/**
* Return an xxx
*/
public String[][] options() { return customOptionArr; }
// Return a PackageDoc for the specified package name
public PackageDoc packageNamed(String name) {
return (PackageDoc)packageDocMap.get(name);
}
// classes and interfaces specified on the command line.
public ClassDoc[] specifiedClasses()
{
return (ClassDocImpl[]) specifiedClasses.toArray(new ClassDocImpl[0]);
}
// packages specified on the command line.
public PackageDoc[] specifiedPackages()
{
return (PackageDocImpl[])specifiedPackages.toArray(new PackageDocImpl[0]);
}
// Print error message, increment error count.
public void printError(java.lang.String msg) {
reporter.printError(msg);
}
// Print error message, increment error count.
public void printFatal(java.lang.String msg) {
reporter.printFatal(msg);
}
// Print a message.
public void printNotice(java.lang.String msg) {
reporter.printNotice(msg);
}
// Print warning message, increment warning count.
public void printWarning(java.lang.String msg) {
reporter.printWarning(msg);
}
public String name() {
return "RootDoc";
}
public ErrorReporter getReporter() {
return reporter;
}
public void build() throws ParseException, IOException {
//--- Create a temporary random access file for caching comment text.
//File rawCommentCacheFile=File.createTempFile("gjdoc_rawcomment",".cache");
File rawCommentCacheFile = new File("gjdoc_rawcomment.cache");
rawCommentCacheFile.deleteOnExit();
rawCommentCache = new RandomAccessFile(rawCommentCacheFile, "rw");
//--- Parse all files in "java.lang".
List javaLangSourceDirs = findSourceFiles("java/lang");
if (!javaLangSourceDirs.isEmpty()) {
Iterator it = javaLangSourceDirs.iterator();
while (it.hasNext()) {
File javaLangSourceDir = (File)it.next();
parser.processSourceDir(javaLangSourceDir,
sourceEncoding, "java.lang");
}
}
else {
Debug.log(1, "Sourcepath is "+sourcePath);
// Core docs not included in source-path:
// we need to gather the information about java.lang
// classes via reflection...
}
//--- Parse all files in explicitly specified package directories.
for (Iterator it=specifiedPackageNames.iterator(); it.hasNext(); ) {
String specifiedPackageName = (String)it.next();
String displayPackageName = specifiedPackageName;
if (null == displayPackageName || 0 == displayPackageName.length()) {
displayPackageName = "<unnamed>";
}
printNotice("Loading classes for package "+displayPackageName+"...");
String relPath;
if (null != specifiedPackageName) {
relPath = specifiedPackageName.replace('.',File.separatorChar);
}
else {
relPath = "";
}
List sourceDirs = findSourceFiles(relPath);
if (!sourceDirs.isEmpty()) {
Iterator sourceDirIt = sourceDirs.iterator();
while (sourceDirIt.hasNext()) {
File sourceDir = (File)sourceDirIt.next();
parser.processSourceDir(sourceDir, sourceEncoding, specifiedPackageName);
}
}
else {
printError("Package '"+specifiedPackageName+"' not found.");
}
}
specifiedClasses = new LinkedList();
//--- Parse all explicitly specified source files.
for (Iterator it=specifiedSourceFiles.iterator(); it.hasNext(); ) {
File specifiedSourceFile = (File)it.next();
printNotice("Loading source file "+specifiedSourceFile+" ...");
ClassDocImpl classDoc = parser.processSourceFile(specifiedSourceFile, true, sourceEncoding, null);
if (null != classDoc) {
specifiedClasses.add(classDoc);
classesList.add(classDoc);
classDoc.setIsIncluded(true);
addPackageDoc(classDoc.containingPackage());
}
}
//--- Let the user know that all specified classes are loaded.
printNotice("Constructing Javadoc information...");
//--- Load all classes implicitly referenced by explicitly specified classes.
loadScheduledClasses(parser);
printNotice("Resolving references in comments...");
resolveComments();
//--- Resolve pending references in all ClassDocImpls
printNotice("Resolving references in classes...");
for (Iterator it = classDocMap.values().iterator(); it.hasNext(); ) {
ClassDoc cd=(ClassDoc)it.next();
if (cd instanceof ClassDocImpl) {
((ClassDocImpl)cd).resolve();
}
}
//--- Resolve pending references in all PackageDocImpls
printNotice("Resolving references in packages...");
for (Iterator it = packageDocMap.values().iterator(); it.hasNext(); ) {
PackageDocImpl pd=(PackageDocImpl)it.next();
pd.resolve();
}
//--- Assemble the array with all specified packages
specifiedPackages = new LinkedHashSet();
for (Iterator it = specifiedPackageNames.iterator(); it.hasNext(); ) {
String specifiedPackageName = (String)it.next();
PackageDoc specifiedPackageDoc = (PackageDoc)packageDocMap.get(specifiedPackageName);
if (null!=specifiedPackageDoc) {
((PackageDocImpl)specifiedPackageDoc).setIsIncluded(true);
specifiedPackages.add(specifiedPackageDoc);
ClassDoc[] packageClassDocs=specifiedPackageDoc.allClasses();
for (int i=0; i<packageClassDocs.length; ++i) {
ClassDocImpl specifiedPackageClassDoc=(ClassDocImpl)packageClassDocs[i];
specifiedPackageClassDoc.setIsIncluded(true);
classesList.add(specifiedPackageClassDoc);
}
}
}
//--- Resolve pending references in comment data of all classes
printNotice("Resolving references in class comments...");
for (Iterator it=classDocMap.values().iterator(); it.hasNext(); ) {
ClassDoc cd=(ClassDoc)it.next();
if (cd instanceof ClassDocImpl) {
((ClassDocImpl)cd).resolveComments();
}
}
//--- Resolve pending references in comment data of all packages
printNotice("Resolving references in package comments...");
for (Iterator it=packageDocMap.values().iterator(); it.hasNext(); ) {
PackageDocImpl pd=(PackageDocImpl)it.next();
pd.resolveComments();
}
//--- Create array with all loaded classes
this.classes=(ClassDocImpl[])classesList.toArray(new ClassDocImpl[0]);
Arrays.sort(this.classes);
//--- Close comment cache
parser = null;
System.gc();
System.gc();
}
public long writeRawComment(String rawComment) {
try {
long pos=rawCommentCache.getFilePointer();
//rawCommentCache.writeUTF(rawComment);
byte[] bytes = rawComment.getBytes("utf-8");
rawCommentCache.writeInt(bytes.length);
rawCommentCache.write(bytes);
return pos;
}
catch (IOException e) {
printFatal("Cannot write to comment cache: "+e.getMessage());
return -1;
}
}
public String readRawComment(long pos) {
try {
rawCommentCache.seek(pos);
int sz = rawCommentCache.readInt();
byte[] bytes = new byte[sz];
rawCommentCache.read(bytes);
return new String(bytes, "utf-8");
//return rawCommentCache.readUTF();
}
catch (IOException e) {
e.printStackTrace();
printFatal("Cannot read from comment cache: "+e.getMessage());
return null;
}
}
List findSourceFiles(String relPath) {
List result = new LinkedList();
for (Iterator it = sourcePath.iterator(); it.hasNext(); ) {
File path = (File)it.next();
File file = new File(path, relPath);
if (file.exists()) {
result.add(file);
}
}
return result;
}
PackageDocImpl findOrCreatePackageDoc(String packageName) {
PackageDocImpl rc=(PackageDocImpl)getPackageDoc(packageName);
if (null==rc) {
rc=new PackageDocImpl(packageName);
if (specifiedPackageNames.contains(packageName)) {
String packageDirectoryName = packageName.replace('.', File.separatorChar);
List packageDirectories = findSourceFiles(packageDirectoryName);
Iterator it = packageDirectories.iterator();
boolean packageDocFound = false;
while (it.hasNext()) {
File packageDirectory = (File)it.next();
File packageDocFile = new File(packageDirectory, "package.html");
rc.setPackageDirectory(packageDirectory);
packageDocFound = true;
if (null!=packageDocFile && packageDocFile.exists()) {
try {
rc.setRawCommentText(readHtmlBody(packageDocFile));
}
catch (IOException e) {
printWarning("Error while reading documentation for package "+packageName+": "+e.getMessage());
}
break;
}
}
if (!packageDocFound) {
printNotice("No description found for package "+packageName);
}
}
addPackageDoc(rc);
}
return rc;
}
public void addClassDoc(ClassDoc cd) {
classDocMap.put(cd.qualifiedName(), cd);
}
public void addClassDocRecursive(ClassDoc cd) {
classDocMap.put(cd.qualifiedName(), cd);
ClassDoc[] innerClasses = cd.innerClasses(false);
for (int i=0; i<innerClasses.length; ++i) {
addClassDocRecursive(innerClasses[i]);
}
}
public void addPackageDoc(PackageDoc pd) {
packageDocMap.put(pd.name(), pd);
}
public PackageDocImpl getPackageDoc(String name) {
return (PackageDocImpl)packageDocMap.get(name);
}
public ClassDocImpl getClassDoc(String qualifiedName) {
return (ClassDocImpl)classDocMap.get(qualifiedName);
}
class ScheduledClass {
ClassDoc contextClass;
String qualifiedName;
ScheduledClass(ClassDoc contextClass, String qualifiedName) {
this.contextClass=contextClass;
this.qualifiedName=qualifiedName;
}
public String toString() { return "ScheduledClass{"+qualifiedName+"}"; }
}
public void scheduleClass(ClassDoc context, String qualifiedName) throws ParseException, IOException {
if (classDocMap.get(qualifiedName)==null) {
//Debug.log(9,"Scheduling "+qualifiedName+", context "+context+".");
//System.err.println("Scheduling " + qualifiedName + ", context " + context);
scheduledClasses.add(new ScheduledClass(context, qualifiedName));
}
}
/**
* Load all classes that were implictly referenced by the classes
* (already loaded) that the user explicitly specified on the
* command line.
*
* For example, if the user generates Documentation for his simple
* 'class Test {}', which of course 'extends java.lang.Object',
* then 'java.lang.Object' is implicitly referenced because it is
* the base class of Test.
*
* Gjdoc needs a ClassDocImpl representation of all classes
* implicitly referenced through derivation (base class),
* or implementation (interface), or field type, method argument
* type, or method return type.
*
* The task of this method is to ensure that Gjdoc has all this
* information at hand when it exits.
*
*
*/
public void loadScheduledClasses(Parser parser) throws ParseException, IOException {
// Because the referenced classes could in turn reference other
// classes, this method runs as long as there are still unloaded
// classes.
while (!scheduledClasses.isEmpty()) {
// Make a copy of scheduledClasses and empty it. This
// prevents any Concurrent Modification issues.
// As the copy won't need to grow (as it won't change)
// we make it an Array for performance reasons.
ScheduledClass[] scheduledClassesArr = (ScheduledClass[])scheduledClasses.toArray(new ScheduledClass[0]);
scheduledClasses.clear();
// Load each class specified in our array copy
for (int i=0; i<scheduledClassesArr.length; ++i) {
// The name of the class we are looking for. This name
// needs not be fully qualified.
String scheduledClassName=scheduledClassesArr[i].qualifiedName;
// The ClassDoc in whose context the scheduled class was looked for.
// This is necessary in order to resolve non-fully qualified
// class names.
ClassDoc scheduledClassContext=scheduledClassesArr[i].contextClass;
// If there already is a class doc with this name, skip. There's
// nothing to do for us.
if (classDocMap.get(scheduledClassName)!=null) {
continue;
}
try {
// Try to load the class
//printNotice("Trying to load " + scheduledClassName);
loadScheduledClass(parser, scheduledClassName, scheduledClassContext);
}
catch (ParseException e) {
/**********************************************************
// Check whether the following is necessary at all.
if (scheduledClassName.indexOf('.')>0) {
// Maybe the dotted notation doesn't mean a package
// name but instead an inner class, as in 'Outer.Inner'.
// so let's assume this and try to load the outer class.
String outerClass="";
for (StringTokenizer st=new StringTokenizer(scheduledClassName,"."); st.hasMoreTokens(); ) {
if (outerClass.length()>0) outerClass+=".";
outerClass+=st.nextToken();
if (!st.hasMoreTokens()) break;
try {
loadClass(outerClass);
//FIXME: shouldn't this be loadScheduledClass(outerClass, scheduledClassContext); ???
continue;
}
catch (Exception ee) {
// Ignore: try next level
}
}
}
**********************************************************/
// If we arrive here, the class could not be found
printWarning("Couldn't load class "+scheduledClassName+" referenced by "+scheduledClassContext);
//FIXME: shouldn't this be throw new Error("cannot load: "+scheduledClassName);
}
}
}
}
private void loadScheduledClass(Parser parser, String scheduledClassName, ClassDoc scheduledClassContext) throws ParseException, IOException {
ClassDoc loadedClass=(ClassDoc)scheduledClassContext.findClass(scheduledClassName);
if (loadedClass==null || loadedClass instanceof ClassDocProxy) {
ClassDoc classDoc = findScheduledClassFile(scheduledClassName, scheduledClassContext);
if (null != classDoc) {
if (classDoc instanceof ClassDocReflectedImpl) {
Main.getRootDoc().addClassDocRecursive(classDoc);
}
if (Main.DESCEND_SUPERCLASS
&& null != classDoc.superclass()
&& (classDoc.superclass() instanceof ClassDocProxy)) {
scheduleClass(classDoc, classDoc.superclass().qualifiedName());
}
}
else {
// It might be an inner class of one of the outer/super classes.
// But we can only check that when they are all fully loaded.
boolean retryLater = false;
int numberOfProcessedFilesBefore = parser.getNumberOfProcessedFiles();
ClassDoc cc = scheduledClassContext.containingClass();
while (cc != null && !retryLater) {
ClassDoc sc = cc.superclass();
while (sc != null && !retryLater) {
if (sc instanceof ClassDocProxy) {
((ClassDocImpl)cc).resolve();
retryLater = true;
}
sc = sc.superclass();
}
cc = cc.containingClass();
}
// Now that outer/super references have been resolved, try again
// to find the class.
loadedClass = (ClassDoc)scheduledClassContext.findClass(scheduledClassName);
int numberOfProcessedFilesAfter = parser.getNumberOfProcessedFiles();
boolean filesWereProcessed = numberOfProcessedFilesAfter > numberOfProcessedFilesBefore;
// Only re-schedule class if additional files have been processed
// If there haven't, there's no point in re-scheduling.
// Will avoid infinite loops of re-scheduling
if (null == loadedClass && retryLater && filesWereProcessed)
scheduleClass(scheduledClassContext, scheduledClassName);
/* A warning needn't be emitted - this is normal, can happen
if the scheduled class is in a package which is not
included on the command line.
else if (null == loadedClass)
printWarning("Can't find scheduled class '"
+ scheduledClassName
+ "' in context '"
+ scheduledClassContext.qualifiedName()
+ "'");
*/
}
}
}
private static interface ResolvedImport
{
public String match(String name);
public boolean mismatch(String name);
public ClassDoc tryFetch(String name);
}
private class ResolvedImportNotFound
implements ResolvedImport
{
private String importSpecifier;
private String name;
ResolvedImportNotFound(String importSpecifier)
{
this.importSpecifier = importSpecifier;
int ndx = importSpecifier.lastIndexOf('.');
if (ndx >= 0) {
this.name = importSpecifier.substring(ndx + 1);
}
else {
this.name = importSpecifier;
}
}
public String toString()
{
return "ResolvedImportNotFound{" + importSpecifier + "}";
}
public String match(String name)
{
if ((name.equals(this.name)) || (importSpecifier.equals(name)))
return this.name;
// FIXME: note that we don't handle on-demand imports here.
return null;
}
public boolean mismatch(String name)
{
return true; // FIXME!
}
public ClassDoc tryFetch(String name)
{
return null;
}
}
private class ResolvedImportPackageFile
implements ResolvedImport
{
private Set topLevelClassNames;
private File packageFile;
private String packageName;
private Map cache = new HashMap();
ResolvedImportPackageFile(File packageFile, String packageName)
{
this.packageFile = packageFile;
this.packageName = packageName;
topLevelClassNames = new HashSet();
File[] files = packageFile.listFiles();
for (int i=0; i<files.length; ++i) {
if (!files[i].isDirectory() && files[i].getName().endsWith(".java")) {
String topLevelClassName = files[i].getName();
topLevelClassName
= topLevelClassName.substring(0, topLevelClassName.length() - 5);
topLevelClassNames.add(topLevelClassName);
}
}
}
public String match(String name)
{
ClassDoc loadedClass = classNamed(packageName + "." + name);
if (null != loadedClass) {
return loadedClass.qualifiedName();
}
else {
String topLevelName = name;
int ndx = topLevelName.indexOf('.');
String innerClassName = null;
if (ndx > 0) {
innerClassName = topLevelName.substring(ndx + 1);
topLevelName = topLevelName.substring(0, ndx);
}
if (topLevelClassNames.contains(topLevelName)) {
//System.err.println(this + ".match returns " + packageName + "." + name);
return packageName + "." + name;
}
// FIXME: inner classes
else {
return null;
}
}
}
public boolean mismatch(String name)
{
return null == match(name);
}
public ClassDoc tryFetch(String name)
{
ClassDoc loadedClass = classNamed(packageName + "." + name);
if (null != loadedClass) {
return loadedClass;
}
else if (null != match(name)) {
String topLevelName = name;
int ndx = topLevelName.indexOf('.');
String innerClassName = null;
if (ndx > 0) {
innerClassName = topLevelName.substring(ndx + 1);
topLevelName = topLevelName.substring(0, ndx);
}
ClassDoc topLevelClass = (ClassDoc)cache.get(topLevelName);
if (null == topLevelClass) {
File classFile = new File(packageFile, topLevelName + ".java");
try {
// FIXME: inner classes
topLevelClass = parser.processSourceFile(classFile, false, sourceEncoding, null);
}
catch (Exception ignore) {
printWarning("Could not parse source file " + classFile);
}
cache.put(topLevelName, topLevelClass);
}
if (null == innerClassName) {
return topLevelClass;
}
else {
return getInnerClass(topLevelClass, innerClassName);
}
}
else {
return null;
}
}
public String toString()
{
return "ResolvedImportPackageFile{" + packageFile + "," + packageName + "}";
}
}
private ClassDoc getInnerClass(ClassDoc topLevelClass, String innerClassName)
{
StringTokenizer st = new StringTokenizer(innerClassName, ".");
outer:
while (st.hasMoreTokens()) {
String innerClassNameComponent = st.nextToken();
ClassDoc[] innerClasses = topLevelClass.innerClasses();
for (int i=0; i<innerClasses.length; ++i) {
if (innerClasses[i].name().equals(innerClassNameComponent)) {
topLevelClass = innerClasses[i];
continue outer;
}
}
printWarning("Could not find inner class " + innerClassName + " in class " + topLevelClass.qualifiedName());
return null;
}
return topLevelClass;
}
private class ResolvedImportClassFile
implements ResolvedImport
{
private File classFile;
private String innerClassName;
private String name;
private ClassDoc classDoc;
private boolean alreadyFetched;
private String qualifiedName;
ResolvedImportClassFile(File classFile, String innerClassName, String name, String qualifiedName)
{
this.classFile = classFile;
this.innerClassName = innerClassName;
this.name = name;
this.qualifiedName = qualifiedName;
}
public String toString()
{
return "ResolvedImportClassFile{" + classFile + "," + innerClassName + "}";
}
public String match(String name)
{
String topLevelName = name;
int ndx = topLevelName.indexOf('.');
String _innerClassName = null;
if (ndx > 0) {
_innerClassName = topLevelName.substring(ndx + 1);
topLevelName = topLevelName.substring(0, ndx);
}
if (this.name.equals(topLevelName)) {
if (null == _innerClassName) {
return qualifiedName;
}
else {
return qualifiedName + "." + _innerClassName;
}
}
else {
return null;
}
}
public boolean mismatch(String name)
{
return null == match(name);
}
public ClassDoc tryFetch(String name)
{
if (null != match(name)) {
ClassDoc topLevelClass = null;
if (alreadyFetched) {
topLevelClass = classDoc;
}
else {
alreadyFetched = true;
try {
topLevelClass = parser.processSourceFile(classFile, false, sourceEncoding, null);
}
catch (Exception ignore) {
printWarning("Could not parse source file " + classFile);
}
}
if (null == topLevelClass) {
return null;
}
else {
return getInnerClass(topLevelClass, innerClassName);
}
}
else {
return null;
}
}
public String getName()
{
if (innerClassName != null) {
return name + innerClassName;
}
else {
return name;
}
}
}
private class ResolvedImportReflectionClass
implements ResolvedImport
{
private Class clazz;
private String name;
ResolvedImportReflectionClass(Class clazz)
{
this.clazz = clazz;
String className = clazz.getName();
int ndx = className.lastIndexOf('.');
if (ndx >= 0) {
this.name = className.substring(ndx + 1);
}
else {
this.name = className;
}
}
public String toString()
{
return "ResolvedImportReflectionClass{" + clazz.getName() + "}";
}
public String match(String name)
{
if ((this.name.equals(name)) || (clazz.getName().equals(name))) {
return clazz.getName();
}
else {
return null;
}
}
public boolean mismatch(String name)
{
return null == match(name);
}
public ClassDoc tryFetch(String name)
{
if (null != match(name)) {
return new ClassDocReflectedImpl(clazz);
}
// FIXME: inner classes?
else {
return null;
}
}
public String getName()
{
return name;
}
}
private class ResolvedImportReflectionPackage
implements ResolvedImport
{
private String packagePrefix;
ResolvedImportReflectionPackage(String packagePrefix)
{
this.packagePrefix = packagePrefix;
}
public String toString()
{
return "ResolvedImportReflectionPackage{" + packagePrefix + ".*}";
}
public String match(String name)
{
try {
Class clazz = Class.forName(packagePrefix + "." + name);
return clazz.getName();
}
catch (Exception e) {
return null;
}
}
public boolean mismatch(String name)
{
return null == match(name);
}
public ClassDoc tryFetch(String name)
{
try {
Class clazz = Class.forName(packagePrefix + name);
return ClassDocReflectedImpl.newInstance(clazz);
}
catch (Exception e) {
return null;
}
}
public String getName()
{
return packagePrefix;
}
}
private List unlocatablePrefixes = new LinkedList();
private ResolvedImport resolveImport(String importSpecifier)
{
ResolvedImport result = resolveImportFileSystem(importSpecifier);
if (null == result && Main.getInstance().isReflectionEnabled()) {
result = resolveImportReflection(importSpecifier);
}
if (null == result) {
result = new ResolvedImportNotFound(importSpecifier);
}
return result;
}
private ResolvedImport resolveImportReflection(String importSpecifier)
{
String importedPackageOrClass = importSpecifier;
if (importedPackageOrClass.endsWith(".*")) {
importedPackageOrClass = importedPackageOrClass.substring(0, importedPackageOrClass.length() - 2);
return new ResolvedImportReflectionPackage(importedPackageOrClass);
//return null;
}
else {
try {
Class importedClass = Class.forName(importSpecifier);
return new ResolvedImportReflectionClass(importedClass);
}
catch (Throwable ignore) {
return null;
}
}
}
private ResolvedImport resolveImportFileSystem(String importSpecifier)
{
for (Iterator it = unlocatablePrefixes.iterator(); it.hasNext(); ) {
String unlocatablePrefix = (String)it.next();
if (importSpecifier.startsWith(unlocatablePrefix)) {
return null;
}
}
String longestUnlocatablePrefix = "";
for (Iterator it=sourcePath.iterator(); it.hasNext(); ) {
File _sourcePath = (File)it.next();
StringBuffer packageOrClassPrefix = new StringBuffer();
StringTokenizer st = new StringTokenizer(importSpecifier, ".");
while (st.hasMoreTokens() && _sourcePath.isDirectory()) {
String token = st.nextToken();
if ("*".equals(token)) {
return new ResolvedImportPackageFile(_sourcePath,
packageOrClassPrefix.substring(0, packageOrClassPrefix.length() - 1));
}
else {
packageOrClassPrefix.append(token);
packageOrClassPrefix.append('.');
File classFile = new File(_sourcePath, token + ".java");
//System.err.println(" looking for file " + classFile);
if (classFile.exists()) {
StringBuffer innerClassName = new StringBuffer();
while (st.hasMoreTokens()) {
token = st.nextToken();
if (innerClassName.length() > 0) {
innerClassName.append('.');
}
innerClassName.append(token);
}
return new ResolvedImportClassFile(classFile, innerClassName.toString(), token, importSpecifier);
}
else {
_sourcePath = new File(_sourcePath, token);
}
}
}
if (st.hasMoreTokens()) {
if (packageOrClassPrefix.length() > longestUnlocatablePrefix.length()) {
longestUnlocatablePrefix = packageOrClassPrefix.toString();
}
}
}
if (longestUnlocatablePrefix.length() > 0) {
unlocatablePrefixes.add(longestUnlocatablePrefix);
}
return null;
}
private Map resolvedImportCache = new HashMap();
private ResolvedImport getResolvedImport(String importSpecifier)
{
ResolvedImport result
= (ResolvedImport)resolvedImportCache.get(importSpecifier);
if (null == result) {
result = resolveImport(importSpecifier);
resolvedImportCache.put(importSpecifier, result);
}
return result;
}
public String resolveClassName(String className, ClassDocImpl context)
{
Iterator it = context.getImportSpecifierList().iterator();
while (it.hasNext()) {
String importSpecifier = (String)it.next();
ResolvedImport resolvedImport = getResolvedImport(importSpecifier);
String resolvedScheduledClassName = resolvedImport.match(className);
if (null != resolvedScheduledClassName) {
return resolvedScheduledClassName;
}
}
return className;
}
public ClassDoc findScheduledClassFile(String scheduledClassName,
ClassDoc scheduledClassContext)
throws ParseException, IOException
{
String resolvedScheduledClassName = null;
if (scheduledClassContext instanceof ClassDocImpl) {
//((ClassDocImpl)scheduledClassContext).resolveReferencedName(scheduledClassName);
Iterator it = ((ClassDocImpl)scheduledClassContext).getImportSpecifierList().iterator();
while (it.hasNext()) {
String importSpecifier = (String)it.next();
ResolvedImport resolvedImport = getResolvedImport(importSpecifier);
//System.err.println(" looking in import '" + resolvedImport + "'");
resolvedScheduledClassName = resolvedImport.match(scheduledClassName);
if (null != resolvedScheduledClassName) {
ClassDoc result = resolvedImport.tryFetch(scheduledClassName);
if (null != result) {
return result;
}
else {
if (!inaccessibleReportedSet.contains(scheduledClassName)) {
inaccessibleReportedSet.add(scheduledClassName);
printWarning("Error while loading class " + scheduledClassName);
}
// FIXME: output resolved class name here
return null;
}
}
}
}
else {
System.err.println("findScheduledClassFile for '" + scheduledClassName + "' in proxy for " + scheduledClassContext);
}
// interpret as fully qualified name on file system
ResolvedImport fqImport = resolveImportFileSystem(scheduledClassName);
if (null != fqImport && fqImport instanceof ResolvedImportClassFile) {
return fqImport.tryFetch(((ResolvedImportClassFile)fqImport).getName());
}
// use reflection, assume fully qualified class name
if (!unlocatableReflectedClassNames.contains(scheduledClassName)) {
if (Main.getInstance().isReflectionEnabled()) {
try {
Class clazz = Class.forName(scheduledClassName);
printWarning("Cannot locate class " + scheduledClassName + " on file system, falling back to reflection.");
ClassDoc result = new ClassDocReflectedImpl(clazz);
return result;
}
catch (Throwable ignore) {
unlocatableReflectedClassNames.add(scheduledClassName);
}
}
else {
unlocatableReflectedClassNames.add(scheduledClassName);
}
}
if (null == resolvedScheduledClassName) {
resolvedScheduledClassName = scheduledClassName;
}
if (!unlocatableReportedSet.contains(resolvedScheduledClassName)) {
unlocatableReportedSet.add(resolvedScheduledClassName);
printWarning("Cannot locate class " + resolvedScheduledClassName + " referenced in class " + scheduledClassContext.qualifiedName());
}
return null;
}
private Set unlocatableReflectedClassNames = new HashSet();
public static boolean recursiveClasses = false;
public void addSpecifiedPackageName(String packageName) {
specifiedPackageNames.add(packageName);
}
public void addSpecifiedSourceFile(File sourceFile) {
specifiedSourceFiles.add(sourceFile);
}
public boolean hasSpecifiedPackagesOrClasses() {
return !specifiedPackageNames.isEmpty()
|| !specifiedSourceFiles.isEmpty();
}
public void setOptions(String[][] customOptionArr) {
this.customOptionArr = customOptionArr;
}
public void setSourcePath(List sourcePath) {
this.sourcePath = sourcePath;
}
public void finalize() throws Throwable {
super.finalize();
}
public void flush()
{
try {
rawCommentCache.close();
}
catch (IOException e) {
printError("Cannot close raw comment cache");
}
rawCommentCache = null;
customOptionArr = null;
specifiedPackageNames = null;
classesList = null;
classDocMap = null;
packageDocMap = null;
classes = null;
specifiedClasses = null;
specifiedPackages = null;
scheduledClasses = null;
sourcePath = null;
parser = null;
unlocatableReportedSet = null;
inaccessibleReportedSet = null;
}
public void setSourceEncoding(String sourceEncoding)
{
this.sourceEncoding = sourceEncoding;
}
public RootDocImpl()
{
super(null);
}
public static String readHtmlBody(File file)
throws IOException
{
FileReader fr=new FileReader(file);
long size = file.length();
char[] packageDocBuf=new char[(int)(size)];
int index = 0;
int i = fr.read(packageDocBuf, index, (int)size);
while (i > 0) {
index += i;
size -= i;
i = fr.read(packageDocBuf, index, (int)size);
}
fr.close();
// We only need the part between the begin and end body tag.
String html = new String(packageDocBuf);
int start = html.indexOf("<body");
if (start == -1)
start = html.indexOf("<BODY");
int end = html.indexOf("</body>");
if (end == -1)
end = html.indexOf("</BODY>");
if (start != -1 && end != -1) {
// Start is end of body tag.
start = html.indexOf('>', start) + 1;
if (start != -1 && start < end)
html = html.substring(start, end);
}
return html.trim();
}
public Parser getParser()
{
return parser;
}
}