1 /*
   2  * Copyright (c) 2011, 2016, 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 com.sun.javafx.tools.packager;
  27 
  28 import com.oracle.tools.packager.*;
  29 import com.oracle.tools.packager.ConfigException;
  30 import com.oracle.tools.packager.UnsupportedPlatformException;
  31 import com.sun.javafx.tools.packager.bundlers.Bundler.BundleType;
  32 
  33 import java.io.File;
  34 import java.io.FileInputStream;
  35 import java.io.IOException;
  36 import java.text.MessageFormat;
  37 import java.util.*;
  38 import jdk.packager.internal.JLinkBundlerHelper;
  39 
  40 
  41 public class Main {
  42 
  43     private static final ResourceBundle bundle =
  44             ResourceBundle.getBundle("com/sun/javafx/tools/packager/Bundle");
  45 
  46     private static final String version = bundle.getString("MSG_Version")
  47             + " " + PackagerLib.JAVAFX_VERSION + "\n";
  48     private static final String help = bundle.getString("MSG_Help_1")
  49                                         + bundle.getString("MSG_Help_2")
  50                                         + bundle.getString("MSG_Help_3")
  51                                         + bundle.getString("MSG_Help_4")
  52                                         + bundle.getString("MSG_Help_5")
  53                                         + bundle.getString("MSG_Help_6")
  54                                         + bundle.getString("MSG_Help_7");
  55 
  56     private static String nextArg(String args[], int i) {
  57         return (i == args.length - 1) ? "" : args[i + 1];
  58     }
  59 
  60     private static boolean verbose = false;
  61     private static boolean packageAsJar = false;
  62     private static boolean genJNLP = false;
  63     private static boolean genPackages = false;
  64     private static boolean css2Bin = false;
  65     private static boolean signJar = false;
  66     private static boolean makeAll = false;
  67 
  68     private static void addResources(CommonParams commonParams,
  69                                      String baseDir, String s) {
  70         if (s == null || "".equals(s)) {
  71             return;
  72         }
  73 
  74         String ls = ".";
  75 
  76         if (s != null) {
  77             ls = s;
  78         }
  79 
  80         String[] pathArray = ls.split(File.pathSeparator);
  81 
  82         File lbaseDir = null;
  83 
  84         if (baseDir != null) {
  85             lbaseDir = new File(baseDir);
  86         }
  87 
  88         for (final String path: pathArray) {
  89             commonParams.addResource(lbaseDir, path);
  90         }
  91     }
  92 
  93     private static void addArgument(DeployParams deployParams, String argument) {
  94         if (deployParams.arguments != null) {
  95             deployParams.arguments.add(argument);
  96         } else {
  97             List<String> list = new LinkedList<>();
  98             list.add(argument);
  99             deployParams.setArguments(list);
 100         }
 101     }
 102 
 103     private static void addArgument(CreateJarParams deployParams, String argument) {
 104         if (deployParams.arguments != null) {
 105             deployParams.arguments.add(argument);
 106         } else {
 107             List<String> list = new LinkedList<>();
 108             list.add(argument);
 109             deployParams.setArguments(list);
 110         }
 111     }
 112 
 113     private static Map<String, String> createAttrMap(String arg) {
 114         Map<String, String> map = new HashMap<>();
 115         if (arg == null || "".equals(arg)) {
 116             return null;
 117         }
 118         String[] pairsArray = arg.split(",");
 119         for (String pair: pairsArray) {
 120             String[] attr = pair.split("=");
 121             map.put(attr[0].trim(), attr[1].trim());
 122         }
 123         return map;
 124     }
 125 
 126     private static List<Param> parseParams(String filename) throws IOException {
 127         File paramFile = new File(filename);
 128         Properties properties = new Properties();
 129         FileInputStream in = new FileInputStream(paramFile);
 130         properties.load(in);
 131         in.close();
 132 
 133         List<Param> parameters = new ArrayList<>(properties.size());
 134 
 135         for (Map.Entry en : properties.entrySet()) {
 136             Param p = new Param();
 137             p.setName((String)en.getKey());
 138             p.setValue((String)en.getValue());
 139             parameters.add(p);
 140         }
 141         return parameters;
 142     }
 143 
 144     private static List<HtmlParam> parseHtmlParams(String filename) throws IOException {
 145         File paramFile = new File(filename);
 146         Properties properties = new Properties();
 147         FileInputStream in = new FileInputStream(paramFile);
 148         properties.load(in);
 149         in.close();
 150 
 151         List<HtmlParam> parameters = new ArrayList<>(properties.size());
 152 
 153         for (Map.Entry en : properties.entrySet()) {
 154             HtmlParam p = new HtmlParam();
 155             p.setName((String)en.getKey());
 156             p.setValue((String)en.getValue());
 157             parameters.add(p);
 158         }
 159         return parameters;
 160     }
 161 
 162     private static List<JSCallback> parseCallbacks(String param) {
 163         String[] callbacks = param.split(",");
 164         List<JSCallback> list = new ArrayList<>(callbacks.length);
 165 
 166         for (String cb: callbacks) {
 167             String[] nameCmd = cb.split(":");
 168             if (nameCmd.length == 2) {
 169                 list.add(new JSCallback(nameCmd[0], nameCmd[1]));
 170             }
 171         }
 172         return list;
 173     }
 174 
 175 
 176     @SuppressWarnings("deprecation")
 177     public static void main(String... args) throws Exception {
 178         if (args.length == 0 || args.length == 1 && args[0].equals("-help")) {
 179             System.out.println(help);
 180         } else if (args.length == 1 && args[0].equals("-version")) {
 181             System.out.println(version);
 182         } else {
 183             PackagerLib packager = new PackagerLib();
 184             CreateJarParams createJarParams = new CreateJarParams();
 185             DeployParams deployParams = new DeployParams();
 186             CreateBSSParams createBssParams = new CreateBSSParams();
 187             SignJarParams signJarParams = new SignJarParams();
 188             MakeAllParams makeAllParams = new MakeAllParams();
 189             String srcdir = null;
 190             String srcfiles = null;
 191 
 192             try {
 193                 if (args[0].equalsIgnoreCase("-createjar")) {
 194                     for (int i = 1; i < args.length; i++) {
 195                         String arg = args[i];
 196                         if (arg.equalsIgnoreCase("-appclass")) {
 197                             createJarParams.setApplicationClass(nextArg(args, i++));
 198                         } else if (arg.equalsIgnoreCase("-preloader")) {
 199                             createJarParams.setPreloader(nextArg(args, i++));
 200                         } else if (arg.equalsIgnoreCase("-classpath")) {
 201                             createJarParams.setClasspath(nextArg(args, i++));
 202                         } else if (arg.equalsIgnoreCase("-manifestAttrs")) {
 203                             createJarParams.setManifestAttrs(createAttrMap(nextArg(args, i++)));
 204                         } else if (arg.equalsIgnoreCase("-noembedlauncher")) {
 205                             System.err.println("-noembedlauncher is deprecated");
 206                         } else if (arg.equalsIgnoreCase("-nocss2bin")) {
 207                             createJarParams.setCss2bin(false);
 208                         } else if (arg.equalsIgnoreCase("-runtimeVersion")) {
 209                             createJarParams.setFxVersion(nextArg(args, i++));
 210                             System.err.println("-runtimeVersion is deprecated");
 211                         } else if (arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
 212                             createJarParams.setVerbose(true);
 213                             verbose = true;
 214                         } else if (arg.equalsIgnoreCase("-outdir")) {
 215                             createJarParams.setOutdir(new File(nextArg(args, i++)));
 216                         } else if (arg.equalsIgnoreCase("-outfile")) {
 217                             createJarParams.setOutfile(nextArg(args, i++));
 218                         } else if (arg.equalsIgnoreCase("-" + StandardBundlerParam.SOURCE_DIR.getID())) {
 219                             srcdir = nextArg(args, i++);
 220                         } else if (arg.equalsIgnoreCase("-srcfiles")) {
 221                             srcfiles = nextArg(args, i++);
 222                         } else if (arg.equalsIgnoreCase("-argument")) {
 223                             addArgument(createJarParams, nextArg(args, i++));
 224                         }  else if (arg.equalsIgnoreCase("-paramFile")) {
 225                             createJarParams.setParams(parseParams(nextArg(args, i++)));
 226                         } else {
 227                             throw new PackagerException("ERR_UnknownArgument", arg);
 228                         }
 229                     }
 230 
 231                     addResources(createJarParams, srcdir, srcfiles);
 232                     packageAsJar = true;
 233                 } else if (args[0].equalsIgnoreCase("-deploy")) {
 234                     File templateInFile = null;
 235                     File templateOutFile = null;
 236                     deployParams.setBundleType(BundleType.JNLP);
 237                     deployParams.setTargetFormat("jnlp");
 238 
 239 
 240                     //can only set it to true with command line, reset default
 241                     deployParams.setEmbedJNLP(false);
 242                     for (int i = 1; i < args.length; i++) {
 243                         String arg = args[i];
 244                         if (arg.startsWith("-B")) {
 245                             String key;
 246                             String value;
 247 
 248                             int keyStart = 2;
 249                             int equals = arg.indexOf("=");
 250                             int len = arg.length();
 251                             if (equals < keyStart) {
 252                                 if (keyStart < len) {
 253                                     key = arg.substring(keyStart, len);
 254                                     value = Boolean.TRUE.toString();
 255                                 } else {
 256                                     continue;
 257                                 }
 258                             } else if (keyStart < equals) {
 259                                 key = arg.substring(keyStart, equals);
 260                                 value = arg.substring(equals+1, len);
 261                             } else {
 262                                 continue;
 263                             }
 264                             deployParams.addBundleArgument(key, value);
 265                         } else if (arg.equalsIgnoreCase("-title")) {
 266                             deployParams.setTitle(nextArg(args, i++));
 267                         } else if (arg.equalsIgnoreCase("-vendor")) {
 268                             deployParams.setVendor(nextArg(args, i++));
 269                         } else if (arg.equalsIgnoreCase("-native")) {
 270                             BundleType type = BundleType.NONE;
 271                             String format = null; //null means ANY
 272                             if (i+1 < args.length && !args[i+1].startsWith("-")) {
 273                                 String v = args[++i];
 274                                 com.sun.javafx.tools.packager.bundlers.Bundler.Bundle bundle =
 275                                         com.sun.javafx.tools.packager.bundlers.Bundler.stringToBundle(v);
 276                                 type = bundle.type;
 277                                 format = bundle.format;
 278                             }
 279                             deployParams.setBundleType(type);
 280                             deployParams.setTargetFormat(format);
 281                         } else if (arg.equalsIgnoreCase("-description")) {
 282                             deployParams.setDescription(nextArg(args, i++));
 283                         } else if(arg.equalsIgnoreCase("-appclass")) {
 284                             deployParams.setApplicationClass(nextArg(args, i++));
 285                         } else if(arg.equalsIgnoreCase("-daemon")) {
 286                             deployParams.setServiceHint(true);
 287                         } else if(arg.equalsIgnoreCase("-installdirChooser")) {
 288                             deployParams.setInstalldirChooser(true);
 289                         } else if (arg.equalsIgnoreCase("-preloader")) {
 290                             deployParams.setPreloader(nextArg(args, i++));
 291                         } else if (arg.equalsIgnoreCase("-paramFile")) {
 292                             deployParams.setParams(parseParams(nextArg(args, i++)));
 293                         } else if (arg.equalsIgnoreCase("-htmlParamFile")) {
 294                             deployParams.setHtmlParams(parseHtmlParams(nextArg(args, i++)));
 295                         } else if (arg.equalsIgnoreCase("-width")) {
 296                             deployParams.setWidth(Integer.parseInt(nextArg(args, i++)));
 297                         } else if (arg.equalsIgnoreCase("-height")) {
 298                             deployParams.setHeight(Integer.parseInt(nextArg(args, i++)));
 299                         } else if (arg.equalsIgnoreCase("-name")) {
 300                             deployParams.setAppName(nextArg(args, i++));
 301                         } else if (arg.equalsIgnoreCase("-embedJNLP")) {
 302                             deployParams.setEmbedJNLP(true);
 303                         } else if (arg.equalsIgnoreCase("-embedCertificates")) {
 304                             System.err.println("-embedCertificates is deprecated");
 305                         } else if (arg.equalsIgnoreCase("-allpermissions")) {
 306                             deployParams.setAllPermissions(true);
 307                         } else if (arg.equalsIgnoreCase("-updatemode")) {
 308                             deployParams.setUpdateMode(nextArg(args, i++));
 309                         } else if (arg.equalsIgnoreCase("-isExtension")) {
 310                             deployParams.setExtension(true);
 311                         } else if (arg.equalsIgnoreCase("-callbacks")) {
 312                             deployParams.setJSCallbacks(parseCallbacks(nextArg(args, i++)));
 313                         } else if (arg.equalsIgnoreCase("-templateInFilename")) {
 314                             templateInFile = new File(nextArg(args, i++));
 315                         } else if (arg.equalsIgnoreCase("-templateOutFilename")) {
 316                             templateOutFile = new File(nextArg(args, i++));
 317                         } else if (arg.equalsIgnoreCase("-appId") || arg.equalsIgnoreCase("-templateId")) {
 318                             String appIdArg = nextArg(args, i++);
 319                             deployParams.setAppId(appIdArg);
 320                             deployParams.setId(appIdArg);
 321                         } else if (arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
 322                             deployParams.setVerbose(true);
 323                             verbose = true;
 324                         } else if (arg.equalsIgnoreCase("-includedt")) {
 325                             deployParams.setIncludeDT(true);
 326                         } else if (arg.equalsIgnoreCase("-outdir")) {
 327                             deployParams.setOutdir(new File(nextArg(args, i++)));
 328                         } else if (arg.equalsIgnoreCase("-outfile")) {
 329                             deployParams.setOutfile(nextArg(args, i++));
 330                         } else if (arg.equalsIgnoreCase("-" + StandardBundlerParam.SOURCE_DIR.getID())) {
 331                             srcdir = nextArg(args, i++);
 332                             deployParams.srcdir = srcdir;
 333                         } else if (arg.equalsIgnoreCase("-srcfiles")) {
 334                             srcfiles = nextArg(args, i++);
 335                         } else if (arg.equalsIgnoreCase("-argument")) {
 336                             addArgument(deployParams, nextArg(args, i++));
 337                         } else if (arg.equalsIgnoreCase("-nosign")) {
 338                             deployParams.setSignBundle(false);
 339                         } else if (arg.equals(ADD_MODULES)) {
 340                             deployParams.addModules.add(nextArg(args, i++));
 341                         } else if (arg.startsWith(ADD_MODULES + "=")) {
 342                             deployParams.addModules.add(arg.replace(ADD_MODULES + "=", ""));
 343                         } else if (arg.equals(LIMIT_MODULES)) {
 344                             deployParams.limitModules.add(nextArg(args, i++));
 345                         } else if (arg.startsWith(LIMIT_MODULES + "=")) {
 346                             deployParams.limitModules.add(arg.replace(LIMIT_MODULES + "=", ""));
 347                         } else if (arg.equals(STRIP_NATIVE_COMMANDS)) {
 348                             deployParams.setStripNativeCommands(Boolean.valueOf(nextArg(args, i++)));
 349                         } else if (arg.equals(STRIP_NATIVE_COMMANDS + "=")) {
 350                             deployParams.setStripNativeCommands(Boolean.valueOf(arg.replace(STRIP_NATIVE_COMMANDS + "=", "")));
 351                         } else if (arg.equals(DETECT_MODULES)) {
 352                             deployParams.setDetectModules(true);
 353                         } else if (arg.equals(MODULE_PATH) || arg.equals(P)) {
 354                             deployParams.modulePath = nextArg(args, i++);
 355                         } else if (arg.equals(MODULE_PATH + "=")) {
 356                             deployParams.modulePath = arg.replace(MODULE_PATH + "=", "");
 357                         } else if (arg.equals(MODULE) || arg.equals(M)) {
 358                             deployParams.setModule(nextArg(args, i++));
 359                         } else if (arg.equals(MODULE + "=")) {
 360                             deployParams.setModule(arg.replace(MODULE + "=", ""));
 361                         } else if (arg.startsWith(J_XDEBUG)) {
 362                             deployParams.setDebug(arg.replace(J_XDEBUG, ""));
 363                         } else {
 364                             throw new PackagerException("ERR_UnknownArgument", arg);
 365                         }
 366                     }
 367                     if (templateInFile != null) {
 368                         deployParams.addTemplate(templateInFile, templateOutFile);
 369                     }
 370 
 371                     if (deployParams.validateForJNLP()) {
 372                         genJNLP = true;
 373                     }
 374 
 375                     if (deployParams.validateForBundle()) {
 376                         genPackages = true;
 377                     }
 378 
 379                     addResources(deployParams, srcdir, srcfiles);
 380                 } else if (args[0].equalsIgnoreCase("-createbss")) {
 381                     for (int i = 1; i < args.length; i++) {
 382                         String arg = args[i];
 383                         if (arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
 384                             createBssParams.setVerbose(true);
 385                             verbose = true;
 386                         } else if (arg.equalsIgnoreCase("-outdir")) {
 387                             createBssParams.setOutdir(new File(nextArg(args, i++)));
 388                         } else if (arg.equalsIgnoreCase("-srcdir")) {
 389                             srcdir = nextArg(args, i++);
 390                         } else if (arg.equalsIgnoreCase("-srcfiles")) {
 391                             srcfiles = nextArg(args, i++);
 392                         } else {
 393                             throw new PackagerException("ERR_UnknownArgument", arg);
 394                         }
 395                     }
 396 
 397                     addResources(createBssParams, srcdir, srcfiles);
 398                     css2Bin = true;
 399                 } else if (args[0].equalsIgnoreCase("-signJar")) {
 400                     for (int i = 1; i < args.length; i++) {
 401                         String arg = args[i];
 402                         if (arg.equalsIgnoreCase("-keyStore")) {
 403                             signJarParams.setKeyStore(new File(nextArg(args, i++)));
 404                         } else if(arg.equalsIgnoreCase("-alias")) {
 405                             signJarParams.setAlias(nextArg(args, i++));
 406                         } else if(arg.equalsIgnoreCase("-storePass")) {
 407                             signJarParams.setStorePass(nextArg(args, i++));
 408                         } else if(arg.equalsIgnoreCase("-keyPass")) {
 409                             signJarParams.setKeyPass(nextArg(args, i++));
 410                         } else if(arg.equalsIgnoreCase("-storeType")) {
 411                             signJarParams.setStoreType(nextArg(args, i++));
 412                         } else if(arg.equalsIgnoreCase("-verbose") || arg.equalsIgnoreCase("-v")) {
 413                             signJarParams.setVerbose(true);
 414                             verbose = true;
 415                         } else if (arg.equalsIgnoreCase("-outdir")) {
 416                             signJarParams.setOutdir(new File(nextArg(args, i++)));
 417                         } else if (arg.equalsIgnoreCase("-srcdir")) {
 418                             srcdir = nextArg(args, i++);
 419                         } else if (arg.equalsIgnoreCase("-srcfiles")) {
 420                             srcfiles = nextArg(args, i++);
 421                         } else {
 422                             throw new PackagerException("ERR_UnknownArgument", arg);
 423                         }
 424                     }
 425 
 426                     addResources(signJarParams, srcdir, srcfiles);
 427                     signJar = true;
 428                 } else if (args[0].equalsIgnoreCase("-makeall")) {
 429                     System.err.println("-makeall is deprecated");
 430                     for (int i = 1; i < args.length; i++) {
 431                         String arg = args[i];
 432                         if (arg.equalsIgnoreCase("-appclass")) {
 433                             makeAllParams.setAppClass(nextArg(args, i++));
 434                         } else if (arg.equalsIgnoreCase("-preloader")) {
 435                             makeAllParams.setPreloader(nextArg(args, i++));
 436                         } else if (arg.equalsIgnoreCase("-classpath")) {
 437                             makeAllParams.setClasspath(nextArg(args, i++));
 438                         } else if (arg.equalsIgnoreCase("-name")) {
 439                             makeAllParams.setAppName(nextArg(args, i++));
 440                         } else if(arg.equalsIgnoreCase("-width")) {
 441                             makeAllParams.setWidth(Integer.parseInt(nextArg(args, i++)));
 442                         } else if(arg.equalsIgnoreCase("-height")) {
 443                             makeAllParams.setHeight(Integer.parseInt(nextArg(args, i++)));
 444                         } else if(arg.equalsIgnoreCase("-v")) {
 445                             makeAllParams.setVerbose(true);
 446                         } else {
 447                             throw new PackagerException("ERR_UnknownArgument", arg);
 448                         }
 449                     }
 450                     makeAll = true;
 451                 } else if (args[0].equalsIgnoreCase("-help")) {
 452                     showBundlerHelp(args[1], args.length > 2 && "-verbose".equals(args[2]));
 453                 } else {
 454                     System.err.println(MessageFormat.format(
 455                                         bundle.getString("ERR_UnknownCommand"),
 456                                         args[0]));
 457                     System.exit(-1);
 458                 }
 459 
 460                 //set default logger
 461                 if (verbose) {
 462                     com.oracle.tools.packager.Log.setLogger(new com.oracle.tools.packager.Log.Logger(true));
 463                 } else {
 464                     com.oracle.tools.packager.Log.setLogger(new com.oracle.tools.packager.Log.Logger(false));
 465                 }
 466 
 467                 if (css2Bin) {
 468                     createBssParams.validate();
 469                     packager.generateBSS(createBssParams);
 470                 }
 471                 if (packageAsJar) {
 472                     createJarParams.validate();
 473                     packager.packageAsJar(createJarParams);
 474                 }
 475                 if (genJNLP) {
 476                     deployParams.setBundleType(BundleType.JNLP);
 477                     deployParams.validate();
 478                     packager.generateDeploymentPackages(deployParams);
 479                 }
 480                 if (genPackages) {
 481                     deployParams.setBundleType(BundleType.NATIVE);
 482                     deployParams.validate();
 483                     packager.generateDeploymentPackages(deployParams);
 484                 }
 485                 if (signJar) {
 486                     signJarParams.validate();
 487                     if (signJarParams.storePass == null) {
 488                         char[] passwd = System.console().readPassword(bundle.getString("MSG_EnterKeystorePassword"));
 489                         if (passwd == null) {
 490                             signJarParams.storePass = "";
 491                         } else {
 492                             signJarParams.storePass = new String(passwd);
 493                         }
 494                     }
 495                     if (signJarParams.keyPass == null) {
 496                         char[] passwd = System.console().readPassword(bundle.getString("MSG_EnterKeyPassword"), signJarParams.alias);
 497                         if (passwd == null) {
 498                             signJarParams.keyPass = "";
 499                         } else {
 500                             signJarParams.keyPass = new String(passwd);
 501                         }
 502                     }
 503                     packager.signJar(signJarParams);
 504                 }
 505                 if (makeAll) {
 506                     makeAllParams.validate();
 507                     packager.makeAll(makeAllParams);
 508                 }
 509 
 510             } catch (Exception e) {
 511                 if (verbose) {
 512                     throw e;
 513                 } else {
 514                     System.err.println(e.getMessage());
 515                     if (e.getCause() != null && e.getCause() != e) {
 516                         System.err.println(e.getCause().getMessage());
 517                     }
 518                     System.exit(-1);
 519                 }
 520             }
 521         }
 522     }
 523     private static final String J_XDEBUG = JLinkBundlerHelper.DEBUG.getID() + ":";
 524 
 525     private static final String MODULE = "--" + JLinkBundlerHelper.MODULE.getID();
 526     private static final String M = "-m";
 527     private static final String MODULE_PATH = "--" + JLinkBundlerHelper.MODULE_PATH.getID();
 528     private static final String P = "-p";
 529     private static final String ADD_MODULES = "--" + JLinkBundlerHelper.ADD_MODULES.getID();
 530     private static final String LIMIT_MODULES = "--" + JLinkBundlerHelper.LIMIT_MODULES.getID();
 531     private static final String STRIP_NATIVE_COMMANDS = "--" + JLinkBundlerHelper.STRIP_NATIVE_COMMANDS.getID();
 532     private static final String DETECT_MODULES = "--" + JLinkBundlerHelper.DETECT_MODULES.getID();
 533 
 534     public static void showBundlerHelp(String bundlerName, boolean verbose) {
 535         //TODO I18N
 536         if ("bundlers".equals(bundlerName)) {
 537             // enumerate bundlers
 538             System.out.println("Known Bundlers -- \n");
 539             for (Bundler bundler : Bundlers.createBundlersInstance().getBundlers()) {
 540                 try {
 541                     bundler.validate(new HashMap<>());
 542                 } catch (UnsupportedPlatformException upe) {
 543                     // don't list bundlers this platform cannot run
 544                     continue;
 545                 } catch (ConfigException ignore) {
 546                     // but requiring more than an empty map is perfectly fine.
 547                 //} catch (RuntimeException re) {
 548                 //    re.printStackTrace();
 549                 }
 550 
 551                 if (verbose) {
 552                     System.out.printf(
 553                             "%s - %s - %s\n\t%s\n",
 554                             bundler.getID(),
 555                             bundler.getName(),
 556                             bundler.getBundleType(),
 557                             bundler.getDescription()
 558                     );
 559                 } else {
 560                     System.out.printf(
 561                             "%s - %s - %s\n",
 562                             bundler.getID(),
 563                             bundler.getName(),
 564                             bundler.getBundleType()
 565                     );
 566                 }
 567             }
 568         } else {
 569             // enumerate parameters for a bundler
 570             for (Bundler bundler : Bundlers.createBundlersInstance().getBundlers()) {
 571                 if (bundler.getID().equals(bundlerName)) {
 572                     System.out.printf("Bundler Parameters for %s (%s) --\n", bundler.getName(), bundler.getID());
 573                     for (BundlerParamInfo bpi : bundler.getBundleParameters()) {
 574                         if (bpi.getStringConverter() == null) continue;
 575                         if (verbose) {
 576                             System.out.printf(
 577                                     "%s - %s - %s\n\t%s\n",
 578                                     bpi.getID(),
 579                                     bpi.getName(),
 580                                     bpi.getValueType().getSimpleName(),
 581                                     bpi.getDescription()
 582                             );
 583                         } else {
 584                             System.out.printf(
 585                                     "%s - %s - %s\n",
 586                                     bpi.getID(),
 587                                     bpi.getName(),
 588                                     bpi.getValueType().getSimpleName()
 589                             );
 590                         }
 591                     }
 592                     return;
 593                 }
 594             }
 595             System.out.printf("Sorry, no bundler matching the id %s was found.\n", bundlerName);
 596         }
 597     }
 598 }