JDK14/Java14源码在线阅读

#
# Copyright (c) 2012, 2020, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.  Oracle designates this
# particular file as subject to the "Classpath" exception as provided
# by Oracle in the LICENSE file that accompanied this code.
#
# This code is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
# version 2 for more details (a copy is included in the LICENSE file that
# accompanied this code).
#
# You should have received a copy of the GNU General Public License version
# 2 along with this work; if not, write to the Free Software Foundation,
# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
#
# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
# or visit www.oracle.com if you need additional information or have any
# questions.
#

main.usage.summary=\
Usage: {0} <options> <path ...>]\n\
use --help for a list of possible options

main.usage=\
Usage: {0} <options> <path ...>]\n\
<path> can be a pathname to a .class file, a directory, a JAR file.\n\
\n\
Possible options include:

error.prefix=Error:
warn.prefix=Warning:

main.opt.h=\
\  -h -? --help                  Print this help message

main.opt.version=\
\  -version --version            Version information

main.opt.v=\
\  -v       -verbose             Print all class level dependences\n\
\                                Equivalent to -verbose:class -filter:none.\n\
\  -verbose:package              Print package-level dependences excluding\n\
\                                dependences within the same package by default\n\
\  -verbose:class                Print class-level dependences excluding\n\
\                                dependences within the same package by default

main.opt.s=\
\  -s       -summary             Print dependency summary only.

main.opt.f=\
\  -f <regex> -filter <regex>    Filter dependences matching the given\n\
\                                pattern. If given multiple times, the last\n\
\                                one will be used.\n\
\  -filter:package               Filter dependences within the same package.\n\
\                                This is the default.\n\
\  -filter:archive               Filter dependences within the same archive.\n\
\  -filter:module                Filter dependences within the same module.\n\
\  -filter:none                  No -filter:package and -filter:archive\n\
\                                filtering.  Filtering specified via the\n\
\                                -filter option still applies.\n\

main.opt.p=\n\
\Options to filter dependences:\n\
\  -p <pkg>\n\
\  -package <pkg>\n\
\  --package <pkg>               Finds dependences matching the given package\n\
\                                name (may be given multiple times).

main.opt.e=\
\  -e <regex>\n\
\  -regex <regex>\n\
\  --regex <regex>               Finds dependences matching the given pattern.

main.opt.require=\
\  --require <module-name>       Finds dependences matching the given module\n\
\                                name (may be given multiple times). --package,\n\
\                                --regex, --require are mutual exclusive.

main.opt.missing-deps=\
\  --missing-deps                Finds missing dependences.  This option\n\
\                                cannot be used with -p, -e and -s options.

main.opt.ignore-missing-deps=\
\  --ignore-missing-deps         Ignore missing dependences.

main.opt.include=\n\
 \Options to filter classes to be analyzed:\n\
\  -include <regex>              Restrict analysis to classes matching pattern\n\
\                                This option filters the list of classes to\n\
\                                be analyzed.  It can be used together with\n\
\                                -p and -e which apply pattern to the dependences

main.opt.P=\
\  -P       -profile             Show profile containing a package

main.opt.cp=\
\  -cp <path>\n\
\  -classpath <path>\n\
\  --class-path <path>           Specify where to find class files

main.opt.module-path=\
\  --module-path <module path>   Specify module path

main.opt.upgrade-module-path=\
\  --upgrade-module-path <module path>  Specify upgrade module path

main.opt.system=\
\  --system <java-home>          Specify an alternate system module path

main.opt.add-modules=\
\  --add-modules <module-name>[,<module-name>...]\n\
\                                Adds modules to the root set for analysis

main.opt.R=\
\  -R\n\
\  --recursive                   Recursively traverse all run-time dependences.\n\
\                                The -R option implies -filter:none.  If -p,\n\
\                                -e, -f option is specified, only the matching\n\
\                                dependences are analyzed.

main.opt.no-recursive=\
\  --no-recursive                Do not recursively traverse dependences.

main.opt.I=\
\  -I\n\
\  --inverse                     Analyzes the dependences per other given options\n\
\                                and then find all artifacts that directly\n\
\                                and indirectly depend on the matching nodes.\n\
\                                This is equivalent to the inverse of\n\
\                                compile-time view analysis and print\n\
\                                dependency summary.  This option must use\n\
\                                with --require, --package or --regex option.

