JDK 11 jdk.jdeps.jmod - JDeps Tool

JDK 11 jdk.jdeps.jmod is the JMOD file for JDK 11 JDeps tool, which can be invoked by the "jdeps" command.

JDK 11 JDeps tool compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.jdeps.jmod.

JDK 11 JDeps tool compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.

JDK 11 JDeps tool source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.jdeps.

You can click and view the content of each source code file in the list below.

✍: FYIcenter


package com.sun.tools.jdeps.resources;

public final class jdeps extends java.util.ListResourceBundle {
    protected final Object[][] getContents() {
        return new Object[][] {
            { "artifact.not.found", "not found" },
            { "err.command.set", "{0} and {1} options are specified." },
            { "err.exception.message", "{0}" },
            { "err.filter.not.specified", "--package (-p), --regex (-e), --require option must be specified" },
            { "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.invalid.arg.for.option", "invalid argument for option: {0}" },
            { "err.invalid.options", "{0} cannot be used with {1} option" },
            { "err.invalid.path", "invalid path: {0}" },
            { "err.missing.arg", "no value given for {0}" },
            { "err.missing.dependences", "missing dependencies" },
            { "err.module.not.found", "module not found: {0}" },
            { "err.multirelease.jar.malformed", "malformed multi-release jar, {0}, bad entry: {1}" },
            { "err.multirelease.option.exists", "{0} is not a multi-release jar file but --multi-release option is set" },
            { "err.multirelease.option.notfound", "{0} is a multi-release jar file but --multi-release option is not set" },
            { "err.multirelease.version.associated", "class {0} already associated with version {1}, trying to add version {2}" },
            { "err.option.after.class", "option must be specified before classes: {0}" },
            { "err.option.already.specified", "{0} option specified more than once." },
            { "err.profiles.msg", "No profile information" },
            { "err.root.module.not.set", "root module set empty" },
            { "err.unknown.option", "unknown option: {0}" },
            { "error.prefix", "Error:" },
            { "internal.api.column.header", "JDK Internal API" },
            { "inverse.transitive.dependencies.matching", "Inverse transitive dependences matching {0}" },
            { "inverse.transitive.dependencies.on", "Inverse transitive dependences on {0}" },
            { "jdeps.wiki.url", "https://wiki.openjdk.java.net/display/JDK8/Java+Dependency+Analysis+Tool" },
            { "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 --require, --package or --regex option." },
            { "main.opt.P", "  -P       -profile             Show profile containing a package" },
            { "main.opt.R", "  -R       -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.add-modules", "  --add-modules <module-name>[,<module-name>...]\n                                Adds modules to the root set for analysis" },
            { "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.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.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.cp", "  -cp <path>\n  -classpath <path>\n  --class-path <path>           Specify where to find class files" },
            { "main.opt.depth", "  -depth=<depth>                Specify the depth of the transitive\n                                dependency analysis" },
            { "main.opt.dotoutput", "  -dotoutput <dir>\n  --dot-output <dir>            Destination directory for DOT file output" },
            { "main.opt.e", "  -e <regex>\n  -regex <regex>\n  --regex <regex>               Finds dependences matching the given pattern." },
            { "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.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.h", "  -h -? --help                  Print this help message" },
            { "main.opt.include", "\nOptions 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.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 JDK internal API packages if referenced.\n                                This option does not show dependences on the\n                                class path or not found." },
            { "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.m", "\nModule dependence analysis options:\n  -m <module-name>\n  --module <module-name>        Specify the root module for analysis" },
            { "main.opt.module-path", "  --module-path <module path>   Specify module path" },
            { "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." },
            { "main.opt.p", "\nOptions 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.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.q", "  -q       -quiet               Suppress warning messages" },
            { "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.s", "  -s       -summary             Print dependency summary only." },
            { "main.opt.system", "  --system <java-home>          Specify an alternate system module path" },
            { "main.opt.upgrade-module-path", "  --upgrade-module-path <module path>  Specify upgrade module path" },
            { "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.version", "  -version --version            Version information" },
            { "main.usage", "Usage: {0} <options> <path ...>]\n<path> can be a pathname to a .class file, a directory, a JAR file.\n\nPossible options include:" },
            { "main.usage.summary", "Usage: {0} <options> <path ...>]\nuse --help for a list of possible options" },
            { "public.api.replacement.column.header", "Suggested Replacement" },
            { "warn.invalid.arg", "Path does not exist: {0}" },
            { "warn.prefix", "Warning:" },
            { "warn.replace.useJDKInternals", "JDK internal APIs are unsupported and private to JDK implementation that are\nsubject to be removed or changed incompatibly and could break your application.\nPlease modify your code to eliminate dependence on any JDK internal APIs.\nFor the most recent update on JDK internal API replacements, please check:\n{0}" },
            { "warn.skipped.entry", "{0}" },
            { "warn.split.package", "split package: {0} {1}" },



JDK 11 jdk.jdi.jmod - JDI Tool

JDK 11 jdk.jconsole.jmod - JConsole Tool

Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)

2020-07-07, 5247👍, 0💬