?? driver.java
字號:
protected void outputFieldDocBody(int level, FieldDoc fieldDoc) {
outputType(level, "type", fieldDoc.type());
if (fieldDoc.isTransient()) {
printAtomTag(level, "isTransient");
}
if (fieldDoc.isVolatile()) {
printAtomTag(level, "isVolatile");
}
}
private void outputFieldDoc(int level, FieldDoc fieldDoc) {
println();
printOpenTag(level, "fielddoc name=\""+fieldDoc.name()+"\"");
outputMemberDocBody(level+1, fieldDoc);
outputFieldDocBody(level+1, fieldDoc);
printCloseTag(level, "fielddoc");
}
protected void outputConstructorDoc(int level, ConstructorDoc constructorDoc) {
println();
printOpenTag(level, "constructordoc name=\""+constructorDoc.name()+"\"");
outputExecutableMemberDocBody(level+1, constructorDoc);
printCloseTag(level, "constructordoc");
}
protected void outputSuperInterfacesRec(int level, ClassDoc classDoc) {
if (null!=classDoc) {
ClassDoc[] interfaces = classDoc.interfaces();
if (null != interfaces) {
for (int i=0, ilim=interfaces.length; i<ilim; ++i) {
outputType(level, "superimplements", interfaces[i]);
}
}
outputSuperInterfacesRec(level, classDoc.superclass());
}
}
protected void outputClassDocSummary(ClassDoc classDoc) {
println();
printOpenTag(1, "classdoc name=\""+classDoc.name()+"\" qualifiedtypename=\""+classDoc.qualifiedName()+"\" isIncluded=\"true\"");
if (null!=classDoc.superclass()) {
outputType(2, "superclass", classDoc.superclass());
}
ClassDoc[] interfaces = classDoc.interfaces();
for (int i=0, ilim=interfaces.length; i<ilim; ++i) {
outputType(2, "implements", interfaces[i]);
}
outputSuperInterfacesRec(2, classDoc.superclass());
printAtomTag(2, "containingPackage name=\""+classDoc.containingPackage().name()+"\"");
if (classDoc.isError()) {
printAtomTag(2, "isError");
}
if (classDoc.isException()) {
printAtomTag(2, "isException");
}
if (classDoc.isInterface()) {
printAtomTag(2, "isInterface");
}
if (classDoc.isOrdinaryClass()) {
printAtomTag(2, "isOrdinaryClass");
}
printCloseTag(1, "classdoc");
}
protected void outputPackageDoc(PackageDoc packageDoc) {
println();
printOpenTag(1, "packagedoc name=\""+packageDoc.name()+"\"");
if (packageDoc.firstSentenceTags().length > 0) {
printOpenTag(2, "firstSentenceTags", false);
outputTags(3, packageDoc.firstSentenceTags(), true, CONTEXT_PACKAGE);
printCloseTag(0, "firstSentenceTags");
printOpenTag(2, "inlineTags", false);
outputTags(3, packageDoc.inlineTags(), true, CONTEXT_PACKAGE);
printCloseTag(0, "inlineTags");
}
if (packageDoc.tags().length > 0) {
printOpenTag(2, "tags");
outputTags(3, packageDoc.tags(), true, CONTEXT_PACKAGE);
printCloseTag(2, "tags");
}
if (packageDoc.seeTags().length > 0) {
printOpenTag(2, "seeTags");
outputTags(3, packageDoc.seeTags(), true, CONTEXT_PACKAGE);
printCloseTag(2, "seeTags");
}
ClassDoc[] allClasses = (ClassDoc[]) packageDoc.allClasses().clone();
Arrays.sort(allClasses);
if (false) {
for (int i = 0, ilim = allClasses.length; i < ilim; ++ i) {
printAtomTag(2, "containsClass qualifiedtypename=\""+allClasses[i].qualifiedTypeName()+"\"");
}
}
printCloseTag(1, "packagedoc");
}
protected void outputClassDoc(ClassDoc classDoc) throws IOException {
currentClass = classDoc;
println();
printOpenTag(1, "classdoc xmlns=\"http://www.w3.org/TR/REC-html40\" xmlns:"+tagPrefix+"=\"http://www.gnu.org/software/cp-tools/gjdocxml\" name=\""+classDoc.name()+"\" qualifiedtypename=\""+classDoc.qualifiedName()+"\"");
ClassDoc[] interfaces = classDoc.interfaces();
for (int i=0, ilim=interfaces.length; i<ilim; ++i) {
outputType(2, "implements", interfaces[i]);
}
outputSuperInterfacesRec(2, classDoc.superclass());
outputProgramElementDocBody(2, classDoc);
if (classDoc.isAbstract())
printAtomTag(2, "isAbstract");
if (classDoc.isSerializable())
printAtomTag(2, "isSerializable");
if (classDoc.isExternalizable())
printAtomTag(2, "isExternalizable");
if (classDoc.definesSerializableFields()) {
printAtomTag(2, "definesSerializableFields");
}
ConstructorDoc[] constructors = classDoc.constructors();
for (int i=0, ilim=constructors.length; i<ilim; ++i) {
outputConstructorDoc(2, constructors[i]);
}
MethodDoc[] methods = classDoc.methods();
for (int i=0, ilim=methods.length; i<ilim; ++i) {
outputMethodDoc(2, methods[i]);
}
FieldDoc[] fields = classDoc.fields();
for (int i=0, ilim=fields.length; i<ilim; ++i) {
outputFieldDoc(2, fields[i]);
}
if (classDoc.serializableFields().length > 0) {
printOpenTag(2, "serializableFields");
FieldDoc[] sfields = classDoc.serializableFields();
for (int i=0, ilim=sfields.length; i<ilim; ++i) {
outputFieldDoc(2, sfields[i]);
}
printCloseTag(2, "serializableFields");
}
Java2xhtml java2xhtml = new Java2xhtml();
Properties properties = new Properties();
properties.setProperty("isCodeSnippet", "true");
properties.setProperty("hasLineNumbers", "true");
java2xhtml.setProperties(properties);
if (null == classDoc.containingClass() && docTransletOptions.linksource) {
printOpenTag(2, "source");
StringWriter sourceBuffer = new StringWriter();
File sourceFile = new File(((GjdocPackageDoc)classDoc.containingPackage()).packageDirectory(),
classDoc.name() + ".java");
FileReader sourceReader = new FileReader(sourceFile);
IOToolkit.copyStream(sourceReader, sourceBuffer);
print(java2xhtml.makeHTML(sourceBuffer.getBuffer(), sourceFile.getName()));
printCloseTag(2, "source");
}
ClassDoc superclassDoc = classDoc.superclass();
while (superclassDoc != null) {
outputType(2, "superclass", superclassDoc, false);
// FIXME: remove the following after adjusting the XSLT sheets:
printAtomTag(3, "containingPackage name=\"" + superclassDoc.containingPackage().name() + "\"");
MethodDoc[] superMethods = superclassDoc.methods();
if (null != superMethods) {
for (int i=0, ilim=superMethods.length; i<ilim; ++i) {
printAtomTag(3, "methoddoc name=\"" + superMethods[i].name() + "\" signature=\"" + superMethods[i].signature() + "\"");
}
}
FieldDoc[] superFields = superclassDoc.fields();
if (null != superFields) {
for (int i=0, ilim=superFields.length; i<ilim; ++i) {
printAtomTag(3, "fielddoc name=\"" + superFields[i].name() + "\"");
}
}
printCloseTag(2, "superclass");
superclassDoc = superclassDoc.superclass();
}
outputUsage(classDoc, 2);
printCloseTag(1, "classdoc");
currentClass = null;
currentMember = null;
currentExecMember = null;
}
protected int outputHeritageOpen(int level, ClassDoc classDoc) {
ClassDoc superClassDoc = classDoc.superclass();
if (null != superClassDoc) {
level = outputHeritageOpen(level, superClassDoc);
++ level;
}
outputType(level, "heritage", classDoc, false);
return level;
}
protected void outputHeritageClose(int level, ClassDoc classDoc) {
ClassDoc superClassDoc = classDoc.superclass();
if (null != superClassDoc) {
outputHeritageClose(level + 1, superClassDoc);
}
printCloseTag(level, "heritage");
}
protected void outputDocBody(int level, Doc doc) {
int context = CONTEXT_TYPE;
if (doc.isClass()) {
printAtomTag(level, "isClass");
ClassDoc classDoc = (ClassDoc)doc;
ClassDoc[] classes = rootDoc.classes();
for (int i=0, ilim=classes.length; i<ilim; ++i) {
if (classes[i].superclass() == classDoc) {
outputType(level, "extended-by", classes[i]);
}
}
outputHeritageOpen(level, classDoc);
outputHeritageClose(level, classDoc);
}
if (doc.isConstructor()) {
printAtomTag(level, "isConstructor");
context = CONTEXT_CONSTRUCTOR;
}
if (doc.isError()) {
printAtomTag(level, "isError");
}
if (doc.isException()) {
printAtomTag(level, "isException");
}
if (doc.isField()) {
printAtomTag(level, "isField");
context = CONTEXT_FIELD;
}
if (doc.isIncluded()) {
printAtomTag(level, "isIncluded");
}
if (doc.isInterface()) {
printAtomTag(level, "isInterface");
ClassDoc classDoc = (ClassDoc)doc;
ClassDoc[] classes = rootDoc.classes();
for (int i=0, ilim=classes.length; i<ilim; ++i) {
ClassDoc[] implementedInterfaces = classes[i].interfaces();
for (int j=0; j<implementedInterfaces.length; ++j) {
if (implementedInterfaces[j] == classDoc) {
if (classDoc.isInterface()) {
outputType(level, "subinterface", classes[i]);
}
else {
outputType(level, "implemented-by", classes[i]);
}
break;
}
}
}
}
if (doc.isMethod()) {
printAtomTag(level, "isMethod");
context = CONTEXT_METHOD;
}
if (doc.isOrdinaryClass()) {
printAtomTag(level, "isOrdinaryClass");
}
if (doc.inlineTags().length > 0) {
printOpenTag(level, "inlineTags", false);
outputTags(level+1, doc.inlineTags(), true, context);
printCloseTag(0, "inlineTags");
}
if (doc.firstSentenceTags().length > 0) {
printOpenTag(level, "firstSentenceTags", false);
outputTags(level+1, doc.firstSentenceTags(), true, context);
printCloseTag(0, "firstSentenceTags");
}
if (doc.tags().length > 0) {
printOpenTag(level, "tags");
outputTaglets(level+1, doc.tags(), true, context);
printCloseTag(level, "tags");
}
if (doc.seeTags().length > 0) {
printOpenTag(level, "seeTags");
outputTags(level+1, doc.seeTags(), true, context);
printCloseTag(level, "seeTags");
}
SourcePosition position = doc.position();
if (null != position) {
printAtomTag(level, "position file=\"" + position.file().getAbsolutePath() + "\" line=\"" + position.line() + "\" column=\"" + position.column() + "\"");
}
}
protected void outputProgramElementDocBody(int level, ProgramElementDoc programElementDoc) {
outputDocBody(level, programElementDoc);
printAtomTag(level, "containingPackage name=\""+programElementDoc.containingPackage().name()+"\"");
if (null!=programElementDoc.containingClass()) {
outputType(level, "containingClass", programElementDoc.containingClass());
}
String access;
if (programElementDoc.isPublic())
access="public";
else if (programElementDoc.isProtected())
access="protected";
else if (programElementDoc.isPrivate())
access="private";
else if (programElementDoc.isPackagePrivate())
access="package";
else
throw new RuntimeException("Huh? "+programElementDoc+" is neither public, protected, private nor package protected.");
printAtomTag(level, "access scope=\""+access+"\"");
if (programElementDoc.isFinal())
printAtomTag(level, "isFinal");
if (programElementDoc.isStatic())
printAtomTag(level, "isStatic");
}
protected void outputTags(int level, Tag[] tags, boolean descend, int context) {
for (int i=0; i<tags.length; ++i) {
outputTag(tags[i], level, descend, context, i == tags.length-1);
}
}
protected void outputTag(Tag tag, int level, boolean descend, int context, boolean lastTag) {
if (!"Text".equals(tag.name())) {
printOpenTag(0 /* don't introduce additional whitespace */,
"tag kind=\""+tag.kind()+"\" name=\""+tag.name()+"\"", false);
}
if (tag instanceof ThrowsTag) {
ThrowsTag throwsTag = (ThrowsTag)tag;
?? 快捷鍵說明
復(fù)制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -