1 /*
2 * Copyright (c) 2018, 2019, 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 package jdk.jpackage.internal;
26
27 import java.io.File;
28 import java.io.FileInputStream;
29 import java.io.IOException;
30 import java.nio.file.Files;
31 import java.nio.file.Path;
32 import java.text.MessageFormat;
33 import java.util.ArrayList;
34 import java.util.Arrays;
35 import java.util.Collection;
36 import java.util.EnumSet;
37 import java.util.HashMap;
38 import java.util.HashSet;
39 import java.util.List;
40 import java.util.Map;
41 import java.util.Set;
42 import java.util.Properties;
43 import java.util.ResourceBundle;
44 import java.util.jar.Attributes;
45 import java.util.jar.JarFile;
46 import java.util.jar.Manifest;
47 import java.util.stream.Stream;
48 import java.util.regex.Matcher;
49 import java.util.regex.Pattern;
50
51 /**
52 * Arguments
53 *
54 * This class encapsulates and processes the command line arguments,
55 * in effect, implementing all the work of jpackage tool.
56 *
57 * The primary entry point, processArguments():
58 * Processes and validates command line arguments, constructing DeployParams.
59 * Validates the DeployParams, and generate the BundleParams.
60 * Generates List of Bundlers from BundleParams valid for this platform.
61 * Executes each Bundler in the list.
62 */
63 public class Arguments {
64 private static final ResourceBundle I18N = ResourceBundle.getBundle(
65 "jdk.jpackage.internal.resources.MainResources");
66
67 private static final String FA_EXTENSIONS = "extension";
68 private static final String FA_CONTENT_TYPE = "mime-type";
69 private static final String FA_DESCRIPTION = "description";
70 private static final String FA_ICON = "icon";
71
72 // regexp for parsing args (for example, for additional launchers)
73 private static Pattern pattern = Pattern.compile(
74 "(?:(?:([\"'])(?:\\\\\\1|.)*?(?:\\1|$))|(?:\\\\[\"'\\s]|[^\\s]))++");
75
76 private DeployParams deployParams = null;
77 private String packageType = null;
78
79 private int pos = 0;
80 private List<String> argList = null;
81
82 private List<CLIOptions> allOptions = null;
83
84 private String input = null;
85 private String output = null;
86
87 private boolean hasMainJar = false;
88 private boolean hasMainClass = false;
89 private boolean hasMainModule = false;
90 public boolean userProvidedBuildRoot = false;
91
92 private String buildRoot = null;
93 private String mainJarPath = null;
94
95 private static boolean runtimeInstaller = false;
96
97 private List<AddLauncherArguments> addLaunchers = null;
98
99 private static Map<String, CLIOptions> argIds = new HashMap<>();
100 private static Map<String, CLIOptions> argShortIds = new HashMap<>();
101
102 static {
103 // init maps for parsing arguments
104 (EnumSet.allOf(CLIOptions.class)).forEach(option -> {
105 argIds.put(option.getIdWithPrefix(), option);
106 if (option.getShortIdWithPrefix() != null) {
107 argShortIds.put(option.getShortIdWithPrefix(), option);
108 }
109 });
110 }
111
112 public Arguments(String[] args) {
113 argList = new ArrayList<String>(args.length);
114 for (String arg : args) {
115 argList.add(arg);
116 }
117 Log.debug ("\njpackage argument list: \n" + argList + "\n");
118 pos = 0;
119
120 deployParams = new DeployParams();
121
122 packageType = null;
123
124 allOptions = new ArrayList<>();
125
126 addLaunchers = new ArrayList<>();
127 }
128
129 // CLIOptions is public for DeployParamsTest
130 public enum CLIOptions {
131 PACKAGE_TYPE("package-type", OptionCategories.PROPERTY, () -> {
132 context().packageType = popArg();
133 context().deployParams.setTargetFormat(context().packageType);
134 }),
135
136 INPUT ("input", "i", OptionCategories.PROPERTY, () -> {
137 context().input = popArg();
138 setOptionValue("input", context().input);
139 }),
140
141 OUTPUT ("output", "o", OptionCategories.PROPERTY, () -> {
142 context().output = popArg();
143 context().deployParams.setOutput(new File(context().output));
144 }),
145
146 DESCRIPTION ("description", "d", OptionCategories.PROPERTY),
147
148 VENDOR ("vendor", OptionCategories.PROPERTY),
149
150 APPCLASS ("main-class", OptionCategories.PROPERTY, () -> {
151 context().hasMainClass = true;
152 setOptionValue("main-class", popArg());
153 }),
154
155 NAME ("name", "n", OptionCategories.PROPERTY),
156
157 IDENTIFIER ("identifier", OptionCategories.PROPERTY),
158
159 VERBOSE ("verbose", OptionCategories.PROPERTY, () -> {
160 setOptionValue("verbose", true);
161 Log.setVerbose(true);
162 }),
163
164 RESOURCE_DIR("resource-dir",
165 OptionCategories.PROPERTY, () -> {
166 String resourceDir = popArg();
167 setOptionValue("resource-dir", resourceDir);
168 }),
169
170 ARGUMENTS ("arguments", OptionCategories.PROPERTY, () -> {
171 List<String> arguments = getArgumentList(popArg());
172 setOptionValue("arguments", arguments);
173 }),
174
175 ICON ("icon", OptionCategories.PROPERTY),
176
177 COPYRIGHT ("copyright", OptionCategories.PROPERTY),
178
179 LICENSE_FILE ("license-file", OptionCategories.PROPERTY),
180
181 VERSION ("app-version", OptionCategories.PROPERTY),
182
183 JAVA_OPTIONS ("java-options", OptionCategories.PROPERTY, () -> {
184 List<String> args = getArgumentList(popArg());
185 args.forEach(a -> setOptionValue("java-options", a));
186 }),
187
188 FILE_ASSOCIATIONS ("file-associations",
189 OptionCategories.PROPERTY, () -> {
190 Map<String, ? super Object> args = new HashMap<>();
191
192 // load .properties file
193 Map<String, String> initialMap = getPropertiesFromFile(popArg());
194
195 String ext = initialMap.get(FA_EXTENSIONS);
196 if (ext != null) {
197 args.put(StandardBundlerParam.FA_EXTENSIONS.getID(), ext);
198 }
199
200 String type = initialMap.get(FA_CONTENT_TYPE);
201 if (type != null) {
202 args.put(StandardBundlerParam.FA_CONTENT_TYPE.getID(), type);
203 }
204
205 String desc = initialMap.get(FA_DESCRIPTION);
206 if (desc != null) {
207 args.put(StandardBundlerParam.FA_DESCRIPTION.getID(), desc);
208 }
209
210 String icon = initialMap.get(FA_ICON);
211 if (icon != null) {
212 args.put(StandardBundlerParam.FA_ICON.getID(), icon);
213 }
214
215 ArrayList<Map<String, ? super Object>> associationList =
216 new ArrayList<Map<String, ? super Object>>();
217
218 associationList.add(args);
219
220 // check that we really add _another_ value to the list
221 setOptionValue("file-associations", associationList);
222
223 }),
224
225 ADD_LAUNCHER ("add-launcher",
226 OptionCategories.PROPERTY, () -> {
227 String spec = popArg();
228 String name = null;
229 String filename = spec;
230 if (spec.contains("=")) {
231 String[] values = spec.split("=", 2);
232 name = values[0];
233 filename = values[1];
234 }
235 context().addLaunchers.add(
236 new AddLauncherArguments(name, filename));
237 }),
238
239 TEMP_ROOT ("temp-root", OptionCategories.PROPERTY, () -> {
240 context().buildRoot = popArg();
241 context().userProvidedBuildRoot = true;
242 setOptionValue("temp-root", context().buildRoot);
243 }),
244
245 INSTALL_DIR ("install-dir", OptionCategories.PROPERTY),
246
247 PREDEFINED_APP_IMAGE ("app-image", OptionCategories.PROPERTY),
248
249 PREDEFINED_RUNTIME_IMAGE ("runtime-image", OptionCategories.PROPERTY),
250
251 MAIN_JAR ("main-jar", OptionCategories.PROPERTY, () -> {
252 context().mainJarPath = popArg();
253 context().hasMainJar = true;
254 setOptionValue("main-jar", context().mainJarPath);
255 }),
256
257 MODULE ("module", "m", OptionCategories.MODULAR, () -> {
258 context().hasMainModule = true;
259 setOptionValue("module", popArg());
260 }),
261
262 ADD_MODULES ("add-modules", OptionCategories.MODULAR),
263
264 MODULE_PATH ("module-path", "p", OptionCategories.MODULAR),
265
266 MAC_SIGN ("mac-sign", "s", OptionCategories.PLATFORM_MAC, () -> {
267 setOptionValue("mac-sign", true);
268 }),
269
270 MAC_BUNDLE_NAME ("mac-bundle-name", OptionCategories.PLATFORM_MAC),
271
272 MAC_BUNDLE_IDENTIFIER("mac-bundle-identifier",
273 OptionCategories.PLATFORM_MAC),
274
275 MAC_APP_STORE_CATEGORY ("mac-app-store-category",
276 OptionCategories.PLATFORM_MAC),
277
278 MAC_BUNDLE_SIGNING_PREFIX ("mac-bundle-signing-prefix",
279 OptionCategories.PLATFORM_MAC),
280
281 MAC_SIGNING_KEY_NAME ("mac-signing-key-user-name",
282 OptionCategories.PLATFORM_MAC),
283
284 MAC_SIGNING_KEYCHAIN ("mac-signing-keychain",
285 OptionCategories.PLATFORM_MAC),
286
287 MAC_APP_STORE_ENTITLEMENTS ("mac-app-store-entitlements",
288 OptionCategories.PLATFORM_MAC),
289
290 WIN_MENU_HINT ("win-menu", OptionCategories.PLATFORM_WIN, () -> {
291 setOptionValue("win-menu", true);
292 }),
293
294 WIN_MENU_GROUP ("win-menu-group", OptionCategories.PLATFORM_WIN),
295
296 WIN_SHORTCUT_HINT ("win-shortcut",
297 OptionCategories.PLATFORM_WIN, () -> {
298 setOptionValue("win-shortcut", true);
299 }),
300
301 WIN_PER_USER_INSTALLATION ("win-per-user-install",
302 OptionCategories.PLATFORM_WIN, () -> {
303 setOptionValue("win-per-user-install", false);
304 }),
305
306 WIN_DIR_CHOOSER ("win-dir-chooser",
307 OptionCategories.PLATFORM_WIN, () -> {
308 setOptionValue("win-dir-chooser", true);
309 }),
310
311 WIN_REGISTRY_NAME ("win-registry-name", OptionCategories.PLATFORM_WIN),
312
313 WIN_UPGRADE_UUID ("win-upgrade-uuid",
314 OptionCategories.PLATFORM_WIN),
315
316 WIN_CONSOLE_HINT ("win-console", OptionCategories.PLATFORM_WIN, () -> {
317 setOptionValue("win-console", true);
318 }),
319
320 LINUX_BUNDLE_NAME ("linux-bundle-name",
321 OptionCategories.PLATFORM_LINUX),
322
323 LINUX_DEB_MAINTAINER ("linux-deb-maintainer",
324 OptionCategories.PLATFORM_LINUX),
325
326 LINUX_RPM_LICENSE_TYPE ("linux-rpm-license-type",
327 OptionCategories.PLATFORM_LINUX),
328
329 LINUX_PACKAGE_DEPENDENCIES ("linux-package-deps",
330 OptionCategories.PLATFORM_LINUX),
331
332 LINUX_MENU_GROUP ("linux-menu-group", OptionCategories.PLATFORM_LINUX);
333
334 private final String id;
335 private final String shortId;
336 private final OptionCategories category;
337 private final ArgAction action;
338 private static Arguments argContext;
339
340 private CLIOptions(String id, OptionCategories category) {
341 this(id, null, category, null);
342 }
343
344 private CLIOptions(String id, String shortId,
345 OptionCategories category) {
346 this(id, shortId, category, null);
347 }
348
349 private CLIOptions(String id,
350 OptionCategories category, ArgAction action) {
351 this(id, null, category, action);
352 }
353
354 private CLIOptions(String id, String shortId,
355 OptionCategories category, ArgAction action) {
356 this.id = id;
357 this.shortId = shortId;
358 this.action = action;
359 this.category = category;
360 }
361
362 static void setContext(Arguments context) {
363 argContext = context;
364 }
365
366 public static Arguments context() {
367 if (argContext != null) {
368 return argContext;
369 } else {
370 throw new RuntimeException("Argument context is not set.");
371 }
372 }
373
374 public String getId() {
375 return this.id;
376 }
377
378 String getIdWithPrefix() {
379 return "--" + this.id;
380 }
381
382 String getShortIdWithPrefix() {
383 return this.shortId == null ? null : "-" + this.shortId;
384 }
385
386 void execute() {
387 if (action != null) {
388 action.execute();
389 } else {
390 defaultAction();
391 }
392 }
393
394 OptionCategories getCategory() {
395 return category;
396 }
397
398 private void defaultAction() {
399 context().deployParams.addBundleArgument(id, popArg());
400 }
401
402 private static void setOptionValue(String option, Object value) {
403 context().deployParams.addBundleArgument(option, value);
404 }
405
406 private static String popArg() {
407 nextArg();
408 return (context().pos >= context().argList.size()) ?
409 "" : context().argList.get(context().pos);
410 }
411
412 private static String getArg() {
413 return (context().pos >= context().argList.size()) ?
414 "" : context().argList.get(context().pos);
415 }
416
417 private static void nextArg() {
418 context().pos++;
419 }
420
421 private static boolean hasNextArg() {
422 return context().pos < context().argList.size();
423 }
424 }
425
426 enum OptionCategories {
427 MODULAR,
428 PROPERTY,
429 PLATFORM_MAC,
430 PLATFORM_WIN,
431 PLATFORM_LINUX;
432 }
433
434 public boolean processArguments() {
435 try {
436
437 // init context of arguments
438 CLIOptions.setContext(this);
439
440 // parse cmd line
441 String arg;
442 CLIOptions option;
443 for (; CLIOptions.hasNextArg(); CLIOptions.nextArg()) {
444 arg = CLIOptions.getArg();
445 if ((option = toCLIOption(arg)) != null) {
446 // found a CLI option
447 allOptions.add(option);
448 option.execute();
449 } else {
450 throw new PackagerException("ERR_InvalidOption", arg);
451 }
452 }
453
454 if (hasMainJar && !hasMainClass) {
455 // try to get main-class from manifest
456 String mainClass = getMainClassFromManifest();
457 if (mainClass != null) {
458 CLIOptions.setOptionValue(
459 CLIOptions.APPCLASS.getId(), mainClass);
460 }
461 }
462
463 // display error for arguments that are not supported
464 // for current configuration.
465
466 validateArguments();
467
468 addResources(deployParams, input);
469
470 List<Map<String, ? super Object>> launchersAsMap =
471 new ArrayList<>();
472
473 for (AddLauncherArguments sl : addLaunchers) {
474 launchersAsMap.add(sl.getLauncherMap());
475 }
476
477 deployParams.addBundleArgument(
478 StandardBundlerParam.ADD_LAUNCHERS.getID(),
479 launchersAsMap);
480
481 // at this point deployParams should be already configured
482
483 deployParams.validate();
484
485 BundleParams bp = deployParams.getBundleParams();
486
487 // validate name(s)
488 ArrayList<String> usedNames = new ArrayList<String>();
489 usedNames.add(bp.getName()); // add main app name
490
491 for (AddLauncherArguments sl : addLaunchers) {
492 Map<String, ? super Object> slMap = sl.getLauncherMap();
493 String slName =
494 (String) slMap.get(Arguments.CLIOptions.NAME.getId());
495 if (slName == null) {
496 throw new PackagerException("ERR_NoAddLauncherName");
497 }
498 // same rules apply to additional launcher names as app name
499 DeployParams.validateName(slName, false);
500 for (String usedName : usedNames) {
501 if (slName.equals(usedName)) {
502 throw new PackagerException("ERR_NoUniqueName");
503 }
504 }
505 usedNames.add(slName);
506 }
507 if (runtimeInstaller && bp.getName() == null) {
508 throw new PackagerException("ERR_NoJreInstallerName");
509 }
510
511 generateBundle(bp.getBundleParamsAsMap());
512 return true;
513 } catch (Exception e) {
514 if (Log.isVerbose()) {
515 Log.verbose(e);
516 } else {
517 String msg1 = e.getMessage();
518 Log.error(msg1);
519 if (e.getCause() != null && e.getCause() != e) {
520 String msg2 = e.getCause().getMessage();
521 if (!msg1.contains(msg2)) {
522 Log.error(msg2);
523 }
524 }
525 }
526 return false;
527 }
528 }
529
530 private void validateArguments() throws PackagerException {
531 String packageType = deployParams.getTargetFormat();
532 String ptype = (packageType != null) ? packageType : "default";
533 boolean imageOnly = (packageType == null);
534 boolean hasAppImage = allOptions.contains(
535 CLIOptions.PREDEFINED_APP_IMAGE);
536 boolean hasRuntime = allOptions.contains(
537 CLIOptions.PREDEFINED_RUNTIME_IMAGE);
538 boolean installerOnly = !imageOnly && hasAppImage;
539 runtimeInstaller = !imageOnly && hasRuntime && !hasAppImage &&
540 !hasMainModule && !hasMainJar;
541
542 for (CLIOptions option : allOptions) {
543 if (!ValidOptions.checkIfSupported(option)) {
544 // includes option valid only on different platform
545 throw new PackagerException("ERR_UnsupportedOption",
546 option.getIdWithPrefix());
547 }
548 if (imageOnly) {
549 if (!ValidOptions.checkIfImageSupported(option)) {
550 throw new PackagerException("ERR_InvalidTypeOption",
551 option.getIdWithPrefix(), packageType);
552 }
553 } else if (installerOnly || runtimeInstaller) {
554 if (!ValidOptions.checkIfInstallerSupported(option)) {
555 if (runtimeInstaller) {
556 throw new PackagerException("ERR_NoInstallerEntryPoint",
557 option.getIdWithPrefix());
558 } else {
559 throw new PackagerException("ERR_InvalidTypeOption",
560 option.getIdWithPrefix(), ptype);
561 }
562 }
563 }
564 }
565 if (installerOnly && hasRuntime) {
566 // note --runtime-image is only for image or runtime installer.
567 throw new PackagerException("ERR_InvalidTypeOption",
568 CLIOptions.PREDEFINED_RUNTIME_IMAGE.getIdWithPrefix(),
569 ptype);
570 }
571 if (hasMainJar && hasMainModule) {
572 throw new PackagerException("ERR_BothMainJarAndModule");
573 }
574 if (imageOnly && !hasMainJar && !hasMainModule) {
575 throw new PackagerException("ERR_NoEntryPoint");
576 }
577 }
578
579 private jdk.jpackage.internal.Bundler getPlatformBundler() {
580 String bundleType = (packageType == null ? "IMAGE" : "INSTALLER");
581
582 for (jdk.jpackage.internal.Bundler bundler :
583 Bundlers.createBundlersInstance().getBundlers(bundleType)) {
584 if ((packageType == null) ||
585 packageType.equalsIgnoreCase(bundler.getID())) {
586 if (bundler.supported(runtimeInstaller)) {
587 return bundler;
588 }
589 }
590 }
591 return null;
592 }
593
594 private void generateBundle(Map<String,? super Object> params)
595 throws PackagerException {
596
597 boolean bundleCreated = false;
598
599 // the temp-root needs to be fetched from the params early,
600 // to prevent each copy of the params (such as may be used for
601 // additional launchers) from generating a separate temp-root when
602 // the default is used (the default is a new temp directory)
603 // The bundler.cleanup() below would not otherwise be able to
604 // clean these extra (and unneeded) temp directories.
605 StandardBundlerParam.TEMP_ROOT.fetchFrom(params);
606
607 // determine what bundler to run
608 jdk.jpackage.internal.Bundler bundler = getPlatformBundler();
609
610 if (bundler == null) {
611 throw new PackagerException("ERR_InvalidInstallerType",
612 deployParams.getTargetFormat());
613 }
614
615 Map<String, ? super Object> localParams = new HashMap<>(params);
616 try {
617 bundler.validate(localParams);
618 File result = bundler.execute(localParams, deployParams.outdir);
619 if (result == null) {
620 throw new PackagerException("MSG_BundlerFailed",
621 bundler.getID(), bundler.getName());
622 }
623 Log.verbose(MessageFormat.format(
624 I18N.getString("message.bundle-created"),
625 bundler.getName()));
626 } catch (UnsupportedPlatformException upe) {
627 Log.debug(upe);
628 throw new PackagerException(upe,
629 "MSG_BundlerPlatformException", bundler.getName());
630 } catch (ConfigException e) {
631 Log.debug(e);
632 if (e.getAdvice() != null) {
633 throw new PackagerException(e, "MSG_BundlerConfigException",
634 bundler.getName(), e.getMessage(), e.getAdvice());
635 } else {
636 throw new PackagerException(e,
637 "MSG_BundlerConfigExceptionNoAdvice",
638 bundler.getName(), e.getMessage());
639 }
640 } catch (RuntimeException re) {
641 Log.debug(re);
642 throw new PackagerException(re, "MSG_BundlerRuntimeException",
643 bundler.getName(), re.toString());
644 } finally {
645 if (userProvidedBuildRoot) {
646 Log.verbose(MessageFormat.format(
647 I18N.getString("message.debug-working-directory"),
648 (new File(buildRoot)).getAbsolutePath()));
649 } else {
650 // always clean up the temporary directory created
651 // when --temp-root option not used.
652 bundler.cleanup(localParams);
653 }
654 }
655 }
656
657 private void addResources(DeployParams deployParams,
658 String inputdir) throws PackagerException {
659
660 if (inputdir == null || inputdir.isEmpty()) {
661 return;
662 }
663
664 File baseDir = new File(inputdir);
665
666 if (!baseDir.isDirectory()) {
667 throw new PackagerException("ERR_InputNotDirectory", inputdir);
668 }
669 if (!baseDir.canRead()) {
670 throw new PackagerException("ERR_CannotReadInputDir", inputdir);
671 }
672
673 List<String> fileNames;
674 fileNames = new ArrayList<>();
675 try (Stream<Path> files = Files.list(baseDir.toPath())) {
676 files.forEach(file -> fileNames.add(
677 file.getFileName().toString()));
678 } catch (IOException e) {
679 Log.error("Unable to add resources: " + e.getMessage());
680 }
681 fileNames.forEach(file -> deployParams.addResource(baseDir, file));
682
683 deployParams.setClasspath();
684 }
685
686 static CLIOptions toCLIOption(String arg) {
687 CLIOptions option;
688 if ((option = argIds.get(arg)) == null) {
689 option = argShortIds.get(arg);
690 }
691 return option;
692 }
693
694 static Map<String, String> getPropertiesFromFile(String filename) {
695 Map<String, String> map = new HashMap<>();
696 // load properties file
697 File file = new File(filename);
698 Properties properties = new Properties();
699 try (FileInputStream in = new FileInputStream(file)) {
700 properties.load(in);
701 } catch (IOException e) {
702 Log.error("Exception: " + e.getMessage());
703 }
704
705 for (final String name: properties.stringPropertyNames()) {
706 map.put(name, properties.getProperty(name));
707 }
708
709 return map;
710 }
711
712 static List<String> getArgumentList(String inputString) {
713 List<String> list = new ArrayList<>();
714 if (inputString == null || inputString.isEmpty()) {
715 return list;
716 }
717
718 // The "pattern" regexp attempts to abide to the rule that
719 // strings are delimited by whitespace unless surrounded by
720 // quotes, then it is anything (including spaces) in the quotes.
721 Matcher m = pattern.matcher(inputString);
722 while (m.find()) {
723 String s = inputString.substring(m.start(), m.end()).trim();
724 // Ensure we do not have an empty string. trim() will take care of
725 // whitespace only strings. The regex preserves quotes and escaped
726 // chars so we need to clean them before adding to the List
727 if (!s.isEmpty()) {
728 list.add(unquoteIfNeeded(s));
729 }
730 }
731 return list;
732 }
733
734 private static String unquoteIfNeeded(String in) {
735 if (in == null) {
736 return null;
737 }
738
739 if (in.isEmpty()) {
740 return "";
741 }
742
743 // Use code points to preserve non-ASCII chars
744 StringBuilder sb = new StringBuilder();
745 int codeLen = in.codePointCount(0, in.length());
746 int quoteChar = -1;
747 for (int i = 0; i < codeLen; i++) {
748 int code = in.codePointAt(i);
749 if (code == '"' || code == '\'') {
750 // If quote is escaped make sure to copy it
751 if (i > 0 && in.codePointAt(i - 1) == '\\') {
752 sb.deleteCharAt(sb.length() - 1);
753 sb.appendCodePoint(code);
754 continue;
755 }
756 if (quoteChar != -1) {
757 if (code == quoteChar) {
758 // close quote, skip char
759 quoteChar = -1;
760 } else {
761 sb.appendCodePoint(code);
762 }
763 } else {
764 // opening quote, skip char
765 quoteChar = code;
766 }
767 } else {
768 sb.appendCodePoint(code);
769 }
770 }
771 return sb.toString();
772 }
773
774 private String getMainClassFromManifest() {
775 if (mainJarPath == null ||
776 input == null ) {
777 return null;
778 }
779
780 JarFile jf;
781 try {
782 File file = new File(input, mainJarPath);
783 if (!file.exists()) {
784 return null;
785 }
786 jf = new JarFile(file);
787 Manifest m = jf.getManifest();
788 Attributes attrs = (m != null) ? m.getMainAttributes() : null;
789 if (attrs != null) {
790 return attrs.getValue(Attributes.Name.MAIN_CLASS);
791 }
792 } catch (IOException ignore) {}
793 return null;
794 }
795
796 }