| /* |
| * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.tools.jdeps; |
| |
| import java.lang.module.ModuleDescriptor; |
| import java.net.URI; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Jdeps internal representation of module for dependency analysis. |
| */ |
| class Module extends Archive { |
| static final Module UNNAMED_MODULE = new UnnamedModule(); |
| static final String JDK_UNSUPPORTED = "jdk.unsupported"; |
| |
| static final boolean DEBUG = Boolean.getBoolean("jdeps.debug"); |
| static void trace(String fmt, Object... args) { |
| trace(DEBUG, fmt, args); |
| } |
| |
| static void trace(boolean traceOn, String fmt, Object... args) { |
| if (traceOn) { |
| System.err.format(fmt, args); |
| } |
| } |
| |
| private final ModuleDescriptor descriptor; |
| private final Map<String, Set<String>> exports; |
| private final Map<String, Set<String>> opens; |
| private final boolean isSystem; |
| private final URI location; |
| |
| protected Module(String name) { |
| super(name); |
| this.descriptor = null; |
| this.location = null; |
| this.exports = Collections.emptyMap(); |
| this.opens = Collections.emptyMap(); |
| this.isSystem = true; |
| } |
| |
| private Module(String name, |
| URI location, |
| ModuleDescriptor descriptor, |
| Map<String, Set<String>> exports, |
| Map<String, Set<String>> opens, |
| boolean isSystem, |
| ClassFileReader reader) { |
| super(name, location, reader); |
| this.descriptor = descriptor; |
| this.location = location; |
| this.exports = Collections.unmodifiableMap(exports); |
| this.opens = Collections.unmodifiableMap(opens); |
| this.isSystem = isSystem; |
| } |
| |
| /** |
| * Returns module name |
| */ |
| public String name() { |
| return descriptor != null ? descriptor.name() : getName(); |
| } |
| |
| public boolean isNamed() { |
| return true; |
| } |
| |
| public boolean isAutomatic() { |
| return descriptor.isAutomatic(); |
| } |
| |
| public Module getModule() { |
| return this; |
| } |
| |
| public ModuleDescriptor descriptor() { |
| return descriptor; |
| } |
| |
| public URI location() { |
| return location; |
| } |
| |
| public boolean isJDK() { |
| String mn = name(); |
| return isSystem && |
| (mn.startsWith("java.") || mn.startsWith("jdk.") || mn.startsWith("javafx.")); |
| } |
| |
| public boolean isSystem() { |
| return isSystem; |
| } |
| |
| public Map<String, Set<String>> exports() { |
| return exports; |
| } |
| |
| public Set<String> packages() { |
| return descriptor.packages(); |
| } |
| |
| public boolean isJDKUnsupported() { |
| return JDK_UNSUPPORTED.equals(this.name()); |
| } |
| |
| /** |
| * Converts this module to a normal module with the given dependences |
| * |
| * @throws IllegalArgumentException if this module is not an automatic module |
| */ |
| public Module toNormalModule(Map<String, Boolean> requires) { |
| if (!isAutomatic()) { |
| throw new IllegalArgumentException(name() + " not an automatic module"); |
| } |
| return new NormalModule(this, requires); |
| } |
| |
| /** |
| * Tests if the package of the given name is exported. |
| */ |
| public boolean isExported(String pn) { |
| return exports.containsKey(pn) && exports.get(pn).isEmpty(); |
| } |
| |
| /** |
| * Tests if the package of the given name is exported to the target |
| * in a qualified fashion. |
| */ |
| public boolean isExported(String pn, String target) { |
| return isExported(pn) |
| || exports.containsKey(pn) && exports.get(pn).contains(target); |
| } |
| |
| /** |
| * Tests if the package of the given name is open. |
| */ |
| public boolean isOpen(String pn) { |
| return opens.containsKey(pn) && opens.get(pn).isEmpty(); |
| } |
| |
| /** |
| * Tests if the package of the given name is open to the target |
| * in a qualified fashion. |
| */ |
| public boolean isOpen(String pn, String target) { |
| return isOpen(pn) |
| || opens.containsKey(pn) && opens.get(pn).contains(target); |
| } |
| |
| @Override |
| public String toString() { |
| return name(); |
| } |
| |
| public final static class Builder { |
| final String name; |
| final ModuleDescriptor descriptor; |
| final boolean isSystem; |
| ClassFileReader reader; |
| URI location; |
| |
| public Builder(ModuleDescriptor md) { |
| this(md, false); |
| } |
| |
| public Builder(ModuleDescriptor md, boolean isSystem) { |
| this.name = md.name(); |
| this.descriptor = md; |
| this.isSystem = isSystem; |
| } |
| |
| public Builder location(URI location) { |
| this.location = location; |
| return this; |
| } |
| |
| public Builder classes(ClassFileReader reader) { |
| this.reader = reader; |
| return this; |
| } |
| |
| public Module build() { |
| if (descriptor.isAutomatic() && isSystem) { |
| throw new InternalError("JDK module: " + name + " can't be automatic module"); |
| } |
| |
| Map<String, Set<String>> exports = new HashMap<>(); |
| Map<String, Set<String>> opens = new HashMap<>(); |
| |
| if (descriptor.isAutomatic()) { |
| // ModuleDescriptor::exports and opens returns an empty set |
| descriptor.packages().forEach(pn -> exports.put(pn, Collections.emptySet())); |
| descriptor.packages().forEach(pn -> opens.put(pn, Collections.emptySet())); |
| } else { |
| descriptor.exports().stream() |
| .forEach(exp -> exports.computeIfAbsent(exp.source(), _k -> new HashSet<>()) |
| .addAll(exp.targets())); |
| descriptor.opens().stream() |
| .forEach(exp -> opens.computeIfAbsent(exp.source(), _k -> new HashSet<>()) |
| .addAll(exp.targets())); |
| } |
| return new Module(name, location, descriptor, exports, opens, isSystem, reader); |
| } |
| } |
| |
| private static class UnnamedModule extends Module { |
| private UnnamedModule() { |
| super("unnamed", null, null, |
| Collections.emptyMap(), Collections.emptyMap(), |
| false, null); |
| } |
| |
| @Override |
| public String name() { |
| return "unnamed"; |
| } |
| |
| @Override |
| public boolean isNamed() { |
| return false; |
| } |
| |
| @Override |
| public boolean isAutomatic() { |
| return false; |
| } |
| |
| @Override |
| public boolean isExported(String pn) { |
| return true; |
| } |
| } |
| |
| /** |
| * A normal module has a module-info.class |
| */ |
| private static class NormalModule extends Module { |
| private final ModuleDescriptor md; |
| |
| /** |
| * Converts the given automatic module to a normal module. |
| * |
| * Replace this module's dependences with the given requires and also |
| * declare service providers, if specified in META-INF/services configuration file |
| */ |
| private NormalModule(Module m, Map<String, Boolean> requires) { |
| super(m.name(), m.location, m.descriptor, m.exports, m.opens, m.isSystem, m.reader()); |
| |
| ModuleDescriptor.Builder builder = ModuleDescriptor.newModule(m.name()); |
| requires.keySet().forEach(mn -> { |
| if (requires.get(mn).equals(Boolean.TRUE)) { |
| builder.requires(Set.of(ModuleDescriptor.Requires.Modifier.TRANSITIVE), mn); |
| } else { |
| builder.requires(mn); |
| } |
| }); |
| // exports all packages |
| m.descriptor.packages().forEach(builder::exports); |
| m.descriptor.uses().forEach(builder::uses); |
| m.descriptor.provides().forEach(builder::provides); |
| this.md = builder.build(); |
| } |
| |
| @Override |
| public ModuleDescriptor descriptor() { |
| return md; |
| } |
| } |
| } |