Neurogami-roir 1.3.3.1

data/lib/launch4j/src/net/sf/launch4j/config/ConfigPersister.java

@@ -0,0 +1,249 @@
+/*
+	Launch4j (http://launch4j.sourceforge.net/)
+	Cross-platform Java application wrapper for creating Windows native executables.
+
+	Copyright (c) 2004, 2007 Grzegorz Kowal
+
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without modification,
+	are permitted provided that the following conditions are met:
+
+	    * Redistributions of source code must retain the above copyright notice,
+	      this list of conditions and the following disclaimer.
+	    * Redistributions in binary form must reproduce the above copyright notice,
+	      this list of conditions and the following disclaimer in the documentation
+	      and/or other materials provided with the distribution.
+	    * Neither the name of the Launch4j nor the names of its contributors
+	      may be used to endorse or promote products derived from this software without
+	      specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+	CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+ * Created on Apr 22, 2005
+ */
+package net.sf.launch4j.config;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Properties;
+
+import net.sf.launch4j.Util;
+
+import com.thoughtworks.xstream.XStream;
+import com.thoughtworks.xstream.io.xml.DomDriver;
+
+/**
+ * @author Copyright (C) 2005 Grzegorz Kowal
+ */
+public class ConfigPersister {
+
+	private static final ConfigPersister _instance = new ConfigPersister();
+
+	private final XStream _xstream;
+	private Config _config;
+	private File _configPath;
+
+	private ConfigPersister() {
+		_xstream = new XStream(new DomDriver());
+    	_xstream.alias("launch4jConfig", Config.class);
+    	_xstream.alias("classPath", ClassPath.class);
+    	_xstream.alias("jre", Jre.class);
+    	_xstream.alias("splash", Splash.class);
+    	_xstream.alias("versionInfo", VersionInfo.class);
+
+    	_xstream.addImplicitCollection(Config.class, "headerObjects", "obj",
+    			String.class);
+    	_xstream.addImplicitCollection(Config.class, "libs", "lib", String.class);
+    	_xstream.addImplicitCollection(Config.class, "variables", "var", String.class);
+    	_xstream.addImplicitCollection(ClassPath.class, "paths", "cp", String.class);
+    	_xstream.addImplicitCollection(Jre.class, "options", "opt", String.class);
+	}
+
+	public static ConfigPersister getInstance() {
+		return _instance;
+	}
+	
+	public Config getConfig() {
+		return _config;
+	}
+
+	public File getConfigPath() {
+		return _configPath;
+	}
+	
+	public File getOutputPath() throws IOException {
+		if (_config.getOutfile().isAbsolute()) {
+			return _config.getOutfile().getParentFile();
+		}
+		File parent = _config.getOutfile().getParentFile();
+		return (parent != null) ? new File(_configPath, parent.getPath()) : _configPath;
+	}
+	
+	public File getOutputFile() throws IOException {
+		return _config.getOutfile().isAbsolute()
+			? _config.getOutfile()
+			: new File(getOutputPath(), _config.getOutfile().getName());
+	}
+
+	public void createBlank() {
+		_config = new Config();
+		_config.setJre(new Jre());
+		_configPath = null;
+	}
+
+	public void setAntConfig(Config c, File basedir) {
+		_config = c;
+		_configPath = basedir;
+	}
+
+	public void load(File f) throws ConfigPersisterException {
+		try {
+			FileReader r = new FileReader(f);
+			char[] buf = new char[(int) f.length()];
+			r.read(buf);
+	    	r.close();
+	    	// Convert 2.x config to 3.x
+	    	String s = String.valueOf(buf)
+	    			.replaceAll("<headerType>0<", "<headerType>gui<")
+	    			.replaceAll("<headerType>1<", "<headerType>console<")
+	    			.replaceAll("jarArgs>", "cmdLine>")
+	    			.replaceAll("<jarArgs[ ]*/>", "<cmdLine/>")
+	    			.replaceAll("args>", "opt>")
+	    			.replaceAll("<args[ ]*/>", "<opt/>")
+	    			.replaceAll("<dontUsePrivateJres>false</dontUsePrivateJres>",
+	    					"<jdkPreference>" + Jre.JDK_PREFERENCE_PREFER_JRE + "</jdkPreference>")
+	    			.replaceAll("<dontUsePrivateJres>true</dontUsePrivateJres>",
+	    					"<jdkPreference>" + Jre.JDK_PREFERENCE_JRE_ONLY + "</jdkPreference>")
+	    			.replaceAll("<initialHeapSize>0</initialHeapSize>", "")
+	    			.replaceAll("<maxHeapSize>0</maxHeapSize>", "");
+	    	_config = (Config) _xstream.fromXML(s);
+	    	setConfigPath(f);
+		} catch (Exception e) {
+			throw new ConfigPersisterException(e);
+		}
+	}
+
+	/**
+	 * Imports launch4j 1.x.x config file.
+	 */
+	public void loadVersion1(File f) throws ConfigPersisterException {
+		try {
+			Props props = new Props(f);
+			_config = new Config();
+			String header = props.getProperty(Config.HEADER);
+			_config.setHeaderType(header == null
+					|| header.toLowerCase().equals("guihead.bin") ? Config.GUI_HEADER
+															: Config.CONSOLE_HEADER);
+			_config.setJar(props.getFile(Config.JAR));
+			_config.setOutfile(props.getFile(Config.OUTFILE));
+			_config.setJre(new Jre());
+			_config.getJre().setPath(props.getProperty(Jre.PATH));
+			_config.getJre().setMinVersion(props.getProperty(Jre.MIN_VERSION));
+			_config.getJre().setMaxVersion(props.getProperty(Jre.MAX_VERSION));
+			String args = props.getProperty(Jre.ARGS);
+			if (args != null) {
+				List jreOptions = new ArrayList();
+				jreOptions.add(args);
+				_config.getJre().setOptions(jreOptions);
+			}
+			_config.setCmdLine(props.getProperty(Config.JAR_ARGS));
+			_config.setChdir("true".equals(props.getProperty(Config.CHDIR))
+					? "." : null);
+			_config.setCustomProcName("true".equals(
+					props.getProperty("setProcName")));				// 1.x
+			_config.setStayAlive("true".equals(props.getProperty(Config.STAY_ALIVE)));
+			_config.setErrTitle(props.getProperty(Config.ERR_TITLE));
+			_config.setIcon(props.getFile(Config.ICON));
+			File splashFile = props.getFile(Splash.SPLASH_FILE);
+			if (splashFile != null) {
+				_config.setSplash(new Splash());
+				_config.getSplash().setFile(splashFile);
+				String waitfor = props.getProperty("waitfor");		// 1.x
+				_config.getSplash().setWaitForWindow(waitfor != null
+													&& !waitfor.equals(""));
+				String splashTimeout = props.getProperty(Splash.TIMEOUT);
+				if (splashTimeout != null) {
+					_config.getSplash().setTimeout(Integer.parseInt(splashTimeout));	
+				}
+				_config.getSplash().setTimeoutErr("true".equals(
+						props.getProperty(Splash.TIMEOUT_ERR)));
+			} else {
+				_config.setSplash(null);
+			}
+			setConfigPath(f);
+		} catch (IOException e) {
+			throw new ConfigPersisterException(e);
+		}
+	}
+
+	public void save(File f) throws ConfigPersisterException {
+		try {
+			BufferedWriter w = new BufferedWriter(new FileWriter(f));
+	    	_xstream.toXML(_config, w);
+	    	w.close();
+	    	setConfigPath(f);
+		} catch (Exception e) {
+			throw new ConfigPersisterException(e);
+		}
+	}
+
+	private void setConfigPath(File configFile) {
+		_configPath = configFile.getAbsoluteFile().getParentFile();
+	}
+
+	private class Props {
+		final Properties _properties = new Properties();
+
+		public Props(File f) throws IOException {
+			FileInputStream is = null;
+			try {
+				is = new FileInputStream(f);
+				_properties.load(is);
+			} finally {
+				Util.close(is);
+			}
+		}
+
+		/**
+		 * Get property and remove trailing # comments.
+		 */
+		public String getProperty(String key) {
+			String p = _properties.getProperty(key);
+			if (p == null) {
+				return null;
+			}
+			int x = p.indexOf('#');
+			if (x == -1) {
+				return p;
+			}
+			do {
+				x--;
+			} while (x > 0 && (p.charAt(x) == ' ' || p.charAt(x) == '\t'));
+			return (x == 0) ? "" : p.substring(0, x + 1);
+		}
+
+		public File getFile(String key) {
+			String value = getProperty(key);
+			return value != null ? new File(value) : null;
+		}
+	}
+}

