Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
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/util/Dependencies.java
/* * Copyright (c) 2014, 2016, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package com.sun.tools.javac.util; import com.sun.tools.javac.code.Symbol; import com.sun.tools.javac.code.Symbol.ClassSymbol; import com.sun.tools.javac.code.Symbol.Completer; import com.sun.tools.javac.code.Symbol.CompletionFailure; import com.sun.tools.javac.main.JavaCompiler; import com.sun.tools.javac.util.GraphUtils.DependencyKind; import com.sun.tools.javac.util.GraphUtils.DotVisitor; import com.sun.tools.javac.util.GraphUtils.NodeVisitor; import java.io.Closeable; import java.io.FileWriter; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.EnumMap; import java.util.EnumSet; import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import java.util.Properties; import java.util.Stack; import javax.tools.JavaFileObject; /** * This class is used to track dependencies in the javac symbol completion process. * * <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 abstract class Dependencies { protected static final Context.Key<Dependencies> dependenciesKey = new Context.Key<>(); public static Dependencies instance(Context context) { Dependencies instance = context.get(dependenciesKey); if (instance == null) { //use a do-nothing implementation in case no other implementation has been set by preRegister instance = new DummyDependencies(context); } return instance; } protected Dependencies(Context context) { context.put(dependenciesKey, this); } /** * Push a new completion node on the stack. */ abstract public void push(ClassSymbol s, CompletionCause phase); /** * Remove current dependency node from the stack. */ abstract public void pop(); public enum CompletionCause implements GraphUtils.DependencyKind { CLASS_READER, HEADER_PHASE, HIERARCHY_PHASE, IMPORTS_PHASE, MEMBER_ENTER, MEMBERS_PHASE, OTHER; } /** * This class creates a graph of all dependencies as symbols are completed; * when compilation finishes, the resulting dependency graph is then dumped * onto a dot file. Several options are provided to customize the output of the graph. */ public static class GraphDependencies extends Dependencies implements Closeable, Completer { /** * set of enabled dependencies modes */ private EnumSet<DependenciesMode> dependenciesModes; /** * file in which the dependency graph should be written */ private String dependenciesFile; /** * Register a Context.Factory to create a Dependencies. */ public static void preRegister(Context context) { context.put(dependenciesKey, (Context.Factory<Dependencies>) GraphDependencies::new); } /** * Build a Dependencies instance. */ GraphDependencies(Context context) { super(context); //fetch filename Options options = Options.instance(context); String[] modes = options.get("debug.completionDeps").split(","); for (String mode : modes) { if (mode.startsWith("file=")) { dependenciesFile = mode.substring(5); } } //parse modes dependenciesModes = DependenciesMode.getDependenciesModes(modes); //add to closeables JavaCompiler compiler = JavaCompiler.instance(context); compiler.closeables = compiler.closeables.prepend(this); } enum DependenciesMode { SOURCE("source"), CLASS("class"), REDUNDANT("redundant"); final String opt; DependenciesMode(String opt) { this.opt = opt; } /** * This method is used to parse the {@code completionDeps} option. * Possible modes are separated by colon; a mode can be excluded by * prepending '-' to its name. Finally, the special mode 'all' can be used to * add all modes to the resulting enum. */ static EnumSet<DependenciesMode> getDependenciesModes(String[] modes) { EnumSet<DependenciesMode> res = EnumSet.noneOf(DependenciesMode.class); Collection<String> args = Arrays.asList(modes); if (args.contains("all")) { res = EnumSet.allOf(DependenciesMode.class); } for (DependenciesMode mode : values()) { if (args.contains(mode.opt)) { res.add(mode); } else if (args.contains("-" + mode.opt)) { res.remove(mode); } } return res; } } /** * Class representing a node in the dependency graph. */ public static abstract class Node extends GraphUtils.AbstractNode<ClassSymbol, Node> implements GraphUtils.DottableNode<ClassSymbol, Node> { /** * dependant nodes grouped by kind */ EnumMap<CompletionCause, List<Node>> depsByKind; Node(ClassSymbol value) { super(value); this.depsByKind = new EnumMap<>(CompletionCause.class); for (CompletionCause depKind : CompletionCause.values()) { depsByKind.put(depKind, new ArrayList<Node>()); } } void addDependency(DependencyKind depKind, Node dep) { List<Node> deps = depsByKind.get(depKind); if (!deps.contains(dep)) { deps.add(dep); } } @Override public boolean equals(Object obj) { return obj instanceof Node && data.equals(((Node) obj).data); } @Override public int hashCode() { return data.hashCode(); } @Override public GraphUtils.DependencyKind[] getSupportedDependencyKinds() { return CompletionCause.values(); } @Override public java.util.Collection<? extends Node> getDependenciesByKind(DependencyKind dk) { return depsByKind.get(dk); } @Override public Properties nodeAttributes() { Properties p = new Properties(); p.put("label", DotVisitor.wrap(toString())); return p; } @Override public Properties dependencyAttributes(Node to, GraphUtils.DependencyKind dk) { Properties p = new Properties(); p.put("label", dk); return p; } @Override public String toString() { return data.getQualifiedName().toString(); } } /** * This is a dependency node used to model symbol completion requests. * Completion requests can come from either source or class. */ public static class CompletionNode extends Node { /** * Completion kind (source vs. classfile) */ enum Kind { /** * Source completion request */ SOURCE("solid"), /** * Classfile completion request */ CLASS("dotted"); final String dotStyle; Kind(String dotStyle) { this.dotStyle = dotStyle; } } final Kind ck; CompletionNode(ClassSymbol sym) { super(sym); //infer completion kind by looking at the symbol fields boolean fromClass = (sym.classfile == null && sym.sourcefile == null) || (sym.classfile != null && sym.classfile.getKind() == JavaFileObject.Kind.CLASS); ck = fromClass ? CompletionNode.Kind.CLASS : CompletionNode.Kind.SOURCE; } @Override public Properties nodeAttributes() { Properties p = super.nodeAttributes(); p.put("style", ck.dotStyle); p.put("shape", "ellipse"); return p; } public ClassSymbol getClassSymbol() { return data; } } /** * stack of dependency nodes currently being processed */ Stack<Node> nodeStack = new Stack<>(); /** * map containing all dependency nodes seen so far */ Map<ClassSymbol, Node> dependencyNodeMap = new LinkedHashMap<>(); @Override public void push(ClassSymbol s, CompletionCause phase) { Node n = new CompletionNode(s); if (n == push(n, phase)) { s.completer = this; } } /** * Push a new dependency on the stack. */ protected Node push(Node newNode, CompletionCause cc) { Node cachedNode = dependencyNodeMap.get(newNode.data); if (cachedNode == null) { dependencyNodeMap.put(newNode.data, newNode); } else { newNode = cachedNode; } if (!nodeStack.isEmpty()) { Node currentNode = nodeStack.peek(); currentNode.addDependency(cc, newNode); } nodeStack.push(newNode); return newNode; } @Override public void pop() { nodeStack.pop(); } @Override public void close() throws IOException { if (!dependenciesModes.contains(DependenciesMode.REDUNDANT)) { //prune spurious edges new PruneVisitor().visit(dependencyNodeMap.values(), null); } if (!dependenciesModes.contains(DependenciesMode.CLASS)) { //filter class completions new FilterVisitor(CompletionNode.Kind.SOURCE).visit(dependencyNodeMap.values(), null); } if (!dependenciesModes.contains(DependenciesMode.SOURCE)) { //filter source completions new FilterVisitor(CompletionNode.Kind.CLASS).visit(dependencyNodeMap.values(), null); } if (dependenciesFile != null) { //write to file try (FileWriter fw = new FileWriter(dependenciesFile)) { fw.append(GraphUtils.toDot(dependencyNodeMap.values(), "CompletionDeps", "")); } } } @Override public void complete(Symbol sym) throws CompletionFailure { push((ClassSymbol)sym, CompletionCause.OTHER); pop(); sym.completer = this; } @Override public boolean isTerminal() { return true; } public Collection<Node> getNodes() { return dependencyNodeMap.values(); } /** * This visitor is used to prune the graph from spurious edges using some heuristics. */ private static class PruneVisitor extends NodeVisitor<ClassSymbol, Node, Void> { @Override public void visitNode(Node node, Void arg) { //do nothing } @Override public void visitDependency(GraphUtils.DependencyKind dk, Node from, Node to, Void arg) { //heuristic - skips dependencies that are likely to be fake if (from.equals(to)) { to.depsByKind.get(dk).remove(from); } } } /** * This visitor is used to retain only completion nodes with given kind. */ private class FilterVisitor extends NodeVisitor<ClassSymbol, Node, Void> { CompletionNode.Kind ck; private FilterVisitor(CompletionNode.Kind ck) { this.ck = ck; } @Override public void visitNode(Node node, Void arg) { if (node instanceof CompletionNode) { if (((CompletionNode) node).ck != ck) { dependencyNodeMap.remove(node.data); } } } @Override public void visitDependency(GraphUtils.DependencyKind dk, Node from, Node to, Void arg) { if (to instanceof CompletionNode) { if (((CompletionNode) to).ck != ck) { from.depsByKind.get(dk).remove(to); } } } } } /** * Dummy class to be used when dependencies options are not set. This keeps * performance cost of calling push/pop methods during completion marginally low. */ private static class DummyDependencies extends Dependencies { private DummyDependencies(Context context) { super(context); } @Override public void push(ClassSymbol s, CompletionCause phase) { //do nothing } @Override public void pop() { //do nothing } } }
⏎ com/sun/tools/javac/util/Dependencies.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
2020-08-13, 124625👍, 0💬
Popular Posts:
JDK 17 java.management.jmod is the JMOD file for JDK 17 Management module. JDK 17 Management module ...
JDK 17 java.base.jmod is the JMOD file for JDK 17 Base module. JDK 17 Base module compiled class fil...
JDOM provides a solution for using XML from Java that is as simple as Java itself. There is no compe...
JAX-WS is an API for building web services and clients. It is the next generation Web Services API r...
How to download and install ojdbc14.jar for Oracle 10g R2? ojdbc14.jar for Oracle 10g R2 is a Java 1...