X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.eclipse.swt.win32.win32.x86_64%2Fsrc%2Forg%2Feclipse%2Fswt%2Finternal%2FLibrary.java;fp=bundles%2Forg.eclipse.swt.win32.win32.x86_64%2Fsrc%2Forg%2Feclipse%2Fswt%2Finternal%2FLibrary.java;h=eab183c8924af8035613ada9992cbdc4e107559c;hb=db618b088560ad9a524dade82a3847f8d08bfb7c;hp=0000000000000000000000000000000000000000;hpb=930da66f9b2d7d1acba3e5dc805a323933abb780;p=simantics%2Fplatform.git diff --git a/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/internal/Library.java b/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/internal/Library.java new file mode 100644 index 000000000..eab183c89 --- /dev/null +++ b/bundles/org.eclipse.swt.win32.win32.x86_64/src/org/eclipse/swt/internal/Library.java @@ -0,0 +1,476 @@ +/******************************************************************************* + * Copyright (c) 2000, 2019 IBM Corporation and others. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * IBM Corporation - initial API and implementation + *******************************************************************************/ +package org.eclipse.swt.internal; + +import java.io.*; +import java.lang.reflect.*; +import java.net.*; +import java.nio.file.*; +import java.util.function.*; +import java.util.jar.*; + +public class Library { + + /* SWT Version - Mmmm (M=major, mmm=minor) */ + + /** + * SWT Major version number (must be >= 0) + */ + static int MAJOR_VERSION = 4; + + /** + * SWT Minor version number (must be in the range 0..999) + */ + static int MINOR_VERSION = 930; + + /** + * SWT revision number (must be >= 0) + */ + static int REVISION = 7; + + /** + * The JAVA and SWT versions + */ + public static final int JAVA_VERSION, SWT_VERSION; + public static final String USER_HOME; + + static final String SEPARATOR; + static final String DELIMITER; + + static final String JAVA_LIB_PATH = "java.library.path"; + static final String SWT_LIB_PATH = "swt.library.path"; + + + /* 64-bit support */ + static final boolean IS_64 = longConst() == (long /*int*/)longConst(); + static final String SUFFIX_64 = "-64"; //$NON-NLS-1$ + static final String SWT_LIB_DIR; + +static { + DELIMITER = System.getProperty("line.separator"); //$NON-NLS-1$ + SEPARATOR = File.separator; + USER_HOME = System.getProperty ("user.home"); + SWT_LIB_DIR = ".swt" + SEPARATOR + "lib" + SEPARATOR + os() + SEPARATOR + arch(); //$NON-NLS-1$ $NON-NLS-2$ + JAVA_VERSION = parseVersion(System.getProperty("java.version")); //$NON-NLS-1$ + SWT_VERSION = SWT_VERSION(MAJOR_VERSION, MINOR_VERSION); +} + +static String arch() { + String osArch = System.getProperty("os.arch"); //$NON-NLS-1$ + if (osArch.equals ("i386") || osArch.equals ("i686")) return "x86"; //$NON-NLS-1$ $NON-NLS-2$ $NON-NLS-3$ + if (osArch.equals ("amd64")) return "x86_64"; //$NON-NLS-1$ $NON-NLS-2$ + return osArch; +} + +static String os() { + String osName = System.getProperty("os.name"); //$NON-NLS-1$ + if (osName.equals ("Linux")) return "linux"; //$NON-NLS-1$ $NON-NLS-2$ + if (osName.equals ("Mac OS X")) return "macosx"; //$NON-NLS-1$ $NON-NLS-2$ + if (osName.startsWith ("Win")) return "win32"; //$NON-NLS-1$ $NON-NLS-2$ + return osName; +} + +static void chmod(String permision, String path) { + if (os().equals ("win32")) return; //$NON-NLS-1$ + try { + Runtime.getRuntime ().exec (new String []{"chmod", permision, path}).waitFor(); //$NON-NLS-1$ + } catch (Throwable e) {} +} + +/* Use method instead of in-lined constants to avoid compiler warnings */ +static long longConst() { + return 0x1FFFFFFFFL; +} + +static int parseVersion(String version) { + if (version == null) return 0; + int major = 0, minor = 0, micro = 0; + int length = version.length(), index = 0, start = 0; + while (index < length && Character.isDigit(version.charAt(index))) index++; + try { + if (start < length) major = Integer.parseInt(version.substring(start, index)); + } catch (NumberFormatException e) {} + start = ++index; + while (index < length && Character.isDigit(version.charAt(index))) index++; + try { + if (start < length) minor = Integer.parseInt(version.substring(start, index)); + } catch (NumberFormatException e) {} + start = ++index; + while (index < length && Character.isDigit(version.charAt(index))) index++; + try { + if (start < length) micro = Integer.parseInt(version.substring(start, index)); + } catch (NumberFormatException e) {} + return JAVA_VERSION(major, minor, micro); +} + +/** + * Returns the Java version number as an integer. + * + * @param major + * @param minor + * @param micro + * @return the version + */ +public static int JAVA_VERSION (int major, int minor, int micro) { + return (major << 16) + (minor << 8) + micro; +} + +/** + * Returns the SWT version number as an integer. + * + * @param major + * @param minor + * @return the version + */ +public static int SWT_VERSION (int major, int minor) { + return major * 1000 + minor; +} + +private static boolean extractResource(String resourceName, File outFile) { + try (InputStream inputStream = Library.class.getResourceAsStream (resourceName)) { + if (inputStream == null) return false; + Files.copy(inputStream, outFile.toPath(), StandardCopyOption.REPLACE_EXISTING); + } catch (Throwable e) { + return false; + } + + return true; +} + +/** + * Extract file with 'mappedName' into path 'extractToFilePath'. + * Does not overwrite existing file. + * Does not leave trash on error. + * @param extractToFilePath full path of where the file is to be extacted to, inc name of file, + * e.g /home/USER/.swt/lib/linux/x86_64/libswt-MYLIB-gtk-4826.so + * @param mappedName file to be searched in jar. + * @return true upon success, failure if something went wrong. + */ +static boolean extract (String extractToFilePath, String mappedName) { + File file = new File(extractToFilePath); + if (file.exists ()) return true; + + // Write to temp file first, so that other processes don't see + // partially written library on disk + File tempFile; + try { + tempFile = File.createTempFile (file.getName(), ".tmp", file.getParentFile()); //$NON-NLS-1$ + } catch (Throwable e) { + return false; + } + + // Extract resource + String resourceName = "/" + mappedName; //$NON-NLS-1$ + if (!extractResource (resourceName, tempFile)) { + tempFile.delete(); + return false; + } + + // Make it executable + chmod ("755", tempFile.getPath()); //$NON-NLS-1$ + + // "Publish" file now that it's ready to use. + // If there is a file already, then someone published while we were + // extracting, just delete our file and consider it a success. + try { + Files.move (tempFile.toPath(), file.toPath()); + } catch (Throwable e) { + tempFile.delete(); + } + + return true; +} + +static boolean isLoadable () { + URL url = Platform.class.getClassLoader ().getResource ("org/eclipse/swt/internal/Library.class"); //$NON-NLS-1$ + if (!url.getProtocol ().equals ("jar")) { //$NON-NLS-1$ + /* SWT is presumably running in a development environment */ + return true; + } + + Attributes attributes = null; + try { + URLConnection connection = url.openConnection(); + if (!(connection instanceof JarURLConnection)) { + /* should never happen for a "jar:" url */ + return false; + } + JarURLConnection jc = (JarURLConnection) connection; + attributes = jc.getMainAttributes(); + } catch (IOException e) { + /* should never happen for a valid SWT jar with the expected manifest values */ + return false; + } + + String os = os (); + String arch = arch (); + String manifestOS = attributes.getValue ("SWT-OS"); //$NON-NLS-1$ + String manifestArch = attributes.getValue ("SWT-Arch"); //$NON-NLS-1$ + if (arch.equals (manifestArch) && os.equals (manifestOS)) { + return true; + } + + return false; +} + +static boolean load (String libName, StringBuilder message) { + try { + if (libName.contains (SEPARATOR)) { + System.load (libName); + } else { + System.loadLibrary (libName); + } + return true; + } catch (UnsatisfiedLinkError e) { + if (message.length() == 0) message.append(DELIMITER); + message.append('\t'); + message.append(e.getMessage()); + message.append(DELIMITER); + } + return false; +} + +/** + * Loads the shared library that matches the version of the + * Java code which is currently running. SWT shared libraries + * follow an encoding scheme where the major, minor and revision + * numbers are embedded in the library name and this along with + * name is used to load the library. If this fails, + * name is used in another attempt to load the library, + * this time ignoring the SWT version encoding scheme. + * + * @param name the name of the library to load + */ +public static void loadLibrary (String name) { + loadLibrary (name, true); +} + +/** + * Loads the shared library that matches the version of the + * Java code which is currently running. SWT shared libraries + * follow an encoding scheme where the major, minor and revision + * numbers are embedded in the library name and this along with + * name is used to load the library. If this fails, + * name is used in another attempt to load the library, + * this time ignoring the SWT version encoding scheme. + * + * @param name the name of the library to load + * @param mapName true if the name should be mapped, false otherwise + */ +public static void loadLibrary (String name, boolean mapName) { + String prop = System.getProperty ("sun.arch.data.model"); //$NON-NLS-1$ + if (prop == null) prop = System.getProperty ("com.ibm.vm.bitmode"); //$NON-NLS-1$ + if (prop != null) { + if ("32".equals (prop) && IS_64) { //$NON-NLS-1$ + throw new UnsatisfiedLinkError ("Cannot load 64-bit SWT libraries on 32-bit JVM"); //$NON-NLS-1$ + } + if ("64".equals (prop) && !IS_64) { //$NON-NLS-1$ + throw new UnsatisfiedLinkError ("Cannot load 32-bit SWT libraries on 64-bit JVM"); //$NON-NLS-1$ + } + } + + /* Compute the library name and mapped name */ + String libName1, libName2, mappedName1, mappedName2; + if (mapName) { + String version = getVersionString (); + libName1 = name + "-" + Platform.PLATFORM + "-" + version; //$NON-NLS-1$ //$NON-NLS-2$ + libName2 = name + "-" + Platform.PLATFORM; //$NON-NLS-1$ + mappedName1 = mapLibraryName (libName1); + mappedName2 = mapLibraryName (libName2); + } else { + libName1 = libName2 = mappedName1 = mappedName2 = name; + } + + StringBuilder message = new StringBuilder(); + + /* Try loading library from swt library path */ + String path = System.getProperty (SWT_LIB_PATH); //$NON-NLS-1$ + if (path != null) { + path = new File (path).getAbsolutePath (); + if (load (path + SEPARATOR + mappedName1, message)) return; + if (mapName && load (path + SEPARATOR + mappedName2, message)) return; + } + + /* Try loading library from java library path */ + if (load (libName1, message)) return; + if (mapName && load (libName2, message)) return; + + /* Try loading library from the tmp directory if swt library path is not specified. + * Create the tmp folder if it doesn't exist. Tmp folder looks like this: + * ~/.swt/lib/// + */ + String fileName1 = mappedName1; + String fileName2 = mappedName2; + if (path == null) { + path = USER_HOME; + File dir = new File (path, SWT_LIB_DIR); + if ((dir.exists () && dir.isDirectory ()) || dir.mkdirs ()) { // Create if not exist. + path = dir.getAbsolutePath (); + } else { + /* fall back to using the home dir directory */ + if (IS_64) { + fileName1 = mapLibraryName (libName1 + SUFFIX_64); + fileName2 = mapLibraryName (libName2 + SUFFIX_64); + } + } + if (load (path + SEPARATOR + fileName1, message)) return; + if (mapName && load (path + SEPARATOR + fileName2, message)) return; + } + + /* Try extracting and loading library from jar. */ + if (path != null) { + if (extract (path + SEPARATOR + fileName1, mappedName1)) { + load(path + SEPARATOR + fileName1, message); + return; + } + if (mapName && extract (path + SEPARATOR + fileName2, mappedName2)) { + load(path + SEPARATOR + fileName2, message); + return; + } + } + + /* Failed to find the library */ + throw new UnsatisfiedLinkError ("Could not load SWT library. Reasons: " + message.toString()); //$NON-NLS-1$ +} + +static String mapLibraryName (String libName) { + /* SWT libraries in the Macintosh use the extension .jnilib but the some VMs map to .dylib. */ + libName = System.mapLibraryName (libName); + String ext = ".dylib"; //$NON-NLS-1$ + if (libName.endsWith(ext)) { + libName = libName.substring(0, libName.length() - ext.length()) + ".jnilib"; //$NON-NLS-1$ + } + return libName; +} + +/** + * @return String Combined SWT version like 4826 + */ +public static String getVersionString () { + String version = System.getProperty ("swt.version"); //$NON-NLS-1$ + if (version == null) { + version = "" + MAJOR_VERSION; //$NON-NLS-1$ + /* Force 3 digits in minor version number */ + if (MINOR_VERSION < 10) { + version += "00"; //$NON-NLS-1$ + } else { + if (MINOR_VERSION < 100) version += "0"; //$NON-NLS-1$ + } + version += MINOR_VERSION; + /* No "r" until first revision */ + if (REVISION > 0) version += "r" + REVISION; //$NON-NLS-1$ + } + return version; +} + + +/** + * Locates a resource located either in java library path, swt library path, or attempts to extract it from inside swt.jar file. + * This function supports a single level subfolder, e.g SubFolder/resource. + * + * Dev note: (17/12/07) This has been developed and throughly tested on GTK. Designed to work on Cocoa/Win as well, but not tested. + * + * @param subDir 'null' or a folder name without slashes. E.g Correct: 'mysubdir', incorrect: '/subdir/'. + * Platform specific Slashes will be added automatically. + * @param resourceName e.g swt-webkitgtk + * @param mapResourceName true if you like platform specific mapping applied to resource name. e.g MyLib -> libMyLib-gtk-4826.so + */ +public static File findResource(String subDir, String resourceName, boolean mapResourceName){ + + //We construct a 'maybe' subdirectory path. 'Maybe' because if no subDir given, then it's an empty string "". + // subdir e.g: subdir + String maybeSubDirPath = subDir != null ? subDir + SEPARATOR : ""; // e.g: subdir/ or "" + String maybeSubDirPathWithPrefix = subDir != null ? SEPARATOR + maybeSubDirPath : ""; // e.g: /subdir/ or "" + final String finalResourceName = mapResourceName ? + mapLibraryName(resourceName + "-" + Platform.PLATFORM + "-" + getVersionString ()) // e.g libMyLib-gtk-3826.so + : resourceName; + + // 1) Look for the resource in the java/swt library path(s) + // This code commonly finds the resource if the swt project is a required project and the swt binary (for your platform) + // project is open in your workplace (found in the JAVA_LIBRARY_PATH) or if you're explicitly specified SWT_LIBRARY_PATH. + { + Function lookForFileInPath = searchPath -> { + String classpath = System.getProperty(searchPath); + if (classpath != null){ + String[] paths = classpath.split(":"); + for (String path : paths) { + File file = new File(path + SEPARATOR + maybeSubDirPath + finalResourceName); + if (file.exists()){ + return file; + } + } + } + return null; + }; + File result = null; + for (String path : new String[] {JAVA_LIB_PATH,SWT_LIB_PATH}) { + result = lookForFileInPath.apply(path); + if (result != null) + return result; + } + } + + // 2) If SWT is ran as OSGI bundle (e.g inside Eclipse), then local resources are extracted to + // eclipse/configuration/org.eclipse.osgi/NN/N/.cp/ and we're given a pointer to the file. + { + // If this is an OSGI bundle look for the resource using getResource + URL url = Library.class.getClassLoader().getResource(maybeSubDirPathWithPrefix + finalResourceName); + URLConnection connection; + try { + connection = url.openConnection(); + Method getFileURLMethod = connection.getClass().getMethod("getFileURL"); + if (getFileURLMethod != null){ + // This method does the actual extraction of file to: ../eclipse/configuration/org.eclipse.osgi/NN/N/.cp//resource.ext + URL result = (URL) getFileURLMethod.invoke(connection); + return new File(result.toURI()); + } + } catch (Exception e) { + // If any exceptions are thrown the resource cannot be located this way. + } + } + + // 3) Need to try to pull the resource out of the swt.jar. + // Look for the resource in the user's home directory, (if already extracted in the temp swt folder. (~/.swt/lib...) + // Extract from the swt.jar if not there already. + { + // Developer note: + // To test this piece of code, you need to compile SWT into a jar and use it in a test project. E.g + // cd ~/git/eclipse.platform.swt.binaries/bundles/org.eclipse.swt.gtk.linux.x86_64/ + // mvn clean verify -Pbuild-individual-bundles -Dnative=gtk.linux.x86_64 + // then ./target/ will contain org.eclipse.swt.gtk.linux.x86_64-3.106.100-SNAPSHOT.jar (and it's source), + // you can copy those into your test swt project and test that your resource is extracted into something like ~/.swt/... + // Lastly, if using subDir, you need to edit the build.properties and specify the folder you wish to have included in your jar in the includes. + File file = new File (USER_HOME + SEPARATOR + SWT_LIB_DIR + maybeSubDirPathWithPrefix, finalResourceName); + if (file.exists()){ + return file; + } else { // Try to extract file from jar if not found. + + // Create temp directory if it doesn't exist + File tempDir = new File (USER_HOME, SWT_LIB_DIR + maybeSubDirPathWithPrefix); + if ((!tempDir.exists () || tempDir.isDirectory ())) { + tempDir.mkdirs (); + } + + if (extract(file.getPath(), maybeSubDirPath + finalResourceName)) { + if (file.exists()) { + return file; + } + } + } + } + throw new UnsatisfiedLinkError("Could not find resource" + resourceName + (subDir != null ? " (in subdirectory: " + subDir + " )" : "")); +} + + +}