--- /dev/null	2018-10-22 10:23:37.000000000 -0400
+++ new/src/demo/share/jpackager/JNLPConverter/src/jnlp/converter/parser/GeneralUtil.java	2018-10-22 10:23:34.744062800 -0400
@@ -0,0 +1,415 @@
+/*
+ * Copyright (c) 2006, 2018, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package jnlp.converter.parser;
+
+import java.util.Locale;
+import java.util.ArrayList;
+import java.util.StringTokenizer;
+import java.io.BufferedInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.MalformedURLException;
+import java.net.URL;
+
+/**
+ * Handy class to add some utility methods for dealing with property matching
+ * etc.
+ */
+public class GeneralUtil {
+
+    public static boolean prefixMatchStringList(String[] prefixList, String target) {
+        // No prefixes matches everything
+        if (prefixList == null) {
+            return true;
+        }
+        // No target, but a prefix list does not match anything
+        if (target == null) {
+            return false;
+        }
+        for (String prefix : prefixList) {
+            if (target.startsWith(prefix)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static String getOSArch() {
+        return System.getProperty("os.arch");
+    }
+
+    public static boolean prefixMatchArch(String[] prefixList) {
+        // No prefixes matches everything
+        if (prefixList == null) {
+            return true;
+        }
+
+        // check for the current arch
+        String arch = getOSArch();
+        for (String prefix : prefixList) {
+            if (arch.startsWith(prefix)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Converts a space delimited string to a list of strings
+     */
+    public static String[] getStringList(String str) {
+        if (str == null) {
+            return null;
+        }
+        ArrayList<String> list = new ArrayList<>();
+        int i = 0;
+        int length = str.length();
+        StringBuffer sb = null;
+        while (i < length) {
+            char ch = str.charAt(i);
+            switch (ch) {
+                case ' ':
+                    // A space was hit. Add string to list
+                    if (sb != null) {
+                        list.add(sb.toString());
+                        sb = null;
+                    }
+                    break;
+                case '\\':
+                    // It is a delimiter. Add next character
+                    if (i + 1 < length) {
+                        ch = str.charAt(++i);
+                        if (sb == null) {
+                            sb = new StringBuffer();
+                        }
+                        sb.append(ch);
+                    }
+                    break;
+                default:
+                    if (sb == null) {
+                        sb = new StringBuffer();
+                    }   sb.append(ch);
+                    break;
+            }
+            i++; // Next character
+        }
+        // Make sure to add the last part to the list too
+        if (sb != null) {
+            list.add(sb.toString());
+        }
+        if (list.isEmpty()) {
+            return null;
+        }
+        String[] results = new String[list.size()];
+        return list.toArray(results);
+    }
+
+    /**
+     * Checks if string list matches default locale
+     */
+    public static boolean matchLocale(String[] localeList, Locale locale) {
+        // No locale specified matches everything
+        if (localeList == null) {
+            return true;
+        }
+        for (String localeList1 : localeList) {
+            if (matchLocale(localeList1, locale)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Checks if string matches default locale
+     */
+    public static boolean matchLocale(String localeStr, Locale locale) {
+        if (localeStr == null || localeStr.length() == 0) {
+            return true;
+        }
+
+        // Compare against default locale
+        String language;
+        String country;
+        String variant;
+
+        // The locale string is of the form language_country_variant
+        StringTokenizer st = new StringTokenizer(localeStr, "_", false);
+        if (st.hasMoreElements() && locale.getLanguage().length() > 0) {
+            language = st.nextToken();
+            if (!language.equalsIgnoreCase(locale.getLanguage())) {
+                return false;
+            }
+        }
+        if (st.hasMoreElements() && locale.getCountry().length() > 0) {
+            country = st.nextToken();
+            if (!country.equalsIgnoreCase(locale.getCountry())) {
+                return false;
+            }
+        }
+        if (st.hasMoreElements() && locale.getVariant().length() > 0) {
+            variant = st.nextToken();
+            if (!variant.equalsIgnoreCase(locale.getVariant())) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public static long heapValToLong(String heapValue) {
+        if (heapValue == null) {
+            return -1;
+        }
+        long multiplier = 1;
+        if (heapValue.toLowerCase().lastIndexOf('m') != -1) {
+            // units are megabytes, 1 megabyte = 1024 * 1024 bytes
+            multiplier = 1024 * 1024;
+            heapValue = heapValue.substring(0, heapValue.length() - 1);
+        } else if (heapValue.toLowerCase().lastIndexOf('k') != -1) {
+            // units are kilobytes, 1 kilobyte = 1024 bytes
+            multiplier = 1024;
+            heapValue = heapValue.substring(0, heapValue.length() - 1);
+        }
+        long theValue;
+        try {
+            theValue = Long.parseLong(heapValue);
+            theValue = theValue * multiplier;
+        } catch (NumberFormatException e) {
+            theValue = -1;
+        }
+        return theValue;
+    }
+
+    public static byte[] readBytes(InputStream is, long size) throws IOException {
+        // Sanity on file size (restrict to 1M)
+        if (size > 1024 * 1024) {
+            throw new IOException("File too large");
+        }
+
+        BufferedInputStream bis;
+        if (is instanceof BufferedInputStream) {
+            bis = (BufferedInputStream) is;
+        } else {
+            bis = new BufferedInputStream(is);
+        }
+
+        if (size <= 0) {
+            size = 10 * 1024; // Default to 10K
+        }
+        byte[] b = new byte[(int) size];
+        int n;
+        int bytesRead = 0;
+        n = bis.read(b, bytesRead, b.length - bytesRead);
+        while (n != -1) {
+            bytesRead += n;
+            // Still room in array
+            if (b.length == bytesRead) {
+                byte[] bb = new byte[b.length * 2];
+                System.arraycopy(b, 0, bb, 0, b.length);
+                b = bb;
+            }
+            // Read next line
+            n = bis.read(b, bytesRead, b.length - bytesRead);
+        }
+        bis.close();
+        is.close();
+
+        if (bytesRead != b.length) {
+            byte[] bb = new byte[bytesRead];
+            System.arraycopy(b, 0, bb, 0, bytesRead);
+            b = bb;
+        }
+        return b;
+    }
+
+    public static String getOSFullName() {
+        return System.getProperty("os.name");
+    }
+
+    /**
+     * Makes sure a URL is a path URL, i.e., ends with '/'
+     */
+    public static URL asPathURL(URL url) {
+        if (url == null) {
+            return null;
+        }
+
+        String path = url.getFile();
+        if (path != null && !path.endsWith("/")) {
+            try {
+                return new URL(url.getProtocol(),
+                        url.getHost(),
+                        url.getPort(),
+                        url.getFile() + "/");
+            } catch (MalformedURLException mue) {
+                // Should not happen
+            }
+        }
+        // Just return same URl
+        return url;
+    }
+
+    public static Locale getDefaultLocale() {
+        return Locale.getDefault();
+    }
+
+    public static String toNormalizedString(URL u) {
+        if (u == null) {
+            return "";
+        }
+
+        try {
+            if (u.getPort() == u.getDefaultPort()) {
+                u = new URL(u.getProtocol().toLowerCase(),
+                        u.getHost().toLowerCase(), -1, u.getFile());
+            } else {
+                u = new URL(u.getProtocol().toLowerCase(),
+                        u.getHost().toLowerCase(), u.getPort(), u.getFile());
+            }
+        } catch (MalformedURLException ex) {
+        }
+        return u.toExternalForm();
+    }
+
+    public static boolean sameURLs(URL u1, URL u2) {
+        if (u1 == null || u2 == null || (u1 == u2)) {
+            return (u1 == u2);
+        }
+        //NB: do not use URL.sameFile() as it will do DNS lookup
+        // Also, do quick check before slow string comparisons
+        String f1 = u1.getFile();
+        String f2 = u2.getFile();
+        return (f1.length() == f2.length()) && sameBase(u1, u2)
+                && f1.equalsIgnoreCase(f2);
+    }
+
+    public static boolean sameBase(URL u1, URL u2) {
+        return u1 != null && u2 != null &&
+                sameHost(u1, u2) && samePort(u1, u2) && sameProtocol(u1, u2);
+    }
+
+    private static boolean sameProtocol(URL u1, URL u2) {
+        //protocols are known to be lowercase
+        return u1.getProtocol().equals(u2.getProtocol());
+    }
+
+    private static boolean sameHost(URL u1, URL u2) {
+        String host = u1.getHost();
+        String otherHost = u2.getHost();
+        if (host == null || otherHost == null) {
+            return (host == null && otherHost == null);
+        } else {
+            //avoid slow comparison for strings of different length
+            return ((host.length() == otherHost.length())
+                       && host.equalsIgnoreCase(otherHost));
+        }
+    }
+
+    private static boolean samePort(URL u1, URL u2) {
+        return getPort(u1) == getPort(u2);
+    }
+
+    public static int getPort(URL u) {
+        if (u.getPort() != -1) {
+            return u.getPort();
+        } else {
+            return u.getDefaultPort();
+        }
+    }
+
+    public static URL getBase(URL url) {
+        if (url == null) return null;
+        String file = url.getFile();
+        if (file != null) {
+            int idx = file.lastIndexOf('/');
+            if (idx != -1 ) {
+                file = file.substring(0, idx + 1);
+            }
+            try {
+                return new URL(
+                    url.getProtocol(),
+                    url.getHost(),
+                    url.getPort(),
+                    file);
+            } catch(MalformedURLException mue) {
+                System.err.println(mue.getMessage());
+            }
+        }
+        // Just return same URL
+        return url;
+    }
+
+    private static String getEmbeddedVersionPath(String path, String version) {
+        int index = path.lastIndexOf("/");
+        String filename = path.substring(index + 1);
+        path = path.substring(0, index + 1);
+
+        String ext = null;
+        index = filename.lastIndexOf(".");
+        if (index != -1) {
+            ext = filename.substring(index + 1);
+            filename = filename.substring(0, index);
+        }
+
+        StringBuilder filenameSB = new StringBuilder(filename);
+        if (version != null) {
+            filenameSB.append("__V");
+            filenameSB.append(version);
+        }
+        if (ext != null) {
+            filenameSB.append(".");
+            filenameSB.append(ext);
+        }
+
+        path += filenameSB.toString();
+        return path;
+    }
+
+    public static URL getEmbeddedVersionURL(URL u, String version) throws Exception {
+        if (u == null) {
+            return null;
+        }
+
+        if (version == null || version.indexOf("*") != -1
+                || version.indexOf("+") != -1) {
+            // Do not support * or + in version string
+            return u;
+        }
+
+        URL versionURL = null;
+
+        String protocol = u.getProtocol();
+        String host = u.getHost();
+        int port = u.getPort();
+        String path = u.getPath();
+
+        path = getEmbeddedVersionPath(path, version);
+
+        versionURL = new URL(protocol, host, port, path);
+
+        return versionURL;
+    }
+}