jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java@a78f51d6bd5e (annotated)

src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java@a78f51d6bd5e (annotated)

src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java

Mon, 25 Nov 2013 17:42:28 -0800

author: jjg
date: Mon, 25 Nov 2013 17:42:28 -0800
changeset 2204: a78f51d6bd5e
parent 1704: ed918a442b83
child 2268: b4e592c5314d
permissions: -rw-r--r--

8028318: [doclint] doclint will reject existing user-written doc comments using custom tags that follow the recommended rules
Reviewed-by: darcy

 /*
  * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code 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
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */
 package com.sun.tools.javac.parser;
 import java.text.BreakIterator;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import com.sun.source.doctree.AttributeTree.ValueKind;
 import com.sun.tools.javac.parser.DocCommentParser.TagParser.Kind;
 import com.sun.tools.javac.parser.Tokens.Comment;
 import com.sun.tools.javac.parser.Tokens.TokenKind;
 import com.sun.tools.javac.tree.DCTree;
 import com.sun.tools.javac.tree.DCTree.DCAttribute;
 import com.sun.tools.javac.tree.DCTree.DCDocComment;
 import com.sun.tools.javac.tree.DCTree.DCEndElement;
 import com.sun.tools.javac.tree.DCTree.DCEndPosTree;
 import com.sun.tools.javac.tree.DCTree.DCErroneous;
 import com.sun.tools.javac.tree.DCTree.DCIdentifier;
 import com.sun.tools.javac.tree.DCTree.DCReference;
 import com.sun.tools.javac.tree.DCTree.DCStartElement;
 import com.sun.tools.javac.tree.DCTree.DCText;
 import com.sun.tools.javac.tree.DocTreeMaker;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.util.DiagnosticSource;
 import com.sun.tools.javac.util.List;
 import com.sun.tools.javac.util.ListBuffer;
 import com.sun.tools.javac.util.Log;
 import com.sun.tools.javac.util.Name;
 import com.sun.tools.javac.util.Names;
 import com.sun.tools.javac.util.Options;
 import com.sun.tools.javac.util.Position;
 import static com.sun.tools.javac.util.LayoutCharacters.*;
 /**
  *
  *  <p><b>This is NOT part of any supported API.
  *  If you write code that depends on this, you do so at your own risk.
  *  This code and its internal interfaces are subject to change or
  *  deletion without notice.</b>
  */
 public class DocCommentParser {
     static class ParseException extends Exception {
         private static final long serialVersionUID = 0;
         ParseException(String key) {
             super(key);
         }
     }
     final ParserFactory fac;
     final DiagnosticSource diagSource;
     final Comment comment;
     final DocTreeMaker m;
     final Names names;
     BreakIterator sentenceBreaker;
     /** The input buffer, index of most recent character read,
      *  index of one past last character in buffer.
      */
     protected char[] buf;
     protected int bp;
     protected int buflen;
     /** The current character.
      */
     protected char ch;
     int textStart = -1;
     int lastNonWhite = -1;
     boolean newline = true;
     Map<Name, TagParser> tagParsers;
     DocCommentParser(ParserFactory fac, DiagnosticSource diagSource, Comment comment) {
         this.fac = fac;
         this.diagSource = diagSource;
         this.comment = comment;
         names = fac.names;
         m = fac.docTreeMaker;
         Locale locale = (fac.locale == null) ? Locale.getDefault() : fac.locale;
         Options options = fac.options;
         boolean useBreakIterator = options.isSet("breakIterator");
         if (useBreakIterator || !locale.getLanguage().equals(Locale.ENGLISH.getLanguage()))
             sentenceBreaker = BreakIterator.getSentenceInstance(locale);
         initTagParsers();
     }
     DCDocComment parse() {
         String c = comment.getText();
         buf = new char[c.length() + 1];
         c.getChars(0, c.length(), buf, 0);
         buf[buf.length - 1] = EOI;
         buflen = buf.length - 1;
         bp = -1;
         nextChar();
         List<DCTree> body = blockContent();
         List<DCTree> tags = blockTags();
         // split body into first sentence and body
         ListBuffer<DCTree> fs = new ListBuffer<DCTree>();
         loop:
         for (; body.nonEmpty(); body = body.tail) {
             DCTree t = body.head;
             switch (t.getKind()) {
                 case TEXT:
                     String s = ((DCText) t).getBody();
                     int i = getSentenceBreak(s);
                     if (i > 0) {
                         int i0 = i;
                         while (i0 > 0 && isWhitespace(s.charAt(i0 - 1)))
                             i0--;
                         fs.add(m.at(t.pos).Text(s.substring(0, i0)));
                         int i1 = i;
                         while (i1 < s.length() && isWhitespace(s.charAt(i1)))
                             i1++;
                         body = body.tail;
                         if (i1 < s.length())
                             body = body.prepend(m.at(t.pos + i1).Text(s.substring(i1)));
                         break loop;
                     } else if (body.tail.nonEmpty()) {
                         if (isSentenceBreak(body.tail.head)) {
                             int i0 = s.length() - 1;
                             while (i0 > 0 && isWhitespace(s.charAt(i0)))
                                 i0--;
                             fs.add(m.at(t.pos).Text(s.substring(0, i0 + 1)));
                             body = body.tail;
                             break loop;
                         }
                     }
                     break;
                 case START_ELEMENT:
                 case END_ELEMENT:
                     if (isSentenceBreak(t))
                         break loop;
                     break;
             }
             fs.add(t);
         }
         @SuppressWarnings("unchecked")
         DCTree first = getFirst(fs.toList(), body, tags);
         int pos = (first == null) ? Position.NOPOS : first.pos;
         DCDocComment dc = m.at(pos).DocComment(comment, fs.toList(), body, tags);
         return dc;
     }
     void nextChar() {
         ch = buf[bp < buflen ? ++bp : buflen];
         switch (ch) {
             case '\f': case '\n': case '\r':
                 newline = true;
         }
     }
     /**
      * Read block content, consisting of text, html and inline tags.
      * Terminated by the end of input, or the beginning of the next block tag:
      * i.e. @ as the first non-whitespace character on a line.
      */
     @SuppressWarnings("fallthrough")
     protected List<DCTree> blockContent() {
         ListBuffer<DCTree> trees = new ListBuffer<DCTree>();
         textStart = -1;
         loop:
         while (bp < buflen) {
             switch (ch) {
                 case '\n': case '\r': case '\f':
                     newline = true;
                     // fallthrough
                 case ' ': case '\t':
                     nextChar();
                     break;
                 case '&':
                     entity(trees);
                     break;
                 case '<':
                     newline = false;
                     addPendingText(trees, bp - 1);
                     trees.add(html());
                     if (textStart == -1) {
                         textStart = bp;
                         lastNonWhite = -1;
                     }
                     break;
                 case '>':
                     newline = false;
                     addPendingText(trees, bp - 1);
                     trees.add(m.at(bp).Erroneous(newString(bp, bp+1), diagSource, "dc.bad.gt"));
                     nextChar();
                     if (textStart == -1) {
                         textStart = bp;
                         lastNonWhite = -1;
                     }
                     break;
                 case '{':
                     inlineTag(trees);
                     break;
                 case '@':
                     if (newline) {
                         addPendingText(trees, lastNonWhite);
                         break loop;
                     }
                     // fallthrough
                 default:
                     newline = false;
                     if (textStart == -1)
                         textStart = bp;
                     lastNonWhite = bp;
                     nextChar();
             }
         }
         if (lastNonWhite != -1)
             addPendingText(trees, lastNonWhite);
         return trees.toList();
     }
     /**
      * Read a series of block tags, including their content.
      * Standard tags parse their content appropriately.
      * Non-standard tags are represented by {@link UnknownBlockTag}.
      */
     protected List<DCTree> blockTags() {
         ListBuffer<DCTree> tags = new ListBuffer<DCTree>();
         while (ch == '@')
             tags.add(blockTag());
         return tags.toList();
     }
     /**
      * Read a single block tag, including its content.
      * Standard tags parse their content appropriately.
      * Non-standard tags are represented by {@link UnknownBlockTag}.
      */
     protected DCTree blockTag() {
         int p = bp;
         try {
             nextChar();
             if (isIdentifierStart(ch)) {
                 Name name = readTagName();
                 TagParser tp = tagParsers.get(name);
                 if (tp == null) {
                     List<DCTree> content = blockContent();
                     return m.at(p).UnknownBlockTag(name, content);
                 } else {
                     switch (tp.getKind()) {
                         case BLOCK:
                             return tp.parse(p);
                         case INLINE:
                             return erroneous("dc.bad.inline.tag", p);
                     }
                 }
             }
             blockContent();
             return erroneous("dc.no.tag.name", p);
         } catch (ParseException e) {
             blockContent();
             return erroneous(e.getMessage(), p);
         }
     }
     protected void inlineTag(ListBuffer<DCTree> list) {
         newline = false;
         nextChar();
         if (ch == '@') {
             addPendingText(list, bp - 2);
             list.add(inlineTag());
             textStart = bp;
             lastNonWhite = -1;
         } else {
             if (textStart == -1)
                 textStart = bp - 1;
             lastNonWhite = bp;
         }
     }
     /**
      * Read a single inline tag, including its content.
      * Standard tags parse their content appropriately.
      * Non-standard tags are represented by {@link UnknownBlockTag}.
      * Malformed tags may be returned as {@link Erroneous}.
      */
     protected DCTree inlineTag() {
         int p = bp - 1;
         try {
             nextChar();
             if (isIdentifierStart(ch)) {
                 Name name = readTagName();
                 skipWhitespace();
                 TagParser tp = tagParsers.get(name);
                 if (tp == null) {
                     DCTree text = inlineText();
                     if (text != null) {
                         nextChar();
                         return m.at(p).UnknownInlineTag(name, List.of(text)).setEndPos(bp);
                     }
                 } else if (tp.getKind() == TagParser.Kind.INLINE) {
                     DCEndPosTree<?> tree = (DCEndPosTree<?>) tp.parse(p);
                     if (tree != null) {
                         return tree.setEndPos(bp);
                     }
                 } else {
                     inlineText(); // skip content
                     nextChar();
                 }
             }
             return erroneous("dc.no.tag.name", p);
         } catch (ParseException e) {
             return erroneous(e.getMessage(), p);
         }
     }
     /**
      * Read plain text content of an inline tag.
      * Matching pairs of { } are skipped; the text is terminated by the first
      * unmatched }. It is an error if the beginning of the next tag is detected.
      */
     protected DCTree inlineText() throws ParseException {
         skipWhitespace();
         int pos = bp;
         int depth = 1;
         loop:
         while (bp < buflen) {
             switch (ch) {
                 case '\n': case '\r': case '\f':
                     newline = true;
                     break;
                 case ' ': case '\t':
                     break;
                 case '{':
                     newline = false;
                     lastNonWhite = bp;
                     depth++;
                     break;
                 case '}':
                     if (--depth == 0) {
                         return m.at(pos).Text(newString(pos, bp));
                     }
                     newline = false;
                     lastNonWhite = bp;
                     break;
                 case '@':
                     if (newline)
                         break loop;
                     newline = false;
                     lastNonWhite = bp;
                     break;
                 default:
                     newline = false;
                     lastNonWhite = bp;
                     break;
             }
             nextChar();
         }
         throw new ParseException("dc.unterminated.inline.tag");
     }
     /**
      * Read Java class name, possibly followed by member
      * Matching pairs of < > are skipped. The text is terminated by the first
      * unmatched }. It is an error if the beginning of the next tag is detected.
      */
     // TODO: boolean allowMember should be enum FORBID, ALLOW, REQUIRE
     // TODO: improve quality of parse to forbid bad constructions.
     @SuppressWarnings("fallthrough")
     protected DCReference reference(boolean allowMember) throws ParseException {
         int pos = bp;
         int depth = 0;
         // scan to find the end of the signature, by looking for the first
         // whitespace not enclosed in () or <>, or the end of the tag
         loop:
         while (bp < buflen) {
             switch (ch) {
                 case '\n': case '\r': case '\f':
                     newline = true;
                     // fallthrough
                 case ' ': case '\t':
                     if (depth == 0)
                         break loop;
                     break;
                 case '(':
                 case '<':
                     newline = false;
                     depth++;
                     break;
                 case ')':
                 case '>':
                     newline = false;
                     --depth;
                     break;
                 case '}':
                     if (bp == pos)
                         return null;
                     newline = false;
                     break loop;
                 case '@':
                     if (newline)
                         break loop;
                     // fallthrough
                 default:
                     newline = false;
             }
             nextChar();
         }
         if (depth != 0)
             throw new ParseException("dc.unterminated.signature");
         String sig = newString(pos, bp);
         // Break sig apart into qualifiedExpr member paramTypes.
         JCTree qualExpr;
         Name member;
         List<JCTree> paramTypes;
         Log.DeferredDiagnosticHandler deferredDiagnosticHandler
                 = new Log.DeferredDiagnosticHandler(fac.log);
         try {
             int hash = sig.indexOf("#");
             int lparen = sig.indexOf("(", hash + 1);
             if (hash == -1) {
                 if (lparen == -1) {
                     qualExpr = parseType(sig);
                     member = null;
                 } else {
                     qualExpr = null;
                     member = parseMember(sig.substring(0, lparen));
                 }
             } else {
                 qualExpr = (hash == 0) ? null : parseType(sig.substring(0, hash));
                 if (lparen == -1)
                     member = parseMember(sig.substring(hash + 1));
                 else
                     member = parseMember(sig.substring(hash + 1, lparen));
             }
             if (lparen < 0) {
                 paramTypes = null;
             } else {
                 int rparen = sig.indexOf(")", lparen);
                 if (rparen != sig.length() - 1)
                     throw new ParseException("dc.ref.bad.parens");
                 paramTypes = parseParams(sig.substring(lparen + 1, rparen));
             }
             if (!deferredDiagnosticHandler.getDiagnostics().isEmpty())
                 throw new ParseException("dc.ref.syntax.error");
         } finally {
             fac.log.popDiagnosticHandler(deferredDiagnosticHandler);
         }
         return m.at(pos).Reference(sig, qualExpr, member, paramTypes).setEndPos(bp);
     }
     JCTree parseType(String s) throws ParseException {
         JavacParser p = fac.newParser(s, false, false, false);
         JCTree tree = p.parseType();
         if (p.token().kind != TokenKind.EOF)
             throw new ParseException("dc.ref.unexpected.input");
         return tree;
     }
     Name parseMember(String s) throws ParseException {
         JavacParser p = fac.newParser(s, false, false, false);
         Name name = p.ident();
         if (p.token().kind != TokenKind.EOF)
             throw new ParseException("dc.ref.unexpected.input");
         return name;
     }
     List<JCTree> parseParams(String s) throws ParseException {
         if (s.trim().isEmpty())
             return List.nil();
         JavacParser p = fac.newParser(s.replace("...", "[]"), false, false, false);
         ListBuffer<JCTree> paramTypes = new ListBuffer<JCTree>();
         paramTypes.add(p.parseType());
         if (p.token().kind == TokenKind.IDENTIFIER)
             p.nextToken();
         while (p.token().kind == TokenKind.COMMA) {
             p.nextToken();
             paramTypes.add(p.parseType());
             if (p.token().kind == TokenKind.IDENTIFIER)
                 p.nextToken();
         }
         if (p.token().kind != TokenKind.EOF)
             throw new ParseException("dc.ref.unexpected.input");
         return paramTypes.toList();
     }
     /**
      * Read Java identifier
      * Matching pairs of { } are skipped; the text is terminated by the first
      * unmatched }. It is an error if the beginning of the next tag is detected.
      */
     @SuppressWarnings("fallthrough")
     protected DCIdentifier identifier() throws ParseException {
         skipWhitespace();
         int pos = bp;
         if (isJavaIdentifierStart(ch)) {
             Name name = readJavaIdentifier();
             return m.at(pos).Identifier(name);
         }
         throw new ParseException("dc.identifier.expected");
     }
     /**
      * Read a quoted string.
      * It is an error if the beginning of the next tag is detected.
      */
     @SuppressWarnings("fallthrough")
     protected DCText quotedString() {
         int pos = bp;
         nextChar();
         loop:
         while (bp < buflen) {
             switch (ch) {
                 case '\n': case '\r': case '\f':
                     newline = true;
                     break;
                 case ' ': case '\t':
                     break;
                 case '"':
                     nextChar();
                     // trim trailing white-space?
                     return m.at(pos).Text(newString(pos, bp));
                 case '@':
                     if (newline)
                         break loop;
             }
             nextChar();
         }
         return null;
     }
     /**
      * Read general text content of an inline tag, including HTML entities and elements.
      * Matching pairs of { } are skipped; the text is terminated by the first
      * unmatched }. It is an error if the beginning of the next tag is detected.
      */
     @SuppressWarnings("fallthrough")
     protected List<DCTree> inlineContent() {
         ListBuffer<DCTree> trees = new ListBuffer<DCTree>();
         skipWhitespace();
         int pos = bp;
         int depth = 1;
         textStart = -1;
         loop:
         while (bp < buflen) {
             switch (ch) {
                 case '\n': case '\r': case '\f':
                     newline = true;
                     // fall through
                 case ' ': case '\t':
                     nextChar();
                     break;
                 case '&':
                     entity(trees);
                     break;
                 case '<':
                     newline = false;
                     addPendingText(trees, bp - 1);
                     trees.add(html());
                     break;
                 case '{':
                     newline = false;
                     depth++;
                     nextChar();
                     break;
                 case '}':
                     newline = false;
                     if (--depth == 0) {
                         addPendingText(trees, bp - 1);
                         nextChar();
                         return trees.toList();
                     }
                     nextChar();
                     break;
                 case '@':
                     if (newline)
                         break loop;
                     // fallthrough
                 default:
                     if (textStart == -1)
                         textStart = bp;
                     nextChar();
                     break;
             }
         }
         return List.<DCTree>of(erroneous("dc.unterminated.inline.tag", pos));
     }
     protected void entity(ListBuffer<DCTree> list) {
         newline = false;
         addPendingText(list, bp - 1);
         list.add(entity());
         if (textStart == -1) {
             textStart = bp;
             lastNonWhite = -1;
         }
     }
     /**
      * Read an HTML entity.
      * {@literal &identifier; } or {@literal &#digits; } or {@literal &#xhex-digits; }
      */
     protected DCTree entity() {
         int p = bp;
         nextChar();
         Name name = null;
         boolean checkSemi = false;
         if (ch == '#') {
             int namep = bp;
             nextChar();
             if (isDecimalDigit(ch)) {
                 nextChar();
                 while (isDecimalDigit(ch))
                     nextChar();
                 name = names.fromChars(buf, namep, bp - namep);
             } else if (ch == 'x' || ch == 'X') {
                 nextChar();
                 if (isHexDigit(ch)) {
                     nextChar();
                     while (isHexDigit(ch))
                         nextChar();
                     name = names.fromChars(buf, namep, bp - namep);
                 }
             }
         } else if (isIdentifierStart(ch)) {
             name = readIdentifier();
         }
         if (name == null)
             return erroneous("dc.bad.entity", p);
         else {
             if (ch != ';')
                 return erroneous("dc.missing.semicolon", p);
             nextChar();
             return m.at(p).Entity(name);
         }
     }
     /**
      * Read the start or end of an HTML tag, or an HTML comment
      * {@literal <identifier attrs> } or {@literal </identifier> }
      */
     protected DCTree html() {
         int p = bp;
         nextChar();
         if (isIdentifierStart(ch)) {
             Name name = readIdentifier();
             List<DCTree> attrs = htmlAttrs();
             if (attrs != null) {
                 boolean selfClosing = false;
                 if (ch == '/') {
                     nextChar();
                     selfClosing = true;
                 }
                 if (ch == '>') {
                     nextChar();
                     return m.at(p).StartElement(name, attrs, selfClosing).setEndPos(bp);
                 }
             }
         } else if (ch == '/') {
             nextChar();
             if (isIdentifierStart(ch)) {
                 Name name = readIdentifier();
                 skipWhitespace();
                 if (ch == '>') {
                     nextChar();
                     return m.at(p).EndElement(name);
                 }
             }
         } else if (ch == '!') {
             nextChar();
             if (ch == '-') {
                 nextChar();
                 if (ch == '-') {
                     nextChar();
                     while (bp < buflen) {
                         int dash = 0;
                         while (ch == '-') {
                             dash++;
                             nextChar();
                         }
                         // strictly speaking, a comment should not contain "--"
                         // so dash > 2 is an error, dash == 2 implies ch == '>'
                         if (dash >= 2 && ch == '>') {
                             nextChar();
                             return m.at(p).Comment(newString(p, bp));
                         }
                         nextChar();
                     }
                 }
             }
         }
         bp = p + 1;
         ch = buf[bp];
         return erroneous("dc.malformed.html", p);
     }
     /**
      * Read a series of HTML attributes, terminated by {@literal > }.
      * Each attribute is of the form {@literal identifier[=value] }.
      * "value" may be unquoted, single-quoted, or double-quoted.
      */
     protected List<DCTree> htmlAttrs() {
         ListBuffer<DCTree> attrs = new ListBuffer<DCTree>();
         skipWhitespace();
         loop:
         while (isIdentifierStart(ch)) {
             int namePos = bp;
             Name name = readIdentifier();
             skipWhitespace();
             List<DCTree> value = null;
             ValueKind vkind = ValueKind.EMPTY;
             if (ch == '=') {
                 ListBuffer<DCTree> v = new ListBuffer<DCTree>();
                 nextChar();
                 skipWhitespace();
                 if (ch == '\'' || ch == '"') {
                     vkind = (ch == '\'') ? ValueKind.SINGLE : ValueKind.DOUBLE;
                     char quote = ch;
                     nextChar();
                     textStart = bp;
                     while (bp < buflen && ch != quote) {
                         if (newline && ch == '@') {
                             attrs.add(erroneous("dc.unterminated.string", namePos));
                             // No point trying to read more.
                             // In fact, all attrs get discarded by the caller
                             // and superseded by a malformed.html node because
                             // the html tag itself is not terminated correctly.
                             break loop;
                         }
                         attrValueChar(v);
                     }
                     addPendingText(v, bp - 1);
                     nextChar();
                 } else {
                     vkind = ValueKind.UNQUOTED;
                     textStart = bp;
                     while (bp < buflen && !isUnquotedAttrValueTerminator(ch)) {
                         attrValueChar(v);
                     }
                     addPendingText(v, bp - 1);
                 }
                 skipWhitespace();
                 value = v.toList();
             }
             DCAttribute attr = m.at(namePos).Attribute(name, vkind, value);
             attrs.add(attr);
         }
         return attrs.toList();
     }
     protected void attrValueChar(ListBuffer<DCTree> list) {
         switch (ch) {
             case '&':
                 entity(list);
                 break;
             case '{':
                 inlineTag(list);
                 break;
             default:
                 nextChar();
         }
     }
     protected void addPendingText(ListBuffer<DCTree> list, int textEnd) {
         if (textStart != -1) {
             if (textStart <= textEnd) {
                 list.add(m.at(textStart).Text(newString(textStart, textEnd + 1)));
             }
             textStart = -1;
         }
     }
     protected DCErroneous erroneous(String code, int pos) {
         int i = bp - 1;
         loop:
         while (i > pos) {
             switch (buf[i]) {
                 case '\f': case '\n': case '\r':
                     newline = true;
                     break;
                 case '\t': case ' ':
                     break;
                 default:
                     break loop;
             }
             i--;
         }
         textStart = -1;
         return m.at(pos).Erroneous(newString(pos, i + 1), diagSource, code);
     }
     @SuppressWarnings("unchecked")
     <T> T getFirst(List<T>... lists) {
         for (List<T> list: lists) {
             if (list.nonEmpty())
                 return list.head;
         }
         return null;
     }
     protected boolean isIdentifierStart(char ch) {
         return Character.isUnicodeIdentifierStart(ch);
     }
     protected Name readIdentifier() {
         int start = bp;
         nextChar();
         while (bp < buflen && Character.isUnicodeIdentifierPart(ch))
             nextChar();
         return names.fromChars(buf, start, bp - start);
     }
     protected Name readTagName() {
         int start = bp;
         nextChar();
         while (bp < buflen && (Character.isUnicodeIdentifierPart(ch) || ch == '.'))
             nextChar();
         return names.fromChars(buf, start, bp - start);
     }
     protected boolean isJavaIdentifierStart(char ch) {
         return Character.isJavaIdentifierStart(ch);
     }
     protected Name readJavaIdentifier() {
         int start = bp;
         nextChar();
         while (bp < buflen && Character.isJavaIdentifierPart(ch))
             nextChar();
         return names.fromChars(buf, start, bp - start);
     }
     protected boolean isDecimalDigit(char ch) {
         return ('0' <= ch && ch <= '9');
     }
     protected boolean isHexDigit(char ch) {
         return ('0' <= ch && ch <= '9')
                 || ('a' <= ch && ch <= 'f')
                 || ('A' <= ch && ch <= 'F');
     }
     protected boolean isUnquotedAttrValueTerminator(char ch) {
         switch (ch) {
             case '\f': case '\n': case '\r': case '\t':
             case ' ':
             case '"': case '\'': case '`':
             case '=': case '<': case '>':
                 return true;
             default:
                 return false;
         }
     }
     protected boolean isWhitespace(char ch) {
         return Character.isWhitespace(ch);
     }
     protected void skipWhitespace() {
         while (isWhitespace(ch))
             nextChar();
     }
     protected int getSentenceBreak(String s) {
         if (sentenceBreaker != null) {
             sentenceBreaker.setText(s);
             int i = sentenceBreaker.next();
             return (i == s.length()) ? -1 : i;
         }
         // scan for period followed by whitespace
         boolean period = false;
         for (int i = 0; i < s.length(); i++) {
             switch (s.charAt(i)) {
                 case '.':
                     period = true;
                     break;
                 case ' ':
                 case '\f':
                 case '\n':
                 case '\r':
                 case '\t':
                     if (period)
                         return i;
                     break;
                 default:
                     period = false;
                     break;
             }
         }
         return -1;
     }
     Set<String> htmlBlockTags = new HashSet<String>(Arrays.asList(
                     "h1", "h2", "h3", "h4", "h5", "h6", "p", "pre"));
     protected boolean isSentenceBreak(Name n) {
         return htmlBlockTags.contains(n.toString().toLowerCase());
     }
     protected boolean isSentenceBreak(DCTree t) {
         switch (t.getKind()) {
             case START_ELEMENT:
                 return isSentenceBreak(((DCStartElement) t).getName());
             case END_ELEMENT:
                 return isSentenceBreak(((DCEndElement) t).getName());
         }
         return false;
     }
     /**
      * @param start position of first character of string
      * @param end position of character beyond last character to be included
      */
     String newString(int start, int end) {
         return new String(buf, start, end - start);
     }
     static abstract class TagParser {
         enum Kind { INLINE, BLOCK }
         Kind kind;
         DCTree.Kind treeKind;
         TagParser(Kind k, DCTree.Kind tk) {
             kind = k;
             treeKind = tk;
         }
         Kind getKind() {
             return kind;
         }
         DCTree.Kind getTreeKind() {
             return treeKind;
         }
         abstract DCTree parse(int pos) throws ParseException;
     }
     /**
      * @see <a href="http://docs.oracle.com/javase/7/docs/technotes/tools/solaris/javadoc.html#javadoctags">Javadoc Tags</a>
      */
     private void initTagParsers() {
         TagParser[] parsers = {
             // @author name-text
             new TagParser(Kind.BLOCK, DCTree.Kind.AUTHOR) {
                 public DCTree parse(int pos) {
                     List<DCTree> name = blockContent();
                     return m.at(pos).Author(name);
                 }
             },
             // {@code text}
             new TagParser(Kind.INLINE, DCTree.Kind.CODE) {
                 public DCTree parse(int pos) throws ParseException {
                     DCTree text = inlineText();
                     nextChar();
                     return m.at(pos).Code((DCText) text);
                 }
             },
             // @deprecated deprecated-text
             new TagParser(Kind.BLOCK, DCTree.Kind.DEPRECATED) {
                 public DCTree parse(int pos) {
                     List<DCTree> reason = blockContent();
                     return m.at(pos).Deprecated(reason);
                 }
             },
             // {@docRoot}
             new TagParser(Kind.INLINE, DCTree.Kind.DOC_ROOT) {
                 public DCTree parse(int pos) throws ParseException {
                     if (ch == '}') {
                         nextChar();
                         return m.at(pos).DocRoot();
                     }
                     inlineText(); // skip unexpected content
                     nextChar();
                     throw new ParseException("dc.unexpected.content");
                 }
             },
             // @exception class-name description
             new TagParser(Kind.BLOCK, DCTree.Kind.EXCEPTION) {
                 public DCTree parse(int pos) throws ParseException {
                     skipWhitespace();
                     DCReference ref = reference(false);
                     List<DCTree> description = blockContent();
                     return m.at(pos).Exception(ref, description);
                 }
             },
             // {@inheritDoc}
             new TagParser(Kind.INLINE, DCTree.Kind.INHERIT_DOC) {
                 public DCTree parse(int pos) throws ParseException {
                     if (ch == '}') {
                         nextChar();
                         return m.at(pos).InheritDoc();
                     }
                     inlineText(); // skip unexpected content
                     nextChar();
                     throw new ParseException("dc.unexpected.content");
                 }
             },
             // {@link package.class#member label}
             new TagParser(Kind.INLINE, DCTree.Kind.LINK) {
                 public DCTree parse(int pos) throws ParseException {
                     DCReference ref = reference(true);
                     List<DCTree> label = inlineContent();
                     return m.at(pos).Link(ref, label);
                 }
             },
             // {@linkplain package.class#member label}
             new TagParser(Kind.INLINE, DCTree.Kind.LINK_PLAIN) {
                 public DCTree parse(int pos) throws ParseException {
                     DCReference ref = reference(true);
                     List<DCTree> label = inlineContent();
                     return m.at(pos).LinkPlain(ref, label);
                 }
             },
             // {@literal text}
             new TagParser(Kind.INLINE, DCTree.Kind.LITERAL) {
                 public DCTree parse(int pos) throws ParseException {
                     DCTree text = inlineText();
                     nextChar();
                     return m.at(pos).Literal((DCText) text);
                 }
             },
             // @param parameter-name description
             new TagParser(Kind.BLOCK, DCTree.Kind.PARAM) {
                 public DCTree parse(int pos) throws ParseException {
                     skipWhitespace();
                     boolean typaram = false;
                     if (ch == '<') {
                         typaram = true;
                         nextChar();
                     }
                     DCIdentifier id = identifier();
                     if (typaram) {
                         if (ch != '>')
                             throw new ParseException("dc.gt.expected");
                         nextChar();
                     }
                     skipWhitespace();
                     List<DCTree> desc = blockContent();
                     return m.at(pos).Param(typaram, id, desc);
                 }
             },
             // @return description
             new TagParser(Kind.BLOCK, DCTree.Kind.RETURN) {
                 public DCTree parse(int pos) {
                     List<DCTree> description = blockContent();
                     return m.at(pos).Return(description);
                 }
             },
             // @see reference | quoted-string | HTML
             new TagParser(Kind.BLOCK, DCTree.Kind.SEE) {
                 public DCTree parse(int pos) throws ParseException {
                     skipWhitespace();
                     switch (ch) {
                         case '"':
                             DCText string = quotedString();
                             if (string != null) {
                                 skipWhitespace();
                                 if (ch == '@')
                                     return m.at(pos).See(List.<DCTree>of(string));
                             }
                             break;
                         case '<':
                             List<DCTree> html = blockContent();
                             if (html != null)
                                 return m.at(pos).See(html);
                             break;
                         case '@':
                             if (newline)
                                 throw new ParseException("dc.no.content");
                             break;
                         case EOI:
                             if (bp == buf.length - 1)
                                 throw new ParseException("dc.no.content");
                             break;
                         default:
                             if (isJavaIdentifierStart(ch) || ch == '#') {
                                 DCReference ref = reference(true);
                                 List<DCTree> description = blockContent();
                                 return m.at(pos).See(description.prepend(ref));
                             }
                     }
                     throw new ParseException("dc.unexpected.content");
                 }
             },
             // @serialData data-description
             new TagParser(Kind.BLOCK, DCTree.Kind.SERIAL_DATA) {
                 public DCTree parse(int pos) {
                     List<DCTree> description = blockContent();
                     return m.at(pos).SerialData(description);
                 }
             },
             // @serialField field-name field-type description
             new TagParser(Kind.BLOCK, DCTree.Kind.SERIAL_FIELD) {
                 public DCTree parse(int pos) throws ParseException {
                     skipWhitespace();
                     DCIdentifier name = identifier();
                     skipWhitespace();
                     DCReference type = reference(false);
                     List<DCTree> description = null;
                     if (isWhitespace(ch)) {
                         skipWhitespace();
                         description = blockContent();
                     }
                     return m.at(pos).SerialField(name, type, description);
                 }
             },
             // @serial field-description | include | exclude
             new TagParser(Kind.BLOCK, DCTree.Kind.SERIAL) {
                 public DCTree parse(int pos) {
                     List<DCTree> description = blockContent();
                     return m.at(pos).Serial(description);
                 }
             },
             // @since since-text
             new TagParser(Kind.BLOCK, DCTree.Kind.SINCE) {
                 public DCTree parse(int pos) {
                     List<DCTree> description = blockContent();
                     return m.at(pos).Since(description);
                 }
             },
             // @throws class-name description
             new TagParser(Kind.BLOCK, DCTree.Kind.THROWS) {
                 public DCTree parse(int pos) throws ParseException {
                     skipWhitespace();
                     DCReference ref = reference(false);
                     List<DCTree> description = blockContent();
                     return m.at(pos).Throws(ref, description);
                 }
             },
             // {@value package.class#field}
             new TagParser(Kind.INLINE, DCTree.Kind.VALUE) {
                 public DCTree parse(int pos) throws ParseException {
                     DCReference ref = reference(true);
                     skipWhitespace();
                     if (ch == '}') {
                         nextChar();
                         return m.at(pos).Value(ref);
                     }
                     nextChar();
                     throw new ParseException("dc.unexpected.content");
                 }
             },
             // @version version-text
             new TagParser(Kind.BLOCK, DCTree.Kind.VERSION) {
                 public DCTree parse(int pos) {
                     List<DCTree> description = blockContent();
                     return m.at(pos).Version(description);
                 }
             },
         };
         tagParsers = new HashMap<Name,TagParser>();
         for (TagParser p: parsers)
             tagParsers.put(names.fromString(p.getTreeKind().tagName), p);
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java@a78f51d6bd5e (annotated)

src/share/classes/com/sun/tools/javac/parser/DocCommentParser.java