1 /*
2 * Copyright (c) 2007, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package sun.launcher;
27
28 /*
29 *
30 * <p><b>This is NOT part of any API supported by Sun Microsystems.
31 * If you write code that depends on this, you do so at your own
32 * risk. This code and its internal interfaces are subject to change
33 * or deletion without notice.</b>
34 *
35 */
36
37 /**
38 * A utility package for the java(1), javaw(1) launchers.
39 * The following are helper methods that the native launcher uses
40 * to perform checks etc. using JNI, see src/share/bin/java.c
41 */
42 import java.io.File;
43 import java.io.IOException;
44 import java.io.PrintStream;
45 import java.io.UnsupportedEncodingException;
46 import java.lang.module.ModuleFinder;
47 import java.lang.module.ModuleReference;
48 import java.lang.module.ModuleDescriptor;
49 import java.lang.module.ModuleDescriptor.Requires;
50 import java.lang.module.ModuleDescriptor.Exports;
51 import java.lang.module.ModuleDescriptor.Provides;
52 import java.lang.reflect.Layer;
53 import java.lang.reflect.Method;
54 import java.lang.reflect.Modifier;
55 import java.lang.reflect.Module;
56 import java.math.BigDecimal;
57 import java.math.RoundingMode;
58 import java.net.URI;
59 import java.nio.charset.Charset;
60 import java.nio.file.DirectoryStream;
61 import java.nio.file.Files;
62 import java.nio.file.Path;
63 import java.security.AccessController;
64 import java.security.PrivilegedAction;
65 import java.text.Normalizer;
66 import java.text.MessageFormat;
67 import java.util.ResourceBundle;
68 import java.util.ArrayList;
69 import java.util.Collection;
70 import java.util.Collections;
71 import java.util.Comparator;
72 import java.util.Iterator;
73 import java.util.List;
74 import java.util.Locale;
75 import java.util.Locale.Category;
76 import java.util.Optional;
77 import java.util.Properties;
78 import java.util.Map;
79 import java.util.Set;
80 import java.util.TreeSet;
81 import java.util.jar.Attributes;
82 import java.util.jar.JarFile;
83 import java.util.jar.Manifest;
84 import jdk.internal.misc.VM;
85
86
87 public final class LauncherHelper {
88
89 // No instantiation
90 private LauncherHelper() {}
91
92 // used to identify JavaFX applications
93 private static final String JAVAFX_APPLICATION_MARKER =
94 "JavaFX-Application-Class";
95 private static final String JAVAFX_APPLICATION_CLASS_NAME =
96 "javafx.application.Application";
97 private static final String JAVAFX_FXHELPER_CLASS_NAME_SUFFIX =
98 "sun.launcher.LauncherHelper$FXHelper";
99 private static final String MAIN_CLASS = "Main-Class";
100
101 private static StringBuilder outBuf = new StringBuilder();
102
103 private static final String INDENT = " ";
104 private static final String VM_SETTINGS = "VM settings:";
105 private static final String PROP_SETTINGS = "Property settings:";
106 private static final String LOCALE_SETTINGS = "Locale settings:";
107
108 // sync with java.c and jdk.internal.misc.VM
109 private static final String diagprop = "sun.java.launcher.diag";
110 static final boolean trace = VM.getSavedProperty(diagprop) != null;
111
112 private static final String defaultBundleName =
113 "sun.launcher.resources.launcher";
114 private static class ResourceBundleHolder {
115 private static final ResourceBundle RB =
116 ResourceBundle.getBundle(defaultBundleName);
117 }
118 private static PrintStream ostream;
119 private static Class<?> appClass; // application class, for GUI/reporting purposes
120
121 /*
122 * A method called by the launcher to print out the standard settings,
123 * by default -XshowSettings is equivalent to -XshowSettings:all,
124 * Specific information may be gotten by using suboptions with possible
125 * values vm, properties and locale.
126 *
127 * printToStderr: choose between stdout and stderr
128 *
129 * optionFlag: specifies which options to print default is all other
130 * possible values are vm, properties, locale.
131 *
132 * initialHeapSize: in bytes, as set by the launcher, a zero-value indicates
133 * this code should determine this value, using a suitable method or
134 * the line could be omitted.
135 *
136 * maxHeapSize: in bytes, as set by the launcher, a zero-value indicates
137 * this code should determine this value, using a suitable method.
138 *
139 * stackSize: in bytes, as set by the launcher, a zero-value indicates
140 * this code determine this value, using a suitable method or omit the
141 * line entirely.
142 */
143 static void showSettings(boolean printToStderr, String optionFlag,
144 long initialHeapSize, long maxHeapSize, long stackSize,
145 boolean isServer) {
146
147 initOutput(printToStderr);
148 String opts[] = optionFlag.split(":");
149 String optStr = (opts.length > 1 && opts[1] != null)
150 ? opts[1].trim()
151 : "all";
152 switch (optStr) {
153 case "vm":
154 printVmSettings(initialHeapSize, maxHeapSize,
155 stackSize, isServer);
156 break;
157 case "properties":
158 printProperties();
159 break;
160 case "locale":
161 printLocale();
162 break;
163 default:
164 printVmSettings(initialHeapSize, maxHeapSize, stackSize,
165 isServer);
166 printProperties();
167 printLocale();
168 break;
169 }
170 }
171
172 /*
173 * prints the main vm settings subopt/section
174 */
175 private static void printVmSettings(
176 long initialHeapSize, long maxHeapSize,
177 long stackSize, boolean isServer) {
178
179 ostream.println(VM_SETTINGS);
180 if (stackSize != 0L) {
181 ostream.println(INDENT + "Stack Size: " +
182 SizePrefix.scaleValue(stackSize));
183 }
184 if (initialHeapSize != 0L) {
185 ostream.println(INDENT + "Min. Heap Size: " +
186 SizePrefix.scaleValue(initialHeapSize));
187 }
188 if (maxHeapSize != 0L) {
189 ostream.println(INDENT + "Max. Heap Size: " +
190 SizePrefix.scaleValue(maxHeapSize));
191 } else {
192 ostream.println(INDENT + "Max. Heap Size (Estimated): "
193 + SizePrefix.scaleValue(Runtime.getRuntime().maxMemory()));
194 }
195 ostream.println(INDENT + "Ergonomics Machine Class: "
196 + ((isServer) ? "server" : "client"));
197 ostream.println(INDENT + "Using VM: "
198 + System.getProperty("java.vm.name"));
199 ostream.println();
200 }
201
202 /*
203 * prints the properties subopt/section
204 */
205 private static void printProperties() {
206 Properties p = System.getProperties();
207 ostream.println(PROP_SETTINGS);
208 List<String> sortedPropertyKeys = new ArrayList<>();
209 sortedPropertyKeys.addAll(p.stringPropertyNames());
210 Collections.sort(sortedPropertyKeys);
211 for (String x : sortedPropertyKeys) {
212 printPropertyValue(x, p.getProperty(x));
213 }
214 ostream.println();
215 }
216
217 private static boolean isPath(String key) {
218 return key.endsWith(".dirs") || key.endsWith(".path");
219 }
220
221 private static void printPropertyValue(String key, String value) {
222 ostream.print(INDENT + key + " = ");
223 if (key.equals("line.separator")) {
224 for (byte b : value.getBytes()) {
225 switch (b) {
226 case 0xd:
227 ostream.print("\\r ");
228 break;
229 case 0xa:
230 ostream.print("\\n ");
231 break;
232 default:
233 // print any bizzare line separators in hex, but really
234 // shouldn't happen.
235 ostream.printf("0x%02X", b & 0xff);
236 break;
237 }
238 }
239 ostream.println();
240 return;
241 }
242 if (!isPath(key)) {
243 ostream.println(value);
244 return;
245 }
246 String[] values = value.split(System.getProperty("path.separator"));
247 boolean first = true;
248 for (String s : values) {
249 if (first) { // first line treated specially
250 ostream.println(s);
251 first = false;
252 } else { // following lines prefix with indents
253 ostream.println(INDENT + INDENT + s);
254 }
255 }
256 }
257
258 /*
259 * prints the locale subopt/section
260 */
261 private static void printLocale() {
262 Locale locale = Locale.getDefault();
263 ostream.println(LOCALE_SETTINGS);
264 ostream.println(INDENT + "default locale = " +
265 locale.getDisplayLanguage());
266 ostream.println(INDENT + "default display locale = " +
267 Locale.getDefault(Category.DISPLAY).getDisplayName());
268 ostream.println(INDENT + "default format locale = " +
269 Locale.getDefault(Category.FORMAT).getDisplayName());
270 printLocales();
271 ostream.println();
272 }
273
274 private static void printLocales() {
275 Locale[] tlocales = Locale.getAvailableLocales();
276 final int len = tlocales == null ? 0 : tlocales.length;
277 if (len < 1 ) {
278 return;
279 }
280 // Locale does not implement Comparable so we convert it to String
281 // and sort it for pretty printing.
282 Set<String> sortedSet = new TreeSet<>();
283 for (Locale l : tlocales) {
284 sortedSet.add(l.toString());
285 }
286
287 ostream.print(INDENT + "available locales = ");
288 Iterator<String> iter = sortedSet.iterator();
289 final int last = len - 1;
290 for (int i = 0 ; iter.hasNext() ; i++) {
291 String s = iter.next();
292 ostream.print(s);
293 if (i != last) {
294 ostream.print(", ");
295 }
296 // print columns of 8
297 if ((i + 1) % 8 == 0) {
298 ostream.println();
299 ostream.print(INDENT + INDENT);
300 }
301 }
302 }
303
304 private enum SizePrefix {
305
306 KILO(1024, "K"),
307 MEGA(1024 * 1024, "M"),
308 GIGA(1024 * 1024 * 1024, "G"),
309 TERA(1024L * 1024L * 1024L * 1024L, "T");
310 long size;
311 String abbrev;
312
313 SizePrefix(long size, String abbrev) {
314 this.size = size;
315 this.abbrev = abbrev;
316 }
317
318 private static String scale(long v, SizePrefix prefix) {
319 return BigDecimal.valueOf(v).divide(BigDecimal.valueOf(prefix.size),
320 2, RoundingMode.HALF_EVEN).toPlainString() + prefix.abbrev;
321 }
322 /*
323 * scale the incoming values to a human readable form, represented as
324 * K, M, G and T, see java.c parse_size for the scaled values and
325 * suffixes. The lowest possible scaled value is Kilo.
326 */
327 static String scaleValue(long v) {
328 if (v < MEGA.size) {
329 return scale(v, KILO);
330 } else if (v < GIGA.size) {
331 return scale(v, MEGA);
332 } else if (v < TERA.size) {
333 return scale(v, GIGA);
334 } else {
335 return scale(v, TERA);
336 }
337 }
338 }
339
340 /**
341 * A private helper method to get a localized message and also
342 * apply any arguments that we might pass.
343 */
344 private static String getLocalizedMessage(String key, Object... args) {
345 String msg = ResourceBundleHolder.RB.getString(key);
346 return (args != null) ? MessageFormat.format(msg, args) : msg;
347 }
348
349 /**
350 * The java -help message is split into 3 parts, an invariant, followed
351 * by a set of platform dependent variant messages, finally an invariant
352 * set of lines.
353 * This method initializes the help message for the first time, and also
354 * assembles the invariant header part of the message.
355 */
356 static void initHelpMessage(String progname) {
357 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.header",
358 (progname == null) ? "java" : progname ));
359 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.datamodel",
360 32));
361 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.datamodel",
362 64));
363 }
364
365 /**
366 * Appends the vm selection messages to the header, already created.
367 * initHelpSystem must already be called.
368 */
369 static void appendVmSelectMessage(String vm1, String vm2) {
370 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.vmselect",
371 vm1, vm2));
372 }
373
374 /**
375 * Appends the vm synoym message to the header, already created.
376 * initHelpSystem must be called before using this method.
377 */
378 static void appendVmSynonymMessage(String vm1, String vm2) {
379 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.hotspot",
380 vm1, vm2));
381 }
382
383 /**
384 * Appends the vm Ergo message to the header, already created.
385 * initHelpSystem must be called before using this method.
386 */
387 static void appendVmErgoMessage(boolean isServerClass, String vm) {
388 outBuf = outBuf.append(getLocalizedMessage("java.launcher.ergo.message1",
389 vm));
390 outBuf = (isServerClass) ? outBuf.append(",\n")
391 .append(getLocalizedMessage("java.launcher.ergo.message2"))
392 .append("\n\n") : outBuf.append(".\n\n");
393 }
394
395 /**
396 * Appends the last invariant part to the previously created messages,
397 * and finishes up the printing to the desired output stream.
398 * initHelpSystem must be called before using this method.
399 */
400 static void printHelpMessage(boolean printToStderr) {
401 initOutput(printToStderr);
402 outBuf = outBuf.append(getLocalizedMessage("java.launcher.opt.footer",
403 File.pathSeparator));
404 ostream.println(outBuf.toString());
405 }
406
407 /**
408 * Prints the Xusage text to the desired output stream.
409 */
410 static void printXUsageMessage(boolean printToStderr) {
411 initOutput(printToStderr);
412 ostream.println(getLocalizedMessage("java.launcher.X.usage",
413 File.pathSeparator));
414 if (System.getProperty("os.name").contains("OS X")) {
415 ostream.println(getLocalizedMessage("java.launcher.X.macosx.usage",
416 File.pathSeparator));
417 }
418 }
419
420 static void initOutput(boolean printToStderr) {
421 ostream = (printToStderr) ? System.err : System.out;
422 }
423
424 static String getMainClassFromJar(String jarname) {
425 String mainValue = null;
426 try (JarFile jarFile = new JarFile(jarname)) {
427 Manifest manifest = jarFile.getManifest();
428 if (manifest == null) {
429 abort(null, "java.launcher.jar.error2", jarname);
430 }
431 Attributes mainAttrs = manifest.getMainAttributes();
432 if (mainAttrs == null) {
433 abort(null, "java.launcher.jar.error3", jarname);
434 }
435 mainValue = mainAttrs.getValue(MAIN_CLASS);
436 if (mainValue == null) {
437 abort(null, "java.launcher.jar.error3", jarname);
438 }
439
440 /*
441 * Hand off to FXHelper if it detects a JavaFX application
442 * This must be done after ensuring a Main-Class entry
443 * exists to enforce compliance with the jar specification
444 */
445 if (mainAttrs.containsKey(
446 new Attributes.Name(JAVAFX_APPLICATION_MARKER))) {
447 FXHelper.setFXLaunchParameters(jarname, LM_JAR);
448 return FXHelper.class.getName();
449 }
450
451 return mainValue.trim();
452 } catch (IOException ioe) {
453 abort(ioe, "java.launcher.jar.error1", jarname);
454 }
455 return null;
456 }
457
458 // From src/share/bin/java.c:
459 // enum LaunchMode { LM_UNKNOWN = 0, LM_CLASS, LM_JAR, LM_MODULE }
460
461 private static final int LM_UNKNOWN = 0;
462 private static final int LM_CLASS = 1;
463 private static final int LM_JAR = 2;
464 private static final int LM_MODULE = 3;
465
466 static void abort(Throwable t, String msgKey, Object... args) {
467 if (msgKey != null) {
468 ostream.println(getLocalizedMessage(msgKey, args));
469 }
470 if (trace) {
471 if (t != null) {
472 t.printStackTrace();
473 } else {
474 Thread.dumpStack();
475 }
476 }
477 System.exit(1);
478 }
479
480 /**
481 * This method:
482 * 1. Loads the main class from the module or class path
483 * 2. Checks the public static void main method.
484 *
485 * @param printToStderr if set, all output will be routed to stderr
486 * @param mode LaunchMode as determined by the arguments passed on the
487 * command line
488 * @param what the module name[/class], JAR file, or the main class
489 * depending on the mode
490 *
491 * @return the application's main class
492 */
493 public static Class<?> checkAndLoadMain(boolean printToStderr,
494 int mode,
495 String what) {
496 initOutput(printToStderr);
497
498 Class<?> mainClass = (mode == LM_MODULE) ? loadModuleMainClass(what)
499 : loadMainClass(mode, what);
500
501 validateMainClass(mainClass);
502
503 // record main class if not already set
504 if (appClass == null)
505 appClass = mainClass;
506
507 return mainClass;
508 }
509
510 /**
511 * Returns the main class for a module. The query is either a module name
512 * or module-name/main-class. For the former then the module's main class
513 * is obtained from the module descriptor (MainClass attribute).
514 */
515 private static Class<?> loadModuleMainClass(String what) {
516 int i = what.indexOf('/');
517 String mainModule;
518 String mainClass;
519 if (i == -1) {
520 mainModule = what;
521 mainClass = null;
522 } else {
523 mainModule = what.substring(0, i);
524 mainClass = what.substring(i+1);
525 }
526
527 // main module is in the boot layer
528 Layer layer = Layer.boot();
529 Optional<Module> om = layer.findModule(mainModule);
530 if (!om.isPresent()) {
531 // should not happen
532 throw new InternalError("Module " + mainModule + " not in boot Layer");
533 }
534 Module m = om.get();
535
536 // get main class
537 if (mainClass == null) {
538 Optional<String> omc = m.getDescriptor().mainClass();
539 if (!omc.isPresent()) {
540 abort(null, "java.launcher.module.error1", mainModule);
541 }
542 mainClass = omc.get();
543 }
544
545 // load the class from the module
546 Class<?> c = Class.forName(m, mainClass);
547 if (c == null && System.getProperty("os.name", "").contains("OS X")
548 && Normalizer.isNormalized(mainClass, Normalizer.Form.NFD)) {
549
550 String cn = Normalizer.normalize(mainClass, Normalizer.Form.NFC);
551 c = Class.forName(m, cn);
552
553 }
554 if (c == null) {
555 abort(null, "java.launcher.module.error2", mainClass, mainModule);
556 }
557
558 System.setProperty("jdk.module.main.class", c.getName());
559 return c;
560 }
561
562 /**
563 * Loads the main class from the class path (LM_CLASS or LM_JAR).
564 * If the main class extends FX Application then call on FXHelper to
565 * determine the main class to launch.
566 */
567 private static Class<?> loadMainClass(int mode, String what) {
568 // get the class name
569 String cn;
570 switch (mode) {
571 case LM_CLASS:
572 cn = what;
573 break;
574 case LM_JAR:
575 cn = getMainClassFromJar(what);
576 break;
577 default:
578 // should never happen
579 throw new InternalError("" + mode + ": Unknown launch mode");
580 }
581
582 // load the main class
583 cn = cn.replace('/', '.');
584 Class<?> mainClass = null;
585 ClassLoader scl = ClassLoader.getSystemClassLoader();
586 try {
587 mainClass = Class.forName(cn, false, scl);
588 } catch (NoClassDefFoundError | ClassNotFoundException cnfe) {
589 if (System.getProperty("os.name", "").contains("OS X")
590 && Normalizer.isNormalized(cn, Normalizer.Form.NFD)) {
591 try {
592 // On Mac OS X since all names with diacretic symbols are
593 // given as decomposed it is possible that main class name
594 // comes incorrectly from the command line and we have
595 // to re-compose it
596 String ncn = Normalizer.normalize(cn, Normalizer.Form.NFC);
597 mainClass = Class.forName(ncn, false, scl);
598 } catch (NoClassDefFoundError | ClassNotFoundException cnfe1) {
599 abort(cnfe, "java.launcher.cls.error1", cn);
600 }
601 } else {
602 abort(cnfe, "java.launcher.cls.error1", cn);
603 }
604 }
605
606 // record the main class
607 appClass = mainClass;
608
609 /*
610 * Check if FXHelper can launch it using the FX launcher. In an FX app,
611 * the main class may or may not have a main method, so do this before
612 * validating the main class.
613 */
614 if (JAVAFX_FXHELPER_CLASS_NAME_SUFFIX.equals(mainClass.getName()) ||
615 doesExtendFXApplication(mainClass)) {
616 // Will abort() if there are problems with FX runtime
617 FXHelper.setFXLaunchParameters(what, mode);
618 return FXHelper.class;
619 }
620 return mainClass;
621 }
622
623 /*
624 * Accessor method called by the launcher after getting the main class via
625 * checkAndLoadMain(). The "application class" is the class that is finally
626 * executed to start the application and in this case is used to report
627 * the correct application name, typically for UI purposes.
628 */
629 public static Class<?> getApplicationClass() {
630 return appClass;
631 }
632
633 /*
634 * Check if the given class is a JavaFX Application class. This is done
635 * in a way that does not cause the Application class to load or throw
636 * ClassNotFoundException if the JavaFX runtime is not available.
637 */
638 private static boolean doesExtendFXApplication(Class<?> mainClass) {
639 for (Class<?> sc = mainClass.getSuperclass(); sc != null;
640 sc = sc.getSuperclass()) {
641 if (sc.getName().equals(JAVAFX_APPLICATION_CLASS_NAME)) {
642 return true;
643 }
644 }
645 return false;
646 }
647
648 // Check the existence and signature of main and abort if incorrect
649 static void validateMainClass(Class<?> mainClass) {
650 Method mainMethod;
651 try {
652 mainMethod = mainClass.getMethod("main", String[].class);
653 } catch (NoSuchMethodException nsme) {
654 // invalid main or not FX application, abort with an error
655 abort(null, "java.launcher.cls.error4", mainClass.getName(),
656 JAVAFX_APPLICATION_CLASS_NAME);
657 return; // Avoid compiler issues
658 }
659
660 /*
661 * getMethod (above) will choose the correct method, based
662 * on its name and parameter type, however, we still have to
663 * ensure that the method is static and returns a void.
664 */
665 int mod = mainMethod.getModifiers();
666 if (!Modifier.isStatic(mod)) {
667 abort(null, "java.launcher.cls.error2", "static",
668 mainMethod.getDeclaringClass().getName());
669 }
670 if (mainMethod.getReturnType() != java.lang.Void.TYPE) {
671 abort(null, "java.launcher.cls.error3",
672 mainMethod.getDeclaringClass().getName());
673 }
674 }
675
676 private static final String encprop = "sun.jnu.encoding";
677 private static String encoding = null;
678 private static boolean isCharsetSupported = false;
679
680 /*
681 * converts a c or a byte array to a platform specific string,
682 * previously implemented as a native method in the launcher.
683 */
684 static String makePlatformString(boolean printToStderr, byte[] inArray) {
685 initOutput(printToStderr);
686 if (encoding == null) {
687 encoding = System.getProperty(encprop);
688 isCharsetSupported = Charset.isSupported(encoding);
689 }
690 try {
691 String out = isCharsetSupported
692 ? new String(inArray, encoding)
693 : new String(inArray);
694 return out;
695 } catch (UnsupportedEncodingException uee) {
696 abort(uee, null);
697 }
698 return null; // keep the compiler happy
699 }
700
701 static String[] expandArgs(String[] argArray) {
702 List<StdArg> aList = new ArrayList<>();
703 for (String x : argArray) {
704 aList.add(new StdArg(x));
705 }
706 return expandArgs(aList);
707 }
708
709 static String[] expandArgs(List<StdArg> argList) {
710 ArrayList<String> out = new ArrayList<>();
711 if (trace) {
712 System.err.println("Incoming arguments:");
713 }
714 for (StdArg a : argList) {
715 if (trace) {
716 System.err.println(a);
717 }
718 if (a.needsExpansion) {
719 File x = new File(a.arg);
720 File parent = x.getParentFile();
721 String glob = x.getName();
722 if (parent == null) {
723 parent = new File(".");
724 }
725 try (DirectoryStream<Path> dstream =
726 Files.newDirectoryStream(parent.toPath(), glob)) {
727 int entries = 0;
728 for (Path p : dstream) {
729 out.add(p.normalize().toString());
730 entries++;
731 }
732 if (entries == 0) {
733 out.add(a.arg);
734 }
735 } catch (Exception e) {
736 out.add(a.arg);
737 if (trace) {
738 System.err.println("Warning: passing argument as-is " + a);
739 System.err.print(e);
740 }
741 }
742 } else {
743 out.add(a.arg);
744 }
745 }
746 String[] oarray = new String[out.size()];
747 out.toArray(oarray);
748
749 if (trace) {
750 System.err.println("Expanded arguments:");
751 for (String x : oarray) {
752 System.err.println(x);
753 }
754 }
755 return oarray;
756 }
757
758 /* duplicate of the native StdArg struct */
759 private static class StdArg {
760 final String arg;
761 final boolean needsExpansion;
762 StdArg(String arg, boolean expand) {
763 this.arg = arg;
764 this.needsExpansion = expand;
765 }
766 // protocol: first char indicates whether expansion is required
767 // 'T' = true ; needs expansion
768 // 'F' = false; needs no expansion
769 StdArg(String in) {
770 this.arg = in.substring(1);
771 needsExpansion = in.charAt(0) == 'T';
772 }
773 public String toString() {
774 return "StdArg{" + "arg=" + arg + ", needsExpansion=" + needsExpansion + '}';
775 }
776 }
777
778 static final class FXHelper {
779
780 private static final String JAVAFX_GRAPHICS_MODULE_NAME =
781 "javafx.graphics";
782
783 private static final String JAVAFX_LAUNCHER_CLASS_NAME =
784 "com.sun.javafx.application.LauncherImpl";
785
786 /*
787 * The launch method used to invoke the JavaFX launcher. These must
788 * match the strings used in the launchApplication method.
789 *
790 * Command line JavaFX-App-Class Launch mode FX Launch mode
791 * java -cp fxapp.jar FXClass N/A LM_CLASS "LM_CLASS"
792 * java -cp somedir FXClass N/A LM_CLASS "LM_CLASS"
793 * java -jar fxapp.jar Present LM_JAR "LM_JAR"
794 * java -jar fxapp.jar Not Present LM_JAR "LM_JAR"
795 */
796 private static final String JAVAFX_LAUNCH_MODE_CLASS = "LM_CLASS";
797 private static final String JAVAFX_LAUNCH_MODE_JAR = "LM_JAR";
798
799 /*
800 * FX application launcher and launch method, so we can launch
801 * applications with no main method.
802 */
803 private static String fxLaunchName = null;
804 private static String fxLaunchMode = null;
805
806 private static Class<?> fxLauncherClass = null;
807 private static Method fxLauncherMethod = null;
808
809 /*
810 * Set the launch params according to what was passed to LauncherHelper
811 * so we can use the same launch mode for FX. Abort if there is any
812 * issue with loading the FX runtime or with the launcher method.
813 */
814 private static void setFXLaunchParameters(String what, int mode) {
815
816 // find the module with the FX launcher
817 Optional<Module> om = Layer.boot().findModule(JAVAFX_GRAPHICS_MODULE_NAME);
818 if (!om.isPresent()) {
819 abort(null, "java.launcher.cls.error5");
820 }
821
822 // load the FX launcher class
823 fxLauncherClass = Class.forName(om.get(), JAVAFX_LAUNCHER_CLASS_NAME);
824 if (fxLauncherClass == null) {
825 abort(null, "java.launcher.cls.error5");
826 }
827
828 try {
829 /*
830 * signature must be:
831 * public static void launchApplication(String launchName,
832 * String launchMode, String[] args);
833 */
834 fxLauncherMethod = fxLauncherClass.getMethod("launchApplication",
835 String.class, String.class, String[].class);
836
837 // verify launcher signature as we do when validating the main method
838 int mod = fxLauncherMethod.getModifiers();
839 if (!Modifier.isStatic(mod)) {
840 abort(null, "java.launcher.javafx.error1");
841 }
842 if (fxLauncherMethod.getReturnType() != java.lang.Void.TYPE) {
843 abort(null, "java.launcher.javafx.error1");
844 }
845 } catch (NoSuchMethodException ex) {
846 abort(ex, "java.launcher.cls.error5", ex);
847 }
848
849 fxLaunchName = what;
850 switch (mode) {
851 case LM_CLASS:
852 fxLaunchMode = JAVAFX_LAUNCH_MODE_CLASS;
853 break;
854 case LM_JAR:
855 fxLaunchMode = JAVAFX_LAUNCH_MODE_JAR;
856 break;
857 default:
858 // should not have gotten this far...
859 throw new InternalError(mode + ": Unknown launch mode");
860 }
861 }
862
863 public static void main(String... args) throws Exception {
864 if (fxLauncherMethod == null
865 || fxLaunchMode == null
866 || fxLaunchName == null) {
867 throw new RuntimeException("Invalid JavaFX launch parameters");
868 }
869 // launch appClass via fxLauncherMethod
870 fxLauncherMethod.invoke(null,
871 new Object[] {fxLaunchName, fxLaunchMode, args});
872 }
873 }
874
875 private static void formatCommaList(PrintStream out,
876 String prefix,
877 Collection<?> list)
878 {
879 if (list.isEmpty())
880 return;
881 out.format("%s", prefix);
882 boolean first = true;
883 for (Object ob : list) {
884 if (first) {
885 out.format(" %s", ob);
886 first = false;
887 } else {
888 out.format(", %s", ob);
889 }
890 }
891 out.format("%n");
892 }
893
894 /**
895 * Called by the launcher to list the observable modules.
896 * If called without any sub-options then the output is a simple list of
897 * the modules. If called with sub-options then the sub-options are the
898 * names of the modules to list (-listmods:java.base,java.desktop for
899 * example).
900 */
901 static void listModules(boolean printToStderr, String optionFlag)
902 throws IOException, ClassNotFoundException
903 {
904 initOutput(printToStderr);
905
906 ModuleFinder finder = jdk.internal.module.ModuleBootstrap.finder();
907
908 int colon = optionFlag.indexOf(':');
909 if (colon == -1) {
910 finder.findAll().stream()
911 .sorted(Comparator.comparing(ModuleReference::descriptor))
912 .forEach(md -> {
913 ostream.println(midAndLocation(md.descriptor(),
914 md.location()));
915 });
916 } else {
917 String[] names = optionFlag.substring(colon+1).split(",");
918 for (String name: names) {
919 ModuleReference mref = finder.find(name).orElse(null);
920 if (mref == null) {
921 // not found
922 continue;
923 }
924
925 ModuleDescriptor md = mref.descriptor();
926 ostream.println(midAndLocation(md, mref.location()));
927
928 for (Requires d : md.requires()) {
929 ostream.format(" requires %s%n", d);
930 }
931 for (String s : md.uses()) {
932 ostream.format(" uses %s%n", s);
933 }
934
935 // sorted exports
936 Set<Exports> exports = new TreeSet<>(Comparator.comparing(Exports::source));
937 exports.addAll(md.exports());
938 for (Exports e : exports) {
939 ostream.format(" exports %s", e.source());
940 if (e.isQualified()) {
941 formatCommaList(ostream, " to", e.targets());
942 } else {
943 ostream.println();
944 }
945 }
946
947 // concealed packages
948 new TreeSet<>(md.conceals())
949 .forEach(p -> ostream.format(" conceals %s%n", p));
950
951 Map<String, Provides> provides = md.provides();
952 for (Provides ps : provides.values()) {
953 for (String impl : ps.providers())
954 ostream.format(" provides %s with %s%n", ps.service(), impl);
955 }
956 }
957 }
958 }
959
960 static String midAndLocation(ModuleDescriptor md, Optional<URI> location ) {
961 URI loc = location.orElse(null);
962 if (loc == null || loc.getScheme().equalsIgnoreCase("jrt"))
963 return md.toNameAndVersion();
964 else
965 return md.toNameAndVersion() + " (" + loc + ")";
966 }
967 }