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.

⏎ com/sun/tools/classfile/Module_attribute.java

/*
 * Copyright (c) 2015, 2016, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package com.sun.tools.classfile;

import java.io.IOException;

import com.sun.tools.classfile.ConstantPool.CONSTANT_Module_info;

/**
 * See Jigsaw.
 *
 *  <p><b>This is NOT part of any supported API.
 *  If you write code that depends on this, you do so at your own risk.
 *  This code and its internal interfaces are subject to change or
 *  deletion without notice.</b>
 */
public class Module_attribute extends Attribute {
    public static final int ACC_TRANSITIVE      =   0x20;
    public static final int ACC_STATIC_PHASE    =   0x40;
    public static final int ACC_OPEN            =   0x20;
    public static final int ACC_SYNTHETIC       = 0x1000;
    public static final int ACC_MANDATED        = 0x8000;

    Module_attribute(ClassReader cr, int name_index, int length) throws IOException {
        super(name_index, length);

        module_name = cr.readUnsignedShort();
        module_flags = cr.readUnsignedShort();

        module_version_index = cr.readUnsignedShort();

        requires_count = cr.readUnsignedShort();
        requires = new RequiresEntry[requires_count];
        for (int i = 0; i < requires_count; i++)
            requires[i] = new RequiresEntry(cr);

        exports_count = cr.readUnsignedShort();
        exports = new ExportsEntry[exports_count];
        for (int i = 0; i < exports_count; i++)
            exports[i] = new ExportsEntry(cr);

        opens_count = cr.readUnsignedShort();
        opens = new OpensEntry[opens_count];
        for (int i = 0; i < opens_count; i++)
            opens[i] = new OpensEntry(cr);

        uses_count = cr.readUnsignedShort();
        uses_index = new int[uses_count];
        for (int i = 0; i < uses_count; i++)
            uses_index[i] = cr.readUnsignedShort();

        provides_count = cr.readUnsignedShort();
        provides = new ProvidesEntry[provides_count];
        for (int i = 0; i < provides_count; i++)
            provides[i] = new ProvidesEntry(cr);
    }

    public Module_attribute(int name_index,
            int module_name,
            int module_flags,
            int module_version_index,
            RequiresEntry[] requires,
            ExportsEntry[] exports,
            OpensEntry[] opens,
            int[] uses,
            ProvidesEntry[] provides) {
        super(name_index, 2);
        this.module_name = module_name;
        this.module_flags = module_flags;
        this.module_version_index = module_version_index;
        requires_count = requires.length;
        this.requires = requires;
        exports_count = exports.length;
        this.exports = exports;
        opens_count = opens.length;
        this.opens = opens;
        uses_count = uses.length;
        this.uses_index = uses;
        provides_count = provides.length;
        this.provides = provides;
    }

    public String getUses(int index, ConstantPool constant_pool) throws ConstantPoolException {
        int i = uses_index[index];
        return constant_pool.getClassInfo(i).getName();
    }

    @Override
    public <R, D> R accept(Visitor<R, D> visitor, D data) {
        return visitor.visitModule(this, data);
    }

    public final int module_name;
    public final int module_flags;
    public final int module_version_index;
    public final int requires_count;
    public final RequiresEntry[] requires;
    public final int exports_count;
    public final ExportsEntry[] exports;
    public final int opens_count;
    public final OpensEntry[] opens;
    public final int uses_count;
    public final int[] uses_index;
    public final int provides_count;
    public final ProvidesEntry[] provides;

    public static class RequiresEntry {
        RequiresEntry(ClassReader cr) throws IOException {
            requires_index = cr.readUnsignedShort();
            requires_flags = cr.readUnsignedShort();
            requires_version_index = cr.readUnsignedShort();
        }

        public RequiresEntry(int index, int flags, int version_index) {
            this.requires_index = index;
            this.requires_flags = flags;
            this.requires_version_index = version_index;
        }

        public String getRequires(ConstantPool constant_pool) throws ConstantPoolException {
            CONSTANT_Module_info info = constant_pool.getModuleInfo(requires_index);
            return info.getName();
        }

        public static final int length = 4;

        public final int requires_index;
        public final int requires_flags;
        public final int requires_version_index;
    }

    public static class ExportsEntry {
        ExportsEntry(ClassReader cr) throws IOException {
            exports_index = cr.readUnsignedShort();
            exports_flags = cr.readUnsignedShort();
            exports_to_count = cr.readUnsignedShort();
            exports_to_index = new int[exports_to_count];
            for (int i = 0; i < exports_to_count; i++)
                exports_to_index[i] = cr.readUnsignedShort();
        }

        public ExportsEntry(int index, int flags, int[] to) {
            this.exports_index = index;
            this.exports_flags = flags;
            this.exports_to_count = to.length;
            this.exports_to_index = to;
        }

        public int length() {
            return 4 + 2 * exports_to_index.length;
        }

        public final int exports_index;
        public final int exports_flags;
        public final int exports_to_count;
        public final int[] exports_to_index;
    }

    public static class OpensEntry {
        OpensEntry(ClassReader cr) throws IOException {
            opens_index = cr.readUnsignedShort();
            opens_flags = cr.readUnsignedShort();
            opens_to_count = cr.readUnsignedShort();
            opens_to_index = new int[opens_to_count];
            for (int i = 0; i < opens_to_count; i++)
                opens_to_index[i] = cr.readUnsignedShort();
        }

        public OpensEntry(int index, int flags, int[] to) {
            this.opens_index = index;
            this.opens_flags = flags;
            this.opens_to_count = to.length;
            this.opens_to_index = to;
        }

        public int length() {
            return 4 + 2 * opens_to_index.length;
        }

        public final int opens_index;
        public final int opens_flags;
        public final int opens_to_count;
        public final int[] opens_to_index;
    }

    public static class ProvidesEntry {
        ProvidesEntry(ClassReader cr) throws IOException {
            provides_index = cr.readUnsignedShort();
            with_count = cr.readUnsignedShort();
            with_index = new int[with_count];
            for (int i = 0; i < with_count; i++)
                with_index[i] = cr.readUnsignedShort();
        }

        public ProvidesEntry(int provides, int[] with) {
            this.provides_index = provides;
            this.with_count = with.length;
            this.with_index = with;
        }

        public static final int length = 4;

        public final int provides_index;
        public final int with_count;
        public final int[] with_index;
    }
}

⏎ com/sun/tools/classfile/Module_attribute.java

Or download all of them as a single archive file:

File name: jdk.jdeps-11.0.1-src.zip
File size: 244145 bytes
Release date: 2018-11-04
Download 

⇒ 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)