data/lib/launch4j/src/net/sf/launch4j/config/ConfigPersisterException.java

@@ -0,0 +1,51 @@
+/*
+	Launch4j (http://launch4j.sourceforge.net/)
+	Cross-platform Java application wrapper for creating Windows native executables.
+
+	Copyright (c) 2004, 2007 Grzegorz Kowal
+
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without modification,
+	are permitted provided that the following conditions are met:
+
+	    * Redistributions of source code must retain the above copyright notice,
+	      this list of conditions and the following disclaimer.
+	    * Redistributions in binary form must reproduce the above copyright notice,
+	      this list of conditions and the following disclaimer in the documentation
+	      and/or other materials provided with the distribution.
+	    * Neither the name of the Launch4j nor the names of its contributors
+	      may be used to endorse or promote products derived from this software without
+	      specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+	CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+ * Created on Apr 22, 2005
+ */
+package net.sf.launch4j.config;
+
+/**
+ * @author Copyright (C) 2005 Grzegorz Kowal
+ */
+public class ConfigPersisterException extends Exception {
+
+	public ConfigPersisterException(String msg, Throwable t) {
+		super(msg, t);
+	}
+	
+	public ConfigPersisterException(Throwable t) {
+		super(t);
+	}
+}

data/lib/launch4j/src/net/sf/launch4j/config/Jre.java

