formatter chewed on it

2 files changed, 2653 insertions, 2706 deletions

diff --git a/util/src/org/aspectj/util/FileUtil.java b/util/src/org/aspectj/util/FileUtil.java
index cfea7e533..b0cd73a3b 100644
--- a/util/src/org/aspectj/util/FileUtil.java
+++ b/util/src/org/aspectj/util/FileUtil.java
@@ -13,980 +13,978 @@
 
 package org.aspectj.util;
 
-import java.io.*;
-import java.net.*;
-import java.util.*;
-import java.util.zip.*;
-
+import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileFilter;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.Writer;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipInputStream;
 
 /**
  * 
  */
 public class FileUtil {
-    /** default parent directory File when a file has a null parent */
-    public static final File DEFAULT_PARENT = new File("."); // XXX user.dir?
-
-    /** unmodifiable List of String source file suffixes (including leading ".") */
-    public static final List SOURCE_SUFFIXES
-        = Collections.unmodifiableList(Arrays.asList(new String[] { ".java", ".aj"}));
-    
-    public static final FileFilter ZIP_FILTER = new FileFilter() {
-        public boolean accept(File file) {
-            return isZipFile(file);
-        }
-        public String toString() { 
-            return "ZIP_FILTER"; 
-        }
-    };
-
-    public static final FileFilter SOURCE_FILTER = new FileFilter() {
-        public boolean accept(File file) {
-            return hasSourceSuffix(file);
-        }
-        public String toString() { 
-            return "SOURCE_FILTER"; 
-        }
-    };
-
-    final static int[] INT_RA = new int[0];
-    
-    /** accept all files */
-    public static final FileFilter ALL = new FileFilter() {
-        public boolean accept(File f) { return true; }
-    };
-    public static final FileFilter DIRS_AND_WRITABLE_CLASSES
-        = new FileFilter() {
-            public boolean accept(File file) {
-                return ((null != file)
-                    && (file.isDirectory()
-                        || (file.canWrite()
-                            && file.getName().toLowerCase().endsWith(".class"))));
-            }
-        };
-    private static final boolean PERMIT_CVS;
-    static {
-        String name = FileUtil.class.getName() + ".PERMIT_CVS";
-        PERMIT_CVS = LangUtil.getBoolean(name, false);
-    }
-
-    /** @return true if file exists and is a zip file */
-    public static boolean isZipFile(File file) {
-        try {
+	/** default parent directory File when a file has a null parent */
+	public static final File DEFAULT_PARENT = new File("."); // XXX user.dir?
+
+	/** unmodifiable List of String source file suffixes (including leading ".") */
+	public static final List SOURCE_SUFFIXES = Collections.unmodifiableList(Arrays.asList(new String[] { ".java", ".aj" }));
+
+	public static final FileFilter ZIP_FILTER = new FileFilter() {
+		public boolean accept(File file) {
+			return isZipFile(file);
+		}
+
+		public String toString() {
+			return "ZIP_FILTER";
+		}
+	};
+
+	public static final FileFilter SOURCE_FILTER = new FileFilter() {
+		public boolean accept(File file) {
+			return hasSourceSuffix(file);
+		}
+
+		public String toString() {
+			return "SOURCE_FILTER";
+		}
+	};
+
+	final static int[] INT_RA = new int[0];
+
+	/** accept all files */
+	public static final FileFilter ALL = new FileFilter() {
+		public boolean accept(File f) {
+			return true;
+		}
+	};
+	public static final FileFilter DIRS_AND_WRITABLE_CLASSES = new FileFilter() {
+		public boolean accept(File file) {
+			return ((null != file) && (file.isDirectory() || (file.canWrite() && file.getName().toLowerCase().endsWith(".class"))));
+		}
+	};
+	private static final boolean PERMIT_CVS;
+	static {
+		String name = FileUtil.class.getName() + ".PERMIT_CVS";
+		PERMIT_CVS = LangUtil.getBoolean(name, false);
+	}
+
+	/** @return true if file exists and is a zip file */
+	public static boolean isZipFile(File file) {
+		try {
 			return (null != file) && new ZipFile(file) != null;
 		} catch (IOException e) {
 			return false;
 		}
-    }
-
-    /** @return true if path ends with .zip or .jar */
-//    public static boolean hasZipSuffix(String path) {
-//        return ((null != path) && (0 != zipSuffixLength(path)));
-//    }
-    
-    /** @return 0 if file has no zip/jar suffix or 4 otherwise  */
-    public static int zipSuffixLength(File file) {
-        return (null == file ? 0 : zipSuffixLength(file.getPath()));
-    }
-    
-    /** @return 0 if no zip/jar suffix or 4 otherwise */
-    public static int zipSuffixLength(String path) {
-        if ((null != path) && (4 < path.length())){
-            String test = path.substring(path.length()-4).toLowerCase();
-            if (".zip".equals(test) || ".jar".equals(test)) {
-                return 4;
-            } 
-        }
-        return 0;
-    }
-
-    /** @return true if file path has a source suffix */
-    public static boolean hasSourceSuffix(File file) {
-        return ((null != file) && hasSourceSuffix(file.getPath()));
-    }
-
-    /** @return true if path ends with .java or .aj */
-    public static boolean hasSourceSuffix(String path) {
-        return ((null != path) && (0 != sourceSuffixLength(path)));
-    }
-    
-    /** @return 0 if file has no source suffix or the length of the suffix otherwise */
-    public static int sourceSuffixLength(File file) {
-        return (null == file ? 0 : sourceSuffixLength(file.getPath()));
-    }
-    
-    /** @return 0 if no source suffix or the length of the suffix otherwise */
-    public static int sourceSuffixLength(String path) {
-        if (LangUtil.isEmpty(path)) {
-            return 0;
-        }
-        
-        for (Iterator iter = SOURCE_SUFFIXES.iterator(); iter.hasNext();) {
+	}
+
+	/** @return true if path ends with .zip or .jar */
+	// public static boolean hasZipSuffix(String path) {
+	// return ((null != path) && (0 != zipSuffixLength(path)));
+	// }
+	/** @return 0 if file has no zip/jar suffix or 4 otherwise */
+	public static int zipSuffixLength(File file) {
+		return (null == file ? 0 : zipSuffixLength(file.getPath()));
+	}
+
+	/** @return 0 if no zip/jar suffix or 4 otherwise */
+	public static int zipSuffixLength(String path) {
+		if ((null != path) && (4 < path.length())) {
+			String test = path.substring(path.length() - 4).toLowerCase();
+			if (".zip".equals(test) || ".jar".equals(test)) {
+				return 4;
+			}
+		}
+		return 0;
+	}
+
+	/** @return true if file path has a source suffix */
+	public static boolean hasSourceSuffix(File file) {
+		return ((null != file) && hasSourceSuffix(file.getPath()));
+	}
+
+	/** @return true if path ends with .java or .aj */
+	public static boolean hasSourceSuffix(String path) {
+		return ((null != path) && (0 != sourceSuffixLength(path)));
+	}
+
+	/** @return 0 if file has no source suffix or the length of the suffix otherwise */
+	public static int sourceSuffixLength(File file) {
+		return (null == file ? 0 : sourceSuffixLength(file.getPath()));
+	}
+
+	/** @return 0 if no source suffix or the length of the suffix otherwise */
+	public static int sourceSuffixLength(String path) {
+		if (LangUtil.isEmpty(path)) {
+			return 0;
+		}
+
+		for (Iterator iter = SOURCE_SUFFIXES.iterator(); iter.hasNext();) {
 			String suffix = (String) iter.next();
-            if (path.endsWith(suffix)
-                || path.toLowerCase().endsWith(suffix)) {
-                return suffix.length();
-            }
-		} 
-        return 0;
-    }
-
-    /** @return true if this is a readable directory */
-    public static boolean canReadDir(File dir) {
-        return ((null != dir) && dir.canRead() && dir.isDirectory());
-    }
-    
-    /** @return true if this is a readable file */
-    public static boolean canReadFile(File file) {
-        return ((null != file) && file.canRead() && file.isFile());
-    }
-    
-    /** @return true if dir is a writable directory */
-    public static boolean canWriteDir(File dir) {
-        return ((null != dir) && dir.canWrite() && dir.isDirectory());
-    }
-    
-    /** @return true if this is a writable file */
-    public static boolean canWriteFile(File file) {
-        return ((null != file) && file.canWrite() && file.isFile());
-    }
-    
-    /** @throws IllegalArgumentException unless file is readable and not a directory */
-    public static void throwIaxUnlessCanReadFile(File file, String label) {
-        if (!canReadFile(file)) {
-            throw new IllegalArgumentException(label + " not readable file: " + file);
-        }
-    }
-
-    /** @throws IllegalArgumentException unless dir is a readable directory */
-    public static void throwIaxUnlessCanReadDir(File dir, String label) {
-        if (!canReadDir(dir)) {
-            throw new IllegalArgumentException(label + " not readable dir: " + dir);
-        }
-    }
-    
-    /** @throws IllegalArgumentException unless file is readable and not a directory */
-    public static void throwIaxUnlessCanWriteFile(File file, String label) {
-        if (!canWriteFile(file)) {
-            throw new IllegalArgumentException(label + " not writable file: " + file);
-        }
-    }
-
-    /** @throws IllegalArgumentException unless dir is a readable directory */
-    public static void throwIaxUnlessCanWriteDir(File dir, String label) {
-        if (!canWriteDir(dir)) {
-            throw new IllegalArgumentException(label + " not writable dir: " + dir);
-        }
-    }
-    
-    /** @return array same length as input, with String paths */
-    public static String[] getPaths(File[] files) {
-        if ((null == files) || (0 == files.length)) {
-            return new String[0];
-        }
-        String[] result = new String[files.length];
-        for (int i = 0; i < result.length; i++) {
+			if (path.endsWith(suffix) || path.toLowerCase().endsWith(suffix)) {
+				return suffix.length();
+			}
+		}
+		return 0;
+	}
+
+	/** @return true if this is a readable directory */
+	public static boolean canReadDir(File dir) {
+		return ((null != dir) && dir.canRead() && dir.isDirectory());
+	}
+
+	/** @return true if this is a readable file */
+	public static boolean canReadFile(File file) {
+		return ((null != file) && file.canRead() && file.isFile());
+	}
+
+	/** @return true if dir is a writable directory */
+	public static boolean canWriteDir(File dir) {
+		return ((null != dir) && dir.canWrite() && dir.isDirectory());
+	}
+
+	/** @return true if this is a writable file */
+	public static boolean canWriteFile(File file) {
+		return ((null != file) && file.canWrite() && file.isFile());
+	}
+
+	/** @throws IllegalArgumentException unless file is readable and not a directory */
+	public static void throwIaxUnlessCanReadFile(File file, String label) {
+		if (!canReadFile(file)) {
+			throw new IllegalArgumentException(label + " not readable file: " + file);
+		}
+	}
+
+	/** @throws IllegalArgumentException unless dir is a readable directory */
+	public static void throwIaxUnlessCanReadDir(File dir, String label) {
+		if (!canReadDir(dir)) {
+			throw new IllegalArgumentException(label + " not readable dir: " + dir);
+		}
+	}
+
+	/** @throws IllegalArgumentException unless file is readable and not a directory */
+	public static void throwIaxUnlessCanWriteFile(File file, String label) {
+		if (!canWriteFile(file)) {
+			throw new IllegalArgumentException(label + " not writable file: " + file);
+		}
+	}
+
+	/** @throws IllegalArgumentException unless dir is a readable directory */
+	public static void throwIaxUnlessCanWriteDir(File dir, String label) {
+		if (!canWriteDir(dir)) {
+			throw new IllegalArgumentException(label + " not writable dir: " + dir);
+		}
+	}
+
+	/** @return array same length as input, with String paths */
+	public static String[] getPaths(File[] files) {
+		if ((null == files) || (0 == files.length)) {
+			return new String[0];
+		}
+		String[] result = new String[files.length];
+		for (int i = 0; i < result.length; i++) {
 			if (null != files[i]) {
-                result[i] = files[i].getPath();
-            }
-		}
-        return result;
-    }
-
-    /** @return array same length as input, with String paths */
-    public static String[] getPaths(List files) {
-        final int size = (null == files ? 0 : files.size());
-        if (0 == size) {
-            return new String[0];
-        }
-        String[] result = new String[size];
-        for (int i = 0; i < size; i++) {
-            File file = (File) files.get(i);
-            if (null != file) {
-                result[i] = file.getPath();
-            }
-        }
-        return result;
-    }
-
-
-    /**
-     * Extract the name of a class from the path to its file.
-     * If the basedir is null, then the class is assumed to be in
-     * the default package unless the classFile has one of the 
-     * top-level suffixes { com, org, java, javax } as a parent directory.
-     * @param basedir the File of the base directory (prefix of classFile)
-     * @param classFile the File of the class to extract the name for
-     * @throws IllegalArgumentException if classFile is null or does not end with 
-     *          ".class" or a non-null basedir is not a prefix of classFile
-     */
-    public static String fileToClassName(File basedir, File classFile) {
-        LangUtil.throwIaxIfNull(classFile, "classFile");
-        String classFilePath = normalizedPath(classFile);
-        if (!classFilePath.endsWith(".class")) {
-            String m = classFile + " does not end with .class";
-            throw new IllegalArgumentException(m);
-        }
-        classFilePath = classFilePath.substring(0, classFilePath.length()-6);
-        if (null != basedir) {
-            String basePath = normalizedPath(basedir);
-            if (!classFilePath.startsWith(basePath)) {
-                String m = classFile + " does not start with " + basedir;
-                throw new IllegalArgumentException(m);
-            }    
-            classFilePath = classFilePath.substring(basePath.length()+1);
-        } else {
-            final String[] suffixes = new String[] { "com", "org", "java", "javax"};
-            boolean found = false;
-            for (int i = 0; !found && (i < suffixes.length); i++) {
+				result[i] = files[i].getPath();
+			}
+		}
+		return result;
+	}
+
+	/** @return array same length as input, with String paths */
+	public static String[] getPaths(List files) {
+		final int size = (null == files ? 0 : files.size());
+		if (0 == size) {
+			return new String[0];
+		}
+		String[] result = new String[size];
+		for (int i = 0; i < size; i++) {
+			File file = (File) files.get(i);
+			if (null != file) {
+				result[i] = file.getPath();
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Extract the name of a class from the path to its file. If the basedir is null, then the class is assumed to be in the default
+	 * package unless the classFile has one of the top-level suffixes { com, org, java, javax } as a parent directory.
+	 * 
+	 * @param basedir the File of the base directory (prefix of classFile)
+	 * @param classFile the File of the class to extract the name for
+	 * @throws IllegalArgumentException if classFile is null or does not end with ".class" or a non-null basedir is not a prefix of
+	 *         classFile
+	 */
+	public static String fileToClassName(File basedir, File classFile) {
+		LangUtil.throwIaxIfNull(classFile, "classFile");
+		String classFilePath = normalizedPath(classFile);
+		if (!classFilePath.endsWith(".class")) {
+			String m = classFile + " does not end with .class";
+			throw new IllegalArgumentException(m);
+		}
+		classFilePath = classFilePath.substring(0, classFilePath.length() - 6);
+		if (null != basedir) {
+			String basePath = normalizedPath(basedir);
+			if (!classFilePath.startsWith(basePath)) {
+				String m = classFile + " does not start with " + basedir;
+				throw new IllegalArgumentException(m);
+			}
+			classFilePath = classFilePath.substring(basePath.length() + 1);
+		} else {
+			final String[] suffixes = new String[] { "com", "org", "java", "javax" };
+			boolean found = false;
+			for (int i = 0; !found && (i < suffixes.length); i++) {
 				int loc = classFilePath.indexOf(suffixes[i] + "/");
-                if ((0 == loc) 
-                    ||  ((-1 != loc) && ('/' == classFilePath.charAt(loc-1)))) {
-                    classFilePath = classFilePath.substring(loc);
-                    found = true;
-                }
+				if ((0 == loc) || ((-1 != loc) && ('/' == classFilePath.charAt(loc - 1)))) {
+					classFilePath = classFilePath.substring(loc);
+					found = true;
+				}
+			}
+			if (!found) {
+				int loc = classFilePath.lastIndexOf("/");
+				if (-1 != loc) { // treat as default package
+					classFilePath = classFilePath.substring(loc + 1);
+				}
+			}
+		}
+		return classFilePath.replace('/', '.');
+	}
+
+	/**
+	 * Normalize path for comparisons by rendering absolute, clipping basedir prefix, trimming and changing '\\' to '/'
+	 * 
+	 * @param file the File with the path to normalize
+	 * @param basedir the File for the prefix of the file to normalize - ignored if null
+	 * @return "" if null or normalized path otherwise
+	 * @throws IllegalArgumentException if basedir is not a prefix of file
+	 */
+	public static String normalizedPath(File file, File basedir) {
+		String filePath = normalizedPath(file);
+		if (null != basedir) {
+			String basePath = normalizedPath(basedir);
+			if (filePath.startsWith(basePath)) {
+				filePath = filePath.substring(basePath.length());
+				if (filePath.startsWith("/")) {
+					filePath = filePath.substring(1);
+				}
+			}
+		}
+		return filePath;
+	}
+
+	/**
+	 * Render a set of files to String as a path by getting absolute paths of each and delimiting with infix.
+	 * 
+	 * @param files the File[] to flatten - may be null or empty
+	 * @param infix the String delimiter internally between entries (if null, then use File.pathSeparator). (alias to
+	 *        <code>flatten(getAbsolutePaths(files), infix)</code>
+	 * @return String with absolute paths to entries in order, delimited with infix
+	 */
+	public static String flatten(File[] files, String infix) {
+		if (LangUtil.isEmpty(files)) {
+			return "";
+		}
+		return flatten(getPaths(files), infix);
+	}
+
+	/**
+	 * Flatten File[] to String.
+	 * 
+	 * @param files the File[] of paths to flatten - null ignored
+	 * @param infix the String infix to use - null treated as File.pathSeparator
+	 */
+	public static String flatten(String[] paths, String infix) {
+		if (null == infix) {
+			infix = File.pathSeparator;
+		}
+		StringBuffer result = new StringBuffer();
+		boolean first = true;
+		for (int i = 0; i < paths.length; i++) {
+			String path = paths[i];
+			if (null == path) {
+				continue;
+			}
+			if (first) {
+				first = false;
+			} else {
+				result.append(infix);
 			}
-            if (!found) {
-                int loc = classFilePath.lastIndexOf("/");
-                if (-1 != loc) { // treat as default package
-                    classFilePath = classFilePath.substring(loc+1);
-                }
-            }
-        }
-        return classFilePath.replace('/', '.');        
-    }
-    
-    /** 
-     * Normalize path for comparisons by rendering absolute,
-     * clipping basedir prefix,
-     *  trimming and changing '\\' to '/'
-     * @param file the File with the path to normalize
-     * @param basedir the File for the prefix of the file to normalize - ignored if null
-     * @return "" if null or normalized path otherwise
-     * @throws IllegalArgumentException if basedir is not a prefix of file
-     */
-    public static String normalizedPath(File file, File basedir) {
-        String filePath = normalizedPath(file);
-        if (null != basedir) {
-            String basePath = normalizedPath(basedir);
-            if (filePath.startsWith(basePath)) {
-                filePath = filePath.substring(basePath.length());
-                if (filePath.startsWith("/")) {
-                    filePath = filePath.substring(1);
-                }
-            }
-        }
-        return filePath;
-    }
-
-    /**
-     * Render a set of files to String as a path by getting absolute
-     * paths of each and delimiting with infix.
-     * @param files the File[] to flatten - may be null or empty
-     * @param infix the String delimiter internally between entries 
-     *        (if null, then use File.pathSeparator).
-     * (alias to <code>flatten(getAbsolutePaths(files), infix)</code> 
-     * @return String with absolute paths to entries in order, 
-     *         delimited with infix
-     */
-    public static String flatten(File[] files, String infix) {
-        if (LangUtil.isEmpty(files)) {
-            return "";
-        }
-        return flatten(getPaths(files), infix);
-    }
-    
-    /**
-     * Flatten File[] to String.
-     * @param files the File[] of paths to flatten - null ignored
-     * @param infix the String infix to use - null treated as File.pathSeparator
-     */
-    public static String flatten(String[] paths, String infix) {
-        if (null == infix) {
-            infix = File.pathSeparator;
-        }
-        StringBuffer result = new StringBuffer();            
-        boolean first = true;
-        for (int i = 0; i < paths.length; i++) {
+			result.append(path);
+		}
+		return result.toString();
+	}
+
+	/**
+	 * Normalize path for comparisons by rendering absolute trimming and changing '\\' to '/'
+	 * 
+	 * @return "" if null or normalized path otherwise
+	 */
+	public static String normalizedPath(File file) {
+		return (null == file ? "" : weakNormalize(file.getAbsolutePath()));
+	}
+
+	/**
+	 * Weakly normalize path for comparisons by trimming and changing '\\' to '/'
+	 */
+	public static String weakNormalize(String path) {
+		if (null != path) {
+			path = path.replace('\\', '/').trim();
+		}
+		return path;
+	}
+
+	/**
+	 * Get best File for the first-readable path in input paths, treating entries prefixed "sp:" as system property keys. Safe to
+	 * call in static initializers.
+	 * 
+	 * @param paths the String[] of paths to check.
+	 * @return null if not found, or valid File otherwise
+	 */
+	public static File getBestFile(String[] paths) {
+		if (null == paths) {
+			return null;
+		}
+		File result = null;
+		for (int i = 0; (null == result) && (i < paths.length); i++) {
 			String path = paths[i];
-            if (null == path) {
-                continue;
-            }
-            if (first) {
-                first = false;
-            } else {
-                result.append(infix);
-            }            
-            result.append(path);
-		}
-        return result.toString();
-    }
-    
-    /** 
-     * Normalize path for comparisons by rendering absolute 
-     *  trimming and changing '\\' to '/'
-     * @return "" if null or normalized path otherwise
-     */
-    public static String normalizedPath(File file) {
-        return (null == file ? "" : weakNormalize(file.getAbsolutePath()));
-    }
-    
-    /** 
-     * Weakly normalize path for comparisons by
-     *  trimming and changing '\\' to '/'
-     */
-    public static String weakNormalize(String path) {
-        if (null != path) {
-            path = path.replace('\\', '/').trim();
-        }
-        return path;
-    }
-    
-    /**
-     * Get best File for the first-readable path in input paths,
-     * treating entries prefixed "sp:" as system property keys.
-     * Safe to call in static initializers.
-     * @param paths the String[] of paths to check.
-     * @return null if not found, or valid File otherwise
-     */
-    public static File getBestFile(String[] paths) {
-        if (null == paths) {
-            return null;
-        }
-        File result = null;
-        for (int i = 0; (null == result) && (i < paths.length); i++) {
-            String path = paths[i];
-            if (null == path) {
-                continue;
-            }
-            if (path.startsWith("sp:")) {
-                try {
-                    path = System.getProperty(path.substring(3));
-                } catch (Throwable t) {
-                    path = null;
-                }
-                if (null == path) {
-                    continue;
-                }
-            }
-            try {
-                File f = new File(path);
-                if (f.exists() && f.canRead()) {
-                    result = FileUtil.getBestFile(f);
-                }
-            } catch (Throwable t) {
-                // swallow
-            }
-        }
-        return result;
-    }
-
-    /**
-     * Render as best file, canonical or absolute.
-     * @param file the File to get the best File for (not null)
-     * @return File of the best-available path
-     * @throws IllegalArgumentException if file is null
-     */
-    public static File getBestFile(File file) {
-        LangUtil.throwIaxIfNull(file, "file");
-        if (file.exists()) {
-            try {
-                return file.getCanonicalFile();
-            } catch (IOException e) {
-                return file.getAbsoluteFile();
-            }
-        } else {
-            return file;
-        }
-    }
-
-    /**
-     * Render as best path, canonical or absolute.
-     * @param file the File to get the path for (not null)
-     * @return String of the best-available path
-     * @throws IllegalArgumentException if file is null
-     */
-    public static String getBestPath(File file) {
-        LangUtil.throwIaxIfNull(file, "file");
-        if (file.exists()) {
-	        try {
-	            return file.getCanonicalPath();
-	        } catch (IOException e) {
-	            return file.getAbsolutePath();
-	        }
-        } else {
-        	return file.getPath();
-        }
-    }
-    
-    /** @return array same length as input, with String absolute paths */
-    public static String[] getAbsolutePaths(File[] files) {
-        if ((null == files) || (0 == files.length)) {
-            return new String[0];
-        }
-        String[] result = new String[files.length];
-        for (int i = 0; i < result.length; i++) {
-            if (null != files[i]) {
-                result[i] = files[i].getAbsolutePath();
-            }
-        }
-        return result;
-    }
-    
-    /** 
-     * Recursively delete the contents of dir, but not the dir itself 
-     * @return the total number of files deleted 
-     */    
-    public static int deleteContents(File dir) {
-        return deleteContents(dir, ALL);
-    }
-    
-    /** 
-     * Recursively delete some contents of dir, but not the dir itself.
-     * This deletes any subdirectory which is empty after its files
-     * are deleted.
-     * @return the total number of files deleted 
-     */    
-    public static int deleteContents(File dir, FileFilter filter) {
-        return deleteContents(dir, filter, true);
-    }
-    
-    /** 
-     * Recursively delete some contents of dir, but not the dir itself.
-     * If deleteEmptyDirs is true, this deletes any subdirectory 
-     * which is empty after its files are deleted.
-     * @param dir the File directory (if a file, the the file is deleted)
-     * @return the total number of files deleted 
-     */    
-    public static int deleteContents(File dir, FileFilter filter, 
-                                    boolean deleteEmptyDirs) {
-        if (null == dir) {
-            throw new IllegalArgumentException("null dir");
-        }
-        if ((!dir.exists()) || (!dir.canWrite())) {
-            return 0;
-        }
-        if (!dir.isDirectory()) {
-            dir.delete();
-            return 1;
-        }
-        String[] fromFiles = dir.list();
-        int result = 0;
-        for (int i = 0; i < fromFiles.length; i++) {
-            String string = fromFiles[i];
-            File file = new File(dir, string);
-            if ((null == filter) || filter.accept(file)) {
-                if (file.isDirectory()) {
-                    result += deleteContents(file, filter, deleteEmptyDirs);
-                    if (deleteEmptyDirs && (0 == file.list().length)) {
-                        file.delete();
-                    }
-                } else {
-                    /*boolean ret = */file.delete();
-                    result++;
-                }
-            }
-        }
-        return result;
-    }
-    
-    /** 
-     * Copy contents of fromDir into toDir
-     * @param fromDir must exist and be readable
-     * @param toDir must exist or be creatable and be writable
-     * @return the total number of files copied 
-     */
-    public static int copyDir(File fromDir, File toDir) throws IOException {
-        return copyDir(fromDir, toDir, null, null);
-    }
-    
-    /** 
-     * Recursively copy files in fromDir (with any fromSuffix) to toDir,
-     * replacing fromSuffix with toSuffix if any.
-     * This silently ignores dirs and files that are not readable
-     * but throw IOException for directories that are not writable.
-     * This does not clean out the original contents of toDir.
-     * (subdirectories are not renamed per directory rules)
-     * @param fromSuffix select files with this suffix - select all if null or empty
-     * @param toSuffix replace fromSuffix with toSuffix in the destination file
-     *         name - ignored if null or empty, 
-     *         appended to name if fromSuffix is null or empty
-     * @return the total number of files copied 
-     */
-    public static int copyDir(File fromDir, File toDir,
-                               final String fromSuffix, String toSuffix) throws IOException {
-        return copyDir(fromDir, toDir, fromSuffix, toSuffix, (FileFilter) null);
-    }
-    
-    /** 
-     * Recursively copy files in fromDir (with any fromSuffix) to toDir,
-     * replacing fromSuffix with toSuffix if any,
-     * and adding the destination file to any collector.
-     * This silently ignores dirs and files that are not readable
-     * but throw IOException for directories that are not writable.
-     * This does not clean out the original contents of toDir.
-     * (subdirectories are not renamed per directory rules)
-     * This calls any delegate FilenameFilter to collect any selected file.
-     * @param fromSuffix select files with this suffix - select all if null or empty
-     * @param toSuffix replace fromSuffix with toSuffix in the destination file
-     *         name - ignored if null or empty, 
-     *         appended to name if fromSuffix is null or empty
-     * @param collector the List sink for destination files - ignored if null
-     * @return the total number of files copied 
-     */
-    public static int copyDir(File fromDir, File toDir, final String fromSuffix, 
-                             final String toSuffix, final List collector) throws IOException {
-        //int before = collector.size();        
-        if (null == collector) {
-            return copyDir(fromDir, toDir, fromSuffix, toSuffix);
-        } else {
-            FileFilter collect = new FileFilter() {
-    			public boolean accept(File pathname) {
-    				return collector.add(pathname);
-    			}
-            };
-            return copyDir(fromDir, toDir, fromSuffix, toSuffix, collect);
-         }
-    }
-    
-    /** 
-     * Recursively copy files in fromDir (with any fromSuffix) to toDir,
-     * replacing fromSuffix with toSuffix if any.
-     * This silently ignores dirs and files that are not readable
-     * but throw IOException for directories that are not writable.
-     * This does not clean out the original contents of toDir.
-     * (subdirectories are not renamed per directory rules)
-     * This calls any delegate FilenameFilter to collect any selected file.
-     * @param fromSuffix select files with this suffix - select all if null or empty
-     * @param toSuffix replace fromSuffix with toSuffix in the destination file
-     *         name - ignored if null or empty, 
-     *         appended to name if fromSuffix is null or empty
-     * @return the total number of files copied 
-     */
-    public static int copyDir(File fromDir, File toDir, final String fromSuffix, 
-                             final String toSuffix, final FileFilter delegate) throws IOException {
-                                
-        if ((null == fromDir) || (!fromDir.canRead())) {
-            return 0;
-        }
-        final boolean haveSuffix = ((null != fromSuffix) && (0 < fromSuffix.length()));
-        final int slen = (!haveSuffix ? 0 : fromSuffix.length());
-        
-        if (!toDir.exists()) {
-            toDir.mkdirs();
-        }
-        final String[] fromFiles;
-        if (!haveSuffix) {
-            fromFiles = fromDir.list();
-        } else {
-            FilenameFilter filter = new FilenameFilter() {
-                public boolean accept(File dir, String name) {
-                    return (new File(dir, name).isDirectory()
-                        || (name.endsWith(fromSuffix)));
-                }
-            };
-            fromFiles = fromDir.list(filter);
-        }
-        int result = 0;
-        final int MAX = (null == fromFiles ? 0 : fromFiles.length);
-        for (int i = 0; i < MAX; i++) {
-            String filename = fromFiles[i];
-            File fromFile = new File(fromDir, filename);
-            if (fromFile.canRead()) {
-                if (fromFile.isDirectory()) {
-                    result += copyDir(fromFile, new File(toDir, filename), fromSuffix, toSuffix, delegate);
-                } else if (fromFile.isFile()) {
-                    if (haveSuffix) {
-                        filename = filename.substring(0, filename.length()-slen);
-                    }
-                    if (null != toSuffix) {
-                        filename = filename + toSuffix;
-                    }
-                    File targetFile = new File(toDir, filename);
-                    if ((null == delegate) || delegate.accept(targetFile)) {
-                        copyFile(fromFile, targetFile);
-                    }
-                    result++;
-                }
-            }
-        }
-        return result;
-    }
-        
-    /** 
-     * Recursively list files in srcDir.
-     * @return ArrayList with String paths of File under srcDir (relative to srcDir)
-     */
-    public static String[] listFiles(File srcDir)  {
-        ArrayList result = new ArrayList();
-        if ((null != srcDir) && srcDir.canRead()) {
-            listFiles(srcDir, null, result);
-        }     
-        return (String[]) result.toArray(new String[0]);
-    }
-    
-    public static final FileFilter aspectjSourceFileFilter = new FileFilter() {
+			if (null == path) {
+				continue;
+			}
+			if (path.startsWith("sp:")) {
+				try {
+					path = System.getProperty(path.substring(3));
+				} catch (Throwable t) {
+					path = null;
+				}
+				if (null == path) {
+					continue;
+				}
+			}
+			try {
+				File f = new File(path);
+				if (f.exists() && f.canRead()) {
+					result = FileUtil.getBestFile(f);
+				}
+			} catch (Throwable t) {
+				// swallow
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Render as best file, canonical or absolute.
+	 * 
+	 * @param file the File to get the best File for (not null)
+	 * @return File of the best-available path
+	 * @throws IllegalArgumentException if file is null
+	 */
+	public static File getBestFile(File file) {
+		LangUtil.throwIaxIfNull(file, "file");
+		if (file.exists()) {
+			try {
+				return file.getCanonicalFile();
+			} catch (IOException e) {
+				return file.getAbsoluteFile();
+			}
+		} else {
+			return file;
+		}
+	}
+
+	/**
+	 * Render as best path, canonical or absolute.
+	 * 
+	 * @param file the File to get the path for (not null)
+	 * @return String of the best-available path
+	 * @throws IllegalArgumentException if file is null
+	 */
+	public static String getBestPath(File file) {
+		LangUtil.throwIaxIfNull(file, "file");
+		if (file.exists()) {
+			try {
+				return file.getCanonicalPath();
+			} catch (IOException e) {
+				return file.getAbsolutePath();
+			}
+		} else {
+			return file.getPath();
+		}
+	}
+
+	/** @return array same length as input, with String absolute paths */
+	public static String[] getAbsolutePaths(File[] files) {
+		if ((null == files) || (0 == files.length)) {
+			return new String[0];
+		}
+		String[] result = new String[files.length];
+		for (int i = 0; i < result.length; i++) {
+			if (null != files[i]) {
+				result[i] = files[i].getAbsolutePath();
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Recursively delete the contents of dir, but not the dir itself
+	 * 
+	 * @return the total number of files deleted
+	 */
+	public static int deleteContents(File dir) {
+		return deleteContents(dir, ALL);
+	}
+
+	/**
+	 * Recursively delete some contents of dir, but not the dir itself. This deletes any subdirectory which is empty after its files
+	 * are deleted.
+	 * 
+	 * @return the total number of files deleted
+	 */
+	public static int deleteContents(File dir, FileFilter filter) {
+		return deleteContents(dir, filter, true);
+	}
+
+	/**
+	 * Recursively delete some contents of dir, but not the dir itself. If deleteEmptyDirs is true, this deletes any subdirectory
+	 * which is empty after its files are deleted.
+	 * 
+	 * @param dir the File directory (if a file, the the file is deleted)
+	 * @return the total number of files deleted
+	 */
+	public static int deleteContents(File dir, FileFilter filter, boolean deleteEmptyDirs) {
+		if (null == dir) {
+			throw new IllegalArgumentException("null dir");
+		}
+		if ((!dir.exists()) || (!dir.canWrite())) {
+			return 0;
+		}
+		if (!dir.isDirectory()) {
+			dir.delete();
+			return 1;
+		}
+		String[] fromFiles = dir.list();
+		int result = 0;
+		for (int i = 0; i < fromFiles.length; i++) {
+			String string = fromFiles[i];
+			File file = new File(dir, string);
+			if ((null == filter) || filter.accept(file)) {
+				if (file.isDirectory()) {
+					result += deleteContents(file, filter, deleteEmptyDirs);
+					if (deleteEmptyDirs && (0 == file.list().length)) {
+						file.delete();
+					}
+				} else {
+					/* boolean ret = */file.delete();
+					result++;
+				}
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Copy contents of fromDir into toDir
+	 * 
+	 * @param fromDir must exist and be readable
+	 * @param toDir must exist or be creatable and be writable
+	 * @return the total number of files copied
+	 */
+	public static int copyDir(File fromDir, File toDir) throws IOException {
+		return copyDir(fromDir, toDir, null, null);
+	}
+
+	/**
+	 * Recursively copy files in fromDir (with any fromSuffix) to toDir, replacing fromSuffix with toSuffix if any. This silently
+	 * ignores dirs and files that are not readable but throw IOException for directories that are not writable. This does not clean
+	 * out the original contents of toDir. (subdirectories are not renamed per directory rules)
+	 * 
+	 * @param fromSuffix select files with this suffix - select all if null or empty
+	 * @param toSuffix replace fromSuffix with toSuffix in the destination file name - ignored if null or empty, appended to name if
+	 *        fromSuffix is null or empty
+	 * @return the total number of files copied
+	 */
+	public static int copyDir(File fromDir, File toDir, final String fromSuffix, String toSuffix) throws IOException {
+		return copyDir(fromDir, toDir, fromSuffix, toSuffix, (FileFilter) null);
+	}
+
+	/**
+	 * Recursively copy files in fromDir (with any fromSuffix) to toDir, replacing fromSuffix with toSuffix if any, and adding the
+	 * destination file to any collector. This silently ignores dirs and files that are not readable but throw IOException for
+	 * directories that are not writable. This does not clean out the original contents of toDir. (subdirectories are not renamed
+	 * per directory rules) This calls any delegate FilenameFilter to collect any selected file.
+	 * 
+	 * @param fromSuffix select files with this suffix - select all if null or empty
+	 * @param toSuffix replace fromSuffix with toSuffix in the destination file name - ignored if null or empty, appended to name if
+	 *        fromSuffix is null or empty
+	 * @param collector the List sink for destination files - ignored if null
+	 * @return the total number of files copied
+	 */
+	public static int copyDir(File fromDir, File toDir, final String fromSuffix, final String toSuffix, final List collector)
+			throws IOException {
+		// int before = collector.size();
+		if (null == collector) {
+			return copyDir(fromDir, toDir, fromSuffix, toSuffix);
+		} else {
+			FileFilter collect = new FileFilter() {
+				public boolean accept(File pathname) {
+					return collector.add(pathname);
+				}
+			};
+			return copyDir(fromDir, toDir, fromSuffix, toSuffix, collect);
+		}
+	}
+
+	/**
+	 * Recursively copy files in fromDir (with any fromSuffix) to toDir, replacing fromSuffix with toSuffix if any. This silently
+	 * ignores dirs and files that are not readable but throw IOException for directories that are not writable. This does not clean
+	 * out the original contents of toDir. (subdirectories are not renamed per directory rules) This calls any delegate
+	 * FilenameFilter to collect any selected file.
+	 * 
+	 * @param fromSuffix select files with this suffix - select all if null or empty
+	 * @param toSuffix replace fromSuffix with toSuffix in the destination file name - ignored if null or empty, appended to name if
+	 *        fromSuffix is null or empty
+	 * @return the total number of files copied
+	 */
+	public static int copyDir(File fromDir, File toDir, final String fromSuffix, final String toSuffix, final FileFilter delegate)
+			throws IOException {
+
+		if ((null == fromDir) || (!fromDir.canRead())) {
+			return 0;
+		}
+		final boolean haveSuffix = ((null != fromSuffix) && (0 < fromSuffix.length()));
+		final int slen = (!haveSuffix ? 0 : fromSuffix.length());
+
+		if (!toDir.exists()) {
+			toDir.mkdirs();
+		}
+		final String[] fromFiles;
+		if (!haveSuffix) {
+			fromFiles = fromDir.list();
+		} else {
+			FilenameFilter filter = new FilenameFilter() {
+				public boolean accept(File dir, String name) {
+					return (new File(dir, name).isDirectory() || (name.endsWith(fromSuffix)));
+				}
+			};
+			fromFiles = fromDir.list(filter);
+		}
+		int result = 0;
+		final int MAX = (null == fromFiles ? 0 : fromFiles.length);
+		for (int i = 0; i < MAX; i++) {
+			String filename = fromFiles[i];
+			File fromFile = new File(fromDir, filename);
+			if (fromFile.canRead()) {
+				if (fromFile.isDirectory()) {
+					result += copyDir(fromFile, new File(toDir, filename), fromSuffix, toSuffix, delegate);
+				} else if (fromFile.isFile()) {
+					if (haveSuffix) {
+						filename = filename.substring(0, filename.length() - slen);
+					}
+					if (null != toSuffix) {
+						filename = filename + toSuffix;
+					}
+					File targetFile = new File(toDir, filename);
+					if ((null == delegate) || delegate.accept(targetFile)) {
+						copyFile(fromFile, targetFile);
+					}
+					result++;
+				}
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Recursively list files in srcDir.
+	 * 
+	 * @return ArrayList with String paths of File under srcDir (relative to srcDir)
+	 */
+	public static String[] listFiles(File srcDir) {
+		ArrayList result = new ArrayList();
+		if ((null != srcDir) && srcDir.canRead()) {
+			listFiles(srcDir, null, result);
+		}
+		return (String[]) result.toArray(new String[0]);
+	}
+
+	public static final FileFilter aspectjSourceFileFilter = new FileFilter() {
 		public boolean accept(File pathname) {
 			String name = pathname.getName().toLowerCase();
 			return name.endsWith(".java") || name.endsWith(".aj");
 		}
-    };
-    
-    
-    /** 
-     * Recursively list files in srcDir.
-     * @return ArrayList with String paths of File under srcDir (relative to srcDir)
-     */
-    public static File[] listFiles(File srcDir, FileFilter fileFilter)  {
-        ArrayList result = new ArrayList();
-        if ((null != srcDir) && srcDir.canRead()) {
-            listFiles(srcDir, result, fileFilter);
-        }     
-        return (File[]) result.toArray(new File[result.size()]);
-    }
-
-    /**
-     * Convert String[] paths to File[] as offset of base directory 
-     * @param basedir the non-null File base directory for File to create with paths
-     * @param paths the String[] of paths to create
-     * @return File[] with same length as paths
-     */
-    public static File[] getBaseDirFiles(
-        File basedir, 
-        String[] paths) {
-        return getBaseDirFiles(basedir, paths, (String[]) null);
-    }
-    
-    /**
-     * Convert String[] paths to File[] as offset of base directory 
-     * @param basedir the non-null File base directory for File to create with paths
-     * @param paths the String[] of paths to create
-     * @param suffixes the String[] of suffixes to limit sources to - ignored if null
-     * @return File[] with same length as paths
-     */
-    public static File[] getBaseDirFiles(
-        File basedir, 
-        String[] paths, 
-        String[] suffixes) {
-        LangUtil.throwIaxIfNull(basedir, "basedir");
-        LangUtil.throwIaxIfNull(paths, "paths");
-        File[] result = null;
-        if (!LangUtil.isEmpty(suffixes)) {
-            ArrayList list = new ArrayList();
-            for (int i = 0; i < paths.length; i++) {
-                String path = paths[i];
-                for (int j = 0; j < suffixes.length; j++) {
-                	if (path.endsWith(suffixes[j])) {
-                        list.add(new File(basedir, paths[i]));
-                        break;
-                	}
+	};
+
+	/**
+	 * Recursively list files in srcDir.
+	 * 
+	 * @return ArrayList with String paths of File under srcDir (relative to srcDir)
+	 */
+	public static File[] listFiles(File srcDir, FileFilter fileFilter) {
+		ArrayList result = new ArrayList();
+		if ((null != srcDir) && srcDir.canRead()) {
+			listFiles(srcDir, result, fileFilter);
+		}
+		return (File[]) result.toArray(new File[result.size()]);
+	}
+
+	/**
+	 * Convert String[] paths to File[] as offset of base directory
+	 * 
+	 * @param basedir the non-null File base directory for File to create with paths
+	 * @param paths the String[] of paths to create
+	 * @return File[] with same length as paths
+	 */
+	public static File[] getBaseDirFiles(File basedir, String[] paths) {
+		return getBaseDirFiles(basedir, paths, (String[]) null);
+	}
+
+	/**
+	 * Convert String[] paths to File[] as offset of base directory
+	 * 
+	 * @param basedir the non-null File base directory for File to create with paths
+	 * @param paths the String[] of paths to create
+	 * @param suffixes the String[] of suffixes to limit sources to - ignored if null
+	 * @return File[] with same length as paths
+	 */
+	public static File[] getBaseDirFiles(File basedir, String[] paths, String[] suffixes) {
+		LangUtil.throwIaxIfNull(basedir, "basedir");
+		LangUtil.throwIaxIfNull(paths, "paths");
+		File[] result = null;
+		if (!LangUtil.isEmpty(suffixes)) {
+			ArrayList list = new ArrayList();
+			for (int i = 0; i < paths.length; i++) {
+				String path = paths[i];
+				for (int j = 0; j < suffixes.length; j++) {
+					if (path.endsWith(suffixes[j])) {
+						list.add(new File(basedir, paths[i]));
+						break;
+					}
 				}
-            }
-            result = (File[]) list.toArray(new File[0]);
-        } else {
-            result = new File[paths.length];
-            for (int i = 0; i < result.length; i++) {
-                result[i] = newFile(basedir, paths[i]);
-            }
-        }
-        return result;
-    }
-    
-    /**
-     * Create a new File, resolving paths ".." and "." specially.
-     * @param dir the File for the parent directory of the file
-     * @param path the path in the parent directory (filename only?)
-     * @return File for the new file.
-     */
-    private static File newFile(File dir, String path) {
-        if (".".equals(path)) {
-            return dir;
-        } else if ("..".equals(path)) {
-            File parentDir = dir.getParentFile();
-            if (null != parentDir) {
-                return parentDir;
-            } else {
-                return new File(dir, "..");
-            }
-        } else {
-            return new File(dir, path);
-        }
-    }
-
-    /**
-     * Copy files from source dir into destination directory,
-     * creating any needed directories.  This differs from copyDir in not
-     * being recursive; each input with the source dir creates a full path.
-     * However, if the source is a directory, it is copied as such.
-     * @param srcDir an existing, readable directory containing relativePaths files
-     * @param relativePaths a set of paths relative to srcDir to readable File to copy
-     * @param destDir an existing, writable directory to copy files to
-     * @throws IllegalArgumentException if input invalid, IOException if operations fail
-     */
-    public static File[] copyFiles(File srcDir, String[] relativePaths, File destDir) 
-            throws IllegalArgumentException, IOException {
-        final String[] paths = relativePaths;
-        throwIaxUnlessCanReadDir(srcDir, "srcDir");
-        throwIaxUnlessCanWriteDir(destDir, "destDir");
-        LangUtil.throwIaxIfNull(paths, "relativePaths");
-        File[] result = new File[paths.length];
-        for (int i = 0; i < paths.length; i++) {
-            String path = paths[i];
-            LangUtil.throwIaxIfNull(path, "relativePaths-entry");
-            File src = newFile(srcDir, paths[i]);
-            File dest = newFile(destDir, path);
-            File destParent = dest.getParentFile();
-            if (!destParent.exists()) {
-                destParent.mkdirs();
-            }
-            LangUtil.throwIaxIfFalse(canWriteDir(destParent), "dest-entry-parent");
-            copyFile(src, dest); // both file-dir and dir-dir copies
-            result[i] = dest;
-        }
-        return result;
-    }
-
-    /** 
-     * Copy fromFile to toFile, handling file-file, dir-dir, and file-dir
-     * copies.
-     * @param fromFile the File path of the file or directory to copy - must be
-     * readable
-     * @param toFile the File path of the target file or directory - must be
-     * writable (will be created if it does not exist)
-     */
-    public static void copyFile(File fromFile, File toFile) throws IOException {
-        LangUtil.throwIaxIfNull(fromFile, "fromFile");
-        LangUtil.throwIaxIfNull(toFile, "toFile");
-        LangUtil.throwIaxIfFalse(!toFile.equals(fromFile), "same file");
-        if (toFile.isDirectory()) {   // existing directory 
-            throwIaxUnlessCanWriteDir(toFile, "toFile");
-            if (fromFile.isFile()) {  // file-dir
-                File targFile = new File(toFile, fromFile.getName());
-                copyValidFiles(fromFile, targFile);
-            } else if (fromFile.isDirectory()) { // dir-dir
-                copyDir(fromFile, toFile);
-            } else {
-                LangUtil.throwIaxIfFalse(false, "not dir or file: " + fromFile);
-            }
-        } else if (toFile.isFile()) {     // target file exists
-            if (fromFile.isDirectory()) {
-                LangUtil.throwIaxIfFalse(false, "can't copy to file dir: " + fromFile);
-            }
-            copyValidFiles(fromFile, toFile); // file-file                
-        } else { // target file is a non-existent path -- could be file or dir
-            /*File toFileParent = */ensureParentWritable(toFile);
-            if (fromFile.isFile()) {
-                copyValidFiles(fromFile, toFile);
-            } else if (fromFile.isDirectory()) {
-                toFile.mkdirs();
-                throwIaxUnlessCanWriteDir(toFile, "toFile");
-                copyDir(fromFile, toFile);                
-            } else {
-                LangUtil.throwIaxIfFalse(false, "not dir or file: " + fromFile);
-            }
-        }
-    }
-    
-    /**
-     * Ensure that the parent directory to path can be written.
-     * If the path has a null parent, DEFAULT_PARENT is tested.
-     * If the path parent does not exist, this tries to create it.
-     * @param path the File path whose parent should be writable
-     * @return the File path of the writable parent directory
-     * @throws IllegalArgumentException if parent cannot be written
-     *         or path is null.
-     */
-    public static File ensureParentWritable(File path) {
-        LangUtil.throwIaxIfNull(path, "path");
-        File pathParent = path.getParentFile();
-        if (null == pathParent) {
-            pathParent = DEFAULT_PARENT;     
-        }
-        if (!pathParent.canWrite()) {
-            pathParent.mkdirs();
-        }
-        throwIaxUnlessCanWriteDir(pathParent, "pathParent");
-        return pathParent;
-    }
-    
-    /** 
-     * Copy file to file.
-     * @param fromFile the File to copy (readable, non-null file)
-     * @param toFile the File to copy to (non-null, parent dir exists)
-     * @throws IOException
-     */
-    public static void copyValidFiles(File fromFile, File toFile) throws IOException {
-        FileInputStream in = null;
-        FileOutputStream out = null;
-        try {
-            in = new FileInputStream(fromFile);
-            out = new FileOutputStream(toFile);
-            copyStream(in, out);
-        } finally {
-            if (out != null) {
-                out.close();
-            }
-            if (in != null) {
-                in.close();
-            }
-        }
-    }
-    
-    /** do line-based copying */
-    public static void copyStream(DataInputStream in, PrintStream out) throws IOException {
-        LangUtil.throwIaxIfNull(in, "in");
-        LangUtil.throwIaxIfNull(in, "out");
-        String s;
-        while (null != (s = in.readLine())) {
-            out.println(s);
-        }
-    }
-
-    public static void copyStream(InputStream in, OutputStream out) throws IOException {
-        final int MAX = 4096;
-        byte[] buf = new byte[MAX];
-        for (int bytesRead = in.read(buf, 0, MAX);
-            bytesRead != -1;
-            bytesRead = in.read(buf, 0, MAX)) {
-            out.write(buf, 0, bytesRead);
-        }
-    }
-
-    public static void copyStream(Reader in, Writer out) throws IOException {
-        final int MAX = 4096;
-        char[] buf = new char[MAX];
-        for (int bytesRead = in.read(buf, 0, MAX);
-            bytesRead != -1;
-            bytesRead = in.read(buf, 0, MAX)) {
-            out.write(buf, 0, bytesRead);
-        }
-    }
-        
-    /** 
-     * Make a new child directory of parent
-     * @param parent a File for the parent (writable)
-     * @param child a prefix for the child directory
-     * @return a File dir that exists with parentDir as the parent file or null
-     */
-    public static File makeNewChildDir(File parent, String child) {
-        if (null == parent || ! parent.canWrite() || !parent.isDirectory()) {
-            throw new IllegalArgumentException("bad parent: " + parent);
-        } else if (null == child) {
-            child = "makeNewChildDir";
-        } else if (!isValidFileName(child)) {
-            throw new IllegalArgumentException("bad child: " + child);
-        }
-        File result = new File(parent, child);
-        int safety = 1000;
-        for (String suffix = FileUtil.randomFileString();
-            ((0 < --safety) && result.exists());
-            suffix = FileUtil.randomFileString()) {
-            result = new File(parent, child+suffix);
-        }
-        if (result.exists()) {
-            System.err.println("exhausted files for child dir in " + parent);
-            return null;
-        } 
-        return ((result.mkdirs() && result.exists()) ? result : null);
-    }
-
-    /**
-     * Make a new temporary directory in the same directory
-     * that the system uses for temporary files, or if
-     * that files, in the current directory.
-     * @param name the preferred (simple) name of the directory - may be null.
-     * @return File of an existing new temp dir, or null if unable to create
-     */
-    public static File getTempDir(String name) {
-        if (null == name) {
-            name = "FileUtil_getTempDir";
-        } else if (!isValidFileName(name)) {
-            throw new IllegalArgumentException(" invalid: " + name);
-        }
-        File result = null;
-        File tempFile = null;
-        try {
-            tempFile = File.createTempFile("ignoreMe", ".txt");
-            File tempParent = tempFile.getParentFile();
-            result = makeNewChildDir(tempParent, name);
-        } catch (IOException t) {
-            result = makeNewChildDir(new File("."), name);
-        } finally {
-            if (null != tempFile) {
-                tempFile.delete();
-            }            
-        }
-        return result;
-    }
-        
-    public static URL[] getFileURLs(File[] files) { 
-        if ((null == files) || (0 == files.length)) {
-            return new URL[0];
-        }
-        URL[] result = new URL[files.length]; // XXX dangerous non-copy...
-        for (int i = 0; i < result.length; i++) {
+			}
+			result = (File[]) list.toArray(new File[0]);
+		} else {
+			result = new File[paths.length];
+			for (int i = 0; i < result.length; i++) {
+				result[i] = newFile(basedir, paths[i]);
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Create a new File, resolving paths ".." and "." specially.
+	 * 
+	 * @param dir the File for the parent directory of the file
+	 * @param path the path in the parent directory (filename only?)
+	 * @return File for the new file.
+	 */
+	private static File newFile(File dir, String path) {
+		if (".".equals(path)) {
+			return dir;
+		} else if ("..".equals(path)) {
+			File parentDir = dir.getParentFile();
+			if (null != parentDir) {
+				return parentDir;
+			} else {
+				return new File(dir, "..");
+			}
+		} else {
+			return new File(dir, path);
+		}
+	}
+
+	/**
+	 * Copy files from source dir into destination directory, creating any needed directories. This differs from copyDir in not
+	 * being recursive; each input with the source dir creates a full path. However, if the source is a directory, it is copied as
+	 * such.
+	 * 
+	 * @param srcDir an existing, readable directory containing relativePaths files
+	 * @param relativePaths a set of paths relative to srcDir to readable File to copy
+	 * @param destDir an existing, writable directory to copy files to
+	 * @throws IllegalArgumentException if input invalid, IOException if operations fail
+	 */
+	public static File[] copyFiles(File srcDir, String[] relativePaths, File destDir) throws IllegalArgumentException, IOException {
+		final String[] paths = relativePaths;
+		throwIaxUnlessCanReadDir(srcDir, "srcDir");
+		throwIaxUnlessCanWriteDir(destDir, "destDir");
+		LangUtil.throwIaxIfNull(paths, "relativePaths");
+		File[] result = new File[paths.length];
+		for (int i = 0; i < paths.length; i++) {
+			String path = paths[i];
+			LangUtil.throwIaxIfNull(path, "relativePaths-entry");
+			File src = newFile(srcDir, paths[i]);
+			File dest = newFile(destDir, path);
+			File destParent = dest.getParentFile();
+			if (!destParent.exists()) {
+				destParent.mkdirs();
+			}
+			LangUtil.throwIaxIfFalse(canWriteDir(destParent), "dest-entry-parent");
+			copyFile(src, dest); // both file-dir and dir-dir copies
+			result[i] = dest;
+		}
+		return result;
+	}
+
+	/**
+	 * Copy fromFile to toFile, handling file-file, dir-dir, and file-dir copies.
+	 * 
+	 * @param fromFile the File path of the file or directory to copy - must be readable
+	 * @param toFile the File path of the target file or directory - must be writable (will be created if it does not exist)
+	 */
+	public static void copyFile(File fromFile, File toFile) throws IOException {
+		LangUtil.throwIaxIfNull(fromFile, "fromFile");
+		LangUtil.throwIaxIfNull(toFile, "toFile");
+		LangUtil.throwIaxIfFalse(!toFile.equals(fromFile), "same file");
+		if (toFile.isDirectory()) { // existing directory
+			throwIaxUnlessCanWriteDir(toFile, "toFile");
+			if (fromFile.isFile()) { // file-dir
+				File targFile = new File(toFile, fromFile.getName());
+				copyValidFiles(fromFile, targFile);
+			} else if (fromFile.isDirectory()) { // dir-dir
+				copyDir(fromFile, toFile);
+			} else {
+				LangUtil.throwIaxIfFalse(false, "not dir or file: " + fromFile);
+			}
+		} else if (toFile.isFile()) { // target file exists
+			if (fromFile.isDirectory()) {
+				LangUtil.throwIaxIfFalse(false, "can't copy to file dir: " + fromFile);
+			}
+			copyValidFiles(fromFile, toFile); // file-file
+		} else { // target file is a non-existent path -- could be file or dir
+			/* File toFileParent = */ensureParentWritable(toFile);
+			if (fromFile.isFile()) {
+				copyValidFiles(fromFile, toFile);
+			} else if (fromFile.isDirectory()) {
+				toFile.mkdirs();
+				throwIaxUnlessCanWriteDir(toFile, "toFile");
+				copyDir(fromFile, toFile);
+			} else {
+				LangUtil.throwIaxIfFalse(false, "not dir or file: " + fromFile);
+			}
+		}
+	}
+
+	/**
+	 * Ensure that the parent directory to path can be written. If the path has a null parent, DEFAULT_PARENT is tested. If the path
+	 * parent does not exist, this tries to create it.
+	 * 
+	 * @param path the File path whose parent should be writable
+	 * @return the File path of the writable parent directory
+	 * @throws IllegalArgumentException if parent cannot be written or path is null.
+	 */
+	public static File ensureParentWritable(File path) {
+		LangUtil.throwIaxIfNull(path, "path");
+		File pathParent = path.getParentFile();
+		if (null == pathParent) {
+			pathParent = DEFAULT_PARENT;
+		}
+		if (!pathParent.canWrite()) {
+			pathParent.mkdirs();
+		}
+		throwIaxUnlessCanWriteDir(pathParent, "pathParent");
+		return pathParent;
+	}
+
+	/**
+	 * Copy file to file.
+	 * 
+	 * @param fromFile the File to copy (readable, non-null file)
+	 * @param toFile the File to copy to (non-null, parent dir exists)
+	 * @throws IOException
+	 */
+	public static void copyValidFiles(File fromFile, File toFile) throws IOException {
+		FileInputStream in = null;
+		FileOutputStream out = null;
+		try {
+			in = new FileInputStream(fromFile);
+			out = new FileOutputStream(toFile);
+			copyStream(in, out);
+		} finally {
+			if (out != null) {
+				out.close();
+			}
+			if (in != null) {
+				in.close();
+			}
+		}
+	}
+
+	/** do line-based copying */
+	public static void copyStream(DataInputStream in, PrintStream out) throws IOException {
+		LangUtil.throwIaxIfNull(in, "in");
+		LangUtil.throwIaxIfNull(in, "out");
+		String s;
+		while (null != (s = in.readLine())) {
+			out.println(s);
+		}
+	}
+
+	public static void copyStream(InputStream in, OutputStream out) throws IOException {
+		final int MAX = 4096;
+		byte[] buf = new byte[MAX];
+		for (int bytesRead = in.read(buf, 0, MAX); bytesRead != -1; bytesRead = in.read(buf, 0, MAX)) {
+			out.write(buf, 0, bytesRead);
+		}
+	}
+
+	public static void copyStream(Reader in, Writer out) throws IOException {
+		final int MAX = 4096;
+		char[] buf = new char[MAX];
+		for (int bytesRead = in.read(buf, 0, MAX); bytesRead != -1; bytesRead = in.read(buf, 0, MAX)) {
+			out.write(buf, 0, bytesRead);
+		}
+	}
+
+	/**
+	 * Make a new child directory of parent
+	 * 
+	 * @param parent a File for the parent (writable)
+	 * @param child a prefix for the child directory
+	 * @return a File dir that exists with parentDir as the parent file or null
+	 */
+	public static File makeNewChildDir(File parent, String child) {
+		if (null == parent || !parent.canWrite() || !parent.isDirectory()) {
+			throw new IllegalArgumentException("bad parent: " + parent);
+		} else if (null == child) {
+			child = "makeNewChildDir";
+		} else if (!isValidFileName(child)) {
+			throw new IllegalArgumentException("bad child: " + child);
+		}
+		File result = new File(parent, child);
+		int safety = 1000;
+		for (String suffix = FileUtil.randomFileString(); ((0 < --safety) && result.exists()); suffix = FileUtil.randomFileString()) {
+			result = new File(parent, child + suffix);
+		}
+		if (result.exists()) {
+			System.err.println("exhausted files for child dir in " + parent);
+			return null;
+		}
+		return ((result.mkdirs() && result.exists()) ? result : null);
+	}
+
+	/**
+	 * Make a new temporary directory in the same directory that the system uses for temporary files, or if that files, in the
+	 * current directory.
+	 * 
+	 * @param name the preferred (simple) name of the directory - may be null.
+	 * @return File of an existing new temp dir, or null if unable to create
+	 */
+	public static File getTempDir(String name) {
+		if (null == name) {
+			name = "FileUtil_getTempDir";
+		} else if (!isValidFileName(name)) {
+			throw new IllegalArgumentException(" invalid: " + name);
+		}
+		File result = null;
+		File tempFile = null;
+		try {
+			tempFile = File.createTempFile("ignoreMe", ".txt");
+			File tempParent = tempFile.getParentFile();
+			result = makeNewChildDir(tempParent, name);
+		} catch (IOException t) {
+			result = makeNewChildDir(new File("."), name);
+		} finally {
+			if (null != tempFile) {
+				tempFile.delete();
+			}
+		}
+		return result;
+	}
+
+	public static URL[] getFileURLs(File[] files) {
+		if ((null == files) || (0 == files.length)) {
+			return new URL[0];
+		}
+		URL[] result = new URL[files.length]; // XXX dangerous non-copy...
+		for (int i = 0; i < result.length; i++) {
 			result[i] = getFileURL(files[i]);
 		}
-        return result;
-    }
-	
-    /**
-     * Get URL for a File. 
-     * This appends "/" for directories.
-     * prints errors to System.err 
-     * @param file the File to convert to URL (not null)
-     */
-    public static URL getFileURL(File file) { 
+		return result;
+	}
+
+	/**
+	 * Get URL for a File. This appends "/" for directories. prints errors to System.err
+	 * 
+	 * @param file the File to convert to URL (not null)
+	 */
+	public static URL getFileURL(File file) {
 		LangUtil.throwIaxIfNull(file, "file");
-        URL result = null;
-        try {
-            result = file.toURL();//TODO AV - was toURI.toURL that does not works on Java 1.3 
-            if (null != result) {
-                return result;
-            }
-            String url =  "file:" + file.getAbsolutePath().replace('\\', '/');
-            result = new URL(url + (file.isDirectory() ? "/" : ""));
-        } catch (MalformedURLException e) {
-            String m = "Util.makeURL(\"" + file.getPath() + "\" MUE " + e.getMessage();
-            System.err.println(m);
-        }
+		URL result = null;
+		try {
+			result = file.toURL();// TODO AV - was toURI.toURL that does not works on Java 1.3
+			if (null != result) {
+				return result;
+			}
+			String url = "file:" + file.getAbsolutePath().replace('\\', '/');
+			result = new URL(url + (file.isDirectory() ? "/" : ""));
+		} catch (MalformedURLException e) {
+			String m = "Util.makeURL(\"" + file.getPath() + "\" MUE " + e.getMessage();
+			System.err.println(m);
+		}
 		return result;
 	}
-	
-	
-    
-    /**
-     * Write contents to file, returning null on success or error message otherwise.
-     * This tries to make any necessary parent directories first.
-     * @param file the File to write (not null)
-     * @param contents the String to write (use "" if null)
-     * @return String null on no error, error otherwise 
-     */
-    public static String writeAsString(File file, String contents) {
-        LangUtil.throwIaxIfNull(file, "file");
-        if (null == contents) {
-            contents = "";
-        }
-        Writer out = null;
-        try {
-            File parentDir = file.getParentFile();
-            if (!parentDir.exists() && !parentDir.mkdirs()) {
-                return "unable to make parent dir for " + file;
-            }
-            Reader in = new StringReader(contents);
-            out = new FileWriter(file);
-            FileUtil.copyStream(in, out);
-            return null;
-        } catch (IOException e) {
-            return LangUtil.unqualifiedClassName(e) + " writing " + file 
-                + ": " + e.getMessage();
-        } finally {
-            if (null != out) {
-                try { out.close(); }
-                catch (IOException e) {} // ignored
-            }
-        }        
-    }
 
+	/**
+	 * Write contents to file, returning null on success or error message otherwise. This tries to make any necessary parent
+	 * directories first.
+	 * 
+	 * @param file the File to write (not null)
+	 * @param contents the String to write (use "" if null)
+	 * @return String null on no error, error otherwise
+	 */
+	public static String writeAsString(File file, String contents) {
+		LangUtil.throwIaxIfNull(file, "file");
+		if (null == contents) {
+			contents = "";
+		}
+		Writer out = null;
+		try {
+			File parentDir = file.getParentFile();
+			if (!parentDir.exists() && !parentDir.mkdirs()) {
+				return "unable to make parent dir for " + file;
+			}
+			Reader in = new StringReader(contents);
+			out = new FileWriter(file);
+			FileUtil.copyStream(in, out);
+			return null;
+		} catch (IOException e) {
+			return LangUtil.unqualifiedClassName(e) + " writing " + file + ": " + e.getMessage();
+		} finally {
+			if (null != out) {
+				try {
+					out.close();
+				} catch (IOException e) {
+				} // ignored
+			}
+		}
+	}
 
 	/**
 	 * Reads a boolean array with our encoding
@@ -994,54 +992,53 @@ public class FileUtil {
 	public static boolean[] readBooleanArray(DataInputStream s) throws IOException {
 		int len = s.readInt();
 		boolean[] ret = new boolean[len];
-		for (int i=0; i < len; i++) ret[i] = s.readBoolean();
+		for (int i = 0; i < len; i++)
+			ret[i] = s.readBoolean();
 		return ret;
 	}
 
-
 	/**
 	 * Writes a boolean array with our encoding
 	 */
 	public static void writeBooleanArray(boolean[] a, DataOutputStream s) throws IOException {
 		int len = a.length;
 		s.writeInt(len);
-		for (int i=0; i < len; i++) s.writeBoolean(a[i]);
+		for (int i = 0; i < len; i++)
+			s.writeBoolean(a[i]);
 	}
 
-
 	/**
 	 * Reads an int array with our encoding
 	 */
 	public static int[] readIntArray(DataInputStream s) throws IOException {
 		int len = s.readInt();
 		int[] ret = new int[len];
-		for (int i=0; i < len; i++) ret[i] = s.readInt();
+		for (int i = 0; i < len; i++)
+			ret[i] = s.readInt();
 		return ret;
 	}
 
-
 	/**
 	 * Writes an int array with our encoding
 	 */
 	public static void writeIntArray(int[] a, DataOutputStream s) throws IOException {
 		int len = a.length;
 		s.writeInt(len);
-		for (int i=0; i < len; i++) s.writeInt(a[i]);
+		for (int i = 0; i < len; i++)
+			s.writeInt(a[i]);
 	}
 
-
-
 	/**
 	 * Reads an int array with our encoding
 	 */
 	public static String[] readStringArray(DataInputStream s) throws IOException {
 		int len = s.readInt();
 		String[] ret = new String[len];
-		for (int i=0; i < len; i++) ret[i] = s.readUTF();
+		for (int i = 0; i < len; i++)
+			ret[i] = s.readUTF();
 		return ret;
 	}
 
-
 	/**
 	 * Writes an int array with our encoding
 	 */
@@ -1052,10 +1049,10 @@ public class FileUtil {
 		}
 		int len = a.length;
 		s.writeInt(len);
-		for (int i=0; i < len; i++) s.writeUTF(a[i]);
+		for (int i = 0; i < len; i++)
+			s.writeUTF(a[i]);
 	}
 
-
 	/**
 	 * Returns the contents of this file as a String
 	 */
@@ -1064,13 +1061,14 @@ public class FileUtil {
 		StringBuffer b = new StringBuffer();
 		while (true) {
 			int ch = r.read();
-			if (ch == -1) break;
-			b.append((char)ch);
+			if (ch == -1)
+				break;
+			b.append((char) ch);
 		}
 		r.close();
 		return b.toString();
 	}
-	
+
 	/**
 	 * Returns the contents of this stream as a String
 	 */
@@ -1079,14 +1077,14 @@ public class FileUtil {
 		StringBuffer b = new StringBuffer();
 		while (true) {
 			int ch = r.read();
-			if (ch == -1) break;
-			b.append((char)ch);
+			if (ch == -1)
+				break;
+			b.append((char) ch);
 		}
 		in.close();
 		r.close();
 		return b.toString();
 	}
-	
 
 	/**
 	 * Returns the contents of this file as a byte[]
@@ -1098,7 +1096,6 @@ public class FileUtil {
 		return ret;
 	}
 
-
 	/**
 	 * Reads this input stream and returns contents as a byte[]
 	 */
@@ -1106,10 +1103,11 @@ public class FileUtil {
 		int size = 1024;
 		byte[] ba = new byte[size];
 		int readSoFar = 0;
-		
+
 		while (true) {
-			int nRead = inStream.read(ba, readSoFar, size-readSoFar);
-			if (nRead == -1) break;
+			int nRead = inStream.read(ba, readSoFar, size - readSoFar);
+			if (nRead == -1)
+				break;
 			readSoFar += nRead;
 			if (readSoFar == size) {
 				int newSize = size * 2;
@@ -1119,54 +1117,55 @@ public class FileUtil {
 				size = newSize;
 			}
 		}
-		
+
 		byte[] newBa = new byte[readSoFar];
 		System.arraycopy(ba, 0, newBa, 0, readSoFar);
 		return newBa;
 	}
 
-    final static String FILECHARS = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
-    /** @return semi-random String of length 6 usable as filename suffix */
-    static String randomFileString() {
-        final double FILECHARS_length = FILECHARS.length();
-        final int LEN = 6;
-        final char[] result = new char[LEN];
-        int index = (int) (Math.random() * 6d);
-        for (int i = 0; i < LEN; i++) {
-            if (index >= LEN) {
-                index = 0;
-            }
-            result[index++] = FILECHARS.charAt((int) (Math.random() * FILECHARS_length));		
+	final static String FILECHARS = "abcdefghijklmnopqrstuvxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+
+	/** @return semi-random String of length 6 usable as filename suffix */
+	static String randomFileString() {
+		final double FILECHARS_length = FILECHARS.length();
+		final int LEN = 6;
+		final char[] result = new char[LEN];
+		int index = (int) (Math.random() * 6d);
+		for (int i = 0; i < LEN; i++) {
+			if (index >= LEN) {
+				index = 0;
+			}
+			result[index++] = FILECHARS.charAt((int) (Math.random() * FILECHARS_length));
 		}
-        return new String(result);     
-    }
+		return new String(result);
+	}
 
 	public static InputStream getStreamFromZip(String zipFile, String name) {
 		try {
 			ZipFile zf = new ZipFile(zipFile);
 			try {
-	    		ZipEntry entry = zf.getEntry(name);
-	    		return zf.getInputStream(entry);
+				ZipEntry entry = zf.getEntry(name);
+				return zf.getInputStream(entry);
 			} finally {
-				//??? is it safe not to close this zf.close();
+				// ??? is it safe not to close this zf.close();
 			}
 		} catch (IOException ioe) {
 			return null;
 		}
 	}
-	
 
 	public static void extractJar(String zipFile, String outDir) throws IOException {
 		ZipInputStream zs = new ZipInputStream(new FileInputStream(zipFile));
 		ZipEntry entry;
-		while ( (entry = zs.getNextEntry()) != null) {
-			if (entry.isDirectory()) continue;
+		while ((entry = zs.getNextEntry()) != null) {
+			if (entry.isDirectory())
+				continue;
 			byte[] in = readAsByteArray(zs);
-			
+
 			File outFile = new File(outDir + "/" + entry.getName());
-			//if (!outFile.getParentFile().exists()) 
-			//System.err.println("parent: " + outFile.getParentFile());
-			//System.err.println("parent: " + outFile.getParentFile());
+			// if (!outFile.getParentFile().exists())
+			// System.err.println("parent: " + outFile.getParentFile());
+			// System.err.println("parent: " + outFile.getParentFile());
 			outFile.getParentFile().mkdirs();
 			FileOutputStream os = new FileOutputStream(outFile);
 			os.write(in);
@@ -1177,157 +1176,157 @@ public class FileUtil {
 	}
 
 	/**
-	 * Do line-based search  for literal text in source files, 
-     * returning file:line where found.
+	 * Do line-based search for literal text in source files, returning file:line where found.
+	 * 
 	 * @param sought the String text to seek in the file
 	 * @param sources the List of String paths to the source files
-     * @param listAll if false, only list first match in file
-     * @param errorSink the PrintStream to print any errors to (one per line)
-     *         (use null to silently ignore errors)
-	 * @return List of String of the form file:line for each found entry
-     *          (never null, might be empty)
+	 * @param listAll if false, only list first match in file
+	 * @param errorSink the PrintStream to print any errors to (one per line) (use null to silently ignore errors)
+	 * @return List of String of the form file:line for each found entry (never null, might be empty)
 	 */
 	// OPTIMIZE only used by tests? move it out
-	public static List lineSeek(String sought, List sources, boolean listAll,
-        PrintStream errorSink) {
-        if (LangUtil.isEmpty(sought) || LangUtil.isEmpty(sources)) {
-            return Collections.EMPTY_LIST;
-        }
-        ArrayList result = new ArrayList();
-        for (Iterator iter = sources.iterator(); iter.hasNext();) {
+	public static List lineSeek(String sought, List sources, boolean listAll, PrintStream errorSink) {
+		if (LangUtil.isEmpty(sought) || LangUtil.isEmpty(sources)) {
+			return Collections.EMPTY_LIST;
+		}
+		ArrayList result = new ArrayList();
+		for (Iterator iter = sources.iterator(); iter.hasNext();) {
 			String path = (String) iter.next();
-            String error = lineSeek(sought, path, listAll, result);
-            if ((null != error) && (null != errorSink)) {
-                errorSink.println(error);
-            }
-		}
-        return result;
-	}
-    
-    /**
-     * Do line-based search  for literal text in source file, 
-     * returning line where found as a String 
-     * in the form {sourcePath}:line:column submitted to the
-     * collecting parameter sink.
-     * Any error is rendered to String and returned as the result.
-     * 
-     * @param sought the String text to seek in the file
-     * @param sources the List of String paths to the source files
-     * @param listAll if false, only list first match in file
-     * @param List sink the List for String entries of the form {sourcePath}:line:column
-     * @return String error if any, or add String entries to sink
-     */
-    public static String lineSeek(String sought, String sourcePath, boolean listAll,
-        ArrayList sink) {
-        if (LangUtil.isEmpty(sought) || LangUtil.isEmpty(sourcePath)) {
-            return "nothing sought";
-        }
-        if (LangUtil.isEmpty(sourcePath)) {
-            return "no sourcePath";
-        }
-        final File file = new File(sourcePath);
-        if (!file.canRead() || !file.isFile()) {
-            return "sourcePath not a readable file";
-        }
-        int lineNum = 0;
-        FileReader fin = null;
-        try {
-            fin = new FileReader(file);
-            BufferedReader reader = new BufferedReader(fin);
-            String line;
-            while (null != (line = reader.readLine())) {
-                lineNum++;
-                int loc = line.indexOf(sought);
-                if (-1 != loc) {
-                    sink.add(sourcePath + ":" + lineNum + ":" + loc);
-                    if (!listAll) {
-                        break;
-                    }
-                }
-            }
-        } catch (IOException e) {
-            return LangUtil.unqualifiedClassName(e) + " reading " + sourcePath 
-                + ":" + lineNum;
-        } finally {
-            try { if (null != fin) fin.close(); }
-            catch (IOException e) {} // ignore
-        }
-        return null;
-    }
+			String error = lineSeek(sought, path, listAll, result);
+			if ((null != error) && (null != errorSink)) {
+				errorSink.println(error);
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Do line-based search for literal text in source file, returning line where found as a String in the form
+	 * {sourcePath}:line:column submitted to the collecting parameter sink. Any error is rendered to String and returned as the
+	 * result.
+	 * 
+	 * @param sought the String text to seek in the file
+	 * @param sources the List of String paths to the source files
+	 * @param listAll if false, only list first match in file
+	 * @param List sink the List for String entries of the form {sourcePath}:line:column
+	 * @return String error if any, or add String entries to sink
+	 */
+	public static String lineSeek(String sought, String sourcePath, boolean listAll, ArrayList sink) {
+		if (LangUtil.isEmpty(sought) || LangUtil.isEmpty(sourcePath)) {
+			return "nothing sought";
+		}
+		if (LangUtil.isEmpty(sourcePath)) {
+			return "no sourcePath";
+		}
+		final File file = new File(sourcePath);
+		if (!file.canRead() || !file.isFile()) {
+			return "sourcePath not a readable file";
+		}
+		int lineNum = 0;
+		FileReader fin = null;
+		try {
+			fin = new FileReader(file);
+			BufferedReader reader = new BufferedReader(fin);
+			String line;
+			while (null != (line = reader.readLine())) {
+				lineNum++;
+				int loc = line.indexOf(sought);
+				if (-1 != loc) {
+					sink.add(sourcePath + ":" + lineNum + ":" + loc);
+					if (!listAll) {
+						break;
+					}
+				}
+			}
+		} catch (IOException e) {
+			return LangUtil.unqualifiedClassName(e) + " reading " + sourcePath + ":" + lineNum;
+		} finally {
+			try {
+				if (null != fin)
+					fin.close();
+			} catch (IOException e) {
+			} // ignore
+		}
+		return null;
+	}
 
 	public static BufferedOutputStream makeOutputStream(File file) throws FileNotFoundException {
 		File parent = file.getParentFile();
-		if (parent != null) parent.mkdirs();
+		if (parent != null)
+			parent.mkdirs();
 		return new BufferedOutputStream(new FileOutputStream(file));
 	}
 
-    /**
-     * Sleep until after the last last-modified stamp from the files.
-     * @param files the File[] of files to inspect for last modified times
-     *        (this ignores null or empty files array
-     *         and null or non-existing components of files array)
-     * @return true if succeeded without 100 interrupts
-     */
-    public static boolean sleepPastFinalModifiedTime(File[] files) {
-        if ((null == files) || (0 == files.length)) {
-            return true;
-        }
-        long delayUntil = System.currentTimeMillis();
-        for (int i = 0; i < files.length; i++) {
-            File file = files[i];
-            if ((null == file) || !file.exists()) {
-                continue;
-            }
-            long nextModTime = file.lastModified();
-            if (nextModTime > delayUntil) {
-                delayUntil = nextModTime;
-            }
-        }
-        return LangUtil.sleepUntil(++delayUntil);
-    }
-
-    private static void listFiles(final File baseDir, ArrayList result, FileFilter filter)  {
-        File[] files = baseDir.listFiles();
-        // hack https://bugs.eclipse.org/bugs/show_bug.cgi?id=48650
-        final boolean skipCVS = (! PERMIT_CVS && (filter == aspectjSourceFileFilter));
-        for (int i = 0; i < files.length; i++) {
-            File f = files[i];
-            if (f.isDirectory()) {
-                if (skipCVS) {
-                    String name = f.getName().toLowerCase();
-                    if ("cvs".equals(name) || "sccs".equals(name)) {
-                        continue;
-                    }
-                }
-                listFiles(f, result, filter);
-            } else {
-                if (filter.accept(f)) result.add(f);
-            }
-        }
-    }
-
-    /** @return true if input is not null and contains no path separator */
-    private static boolean isValidFileName(String input) {
-        return ((null != input) && (-1 == input.indexOf(File.pathSeparator)));
-    }
-
-    private static void listFiles(final File baseDir, String dir, ArrayList result)  {
-        final String dirPrefix = (null == dir ? "" : dir + "/");
-        final File dirFile = (null == dir ? baseDir : new File(baseDir.getPath() + "/" + dir));
-        final String[] files = dirFile.list();
-        for (int i = 0; i < files.length; i++) {
-            File f = new File(dirFile, files[i]);
-            String path = dirPrefix + files[i];
-            if (f.isDirectory()) {
-                listFiles(baseDir, path, result);
-            } else {
-                result.add(path);
-            }
-        }
-    }
-
-    private FileUtil() { throw new Error("utility class"); }
-	
+	/**
+	 * Sleep until after the last last-modified stamp from the files.
+	 * 
+	 * @param files the File[] of files to inspect for last modified times (this ignores null or empty files array and null or
+	 *        non-existing components of files array)
+	 * @return true if succeeded without 100 interrupts
+	 */
+	public static boolean sleepPastFinalModifiedTime(File[] files) {
+		if ((null == files) || (0 == files.length)) {
+			return true;
+		}
+		long delayUntil = System.currentTimeMillis();
+		for (int i = 0; i < files.length; i++) {
+			File file = files[i];
+			if ((null == file) || !file.exists()) {
+				continue;
+			}
+			long nextModTime = file.lastModified();
+			if (nextModTime > delayUntil) {
+				delayUntil = nextModTime;
+			}
+		}
+		return LangUtil.sleepUntil(++delayUntil);
+	}
+
+	private static void listFiles(final File baseDir, ArrayList result, FileFilter filter) {
+		File[] files = baseDir.listFiles();
+		// hack https://bugs.eclipse.org/bugs/show_bug.cgi?id=48650
+		final boolean skipCVS = (!PERMIT_CVS && (filter == aspectjSourceFileFilter));
+		for (int i = 0; i < files.length; i++) {
+			File f = files[i];
+			if (f.isDirectory()) {
+				if (skipCVS) {
+					String name = f.getName().toLowerCase();
+					if ("cvs".equals(name) || "sccs".equals(name)) {
+						continue;
+					}
+				}
+				listFiles(f, result, filter);
+			} else {
+				if (filter.accept(f))
+					result.add(f);
+			}
+		}
+	}
+
+	/** @return true if input is not null and contains no path separator */
+	private static boolean isValidFileName(String input) {
+		return ((null != input) && (-1 == input.indexOf(File.pathSeparator)));
+	}
+
+	private static void listFiles(final File baseDir, String dir, ArrayList result) {
+		final String dirPrefix = (null == dir ? "" : dir + "/");
+		final File dirFile = (null == dir ? baseDir : new File(baseDir.getPath() + "/" + dir));
+		final String[] files = dirFile.list();
+		for (int i = 0; i < files.length; i++) {
+			File f = new File(dirFile, files[i]);
+			String path = dirPrefix + files[i];
+			if (f.isDirectory()) {
+				listFiles(baseDir, path, result);
+			} else {
+				result.add(path);
+			}
+		}
+	}
+
+	private FileUtil() {
+		throw new Error("utility class");
+	}
+
 	public static List makeClasspath(URL[] urls) {
 		List ret = new LinkedList();
 		if (urls != null) {
@@ -1338,175 +1337,162 @@ public class FileUtil {
 		return ret;
 	}
 
-    /**
-     * A pipe when run reads from an input stream to an output stream,
-     * optionally sleeping between reads.
-     * @see #copyStream(InputStream, OutputStream)
-     */
-    public static class Pipe implements Runnable {
-        private final InputStream in;
-        private final OutputStream out;        
-        private final long sleep;
-        private ByteArrayOutputStream snoop;
-        private long totalWritten;
-        private Throwable thrown;
-        private boolean halt;
-        /** 
-         * Seem to be unable to detect erroroneous closing of System.out...
-         */
-        private final boolean closeInput;
-        private final boolean closeOutput;
-
-        /** 
-         * If true, then continue processing stream until
-         *  no characters are returned when halting.
-         */
-        private boolean finishStream;
-        
-        private boolean done; // true after completing() completes
-
-        /** 
-         * alias for <code>Pipe(in, out, 100l, false, false)</code>
-         * @param in the InputStream source to read
-         * @param out the OutputStream sink to write
-         */
-        Pipe(
-            InputStream in, 
-            OutputStream out) {
-            this(in, out, 100l, false, false);
-        }
-        
-        /** 
-         * @param in the InputStream source to read
-         * @param out the OutputStream sink to write
-         * @param tryClosingStreams if true, then try closing both streams when done
-         * @param sleep milliseconds to delay between reads (pinned to 0..1 minute)
-         */
-        Pipe(
-            InputStream in, 
-            OutputStream out, 
-            long sleep, 
-            boolean closeInput, 
-            boolean closeOutput) {
-            LangUtil.throwIaxIfNull(in, "in");
-            LangUtil.throwIaxIfNull(out, "out");
-            this.in = in;
-            this.out = out;
-            this.closeInput = closeInput;
-            this.closeOutput = closeOutput;
-            this.sleep = Math.min(0l, Math.max(60l*1000l, sleep));
-        }
-
-        public void setSnoop(ByteArrayOutputStream snoop) {
-            this.snoop = snoop;
-        }
-
-        /**
-         * Run the pipe.
-         * This halts on the first Throwable thrown or when a read returns
-         * -1 (for end-of-file) or on demand.
-         */
-        public void run() {
-            totalWritten = 0;
-            if (halt) {
-                return;
-            }
-            try {
-                final int MAX = 4096;
-                byte[] buf = new byte[MAX];
-                // TODO this blocks, hanging the harness
-                int count = in.read(buf, 0, MAX);
-                ByteArrayOutputStream mySnoop;
-                while ((halt && finishStream && (0 < count))
-                    || (!halt && (-1 != count))) {
-                    out.write(buf, 0, count);
-                    mySnoop = snoop;
-                    if (null != mySnoop) {
-                        mySnoop.write(buf, 0, count);
-                    }
-                    totalWritten += count;
-                    if (halt && !finishStream) { 
-                        break; 
-                    }
-                    if (!halt && (0 < sleep)) {
-                        Thread.sleep(sleep);
-                    }
-                    if (halt && !finishStream) { 
-                        break; 
-                    }
-                    count = in.read(buf, 0, MAX);
-                }
-            } catch (Throwable e) {
-                thrown = e;
-            } finally {
-                halt = true;
-                if (closeInput) {
-                    try {
-                        in.close();
-                    } catch (IOException e) {
-                        // ignore
-                    }
-                }
-                if (closeOutput) {
-                    try {
-                        out.close();
-                    } catch (IOException e) {
-                        // ignore
-                    }
-                }
-                done = true;
-                completing(totalWritten, thrown);
-            }
-            
-        }    
-
-        /**
-         * Tell the pipe to halt the next time it gains control.
-         * @param wait if true, this waits synchronously until pipe is done
-         * @param finishStream if true, then continue until 
-         *        a read from the input stream returns no bytes, then halt.
-         * @return true if <code>run()</code> will return the next time it gains control
-         */
-        public boolean halt(boolean wait, boolean finishStream) {
-            if (!halt) {
-                halt = true;
-            }
-            if (wait) {
-                while (!done) {
-                    synchronized (this) {
-                        notifyAll();
-                    }
-                    if (!done) {
-                        try {
-                            Thread.sleep(5l);
-                        } catch (InterruptedException e) {
-                            break;
-                        }
-                    }
-                }
-            }
-            return halt;
-        }
-
-        /** @return the total number of bytes written */
-        public long totalWritten() {
-            return totalWritten;
-        }
-
-        /** @return any exception thrown when reading/writing */
-        public Throwable getThrown() {
-            return thrown;
-        }
-        
-        /**
-         * This is called when the pipe is completing.
-         * This implementation does nothing.
-         * Subclasses implement this to get notice.
-         * Note that halt(true, true) might or might not have completed
-         * before this method is called.
-         */
-        protected void completing(long totalWritten, Throwable thrown) {
-        }
-    }
+	/**
+	 * A pipe when run reads from an input stream to an output stream, optionally sleeping between reads.
+	 * 
+	 * @see #copyStream(InputStream, OutputStream)
+	 */
+	public static class Pipe implements Runnable {
+		private final InputStream in;
+		private final OutputStream out;
+		private final long sleep;
+		private ByteArrayOutputStream snoop;
+		private long totalWritten;
+		private Throwable thrown;
+		private boolean halt;
+		/**
+		 * Seem to be unable to detect erroroneous closing of System.out...
+		 */
+		private final boolean closeInput;
+		private final boolean closeOutput;
+
+		/**
+		 * If true, then continue processing stream until no characters are returned when halting.
+		 */
+		private boolean finishStream;
+
+		private boolean done; // true after completing() completes
+
+		/**
+		 * alias for <code>Pipe(in, out, 100l, false, false)</code>
+		 * 
+		 * @param in the InputStream source to read
+		 * @param out the OutputStream sink to write
+		 */
+		Pipe(InputStream in, OutputStream out) {
+			this(in, out, 100l, false, false);
+		}
+
+		/**
+		 * @param in the InputStream source to read
+		 * @param out the OutputStream sink to write
+		 * @param tryClosingStreams if true, then try closing both streams when done
+		 * @param sleep milliseconds to delay between reads (pinned to 0..1 minute)
+		 */
+		Pipe(InputStream in, OutputStream out, long sleep, boolean closeInput, boolean closeOutput) {
+			LangUtil.throwIaxIfNull(in, "in");
+			LangUtil.throwIaxIfNull(out, "out");
+			this.in = in;
+			this.out = out;
+			this.closeInput = closeInput;
+			this.closeOutput = closeOutput;
+			this.sleep = Math.min(0l, Math.max(60l * 1000l, sleep));
+		}
+
+		public void setSnoop(ByteArrayOutputStream snoop) {
+			this.snoop = snoop;
+		}
+
+		/**
+		 * Run the pipe. This halts on the first Throwable thrown or when a read returns -1 (for end-of-file) or on demand.
+		 */
+		public void run() {
+			totalWritten = 0;
+			if (halt) {
+				return;
+			}
+			try {
+				final int MAX = 4096;
+				byte[] buf = new byte[MAX];
+				// TODO this blocks, hanging the harness
+				int count = in.read(buf, 0, MAX);
+				ByteArrayOutputStream mySnoop;
+				while ((halt && finishStream && (0 < count)) || (!halt && (-1 != count))) {
+					out.write(buf, 0, count);
+					mySnoop = snoop;
+					if (null != mySnoop) {
+						mySnoop.write(buf, 0, count);
+					}
+					totalWritten += count;
+					if (halt && !finishStream) {
+						break;
+					}
+					if (!halt && (0 < sleep)) {
+						Thread.sleep(sleep);
+					}
+					if (halt && !finishStream) {
+						break;
+					}
+					count = in.read(buf, 0, MAX);
+				}
+			} catch (Throwable e) {
+				thrown = e;
+			} finally {
+				halt = true;
+				if (closeInput) {
+					try {
+						in.close();
+					} catch (IOException e) {
+						// ignore
+					}
+				}
+				if (closeOutput) {
+					try {
+						out.close();
+					} catch (IOException e) {
+						// ignore
+					}
+				}
+				done = true;
+				completing(totalWritten, thrown);
+			}
+
+		}
+
+		/**
+		 * Tell the pipe to halt the next time it gains control.
+		 * 
+		 * @param wait if true, this waits synchronously until pipe is done
+		 * @param finishStream if true, then continue until a read from the input stream returns no bytes, then halt.
+		 * @return true if <code>run()</code> will return the next time it gains control
+		 */
+		public boolean halt(boolean wait, boolean finishStream) {
+			if (!halt) {
+				halt = true;
+			}
+			if (wait) {
+				while (!done) {
+					synchronized (this) {
+						notifyAll();
+					}
+					if (!done) {
+						try {
+							Thread.sleep(5l);
+						} catch (InterruptedException e) {
+							break;
+						}
+					}
+				}
+			}
+			return halt;
+		}
+
+		/** @return the total number of bytes written */
+		public long totalWritten() {
+			return totalWritten;
+		}
+
+		/** @return any exception thrown when reading/writing */
+		public Throwable getThrown() {
+			return thrown;
+		}
+
+		/**
+		 * This is called when the pipe is completing. This implementation does nothing. Subclasses implement this to get notice.
+		 * Note that halt(true, true) might or might not have completed before this method is called.
+		 */
+		protected void completing(long totalWritten, Throwable thrown) {
+		}
+	}
 
 }
diff --git a/util/src/org/aspectj/util/LangUtil.java b/util/src/org/aspectj/util/LangUtil.java
index 4bcac4198..c17ceaa40 100644
--- a/util/src/org/aspectj/util/LangUtil.java
+++ b/util/src/org/aspectj/util/LangUtil.java
@@ -26,7 +26,6 @@ import java.util.Arrays;
 import java.util.BitSet;
 import java.util.Collection;
 import java.util.Collections;
-import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.StringTokenizer;
@@ -34,270 +33,282 @@ import java.util.StringTokenizer;
 /**
  * 
  */
-public class LangUtil {    
-
-//	/** map from String version to String class implemented in that version or later */
-//    private static final Map VM_CLASSES;
-
-    public static final String EOL;
-    static {
-        StringWriter buf = new StringWriter();
-        PrintWriter writer = new PrintWriter(buf);
-        writer.println("");
-        String eol = "\n";
-        try { 
-            buf.close(); 
-            StringBuffer sb = buf.getBuffer(); 
-            if (sb!=null) {
-                eol = buf.toString();
-            }
-        } catch (Throwable t) { }
-        EOL = eol;
-        
-//        HashMap map = new HashMap();
-//        map.put("1.2", "java.lang.ref.Reference");
-//        map.put("1.3", "java.lang.reflect.Proxy");
-//        map.put("1.4", "java.nio.Buffer");
-//        map.put("1.5", "java.lang.annotation.Annotation");
-//        
-//        VM_CLASSES = Collections.unmodifiableMap(map);
-    }
-
-//    /**
-//     * Detect whether Java version is supported.
-//     * @param version String "1.2" or "1.3" or "1.4"
-//     * @return true if the currently-running VM supports the version 
-//     * @throws IllegalArgumentException if version is not known
-//     */
-//    public static final boolean supportsJava(String version) {
-//        LangUtil.throwIaxIfNull(version, "version");
-//        String className = (String) VM_CLASSES.get(version);
-//        if (null == className) {
-//            throw new IllegalArgumentException("unknown version: " + version);
-//        }
-//        try {
-//            Class.forName(className);
-//            return true;
-//        } catch (Throwable t) {
-//            return false;
-//        }        
-//    }
-	
+public class LangUtil {
+
+	// /** map from String version to String class implemented in that version or later */
+	// private static final Map VM_CLASSES;
+
+	public static final String EOL;
+	static {
+		StringWriter buf = new StringWriter();
+		PrintWriter writer = new PrintWriter(buf);
+		writer.println("");
+		String eol = "\n";
+		try {
+			buf.close();
+			StringBuffer sb = buf.getBuffer();
+			if (sb != null) {
+				eol = buf.toString();
+			}
+		} catch (Throwable t) {
+		}
+		EOL = eol;
+
+		// HashMap map = new HashMap();
+		// map.put("1.2", "java.lang.ref.Reference");
+		// map.put("1.3", "java.lang.reflect.Proxy");
+		// map.put("1.4", "java.nio.Buffer");
+		// map.put("1.5", "java.lang.annotation.Annotation");
+		//        
+		// VM_CLASSES = Collections.unmodifiableMap(map);
+	}
+
+	// /**
+	// * Detect whether Java version is supported.
+	// * @param version String "1.2" or "1.3" or "1.4"
+	// * @return true if the currently-running VM supports the version
+	// * @throws IllegalArgumentException if version is not known
+	// */
+	// public static final boolean supportsJava(String version) {
+	// LangUtil.throwIaxIfNull(version, "version");
+	// String className = (String) VM_CLASSES.get(version);
+	// if (null == className) {
+	// throw new IllegalArgumentException("unknown version: " + version);
+	// }
+	// try {
+	// Class.forName(className);
+	// return true;
+	// } catch (Throwable t) {
+	// return false;
+	// }
+	// }
+
 	private static boolean is13VMOrGreater = true;
 	private static boolean is14VMOrGreater = true;
 	private static boolean is15VMOrGreater = false;
 	private static boolean is16VMOrGreater = false;
-	
+
 	static {
-        String vm = System.getProperty("java.version"); // JLS 20.18.7
-        if (vm==null) vm = System.getProperty("java.runtime.version");
-		if (vm==null) vm = System.getProperty("java.vm.version");
+		String vm = System.getProperty("java.version"); // JLS 20.18.7
+		if (vm == null)
+			vm = System.getProperty("java.runtime.version");
+		if (vm == null)
+			vm = System.getProperty("java.vm.version");
 		if (vm.startsWith("1.3")) {
 			is14VMOrGreater = false;
-		} else if (vm.startsWith("1.5") || vm.startsWith("1.6")) {	
+		} else if (vm.startsWith("1.5") || vm.startsWith("1.6")) {
 			is15VMOrGreater = true;
 			is16VMOrGreater = true;
 		}
 	}
-	
-	public static boolean is13VMOrGreater() { return is13VMOrGreater;}
-	public static boolean is14VMOrGreater() { return is14VMOrGreater;}
-	public static boolean is15VMOrGreater() { return is15VMOrGreater;}
-	public static boolean is16VMOrGreater() { return is16VMOrGreater;}
-    
-    /**
-     * Shorthand for "if null, throw IllegalArgumentException"
-     * @throws IllegalArgumentException "null {name}" if o is null 
-     */
-    public static final void throwIaxIfNull(final Object o, final String name) {
-        if (null == o) {
-            String message = "null " + (null == name ? "input" : name);
-            throw new IllegalArgumentException(message);
-        }
-    }
-    
-    /**
-     * Shorthand for "if not null or not assignable, throw IllegalArgumentException"
-     * @param c the Class to check - use null to ignore type check
-     * @throws IllegalArgumentException "null {name}" if o is null 
-     */
-    public static final void throwIaxIfNotAssignable(final Object ra[], final Class c, final String name) {
-        throwIaxIfNull(ra, name);
-        String label = (null == name ? "input" : name);
-        for (int i = 0; i < ra.length; i++) {
-            if (null == ra[i]) {
-                String m = " null " + label + "[" + i + "]";
-                throw new IllegalArgumentException(m);
-            } else if (null != c) {
-                Class actualClass = ra[i].getClass();
-                if (!c.isAssignableFrom(actualClass)) {
-                    String message = label + " not assignable to " + c.getName();
-                    throw new IllegalArgumentException(message);           
-                }
-            }
-        }
-    }
-    /**
-     * Shorthand for "if not null or not assignable, throw IllegalArgumentException"
-     * @throws IllegalArgumentException "null {name}" if o is null 
-     */
-    public static final void throwIaxIfNotAssignable(final Object o, final Class c, final String name) {
-        throwIaxIfNull(o, name);
-        if (null != c) {
-            Class actualClass = o.getClass();
-            if (!c.isAssignableFrom(actualClass)) {
-                String message = name + " not assignable to " + c.getName();
-                throw new IllegalArgumentException(message);           
-            }
-        }
-    }
-    
-//    /**
-//     * Shorthand for "if any not null or not assignable, throw IllegalArgumentException"
-//     * @throws IllegalArgumentException "{name} is not assignable to {c}"  
-//     */
-//    public static final void throwIaxIfNotAllAssignable(final Collection collection, 
-//        final Class c, final String name) {
-//        throwIaxIfNull(collection, name);
-//        if (null != c) {
-//            for (Iterator iter = collection.iterator(); iter.hasNext();) {
-//				throwIaxIfNotAssignable(iter.next(), c, name);
-//				
-//			}
-//        }
-//    }
-    /**
-     * Shorthand for "if false, throw IllegalArgumentException"
-     * @throws IllegalArgumentException "{message}" if test is false
-     */
-    public static final void throwIaxIfFalse(final boolean test, final String message) {
-        if (!test) {
-            throw new IllegalArgumentException(message);
-        }
-    }
-    
-//    /** @return ((null == s) || (0 == s.trim().length())); */
-//    public static boolean isEmptyTrimmed(String s) {
-//        return ((null == s) || (0 == s.length())
-//            || (0 == s.trim().length()));
-//    }
-
-    /** @return ((null == s) || (0 == s.length())); */
-    public static boolean isEmpty(String s) {
-        return ((null == s) || (0 == s.length()));
-    }
-
-    /** @return ((null == ra) || (0 == ra.length)) */
-    public static boolean isEmpty(Object[] ra) {
-        return ((null == ra) || (0 == ra.length));
-    }
-
-    /** @return ((null == collection) || (0 == collection.size())) */
-    public static boolean isEmpty(Collection collection) {
-        return ((null == collection) || (0 == collection.size()));
-    }
-
-    /**
+
+	public static boolean is13VMOrGreater() {
+		return is13VMOrGreater;
+	}
+
+	public static boolean is14VMOrGreater() {
+		return is14VMOrGreater;
+	}
+
+	public static boolean is15VMOrGreater() {
+		return is15VMOrGreater;
+	}
+
+	public static boolean is16VMOrGreater() {
+		return is16VMOrGreater;
+	}
+
+	/**
+	 * Shorthand for "if null, throw IllegalArgumentException"
+	 * 
+	 * @throws IllegalArgumentException "null {name}" if o is null
+	 */
+	public static final void throwIaxIfNull(final Object o, final String name) {
+		if (null == o) {
+			String message = "null " + (null == name ? "input" : name);
+			throw new IllegalArgumentException(message);
+		}
+	}
+
+	/**
+	 * Shorthand for "if not null or not assignable, throw IllegalArgumentException"
+	 * 
+	 * @param c the Class to check - use null to ignore type check
+	 * @throws IllegalArgumentException "null {name}" if o is null
+	 */
+	public static final void throwIaxIfNotAssignable(final Object ra[], final Class c, final String name) {
+		throwIaxIfNull(ra, name);
+		String label = (null == name ? "input" : name);
+		for (int i = 0; i < ra.length; i++) {
+			if (null == ra[i]) {
+				String m = " null " + label + "[" + i + "]";
+				throw new IllegalArgumentException(m);
+			} else if (null != c) {
+				Class actualClass = ra[i].getClass();
+				if (!c.isAssignableFrom(actualClass)) {
+					String message = label + " not assignable to " + c.getName();
+					throw new IllegalArgumentException(message);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Shorthand for "if not null or not assignable, throw IllegalArgumentException"
+	 * 
+	 * @throws IllegalArgumentException "null {name}" if o is null
+	 */
+	public static final void throwIaxIfNotAssignable(final Object o, final Class c, final String name) {
+		throwIaxIfNull(o, name);
+		if (null != c) {
+			Class actualClass = o.getClass();
+			if (!c.isAssignableFrom(actualClass)) {
+				String message = name + " not assignable to " + c.getName();
+				throw new IllegalArgumentException(message);
+			}
+		}
+	}
+
+	// /**
+	// * Shorthand for "if any not null or not assignable, throw IllegalArgumentException"
+	// * @throws IllegalArgumentException "{name} is not assignable to {c}"
+	// */
+	// public static final void throwIaxIfNotAllAssignable(final Collection collection,
+	// final Class c, final String name) {
+	// throwIaxIfNull(collection, name);
+	// if (null != c) {
+	// for (Iterator iter = collection.iterator(); iter.hasNext();) {
+	// throwIaxIfNotAssignable(iter.next(), c, name);
+	//				
+	// }
+	// }
+	// }
+	/**
+	 * Shorthand for "if false, throw IllegalArgumentException"
+	 * 
+	 * @throws IllegalArgumentException "{message}" if test is false
+	 */
+	public static final void throwIaxIfFalse(final boolean test, final String message) {
+		if (!test) {
+			throw new IllegalArgumentException(message);
+		}
+	}
+
+	// /** @return ((null == s) || (0 == s.trim().length())); */
+	// public static boolean isEmptyTrimmed(String s) {
+	// return ((null == s) || (0 == s.length())
+	// || (0 == s.trim().length()));
+	// }
+
+	/** @return ((null == s) || (0 == s.length())); */
+	public static boolean isEmpty(String s) {
+		return ((null == s) || (0 == s.length()));
+	}
+
+	/** @return ((null == ra) || (0 == ra.length)) */
+	public static boolean isEmpty(Object[] ra) {
+		return ((null == ra) || (0 == ra.length));
+	}
+
+	/** @return ((null == collection) || (0 == collection.size())) */
+	public static boolean isEmpty(Collection collection) {
+		return ((null == collection) || (0 == collection.size()));
+	}
+
+	/**
 	 * Splits <code>text</code> at whitespace.
-	 *
+	 * 
 	 * @param text <code>String</code> to split.
 	 */
 	public static String[] split(String text) {
 		return (String[]) strings(text).toArray(new String[0]);
 	}
-    
-    /**
-     * Splits <code>input</code> at commas, 
-     * trimming any white space.
-     *
-     * @param input <code>String</code> to split.
-     * @return List of String of elements.
-     */
-    public static List commaSplit(String input) {
-        return anySplit(input, ",");
-    }
-    
-    /**
-     * Split string as classpath, delimited at File.pathSeparator.
-     * Entries are not trimmed, but empty entries are ignored.
-     * @param classpath the String to split - may be null or empty
-     * @return String[] of classpath entries
-     */
-    public static String[] splitClasspath(String classpath) {
-        if (LangUtil.isEmpty(classpath)) {
-            return new String[0];
-        }
-        StringTokenizer st = new StringTokenizer(classpath, File.pathSeparator);
-        ArrayList result = new ArrayList(st.countTokens());
-        while (st.hasMoreTokens()) {
-            String entry = st.nextToken();
-            if (!LangUtil.isEmpty(entry)) {
-                result.add(entry);
-            }
-        }
-        return (String[]) result.toArray(new String[0]);
-    }
-
-    /** 
-     * Get System property as boolean, 
-     * but use default value where the system property is not set.
-     * @return true if value is set to true, false otherwise 
-     */
-    public static boolean getBoolean(String propertyName, boolean defaultValue) {
-        if (null != propertyName) {
-            try {
-                String value = System.getProperty(propertyName);
-                if (null != value) {
-                    return Boolean.valueOf(value).booleanValue();
-                }
-            } catch (Throwable t) {
-                // default below
-            }
-        }
-        return defaultValue;
-    }
-
-    /**
-     * Splits <code>input</code>, removing delimiter and 
-     * trimming any white space.
-     * Returns an empty collection if the input is null.
-     * If delimiter is null or empty or if the input contains
-     * no delimiters, the input itself is returned
-     * after trimming white space.
-     *
-     * @param input <code>String</code> to split.
-     * @param delim <code>String</code> separators for input.
-     * @return List of String of elements.
-     */
-    public static List anySplit(String input, String delim) {
-        if (null == input) {
-            return Collections.EMPTY_LIST;
-        } 
-        ArrayList result = new ArrayList();
-        
-        if (LangUtil.isEmpty(delim)
-            || (-1 == input.indexOf(delim))) {
-            result.add(input.trim());
-        } else {
-            StringTokenizer st = new StringTokenizer(input, delim);
-            while (st.hasMoreTokens()) {
-                result.add(st.nextToken().trim());
-            }
-        }
-        return result;        
-    }
-    
 
 	/**
-	 * Splits strings into a <code>List</code> using a
-	 * <code>StringTokenizer</code>.
-	 *
+	 * Splits <code>input</code> at commas, trimming any white space.
+	 * 
+	 * @param input <code>String</code> to split.
+	 * @return List of String of elements.
+	 */
+	public static List commaSplit(String input) {
+		return anySplit(input, ",");
+	}
+
+	/**
+	 * Split string as classpath, delimited at File.pathSeparator. Entries are not trimmed, but empty entries are ignored.
+	 * 
+	 * @param classpath the String to split - may be null or empty
+	 * @return String[] of classpath entries
+	 */
+	public static String[] splitClasspath(String classpath) {
+		if (LangUtil.isEmpty(classpath)) {
+			return new String[0];
+		}
+		StringTokenizer st = new StringTokenizer(classpath, File.pathSeparator);
+		ArrayList result = new ArrayList(st.countTokens());
+		while (st.hasMoreTokens()) {
+			String entry = st.nextToken();
+			if (!LangUtil.isEmpty(entry)) {
+				result.add(entry);
+			}
+		}
+		return (String[]) result.toArray(new String[0]);
+	}
+
+	/**
+	 * Get System property as boolean, but use default value where the system property is not set.
+	 * 
+	 * @return true if value is set to true, false otherwise
+	 */
+	public static boolean getBoolean(String propertyName, boolean defaultValue) {
+		if (null != propertyName) {
+			try {
+				String value = System.getProperty(propertyName);
+				if (null != value) {
+					return Boolean.valueOf(value).booleanValue();
+				}
+			} catch (Throwable t) {
+				// default below
+			}
+		}
+		return defaultValue;
+	}
+
+	/**
+	 * Splits <code>input</code>, removing delimiter and trimming any white space. Returns an empty collection if the input is null.
+	 * If delimiter is null or empty or if the input contains no delimiters, the input itself is returned after trimming white
+	 * space.
+	 * 
+	 * @param input <code>String</code> to split.
+	 * @param delim <code>String</code> separators for input.
+	 * @return List of String of elements.
+	 */
+	public static List anySplit(String input, String delim) {
+		if (null == input) {
+			return Collections.EMPTY_LIST;
+		}
+		ArrayList result = new ArrayList();
+
+		if (LangUtil.isEmpty(delim) || (-1 == input.indexOf(delim))) {
+			result.add(input.trim());
+		} else {
+			StringTokenizer st = new StringTokenizer(input, delim);
+			while (st.hasMoreTokens()) {
+				result.add(st.nextToken().trim());
+			}
+		}
+		return result;
+	}
+
+	/**
+	 * Splits strings into a <code>List</code> using a <code>StringTokenizer</code>.
+	 * 
 	 * @param text <code>String</code> to split.
 	 */
 	public static List strings(String text) {
-        if (LangUtil.isEmpty(text)) {
-            return Collections.EMPTY_LIST;
-        }
+		if (LangUtil.isEmpty(text)) {
+			return Collections.EMPTY_LIST;
+		}
 		List strings = new ArrayList();
 		StringTokenizer tok = new StringTokenizer(text);
 		while (tok.hasMoreTokens()) {
@@ -308,1169 +319,1119 @@ public class LangUtil {
 
 	/** @return a non-null unmodifiable List */
 	public static List safeList(List list) {
-		return (
-			null == list
-				? Collections.EMPTY_LIST
-				: Collections.unmodifiableList(list));
+		return (null == list ? Collections.EMPTY_LIST : Collections.unmodifiableList(list));
+	}
+
+	// /**
+	// * Select from input String[] based on suffix-matching
+	// * @param inputs String[] of input - null ignored
+	// * @param suffixes String[] of suffix selectors - null ignored
+	// * @param ignoreCase if true, ignore case
+	// * @return String[] of input that end with any input
+	// */
+	// public static String[] endsWith(String[] inputs, String[] suffixes, boolean ignoreCase) {
+	// if (LangUtil.isEmpty(inputs) || LangUtil.isEmpty(suffixes)) {
+	// return new String[0];
+	// }
+	// if (ignoreCase) {
+	// String[] temp = new String[suffixes.length];
+	// for (int i = 0; i < temp.length; i++) {
+	// String suff = suffixes[i];
+	// temp[i] = (null == suff ? null : suff.toLowerCase());
+	// }
+	// suffixes = temp;
+	// }
+	// ArrayList result = new ArrayList();
+	// for (int i = 0; i < inputs.length; i++) {
+	// String input = inputs[i];
+	// if (null == input) {
+	// continue;
+	// }
+	// if (!ignoreCase) {
+	// input = input.toLowerCase();
+	// }
+	// for (int j = 0; j < suffixes.length; j++) {
+	// String suffix = suffixes[j];
+	// if (null == suffix) {
+	// continue;
+	// }
+	// if (input.endsWith(suffix)) {
+	// result.add(input);
+	// break;
+	// }
+	// }
+	// }
+	// return (String[]) result.toArray(new String[0]);
+	// }
+	//    
+	// /**
+	// * Select from input String[] if readable directories
+	// * @param inputs String[] of input - null ignored
+	// * @param baseDir the base directory of the input
+	// * @return String[] of input that end with any input
+	// */
+	// public static String[] selectDirectories(String[] inputs, File baseDir) {
+	// if (LangUtil.isEmpty(inputs)) {
+	// return new String[0];
+	// }
+	// ArrayList result = new ArrayList();
+	// for (int i = 0; i < inputs.length; i++) {
+	// String input = inputs[i];
+	// if (null == input) {
+	// continue;
+	// }
+	// File inputFile = new File(baseDir, input);
+	// if (inputFile.canRead() && inputFile.isDirectory()) {
+	// result.add(input);
+	// }
+	// }
+	// return (String[]) result.toArray(new String[0]);
+	// }
+
+	/**
+	 * copy non-null two-dimensional String[][]
+	 * 
+	 * @see extractOptions(String[], String[][])
+	 */
+	public static String[][] copyStrings(String[][] in) {
+		String[][] out = new String[in.length][];
+		for (int i = 0; i < out.length; i++) {
+			out[i] = new String[in[i].length];
+			System.arraycopy(in[i], 0, out[i], 0, out[i].length);
+		}
+		return out;
 	}
-    
-//    /**
-//     * Select from input String[] based on suffix-matching
-//     * @param inputs String[] of input - null ignored
-//     * @param suffixes String[] of suffix selectors - null ignored
-//     * @param ignoreCase if true, ignore case
-//     * @return String[] of input that end with any input
-//     */
-//    public static String[] endsWith(String[] inputs, String[] suffixes, boolean ignoreCase) {
-//        if (LangUtil.isEmpty(inputs) || LangUtil.isEmpty(suffixes)) {
-//            return new String[0];
-//        }
-//        if (ignoreCase) {
-//            String[] temp = new String[suffixes.length];
-//            for (int i = 0; i < temp.length; i++) {                
-//				String suff = suffixes[i];
-//                temp[i] = (null ==  suff ? null : suff.toLowerCase());
-//			}
-//            suffixes = temp;
-//        }
-//        ArrayList result = new ArrayList();
-//        for (int i = 0; i < inputs.length; i++) {
-//            String input = inputs[i];
-//            if (null == input) {
-//                continue;
-//            }
-//            if (!ignoreCase) {
-//                input = input.toLowerCase();
-//            }
-//            for (int j = 0; j < suffixes.length; j++) {
-//                String suffix = suffixes[j];
-//                if (null == suffix) {
-//                    continue;
-//                }
-//                if (input.endsWith(suffix)) {
-//                    result.add(input);
-//                    break;
-//                }
-//            }
-//        }
-//        return (String[]) result.toArray(new String[0]);
-//    }
-//    
-//    /**
-//     * Select from input String[] if readable directories
-//     * @param inputs String[] of input - null ignored
-//     * @param baseDir the base directory of the input
-//     * @return String[] of input that end with any input
-//     */
-//    public static String[] selectDirectories(String[] inputs, File baseDir) {
-//        if (LangUtil.isEmpty(inputs)) {
-//            return new String[0];
-//        }
-//        ArrayList result = new ArrayList();
-//        for (int i = 0; i < inputs.length; i++) {
-//            String input = inputs[i];
-//            if (null == input) {
-//                continue;
-//            }
-//            File inputFile = new File(baseDir, input);
-//            if (inputFile.canRead() && inputFile.isDirectory()) {
-//                result.add(input);
-//            }
-//        }
-//        return (String[]) result.toArray(new String[0]);
-//    }
-
-    /** 
-     * copy non-null two-dimensional String[][] 
-     * @see extractOptions(String[], String[][]) 
-     */
-    public static String[][] copyStrings(String[][] in) {
-        String[][] out = new String[in.length][];
-        for (int i = 0; i < out.length; i++) {
-            out[i] = new String[in[i].length];
-            System.arraycopy(in[i], 0, out[i], 0, out[i].length);
-        } 
-        return out;
-    }
-
-    /** 
-     * Extract options and arguments to input option list, returning remainder.
-     * The input options will be nullified if not found.  e.g., 
-     * <pre>String[] options = new String[][] { new String[] { "-verbose" },
-     *     new String[] { "-classpath", null } };
-     * String[] args = extractOptions(args, options);
-     * boolean verbose = null != options[0][0];
-     * boolean classpath = options[1][1];</pre>
-     * @param args the String[] input options
-     * @param options the String[][]options to find in the input args - not null
-     *         for each String[] component the first subcomponent is the option itself,
-     *         and there is one String subcomponent for each additional argument.
-     * @return String[] of args remaining after extracting options to extracted 
-     */
-    public static String[] extractOptions(String[] args, String[][] options) {
-        if (LangUtil.isEmpty(args) || LangUtil.isEmpty(options) ) {
-            return args;
-        }
-        BitSet foundSet = new BitSet();
-        String[] result = new String[args.length];
-        int resultIndex = 0;
-        for (int j = 0; j < args.length; j++) {
-            boolean found = false;
-            for (int i = 0; !found && (i < options.length); i++) {
-                String[] option = options[i];
-                LangUtil.throwIaxIfFalse(!LangUtil.isEmpty(option), "options");
-                String sought = option[0];
-                found = sought.equals(args[j]);
-                if (found) {                    
-                    foundSet.set(i);
-                    int doMore = option.length-1;
-                    if (0 < doMore) {
-                        final int MAX = j + doMore;
-                        if (MAX >= args.length) {
-                            String s = "expecting " + doMore + " args after ";
-                            throw new IllegalArgumentException(s + args[j]);
-                        }
-                        for (int k = 1; k < option.length; k++) {
+
+	/**
+	 * Extract options and arguments to input option list, returning remainder. The input options will be nullified if not found.
+	 * e.g.,
+	 * 
+	 * <pre>
+	 * String[] options = new String[][] { new String[] { &quot;-verbose&quot; }, new String[] { &quot;-classpath&quot;, null } };
+	 * String[] args = extractOptions(args, options);
+	 * boolean verbose = null != options[0][0];
+	 * boolean classpath = options[1][1];
+	 * </pre>
+	 * 
+	 * @param args the String[] input options
+	 * @param options the String[][]options to find in the input args - not null for each String[] component the first subcomponent
+	 *        is the option itself, and there is one String subcomponent for each additional argument.
+	 * @return String[] of args remaining after extracting options to extracted
+	 */
+	public static String[] extractOptions(String[] args, String[][] options) {
+		if (LangUtil.isEmpty(args) || LangUtil.isEmpty(options)) {
+			return args;
+		}
+		BitSet foundSet = new BitSet();
+		String[] result = new String[args.length];
+		int resultIndex = 0;
+		for (int j = 0; j < args.length; j++) {
+			boolean found = false;
+			for (int i = 0; !found && (i < options.length); i++) {
+				String[] option = options[i];
+				LangUtil.throwIaxIfFalse(!LangUtil.isEmpty(option), "options");
+				String sought = option[0];
+				found = sought.equals(args[j]);
+				if (found) {
+					foundSet.set(i);
+					int doMore = option.length - 1;
+					if (0 < doMore) {
+						final int MAX = j + doMore;
+						if (MAX >= args.length) {
+							String s = "expecting " + doMore + " args after ";
+							throw new IllegalArgumentException(s + args[j]);
+						}
+						for (int k = 1; k < option.length; k++) {
 							option[k] = args[++j];
 						}
-                    }
-                }
-            }
-            if (!found) {
-                result[resultIndex++] = args[j];
-            }
-        }
-        
-        // unset any not found
-        for (int i = 0; i < options.length; i++) {
-            if (!foundSet.get(i)) {
-                options[i][0] = null;
-            }
-        }        
-        // fixup remainder
-        if (resultIndex < args.length) {
-            String[] temp = new String[resultIndex];
-            System.arraycopy(result, 0, temp, 0, resultIndex);
-            args = temp;
-        }
-        
-        return args;        
-    }
-//    
-//    /** 
-//     * Extract options and arguments to input parameter list, returning remainder.
-//     * @param args the String[] input options
-//     * @param validOptions the String[] options to find in the input args - not null
-//     * @param optionArgs the int[] number of arguments for each option in validOptions
-//     *         (if null, then no arguments for any option)
-//     * @param extracted the List for the matched options
-//     * @return String[] of args remaining after extracting options to extracted 
-//     */
-//    public static String[] extractOptions(String[] args, String[] validOptions,
-//        int[] optionArgs, List extracted) {
-//        if (LangUtil.isEmpty(args) 
-//            || LangUtil.isEmpty(validOptions) ) {
-//            return args;
-//        }
-//        if (null != optionArgs) {
-//            if (optionArgs.length != validOptions.length) {
-//                throw new IllegalArgumentException("args must match options");
-//            }
-//        }
-//        String[] result = new String[args.length];
-//        int resultIndex = 0;
-//        for (int j = 0; j < args.length; j++) {
-//            boolean found = false;
-//            for (int i = 0; !found && (i < validOptions.length); i++) {
-//                String sought = validOptions[i];
-//                int doMore = (null == optionArgs ? 0 : optionArgs[i]);
-//                if (LangUtil.isEmpty(sought)) {
-//                    continue;
-//                }
-//                found = sought.equals(args[j]);
-//                if (found) {                    
-//                    if (null != extracted) {
-//                        extracted.add(sought);
-//                    }
-//                    if (0 < doMore) {
-//                        final int MAX = j + doMore;
-//                        if (MAX >= args.length) {
-//                            String s = "expecting " + doMore + " args after ";
-//                            throw new IllegalArgumentException(s + args[j]);
-//                        }
-//                        if (null != extracted) {                            
-//                            while (j < MAX) {
-//                                extracted.add(args[++j]);
-//                            }
-//                        } else {
-//                            j = MAX;
-//                        }                        
-//                    }
-//                    break;
-//                }
-//            }
-//            if (!found) {
-//                result[resultIndex++] = args[j];
-//            }
-//        }
-//        if (resultIndex < args.length) {
-//            String[] temp = new String[resultIndex];
-//            System.arraycopy(result, 0, temp, 0, resultIndex);
-//            args = temp;
-//        }
-//        return args;        
-//    }
-
-//    /** @return String[] of entries in validOptions found in args */
-//    public static String[] selectOptions(String[] args, String[] validOptions) {
-//        if (LangUtil.isEmpty(args) || LangUtil.isEmpty(validOptions)) {
-//            return new String[0];
-//        }
-//        ArrayList result = new ArrayList();
-//        for (int i = 0; i < validOptions.length; i++) {
-//            String sought = validOptions[i];
-//            if (LangUtil.isEmpty(sought)) {
-//                continue;
-//            }
-//			for (int j = 0; j < args.length; j++) {
-//				if (sought.equals(args[j])) {
-//                    result.add(sought);
-//                    break;
-//                }
-//			}
-//		}
-//        return (String[]) result.toArray(new String[0]);
-//    }
-    
-//    /** @return String[] of entries in validOptions found in args */
-//    public static String[] selectOptions(List args, String[] validOptions) {
-//        if (LangUtil.isEmpty(args) || LangUtil.isEmpty(validOptions)) {
-//            return new String[0];
-//        }
-//        ArrayList result = new ArrayList();
-//        for (int i = 0; i < validOptions.length; i++) {
-//            String sought = validOptions[i];
-//            if (LangUtil.isEmpty(sought)) {
-//                continue;
-//            }
-//            for (Iterator iter = args.iterator(); iter.hasNext();) {
-//				String arg = (String) iter.next();
-//                if (sought.equals(arg)) {
-//                    result.add(sought);
-//                    break;
-//                }
-//            }
-//        }
-//        return (String[]) result.toArray(new String[0]);
-//    }
-    
-//    /**
-//     * Generate variants of String[] options by creating an extra set for
-//     * each option that ends with "-".  If none end with "-", then an
-//     * array equal to <code>new String[][] { options }</code> is returned;
-//     * if one ends with "-", then two sets are returned,
-//     * three causes eight sets, etc.
-//     * @return String[][] with each option set.
-//     * @throws IllegalArgumentException if any option is null or empty.
-//     */
-//    public static String[][] optionVariants(String[] options) {
-//        if ((null == options) || (0 == options.length)) {
-//            return new String[][] { new String[0]};            
-//        }
-//        // be nice, don't stomp input
-//        String[] temp = new String[options.length];
-//        System.arraycopy(options, 0, temp, 0, temp.length);
-//        options = temp;
-//        boolean[] dup = new boolean[options.length];
-//        int numDups = 0;
-//        
-//        for (int i = 0; i < options.length; i++) {
-//            String option = options[i];
-//            if (LangUtil.isEmpty(option)) {
-//                throw new IllegalArgumentException("empty option at " + i);
-//            }
-//            if (option.endsWith("-")) {
-//                options[i] = option.substring(0, option.length()-1);
-//                dup[i] = true;
-//                numDups++;
-//            }
-//        }
-//        final String[] NONE = new String[0];
-//        final int variants = exp(2, numDups);
-//        final String[][] result = new String[variants][];
-//        // variant is a bitmap wrt doing extra value when dup[k]=true
-//        for (int variant = 0; variant < variants; variant++) { 
-//            ArrayList next = new ArrayList();
-//            int nextOption = 0;
-//            for (int k = 0; k < options.length; k++) {
-//                if (!dup[k] || (0 != (variant & (1 << (nextOption++))))) {
-//                    next.add(options[k]);
-//                }                   
-//            }
-//            result[variant] = (String[]) next.toArray(NONE);
-//        }
-//        return result;
-//    }
-//    
-//    private static int exp(int base, int power) { // not in Math?
-//        if (0 > power) {
-//            throw new IllegalArgumentException("negative power: " + power);
-//        } 
-//        int result = 1;
-//        while (0 < power--) {
-//            result *= base;
-//        }
-//        return result;
-//    }
-
-//    /**
-//     * Make a copy of the array.
-//     * @return an array with the same component type as source
-//     * containing same elements, even if null.
-//     * @throws IllegalArgumentException if source is null
-//     */
-//    public static final Object[] copy(Object[] source) {
-//        LangUtil.throwIaxIfNull(source, "source");        
-//        final Class c = source.getClass().getComponentType();
-//        Object[] result = (Object[]) Array.newInstance(c, source.length);
-//        System.arraycopy(source, 0, result, 0, result.length);
-//        return result;
-//    }
-    
-    
-    /**
-     * Convert arrays safely.  The number of elements in the result
-     * will be 1 smaller for each element that is null or not assignable.
-     * This will use sink if it has exactly the right size.
-     * The result will always have the same component type as sink.
-     * @return an array with the same component type as sink
-     * containing any assignable elements in source (in the same order).
-     * @throws IllegalArgumentException if either is null
-     */
-    public static Object[] safeCopy(Object[] source, Object[] sink) {
-        final Class sinkType = (null == sink 
-                                ? Object.class 
-                                : sink.getClass().getComponentType());
-        final int sourceLength = (null == source ? 0 : source.length);
-        final int sinkLength = (null == sink ? 0 : sink.length);
-        
-        final int resultSize;
-        ArrayList result = null;
-        if (0 == sourceLength) {
-            resultSize = 0;
-        } else {
-            result = new ArrayList(sourceLength);
-            for (int i = 0; i < sourceLength; i++) {
-                if ((null != source[i])
-                    && (sinkType.isAssignableFrom(source[i].getClass()))) {
-                    result.add(source[i]);
-                }
-            }
-            resultSize = result.size();
-        }
-        if (resultSize != sinkLength) {
-            sink = (Object[]) Array.newInstance(sinkType, result.size());
-        }
-        if (0 < resultSize) {
-            sink = result.toArray(sink);
-        }
-        return sink;
-    }
-
-	/** 
-     * @return a String with the unqualified class name of the class (or "null")
-     */
-    public static String unqualifiedClassName(Class c) {
-        if (null == c) {
-            return "null";
-        }
-        String name = c.getName();
-        int loc = name.lastIndexOf(".");
-        if (-1 != loc) {
-            name = name.substring(1 + loc);
-        }
-        return name;
-    }
-
-	/** 
-     * @return a String with the unqualified class name of the object (or "null")
-     */
-    public static String unqualifiedClassName(Object o) {
-        return LangUtil.unqualifiedClassName(null == o ? null : o.getClass());
-    }
-
-    /** inefficient way to replace all instances of sought with replace */
-    public static String replace(String in, String sought, String replace) {
-        if (LangUtil.isEmpty(in) || LangUtil.isEmpty(sought)) {
-            return in;
-        }
-        StringBuffer result = new StringBuffer();
-        final int len = sought.length();
-        int start = 0;
-        int loc;
-        while (-1 != (loc = in.indexOf(sought, start))) {
-            result.append(in.substring(start, loc));
-            if (!LangUtil.isEmpty(replace)) {
-                result.append(replace);
-            }
-            start = loc + len;
-        }
-        result.append(in.substring(start));
-        return result.toString();    
-    }
-    
-    /** render i right-justified with a given width less than about 40 */
-    public static String toSizedString(long i, int width) {
-        String result = "" + i;
-        int size = result.length();
-        if (width > size) {
-            final String pad = "                                              ";
-            final int padLength = pad.length();
-            if (width > padLength) {
-                width = padLength;
-            }
-            int topad = width-size;
-            result = pad.substring(0, topad) + result;
-        }
-        return result;
-    }
-
-//    /** clip StringBuffer to maximum number of lines */
-//    static String clipBuffer(StringBuffer buffer, int maxLines) {
-//        if ((null == buffer) || (1 > buffer.length())) return "";
-//        StringBuffer result = new StringBuffer();
-//        int j = 0;
-//        final int MAX = maxLines;
-//        final int N = buffer.length();
-//        for (int i = 0, srcBegin = 0; i < MAX; srcBegin += j) {
-//            // todo: replace with String variant if/since getting char?
-//            char[] chars = new char[128];
-//            int srcEnd = srcBegin+chars.length;
-//            if (srcEnd >= N) {
-//                srcEnd = N-1;
-//            }
-//            if (srcBegin == srcEnd) break;
-//            //log("srcBegin:" + srcBegin + ":srcEnd:" + srcEnd);
-//            buffer.getChars(srcBegin, srcEnd, chars, 0);            
-//            for (j = 0; j < srcEnd-srcBegin/*chars.length*/; j++) {
-//                char c = chars[j];
-//                if (c == '\n') {
-//                    i++;
-//                    j++;
-//                    break;
-//                }
-//            }
-//            try { result.append(chars, 0, j); } 
-//            catch (Throwable t) { }
-//        }
-//        return result.toString();
-//    }
-
-    /**
-     * @return "({UnqualifiedExceptionClass}) {message}"
-     */
-    public static String renderExceptionShort(Throwable e) {
-        if (null == e)
-            return "(Throwable) null";
-        return "(" + LangUtil.unqualifiedClassName(e) + ") " + e.getMessage();
-    }
-
-   /**
-     * Renders exception <code>t</code> after unwrapping and 
-     * eliding any test packages.
-     * @param t <code>Throwable</code> to print.
-     * @see   #maxStackTrace
-     */
-    public static String renderException(Throwable t) { 
-        return renderException(t, true);
-    }
-    
-   /**
-     * Renders exception <code>t</code>, unwrapping,
-     * optionally eliding and limiting total number of lines.
-     * @param t <code>Throwable</code> to print.
-     * @param elide true to limit to 100 lines and elide test packages
-     * @see StringChecker#TEST_PACKAGES
-     */
-    public static String renderException(Throwable t, boolean elide) {
-        if (null == t) return "null throwable";
-        t = unwrapException(t);
-        StringBuffer stack = stackToString(t, false);
-        if (elide) {
-            elideEndingLines(StringChecker.TEST_PACKAGES, stack, 100);
-        }
-        return stack.toString();
-    }
-
-    /**
-     * Trim ending lines from a StringBuffer,
-     * clipping to maxLines and further removing any number of
-     * trailing lines accepted by checker.
-     * @param checker returns true if trailing line should be elided.
-     * @param stack StringBuffer with lines to elide
-     * @param maxLines int for maximum number of resulting lines
-     */
-    static void elideEndingLines(StringChecker checker, StringBuffer stack, int maxLines) {
-        if (null == checker || (null == stack) || (0 == stack.length())) {
-            return;
-        }
-        final LinkedList lines = new LinkedList();
-        StringTokenizer st = new StringTokenizer(stack.toString(),"\n\r");
-        while (st.hasMoreTokens() && (0 < --maxLines)) {
-            lines.add(st.nextToken());
-        }
-        st = null;
-        
-        String line;
-        int elided = 0;
-        while (!lines.isEmpty()) { 
-            line = (String) lines.getLast();
-            if (!checker.acceptString(line)) {
-                break;
-            } else {
-                elided++;
-                lines.removeLast();
-            }
-        }
-        if ((elided > 0) || (maxLines < 1)) { 
-            final int EOL_LEN = EOL.length();           
-            int totalLength = 0;
-            while (!lines.isEmpty()) { 
-                totalLength += EOL_LEN + ((String) lines.getFirst()).length();
-                lines.removeFirst();
-            }
-            if (stack.length() > totalLength) {
-                stack.setLength(totalLength);
-                if (elided > 0) {
-                    stack.append("    (... " + elided + " lines...)");
-                }
-            }
-        }
-    }
-
-
-    /** Dump message and stack to StringBuffer. */
-    public static StringBuffer stackToString(Throwable throwable, boolean skipMessage) {
-        if (null == throwable) {
-            return new StringBuffer();
-        }
-        StringWriter buf = new StringWriter();
-        PrintWriter writer = new PrintWriter(buf);
-        if (!skipMessage) {
-            writer.println(throwable.getMessage());
-        }
-        throwable.printStackTrace(writer);
-        try { buf.close(); } 
-        catch (IOException ioe) {} //  ignored
-        return buf.getBuffer(); 
-    }
-
-    
-    /** @return Throwable input or tail of any wrapped exception chain */
-    public static Throwable unwrapException(Throwable t) {
-        Throwable current = t;
-        Throwable next = null;
-        while (current != null) {   
-            // Java 1.2 exceptions that carry exceptions
-            if (current instanceof InvocationTargetException) {
-                next = ((InvocationTargetException) current).getTargetException();
-            } else if (current instanceof ClassNotFoundException) {
-                next = ((ClassNotFoundException) current).getException();
-            } else if (current instanceof ExceptionInInitializerError) {
-                next = ((ExceptionInInitializerError) current).getException();
-            } else if (current instanceof PrivilegedActionException) {
-                next = ((PrivilegedActionException) current).getException();
-            } else if (current instanceof SQLException) {
-                next = ((SQLException) current).getNextException();
-            }
-            // ...getException():
-            // javax.naming.event.NamingExceptionEvent
-            // javax.naming.ldap.UnsolicitedNotification
-            // javax.xml.parsers.FactoryConfigurationError
-            // javax.xml.transform.TransformerFactoryConfigurationError
-            // javax.xml.transform.TransformerException
-            // org.xml.sax.SAXException
-            // 1.4: Throwable.getCause
-            // java.util.logging.LogRecord.getThrown()
-            if (null == next) {
-                break;
-            } else {
-                current = next;
-                next = null;
-            }
-        }
-        return current;
-    }
+					}
+				}
+			}
+			if (!found) {
+				result[resultIndex++] = args[j];
+			}
+		}
+
+		// unset any not found
+		for (int i = 0; i < options.length; i++) {
+			if (!foundSet.get(i)) {
+				options[i][0] = null;
+			}
+		}
+		// fixup remainder
+		if (resultIndex < args.length) {
+			String[] temp = new String[resultIndex];
+			System.arraycopy(result, 0, temp, 0, resultIndex);
+			args = temp;
+		}
+
+		return args;
+	}
+
+	//    
+	// /**
+	// * Extract options and arguments to input parameter list, returning remainder.
+	// * @param args the String[] input options
+	// * @param validOptions the String[] options to find in the input args - not null
+	// * @param optionArgs the int[] number of arguments for each option in validOptions
+	// * (if null, then no arguments for any option)
+	// * @param extracted the List for the matched options
+	// * @return String[] of args remaining after extracting options to extracted
+	// */
+	// public static String[] extractOptions(String[] args, String[] validOptions,
+	// int[] optionArgs, List extracted) {
+	// if (LangUtil.isEmpty(args)
+	// || LangUtil.isEmpty(validOptions) ) {
+	// return args;
+	// }
+	// if (null != optionArgs) {
+	// if (optionArgs.length != validOptions.length) {
+	// throw new IllegalArgumentException("args must match options");
+	// }
+	// }
+	// String[] result = new String[args.length];
+	// int resultIndex = 0;
+	// for (int j = 0; j < args.length; j++) {
+	// boolean found = false;
+	// for (int i = 0; !found && (i < validOptions.length); i++) {
+	// String sought = validOptions[i];
+	// int doMore = (null == optionArgs ? 0 : optionArgs[i]);
+	// if (LangUtil.isEmpty(sought)) {
+	// continue;
+	// }
+	// found = sought.equals(args[j]);
+	// if (found) {
+	// if (null != extracted) {
+	// extracted.add(sought);
+	// }
+	// if (0 < doMore) {
+	// final int MAX = j + doMore;
+	// if (MAX >= args.length) {
+	// String s = "expecting " + doMore + " args after ";
+	// throw new IllegalArgumentException(s + args[j]);
+	// }
+	// if (null != extracted) {
+	// while (j < MAX) {
+	// extracted.add(args[++j]);
+	// }
+	// } else {
+	// j = MAX;
+	// }
+	// }
+	// break;
+	// }
+	// }
+	// if (!found) {
+	// result[resultIndex++] = args[j];
+	// }
+	// }
+	// if (resultIndex < args.length) {
+	// String[] temp = new String[resultIndex];
+	// System.arraycopy(result, 0, temp, 0, resultIndex);
+	// args = temp;
+	// }
+	// return args;
+	// }
+
+	// /** @return String[] of entries in validOptions found in args */
+	// public static String[] selectOptions(String[] args, String[] validOptions) {
+	// if (LangUtil.isEmpty(args) || LangUtil.isEmpty(validOptions)) {
+	// return new String[0];
+	// }
+	// ArrayList result = new ArrayList();
+	// for (int i = 0; i < validOptions.length; i++) {
+	// String sought = validOptions[i];
+	// if (LangUtil.isEmpty(sought)) {
+	// continue;
+	// }
+	// for (int j = 0; j < args.length; j++) {
+	// if (sought.equals(args[j])) {
+	// result.add(sought);
+	// break;
+	// }
+	// }
+	// }
+	// return (String[]) result.toArray(new String[0]);
+	// }
+
+	// /** @return String[] of entries in validOptions found in args */
+	// public static String[] selectOptions(List args, String[] validOptions) {
+	// if (LangUtil.isEmpty(args) || LangUtil.isEmpty(validOptions)) {
+	// return new String[0];
+	// }
+	// ArrayList result = new ArrayList();
+	// for (int i = 0; i < validOptions.length; i++) {
+	// String sought = validOptions[i];
+	// if (LangUtil.isEmpty(sought)) {
+	// continue;
+	// }
+	// for (Iterator iter = args.iterator(); iter.hasNext();) {
+	// String arg = (String) iter.next();
+	// if (sought.equals(arg)) {
+	// result.add(sought);
+	// break;
+	// }
+	// }
+	// }
+	// return (String[]) result.toArray(new String[0]);
+	// }
+
+	// /**
+	// * Generate variants of String[] options by creating an extra set for
+	// * each option that ends with "-". If none end with "-", then an
+	// * array equal to <code>new String[][] { options }</code> is returned;
+	// * if one ends with "-", then two sets are returned,
+	// * three causes eight sets, etc.
+	// * @return String[][] with each option set.
+	// * @throws IllegalArgumentException if any option is null or empty.
+	// */
+	// public static String[][] optionVariants(String[] options) {
+	// if ((null == options) || (0 == options.length)) {
+	// return new String[][] { new String[0]};
+	// }
+	// // be nice, don't stomp input
+	// String[] temp = new String[options.length];
+	// System.arraycopy(options, 0, temp, 0, temp.length);
+	// options = temp;
+	// boolean[] dup = new boolean[options.length];
+	// int numDups = 0;
+	//        
+	// for (int i = 0; i < options.length; i++) {
+	// String option = options[i];
+	// if (LangUtil.isEmpty(option)) {
+	// throw new IllegalArgumentException("empty option at " + i);
+	// }
+	// if (option.endsWith("-")) {
+	// options[i] = option.substring(0, option.length()-1);
+	// dup[i] = true;
+	// numDups++;
+	// }
+	// }
+	// final String[] NONE = new String[0];
+	// final int variants = exp(2, numDups);
+	// final String[][] result = new String[variants][];
+	// // variant is a bitmap wrt doing extra value when dup[k]=true
+	// for (int variant = 0; variant < variants; variant++) {
+	// ArrayList next = new ArrayList();
+	// int nextOption = 0;
+	// for (int k = 0; k < options.length; k++) {
+	// if (!dup[k] || (0 != (variant & (1 << (nextOption++))))) {
+	// next.add(options[k]);
+	// }
+	// }
+	// result[variant] = (String[]) next.toArray(NONE);
+	// }
+	// return result;
+	// }
+	//    
+	// private static int exp(int base, int power) { // not in Math?
+	// if (0 > power) {
+	// throw new IllegalArgumentException("negative power: " + power);
+	// }
+	// int result = 1;
+	// while (0 < power--) {
+	// result *= base;
+	// }
+	// return result;
+	// }
+
+	// /**
+	// * Make a copy of the array.
+	// * @return an array with the same component type as source
+	// * containing same elements, even if null.
+	// * @throws IllegalArgumentException if source is null
+	// */
+	// public static final Object[] copy(Object[] source) {
+	// LangUtil.throwIaxIfNull(source, "source");
+	// final Class c = source.getClass().getComponentType();
+	// Object[] result = (Object[]) Array.newInstance(c, source.length);
+	// System.arraycopy(source, 0, result, 0, result.length);
+	// return result;
+	// }
+
+	/**
+	 * Convert arrays safely. The number of elements in the result will be 1 smaller for each element that is null or not
+	 * assignable. This will use sink if it has exactly the right size. The result will always have the same component type as sink.
+	 * 
+	 * @return an array with the same component type as sink containing any assignable elements in source (in the same order).
+	 * @throws IllegalArgumentException if either is null
+	 */
+	public static Object[] safeCopy(Object[] source, Object[] sink) {
+		final Class sinkType = (null == sink ? Object.class : sink.getClass().getComponentType());
+		final int sourceLength = (null == source ? 0 : source.length);
+		final int sinkLength = (null == sink ? 0 : sink.length);
+
+		final int resultSize;
+		ArrayList result = null;
+		if (0 == sourceLength) {
+			resultSize = 0;
+		} else {
+			result = new ArrayList(sourceLength);
+			for (int i = 0; i < sourceLength; i++) {
+				if ((null != source[i]) && (sinkType.isAssignableFrom(source[i].getClass()))) {
+					result.add(source[i]);
+				}
+			}
+			resultSize = result.size();
+		}
+		if (resultSize != sinkLength) {
+			sink = (Object[]) Array.newInstance(sinkType, result.size());
+		}
+		if (0 < resultSize) {
+			sink = result.toArray(sink);
+		}
+		return sink;
+	}
+
+	/**
+	 * @return a String with the unqualified class name of the class (or "null")
+	 */
+	public static String unqualifiedClassName(Class c) {
+		if (null == c) {
+			return "null";
+		}
+		String name = c.getName();
+		int loc = name.lastIndexOf(".");
+		if (-1 != loc) {
+			name = name.substring(1 + loc);
+		}
+		return name;
+	}
+
+	/**
+	 * @return a String with the unqualified class name of the object (or "null")
+	 */
+	public static String unqualifiedClassName(Object o) {
+		return LangUtil.unqualifiedClassName(null == o ? null : o.getClass());
+	}
+
+	/** inefficient way to replace all instances of sought with replace */
+	public static String replace(String in, String sought, String replace) {
+		if (LangUtil.isEmpty(in) || LangUtil.isEmpty(sought)) {
+			return in;
+		}
+		StringBuffer result = new StringBuffer();
+		final int len = sought.length();
+		int start = 0;
+		int loc;
+		while (-1 != (loc = in.indexOf(sought, start))) {
+			result.append(in.substring(start, loc));
+			if (!LangUtil.isEmpty(replace)) {
+				result.append(replace);
+			}
+			start = loc + len;
+		}
+		result.append(in.substring(start));
+		return result.toString();
+	}
+
+	/** render i right-justified with a given width less than about 40 */
+	public static String toSizedString(long i, int width) {
+		String result = "" + i;
+		int size = result.length();
+		if (width > size) {
+			final String pad = "                                              ";
+			final int padLength = pad.length();
+			if (width > padLength) {
+				width = padLength;
+			}
+			int topad = width - size;
+			result = pad.substring(0, topad) + result;
+		}
+		return result;
+	}
+
+	// /** clip StringBuffer to maximum number of lines */
+	// static String clipBuffer(StringBuffer buffer, int maxLines) {
+	// if ((null == buffer) || (1 > buffer.length())) return "";
+	// StringBuffer result = new StringBuffer();
+	// int j = 0;
+	// final int MAX = maxLines;
+	// final int N = buffer.length();
+	// for (int i = 0, srcBegin = 0; i < MAX; srcBegin += j) {
+	// // todo: replace with String variant if/since getting char?
+	// char[] chars = new char[128];
+	// int srcEnd = srcBegin+chars.length;
+	// if (srcEnd >= N) {
+	// srcEnd = N-1;
+	// }
+	// if (srcBegin == srcEnd) break;
+	// //log("srcBegin:" + srcBegin + ":srcEnd:" + srcEnd);
+	// buffer.getChars(srcBegin, srcEnd, chars, 0);
+	// for (j = 0; j < srcEnd-srcBegin/*chars.length*/; j++) {
+	// char c = chars[j];
+	// if (c == '\n') {
+	// i++;
+	// j++;
+	// break;
+	// }
+	// }
+	// try { result.append(chars, 0, j); }
+	// catch (Throwable t) { }
+	// }
+	// return result.toString();
+	// }
+
+	/**
+	 * @return "({UnqualifiedExceptionClass}) {message}"
+	 */
+	public static String renderExceptionShort(Throwable e) {
+		if (null == e)
+			return "(Throwable) null";
+		return "(" + LangUtil.unqualifiedClassName(e) + ") " + e.getMessage();
+	}
+
+	/**
+	 * Renders exception <code>t</code> after unwrapping and eliding any test packages.
+	 * 
+	 * @param t <code>Throwable</code> to print.
+	 * @see #maxStackTrace
+	 */
+	public static String renderException(Throwable t) {
+		return renderException(t, true);
+	}
+
+	/**
+	 * Renders exception <code>t</code>, unwrapping, optionally eliding and limiting total number of lines.
+	 * 
+	 * @param t <code>Throwable</code> to print.
+	 * @param elide true to limit to 100 lines and elide test packages
+	 * @see StringChecker#TEST_PACKAGES
+	 */
+	public static String renderException(Throwable t, boolean elide) {
+		if (null == t)
+			return "null throwable";
+		t = unwrapException(t);
+		StringBuffer stack = stackToString(t, false);
+		if (elide) {
+			elideEndingLines(StringChecker.TEST_PACKAGES, stack, 100);
+		}
+		return stack.toString();
+	}
+
+	/**
+	 * Trim ending lines from a StringBuffer, clipping to maxLines and further removing any number of trailing lines accepted by
+	 * checker.
+	 * 
+	 * @param checker returns true if trailing line should be elided.
+	 * @param stack StringBuffer with lines to elide
+	 * @param maxLines int for maximum number of resulting lines
+	 */
+	static void elideEndingLines(StringChecker checker, StringBuffer stack, int maxLines) {
+		if (null == checker || (null == stack) || (0 == stack.length())) {
+			return;
+		}
+		final LinkedList lines = new LinkedList();
+		StringTokenizer st = new StringTokenizer(stack.toString(), "\n\r");
+		while (st.hasMoreTokens() && (0 < --maxLines)) {
+			lines.add(st.nextToken());
+		}
+		st = null;
+
+		String line;
+		int elided = 0;
+		while (!lines.isEmpty()) {
+			line = (String) lines.getLast();
+			if (!checker.acceptString(line)) {
+				break;
+			} else {
+				elided++;
+				lines.removeLast();
+			}
+		}
+		if ((elided > 0) || (maxLines < 1)) {
+			final int EOL_LEN = EOL.length();
+			int totalLength = 0;
+			while (!lines.isEmpty()) {
+				totalLength += EOL_LEN + ((String) lines.getFirst()).length();
+				lines.removeFirst();
+			}
+			if (stack.length() > totalLength) {
+				stack.setLength(totalLength);
+				if (elided > 0) {
+					stack.append("    (... " + elided + " lines...)");
+				}
+			}
+		}
+	}
+
+	/** Dump message and stack to StringBuffer. */
+	public static StringBuffer stackToString(Throwable throwable, boolean skipMessage) {
+		if (null == throwable) {
+			return new StringBuffer();
+		}
+		StringWriter buf = new StringWriter();
+		PrintWriter writer = new PrintWriter(buf);
+		if (!skipMessage) {
+			writer.println(throwable.getMessage());
+		}
+		throwable.printStackTrace(writer);
+		try {
+			buf.close();
+		} catch (IOException ioe) {
+		} // ignored
+		return buf.getBuffer();
+	}
+
+	/** @return Throwable input or tail of any wrapped exception chain */
+	public static Throwable unwrapException(Throwable t) {
+		Throwable current = t;
+		Throwable next = null;
+		while (current != null) {
+			// Java 1.2 exceptions that carry exceptions
+			if (current instanceof InvocationTargetException) {
+				next = ((InvocationTargetException) current).getTargetException();
+			} else if (current instanceof ClassNotFoundException) {
+				next = ((ClassNotFoundException) current).getException();
+			} else if (current instanceof ExceptionInInitializerError) {
+				next = ((ExceptionInInitializerError) current).getException();
+			} else if (current instanceof PrivilegedActionException) {
+				next = ((PrivilegedActionException) current).getException();
+			} else if (current instanceof SQLException) {
+				next = ((SQLException) current).getNextException();
+			}
+			// ...getException():
+			// javax.naming.event.NamingExceptionEvent
+			// javax.naming.ldap.UnsolicitedNotification
+			// javax.xml.parsers.FactoryConfigurationError
+			// javax.xml.transform.TransformerFactoryConfigurationError
+			// javax.xml.transform.TransformerException
+			// org.xml.sax.SAXException
+			// 1.4: Throwable.getCause
+			// java.util.logging.LogRecord.getThrown()
+			if (null == next) {
+				break;
+			} else {
+				current = next;
+				next = null;
+			}
+		}
+		return current;
+	}
 
 	/**
-     * Replacement for Arrays.asList(..) which gacks on null
-     * and returns a List in which remove is an unsupported operation.
-     * @param array the Object[] to convert (may be null)
-     * @return the List corresponding to array (never null)
-     */
-    public static List arrayAsList(Object[] array) {
-        if ((null == array) || (1 > array.length)) {
-            return Collections.EMPTY_LIST;
-        }
-        ArrayList list = new ArrayList();
-        list.addAll(Arrays.asList(array));
-        return list;
-    }
-
-       
-
-    
-    /** check if input contains any packages to elide. */
-    public static class StringChecker {
-        static StringChecker TEST_PACKAGES = new StringChecker(new String[] 
-            { "org.aspectj.testing",
-              "org.eclipse.jdt.internal.junit",
-              "junit.framework.",
-              "org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner"
-            }); 
-            
-        String[] infixes;
-
-        /** @param infixes adopted */
-        StringChecker(String[] infixes) {
-            this.infixes = infixes;
-        }
-
-        /** @return true if input contains infixes */
+	 * Replacement for Arrays.asList(..) which gacks on null and returns a List in which remove is an unsupported operation.
+	 * 
+	 * @param array the Object[] to convert (may be null)
+	 * @return the List corresponding to array (never null)
+	 */
+	public static List arrayAsList(Object[] array) {
+		if ((null == array) || (1 > array.length)) {
+			return Collections.EMPTY_LIST;
+		}
+		ArrayList list = new ArrayList();
+		list.addAll(Arrays.asList(array));
+		return list;
+	}
+
+	/** check if input contains any packages to elide. */
+	public static class StringChecker {
+		static StringChecker TEST_PACKAGES = new StringChecker(new String[] { "org.aspectj.testing",
+				"org.eclipse.jdt.internal.junit", "junit.framework.",
+				"org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner" });
+
+		String[] infixes;
+
+		/** @param infixes adopted */
+		StringChecker(String[] infixes) {
+			this.infixes = infixes;
+		}
+
+		/** @return true if input contains infixes */
 		public boolean acceptString(String input) {
-            boolean result = false;
+			boolean result = false;
 			if (!LangUtil.isEmpty(input)) {
-                for (int i = 0; !result && (i < infixes.length); i++) {
-    				result = (-1 != input.indexOf(infixes[i]));
-    			}
-            }
-            return result;
-		}
-    }
-
-    /**
-     * Gen classpath.     
-     * @param bootclasspath
-     * @param classpath
-     * @param classesDir
-     * @param outputJar
-     * @return String combining classpath elements
-     */
-    public static String makeClasspath( // XXX dumb implementation
-        String bootclasspath, 
-        String classpath, 
-        String classesDir, 
-        String outputJar) {
-        StringBuffer sb = new StringBuffer();
-        addIfNotEmpty(bootclasspath, sb, File.pathSeparator);
-        addIfNotEmpty(classpath, sb, File.pathSeparator);
-        if (!addIfNotEmpty(classesDir, sb, File.pathSeparator)) {
-            addIfNotEmpty(outputJar, sb, File.pathSeparator);
-        }
-        return sb.toString();
-    }
-
-    /**
-     * @param input ignored if null
-     * @param sink the StringBuffer to add input to - return false if null
-     * @param delimiter the String to append to input when added - ignored if empty
-     * @return true if input + delimiter added to sink
-     */
-    private static boolean addIfNotEmpty(String input, StringBuffer sink, String delimiter) {
-        if (LangUtil.isEmpty(input) || (null == sink)) {
-            return false;
-        }
-        sink.append(input);
-        if (!LangUtil.isEmpty(delimiter)) {
-            sink.append(delimiter);
-        }
-        return true;
-    }
-
-    
-    /**
-     * Create or initialize a process controller to run 
-     * a process in another VM asynchronously.
-     * @param controller the ProcessController to initialize, if not null
-     * @param classpath
-     * @param mainClass
-     * @param args
-     * @return initialized ProcessController
-     */
-    public static ProcessController makeProcess(
-        ProcessController controller,
-        String classpath, 
-        String mainClass, 
-        String[] args) {
-        File java = LangUtil.getJavaExecutable();
-        ArrayList cmd = new ArrayList();
-        cmd.add(java.getAbsolutePath());
-        cmd.add("-classpath");
-        cmd.add(classpath);
-        cmd.add(mainClass);
-        if (!LangUtil.isEmpty(args)) {
-            cmd.addAll(Arrays.asList(args));
-        }
-        String[] command = (String[]) cmd.toArray(new String[0]);
-        if (null == controller) {
-            controller = new ProcessController();
-        }
-        controller.init(command, mainClass);
-        return controller;
-    }
-    
-//    /**
-//     * Create a process to run asynchronously.
-//     * @param controller if not null, initialize this one
-//     * @param command the String[] command to run
-//     * @param controller the ProcessControl for streams and results
-//     */
-//    public static ProcessController makeProcess( // not needed?
-//        ProcessController controller, 
-//        String[] command, 
-//        String label) {
-//        if (null == controller) {
-//            controller = new ProcessController();
-//        }
-//        controller.init(command, label);
-//        return controller;
-//    }
-    
-    /**
-     * Find java executable File path from java.home system property.
-     * @return File associated with the java command, or null if not found.
-     */
-    public static File getJavaExecutable() { 
-        String javaHome = null;
-        File result = null;
-        //java.home
-        // java.class.path
-        // java.ext.dirs
-        try {
-            javaHome = System.getProperty("java.home");
-        } catch (Throwable t) {
-            // ignore
-        }
-        if (null != javaHome) {
-            File binDir = new File(javaHome, "bin");
-            if (binDir.isDirectory() && binDir.canRead()) {
-                String[] execs = new String[] { "java", "java.exe" };
-                for (int i = 0; i < execs.length; i++) {
-                    result = new File(binDir, execs[i]);
-                    if (result.canRead()) {
-                        break;
-                    }
-                }
-            }
-        }
-        return result;
-    } 
-    
-    /**
-     * Sleep for a particular period (in milliseconds).
-     * @param time the long time in milliseconds to sleep
-     * @return true if delay succeeded, false if interrupted 100 times
-     */
-    public static boolean sleep(long milliseconds) {
-        if (milliseconds == 0) {
-            return true;
-        } else if (milliseconds < 0) {
-            throw new IllegalArgumentException("negative: " + milliseconds);
-        }
-        return sleepUntil(milliseconds + System.currentTimeMillis());
-    }
-    
-    /**
-     * Sleep until a particular time.
-     * @param time the long time in milliseconds to sleep until
-     * @return true if delay succeeded, false if interrupted 100 times
-     */
-    public static boolean sleepUntil(long time) {
-        if (time == 0) {
-            return true;
-        } else if (time < 0) {
-            throw new IllegalArgumentException("negative: " + time);
-        }
-//        final Thread thread = Thread.currentThread();
-        long curTime = System.currentTimeMillis();
-        for (int i = 0; (i < 100) && (curTime < time); i++) {
-            try {
-                Thread.sleep(time-curTime);            
-            } catch (InterruptedException e) {
-                // ignore
-            }
-            curTime = System.currentTimeMillis();
-        }
-        return (curTime >= time);
-    }  
-      
-    /**
-     * Handle an external process asynchrously.
-     * <code>start()</code> launches a main thread to wait for the process 
-     * and pipes streams (in child threads) through to the corresponding
-     * streams (e.g., the process System.err to this System.err).
-     * This can complete normally, by exception, or on demand by a client.
-     * Clients can implement <code>doCompleting(..)</code> to get notice
-     * when the process completes.
-     * <p>The following sample code creates a process with a completion 
-     * callback starts it, and some time later retries the process.
-     * <pre>
-     * LangUtil.ProcessController controller 
-     *   = new LangUtil.ProcessController() {
-     *   protected void doCompleting(LangUtil.ProcessController.Thrown thrown, 
-     *                               int result) {
-     *      // signal result 
-     *   }
-     * };
-     * controller.init(new String[] { "java", "-version" }, "java version");
-     * controller.start();
-     * // some time later...
-     * // retry...
-     * if (!controller.completed()) {
-     *     controller.stop();
-     *     controller.reinit();
-     *     controller.start();
-     * }
-     * </pre>
-     * <u>warning</u>: Currently this does not close the input or output
-     * streams, since doing so prevents their use later.
-     */
-    public static class ProcessController {
-        /*
-         * XXX not verified thread-safe, but should be.  Known problems:
-         * - user stops (completed = true) then exception thrown
-         *   from destroying process (stop() expects !completed)
-         * ...
-         */
-        private String[] command;
-        private String[] envp;
-        private String label;
-        
-        private boolean init;
-        private boolean started;
-        private boolean completed;
-        /** if true, stopped by user when not completed */
-        private boolean userStopped;
-
-        private Process process;
-        private FileUtil.Pipe errStream;
-        private FileUtil.Pipe outStream;
-        private FileUtil.Pipe inStream;
-        private ByteArrayOutputStream errSnoop;
-        private ByteArrayOutputStream outSnoop;
-
-        private int result;
-        private Thrown thrown;     
-        
-        public ProcessController() {
-        }
-        
-        /**
-         * Permit re-running using the same command
-         * if this is not started or if completed.
-         * Can also call this when done with results to release 
-         * references associated with results
-         * (e.g., stack traces).
-         */
-        public final void reinit() {
-            if (!init) {
-                throw new IllegalStateException("must init(..) before reinit()");
-            }
-            if (started && !completed) {
-                throw new IllegalStateException("not completed - do stop()");
-            }
-            // init everything but command and label
-            started = false;
-            completed = false;
-            result = Integer.MIN_VALUE;
-            thrown = null;
-            process = null;
-            errStream = null;
-            outStream = null;
-            inStream = null;
-        }
-
-        public final void init(
-                String classpath, 
-                String mainClass, 
-                String[] args) {
-            init(LangUtil.getJavaExecutable(),
-                    classpath, mainClass, args);
-        }
-
-        public final void init(File java,
-                String classpath, 
-                String mainClass, 
-                String[] args) {
-            LangUtil.throwIaxIfNull(java, "java");
-            LangUtil.throwIaxIfNull(mainClass, "mainClass");
-            LangUtil.throwIaxIfNull(args, "args");
-            ArrayList cmd = new ArrayList();
-            cmd.add(java.getAbsolutePath());
-            cmd.add("-classpath");
-            cmd.add(classpath);
-            cmd.add(mainClass);
-            if (!LangUtil.isEmpty(args)) {
-                cmd.addAll(Arrays.asList(args));
-            }
-            init((String[]) cmd.toArray(new String[0]), mainClass);
-        }        
-        
-        public final void init(String[] command, String label) {
-            this.command = (String[]) LangUtil.safeCopy(command, new String[0]);
-            if (1 > this.command.length) {
-                throw new IllegalArgumentException("empty command");
-            }
-            this.label = LangUtil.isEmpty(label) ? command[0] : label;
-            this.init = true;
-            reinit();
-        }
-
-        public final void setEnvp(String[] envp) {
-            this.envp = (String[]) LangUtil.safeCopy(envp, new String[0]);
-            if (1 > this.envp.length) {
-                throw new IllegalArgumentException("empty envp");
-            }
-        }
-
-        public final void setErrSnoop(ByteArrayOutputStream snoop) {        
-            errSnoop = snoop;
-            if (null != errStream) {
-                errStream.setSnoop(errSnoop);
-            }
-        }
-        
-        public final void setOutSnoop(ByteArrayOutputStream snoop) {        
-            outSnoop = snoop;
-            if (null != outStream) {
-                outStream.setSnoop(outSnoop);
-            }
-        }
-
-        /** 
-         * Start running the process and pipes asynchronously.
-         * @return Thread started or null if unable to start thread
-         *         (results available via <code>getThrown()</code>, etc.) 
-         */
-        public final Thread start() {
-            if (!init) { 
-                throw new IllegalStateException("not initialized");
-            }
-            synchronized (this) {
-                if (started) {
-                    throw new IllegalStateException("already started");
-                }
-                started = true;
-            }
-            try {
-                process = Runtime.getRuntime().exec(command);
-            } catch (IOException e) {
-                stop(e, Integer.MIN_VALUE);
-                return null;
-            }
-            errStream = new FileUtil.Pipe(process.getErrorStream(), System.err);
-            if (null != errSnoop) {
-                errStream.setSnoop(errSnoop);
-            }
-            outStream = new FileUtil.Pipe(process.getInputStream(), System.out);
-            if (null != outSnoop) {
-                outStream.setSnoop(outSnoop);
-            }
-            inStream = new FileUtil.Pipe(System.in, process.getOutputStream());
-            // start 4 threads, process & pipes for in, err, out
-            Runnable processRunner = new Runnable() {
-                public void run() {
-                    Throwable thrown = null;
-                    int result = Integer.MIN_VALUE;
-                    try {
-                        // pipe threads are children
-                        new Thread(errStream).start();
-                        new Thread(outStream).start();
-                        new Thread(inStream).start();
-                        process.waitFor();
-                        result = process.exitValue();
-                    } catch (Throwable e) {
-                        thrown = e;
-                    } finally {
-                        stop(thrown, result);
-                    }
-                }
-            };
-            Thread result = new Thread(processRunner, label);
-            result.start();
-            return result;
-        }
-
-        /** 
-         * Destroy any process, stop any pipes.
-         * This waits for the pipes to clear (reading until
-         * no more input is available), but does not wait
-         * for the input stream for the pipe to close
-         * (i.e., not waiting for end-of-file on input stream). 
-         */
-        public final synchronized void stop() {
-            if (completed) {
-                return;
-            }
-            userStopped = true;
-            stop(null, Integer.MIN_VALUE);
-        }
-        
-        public final String[] getCommand() {
-            String[] toCopy = command;
-            if (LangUtil.isEmpty(toCopy)) {
-                return new String[0];
-            }
-            String[] result = new String[toCopy.length];
-            System.arraycopy(toCopy, 0, result, 0, result.length);
-            return result;
-        }
-        
-        public final boolean completed() {
-            return completed;
-        }
-        
-        public final boolean started() {
-            return started;
-        }
-        
-        public final boolean userStopped() {
-            return userStopped;
-        }
-        
-        /**
-         * Get any Throwable thrown.
-         * Note that the process can complete normally (with a valid return
-         * value), at the same time the pipes throw exceptions,
-         * and that this may return some exceptions even if the process
-         * is not complete.
-         * @return null if not complete or 
-         *         Thrown containing exceptions thrown by the process and streams.
-         */
-        public final Thrown getThrown() { // cache this
-            return makeThrown(null);
-        }
-        
-        public final int getResult() {
-            return result;
-        }
-        
-        /** 
-         * Subclasses implement this to get synchronous notice of completion.
-         * All pipes and processes should be complete at this time. 
-         * To get the exceptions thrown for the pipes, use
-         * <code>getThrown()</code>.
-         * If there is an exception, the process completed abruptly
-         * (including side-effects of the user halting the process).
-         * If <code>userStopped()</code> is true, then some client asked
-         * that the process be destroyed using <code>stop()</code>.
-         * Otherwise, the result code should be the result value
-         * returned by the process.
-         * @param thrown same as <code>getThrown().fromProcess</code>.
-         * @param result same as <code>getResult()</code>
-         * @see getThrown()
-         * @see getResult()
-         * @see stop()
-         */
-        protected void doCompleting(Thrown thrown, int result) {
-        }
-
-        /**
-         * Handle termination (on-demand, abrupt, or normal)
-         * by destroying and/or halting process and pipes. 
-         * @param thrown ignored if null
-         * @param result ignored if Integer.MIN_VALUE
-         */
-        private final synchronized void stop(Throwable thrown, int result) {
-            if (completed) {
-                throw new IllegalStateException("already completed");
-            } else if (null != this.thrown) {
-                throw new IllegalStateException("already set thrown: " + thrown);
-            }
-            // assert null == this.thrown
-            this.thrown = makeThrown(thrown);
-            if (null != process) {
-                process.destroy();        
-            }
-            if (null != inStream) {
-                inStream.halt(false, true); // this will block if waiting
-                inStream = null;
-            }
-            if (null != outStream) {
-                outStream.halt(true, true);
-                outStream = null;
-            }
-            if (null != errStream) {
-                errStream.halt(true, true);
-                errStream = null;
-            }
-            if (Integer.MIN_VALUE != result) {
-                this.result = result;
-            }
-            completed = true;
-            doCompleting(this.thrown, result);
-        }
-        
-        /**
-         * Create snapshot of Throwable's thrown.
-         * @param thrown ignored if null or if this.thrown is not null
-         */
-        private final synchronized Thrown makeThrown(Throwable processThrown) {
-            if (null != thrown) {
-                return thrown;
-            }
-            return new Thrown(
-                processThrown,
-                (null == outStream ? null : outStream.getThrown()),
-                (null == errStream ? null : errStream.getThrown()),
-                (null == inStream ? null : inStream.getThrown())
-            );
-        }
-        
-        public static class Thrown {
-            public final Throwable fromProcess; 
-            public final Throwable fromErrPipe; 
-            public final Throwable fromOutPipe; 
-            public final Throwable fromInPipe;
-            /** true only if some Throwable is not null */
-            public final boolean thrown;
-            private Thrown(
-                Throwable fromProcess,
-                Throwable fromOutPipe, 
-                Throwable fromErrPipe, 
-                Throwable fromInPipe) {
-                this.fromProcess = fromProcess;
-                this.fromErrPipe = fromErrPipe;
-                this.fromOutPipe = fromOutPipe;
-                this.fromInPipe = fromInPipe;
-                thrown = ((null != fromProcess)
-                            || (null != fromInPipe)
-                            || (null != fromOutPipe)
-                            || (null != fromErrPipe));
-            }
-            
-            public String toString() {
-                StringBuffer sb = new StringBuffer();
-                append(sb, fromProcess, "process");
-                append(sb, fromOutPipe, " stdout");
-                append(sb, fromErrPipe, " stderr");
-                append(sb, fromInPipe,  "  stdin");
-                if (0 == sb.length()) {
-                    return "Thrown (none)";
-                } else {
-                    return sb.toString();
-                }
-            }
-            private void append(StringBuffer sb, Throwable thrown, String label) {
-                if (null != thrown) {
-                    sb.append("from " + label + ": ");
-                    sb.append(LangUtil.renderExceptionShort(thrown));
-                    sb.append(LangUtil.EOL);
-                }
-            }
-        } // class Thrown
-    }
+				for (int i = 0; !result && (i < infixes.length); i++) {
+					result = (-1 != input.indexOf(infixes[i]));
+				}
+			}
+			return result;
+		}
+	}
 
-}
+	/**
+	 * Gen classpath.
+	 * 
+	 * @param bootclasspath
+	 * @param classpath
+	 * @param classesDir
+	 * @param outputJar
+	 * @return String combining classpath elements
+	 */
+	public static String makeClasspath( // XXX dumb implementation
+			String bootclasspath, String classpath, String classesDir, String outputJar) {
+		StringBuffer sb = new StringBuffer();
+		addIfNotEmpty(bootclasspath, sb, File.pathSeparator);
+		addIfNotEmpty(classpath, sb, File.pathSeparator);
+		if (!addIfNotEmpty(classesDir, sb, File.pathSeparator)) {
+			addIfNotEmpty(outputJar, sb, File.pathSeparator);
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * @param input ignored if null
+	 * @param sink the StringBuffer to add input to - return false if null
+	 * @param delimiter the String to append to input when added - ignored if empty
+	 * @return true if input + delimiter added to sink
+	 */
+	private static boolean addIfNotEmpty(String input, StringBuffer sink, String delimiter) {
+		if (LangUtil.isEmpty(input) || (null == sink)) {
+			return false;
+		}
+		sink.append(input);
+		if (!LangUtil.isEmpty(delimiter)) {
+			sink.append(delimiter);
+		}
+		return true;
+	}
+
+	/**
+	 * Create or initialize a process controller to run a process in another VM asynchronously.
+	 * 
+	 * @param controller the ProcessController to initialize, if not null
+	 * @param classpath
+	 * @param mainClass
+	 * @param args
+	 * @return initialized ProcessController
+	 */
+	public static ProcessController makeProcess(ProcessController controller, String classpath, String mainClass, String[] args) {
+		File java = LangUtil.getJavaExecutable();
+		ArrayList cmd = new ArrayList();
+		cmd.add(java.getAbsolutePath());
+		cmd.add("-classpath");
+		cmd.add(classpath);
+		cmd.add(mainClass);
+		if (!LangUtil.isEmpty(args)) {
+			cmd.addAll(Arrays.asList(args));
+		}
+		String[] command = (String[]) cmd.toArray(new String[0]);
+		if (null == controller) {
+			controller = new ProcessController();
+		}
+		controller.init(command, mainClass);
+		return controller;
+	}
+
+	// /**
+	// * Create a process to run asynchronously.
+	// * @param controller if not null, initialize this one
+	// * @param command the String[] command to run
+	// * @param controller the ProcessControl for streams and results
+	// */
+	// public static ProcessController makeProcess( // not needed?
+	// ProcessController controller,
+	// String[] command,
+	// String label) {
+	// if (null == controller) {
+	// controller = new ProcessController();
+	// }
+	// controller.init(command, label);
+	// return controller;
+	// }
+
+	/**
+	 * Find java executable File path from java.home system property.
+	 * 
+	 * @return File associated with the java command, or null if not found.
+	 */
+	public static File getJavaExecutable() {
+		String javaHome = null;
+		File result = null;
+		// java.home
+		// java.class.path
+		// java.ext.dirs
+		try {
+			javaHome = System.getProperty("java.home");
+		} catch (Throwable t) {
+			// ignore
+		}
+		if (null != javaHome) {
+			File binDir = new File(javaHome, "bin");
+			if (binDir.isDirectory() && binDir.canRead()) {
+				String[] execs = new String[] { "java", "java.exe" };
+				for (int i = 0; i < execs.length; i++) {
+					result = new File(binDir, execs[i]);
+					if (result.canRead()) {
+						break;
+					}
+				}
+			}
+		}
+		return result;
+	}
 
+	/**
+	 * Sleep for a particular period (in milliseconds).
+	 * 
+	 * @param time the long time in milliseconds to sleep
+	 * @return true if delay succeeded, false if interrupted 100 times
+	 */
+	public static boolean sleep(long milliseconds) {
+		if (milliseconds == 0) {
+			return true;
+		} else if (milliseconds < 0) {
+			throw new IllegalArgumentException("negative: " + milliseconds);
+		}
+		return sleepUntil(milliseconds + System.currentTimeMillis());
+	}
+
+	/**
+	 * Sleep until a particular time.
+	 * 
+	 * @param time the long time in milliseconds to sleep until
+	 * @return true if delay succeeded, false if interrupted 100 times
+	 */
+	public static boolean sleepUntil(long time) {
+		if (time == 0) {
+			return true;
+		} else if (time < 0) {
+			throw new IllegalArgumentException("negative: " + time);
+		}
+		// final Thread thread = Thread.currentThread();
+		long curTime = System.currentTimeMillis();
+		for (int i = 0; (i < 100) && (curTime < time); i++) {
+			try {
+				Thread.sleep(time - curTime);
+			} catch (InterruptedException e) {
+				// ignore
+			}
+			curTime = System.currentTimeMillis();
+		}
+		return (curTime >= time);
+	}
+
+	/**
+	 * Handle an external process asynchrously. <code>start()</code> launches a main thread to wait for the process and pipes
+	 * streams (in child threads) through to the corresponding streams (e.g., the process System.err to this System.err). This can
+	 * complete normally, by exception, or on demand by a client. Clients can implement <code>doCompleting(..)</code> to get notice
+	 * when the process completes.
+	 * <p>
+	 * The following sample code creates a process with a completion callback starts it, and some time later retries the process.
+	 * 
+	 * <pre>
+	 * LangUtil.ProcessController controller = new LangUtil.ProcessController() {
+	 * 	protected void doCompleting(LangUtil.ProcessController.Thrown thrown, int result) {
+	 * 		// signal result 
+	 * 	}
+	 * };
+	 * controller.init(new String[] { &quot;java&quot;, &quot;-version&quot; }, &quot;java version&quot;);
+	 * controller.start();
+	 * // some time later...
+	 * // retry...
+	 * if (!controller.completed()) {
+	 * 	controller.stop();
+	 * 	controller.reinit();
+	 * 	controller.start();
+	 * }
+	 * </pre>
+	 * 
+	 * <u>warning</u>: Currently this does not close the input or output streams, since doing so prevents their use later.
+	 */
+	public static class ProcessController {
+		/*
+		 * XXX not verified thread-safe, but should be. Known problems: - user stops (completed = true) then exception thrown from
+		 * destroying process (stop() expects !completed) ...
+		 */
+		private String[] command;
+		private String[] envp;
+		private String label;
+
+		private boolean init;
+		private boolean started;
+		private boolean completed;
+		/** if true, stopped by user when not completed */
+		private boolean userStopped;
+
+		private Process process;
+		private FileUtil.Pipe errStream;
+		private FileUtil.Pipe outStream;
+		private FileUtil.Pipe inStream;
+		private ByteArrayOutputStream errSnoop;
+		private ByteArrayOutputStream outSnoop;
+
+		private int result;
+		private Thrown thrown;
+
+		public ProcessController() {
+		}
+
+		/**
+		 * Permit re-running using the same command if this is not started or if completed. Can also call this when done with
+		 * results to release references associated with results (e.g., stack traces).
+		 */
+		public final void reinit() {
+			if (!init) {
+				throw new IllegalStateException("must init(..) before reinit()");
+			}
+			if (started && !completed) {
+				throw new IllegalStateException("not completed - do stop()");
+			}
+			// init everything but command and label
+			started = false;
+			completed = false;
+			result = Integer.MIN_VALUE;
+			thrown = null;
+			process = null;
+			errStream = null;
+			outStream = null;
+			inStream = null;
+		}
+
+		public final void init(String classpath, String mainClass, String[] args) {
+			init(LangUtil.getJavaExecutable(), classpath, mainClass, args);
+		}
+
+		public final void init(File java, String classpath, String mainClass, String[] args) {
+			LangUtil.throwIaxIfNull(java, "java");
+			LangUtil.throwIaxIfNull(mainClass, "mainClass");
+			LangUtil.throwIaxIfNull(args, "args");
+			ArrayList cmd = new ArrayList();
+			cmd.add(java.getAbsolutePath());
+			cmd.add("-classpath");
+			cmd.add(classpath);
+			cmd.add(mainClass);
+			if (!LangUtil.isEmpty(args)) {
+				cmd.addAll(Arrays.asList(args));
+			}
+			init((String[]) cmd.toArray(new String[0]), mainClass);
+		}
+
+		public final void init(String[] command, String label) {
+			this.command = (String[]) LangUtil.safeCopy(command, new String[0]);
+			if (1 > this.command.length) {
+				throw new IllegalArgumentException("empty command");
+			}
+			this.label = LangUtil.isEmpty(label) ? command[0] : label;
+			this.init = true;
+			reinit();
+		}
+
+		public final void setEnvp(String[] envp) {
+			this.envp = (String[]) LangUtil.safeCopy(envp, new String[0]);
+			if (1 > this.envp.length) {
+				throw new IllegalArgumentException("empty envp");
+			}
+		}
+
+		public final void setErrSnoop(ByteArrayOutputStream snoop) {
+			errSnoop = snoop;
+			if (null != errStream) {
+				errStream.setSnoop(errSnoop);
+			}
+		}
 
+		public final void setOutSnoop(ByteArrayOutputStream snoop) {
+			outSnoop = snoop;
+			if (null != outStream) {
+				outStream.setSnoop(outSnoop);
+			}
+		}
+
+		/**
+		 * Start running the process and pipes asynchronously.
+		 * 
+		 * @return Thread started or null if unable to start thread (results available via <code>getThrown()</code>, etc.)
+		 */
+		public final Thread start() {
+			if (!init) {
+				throw new IllegalStateException("not initialized");
+			}
+			synchronized (this) {
+				if (started) {
+					throw new IllegalStateException("already started");
+				}
+				started = true;
+			}
+			try {
+				process = Runtime.getRuntime().exec(command);
+			} catch (IOException e) {
+				stop(e, Integer.MIN_VALUE);
+				return null;
+			}
+			errStream = new FileUtil.Pipe(process.getErrorStream(), System.err);
+			if (null != errSnoop) {
+				errStream.setSnoop(errSnoop);
+			}
+			outStream = new FileUtil.Pipe(process.getInputStream(), System.out);
+			if (null != outSnoop) {
+				outStream.setSnoop(outSnoop);
+			}
+			inStream = new FileUtil.Pipe(System.in, process.getOutputStream());
+			// start 4 threads, process & pipes for in, err, out
+			Runnable processRunner = new Runnable() {
+				public void run() {
+					Throwable thrown = null;
+					int result = Integer.MIN_VALUE;
+					try {
+						// pipe threads are children
+						new Thread(errStream).start();
+						new Thread(outStream).start();
+						new Thread(inStream).start();
+						process.waitFor();
+						result = process.exitValue();
+					} catch (Throwable e) {
+						thrown = e;
+					} finally {
+						stop(thrown, result);
+					}
+				}
+			};
+			Thread result = new Thread(processRunner, label);
+			result.start();
+			return result;
+		}
+
+		/**
+		 * Destroy any process, stop any pipes. This waits for the pipes to clear (reading until no more input is available), but
+		 * does not wait for the input stream for the pipe to close (i.e., not waiting for end-of-file on input stream).
+		 */
+		public final synchronized void stop() {
+			if (completed) {
+				return;
+			}
+			userStopped = true;
+			stop(null, Integer.MIN_VALUE);
+		}
+
+		public final String[] getCommand() {
+			String[] toCopy = command;
+			if (LangUtil.isEmpty(toCopy)) {
+				return new String[0];
+			}
+			String[] result = new String[toCopy.length];
+			System.arraycopy(toCopy, 0, result, 0, result.length);
+			return result;
+		}
+
+		public final boolean completed() {
+			return completed;
+		}
+
+		public final boolean started() {
+			return started;
+		}
+
+		public final boolean userStopped() {
+			return userStopped;
+		}
+
+		/**
+		 * Get any Throwable thrown. Note that the process can complete normally (with a valid return value), at the same time the
+		 * pipes throw exceptions, and that this may return some exceptions even if the process is not complete.
+		 * 
+		 * @return null if not complete or Thrown containing exceptions thrown by the process and streams.
+		 */
+		public final Thrown getThrown() { // cache this
+			return makeThrown(null);
+		}
+
+		public final int getResult() {
+			return result;
+		}
+
+		/**
+		 * Subclasses implement this to get synchronous notice of completion. All pipes and processes should be complete at this
+		 * time. To get the exceptions thrown for the pipes, use <code>getThrown()</code>. If there is an exception, the process
+		 * completed abruptly (including side-effects of the user halting the process). If <code>userStopped()</code> is true, then
+		 * some client asked that the process be destroyed using <code>stop()</code>. Otherwise, the result code should be the
+		 * result value returned by the process.
+		 * 
+		 * @param thrown same as <code>getThrown().fromProcess</code>.
+		 * @param result same as <code>getResult()</code>
+		 * @see getThrown()
+		 * @see getResult()
+		 * @see stop()
+		 */
+		protected void doCompleting(Thrown thrown, int result) {
+		}
+
+		/**
+		 * Handle termination (on-demand, abrupt, or normal) by destroying and/or halting process and pipes.
+		 * 
+		 * @param thrown ignored if null
+		 * @param result ignored if Integer.MIN_VALUE
+		 */
+		private final synchronized void stop(Throwable thrown, int result) {
+			if (completed) {
+				throw new IllegalStateException("already completed");
+			} else if (null != this.thrown) {
+				throw new IllegalStateException("already set thrown: " + thrown);
+			}
+			// assert null == this.thrown
+			this.thrown = makeThrown(thrown);
+			if (null != process) {
+				process.destroy();
+			}
+			if (null != inStream) {
+				inStream.halt(false, true); // this will block if waiting
+				inStream = null;
+			}
+			if (null != outStream) {
+				outStream.halt(true, true);
+				outStream = null;
+			}
+			if (null != errStream) {
+				errStream.halt(true, true);
+				errStream = null;
+			}
+			if (Integer.MIN_VALUE != result) {
+				this.result = result;
+			}
+			completed = true;
+			doCompleting(this.thrown, result);
+		}
+
+		/**
+		 * Create snapshot of Throwable's thrown.
+		 * 
+		 * @param thrown ignored if null or if this.thrown is not null
+		 */
+		private final synchronized Thrown makeThrown(Throwable processThrown) {
+			if (null != thrown) {
+				return thrown;
+			}
+			return new Thrown(processThrown, (null == outStream ? null : outStream.getThrown()), (null == errStream ? null
+					: errStream.getThrown()), (null == inStream ? null : inStream.getThrown()));
+		}
+
+		public static class Thrown {
+			public final Throwable fromProcess;
+			public final Throwable fromErrPipe;
+			public final Throwable fromOutPipe;
+			public final Throwable fromInPipe;
+			/** true only if some Throwable is not null */
+			public final boolean thrown;
+
+			private Thrown(Throwable fromProcess, Throwable fromOutPipe, Throwable fromErrPipe, Throwable fromInPipe) {
+				this.fromProcess = fromProcess;
+				this.fromErrPipe = fromErrPipe;
+				this.fromOutPipe = fromOutPipe;
+				this.fromInPipe = fromInPipe;
+				thrown = ((null != fromProcess) || (null != fromInPipe) || (null != fromOutPipe) || (null != fromErrPipe));
+			}
+
+			public String toString() {
+				StringBuffer sb = new StringBuffer();
+				append(sb, fromProcess, "process");
+				append(sb, fromOutPipe, " stdout");
+				append(sb, fromErrPipe, " stderr");
+				append(sb, fromInPipe, "  stdin");
+				if (0 == sb.length()) {
+					return "Thrown (none)";
+				} else {
+					return sb.toString();
+				}
+			}
+
+			private void append(StringBuffer sb, Throwable thrown, String label) {
+				if (null != thrown) {
+					sb.append("from " + label + ": ");
+					sb.append(LangUtil.renderExceptionShort(thrown));
+					sb.append(LangUtil.EOL);
+				}
+			}
+		} // class Thrown
+	}
+
+}