jdk8-mips64-public/langtools: src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java@667843bd2193 (annotated)

src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java@667843bd2193 (annotated)

src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java

Thu, 24 Oct 2013 11:22:50 -0700

author: bpatel
date: Thu, 24 Oct 2013 11:22:50 -0700
changeset 2169: 667843bd2193
parent 1866: 26437287529d
child 2413: fe033d997ddf
permissions: -rw-r--r--

8006248: Since addition of -Xdoclint, javadoc ignores unknown tags
Reviewed-by: jjg

 /*
  * 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.doclets.internal.toolkit.taglets;
 import java.io.*;
 import java.lang.reflect.*;
 import java.net.*;
 import java.util.*;
 import javax.tools.DocumentationTool;
 import javax.tools.JavaFileManager;
 import com.sun.javadoc.*;
 import com.sun.tools.doclets.internal.toolkit.util.*;
 /**
  * Manages the<code>Taglet</code>s used by 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 Jamie Ho
  * @since 1.4
  */
 public class TagletManager {
     /**
      * The default separator for the simple tag option.
      */
     public static final char SIMPLE_TAGLET_OPT_SEPARATOR = ':';
     /**
      * The alternate separator for simple tag options.  Use this
      * when you want the default separator to be in the name of the
      * custom tag.
      */
     public static final String ALT_SIMPLE_TAGLET_OPT_SEPARATOR = "-";
     /**
      * The map of custom tags.
      */
     private LinkedHashMap<String,Taglet> customTags;
     /**
      * The array of custom tags that can appear in packages.
      */
     private Taglet[] packageTags;
     /**
      * The array of custom tags that can appear in classes or interfaces.
      */
     private Taglet[] typeTags;
     /**
      * The array of custom tags that can appear in fields.
      */
     private Taglet[] fieldTags;
     /**
      * The array of custom tags that can appear in constructors.
      */
     private Taglet[] constructorTags;
     /**
      * The array of custom tags that can appear in methods.
      */
     private Taglet[] methodTags;
     /**
      * The array of custom tags that can appear in the overview.
      */
     private Taglet[] overviewTags;
     /**
      * The array of custom tags that can appear in comments.
      */
     private Taglet[] inlineTags;
     /**
      * The array of custom tags that can appear in the serialized form.
      */
     private Taglet[] serializedFormTags;
     /**
      * The message retriever that will be used to print error messages.
      */
     private MessageRetriever message;
     /**
      * Keep track of standard tags.
      */
     private Set<String> standardTags;
     /**
      * Keep track of standard tags in lowercase to compare for better
      * error messages when a tag like @docRoot is mistakenly spelled
      * lowercase @docroot.
      */
     private Set<String> standardTagsLowercase;
     /**
      * Keep track of overriden standard tags.
      */
     private Set<String> overridenStandardTags;
     /**
      * Keep track of the tags that may conflict
      * with standard tags in the future (any custom tag without
      * a period in its name).
      */
     private Set<String> potentiallyConflictingTags;
     /**
      * The set of unseen custom tags.
      */
     private Set<String> unseenCustomTags;
     /**
      * True if we do not want to use @since tags.
      */
     private boolean nosince;
     /**
      * True if we want to use @version tags.
      */
     private boolean showversion;
     /**
      * True if we want to use @author tags.
      */
     private boolean showauthor;
     /**
      * True if we want to use JavaFX-related tags (@propertyGetter,
      * @propertySetter, @propertyDescription, @defaultValue, @treatAsPrivate).
      */
     private boolean javafx;
     /**
      * Construct a new <code>TagletManager</code>.
      * @param nosince true if we do not want to use @since tags.
      * @param showversion true if we want to use @version tags.
      * @param showauthor true if we want to use @author tags.
      * @param message the message retriever to print warnings.
      */
     public TagletManager(boolean nosince, boolean showversion,
                          boolean showauthor, boolean javafx,
                          MessageRetriever message) {
         overridenStandardTags = new HashSet<String>();
         potentiallyConflictingTags = new HashSet<String>();
         standardTags = new HashSet<String>();
         standardTagsLowercase = new HashSet<String>();
         unseenCustomTags = new HashSet<String>();
         customTags = new LinkedHashMap<String,Taglet>();
         this.nosince = nosince;
         this.showversion = showversion;
         this.showauthor = showauthor;
         this.javafx = javafx;
         this.message = message;
         initStandardTaglets();
         initStandardTagsLowercase();
     }
     /**
      * Add a new <code>CustomTag</code>.  This is used to add a Taglet from within
      * a Doclet.  No message is printed to indicate that the Taglet is properly
      * registered because these Taglets are typically added for every execution of the
      * Doclet.  We don't want to see this type of error message every time.
      * @param customTag the new <code>CustomTag</code> to add.
      */
     public void addCustomTag(Taglet customTag) {
         if (customTag != null) {
             String name = customTag.getName();
             if (customTags.containsKey(name)) {
                 customTags.remove(name);
             }
             customTags.put(name, customTag);
             checkTagName(name);
         }
     }
     public Set<String> getCustomTagNames() {
         return customTags.keySet();
     }
     /**
      * Add a new <code>Taglet</code>.  Print a message to indicate whether or not
      * the Taglet was registered properly.
      * @param classname  the name of the class representing the custom tag.
      * @param tagletPath  the path to the class representing the custom tag.
      */
     public void addCustomTag(String classname, JavaFileManager fileManager, String tagletPath) {
         try {
             Class<?> customTagClass = null;
             // construct class loader
             String cpString = null;   // make sure env.class.path defaults to dot
             ClassLoader tagClassLoader;
             if (fileManager != null && fileManager.hasLocation(DocumentationTool.Location.TAGLET_PATH)) {
                 tagClassLoader = fileManager.getClassLoader(DocumentationTool.Location.TAGLET_PATH);
             } else {
                 // do prepends to get correct ordering
                 cpString = appendPath(System.getProperty("env.class.path"), cpString);
                 cpString = appendPath(System.getProperty("java.class.path"), cpString);
                 cpString = appendPath(tagletPath, cpString);
                 tagClassLoader = new URLClassLoader(pathToURLs(cpString));
             }
             customTagClass = tagClassLoader.loadClass(classname);
             Method meth = customTagClass.getMethod("register",
                                                    new Class<?>[] {java.util.Map.class});
             Object[] list = customTags.values().toArray();
             Taglet lastTag = (list != null && list.length > 0)
                 ? (Taglet) list[list.length-1] : null;
             meth.invoke(null, new Object[] {customTags});
             list = customTags.values().toArray();
             Object newLastTag = (list != null&& list.length > 0)
                 ? list[list.length-1] : null;
             if (lastTag != newLastTag) {
                 //New taglets must always be added to the end of the LinkedHashMap.
                 //If the current and previous last taglet are not equal, that
                 //means a new Taglet has been added.
                 message.notice("doclet.Notice_taglet_registered", classname);
                 if (newLastTag != null) {
                     checkTaglet(newLastTag);
                 }
             }
         } catch (Exception exc) {
             message.error("doclet.Error_taglet_not_registered", exc.getClass().getName(), classname);
         }
     }
     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;
         }
     }
     /**
      * Utility method for converting a search path string to an array
      * of directory and JAR file URLs.
      *
      * @param path the search path string
      * @return the resulting array of directory and JAR file URLs
      */
     private URL[] pathToURLs(String path) {
         Set<URL> urls = new LinkedHashSet<URL>();
         for (String s: path.split(File.pathSeparator)) {
             if (s.isEmpty()) continue;
             try {
                 urls.add(new File(s).getAbsoluteFile().toURI().toURL());
             } catch (MalformedURLException e) {
                 message.error("doclet.MalformedURL", s);
             }
         }
         return urls.toArray(new URL[urls.size()]);
     }
     /**
      * Add a new <code>SimpleTaglet</code>.  If this tag already exists
      * and the header passed as an argument is null, move tag to the back of the
      * list. If this tag already exists and the header passed as an argument is
      * not null, overwrite previous tag with new one.  Otherwise, add new
      * SimpleTaglet to list.
      * @param tagName the name of this tag
      * @param header the header to output.
      * @param locations the possible locations that this tag
      * can appear in.
      */
     public void addNewSimpleCustomTag(String tagName, String header, String locations) {
         if (tagName == null || locations == null) {
             return;
         }
         Taglet tag = customTags.get(tagName);
         locations = locations.toLowerCase();
         if (tag == null || header != null) {
             customTags.remove(tagName);
             customTags.put(tagName, new SimpleTaglet(tagName, header, locations));
             if (locations != null && locations.indexOf('x') == -1) {
                 checkTagName(tagName);
             }
         } else {
             //Move to back
             customTags.remove(tagName);
             customTags.put(tagName, tag);
         }
     }
     /**
      * Given a tag name, add it to the set of tags it belongs to.
      */
     private void checkTagName(String name) {
         if (standardTags.contains(name)) {
             overridenStandardTags.add(name);
         } else {
             if (name.indexOf('.') == -1) {
                 potentiallyConflictingTags.add(name);
             }
             unseenCustomTags.add(name);
         }
     }
     /**
      * Check the taglet to see if it is a legacy taglet.  Also
      * check its name for errors.
      */
     private void checkTaglet(Object taglet) {
         if (taglet instanceof Taglet) {
             checkTagName(((Taglet) taglet).getName());
         } else if (taglet instanceof com.sun.tools.doclets.Taglet) {
             com.sun.tools.doclets.Taglet legacyTaglet = (com.sun.tools.doclets.Taglet) taglet;
             customTags.remove(legacyTaglet.getName());
             customTags.put(legacyTaglet.getName(), new LegacyTaglet(legacyTaglet));
             checkTagName(legacyTaglet.getName());
         } else {
             throw new IllegalArgumentException("Given object is not a taglet.");
         }
     }
     /**
      * Given a name of a seen custom tag, remove it from the set of unseen
      * custom tags.
      * @param name the name of the seen custom tag.
      */
     public void seenCustomTag(String name) {
         unseenCustomTags.remove(name);
     }
     /**
      * Given an array of <code>Tag</code>s, check for spelling mistakes.
      * @param doc the Doc object that holds the tags.
      * @param tags the list of <code>Tag</code>s to check.
      * @param areInlineTags true if the array of tags are inline and false otherwise.
      */
     public void checkTags(Doc doc, Tag[] tags, boolean areInlineTags) {
         if (tags == null) {
             return;
         }
         Taglet taglet;
         for (int i = 0; i < tags.length; i++) {
             String name = tags[i].name();
             if (name.length() > 0 && name.charAt(0) == '@') {
                 name = name.substring(1, name.length());
             }
             if (! (standardTags.contains(name) || customTags.containsKey(name))) {
                 if (standardTagsLowercase.contains(name.toLowerCase())) {
                     message.warning(tags[i].position(), "doclet.UnknownTagLowercase", tags[i].name());
                     continue;
                 } else {
                     message.warning(tags[i].position(), "doclet.UnknownTag", tags[i].name());
                     continue;
                 }
             }
             //Check if this tag is being used in the wrong location.
             if ((taglet = customTags.get(name)) != null) {
                 if (areInlineTags && ! taglet.isInlineTag()) {
                     printTagMisuseWarn(taglet, tags[i], "inline");
                 }
                 if ((doc instanceof RootDoc) && ! taglet.inOverview()) {
                     printTagMisuseWarn(taglet, tags[i], "overview");
                 } else if ((doc instanceof PackageDoc) && ! taglet.inPackage()) {
                     printTagMisuseWarn(taglet, tags[i], "package");
                 } else if ((doc instanceof ClassDoc) && ! taglet.inType()) {
                     printTagMisuseWarn(taglet, tags[i], "class");
                 } else if ((doc instanceof ConstructorDoc) && ! taglet.inConstructor()) {
                     printTagMisuseWarn(taglet, tags[i], "constructor");
                 } else if ((doc instanceof FieldDoc) && ! taglet.inField()) {
                     printTagMisuseWarn(taglet, tags[i], "field");
                 } else if ((doc instanceof MethodDoc) && ! taglet.inMethod()) {
                     printTagMisuseWarn(taglet, tags[i], "method");
                 }
             }
         }
     }
     /**
      * Given the taglet, the tag and the type of documentation that the tag
      * was found in, print a tag misuse warning.
      * @param taglet the taglet representing the misused tag.
      * @param tag the misused tag.
      * @param holderType the type of documentation that the misused tag was found in.
      */
     private void printTagMisuseWarn(Taglet taglet, Tag tag, String holderType) {
         Set<String> locationsSet = new LinkedHashSet<String>();
         if (taglet.inOverview()) {
             locationsSet.add("overview");
         }
         if (taglet.inPackage()) {
             locationsSet.add("package");
         }
         if (taglet.inType()) {
             locationsSet.add("class/interface");
         }
         if (taglet.inConstructor())  {
             locationsSet.add("constructor");
         }
         if (taglet.inField()) {
             locationsSet.add("field");
         }
         if (taglet.inMethod()) {
             locationsSet.add("method");
         }
         if (taglet.isInlineTag()) {
             locationsSet.add("inline text");
         }
         String[] locations = locationsSet.toArray(new String[]{});
         if (locations == null || locations.length == 0) {
             //This known tag is excluded.
             return;
         }
         StringBuilder combined_locations = new StringBuilder();
         for (int i = 0; i < locations.length; i++) {
             if (i > 0) {
                 combined_locations.append(", ");
             }
             combined_locations.append(locations[i]);
         }
         message.warning(tag.position(), "doclet.tag_misuse",
             "@" + taglet.getName(), holderType, combined_locations.toString());
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in packages.
      * @return the array of <code>Taglet</code>s that can
      * appear in packages.
      */
     public Taglet[] getPackageCustomTaglets() {
         if (packageTags == null) {
             initCustomTagletArrays();
         }
         return packageTags;
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in classes or interfaces.
      * @return the array of <code>Taglet</code>s that can
      * appear in classes or interfaces.
      */
     public Taglet[] getTypeCustomTaglets() {
         if (typeTags == null) {
             initCustomTagletArrays();
         }
         return typeTags;
     }
     /**
      * Return the array of inline <code>Taglet</code>s that can
      * appear in comments.
      * @return the array of <code>Taglet</code>s that can
      * appear in comments.
      */
     public Taglet[] getInlineCustomTaglets() {
         if (inlineTags == null) {
             initCustomTagletArrays();
         }
         return inlineTags;
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in fields.
      * @return the array of <code>Taglet</code>s that can
      * appear in field.
      */
     public Taglet[] getFieldCustomTaglets() {
         if (fieldTags == null) {
             initCustomTagletArrays();
         }
         return fieldTags;
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in the serialized form.
      * @return the array of <code>Taglet</code>s that can
      * appear in the serialized form.
      */
     public Taglet[] getSerializedFormTaglets() {
         if (serializedFormTags == null) {
             initCustomTagletArrays();
         }
         return serializedFormTags;
     }
     /**
      * @return the array of <code>Taglet</code>s that can
      * appear in the given Doc.
      */
     public Taglet[] getCustomTaglets(Doc doc) {
         if (doc instanceof ConstructorDoc) {
             return getConstructorCustomTaglets();
         } else if (doc instanceof MethodDoc) {
             return getMethodCustomTaglets();
         } else if (doc instanceof FieldDoc) {
             return getFieldCustomTaglets();
         } else if (doc instanceof ClassDoc) {
             return getTypeCustomTaglets();
         } else if (doc instanceof PackageDoc) {
             return getPackageCustomTaglets();
         } else if (doc instanceof RootDoc) {
             return getOverviewCustomTaglets();
         }
         return null;
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in constructors.
      * @return the array of <code>Taglet</code>s that can
      * appear in constructors.
      */
     public Taglet[] getConstructorCustomTaglets() {
         if (constructorTags == null) {
             initCustomTagletArrays();
         }
         return constructorTags;
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in methods.
      * @return the array of <code>Taglet</code>s that can
      * appear in methods.
      */
     public Taglet[] getMethodCustomTaglets() {
         if (methodTags == null) {
             initCustomTagletArrays();
         }
         return methodTags;
     }
     /**
      * Return the array of <code>Taglet</code>s that can
      * appear in an overview.
      * @return the array of <code>Taglet</code>s that can
      * appear in overview.
      */
     public Taglet[] getOverviewCustomTaglets() {
         if (overviewTags == null) {
             initCustomTagletArrays();
         }
         return overviewTags;
     }
     /**
      * Initialize the custom tag arrays.
      */
     private void initCustomTagletArrays() {
         Iterator<Taglet> it = customTags.values().iterator();
         ArrayList<Taglet> pTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> tTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> fTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> cTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> mTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> iTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> oTags = new ArrayList<Taglet>(customTags.size());
         ArrayList<Taglet> sTags = new ArrayList<Taglet>();
         Taglet current;
         while (it.hasNext()) {
             current = it.next();
             if (current.inPackage() && !current.isInlineTag()) {
                 pTags.add(current);
             }
             if (current.inType() && !current.isInlineTag()) {
                 tTags.add(current);
             }
             if (current.inField() && !current.isInlineTag()) {
                 fTags.add(current);
             }
             if (current.inConstructor() && !current.isInlineTag()) {
                 cTags.add(current);
             }
             if (current.inMethod() && !current.isInlineTag()) {
                 mTags.add(current);
             }
             if (current.isInlineTag()) {
                 iTags.add(current);
             }
             if (current.inOverview() && !current.isInlineTag()) {
                 oTags.add(current);
             }
         }
         packageTags = pTags.toArray(new Taglet[] {});
         typeTags = tTags.toArray(new Taglet[] {});
         fieldTags = fTags.toArray(new Taglet[] {});
         constructorTags = cTags.toArray(new Taglet[] {});
         methodTags = mTags.toArray(new Taglet[] {});
         overviewTags = oTags.toArray(new Taglet[] {});
         inlineTags = iTags.toArray(new Taglet[] {});
         //Init the serialized form tags
         sTags.add(customTags.get("serialData"));
         sTags.add(customTags.get("throws"));
         if (!nosince)
             sTags.add(customTags.get("since"));
         sTags.add(customTags.get("see"));
         serializedFormTags = sTags.toArray(new Taglet[] {});
     }
     /**
      * Initialize standard Javadoc tags for ordering purposes.
      */
     private void initStandardTaglets() {
         if (javafx) {
             initJavaFXTaglets();
         }
         Taglet temp;
         addStandardTaglet(new ParamTaglet());
         addStandardTaglet(new ReturnTaglet());
         addStandardTaglet(new ThrowsTaglet());
         addStandardTaglet(new SimpleTaglet("exception", null,
                 SimpleTaglet.METHOD + SimpleTaglet.CONSTRUCTOR));
         addStandardTaglet(!nosince, new SimpleTaglet("since", message.getText("doclet.Since"),
                SimpleTaglet.ALL));
         addStandardTaglet(showversion, new SimpleTaglet("version", message.getText("doclet.Version"),
                 SimpleTaglet.PACKAGE + SimpleTaglet.TYPE + SimpleTaglet.OVERVIEW));
         addStandardTaglet(showauthor, new SimpleTaglet("author", message.getText("doclet.Author"),
                 SimpleTaglet.PACKAGE + SimpleTaglet.TYPE + SimpleTaglet.OVERVIEW));
         addStandardTaglet(new SimpleTaglet("serialData", message.getText("doclet.SerialData"),
             SimpleTaglet.EXCLUDED));
         customTags.put((temp = new SimpleTaglet("factory", message.getText("doclet.Factory"),
             SimpleTaglet.METHOD)).getName(), temp);
         addStandardTaglet(new SeeTaglet());
         //Standard inline tags
         addStandardTaglet(new DocRootTaglet());
         addStandardTaglet(new InheritDocTaglet());
         addStandardTaglet(new ValueTaglet());
         addStandardTaglet(new LiteralTaglet());
         addStandardTaglet(new CodeTaglet());
         // Keep track of the names of standard tags for error
         // checking purposes. The following are not handled above.
         // See, for example, com.sun.tools.javadoc.Comment
         standardTags.add("deprecated");
         standardTags.add("link");
         standardTags.add("linkplain");
         standardTags.add("serial");
         standardTags.add("serialField");
         standardTags.add("Text");
     }
     /**
      * Initialize JavaFX-related tags.
      */
     private void initJavaFXTaglets() {
         addStandardTaglet(new PropertyGetterTaglet());
         addStandardTaglet(new PropertySetterTaglet());
         addStandardTaglet(new SimpleTaglet("propertyDescription",
                 message.getText("doclet.PropertyDescription"),
                 SimpleTaglet.FIELD + SimpleTaglet.METHOD));
         addStandardTaglet(new SimpleTaglet("defaultValue", message.getText("doclet.DefaultValue"),
             SimpleTaglet.FIELD + SimpleTaglet.METHOD));
         addStandardTaglet(new SimpleTaglet("treatAsPrivate", null,
                 SimpleTaglet.FIELD + SimpleTaglet.METHOD + SimpleTaglet.TYPE));
     }
     void addStandardTaglet(Taglet taglet) {
         String name = taglet.getName();
         customTags.put(name, taglet);
         standardTags.add(name);
     }
     void addStandardTaglet(boolean enable, Taglet taglet) {
         String name = taglet.getName();
         if (enable)
             customTags.put(name, taglet);
         standardTags.add(name);
     }
     /**
      * Initialize lowercase version of standard Javadoc tags.
      */
     private void initStandardTagsLowercase() {
         Iterator<String> it = standardTags.iterator();
         while (it.hasNext()) {
             standardTagsLowercase.add(it.next().toLowerCase());
         }
     }
     public boolean isKnownCustomTag(String tagName) {
         return customTags.containsKey(tagName);
     }
     /**
      * Print a list of {@link Taglet}s that might conflict with
      * standard tags in the future and a list of standard tags
      * that have been overriden.
      */
     public void printReport() {
         printReportHelper("doclet.Notice_taglet_conflict_warn", potentiallyConflictingTags);
         printReportHelper("doclet.Notice_taglet_overriden", overridenStandardTags);
         printReportHelper("doclet.Notice_taglet_unseen", unseenCustomTags);
     }
     private void printReportHelper(String noticeKey, Set<String> names) {
         if (names.size() > 0) {
             String[] namesArray = names.toArray(new String[] {});
             String result = " ";
             for (int i = 0; i < namesArray.length; i++) {
                 result += "@" + namesArray[i];
                 if (i + 1 < namesArray.length) {
                     result += ", ";
                 }
             }
             message.notice(noticeKey, result);
         }
     }
     /**
      * Given the name of a tag, return the corresponding taglet.
      * Return null if the tag is unknown.
      *
      * @param name the name of the taglet to retrieve.
      * @return return the corresponding taglet. Return null if the tag is
      *         unknown.
      */
     public Taglet getTaglet(String name) {
         if (name.indexOf("@") == 0) {
             return customTags.get(name.substring(1));
         } else {
             return customTags.get(name);
         }
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java@667843bd2193 (annotated)

src/share/classes/com/sun/tools/doclets/internal/toolkit/taglets/TagletManager.java