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/sjavac/options/Options.java

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

package com.sun.tools.sjavac.options;

import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.HashSet;
import java.util.StringJoiner;

import com.sun.tools.sjavac.Transformer;
import com.sun.tools.sjavac.Util;

/**
 * Instances of this class represent values for sjavac command line options.
 *
 *  <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 Options {

    // Output directories
    private Path destDir, genSrcDir, headerDir, stateDir;

    // Input directories
    private List<SourceLocation> sources = new ArrayList<>();
    private List<SourceLocation> sourceSearchPaths = new ArrayList<>();
    private List<SourceLocation> classSearchPaths = new ArrayList<>();
    private List<SourceLocation> moduleSearchPaths = new ArrayList<>();

    private String logLevel = "info";

    private Set<String> permitted_artifacts = new HashSet<>();
    private boolean permitUnidentifiedArtifacts = false;
    private boolean permitSourcesInDefaultPackage = false;

    private Path sourceReferenceList;
    private int numCores = 4;
    private String implicitPolicy = "none";
    private List<String> javacArgs = new ArrayList<>();

    private Map<String, Transformer> trRules = new HashMap<>();

    private boolean startServer = false;

    // Server configuration string
    private String serverConf;

    /** Get the policy for implicit classes */
    public String getImplicitPolicy() {
        return implicitPolicy;
    }

    /** Get the path for generated sources (or null if no such path is set) */
    public Path getGenSrcDir() {
        return genSrcDir;
    }

    /** Get the path for the destination directory */
    public Path getDestDir() {
        return destDir;
    }

    /** Get the path for the header directory (or null if no such path is set) */
    public Path getHeaderDir() {
        return headerDir;
    }

    /** Get the path for the state directory, defaults to destDir. */
    public Path getStateDir() {
        return stateDir;
    }

    /** Get all source locations for files to be compiled */
    public List<SourceLocation> getSources() {
        return sources;
    }

    /**
     * Get all paths to search for classes in .java format. (Java-files in
     * found here should not be compiled.
     */
    public List<SourceLocation> getSourceSearchPaths() {
        return sourceSearchPaths;
    }

    /** Get all paths to search for classes in. */
    public List<SourceLocation> getClassSearchPath() {
        return classSearchPaths;
    }

    /** Get all paths to search for modules in. */
    public List<SourceLocation> getModuleSearchPaths() {
        return moduleSearchPaths;
    }

    /** Get the log level. */
    public String getLogLevel() {
        return logLevel;
    }

    /** Returns true iff the artifact is permitted in the output dir. */
    public boolean isUnidentifiedArtifactPermitted(String f) {
        return permitted_artifacts.contains(f);
    }

    /** Returns true iff artifacts in the output directories should be kept,
     * even if they would not be generated in a clean build. */
    public boolean areUnidentifiedArtifactsPermitted() {
        return permitUnidentifiedArtifacts;
    }

    /** Returns true iff sources in the default package should be permitted. */
    public boolean isDefaultPackagePermitted() {
        return permitSourcesInDefaultPackage;
    }

    /** Get the path to the list of reference sources (or null if none is set) */
    public Path getSourceReferenceList() {
        return sourceReferenceList;
    }

    /** Get the number of cores to be used by sjavac */
    public int getNumCores() {
        return numCores;
    }

    /** Returns all arguments relevant to javac but irrelevant to sjavac. */
    public List<String> getJavacArgs() {
        return javacArgs;
    }

    /**
     * Get a map which maps suffixes to transformers (for example
     * ".java" {@literal ->} CompileJavaPackages)
     */
    public Map<String, Transformer> getTranslationRules() {
        return trRules;
    }

    /** Return true iff a new server should be started */
    public boolean startServerFlag() {
        return startServer;
    }

    /** Return the server configuration string. */
    public String getServerConf() {
        return serverConf;
    }

    /**
     * Parses the given argument array and returns a corresponding Options
     * instance.
     */
    public static Options parseArgs(String... args) {
        Options options = new Options();
        options.new ArgDecoderOptionHelper().traverse(args);
        return options;
    }

    /** Returns true iff a .java file is among the javac arguments */
    public boolean isJavaFilesAmongJavacArgs() {
        for (String javacArg : javacArgs)
            if (javacArg.endsWith(".java"))
                return true;
        return false;
    }

    /**
     * Returns a string representation of the options that affect the result of
     * the compilation. (Used for saving the state of the options used in a
     * previous compile.)
     */
    public String getStateArgsString() {

        // Local utility class for collecting the arguments
        class StateArgs {

            private List<String> args = new ArrayList<>();

            void addArg(Option opt) {
                args.add(opt.arg);
            }

            void addArg(Option opt, Object val) {
                addArg(opt);
                args.add(val.toString());
            }

            void addSourceLocations(Option opt, List<SourceLocation> locs) {
                for (SourceLocation sl : locs) {
                    for (String pkg : sl.includes) addArg(Option.I, pkg);
                    for (String pkg : sl.excludes) addArg(Option.X, pkg);
                    addArg(opt, sl.getPath());
                }
            }

            String getResult() {
                return String.join(" ", args);
            }

            public void addAll(Collection<String> toAdd) {
                args.addAll(toAdd);
            }
        }

        StateArgs args = new StateArgs();

        // Directories
        if (genSrcDir != null)
            args.addArg(Option.S, genSrcDir.normalize());

        if (headerDir != null)
            args.addArg(Option.H, headerDir.normalize());

        if (destDir != null)
            args.addArg(Option.D, destDir.normalize());

        if (stateDir != null)
            args.addArg(Option.STATE_DIR, stateDir.normalize());

        // Source roots
        args.addSourceLocations(Option.SRC, sources);
        args.addSourceLocations(Option.SOURCE_PATH, sourceSearchPaths);
        args.addSourceLocations(Option.CLASS_PATH,  classSearchPaths);
        args.addSourceLocations(Option.MODULE_PATH, moduleSearchPaths);

        // Boolean options
        if (permitSourcesInDefaultPackage)
            args.addArg(Option.PERMIT_SOURCES_WITHOUT_PACKAGE);

        for (String f : permitted_artifacts) {
            args.addArg(Option.PERMIT_ARTIFACT, f);
        }

        if (permitUnidentifiedArtifacts)
            args.addArg(Option.PERMIT_UNIDENTIFIED_ARTIFACTS);

        // Translation rules
        for (Map.Entry<String, Transformer> tr : trRules.entrySet()) {
            String val = tr.getKey() + "=" + tr.getValue().getClass().getName();
            args.addArg(Option.TR, val);
        }

        // Javac args
        args.addAll(javacArgs);

        return args.getResult();
    }


    /** Extract the arguments to be passed on to javac. */
    public String[] prepJavacArgs() {
        List<String> args = new ArrayList<>();

        // Output directories
        args.add("-d");
        args.add(destDir.toString());

        if (getGenSrcDir() != null) {
            args.add("-s");
            args.add(genSrcDir.toString());
        }

        if (headerDir != null) {
            args.add("-h");
            args.add(headerDir.toString());
        }

        // Prep sourcepath
        List<SourceLocation> sourcepath = new ArrayList<>();
        sourcepath.addAll(sources);
        sourcepath.addAll(sourceSearchPaths);
        if (sourcepath.size() > 0) {
            args.add("-sourcepath");
            args.add(concatenateSourceLocations(sourcepath));
        }

        // Prep classpath
        if (classSearchPaths.size() > 0) {
            args.add("-classpath");
            args.add(concatenateSourceLocations(classSearchPaths));
        }

        // Enable dependency generation
        args.add("--debug=completionDeps=source,class");

        // This can't be anything but 'none'. Enforced by sjavac main method.
        args.add("-implicit:" + implicitPolicy);

        // If this option is not used, Object for instance is erroneously
        // picked up from PLATFORM_CLASS_PATH instead of CLASS_PATH.
        //
        // Discussing this further led to the decision of letting bootclasspath
        // be a dummy (empty) directory when building the JDK.
        //args.add("-XXuserPathsFirst");

        // Append javac-options (i.e. pass through options not recognized by
        // sjavac to javac.)
        args.addAll(javacArgs);

        return args.toArray(new String[args.size()]);
    }

    // Helper method to join a list of source locations separated by
    // File.pathSeparator
    private static String concatenateSourceLocations(List<SourceLocation> locs) {
        StringJoiner joiner = new StringJoiner(java.io.File.pathSeparator);
        for (SourceLocation loc : locs) {
            joiner.add(loc.getPath().toString());
        }
        return joiner.toString();
    }

    // OptionHelper that records the traversed options in this Options instance.
    private class ArgDecoderOptionHelper extends OptionHelper {

        List<String> includes, excludes, includeFiles, excludeFiles;
        {
            resetFilters();
        }

        boolean headerProvided = false;
        boolean genSrcProvided = false;
        boolean stateProvided = false;

        @Override
        public void reportError(String msg) {
            throw new IllegalArgumentException(msg);
        }

        @Override
        public void sourceRoots(List<Path> paths) {
            sources.addAll(createSourceLocations(paths));
        }

        @Override
        public void exclude(String exclPattern) {
            exclPattern = Util.normalizeDriveLetter(exclPattern);
            excludes.add(exclPattern);
        }

        @Override
        public void include(String inclPattern) {
            inclPattern = Util.normalizeDriveLetter(inclPattern);
            includes.add(inclPattern);
        }

        @Override
        public void addTransformer(String suffix, Transformer tr) {
            if (trRules.containsKey(suffix)) {
                reportError("More than one transformer specified for " +
                            "suffix " + suffix + ".");
                return;
            }
            trRules.put(suffix, tr);
        }

        @Override
        public void sourcepath(List<Path> paths) {
            sourceSearchPaths.addAll(createSourceLocations(paths));
        }

        @Override
        public void modulepath(List<Path> paths) {
            moduleSearchPaths.addAll(createSourceLocations(paths));
        }

        @Override
        public void classpath(List<Path> paths) {
            classSearchPaths.addAll(createSourceLocations(paths));
        }

        @Override
        public void numCores(int n) {
            numCores = n;
        }

        @Override
        public void logLevel(String level) {
            logLevel = level;
        }

        @Override
        public void compareFoundSources(Path referenceList) {
            sourceReferenceList = referenceList;
        }

        @Override
        public void permitArtifact(String f) {
            permitted_artifacts.add(f);
        }

        @Override
        public void permitUnidentifiedArtifacts() {
            permitUnidentifiedArtifacts = true;
        }

        @Override
        public void permitDefaultPackage() {
            permitSourcesInDefaultPackage = true;
        }

        @Override
        public void serverConf(String conf) {
            if (serverConf != null)
                reportError("Can not specify more than one server configuration.");
            else
                serverConf = conf;
        }

        @Override
        public void implicit(String policy) {
            implicitPolicy = policy;
        }

        @Override
        public void startServerConf(String conf) {
            if (serverConf != null)
                reportError("Can not specify more than one server configuration.");
            else {
                startServer = true;
                serverConf = conf;
            }
        }

        @Override
        public void javacArg(String... arg) {
            javacArgs.addAll(Arrays.asList(arg));
        }

        @Override
        public void destDir(Path dir) {
            if (destDir != null) {
                reportError("Destination directory already specified.");
                return;
            }
            destDir = dir.toAbsolutePath();
        }

        @Override
        public void generatedSourcesDir(Path dir) {
            if (genSrcProvided) {
                reportError("Directory for generated sources already specified.");
                return;
            }
            genSrcProvided = true;
            genSrcDir = dir.toAbsolutePath();
        }

        @Override
        public void headerDir(Path dir) {
            if (headerProvided) {
                reportError("Header directory already specified.");
                return;
            }
            headerProvided = true;
            headerDir = dir.toAbsolutePath();
        }

        @Override
        public void stateDir(Path dir) {
            if (stateProvided) {
                reportError("State directory already specified.");
                return;
            }
            stateProvided = true;
            stateDir = dir.toAbsolutePath();
        }

        private List<SourceLocation> createSourceLocations(List<Path> paths) {
            List<SourceLocation> result = new ArrayList<>();
            for (Path path : paths) {
                result.add(new SourceLocation(
                        path,
                        includes,
                        excludes));
            }
            resetFilters();
            return result;
        }

        private void resetFilters() {
            includes = new ArrayList<>();
            excludes = new ArrayList<>();
            includeFiles = new ArrayList<>();
            excludeFiles = new ArrayList<>();
        }
    }

}

com/sun/tools/sjavac/options/Options.java

 

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)

2018-11-09, 7990👍, 0💬