@@ -0,0 +1,235 @@
+/*
+	Launch4j (http://launch4j.sourceforge.net/)
+	Cross-platform Java application wrapper for creating Windows native executables.
+
+	Copyright (c) 2004, 2007 Grzegorz Kowal
+
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without modification,
+	are permitted provided that the following conditions are met:
+
+	    * Redistributions of source code must retain the above copyright notice,
+	      this list of conditions and the following disclaimer.
+	    * Redistributions in binary form must reproduce the above copyright notice,
+	      this list of conditions and the following disclaimer in the documentation
+	      and/or other materials provided with the distribution.
+	    * Neither the name of the Launch4j nor the names of its contributors
+	      may be used to endorse or promote products derived from this software without
+	      specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+	CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+ * Created on Apr 21, 2005
+ */
+package net.sf.launch4j.config;
+
+import java.util.Arrays;
+import java.util.List;
+
+import net.sf.launch4j.binding.IValidatable;
+import net.sf.launch4j.binding.Validator;
+
+/**
+ * @author Copyright (C) 2005 Grzegorz Kowal
+ */
+public class Jre implements IValidatable {
+
+	// 1.x config properties_____________________________________________________________
+	public static final String PATH = "jrepath";
+	public static final String MIN_VERSION = "javamin";
+	public static final String MAX_VERSION = "javamax";
+	public static final String ARGS = "jvmArgs";
+
+	// __________________________________________________________________________________
+	public static final String VERSION_PATTERN = "(\\d\\.){2}\\d(_\\d+)?";
+
+	public static final String JDK_PREFERENCE_JRE_ONLY = "jreOnly";
+	public static final String JDK_PREFERENCE_PREFER_JRE = "preferJre";
+	public static final String JDK_PREFERENCE_PREFER_JDK = "preferJdk";
+	public static final String JDK_PREFERENCE_JDK_ONLY = "jdkOnly";
+
+	private static final String[] JDK_PREFERENCE_NAMES = new String[] {
+			JDK_PREFERENCE_JRE_ONLY,
+			JDK_PREFERENCE_PREFER_JRE,
+			JDK_PREFERENCE_PREFER_JDK,
+			JDK_PREFERENCE_JDK_ONLY };
+
+	public static final int DEFAULT_JDK_PREFERENCE_INDEX
+			= Arrays.asList(JDK_PREFERENCE_NAMES).indexOf(JDK_PREFERENCE_PREFER_JRE);
+
+	private String path;
+	private String minVersion;
+	private String maxVersion;
+	private String jdkPreference;
+	private Integer initialHeapSize;
+	private Integer initialHeapPercent;
+	private Integer maxHeapSize;
+	private Integer maxHeapPercent;
+	private List options;
+
+	public void checkInvariants() {
+		Validator.checkOptString(minVersion, 10, VERSION_PATTERN,
+				"jre.minVersion", Messages.getString("Jre.min.version"));
+		Validator.checkOptString(maxVersion, 10, VERSION_PATTERN,
+				"jre.maxVersion", Messages.getString("Jre.max.version"));
+		if (Validator.isEmpty(path)) {
+			Validator.checkFalse(Validator.isEmpty(minVersion),
+					"jre.minVersion", Messages.getString("Jre.specify.jre.min.version.or.path"));
+		} else {
+			Validator.checkString(path, Validator.MAX_PATH,
+					"jre.path", Messages.getString("Jre.bundled.path"));
+		}
+		if (!Validator.isEmpty(maxVersion)) {
+			Validator.checkFalse(Validator.isEmpty(minVersion),
+					"jre.minVersion", Messages.getString("Jre.specify.min.version"));
+			Validator.checkTrue(minVersion.compareTo(maxVersion) < 0,
+					"jre.maxVersion", Messages.getString("Jre.max.greater.than.min"));
+		}
+		Validator.checkTrue(initialHeapSize == null || maxHeapSize != null,
+				"jre.maxHeapSize", Messages.getString("Jre.initial.and.max.heap"));
+		Validator.checkTrue(initialHeapSize == null || initialHeapSize.intValue() > 0,
+				"jre.initialHeapSize", Messages.getString("Jre.initial.heap"));
+		Validator.checkTrue(maxHeapSize == null || (maxHeapSize.intValue()
+				>= ((initialHeapSize != null) ? initialHeapSize.intValue() : 1)),
+				"jre.maxHeapSize", Messages.getString("Jre.max.heap"));
+		Validator.checkTrue(initialHeapPercent == null || maxHeapPercent != null,
+				"jre.maxHeapPercent", Messages.getString("Jre.initial.and.max.heap"));
+		if (initialHeapPercent != null) {
+			Validator.checkRange(initialHeapPercent.intValue(), 1, 100,
+					"jre.initialHeapPercent",
+					Messages.getString("Jre.initial.heap.percent"));
+		}
+		if (maxHeapPercent != null) {
+			Validator.checkRange(maxHeapPercent.intValue(),
+					initialHeapPercent != null ? initialHeapPercent.intValue() : 1, 100,
+					"jre.maxHeapPercent",
+					Messages.getString("Jre.max.heap.percent"));
+		}
+		Validator.checkIn(getJdkPreference(), JDK_PREFERENCE_NAMES,
+				"jre.jdkPreference", Messages.getString("Jre.jdkPreference.invalid"));
+		Validator.checkOptStrings(options,
+				Validator.MAX_ARGS,
+				Validator.MAX_ARGS,
+				"[^\"]*|([^\"]*\"[^\"]*\"[^\"]*)*",
+				"jre.options",
+				Messages.getString("Jre.jvm.options"),
+				Messages.getString("Jre.jvm.options.unclosed.quotation"));
+
+		// Quoted variable references: "[^%]*|([^%]*\"([^%]*%[^%]+%[^%]*)+\"[^%]*)*"
+		Validator.checkOptStrings(options,
+				Validator.MAX_ARGS,
+				Validator.MAX_ARGS,
+				"[^%]*|([^%]*([^%]*%[^%]+%[^%]*)+[^%]*)*",
+				"jre.options",
+				Messages.getString("Jre.jvm.options"),
+				Messages.getString("Jre.jvm.options.variable"));
+	}
+
+	/** JVM options */
+	public List getOptions() {
+		return options;
+	}
+
+	public void setOptions(List options) {
+		this.options = options;
+	}
+
+	/** Max Java version (x.x.x) */
+	public String getMaxVersion() {
+		return maxVersion;
+	}
+
+	public void setMaxVersion(String maxVersion) {
+		this.maxVersion = maxVersion;
+	}
+
+	/** Min Java version (x.x.x) */
+	public String getMinVersion() {
+		return minVersion;
+	}
+
+	public void setMinVersion(String minVersion) {
+		this.minVersion = minVersion;
+	}
+
+	/** Preference for standalone JRE or JDK-private JRE */
+	public String getJdkPreference() {
+		return Validator.isEmpty(jdkPreference) ? JDK_PREFERENCE_PREFER_JRE
+												: jdkPreference;
+	}
+
+	public void setJdkPreference(String jdkPreference) {
+		this.jdkPreference = jdkPreference;
+	}
+
+	/** Preference for standalone JRE or JDK-private JRE */
+	public int getJdkPreferenceIndex() {
+		int x = Arrays.asList(JDK_PREFERENCE_NAMES).indexOf(getJdkPreference());
+		return x != -1 ? x : DEFAULT_JDK_PREFERENCE_INDEX;
+	}
+	
+	public void setJdkPreferenceIndex(int x) {
+		jdkPreference = JDK_PREFERENCE_NAMES[x];
+	}
+
+	/** JRE path */
+	public String getPath() {
+		return path;
+	}
+
+	public void setPath(String path) {
+		this.path = path;
+	}
+
+	/** Initial heap size in MB */
+	public Integer getInitialHeapSize() {
+		return initialHeapSize;
+	}
+
+	public void setInitialHeapSize(Integer initialHeapSize) {
+		this.initialHeapSize = getInteger(initialHeapSize);
+	}
+
+	/** Max heap size in MB */
+	public Integer getMaxHeapSize() {
+		return maxHeapSize;
+	}
+
+	public void setMaxHeapSize(Integer maxHeapSize) {
+		this.maxHeapSize = getInteger(maxHeapSize);
+	}
+	
+	public Integer getInitialHeapPercent() {
+    	return initialHeapPercent;
+    }
+
+	public void setInitialHeapPercent(Integer initialHeapPercent) {
+    	this.initialHeapPercent = getInteger(initialHeapPercent);
+    }
+
+	public Integer getMaxHeapPercent() {
+    	return maxHeapPercent;
+    }
+
+	public void setMaxHeapPercent(Integer maxHeapPercent) {
+    	this.maxHeapPercent = getInteger(maxHeapPercent);
+    }
+
+	/** Convert 0 to null */
+	private Integer getInteger(Integer i) {
+		return i != null && i.intValue() == 0 ? null : i;
+	}
+}

