langtools/src/jdk.javadoc/share/classes/com/sun/tools/doclets/formats/html/ConfigurationImpl.java
author jlahoda
Mon, 13 Jul 2015 16:33:42 +0200
changeset 31752 a4ea4c9bce2f
parent 31751 ec251536a004
child 33920 bd731341c405
permissions -rw-r--r--
8129909: Add -Xdoclint/package: to javadoc Summary: Adding -Xdoclint/package: command line option, similar to the javac -Xdoclint/package: option, to javadoc. Reviewed-by: darcy, jjg, ksrini
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     1
/*
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
     2
 * Copyright (c) 1998, 2015, Oracle and/or its affiliates. All rights reserved.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
06bc494ca11e Initial load
duke
parents:
diff changeset
     4
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
06bc494ca11e Initial load
duke
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
     7
 * published by the Free Software Foundation.  Oracle designates this
10
06bc494ca11e Initial load
duke
parents:
diff changeset
     8
 * particular file as subject to the "Classpath" exception as provided
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
     9
 * by Oracle in the LICENSE file that accompanied this code.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    10
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    11
 * This code is distributed in the hope that it will be useful, but WITHOUT
06bc494ca11e Initial load
duke
parents:
diff changeset
    12
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
06bc494ca11e Initial load
duke
parents:
diff changeset
    13
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
06bc494ca11e Initial load
duke
parents:
diff changeset
    14
 * version 2 for more details (a copy is included in the LICENSE file that
06bc494ca11e Initial load
duke
parents:
diff changeset
    15
 * accompanied this code).
06bc494ca11e Initial load
duke
parents:
diff changeset
    16
 *
06bc494ca11e Initial load
duke
parents:
diff changeset
    17
 * You should have received a copy of the GNU General Public License version
06bc494ca11e Initial load
duke
parents:
diff changeset
    18
 * 2 along with this work; if not, write to the Free Software Foundation,
06bc494ca11e Initial load
duke
parents:
diff changeset
    19
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
06bc494ca11e Initial load
duke
parents:
diff changeset
    20
 *
5520
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
    21
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
    22
 * or visit www.oracle.com if you need additional information or have any
86e4b9a9da40 6943119: Rebrand source copyright notices
ohair
parents: 2212
diff changeset
    23
 * questions.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    24
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    25
06bc494ca11e Initial load
duke
parents:
diff changeset
    26
package com.sun.tools.doclets.formats.html;
06bc494ca11e Initial load
duke
parents:
diff changeset
    27
14258
8d2148961366 8000663: clean up langtools imports
jjg
parents: 13842
diff changeset
    28
import java.net.*;
8d2148961366 8000663: clean up langtools imports
jjg
parents: 13842
diff changeset
    29
import java.util.*;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    30
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
    31
import javax.tools.JavaFileManager;
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
    32
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    33
import com.sun.javadoc.*;
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
    34
import com.sun.tools.doclets.formats.html.markup.*;
14258
8d2148961366 8000663: clean up langtools imports
jjg
parents: 13842
diff changeset
    35
import com.sun.tools.doclets.internal.toolkit.*;
8d2148961366 8000663: clean up langtools imports
jjg
parents: 13842
diff changeset
    36
import com.sun.tools.doclets.internal.toolkit.util.*;
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
    37
import com.sun.tools.doclint.DocLint;
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
    38
import com.sun.tools.javac.file.JavacFileManager;
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
    39
import com.sun.tools.javac.util.Context;
22153
f9f06fcca59d 8029800: Flags.java uses String.toLowerCase without specifying Locale
jlahoda
parents: 21888
diff changeset
    40
import com.sun.tools.javac.util.StringUtils;
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
    41
import com.sun.tools.javadoc.RootDocImpl;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    42
06bc494ca11e Initial load
duke
parents:
diff changeset
    43
/**
06bc494ca11e Initial load
duke
parents:
diff changeset
    44
 * Configure the output based on the command line options.
06bc494ca11e Initial load
duke
parents:
diff changeset
    45
 * <p>
06bc494ca11e Initial load
duke
parents:
diff changeset
    46
 * Also determine the length of the command line option. For example,
06bc494ca11e Initial load
duke
parents:
diff changeset
    47
 * for a option "-header" there will be a string argument associated, then the
06bc494ca11e Initial load
duke
parents:
diff changeset
    48
 * the length of option "-header" is two. But for option "-nohelp" no argument
06bc494ca11e Initial load
duke
parents:
diff changeset
    49
 * is needed so it's length is 1.
06bc494ca11e Initial load
duke
parents:
diff changeset
    50
 * </p>
06bc494ca11e Initial load
duke
parents:
diff changeset
    51
 * <p>
06bc494ca11e Initial load
duke
parents:
diff changeset
    52
 * Also do the error checking on the options used. For example it is illegal to
06bc494ca11e Initial load
duke
parents:
diff changeset
    53
 * use "-helpfile" option when already "-nohelp" option is used.
06bc494ca11e Initial load
duke
parents:
diff changeset
    54
 * </p>
06bc494ca11e Initial load
duke
parents:
diff changeset
    55
 *
14368
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14357
diff changeset
    56
 *  <p><b>This is NOT part of any supported API.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14357
diff changeset
    57
 *  If you write code that depends on this, you do so at your own risk.
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14357
diff changeset
    58
 *  This code and its internal interfaces are subject to change or
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14357
diff changeset
    59
 *  deletion without notice.</b>
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14357
diff changeset
    60
 *
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    61
 * @author Robert Field.
06bc494ca11e Initial load
duke
parents:
diff changeset
    62
 * @author Atul Dambalkar.
06bc494ca11e Initial load
duke
parents:
diff changeset
    63
 * @author Jamie Ho
9608
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
    64
 * @author Bhavesh Patel (Modified)
10
06bc494ca11e Initial load
duke
parents:
diff changeset
    65
 */
