JDK 11 jdk.compiler.jmod - Compiler Tool

JDK 11 jdk.compiler.jmod is the JMOD file for JDK 11 Compiler tool, which can be invoked by the "javac" command.

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

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

JDK 11 Compiler source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.compiler.

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

✍: FYIcenter

com/sun/tools/javac/main/DelegatingJavaFileManager.java

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

package com.sun.tools.javac.main;

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.Collection;
import java.util.Iterator;
import java.util.ServiceLoader;
import java.util.Set;

import javax.tools.FileObject;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileManager.Location;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import javax.tools.StandardJavaFileManager;

import com.sun.tools.javac.util.Context;

/**
 * A JavaFileManager that delegates to one of two delegate ClassLoaders.
 */
public class DelegatingJavaFileManager implements JavaFileManager {

    public static void installReleaseFileManager(Context context,
                                                 JavaFileManager releaseFM,
                                                 JavaFileManager originalFM) {
        context.put(JavaFileManager.class, (JavaFileManager) null);
        JavaFileManager nue = originalFM instanceof StandardJavaFileManager
                ? new DelegatingSJFM(releaseFM,
                                                        (StandardJavaFileManager) originalFM)
                : new DelegatingJavaFileManager(releaseFM, originalFM);
        context.put(JavaFileManager.class, nue);
    }

    private final JavaFileManager releaseFM;
    private final JavaFileManager baseFM;

    private DelegatingJavaFileManager(JavaFileManager releaseFM, JavaFileManager baseFM) {
        this.releaseFM = releaseFM;
        this.baseFM = baseFM;
    }

    private JavaFileManager delegate(Location location) {
        if (releaseFM.hasLocation(location)) {
            return releaseFM;
        }
        return baseFM;
    }

    @Override
    public ClassLoader getClassLoader(Location location) {
        return delegate(location).getClassLoader(location);
    }

    @Override
    public Iterable<JavaFileObject> list(Location location, String packageName,
                                         Set<Kind> kinds, boolean recurse) throws IOException {
        return delegate(location).list(location, packageName, kinds, recurse);
    }

    @Override
    public String inferBinaryName(Location location, JavaFileObject file) {
        return delegate(location).inferBinaryName(location, file);
    }

    @Override
    public boolean isSameFile(FileObject a, FileObject b) {
        return baseFM.isSameFile(a, b);
    }

    @Override
    public boolean handleOption(String current, Iterator<String> remaining) {
        return baseFM.handleOption(current, remaining);
    }

    @Override
    public boolean hasLocation(Location location) {
        return releaseFM.hasLocation(location) || baseFM.hasLocation(location);
    }

    @Override
    public JavaFileObject getJavaFileForInput(Location location, String className,
                                              Kind kind) throws IOException {
        return delegate(location).getJavaFileForInput(location, className, kind);
    }

    @Override
    public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind,
                                               FileObject sibling) throws IOException {
        return delegate(location).getJavaFileForOutput(location, className, kind, sibling);
    }

    @Override
    public FileObject getFileForInput(Location location, String packageName,
                                      String relativeName) throws IOException {
        return delegate(location).getFileForInput(location, packageName, relativeName);
    }

    @Override
    public FileObject getFileForOutput(Location location, String packageName, String relativeName,
                                       FileObject sibling) throws IOException {
        return delegate(location).getFileForOutput(location, packageName, relativeName, sibling);
    }

    @Override
    public void flush() throws IOException {
        releaseFM.flush();
        baseFM.flush();
    }

    @Override
    public void close() throws IOException {
        releaseFM.close();
        baseFM.close();
    }

    @Override
    public Location getLocationForModule(Location location,
                                         String moduleName) throws IOException {
        return delegate(location).getLocationForModule(location, moduleName);
    }

    @Override
    public Location getLocationForModule(Location location,
                                         JavaFileObject fo) throws IOException {
        return delegate(location).getLocationForModule(location, fo);
    }

    @Override
    public <S> ServiceLoader<S> getServiceLoader(Location location,
                                                 Class<S> service) throws IOException {
        return delegate(location).getServiceLoader(location, service);
    }

    @Override
    public String inferModuleName(Location location) throws IOException {
        return delegate(location).inferModuleName(location);
    }

    @Override
    public Iterable<Set<Location>> listLocationsForModules(Location location) throws IOException {
        return delegate(location).listLocationsForModules(location);
    }

    @Override
    public boolean contains(Location location, FileObject fo) throws IOException {
        return delegate(location).contains(location, fo);
    }

    @Override
    public int isSupportedOption(String option) {
        return baseFM.isSupportedOption(option);
    }

    public JavaFileManager getBaseFileManager() {
        return baseFM;
    }

    private static final class DelegatingSJFM extends DelegatingJavaFileManager
                                              implements StandardJavaFileManager {

        private final StandardJavaFileManager baseSJFM;

        private DelegatingSJFM(JavaFileManager releaseFM,
                                                  StandardJavaFileManager baseSJFM) {
            super(releaseFM, baseSJFM);
            this.baseSJFM = baseSJFM;
        }

        @Override
        public boolean isSameFile(FileObject a, FileObject b) {
            return baseSJFM.isSameFile(a, b);
        }

        @Override
        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles
                                                  (Iterable<? extends File> files) {
            return baseSJFM.getJavaFileObjectsFromFiles(files);
        }

        @Override
        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromPaths
                                                  (Iterable<? extends Path> paths) {
            return baseSJFM.getJavaFileObjectsFromPaths(paths);
        }

        @Override
        public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
            return baseSJFM.getJavaFileObjects(files);
        }

        @Override
        public Iterable<? extends JavaFileObject> getJavaFileObjects(Path... paths) {
            return baseSJFM.getJavaFileObjects(paths);
        }

        @Override
        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings
                                                  (Iterable<String> names) {
            return baseSJFM.getJavaFileObjectsFromStrings(names);
        }

        @Override
        public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
            return baseSJFM.getJavaFileObjects(names);
        }

        @Override
        public void setLocation(Location location,
                                Iterable<? extends File> files) throws IOException {
            baseSJFM.setLocation(location, files);
        }

        @Override
        public void setLocationFromPaths(Location location,
                                         Collection<? extends Path> paths) throws IOException {
            baseSJFM.setLocationFromPaths(location, paths);
        }

        @Override
        public void setLocationForModule(Location location, String moduleName,
                                         Collection<? extends Path> paths) throws IOException {
            baseSJFM.setLocationForModule(location, moduleName, paths);
        }

        @Override
        public Iterable<? extends File> getLocation(Location location) {
            return baseSJFM.getLocation(location);
        }

        @Override
        public Iterable<? extends Path> getLocationAsPaths(Location location) {
            return baseSJFM.getLocationAsPaths(location);
        }

        @Override
        public Path asPath(FileObject file) {
            return baseSJFM.asPath(file);
        }

        @Override
        public void setPathFactory(PathFactory f) {
            baseSJFM.setPathFactory(f);
        }

    }
}

com/sun/tools/javac/main/DelegatingJavaFileManager.java

 

Or download all of them as a single archive file:

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

 

JDK 11 jdk.crypto.cryptoki.jmod - Crypto KI Module

JDK 11 jdk.charsets.jmod - Charsets Module

Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)

2020-08-13, 92058👍, 0💬