main.opt.compile-time=\
\  --compile-time                Compile-time view of transitive dependences\n\
\                                i.e. compile-time view of -R option.\n\
\                                Analyzes the dependences per other given options\n\
\                                If a dependence is found from a directory,\n\
\                                a JAR file or a module, all classes in that \n\
\                                containing archive are analyzed.

main.opt.apionly=\
\  -apionly\n\
\  --api-only                    Restrict analysis to APIs i.e. dependences\n\
\                                from the signature of public and protected\n\
\                                members of public classes including field\n\
\                                type, method parameter types, returned type,\n\
\                                checked exception types etc.

main.opt.m=\n\
\Module dependence analysis options:\n\
\  -m <module-name>\n\
\  --module <module-name>        Specify the root module for analysis

main.opt.generate-module-info=\
\  --generate-module-info <dir>  Generate module-info.java under the specified\n\
\                                directory. The specified JAR files will be\n\
\                                analyzed. This option cannot be used with\n\
\                                --dot-output or --class-path. Use \n\
\                                --generate-open-module option for open modules.

main.opt.generate-open-module=\
\  --generate-open-module <dir>  Generate module-info.java for the specified\n\
\                                JAR files under the specified directory as\n\
\                                open modules. This option cannot be used with\n\
\                                --dot-output or --class-path.

main.opt.check=\
\  --check <module-name>[,<module-name>...\n\
\                                Analyze the dependence of the specified modules\n\
\                                It prints the module descriptor, the resulting\n\
\                                module dependences after analysis and the\n\
\                                graph after transition reduction.  It also\n\
\                                identifies any unused qualified exports.

main.opt.dotoutput=\
\  -dotoutput <dir>\n\
\  --dot-output <dir>            Destination directory for DOT file output

main.opt.jdkinternals=\
\  -jdkinternals\n\
\  --jdk-internals               Finds class-level dependences on JDK internal\n\
\                                APIs. By default, it analyzes all classes\n\
\                                on --class-path and input files unless -include\n\
\                                option is specified. This option cannot be\n\
\                                used with -p, -e and -s options.\n\
\                                WARNING: JDK internal APIs are inaccessible.

main.opt.list-deps=\
\  --list-deps                   Lists the module dependences.  It also prints\n\
\                                any internal API packages if referenced.\n\
\                                This option transitively analyzes libraries on\n\
\                                class path and module path if referenced.\n\
\                                Use --no-recursive option for non-transitive\n\
\                                dependency analysis.

main.opt.list-reduced-deps=\
\  --list-reduced-deps           Same as --list-deps with not listing\n\
\                                the implied reads edges from the module graph.\n\
\                                If module M1 reads M2, and M2 requires\n\
\                                transitive on M3, then M1 reading M3 is implied\n\
\                                and is not shown in the graph.

main.opt.print-module-deps=\
\  --print-module-deps           Same as --list-reduced-deps with printing\n\
\                                a comma-separated list of module dependences.\n\
\                                This output can be used by jlink --add-modules\n\
\                                in order to create a custom image containing\n\
\                                those modules and their transitive dependences.

main.opt.depth=\
\  -depth=<depth>                Specify the depth of the transitive\n\
\                                dependency analysis

main.opt.q=\
\  -q       -quiet               Suppress warning messages

main.opt.multi-release=\
\  --multi-release <version>     Specifies the version when processing\n\
\                                multi-release jar files.  <version> should\n\
\                                be integer >= 9 or base.

err.command.set={0} and {1} options are specified.
err.unknown.option=unknown option: {0}
err.missing.arg=no value given for {0}
err.invalid.arg.for.option=invalid argument for option: {0}
err.option.after.class=option must be specified before classes: {0}
err.genmoduleinfo.not.jarfile={0} is a modular JAR file that cannot be specified with the --generate-module-info option
err.genmoduleinfo.unnamed.package={0} contains an unnamed package that is not allowed in a module
err.profiles.msg=No profile information
err.exception.message={0}
err.invalid.path=invalid path: {0}
err.invalid.options={0} cannot be used with {1} option
err.module.not.found=module not found: {0}
err.root.module.not.set=root module set empty
err.option.already.specified={0} option specified more than once.
err.filter.not.specified=--package (-p), --regex (-e), --require option must be specified
err.multirelease.option.exists={0} is not a multi-release jar file but --multi-release option is set

/**代码未完, 请加载全部代码(NowJava.com).**/