| /* gnu.classpath.tools.gjdoc.DocImpl |
| Copyright (C) 2001 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.text.*; |
| import java.io.File; |
| import javax.swing.text.Segment; |
| |
| /** |
| * Represents the least common denominator of all Javadoc |
| * comment classes. |
| */ |
| public abstract class DocImpl implements Doc, TagContainer { |
| |
| protected static Tag[] seeTagEmptyArr = new SeeTagImpl[0]; |
| protected static Tag[] linkTagEmptyArr = new LinkTagImpl[0]; |
| protected static Tag[] paramTagEmptyArr = new ParamTagImpl[0]; |
| protected static Tag[] throwsTagEmptyArr = new ThrowsTagImpl[0]; |
| protected SourcePosition position; |
| private String boilerplateComment; |
| |
| // Return the text of the comment for this doc item. |
| public String commentText() { |
| |
| StringBuffer rc=new StringBuffer(); |
| |
| Tag[] textTags=(Tag[])tagMap.get("text"); |
| if (textTags!=null) { |
| for (int i=0; i<textTags.length; ++i) { |
| rc.append(textTags[i].text()); |
| } |
| } |
| return rc.toString(); |
| } |
| |
| // Compares this Object with the specified Object for order. |
| public int compareTo(java.lang.Object o) { |
| return Main.getInstance().getCollator().compare(name(), ((Doc)o).name()); |
| } |
| |
| // Return the first sentence of the comment as tags. |
| public Tag[] firstSentenceTags() { |
| |
| Tag[] rc=(Tag[])tagMap.get("first"); |
| if (rc==null) rc=new Tag[0]; |
| return rc; |
| } |
| |
| // Return the full unprocessed text of the comment. |
| public String getRawCommentText() { |
| if (rawDocumentation!=null) |
| return rawDocumentation; |
| else if (rawDocOffset>=0) |
| return Main.getRootDoc().readRawComment(rawDocOffset); |
| else |
| return null; |
| } |
| |
| // Return comment as tags. |
| public Tag[] inlineTags() { |
| |
| Tag[] rc=(Tag[])tagMap.get("inline"); |
| if (rc==null) rc=new Tag[0]; |
| return rc; |
| } |
| |
| // Is this Doc item a class. |
| public boolean isClass() { |
| return false; |
| } |
| |
| // Is this Doc item a constructor? False until overridden. |
| public boolean isConstructor() { |
| return false; |
| } |
| |
| // Is this Doc item a error class? False until overridden. |
| public boolean isError() { |
| return false; |
| } |
| |
| // Is this Doc item a exception class? False until overridden. |
| public boolean isException() { |
| return false; |
| } |
| |
| // Is this Doc item a field? False until overridden. |
| public boolean isField() { |
| return false; |
| } |
| |
| // return true if this Doc is include in the active set. |
| public boolean isIncluded() { |
| return false; |
| } |
| |
| // Is this Doc item a interface? False until overridden. |
| public boolean isInterface() { |
| return false; |
| } |
| |
| // Is this Doc item a simple method (i.e. |
| public boolean isMethod() { |
| return false; |
| } |
| |
| public boolean isPackage() { |
| return false; |
| } |
| |
| // Is this Doc item a ordinary class (i.e. |
| public boolean isOrdinaryClass() { |
| return false; |
| } |
| |
| // Return the see also tags in this Doc item. |
| public SeeTag[] seeTags() { |
| return (SeeTag[])getTagArr("see", seeTagEmptyArr); |
| } |
| |
| protected Tag[] getTagArr(String kindOfTag, Tag[] defaultRc) { |
| Tag[] rc=(Tag[])tagMap.get(kindOfTag); |
| if (rc==null) rc=defaultRc; |
| return rc; |
| } |
| |
| // Set the full unprocessed text of the comment. |
| public void setRawCommentText(String rawDocumentation) { |
| this.rawDocumentation=rawDocumentation; |
| } |
| |
| public void resolveComments() { |
| |
| if (rawDocumentation!=null && tagMap.isEmpty()) { |
| char[] charArray = rawDocumentation.toCharArray(); |
| int length = rawDocumentation.length(); |
| int startOffset = 0; |
| int endOffset = 0; |
| if (charArray[0] == '/' |
| && charArray[1] == '*' |
| && charArray[2] == '*' |
| && charArray[length - 2] == '*' |
| && charArray[length - 1] == '/') { |
| |
| startOffset = 3; |
| endOffset = 2; |
| } |
| |
| this.tagMap=parseCommentTags(charArray, |
| startOffset, |
| length - endOffset, |
| getContextClass(), |
| getContextMember(), |
| null, |
| boilerplateComment); |
| |
| if (Main.getInstance().isCacheRawComments()) { |
| rawDocOffset=Main.getRootDoc().writeRawComment(rawDocumentation); |
| rawDocumentation=null; |
| } |
| |
| resolveTags(); |
| } |
| else if (tagMap.isEmpty() && null != boilerplateComment) { |
| tagMap.put("all", new Tag[] { new TagImpl("@boilerplate", boilerplateComment,getContextClass(),null) }); |
| tagMap.put("@boilerplate", new Tag[] { new TagImpl("@boilerplate", boilerplateComment,getContextClass(),null) }); |
| } |
| } |
| |
| public static int skipHtmlWhitespace(char[] buffer, int startIndex) { |
| while (startIndex < buffer.length) { |
| char c=buffer[startIndex]; |
| if (!Parser.isWhitespace(c)) { |
| break; |
| } |
| else { |
| ++ startIndex; |
| } |
| } |
| return startIndex; |
| } |
| |
| /** |
| * Looks for an end-of-sentence marker in <code>text</code>, |
| * starting at <code>startIndex</code> and stopping at |
| * <code>endIndex</code>. |
| * |
| * @param text the text to be searched |
| * @param startIndex index in <code>text</code> at which to start |
| * @param endIndex index in <code>text</code> at which to stop |
| * |
| * @return the index of the character following the end-of-sentence |
| * marker, <code>endIndex</code> if no end-of-sentence |
| * marker could be found, or -1 if not implemented. |
| */ |
| private static int findEndOfSentence(char[] text, int startIndex, |
| int endIndex) |
| { |
| if (Main.getInstance().isUseBreakIterator()) { |
| Segment segment = new Segment(text, startIndex, endIndex - startIndex); |
| BreakIterator breakIterator = BreakIterator.getSentenceInstance(Main.getInstance().getLocale()); |
| breakIterator.setText(segment); |
| int result = breakIterator.next(); |
| if (BreakIterator.DONE == result) { |
| return endIndex; |
| } |
| else { |
| return result; |
| } |
| } |
| else { |
| while (startIndex < endIndex) { |
| if (text[startIndex] == '.' |
| && (startIndex+1 == endIndex |
| || Character.isWhitespace(text[startIndex+1]) |
| || isHTMLBreakTag(text, startIndex+1, endIndex) |
| )) { |
| return startIndex; |
| } |
| |
| startIndex++; |
| } |
| return endIndex; |
| } |
| } |
| |
| /** |
| * Returns true is the text from start to end begins with a 'p' or 'br' tag. |
| */ |
| private static boolean isHTMLBreakTag(char[] text, int start, int end) |
| { |
| String[] breakTags = { |
| "p>", "/p>", "h1>", "h2>", "h3>", "h4>", "h5>", "h6>", "hr>", |
| "pre>", "/pre>" |
| }; |
| |
| if (text[start] == '<') { |
| |
| outer: |
| for (int i=0; i<breakTags.length; ++i) { |
| String tag = breakTags[i]; |
| int len = tag.length(); |
| if (start + len < end) { |
| for (int j=0; j<len; ++j) { |
| char c = tag.charAt(j); |
| if (Character.toLowerCase(text[start + 1 + j]) != c) { |
| continue outer; |
| } |
| } |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| //private static final StringBuffer buf=new StringBuffer(32768); |
| private static final StringBuffer whitespaceBuf=new StringBuffer(); |
| private static char[] charBuf = new char[60000]; |
| private static int bufPos = 0; |
| |
| private static void appendToBuf(char c) |
| { |
| if (bufPos < charBuf.length) { |
| charBuf[bufPos++] = c; |
| } |
| else { |
| // |
| } |
| } |
| |
| private static void appendToBuf(StringBuffer s) |
| { |
| if (bufPos + s.length() <= charBuf.length) { |
| s.getChars(0, s.length(), charBuf, bufPos); |
| bufPos += s.length(); |
| } |
| else { |
| // |
| } |
| } |
| |
| private static void setBufLength(int length) |
| { |
| bufPos = 0; |
| } |
| |
| private static String bufToString() |
| { |
| return new String(charBuf, 0, bufPos); |
| } |
| |
| private static int bufLength() |
| { |
| return bufPos; |
| } |
| |
| public static Map parseCommentTags(char[] comment, int startIndex, int endIndex, |
| ClassDocImpl contextClass, MemberDocImpl contextMember, |
| AbstractTagImpl contextTag, String boilerplateComment) { |
| |
| int rawDocStart=skipHtmlWhitespace(comment, startIndex); |
| |
| int firstSentenceEnd = 0; |
| |
| if (comment.length>rawDocStart) { |
| |
| firstSentenceEnd = findEndOfSentence(comment, rawDocStart, comment.length); |
| |
| if (firstSentenceEnd < 0) { |
| BreakIterator boundary = BreakIterator.getSentenceInstance(Locale.ENGLISH); |
| boundary.setText(new ArrayCharacterIterator(comment, rawDocStart)); |
| boundary.first(); |
| boundary.next(); |
| firstSentenceEnd = boundary.current(); |
| } |
| |
| // Always include period at end of sentence if there is one. |
| if (firstSentenceEnd < comment.length |
| && '.' == comment[firstSentenceEnd]) { |
| ++ firstSentenceEnd; |
| } |
| } |
| |
| final int STATE_BEGOFLINE = 1; |
| final int STATE_TEXT = 2; |
| final int STATE_PARAM = 3; |
| final int STATE_PARAMVALUE = 4; |
| final int STATE_PARAMWRAP = 5; |
| final int STATE_INLINEPARAM = 6; |
| final int STATE_INLINEPARAMVALUE = 7; |
| final int STATE_WHITESPACE = 8; |
| final int STATE_INLINEPARAMVALUE_BOL = 9; |
| final int STATE_IPV_WHITESPACE = 10; |
| |
| int state=STATE_BEGOFLINE; |
| int prevState=STATE_TEXT; |
| |
| setBufLength(0); |
| whitespaceBuf.setLength(0); |
| |
| String paramName="", paramValue=""; |
| |
| Map tags=new HashMap(); |
| tags.put("inline", new LinkedList()); |
| tags.put("first", new LinkedList()); |
| tags.put("all", new LinkedList()); |
| |
| final char EOL=(char)-1; |
| |
| for (int i=rawDocStart; i<=endIndex; ++i) { |
| char c=(i<endIndex)?comment[i]:EOL; |
| char peek=(i<endIndex-1)?comment[i+1]:EOL; |
| |
| switch (state){ |
| |
| case STATE_BEGOFLINE: |
| if (i==firstSentenceEnd) { |
| AbstractTagImpl newTag = addTag(tags, "text", bufToString(), true, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| setBufLength(0); |
| } |
| |
| if (Parser.isWhitespace(c)) { |
| // ignore |
| } |
| else if (c=='*') { |
| // ignore, but go to STATE_TEXT |
| if (peek!='*' && peek!='@' && peek!=EOL) { |
| state=STATE_WHITESPACE; |
| } |
| } |
| else if (c=='@' || (c=='{' && peek=='@') || c==EOL) { |
| if (bufLength()>0) { |
| addTag(tags, "text", bufToString(), i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| setBufLength(0); |
| } |
| if (c=='{') { |
| ++i; |
| state=STATE_INLINEPARAM; |
| } |
| else { |
| state=STATE_PARAM; |
| } |
| } |
| else { |
| state=STATE_TEXT; |
| appendToBuf(whitespaceBuf); |
| whitespaceBuf.setLength(0); |
| appendToBuf(c); |
| } |
| break; |
| |
| case STATE_WHITESPACE: |
| if (i==firstSentenceEnd) { |
| AbstractTagImpl newTag = addTag(tags, "text", bufToString(), true, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| setBufLength(0); |
| } |
| |
| if (c=='\n') { |
| whitespaceBuf.append(c); |
| state=STATE_BEGOFLINE; |
| } |
| else if (Parser.isWhitespace(c)) { |
| whitespaceBuf.append(c); |
| } |
| else if (c=='@' || (c=='{' && peek=='@') || c==EOL) { |
| if (bufLength()>0) { |
| AbstractTagImpl newTag = addTag(tags, "text", bufToString(), i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| setBufLength(0); |
| } |
| if (c=='{') { |
| ++i; |
| state=STATE_INLINEPARAM; |
| } |
| else { |
| state=STATE_PARAM; |
| } |
| } |
| else { |
| appendToBuf(whitespaceBuf); |
| whitespaceBuf.setLength(0); |
| appendToBuf(c); |
| state=STATE_TEXT; |
| } |
| break; |
| |
| case STATE_PARAMWRAP: |
| if (c=='\n') { |
| appendToBuf(c); |
| } |
| else if (Parser.isWhitespace(c)) { |
| // ignore |
| } |
| else if (c=='*') { |
| // ignore, but go to STATE_TEXT |
| /* |
| if (i<endIndex && comment[i+1]!='*' && comment[i+1]!='@') { |
| state=STATE_PARAMVALUE; |
| } |
| */ |
| } |
| else if (c=='@' || c==EOL) { |
| paramValue=bufToString(); |
| AbstractTagImpl newTag = addTag(tags, paramName, paramValue, i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| setBufLength(0); |
| if (c=='{') { |
| ++i; |
| state=STATE_INLINEPARAM; |
| } |
| else { |
| state=STATE_PARAM; |
| } |
| } |
| else { |
| state=STATE_PARAMVALUE; |
| appendToBuf(c); |
| } |
| break; |
| |
| case STATE_PARAM: |
| if (!(c==EOL || Parser.isWhitespace(c))) { |
| appendToBuf(c); |
| } |
| else if (c=='\n') { |
| paramName=bufToString(); |
| setBufLength(0); |
| state=STATE_PARAMWRAP; |
| } |
| else { |
| paramName=bufToString(); |
| setBufLength(0); |
| state=STATE_PARAMVALUE; |
| } |
| break; |
| |
| case STATE_INLINEPARAM: |
| if (c=='}') { |
| // tag without value |
| paramName=bufToString(); |
| AbstractTagImpl newTag = addTag(tags, paramName, "", i<firstSentenceEnd, contextClass, contextMember, contextTag, true); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| state=prevState; |
| setBufLength(0); |
| } |
| else if (!(c==EOL || Parser.isWhitespace(c))) { |
| appendToBuf(c); |
| } |
| else if (c=='\n') { |
| paramName=bufToString(); |
| setBufLength(0); |
| state=STATE_INLINEPARAMVALUE_BOL; |
| } |
| else { |
| paramName=bufToString(); |
| setBufLength(0); |
| state=STATE_INLINEPARAMVALUE; |
| } |
| break; |
| |
| case STATE_PARAMVALUE: |
| if (c==EOL) { |
| paramValue=bufToString(); |
| AbstractTagImpl newTag = addTag(tags, paramName, paramValue, i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| } |
| else if (c=='\n') { |
| appendToBuf(c); |
| state=STATE_PARAMWRAP; |
| } |
| else { |
| appendToBuf(c); |
| } |
| break; |
| |
| case STATE_INLINEPARAMVALUE: |
| if (c=='\n') { |
| appendToBuf(c); |
| state=STATE_INLINEPARAMVALUE_BOL; |
| } |
| else if (c==EOL || c=='}') { |
| paramValue=bufToString(); |
| AbstractTagImpl newTag = addTag(tags, paramName, paramValue, i<firstSentenceEnd, contextClass, contextMember, contextTag, true); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| state=prevState; |
| setBufLength(0); |
| } |
| else { |
| appendToBuf(c); |
| } |
| break; |
| |
| case STATE_INLINEPARAMVALUE_BOL: |
| if (Parser.isWhitespace(c)) { |
| // ignore |
| } |
| else if (c=='*') { |
| // ignore, but go to STATE_TEXT |
| if (i<endIndex && peek!='*') { |
| state=STATE_IPV_WHITESPACE; |
| } |
| } |
| else if (c==EOL) { |
| if (bufLength()>0) { |
| AbstractTagImpl newTag = addTag(tags, "text", bufToString(), i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| } |
| } |
| else { |
| state=STATE_INLINEPARAMVALUE; |
| appendToBuf(whitespaceBuf); |
| whitespaceBuf.setLength(0); |
| appendToBuf(c); |
| } |
| break; |
| |
| case STATE_IPV_WHITESPACE: |
| if (c=='\n') { |
| whitespaceBuf.append(c); |
| state=STATE_INLINEPARAMVALUE_BOL; |
| } |
| else if (Parser.isWhitespace(c)) { |
| whitespaceBuf.append(c); |
| } |
| else if (c==EOL) { |
| if (bufLength()>0) { |
| AbstractTagImpl newTag = addTag(tags, "text", bufToString(), i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| setBufLength(0); |
| } |
| } |
| else { |
| appendToBuf(whitespaceBuf); |
| whitespaceBuf.setLength(0); |
| appendToBuf(c); |
| state=STATE_INLINEPARAMVALUE; |
| } |
| break; |
| |
| case STATE_TEXT: |
| if (i==firstSentenceEnd) { |
| AbstractTagImpl newTag = addTag(tags, "text", bufToString(), true, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| setBufLength(0); |
| } |
| |
| if (c==EOL) { |
| paramValue=bufToString(); |
| AbstractTagImpl newTag = addTag(tags, "text", paramValue, i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| } |
| else if (c=='\n') { |
| appendToBuf(c); |
| state=STATE_BEGOFLINE; |
| } |
| else if (c=='{' && peek=='@') { |
| paramValue=bufToString(); |
| AbstractTagImpl newTag = addTag(tags, "text", paramValue, i<firstSentenceEnd, contextClass, contextMember, contextTag, false); |
| if (null != newTag) { |
| contextTag = newTag; |
| } |
| ++i; |
| setBufLength(0); |
| state=STATE_INLINEPARAM; |
| } |
| else { |
| appendToBuf(c); |
| } |
| break; |
| |
| default: |
| throw new Error("illegal state "+state); |
| } |
| } |
| |
| |
| if (null == contextMember && null != boilerplateComment && Main.getInstance().isCopyLicenseText()) { |
| addTag(tags, "@boilerplate", boilerplateComment, false, contextClass, null, null, false); |
| } |
| |
| Map rc=new HashMap(); |
| |
| for (Iterator it=tags.keySet().iterator(); it.hasNext(); ) { |
| String key=(String)it.next(); |
| Tag[] templateArr; |
| List list=(List)tags.get(key); |
| |
| if ("see".equals(key)) |
| templateArr=new SeeTag[list.size()]; |
| else if ("param".equals(key)) |
| templateArr=new ParamTag[list.size()]; |
| else if ("serialField".equals(key)) |
| templateArr=new SerialFieldTag[list.size()]; |
| else if ("throws".equals(key) || "exception".equals(key)) |
| templateArr=new ThrowsTag[list.size()]; |
| else { |
| templateArr=new Tag[list.size()]; |
| } |
| |
| rc.put(key, list.toArray(templateArr)); |
| } |
| |
| return rc; |
| } |
| |
| private ClassDocImpl getContextClass() { |
| if (isClass() || isInterface()) { |
| return (ClassDocImpl)this; |
| } |
| else if (isField() || isMethod() || isConstructor()) { |
| return (ClassDocImpl)((MemberDocImpl)this).containingClass(); |
| } |
| else { |
| return null; |
| } |
| } |
| |
| private MemberDocImpl getContextMember() { |
| if (isField() || isMethod() || isConstructor()) { |
| return (MemberDocImpl)this; |
| } |
| else { |
| return null; |
| } |
| } |
| |
| protected static AbstractTagImpl addTag(Map tags, String name, |
| String value, boolean isFirstSentence, |
| ClassDocImpl contextClass, |
| MemberDocImpl contextMember, |
| AbstractTagImpl contextTag, |
| boolean isInline) { |
| |
| AbstractTagImpl tag = null; |
| |
| boolean haveValue = (0 != value.trim().length()); |
| |
| String emptyWarning = "Empty @" + name + " tag."; |
| |
| if (name.equals("param")) { |
| if (haveValue) { |
| tag=new ParamTagImpl(value, contextClass, contextMember); |
| } |
| else { |
| //printWarning(emptyWarning); |
| } |
| } |
| else if (name.equals("see")) { |
| if (haveValue) { |
| tag=new SeeTagImpl(value, contextClass); |
| } |
| else { |
| //printWarning(emptyWarning); |
| } |
| } |
| else if (name.equals("link") || name.equals("linkplain")) { |
| if (haveValue) { |
| tag=new LinkTagImpl("@" + name, value, contextClass); |
| isInline = true; |
| } |
| else { |
| //printWarning(emptyWarning); |
| } |
| } |
| else if (name.equals("value")) { |
| if (haveValue) { |
| tag=new ValueTagImpl(value, contextClass); |
| isInline = true; |
| } |
| else { |
| //printWarning(emptyWarning); |
| } |
| } |
| else if (name.equals("inheritDoc")) { |
| if (haveValue) { |
| //printWarning("@inheritDoc tags are not supposed to have any content."); |
| } |
| tag=new InheritDocTagImpl(contextClass, contextMember, contextTag); |
| isInline = true; |
| } |
| else if (name.equals("serialField")) { |
| if (haveValue) { |
| tag=new SerialFieldTagImpl(value, contextClass, contextMember); |
| } |
| else { |
| //printWarning(emptyWarning); |
| } |
| } |
| else if (name.equals("throws") || name.equals("exception")) { |
| if (haveValue) { |
| tag=new ThrowsTagImpl(value, contextClass, contextMember); |
| } |
| else { |
| //printWarning(emptyWarning); |
| } |
| name="throws"; |
| } |
| else if (name.equals("text")) { |
| tag=new TextTagImpl(value); |
| isInline = true; |
| } |
| else { |
| tag=new TagImpl("@"+name, value.trim(), contextClass, contextMember); |
| // FIXME: consider taglets |
| } |
| |
| if (tag != null) { |
| if (isInline) { |
| ((List)tags.get("inline")).add(tag); |
| if (isFirstSentence) { |
| if (name.equals("text")) { |
| String txt = ((TextTagImpl)tag).getText(); |
| Tag newTag; |
| if (txt.startsWith("<p>")) { |
| newTag = new TextTagImpl(txt.substring(3)); |
| } |
| else if (txt.endsWith("</p>")) { |
| newTag = new TextTagImpl(txt.substring(0, txt.length() - 4)); |
| } |
| else { |
| newTag = tag; |
| } |
| ((List)tags.get("first")).add(newTag); |
| |
| } |
| else { |
| ((List)tags.get("first")).add(tag); |
| } |
| } |
| } |
| else { |
| ((List)tags.get("all")).add(tag); |
| } |
| |
| List l=((List)tags.get(name)); |
| if (l==null) { |
| l=new LinkedList(); |
| tags.put(name,l); |
| } |
| l.add(tag); |
| |
| return isInline ? tag : contextTag; |
| } |
| else { |
| return null; |
| } |
| } |
| |
| // Return all tags in this Doc item. |
| public Tag[] tags() { |
| Tag[] rc=(Tag[])tagMap.get("all"); |
| if (rc==null) rc=new Tag[0]; |
| return rc; |
| } |
| |
| // Return tags of the specified kind in this Doc item. |
| public Tag[] tags(java.lang.String tagname) { |
| Tag[] rc=(Tag[])tagMap.get(tagname); |
| if (rc==null) rc=new Tag[0]; |
| return rc; |
| } |
| |
| protected String rawDocumentation; |
| protected long rawDocOffset=-1; |
| |
| protected Map tagMap = new HashMap(); |
| |
| public Map getTagMap() { return tagMap; } |
| |
| protected void resolveTags() { |
| |
| Tag[] tags=tags(); |
| for (int i=0; i<tags.length; ++i) { |
| ((AbstractTagImpl)tags[i]).resolve(); |
| } |
| |
| Tag[] inlineTags=inlineTags(); |
| for (int i=0; i<inlineTags.length; ++i) { |
| ((AbstractTagImpl)inlineTags[i]).resolve(); |
| } |
| } |
| |
| private static Map classDocToFileMap = new HashMap(); |
| |
| private static File getFile(ClassDoc classDoc) { |
| File result = (File)classDocToFileMap.get(classDoc); |
| if (null == result) { |
| result = new File(((GjdocPackageDoc)classDoc.containingPackage()).packageDirectory(), |
| classDoc.name() + ".java"); |
| classDocToFileMap.put(classDoc, result); |
| } |
| return result; |
| } |
| |
| public static SourcePosition getPosition(ClassDoc classDoc) |
| { |
| return new SourcePositionImpl(getFile(classDoc), 0, 0); |
| } |
| |
| public static SourcePosition getPosition(ClassDoc classDoc, char[] source, int startIndex) |
| { |
| int column = 0; |
| int line = 0; |
| for (int i=0; i<startIndex; ++i) { |
| if (10 == source[i]) { |
| ++ line; |
| column = 0; |
| } |
| else if (13 != source[i]) { |
| ++ column; |
| } |
| } |
| while (true) { |
| ClassDoc containingClassDoc = classDoc.containingClass(); |
| if (null != containingClassDoc) { |
| classDoc = containingClassDoc; |
| } |
| else { |
| break; |
| } |
| } |
| |
| File file = getFile(classDoc); |
| |
| return new SourcePositionImpl(file, line + 1, column + 1); |
| } |
| |
| public SourcePosition position() |
| { |
| return this.position; |
| } |
| |
| public DocImpl(SourcePosition position) |
| { |
| this.position = position; |
| } |
| |
| public void setPosition(SourcePosition position) |
| { |
| this.position = position; |
| } |
| |
| private static TagContainer checkForInheritedDoc(ClassDoc classDoc, |
| MemberDocImpl memberDoc, |
| AbstractTagImpl tag) |
| { |
| DocImpl result; |
| |
| if (!(classDoc instanceof ClassDocImpl)) { |
| result = null; |
| } |
| else if (null == memberDoc) { |
| result = (DocImpl)classDoc; |
| } |
| else if (memberDoc.isField()) { |
| result = (DocImpl)((ClassDocImpl)classDoc).getFieldDoc(memberDoc.name()); |
| } |
| else if (memberDoc.isMethod()) { |
| result = (DocImpl)((ClassDocImpl)classDoc).getMethodDoc(memberDoc.name(), |
| ((MethodDoc)memberDoc).signature()); |
| } |
| else if (memberDoc.isConstructor()) { |
| result = (DocImpl)((ClassDocImpl)classDoc).getConstructorDoc(((ConstructorDoc)memberDoc).signature()); |
| } |
| else { |
| //assert(false); |
| throw new RuntimeException("memberDoc is supposed to be field, method or constructor"); |
| } |
| |
| if (null != result |
| && null != memberDoc |
| && null != tag) { |
| |
| TagContainer tagDoc = null; |
| |
| Tag[] tags = result.tags(); |
| for (int i=0; i<tags.length; ++i) { |
| if (tags[i].kind().equals(tag.kind())) { |
| if ("@param".equals(tag.kind())) { |
| if (((ParamTagImpl)tags[i]).parameterName().equals(((ParamTagImpl)tag).parameterName())) { |
| tagDoc = (TagContainer)tags[i]; |
| break; |
| } |
| } |
| else if ("@throws".equals(tag.kind())) { |
| if (((ThrowsTagImpl)tags[i]).exceptionName().equals(((ThrowsTagImpl)tag).exceptionName())) { |
| tagDoc = (TagContainer)tags[i]; |
| break; |
| } |
| } |
| else if ("@return".equals(tag.kind())) { |
| tagDoc = (TagContainer)tags[i]; |
| } |
| } |
| } |
| |
| return tagDoc; |
| } |
| |
| if (null == result || result.isEmptyDoc()) { |
| return null; |
| } |
| else { |
| return result; |
| } |
| } |
| |
| public static TagContainer findInheritedDoc(ClassDoc classDoc, |
| MemberDocImpl memberDoc, |
| AbstractTagImpl tag) |
| { |
| TagContainer result; |
| |
| // (Taken from Javadoc Solaris Tool documentation 1.5, |
| // section "Automatic Copying of Method Comments") |
| |
| // Algorithm for Inheriting Method Comments - If a method does |
| // not have a doc comment, or has an {@inheritDoc} tag, the |
| // Javadoc tool searches for an applicable comment using the |
| // following algorithm, which is designed to find the most |
| // specific applicable doc comment, giving preference to |
| // interfaces over superclasses: |
| |
| // 1. Look in each directly implemented (or extended) interface |
| // in the order they appear following the word implements (or |
| // extends) in the method declaration. Use the first doc comment |
| // found for this method. |
| |
| ClassDoc[] interfaces = classDoc.interfaces(); |
| if (null != interfaces) { |
| for (int i=0; i<interfaces.length; ++i) { |
| result = checkForInheritedDoc(interfaces[i], memberDoc, tag); |
| if (null != result) { |
| return result; |
| } |
| } |
| } |
| |
| // 2. If step 1 failed to find a doc comment, recursively apply |
| // this entire algorithm to each directly implemented (or |
| // extended) interface, in the same order they were examined |
| // in step 1. |
| |
| if (null != interfaces) { |
| for (int i=0; i<interfaces.length; ++i) { |
| result = findInheritedDoc(interfaces[i], memberDoc, tag); |
| if (null != result) { |
| return result; |
| } |
| } |
| } |
| |
| ClassDoc superclassDoc = classDoc.superclass(); |
| |
| // 3. If step 2 failed to find a doc comment and this is a class |
| // other than Object (not an interface): |
| if (!classDoc.isInterface() |
| && null != superclassDoc |
| && !"java.lang.Object".equals(classDoc.qualifiedTypeName())) { |
| |
| // 3a. If the superclass has a doc comment for this method, use it. |
| |
| result = checkForInheritedDoc(superclassDoc, memberDoc, tag); |
| if (null != result) { |
| return result; |
| } |
| |
| // 3b. If step 3a failed to find a doc comment, recursively |
| // apply this entire algorithm to the superclass. |
| |
| return findInheritedDoc(superclassDoc, |
| memberDoc, tag); |
| } |
| else { |
| return null; |
| } |
| } |
| |
| public boolean isEmptyDoc() |
| { |
| return tagMap.isEmpty(); |
| } |
| |
| void setBoilerplateComment(String boilerplateComment) |
| { |
| this.boilerplateComment = boilerplateComment; |
| } |
| } |
| |