data/lib/launch4j/src/net/sf/launch4j/config/LdDefaults.java

@@ -0,0 +1,62 @@
+/*
+	Launch4j (http://launch4j.sourceforge.net/)
+	Cross-platform Java application wrapper for creating Windows native executables.
+
+	Copyright (c) 2004, 2007 Grzegorz Kowal
+
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without modification,
+	are permitted provided that the following conditions are met:
+
+	    * Redistributions of source code must retain the above copyright notice,
+	      this list of conditions and the following disclaimer.
+	    * Redistributions in binary form must reproduce the above copyright notice,
+	      this list of conditions and the following disclaimer in the documentation
+	      and/or other materials provided with the distribution.
+	    * Neither the name of the Launch4j nor the names of its contributors
+	      may be used to endorse or promote products derived from this software without
+	      specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+	CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+/*
+ * Created on Sep 3, 2005
+ */
+package net.sf.launch4j.config;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class LdDefaults {
+
+	public static final List GUI_HEADER_OBJECTS = Arrays.asList(new String[] {
+			"w32api/crt2.o",
+			"head/guihead.o",
+			"head/head.o" });
+
+	public static final List CONSOLE_HEADER_OBJECTS = Arrays.asList(new String[] {
+			"w32api/crt2.o",
+			"head/consolehead.o",
+			"head/head.o"});
+
+	public static final List LIBS = Arrays.asList(new String[] {
+			"w32api/libmingw32.a",
+			"w32api/libgcc.a",
+			"w32api/libmsvcrt.a",
+			"w32api/libkernel32.a",
+			"w32api/libuser32.a",
+			"w32api/libadvapi32.a",
+			"w32api/libshell32.a" });
+}

