120 Module normalModule = toNormalModule(m, apiDeps);
121 if (normalModule != null) {
122 automaticToNormalModule.put(m, normalModule);
123
124 // generate module-info.java
125 System.out.format("writing to %s%n", file);
126 writeModuleInfo(file, normalModule.descriptor());
127 } else {
128 // find missing dependences
129 System.out.format("Missing dependence: %s not generated%n", file);
130 missingDeps = true;
131 }
132 }
133
134 return !missingDeps;
135 } finally {
136 dependencyFinder.shutdown();
137 }
138 }
139
140 boolean notFound(Archive m) {
141 return m == NOT_FOUND || m == REMOVED_JDK_INTERNALS;
142 }
143
144 private Module toNormalModule(Module module, Set<Archive> requiresTransitive)
145 throws IOException
146 {
147 // done analysis
148 module.close();
149
150 if (analyzer.requires(module).anyMatch(this::notFound)) {
151 // missing dependencies
152 return null;
153 }
154
155 Map<String, Boolean> requires = new HashMap<>();
156 requiresTransitive.stream()
157 .map(Archive::getModule)
158 .forEach(m -> requires.put(m.name(), Boolean.TRUE));
159
160 analyzer.requires(module)
161 .map(Archive::getModule)
162 .forEach(d -> requires.putIfAbsent(d.name(), Boolean.FALSE));
163
164 return module.toNormalModule(requires);
165 }
166
167 /**
168 * Returns the stream of resulting modules
169 */
170 Stream<Module> modules() {
171 return automaticToNormalModule.values().stream();
172 }
173
174 /**
175 * Returns the stream of resulting ModuleDescriptors
176 */
177 public Stream<ModuleDescriptor> descriptors() {
178 return automaticToNormalModule.entrySet().stream()
179 .map(Map.Entry::getValue)
180 .map(Module::descriptor);
181 }
182
183 void visitMissingDeps(Analyzer.Visitor visitor) {
184 automaticModules().stream()
185 .filter(m -> analyzer.requires(m).anyMatch(this::notFound))
186 .forEach(m -> {
187 analyzer.visitDependences(m, visitor, Analyzer.Type.VERBOSE);
188 });
189 }
190
191 void writeModuleInfo(Path file, ModuleDescriptor md) {
192 try {
193 Files.createDirectories(file.getParent());
194 try (PrintWriter pw = new PrintWriter(Files.newOutputStream(file))) {
195 printModuleInfo(pw, md);
196 }
197 } catch (IOException e) {
198 throw new UncheckedIOException(e);
199 }
200 }
201
202 private void printModuleInfo(PrintWriter writer, ModuleDescriptor md) {
203 writer.format("%smodule %s {%n", open ? "open " : "", md.name());
204
205 Map<String, Module> modules = configuration.getModules();
206
207 // first print requires
|
120 Module normalModule = toNormalModule(m, apiDeps);
121 if (normalModule != null) {
122 automaticToNormalModule.put(m, normalModule);
123
124 // generate module-info.java
125 System.out.format("writing to %s%n", file);
126 writeModuleInfo(file, normalModule.descriptor());
127 } else {
128 // find missing dependences
129 System.out.format("Missing dependence: %s not generated%n", file);
130 missingDeps = true;
131 }
132 }
133
134 return !missingDeps;
135 } finally {
136 dependencyFinder.shutdown();
137 }
138 }
139
140 private Module toNormalModule(Module module, Set<Archive> requiresTransitive)
141 throws IOException
142 {
143 // done analysis
144 module.close();
145
146 if (analyzer.requires(module).anyMatch(Analyzer::notFound)) {
147 // missing dependencies
148 return null;
149 }
150
151 Map<String, Boolean> requires = new HashMap<>();
152 requiresTransitive.stream()
153 .map(Archive::getModule)
154 .forEach(m -> requires.put(m.name(), Boolean.TRUE));
155
156 analyzer.requires(module)
157 .map(Archive::getModule)
158 .forEach(d -> requires.putIfAbsent(d.name(), Boolean.FALSE));
159
160 return module.toNormalModule(requires);
161 }
162
163 /**
164 * Returns the stream of resulting modules
165 */
166 Stream<Module> modules() {
167 return automaticToNormalModule.values().stream();
168 }
169
170 /**
171 * Returns the stream of resulting ModuleDescriptors
172 */
173 public Stream<ModuleDescriptor> descriptors() {
174 return automaticToNormalModule.entrySet().stream()
175 .map(Map.Entry::getValue)
176 .map(Module::descriptor);
177 }
178
179 void visitMissingDeps(Analyzer.Visitor visitor) {
180 automaticModules().stream()
181 .filter(m -> analyzer.requires(m).anyMatch(Analyzer::notFound))
182 .forEach(m -> {
183 analyzer.visitDependences(m, visitor, Analyzer.Type.VERBOSE, Analyzer::notFound);
184 });
185 }
186
187 void writeModuleInfo(Path file, ModuleDescriptor md) {
188 try {
189 Files.createDirectories(file.getParent());
190 try (PrintWriter pw = new PrintWriter(Files.newOutputStream(file))) {
191 printModuleInfo(pw, md);
192 }
193 } catch (IOException e) {
194 throw new UncheckedIOException(e);
195 }
196 }
197
198 private void printModuleInfo(PrintWriter writer, ModuleDescriptor md) {
199 writer.format("%smodule %s {%n", open ? "open " : "", md.name());
200
201 Map<String, Module> modules = configuration.getModules();
202
203 // first print requires
|