src/jdk.jdeps/share/classes/com/sun/tools/jdeps/resources/jdeps.properties

main.usage.summary=\
Usage: {0} <options> [-m <module-name> | <classes...>]\n\
use -h, -? or -help for a list of possible options

main.usage=\
Usage: {0} <options> [-m <module-name> | <classes...>]\n\
If -m <module-name> is specified, the specified module will be analyzed\n\
otherwise, <classes> can be a pathname to a .class file, a directory,\n\
a JAR file, or a fully-qualified class name.\n\
\n\
Possible options include:

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

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

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

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

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

main.opt.s=\
\  -s           -summary                Print dependency summary only.\n\
\                                       If -s option is used with -m, the module descriptor of\n\
\                                       the given module will be read to generate the graph.

main.opt.p=\
\  -p <pkgname>                         Finds dependences matching the given package name\n\
\  -package <pkgname>                   (may be given multiple times).

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

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

main.opt.include=\
\  -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.M=\
\  -M                                   Show module containing a package

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

main.opt.mp=\
\  -mp <module path>...\n\
\  -modulepath <module path>...         Specify module path

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

main.opt.m=\
\  -m <module-name>                     Specify the name of the module and its transitive\n\
\                                       dependences to be analyzed.

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

main.opt.ct=\
\  -ct          -compile-time           Compile-time view of transitive dependencies\n\
\                                       i.e. compile-time view of -R option.  If a dependence\n\
\                                       is found from a directory, a JAR file or a module,\n\
\                                       all class files in that containing archive are analyzed.

main.opt.apionly=\
\  -apionly                             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.genmoduleinfo=\
\  -genmoduleinfo <dir>                 Generate module-info.java under the specified directory.\n\
\                                       The specified JAR files will be analyzed.\n\
\                                       This option cannot be used with -dotoutput or -cp.

main.opt.check=\
\  -check                               Analyze the dependence of a given module specified via\n\
\                                       -m option.  It prints out the resulting module dependency\n\
\                                       graph after transition reduction and also identifies any\n\
\                                       unused qualified exports.


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

main.opt.jdkinternals=\
\  -jdkinternals                        Finds class-level dependences on JDK internal APIs.\n\
\                                       By default, it analyzes all classes on -classpath\n\
\                                       and input files unless -include option is specified.\n\
\                                       This option cannot be used with -p, -e and -s options.\n\
\                                       WARNING: JDK internal APIs may not be accessible in\n\
\                                       the next release.

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

main.opt.q=\
\  -q           -quiet                  Do not show missing dependencies from -genmoduleinfo output.

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} not valid for -genmoduleinfo option (must be JAR file)
err.profiles.msg=No profile information
err.exception.message={0}
err.invalid.path=invalid path: {0}
err.invalid.module.option=-m {0} is set but {1} is specified.
err.invalid.filters=Only one of -package (-p), -regex (-e), -requires option can be set
err.module.not.found=module not found: {0}
err.root.module.not.set=-m is not set
warn.invalid.arg=Invalid classname or pathname not exist: {0}
warn.split.package=package {0} defined in {1} {2}
warn.replace.useJDKInternals=\
JDK internal APIs are unsupported and private to JDK implementation that are\n\
subject to be removed or changed incompatibly and could break your application.\n\
Please modify your code to eliminate dependency on any JDK internal APIs.\n\
For the most recent update on JDK internal API replacements, please check:\n\
{0}

artifact.not.found=not found
jdeps.wiki.url=https://wiki.openjdk.java.net/display/JDK8/Java+Dependency+Analysis+Tool