data/lib/launch4j/src/net/sf/launch4j/config/Messages.java

@@ -0,0 +1,78 @@
+/*
+	Launch4j (http://launch4j.sourceforge.net/)
+	Cross-platform Java application wrapper for creating Windows native executables.
+
+	Copyright (c) 2004, 2007 Grzegorz Kowal
+
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without modification,
+	are permitted provided that the following conditions are met:
+
+	    * Redistributions of source code must retain the above copyright notice,
+	      this list of conditions and the following disclaimer.
+	    * Redistributions in binary form must reproduce the above copyright notice,
+	      this list of conditions and the following disclaimer in the documentation
+	      and/or other materials provided with the distribution.
+	    * Neither the name of the Launch4j nor the names of its contributors
+	      may be used to endorse or promote products derived from this software without
+	      specific prior written permission.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+	CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+	EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+	PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+	LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+	NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+	SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+package net.sf.launch4j.config;
+
+import java.text.MessageFormat;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+
+public class Messages {
+	private static final String BUNDLE_NAME = "net.sf.launch4j.config.messages";
+
+	private static final ResourceBundle RESOURCE_BUNDLE = ResourceBundle
+			.getBundle(BUNDLE_NAME);
+	private static final MessageFormat FORMATTER = new MessageFormat("");
+
+	private Messages() {
+	}
+	
+	public static String getString(String key) {
+		try {
+			return RESOURCE_BUNDLE.getString(key);
+		} catch (MissingResourceException e) {
+			return '!' + key + '!';
+		}
+	}
+	
+	public static String getString(String key, String arg0) {
+		return getString(key, new Object[] {arg0});
+	}
+
+	public static String getString(String key, String arg0, String arg1) {
+		return getString(key, new Object[] {arg0, arg1});
+	}
+
+	public static String getString(String key, String arg0, String arg1, String arg2) {
+		return getString(key, new Object[] {arg0, arg1, arg2});
+	}
+
+	public static String getString(String key, Object[] args) {
+		try {
+			FORMATTER.applyPattern(RESOURCE_BUNDLE.getString(key));
+			return FORMATTER.format(args);
+		} catch (MissingResourceException e) {
+			return '!' + key + '!';
+		}
+	}
+}