06bc494ca11e Initial load
duke
parents:
diff changeset
    66
public class ConfigurationImpl extends Configuration {
06bc494ca11e Initial load
duke
parents:
diff changeset
    67
06bc494ca11e Initial load
duke
parents:
diff changeset
    68
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    69
     * The build date.  Note: For now, we will use
06bc494ca11e Initial load
duke
parents:
diff changeset
    70
     * a version number instead of a date.
06bc494ca11e Initial load
duke
parents:
diff changeset
    71
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    72
    public static final String BUILD_DATE = System.getProperty("java.version");
06bc494ca11e Initial load
duke
parents:
diff changeset
    73
06bc494ca11e Initial load
duke
parents:
diff changeset
    74
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    75
     * Argument for command line option "-header".
06bc494ca11e Initial load
duke
parents:
diff changeset
    76
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    77
    public String header = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
    78
06bc494ca11e Initial load
duke
parents:
diff changeset
    79
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    80
     * Argument for command line option "-packagesheader".
06bc494ca11e Initial load
duke
parents:
diff changeset
    81
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    82
    public String packagesheader = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
    83
06bc494ca11e Initial load
duke
parents:
diff changeset
    84
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    85
     * Argument for command line option "-footer".
06bc494ca11e Initial load
duke
parents:
diff changeset
    86
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    87
    public String footer = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
    88
06bc494ca11e Initial load
duke
parents:
diff changeset
    89
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    90
     * Argument for command line option "-doctitle".
06bc494ca11e Initial load
duke
parents:
diff changeset
    91
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    92
    public String doctitle = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
    93
06bc494ca11e Initial load
duke
parents:
diff changeset
    94
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
    95
     * Argument for command line option "-windowtitle".
06bc494ca11e Initial load
duke
parents:
diff changeset
    96
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
    97
    public String windowtitle = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
    98
06bc494ca11e Initial load
duke
parents:
diff changeset
    99
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   100
     * Argument for command line option "-top".
06bc494ca11e Initial load
duke
parents:
diff changeset
   101
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   102
    public String top = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   103
06bc494ca11e Initial load
duke
parents:
diff changeset
   104
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   105
     * Argument for command line option "-bottom".
06bc494ca11e Initial load
duke
parents:
diff changeset
   106
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   107
    public String bottom = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   108
06bc494ca11e Initial load
duke
parents:
diff changeset
   109
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   110
     * Argument for command line option "-helpfile".
06bc494ca11e Initial load
duke
parents:
diff changeset
   111
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   112
    public String helpfile = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   113
06bc494ca11e Initial load
duke
parents:
diff changeset
   114
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   115
     * Argument for command line option "-stylesheetfile".
06bc494ca11e Initial load
duke
parents:
diff changeset
   116
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   117
    public String stylesheetfile = "";
06bc494ca11e Initial load
duke
parents:
diff changeset
   118
06bc494ca11e Initial load
duke
parents:
diff changeset
   119
    /**
9608
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   120
     * Argument for command line option "-Xdocrootparent".
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   121
     */
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   122
    public String docrootparent = "";
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   123
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   124
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   125
     * True if command line option "-nohelp" is used. Default value is false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   126
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   127
    public boolean nohelp = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   128
06bc494ca11e Initial load
duke
parents:
diff changeset
   129
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   130
     * True if command line option "-splitindex" is used. Default value is
06bc494ca11e Initial load
duke
parents:
diff changeset
   131
     * false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   132
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   133
    public boolean splitindex = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   134
06bc494ca11e Initial load
duke
parents:
diff changeset
   135
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   136
     * False if command line option "-noindex" is used. Default value is true.
06bc494ca11e Initial load
duke
parents:
diff changeset
   137
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   138
    public boolean createindex = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   139
06bc494ca11e Initial load
duke
parents:
diff changeset
   140
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   141
     * True if command line option "-use" is used. Default value is false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   142
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   143
    public boolean classuse = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   144
06bc494ca11e Initial load
duke
parents:
diff changeset
   145
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   146
     * False if command line option "-notree" is used. Default value is true.
06bc494ca11e Initial load
duke
parents:
diff changeset
   147
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   148
    public boolean createtree = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   149
06bc494ca11e Initial load
duke
parents:
diff changeset
   150
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   151
     * True if command line option "-nodeprecated" is used. Default value is
06bc494ca11e Initial load
duke
parents:
diff changeset
   152
     * false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   153
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   154
    public boolean nodeprecatedlist = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   155
06bc494ca11e Initial load
duke
parents:
diff changeset
   156
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   157
     * True if command line option "-nonavbar" is used. Default value is false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   158
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   159
    public boolean nonavbar = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   160
06bc494ca11e Initial load
duke
parents:
diff changeset
   161
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   162
     * True if command line option "-nooverview" is used. Default value is
06bc494ca11e Initial load
duke
parents:
diff changeset
   163
     * false
06bc494ca11e Initial load
duke
parents:
diff changeset
   164
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   165
    private boolean nooverview = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   166
06bc494ca11e Initial load
duke
parents:
diff changeset
   167
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   168
     * True if command line option "-overview" is used. Default value is false.
06bc494ca11e Initial load
duke
parents:
diff changeset
   169
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   170
    public boolean overview = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   171
06bc494ca11e Initial load
duke
parents:
diff changeset
   172
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   173
     * This is true if option "-overview" is used or option "-overview" is not
06bc494ca11e Initial load
duke
parents:
diff changeset
   174
     * used and number of packages is more than one.
06bc494ca11e Initial load
duke
parents:
diff changeset
   175
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   176
    public boolean createoverview = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   177
06bc494ca11e Initial load
duke
parents:
diff changeset
   178
    /**
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   179
     * This is the HTML version of the generated pages. HTML 4.01 is the default output version.
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   180
     */
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   181
    public HtmlVersion htmlVersion = HtmlVersion.HTML4;
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   182
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   183
    /**
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   184
     * Collected set of doclint options
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   185
     */
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   186
    public Set<String> doclintOpts = new LinkedHashSet<>();
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   187
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   188
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   189
     * Unique Resource Handler for this package.
06bc494ca11e Initial load
duke
parents:
diff changeset
   190
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   191
    public final MessageRetriever standardmessage;
06bc494ca11e Initial load
duke
parents:
diff changeset
   192
06bc494ca11e Initial load
duke
parents:
diff changeset
   193
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   194
     * First file to appear in the right-hand frame in the generated
06bc494ca11e Initial load
duke
parents:
diff changeset
   195
     * documentation.
06bc494ca11e Initial load
duke
parents:
diff changeset
   196
     */
14357
faf9cde2817b 8000741: refactor javadoc to use abstraction to handle relative paths
jjg
parents: 14259
diff changeset
   197
    public DocPath topFile = DocPath.empty;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   198
06bc494ca11e Initial load
duke
parents:
diff changeset
   199
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   200
     * The classdoc for the class file getting generated.
06bc494ca11e Initial load
duke
parents:
diff changeset
   201
     */
14542
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
   202
    public ClassDoc currentcd = null;  // Set this classdoc in the ClassWriter.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   203
06bc494ca11e Initial load
duke
parents:
diff changeset
   204
    /**
14259
fb94a1df0d53 8000208: fix langtools javadoc comment issues
jjg
parents: 14258
diff changeset
   205
     * Constructor. Initializes resource for the
fb94a1df0d53 8000208: fix langtools javadoc comment issues
jjg
parents: 14258
diff changeset
   206
     * {@link com.sun.tools.doclets.internal.toolkit.util.MessageRetriever MessageRetriever}.
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   207
     */
14542
7062120649c2 8000800: javadoc uses static non-final fields
jjg
parents: 14368
diff changeset
   208
    public ConfigurationImpl() {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   209
        standardmessage = new MessageRetriever(this,
06bc494ca11e Initial load
duke
parents:
diff changeset
   210
            "com.sun.tools.doclets.formats.html.resources.standard");
06bc494ca11e Initial load
duke
parents:
diff changeset
   211
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   212
21888
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   213
    private final String versionRBName = "com.sun.tools.javadoc.resources.version";
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   214
    private ResourceBundle versionRB;
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   215
1475
19c0851667ca 6748541: javadoc should be reusable
jjg
parents: 1264
diff changeset
   216
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   217
     * Return the build date for the doclet.
06bc494ca11e Initial load
duke
parents:
diff changeset
   218
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   219
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   220
    public String getDocletSpecificBuildDate() {
21888
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   221
        if (versionRB == null) {
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   222
            try {
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   223
                versionRB = ResourceBundle.getBundle(versionRBName);
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   224
            } catch (MissingResourceException e) {
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   225
                return BUILD_DATE;
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   226
            }
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   227
        }
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   228
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   229
        try {
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   230
            return versionRB.getString("release");
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   231
        } catch (MissingResourceException e) {
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   232
            return BUILD_DATE;
568c5da9f16b 6726154: javadoc generated with incorrect version in comment
kizune
parents: 21500
diff changeset
   233
        }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   234
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   235
06bc494ca11e Initial load
duke
parents:
diff changeset
   236
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   237
     * Depending upon the command line options provided by the user, set
06bc494ca11e Initial load
duke
parents:
diff changeset
   238
     * configure the output generation environment.
06bc494ca11e Initial load
duke
parents:
diff changeset
   239
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   240
     * @param options The array of option names and values.
06bc494ca11e Initial load
duke
parents:
diff changeset
   241
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   242
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   243
    public void setSpecificDocletOptions(String[][] options) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   244
        for (int oi = 0; oi < options.length; ++oi) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   245
            String[] os = options[oi];
22153
f9f06fcca59d 8029800: Flags.java uses String.toLowerCase without specifying Locale
jlahoda
parents: 21888
diff changeset
   246
            String opt = StringUtils.toLowerCase(os[0]);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   247
            if (opt.equals("-footer")) {
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   248
                footer = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   249
            } else if (opt.equals("-header")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   250
                header = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   251
            } else if (opt.equals("-packagesheader")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   252
                packagesheader = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   253
            } else if (opt.equals("-doctitle")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   254
                doctitle = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   255
            } else if (opt.equals("-windowtitle")) {
23968
d67158b385dd 8026736: Enhance Javadoc pages
bpatel
parents: 22163
diff changeset
   256
                windowtitle = os[1].replaceAll("\\<.*?>", "");
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   257
            } else if (opt.equals("-top")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   258
                top = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   259
            } else if (opt.equals("-bottom")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   260
                bottom = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   261
            } else if (opt.equals("-helpfile")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   262
                helpfile = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   263
            } else if (opt.equals("-stylesheetfile")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   264
                stylesheetfile = os[1];
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   265
            } else if (opt.equals("-charset")) {
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   266
                charset = os[1];
9608
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   267
            } else if (opt.equals("-xdocrootparent")) {
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   268
                docrootparent = os[1];
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   269
            } else if (opt.equals("-nohelp")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   270
                nohelp = true;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   271
            } else if (opt.equals("-splitindex")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   272
                splitindex = true;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   273
            } else if (opt.equals("-noindex")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   274
                createindex = false;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   275
            } else if (opt.equals("-use")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   276
                classuse = true;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   277
            } else if (opt.equals("-notree")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   278
                createtree = false;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   279
            } else if (opt.equals("-nodeprecatedlist")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   280
                nodeprecatedlist = true;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   281
            } else if (opt.equals("-nonavbar")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   282
                nonavbar = true;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   283
            } else if (opt.equals("-nooverview")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   284
                nooverview = true;
13842
6908f6badce4 7180906: Javadoc tool does not apply parameter -nosince
bpatel
parents: 9608
diff changeset
   285
            } else if (opt.equals("-overview")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   286
                overview = true;
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   287
            } else if (opt.equals("-html4")) {
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   288
                htmlVersion = HtmlVersion.HTML4;
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   289
            } else if (opt.equals("-html5")) {
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   290
                htmlVersion = HtmlVersion.HTML5;
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   291
            } else if (opt.equals("-xdoclint")) {
31752
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   292
                doclintOpts.add(DocLint.XMSGS_OPTION);
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   293
            } else if (opt.startsWith("-xdoclint:")) {
31752
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   294
                doclintOpts.add(DocLint.XMSGS_CUSTOM_PREFIX + opt.substring(opt.indexOf(":") + 1));
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   295
            } else if (opt.startsWith("-xdoclint/package:")) {
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   296
                doclintOpts.add(DocLint.XCHECK_PACKAGE + opt.substring(opt.indexOf(":") + 1));
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   297
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   298
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   299
        if (root.specifiedClasses().length > 0) {
22163
3651128c74eb 8030244: Update langtools to use Diamond
briangoetz
parents: 22159
diff changeset
   300
            Map<String,PackageDoc> map = new HashMap<>();
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   301
            PackageDoc pd;
06bc494ca11e Initial load
duke
parents:
diff changeset
   302
            ClassDoc[] classes = root.classes();
22159
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   303
            for (ClassDoc aClass : classes) {
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   304
                pd = aClass.containingPackage();
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   305
                if (!map.containsKey(pd.name())) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   306
                    map.put(pd.name(), pd);
06bc494ca11e Initial load
duke
parents:
diff changeset
   307
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   308
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   309
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   310
        setCreateOverview();
06bc494ca11e Initial load
duke
parents:
diff changeset
   311
        setTopFile(root);
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   312
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   313
        if (root instanceof RootDocImpl) {
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   314
            ((RootDocImpl) root).initDocLint(doclintOpts, tagletManager.getCustomTagNames(),
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   315
                    StringUtils.toLowerCase(htmlVersion.name()));
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   316
        }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   317
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   318
06bc494ca11e Initial load
duke
parents:
diff changeset
   319
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   320
     * Returns the "length" of a given option. If an option takes no
06bc494ca11e Initial load
duke
parents:
diff changeset
   321
     * arguments, its length is one. If it takes one argument, it's
06bc494ca11e Initial load
duke
parents:
diff changeset
   322
     * length is two, and so on. This method is called by JavaDoc to
06bc494ca11e Initial load
duke
parents:
diff changeset
   323
     * parse the options it does not recognize. It then calls
06bc494ca11e Initial load
duke
parents:
diff changeset
   324
     * {@link #validOptions(String[][], DocErrorReporter)} to
06bc494ca11e Initial load
duke
parents:
diff changeset
   325
     * validate them.
06bc494ca11e Initial load
duke
parents:
diff changeset
   326
     * <b>Note:</b><br>
06bc494ca11e Initial load
duke
parents:
diff changeset
   327
     * The options arrive as case-sensitive strings. For options that
06bc494ca11e Initial load
duke
parents:
diff changeset
   328
     * are not case-sensitive, use toLowerCase() on the option string
06bc494ca11e Initial load
duke
parents:
diff changeset
   329
     * before comparing it.
06bc494ca11e Initial load
duke
parents:
diff changeset
   330
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   331
     * @return number of arguments + 1 for a option. Zero return means
06bc494ca11e Initial load
duke
parents:
diff changeset
   332
     * option not known.  Negative value means error occurred.
06bc494ca11e Initial load
duke
parents:
diff changeset
   333
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   334
    public int optionLength(String option) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   335
        int result = -1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   336
        if ((result = super.optionLength(option)) > 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   337
            return result;
06bc494ca11e Initial load
duke
parents:
diff changeset
   338
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   339
        // otherwise look for the options we have added
22153
f9f06fcca59d 8029800: Flags.java uses String.toLowerCase without specifying Locale
jlahoda
parents: 21888
diff changeset
   340
        option = StringUtils.toLowerCase(option);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   341
        if (option.equals("-nodeprecatedlist") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   342
            option.equals("-noindex") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   343
            option.equals("-notree") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   344
            option.equals("-nohelp") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   345
            option.equals("-splitindex") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   346
            option.equals("-serialwarn") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   347
            option.equals("-use") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   348
            option.equals("-nonavbar") ||
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   349
            option.equals("-nooverview") ||
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   350
            option.equals("-html4") ||
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   351
            option.equals("-html5") ||
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   352
            option.equals("-xdoclint") ||
31752
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   353
            option.startsWith("-xdoclint:") ||
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   354
            option.startsWith("-xdoclint/package:")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   355
            return 1;
06bc494ca11e Initial load
duke
parents:
diff changeset
   356
        } else if (option.equals("-help")) {
18005
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   357
            // Uugh: first, this should not be hidden inside optionLength,
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   358
            // and second, we should not be writing directly to stdout.
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   359
            // But we have no access to a DocErrorReporter, which would
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   360
            // allow use of reporter.printNotice
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   361
            System.out.println(getText("doclet.usage"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   362
            return 1;
18005
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   363
        } else if (option.equals("-x")) {
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   364
            // Uugh: first, this should not be hidden inside optionLength,
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   365
            // and second, we should not be writing directly to stdout.
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   366
            // But we have no access to a DocErrorReporter, which would
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   367
            // allow use of reporter.printNotice
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   368
            System.out.println(getText("doclet.X.usage"));
598e2e068668 8007687: javadoc -X does not include -Xdoclint
jjg
parents: 17570
diff changeset
   369
            return 1;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   370
        } else if (option.equals("-footer") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   371
                   option.equals("-header") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   372
                   option.equals("-packagesheader") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   373
                   option.equals("-doctitle") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   374
                   option.equals("-windowtitle") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   375
                   option.equals("-top") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   376
                   option.equals("-bottom") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   377
                   option.equals("-helpfile") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   378
                   option.equals("-stylesheetfile") ||
06bc494ca11e Initial load
duke
parents:
diff changeset
   379
                   option.equals("-charset") ||
9608
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   380
                   option.equals("-overview") ||
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   381
                   option.equals("-xdocrootparent")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   382
            return 2;
06bc494ca11e Initial load
duke
parents:
diff changeset
   383
        } else {
06bc494ca11e Initial load
duke
parents:
diff changeset
   384
            return 0;
06bc494ca11e Initial load
duke
parents:
diff changeset
   385
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   386
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   387
06bc494ca11e Initial load
duke
parents:
diff changeset
   388
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   389
     * {@inheritDoc}
06bc494ca11e Initial load
duke
parents:
diff changeset
   390
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   391
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   392
    public boolean validOptions(String options[][],
06bc494ca11e Initial load
duke
parents:
diff changeset
   393
            DocErrorReporter reporter) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   394
        boolean helpfile = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   395
        boolean nohelp = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   396
        boolean overview = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   397
        boolean nooverview = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   398
        boolean splitindex = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   399
        boolean noindex = false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   400
        // check shared options
06bc494ca11e Initial load
duke
parents:
diff changeset
   401
        if (!generalValidOptions(options, reporter)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   402
            return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   403
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   404
        // otherwise look at our options
06bc494ca11e Initial load
duke
parents:
diff changeset
   405
        for (int oi = 0; oi < options.length; ++oi) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   406
            String[] os = options[oi];
22153
f9f06fcca59d 8029800: Flags.java uses String.toLowerCase without specifying Locale
jlahoda
parents: 21888
diff changeset
   407
            String opt = StringUtils.toLowerCase(os[0]);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   408
            if (opt.equals("-helpfile")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   409
                if (nohelp == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   410
                    reporter.printError(getText("doclet.Option_conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
   411
                        "-helpfile", "-nohelp"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   412
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   413
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   414
                if (helpfile == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   415
                    reporter.printError(getText("doclet.Option_reuse",
06bc494ca11e Initial load
duke
parents:
diff changeset
   416
                        "-helpfile"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   417
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   418
                }
14368
6f4c62de6985 8001664: refactor javadoc to use abstraction to handle files
jjg
parents: 14357
diff changeset
   419
                DocFile help = DocFile.createFileForInput(this, os[1]);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   420
                if (!help.exists()) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   421
                    reporter.printError(getText("doclet.File_not_found", os[1]));
06bc494ca11e Initial load
duke
parents:
diff changeset
   422
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   423
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   424
                helpfile = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   425
            } else  if (opt.equals("-nohelp")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   426
                if (helpfile == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   427
                    reporter.printError(getText("doclet.Option_conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
   428
                        "-nohelp", "-helpfile"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   429
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   430
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   431
                nohelp = true;
9608
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   432
            } else if (opt.equals("-xdocrootparent")) {
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   433
                try {
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   434
                    new URL(os[1]);
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   435
                } catch (MalformedURLException e) {
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   436
                    reporter.printError(getText("doclet.MalformedURL", os[1]));
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   437
                    return false;
385a828ba236 6553182: Need to modify javadoc doclet for GPL
bpatel
parents: 5520
diff changeset
   438
                }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   439
            } else if (opt.equals("-overview")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   440
                if (nooverview == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   441
                    reporter.printError(getText("doclet.Option_conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
   442
                        "-overview", "-nooverview"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   443
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   444
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   445
                if (overview == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   446
                    reporter.printError(getText("doclet.Option_reuse",
06bc494ca11e Initial load
duke
parents:
diff changeset
   447
                        "-overview"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   448
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   449
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   450
                overview = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   451
            } else  if (opt.equals("-nooverview")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   452
                if (overview == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   453
                    reporter.printError(getText("doclet.Option_conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
   454
                        "-nooverview", "-overview"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   455
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   456
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   457
                nooverview = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   458
            } else if (opt.equals("-splitindex")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   459
                if (noindex == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   460
                    reporter.printError(getText("doclet.Option_conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
   461
                        "-splitindex", "-noindex"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   462
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   463
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   464
                splitindex = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   465
            } else if (opt.equals("-noindex")) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   466
                if (splitindex == true) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   467
                    reporter.printError(getText("doclet.Option_conflict",
06bc494ca11e Initial load
duke
parents:
diff changeset
   468
                        "-noindex", "-splitindex"));
06bc494ca11e Initial load
duke
parents:
diff changeset
   469
                    return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   470
                }
06bc494ca11e Initial load
duke
parents:
diff changeset
   471
                noindex = true;
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   472
            } else if (opt.startsWith("-xdoclint:")) {
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   473
                if (opt.contains("/")) {
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   474
                    reporter.printError(getText("doclet.Option_doclint_no_qualifiers"));
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   475
                    return false;
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   476
                }
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   477
                if (!DocLint.isValidOption(
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   478
                        opt.replace("-xdoclint:", DocLint.XMSGS_CUSTOM_PREFIX))) {
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   479
                    reporter.printError(getText("doclet.Option_doclint_invalid_arg"));
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   480
                    return false;
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   481
                }
31752
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   482
            } else if (opt.startsWith("-xdoclint/package:")) {
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   483
                if (!DocLint.isValidOption(
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   484
                        opt.replace("-xdoclint/package:", DocLint.XCHECK_PACKAGE))) {
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   485
                    reporter.printError(getText("doclet.Option_doclint_package_invalid_arg"));
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   486
                    return false;
a4ea4c9bce2f 8129909: Add -Xdoclint/package: to javadoc
jlahoda
parents: 31751
diff changeset
   487
                }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   488
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   489
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   490
        return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   491
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   492
06bc494ca11e Initial load
duke
parents:
diff changeset
   493
    /**
29957
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   494
     * Return true if the generated output is HTML5.
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   495
     */
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   496
    public boolean isOutputHtml5() {
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   497
        return htmlVersion == HtmlVersion.HTML5;
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   498
    }
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   499
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   500
    /**
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   501
     * Return true if the tag is allowed for this specific version of HTML.
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   502
     */
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   503
    public boolean allowTag(HtmlTag htmlTag) {
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   504
        return htmlTag.allowTag(this.htmlVersion);
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   505
    }
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   506
7740f9657f56 8072945: Javadoc should generate valid and compliant HTML5 output
bpatel
parents: 25874
diff changeset
   507
    /**
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   508
     * {@inheritDoc}
06bc494ca11e Initial load
duke
parents:
diff changeset
   509
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   510
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   511
    public MessageRetriever getDocletSpecificMsg() {
06bc494ca11e Initial load
duke
parents:
diff changeset
   512
        return standardmessage;
06bc494ca11e Initial load
duke
parents:
diff changeset
   513
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   514
06bc494ca11e Initial load
duke
parents:
diff changeset
   515
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   516
     * Decide the page which will appear first in the right-hand frame. It will
06bc494ca11e Initial load
duke
parents:
diff changeset
   517
     * be "overview-summary.html" if "-overview" option is used or no
06bc494ca11e Initial load
duke
parents:
diff changeset
   518
     * "-overview" but the number of packages is more than one. It will be
06bc494ca11e Initial load
duke
parents:
diff changeset
   519
     * "package-summary.html" of the respective package if there is only one
06bc494ca11e Initial load
duke
parents:
diff changeset
   520
     * package to document. It will be a class page(first in the sorted order),
06bc494ca11e Initial load
duke
parents:
diff changeset
   521
     * if only classes are provided on the command line.
06bc494ca11e Initial load
duke
parents:
diff changeset
   522
     *
06bc494ca11e Initial load
duke
parents:
diff changeset
   523
     * @param root Root of the program structure.
06bc494ca11e Initial load
duke
parents:
diff changeset
   524
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   525
    protected void setTopFile(RootDoc root) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   526
        if (!checkForDeprecation(root)) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   527
            return;
06bc494ca11e Initial load
duke
parents:
diff changeset
   528
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   529
        if (createoverview) {
14357
faf9cde2817b 8000741: refactor javadoc to use abstraction to handle relative paths
jjg
parents: 14259
diff changeset
   530
            topFile = DocPaths.OVERVIEW_SUMMARY;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   531
        } else {
24221
2376793dd33b 8038583: [javadoc] Refactor uses of arrays to Collections
ksrini
parents: 23968
diff changeset
   532
            if (packages.size() == 1 && packages.first().name().equals("")) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   533
                if (root.classes().length > 0) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   534
                    ClassDoc[] classarr = root.classes();
06bc494ca11e Initial load
duke
parents:
diff changeset
   535
                    Arrays.sort(classarr);
06bc494ca11e Initial load
duke
parents:
diff changeset
   536
                    ClassDoc cd = getValidClass(classarr);
14357
faf9cde2817b 8000741: refactor javadoc to use abstraction to handle relative paths
jjg
parents: 14259
diff changeset
   537
                    topFile = DocPath.forClass(cd);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   538
                }
24221
2376793dd33b 8038583: [javadoc] Refactor uses of arrays to Collections
ksrini
parents: 23968
diff changeset
   539
            } else if (!packages.isEmpty()) {
2376793dd33b 8038583: [javadoc] Refactor uses of arrays to Collections
ksrini
parents: 23968
diff changeset
   540
                topFile = DocPath.forPackage(packages.first()).resolve(DocPaths.PACKAGE_SUMMARY);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   541
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   542
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   543
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   544
06bc494ca11e Initial load
duke
parents:
diff changeset
   545
    protected ClassDoc getValidClass(ClassDoc[] classarr) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   546
        if (!nodeprecated) {
06bc494ca11e Initial load
duke
parents:
diff changeset
   547
            return classarr[0];
06bc494ca11e Initial load
duke
parents:
diff changeset
   548
        }
22159
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   549
        for (ClassDoc cd : classarr) {
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   550
            if (cd.tags("deprecated").length == 0) {
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   551
                return cd;
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   552
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   553
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   554
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   555
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   556
06bc494ca11e Initial load
duke
parents:
diff changeset
   557
    protected boolean checkForDeprecation(RootDoc root) {
22159
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   558
        for (ClassDoc cd : root.classes()) {
682da512ec17 8030253: Update langtools to use strings-in-switch
briangoetz
parents: 22153
diff changeset
   559
            if (isGeneratedDoc(cd)) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   560
                return true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   561
            }
06bc494ca11e Initial load
duke
parents:
diff changeset
   562
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   563
        return false;
06bc494ca11e Initial load
duke
parents:
diff changeset
   564
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   565
06bc494ca11e Initial load
duke
parents:
diff changeset
   566
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   567
     * Generate "overview.html" page if option "-overview" is used or number of
06bc494ca11e Initial load
duke
parents:
diff changeset
   568
     * packages is more than one. Sets {@link #createoverview} field to true.
06bc494ca11e Initial load
duke
parents:
diff changeset
   569
     */
06bc494ca11e Initial load
duke
parents:
diff changeset
   570
    protected void setCreateOverview() {
24221
2376793dd33b 8038583: [javadoc] Refactor uses of arrays to Collections
ksrini
parents: 23968
diff changeset
   571
        if ((overview || packages.size() > 1) && !nooverview) {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   572
            createoverview = true;
06bc494ca11e Initial load
duke
parents:
diff changeset
   573
        }
06bc494ca11e Initial load
duke
parents:
diff changeset
   574
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   575
06bc494ca11e Initial load
duke
parents:
diff changeset
   576
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   577
     * {@inheritDoc}
06bc494ca11e Initial load
duke
parents:
diff changeset
   578
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   579
    @Override
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   580
    public WriterFactory getWriterFactory() {
1475
19c0851667ca 6748541: javadoc should be reusable
jjg
parents: 1264
diff changeset
   581
        return new WriterFactoryImpl(this);
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   582
    }
06bc494ca11e Initial load
duke
parents:
diff changeset
   583
06bc494ca11e Initial load
duke
parents:
diff changeset
   584
    /**
06bc494ca11e Initial load
duke
parents:
diff changeset
   585
     * {@inheritDoc}
06bc494ca11e Initial load
duke
parents:
diff changeset
   586
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   587
    @Override
868
d0f233085cbb 6657907: javadoc has unchecked warnings
jjg
parents: 10
diff changeset
   588
    public Comparator<ProgramElementDoc> getMemberComparator() {
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   589
        return null;
06bc494ca11e Initial load
duke
parents:
diff changeset
   590
    }
1863
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   591
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   592
    /**
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   593
     * {@inheritDoc}
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   594
     */
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   595
    @Override
1863
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   596
    public Locale getLocale() {
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   597
        if (root instanceof RootDocImpl)
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   598
            return ((RootDocImpl)root).getLocale();
1863
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   599
        else
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   600
            return Locale.getDefault();
e5de9abc0eb1 6786682: Javadoc HTML WCAG 2.0 accessibility issues in standard doclet - HTML tag should have lang attribute
bpatel
parents: 1475
diff changeset
   601
    }
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   602
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   603
    /**
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   604
     * {@inheritDoc}
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   605
     */
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   606
    @Override
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   607
    public JavaFileManager getFileManager() {
14545
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   608
        if (fileManager == null) {
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   609
            if (root instanceof RootDocImpl)
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   610
                fileManager = ((RootDocImpl) root).getFileManager();
14545
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   611
            else
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   612
                fileManager = new JavacFileManager(new Context(), false, null);
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   613
        }
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   614
        return fileManager;
14544
d71d992cb905 8002079: update DocFile to use a JavaFileManager
jjg
parents: 14542
diff changeset
   615
    }
14545
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   616
2e7bab0639b8 6493690: javadoc should have a javax.tools.Tool service provider installed in tools.jar
jjg
parents: 14544
diff changeset
   617
    private JavaFileManager fileManager;
15354
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   618
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   619
    @Override
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   620
    public boolean showMessage(SourcePosition pos, String key) {
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   621
        if (root instanceof RootDocImpl) {
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   622
            return pos == null || ((RootDocImpl) root).showTagMessages();
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   623
        }
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   624
        return true;
52a04c670c05 8004834: Add doclint support into javadoc
jjg
parents: 14545
diff changeset
   625
    }
17563
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 15354
diff changeset
   626
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 15354
diff changeset
   627
    @Override
17570
78512b2899db 8012183: replace some uses of Configuration.getText with Configuration.getResource
jjg
parents: 17563
diff changeset
   628
    public Content newContent() {
17563
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 15354
diff changeset
   629
        return new ContentBuilder();
e8ddeb9bd17c 8011668: Allow HTMLWriter.getResource to take Content args
jjg
parents: 15354
diff changeset
   630
    }
10
06bc494ca11e Initial load
duke
parents:
diff changeset
   631
}