main.usage.summary=\
Usage: {0} <options> <path ...>]\n\
use -h, -?, -help, or --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\n\
\  --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.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 dependencies:\n\
\  -p <pkgname> -package <pkgname>   Finds dependences matching the given package\n\
\                                    name (may be given multiple times).

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

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

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.m=\
\  -m <module-name>\n\
\  --module <module-name>            Specify the root module for analysis

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

main.opt.I=\
\  -I           -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 -requires, -package or -regex option.

main.opt.compile-time=\
\  --compile-time                    Compile-time view of transitive dependencies\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                          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.gen-module-info=\
\  --gen-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\
\                                    -dotoutput or -cp.

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>                  Destination directory for DOT file output

main.opt.jdkinternals=\
\  -jdkinternals                     Finds class-level dependences on JDK internal\n\
\                                    APIs. By default, it analyzes all classes\n\
\                                    on -classpath 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.depth=\
\  -depth=<depth>                    Specify the depth of the transitive\n\
\                                    dependency analysis

main.opt.q=\
\  -q           -quiet               Do not show missing dependencies from \n\
\                                    -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 --gen-module-info option (must be non-modular JAR file)
err.profiles.msg=No profile information
err.exception.message={0}
err.invalid.path=invalid path: {0}
err.invalid.module.option=Cannot set {0} with {1} option.
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=root module set empty
err.invalid.inverse.option={0} cannot be used with -inverse option
err.inverse.filter.not.set={0} cannot be used with -inverse option
warn.invalid.arg=Path 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