1 /*

     2  * Copyright (c) 1998, 2017, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 

    26 package jdk.javadoc.internal.doclets.formats.html;

    27 

    28 import java.net.*;

    29 import java.util.*;

    30 

    31 import javax.lang.model.element.Element;

    32 import javax.lang.model.element.PackageElement;

    33 import javax.lang.model.element.TypeElement;

    34 import javax.tools.JavaFileManager;

    35 import javax.tools.JavaFileObject;

    36 import javax.tools.StandardJavaFileManager;

    37 

    38 import com.sun.source.util.DocTreePath;

    39 import com.sun.tools.doclint.DocLint;

    40 

    41 import jdk.javadoc.doclet.Doclet;

    42 import jdk.javadoc.doclet.DocletEnvironment;

    43 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlTag;

    44 import jdk.javadoc.internal.doclets.formats.html.markup.HtmlVersion;

    45 import jdk.javadoc.internal.doclets.toolkit.Configuration;

    46 import jdk.javadoc.internal.doclets.toolkit.Content;

    47 import jdk.javadoc.internal.doclets.toolkit.Messages;

    48 import jdk.javadoc.internal.doclets.toolkit.Resources;

    49 import jdk.javadoc.internal.doclets.toolkit.WriterFactory;

    50 import jdk.javadoc.internal.doclets.toolkit.util.DocFile;

    51 import jdk.javadoc.internal.doclets.toolkit.util.DocPath;

    52 import jdk.javadoc.internal.doclets.toolkit.util.DocPaths;

    53 import jdk.javadoc.internal.doclets.toolkit.util.Utils;

    54 

    55 import static javax.tools.Diagnostic.Kind.*;

    56 

    57 /**

    58  * Configure the output based on the command line options.

    59  * <p>

    60  * Also determine the length of the command line option. For example,

    61  * for a option "-header" there will be a string argument associated, then the

    62  * the length of option "-header" is two. But for option "-nohelp" no argument

    63  * is needed so it's length is 1.

    64  * </p>

    65  * <p>

    66  * Also do the error checking on the options used. For example it is illegal to

    67  * use "-helpfile" option when already "-nohelp" option is used.

    68  * </p>

    69  *

    70  *  <p><b>This is NOT part of any supported API.

    71  *  If you write code that depends on this, you do so at your own risk.

    72  *  This code and its internal interfaces are subject to change or

    73  *  deletion without notice.</b>

    74  *

    75  * @author Robert Field.

    76  * @author Atul Dambalkar.

    77  * @author Jamie Ho

    78  * @author Bhavesh Patel (Modified)

    79  */

    80 public class ConfigurationImpl extends Configuration {

    81 

    82     /**

    83      * The build date.  Note: For now, we will use

    84      * a version number instead of a date.

    85      */

    86     public static final String BUILD_DATE = System.getProperty("java.version");

    87 

    88     /**

    89      * Argument for command line option "-header".

    90      */

    91     public String header = "";

    92 

    93     /**

    94      * Argument for command line option "-packagesheader".

    95      */

    96     public String packagesheader = "";

    97 

    98     /**

    99      * Argument for command line option "-footer".

   100      */

   101     public String footer = "";

   102 

   103     /**

   104      * Argument for command line option "-doctitle".

   105      */

   106     public String doctitle = "";

   107 

   108     /**

   109      * Argument for command line option "-windowtitle".

   110      */

   111     public String windowtitle = "";

   112 

   113     /**

   114      * Argument for command line option "-top".

   115      */

   116     public String top = "";

   117 

   118     /**

   119      * Argument for command line option "-bottom".

   120      */

   121     public String bottom = "";

   122 

   123     /**

   124      * Argument for command line option "-helpfile".

   125      */

   126     public String helpfile = "";

   127 

   128     /**

   129      * Argument for command line option "-stylesheetfile".

   130      */

   131     public String stylesheetfile = "";

   132 

   133     /**

   134      * Argument for command line option "-Xdocrootparent".

   135      */

   136     public String docrootparent = "";

   137 

   138     /**

   139      * True if command line option "-nohelp" is used. Default value is false.

   140      */

   141     public boolean nohelp = false;

   142 

   143     /**

   144      * True if command line option "-splitindex" is used. Default value is

   145      * false.

   146      */

   147     public boolean splitindex = false;

   148 

   149     /**

   150      * False if command line option "-noindex" is used. Default value is true.

   151      */

   152     public boolean createindex = true;

   153 

   154     /**

   155      * True if command line option "-use" is used. Default value is false.

   156      */

   157     public boolean classuse = false;

   158 

   159     /**

   160      * False if command line option "-notree" is used. Default value is true.

   161      */

   162     public boolean createtree = true;

   163 

   164     /**

   165      * True if command line option "-nodeprecated" is used. Default value is

   166      * false.

   167      */

   168     public boolean nodeprecatedlist = false;

   169 

   170     /**

   171      * True if command line option "-nonavbar" is used. Default value is false.

   172      */

   173     public boolean nonavbar = false;

   174 

   175     /**

   176      * True if command line option "-nooverview" is used. Default value is

   177      * false

   178      */

   179     private boolean nooverview = false;

   180 

   181     /**

   182      * The overview path specified with "-overview" flag.

   183      */

   184     public String overviewpath = null;

   185 

   186     /**

   187      * This is true if option "-overview" is used or option "-overview" is not

   188      * used and number of packages is more than one.

   189      */

   190     public boolean createoverview = false;

   191 

   192     /**

   193      * Specifies whether or not frames should be generated.

   194      * Defaults to true; can be set by --frames; can be set to false by --no-frames; last one wins.

   195      */

   196     public boolean frames = true;

   197 

   198     /**

   199      * This is the HTML version of the generated pages. HTML 4.01 is the default output version.

   200      */

   201     public HtmlVersion htmlVersion = HtmlVersion.HTML4;

   202 

   203     /**

   204      * Collected set of doclint options

   205      */

   206     public Map<Doclet.Option, String> doclintOpts = new LinkedHashMap<>();

   207 

   208     public final Resources resources;

   209 

   210     /**

   211      * First file to appear in the right-hand frame in the generated

   212      * documentation.

   213      */

   214     public DocPath topFile = DocPath.empty;

   215 

   216     /**

   217      * The TypeElement for the class file getting generated.

   218      */

   219     public TypeElement currentTypeElement = null;  // Set this TypeElement in the ClassWriter.

   220 

   221     protected List<SearchIndexItem> memberSearchIndex = new ArrayList<>();

   222 

   223     protected List<SearchIndexItem> moduleSearchIndex = new ArrayList<>();

   224 

   225     protected List<SearchIndexItem> packageSearchIndex = new ArrayList<>();

   226 

   227     protected List<SearchIndexItem> tagSearchIndex = new ArrayList<>();

   228 

   229     protected List<SearchIndexItem> typeSearchIndex = new ArrayList<>();

   230 

   231     protected Map<Character,List<SearchIndexItem>> tagSearchIndexMap = new HashMap<>();

   232 

   233     protected Set<Character> tagSearchIndexKeys;

   234 

   235     protected Contents contents;

   236 

   237     protected Messages messages;

   238 

   239     /**

   240      * Constructor. Initializes resource for the

   241      * {@link com.sun.tools.doclets.internal.toolkit.util.MessageRetriever MessageRetriever}.

   242      */

   243     public ConfigurationImpl(Doclet doclet) {

   244         super(doclet);

   245         resources = new Resources(this,

   246                 Configuration.sharedResourceBundleName,

   247                 "jdk.javadoc.internal.doclets.formats.html.resources.standard");

   248 

   249         messages = new Messages(this);

   250         contents = new Contents(this);

   251     }

   252 

   253     private final String versionRBName = "jdk.javadoc.internal.tool.resources.version";

   254     private ResourceBundle versionRB;

   255 

   256     /**

   257      * Return the build date for the doclet.

   258      * @return the build date

   259      */

   260     @Override

   261     public String getDocletSpecificBuildDate() {

   262         if (versionRB == null) {

   263             try {

   264                 versionRB = ResourceBundle.getBundle(versionRBName, getLocale());

   265             } catch (MissingResourceException e) {

   266                 return BUILD_DATE;

   267             }

   268         }

   269 

   270         try {

   271             return versionRB.getString("release");

   272         } catch (MissingResourceException e) {

   273             return BUILD_DATE;

   274         }

   275     }

   276 

   277     @Override

   278     public Resources getResources() {

   279         return resources;

   280     }

   281 

   282     @Override

   283     public Messages getMessages() {

   284         return messages;

   285     }

   286 

   287     protected boolean validateOptions() {

   288         // check shared options

   289         if (!generalValidOptions()) {

   290             return false;

   291         }

   292         // check if helpfile exists

   293         if (!helpfile.isEmpty()) {

   294             DocFile help = DocFile.createFileForInput(this, helpfile);

   295             if (!help.exists()) {

   296                 reporter.print(ERROR, getText("doclet.File_not_found", helpfile));

   297                 return false;

   298             }

   299         }

   300 

   301         // In a more object-oriented world, this would be done by methods on the Option objects.

   302         // Note that -windowtitle silently removes any and all HTML elements, and so does not need

   303         // to be handled here.

   304         utils.checkJavaScriptInOption("-header", header);

   305         utils.checkJavaScriptInOption("-footer", footer);

   306         utils.checkJavaScriptInOption("-top", top);

   307         utils.checkJavaScriptInOption("-bottom", bottom);

   308         utils.checkJavaScriptInOption("-doctitle", doctitle);

   309         utils.checkJavaScriptInOption("-packagesheader", packagesheader);

   310 

   311         return true;

   312     }

   313 

   314 

   315     @Override

   316     public boolean finishOptionSettings() {

   317         if (!validateOptions()) {

   318             return false;

   319         }

   320         if (!getSpecifiedTypeElements().isEmpty()) {

   321             Map<String, PackageElement> map = new HashMap<>();

   322             PackageElement pkg;

   323             for (TypeElement aClass : getIncludedTypeElements()) {

   324                 pkg = utils.containingPackage(aClass);

   325                 if (!map.containsKey(utils.getPackageName(pkg))) {

   326                     map.put(utils.getPackageName(pkg), pkg);

   327                 }

   328             }

   329         }

   330         setCreateOverview();

   331         setTopFile(docEnv);

   332         workArounds.initDocLint(doclintOpts.values(), tagletManager.getCustomTagNames(),

   333                 Utils.toLowerCase(htmlVersion.name()));

   334         return true;

   335     }

   336 

   337     /**

   338      * Return true if the generated output is HTML5.

   339      */

   340     public boolean isOutputHtml5() {

   341         return htmlVersion == HtmlVersion.HTML5;

   342     }

   343 

   344     /**

   345      * Return true if the tag is allowed for this specific version of HTML.

   346      */

   347     public boolean allowTag(HtmlTag htmlTag) {

   348         return htmlTag.allowTag(this.htmlVersion);

   349     }

   350 

   351     /**

   352      * Decide the page which will appear first in the right-hand frame. It will

   353      * be "overview-summary.html" if "-overview" option is used or no

   354      * "-overview" but the number of packages is more than one. It will be

   355      * "package-summary.html" of the respective package if there is only one

   356      * package to document. It will be a class page(first in the sorted order),

   357      * if only classes are provided on the command line.

   358      *

   359      * @param docEnv the doclet environment

   360      */

   361     protected void setTopFile(DocletEnvironment docEnv) {

   362         if (!checkForDeprecation(docEnv)) {

   363             return;

   364         }

   365         if (createoverview) {

   366             topFile = DocPaths.overviewSummary(frames);

   367         } else {

   368             if (showModules) {

   369                 topFile = DocPath.empty.resolve(DocPaths.moduleSummary(modules.first()));

   370             } else if (packages.size() == 1 && packages.first().isUnnamed()) {

   371                 List<TypeElement> classes = new ArrayList<>(getIncludedTypeElements());

   372                 if (!classes.isEmpty()) {

   373                     TypeElement te = getValidClass(classes);

   374                     topFile = DocPath.forClass(utils, te);

   375                 }

   376             } else if (!packages.isEmpty()) {

   377                 topFile = DocPath.forPackage(packages.first()).resolve(DocPaths.PACKAGE_SUMMARY);

   378             }

   379         }

   380     }

   381 

   382     protected TypeElement getValidClass(List<TypeElement> classes) {

   383         if (!nodeprecated) {

   384             return classes.get(0);

   385         }

   386         for (TypeElement te : classes) {

   387             if (!utils.isDeprecated(te)) {

   388                 return te;

   389             }

   390         }

   391         return null;

   392     }

   393 

   394     protected boolean checkForDeprecation(DocletEnvironment docEnv) {

   395         for (TypeElement te : getIncludedTypeElements()) {

   396             if (isGeneratedDoc(te)) {

   397                 return true;

   398             }

   399         }

   400         return false;

   401     }

   402 

   403     /**

   404      * Generate "overview.html" page if option "-overview" is used or number of

   405      * packages is more than one. Sets {@link #createoverview} field to true.

   406      */

   407     protected void setCreateOverview() {

   408         if ((overviewpath != null || packages.size() > 1) && !nooverview) {

   409             createoverview = true;

   410         }

   411     }

   412 

   413     /**

   414      * {@inheritDoc}

   415      */

   416     @Override

   417     public WriterFactory getWriterFactory() {

   418         return new WriterFactoryImpl(this);

   419     }

   420 

   421     /**

   422      * {@inheritDoc}

   423      */

   424     @Override

   425     public Locale getLocale() {

   426         if (locale == null)

   427             return Locale.getDefault();

   428         return locale;

   429     }

   430 

   431     /**

   432      * Return the path of the overview file or null if it does not exist.

   433      *

   434      * @return the path of the overview file or null if it does not exist.

   435      */

   436     @Override

   437     public JavaFileObject getOverviewPath() {

   438         if (overviewpath != null && getFileManager() instanceof StandardJavaFileManager) {

   439             StandardJavaFileManager fm = (StandardJavaFileManager) getFileManager();

   440             return fm.getJavaFileObjects(overviewpath).iterator().next();

   441         }

   442         return null;

   443     }

   444 

   445     /**

   446      * {@inheritDoc}

   447      */

   448     @Override

   449     public JavaFileManager getFileManager() {

   450         return docEnv.getJavaFileManager();

   451     }

   452 

   453     @Override

   454     public boolean showMessage(DocTreePath path, String key) {

   455         return (path == null || workArounds.haveDocLint());

   456     }

   457 

   458     @Override

   459     public boolean showMessage(Element e, String key) {

   460         return (e == null || workArounds.haveDocLint());

   461     }

   462 

   463     @Override

   464     public String getText(String key) {

   465         return resources.getText(key);

   466     }

   467 

   468     @Override

   469     public String getText(String key, String... args) {

   470         return resources.getText(key, (Object[]) args);

   471     }

   472 

   473    /**

   474      * {@inheritdoc}

   475      */

   476     @Override

   477     public Content getContent(String key) {

   478         return contents.getContent(key);

   479     }

   480 

   481     /**

   482      * Get the configuration string as a content.

   483      *

   484      * @param key the key to look for in the configuration file

   485      * @param o   string or content argument added to configuration text

   486      * @return a content tree for the text

   487      */

   488     @Override

   489     public Content getContent(String key, Object o) {

   490         return contents.getContent(key, o);

   491     }

   492 

   493     /**

   494      * Get the configuration string as a content.

   495      *

   496      * @param key the key to look for in the configuration file

   497      * @param o1 resource argument

   498      * @param o2 resource argument

   499      * @return a content tree for the text

   500      */

   501     @Override

   502     public Content getContent(String key, Object o1, Object o2) {

   503         return contents.getContent(key, o1, o2);

   504     }

   505 

   506     /**

   507      * Get the configuration string as a content.

   508      *

   509      * @param key the key to look for in the configuration file

   510      * @param o0  string or content argument added to configuration text

   511      * @param o1  string or content argument added to configuration text

   512      * @param o2  string or content argument added to configuration text

   513      * @return a content tree for the text

   514      */

   515     @Override

   516     public Content getContent(String key, Object o0, Object o1, Object o2) {

   517         return contents.getContent(key, o0, o1, o2);

   518     }

   519 

   520     protected void buildSearchTagIndex() {

   521         for (SearchIndexItem sii : tagSearchIndex) {

   522             String tagLabel = sii.getLabel();

   523             Character unicode = (tagLabel.length() == 0)

   524                     ? '*'

   525                     : Character.toUpperCase(tagLabel.charAt(0));

   526             List<SearchIndexItem> list = tagSearchIndexMap.get(unicode);

   527             if (list == null) {

   528                 list = new ArrayList<>();

   529                 tagSearchIndexMap.put(unicode, list);

   530             }

   531             list.add(sii);

   532         }

   533         tagSearchIndexKeys = tagSearchIndexMap.keySet();

   534     }

   535 

   536     @Override

   537     public Set<Doclet.Option> getSupportedOptions() {

   538         Resources resources = getResources();

   539         Doclet.Option[] options = {

   540             new Option(resources, "-bottom", 1) {

   541                 @Override

   542                 public boolean process(String opt,  List<String> args) {

   543                     bottom = args.get(0);

   544                     return true;

   545                 }

   546             },

   547             new Option(resources, "-charset", 1) {

   548                 @Override

   549                 public boolean process(String opt,  List<String> args) {

   550                     charset = args.get(0);

   551                     return true;

   552                 }

   553             },

   554             new Option(resources, "-doctitle", 1) {

   555                 @Override

   556                 public boolean process(String opt,  List<String> args) {

   557                     doctitle = args.get(0);

   558                     return true;

   559                 }

   560             },

   561             new Option(resources, "-footer", 1) {

   562                 @Override

   563                 public boolean process(String opt, List<String> args) {

   564                     footer = args.get(0);

   565                     return true;

   566                 }

   567             },

   568             new Option(resources, "-header", 1) {

   569                 @Override

   570                 public boolean process(String opt,  List<String> args) {

   571                     header = args.get(0);

   572                     return true;

   573                 }

   574             },

   575             new Option(resources, "-helpfile", 1) {

   576                 @Override

   577                 public boolean process(String opt,  List<String> args) {

   578                     if (nohelp == true) {

   579                         reporter.print(ERROR, getText("doclet.Option_conflict",

   580                                 "-helpfile", "-nohelp"));

   581                         return false;

   582                     }

   583                     if (!helpfile.isEmpty()) {

   584                         reporter.print(ERROR, getText("doclet.Option_reuse",

   585                                 "-helpfile"));

   586                         return false;

   587                     }

   588                     helpfile = args.get(0);

   589                     return true;

   590                 }

   591             },

   592             new Option(resources, "-html4") {

   593                 @Override

   594                 public boolean process(String opt,  List<String> args) {

   595                     htmlVersion = HtmlVersion.HTML4;

   596                     return true;

   597                 }

   598             },

   599             new Option(resources, "-html5") {

   600                 @Override

   601                 public boolean process(String opt,  List<String> args) {

   602                     htmlVersion = HtmlVersion.HTML5;

   603                     return true;

   604                 }

   605             },

   606             new Option(resources, "-nohelp") {

   607                 @Override

   608                 public boolean process(String opt, List<String> args) {

   609                     nohelp = true;

   610                     if (!helpfile.isEmpty()) {

   611                         reporter.print(ERROR, getText("doclet.Option_conflict",

   612                                 "-nohelp", "-helpfile"));

   613                         return false;

   614                     }

   615                     return true;

   616                 }

   617             },

   618             new Option(resources, "-nodeprecatedlist") {

   619                 @Override

   620                 public boolean process(String opt,  List<String> args) {

   621                     nodeprecatedlist = true;

   622                     return true;

   623                 }

   624             },

   625             new Option(resources, "-noindex") {

   626                 @Override

   627                 public boolean process(String opt,  List<String> args) {

   628                     createindex = false;

   629                     if (splitindex == true) {

   630                         reporter.print(ERROR, getText("doclet.Option_conflict",

   631                                 "-noindex", "-splitindex"));

   632                         return false;

   633                     }

   634                     return true;

   635                 }

   636             },

   637             new Option(resources, "-nonavbar") {

   638                 @Override

   639                 public boolean process(String opt,  List<String> args) {

   640                     nonavbar = true;

   641                     return true;

   642                 }

   643             },

   644             new Hidden(resources, "-nooverview") {

   645                 @Override

   646                 public boolean process(String opt,  List<String> args) {

   647                     nooverview = true;

   648                     if (overviewpath != null) {

   649                         reporter.print(ERROR, getText("doclet.Option_conflict",

   650                                 "-nooverview", "-overview"));

   651                         return false;

   652                     }

   653                     return true;

   654                 }

   655             },

   656             new Option(resources, "-notree") {

   657                 @Override

   658                 public boolean process(String opt,  List<String> args) {

   659                     createtree = false;

   660                     return true;

   661                 }

   662             },

   663             new Option(resources, "-overview", 1) {

   664                 @Override

   665                 public boolean process(String opt,  List<String> args) {

   666                     overviewpath = args.get(0);

   667                     if (nooverview == true) {

   668                         reporter.print(ERROR, getText("doclet.Option_conflict",

   669                                 "-overview", "-nooverview"));

   670                         return false;

   671                     }

   672                     return true;

   673                 }

   674             },

   675             new Option(resources, "--frames") {

   676                 @Override

   677                 public boolean process(String opt,  List<String> args) {

   678                     frames = true;

   679                     return true;

   680                 }

   681             },

   682             new Option(resources, "--no-frames") {

   683                 @Override

   684                 public boolean process(String opt,  List<String> args) {

   685                     frames = false;

   686                     return true;

   687                 }

   688             },

   689             new Hidden(resources, "-packagesheader", 1) {

   690                 @Override

   691                 public boolean process(String opt,  List<String> args) {

   692                     packagesheader = args.get(0);

   693                     return true;

   694                 }

   695             },

   696             new Option(resources, "-splitindex") {

   697                 @Override

   698                 public boolean process(String opt, List<String> args) {

   699                     splitindex = true;

   700                     if (createindex == false) {

   701                         reporter.print(ERROR, getText("doclet.Option_conflict",

   702                                 "-splitindex", "-noindex"));

   703                         return false;

   704                     }

   705                     return true;

   706                 }

   707             },

   708             new Option(resources, "-stylesheetfile", 1) {

   709                 @Override

   710                 public boolean process(String opt,  List<String> args) {

   711                     stylesheetfile = args.get(0);

   712                     return true;

   713                 }

   714             },

   715             new Option(resources, "-top", 1) {

   716                 @Override

   717                 public boolean process(String opt,  List<String> args) {

   718                     top = args.get(0);

   719                     return true;

   720                 }

   721             },

   722             new Option(resources, "-use") {

   723                 @Override

   724                 public boolean process(String opt,  List<String> args) {

   725                     classuse = true;

   726                     return true;

   727                 }

   728             },

   729             new Option(resources, "-windowtitle", 1) {

   730                 @Override

   731                 public boolean process(String opt,  List<String> args) {

   732                     windowtitle = args.get(0).replaceAll("\\<.*?>", "");

   733                     return true;

   734                 }

   735             },

   736             new XOption(resources, "-Xdoclint") {

   737                 @Override

   738                 public boolean process(String opt,  List<String> args) {

   739                     doclintOpts.put(this, DocLint.XMSGS_OPTION);

   740                     return true;

   741                 }

   742             },

   743             new XOption(resources, "-Xdocrootparent", 1) {

   744                 @Override

   745                 public boolean process(String opt, List<String> args) {

   746                     docrootparent = args.get(0);

   747                     try {

   748                         URL ignored = new URL(docrootparent);

   749                     } catch (MalformedURLException e) {

   750                         reporter.print(ERROR, getText("doclet.MalformedURL", docrootparent));

   751                         return false;

   752                     }

   753                     return true;

   754                 }

   755             },

   756             new XOption(resources, "doclet.usage.xdoclint-extended", "-Xdoclint:", 0) {

   757                 @Override

   758                 public boolean process(String opt,  List<String> args) {

   759                     String dopt = opt.replace("-Xdoclint:", DocLint.XMSGS_CUSTOM_PREFIX);

   760                     doclintOpts.put(this, dopt);

   761                     if (dopt.contains("/")) {

   762                         reporter.print(ERROR, getText("doclet.Option_doclint_no_qualifiers"));

   763                         return false;

   764                     }

   765                     if (!DocLint.isValidOption(dopt)) {

   766                         reporter.print(ERROR, getText("doclet.Option_doclint_invalid_arg"));

   767                         return false;

   768                     }

   769                     return true;

   770                 }

   771             },

   772             new XOption(resources, "doclet.usage.xdoclint-package", "-Xdoclint/package:", 0) {

   773                 @Override

   774                 public boolean process(String opt,  List<String> args) {

   775                     String dopt = opt.replace("-Xdoclint/package:", DocLint.XCHECK_PACKAGE);

   776                     doclintOpts.put(this, dopt);

   777                     if (!DocLint.isValidOption(dopt)) {

   778                         reporter.print(ERROR, getText("doclet.Option_doclint_package_invalid_arg"));

   779                         return false;

   780                     }

   781                     return true;

   782                 }

   783             }

   784         };

   785         Set<Doclet.Option> oset = new TreeSet<>();

   786         oset.addAll(Arrays.asList(options));

   787         oset.addAll(super.getSupportedOptions());

   788         return oset;

   789     }

   790 }