feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/com/sun/tools/javadoc/AbstractTypeImpl.java

@@ -0,0 +1,115 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Type;
+
+
+/**
+ * Abstract implementation of <code>Type</code>, with useful
+ * defaults for the methods in <code>Type</code> (and a couple from
+ * <code>ProgramElementDoc</code>).
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+abstract class AbstractTypeImpl implements com.sun.javadoc.Type {
+
+    protected final DocEnv env;
+    protected final Type type;
+
+    protected AbstractTypeImpl(DocEnv env, Type type) {
+        this.env = env;
+        this.type = type;
+    }
+
+    public String typeName() {
+        return type.tsym.name.toString();
+    }
+
+    public String qualifiedTypeName() {
+        return type.tsym.getQualifiedName().toString();
+    }
+
+    public com.sun.javadoc.Type getElementType() {
+        return null;
+    }
+
+    public String simpleTypeName() {
+        return type.tsym.name.toString();
+    }
+
+    public String name() {
+        return typeName();
+    }
+
+    public String qualifiedName() {
+        return qualifiedTypeName();
+    }
+
+    public String toString() {
+        return qualifiedTypeName();
+    }
+
+    public String dimension() {
+        return "";
+    }
+
+    public boolean isPrimitive() {
+        return false;
+    }
+
+    public ClassDoc asClassDoc() {
+        return null;
+    }
+
+    public TypeVariable asTypeVariable() {
+        return null;
+    }
+
+    public WildcardType asWildcardType() {
+        return null;
+    }
+
+    public ParameterizedType asParameterizedType() {
+        return null;
+    }
+
+    public AnnotationTypeDoc asAnnotationTypeDoc() {
+        return null;
+    }
+
+    public AnnotatedType asAnnotatedType() {
+        return null;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/AnnotatedTypeImpl.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Attribute.TypeCompound;
+import com.sun.tools.javac.util.List;
+
+/**
+ * Implementation of <code>AnnotatedType</code>, which
+ * represents an annotated type.
+ *
+ * @author Mahmood Ali
+ * @since 1.8
+ */
+public class AnnotatedTypeImpl
+        extends AbstractTypeImpl implements AnnotatedType {
+
+    AnnotatedTypeImpl(DocEnv env, com.sun.tools.javac.code.Type type) {
+        super(env, type);
+    }
+
+    /**
+     * Get the annotations of this program element.
+     * Return an empty array if there are none.
+     */
+    @Override
+    public AnnotationDesc[] annotations() {
+        List<? extends TypeCompound> tas = type.getAnnotationMirrors();
+        if (tas == null ||
+                tas.isEmpty()) {
+            return new AnnotationDesc[0];
+        }
+        AnnotationDesc res[] = new AnnotationDesc[tas.length()];
+        int i = 0;
+        for (Attribute.Compound a : tas) {
+            res[i++] = new AnnotationDescImpl(env, a);
+        }
+        return res;
+    }
+
+    @Override
+    public com.sun.javadoc.Type underlyingType() {
+        return TypeMaker.getType(env, type.unannotatedType(), true, false);
+    }
+
+    @Override
+    public AnnotatedType asAnnotatedType() {
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return typeName();
+    }
+
+    @Override
+    public String typeName() {
+        return this.underlyingType().typeName();
+    }
+
+    @Override
+    public String qualifiedTypeName() {
+        return this.underlyingType().qualifiedTypeName();
+    }
+
+    @Override
+    public String simpleTypeName() {
+        return this.underlyingType().simpleTypeName();
+    }
+
+    @Override
+    public String dimension() {
+        return this.underlyingType().dimension();
+    }
+
+    @Override
+    public boolean isPrimitive() {
+        return this.underlyingType().isPrimitive();
+    }
+
+    @Override
+    public ClassDoc asClassDoc() {
+        return this.underlyingType().asClassDoc();
+    }
+
+    @Override
+    public TypeVariable asTypeVariable() {
+        return this.underlyingType().asTypeVariable();
+    }
+
+    @Override
+    public WildcardType asWildcardType() {
+        return this.underlyingType().asWildcardType();
+    }
+
+    @Override
+    public ParameterizedType asParameterizedType() {
+        return this.underlyingType().asParameterizedType();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/AnnotationDescImpl.java

@@ -0,0 +1,175 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Pair;
+
+
+/**
+ * Represents an annotation.
+ * An annotation associates a value with each element of an annotation type.
+ * Sure it ought to be called "Annotation", but that clashes with
+ * java.lang.annotation.Annotation.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+
+public class AnnotationDescImpl implements AnnotationDesc {
+
+    private final DocEnv env;
+    private final Attribute.Compound annotation;
+
+
+    AnnotationDescImpl(DocEnv env, Attribute.Compound annotation) {
+        this.env = env;
+        this.annotation = annotation;
+    }
+
+    /**
+     * Returns the annotation type of this annotation.
+     */
+    public AnnotationTypeDoc annotationType() {
+        ClassSymbol atsym = (ClassSymbol)annotation.type.tsym;
+        if (annotation.type.isErroneous()) {
+            env.warning(null, "javadoc.class_not_found", annotation.type.toString());
+            return new AnnotationTypeDocImpl(env, atsym);
+        } else {
+            return (AnnotationTypeDoc)env.getClassDoc(atsym);
+        }
+    }
+
+    /**
+     * Returns this annotation's elements and their values.
+     * Only those explicitly present in the annotation are
+     * included, not those assuming their default values.
+     * Returns an empty array if there are none.
+     */
+    public ElementValuePair[] elementValues() {
+        List<Pair<MethodSymbol,Attribute>> vals = annotation.values;
+        ElementValuePair res[] = new ElementValuePair[vals.length()];
+        int i = 0;
+        for (Pair<MethodSymbol,Attribute> val : vals) {
+            res[i++] = new ElementValuePairImpl(env, val.fst, val.snd);
+        }
+        return res;
+    }
+
+    /**
+     * Check for the synthesized bit on the annotation.
+     *
+     * @return true if the annotation is synthesized.
+     */
+    public boolean isSynthesized() {
+        return annotation.isSynthesized();
+    }
+
+    /**
+     * Returns a string representation of this annotation.
+     * String is of one of the forms:
+     *     @com.example.foo(name1=val1, name2=val2)
+     *     @com.example.foo(val)
+     *     @com.example.foo
+     * Omit parens for marker annotations, and omit "value=" when allowed.
+     */
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder("@");
+        sb.append(annotation.type.tsym);
+
+        ElementValuePair vals[] = elementValues();
+        if (vals.length > 0) {          // omit parens for marker annotation
+            sb.append('(');
+            boolean first = true;
+            for (ElementValuePair val : vals) {
+                if (!first) {
+                    sb.append(", ");
+                }
+                first = false;
+
+                String name = val.element().name();
+                if (vals.length == 1 && name.equals("value")) {
+                    sb.append(val.value());
+                } else {
+                    sb.append(val);
+                }
+            }
+            sb.append(')');
+        }
+        return sb.toString();
+    }
+
+
+    /**
+     * Represents an association between an annotation type element
+     * and one of its values.
+     */
+    public static class ElementValuePairImpl implements ElementValuePair {
+
+        private final DocEnv env;
+        private final MethodSymbol meth;
+        private final Attribute value;
+
+        ElementValuePairImpl(DocEnv env, MethodSymbol meth, Attribute value) {
+            this.env = env;
+            this.meth = meth;
+            this.value = value;
+        }
+
+        /**
+         * Returns the annotation type element.
+         */
+        public AnnotationTypeElementDoc element() {
+            return env.getAnnotationTypeElementDoc(meth);
+        }
+
+        /**
+         * Returns the value associated with the annotation type element.
+         */
+        public AnnotationValue value() {
+            return new AnnotationValueImpl(env, value);
+        }
+
+        /**
+         * Returns a string representation of this pair
+         * of the form "name=value".
+         */
+        @Override
+        public String toString() {
+            return meth.name + "=" + value();
+        }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/AnnotationTypeDocImpl.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Scope;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.util.List;
+
+/**
+ * Represents an annotation type.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+
+public class AnnotationTypeDocImpl
+        extends ClassDocImpl implements AnnotationTypeDoc {
+
+    public AnnotationTypeDocImpl(DocEnv env, ClassSymbol sym) {
+        this(env, sym, null);
+    }
+
+    public AnnotationTypeDocImpl(DocEnv env, ClassSymbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+    }
+
+    /**
+     * Returns true, as this is an annotation type.
+     * (For legacy doclets, return false.)
+     */
+    public boolean isAnnotationType() {
+        return !isInterface();
+    }
+
+    /**
+     * Returns false.  Though technically an interface, an annotation
+     * type is not considered an interface for this purpose.
+     * (For legacy doclets, returns true.)
+     */
+    public boolean isInterface() {
+        return env.legacyDoclet;
+    }
+
+    /**
+     * Returns an empty array, as all methods are annotation type elements.
+     * (For legacy doclets, returns the elements.)
+     * @see #elements()
+     */
+    public MethodDoc[] methods(boolean filter) {
+        return env.legacyDoclet
+                ? (MethodDoc[])elements()
+                : new MethodDoc[0];
+    }
+
+    /**
+     * Returns the elements of this annotation type.
+     * Returns an empty array if there are none.
+     * Elements are always public, so no need to filter them.
+     */
+    public AnnotationTypeElementDoc[] elements() {
+        List<AnnotationTypeElementDoc> elements = List.nil();
+        for (Scope.Entry e = tsym.members().elems; e != null; e = e.sibling) {
+            if (e.sym != null && e.sym.kind == Kinds.MTH) {
+                MethodSymbol s = (MethodSymbol)e.sym;
+                elements = elements.prepend(env.getAnnotationTypeElementDoc(s));
+            }
+        }
+        return
+            elements.toArray(new AnnotationTypeElementDoc[elements.length()]);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/AnnotationTypeElementDocImpl.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Symbol.*;
+
+/**
+ * Represents an element of an annotation type.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+
+public class AnnotationTypeElementDocImpl
+        extends MethodDocImpl implements AnnotationTypeElementDoc {
+
+    public AnnotationTypeElementDocImpl(DocEnv env, MethodSymbol sym) {
+        super(env, sym);
+    }
+
+    public AnnotationTypeElementDocImpl(DocEnv env, MethodSymbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+    }
+
+    /**
+     * Returns true, as this is an annotation type element.
+     * (For legacy doclets, return false.)
+     */
+    public boolean isAnnotationTypeElement() {
+        return !isMethod();
+    }
+
+    /**
+     * Returns false.  Although this is technically a method, we don't
+     * consider it one for this purpose.
+     * (For legacy doclets, return true.)
+     */
+    public boolean isMethod() {
+        return env.legacyDoclet;
+    }
+
+    /**
+     * Returns false, even though this is indeed abstract.  See
+     * MethodDocImpl.isAbstract() for the (il)logic behind this.
+     */
+    public boolean isAbstract() {
+        return false;
+    }
+
+    /**
+     * Returns the default value of this element.
+     * Returns null if this element has no default.
+     */
+    public AnnotationValue defaultValue() {
+        return (sym.defaultValue == null)
+               ? null
+               : new AnnotationValueImpl(env, sym.defaultValue);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/AnnotationValueImpl.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Attribute;
+
+import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
+
+/**
+ * Represents a value of an annotation type element.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+
+public class AnnotationValueImpl implements AnnotationValue {
+
+    private final DocEnv env;
+    private final Attribute attr;
+
+
+    AnnotationValueImpl(DocEnv env, Attribute attr) {
+        this.env = env;
+        this.attr = attr;
+    }
+
+    /**
+     * Returns the value.
+     * The type of the returned object is one of the following:
+     * <ul><li> a wrapper class for a primitive type
+     *     <li> <code>String</code>
+     *     <li> <code>Type</code> (representing a class literal)
+     *     <li> <code>FieldDoc</code> (representing an enum constant)
+     *     <li> <code>AnnotationDesc</code>
+     *     <li> <code>AnnotationValue[]</code>
+     * </ul>
+     */
+    public Object value() {
+        ValueVisitor vv = new ValueVisitor();
+        attr.accept(vv);
+        return vv.value;
+    }
+
+    private class ValueVisitor implements Attribute.Visitor {
+        public Object value;
+
+        public void visitConstant(Attribute.Constant c) {
+            if (c.type.hasTag(BOOLEAN)) {
+                // javac represents false and true as integers 0 and 1
+                value = Boolean.valueOf(
+                                ((Integer)c.value).intValue() != 0);
+            } else {
+                value = c.value;
+            }
+        }
+
+        public void visitClass(Attribute.Class c) {
+            value = TypeMaker.getType(env,
+                                      env.types.erasure(c.classType));
+        }
+
+        public void visitEnum(Attribute.Enum e) {
+            value = env.getFieldDoc(e.value);
+        }
+
+        public void visitCompound(Attribute.Compound c) {
+            value = new AnnotationDescImpl(env, c);
+        }
+
+        public void visitArray(Attribute.Array a) {
+            AnnotationValue vals[] = new AnnotationValue[a.values.length];
+            for (int i = 0; i < vals.length; i++) {
+                vals[i] = new AnnotationValueImpl(env, a.values[i]);
+            }
+            value = vals;
+        }
+
+        public void visitError(Attribute.Error e) {
+            value = "<error>";
+        }
+    }
+
+    /**
+     * Returns a string representation of the value.
+     *
+     * @return the text of a Java language annotation value expression
+     *          whose value is the value of this annotation type element.
+     */
+    @Override
+    public String toString() {
+        ToStringVisitor tv = new ToStringVisitor();
+        attr.accept(tv);
+        return tv.toString();
+    }
+
+    private class ToStringVisitor implements Attribute.Visitor {
+        private final StringBuilder sb = new StringBuilder();
+
+        @Override
+        public String toString() {
+            return sb.toString();
+        }
+
+        public void visitConstant(Attribute.Constant c) {
+            if (c.type.hasTag(BOOLEAN)) {
+                // javac represents false and true as integers 0 and 1
+                sb.append(((Integer)c.value).intValue() != 0);
+            } else {
+                sb.append(FieldDocImpl.constantValueExpression(c.value));
+            }
+        }
+
+        public void visitClass(Attribute.Class c) {
+            sb.append(c);
+        }
+
+        public void visitEnum(Attribute.Enum e) {
+            sb.append(e);
+        }
+
+        public void visitCompound(Attribute.Compound c) {
+            sb.append(new AnnotationDescImpl(env, c));
+        }
+
+        public void visitArray(Attribute.Array a) {
+            // Omit braces from singleton.
+            if (a.values.length != 1) sb.append('{');
+
+            boolean first = true;
+            for (Attribute elem : a.values) {
+                if (first) {
+                    first = false;
+                } else {
+                    sb.append(", ");
+                }
+                elem.accept(this);
+            }
+            // Omit braces from singleton.
+            if (a.values.length != 1) sb.append('}');
+        }
+
+        public void visitError(Attribute.Error e) {
+            sb.append("<error>");
+        }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/Comment.java

@@ -0,0 +1,450 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import com.sun.javadoc.*;
+import com.sun.tools.javac.util.ListBuffer;
+
+/**
+ * Comment contains all information in comment part.
+ *      It allows users to get first sentence of this comment, get
+ *      comment for different tags...
+ *
+ *  <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>
+ *
+ * @author Kaiyang Liu (original)
+ * @author Robert Field (rewrite)
+ * @author Atul M Dambalkar
+ * @author Neal Gafter (rewrite)
+ */
+class Comment {
+
+    /**
+     * sorted comments with different tags.
+     */
+    private final ListBuffer<Tag> tagList = new ListBuffer<Tag>();
+
+    /**
+     * text minus any tags.
+     */
+    private String text;
+
+    /**
+     * Doc environment
+     */
+    private final DocEnv docenv;
+
+    /**
+     * constructor of Comment.
+     */
+    Comment(final DocImpl holder, final String commentString) {
+        this.docenv = holder.env;
+
+        /**
+         * Separate the comment into the text part and zero to N tags.
+         * Simple state machine is in one of three states:
+         * <pre>
+         * IN_TEXT: parsing the comment text or tag text.
+         * TAG_NAME: parsing the name of a tag.
+         * TAG_GAP: skipping through the gap between the tag name and
+         * the tag text.
+         * </pre>
+         */
+        @SuppressWarnings("fallthrough")
+        class CommentStringParser {
+            /**
+             * The entry point to the comment string parser
+             */
+            void parseCommentStateMachine() {
+                final int IN_TEXT = 1;
+                final int TAG_GAP = 2;
+                final int TAG_NAME = 3;
+                int state = TAG_GAP;
+                boolean newLine = true;
+                String tagName = null;
+                int tagStart = 0;
+                int textStart = 0;
+                int lastNonWhite = -1;
+                int len = commentString.length();
+                for (int inx = 0; inx < len; ++inx) {
+                    char ch = commentString.charAt(inx);
+                    boolean isWhite = Character.isWhitespace(ch);
+                    switch (state)  {
+                        case TAG_NAME:
+                            if (isWhite) {
+                                tagName = commentString.substring(tagStart, inx);
+                                state = TAG_GAP;
+                            }
+                            break;
+                        case TAG_GAP:
+                            if (isWhite) {
+                                break;
+                            }
+                            textStart = inx;
+                            state = IN_TEXT;
+                            /* fall thru */
+                        case IN_TEXT:
+                            if (newLine && ch == '@') {
+                                parseCommentComponent(tagName, textStart,
+                                                      lastNonWhite+1);
+                                tagStart = inx;
+                                state = TAG_NAME;
+                            }
+                            break;
+                    }
+                    if (ch == '\n') {
+                        newLine = true;
+                    } else if (!isWhite) {
+                        lastNonWhite = inx;
+                        newLine = false;
+                    }
+                }
+                // Finish what's currently being processed
+                switch (state)  {
+                    case TAG_NAME:
+                        tagName = commentString.substring(tagStart, len);
+                        /* fall thru */
+                    case TAG_GAP:
+                        textStart = len;
+                        /* fall thru */
+                    case IN_TEXT:
+                        parseCommentComponent(tagName, textStart, lastNonWhite+1);
+                        break;
+                }
+            }
+
+            /**
+             * Save away the last parsed item.
+             */
+            void parseCommentComponent(String tagName,
+                                       int from, int upto) {
+                String tx = upto <= from ? "" : commentString.substring(from, upto);
+                if (tagName == null) {
+                    text = tx;
+                } else {
+                    TagImpl tag;
+                    if (tagName.equals("@exception") || tagName.equals("@throws")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new ThrowsTagImpl(holder, tagName, tx);
+                    } else if (tagName.equals("@param")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new ParamTagImpl(holder, tagName, tx);
+                    } else if (tagName.equals("@see")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new SeeTagImpl(holder, tagName, tx);
+                    } else if (tagName.equals("@serialField")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new SerialFieldTagImpl(holder, tagName, tx);
+                    } else if (tagName.equals("@return")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new TagImpl(holder, tagName, tx);
+                    } else if (tagName.equals("@author")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new TagImpl(holder, tagName, tx);
+                    } else if (tagName.equals("@version")) {
+                        warnIfEmpty(tagName, tx);
+                        tag = new TagImpl(holder, tagName, tx);
+                    } else {
+                        tag = new TagImpl(holder, tagName, tx);
+                    }
+                    tagList.append(tag);
+                }
+            }
+
+            void warnIfEmpty(String tagName, String tx) {
+                if (tx.length() == 0) {
+                    docenv.warning(holder, "tag.tag_has_no_arguments", tagName);
+                }
+            }
+
+        }
+
+        new CommentStringParser().parseCommentStateMachine();
+    }
+
+    /**
+     * Return the text of the comment.
+     */
+    String commentText() {
+        return text;
+    }
+
+    /**
+     * Return all tags in this comment.
+     */
+    Tag[] tags() {
+        return tagList.toArray(new Tag[tagList.length()]);
+    }
+
+    /**
+     * Return tags of the specified kind in this comment.
+     */
+    Tag[] tags(String tagname) {
+        ListBuffer<Tag> found = new ListBuffer<Tag>();
+        String target = tagname;
+        if (target.charAt(0) != '@') {
+            target = "@" + target;
+        }
+        for (Tag tag : tagList) {
+            if (tag.kind().equals(target)) {
+                found.append(tag);
+            }
+        }
+        return found.toArray(new Tag[found.length()]);
+    }
+
+    /**
+     * Return throws tags in this comment.
+     */
+    ThrowsTag[] throwsTags() {
+        ListBuffer<ThrowsTag> found = new ListBuffer<ThrowsTag>();
+        for (Tag next : tagList) {
+            if (next instanceof ThrowsTag) {
+                found.append((ThrowsTag)next);
+            }
+        }
+        return found.toArray(new ThrowsTag[found.length()]);
+    }
+
+    /**
+     * Return param tags (excluding type param tags) in this comment.
+     */
+    ParamTag[] paramTags() {
+        return paramTags(false);
+    }
+
+    /**
+     * Return type param tags in this comment.
+     */
+    ParamTag[] typeParamTags() {
+        return paramTags(true);
+    }
+
+    /**
+     * Return param tags in this comment.  If typeParams is true
+     * include only type param tags, otherwise include only ordinary
+     * param tags.
+     */
+    private ParamTag[] paramTags(boolean typeParams) {
+        ListBuffer<ParamTag> found = new ListBuffer<ParamTag>();
+        for (Tag next : tagList) {
+            if (next instanceof ParamTag) {
+                ParamTag p = (ParamTag)next;
+                if (typeParams == p.isTypeParameter()) {
+                    found.append(p);
+                }
+            }
+        }
+        return found.toArray(new ParamTag[found.length()]);
+    }
+
+    /**
+     * Return see also tags in this comment.
+     */
+    SeeTag[] seeTags() {
+        ListBuffer<SeeTag> found = new ListBuffer<SeeTag>();
+        for (Tag next : tagList) {
+            if (next instanceof SeeTag) {
+                found.append((SeeTag)next);
+            }
+        }
+        return found.toArray(new SeeTag[found.length()]);
+    }
+
+    /**
+     * Return serialField tags in this comment.
+     */
+    SerialFieldTag[] serialFieldTags() {
+        ListBuffer<SerialFieldTag> found = new ListBuffer<SerialFieldTag>();
+        for (Tag next : tagList) {
+            if (next instanceof SerialFieldTag) {
+                found.append((SerialFieldTag)next);
+            }
+        }
+        return found.toArray(new SerialFieldTag[found.length()]);
+    }
+
+    /**
+     * Return array of tags with text and inline See Tags for a Doc comment.
+     */
+    static Tag[] getInlineTags(DocImpl holder, String inlinetext) {
+        ListBuffer<Tag> taglist = new ListBuffer<Tag>();
+        int delimend = 0, textstart = 0, len = inlinetext.length();
+        boolean inPre = false;
+        DocEnv docenv = holder.env;
+
+        if (len == 0) {
+            return taglist.toArray(new Tag[taglist.length()]);
+        }
+        while (true) {
+            int linkstart;
+            if ((linkstart = inlineTagFound(holder, inlinetext,
+                                            textstart)) == -1) {
+                taglist.append(new TagImpl(holder, "Text",
+                                           inlinetext.substring(textstart)));
+                break;
+            } else {
+                inPre = scanForPre(inlinetext, textstart, linkstart, inPre);
+                int seetextstart = linkstart;
+                for (int i = linkstart; i < inlinetext.length(); i++) {
+                    char c = inlinetext.charAt(i);
+                    if (Character.isWhitespace(c) ||
+                        c == '}') {
+                        seetextstart = i;
+                        break;
+                     }
+                }
+                String linkName = inlinetext.substring(linkstart+2, seetextstart);
+                if (!(inPre && (linkName.equals("code") || linkName.equals("literal")))) {
+                    //Move past the white space after the inline tag name.
+                    while (Character.isWhitespace(inlinetext.
+                                                      charAt(seetextstart))) {
+                        if (inlinetext.length() <= seetextstart) {
+                            taglist.append(new TagImpl(holder, "Text",
+                                                       inlinetext.substring(textstart, seetextstart)));
+                            docenv.warning(holder,
+                                           "tag.Improper_Use_Of_Link_Tag",
+                                           inlinetext);
+                            return taglist.toArray(new Tag[taglist.length()]);
+                        } else {
+                            seetextstart++;
+                        }
+                    }
+                }
+                taglist.append(new TagImpl(holder, "Text",
+                                           inlinetext.substring(textstart, linkstart)));
+                textstart = seetextstart;   // this text is actually seetag
+                if ((delimend = findInlineTagDelim(inlinetext, textstart)) == -1) {
+                    //Missing closing '}' character.
+                    // store the text as it is with the {@link.
+                    taglist.append(new TagImpl(holder, "Text",
+                                               inlinetext.substring(textstart)));
+                    docenv.warning(holder,
+                                   "tag.End_delimiter_missing_for_possible_SeeTag",
+                                   inlinetext);
+                    return taglist.toArray(new Tag[taglist.length()]);
+                } else {
+                    //Found closing '}' character.
+                    if (linkName.equals("see")
+                           || linkName.equals("link")
+                           || linkName.equals("linkplain")) {
+                        taglist.append( new SeeTagImpl(holder, "@" + linkName,
+                              inlinetext.substring(textstart, delimend)));
+                    } else {
+                        taglist.append( new TagImpl(holder, "@" + linkName,
+                              inlinetext.substring(textstart, delimend)));
+                    }
+                    textstart = delimend + 1;
+                }
+            }
+            if (textstart == inlinetext.length()) {
+                break;
+            }
+        }
+        return taglist.toArray(new Tag[taglist.length()]);
+    }
+
+    /** regex for case-insensitive match for {@literal <pre> } and  {@literal </pre> }. */
+    private static final Pattern prePat = Pattern.compile("(?i)<(/?)pre>");
+
+    private static boolean scanForPre(String inlinetext, int start, int end, boolean inPre) {
+        Matcher m = prePat.matcher(inlinetext).region(start, end);
+        while (m.find()) {
+            inPre = m.group(1).isEmpty();
+        }
+        return inPre;
+    }
+
+    /**
+     * Recursively find the index of the closing '}' character for an inline tag
+     * and return it.  If it can't be found, return -1.
+     * @param inlineText the text to search in.
+     * @param searchStart the index of the place to start searching at.
+     * @return the index of the closing '}' character for an inline tag.
+     * If it can't be found, return -1.
+     */
+    private static int findInlineTagDelim(String inlineText, int searchStart) {
+        int delimEnd, nestedOpenBrace;
+        if ((delimEnd = inlineText.indexOf("}", searchStart)) == -1) {
+            return -1;
+        } else if (((nestedOpenBrace = inlineText.indexOf("{", searchStart)) != -1) &&
+            nestedOpenBrace < delimEnd){
+            //Found a nested open brace.
+            int nestedCloseBrace = findInlineTagDelim(inlineText, nestedOpenBrace + 1);
+            return (nestedCloseBrace != -1) ?
+                findInlineTagDelim(inlineText, nestedCloseBrace + 1) :
+                -1;
+        } else {
+            return delimEnd;
+        }
+    }
+
+    /**
+     * Recursively search for the characters '{', '@', followed by
+     * name of inline tag and white space,
+     * if found
+     *    return the index of the text following the white space.
+     * else
+     *    return -1.
+     */
+    private static int inlineTagFound(DocImpl holder, String inlinetext, int start) {
+        DocEnv docenv = holder.env;
+        int linkstart = inlinetext.indexOf("{@", start);
+        if (start == inlinetext.length() || linkstart == -1) {
+            return -1;
+        } else if (inlinetext.indexOf('}', linkstart) == -1) {
+            //Missing '}'.
+            docenv.warning(holder, "tag.Improper_Use_Of_Link_Tag",
+                    inlinetext.substring(linkstart, inlinetext.length()));
+            return -1;
+        } else {
+            return linkstart;
+        }
+    }
+
+
+    /**
+     * Return array of tags for the locale specific first sentence in the text.
+     */
+    static Tag[] firstSentenceTags(DocImpl holder, String text) {
+        DocLocale doclocale = holder.env.doclocale;
+        return getInlineTags(holder,
+                             doclocale.localeSpecificFirstSentence(holder, text));
+    }
+
+    /**
+     * Return text for this Doc comment.
+     */
+    @Override
+    public String toString() {
+        return text;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ConstructorDocImpl.java

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+
+/**
+ * Represents a constructor of a java class.
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ */
+
+public class ConstructorDocImpl
+        extends ExecutableMemberDocImpl implements ConstructorDoc {
+
+    /**
+     * constructor.
+     */
+    public ConstructorDocImpl(DocEnv env, MethodSymbol sym) {
+        super(env, sym);
+    }
+
+    /**
+     * constructor.
+     */
+    public ConstructorDocImpl(DocEnv env, MethodSymbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+    }
+
+    /**
+     * Return true if it is a constructor, which it is.
+     *
+     * @return true
+     */
+    public boolean isConstructor() {
+        return true;
+    }
+
+    /**
+     * Get the name.
+     *
+     * @return the name of the member.
+     */
+    public String name() {
+        ClassSymbol c = sym.enclClass();
+        return c.name.toString();
+    }
+
+    /**
+     * Get the name.
+     *
+     * @return the qualified name of the member.
+     */
+    public String qualifiedName() {
+        return sym.enclClass().getQualifiedName().toString();
+    }
+
+    /**
+     * Returns a string representation of this constructor.  Includes the
+     * qualified signature and any type parameters.
+     * Type parameters precede the class name, as they do in the syntax
+     * for invoking constructors with explicit type parameters using "new".
+     * (This is unlike the syntax for invoking methods with explicit type
+     * parameters.)
+     */
+    public String toString() {
+        return typeParametersString() + qualifiedName() + signature();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/DocEnv.java

@@ -0,0 +1,850 @@
+/*
+ * Copyright (c) 2000, 2016, 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.javadoc;
+
+import java.lang.reflect.Modifier;
+import java.util.*;
+
+import javax.tools.JavaFileManager;
+
+import com.sun.javadoc.*;
+import com.sun.source.util.JavacTask;
+import com.sun.source.util.TreePath;
+import com.sun.tools.doclint.DocLint;
+import com.sun.tools.javac.api.BasicJavacTask;
+import com.sun.tools.javac.code.*;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.code.Type.ClassType;
+import com.sun.tools.javac.comp.Check;
+import com.sun.tools.javac.file.JavacFileManager;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Names;
+
+/**
+ * Holds the environment for a run of javadoc.
+ * Holds only the information needed throughout the
+ * run and not the compiler info that could be GC'ed
+ * or ported.
+ *
+ *  <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>
+ *
+ * @since 1.4
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ * @author Scott Seligman (generics)
+ */
+public class DocEnv {
+    protected static final Context.Key<DocEnv> docEnvKey =
+        new Context.Key<DocEnv>();
+
+    public static DocEnv instance(Context context) {
+        DocEnv instance = context.get(docEnvKey);
+        if (instance == null)
+            instance = new DocEnv(context);
+        return instance;
+    }
+
+    private Messager messager;
+
+    DocLocale doclocale;
+
+    /** Predefined symbols known to the compiler. */
+    Symtab syms;
+
+    /** Referenced directly in RootDocImpl. */
+    JavadocClassReader reader;
+
+    /** Javadoc's own version of the compiler's enter phase. */
+    JavadocEnter enter;
+
+    /** The name table. */
+    private final Names names;
+
+    /** The encoding name. */
+    private String encoding;
+
+    final Symbol externalizableSym;
+
+    /** Access filter (public, protected, ...).  */
+    protected ModifierFilter showAccess;
+
+    /** True if we are using a sentence BreakIterator. */
+    boolean breakiterator;
+
+    /**
+     * True if we do not want to print any notifications at all.
+     */
+    boolean quiet = false;
+
+    Check chk;
+    Types types;
+    JavaFileManager fileManager;
+    Context context;
+    DocLint doclint;
+    JavaScriptScanner javaScriptScanner;
+
+    WeakHashMap<JCTree, TreePath> treePaths = new WeakHashMap<JCTree, TreePath>();
+
+    /** Allow documenting from class files? */
+    boolean docClasses = false;
+
+    /** Does the doclet only expect pre-1.5 doclet API? */
+    protected boolean legacyDoclet = true;
+
+    /**
+     * Set this to true if you would like to not emit any errors, warnings and
+     * notices.
+     */
+    private boolean silent = false;
+
+    /**
+     * The source language version.
+     */
+    protected Source source;
+
+    /**
+     * Constructor
+     *
+     * @param context      Context for this javadoc instance.
+     */
+    protected DocEnv(Context context) {
+        context.put(docEnvKey, this);
+        this.context = context;
+
+        messager = Messager.instance0(context);
+        syms = Symtab.instance(context);
+        reader = JavadocClassReader.instance0(context);
+        enter = JavadocEnter.instance0(context);
+        names = Names.instance(context);
+        externalizableSym = reader.enterClass(names.fromString("java.io.Externalizable"));
+        chk = Check.instance(context);
+        types = Types.instance(context);
+        fileManager = context.get(JavaFileManager.class);
+        if (fileManager instanceof JavacFileManager) {
+            ((JavacFileManager)fileManager).setSymbolFileEnabled(false);
+        }
+
+        // Default.  Should normally be reset with setLocale.
+        this.doclocale = new DocLocale(this, "", breakiterator);
+        source = Source.instance(context);
+    }
+
+    public void setSilent(boolean silent) {
+        this.silent = silent;
+    }
+
+    /**
+     * Look up ClassDoc by qualified name.
+     */
+    public ClassDocImpl lookupClass(String name) {
+        ClassSymbol c = getClassSymbol(name);
+        if (c != null) {
+            return getClassDoc(c);
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Load ClassDoc by qualified name.
+     */
+    public ClassDocImpl loadClass(String name) {
+        try {
+            ClassSymbol c = reader.loadClass(names.fromString(name));
+            return getClassDoc(c);
+        } catch (CompletionFailure ex) {
+            chk.completionError(null, ex);
+            return null;
+        }
+    }
+
+    /**
+     * Look up PackageDoc by qualified name.
+     */
+    public PackageDocImpl lookupPackage(String name) {
+        //### Jing alleges that class check is needed
+        //### to avoid a compiler bug.  Most likely
+        //### instead a dummy created for error recovery.
+        //### Should investigate this.
+        PackageSymbol p = syms.packages.get(names.fromString(name));
+        ClassSymbol c = getClassSymbol(name);
+        if (p != null && c == null) {
+            return getPackageDoc(p);
+        } else {
+            return null;
+        }
+    }
+        // where
+        /** Retrieve class symbol by fully-qualified name.
+         */
+        ClassSymbol getClassSymbol(String name) {
+            // Name may contain nested class qualification.
+            // Generate candidate flatnames with successively shorter
+            // package qualifiers and longer nested class qualifiers.
+            int nameLen = name.length();
+            char[] nameChars = name.toCharArray();
+            int idx = name.length();
+            for (;;) {
+                ClassSymbol s = syms.classes.get(names.fromChars(nameChars, 0, nameLen));
+                if (s != null)
+                    return s; // found it!
+                idx = name.substring(0, idx).lastIndexOf('.');
+                if (idx < 0) break;
+                nameChars[idx] = '$';
+            }
+            return null;
+        }
+
+    /**
+     * Set the locale.
+     */
+    public void setLocale(String localeName) {
+        // create locale specifics
+        doclocale = new DocLocale(this, localeName, breakiterator);
+        // update Messager if locale has changed.
+        messager.setLocale(doclocale.locale);
+    }
+
+    /** Check whether this member should be documented. */
+    public boolean shouldDocument(VarSymbol sym) {
+        long mod = sym.flags();
+
+        if ((mod & Flags.SYNTHETIC) != 0) {
+            return false;
+        }
+
+        return showAccess.checkModifier(translateModifiers(mod));
+    }
+
+    /** Check whether this member should be documented. */
+    public boolean shouldDocument(MethodSymbol sym) {
+        long mod = sym.flags();
+
+        if ((mod & Flags.SYNTHETIC) != 0) {
+            return false;
+        }
+
+        return showAccess.checkModifier(translateModifiers(mod));
+    }
+
+    /** check whether this class should be documented. */
+    public boolean shouldDocument(ClassSymbol sym) {
+        return
+            (sym.flags_field&Flags.SYNTHETIC) == 0 && // no synthetics
+            (docClasses || getClassDoc(sym).tree != null) &&
+            isVisible(sym);
+    }
+
+    //### Comment below is inaccurate wrt modifier filter testing
+    /**
+     * Check the visibility if this is an nested class.
+     * if this is not a nested class, return true.
+     * if this is an static visible nested class,
+     *    return true.
+     * if this is an visible nested class
+     *    if the outer class is visible return true.
+     *    else return false.
+     * IMPORTANT: This also allows, static nested classes
+     * to be defined inside an nested class, which is not
+     * allowed by the compiler. So such an test case will
+     * not reach upto this method itself, but if compiler
+     * allows it, then that will go through.
+     */
+    protected boolean isVisible(ClassSymbol sym) {
+        long mod = sym.flags_field;
+        if (!showAccess.checkModifier(translateModifiers(mod))) {
+            return false;
+        }
+        ClassSymbol encl = sym.owner.enclClass();
+        return (encl == null || (mod & Flags.STATIC) != 0 || isVisible(encl));
+    }
+
+    //---------------- print forwarders ----------------//
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param msg message to print.
+     */
+    public void printError(String msg) {
+        if (silent)
+            return;
+        messager.printError(msg);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param key selects message from resource
+     */
+    public void error(DocImpl doc, String key) {
+        if (silent)
+            return;
+        messager.error(doc==null ? null : doc.position(), key);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param key selects message from resource
+     */
+    public void error(SourcePosition pos, String key) {
+        if (silent)
+            return;
+        messager.error(pos, key);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param msg message to print.
+     */
+    public void printError(SourcePosition pos, String msg) {
+        if (silent)
+            return;
+        messager.printError(pos, msg);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     */
+    public void error(DocImpl doc, String key, String a1) {
+        if (silent)
+            return;
+        messager.error(doc==null ? null : doc.position(), key, a1);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     */
+    public void error(DocImpl doc, String key, String a1, String a2) {
+        if (silent)
+            return;
+        messager.error(doc==null ? null : doc.position(), key, a1, a2);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     * @param a3 third argument
+     */
+    public void error(DocImpl doc, String key, String a1, String a2, String a3) {
+        if (silent)
+            return;
+        messager.error(doc==null ? null : doc.position(), key, a1, a2, a3);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param msg message to print.
+     */
+    public void printWarning(String msg) {
+        if (silent)
+            return;
+        messager.printWarning(msg);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param key selects message from resource
+     */
+    public void warning(DocImpl doc, String key) {
+        if (silent)
+            return;
+        messager.warning(doc==null ? null : doc.position(), key);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param msg message to print.
+     */
+    public void printWarning(SourcePosition pos, String msg) {
+        if (silent)
+            return;
+        messager.printWarning(pos, msg);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     */
+    public void warning(DocImpl doc, String key, String a1) {
+        if (silent)
+            return;
+        // suppress messages that have (probably) been covered by doclint
+        if (doclint != null && doc != null && key.startsWith("tag"))
+            return;
+        messager.warning(doc==null ? null : doc.position(), key, a1);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     */
+    public void warning(DocImpl doc, String key, String a1, String a2) {
+        if (silent)
+            return;
+        messager.warning(doc==null ? null : doc.position(), key, a1, a2);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     * @param a3 third argument
+     */
+    public void warning(DocImpl doc, String key, String a1, String a2, String a3) {
+        if (silent)
+            return;
+        messager.warning(doc==null ? null : doc.position(), key, a1, a2, a3);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     * @param a3 third argument
+     */
+    public void warning(DocImpl doc, String key, String a1, String a2, String a3,
+                        String a4) {
+        if (silent)
+            return;
+        messager.warning(doc==null ? null : doc.position(), key, a1, a2, a3, a4);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param msg message to print.
+     */
+    public void printNotice(String msg) {
+        if (silent || quiet)
+            return;
+        messager.printNotice(msg);
+    }
+
+
+    /**
+     * Print a message.
+     *
+     * @param key selects message from resource
+     */
+    public void notice(String key) {
+        if (silent || quiet)
+            return;
+        messager.notice(key);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param msg message to print.
+     */
+    public void printNotice(SourcePosition pos, String msg) {
+        if (silent || quiet)
+            return;
+        messager.printNotice(pos, msg);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     */
+    public void notice(String key, String a1) {
+        if (silent || quiet)
+            return;
+        messager.notice(key, a1);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     */
+    public void notice(String key, String a1, String a2) {
+        if (silent || quiet)
+            return;
+        messager.notice(key, a1, a2);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param key selects message from resource
+     * @param a1 first argument
+     * @param a2 second argument
+     * @param a3 third argument
+     */
+    public void notice(String key, String a1, String a2, String a3) {
+        if (silent || quiet)
+            return;
+        messager.notice(key, a1, a2, a3);
+    }
+
+    /**
+     * Exit, reporting errors and warnings.
+     */
+    public void exit() {
+        // Messager should be replaced by a more general
+        // compilation environment.  This can probably
+        // subsume DocEnv as well.
+        messager.exit();
+    }
+
+    protected Map<PackageSymbol, PackageDocImpl> packageMap =
+            new HashMap<PackageSymbol, PackageDocImpl>();
+    /**
+     * Return the PackageDoc of this package symbol.
+     */
+    public PackageDocImpl getPackageDoc(PackageSymbol pack) {
+        PackageDocImpl result = packageMap.get(pack);
+        if (result != null) return result;
+        result = new PackageDocImpl(this, pack);
+        packageMap.put(pack, result);
+        return result;
+    }
+
+    /**
+     * Create the PackageDoc (or a subtype) for a package symbol.
+     */
+    void makePackageDoc(PackageSymbol pack, TreePath treePath) {
+        PackageDocImpl result = packageMap.get(pack);
+        if (result != null) {
+            if (treePath != null) result.setTreePath(treePath);
+        } else {
+            result = new PackageDocImpl(this, pack, treePath);
+            packageMap.put(pack, result);
+        }
+    }
+
+
+    protected Map<ClassSymbol, ClassDocImpl> classMap =
+            new HashMap<ClassSymbol, ClassDocImpl>();
+    /**
+     * Return the ClassDoc (or a subtype) of this class symbol.
+     */
+    public ClassDocImpl getClassDoc(ClassSymbol clazz) {
+        ClassDocImpl result = classMap.get(clazz);
+        if (result != null) return result;
+        if (isAnnotationType(clazz)) {
+            result = new AnnotationTypeDocImpl(this, clazz);
+        } else {
+            result = new ClassDocImpl(this, clazz);
+        }
+        classMap.put(clazz, result);
+        return result;
+    }
+
+    /**
+     * Create the ClassDoc (or a subtype) for a class symbol.
+     */
+    protected void makeClassDoc(ClassSymbol clazz, TreePath treePath) {
+        ClassDocImpl result = classMap.get(clazz);
+        if (result != null) {
+            if (treePath != null) result.setTreePath(treePath);
+            return;
+        }
+        if (isAnnotationType((JCClassDecl) treePath.getLeaf())) {   // flags of clazz may not yet be set
+            result = new AnnotationTypeDocImpl(this, clazz, treePath);
+        } else {
+            result = new ClassDocImpl(this, clazz, treePath);
+        }
+        classMap.put(clazz, result);
+    }
+
+    protected static boolean isAnnotationType(ClassSymbol clazz) {
+        return ClassDocImpl.isAnnotationType(clazz);
+    }
+
+    protected static boolean isAnnotationType(JCClassDecl tree) {
+        return (tree.mods.flags & Flags.ANNOTATION) != 0;
+    }
+
+    protected Map<VarSymbol, FieldDocImpl> fieldMap =
+            new HashMap<VarSymbol, FieldDocImpl>();
+    /**
+     * Return the FieldDoc of this var symbol.
+     */
+    public FieldDocImpl getFieldDoc(VarSymbol var) {
+        FieldDocImpl result = fieldMap.get(var);
+        if (result != null) return result;
+        result = new FieldDocImpl(this, var);
+        fieldMap.put(var, result);
+        return result;
+    }
+    /**
+     * Create a FieldDoc for a var symbol.
+     */
+    protected void makeFieldDoc(VarSymbol var, TreePath treePath) {
+        FieldDocImpl result = fieldMap.get(var);
+        if (result != null) {
+            if (treePath != null) result.setTreePath(treePath);
+        } else {
+            result = new FieldDocImpl(this, var, treePath);
+            fieldMap.put(var, result);
+        }
+    }
+
+    protected Map<MethodSymbol, ExecutableMemberDocImpl> methodMap =
+            new HashMap<MethodSymbol, ExecutableMemberDocImpl>();
+    /**
+     * Create a MethodDoc for this MethodSymbol.
+     * Should be called only on symbols representing methods.
+     */
+    protected void makeMethodDoc(MethodSymbol meth, TreePath treePath) {
+        MethodDocImpl result = (MethodDocImpl)methodMap.get(meth);
+        if (result != null) {
+            if (treePath != null) result.setTreePath(treePath);
+        } else {
+            result = new MethodDocImpl(this, meth, treePath);
+            methodMap.put(meth, result);
+        }
+    }
+
+    /**
+     * Return the MethodDoc for a MethodSymbol.
+     * Should be called only on symbols representing methods.
+     */
+    public MethodDocImpl getMethodDoc(MethodSymbol meth) {
+        assert !meth.isConstructor() : "not expecting a constructor symbol";
+        MethodDocImpl result = (MethodDocImpl)methodMap.get(meth);
+        if (result != null) return result;
+        result = new MethodDocImpl(this, meth);
+        methodMap.put(meth, result);
+        return result;
+    }
+
+    /**
+     * Create the ConstructorDoc for a MethodSymbol.
+     * Should be called only on symbols representing constructors.
+     */
+    protected void makeConstructorDoc(MethodSymbol meth, TreePath treePath) {
+        ConstructorDocImpl result = (ConstructorDocImpl)methodMap.get(meth);
+        if (result != null) {
+            if (treePath != null) result.setTreePath(treePath);
+        } else {
+            result = new ConstructorDocImpl(this, meth, treePath);
+            methodMap.put(meth, result);
+        }
+    }
+
+    /**
+     * Return the ConstructorDoc for a MethodSymbol.
+     * Should be called only on symbols representing constructors.
+     */
+    public ConstructorDocImpl getConstructorDoc(MethodSymbol meth) {
+        assert meth.isConstructor() : "expecting a constructor symbol";
+        ConstructorDocImpl result = (ConstructorDocImpl)methodMap.get(meth);
+        if (result != null) return result;
+        result = new ConstructorDocImpl(this, meth);
+        methodMap.put(meth, result);
+        return result;
+    }
+
+    /**
+     * Create the AnnotationTypeElementDoc for a MethodSymbol.
+     * Should be called only on symbols representing annotation type elements.
+     */
+    protected void makeAnnotationTypeElementDoc(MethodSymbol meth, TreePath treePath) {
+        AnnotationTypeElementDocImpl result =
+            (AnnotationTypeElementDocImpl)methodMap.get(meth);
+        if (result != null) {
+            if (treePath != null) result.setTreePath(treePath);
+        } else {
+            result =
+                new AnnotationTypeElementDocImpl(this, meth, treePath);
+            methodMap.put(meth, result);
+        }
+    }
+
+    /**
+     * Return the AnnotationTypeElementDoc for a MethodSymbol.
+     * Should be called only on symbols representing annotation type elements.
+     */
+    public AnnotationTypeElementDocImpl getAnnotationTypeElementDoc(
+            MethodSymbol meth) {
+
+        AnnotationTypeElementDocImpl result =
+            (AnnotationTypeElementDocImpl)methodMap.get(meth);
+        if (result != null) return result;
+        result = new AnnotationTypeElementDocImpl(this, meth);
+        methodMap.put(meth, result);
+        return result;
+    }
+
+//  private Map<ClassType, ParameterizedTypeImpl> parameterizedTypeMap =
+//          new HashMap<ClassType, ParameterizedTypeImpl>();
+    /**
+     * Return the ParameterizedType of this instantiation.
+//   * ### Could use Type.sameTypeAs() instead of equality matching in hashmap
+//   * ### to avoid some duplication.
+     */
+    ParameterizedTypeImpl getParameterizedType(ClassType t) {
+        return new ParameterizedTypeImpl(this, t);
+//      ParameterizedTypeImpl result = parameterizedTypeMap.get(t);
+//      if (result != null) return result;
+//      result = new ParameterizedTypeImpl(this, t);
+//      parameterizedTypeMap.put(t, result);
+//      return result;
+    }
+
+    TreePath getTreePath(JCCompilationUnit tree) {
+        TreePath p = treePaths.get(tree);
+        if (p == null)
+            treePaths.put(tree, p = new TreePath(tree));
+        return p;
+    }
+
+    TreePath getTreePath(JCCompilationUnit toplevel, JCClassDecl tree) {
+        TreePath p = treePaths.get(tree);
+        if (p == null)
+            treePaths.put(tree, p = new TreePath(getTreePath(toplevel), tree));
+        return p;
+    }
+
+    TreePath getTreePath(JCCompilationUnit toplevel, JCClassDecl cdecl, JCTree tree) {
+        return new TreePath(getTreePath(toplevel, cdecl), tree);
+    }
+
+    /**
+     * Set the encoding.
+     */
+    public void setEncoding(String encoding) {
+        this.encoding = encoding;
+    }
+
+    /**
+     * Get the encoding.
+     */
+    public String getEncoding() {
+        return encoding;
+    }
+
+    /**
+     * Convert modifier bits from private coding used by
+     * the compiler to that of java.lang.reflect.Modifier.
+     */
+    static int translateModifiers(long flags) {
+        int result = 0;
+        if ((flags & Flags.ABSTRACT) != 0)
+            result |= Modifier.ABSTRACT;
+        if ((flags & Flags.FINAL) != 0)
+            result |= Modifier.FINAL;
+        if ((flags & Flags.INTERFACE) != 0)
+            result |= Modifier.INTERFACE;
+        if ((flags & Flags.NATIVE) != 0)
+            result |= Modifier.NATIVE;
+        if ((flags & Flags.PRIVATE) != 0)
+            result |= Modifier.PRIVATE;
+        if ((flags & Flags.PROTECTED) != 0)
+            result |= Modifier.PROTECTED;
+        if ((flags & Flags.PUBLIC) != 0)
+            result |= Modifier.PUBLIC;
+        if ((flags & Flags.STATIC) != 0)
+            result |= Modifier.STATIC;
+        if ((flags & Flags.SYNCHRONIZED) != 0)
+            result |= Modifier.SYNCHRONIZED;
+        if ((flags & Flags.TRANSIENT) != 0)
+            result |= Modifier.TRANSIENT;
+        if ((flags & Flags.VOLATILE) != 0)
+            result |= Modifier.VOLATILE;
+        return result;
+    }
+
+    void initDoclint(Collection<String> opts, Collection<String> customTagNames) {
+        ArrayList<String> doclintOpts = new ArrayList<String>();
+
+        for (String opt: opts) {
+            doclintOpts.add(opt == null ? DocLint.XMSGS_OPTION : DocLint.XMSGS_CUSTOM_PREFIX + opt);
+        }
+
+        if (doclintOpts.isEmpty()) {
+            doclintOpts.add(DocLint.XMSGS_OPTION);
+        } else if (doclintOpts.size() == 1
+                && doclintOpts.get(0).equals(DocLint.XMSGS_CUSTOM_PREFIX + "none")) {
+            return;
+        }
+
+        String sep = "";
+        StringBuilder customTags = new StringBuilder();
+        for (String customTag : customTagNames) {
+            customTags.append(sep);
+            customTags.append(customTag);
+            sep = DocLint.TAGS_SEPARATOR;
+        }
+        doclintOpts.add(DocLint.XCUSTOM_TAGS_PREFIX + customTags.toString());
+
+        JavacTask t = BasicJavacTask.instance(context);
+        doclint = new DocLint();
+        // standard doclet normally generates H1, H2
+        doclintOpts.add(DocLint.XIMPLICIT_HEADERS + "2");
+        doclint.init(t, doclintOpts.toArray(new String[doclintOpts.size()]), false);
+    }
+
+    JavaScriptScanner initJavaScriptScanner(boolean allowScriptInComments) {
+        if (allowScriptInComments) {
+            javaScriptScanner = null;
+        } else {
+            javaScriptScanner = new JavaScriptScanner();
+        }
+        return javaScriptScanner;
+    }
+
+    boolean showTagMessages() {
+        return (doclint == null);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/DocImpl.java

@@ -0,0 +1,453 @@
+/*
+ * Copyright (c) 1997, 2016, 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.javadoc;
+
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.text.CollationKey;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import javax.tools.FileObject;
+
+import com.sun.javadoc.*;
+import com.sun.source.util.TreePath;
+import com.sun.tools.doclets.internal.toolkit.util.FatalError;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.util.Position;
+
+/**
+ * abstract base class of all Doc classes.  Doc item's are representations
+ * of java language constructs (class, package, method,...) which have
+ * comments and have been processed by this run of javadoc.  All Doc items
+ * are unique, that is, they are == comparable.
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Atul M Dambalkar
+ * @author Neal Gafter (rewrite)
+ */
+public abstract class DocImpl implements Doc, Comparable<Object> {
+
+    /**
+     * Doc environment
+     */
+    protected final DocEnv env;   //### Rename this everywhere to 'docenv' ?
+
+    /**
+     * Back pointer to the tree node for this doc item.
+     * May be null if there is no associated tree.
+     */
+    protected TreePath treePath;
+
+    /**
+     *  The complex comment object, lazily initialized.
+     */
+    private Comment comment;
+
+    /**
+     * The cached sort key, to take care of Natural Language Text sorting.
+     */
+    private CollationKey collationkey = null;
+
+    /**
+     *  Raw documentation string.
+     */
+    protected String documentation;  // Accessed in PackageDocImpl, RootDocImpl
+
+    /**
+     * Cached first sentence.
+     */
+    private Tag[] firstSentence;
+
+    /**
+     * Cached inline tags.
+     */
+    private Tag[] inlineTags;
+
+    /**
+     * Constructor.
+     */
+    DocImpl(DocEnv env, TreePath treePath) {
+        this.treePath = treePath;
+        this.documentation = getCommentText(treePath);
+        this.env = env;
+    }
+
+    private static String getCommentText(TreePath p) {
+        if (p == null)
+            return null;
+
+        JCCompilationUnit topLevel = (JCCompilationUnit) p.getCompilationUnit();
+        JCTree tree = (JCTree) p.getLeaf();
+        return topLevel.docComments.getCommentText(tree);
+    }
+
+    /**
+     * So subclasses have the option to do lazy initialization of
+     * "documentation" string.
+     */
+    protected String documentation() {
+        if (documentation == null) documentation = "";
+        return documentation;
+    }
+
+    /**
+     * For lazy initialization of comment.
+     */
+    Comment comment() {
+        if (comment == null) {
+            String d = documentation();
+            if (env.javaScriptScanner != null) {
+                env.javaScriptScanner.parse(d, new JavaScriptScanner.Reporter() {
+                    @Override
+                    public void report() {
+                        env.error(DocImpl.this, "javadoc.JavaScript_in_comment");
+                        throw new FatalError();
+                    }
+                });
+            }
+            if (env.doclint != null
+                    && treePath != null
+                    && d.equals(getCommentText(treePath))) {
+                env.doclint.scan(treePath);
+            }
+            comment = new Comment(this, d);
+        }
+        return comment;
+    }
+
+    /**
+     * Return the text of the comment for this doc item.
+     * TagImpls have been removed.
+     */
+    public String commentText() {
+        return comment().commentText();
+    }
+
+    /**
+     * Return all tags in this Doc item.
+     *
+     * @return an array of TagImpl containing all tags on this Doc item.
+     */
+    public Tag[] tags() {
+        return comment().tags();
+    }
+
+    /**
+     * Return tags of the specified kind in this Doc item.
+     *
+     * @param tagname name of the tag kind to search for.
+     * @return an array of TagImpl containing all tags whose 'kind()'
+     * matches 'tagname'.
+     */
+    public Tag[] tags(String tagname) {
+        return comment().tags(tagname);
+    }
+
+    /**
+     * Return the see also tags in this Doc item.
+     *
+     * @return an array of SeeTag containing all &#64;see tags.
+     */
+    public SeeTag[] seeTags() {
+        return comment().seeTags();
+    }
+
+    public Tag[] inlineTags() {
+        if (inlineTags == null) {
+            inlineTags = Comment.getInlineTags(this, commentText());
+        }
+        return inlineTags;
+    }
+
+    public Tag[] firstSentenceTags() {
+        if (firstSentence == null) {
+            //Parse all sentences first to avoid duplicate warnings.
+            inlineTags();
+            try {
+                env.setSilent(true);
+                firstSentence = Comment.firstSentenceTags(this, commentText());
+            } finally {
+                env.setSilent(false);
+            }
+        }
+        return firstSentence;
+    }
+
+    /**
+     * Utility for subclasses which read HTML documentation files.
+     */
+    String readHTMLDocumentation(InputStream input, FileObject filename) throws IOException {
+        byte[] filecontents = new byte[input.available()];
+        try {
+            DataInputStream dataIn = new DataInputStream(input);
+            dataIn.readFully(filecontents);
+        } finally {
+            input.close();
+        }
+        String encoding = env.getEncoding();
+        String rawDoc = (encoding!=null)
+            ? new String(filecontents, encoding)
+            : new String(filecontents);
+        Pattern bodyPat = Pattern.compile("(?is).*<body\\b[^>]*>(.*)</body\\b.*");
+        Matcher m = bodyPat.matcher(rawDoc);
+        if (m.matches()) {
+            return m.group(1);
+        } else {
+            String key = rawDoc.matches("(?is).*<body\\b.*")
+                    ? "javadoc.End_body_missing_from_html_file"
+                    : "javadoc.Body_missing_from_html_file";
+            env.error(SourcePositionImpl.make(filename, Position.NOPOS, null), key);
+            return "";
+        }
+    }
+
+    /**
+     * Return the full unprocessed text of the comment.  Tags
+     * are included as text.  Used mainly for store and retrieve
+     * operations like internalization.
+     */
+    public String getRawCommentText() {
+        return documentation();
+    }
+
+    /**
+     * Set the full unprocessed text of the comment.  Tags
+     * are included as text.  Used mainly for store and retrieve
+     * operations like internalization.
+     */
+    public void setRawCommentText(String rawDocumentation) {
+        treePath = null;
+        documentation = rawDocumentation;
+        comment = null;
+    }
+
+    /**
+     * Set the full unprocessed text of the comment and tree path.
+     */
+    void setTreePath(TreePath treePath) {
+        this.treePath = treePath;
+        documentation = getCommentText(treePath);
+        comment = null;
+    }
+
+    /**
+     * return a key for sorting.
+     */
+    CollationKey key() {
+        if (collationkey == null) {
+            collationkey = generateKey();
+        }
+        return collationkey;
+    }
+
+    /**
+     * Generate a key for sorting.
+     * <p>
+     * Default is name().
+     */
+    CollationKey generateKey() {
+        String k = name();
+        // System.out.println("COLLATION KEY FOR " + this + " is \"" + k + "\"");
+        return env.doclocale.collator.getCollationKey(k);
+    }
+
+    /**
+     * Returns a string representation of this Doc item.
+     */
+    @Override
+    public String toString() {
+        return qualifiedName();
+    }
+
+    /**
+     * Returns the name of this Doc item.
+     *
+     * @return  the name
+     */
+    public abstract String name();
+
+    /**
+     * Returns the qualified name of this Doc item.
+     *
+     * @return  the name
+     */
+    public abstract String qualifiedName();
+
+    /**
+     * Compares this Object with the specified Object for order.  Returns a
+     * negative integer, zero, or a positive integer as this Object is less
+     * than, equal to, or greater than the given Object.
+     * <p>
+     * Included so that Doc item are java.lang.Comparable.
+     *
+     * @param   obj the {@code Object} to be compared.
+     * @return  a negative integer, zero, or a positive integer as this Object
+     *          is less than, equal to, or greater than the given Object.
+     * @exception ClassCastException the specified Object's type prevents it
+     *            from being compared to this Object.
+     */
+    public int compareTo(Object obj) {
+        // System.out.println("COMPARE \"" + this + "\" to \"" + obj + "\" = " + key().compareTo(((DocImpl)obj).key()));
+        return key().compareTo(((DocImpl)obj).key());
+    }
+
+    /**
+     * Is this Doc item a field?  False until overridden.
+     *
+     * @return true if it represents a field
+     */
+    public boolean isField() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item an enum constant?  False until overridden.
+     *
+     * @return true if it represents an enum constant
+     */
+    public boolean isEnumConstant() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item a constructor?  False until overridden.
+     *
+     * @return true if it represents a constructor
+     */
+    public boolean isConstructor() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item a method (but not a constructor or annotation
+     * type element)?
+     * False until overridden.
+     *
+     * @return true if it represents a method
+     */
+    public boolean isMethod() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item an annotation type element?
+     * False until overridden.
+     *
+     * @return true if it represents an annotation type element
+     */
+    public boolean isAnnotationTypeElement() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item a interface (but not an annotation type)?
+     * False until overridden.
+     *
+     * @return true if it represents a interface
+     */
+    public boolean isInterface() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item a exception class?  False until overridden.
+     *
+     * @return true if it represents a exception
+     */
+    public boolean isException() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item a error class?  False until overridden.
+     *
+     * @return true if it represents a error
+     */
+    public boolean isError() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item an enum type?  False until overridden.
+     *
+     * @return true if it represents an enum type
+     */
+    public boolean isEnum() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item an annotation type?  False until overridden.
+     *
+     * @return true if it represents an annotation type
+     */
+    public boolean isAnnotationType() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item an ordinary class (i.e. not an interface,
+     * annotation type, enumeration, exception, or error)?
+     * False until overridden.
+     *
+     * @return true if it represents an ordinary class
+     */
+    public boolean isOrdinaryClass() {
+        return false;
+    }
+
+    /**
+     * Is this Doc item a class
+     * (and not an interface or annotation type)?
+     * This includes ordinary classes, enums, errors and exceptions.
+     * False until overridden.
+     *
+     * @return true if it represents a class
+     */
+    public boolean isClass() {
+        return false;
+    }
+
+    /**
+     * return true if this Doc is include in the active set.
+     */
+    public abstract boolean isIncluded();
+
+    /**
+     * Return the source position of the entity, or null if
+     * no position is available.
+     */
+    public SourcePosition position() { return null; }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/DocLocale.java

@@ -0,0 +1,243 @@
+/*
+ * Copyright (c) 2000, 2012, 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.javadoc;
+
+import java.text.BreakIterator;
+import java.text.Collator;
+import java.util.Locale;
+
+/**
+ * This class holds the information about locales.
+ *
+ *  <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>
+ *
+ * @since 1.4
+ * @author Robert Field
+ */
+class DocLocale {
+
+    /**
+     * The locale name will be set by Main, if option is provided on the
+     * command line.
+     */
+    final String localeName;
+
+    /**
+     * The locale to be used. If user doesn't provide this,
+     * then set it to default locale value.
+     */
+    final Locale locale;
+
+    /**
+     * The collator for this application. This is to take care of Locale
+     * Specific or Natural Language Text sorting.
+     */
+    final Collator collator;
+
+    /**
+     * Enclosing DocEnv
+     */
+    private final DocEnv docenv;
+
+    /**
+     * Sentence instance from the BreakIterator.
+     */
+    private final BreakIterator sentenceBreaker;
+
+    /**
+     * True is we should use <code>BreakIterator</code>
+     * to compute first sentence.
+     */
+    private boolean useBreakIterator = false;
+
+    /**
+     * The HTML sentence terminators.
+     */
+    static final String[] sentenceTerminators =
+                    {
+                        "<p>", "</p>", "<h1>", "<h2>",
+                        "<h3>", "<h4>", "<h5>", "<h6>",
+                        "</h1>", "</h2>", "</h3>", "</h4>", "</h5>",
+                        "</h6>", "<hr>", "<pre>", "</pre>"
+                    };
+
+    /**
+     * Constructor
+     */
+    DocLocale(DocEnv docenv, String localeName, boolean useBreakIterator) {
+        this.docenv = docenv;
+        this.localeName = localeName;
+        this.useBreakIterator = useBreakIterator;
+        locale = getLocale();
+        if (locale == null) {
+            docenv.exit();
+        } else {
+            Locale.setDefault(locale); // NOTE: updating global state
+        }
+        collator = Collator.getInstance(locale);
+        sentenceBreaker = BreakIterator.getSentenceInstance(locale);
+    }
+
+    /**
+     * Get the locale if specified on the command line
+     * else return null and if locale option is not used
+     * then return default locale.
+     */
+    private Locale getLocale() {
+        Locale userlocale = null;
+        if (localeName.length() > 0) {
+            int firstuscore = localeName.indexOf('_');
+            int seconduscore = -1;
+            String language = null;
+            String country = null;
+            String variant = null;
+            if (firstuscore == 2) {
+                language = localeName.substring(0, firstuscore);
+                seconduscore = localeName.indexOf('_', firstuscore + 1);
+                if (seconduscore > 0) {
+                    if (seconduscore != firstuscore + 3 ||
+                           localeName.length() <= seconduscore + 1) {
+                        docenv.error(null, "main.malformed_locale_name", localeName);
+                        return null;
+                    }
+                    country = localeName.substring(firstuscore + 1,
+                                                   seconduscore);
+                    variant = localeName.substring(seconduscore + 1);
+                } else if (localeName.length() == firstuscore + 3) {
+                    country = localeName.substring(firstuscore + 1);
+                } else {
+                    docenv.error(null, "main.malformed_locale_name", localeName);
+                    return null;
+                }
+            } else if (firstuscore == -1 && localeName.length() == 2) {
+                language = localeName;
+            } else {
+                docenv.error(null, "main.malformed_locale_name", localeName);
+                return null;
+            }
+            userlocale = searchLocale(language, country, variant);
+            if (userlocale == null) {
+                docenv.error(null, "main.illegal_locale_name", localeName);
+                return null;
+            } else {
+                return userlocale;
+            }
+        } else {
+            return Locale.getDefault();
+        }
+    }
+
+    /**
+     * Search the locale for specified language, specified country and
+     * specified variant.
+     */
+    private Locale searchLocale(String language, String country,
+                                String variant) {
+        Locale[] locales = Locale.getAvailableLocales();
+        for (int i = 0; i < locales.length; i++) {
+            if (locales[i].getLanguage().equals(language) &&
+               (country == null || locales[i].getCountry().equals(country)) &&
+               (variant == null || locales[i].getVariant().equals(variant))) {
+                return locales[i];
+            }
+        }
+        return null;
+    }
+
+    String localeSpecificFirstSentence(DocImpl doc, String s) {
+        if (s == null || s.length() == 0) {
+            return "";
+        }
+        int index = s.indexOf("-->");
+        if(s.trim().startsWith("<!--") && index != -1) {
+            return localeSpecificFirstSentence(doc, s.substring(index + 3, s.length()));
+        }
+        if (useBreakIterator || !locale.getLanguage().equals("en")) {
+            sentenceBreaker.setText(s.replace('\n', ' '));
+            int start = sentenceBreaker.first();
+            int end = sentenceBreaker.next();
+            return s.substring(start, end).trim();
+        } else {
+            return englishLanguageFirstSentence(s).trim();
+        }
+    }
+
+    /**
+     * Return the first sentence of a string, where a sentence ends
+     * with a period followed be white space.
+     */
+    private String englishLanguageFirstSentence(String s) {
+        if (s == null) {
+            return null;
+        }
+        int len = s.length();
+        boolean period = false;
+        for (int i = 0 ; i < len ; i++) {
+            switch (s.charAt(i)) {
+                case '.':
+                    period = true;
+                    break;
+                case ' ':
+                case '\t':
+                case '\n':
+            case '\r':
+            case '\f':
+                    if (period) {
+                        return s.substring(0, i);
+                    }
+                    break;
+            case '<':
+                    if (i > 0) {
+                        if (htmlSentenceTerminatorFound(s, i)) {
+                            return s.substring(0, i);
+                        }
+                    }
+                    break;
+                default:
+                    period = false;
+            }
+        }
+        return s;
+    }
+
+    /**
+     * Find out if there is any HTML tag in the given string. If found
+     * return true else return false.
+     */
+    private boolean htmlSentenceTerminatorFound(String str, int index) {
+        for (int i = 0; i < sentenceTerminators.length; i++) {
+            String terminator = sentenceTerminators[i];
+            if (str.regionMatches(true, index, terminator,
+                                  0, terminator.length())) {
+                    return true;
+            }
+        }
+        return false;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/DocletInvoker.java

@@ -0,0 +1,339 @@
+/*
+ * Copyright (c) 1998, 2012, 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.javadoc;
+
+import java.io.File;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+import javax.tools.DocumentationTool;
+import javax.tools.JavaFileManager;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.file.Locations;
+import com.sun.tools.javac.util.ClientCodeException;
+import com.sun.tools.javac.util.List;
+import static com.sun.javadoc.LanguageVersion.*;
+
+
+/**
+ * Class creates, controls and invokes doclets.
+ *
+ *  <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>
+ *
+ * @author Neal Gafter (rewrite)
+ */
+public class DocletInvoker {
+
+    private final Class<?> docletClass;
+
+    private final String docletClassName;
+
+    private final ClassLoader appClassLoader;
+
+    private final Messager messager;
+
+    /**
+     * In API mode, exceptions thrown while calling the doclet are
+     * propagated using ClientCodeException.
+     */
+    private final boolean apiMode;
+
+    private static class DocletInvokeException extends Exception {
+        private static final long serialVersionUID = 0;
+    }
+
+    private String appendPath(String path1, String path2) {
+        if (path1 == null || path1.length() == 0) {
+            return path2 == null ? "." : path2;
+        } else if (path2 == null || path2.length() == 0) {
+            return path1;
+        } else {
+            return path1  + File.pathSeparator + path2;
+        }
+    }
+
+    public DocletInvoker(Messager messager, Class<?> docletClass, boolean apiMode) {
+        this.messager = messager;
+        this.docletClass = docletClass;
+        docletClassName = docletClass.getName();
+        appClassLoader = null;
+        this.apiMode = apiMode;
+    }
+
+    public DocletInvoker(Messager messager, JavaFileManager fileManager,
+                         String docletClassName, String docletPath,
+                         ClassLoader docletParentClassLoader,
+                         boolean apiMode) {
+        this.messager = messager;
+        this.docletClassName = docletClassName;
+        this.apiMode = apiMode;
+
+        if (fileManager != null && fileManager.hasLocation(DocumentationTool.Location.DOCLET_PATH)) {
+            appClassLoader = fileManager.getClassLoader(DocumentationTool.Location.DOCLET_PATH);
+        } else {
+            // construct class loader
+            String cpString = null;   // make sure env.class.path defaults to dot
+
+            // do prepends to get correct ordering
+            cpString = appendPath(System.getProperty("env.class.path"), cpString);
+            cpString = appendPath(System.getProperty("java.class.path"), cpString);
+            cpString = appendPath(docletPath, cpString);
+            URL[] urls = Locations.pathToURLs(cpString);
+            if (docletParentClassLoader == null)
+                appClassLoader = new URLClassLoader(urls, getDelegationClassLoader(docletClassName));
+            else
+                appClassLoader = new URLClassLoader(urls, docletParentClassLoader);
+        }
+
+        // attempt to find doclet
+        Class<?> dc = null;
+        try {
+            dc = appClassLoader.loadClass(docletClassName);
+        } catch (ClassNotFoundException exc) {
+            messager.error(Messager.NOPOS, "main.doclet_class_not_found", docletClassName);
+            messager.exit();
+        }
+        docletClass = dc;
+    }
+
+    /*
+     * Returns the delegation class loader to use when creating
+     * appClassLoader (used to load the doclet).  The context class
+     * loader is the best choice, but legacy behavior was to use the
+     * default delegation class loader (aka system class loader).
+     *
+     * Here we favor using the context class loader.  To ensure
+     * compatibility with existing apps, we revert to legacy
+     * behavior if either or both of the following conditions hold:
+     *
+     * 1) the doclet is loadable from the system class loader but not
+     *    from the context class loader,
+     *
+     * 2) this.getClass() is loadable from the system class loader but not
+     *    from the context class loader.
+     */
+    private ClassLoader getDelegationClassLoader(String docletClassName) {
+        ClassLoader ctxCL = Thread.currentThread().getContextClassLoader();
+        ClassLoader sysCL = ClassLoader.getSystemClassLoader();
+        if (sysCL == null)
+            return ctxCL;
+        if (ctxCL == null)
+            return sysCL;
+
+        // Condition 1.
+        try {
+            sysCL.loadClass(docletClassName);
+            try {
+                ctxCL.loadClass(docletClassName);
+            } catch (ClassNotFoundException e) {
+                return sysCL;
+            }
+        } catch (ClassNotFoundException e) {
+        }
+
+        // Condition 2.
+        try {
+            if (getClass() == sysCL.loadClass(getClass().getName())) {
+                try {
+                    if (getClass() != ctxCL.loadClass(getClass().getName()))
+                        return sysCL;
+                } catch (ClassNotFoundException e) {
+                    return sysCL;
+                }
+            }
+        } catch (ClassNotFoundException e) {
+        }
+
+        return ctxCL;
+    }
+
+    /**
+     * Generate documentation here.  Return true on success.
+     */
+    public boolean start(RootDoc root) {
+        Object retVal;
+        String methodName = "start";
+        Class<?>[] paramTypes = { RootDoc.class };
+        Object[] params = { root };
+        try {
+            retVal = invoke(methodName, null, paramTypes, params);
+        } catch (DocletInvokeException exc) {
+            return false;
+        }
+        if (retVal instanceof Boolean) {
+            return ((Boolean)retVal).booleanValue();
+        } else {
+            messager.error(Messager.NOPOS, "main.must_return_boolean",
+                           docletClassName, methodName);
+            return false;
+        }
+    }
+
+    /**
+     * Check for doclet added options here. Zero return means
+     * option not known.  Positive value indicates number of
+     * arguments to option.  Negative value means error occurred.
+     */
+    public int optionLength(String option) {
+        Object retVal;
+        String methodName = "optionLength";
+        Class<?>[] paramTypes = { String.class };
+        Object[] params = { option };
+        try {
+            retVal = invoke(methodName, new Integer(0), paramTypes, params);
+        } catch (DocletInvokeException exc) {
+            return -1;
+        }
+        if (retVal instanceof Integer) {
+            return ((Integer)retVal).intValue();
+        } else {
+            messager.error(Messager.NOPOS, "main.must_return_int",
+                           docletClassName, methodName);
+            return -1;
+        }
+    }
+
+    /**
+     * Let doclet check that all options are OK. Returning true means
+     * options are OK.  If method does not exist, assume true.
+     */
+    public boolean validOptions(List<String[]> optlist) {
+        Object retVal;
+        String options[][] = optlist.toArray(new String[optlist.length()][]);
+        String methodName = "validOptions";
+        DocErrorReporter reporter = messager;
+        Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
+        Object[] params = { options, reporter };
+        try {
+            retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
+        } catch (DocletInvokeException exc) {
+            return false;
+        }
+        if (retVal instanceof Boolean) {
+            return ((Boolean)retVal).booleanValue();
+        } else {
+            messager.error(Messager.NOPOS, "main.must_return_boolean",
+                           docletClassName, methodName);
+            return false;
+        }
+    }
+
+    /**
+     * Return the language version supported by this doclet.
+     * If the method does not exist in the doclet, assume version 1.1.
+     */
+    public LanguageVersion languageVersion() {
+        try {
+            Object retVal;
+            String methodName = "languageVersion";
+            Class<?>[] paramTypes = new Class<?>[0];
+            Object[] params = new Object[0];
+            try {
+                retVal = invoke(methodName, JAVA_1_1, paramTypes, params);
+            } catch (DocletInvokeException exc) {
+                return JAVA_1_1;
+            }
+            if (retVal instanceof LanguageVersion) {
+                return (LanguageVersion)retVal;
+            } else {
+                messager.error(Messager.NOPOS, "main.must_return_languageversion",
+                               docletClassName, methodName);
+                return JAVA_1_1;
+            }
+        } catch (NoClassDefFoundError ex) { // for boostrapping, no Enum class.
+            return null;
+        }
+    }
+
+    /**
+     * Utility method for calling doclet functionality
+     */
+    private Object invoke(String methodName, Object returnValueIfNonExistent,
+                          Class<?>[] paramTypes, Object[] params)
+        throws DocletInvokeException {
+            Method meth;
+            try {
+                meth = docletClass.getMethod(methodName, paramTypes);
+            } catch (NoSuchMethodException exc) {
+                if (returnValueIfNonExistent == null) {
+                    messager.error(Messager.NOPOS, "main.doclet_method_not_found",
+                                   docletClassName, methodName);
+                    throw new DocletInvokeException();
+                } else {
+                    return returnValueIfNonExistent;
+                }
+            } catch (SecurityException exc) {
+                messager.error(Messager.NOPOS, "main.doclet_method_not_accessible",
+                               docletClassName, methodName);
+                throw new DocletInvokeException();
+            }
+            if (!Modifier.isStatic(meth.getModifiers())) {
+                messager.error(Messager.NOPOS, "main.doclet_method_must_be_static",
+                               docletClassName, methodName);
+                throw new DocletInvokeException();
+            }
+            ClassLoader savedCCL =
+                Thread.currentThread().getContextClassLoader();
+            try {
+                if (appClassLoader != null) // will be null if doclet class provided via API
+                    Thread.currentThread().setContextClassLoader(appClassLoader);
+                return meth.invoke(null , params);
+            } catch (IllegalArgumentException exc) {
+                messager.error(Messager.NOPOS, "main.internal_error_exception_thrown",
+                               docletClassName, methodName, exc.toString());
+                throw new DocletInvokeException();
+            } catch (IllegalAccessException exc) {
+                messager.error(Messager.NOPOS, "main.doclet_method_not_accessible",
+                               docletClassName, methodName);
+                throw new DocletInvokeException();
+            } catch (NullPointerException exc) {
+                messager.error(Messager.NOPOS, "main.internal_error_exception_thrown",
+                               docletClassName, methodName, exc.toString());
+                throw new DocletInvokeException();
+            } catch (InvocationTargetException exc) {
+                Throwable err = exc.getTargetException();
+                if (apiMode)
+                    throw new ClientCodeException(err);
+                if (err instanceof java.lang.OutOfMemoryError) {
+                    messager.error(Messager.NOPOS, "main.out.of.memory");
+                } else {
+                    messager.error(Messager.NOPOS, "main.exception_thrown",
+                               docletClassName, methodName, exc.toString());
+                    exc.getTargetException().printStackTrace();
+                }
+                throw new DocletInvokeException();
+            } finally {
+                Thread.currentThread().setContextClassLoader(savedCCL);
+            }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ExecutableMemberDocImpl.java

@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import java.lang.reflect.Modifier;
+import java.text.CollationKey;
+
+import com.sun.javadoc.*;
+
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.ListBuffer;
+
+/**
+ * Represents a method or constructor of a java class.
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ * @author Scott Seligman (generics, annotations)
+ */
+
+public abstract class ExecutableMemberDocImpl
+        extends MemberDocImpl implements ExecutableMemberDoc {
+
+    protected final MethodSymbol sym;
+
+    /**
+     * Constructor.
+     */
+    public ExecutableMemberDocImpl(DocEnv env, MethodSymbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+        this.sym = sym;
+    }
+
+    /**
+     * Constructor.
+     */
+    public ExecutableMemberDocImpl(DocEnv env, MethodSymbol sym) {
+        this(env, sym, null);
+    }
+
+    /**
+     * Returns the flags in terms of javac's flags
+     */
+    protected long getFlags() {
+        return sym.flags();
+    }
+
+    /**
+     * Identify the containing class
+     */
+    protected ClassSymbol getContainingClass() {
+        return sym.enclClass();
+    }
+
+    /**
+     * Return true if this method is native
+     */
+    public boolean isNative() {
+        return Modifier.isNative(getModifiers());
+    }
+
+    /**
+     * Return true if this method is synchronized
+     */
+    public boolean isSynchronized() {
+        return Modifier.isSynchronized(getModifiers());
+    }
+
+    /**
+     * Return true if this method was declared to take a variable number
+     * of arguments.
+     */
+    public boolean isVarArgs() {
+        return ((sym.flags() & Flags.VARARGS) != 0
+                && !env.legacyDoclet);
+    }
+
+    /**
+     * Returns true if this field was synthesized by the compiler.
+     */
+    public boolean isSynthetic() {
+        return ((sym.flags() & Flags.SYNTHETIC) != 0);
+    }
+
+    public boolean isIncluded() {
+        return containingClass().isIncluded() && env.shouldDocument(sym);
+    }
+
+    /**
+     * Return the throws tags in this method.
+     *
+     * @return an array of ThrowTagImpl containing all {@code @exception}
+     * and {@code @throws} tags.
+     */
+    public ThrowsTag[] throwsTags() {
+        return comment().throwsTags();
+    }
+
+    /**
+     * Return the param tags in this method, excluding the type
+     * parameter tags.
+     *
+     * @return an array of ParamTagImpl containing all {@code @param} tags.
+     */
+    public ParamTag[] paramTags() {
+        return comment().paramTags();
+    }
+
+    /**
+     * Return the type parameter tags in this method.
+     */
+    public ParamTag[] typeParamTags() {
+        return env.legacyDoclet
+            ? new ParamTag[0]
+            : comment().typeParamTags();
+    }
+
+    /**
+     * Return exceptions this method or constructor throws.
+     *
+     * @return an array of ClassDoc[] representing the exceptions
+     * thrown by this method.
+     */
+    public ClassDoc[] thrownExceptions() {
+        ListBuffer<ClassDocImpl> l = new ListBuffer<ClassDocImpl>();
+        for (Type ex : sym.type.getThrownTypes()) {
+            ex = env.types.erasure(ex);
+            //### Will these casts succeed in the face of static semantic
+            //### errors in the documented code?
+            ClassDocImpl cdi = env.getClassDoc((ClassSymbol)ex.tsym);
+            if (cdi != null) l.append(cdi);
+        }
+        return l.toArray(new ClassDocImpl[l.length()]);
+    }
+
+    /**
+     * Return exceptions this method or constructor throws.
+     * Each array element is either a <code>ClassDoc</code> or a
+     * <code>TypeVariable</code>.
+     */
+    public com.sun.javadoc.Type[] thrownExceptionTypes() {
+        return TypeMaker.getTypes(env, sym.type.getThrownTypes());
+    }
+
+    /**
+     * Get argument information.
+     *
+     * @see ParameterImpl
+     *
+     * @return an array of ParameterImpl, one element per argument
+     * in the order the arguments are present.
+     */
+    public Parameter[] parameters() {
+        // generate the parameters on the fly:  they're not cached
+        List<VarSymbol> params = sym.params();
+        Parameter result[] = new Parameter[params.length()];
+
+        int i = 0;
+        for (VarSymbol param : params) {
+            result[i++] = new ParameterImpl(env, param);
+        }
+        return result;
+    }
+
+    /**
+     * Get the receiver type of this executable element.
+     *
+     * @return the receiver type of this executable element.
+     * @since 1.8
+     */
+    public com.sun.javadoc.Type receiverType() {
+        Type recvtype = sym.type.asMethodType().recvtype;
+        return (recvtype != null) ? TypeMaker.getType(env, recvtype, false, true) : null;
+    }
+
+    /**
+     * Return the formal type parameters of this method or constructor.
+     * Return an empty array if there are none.
+     */
+    public TypeVariable[] typeParameters() {
+        if (env.legacyDoclet) {
+            return new TypeVariable[0];
+        }
+        TypeVariable res[] = new TypeVariable[sym.type.getTypeArguments().length()];
+        TypeMaker.getTypes(env, sym.type.getTypeArguments(), res);
+        return res;
+    }
+
+    /**
+     * Get the signature. It is the parameter list, type is qualified.
+     * For instance, for a method <code>mymethod(String x, int y)</code>,
+     * it will return <code>(java.lang.String,int)</code>.
+     */
+    public String signature() {
+        return makeSignature(true);
+    }
+
+    /**
+     * Get flat signature.  All types are not qualified.
+     * Return a String, which is the flat signiture of this member.
+     * It is the parameter list, type is not qualified.
+     * For instance, for a method <code>mymethod(String x, int y)</code>,
+     * it will return <code>(String, int)</code>.
+     */
+    public String flatSignature() {
+        return makeSignature(false);
+    }
+
+    private String makeSignature(boolean full) {
+        StringBuilder result = new StringBuilder();
+        result.append("(");
+        for (List<Type> types = sym.type.getParameterTypes(); types.nonEmpty(); ) {
+            Type t = types.head;
+            result.append(TypeMaker.getTypeString(env, t, full));
+            types = types.tail;
+            if (types.nonEmpty()) {
+                result.append(", ");
+            }
+        }
+        if (isVarArgs()) {
+            int len = result.length();
+            result.replace(len - 2, len, "...");
+        }
+        result.append(")");
+        return result.toString();
+    }
+
+    protected String typeParametersString() {
+        return TypeMaker.typeParametersString(env, sym, true);
+    }
+
+    /**
+     * Generate a key for sorting.
+     */
+    @Override
+    CollationKey generateKey() {
+        String k = name() + flatSignature() + typeParametersString();
+        // ',' and '&' are between '$' and 'a':  normalize to spaces.
+        k = k.replace(',', ' ').replace('&', ' ');
+        // System.out.println("COLLATION KEY FOR " + this + " is \"" + k + "\"");
+        return env.doclocale.collator.getCollationKey(k);
+    }
+
+    /**
+     * Return the source position of the entity, or null if
+     * no position is available.
+     */
+    @Override
+    public SourcePosition position() {
+        if (sym.enclClass().sourcefile == null) return null;
+        return SourcePositionImpl.make(sym.enclClass().sourcefile,
+                                       (tree==null) ? 0 : tree.pos,
+                                       lineMap);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/FieldDocImpl.java

@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import com.sun.source.util.TreePath;
+import java.lang.reflect.Modifier;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.VarSymbol;
+
+import static com.sun.tools.javac.code.TypeTag.BOOLEAN;
+
+/**
+ * Represents a field in a java class.
+ *
+ *  <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>
+ *
+ * @see MemberDocImpl
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ * @author Scott Seligman (generics, enums, annotations)
+ */
+public class FieldDocImpl extends MemberDocImpl implements FieldDoc {
+
+    protected final VarSymbol sym;
+
+    /**
+     * Constructor.
+     */
+    public FieldDocImpl(DocEnv env, VarSymbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+        this.sym = sym;
+    }
+
+    /**
+     * Constructor.
+     */
+    public FieldDocImpl(DocEnv env, VarSymbol sym) {
+        this(env, sym, null);
+    }
+
+    /**
+     * Returns the flags in terms of javac's flags
+     */
+    protected long getFlags() {
+        return sym.flags();
+    }
+
+    /**
+     * Identify the containing class
+     */
+    protected ClassSymbol getContainingClass() {
+        return sym.enclClass();
+    }
+
+    /**
+     * Get type of this field.
+     */
+    public com.sun.javadoc.Type type() {
+        return TypeMaker.getType(env, sym.type, false);
+    }
+
+    /**
+     * Get the value of a constant field.
+     *
+     * @return the value of a constant field. The value is
+     * automatically wrapped in an object if it has a primitive type.
+     * If the field is not constant, returns null.
+     */
+    public Object constantValue() {
+        Object result = sym.getConstValue();
+        if (result != null && sym.type.hasTag(BOOLEAN))
+            // javac represents false and true as Integers 0 and 1
+            result = Boolean.valueOf(((Integer)result).intValue() != 0);
+        return result;
+    }
+
+    /**
+     * Get the value of a constant field.
+     *
+     * @return the text of a Java language expression whose value
+     * is the value of the constant. The expression uses no identifiers
+     * other than primitive literals. If the field is
+     * not constant, returns null.
+     */
+    public String constantValueExpression() {
+        return constantValueExpression(constantValue());
+    }
+
+    /**
+     * A static version of the above.
+     */
+    static String constantValueExpression(Object cb) {
+        if (cb == null) return null;
+        if (cb instanceof Character) return sourceForm(((Character)cb).charValue());
+        if (cb instanceof Byte) return sourceForm(((Byte)cb).byteValue());
+        if (cb instanceof String) return sourceForm((String)cb);
+        if (cb instanceof Double) return sourceForm(((Double)cb).doubleValue(), 'd');
+        if (cb instanceof Float) return sourceForm(((Float)cb).doubleValue(), 'f');
+        if (cb instanceof Long) return cb + "L";
+        return cb.toString(); // covers int, short
+    }
+        // where
+        private static String sourceForm(double v, char suffix) {
+            if (Double.isNaN(v))
+                return "0" + suffix + "/0" + suffix;
+            if (v == Double.POSITIVE_INFINITY)
+                return "1" + suffix + "/0" + suffix;
+            if (v == Double.NEGATIVE_INFINITY)
+                return "-1" + suffix + "/0" + suffix;
+            return v + (suffix == 'f' || suffix == 'F' ? "" + suffix : "");
+        }
+        private static String sourceForm(char c) {
+            StringBuilder buf = new StringBuilder(8);
+            buf.append('\'');
+            sourceChar(c, buf);
+            buf.append('\'');
+            return buf.toString();
+        }
+        private static String sourceForm(byte c) {
+            return "0x" + Integer.toString(c & 0xff, 16);
+        }
+        private static String sourceForm(String s) {
+            StringBuilder buf = new StringBuilder(s.length() + 5);
+            buf.append('\"');
+            for (int i=0; i<s.length(); i++) {
+                char c = s.charAt(i);
+                sourceChar(c, buf);
+            }
+            buf.append('\"');
+            return buf.toString();
+        }
+        private static void sourceChar(char c, StringBuilder buf) {
+            switch (c) {
+            case '\b': buf.append("\\b"); return;
+            case '\t': buf.append("\\t"); return;
+            case '\n': buf.append("\\n"); return;
+            case '\f': buf.append("\\f"); return;
+            case '\r': buf.append("\\r"); return;
+            case '\"': buf.append("\\\""); return;
+            case '\'': buf.append("\\\'"); return;
+            case '\\': buf.append("\\\\"); return;
+            default:
+                if (isPrintableAscii(c)) {
+                    buf.append(c); return;
+                }
+                unicodeEscape(c, buf);
+                return;
+            }
+        }
+        private static void unicodeEscape(char c, StringBuilder buf) {
+            final String chars = "0123456789abcdef";
+            buf.append("\\u");
+            buf.append(chars.charAt(15 & (c>>12)));
+            buf.append(chars.charAt(15 & (c>>8)));
+            buf.append(chars.charAt(15 & (c>>4)));
+            buf.append(chars.charAt(15 & (c>>0)));
+        }
+        private static boolean isPrintableAscii(char c) {
+            return c >= ' ' && c <= '~';
+        }
+
+    /**
+     * Return true if this field is included in the active set.
+     */
+    public boolean isIncluded() {
+        return containingClass().isIncluded() && env.shouldDocument(sym);
+    }
+
+    /**
+     * Is this Doc item a field (but not an enum constant?
+     */
+    @Override
+    public boolean isField() {
+        return !isEnumConstant();
+    }
+
+    /**
+     * Is this Doc item an enum constant?
+     * (For legacy doclets, return false.)
+     */
+    @Override
+    public boolean isEnumConstant() {
+        return (getFlags() & Flags.ENUM) != 0 &&
+               !env.legacyDoclet;
+    }
+
+    /**
+     * Return true if this field is transient
+     */
+    public boolean isTransient() {
+        return Modifier.isTransient(getModifiers());
+    }
+
+    /**
+     * Return true if this field is volatile
+     */
+    public boolean isVolatile() {
+        return Modifier.isVolatile(getModifiers());
+    }
+
+    /**
+     * Returns true if this field was synthesized by the compiler.
+     */
+    public boolean isSynthetic() {
+        return (getFlags() & Flags.SYNTHETIC) != 0;
+    }
+
+    /**
+     * Return the serialField tags in this FieldDocImpl item.
+     *
+     * @return an array of <tt>SerialFieldTagImpl</tt> containing all
+     *         <code>&#64;serialField</code> tags.
+     */
+    public SerialFieldTag[] serialFieldTags() {
+        return comment().serialFieldTags();
+    }
+
+    public String name() {
+        if (name == null) {
+            name = sym.name.toString();
+        }
+        return name;
+    }
+
+    private String name;
+
+    public String qualifiedName() {
+        if (qualifiedName == null) {
+            qualifiedName = sym.enclClass().getQualifiedName() + "." + name();
+        }
+        return qualifiedName;
+    }
+
+    private String qualifiedName;
+
+    /**
+     * Return the source position of the entity, or null if
+     * no position is available.
+     */
+    @Override
+    public SourcePosition position() {
+        if (sym.enclClass().sourcefile == null) return null;
+        return SourcePositionImpl.make(sym.enclClass().sourcefile,
+                                       (tree==null) ? 0 : tree.pos,
+                                       lineMap);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/JavadocClassReader.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2001, 2012, 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.javadoc;
+
+import java.util.EnumSet;
+import javax.tools.JavaFileObject;
+
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+import com.sun.tools.javac.jvm.ClassReader;
+import com.sun.tools.javac.util.Context;
+
+/** Javadoc uses an extended class reader that records package.html entries
+ *
+ *  <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>
+ *
+ *  @author Neal Gafter
+ */
+public class JavadocClassReader extends ClassReader {
+
+    public static JavadocClassReader instance0(Context context) {
+        ClassReader instance = context.get(classReaderKey);
+        if (instance == null)
+            instance = new JavadocClassReader(context);
+        return (JavadocClassReader)instance;
+    }
+
+    public static void preRegister(Context context) {
+        context.put(classReaderKey, new Context.Factory<ClassReader>() {
+            public ClassReader make(Context c) {
+                return new JavadocClassReader(c);
+            }
+        });
+    }
+
+    private DocEnv docenv;
+    private EnumSet<JavaFileObject.Kind> all = EnumSet.of(JavaFileObject.Kind.CLASS,
+                                                          JavaFileObject.Kind.SOURCE,
+                                                          JavaFileObject.Kind.HTML);
+    private EnumSet<JavaFileObject.Kind> noSource = EnumSet.of(JavaFileObject.Kind.CLASS,
+                                                               JavaFileObject.Kind.HTML);
+
+    public JavadocClassReader(Context context) {
+        super(context, true);
+        docenv = DocEnv.instance(context);
+        preferSource = true;
+    }
+
+    /**
+     * Override getPackageFileKinds to include search for package.html
+     */
+    @Override
+    protected EnumSet<JavaFileObject.Kind> getPackageFileKinds() {
+        return docenv.docClasses ? noSource : all;
+    }
+
+    /**
+     * Override extraFileActions to check for package documentation
+     */
+    @Override
+    protected void extraFileActions(PackageSymbol pack, JavaFileObject fo) {
+        if (fo.isNameCompatible("package", JavaFileObject.Kind.HTML))
+            docenv.getPackageDoc(pack).setDocPath(fo);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/JavadocEnter.java

@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2001, 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.javadoc;
+
+import javax.tools.JavaFileObject;
+
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.comp.Enter;
+import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticPosition;
+import com.sun.tools.javac.util.List;
+
+/**
+ *  Javadoc's own enter phase does a few things above and beyond that
+ *  done by javac.
+ *
+ *  <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>
+ *
+ *  @author Neal Gafter
+ */
+public class JavadocEnter extends Enter {
+    public static JavadocEnter instance0(Context context) {
+        Enter instance = context.get(enterKey);
+        if (instance == null)
+            instance = new JavadocEnter(context);
+        return (JavadocEnter)instance;
+    }
+
+    public static void preRegister(Context context) {
+        context.put(enterKey, new Context.Factory<Enter>() {
+               public Enter make(Context c) {
+                   return new JavadocEnter(c);
+               }
+        });
+    }
+
+    protected JavadocEnter(Context context) {
+        super(context);
+        messager = Messager.instance0(context);
+        docenv = DocEnv.instance(context);
+    }
+
+    final Messager messager;
+    final DocEnv docenv;
+
+    @Override
+    public void main(List<JCCompilationUnit> trees) {
+        // count all Enter errors as warnings.
+        int nerrors = messager.nerrors;
+        super.main(trees);
+        messager.nwarnings += (messager.nerrors - nerrors);
+        messager.nerrors = nerrors;
+    }
+
+    @Override
+    public void visitTopLevel(JCCompilationUnit tree) {
+        super.visitTopLevel(tree);
+        if (tree.sourcefile.isNameCompatible("package-info", JavaFileObject.Kind.SOURCE)) {
+            docenv.makePackageDoc(tree.packge, docenv.getTreePath(tree));
+        }
+    }
+
+    @Override
+    public void visitClassDef(JCClassDecl tree) {
+        super.visitClassDef(tree);
+        if (tree.sym == null) return;
+        if (tree.sym.kind == Kinds.TYP || tree.sym.kind == Kinds.ERR) {
+            ClassSymbol c = tree.sym;
+            docenv.makeClassDoc(c, docenv.getTreePath(env.toplevel, tree));
+        }
+    }
+
+    /** Don't complain about a duplicate class. */
+    @Override
+    protected void duplicateClass(DiagnosticPosition pos, ClassSymbol c) {}
+
+}

jdkSrc/jdk8/com/sun/tools/javadoc/JavadocMemberEnter.java

@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.comp.MemberEnter;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.*;
+import com.sun.tools.javac.util.Context;
+
+import static com.sun.tools.javac.code.Flags.*;
+
+/**
+ *  Javadoc's own memberEnter phase does a few things above and beyond that
+ *  done by javac.
+ *
+ *  <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>
+ *
+ *  @author Neal Gafter
+ */
+public class JavadocMemberEnter extends MemberEnter {
+    public static JavadocMemberEnter instance0(Context context) {
+        MemberEnter instance = context.get(memberEnterKey);
+        if (instance == null)
+            instance = new JavadocMemberEnter(context);
+        return (JavadocMemberEnter)instance;
+    }
+
+    public static void preRegister(Context context) {
+        context.put(memberEnterKey, new Context.Factory<MemberEnter>() {
+               public MemberEnter make(Context c) {
+                   return new JavadocMemberEnter(c);
+               }
+        });
+    }
+
+    final DocEnv docenv;
+
+    protected JavadocMemberEnter(Context context) {
+        super(context);
+        docenv = DocEnv.instance(context);
+    }
+
+    @Override
+    public void visitMethodDef(JCMethodDecl tree) {
+        super.visitMethodDef(tree);
+        MethodSymbol meth = tree.sym;
+        if (meth == null || meth.kind != Kinds.MTH) return;
+        TreePath treePath = docenv.getTreePath(env.toplevel, env.enclClass, tree);
+        if (meth.isConstructor())
+            docenv.makeConstructorDoc(meth, treePath);
+        else if (isAnnotationTypeElement(meth))
+            docenv.makeAnnotationTypeElementDoc(meth, treePath);
+        else
+            docenv.makeMethodDoc(meth, treePath);
+
+        // release resources
+        tree.body = null;
+    }
+
+    @Override
+    public void visitVarDef(JCVariableDecl tree) {
+        if (tree.init != null) {
+            boolean isFinal = (tree.mods.flags & FINAL) != 0
+                    || (env.enclClass.mods.flags & INTERFACE) != 0;
+            if (!isFinal || containsNonConstantExpression(tree.init)) {
+                // Avoid unnecessary analysis and release resources.
+                // In particular, remove non-constant expressions
+                // which may trigger Attr.attribClass, since
+                // method bodies are also removed, in visitMethodDef.
+                tree.init = null;
+            }
+        }
+        super.visitVarDef(tree);
+        if (tree.sym != null &&
+                tree.sym.kind == Kinds.VAR &&
+                !isParameter(tree.sym)) {
+            docenv.makeFieldDoc(tree.sym, docenv.getTreePath(env.toplevel, env.enclClass, tree));
+        }
+    }
+
+    private static boolean isAnnotationTypeElement(MethodSymbol meth) {
+        return ClassDocImpl.isAnnotationType(meth.enclClass());
+    }
+
+    private static boolean isParameter(VarSymbol var) {
+        return (var.flags() & Flags.PARAMETER) != 0;
+    }
+
+    /**
+     * Simple analysis of an expression tree to see if it contains tree nodes
+     * for any non-constant expression. This does not include checking references
+     * to other fields which may or may not be constant.
+     */
+    private static boolean containsNonConstantExpression(JCExpression tree) {
+        return new MaybeConstantExpressionScanner().containsNonConstantExpression(tree);
+    }
+
+    /**
+     * See JLS 15.18, Constant Expression
+     */
+    private static class MaybeConstantExpressionScanner extends JCTree.Visitor {
+        boolean maybeConstantExpr = true;
+
+        public boolean containsNonConstantExpression(JCExpression tree) {
+            scan(tree);
+            return !maybeConstantExpr;
+        }
+
+        public void scan(JCTree tree) {
+            // short circuit scan when end result is definitely false
+            if (maybeConstantExpr && tree != null)
+                tree.accept(this);
+        }
+
+        @Override
+        /** default for any non-overridden visit method. */
+        public void visitTree(JCTree tree) {
+            maybeConstantExpr = false;
+        }
+
+        @Override
+        public void visitBinary(JCBinary tree) {
+            switch (tree.getTag()) {
+                case MUL: case DIV: case MOD:
+                case PLUS: case MINUS:
+                case SL: case SR: case USR:
+                case LT: case LE: case GT: case GE:
+                case EQ: case NE:
+                case BITAND: case BITXOR: case BITOR:
+                case AND: case OR:
+                    break;
+                default:
+                    maybeConstantExpr = false;
+            }
+        }
+
+        @Override
+        public void visitConditional(JCConditional tree) {
+            scan(tree.cond);
+            scan(tree.truepart);
+            scan(tree.falsepart);
+        }
+
+        @Override
+        public void visitIdent(JCIdent tree) { }
+
+        @Override
+        public void visitLiteral(JCLiteral tree) { }
+
+        @Override
+        public void visitParens(JCParens tree) {
+            scan(tree.expr);
+        }
+
+        @Override
+        public void visitSelect(JCTree.JCFieldAccess tree) {
+            scan(tree.selected);
+        }
+
+        @Override
+        public void visitTypeCast(JCTypeCast tree) {
+            scan(tree.clazz);
+            scan(tree.expr);
+        }
+
+        @Override
+        public void visitTypeIdent(JCPrimitiveTypeTree tree) { }
+
+        @Override
+        public void visitUnary(JCUnary tree) {
+            switch (tree.getTag()) {
+                case POS: case NEG: case COMPL: case NOT:
+                    break;
+                default:
+                    maybeConstantExpr = false;
+            }
+        }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/JavadocTodo.java

@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2003, 2012, 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.javadoc;
+
+import com.sun.tools.javac.comp.*;
+import com.sun.tools.javac.util.*;
+
+/**
+ *  Javadoc's own todo queue doesn't queue its inputs, as javadoc
+ *  doesn't perform attribution of method bodies or semantic checking.
+ *
+ *  <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>
+ *
+ *  @author Neal Gafter
+ */
+public class JavadocTodo extends Todo {
+    public static void preRegister(Context context) {
+        context.put(todoKey, new Context.Factory<Todo>() {
+               public Todo make(Context c) {
+                   return new JavadocTodo(c);
+               }
+        });
+    }
+
+    protected JavadocTodo(Context context) {
+        super(context);
+    }
+
+    @Override
+    public void append(Env<AttrContext> e) {
+        // do nothing; Javadoc doesn't perform attribution.
+    }
+
+    @Override
+    public boolean offer(Env<AttrContext> e) {
+        return false;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/JavadocTool.java

@@ -0,0 +1,444 @@
+/*
+ * Copyright (c) 2001, 2014, 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.javadoc;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import javax.tools.JavaFileManager.Location;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
+
+import com.sun.tools.javac.code.Symbol.CompletionFailure;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.util.Abort;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Position;
+
+
+/**
+ *  This class could be the main entry point for Javadoc when Javadoc is used as a
+ *  component in a larger software system. It provides operations to
+ *  construct a new javadoc processor, and to run it on a set of source
+ *  files.
+ *
+ *  <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>
+ *
+ *  @author Neal Gafter
+ */
+public class JavadocTool extends com.sun.tools.javac.main.JavaCompiler {
+    DocEnv docenv;
+
+    final Messager messager;
+    final JavadocClassReader javadocReader;
+    final JavadocEnter javadocEnter;
+    final Set<JavaFileObject> uniquefiles;
+
+    /**
+     * Construct a new JavaCompiler processor, using appropriately
+     * extended phases of the underlying compiler.
+     */
+    protected JavadocTool(Context context) {
+        super(context);
+        messager = Messager.instance0(context);
+        javadocReader = JavadocClassReader.instance0(context);
+        javadocEnter = JavadocEnter.instance0(context);
+        uniquefiles = new HashSet<>();
+    }
+
+    /**
+     * For javadoc, the parser needs to keep comments. Overrides method from JavaCompiler.
+     */
+    protected boolean keepComments() {
+        return true;
+    }
+
+    /**
+     *  Construct a new javadoc tool.
+     */
+    public static JavadocTool make0(Context context) {
+        Messager messager = null;
+        try {
+            // force the use of Javadoc's class reader
+            JavadocClassReader.preRegister(context);
+
+            // force the use of Javadoc's own enter phase
+            JavadocEnter.preRegister(context);
+
+            // force the use of Javadoc's own member enter phase
+            JavadocMemberEnter.preRegister(context);
+
+            // force the use of Javadoc's own todo phase
+            JavadocTodo.preRegister(context);
+
+            // force the use of Messager as a Log
+            messager = Messager.instance0(context);
+
+            return new JavadocTool(context);
+        } catch (CompletionFailure ex) {
+            messager.error(Position.NOPOS, ex.getMessage());
+            return null;
+        }
+    }
+
+    public RootDocImpl getRootDocImpl(String doclocale,
+                                      String encoding,
+                                      ModifierFilter filter,
+                                      List<String> javaNames,
+                                      List<String[]> options,
+                                      Iterable<? extends JavaFileObject> fileObjects,
+                                      boolean breakiterator,
+                                      List<String> subPackages,
+                                      List<String> excludedPackages,
+                                      boolean docClasses,
+                                      boolean legacyDoclet,
+                      boolean quiet) throws IOException {
+        docenv = DocEnv.instance(context);
+        docenv.showAccess = filter;
+        docenv.quiet = quiet;
+        docenv.breakiterator = breakiterator;
+        docenv.setLocale(doclocale);
+        docenv.setEncoding(encoding);
+        docenv.docClasses = docClasses;
+        docenv.legacyDoclet = legacyDoclet;
+        javadocReader.sourceCompleter = docClasses ? null : thisCompleter;
+
+        ListBuffer<String> names = new ListBuffer<String>();
+        ListBuffer<JCCompilationUnit> classTrees = new ListBuffer<JCCompilationUnit>();
+        ListBuffer<JCCompilationUnit> packTrees = new ListBuffer<JCCompilationUnit>();
+
+        try {
+            StandardJavaFileManager fm = docenv.fileManager instanceof StandardJavaFileManager
+                    ? (StandardJavaFileManager) docenv.fileManager : null;
+            for (List<String> it = javaNames; it.nonEmpty(); it = it.tail) {
+                String name = it.head;
+                if (!docClasses && fm != null && name.endsWith(".java") && new File(name).exists()) {
+                    JavaFileObject fo = fm.getJavaFileObjects(name).iterator().next();
+                    parse(fo, classTrees, true);
+                } else if (isValidPackageName(name)) {
+                    names = names.append(name);
+                } else if (name.endsWith(".java")) {
+                    if (fm == null)
+                        throw new IllegalArgumentException();
+                    else
+                        docenv.error(null, "main.file_not_found", name);
+                } else {
+                    docenv.error(null, "main.illegal_package_name", name);
+                }
+            }
+            for (JavaFileObject fo: fileObjects) {
+                parse(fo, classTrees, true);
+            }
+
+            if (!docClasses) {
+                // Recursively search given subpackages.  If any packages
+                //are found, add them to the list.
+                Map<String,List<JavaFileObject>> packageFiles =
+                        searchSubPackages(subPackages, names, excludedPackages);
+
+                // Parse the packages
+                for (List<String> packs = names.toList(); packs.nonEmpty(); packs = packs.tail) {
+                    // Parse sources ostensibly belonging to package.
+                    String packageName = packs.head;
+                    parsePackageClasses(packageName, packageFiles.get(packageName), packTrees, excludedPackages);
+                }
+
+                if (messager.nerrors() != 0) return null;
+
+                // Enter symbols for all files
+                docenv.notice("main.Building_tree");
+                javadocEnter.main(classTrees.toList().appendList(packTrees.toList()));
+            }
+        } catch (Abort ex) {}
+
+        if (messager.nerrors() != 0)
+            return null;
+
+        if (docClasses)
+            return new RootDocImpl(docenv, javaNames, options);
+        else
+            return new RootDocImpl(docenv, listClasses(classTrees.toList()), names.toList(), options);
+    }
+
+    /** Is the given string a valid package name? */
+    boolean isValidPackageName(String s) {
+        int index;
+        while ((index = s.indexOf('.')) != -1) {
+            if (!isValidClassName(s.substring(0, index))) return false;
+            s = s.substring(index+1);
+        }
+        return isValidClassName(s);
+    }
+
+    /**
+     * search all directories in path for subdirectory name. Add all
+     * .java files found in such a directory to args.
+     */
+    private void parsePackageClasses(String name,
+            List<JavaFileObject> files,
+            ListBuffer<JCCompilationUnit> trees,
+            List<String> excludedPackages)
+            throws IOException {
+        if (excludedPackages.contains(name)) {
+            return;
+        }
+
+        docenv.notice("main.Loading_source_files_for_package", name);
+
+        if (files == null) {
+            Location location = docenv.fileManager.hasLocation(StandardLocation.SOURCE_PATH)
+                    ? StandardLocation.SOURCE_PATH : StandardLocation.CLASS_PATH;
+            ListBuffer<JavaFileObject> lb = new ListBuffer<JavaFileObject>();
+            for (JavaFileObject fo: docenv.fileManager.list(
+                    location, name, EnumSet.of(JavaFileObject.Kind.SOURCE), false)) {
+                String binaryName = docenv.fileManager.inferBinaryName(location, fo);
+                String simpleName = getSimpleName(binaryName);
+                if (isValidClassName(simpleName)) {
+                    lb.append(fo);
+                }
+            }
+            files = lb.toList();
+        }
+        if (files.nonEmpty()) {
+            for (JavaFileObject fo : files) {
+                parse(fo, trees, false);
+            }
+        } else {
+            messager.warning(Messager.NOPOS, "main.no_source_files_for_package",
+                             name.replace(File.separatorChar, '.'));
+        }
+    }
+
+    private void parse(JavaFileObject fo, ListBuffer<JCCompilationUnit> trees,
+                       boolean trace) {
+        if (uniquefiles.add(fo)) { // ignore duplicates
+            if (trace)
+                docenv.notice("main.Loading_source_file", fo.getName());
+            trees.append(parse(fo));
+        }
+    }
+
+    /**
+     * Recursively search all directories in path for subdirectory name.
+     * Add all packages found in such a directory to packages list.
+     */
+    private Map<String,List<JavaFileObject>> searchSubPackages(
+            List<String> subPackages,
+            ListBuffer<String> packages,
+            List<String> excludedPackages)
+            throws IOException {
+        Map<String,List<JavaFileObject>> packageFiles =
+                new HashMap<String,List<JavaFileObject>>();
+
+        Map<String,Boolean> includedPackages = new HashMap<String,Boolean>();
+        includedPackages.put("", true);
+        for (String p: excludedPackages)
+            includedPackages.put(p, false);
+
+        StandardLocation path = docenv.fileManager.hasLocation(StandardLocation.SOURCE_PATH)
+                ? StandardLocation.SOURCE_PATH : StandardLocation.CLASS_PATH;
+
+        searchSubPackages(subPackages,
+                includedPackages,
+                packages, packageFiles,
+                path,
+                EnumSet.of(JavaFileObject.Kind.SOURCE));
+
+        return packageFiles;
+    }
+
+    private void searchSubPackages(List<String> subPackages,
+            Map<String,Boolean> includedPackages,
+            ListBuffer<String> packages,
+            Map<String, List<JavaFileObject>> packageFiles,
+            StandardLocation location, Set<JavaFileObject.Kind> kinds)
+            throws IOException {
+        for (String subPackage: subPackages) {
+            if (!isIncluded(subPackage, includedPackages))
+                continue;
+
+            for (JavaFileObject fo: docenv.fileManager.list(location, subPackage, kinds, true)) {
+                String binaryName = docenv.fileManager.inferBinaryName(location, fo);
+                String packageName = getPackageName(binaryName);
+                String simpleName = getSimpleName(binaryName);
+                if (isIncluded(packageName, includedPackages) && isValidClassName(simpleName)) {
+                    List<JavaFileObject> list = packageFiles.get(packageName);
+                    list = (list == null ? List.of(fo) : list.prepend(fo));
+                    packageFiles.put(packageName, list);
+                    if (!packages.contains(packageName))
+                        packages.add(packageName);
+                }
+            }
+        }
+    }
+
+    private String getPackageName(String name) {
+        int lastDot = name.lastIndexOf(".");
+        return (lastDot == -1 ? "" : name.substring(0, lastDot));
+    }
+
+    private String getSimpleName(String name) {
+        int lastDot = name.lastIndexOf(".");
+        return (lastDot == -1 ? name : name.substring(lastDot + 1));
+    }
+
+    private boolean isIncluded(String packageName, Map<String,Boolean> includedPackages) {
+        Boolean b = includedPackages.get(packageName);
+        if (b == null) {
+            b = isIncluded(getPackageName(packageName), includedPackages);
+            includedPackages.put(packageName, b);
+        }
+        return b;
+    }
+
+    /**
+     * Recursively search all directories in path for subdirectory name.
+     * Add all packages found in such a directory to packages list.
+     */
+    private void searchSubPackage(String packageName,
+                                  ListBuffer<String> packages,
+                                  List<String> excludedPackages,
+                                  Collection<File> pathnames) {
+        if (excludedPackages.contains(packageName))
+            return;
+
+        String packageFilename = packageName.replace('.', File.separatorChar);
+        boolean addedPackage = false;
+        for (File pathname : pathnames) {
+            File f = new File(pathname, packageFilename);
+            String filenames[] = f.list();
+            // if filenames not null, then found directory
+            if (filenames != null) {
+                for (String filename : filenames) {
+                    if (!addedPackage
+                            && (isValidJavaSourceFile(filename) ||
+                                isValidJavaClassFile(filename))
+                            && !packages.contains(packageName)) {
+                        packages.append(packageName);
+                        addedPackage = true;
+                    } else if (isValidClassName(filename) &&
+                               (new File(f, filename)).isDirectory()) {
+                        searchSubPackage(packageName + "." + filename,
+                                         packages, excludedPackages, pathnames);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Return true if given file name is a valid class file name.
+     * @param file the name of the file to check.
+     * @return true if given file name is a valid class file name
+     * and false otherwise.
+     */
+    private static boolean isValidJavaClassFile(String file) {
+        if (!file.endsWith(".class")) return false;
+        String clazzName = file.substring(0, file.length() - ".class".length());
+        return isValidClassName(clazzName);
+    }
+
+    /**
+     * Return true if given file name is a valid Java source file name.
+     * @param file the name of the file to check.
+     * @return true if given file name is a valid Java source file name
+     * and false otherwise.
+     */
+    private static boolean isValidJavaSourceFile(String file) {
+        if (!file.endsWith(".java")) return false;
+        String clazzName = file.substring(0, file.length() - ".java".length());
+        return isValidClassName(clazzName);
+    }
+
+    /** Are surrogates supported?
+     */
+    final static boolean surrogatesSupported = surrogatesSupported();
+    private static boolean surrogatesSupported() {
+        try {
+            boolean b = Character.isHighSurrogate('a');
+            return true;
+        } catch (NoSuchMethodError ex) {
+            return false;
+        }
+    }
+
+    /**
+     * Return true if given file name is a valid class name
+     * (including "package-info").
+     * @param s the name of the class to check.
+     * @return true if given class name is a valid class name
+     * and false otherwise.
+     */
+    public static boolean isValidClassName(String s) {
+        if (s.length() < 1) return false;
+        if (s.equals("package-info")) return true;
+        if (surrogatesSupported) {
+            int cp = s.codePointAt(0);
+            if (!Character.isJavaIdentifierStart(cp))
+                return false;
+            for (int j=Character.charCount(cp); j<s.length(); j+=Character.charCount(cp)) {
+                cp = s.codePointAt(j);
+                if (!Character.isJavaIdentifierPart(cp))
+                    return false;
+            }
+        } else {
+            if (!Character.isJavaIdentifierStart(s.charAt(0)))
+                return false;
+            for (int j=1; j<s.length(); j++)
+                if (!Character.isJavaIdentifierPart(s.charAt(j)))
+                    return false;
+        }
+        return true;
+    }
+
+    /**
+     * From a list of top level trees, return the list of contained class definitions
+     */
+    List<JCClassDecl> listClasses(List<JCCompilationUnit> trees) {
+        ListBuffer<JCClassDecl> result = new ListBuffer<JCClassDecl>();
+        for (JCCompilationUnit t : trees) {
+            for (JCTree def : t.defs) {
+                if (def.hasTag(JCTree.Tag.CLASSDEF))
+                    result.append((JCClassDecl)def);
+            }
+        }
+        return result.toList();
+    }
+
+}

jdkSrc/jdk8/com/sun/tools/javadoc/Main.java

@@ -0,0 +1,193 @@
+/*
+ * Copyright (c) 2000, 2012, 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.javadoc;
+
+import java.io.PrintWriter;
+
+/**
+ * Provides external entry points (tool and programmatic)
+ * for the javadoc program.
+ *
+ *  <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>
+ *
+ * @since 1.4
+ */
+public class Main {
+
+    /**
+     * Constructor should never be called.
+     */
+    private Main() {
+    }
+
+    /**
+     * Command line interface.
+     * @param args   The command line parameters.
+     */
+    public static void main(String... args) {
+        System.exit(execute(args));
+    }
+
+    /**
+     * Programmatic interface.
+     * @param args   The command line parameters.
+     * @return The return code.
+     */
+    public static int execute(String... args) {
+        Start jdoc = new Start();
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param args   The command line parameters.
+     * @param docletParentClassLoader The parent class loader used when
+     *  creating the doclet classloader. If null, the class loader used
+     *  to instantiate doclets will be created without specifying a parent
+     *  class loader.
+     * @return The return code.
+     * @since 1.7
+     */
+    public static int execute(ClassLoader docletParentClassLoader, String... args) {
+        Start jdoc = new Start(docletParentClassLoader);
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param programName  Name of the program (for error messages).
+     * @param args   The command line parameters.
+     * @return The return code.
+     */
+    public static int execute(String programName, String... args) {
+        Start jdoc = new Start(programName);
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param programName  Name of the program (for error messages).
+     * @param args   The command line parameters.
+     * @param docletParentClassLoader The parent class loader used when
+     *  creating the doclet classloader. If null, the class loader used
+     *  to instantiate doclets will be created without specifying a parent
+     *  class loader.
+     * @return The return code.
+     * @since 1.7
+     */
+    public static int execute(String programName, ClassLoader docletParentClassLoader, String... args) {
+        Start jdoc = new Start(programName, docletParentClassLoader);
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param programName  Name of the program (for error messages).
+     * @param defaultDocletClassName  Fully qualified class name.
+     * @param args   The command line parameters.
+     * @return The return code.
+     */
+    public static int execute(String programName,
+                              String defaultDocletClassName,
+                              String... args) {
+        Start jdoc = new Start(programName, defaultDocletClassName);
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param programName  Name of the program (for error messages).
+     * @param defaultDocletClassName  Fully qualified class name.
+     * @param docletParentClassLoader The parent class loader used when
+     *  creating the doclet classloader. If null, the class loader used
+     *  to instantiate doclets will be created without specifying a parent
+     *  class loader.
+     * @param args   The command line parameters.
+     * @return The return code.
+     * @since 1.7
+     */
+    public static int execute(String programName,
+                              String defaultDocletClassName,
+                              ClassLoader docletParentClassLoader,
+                              String... args) {
+        Start jdoc = new Start(programName, defaultDocletClassName, docletParentClassLoader);
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param programName  Name of the program (for error messages).
+     * @param errWriter    PrintWriter to receive error messages.
+     * @param warnWriter    PrintWriter to receive error messages.
+     * @param noticeWriter    PrintWriter to receive error messages.
+     * @param defaultDocletClassName  Fully qualified class name.
+     * @param args   The command line parameters.
+     * @return The return code.
+     */
+    public static int execute(String programName,
+                              PrintWriter errWriter,
+                              PrintWriter warnWriter,
+                              PrintWriter noticeWriter,
+                              String defaultDocletClassName,
+                              String... args) {
+        Start jdoc = new Start(programName,
+                               errWriter, warnWriter, noticeWriter,
+                               defaultDocletClassName);
+        return jdoc.begin(args);
+    }
+
+    /**
+     * Programmatic interface.
+     * @param programName  Name of the program (for error messages).
+     * @param errWriter    PrintWriter to receive error messages.
+     * @param warnWriter    PrintWriter to receive error messages.
+     * @param noticeWriter    PrintWriter to receive error messages.
+     * @param defaultDocletClassName  Fully qualified class name.
+     * @param docletParentClassLoader The parent class loader used when
+     *  creating the doclet classloader. If null, the class loader used
+     *  to instantiate doclets will be created without specifying a parent
+     *  class loader.
+     * @param args   The command line parameters.
+     * @return The return code.
+     * @since 1.7
+     */
+    public static int execute(String programName,
+                              PrintWriter errWriter,
+                              PrintWriter warnWriter,
+                              PrintWriter noticeWriter,
+                              String defaultDocletClassName,
+                              ClassLoader docletParentClassLoader,
+                              String... args) {
+        Start jdoc = new Start(programName,
+                               errWriter, warnWriter, noticeWriter,
+                               defaultDocletClassName,
+                               docletParentClassLoader);
+        return jdoc.begin(args);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/MemberDocImpl.java

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1997, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Symbol;
+
+/**
+ * Represents a member of a java class: field, constructor, or method.
+ * This is an abstract class dealing with information common to
+ * method, constructor and field members. Class members of a class
+ * (nested classes) are represented instead by ClassDocImpl.
+ *
+ *  <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>
+ *
+ * @see MethodDocImpl
+ * @see FieldDocImpl
+ * @see ClassDocImpl
+ *
+ * @author Robert Field
+ * @author Neal Gafter
+ */
+
+public abstract class MemberDocImpl
+    extends ProgramElementDocImpl
+    implements MemberDoc {
+
+    /**
+     * constructor.
+     */
+    public MemberDocImpl(DocEnv env, Symbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+    }
+
+    /**
+     * Returns true if this field was synthesized by the compiler.
+     */
+    public abstract boolean isSynthetic();
+}

jdkSrc/jdk8/com/sun/tools/javadoc/Messager.java

@@ -0,0 +1,320 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import java.io.PrintWriter;
+import java.util.Locale;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.JCDiagnostic;
+import com.sun.tools.javac.util.JCDiagnostic.DiagnosticType;
+import com.sun.tools.javac.util.JavacMessages;
+import com.sun.tools.javac.util.Log;
+
+/**
+ * Utility for integrating with javadoc tools and for localization.
+ * Handle Resources. Access to error and warning counts.
+ * Message formatting.
+ * <br>
+ * Also provides implementation for DocErrorReporter.
+ *
+ *  <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>
+ *
+ * @see java.util.ResourceBundle
+ * @see java.text.MessageFormat
+ * @author Neal Gafter (rewrite)
+ */
+public class Messager extends Log implements DocErrorReporter {
+    public static final SourcePosition NOPOS = null;
+
+    /** Get the current messager, which is also the compiler log. */
+    public static Messager instance0(Context context) {
+        Log instance = context.get(logKey);
+        if (instance == null || !(instance instanceof Messager))
+            throw new InternalError("no messager instance!");
+        return (Messager)instance;
+    }
+
+    public static void preRegister(Context context,
+                                   final String programName) {
+        context.put(logKey, new Context.Factory<Log>() {
+            public Log make(Context c) {
+                return new Messager(c,
+                                    programName);
+            }
+        });
+    }
+    public static void preRegister(Context context,
+                                   final String programName,
+                                   final PrintWriter errWriter,
+                                   final PrintWriter warnWriter,
+                                   final PrintWriter noticeWriter) {
+        context.put(logKey, new Context.Factory<Log>() {
+            public Log make(Context c) {
+                return new Messager(c,
+                                    programName,
+                                    errWriter,
+                                    warnWriter,
+                                    noticeWriter);
+            }
+        });
+    }
+
+    public class ExitJavadoc extends Error {
+        private static final long serialVersionUID = 0;
+    }
+
+    final String programName;
+
+    private Locale locale;
+    private final JavacMessages messages;
+    private final JCDiagnostic.Factory javadocDiags;
+
+    /** The default writer for diagnostics
+     */
+    static final PrintWriter defaultErrWriter = new PrintWriter(System.err);
+    static final PrintWriter defaultWarnWriter = new PrintWriter(System.err);
+    static final PrintWriter defaultNoticeWriter = new PrintWriter(System.out);
+
+    /**
+     * Constructor
+     * @param programName  Name of the program (for error messages).
+     */
+    protected Messager(Context context, String programName) {
+        this(context, programName, defaultErrWriter, defaultWarnWriter, defaultNoticeWriter);
+    }
+
+    /**
+     * Constructor
+     * @param programName  Name of the program (for error messages).
+     * @param errWriter    Stream for error messages
+     * @param warnWriter   Stream for warnings
+     * @param noticeWriter Stream for other messages
+     */
+    @SuppressWarnings("deprecation")
+    protected Messager(Context context,
+                       String programName,
+                       PrintWriter errWriter,
+                       PrintWriter warnWriter,
+                       PrintWriter noticeWriter) {
+        super(context, errWriter, warnWriter, noticeWriter);
+        messages = JavacMessages.instance(context);
+        messages.add("com.sun.tools.javadoc.resources.javadoc");
+        javadocDiags = new JCDiagnostic.Factory(messages, "javadoc");
+        this.programName = programName;
+    }
+
+    public void setLocale(Locale locale) {
+        this.locale = locale;
+    }
+
+    /**
+     * get and format message string from resource
+     *
+     * @param key selects message from resource
+     * @param args arguments for the message
+     */
+    String getText(String key, Object... args) {
+        return messages.getLocalizedString(locale, key, args);
+    }
+
+    /**
+     * Print error message, increment error count.
+     * Part of DocErrorReporter.
+     *
+     * @param msg message to print
+     */
+    public void printError(String msg) {
+        printError(null, msg);
+    }
+
+    /**
+     * Print error message, increment error count.
+     * Part of DocErrorReporter.
+     *
+     * @param pos the position where the error occurs
+     * @param msg message to print
+     */
+    public void printError(SourcePosition pos, String msg) {
+        if (diagListener != null) {
+            report(DiagnosticType.ERROR, pos, msg);
+            return;
+        }
+
+        if (nerrors < MaxErrors) {
+            String prefix = (pos == null) ? programName : pos.toString();
+            errWriter.println(prefix + ": " + getText("javadoc.error") + " - " + msg);
+            errWriter.flush();
+            prompt();
+            nerrors++;
+        }
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     * Part of DocErrorReporter.
+     *
+     * @param msg message to print
+     */
+    public void printWarning(String msg) {
+        printWarning(null, msg);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     * Part of DocErrorReporter.
+     *
+     * @param pos the position where the error occurs
+     * @param msg message to print
+     */
+    public void printWarning(SourcePosition pos, String msg) {
+        if (diagListener != null) {
+            report(DiagnosticType.WARNING, pos, msg);
+            return;
+        }
+
+        if (nwarnings < MaxWarnings) {
+            String prefix = (pos == null) ? programName : pos.toString();
+            warnWriter.println(prefix +  ": " + getText("javadoc.warning") +" - " + msg);
+            warnWriter.flush();
+            nwarnings++;
+        }
+    }
+
+    /**
+     * Print a message.
+     * Part of DocErrorReporter.
+     *
+     * @param msg message to print
+     */
+    public void printNotice(String msg) {
+        printNotice(null, msg);
+    }
+
+    /**
+     * Print a message.
+     * Part of DocErrorReporter.
+     *
+     * @param pos the position where the error occurs
+     * @param msg message to print
+     */
+    public void printNotice(SourcePosition pos, String msg) {
+        if (diagListener != null) {
+            report(DiagnosticType.NOTE, pos, msg);
+            return;
+        }
+
+        if (pos == null)
+            noticeWriter.println(msg);
+        else
+            noticeWriter.println(pos + ": " + msg);
+        noticeWriter.flush();
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param key selects message from resource
+     */
+    public void error(SourcePosition pos, String key, Object... args) {
+        printError(pos, getText(key, args));
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param key selects message from resource
+     */
+    public void warning(SourcePosition pos, String key, Object... args) {
+        printWarning(pos, getText(key, args));
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param key selects message from resource
+     */
+    public void notice(String key, Object... args) {
+        printNotice(getText(key, args));
+    }
+
+    /**
+     * Return total number of errors, including those recorded
+     * in the compilation log.
+     */
+    public int nerrors() { return nerrors; }
+
+    /**
+     * Return total number of warnings, including those recorded
+     * in the compilation log.
+     */
+    public int nwarnings() { return nwarnings; }
+
+    /**
+     * Print exit message.
+     */
+    public void exitNotice() {
+        if (nerrors > 0) {
+            notice((nerrors > 1) ? "main.errors" : "main.error",
+                   "" + nerrors);
+        }
+        if (nwarnings > 0) {
+            notice((nwarnings > 1) ?  "main.warnings" : "main.warning",
+                   "" + nwarnings);
+        }
+    }
+
+    /**
+     * Force program exit, e.g., from a fatal error.
+     * <p>
+     * TODO: This method does not really belong here.
+     */
+    public void exit() {
+        throw new ExitJavadoc();
+    }
+
+    private void report(DiagnosticType type, SourcePosition pos, String msg) {
+        switch (type) {
+            case ERROR:
+            case WARNING:
+                Object prefix = (pos == null) ? programName : pos;
+                report(javadocDiags.create(type, null, null, "msg", prefix, msg));
+                break;
+
+            case NOTE:
+                String key = (pos == null) ? "msg" : "pos.msg";
+                report(javadocDiags.create(type, null, null, key, pos, msg));
+                break;
+
+            default:
+                throw new IllegalArgumentException(type.toString());
+        }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/MethodDocImpl.java

@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import java.lang.reflect.Modifier;
+
+import com.sun.javadoc.*;
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.*;
+import com.sun.tools.javac.code.Symbol.*;
+import com.sun.tools.javac.code.Type;
+import static com.sun.tools.javac.code.TypeTag.CLASS;
+
+/**
+ * Represents a method of a java class.
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ */
+
+public class MethodDocImpl
+        extends ExecutableMemberDocImpl implements MethodDoc {
+
+    /**
+     * constructor.
+     */
+    public MethodDocImpl(DocEnv env, MethodSymbol sym) {
+        super(env, sym);
+    }
+
+    /**
+     * constructor.
+     */
+    public MethodDocImpl(DocEnv env, MethodSymbol sym, TreePath treePath) {
+        super(env, sym, treePath);
+    }
+
+    /**
+     * Return true if it is a method, which it is.
+     * Note: constructors are not methods.
+     * This method is overridden by AnnotationTypeElementDocImpl.
+     *
+     * @return true
+     */
+    public boolean isMethod() {
+        return true;
+    }
+
+    /**
+     * Return true if this method is default
+     */
+    public boolean isDefault() {
+        return (sym.flags() & Flags.DEFAULT) != 0;
+    }
+
+    /**
+     * Return true if this method is abstract
+     */
+    public boolean isAbstract() {
+        return (Modifier.isAbstract(getModifiers()) && !isDefault());
+    }
+
+    /**
+     * Get return type.
+     *
+     * @return the return type of this method, null if it
+     * is a constructor.
+     */
+    public com.sun.javadoc.Type returnType() {
+        return TypeMaker.getType(env, sym.type.getReturnType(), false);
+    }
+
+    /**
+     * Return the class that originally defined the method that
+     * is overridden by the current definition, or null if no
+     * such class exists.
+     *
+     * @return a ClassDocImpl representing the superclass that
+     * originally defined this method, null if this method does
+     * not override a definition in a superclass.
+     */
+    public ClassDoc overriddenClass() {
+        com.sun.javadoc.Type t = overriddenType();
+        return (t != null) ? t.asClassDoc() : null;
+    }
+
+    /**
+     * Return the type containing the method that this method overrides.
+     * It may be a <code>ClassDoc</code> or a <code>ParameterizedType</code>.
+     */
+    public com.sun.javadoc.Type overriddenType() {
+
+        if ((sym.flags() & Flags.STATIC) != 0) {
+            return null;
+        }
+
+        ClassSymbol origin = (ClassSymbol)sym.owner;
+        for (Type t = env.types.supertype(origin.type);
+             t.hasTag(CLASS);
+             t = env.types.supertype(t)) {
+            ClassSymbol c = (ClassSymbol)t.tsym;
+            for (Scope.Entry e = membersOf(c).lookup(sym.name); e.scope != null; e = e.next()) {
+                if (sym.overrides(e.sym, origin, env.types, true)) {
+                    return TypeMaker.getType(env, t);
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Return the method that this method overrides.
+     *
+     * @return a MethodDoc representing a method definition
+     * in a superclass this method overrides, null if
+     * this method does not override.
+     */
+    public MethodDoc overriddenMethod() {
+
+        // Real overriding only.  Static members are simply hidden.
+        // Likewise for constructors, but the MethodSymbol.overrides
+        // method takes this into account.
+        if ((sym.flags() & Flags.STATIC) != 0) {
+            return null;
+        }
+
+        // Derived from  com.sun.tools.javac.comp.Check.checkOverride .
+
+        ClassSymbol origin = (ClassSymbol)sym.owner;
+        for (Type t = env.types.supertype(origin.type);
+             t.hasTag(CLASS);
+             t = env.types.supertype(t)) {
+            ClassSymbol c = (ClassSymbol)t.tsym;
+            for (Scope.Entry e = membersOf(c).lookup(sym.name); e.scope != null; e = e.next()) {
+                if (sym.overrides(e.sym, origin, env.types, true)) {
+                    return env.getMethodDoc((MethodSymbol)e.sym);
+                }
+            }
+        }
+        return null;
+    }
+
+    /**Retrieve members of c, ignoring any CompletionFailures that occur. */
+    private Scope membersOf(ClassSymbol c) {
+        try {
+            return c.members();
+        } catch (CompletionFailure cf) {
+            /* Quietly ignore completion failures and try again - the type
+             * for which the CompletionFailure was thrown shouldn't be completed
+             * again by the completer that threw the CompletionFailure.
+             */
+            return membersOf(c);
+        }
+    }
+
+    /**
+     * Tests whether this method overrides another.
+     * The overridden method may be one declared in a superclass or
+     * a superinterface (unlike {@link #overriddenMethod()}).
+     *
+     * <p> When a non-abstract method overrides an abstract one, it is
+     * also said to <i>implement</i> the other.
+     *
+     * @param meth  the other method to examine
+     * @return <tt>true</tt> if this method overrides the other
+     */
+    public boolean overrides(MethodDoc meth) {
+        MethodSymbol overridee = ((MethodDocImpl) meth).sym;
+        ClassSymbol origin = (ClassSymbol) sym.owner;
+
+        return sym.name == overridee.name &&
+
+               // not reflexive as per JLS
+               sym != overridee &&
+
+               // we don't care if overridee is static, though that wouldn't
+               // compile
+               !sym.isStatic() &&
+
+               // sym, whose declaring type is the origin, must be
+               // in a subtype of overridee's type
+               env.types.asSuper(origin.type, overridee.owner) != null &&
+
+               // check access and signatures; don't check return types
+               sym.overrides(overridee, origin, env.types, false);
+    }
+
+
+    public String name() {
+        if (name == null) {
+            name = sym.name.toString();
+        }
+        return name;
+    }
+
+    private String name;
+
+    public String qualifiedName() {
+        if (qualifiedName == null) {
+            qualifiedName =  sym.enclClass().getQualifiedName() + "." + sym.name;
+        }
+        return qualifiedName;
+    }
+
+    private String qualifiedName;
+
+    /**
+     * Returns a string representation of this method.  Includes the
+     * qualified signature, the qualified method name, and any type
+     * parameters.  Type parameters follow the class name, as they do
+     * in the syntax for invoking methods with explicit type parameters.
+     */
+    public String toString() {
+        return sym.enclClass().getQualifiedName() +
+                "." + typeParametersString() + name() + signature();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ModifierFilter.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2000, 2012, 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.javadoc;
+
+import static com.sun.tools.javac.code.Flags.*;
+
+/**
+ *   A class whose instances are filters over Modifier bits.
+ *   Filtering is done by returning boolean values.
+ *   Classes, methods and fields can be filtered, or filtering
+ *   can be done directly on modifier bits.
+ *
+ *  <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>
+ *
+ *   @see com.sun.tools.javac.code.Flags
+ *   @author Robert Field
+ */
+
+public class ModifierFilter {
+
+    /**
+    * Package private access.
+    * A "pseudo-" modifier bit that can be used in the
+    * constructors of this class to specify package private
+    * access. This is needed since there is no Modifier.PACKAGE.
+    */
+    public static final long PACKAGE = 0x8000000000000000L;
+
+    /**
+    * All access modifiers.
+    * A short-hand set of modifier bits that can be used in the
+    * constructors of this class to specify all access modifiers,
+    * Same as PRIVATE | PROTECTED | PUBLIC | PACKAGE.
+    */
+    public static final long ALL_ACCESS =
+                PRIVATE | PROTECTED | PUBLIC | PACKAGE;
+
+    private long oneOf;
+    private long must;
+    private long cannot;
+
+    private static final int ACCESS_BITS = PRIVATE | PROTECTED | PUBLIC;
+
+    /**
+     * Constructor - Specify a filter.
+     *
+     * @param   oneOf   If zero, everything passes the filter.
+     *                  If non-zero, at least one of the specified
+     *                  bits must be on in the modifier bits to
+     *                  pass the filter.
+     */
+    public ModifierFilter(long oneOf) {
+        this(oneOf, 0, 0);
+    }
+
+    /**
+     * Constructor - Specify a filter.
+     * For example, the filter below  will only pass synchronized
+     * methods that are private or package private access and are
+     * not native or static.
+     * <pre>
+     * ModifierFilter(  Modifier.PRIVATE | ModifierFilter.PACKAGE,
+     *                  Modifier.SYNCHRONIZED,
+     *                  Modifier.NATIVE | Modifier.STATIC)
+     * </pre><p>
+     * Each of the three arguments must either be
+     * zero or the or'ed combination of the bits specified in the
+     * class Modifier or this class. During filtering, these values
+     * are compared against the modifier bits as follows:
+     *
+     * @param   oneOf   If zero, ignore this argument.
+     *                  If non-zero, at least one of the bits must be on.
+     * @param   must    All bits specified must be on.
+     * @param   cannot  None of the bits specified can be on.
+     */
+    public ModifierFilter(long oneOf, long must, long cannot) {
+        this.oneOf = oneOf;
+        this.must = must;
+        this.cannot = cannot;
+    }
+
+    /**
+     * Filter on modifier bits.
+     *
+     * @param   modifierBits    Bits as specified in the Modifier class
+     *
+     * @return                  Whether the modifierBits pass this filter.
+     */
+    public boolean checkModifier(int modifierBits) {
+        // Add in the "pseudo-" modifier bit PACKAGE, if needed
+        long fmod = ((modifierBits & ACCESS_BITS) == 0) ?
+                        modifierBits | PACKAGE :
+                        modifierBits;
+        return ((oneOf == 0) || ((oneOf & fmod) != 0)) &&
+                ((must & fmod) == must) &&
+                ((cannot & fmod) == 0);
+    }
+
+} // end ModifierFilter

jdkSrc/jdk8/com/sun/tools/javadoc/PackageDocImpl.java

@@ -0,0 +1,388 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+import javax.tools.FileObject;
+
+import com.sun.javadoc.*;
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Scope;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.PackageSymbol;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.Position;
+
+/**
+ * Represents a java package.  Provides access to information
+ * about the package, the package's comment and tags, and the
+ * classes in the package.
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Kaiyang Liu (original)
+ * @author Robert Field (rewrite)
+ * @author Neal Gafter (rewrite)
+ * @author Scott Seligman (package-info.java)
+ */
+
+public class PackageDocImpl extends DocImpl implements PackageDoc {
+
+    protected PackageSymbol sym;
+    private JCCompilationUnit tree = null;    // for source position
+
+    public FileObject docPath = null;
+    private boolean foundDoc;   // found a doc comment in either
+                                // package.html or package-info.java
+
+    boolean isIncluded = false;  // Set in RootDocImpl.
+    public boolean setDocPath = false;  //Flag to avoid setting doc path multiple times.
+
+    /**
+     * Constructor
+     */
+    public PackageDocImpl(DocEnv env, PackageSymbol sym) {
+        this(env, sym, null);
+    }
+
+    /**
+     * Constructor
+     */
+    public PackageDocImpl(DocEnv env, PackageSymbol sym, TreePath treePath) {
+        super(env, treePath);
+        this.sym = sym;
+        this.tree = (treePath == null) ? null : (JCCompilationUnit) treePath.getCompilationUnit();
+        foundDoc = (documentation != null);
+    }
+
+    void setTree(JCTree tree) {
+        this.tree = (JCCompilationUnit) tree;
+    }
+
+    public void setTreePath(TreePath treePath) {
+        super.setTreePath(treePath);
+        checkDoc();
+    }
+
+    /**
+     * Do lazy initialization of "documentation" string.
+     */
+    protected String documentation() {
+        if (documentation != null)
+            return documentation;
+        if (docPath != null) {
+            // read from file
+            try {
+                InputStream s = docPath.openInputStream();
+                documentation = readHTMLDocumentation(s, docPath);
+            } catch (IOException exc) {
+                documentation = "";
+                env.error(null, "javadoc.File_Read_Error", docPath.getName());
+            }
+        } else {
+            // no doc file to be had
+            documentation = "";
+        }
+        return documentation;
+    }
+
+    /**
+     * Cache of all classes contained in this package, including
+     * member classes of those classes, and their member classes, etc.
+     * Includes only those classes at the specified protection level
+     * and weaker.
+     */
+    private List<ClassDocImpl> allClassesFiltered = null;
+
+    /**
+     * Cache of all classes contained in this package, including
+     * member classes of those classes, and their member classes, etc.
+     */
+    private List<ClassDocImpl> allClasses = null;
+
+    /**
+     * Return a list of all classes contained in this package, including
+     * member classes of those classes, and their member classes, etc.
+     */
+    private List<ClassDocImpl> getClasses(boolean filtered) {
+        if (allClasses != null && !filtered) {
+            return allClasses;
+        }
+        if (allClassesFiltered != null && filtered) {
+            return allClassesFiltered;
+        }
+        ListBuffer<ClassDocImpl> classes = new ListBuffer<ClassDocImpl>();
+        for (Scope.Entry e = sym.members().elems; e != null; e = e.sibling) {
+            if (e.sym != null) {
+                ClassSymbol s = (ClassSymbol)e.sym;
+                ClassDocImpl c = env.getClassDoc(s);
+                if (c != null && !c.isSynthetic())
+                    c.addAllClasses(classes, filtered);
+            }
+        }
+        if (filtered)
+            return allClassesFiltered = classes.toList();
+        else
+            return allClasses = classes.toList();
+    }
+
+    /**
+     * Add all included classes (including Exceptions and Errors)
+     * and interfaces.
+     */
+    public void addAllClassesTo(ListBuffer<ClassDocImpl> list) {
+        list.appendList(getClasses(true));
+    }
+
+    /**
+     * Get all classes (including Exceptions and Errors)
+     * and interfaces.
+     * @since J2SE1.4.
+     *
+     * @return all classes and interfaces in this package, filtered to include
+     * only the included classes if filter==true.
+     */
+    public ClassDoc[] allClasses(boolean filter) {
+        List<ClassDocImpl> classes = getClasses(filter);
+        return classes.toArray(new ClassDocImpl[classes.length()]);
+    }
+
+    /**
+     * Get all included classes (including Exceptions and Errors)
+     * and interfaces.  Same as allClasses(true).
+     *
+     * @return all included classes and interfaces in this package.
+     */
+    public ClassDoc[] allClasses() {
+        return allClasses(true);
+    }
+
+    /**
+     * Get ordinary classes (that is, exclude exceptions, errors,
+     * enums, interfaces, and annotation types) in this package.
+     *
+     * @return included ordinary classes in this package.
+     */
+    public ClassDoc[] ordinaryClasses() {
+        ListBuffer<ClassDocImpl> ret = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl c : getClasses(true)) {
+            if (c.isOrdinaryClass()) {
+                ret.append(c);
+            }
+        }
+        return ret.toArray(new ClassDocImpl[ret.length()]);
+    }
+
+    /**
+     * Get Exception classes in this package.
+     *
+     * @return included Exceptions in this package.
+     */
+    public ClassDoc[] exceptions() {
+        ListBuffer<ClassDocImpl> ret = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl c : getClasses(true)) {
+            if (c.isException()) {
+                ret.append(c);
+            }
+        }
+        return ret.toArray(new ClassDocImpl[ret.length()]);
+    }
+
+    /**
+     * Get Error classes in this package.
+     *
+     * @return included Errors in this package.
+     */
+    public ClassDoc[] errors() {
+        ListBuffer<ClassDocImpl> ret = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl c : getClasses(true)) {
+            if (c.isError()) {
+                ret.append(c);
+            }
+        }
+        return ret.toArray(new ClassDocImpl[ret.length()]);
+    }
+
+    /**
+     * Get included enum types in this package.
+     *
+     * @return included enum types in this package.
+     */
+    public ClassDoc[] enums() {
+        ListBuffer<ClassDocImpl> ret = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl c : getClasses(true)) {
+            if (c.isEnum()) {
+                ret.append(c);
+            }
+        }
+        return ret.toArray(new ClassDocImpl[ret.length()]);
+    }
+
+    /**
+     * Get included interfaces in this package, omitting annotation types.
+     *
+     * @return included interfaces in this package.
+     */
+    public ClassDoc[] interfaces() {
+        ListBuffer<ClassDocImpl> ret = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl c : getClasses(true)) {
+            if (c.isInterface()) {
+                ret.append(c);
+            }
+        }
+        return ret.toArray(new ClassDocImpl[ret.length()]);
+    }
+
+    /**
+     * Get included annotation types in this package.
+     *
+     * @return included annotation types in this package.
+     */
+    public AnnotationTypeDoc[] annotationTypes() {
+        ListBuffer<AnnotationTypeDocImpl> ret =
+            new ListBuffer<AnnotationTypeDocImpl>();
+        for (ClassDocImpl c : getClasses(true)) {
+            if (c.isAnnotationType()) {
+                ret.append((AnnotationTypeDocImpl)c);
+            }
+        }
+        return ret.toArray(new AnnotationTypeDocImpl[ret.length()]);
+    }
+
+    /**
+     * Get the annotations of this package.
+     * Return an empty array if there are none.
+     */
+    public AnnotationDesc[] annotations() {
+        AnnotationDesc res[] = new AnnotationDesc[sym.getRawAttributes().length()];
+        int i = 0;
+        for (Attribute.Compound a : sym.getRawAttributes()) {
+            res[i++] = new AnnotationDescImpl(env, a);
+        }
+        return res;
+    }
+
+
+    /**
+     * Lookup for a class within this package.
+     *
+     * @return ClassDocImpl of found class, or null if not found.
+     */
+    public ClassDoc findClass(String className) {
+        final boolean filtered = true;
+        for (ClassDocImpl c : getClasses(filtered)) {
+            if (c.name().equals(className)) {
+                return c;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Return true if this package is included in the active set.
+     */
+    public boolean isIncluded() {
+        return isIncluded;
+    }
+
+    /**
+     * Get package name.
+     *
+     * Note that we do not provide a means of obtaining the simple
+     * name of a package -- package names are always returned in their
+     * uniquely qualified form.
+     */
+    public String name() {
+        return qualifiedName();
+    }
+
+    /**
+     * Get package name.
+     */
+    public String qualifiedName() {
+        if (qualifiedName == null) {
+            Name fullname = sym.getQualifiedName();
+            // Some bogus tests depend on the interned "" being returned.
+            // See 6457276.
+            qualifiedName = fullname.isEmpty() ? "" : fullname.toString();
+        }
+        return qualifiedName;
+    }
+
+    private String qualifiedName;
+
+    /**
+     * set doc path for an unzipped directory
+     */
+    public void setDocPath(FileObject path) {
+        setDocPath = true;
+        if (path == null)
+            return;
+        if (!path.equals(docPath)) {
+            docPath = path;
+            checkDoc();
+        }
+    }
+
+    // Has checkDoc() sounded off yet?
+    private boolean checkDocWarningEmitted = false;
+
+    /**
+     * Invoked when a source of package doc comments is located.
+     * Emits a diagnostic if this is the second one.
+     */
+    private void checkDoc() {
+        if (foundDoc) {
+            if (!checkDocWarningEmitted) {
+                env.warning(null, "javadoc.Multiple_package_comments", name());
+                checkDocWarningEmitted = true;
+            }
+        } else {
+            foundDoc = true;
+        }
+    }
+
+    /**
+     * Return the source position of the entity, or null if
+     * no position is available.
+     */
+    public SourcePosition position() {
+        return (tree != null)
+                ? SourcePositionImpl.make(tree.sourcefile, tree.pos, tree.lineMap)
+                : SourcePositionImpl.make(docPath, Position.NOPOS, null);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ParamTagImpl.java

@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) 1997, 2012, 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.javadoc;
+
+import java.util.regex.*;
+
+import com.sun.javadoc.*;
+
+/**
+ * Represents an @param documentation tag.
+ * Parses and stores the name and comment parts of the parameter tag.
+ *
+ *  <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>
+ *
+ * @author Robert Field
+ *
+ */
+class ParamTagImpl extends TagImpl implements ParamTag {
+
+    private static final Pattern typeParamRE = Pattern.compile("<([^<>]+)>");
+
+    private final String parameterName;
+    private final String parameterComment;
+    private final boolean isTypeParameter;
+
+    /**
+     * Cached inline tags.
+     */
+    private Tag[] inlineTags;
+
+    ParamTagImpl(DocImpl holder, String name, String text) {
+        super(holder, name, text);
+        String[] sa = divideAtWhite();
+
+        Matcher m = typeParamRE.matcher(sa[0]);
+        isTypeParameter = m.matches();
+        parameterName = isTypeParameter ? m.group(1) : sa[0];
+        parameterComment = sa[1];
+    }
+
+    /**
+     * Return the parameter name.
+     */
+    public String parameterName() {
+        return parameterName;
+    }
+
+    /**
+     * Return the parameter comment.
+     */
+    public String parameterComment() {
+        return parameterComment;
+    }
+
+    /**
+     * Return the kind of this tag.
+     */
+    @Override
+    public String kind() {
+        return "@param";
+    }
+
+    /**
+     * Return true if this ParamTag corresponds to a type parameter.
+     */
+    public boolean isTypeParameter() {
+        return isTypeParameter;
+    }
+
+    /**
+     * convert this object to a string.
+     */
+    @Override
+    public String toString() {
+        return name + ":" + text;
+    }
+
+    /**
+     * For the parameter comment with embedded @link tags return the array of
+     * TagImpls consisting of SeeTagImpl(s) and text containing TagImpl(s).
+     *
+     * @return TagImpl[] Array of tags with inline SeeTagImpls.
+     * @see TagImpl#inlineTags()
+     * @see ThrowsTagImpl#inlineTags()
+     */
+    @Override
+    public Tag[] inlineTags() {
+        if (inlineTags == null) {
+            inlineTags = Comment.getInlineTags(holder, parameterComment);
+        }
+        return inlineTags;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ParameterImpl.java

@@ -0,0 +1,109 @@
+/*
+ * Copyright (c) 1997, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Symbol.VarSymbol;
+
+/**
+ * ParameterImpl information.
+ * This includes a parameter type and parameter name.
+ *
+ *  <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>
+ *
+ * @author Kaiyang Liu (original)
+ * @author Robert Field (rewrite)
+ * @author Scott Seligman (generics, annotations)
+ */
+class ParameterImpl implements Parameter {
+
+    private final DocEnv env;
+    private final VarSymbol sym;
+    private final com.sun.javadoc.Type type;
+
+    /**
+     * Constructor of parameter info class.
+     */
+    ParameterImpl(DocEnv env, VarSymbol sym) {
+        this.env = env;
+        this.sym = sym;
+        this.type = TypeMaker.getType(env, sym.type, false);
+    }
+
+    /**
+     * Get the type of this parameter.
+     */
+    public com.sun.javadoc.Type type() {
+        return type;
+    }
+
+    /**
+     * Get local name of this parameter.
+     * For example if parameter is the short 'index', returns "index".
+     */
+    public String name() {
+        return sym.toString();
+    }
+
+    /**
+     * Get type name of this parameter.
+     * For example if parameter is the short 'index', returns "short".
+     */
+    public String typeName() {
+        return (type instanceof ClassDoc || type instanceof TypeVariable)
+                ? type.typeName()       // omit formal type params or bounds
+                : type.toString();
+    }
+
+    /**
+     * Returns a string representation of the parameter.
+     * <p>
+     * For example if parameter is the short 'index', returns "short index".
+     *
+     * @return type name and parameter name of this parameter.
+     */
+    public String toString() {
+        return typeName() + " " + sym;
+    }
+
+    /**
+     * Get the annotations of this parameter.
+     * Return an empty array if there are none.
+     */
+    public AnnotationDesc[] annotations() {
+        AnnotationDesc res[] = new AnnotationDesc[sym.getRawAttributes().length()];
+        int i = 0;
+        for (Attribute.Compound a : sym.getRawAttributes()) {
+            res[i++] = new AnnotationDescImpl(env, a);
+        }
+        return res;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ParameterizedTypeImpl.java

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2003, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Type.ClassType;
+
+import static com.sun.tools.javac.code.TypeTag.CLASS;
+
+
+/**
+ * Implementation of <code>ParameterizedType</code>, which
+ * represents an invocation of a generic class or interface.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+public class ParameterizedTypeImpl
+        extends AbstractTypeImpl implements ParameterizedType {
+
+    ParameterizedTypeImpl(DocEnv env, Type type) {
+        super(env, type);
+    }
+
+    /**
+     * Return the generic class or interface that declared this type.
+     */
+    @Override
+    public ClassDoc asClassDoc() {
+        return env.getClassDoc((ClassSymbol)type.tsym);
+    }
+
+    /**
+     * Return the actual type arguments of this type.
+     */
+    public com.sun.javadoc.Type[] typeArguments() {
+        return TypeMaker.getTypes(env, type.getTypeArguments());
+    }
+
+    /**
+     * Return the class type that is a direct supertype of this one.
+     * Return null if this is an interface type.
+     */
+    public com.sun.javadoc.Type superclassType() {
+        if (asClassDoc().isInterface()) {
+            return null;
+        }
+        Type sup = env.types.supertype(type);
+        return TypeMaker.getType(env,
+                                 (sup != type) ? sup : env.syms.objectType);
+    }
+
+    /**
+     * Return the interface types directly implemented by or extended by this
+     * parameterized type.
+     * Return an empty array if there are no interfaces.
+     */
+    public com.sun.javadoc.Type[] interfaceTypes() {
+        return TypeMaker.getTypes(env, env.types.interfaces(type));
+    }
+
+    /**
+     * Return the type that contains this type as a member.
+     * Return null is this is a top-level type.
+     */
+    public com.sun.javadoc.Type containingType() {
+        if (type.getEnclosingType().hasTag(CLASS)) {
+            // This is the type of an inner class.
+            return TypeMaker.getType(env, type.getEnclosingType());
+        }
+        ClassSymbol enclosing = type.tsym.owner.enclClass();
+        if (enclosing != null) {
+            // Nested but not inner.  Return the ClassDoc of the enclosing
+            // class or interface.
+            // See java.lang.reflect.ParameterizedType.getOwnerType().
+            return env.getClassDoc(enclosing);
+        }
+        return null;
+    }
+
+
+    // Asking for the "name" of a parameterized type doesn't exactly make
+    // sense.  It's a type expression.  Return the name of its generic
+    // type.
+    @Override
+    public String typeName() {
+        return TypeMaker.getTypeName(type, false);
+    }
+
+    @Override
+    public ParameterizedType asParameterizedType() {
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return parameterizedTypeToString(env, (ClassType)type, true);
+    }
+
+    static String parameterizedTypeToString(DocEnv env, ClassType cl,
+                                            boolean full) {
+        if (env.legacyDoclet) {
+            return TypeMaker.getTypeName(cl, full);
+        }
+        StringBuilder s = new StringBuilder();
+        if (!(cl.getEnclosingType().hasTag(CLASS))) {               // if not an inner class...
+            s.append(TypeMaker.getTypeName(cl, full));
+        } else {
+            ClassType encl = (ClassType)cl.getEnclosingType();
+            s.append(parameterizedTypeToString(env, encl, full))
+             .append('.')
+             .append(cl.tsym.name.toString());
+        }
+        s.append(TypeMaker.typeArgumentsString(env, cl, full));
+        return s.toString();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/PrimitiveType.java

@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2001, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+/**
+ *  <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>
+ */
+class PrimitiveType implements com.sun.javadoc.Type {
+
+    private final String name;
+
+    static final PrimitiveType voidType = new PrimitiveType("void");
+    static final PrimitiveType booleanType = new PrimitiveType("boolean");
+    static final PrimitiveType byteType = new PrimitiveType("byte");
+    static final PrimitiveType charType = new PrimitiveType("char");
+    static final PrimitiveType shortType = new PrimitiveType("short");
+    static final PrimitiveType intType = new PrimitiveType("int");
+    static final PrimitiveType longType = new PrimitiveType("long");
+    static final PrimitiveType floatType = new PrimitiveType("float");
+    static final PrimitiveType doubleType = new PrimitiveType("double");
+
+    // error type, should never actually be used
+    static final PrimitiveType errorType = new PrimitiveType("");
+
+    PrimitiveType(String name) {
+        this.name = name;
+    }
+
+    /**
+     * Return unqualified name of type excluding any dimension information.
+     * <p>
+     * For example, a two dimensional array of String returns 'String'.
+     */
+    public String typeName() {
+        return name;
+    }
+
+    public com.sun.javadoc.Type getElementType() {
+        return null;
+    }
+
+    /**
+     * Return qualified name of type excluding any dimension information.
+     *<p>
+     * For example, a two dimensional array of String
+     * returns 'java.lang.String'.
+     */
+    public String qualifiedTypeName() {
+        return name;
+    }
+
+    /**
+     * Return the simple name of this type.
+     */
+    public String simpleTypeName() {
+        return name;
+    }
+
+    /**
+     * Return the type's dimension information, as a string.
+     * <p>
+     * For example, a two dimensional array of String returns '[][]'.
+     */
+    public String dimension() {
+        return "";
+    }
+
+    /**
+     * Return this type as a class.  Array dimensions are ignored.
+     *
+     * @return a ClassDocImpl if the type is a Class.
+     * Return null if it is a primitive type..
+     */
+    public ClassDoc asClassDoc() {
+        return null;
+    }
+
+    /**
+     * Return null, as this is not an annotation type.
+     */
+    public AnnotationTypeDoc asAnnotationTypeDoc() {
+        return null;
+    }
+
+    /**
+     * Return null, as this is not an instantiation.
+     */
+    public ParameterizedType asParameterizedType() {
+        return null;
+    }
+
+    /**
+     * Return null, as this is not a type variable.
+     */
+    public TypeVariable asTypeVariable() {
+        return null;
+    }
+
+    /**
+     * Return null, as this is not a wildcard type.
+     */
+    public WildcardType asWildcardType() {
+        return null;
+    }
+
+    /**
+     * Return null, as this is not an annotated type.
+     */
+    public AnnotatedType asAnnotatedType() {
+        return null;
+    }
+
+    /**
+     * Returns a string representation of the type.
+     *
+     * Return name of type including any dimension information.
+     * <p>
+     * For example, a two dimensional array of String returns
+     * <code>String[][]</code>.
+     *
+     * @return name of type including any dimension information.
+     */
+    public String toString() {
+        return qualifiedTypeName();
+    }
+
+    /**
+     * Return true if this is a primitive type.
+     */
+    public boolean isPrimitive() {
+        return true;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ProgramElementDocImpl.java

@@ -0,0 +1,231 @@
+/*
+ * Copyright (c) 1997, 2012, 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.javadoc;
+
+import java.lang.reflect.Modifier;
+import java.text.CollationKey;
+
+import com.sun.javadoc.*;
+import com.sun.source.util.TreePath;
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import com.sun.tools.javac.util.Position;
+
+/**
+ * Represents a java program element: class, interface, field,
+ * constructor, or method.
+ * This is an abstract class dealing with information common to
+ * these elements.
+ *
+ *  <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>
+ *
+ * @see MemberDocImpl
+ * @see ClassDocImpl
+ *
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ * @author Scott Seligman (generics, enums, annotations)
+ */
+public abstract class ProgramElementDocImpl
+        extends DocImpl implements ProgramElementDoc {
+
+    private final Symbol sym;
+
+    // For source position information.
+    JCTree tree = null;
+    Position.LineMap lineMap = null;
+
+
+    // Cache for getModifiers().
+    private int modifiers = -1;
+
+    protected ProgramElementDocImpl(DocEnv env, Symbol sym, TreePath treePath) {
+        super(env, treePath);
+        this.sym = sym;
+        if (treePath != null) {
+            tree = (JCTree) treePath.getLeaf();
+            lineMap = ((JCCompilationUnit) treePath.getCompilationUnit()).lineMap;
+        }
+    }
+
+    @Override
+    void setTreePath(TreePath treePath) {
+        super.setTreePath(treePath);
+        this.tree = (JCTree) treePath.getLeaf();
+        this.lineMap = ((JCCompilationUnit) treePath.getCompilationUnit()).lineMap;
+    }
+
+    /**
+     * Subclasses override to identify the containing class
+     */
+    protected abstract ClassSymbol getContainingClass();
+
+    /**
+     * Returns the flags in terms of javac's flags
+     */
+    abstract protected long getFlags();
+
+    /**
+     * Returns the modifier flags in terms of java.lang.reflect.Modifier.
+     */
+    protected int getModifiers() {
+        if (modifiers == -1) {
+            modifiers = DocEnv.translateModifiers(getFlags());
+        }
+        return modifiers;
+    }
+
+    /**
+     * Get the containing class of this program element.
+     *
+     * @return a ClassDocImpl for this element's containing class.
+     * If this is a class with no outer class, return null.
+     */
+    public ClassDoc containingClass() {
+        if (getContainingClass() == null) {
+            return null;
+        }
+        return env.getClassDoc(getContainingClass());
+    }
+
+    /**
+     * Return the package that this member is contained in.
+     * Return "" if in unnamed package.
+     */
+    public PackageDoc containingPackage() {
+        return env.getPackageDoc(getContainingClass().packge());
+    }
+
+    /**
+     * Get the modifier specifier integer.
+     *
+     * @see java.lang.reflect.Modifier
+     */
+    public int modifierSpecifier() {
+        int modifiers = getModifiers();
+        if (isMethod() && containingClass().isInterface())
+            // Remove the implicit abstract modifier.
+            return modifiers & ~Modifier.ABSTRACT;
+        return modifiers;
+    }
+
+    /**
+     * Get modifiers string.
+     * <pre>
+     * Example, for:
+     *   public abstract int foo() { ... }
+     * modifiers() would return:
+     *   'public abstract'
+     * </pre>
+     * Annotations are not included.
+     */
+    public String modifiers() {
+        int modifiers = getModifiers();
+        if (isAnnotationTypeElement() ||
+                (isMethod() && containingClass().isInterface())) {
+            // Remove the implicit abstract modifier.
+            return Modifier.toString(modifiers & ~Modifier.ABSTRACT);
+        } else {
+            return Modifier.toString(modifiers);
+        }
+    }
+
+    /**
+     * Get the annotations of this program element.
+     * Return an empty array if there are none.
+     */
+    public AnnotationDesc[] annotations() {
+        AnnotationDesc res[] = new AnnotationDesc[sym.getRawAttributes().length()];
+        int i = 0;
+        for (Attribute.Compound a : sym.getRawAttributes()) {
+            res[i++] = new AnnotationDescImpl(env, a);
+        }
+        return res;
+    }
+
+    /**
+     * Return true if this program element is public
+     */
+    public boolean isPublic() {
+        int modifiers = getModifiers();
+        return Modifier.isPublic(modifiers);
+    }
+
+    /**
+     * Return true if this program element is protected
+     */
+    public boolean isProtected() {
+        int modifiers = getModifiers();
+        return Modifier.isProtected(modifiers);
+    }
+
+    /**
+     * Return true if this program element is private
+     */
+    public boolean isPrivate() {
+        int modifiers = getModifiers();
+        return Modifier.isPrivate(modifiers);
+    }
+
+    /**
+     * Return true if this program element is package private
+     */
+    public boolean isPackagePrivate() {
+        return !(isPublic() || isPrivate() || isProtected());
+    }
+
+    /**
+     * Return true if this program element is static
+     */
+    public boolean isStatic() {
+        int modifiers = getModifiers();
+        return Modifier.isStatic(modifiers);
+    }
+
+    /**
+     * Return true if this program element is final
+     */
+    public boolean isFinal() {
+        int modifiers = getModifiers();
+        return Modifier.isFinal(modifiers);
+    }
+
+    /**
+     * Generate a key for sorting.
+     */
+    CollationKey generateKey() {
+        String k = name();
+        // System.out.println("COLLATION KEY FOR " + this + " is \"" + k + "\"");
+        return env.doclocale.collator.getCollationKey(k);
+    }
+
+}

jdkSrc/jdk8/com/sun/tools/javadoc/RootDocImpl.java

@@ -0,0 +1,396 @@
+/*
+ * Copyright (c) 1997, 2016, 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.javadoc;
+
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Locale;
+
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.tree.JCTree.JCClassDecl;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Position;
+
+/**
+ * This class holds the information from one run of javadoc.
+ * Particularly the packages, classes and options specified
+ * by the user.
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Atul M Dambalkar
+ * @author Neal Gafter (rewrite)
+ */
+public class RootDocImpl extends DocImpl implements RootDoc {
+
+    /**
+     * list of classes specified on the command line.
+     */
+    private List<ClassDocImpl> cmdLineClasses;
+
+    /**
+     * list of packages specified on the command line.
+     */
+    private List<PackageDocImpl> cmdLinePackages;
+
+    /**
+     * a collection of all options.
+     */
+    private List<String[]> options;
+
+    /**
+     * Constructor used when reading source files.
+     *
+     * @param env the documentation environment, state for this javadoc run
+     * @param classes list of classes specified on the commandline
+     * @param packages list of package names specified on the commandline
+     * @param options list of options
+     */
+    public RootDocImpl(DocEnv env, List<JCClassDecl> classes, List<String> packages, List<String[]> options) {
+        super(env, null);
+        this.options = options;
+        setPackages(env, packages);
+        setClasses(env, classes);
+    }
+
+    /**
+     * Constructor used when reading class files.
+     *
+     * @param env the documentation environment, state for this javadoc run
+     * @param classes list of class names specified on the commandline
+     * @param options list of options
+     */
+    public RootDocImpl(DocEnv env, List<String> classes, List<String[]> options) {
+        super(env, null);
+        this.options = options;
+        cmdLinePackages = List.nil();
+        ListBuffer<ClassDocImpl> classList = new ListBuffer<ClassDocImpl>();
+        for (String className : classes) {
+            ClassDocImpl c = env.loadClass(className);
+            if (c == null)
+                env.error(null, "javadoc.class_not_found", className);
+            else
+                classList = classList.append(c);
+        }
+        cmdLineClasses = classList.toList();
+    }
+
+    /**
+     * Initialize classes information. Those classes are input from
+     * command line.
+     *
+     * @param env the compilation environment
+     * @param classes a list of ClassDeclaration
+     */
+    private void setClasses(DocEnv env, List<JCClassDecl> classes) {
+        ListBuffer<ClassDocImpl> result = new ListBuffer<ClassDocImpl>();
+        for (JCClassDecl def : classes) {
+            //### Do we want modifier check here?
+            if (env.shouldDocument(def.sym)) {
+                ClassDocImpl cd = env.getClassDoc(def.sym);
+                if (cd != null) {
+                    cd.isIncluded = true;
+                    result.append(cd);
+                } //else System.out.println(" (classdoc is null)");//DEBUG
+            } //else System.out.println(" (env.shouldDocument() returned false)");//DEBUG
+        }
+        cmdLineClasses = result.toList();
+    }
+
+    /**
+     * Initialize packages information.
+     *
+     * @param env the compilation environment
+     * @param packages a list of package names (String)
+     */
+    private void setPackages(DocEnv env, List<String> packages) {
+        ListBuffer<PackageDocImpl> packlist = new ListBuffer<PackageDocImpl>();
+        for (String name : packages) {
+            PackageDocImpl pkg = env.lookupPackage(name);
+            if (pkg != null) {
+                pkg.isIncluded = true;
+                packlist.append(pkg);
+            } else {
+                env.warning(null, "main.no_source_files_for_package", name);
+            }
+        }
+        cmdLinePackages = packlist.toList();
+    }
+
+    /**
+     * Command line options.
+     *
+     * <pre>
+     * For example, given:
+     *     javadoc -foo this that -bar other ...
+     *
+     * This method will return:
+     *      options()[0][0] = "-foo"
+     *      options()[0][1] = "this"
+     *      options()[0][2] = "that"
+     *      options()[1][0] = "-bar"
+     *      options()[1][1] = "other"
+     * </pre>
+     *
+     * @return an array of arrays of String.
+     */
+    public String[][] options() {
+        return options.toArray(new String[options.length()][]);
+    }
+
+    /**
+     * Packages specified on the command line.
+     */
+    public PackageDoc[] specifiedPackages() {
+        return (PackageDoc[])cmdLinePackages
+            .toArray(new PackageDocImpl[cmdLinePackages.length()]);
+    }
+
+    /**
+     * Classes and interfaces specified on the command line.
+     */
+    public ClassDoc[] specifiedClasses() {
+        ListBuffer<ClassDocImpl> classesToDocument = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl cd : cmdLineClasses) {
+            cd.addAllClasses(classesToDocument, true);
+        }
+        return (ClassDoc[])classesToDocument.toArray(new ClassDocImpl[classesToDocument.length()]);
+    }
+
+    /**
+     * Return all classes and interfaces (including those inside
+     * packages) to be documented.
+     */
+    public ClassDoc[] classes() {
+        ListBuffer<ClassDocImpl> classesToDocument = new ListBuffer<ClassDocImpl>();
+        for (ClassDocImpl cd : cmdLineClasses) {
+            cd.addAllClasses(classesToDocument, true);
+        }
+        for (PackageDocImpl pd : cmdLinePackages) {
+            pd.addAllClassesTo(classesToDocument);
+        }
+        return classesToDocument.toArray(new ClassDocImpl[classesToDocument.length()]);
+    }
+
+    /**
+     * Return a ClassDoc for the specified class/interface name
+     *
+     * @param qualifiedName qualified class name
+     *                        (i.e. includes package name).
+     *
+     * @return a ClassDocImpl holding the specified class, null if
+     * this class is not referenced.
+     */
+    public ClassDoc classNamed(String qualifiedName) {
+        return env.lookupClass(qualifiedName);
+    }
+
+    /**
+     * Return a PackageDoc for the specified package name
+     *
+     * @param name package name
+     *
+     * @return a PackageDoc holding the specified package, null if
+     * this package is not referenced.
+     */
+    public PackageDoc packageNamed(String name) {
+        return env.lookupPackage(name);
+    }
+
+    /**
+     * Return the name of this Doc item.
+     *
+     * @return the string <code>"*RootDocImpl*"</code>.
+     */
+    public String name() {
+        return "*RootDocImpl*";
+    }
+
+    /**
+     * Return the name of this Doc item.
+     *
+     * @return the string <code>"*RootDocImpl*"</code>.
+     */
+    public String qualifiedName() {
+        return "*RootDocImpl*";
+    }
+
+    /**
+     * Return true if this Doc is include in the active set.
+     * RootDocImpl isn't even a program entity so it is always false.
+     */
+    public boolean isIncluded() {
+        return false;
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param msg message to print
+     */
+    public void printError(String msg) {
+        env.printError(msg);
+    }
+
+    /**
+     * Print error message, increment error count.
+     *
+     * @param msg message to print
+     */
+    public void printError(SourcePosition pos, String msg) {
+        env.printError(pos, msg);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param msg message to print
+     */
+    public void printWarning(String msg) {
+        env.printWarning(msg);
+    }
+
+    /**
+     * Print warning message, increment warning count.
+     *
+     * @param msg message to print
+     */
+    public void printWarning(SourcePosition pos, String msg) {
+        env.printWarning(pos, msg);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param msg message to print
+     */
+    public void printNotice(String msg) {
+        env.printNotice(msg);
+    }
+
+    /**
+     * Print a message.
+     *
+     * @param msg message to print
+     */
+    public void printNotice(SourcePosition pos, String msg) {
+        env.printNotice(pos, msg);
+    }
+
+    /**
+     * Return the path of the overview file and null if it does not exist.
+     * @return the path of the overview file and null if it does not exist.
+     */
+    private JavaFileObject getOverviewPath() {
+        for (String[] opt : options) {
+            if (opt[0].equals("-overview")) {
+                if (env.fileManager instanceof StandardJavaFileManager) {
+                    StandardJavaFileManager fm = (StandardJavaFileManager) env.fileManager;
+                    return fm.getJavaFileObjects(opt[1]).iterator().next();
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Do lazy initialization of "documentation" string.
+     */
+    @Override
+    protected String documentation() {
+        if (documentation == null) {
+            JavaFileObject overviewPath = getOverviewPath();
+            if (overviewPath == null) {
+                // no doc file to be had
+                documentation = "";
+            } else {
+                // read from file
+                try {
+                    documentation = readHTMLDocumentation(
+                        overviewPath.openInputStream(),
+                        overviewPath);
+                } catch (IOException exc) {
+                    documentation = "";
+                    env.error(null, "javadoc.File_Read_Error", overviewPath.getName());
+                }
+            }
+        }
+        return documentation;
+    }
+
+    /**
+     * Return the source position of the entity, or null if
+     * no position is available.
+     */
+    @Override
+    public SourcePosition position() {
+        JavaFileObject path;
+        return ((path = getOverviewPath()) == null) ?
+            null :
+            SourcePositionImpl.make(path, Position.NOPOS, null);
+    }
+
+    /**
+     * Return the locale provided by the user or the default locale value.
+     */
+    public Locale getLocale() {
+        return env.doclocale.locale;
+    }
+
+    /**
+     * Return the current file manager.
+     */
+    public JavaFileManager getFileManager() {
+        return env.fileManager;
+    }
+
+    public void initDocLint(Collection<String> opts, Collection<String> customTagNames) {
+        env.initDoclint(opts, customTagNames);
+    }
+
+    public JavaScriptScanner initJavaScriptScanner(boolean allowScriptInComments) {
+        return env.initJavaScriptScanner(allowScriptInComments);
+    }
+
+    public boolean isFunctionalInterface(AnnotationDesc annotationDesc) {
+        return annotationDesc.annotationType().qualifiedName().equals(
+                env.syms.functionalInterfaceType.toString()) && env.source.allowLambda();
+    }
+
+    public boolean showTagMessages() {
+        return env.showTagMessages();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/SeeTagImpl.java

@@ -0,0 +1,542 @@
+/*
+ * Copyright (c) 1997, 2014, 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.javadoc;
+
+import java.io.File;
+import java.util.Locale;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Printer;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Type.CapturedType;
+import com.sun.tools.javac.util.*;
+
+/**
+ * Represents a see also documentation tag.
+ * The @see tag can be plain text, or reference a class or member.
+ *
+ *  <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>
+ *
+ * @author Kaiyang Liu (original)
+ * @author Robert Field (rewrite)
+ * @author Atul M Dambalkar
+ *
+ */
+class SeeTagImpl extends TagImpl implements SeeTag, LayoutCharacters {
+
+    //### TODO: Searching for classes, fields, and methods
+    //### should follow the normal rules applied by the compiler.
+
+    /**
+     * where of  where#what - i.e. the class name (may be empty)
+     */
+    private String where;
+
+    /**
+     * what of  where#what - i.e. the member (may be null)
+     */
+    private String what;
+
+    private PackageDoc referencedPackage;
+    private ClassDoc referencedClass;
+    private MemberDoc referencedMember;
+
+    String label = "";
+
+    SeeTagImpl(DocImpl holder, String name, String text) {
+        super(holder, name, text);
+        parseSeeString();
+        if (where != null) {
+            ClassDocImpl container = null;
+            if (holder instanceof MemberDoc) {
+                container =
+                  (ClassDocImpl)((ProgramElementDoc)holder).containingClass();
+            } else if (holder instanceof ClassDoc) {
+                container = (ClassDocImpl)holder;
+            }
+            findReferenced(container);
+            if (showRef) showRef();
+        }
+    }
+
+    private static final boolean showRef = false;
+
+    private void showRef() {
+        Symbol sym;
+        if (referencedMember != null) {
+            if (referencedMember instanceof MethodDocImpl)
+                sym = ((MethodDocImpl) referencedMember).sym;
+            else if (referencedMember instanceof FieldDocImpl)
+                sym = ((FieldDocImpl) referencedMember).sym;
+            else
+                sym = ((ConstructorDocImpl) referencedMember).sym;
+        } else if (referencedClass != null) {
+            sym = ((ClassDocImpl) referencedClass).tsym;
+        } else if (referencedPackage != null) {
+            sym = ((PackageDocImpl) referencedPackage).sym;
+        } else
+            return;
+
+        final JavacMessages messages = JavacMessages.instance(docenv().context);
+        Locale locale = Locale.getDefault();
+        Printer printer = new Printer() {
+            int count;
+            @Override
+            protected String localize(Locale locale, String key, Object... args) {
+                return messages.getLocalizedString(locale, key, args);
+            }
+            @Override
+            protected String capturedVarId(CapturedType t, Locale locale) {
+                return "CAP#" + (++count);
+            }
+        };
+
+        String s = text.replaceAll("\\s+", " ");  // normalize white space
+        int sp = s.indexOf(" ");
+        int lparen = s.indexOf("(");
+        int rparen = s.indexOf(")");
+        String seetext = (sp == -1) ? s
+                : (lparen == -1 || sp < lparen) ? s.substring(0, sp)
+                : s.substring(0, rparen + 1);
+
+        File file = new File(holder.position().file().getAbsoluteFile().toURI().normalize());
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("+++ ").append(file).append(": ")
+                .append(name()).append(" ").append(seetext).append(": ");
+        sb.append(sym.getKind()).append(" ");
+        if (sym.kind == Kinds.MTH || sym.kind == Kinds.VAR)
+            sb.append(printer.visit(sym.owner, locale)).append(".");
+        sb.append(printer.visit(sym, locale));
+
+        System.err.println(sb);
+    }
+
+    /**
+     * get the class name part of @see, For instance,
+     * if the comment is @see String#startsWith(java.lang.String) .
+     *      This function returns String.
+     * Returns null if format was not that of java reference.
+     * Return empty string if class name was not specified..
+     */
+    public String referencedClassName() {
+        return where;
+    }
+
+    /**
+     * get the package referenced by  @see. For instance,
+     * if the comment is @see java.lang
+     *      This function returns a PackageDocImpl for java.lang
+     * Returns null if no known package found.
+     */
+    public PackageDoc referencedPackage() {
+        return referencedPackage;
+    }
+
+    /**
+     * get the class referenced by the class name part of @see, For instance,
+     * if the comment is @see String#startsWith(java.lang.String) .
+     *      This function returns a ClassDocImpl for java.lang.String.
+     * Returns null if class is not a class specified on the javadoc command line..
+     */
+    public ClassDoc referencedClass() {
+        return referencedClass;
+    }
+
+    /**
+     * get the name of the member referenced by the prototype part of @see,
+     * For instance,
+     * if the comment is @see String#startsWith(java.lang.String) .
+     *      This function returns "startsWith(java.lang.String)"
+     * Returns null if format was not that of java reference.
+     * Return empty string if member name was not specified..
+     */
+    public String referencedMemberName() {
+        return what;
+    }
+
+    /**
+     * get the member referenced by the prototype part of @see,
+     * For instance,
+     * if the comment is @see String#startsWith(java.lang.String) .
+     *      This function returns a MethodDocImpl for startsWith.
+     * Returns null if member could not be determined.
+     */
+    public MemberDoc referencedMember() {
+        return referencedMember;
+    }
+
+
+    /**
+     * parse @see part of comment. Determine 'where' and 'what'
+     */
+    private void parseSeeString() {
+        int len = text.length();
+        if (len == 0) {
+            return;
+        }
+        switch (text.charAt(0)) {
+            case '<':
+                if (text.charAt(len-1) != '>') {
+                    docenv().warning(holder,
+                                     "tag.see.no_close_bracket_on_url",
+                                     name, text);
+                }
+                return;
+            case '"':
+                if (len == 1 || text.charAt(len-1) != '"') {
+                    docenv().warning(holder,
+                                     "tag.see.no_close_quote",
+                                     name, text);
+                } else {
+//                    text = text.substring(1,len-1); // strip quotes
+                }
+                return;
+        }
+
+        // check that the text is one word, with possible parentheses
+        // this part of code doesn't allow
+        // @see <a href=.....>asfd</a>
+        // comment it.
+
+        // the code assumes that there is no initial white space.
+        int parens = 0;
+        int commentstart = 0;
+        int start = 0;
+        int cp;
+        for (int i = start; i < len ; i += Character.charCount(cp)) {
+            cp = text.codePointAt(i);
+            switch (cp) {
+                case '(': parens++; break;
+                case ')': parens--; break;
+                case '[': case ']': case '.': case '#': break;
+                case ',':
+                    if (parens <= 0) {
+                        docenv().warning(holder,
+                                         "tag.see.malformed_see_tag",
+                                         name, text);
+                        return;
+                    }
+                    break;
+                case ' ': case '\t': case '\n': case CR:
+                    if (parens == 0) { //here onwards the comment starts.
+                        commentstart = i;
+                        i = len;
+                    }
+                    break;
+                default:
+                    if (!Character.isJavaIdentifierPart(cp)) {
+                        docenv().warning(holder,
+                                         "tag.see.illegal_character",
+                                         name, ""+cp, text);
+                    }
+                    break;
+            }
+        }
+        if (parens != 0) {
+            docenv().warning(holder,
+                             "tag.see.malformed_see_tag",
+                             name, text);
+            return;
+        }
+
+        String seetext = "";
+        String labeltext = "";
+
+        if (commentstart > 0) {
+            seetext = text.substring(start, commentstart);
+            labeltext = text.substring(commentstart + 1);
+            // strip off the white space which can be between seetext and the
+            // actual label.
+            for (int i = 0; i < labeltext.length(); i++) {
+                char ch2 = labeltext.charAt(i);
+                if (!(ch2 == ' ' || ch2 == '\t' || ch2 == '\n')) {
+                    label = labeltext.substring(i);
+                    break;
+                }
+            }
+        } else {
+            seetext = text;
+            label = "";
+        }
+
+        int sharp = seetext.indexOf('#');
+        if (sharp >= 0) {
+            // class#member
+            where = seetext.substring(0, sharp);
+            what = seetext.substring(sharp + 1);
+        } else {
+            if (seetext.indexOf('(') >= 0) {
+                docenv().warning(holder,
+                                 "tag.see.missing_sharp",
+                                 name, text);
+                where = "";
+                what = seetext;
+            }
+            else {
+                // no member specified, text names class
+                where = seetext;
+                what = null;
+            }
+        }
+    }
+
+    /**
+     * Find what is referenced by the see also.  If possible, sets
+     * referencedClass and referencedMember.
+     *
+     * @param containingClass the class containing the comment containing
+     * the tag. May be null, if, for example, it is a package comment.
+     */
+    private void findReferenced(ClassDocImpl containingClass) {
+        if (where.length() > 0) {
+            if (containingClass != null) {
+                referencedClass = containingClass.findClass(where);
+            } else {
+                referencedClass = docenv().lookupClass(where);
+            }
+            if (referencedClass == null && holder() instanceof ProgramElementDoc) {
+                referencedClass = docenv().lookupClass(
+                    ((ProgramElementDoc) holder()).containingPackage().name() + "." + where);
+            }
+
+            if (referencedClass == null) { /* may just not be in this run */
+                // check if it's a package name
+                referencedPackage = docenv().lookupPackage(where);
+                return;
+            }
+        } else {
+            if (containingClass == null) {
+                docenv().warning(holder,
+                                 "tag.see.class_not_specified",
+                                 name, text);
+                return;
+            } else {
+                referencedClass = containingClass;
+            }
+        }
+        where = referencedClass.qualifiedName();
+
+        if (what == null) {
+            return;
+        } else {
+            int paren = what.indexOf('(');
+            String memName = (paren >= 0 ? what.substring(0, paren) : what);
+            String[] paramarr;
+            if (paren > 0) {
+                // has parameter list -- should be method or constructor
+                paramarr = new ParameterParseMachine(what.
+                        substring(paren, what.length())).parseParameters();
+                if (paramarr != null) {
+                    referencedMember = findExecutableMember(memName, paramarr,
+                                                            referencedClass);
+                } else {
+                    referencedMember = null;
+                }
+            } else {
+                // no parameter list -- should be field
+                referencedMember = findExecutableMember(memName, null,
+                                                        referencedClass);
+                FieldDoc fd = ((ClassDocImpl)referencedClass).
+                                                            findField(memName);
+                // when no args given, prefer fields over methods
+                if (referencedMember == null ||
+                    (fd != null &&
+                     fd.containingClass()
+                         .subclassOf(referencedMember.containingClass()))) {
+                    referencedMember = fd;
+                }
+            }
+            if (referencedMember == null) {
+                docenv().warning(holder,
+                                 "tag.see.can_not_find_member",
+                                 name, what, where);
+            }
+        }
+    }
+
+    private MemberDoc findReferencedMethod(String memName, String[] paramarr,
+                                           ClassDoc referencedClass) {
+        MemberDoc meth = findExecutableMember(memName, paramarr, referencedClass);
+        ClassDoc[] nestedclasses = referencedClass.innerClasses();
+        if (meth == null) {
+            for (int i = 0; i < nestedclasses.length; i++) {
+                meth = findReferencedMethod(memName, paramarr, nestedclasses[i]);
+                if (meth != null) {
+                    return meth;
+                }
+            }
+        }
+        return null;
+    }
+
+    private MemberDoc findExecutableMember(String memName, String[] paramarr,
+                                           ClassDoc referencedClass) {
+        String className = referencedClass.name();
+        if (memName.equals(className.substring(className.lastIndexOf(".") + 1))) {
+            return ((ClassDocImpl)referencedClass).findConstructor(memName,
+                                                                   paramarr);
+        } else {   // it's a method.
+            return ((ClassDocImpl)referencedClass).findMethod(memName,
+                                                              paramarr);
+        }
+    }
+
+    // separate "int, String" from "(int, String)"
+    // (int i, String s) ==> [0] = "int",  [1] = String
+    // (int[][], String[]) ==> [0] = "int[][]" // [1] = "String[]"
+    class ParameterParseMachine {
+        static final int START = 0;
+        static final int TYPE = 1;
+        static final int NAME = 2;
+        static final int TNSPACE = 3;  // space between type and name
+        static final int ARRAYDECORATION = 4;
+        static final int ARRAYSPACE = 5;
+
+        String parameters;
+
+        StringBuilder typeId;
+
+        ListBuffer<String> paramList;
+
+        ParameterParseMachine(String parameters) {
+            this.parameters = parameters;
+            this.paramList = new ListBuffer<String>();
+            typeId = new StringBuilder();
+        }
+
+        public String[] parseParameters() {
+            if (parameters.equals("()")) {
+                return new String[0];
+            }   // now strip off '(' and ')'
+            int state = START;
+            int prevstate = START;
+            parameters = parameters.substring(1, parameters.length() - 1);
+            int cp;
+            for (int index = 0; index < parameters.length(); index += Character.charCount(cp)) {
+                cp = parameters.codePointAt(index);
+                switch (state) {
+                    case START:
+                        if (Character.isJavaIdentifierStart(cp)) {
+                            typeId.append(Character.toChars(cp));
+                            state = TYPE;
+                        }
+                        prevstate = START;
+                        break;
+                    case TYPE:
+                        if (Character.isJavaIdentifierPart(cp) || cp == '.') {
+                            typeId.append(Character.toChars(cp));
+                        } else if (cp == '[') {
+                            typeId.append('[');
+                            state = ARRAYDECORATION;
+                        } else if (Character.isWhitespace(cp)) {
+                            state = TNSPACE;
+                        } else if (cp == ',') {  // no name, just type
+                            addTypeToParamList();
+                            state = START;
+                        }
+                        prevstate = TYPE;
+                        break;
+                    case TNSPACE:
+                        if (Character.isJavaIdentifierStart(cp)) { // name
+                            if (prevstate == ARRAYDECORATION) {
+                                docenv().warning(holder,
+                                                 "tag.missing_comma_space",
+                                                 name,
+                                                 "(" + parameters + ")");
+                                return (String[])null;
+                            }
+                            addTypeToParamList();
+                            state = NAME;
+                        } else if (cp == '[') {
+                            typeId.append('[');
+                            state = ARRAYDECORATION;
+                        } else if (cp == ',') {   // just the type
+                            addTypeToParamList();
+                            state = START;
+                        } // consume rest all
+                        prevstate = TNSPACE;
+                        break;
+                    case ARRAYDECORATION:
+                        if (cp == ']') {
+                            typeId.append(']');
+                            state = TNSPACE;
+                        } else if (!Character.isWhitespace(cp)) {
+                            docenv().warning(holder,
+                                             "tag.illegal_char_in_arr_dim",
+                                             name,
+                                             "(" + parameters + ")");
+                            return (String[])null;
+                        }
+                        prevstate = ARRAYDECORATION;
+                        break;
+                    case NAME:
+                        if (cp == ',') {  // just consume everything till ','
+                            state = START;
+                        }
+                        prevstate = NAME;
+                        break;
+                }
+            }
+            if (state == ARRAYDECORATION ||
+                (state == START && prevstate == TNSPACE)) {
+                docenv().warning(holder,
+                                 "tag.illegal_see_tag",
+                                 "(" + parameters + ")");
+            }
+            if (typeId.length() > 0) {
+                paramList.append(typeId.toString());
+            }
+            return paramList.toArray(new String[paramList.length()]);
+        }
+
+        void addTypeToParamList() {
+            if (typeId.length() > 0) {
+                paramList.append(typeId.toString());
+                typeId.setLength(0);
+            }
+        }
+    }
+
+    /**
+     * Return the kind of this tag.
+     */
+    @Override
+    public String kind() {
+        return "@see";
+    }
+
+    /**
+     * Return the label of the see tag.
+     */
+    public String label() {
+        return label;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/SerialFieldTagImpl.java

@@ -0,0 +1,267 @@
+/*
+ * Copyright (c) 1998, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+/**
+ * Documents a Serializable field defined by an ObjectStreamField.
+ * <pre>
+ * The class parses and stores the three serialField tag parameters:
+ *
+ * - field name
+ * - field type name
+ *      (fully-qualified or visible from the current import context)
+ * - description of the valid values for the field
+
+ * </pre>
+ * This tag is only allowed in the javadoc for the special member
+ * serialPersistentFields.
+ *
+ *  <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>
+ *
+ * @author Joe Fialli
+ * @author Neal Gafter
+ *
+ * @see java.io.ObjectStreamField
+ */
+class SerialFieldTagImpl
+    extends TagImpl
+    implements SerialFieldTag, Comparable<Object>
+{
+    //### These could be final, except that the constructor
+    //### does not set them directly.
+
+    private String fieldName;    // Required Argument 1 of serialField
+    private String fieldType;    // Required Argument 2 of serialField
+    private String description;  // Optional Remaining Arguments of serialField
+
+    private ClassDoc containingClass;   // Class containing serialPersistentField member
+    private ClassDoc fieldTypeDoc;      // ClassDocImpl of fieldType
+    private FieldDocImpl matchingField; // FieldDocImpl with same name as fieldName
+
+   /* Constructor. */
+   SerialFieldTagImpl(DocImpl holder, String name, String text) {
+        super(holder, name, text);
+        parseSerialFieldString();
+        if (holder instanceof MemberDoc) {
+            containingClass = ((MemberDocImpl)holder).containingClass();
+        }
+    }
+
+    /*
+     * The serialField tag is composed of three entities.
+     *
+     *   serialField  serializableFieldName serisliableFieldType
+     *                 description of field.
+     *
+     * The fieldName and fieldType must be legal Java Identifiers.
+     */
+    private void parseSerialFieldString() {
+        int len = text.length();
+        if (len == 0) {
+            return;
+        }
+
+        // if no white space found
+        /* Skip white space. */
+        int inx = 0;
+        int cp;
+        for (; inx < len; inx += Character.charCount(cp)) {
+             cp = text.codePointAt(inx);
+             if (!Character.isWhitespace(cp)) {
+                 break;
+             }
+        }
+
+        /* find first word. */
+        int first = inx;
+        int last = inx;
+        cp = text.codePointAt(inx);
+        if (! Character.isJavaIdentifierStart(cp)) {
+            docenv().warning(holder,
+                             "tag.serialField.illegal_character",
+                             new String(Character.toChars(cp)), text);
+            return;
+        }
+
+        for (inx += Character.charCount(cp); inx < len; inx += Character.charCount(cp)) {
+             cp = text.codePointAt(inx);
+             if (!Character.isJavaIdentifierPart(cp)) {
+                 break;
+             }
+        }
+
+        if (inx < len && ! Character.isWhitespace(cp = text.codePointAt(inx))) {
+            docenv().warning(holder,
+                             "tag.serialField.illegal_character",
+                             new String(Character.toChars(cp)), text);
+            return;
+        }
+
+        last = inx;
+        fieldName = text.substring(first, last);
+
+        /* Skip white space. */
+        for (; inx < len; inx += Character.charCount(cp)) {
+             cp = text.codePointAt(inx);
+             if (!Character.isWhitespace(cp)) {
+                 break;
+             }
+        }
+
+        /* find second word. */
+        first = inx;
+        last = inx;
+
+        for (; inx < len; inx += Character.charCount(cp)) {
+             cp = text.codePointAt(inx);
+             if (Character.isWhitespace(cp)) {
+                 break;
+             }
+        }
+        if (inx < len && ! Character.isWhitespace(cp = text.codePointAt(inx))) {
+            docenv().warning(holder,
+                             "tag.serialField.illegal_character",
+                             new String(Character.toChars(cp)), text);
+            return;
+        }
+        last = inx;
+        fieldType = text.substring(first, last);
+
+        /* Skip leading white space. Rest of string is description for serialField.*/
+        for (; inx < len; inx += Character.charCount(cp)) {
+             cp = text.codePointAt(inx);
+             if (!Character.isWhitespace(cp)) {
+                 break;
+             }
+        }
+        description = text.substring(inx);
+    }
+
+    /**
+     * return a key for sorting.
+     */
+    String key() {
+        return fieldName;
+    }
+
+    /*
+     * Optional. Link this serialField tag to its corrsponding
+     * field in the class. Note: there is no requirement that
+     * there be a field in the class that matches serialField tag.
+     */
+    void mapToFieldDocImpl(FieldDocImpl fd) {
+        matchingField = fd;
+    }
+
+    /**
+     * Return the serialziable field name.
+     */
+    public String fieldName() {
+        return fieldName;
+    }
+
+    /**
+     * Return the field type string.
+     */
+    public String fieldType() {
+        return fieldType;
+    }
+
+    /**
+     * Return the ClassDocImpl for field type.
+     *
+     * @returns null if no ClassDocImpl for field type is visible from
+     *          containingClass context.
+     */
+    public ClassDoc fieldTypeDoc() {
+        if (fieldTypeDoc == null && containingClass != null) {
+            fieldTypeDoc = containingClass.findClass(fieldType);
+        }
+        return fieldTypeDoc;
+    }
+
+    /**
+     * Return the corresponding FieldDocImpl for this SerialFieldTagImpl.
+     *
+     * @returns null if no matching FieldDocImpl.
+     */
+    FieldDocImpl getMatchingField() {
+        return matchingField;
+    }
+
+    /**
+     * Return the field comment. If there is no serialField comment, return
+     * javadoc comment of corresponding FieldDocImpl.
+     */
+    public String description() {
+        if (description.length() == 0 && matchingField != null) {
+
+            //check for javadoc comment of corresponding field.
+            Comment comment = matchingField.comment();
+            if (comment != null) {
+                return comment.commentText();
+            }
+        }
+        return description;
+    }
+
+    /**
+     * Return the kind of this tag.
+     */
+    public String kind() {
+        return "@serialField";
+    }
+
+    /**
+     * Convert this object to a string.
+     */
+    public String toString() {
+        return name + ":" + text;
+    }
+
+    /**
+     * Compares this Object with the specified Object for order.  Returns a
+     * negative integer, zero, or a positive integer as this Object is less
+     * than, equal to, or greater than the given Object.
+     * <p>
+     * Included to make SerialFieldTagImpl items java.lang.Comparable.
+     *
+     * @param   obj the <code>Object</code> to be compared.
+     * @return  a negative integer, zero, or a positive integer as this Object
+     *          is less than, equal to, or greater than the given Object.
+     * @exception ClassCastException the specified Object's type prevents it
+     *            from being compared to this Object.
+     * @since 1.2
+     */
+    public int compareTo(Object obj) {
+        return key().compareTo(((SerialFieldTagImpl)obj).key());
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/SerializedForm.java

@@ -0,0 +1,290 @@
+/*
+ * Copyright (c) 1998, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Scope;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Symbol.VarSymbol;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.Names;
+
+/**
+ * The serialized form is the specification of a class' serialization
+ * state. <p>
+ *
+ * It consists of the following information:<p>
+ *
+ * <pre>
+ * 1. Whether class is Serializable or Externalizable.
+ * 2. Javadoc for serialization methods.
+ *    a. For Serializable, the optional readObject, writeObject,
+ *       readResolve and writeReplace.
+ *       serialData tag describes, in prose, the sequence and type
+ *       of optional data written by writeObject.
+ *    b. For Externalizable, writeExternal and readExternal.
+ *       serialData tag describes, in prose, the sequence and type
+ *       of optional data written by writeExternal.
+ * 3. Javadoc for serialization data layout.
+ *    a. For Serializable, the name,type and description
+ *       of each Serializable fields.
+ *    b. For Externalizable, data layout is described by 2(b).
+ * </pre>
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Joe Fialli
+ * @author Neal Gafter (rewrite but not too proud)
+ */
+class SerializedForm {
+    ListBuffer<MethodDoc> methods = new ListBuffer<MethodDoc>();
+
+    /* List of FieldDocImpl - Serializable fields.
+     * Singleton list if class defines Serializable fields explicitly.
+     * Otherwise, list of default serializable fields.
+     * 0 length list for Externalizable.
+     */
+    private final ListBuffer<FieldDocImpl> fields = new ListBuffer<FieldDocImpl>();
+
+    /* True if class specifies serializable fields explicitly.
+     * using special static member, serialPersistentFields.
+     */
+    private boolean definesSerializableFields = false;
+
+    // Specially treated field/method names defined by Serialization.
+    private static final String SERIALIZABLE_FIELDS = "serialPersistentFields";
+    private static final String READOBJECT  = "readObject";
+    private static final String WRITEOBJECT = "writeObject";
+    private static final String READRESOLVE  = "readResolve";
+    private static final String WRITEREPLACE = "writeReplace";
+    private static final String READOBJECTNODATA = "readObjectNoData";
+
+    /**
+     * Constructor.
+     *
+     * Catalog Serializable fields for Serializable class.
+     * Catalog serialization methods for Serializable and
+     * Externalizable classes.
+     */
+    SerializedForm(DocEnv env, ClassSymbol def, ClassDocImpl cd) {
+        if (cd.isExternalizable()) {
+            /* look up required public accessible methods,
+             *   writeExternal and readExternal.
+             */
+            String[] readExternalParamArr = { "java.io.ObjectInput" };
+            String[] writeExternalParamArr = { "java.io.ObjectOutput" };
+            MethodDoc md = cd.findMethod("readExternal", readExternalParamArr);
+            if (md != null) {
+                methods.append(md);
+            }
+            md = cd.findMethod("writeExternal", writeExternalParamArr);
+            if (md != null) {
+                methods.append(md);
+                Tag tag[] = md.tags("serialData");
+            }
+        // } else { // isSerializable() //### ???
+        } else if (cd.isSerializable()) {
+
+            VarSymbol dsf = getDefinedSerializableFields(def);
+            if (dsf != null) {
+
+                /* Define serializable fields with array of ObjectStreamField.
+                 * Each ObjectStreamField should be documented by a
+                 * serialField tag.
+                 */
+                definesSerializableFields = true;
+                //### No modifier filtering applied here.
+                FieldDocImpl dsfDoc = env.getFieldDoc(dsf);
+                fields.append(dsfDoc);
+                mapSerialFieldTagImplsToFieldDocImpls(dsfDoc, env, def);
+            } else {
+
+                /* Calculate default Serializable fields as all
+                 * non-transient, non-static fields.
+                 * Fields should be documented by serial tag.
+                 */
+                computeDefaultSerializableFields(env, def, cd);
+            }
+
+           /* Check for optional customized readObject, writeObject,
+            * readResolve and writeReplace, which can all contain
+            * the serialData tag.        */
+            addMethodIfExist(env, def, READOBJECT);
+            addMethodIfExist(env, def, WRITEOBJECT);
+            addMethodIfExist(env, def, READRESOLVE);
+            addMethodIfExist(env, def, WRITEREPLACE);
+            addMethodIfExist(env, def, READOBJECTNODATA);
+        }
+    }
+
+    /*
+     * Check for explicit Serializable fields.
+     * Check for a private static array of ObjectStreamField with
+     * name SERIALIZABLE_FIELDS.
+     */
+    private VarSymbol getDefinedSerializableFields(ClassSymbol def) {
+        Names names = def.name.table.names;
+
+        /* SERIALIZABLE_FIELDS can be private,
+         * so must lookup by ClassSymbol, not by ClassDocImpl.
+         */
+        for (Scope.Entry e = def.members().lookup(names.fromString(SERIALIZABLE_FIELDS)); e.scope != null; e = e.next()) {
+            if (e.sym.kind == Kinds.VAR) {
+                VarSymbol f = (VarSymbol)e.sym;
+                if ((f.flags() & Flags.STATIC) != 0 &&
+                    (f.flags() & Flags.PRIVATE) != 0) {
+                    return f;
+                }
+            }
+        }
+        return null;
+    }
+
+    /*
+     * Compute default Serializable fields from all members of ClassSymbol.
+     *
+     * Since the fields of ClassDocImpl might not contain private or
+     * package accessible fields, must walk over all members of ClassSymbol.
+     */
+    private void computeDefaultSerializableFields(DocEnv env,
+                                                  ClassSymbol def,
+                                                  ClassDocImpl cd) {
+        for (Scope.Entry e = def.members().elems; e != null; e = e.sibling) {
+            if (e.sym != null && e.sym.kind == Kinds.VAR) {
+                VarSymbol f = (VarSymbol)e.sym;
+                if ((f.flags() & Flags.STATIC) == 0 &&
+                    (f.flags() & Flags.TRANSIENT) == 0) {
+                    //### No modifier filtering applied here.
+                    FieldDocImpl fd = env.getFieldDoc(f);
+                    //### Add to beginning.
+                    //### Preserve order used by old 'javadoc'.
+                    fields.prepend(fd);
+                }
+            }
+        }
+    }
+
+    /*
+     * Catalog Serializable method if it exists in current ClassSymbol.
+     * Do not look for method in superclasses.
+     *
+     * Serialization requires these methods to be non-static.
+     *
+     * @param method should be an unqualified Serializable method
+     *               name either READOBJECT, WRITEOBJECT, READRESOLVE
+     *               or WRITEREPLACE.
+     * @param visibility the visibility flag for the given method.
+     */
+    private void addMethodIfExist(DocEnv env, ClassSymbol def, String methodName) {
+        Names names = def.name.table.names;
+
+        for (Scope.Entry e = def.members().lookup(names.fromString(methodName)); e.scope != null; e = e.next()) {
+            if (e.sym.kind == Kinds.MTH) {
+                MethodSymbol md = (MethodSymbol)e.sym;
+                if ((md.flags() & Flags.STATIC) == 0) {
+                    /*
+                     * WARNING: not robust if unqualifiedMethodName is overloaded
+                     *          method. Signature checking could make more robust.
+                     * READOBJECT takes a single parameter, java.io.ObjectInputStream.
+                     * WRITEOBJECT takes a single parameter, java.io.ObjectOutputStream.
+                     */
+                    methods.append(env.getMethodDoc(md));
+                }
+            }
+        }
+    }
+
+    /*
+     * Associate serialField tag fieldName with FieldDocImpl member.
+     * Note: A serialField tag does not have to map an existing field
+     *       of a class.
+     */
+    private void mapSerialFieldTagImplsToFieldDocImpls(FieldDocImpl spfDoc,
+                                                       DocEnv env,
+                                                       ClassSymbol def) {
+        Names names = def.name.table.names;
+
+        SerialFieldTag[] sfTag = spfDoc.serialFieldTags();
+        for (int i = 0; i < sfTag.length; i++) {
+            if (sfTag[i].fieldName() == null || sfTag[i].fieldType() == null) // ignore malformed @serialField tags
+                continue;
+
+            Name fieldName = names.fromString(sfTag[i].fieldName());
+
+            // Look for a FieldDocImpl that is documented by serialFieldTagImpl.
+            for (Scope.Entry e = def.members().lookup(fieldName); e.scope != null; e = e.next()) {
+                if (e.sym.kind == Kinds.VAR) {
+                    VarSymbol f = (VarSymbol)e.sym;
+                    FieldDocImpl fdi = env.getFieldDoc(f);
+                    ((SerialFieldTagImpl)(sfTag[i])).mapToFieldDocImpl(fdi);
+                    break;
+                }
+            }
+        }
+    }
+
+    /**
+     * Return serializable fields in class. <p>
+     *
+     * Returns either a list of default fields documented by serial tag comment or
+     *         javadoc comment<p>
+     * Or Returns a single FieldDocImpl for serialPersistentField. There is a
+     *         serialField tag for each serializable field.<p>
+     *
+     * @return an array of FieldDocImpl for representing the visible
+     *         fields in this class.
+     */
+    FieldDoc[] fields() {
+        return (FieldDoc[])fields.toArray(new FieldDocImpl[fields.length()]);
+    }
+
+    /**
+     * Return serialization methods in class.
+     *
+     * @return an array of MethodDocImpl for serialization methods in this class.
+     */
+    MethodDoc[] methods() {
+        return methods.toArray(new MethodDoc[methods.length()]);
+    }
+
+    /**
+     * Returns true if Serializable fields are defined explicitly using
+     * member, serialPersistentFields.
+     *
+     * @see #fields()
+     */
+    boolean definesSerializableFields() {
+        return definesSerializableFields;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/SourcePositionImpl.java

@@ -0,0 +1,117 @@
+/*
+ * Copyright (c) 2001, 2012, 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.javadoc;
+
+import java.io.File;
+import javax.tools.FileObject;
+
+import com.sun.javadoc.SourcePosition;
+import com.sun.tools.javac.util.Position;
+
+/**
+ * A source position: filename, line number, and column number.
+ *
+ *  <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>
+ *
+ * @since J2SE1.4
+ * @author Neal M Gafter
+ * @author Michael Van De Vanter (position representation changed to char offsets)
+ */
+public class SourcePositionImpl implements SourcePosition {
+    FileObject filename;
+    int position;
+    Position.LineMap lineMap;
+
+    /** The source file. Returns null if no file information is
+     *  available. */
+    public File file() {
+        return (filename == null) ? null : new File(filename.getName());
+    }
+
+    /** The source file. Returns null if no file information is
+     *  available. */
+    public FileObject fileObject() {
+        return filename;
+    }
+
+    /** The line in the source file. The first line is numbered 1;
+     *  0 means no line number information is available. */
+    public int line() {
+        if (lineMap == null) {
+            return 0;
+        } else {
+            return lineMap.getLineNumber(position);
+        }
+    }
+
+    /** The column in the source file. The first column is
+     *  numbered 1; 0 means no column information is available.
+     *  Columns count characters in the input stream; a tab
+     *  advances the column number to the next 8-column tab stop.
+     */
+    public int column() {
+        if (lineMap == null) {
+            return 0;
+        }else {
+            return lineMap.getColumnNumber(position);
+        }
+    }
+
+    private SourcePositionImpl(FileObject file, int position,
+                               Position.LineMap lineMap) {
+        super();
+        this.filename = file;
+        this.position = position;
+        this.lineMap = lineMap;
+    }
+
+    public static SourcePosition make(FileObject file, int pos,
+                                      Position.LineMap lineMap) {
+        if (file == null) return null;
+        return new SourcePositionImpl(file, pos, lineMap);
+    }
+
+    public String toString() {
+        // Backwards compatibility hack. ZipFileObjects use the format
+        // zipfile(zipentry) but javadoc has been using zipfile/zipentry
+        String fn = filename.getName();
+        if (fn.endsWith(")")) {
+            int paren = fn.lastIndexOf("(");
+            if (paren != -1)
+                fn = fn.substring(0, paren)
+                        + File.separatorChar
+                        + fn.substring(paren + 1, fn.length() - 1);
+        }
+
+        if (position == Position.NOPOS)
+            return fn;
+        else
+            return fn + ":" + line();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/Start.java

@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.main.CommandLine;
+import com.sun.tools.javac.util.ClientCodeException;
+import com.sun.tools.javac.util.Context;
+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.Options;
+import static com.sun.tools.javac.code.Flags.*;
+
+/**
+ * Main program of Javadoc.
+ * Previously named "Main".
+ *
+ *  <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>
+ *
+ * @since 1.2
+ * @author Robert Field
+ * @author Neal Gafter (rewrite)
+ */
+public class Start extends ToolOption.Helper {
+    /** Context for this invocation. */
+    private final Context context;
+
+    private final String defaultDocletClassName;
+    private final ClassLoader docletParentClassLoader;
+
+    private static final String javadocName = "javadoc";
+
+    private static final String standardDocletClassName =
+        "com.sun.tools.doclets.standard.Standard";
+
+    private long defaultFilter = PUBLIC | PROTECTED;
+
+    private final Messager messager;
+
+    private DocletInvoker docletInvoker;
+
+    /**
+     * In API mode, exceptions thrown while calling the doclet are
+     * propagated using ClientCodeException.
+     */
+    private boolean apiMode;
+
+    Start(String programName,
+          PrintWriter errWriter,
+          PrintWriter warnWriter,
+          PrintWriter noticeWriter,
+          String defaultDocletClassName) {
+        this(programName, errWriter, warnWriter, noticeWriter, defaultDocletClassName, null);
+    }
+
+    Start(String programName,
+          PrintWriter errWriter,
+          PrintWriter warnWriter,
+          PrintWriter noticeWriter,
+          String defaultDocletClassName,
+          ClassLoader docletParentClassLoader) {
+        context = new Context();
+        messager = new Messager(context, programName, errWriter, warnWriter, noticeWriter);
+        this.defaultDocletClassName = defaultDocletClassName;
+        this.docletParentClassLoader = docletParentClassLoader;
+    }
+
+    Start(String programName, String defaultDocletClassName) {
+        this(programName, defaultDocletClassName, null);
+    }
+
+    Start(String programName, String defaultDocletClassName,
+          ClassLoader docletParentClassLoader) {
+        context = new Context();
+        messager = new Messager(context, programName);
+        this.defaultDocletClassName = defaultDocletClassName;
+        this.docletParentClassLoader = docletParentClassLoader;
+    }
+
+    Start(String programName, ClassLoader docletParentClassLoader) {
+        this(programName, standardDocletClassName, docletParentClassLoader);
+    }
+
+    Start(String programName) {
+        this(programName, standardDocletClassName);
+    }
+
+    Start(ClassLoader docletParentClassLoader) {
+        this(javadocName, docletParentClassLoader);
+    }
+
+    Start() {
+        this(javadocName);
+    }
+
+    public Start(Context context) {
+        context.getClass(); // null check
+        this.context = context;
+        apiMode = true;
+        defaultDocletClassName = standardDocletClassName;
+        docletParentClassLoader = null;
+
+        Log log = context.get(Log.logKey);
+        if (log instanceof Messager)
+            messager = (Messager) log;
+        else {
+            PrintWriter out = context.get(Log.outKey);
+            messager = (out == null) ? new Messager(context, javadocName)
+                    : new Messager(context, javadocName, out, out, out);
+        }
+    }
+
+    /**
+     * Usage
+     */
+    @Override
+    void usage() {
+        usage(true);
+    }
+
+    void usage(boolean exit) {
+        usage("main.usage", "-help", null, exit);
+    }
+
+    @Override
+    void Xusage() {
+        Xusage(true);
+    }
+
+    void Xusage(boolean exit) {
+        usage("main.Xusage", "-X", "main.Xusage.foot", exit);
+    }
+
+    private void usage(String main, String doclet, String foot, boolean exit) {
+        // RFE: it would be better to replace the following with code to
+        // write a header, then help for each option, then a footer.
+        messager.notice(main);
+
+        // let doclet print usage information (does nothing on error)
+        if (docletInvoker != null) {
+            // RFE: this is a pretty bad way to get the doclet to show
+            // help info. Moreover, the output appears on stdout,
+            // and <i>not</i> on any of the standard streams passed
+            // to javadoc, and in particular, not to the noticeWriter
+            // But, to fix this, we need to fix the Doclet API.
+            docletInvoker.optionLength(doclet);
+        }
+
+        if (foot != null)
+            messager.notice(foot);
+
+        if (exit) exit();
+    }
+
+    /**
+     * Exit
+     */
+    private void exit() {
+        messager.exit();
+    }
+
+
+    /**
+     * Main program - external wrapper
+     */
+    int begin(String... argv) {
+        boolean ok = begin(null, argv, Collections.<JavaFileObject> emptySet());
+        return ok ? 0 : 1;
+    }
+
+    public boolean begin(Class<?> docletClass, Iterable<String> options, Iterable<? extends JavaFileObject> fileObjects) {
+        Collection<String> opts = new ArrayList<String>();
+        for (String opt: options) opts.add(opt);
+        return begin(docletClass, opts.toArray(new String[opts.size()]), fileObjects);
+    }
+
+    private boolean begin(Class<?> docletClass, String[] options, Iterable<? extends JavaFileObject> fileObjects) {
+        boolean failed = false;
+
+        try {
+            failed = !parseAndExecute(docletClass, options, fileObjects);
+        } catch (Messager.ExitJavadoc exc) {
+            // ignore, we just exit this way
+        } catch (OutOfMemoryError ee) {
+            messager.error(Messager.NOPOS, "main.out.of.memory");
+            failed = true;
+        } catch (ClientCodeException e) {
+            // simply rethrow these exceptions, to be caught and handled by JavadocTaskImpl
+            throw e;
+        } catch (Error ee) {
+            ee.printStackTrace(System.err);
+            messager.error(Messager.NOPOS, "main.fatal.error");
+            failed = true;
+        } catch (Exception ee) {
+            ee.printStackTrace(System.err);
+            messager.error(Messager.NOPOS, "main.fatal.exception");
+            failed = true;
+        } finally {
+            messager.exitNotice();
+            messager.flush();
+        }
+        failed |= messager.nerrors() > 0;
+        failed |= rejectWarnings && messager.nwarnings() > 0;
+        return !failed;
+    }
+
+    /**
+     * Main program - internal
+     */
+    private boolean parseAndExecute(
+            Class<?> docletClass,
+            String[] argv,
+            Iterable<? extends JavaFileObject> fileObjects) throws IOException {
+        long tm = System.currentTimeMillis();
+
+        ListBuffer<String> javaNames = new ListBuffer<String>();
+
+        // Preprocess @file arguments
+        try {
+            argv = CommandLine.parse(argv);
+        } catch (FileNotFoundException e) {
+            messager.error(Messager.NOPOS, "main.cant.read", e.getMessage());
+            exit();
+        } catch (IOException e) {
+            e.printStackTrace(System.err);
+            exit();
+        }
+
+
+        JavaFileManager fileManager = context.get(JavaFileManager.class);
+        setDocletInvoker(docletClass, fileManager, argv);
+
+        compOpts = Options.instance(context);
+        // Make sure no obsolete source/target messages are reported
+        compOpts.put("-Xlint:-options", "-Xlint:-options");
+
+        // Parse arguments
+        for (int i = 0 ; i < argv.length ; i++) {
+            String arg = argv[i];
+
+            ToolOption o = ToolOption.get(arg);
+            if (o != null) {
+                // hack: this restriction should be removed
+                if (o == ToolOption.LOCALE && i > 0)
+                    usageError("main.locale_first");
+
+                if (o.hasArg) {
+                    oneArg(argv, i++);
+                    o.process(this, argv[i]);
+                } else {
+                    setOption(arg);
+                    o.process(this);
+                }
+
+            } else if (arg.startsWith("-XD")) {
+                // hidden javac options
+                String s = arg.substring("-XD".length());
+                int eq = s.indexOf('=');
+                String key = (eq < 0) ? s : s.substring(0, eq);
+                String value = (eq < 0) ? s : s.substring(eq+1);
+                compOpts.put(key, value);
+            }
+            // call doclet for its options
+            // other arg starts with - is invalid
+            else if (arg.startsWith("-")) {
+                int optionLength;
+                optionLength = docletInvoker.optionLength(arg);
+                if (optionLength < 0) {
+                    // error already displayed
+                    exit();
+                } else if (optionLength == 0) {
+                    // option not found
+                    usageError("main.invalid_flag", arg);
+                } else {
+                    // doclet added option
+                    if ((i + optionLength) > argv.length) {
+                        usageError("main.requires_argument", arg);
+                    }
+                    ListBuffer<String> args = new ListBuffer<String>();
+                    for (int j = 0; j < optionLength-1; ++j) {
+                        args.append(argv[++i]);
+                    }
+                    setOption(arg, args.toList());
+                }
+            } else {
+                javaNames.append(arg);
+            }
+        }
+        compOpts.notifyListeners();
+
+        if (javaNames.isEmpty() && subPackages.isEmpty() && isEmpty(fileObjects)) {
+            usageError("main.No_packages_or_classes_specified");
+        }
+
+        if (!docletInvoker.validOptions(options.toList())) {
+            // error message already displayed
+            exit();
+        }
+
+        JavadocTool comp = JavadocTool.make0(context);
+        if (comp == null) return false;
+
+        if (showAccess == null) {
+            setFilter(defaultFilter);
+        }
+
+        LanguageVersion languageVersion = docletInvoker.languageVersion();
+        RootDocImpl root = comp.getRootDocImpl(
+                docLocale,
+                encoding,
+                showAccess,
+                javaNames.toList(),
+                options.toList(),
+                fileObjects,
+                breakiterator,
+                subPackages.toList(),
+                excludedPackages.toList(),
+                docClasses,
+                // legacy?
+                languageVersion == null || languageVersion == LanguageVersion.JAVA_1_1,
+                quiet);
+
+        // release resources
+        comp = null;
+
+        // pass off control to the doclet
+        boolean ok = root != null;
+        if (ok) ok = docletInvoker.start(root);
+
+        // We're done.
+        if (compOpts.get("-verbose") != null) {
+            tm = System.currentTimeMillis() - tm;
+            messager.notice("main.done_in", Long.toString(tm));
+        }
+
+        return ok;
+    }
+
+    private <T> boolean isEmpty(Iterable<T> iter) {
+        return !iter.iterator().hasNext();
+    }
+
+    /**
+     * Init the doclet invoker.
+     * The doclet class may be given explicitly, or via the -doclet option in
+     * argv.
+     * If the doclet class is not given explicitly, it will be loaded from
+     * the file manager's DOCLET_PATH location, if available, or via the
+     * -doclet path option in argv.
+     * @param docletClass The doclet class. May be null.
+     * @param fileManager The file manager used to get the class loader to load
+     * the doclet class if required. May be null.
+     * @param argv Args containing -doclet and -docletpath, in case they are required.
+     */
+    private void setDocletInvoker(Class<?> docletClass, JavaFileManager fileManager, String[] argv) {
+        if (docletClass != null) {
+            docletInvoker = new DocletInvoker(messager, docletClass, apiMode);
+            // TODO, check no -doclet, -docletpath
+            return;
+        }
+
+        String docletClassName = null;
+        String docletPath = null;
+
+        // Parse doclet specifying arguments
+        for (int i = 0 ; i < argv.length ; i++) {
+            String arg = argv[i];
+            if (arg.equals(ToolOption.DOCLET.opt)) {
+                oneArg(argv, i++);
+                if (docletClassName != null) {
+                    usageError("main.more_than_one_doclet_specified_0_and_1",
+                               docletClassName, argv[i]);
+                }
+                docletClassName = argv[i];
+            } else if (arg.equals(ToolOption.DOCLETPATH.opt)) {
+                oneArg(argv, i++);
+                if (docletPath == null) {
+                    docletPath = argv[i];
+                } else {
+                    docletPath += File.pathSeparator + argv[i];
+                }
+            }
+        }
+
+        if (docletClassName == null) {
+            docletClassName = defaultDocletClassName;
+        }
+
+        // attempt to find doclet
+        docletInvoker = new DocletInvoker(messager, fileManager,
+                docletClassName, docletPath,
+                docletParentClassLoader,
+                apiMode);
+    }
+
+    /**
+     * Set one arg option.
+     * Error and exit if one argument is not provided.
+     */
+    private void oneArg(String[] args, int index) {
+        if ((index + 1) < args.length) {
+            setOption(args[index], args[index+1]);
+        } else {
+            usageError("main.requires_argument", args[index]);
+        }
+    }
+
+    @Override
+    void usageError(String key, Object... args) {
+        messager.error(Messager.NOPOS, key, args);
+        usage(true);
+    }
+
+    /**
+     * indicate an option with no arguments was given.
+     */
+    private void setOption(String opt) {
+        String[] option = { opt };
+        options.append(option);
+    }
+
+    /**
+     * indicate an option with one argument was given.
+     */
+    private void setOption(String opt, String argument) {
+        String[] option = { opt, argument };
+        options.append(option);
+    }
+
+    /**
+     * indicate an option with the specified list of arguments was given.
+     */
+    private void setOption(String opt, List<String> arguments) {
+        String[] args = new String[arguments.length() + 1];
+        int k = 0;
+        args[k++] = opt;
+        for (List<String> i = arguments; i.nonEmpty(); i=i.tail) {
+            args[k++] = i.head;
+        }
+        options.append(args);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/TagImpl.java

@@ -0,0 +1,188 @@
+/*
+ * Copyright (c) 1997, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+/**
+ * Represents a documentation tag, e.g. @since, @author, @version.
+ * Given a tag (e.g. "@since 1.2"), holds tag name (e.g. "@since")
+ * and tag text (e.g. "1.2").  TagImpls with structure or which require
+ * special processing are handled by subclasses (ParamTagImpl, SeeTagImpl,
+ * and ThrowsTagImpl
+ *
+ *  <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>
+ *
+ * @author Robert Field
+ * @author Atul M Dambalkar
+ * @author Neal M Gafter
+ * @see SeeTagImpl
+ * @see ParamTagImpl
+ * @see ThrowsTagImpl
+ * @see Doc#tags()
+ *
+ */
+class TagImpl implements Tag {
+
+    protected final String text;
+    protected final String name;
+    protected final DocImpl holder;
+
+    /**
+     * Cached first sentence.
+     */
+    private Tag[] firstSentence;
+
+    /**
+     * Cached inline tags.
+     */
+    private Tag[] inlineTags;
+
+    /**
+     *  Constructor
+     */
+    TagImpl(DocImpl holder, String name, String text) {
+        this.holder = holder;
+        this.name = name;
+        this.text = text;
+    }
+
+    /**
+     * Return the name of this tag.
+     */
+    public String name() {
+        return name;
+    }
+
+    /**
+     * Return the containing {@link Doc} of this Tag element.
+     */
+    public Doc holder() {
+        return holder;
+    }
+
+    /**
+     * Return the kind of this tag.
+     */
+    public String kind() {
+        return name;
+    }
+
+    /**
+     * Return the text of this tag, that is, portion beyond tag name.
+     */
+    public String text() {
+        return text;
+    }
+
+    DocEnv docenv() {
+        return holder.env;
+    }
+
+    /**
+     * for use by subclasses which have two part tag text.
+     */
+    String[] divideAtWhite() {
+        String[] sa = new String[2];
+        int len = text.length();
+        // if no white space found
+        sa[0] = text;
+        sa[1] = "";
+        for (int inx = 0; inx < len; ++inx) {
+            char ch = text.charAt(inx);
+            if (Character.isWhitespace(ch)) {
+                sa[0] = text.substring(0, inx);
+                for (; inx < len; ++inx) {
+                    ch = text.charAt(inx);
+                    if (!Character.isWhitespace(ch)) {
+                        sa[1] = text.substring(inx, len);
+                        break;
+                    }
+                }
+                break;
+            }
+        }
+        return sa;
+    }
+
+    /**
+     * convert this object to a string.
+     */
+    public String toString() {
+        return name + ":" + text;
+    }
+
+    /**
+     * For documentation comment with embedded @link tags, return the array of
+     * TagImpls consisting of SeeTagImpl(s) and text containing TagImpl(s).
+     * Within a comment string "This is an example of inline tags for a
+     * documentation comment {@link Doc {@link Doc commentlabel}}",
+     * where inside the inner braces, the first "Doc" carries exctly the same
+     * syntax as a SeeTagImpl and the second "commentlabel" is label for the Html
+     * Link, will return an array of TagImpl(s) with first element as TagImpl with
+     * comment text "This is an example of inline tags for a documentation
+     * comment" and second element as SeeTagImpl with referenced class as "Doc"
+     * and the label for the Html Link as "commentlabel".
+     *
+     * @return TagImpl[] Array of tags with inline SeeTagImpls.
+     * @see ParamTagImpl
+     * @see ThrowsTagImpl
+     */
+    public Tag[] inlineTags() {
+        if (inlineTags == null) {
+            inlineTags = Comment.getInlineTags(holder, text);
+        }
+        return inlineTags;
+    }
+
+    /**
+     * Return array of tags for the first sentence in the doc comment text.
+     */
+    public Tag[] firstSentenceTags() {
+        if (firstSentence == null) {
+            //Parse all sentences first to avoid duplicate warnings.
+            inlineTags();
+            try {
+                docenv().setSilent(true);
+                firstSentence = Comment.firstSentenceTags(holder, text);
+            } finally {
+                docenv().setSilent(false);
+            }
+        }
+        return firstSentence;
+    }
+
+    /**
+     * Return the doc item to which this tag is attached.
+     * @return the doc item to which this tag is attached.
+     */
+    public SourcePosition position() {
+        return holder.position();
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ThrowsTagImpl.java

@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) 1997, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+/**
+ * Represents a @throws or @exception documentation tag.
+ * Parses and holds the exception name and exception comment.
+ * The exception name my be the name of a type variable.
+ * Note: @exception is a backwards compatible synonymy for @throws.
+ *
+ *  <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>
+ *
+ * @author Robert Field
+ * @author Atul M Dambalkar
+ * @see ExecutableMemberDocImpl#throwsTags()
+ *
+ */
+class ThrowsTagImpl extends TagImpl implements ThrowsTag {
+
+    private final String exceptionName;
+    private final String exceptionComment;
+
+    /**
+     * Cached inline tags.
+     */
+    private Tag[] inlineTags;
+
+    ThrowsTagImpl(DocImpl holder, String name, String text) {
+        super(holder, name, text);
+        String[] sa = divideAtWhite();
+        exceptionName = sa[0];
+        exceptionComment = sa[1];
+    }
+
+    /**
+     * Return the exception name.
+     */
+    public String exceptionName() {
+        return exceptionName;
+    }
+
+    /**
+     * Return the exception comment.
+     */
+    public String exceptionComment() {
+        return exceptionComment;
+    }
+
+    /**
+     * Return the exception as a ClassDocImpl.
+     */
+    public ClassDoc exception() {
+        ClassDocImpl exceptionClass;
+        if (!(holder instanceof ExecutableMemberDoc)) {
+            exceptionClass = null;
+        } else {
+            ExecutableMemberDocImpl emd = (ExecutableMemberDocImpl)holder;
+            ClassDocImpl con = (ClassDocImpl)emd.containingClass();
+            exceptionClass = (ClassDocImpl)con.findClass(exceptionName);
+        }
+        return exceptionClass;
+    }
+
+    /**
+     * Return the type that represents the exception.
+     * This may be a <code>ClassDoc</code> or a <code>TypeVariable</code>.
+     */
+    public Type exceptionType() {
+        //###(gj) TypeVariable not yet supported.
+        return exception();
+    }
+
+
+    /**
+     * Return the kind of this tag.  Always "@throws" for instances
+     * of ThrowsTagImpl.
+     */
+    @Override
+    public String kind() {
+        return "@throws";
+    }
+
+    /**
+     * For the exception comment with embedded @link tags return the array of
+     * TagImpls consisting of SeeTagImpl(s) and text containing TagImpl(s).
+     *
+     * @return TagImpl[] Array of tags with inline SeeTagImpls.
+     * @see TagImpl#inlineTags()
+     * @see ParamTagImpl#inlineTags()
+     */
+    @Override
+    public Tag[] inlineTags() {
+        if (inlineTags == null) {
+            inlineTags = Comment.getInlineTags(holder, exceptionComment());
+        }
+        return inlineTags;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/ToolOption.java

@@ -0,0 +1,332 @@
+/*
+ * 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.javadoc;
+
+import com.sun.tools.javac.code.Flags;
+import com.sun.tools.javac.util.ListBuffer;
+import com.sun.tools.javac.util.Options;
+import java.util.StringTokenizer;
+
+
+/**
+ * javadoc tool options.
+ *
+ *  <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 enum ToolOption {
+    // ----- options for underlying compiler -----
+
+    BOOTCLASSPATH("-bootclasspath", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    CLASSPATH("-classpath", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    CP("-cp", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    EXTDIRS("-extdirs", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    SOURCEPATH("-sourcepath", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    SYSCLASSPATH("-sysclasspath", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt("-bootclasspath", arg);
+        }
+    },
+
+    ENCODING("-encoding", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.encoding = arg;
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    SOURCE("-source", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    XMAXERRS("-Xmaxerrs", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    XMAXWARNS("-Xmaxwarns", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.setCompilerOpt(opt, arg);
+        }
+    },
+
+    // ----- doclet options -----
+
+    DOCLET("-doclet", true), // handled in setDocletInvoker
+
+    DOCLETPATH("-docletpath", true), // handled in setDocletInvoker
+
+    // ----- selection options -----
+
+    SUBPACKAGES("-subpackages", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.addToList(helper.subPackages, arg);
+        }
+    },
+
+    EXCLUDE("-exclude", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.addToList(helper.excludedPackages, arg);
+        }
+    },
+
+    // ----- filtering options -----
+
+    PACKAGE("-package") {
+        @Override
+        public void process(Helper helper) {
+            helper.setFilter(
+                    Flags.PUBLIC | Flags.PROTECTED | ModifierFilter.PACKAGE);
+        }
+    },
+
+    PRIVATE("-private") {
+        @Override
+        public void process(Helper helper) {
+            helper.setFilter(ModifierFilter.ALL_ACCESS);
+        }
+    },
+
+    PROTECTED("-protected") {
+        @Override
+        public void process(Helper helper) {
+            helper.setFilter(Flags.PUBLIC | Flags.PROTECTED);
+        }
+    },
+
+    PUBLIC("-public") {
+        @Override
+        public void process(Helper helper) {
+            helper.setFilter(Flags.PUBLIC);
+        }
+    },
+
+    // ----- output control options -----
+
+    PROMPT("-prompt") {
+        @Override
+        public void process(Helper helper) {
+            helper.compOpts.put("-prompt", "-prompt");
+            helper.promptOnError = true;
+        }
+    },
+
+    QUIET("-quiet") {
+        @Override
+        public void process(Helper helper) {
+            helper.quiet = true;
+        }
+    },
+
+    VERBOSE("-verbose") {
+        @Override
+        public void process(Helper helper) {
+            helper.compOpts.put("-verbose", "");
+        }
+    },
+
+    XWERROR("-Xwerror") {
+        @Override
+        public void process(Helper helper) {
+            helper.rejectWarnings = true;
+
+        }
+    },
+
+    // ----- other options -----
+
+    BREAKITERATOR("-breakiterator") {
+        @Override
+        public void process(Helper helper) {
+            helper.breakiterator = true;
+        }
+    },
+
+    LOCALE("-locale", true) {
+        @Override
+        public void process(Helper helper, String arg) {
+            helper.docLocale = arg;
+        }
+    },
+
+    OVERVIEW("-overview", true),
+
+    XCLASSES("-Xclasses") {
+        @Override
+        public void process(Helper helper) {
+            helper.docClasses = true;
+
+        }
+    },
+
+    // ----- help options -----
+
+    HELP("-help") {
+        @Override
+        public void process(Helper helper) {
+            helper.usage();
+        }
+    },
+
+    X("-X") {
+        @Override
+        public void process(Helper helper) {
+            helper.Xusage();
+        }
+    };
+
+    public final String opt;
+    public final boolean hasArg;
+
+    ToolOption(String opt) {
+        this(opt, false);
+    }
+
+    ToolOption(String opt, boolean hasArg) {
+        this.opt = opt;
+        this.hasArg = hasArg;
+    }
+
+    void process(Helper helper, String arg) { }
+
+    void process(Helper helper) { }
+
+    static ToolOption get(String name) {
+        for (ToolOption o: values()) {
+            if (name.equals(o.opt))
+                return o;
+        }
+        return null;
+    }
+
+    static abstract class Helper {
+        /** List of decoded options. */
+        final ListBuffer<String[]> options = new ListBuffer<String[]>();
+
+        /** Selected packages, from -subpackages. */
+        final ListBuffer<String> subPackages = new ListBuffer<String>();
+
+        /** Excluded packages, from -exclude. */
+        final ListBuffer<String> excludedPackages = new ListBuffer<String>();
+
+        /** javac options, set by various options. */
+        Options compOpts; // = Options.instance(context)
+
+        /* Encoding for javac, and files written? set by -encoding. */
+        String encoding = null;
+
+        /** Set by -breakiterator. */
+        boolean breakiterator = false;
+
+        /** Set by -quiet. */
+        boolean quiet = false;
+
+        /** Set by -Xclasses. */
+        boolean docClasses = false;
+
+        /** Set by -Xwerror. */
+        boolean rejectWarnings = false;
+
+        /** Set by -prompt. */
+        boolean promptOnError;
+
+        /** Set by -locale. */
+        String docLocale = "";
+
+        /** Set by -public, private, -protected, -package. */
+        ModifierFilter showAccess = null;
+
+        abstract void usage();
+        abstract void Xusage();
+
+        abstract void usageError(String msg, Object... args);
+
+        protected void addToList(ListBuffer<String> list, String str){
+            StringTokenizer st = new StringTokenizer(str, ":");
+            String current;
+            while(st.hasMoreTokens()){
+                current = st.nextToken();
+                list.append(current);
+            }
+        }
+
+        protected void setFilter(long filterBits) {
+            if (showAccess != null) {
+                usageError("main.incompatible.access.flags");
+            }
+            showAccess = new ModifierFilter(filterBits);
+        }
+
+        private void setCompilerOpt(String opt, String arg) {
+            if (compOpts.get(opt) != null) {
+                usageError("main.option.already.seen", opt);
+            }
+            compOpts.put(opt, arg);
+        }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/TypeMaker.java

@@ -0,0 +1,353 @@
+/*
+ * Copyright (c) 1997, 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.javadoc;
+
+import com.sun.javadoc.*;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.CompletionFailure;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Type.ArrayType;
+import com.sun.tools.javac.code.Type.ClassType;
+import com.sun.tools.javac.code.Type.TypeVar;
+import com.sun.tools.javac.util.List;
+import static com.sun.tools.javac.code.TypeTag.ARRAY;
+
+/**
+ *  <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 TypeMaker {
+
+    public static com.sun.javadoc.Type getType(DocEnv env, Type t) {
+        return getType(env, t, true);
+    }
+
+    /**
+     * @param errToClassDoc  if true, ERROR type results in a ClassDoc;
+     *          false preserves legacy behavior
+     */
+    public static com.sun.javadoc.Type getType(DocEnv env, Type t,
+            boolean errorToClassDoc) {
+        return getType(env, t, errorToClassDoc, true);
+    }
+
+    public static com.sun.javadoc.Type getType(DocEnv env, Type t,
+            boolean errToClassDoc, boolean considerAnnotations) {
+        try {
+            return getTypeImpl(env, t, errToClassDoc, considerAnnotations);
+        } catch (CompletionFailure cf) {
+            /* Quietly ignore completion failures and try again - the type
+             * for which the CompletionFailure was thrown shouldn't be completed
+             * again by the completer that threw the CompletionFailure.
+             */
+            return getType(env, t, errToClassDoc, considerAnnotations);
+        }
+    }
+
+    @SuppressWarnings("fallthrough")
+    private static com.sun.javadoc.Type getTypeImpl(DocEnv env, Type t,
+            boolean errToClassDoc, boolean considerAnnotations) {
+        if (env.legacyDoclet) {
+            t = env.types.erasure(t);
+        }
+
+        if (considerAnnotations && t.isAnnotated()) {
+            return new AnnotatedTypeImpl(env, t);
+        }
+
+        switch (t.getTag()) {
+        case CLASS:
+            if (ClassDocImpl.isGeneric((ClassSymbol)t.tsym)) {
+                return env.getParameterizedType((ClassType)t);
+            } else {
+                return env.getClassDoc((ClassSymbol)t.tsym);
+            }
+        case WILDCARD:
+            Type.WildcardType a = (Type.WildcardType)t;
+            return new WildcardTypeImpl(env, a);
+        case TYPEVAR: return new TypeVariableImpl(env, (TypeVar)t);
+        case ARRAY: return new ArrayTypeImpl(env, t);
+        case BYTE: return PrimitiveType.byteType;
+        case CHAR: return PrimitiveType.charType;
+        case SHORT: return PrimitiveType.shortType;
+        case INT: return PrimitiveType.intType;
+        case LONG: return PrimitiveType.longType;
+        case FLOAT: return PrimitiveType.floatType;
+        case DOUBLE: return PrimitiveType.doubleType;
+        case BOOLEAN: return PrimitiveType.booleanType;
+        case VOID: return PrimitiveType.voidType;
+        case ERROR:
+            if (errToClassDoc)
+                return env.getClassDoc((ClassSymbol)t.tsym);
+            // FALLTHRU
+        default:
+            return new PrimitiveType(t.tsym.getQualifiedName().toString());
+        }
+    }
+
+    /**
+     * Convert a list of javac types into an array of javadoc types.
+     */
+    public static com.sun.javadoc.Type[] getTypes(DocEnv env, List<Type> ts) {
+        return getTypes(env, ts, new com.sun.javadoc.Type[ts.length()]);
+    }
+
+    /**
+     * Like the above version, but use and return the array given.
+     */
+    public static com.sun.javadoc.Type[] getTypes(DocEnv env, List<Type> ts,
+                                                  com.sun.javadoc.Type res[]) {
+        int i = 0;
+        for (Type t : ts) {
+            res[i++] = getType(env, t);
+        }
+        return res;
+    }
+
+    public static String getTypeName(Type t, boolean full) {
+        switch (t.getTag()) {
+        case ARRAY:
+            StringBuilder s = new StringBuilder();
+            while (t.hasTag(ARRAY)) {
+                s.append("[]");
+                t = ((ArrayType)t).elemtype;
+            }
+            s.insert(0, getTypeName(t, full));
+            return s.toString();
+        case CLASS:
+            return ClassDocImpl.getClassName((ClassSymbol)t.tsym, full);
+        default:
+            return t.tsym.getQualifiedName().toString();
+        }
+    }
+
+    /**
+     * Return the string representation of a type use.  Bounds of type
+     * variables are not included; bounds of wildcard types are.
+     * Class names are qualified if "full" is true.
+     */
+    static String getTypeString(DocEnv env, Type t, boolean full) {
+        // TODO: should annotations be included here?
+        if (t.isAnnotated()) {
+            t = t.unannotatedType();
+        }
+        switch (t.getTag()) {
+        case ARRAY:
+            StringBuilder s = new StringBuilder();
+            while (t.hasTag(ARRAY)) {
+                s.append("[]");
+                t = env.types.elemtype(t);
+            }
+            s.insert(0, getTypeString(env, t, full));
+            return s.toString();
+        case CLASS:
+            return ParameterizedTypeImpl.
+                        parameterizedTypeToString(env, (ClassType)t, full);
+        case WILDCARD:
+            Type.WildcardType a = (Type.WildcardType)t;
+            return WildcardTypeImpl.wildcardTypeToString(env, a, full);
+        default:
+            return t.tsym.getQualifiedName().toString();
+        }
+    }
+
+    /**
+     * Return the formal type parameters of a class or method as an
+     * angle-bracketed string.  Each parameter is a type variable with
+     * optional bounds.  Class names are qualified if "full" is true.
+     * Return "" if there are no type parameters or we're hiding generics.
+     */
+    static String typeParametersString(DocEnv env, Symbol sym, boolean full) {
+        if (env.legacyDoclet || sym.type.getTypeArguments().isEmpty()) {
+            return "";
+        }
+        StringBuilder s = new StringBuilder();
+        for (Type t : sym.type.getTypeArguments()) {
+            s.append(s.length() == 0 ? "<" : ", ");
+            s.append(TypeVariableImpl.typeVarToString(env, (TypeVar)t, full));
+        }
+        s.append(">");
+        return s.toString();
+    }
+
+    /**
+     * Return the actual type arguments of a parameterized type as an
+     * angle-bracketed string.  Class name are qualified if "full" is true.
+     * Return "" if there are no type arguments or we're hiding generics.
+     */
+    static String typeArgumentsString(DocEnv env, ClassType cl, boolean full) {
+        if (env.legacyDoclet || cl.getTypeArguments().isEmpty()) {
+            return "";
+        }
+        StringBuilder s = new StringBuilder();
+        for (Type t : cl.getTypeArguments()) {
+            s.append(s.length() == 0 ? "<" : ", ");
+            s.append(getTypeString(env, t, full));
+        }
+        s.append(">");
+        return s.toString();
+    }
+
+
+    private static class ArrayTypeImpl implements com.sun.javadoc.Type {
+
+        Type arrayType;
+
+        DocEnv env;
+
+        ArrayTypeImpl(DocEnv env, Type arrayType) {
+            this.env = env;
+            this.arrayType = arrayType;
+        }
+
+        private com.sun.javadoc.Type skipArraysCache = null;
+
+        public com.sun.javadoc.Type getElementType() {
+            return TypeMaker.getType(env, env.types.elemtype(arrayType));
+        }
+
+        private com.sun.javadoc.Type skipArrays() {
+            if (skipArraysCache == null) {
+                Type t;
+                for (t = arrayType; t.hasTag(ARRAY); t = env.types.elemtype(t)) { }
+                skipArraysCache = TypeMaker.getType(env, t);
+            }
+            return skipArraysCache;
+        }
+
+        /**
+         * Return the type's dimension information, as a string.
+         * <p>
+         * For example, a two dimensional array of String returns '[][]'.
+         */
+        public String dimension() {
+            StringBuilder dimension = new StringBuilder();
+            for (Type t = arrayType; t.hasTag(ARRAY); t = env.types.elemtype(t)) {
+                dimension.append("[]");
+            }
+            return dimension.toString();
+        }
+
+        /**
+         * Return unqualified name of type excluding any dimension information.
+         * <p>
+         * For example, a two dimensional array of String returns 'String'.
+         */
+        public String typeName() {
+            return skipArrays().typeName();
+        }
+
+        /**
+         * Return qualified name of type excluding any dimension information.
+         *<p>
+         * For example, a two dimensional array of String
+         * returns 'java.lang.String'.
+         */
+        public String qualifiedTypeName() {
+            return skipArrays().qualifiedTypeName();
+        }
+
+        /**
+         * Return the simple name of this type excluding any dimension information.
+         */
+        public String simpleTypeName() {
+            return skipArrays().simpleTypeName();
+        }
+
+        /**
+         * Return this type as a class.  Array dimensions are ignored.
+         *
+         * @return a ClassDocImpl if the type is a Class.
+         * Return null if it is a primitive type..
+         */
+        public ClassDoc asClassDoc() {
+            return skipArrays().asClassDoc();
+        }
+
+        /**
+         * Return this type as a <code>ParameterizedType</code> if it
+         * represents a parameterized type.  Array dimensions are ignored.
+         */
+        public ParameterizedType asParameterizedType() {
+            return skipArrays().asParameterizedType();
+        }
+
+        /**
+         * Return this type as a <code>TypeVariable</code> if it represents
+         * a type variable.  Array dimensions are ignored.
+         */
+        public TypeVariable asTypeVariable() {
+            return skipArrays().asTypeVariable();
+        }
+
+        /**
+         * Return null, as there are no arrays of wildcard types.
+         */
+        public WildcardType asWildcardType() {
+            return null;
+        }
+
+        /**
+         * Return null, as there are no annotations of the type
+         */
+        public AnnotatedType asAnnotatedType() {
+            return null;
+        }
+
+        /**
+         * Return this type as an <code>AnnotationTypeDoc</code> if it
+         * represents an annotation type.  Array dimensions are ignored.
+         */
+        public AnnotationTypeDoc asAnnotationTypeDoc() {
+            return skipArrays().asAnnotationTypeDoc();
+        }
+
+        /**
+         * Return true if this is an array of a primitive type.
+         */
+        public boolean isPrimitive() {
+            return skipArrays().isPrimitive();
+        }
+
+        /**
+         * Return a string representation of the type.
+         *
+         * Return name of type including any dimension information.
+         * <p>
+         * For example, a two dimensional array of String returns
+         * <code>String[][]</code>.
+         *
+         * @return name of type including any dimension information.
+         */
+        @Override
+        public String toString() {
+            return qualifiedTypeName() + dimension();
+        }
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/TypeVariableImpl.java

@@ -0,0 +1,151 @@
+/*
+ * Copyright (c) 2003, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Attribute;
+import com.sun.tools.javac.code.Attribute.TypeCompound;
+import com.sun.tools.javac.code.Kinds;
+import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Symbol.MethodSymbol;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.code.Type.TypeVar;
+import com.sun.tools.javac.util.List;
+import com.sun.tools.javac.util.Name;
+import com.sun.tools.javac.util.Names;
+
+/**
+ * Implementation of <code>TypeVariable</code>, which
+ * represents a type variable.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+public class TypeVariableImpl extends AbstractTypeImpl implements TypeVariable {
+
+    TypeVariableImpl(DocEnv env, TypeVar type) {
+        super(env, type);
+    }
+
+    /**
+     * Return the bounds of this type variable.
+     */
+    public com.sun.javadoc.Type[] bounds() {
+        return TypeMaker.getTypes(env, getBounds((TypeVar)type, env));
+    }
+
+    /**
+     * Return the class, interface, method, or constructor within
+     * which this type variable is declared.
+     */
+    public ProgramElementDoc owner() {
+        Symbol osym = type.tsym.owner;
+        if ((osym.kind & Kinds.TYP) != 0) {
+            return env.getClassDoc((ClassSymbol)osym);
+        }
+        Names names = osym.name.table.names;
+        if (osym.name == names.init) {
+            return env.getConstructorDoc((MethodSymbol)osym);
+        } else {
+            return env.getMethodDoc((MethodSymbol)osym);
+        }
+    }
+
+    /**
+     * Return the ClassDoc of the erasure of this type variable.
+     */
+    @Override
+    public ClassDoc asClassDoc() {
+        return env.getClassDoc((ClassSymbol)env.types.erasure(type).tsym);
+    }
+
+    @Override
+    public TypeVariable asTypeVariable() {
+        return this;
+    }
+
+    @Override
+    public String toString() {
+        return typeVarToString(env, (TypeVar)type, true);
+    }
+
+
+    /**
+     * Return the string form of a type variable along with any
+     * "extends" clause.  Class names are qualified if "full" is true.
+     */
+    static String typeVarToString(DocEnv env, TypeVar v, boolean full) {
+        StringBuilder s = new StringBuilder(v.toString());
+        List<Type> bounds = getBounds(v, env);
+        if (bounds.nonEmpty()) {
+            boolean first = true;
+            for (Type b : bounds) {
+                s.append(first ? " extends " : " & ");
+                s.append(TypeMaker.getTypeString(env, b, full));
+                first = false;
+            }
+        }
+        return s.toString();
+    }
+
+    /**
+     * Get the bounds of a type variable as listed in the "extends" clause.
+     */
+    private static List<Type> getBounds(TypeVar v, DocEnv env) {
+        final Type upperBound = v.getUpperBound();
+        Name boundname = upperBound.tsym.getQualifiedName();
+        if (boundname == boundname.table.names.java_lang_Object
+            && !upperBound.isAnnotated()) {
+            return List.nil();
+        } else {
+            return env.types.getBounds(v);
+        }
+    }
+
+    /**
+     * Get the annotations of this program element.
+     * Return an empty array if there are none.
+     */
+    public AnnotationDesc[] annotations() {
+        if (!type.isAnnotated()) {
+            return new AnnotationDesc[0];
+        }
+        List<? extends TypeCompound> tas = type.getAnnotationMirrors();
+        AnnotationDesc res[] = new AnnotationDesc[tas.length()];
+        int i = 0;
+        for (Attribute.Compound a : tas) {
+            res[i++] = new AnnotationDescImpl(env, a);
+        }
+        return res;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/WildcardTypeImpl.java

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2003, 2012, 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.javadoc;
+
+import com.sun.javadoc.*;
+
+import com.sun.tools.javac.code.Symbol.ClassSymbol;
+import com.sun.tools.javac.code.Type;
+import com.sun.tools.javac.util.List;
+
+
+/**
+ * Implementation of <code>WildcardType</code>, which
+ * represents a wildcard type.
+ *
+ *  <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>
+ *
+ * @author Scott Seligman
+ * @since 1.5
+ */
+public class WildcardTypeImpl extends AbstractTypeImpl implements WildcardType {
+
+    WildcardTypeImpl(DocEnv env, Type.WildcardType type) {
+        super(env, type);
+    }
+
+    /**
+     * Return the upper bounds of this wildcard type argument
+     * as given by the <i>extends</i> clause.
+     * Return an empty array if no such bounds are explicitly given.
+     */
+    public com.sun.javadoc.Type[] extendsBounds() {
+        return TypeMaker.getTypes(env, getExtendsBounds((Type.WildcardType)type));
+    }
+
+    /**
+     * Return the lower bounds of this wildcard type argument
+     * as given by the <i>super</i> clause.
+     * Return an empty array if no such bounds are explicitly given.
+     */
+    public com.sun.javadoc.Type[] superBounds() {
+        return TypeMaker.getTypes(env, getSuperBounds((Type.WildcardType)type));
+    }
+
+    /**
+     * Return the ClassDoc of the erasure of this wildcard type.
+     */
+    @Override
+    public ClassDoc asClassDoc() {
+        return env.getClassDoc((ClassSymbol)env.types.erasure(type).tsym);
+    }
+
+    @Override
+    public WildcardType asWildcardType() {
+        return this;
+    }
+
+    @Override
+    public String typeName()            { return "?"; }
+    @Override
+    public String qualifiedTypeName()   { return "?"; }
+    @Override
+    public String simpleTypeName()      { return "?"; }
+
+    @Override
+    public String toString() {
+        return wildcardTypeToString(env, (Type.WildcardType)type, true);
+    }
+
+
+    /**
+     * Return the string form of a wildcard type ("?") along with any
+     * "extends" or "super" clause.  Delimiting brackets are not
+     * included.  Class names are qualified if "full" is true.
+     */
+    static String wildcardTypeToString(DocEnv env,
+                                       Type.WildcardType wildThing, boolean full) {
+        if (env.legacyDoclet) {
+            return TypeMaker.getTypeName(env.types.erasure(wildThing), full);
+        }
+        StringBuilder s = new StringBuilder("?");
+        List<Type> bounds = getExtendsBounds(wildThing);
+        if (bounds.nonEmpty()) {
+            s.append(" extends ");
+        } else {
+            bounds = getSuperBounds(wildThing);
+            if (bounds.nonEmpty()) {
+                s.append(" super ");
+            }
+        }
+        boolean first = true;   // currently only one bound is allowed
+        for (Type b : bounds) {
+            if (!first) {
+                s.append(" & ");
+            }
+            s.append(TypeMaker.getTypeString(env, b, full));
+            first = false;
+        }
+        return s.toString();
+    }
+
+    private static List<Type> getExtendsBounds(Type.WildcardType wild) {
+        return wild.isSuperBound()
+                ? List.<Type>nil()
+                : List.of(wild.type);
+    }
+
+    private static List<Type> getSuperBounds(Type.WildcardType wild) {
+        return wild.isExtendsBound()
+                ? List.<Type>nil()
+                : List.of(wild.type);
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/api/JavadocTaskImpl.java

@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2012, 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.javadoc.api;
+
+import com.sun.tools.javac.util.ClientCodeException;
+import java.util.Locale;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import javax.tools.DocumentationTool.DocumentationTask;
+import javax.tools.JavaFileObject;
+
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javadoc.Start;
+import java.util.Collections;
+
+/**
+ * Provides access to functionality specific to the JDK documentation tool,
+ * javadoc.
+ *
+ * <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></p>
+ */
+public class JavadocTaskImpl implements DocumentationTask {
+    private final AtomicBoolean used = new AtomicBoolean();
+
+    private final Context context;
+    private Class<?> docletClass;
+    private Iterable<String> options;
+    private Iterable<? extends JavaFileObject> fileObjects;
+    private Locale locale;
+
+    public JavadocTaskImpl(Context context, Class<?> docletClass,
+            Iterable<String> options, Iterable<? extends JavaFileObject> fileObjects) {
+        this.context = context;
+        this.docletClass = docletClass;
+
+        this.options = (options == null) ? Collections.<String>emptySet()
+                : nullCheck(options);
+        this.fileObjects = (fileObjects == null) ? Collections.<JavaFileObject>emptySet()
+                : nullCheck(fileObjects);
+        setLocale(Locale.getDefault());
+    }
+
+    public void setLocale(Locale locale) {
+        if (used.get())
+            throw new IllegalStateException();
+        this.locale = locale;
+    }
+
+    public Boolean call() {
+        if (!used.getAndSet(true)) {
+            initContext();
+            Start jdoc = new Start(context);
+            try {
+                return jdoc.begin(docletClass, options, fileObjects);
+            } catch (ClientCodeException e) {
+                throw new RuntimeException(e.getCause());
+            }
+        } else {
+            throw new IllegalStateException("multiple calls to method 'call'");
+        }
+    }
+
+    private void initContext() {
+        //initialize compiler's default locale
+        context.put(Locale.class, locale);
+    }
+
+    private static <T> Iterable<T> nullCheck(Iterable<T> items) {
+        for (T item: items) {
+            if (item == null)
+                throw new NullPointerException();
+        }
+        return items;
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/api/JavadocTool.java

@@ -0,0 +1,172 @@
+/*
+ * 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.javadoc.api;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.nio.charset.Charset;
+import java.util.Collections;
+import java.util.EnumSet;
+import java.util.Locale;
+import java.util.Set;
+
+import javax.lang.model.SourceVersion;
+import javax.tools.DiagnosticListener;
+import javax.tools.DocumentationTool;
+import javax.tools.JavaFileManager;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+
+import com.sun.tools.javac.api.ClientCodeWrapper;
+import com.sun.tools.javac.file.JavacFileManager;
+import com.sun.tools.javac.util.ClientCodeException;
+import com.sun.tools.javac.util.Context;
+import com.sun.tools.javac.util.Log;
+import com.sun.tools.javadoc.ToolOption;
+
+/**
+ * Provides access to functionality specific to the JDK documentation tool,
+ * javadoc.
+ *
+ * <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></p>
+ */
+public class JavadocTool implements DocumentationTool {
+    @Override
+    public DocumentationTask getTask(
+            Writer out,
+            JavaFileManager fileManager,
+            DiagnosticListener<? super JavaFileObject> diagnosticListener,
+            Class<?> docletClass,
+            Iterable<String> options,
+            Iterable<? extends JavaFileObject> compilationUnits) {
+        Context context = new Context();
+        return getTask(out, fileManager, diagnosticListener,
+                docletClass, options, compilationUnits, context);
+    }
+
+    public DocumentationTask getTask(
+            Writer out,
+            JavaFileManager fileManager,
+            DiagnosticListener<? super JavaFileObject> diagnosticListener,
+            Class<?> docletClass,
+            Iterable<String> options,
+            Iterable<? extends JavaFileObject> compilationUnits,
+            Context context) {
+        try {
+            ClientCodeWrapper ccw = ClientCodeWrapper.instance(context);
+
+            if (options != null) {
+                for (String option : options)
+                    option.getClass(); // null check
+            }
+
+            if (compilationUnits != null) {
+                compilationUnits = ccw.wrapJavaFileObjects(compilationUnits); // implicit null check
+                for (JavaFileObject cu : compilationUnits) {
+                    if (cu.getKind() != JavaFileObject.Kind.SOURCE) {
+                        final String kindMsg = "All compilation units must be of SOURCE kind";
+                        throw new IllegalArgumentException(kindMsg);
+                    }
+                }
+            }
+
+            if (diagnosticListener != null)
+                context.put(DiagnosticListener.class, ccw.wrap(diagnosticListener));
+
+            if (out == null)
+                context.put(Log.outKey, new PrintWriter(System.err, true));
+            else if (out instanceof PrintWriter)
+                context.put(Log.outKey, ((PrintWriter) out));
+            else
+                context.put(Log.outKey, new PrintWriter(out, true));
+
+            if (fileManager == null)
+                fileManager = getStandardFileManager(diagnosticListener, null, null);
+            fileManager = ccw.wrap(fileManager);
+            context.put(JavaFileManager.class, fileManager);
+
+            return new JavadocTaskImpl(context, docletClass, options, compilationUnits);
+        } catch (ClientCodeException ex) {
+            throw new RuntimeException(ex.getCause());
+        }
+    }
+
+    // TODO: used shared static method in JavacFileManager
+    @Override
+    public StandardJavaFileManager getStandardFileManager(
+            DiagnosticListener<? super JavaFileObject> diagnosticListener,
+            Locale locale,
+            Charset charset) {
+        Context context = new Context();
+        context.put(Locale.class, locale);
+        if (diagnosticListener != null)
+            context.put(DiagnosticListener.class, diagnosticListener);
+        PrintWriter pw = (charset == null)
+                ? new PrintWriter(System.err, true)
+                : new PrintWriter(new OutputStreamWriter(System.err, charset), true);
+        context.put(Log.outKey, pw);
+        return new JavacFileManager(context, true, charset);
+    }
+
+    @Override
+    public int run(InputStream in, OutputStream out, OutputStream err, String... arguments) {
+        PrintWriter err_pw = new PrintWriter(err == null ? System.err : err, true);
+        PrintWriter out_pw = new PrintWriter(out == null ? System.out : out);
+        try {
+            String standardDocletName = "com.sun.tools.doclets.standard.Standard";
+            ClassLoader cl = getClass().getClassLoader();
+            return com.sun.tools.javadoc.Main.execute(
+                    "javadoc", err_pw, err_pw, out_pw, standardDocletName, cl, arguments);
+        } finally {
+            err_pw.flush();
+            out_pw.flush();
+        }
+    }
+
+    @Override
+    public Set<SourceVersion> getSourceVersions() {
+        return Collections.unmodifiableSet(
+                EnumSet.range(SourceVersion.RELEASE_3, SourceVersion.latest()));
+    }
+
+    @Override
+    public int isSupportedOption(String option) {
+        if (option == null)
+            throw new NullPointerException();
+        for (ToolOption o: ToolOption.values()) {
+            if (o.opt.equals(option))
+                return o.hasArg ? 1 : 0;
+        }
+        return -1;
+    }
+
+}

jdkSrc/jdk8/com/sun/tools/javadoc/resources/javadoc.java

@@ -0,0 +1,70 @@
+package com.sun.tools.javadoc.resources;
+
+public final class javadoc extends java.util.ListResourceBundle {
+    protected final Object[][] getContents() {
+        return new Object[][] {
+            { "javadoc.Body_missing_from_html_file", "Body tag missing from HTML file" },
+            { "javadoc.End_body_missing_from_html_file", "Close body tag missing from HTML file" },
+            { "javadoc.File_Read_Error", "Error while reading file {0}" },
+            { "javadoc.JavaScript_in_comment", "JavaScript found in documentation comment.\nUse --allow-script-in-comments to allow use of JavaScript." },
+            { "javadoc.Multiple_package_comments", "Multiple sources of package comments found for package \"{0}\"" },
+            { "javadoc.class_not_found", "Class {0} not found." },
+            { "javadoc.error", "error" },
+            { "javadoc.error.msg", "{0}: error - {1}" },
+            { "javadoc.note.msg", "{1}" },
+            { "javadoc.note.pos.msg", "{0}: {1}" },
+            { "javadoc.warning", "warning" },
+            { "javadoc.warning.msg", "{0}: warning - {1}" },
+            { "main.Building_tree", "Constructing Javadoc information..." },
+            { "main.Loading_source_file", "Loading source file {0}..." },
+            { "main.Loading_source_files_for_package", "Loading source files for package {0}..." },
+            { "main.No_packages_or_classes_specified", "No packages or classes specified." },
+            { "main.Xusage", "  -Xmaxerrs <number>               Set the maximum number of errors to print\n  -Xmaxwarns <number>              Set the maximum number of warnings to print\n" },
+            { "main.Xusage.foot", "These options are non-standard and subject to change without notice." },
+            { "main.cant.read", "cannot read {0}" },
+            { "main.doclet_class_not_found", "Cannot find doclet class {0}" },
+            { "main.doclet_method_must_be_static", "In doclet class {0}, method {1} must be static." },
+            { "main.doclet_method_not_accessible", "In doclet class {0},  method {1} not accessible" },
+            { "main.doclet_method_not_found", "Doclet class {0} does not contain a {1} method" },
+            { "main.done_in", "[done in {0} ms]" },
+            { "main.error", "{0} error" },
+            { "main.errors", "{0} errors" },
+            { "main.exception_thrown", "In doclet class {0},  method {1} has thrown an exception {2}" },
+            { "main.fatal.error", "fatal error" },
+            { "main.fatal.exception", "fatal exception" },
+            { "main.file_not_found", "File not found: \"{0}\"" },
+            { "main.illegal_locale_name", "Locale not available: {0}" },
+            { "main.illegal_package_name", "Illegal package name: \"{0}\"" },
+            { "main.incompatible.access.flags", "More than one of -public, -private, -package, or -protected specified." },
+            { "main.internal_error_exception_thrown", "Internal error: In doclet class {0},  method {1} has thrown an exception {2}" },
+            { "main.invalid_flag", "invalid flag: {0}" },
+            { "main.locale_first", "option -locale must be first on the command line." },
+            { "main.malformed_locale_name", "Malformed locale name: {0}" },
+            { "main.more_than_one_doclet_specified_0_and_1", "More than one doclet specified ({0} and {1})." },
+            { "main.must_return_boolean", "In doclet class {0}, method {1} must return boolean." },
+            { "main.must_return_int", "In doclet class {0}, method {1} must return int." },
+            { "main.must_return_languageversion", "In doclet class {0}, method {1} must return LanguageVersion." },
+            { "main.no_source_files_for_package", "No source files for package {0}" },
+            { "main.option.already.seen", "The {0} option may be specified no more than once." },
+            { "main.out.of.memory", "java.lang.OutOfMemoryError: Please increase memory.\nFor example, on the JDK Classic or HotSpot VMs, add the option -J-Xmx\nsuch as -J-Xmx32m." },
+            { "main.requires_argument", "option {0} requires an argument." },
+            { "main.usage", "Usage: javadoc [options] [packagenames] [sourcefiles] [@files]\n  -overview <file>                 Read overview documentation from HTML file\n  -public                          Show only public classes and members\n  -protected                       Show protected/public classes and members (default)\n  -package                         Show package/protected/public classes and members\n  -private                         Show all classes and members\n  -help                            Display command line options and exit\n  -doclet <class>                  Generate output via alternate doclet\n  -docletpath <path>               Specify where to find doclet class files\n  -sourcepath <pathlist>           Specify where to find source files\n  -classpath <pathlist>            Specify where to find user class files\n  -cp <pathlist>                   Specify where to find user class files\n  -exclude <pkglist>               Specify a list of packages to exclude\n  -subpackages <subpkglist>        Specify subpackages to recursively load\n  -breakiterator                   Compute first sentence with BreakIterator\n  -bootclasspath <pathlist>        Override location of class files loaded\n                                   by the bootstrap class loader\n  -source <release>                Provide source compatibility with specified release\n  -extdirs <dirlist>               Override location of installed extensions\n  -verbose                         Output messages about what Javadoc is doing\n  -locale <name>                   Locale to be used, e.g. en_US or en_US_WIN\n  -encoding <name>                 Source file encoding name\n  -quiet                           Do not display status messages\n  -J<flag>                         Pass <flag> directly to the runtime system\n  -X                               Print a synopsis of nonstandard options and exit\n" },
+            { "main.warning", "{0} warning" },
+            { "main.warnings", "{0} warnings" },
+            { "tag.End_delimiter_missing_for_possible_SeeTag", "End Delimiter } missing for possible See Tag in comment string: \"{0}\"" },
+            { "tag.Improper_Use_Of_Link_Tag", "Missing closing ''}'' character for inline tag: \"{0}\"" },
+            { "tag.illegal_char_in_arr_dim", "Tag {0}: Syntax Error in array dimension, method parameters: {1}" },
+            { "tag.illegal_see_tag", "Tag {0}: Syntax Error in method parameters: {1}" },
+            { "tag.missing_comma_space", "Tag {0}: Missing comma or space in method parameters: {1}" },
+            { "tag.see.can_not_find_member", "Tag {0}: can''t find {1} in {2}" },
+            { "tag.see.class_not_specified", "Tag {0}: class not specified: \"{1}\"" },
+            { "tag.see.illegal_character", "Tag {0}:illegal character: \"{1}\" in \"{2}\"" },
+            { "tag.see.malformed_see_tag", "Tag {0}: malformed: \"{1}\"" },
+            { "tag.see.missing_sharp", "Tag {0}: missing ''#'': \"{1}\"" },
+            { "tag.see.no_close_bracket_on_url", "Tag {0}: missing final ''>'': \"{1}\"" },
+            { "tag.see.no_close_quote", "Tag {0}: no final close quote: \"{1}\"" },
+            { "tag.serialField.illegal_character", "illegal character {0} in @serialField tag: {1}." },
+            { "tag.tag_has_no_arguments", "{0} tag has no arguments." },
+        };
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/resources/javadoc_ja.java

@@ -0,0 +1,70 @@
+package com.sun.tools.javadoc.resources;
+
+public final class javadoc_ja extends java.util.ListResourceBundle {
+    protected final Object[][] getContents() {
+        return new Object[][] {
+            { "javadoc.Body_missing_from_html_file", "HTML\u306Bbody\u30BF\u30B0\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "javadoc.End_body_missing_from_html_file", "HTML\u30D5\u30A1\u30A4\u30EB\u306Bbody\u306E\u9589\u3058\u30BF\u30B0\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "javadoc.File_Read_Error", "\u30D5\u30A1\u30A4\u30EB{0}\u306E\u8AAD\u8FBC\u307F\u4E2D\u306B\u30A8\u30E9\u30FC\u304C\u767A\u751F\u3057\u307E\u3057\u305F" },
+            { "javadoc.JavaScript_in_comment", "\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u30FB\u30B3\u30E1\u30F3\u30C8\u306BJavaScript\u304C\u898B\u3064\u304B\u308A\u307E\u3057\u305F\u3002\n--allow-script-in-comments\u3092\u4F7F\u7528\u3057\u3066\u3001JavaScript\u306E\u4F7F\u7528\u3092\u8A31\u53EF\u3057\u3066\u304F\u3060\u3055\u3044\u3002" },
+            { "javadoc.Multiple_package_comments", "\u30D1\u30C3\u30B1\u30FC\u30B8\"{0}\"\u306B\u8907\u6570\u306E\u30D1\u30C3\u30B1\u30FC\u30B8\u30FB\u30B3\u30E1\u30F3\u30C8\u306E\u30BD\u30FC\u30B9\u304C\u691C\u51FA\u3055\u308C\u307E\u3057\u305F" },
+            { "javadoc.class_not_found", "\u30AF\u30E9\u30B9{0}\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3002" },
+            { "javadoc.error", "\u30A8\u30E9\u30FC" },
+            { "javadoc.error.msg", "{0}: \u30A8\u30E9\u30FC - {1}" },
+            { "javadoc.note.msg", "{1}" },
+            { "javadoc.note.pos.msg", "{0}: {1}" },
+            { "javadoc.warning", "\u8B66\u544A" },
+            { "javadoc.warning.msg", "{0}: \u8B66\u544A - {1}" },
+            { "main.Building_tree", "Javadoc\u60C5\u5831\u3092\u69CB\u7BC9\u3057\u3066\u3044\u307E\u3059..." },
+            { "main.Loading_source_file", "\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB{0}\u3092\u8AAD\u307F\u8FBC\u3093\u3067\u3044\u307E\u3059..." },
+            { "main.Loading_source_files_for_package", "\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u306E\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u8AAD\u307F\u8FBC\u3093\u3067\u3044\u307E\u3059..." },
+            { "main.No_packages_or_classes_specified", "\u30D1\u30C3\u30B1\u30FC\u30B8\u307E\u305F\u306F\u30AF\u30E9\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093\u3002" },
+            { "main.Xusage", "  -Xmaxerrs <number>        \u51FA\u529B\u3059\u308B\u30A8\u30E9\u30FC\u306E\u6700\u5927\u6570\u3092\u8A2D\u5B9A\u3059\u308B\n  -Xmaxwarns <number>       \u51FA\u529B\u3059\u308B\u8B66\u544A\u306E\u6700\u5927\u6570\u3092\u8A2D\u5B9A\u3059\u308B\n" },
+            { "main.Xusage.foot", "\u3053\u308C\u3089\u306F\u975E\u6A19\u6E96\u30AA\u30D7\u30B7\u30E7\u30F3\u3067\u3042\u308A\u4E88\u544A\u306A\u3057\u306B\u5909\u66F4\u3055\u308C\u308B\u3053\u3068\u304C\u3042\u308A\u307E\u3059\u3002" },
+            { "main.cant.read", "{0}\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093" },
+            { "main.doclet_class_not_found", "doclet\u30AF\u30E9\u30B9{0}\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
+            { "main.doclet_method_must_be_static", "doclet\u30AF\u30E9\u30B9{0}\u3067\u306F\u3001\u30E1\u30BD\u30C3\u30C9{1}\u306Fstatic\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" },
+            { "main.doclet_method_not_accessible", "doclet\u30AF\u30E9\u30B9{0}\u3067\u306F\u3001\u30E1\u30BD\u30C3\u30C9{1}\u306B\u30A2\u30AF\u30BB\u30B9\u3067\u304D\u307E\u305B\u3093" },
+            { "main.doclet_method_not_found", "doclet\u30AF\u30E9\u30B9{0}\u306B\u306F\u30E1\u30BD\u30C3\u30C9{1}\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "main.done_in", "[{0}\u30DF\u30EA\u79D2\u3067\u5B8C\u4E86]" },
+            { "main.error", "\u30A8\u30E9\u30FC{0}\u500B" },
+            { "main.errors", "\u30A8\u30E9\u30FC{0}\u500B" },
+            { "main.exception_thrown", "doclet\u30AF\u30E9\u30B9{0}\u3067\u306F\u3001\u30E1\u30BD\u30C3\u30C9{1}\u306F\u4F8B\u5916{2}\u3092\u30B9\u30ED\u30FC\u3057\u307E\u3057\u305F" },
+            { "main.fatal.error", "\u81F4\u547D\u7684\u30A8\u30E9\u30FC" },
+            { "main.fatal.exception", "\u81F4\u547D\u7684\u4F8B\u5916" },
+            { "main.file_not_found", "\u30D5\u30A1\u30A4\u30EB\"{0}\"\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
+            { "main.illegal_locale_name", "\u30ED\u30B1\u30FC\u30EB{0}\u304C\u7121\u52B9\u3067\u3059" },
+            { "main.illegal_package_name", "\u30D1\u30C3\u30B1\u30FC\u30B8\u540D\"{0}\"\u306F\u4E0D\u6B63\u3067\u3059" },
+            { "main.incompatible.access.flags", "-public\u3001-private\u3001-package\u307E\u305F\u306F-protected\u306E\u3046\u3061\u306E2\u3064\u4EE5\u4E0A\u3092\u6307\u5B9A\u3057\u307E\u3057\u305F\u3002" },
+            { "main.internal_error_exception_thrown", "doclet\u30AF\u30E9\u30B9{0}\u306E\u5185\u90E8\u30A8\u30E9\u30FC\u3067\u3059\u3002\u30E1\u30BD\u30C3\u30C9{1}\u306F\u4F8B\u5916{2}\u3092\u30B9\u30ED\u30FC\u3057\u307E\u3057\u305F" },
+            { "main.invalid_flag", "{0}\u306F\u7121\u52B9\u306A\u30D5\u30E9\u30B0\u3067\u3059" },
+            { "main.locale_first", "\u30AA\u30D7\u30B7\u30E7\u30F3-locale\u306F\u3001\u30B3\u30DE\u30F3\u30C9\u884C\u306E\u6700\u521D\u306B\u6307\u5B9A\u3059\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" },
+            { "main.malformed_locale_name", "\u30ED\u30B1\u30FC\u30EB\u540D{0}\u306E\u66F8\u5F0F\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093" },
+            { "main.more_than_one_doclet_specified_0_and_1", "\u8907\u6570\u306Edoclet({0}\u3068{1})\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u3059\u3002" },
+            { "main.must_return_boolean", "doclet\u30AF\u30E9\u30B9{0}\u3067\u306F\u3001\u30E1\u30BD\u30C3\u30C9{1}\u306Fboolean\u3092\u8FD4\u3059\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" },
+            { "main.must_return_int", "doclet\u30AF\u30E9\u30B9{0}\u3067\u306F\u3001\u30E1\u30BD\u30C3\u30C9{1}\u306Fint\u3092\u8FD4\u3059\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" },
+            { "main.must_return_languageversion", "doclet\u30AF\u30E9\u30B9{0}\u3067\u306F\u3001\u30E1\u30BD\u30C3\u30C9{1}\u306FLanguageVersion\u3092\u8FD4\u3059\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\u3002" },
+            { "main.no_source_files_for_package", "\u30D1\u30C3\u30B1\u30FC\u30B8{0}\u306E\u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "main.option.already.seen", "{0}\u30AA\u30D7\u30B7\u30E7\u30F3\u304C\u8907\u6570\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u3059\u3002" },
+            { "main.out.of.memory", "java.lang.OutOfMemoryError: \u30E1\u30E2\u30EA\u30FC\u3092\u5897\u3084\u3057\u3066\u304F\u3060\u3055\u3044\u3002\n\u305F\u3068\u3048\u3070\u3001JDK\u306Eclassic\u3082\u3057\u304F\u306Fhotspot VM\u3067\u306F\u3001-J-Xmx32m\u306E\u3088\u3046\u306B\n-J-Xmx\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u4F7F\u7528\u3057\u307E\u3059\u3002" },
+            { "main.requires_argument", "\u30AA\u30D7\u30B7\u30E7\u30F3{0}\u306B\u306F\u5F15\u6570\u304C\u5FC5\u8981\u3067\u3059\u3002" },
+            { "main.usage", "\u4F7F\u7528\u65B9\u6CD5: javadoc [options] [packagenames] [sourcefiles] [@files]\n  -overview <file>          HTML\u30D5\u30A1\u30A4\u30EB\u304B\u3089\u6982\u8981\u30C9\u30AD\u30E5\u30E1\u30F3\u30C8\u3092\u8AAD\u307F\u8FBC\u3080\n  -public                   public\u30AF\u30E9\u30B9\u3068\u30E1\u30F3\u30D0\u30FC\u306E\u307F\u3092\u793A\u3059\n  -protected                protected/public\u30AF\u30E9\u30B9\u3068\u30E1\u30F3\u30D0\u30FC\u3092\u793A\u3059(\u30C7\u30D5\u30A9\u30EB\u30C8)\n  -package                  package/protected/public\u30AF\u30E9\u30B9\u3068\u30E1\u30F3\u30D0\u30FC\u3092\u793A\u3059\n  -private                  \u3059\u3079\u3066\u306E\u30AF\u30E9\u30B9\u3068\u30E1\u30F3\u30D0\u30FC\u3092\u793A\u3059\n  -help                     \u30B3\u30DE\u30F3\u30C9\u884C\u30AA\u30D7\u30B7\u30E7\u30F3\u3092\u8868\u793A\u3057\u3066\u7D42\u4E86\u3059\u308B\n  -doclet <class>           \u4EE3\u66FFdoclet\u3092\u4ECB\u3057\u3066\u51FA\u529B\u3092\u751F\u6210\u3059\u308B\n  -docletpath <path>        doclet\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u3092\u63A2\u3059\u5834\u6240\u3092\u6307\u5B9A\u3059\u308B\n  -sourcepath <pathlist>    \u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u3042\u308B\u5834\u6240\u3092\u6307\u5B9A\u3059\u308B\n  -classpath <pathlist>     \u30E6\u30FC\u30B6\u30FC\u30FB\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u3042\u308B\u5834\u6240\u3092\u6307\u5B9A\u3059\u308B\n  -cp <pathlist>                   \u30E6\u30FC\u30B6\u30FC\u30FB\u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u3042\u308B\u5834\u6240\u3092\u6307\u5B9A\u3059\u308B\r\n  -exclude <pkglist>        \u9664\u5916\u3059\u308B\u30D1\u30C3\u30B1\u30FC\u30B8\u30FB\u30EA\u30B9\u30C8\u3092\u6307\u5B9A\u3059\u308B\n  -subpackages <subpkglist> \u518D\u5E30\u7684\u306B\u30ED\u30FC\u30C9\u3059\u308B\u30B5\u30D6\u30D1\u30C3\u30B1\u30FC\u30B8\u3092\u6307\u5B9A\u3059\u308B\n  -breakiterator            BreakIterator\u3067\u6700\u521D\u306E\u6587\u3092\u8A08\u7B97\u3059\u308B\n  -bootclasspath <pathlist> \u30D6\u30FC\u30C8\u30B9\u30C8\u30E9\u30C3\u30D7\u30FB\u30AF\u30E9\u30B9\u30FB\u30ED\u30FC\u30C0\u30FC\u306B\u3088\u308A\u30ED\u30FC\u30C9\u3055\u308C\u305F\n                                   \u30AF\u30E9\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B\n  -source <release>         \u6307\u5B9A\u3055\u308C\u305F\u30EA\u30EA\u30FC\u30B9\u3068\u30BD\u30FC\u30B9\u306E\u4E92\u63DB\u6027\u3092\u63D0\u4F9B\u3059\u308B\n  -extdirs <dirlist>        \u30A4\u30F3\u30B9\u30C8\u30FC\u30EB\u3055\u308C\u305F\u62E1\u5F35\u6A5F\u80FD\u306E\u5834\u6240\u3092\u30AA\u30FC\u30D0\u30FC\u30E9\u30A4\u30C9\u3059\u308B\n  -verbose                  Javadoc\u306E\u52D5\u4F5C\u306B\u3064\u3044\u3066\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u51FA\u529B\u3059\u308B\n  -locale <name>            en_US\u3084en_US_WIN\u306A\u3069\u306E\u4F7F\u7528\u3059\u308B\u30ED\u30B1\u30FC\u30EB\n  -encoding <name>          \u30BD\u30FC\u30B9\u30FB\u30D5\u30A1\u30A4\u30EB\u306E\u30A8\u30F3\u30B3\u30FC\u30C7\u30A3\u30F3\u30B0\u540D\n  -quiet                    \u72B6\u614B\u30E1\u30C3\u30BB\u30FC\u30B8\u3092\u8868\u793A\u3057\u306A\u3044\n  -J<flag>                  <flag>\u3092\u5B9F\u884C\u6642\u30B7\u30B9\u30C6\u30E0\u306B\u76F4\u63A5\u6E21\u3059\n  -X                        \u975E\u6A19\u6E96\u30AA\u30D7\u30B7\u30E7\u30F3\u306E\u6982\u8981\u3092\u51FA\u529B\u3057\u7D42\u4E86\u3059\u308B\n" },
+            { "main.warning", "\u8B66\u544A{0}\u500B" },
+            { "main.warnings", "\u8B66\u544A{0}\u500B" },
+            { "tag.End_delimiter_missing_for_possible_SeeTag", "\u30B3\u30E1\u30F3\u30C8\u6587\u5B57\u5217\"{0}\"\u3067\u3001\u6709\u52B9\u306Asee\u30BF\u30B0\u306B\u7D42\u7AEF\u30C7\u30EA\u30DF\u30BF}\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "tag.Improper_Use_Of_Link_Tag", "\u30A4\u30F3\u30E9\u30A4\u30F3\u30FB\u30BF\u30B0\"{0}\"\u306B\u7D42\u4E86\u6587\u5B57''}''\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "tag.illegal_char_in_arr_dim", "\u30BF\u30B0{0}: \u914D\u5217\u306E\u5927\u304D\u3055\u3001\u30E1\u30BD\u30C3\u30C9\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF{1}\u306B\u69CB\u6587\u30A8\u30E9\u30FC\u304C\u3042\u308A\u307E\u3059" },
+            { "tag.illegal_see_tag", "\u30BF\u30B0{0}: \u30E1\u30BD\u30C3\u30C9\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF{1}\u306B\u69CB\u6587\u30A8\u30E9\u30FC\u304C\u3042\u308A\u307E\u3059" },
+            { "tag.missing_comma_space", "\u30BF\u30B0{0}: \u30E1\u30BD\u30C3\u30C9\u30FB\u30D1\u30E9\u30E1\u30FC\u30BF{1}\u306B\u30AB\u30F3\u30DE\u307E\u305F\u306F\u7A7A\u767D\u6587\u5B57\u304C\u3042\u308A\u307E\u305B\u3093" },
+            { "tag.see.can_not_find_member", "\u30BF\u30B0{0}: {2}\u3067{1}\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093" },
+            { "tag.see.class_not_specified", "\u30BF\u30B0{0}: \u30AF\u30E9\u30B9\u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u307E\u305B\u3093: \"{1}\"" },
+            { "tag.see.illegal_character", "\u30BF\u30B0{0}: \"{2}\"\u306B\u4E0D\u6B63\u306A\u6587\u5B57\"{1}\"\u304C\u3042\u308A\u307E\u3059" },
+            { "tag.see.malformed_see_tag", "\u30BF\u30B0{0}: \u66F8\u5F0F\u304C\u6B63\u3057\u304F\u3042\u308A\u307E\u305B\u3093: \"{1}\"" },
+            { "tag.see.missing_sharp", "\u30BF\u30B0{0}: ''#''\u304C\u3042\u308A\u307E\u305B\u3093: \"{1}\"" },
+            { "tag.see.no_close_bracket_on_url", "\u30BF\u30B0{0}: \u9589\u3058\u30BF\u30B0''>''\u304C\u3042\u308A\u307E\u305B\u3093: \"{1}\"" },
+            { "tag.see.no_close_quote", "\u30BF\u30B0{0}: \u9589\u3058\u5F15\u7528\u7B26\u304C\u3042\u308A\u307E\u305B\u3093: \"{1}\"" },
+            { "tag.serialField.illegal_character", "@serialField\u30BF\u30B0\u306B\u4E0D\u6B63\u306A\u6587\u5B57{0}\u304C\u3042\u308A\u307E\u3059: {1}\u3002" },
+            { "tag.tag_has_no_arguments", "{0}\u30BF\u30B0\u306B\u5F15\u6570\u304C\u3042\u308A\u307E\u305B\u3093\u3002" },
+        };
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/resources/javadoc_zh_CN.java

@@ -0,0 +1,70 @@
+package com.sun.tools.javadoc.resources;
+
+public final class javadoc_zh_CN extends java.util.ListResourceBundle {
+    protected final Object[][] getContents() {
+        return new Object[][] {
+            { "javadoc.Body_missing_from_html_file", "HTML \u6587\u4EF6\u4E2D\u7F3A\u5C11\u4E3B\u4F53\u6807\u8BB0" },
+            { "javadoc.End_body_missing_from_html_file", "HTML \u6587\u4EF6\u4E2D\u7F3A\u5C11\u4E3B\u4F53\u7ED3\u675F\u6807\u8BB0" },
+            { "javadoc.File_Read_Error", "\u8BFB\u53D6\u6587\u4EF6{0}\u65F6\u51FA\u9519" },
+            { "javadoc.JavaScript_in_comment", "\u6587\u6863\u6CE8\u91CA\u4E2D\u53D1\u73B0 JavaScript\u3002\n\u4F7F\u7528 --allow-script-in-comments \u53EF\u5141\u8BB8\u4F7F\u7528 JavaScript\u3002" },
+            { "javadoc.Multiple_package_comments", "\u627E\u5230\u7A0B\u5E8F\u5305 \"{0}\" \u7684\u591A\u4E2A\u7A0B\u5E8F\u5305\u6CE8\u91CA\u6E90" },
+            { "javadoc.class_not_found", "\u627E\u4E0D\u5230\u7C7B{0}\u3002" },
+            { "javadoc.error", "\u9519\u8BEF" },
+            { "javadoc.error.msg", "{0}: \u9519\u8BEF - {1}" },
+            { "javadoc.note.msg", "{1}" },
+            { "javadoc.note.pos.msg", "{0}: {1}" },
+            { "javadoc.warning", "\u8B66\u544A" },
+            { "javadoc.warning.msg", "{0}: \u8B66\u544A - {1}" },
+            { "main.Building_tree", "\u6B63\u5728\u6784\u9020 Javadoc \u4FE1\u606F..." },
+            { "main.Loading_source_file", "\u6B63\u5728\u52A0\u8F7D\u6E90\u6587\u4EF6{0}..." },
+            { "main.Loading_source_files_for_package", "\u6B63\u5728\u52A0\u8F7D\u7A0B\u5E8F\u5305{0}\u7684\u6E90\u6587\u4EF6..." },
+            { "main.No_packages_or_classes_specified", "\u672A\u6307\u5B9A\u7A0B\u5E8F\u5305\u6216\u7C7B\u3002" },
+            { "main.Xusage", "  -Xmaxerrs <number>               \u8BBE\u7F6E\u8981\u8F93\u51FA\u7684\u6700\u5927\u9519\u8BEF\u6570\n  -Xmaxwarns <number>              \u8BBE\u7F6E\u8981\u8F93\u51FA\u7684\u6700\u5927\u8B66\u544A\u6570\n" },
+            { "main.Xusage.foot", "\u8FD9\u4E9B\u9009\u9879\u90FD\u662F\u975E\u6807\u51C6\u9009\u9879, \u5982\u6709\u66F4\u6539, \u6055\u4E0D\u53E6\u884C\u901A\u77E5\u3002" },
+            { "main.cant.read", "\u65E0\u6CD5\u8BFB\u53D6{0}" },
+            { "main.doclet_class_not_found", "\u627E\u4E0D\u5230 doclet \u7C7B{0}" },
+            { "main.doclet_method_must_be_static", "\u5728 doclet \u7C7B{0}\u4E2D, \u65B9\u6CD5{1}\u5FC5\u987B\u4E3A\u9759\u6001\u3002" },
+            { "main.doclet_method_not_accessible", "\u5728 doclet \u7C7B{0}\u4E2D, \u65E0\u6CD5\u8BBF\u95EE\u65B9\u6CD5{1}" },
+            { "main.doclet_method_not_found", "doclet \u7C7B{0}\u4E0D\u5305\u542B{1}\u65B9\u6CD5" },
+            { "main.done_in", "[\u5728 {0} \u6BEB\u79D2\u5185\u5B8C\u6210]" },
+            { "main.error", "{0} \u4E2A\u9519\u8BEF" },
+            { "main.errors", "{0} \u4E2A\u9519\u8BEF" },
+            { "main.exception_thrown", "\u5728 doclet \u7C7B{0}\u4E2D, \u65B9\u6CD5{1}\u5DF2\u629B\u51FA\u5F02\u5E38\u9519\u8BEF{2}" },
+            { "main.fatal.error", "\u81F4\u547D\u9519\u8BEF" },
+            { "main.fatal.exception", "\u81F4\u547D\u5F02\u5E38\u9519\u8BEF" },
+            { "main.file_not_found", "\u627E\u4E0D\u5230\u6587\u4EF6: \"{0}\"" },
+            { "main.illegal_locale_name", "\u8BED\u8A00\u73AF\u5883\u4E0D\u53EF\u7528: {0}" },
+            { "main.illegal_package_name", "\u975E\u6CD5\u7684\u7A0B\u5E8F\u5305\u540D\u79F0: \"{0}\"" },
+            { "main.incompatible.access.flags", "\u6307\u5B9A\u4E86\u591A\u4E2A -public, -private, -package \u6216 -protected\u3002" },
+            { "main.internal_error_exception_thrown", "\u5185\u90E8\u9519\u8BEF: \u5728 doclet \u7C7B{0}\u4E2D, \u65B9\u6CD5{1}\u5DF2\u629B\u51FA\u5F02\u5E38\u9519\u8BEF{2}" },
+            { "main.invalid_flag", "\u65E0\u6548\u7684\u6807\u8BB0: {0}" },
+            { "main.locale_first", "\u5728\u547D\u4EE4\u884C\u4E2D, \u9009\u9879 -locale \u5FC5\u987B\u4E3A\u7B2C\u4E00\u4E2A\u9009\u9879\u3002" },
+            { "main.malformed_locale_name", "\u683C\u5F0F\u9519\u8BEF\u7684\u8BED\u8A00\u73AF\u5883\u540D\u79F0: {0}" },
+            { "main.more_than_one_doclet_specified_0_and_1", "\u6307\u5B9A\u4E86\u591A\u4E2A doclet ({0}\u548C{1})\u3002" },
+            { "main.must_return_boolean", "\u5728 doclet \u7C7B{0}\u4E2D, \u65B9\u6CD5{1}\u5FC5\u987B\u8FD4\u56DE\u5E03\u5C14\u503C\u3002" },
+            { "main.must_return_int", "\u5728 doclet \u7C7B{0}\u4E2D, \u65B9\u6CD5{1}\u5FC5\u987B\u8FD4\u56DE\u6574\u578B\u503C\u3002" },
+            { "main.must_return_languageversion", "\u5728 doclet \u7C7B{0}\u4E2D, \u65B9\u6CD5{1}\u5FC5\u987B\u8FD4\u56DE\u8BED\u8A00\u7248\u672C\u3002" },
+            { "main.no_source_files_for_package", "\u6CA1\u6709\u7A0B\u5E8F\u5305{0}\u7684\u6E90\u6587\u4EF6" },
+            { "main.option.already.seen", "{0}\u9009\u9879\u53EA\u80FD\u6307\u5B9A\u4E00\u6B21\u3002" },
+            { "main.out.of.memory", "java.lang.OutOfMemoryError: \u8BF7\u589E\u5927\u5185\u5B58\u3002\n\u4F8B\u5982, \u5BF9\u4E8E JDK \u7ECF\u5178\u6216 HotSpot VM, \u8BF7\u589E\u5927\u9009\u9879 -J-Xmx,\n\u4F8B\u5982 -J-Xmx32m\u3002" },
+            { "main.requires_argument", "\u9009\u9879{0}\u9700\u8981\u53C2\u6570\u3002" },
+            { "main.usage", "\u7528\u6CD5: javadoc [options] [packagenames] [sourcefiles] [@files]\n  -overview <file>                 \u4ECE HTML \u6587\u4EF6\u8BFB\u53D6\u6982\u89C8\u6587\u6863\n  -public                          \u4EC5\u663E\u793A public \u7C7B\u548C\u6210\u5458\n  -protected                       \u663E\u793A protected/public \u7C7B\u548C\u6210\u5458 (\u9ED8\u8BA4\u503C)\n  -package                         \u663E\u793A package/protected/public \u7C7B\u548C\u6210\u5458\n  -private                         \u663E\u793A\u6240\u6709\u7C7B\u548C\u6210\u5458\n  -help                            \u663E\u793A\u547D\u4EE4\u884C\u9009\u9879\u5E76\u9000\u51FA\n  -doclet <class>                  \u901A\u8FC7\u66FF\u4EE3 doclet \u751F\u6210\u8F93\u51FA\n  -docletpath <path>               \u6307\u5B9A\u67E5\u627E doclet \u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E\n  -sourcepath <pathlist>           \u6307\u5B9A\u67E5\u627E\u6E90\u6587\u4EF6\u7684\u4F4D\u7F6E\n  -classpath <pathlist>            \u6307\u5B9A\u67E5\u627E\u7528\u6237\u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E\n  -cp <pathlist>                   \u6307\u5B9A\u67E5\u627E\u7528\u6237\u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E\n  -exclude <pkglist>               \u6307\u5B9A\u8981\u6392\u9664\u7684\u7A0B\u5E8F\u5305\u5217\u8868\n  -subpackages <subpkglist>        \u6307\u5B9A\u8981\u9012\u5F52\u52A0\u8F7D\u7684\u5B50\u7A0B\u5E8F\u5305\n  -breakiterator                   \u8BA1\u7B97\u5E26\u6709 BreakIterator \u7684\u7B2C\u4E00\u4E2A\u8BED\u53E5\n  -bootclasspath <pathlist>        \u8986\u76D6\u7531\u5F15\u5BFC\u7C7B\u52A0\u8F7D\u5668\u6240\u52A0\u8F7D\u7684\n                                   \u7C7B\u6587\u4EF6\u7684\u4F4D\u7F6E\n  -source <release>                \u63D0\u4F9B\u4E0E\u6307\u5B9A\u53D1\u884C\u7248\u7684\u6E90\u517C\u5BB9\u6027\n  -extdirs <dirlist>               \u8986\u76D6\u6240\u5B89\u88C5\u6269\u5C55\u7684\u4F4D\u7F6E\n  -verbose                         \u8F93\u51FA\u6709\u5173 Javadoc \u6B63\u5728\u6267\u884C\u7684\u64CD\u4F5C\u7684\u4FE1\u606F\n  -locale <name>                   \u8981\u4F7F\u7528\u7684\u533A\u57DF\u8BBE\u7F6E, \u4F8B\u5982 en_US \u6216 en_US_WIN\n  -encoding <name>                 \u6E90\u6587\u4EF6\u7F16\u7801\u540D\u79F0\n  -quiet                           \u4E0D\u663E\u793A\u72B6\u6001\u6D88\u606F\n  -J<flag>                         \u76F4\u63A5\u5C06 <flag> \u4F20\u9012\u5230\u8FD0\u884C\u65F6\u7CFB\u7EDF\n  -X                               \u8F93\u51FA\u975E\u6807\u51C6\u9009\u9879\u7684\u63D0\u8981\n" },
+            { "main.warning", "{0} \u4E2A\u8B66\u544A" },
+            { "main.warnings", "{0} \u4E2A\u8B66\u544A" },
+            { "tag.End_delimiter_missing_for_possible_SeeTag", "\u6CE8\u91CA\u5B57\u7B26\u4E32\u4E2D\u53EF\u80FD\u51FA\u73B0\u7684 See \u6807\u8BB0\u7F3A\u5C11\u7ED3\u675F\u5206\u9694\u7B26 }: \"{0}\"" },
+            { "tag.Improper_Use_Of_Link_Tag", "\u5185\u5D4C\u6807\u8BB0\u7F3A\u5C11\u7ED3\u675F ''}'' \u5B57\u7B26: \"{0}\"" },
+            { "tag.illegal_char_in_arr_dim", "\u6807\u8BB0{0}: \u6570\u7EC4\u7EF4\u4E2D\u6709\u8BED\u6CD5\u9519\u8BEF, \u65B9\u6CD5\u53C2\u6570: {1}" },
+            { "tag.illegal_see_tag", "\u6807\u8BB0{0}: \u65B9\u6CD5\u53C2\u6570\u4E2D\u6709\u8BED\u6CD5\u9519\u8BEF: {1}" },
+            { "tag.missing_comma_space", "\u6807\u8BB0{0}: \u65B9\u6CD5\u53C2\u6570\u4E2D\u7F3A\u5C11\u9017\u53F7\u6216\u7A7A\u683C: {1}" },
+            { "tag.see.can_not_find_member", "\u6807\u8BB0{0}: \u5728{2}\u4E2D\u627E\u4E0D\u5230{1}" },
+            { "tag.see.class_not_specified", "\u6807\u8BB0{0}: \u672A\u6307\u5B9A\u7C7B: \"{1}\"" },
+            { "tag.see.illegal_character", "\u6807\u8BB0{0}: \"{2}\" \u4E2D\u7684 \"{1}\" \u4E3A\u975E\u6CD5\u5B57\u7B26" },
+            { "tag.see.malformed_see_tag", "\u6807\u8BB0{0}: \u683C\u5F0F\u9519\u8BEF: \"{1}\"" },
+            { "tag.see.missing_sharp", "\u6807\u8BB0{0}: \u7F3A\u5C11 ''#'': \"{1}\"" },
+            { "tag.see.no_close_bracket_on_url", "\u6807\u8BB0{0}: \u7F3A\u5C11\u6700\u540E\u7684 ''>'': \"{1}\"" },
+            { "tag.see.no_close_quote", "\u6807\u8BB0{0}: \u65E0\u53F3\u5F15\u53F7: \"{1}\"" },
+            { "tag.serialField.illegal_character", "@serialField \u6807\u8BB0\u4E2D\u7684\u975E\u6CD5\u5B57\u7B26 {0}: {1}\u3002" },
+            { "tag.tag_has_no_arguments", "{0} \u6807\u8BB0\u6CA1\u6709\u53C2\u6570\u3002" },
+        };
+    }
+}

jdkSrc/jdk8/com/sun/tools/javadoc/resources/version.java

@@ -0,0 +1,11 @@
+package com.sun.tools.javadoc.resources;
+
+public final class version extends java.util.ListResourceBundle {
+    protected final Object[][] getContents() {
+        return new Object[][] {
+            { "full", "1.8.0_462-b08" },
+            { "jdk", "1.8.0_462" },
+            { "release", "1.8.0_462" },
+        };
+    }
+}