Removed compiler/ directory from repository

dart/compiler/java/com/google/dart/compiler/util/apache/FilenameUtils.java

Index: dart/compiler/java/com/google/dart/compiler/util/apache/FilenameUtils.java
diff --git a/dart/compiler/java/com/google/dart/compiler/util/apache/FilenameUtils.java b/dart/compiler/java/com/google/dart/compiler/util/apache/FilenameUtils.java
deleted file mode 100644
index 31288d32eeb99083357e6f200c0cbd44c5fbb2c1..0000000000000000000000000000000000000000
--- a/dart/compiler/java/com/google/dart/compiler/util/apache/FilenameUtils.java
+++ /dev/null
@@ -1,1405 +0,0 @@
-// Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
-// for details. All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- *      http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.google.dart.compiler.util.apache;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Stack;
-
-/**
- * General filename and filepath manipulation utilities.
- * <p>
- * When dealing with filenames you can hit problems when moving from a Windows
- * based development machine to a Unix based production machine.
- * This class aims to help avoid those problems.
- * <p>
- * <b>NOTE</b>: You may be able to avoid using this class entirely simply by
- * using JDK {@link java.io.File File} objects and the two argument constructor
- * {@link java.io.File#File(java.io.File, java.lang.String) File(File,String)}.
- * <p>
- * Most methods on this class are designed to work the same on both Unix and Windows.
- * Those that don't include 'System', 'Unix' or 'Windows' in their name.
- * <p>
- * Most methods recognise both separators (forward and back), and both
- * sets of prefixes. See the javadoc of each method for details.
- * <p>
- * This class defines six components within a filename
- * (example C:\dev\project\file.txt):
- * <ul>
- * <li>the prefix - C:\</li>
- * <li>the path - dev\project\</li>
- * <li>the full path - C:\dev\project\</li>
- * <li>the name - file.txt</li>
- * <li>the base name - file</li>
- * <li>the extension - txt</li>
- * </ul>
- * Note that this class works best if directory filenames end with a separator.
- * If you omit the last separator, it is impossible to determine if the filename
- * corresponds to a file or a directory. As a result, we have chosen to say
- * it corresponds to a file.
- * <p>
- * This class only supports Unix and Windows style names.
- * Prefixes are matched as follows:
- * <pre>
- * Windows:
- * a\b\c.txt           --> ""          --> relative
- * \a\b\c.txt          --> "\"         --> current drive absolute
- * C:a\b\c.txt         --> "C:"        --> drive relative
- * C:\a\b\c.txt        --> "C:\"       --> absolute
- * \\server\a\b\c.txt  --> "\\server\" --> UNC
- *
- * Unix:
- * a/b/c.txt           --> ""          --> relative
- * /a/b/c.txt          --> "/"         --> absolute
- * ~/a/b/c.txt         --> "~/"        --> current user
- * ~                   --> "~/"        --> current user (slash added)
- * ~user/a/b/c.txt     --> "~user/"    --> named user
- * ~user               --> "~user/"    --> named user (slash added)
- * </pre>
- * Both prefix styles are matched always, irrespective of the machine that you are
- * currently running on.
- * <p>
- * Origin of code: Excalibur, Alexandria, Tomcat, Commons-Utils.
- *
- * @version $Id: FilenameUtils.java 1307462 2012-03-30 15:13:11Z ggregory $
- * @since 1.1
- */
-public class FilenameUtils {
-
-    /**
-     * The extension separator character.
-     * @since 1.4
-     */
-    public static final char EXTENSION_SEPARATOR = '.';
-
-    /**
-     * The extension separator String.
-     * @since 1.4
-     */
-    public static final String EXTENSION_SEPARATOR_STR = Character.toString(EXTENSION_SEPARATOR);
-
-    /**
-     * The Unix separator character.
-     */
-    private static final char UNIX_SEPARATOR = '/';
-
-    /**
-     * The Windows separator character.
-     */
-    private static final char WINDOWS_SEPARATOR = '\\';
-
-    /**
-     * The system separator character.
-     */
-    private static final char SYSTEM_SEPARATOR = File.separatorChar;
-
-    /**
-     * The separator character that is the opposite of the system separator.
-     */
-    private static final char OTHER_SEPARATOR;
-    static {
-        if (isSystemWindows()) {
-            OTHER_SEPARATOR = UNIX_SEPARATOR;
-        } else {
-            OTHER_SEPARATOR = WINDOWS_SEPARATOR;
-        }
-    }
-
-    /**
-     * Instances should NOT be constructed in standard programming.
-     */
-    public FilenameUtils() {
-        super();
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Determines if Windows file system is in use.
-     * 
-     * @return true if the system is Windows
-     */
-    static boolean isSystemWindows() {
-        return SYSTEM_SEPARATOR == WINDOWS_SEPARATOR;
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Checks if the character is a separator.
-     * 
-     * @param ch  the character to check
-     * @return true if it is a separator character
-     */
-    private static boolean isSeparator(char ch) {
-        return ch == UNIX_SEPARATOR || ch == WINDOWS_SEPARATOR;
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Normalizes a path, removing double and single dot path steps.
-     * <p>
-     * This method normalizes a path to a standard format.
-     * The input may contain separators in either Unix or Windows format.
-     * The output will contain separators in the format of the system.
-     * <p>
-     * A trailing slash will be retained.
-     * A double slash will be merged to a single slash (but UNC names are handled).
-     * A single dot path segment will be removed.
-     * A double dot will cause that path segment and the one before to be removed.
-     * If the double dot has no parent path segment to work with, {@code null}
-     * is returned.
-     * <p>
-     * The output will be the same on both Unix and Windows except
-     * for the separator character.
-     * <pre>
-     * /foo//               -->   /foo/
-     * /foo/./              -->   /foo/
-     * /foo/../bar          -->   /bar
-     * /foo/../bar/         -->   /bar/
-     * /foo/../bar/../baz   -->   /baz
-     * //foo//./bar         -->   /foo/bar
-     * /../                 -->   null
-     * ../foo               -->   null
-     * foo/bar/..           -->   foo/
-     * foo/../../bar        -->   null
-     * foo/../bar           -->   bar
-     * //server/foo/../bar  -->   //server/bar
-     * //server/../bar      -->   null
-     * C:\foo\..\bar        -->   C:\bar
-     * C:\..\bar            -->   null
-     * ~/foo/../bar/        -->   ~/bar/
-     * ~/../bar             -->   null
-     * </pre>
-     * (Note the file separator returned will be correct for Windows/Unix)
-     *
-     * @param filename  the filename to normalize, null returns null
-     * @return the normalized filename, or null if invalid
-     */
-    public static String normalize(String filename) {
-        return doNormalize(filename, SYSTEM_SEPARATOR, true);
-    }
-    /**
-     * Normalizes a path, removing double and single dot path steps.
-     * <p>
-     * This method normalizes a path to a standard format.
-     * The input may contain separators in either Unix or Windows format.
-     * The output will contain separators in the format specified.
-     * <p>
-     * A trailing slash will be retained.
-     * A double slash will be merged to a single slash (but UNC names are handled).
-     * A single dot path segment will be removed.
-     * A double dot will cause that path segment and the one before to be removed.
-     * If the double dot has no parent path segment to work with, {@code null}
-     * is returned.
-     * <p>
-     * The output will be the same on both Unix and Windows except
-     * for the separator character.
-     * <pre>
-     * /foo//               -->   /foo/
-     * /foo/./              -->   /foo/
-     * /foo/../bar          -->   /bar
-     * /foo/../bar/         -->   /bar/
-     * /foo/../bar/../baz   -->   /baz
-     * //foo//./bar         -->   /foo/bar
-     * /../                 -->   null
-     * ../foo               -->   null
-     * foo/bar/..           -->   foo/
-     * foo/../../bar        -->   null
-     * foo/../bar           -->   bar
-     * //server/foo/../bar  -->   //server/bar
-     * //server/../bar      -->   null
-     * C:\foo\..\bar        -->   C:\bar
-     * C:\..\bar            -->   null
-     * ~/foo/../bar/        -->   ~/bar/
-     * ~/../bar             -->   null
-     * </pre>
-     * The output will be the same on both Unix and Windows including
-     * the separator character.
-     *
-     * @param filename  the filename to normalize, null returns null
-     * @param unixSeparator {@code true} if a unix separator should
-     * be used or {@code false} if a windows separator should be used.
-     * @return the normalized filename, or null if invalid
-     * @since 2.0
-     */
-    public static String normalize(String filename, boolean unixSeparator) {
-        char separator = unixSeparator ? UNIX_SEPARATOR : WINDOWS_SEPARATOR;
-        return doNormalize(filename, separator, true);
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Normalizes a path, removing double and single dot path steps,
-     * and removing any final directory separator.
-     * <p>
-     * This method normalizes a path to a standard format.
-     * The input may contain separators in either Unix or Windows format.
-     * The output will contain separators in the format of the system.
-     * <p>
-     * A trailing slash will be removed.
-     * A double slash will be merged to a single slash (but UNC names are handled).
-     * A single dot path segment will be removed.
-     * A double dot will cause that path segment and the one before to be removed.
-     * If the double dot has no parent path segment to work with, {@code null}
-     * is returned.
-     * <p>
-     * The output will be the same on both Unix and Windows except
-     * for the separator character.
-     * <pre>
-     * /foo//               -->   /foo
-     * /foo/./              -->   /foo
-     * /foo/../bar          -->   /bar
-     * /foo/../bar/         -->   /bar
-     * /foo/../bar/../baz   -->   /baz
-     * //foo//./bar         -->   /foo/bar
-     * /../                 -->   null
-     * ../foo               -->   null
-     * foo/bar/..           -->   foo
-     * foo/../../bar        -->   null
-     * foo/../bar           -->   bar
-     * //server/foo/../bar  -->   //server/bar
-     * //server/../bar      -->   null
-     * C:\foo\..\bar        -->   C:\bar
-     * C:\..\bar            -->   null
-     * ~/foo/../bar/        -->   ~/bar
-     * ~/../bar             -->   null
-     * </pre>
-     * (Note the file separator returned will be correct for Windows/Unix)
-     *
-     * @param filename  the filename to normalize, null returns null
-     * @return the normalized filename, or null if invalid
-     */
-    public static String normalizeNoEndSeparator(String filename) {
-        return doNormalize(filename, SYSTEM_SEPARATOR, false);
-    }
-
-    /**
-     * Normalizes a path, removing double and single dot path steps,
-     * and removing any final directory separator.
-     * <p>
-     * This method normalizes a path to a standard format.
-     * The input may contain separators in either Unix or Windows format.
-     * The output will contain separators in the format specified.
-     * <p>
-     * A trailing slash will be removed.
-     * A double slash will be merged to a single slash (but UNC names are handled).
-     * A single dot path segment will be removed.
-     * A double dot will cause that path segment and the one before to be removed.
-     * If the double dot has no parent path segment to work with, {@code null}
-     * is returned.
-     * <p>
-     * The output will be the same on both Unix and Windows including
-     * the separator character.
-     * <pre>
-     * /foo//               -->   /foo
-     * /foo/./              -->   /foo
-     * /foo/../bar          -->   /bar
-     * /foo/../bar/         -->   /bar
-     * /foo/../bar/../baz   -->   /baz
-     * //foo//./bar         -->   /foo/bar
-     * /../                 -->   null
-     * ../foo               -->   null
-     * foo/bar/..           -->   foo
-     * foo/../../bar        -->   null
-     * foo/../bar           -->   bar
-     * //server/foo/../bar  -->   //server/bar
-     * //server/../bar      -->   null
-     * C:\foo\..\bar        -->   C:\bar
-     * C:\..\bar            -->   null
-     * ~/foo/../bar/        -->   ~/bar
-     * ~/../bar             -->   null
-     * </pre>
-     *
-     * @param filename  the filename to normalize, null returns null
-     * @param unixSeparator {@code true} if a unix separator should
-     * be used or {@code false} if a windows separtor should be used.
-     * @return the normalized filename, or null if invalid
-     * @since 2.0
-     */
-    public static String normalizeNoEndSeparator(String filename, boolean unixSeparator) {
-         char separator = unixSeparator ? UNIX_SEPARATOR : WINDOWS_SEPARATOR;
-        return doNormalize(filename, separator, false);
-    }
-
-    /**
-     * Internal method to perform the normalization.
-     *
-     * @param filename  the filename
-     * @param separator The separator character to use
-     * @param keepSeparator  true to keep the final separator
-     * @return the normalized filename
-     */
-    private static String doNormalize(String filename, char separator, boolean keepSeparator) {
-        if (filename == null) {
-            return null;
-        }
-        int size = filename.length();
-        if (size == 0) {
-            return filename;
-        }
-        int prefix = getPrefixLength(filename);
-        if (prefix < 0) {
-            return null;
-        }
-        
-        char[] array = new char[size + 2];  // +1 for possible extra slash, +2 for arraycopy
-        filename.getChars(0, filename.length(), array, 0);
-        
-        // fix separators throughout
-        char otherSeparator = separator == SYSTEM_SEPARATOR ? OTHER_SEPARATOR : SYSTEM_SEPARATOR;
-        for (int i = 0; i < array.length; i++) {
-            if (array[i] == otherSeparator) {
-                array[i] = separator;
-            }
-        }
-        
-        // add extra separator on the end to simplify code below
-        boolean lastIsDirectory = true;
-        if (array[size - 1] != separator) {
-            array[size++] = separator;
-            lastIsDirectory = false;
-        }
-        
-        // adjoining slashes
-        for (int i = prefix + 1; i < size; i++) {
-            if (array[i] == separator && array[i - 1] == separator) {
-                System.arraycopy(array, i, array, i - 1, size - i);
-                size--;
-                i--;
-            }
-        }
-        
-        // dot slash
-        for (int i = prefix + 1; i < size; i++) {
-            if (array[i] == separator && array[i - 1] == '.' &&
-                    (i == prefix + 1 || array[i - 2] == separator)) {
-                if (i == size - 1) {
-                    lastIsDirectory = true;
-                }
-                System.arraycopy(array, i + 1, array, i - 1, size - i);
-                size -=2;
-                i--;
-            }
-        }
-        
-        // double dot slash
-        outer:
-        for (int i = prefix + 2; i < size; i++) {
-            if (array[i] == separator && array[i - 1] == '.' && array[i - 2] == '.' &&
-                    (i == prefix + 2 || array[i - 3] == separator)) {
-                if (i == prefix + 2) {
-                    return null;
-                }
-                if (i == size - 1) {
-                    lastIsDirectory = true;
-                }
-                int j;
-                for (j = i - 4 ; j >= prefix; j--) {
-                    if (array[j] == separator) {
-                        // remove b/../ from a/b/../c
-                        System.arraycopy(array, i + 1, array, j + 1, size - i);
-                        size -= i - j;
-                        i = j + 1;
-                        continue outer;
-                    }
-                }
-                // remove a/../ from a/../c
-                System.arraycopy(array, i + 1, array, prefix, size - i);
-                size -= i + 1 - prefix;
-                i = prefix + 1;
-            }
-        }
-        
-        if (size <= 0) {  // should never be less than 0
-            return "";
-        }
-        if (size <= prefix) {  // should never be less than prefix
-            return new String(array, 0, size);
-        }
-        if (lastIsDirectory && keepSeparator) {
-            return new String(array, 0, size);  // keep trailing separator
-        }
-        return new String(array, 0, size - 1);  // lose trailing separator
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Concatenates a filename to a base path using normal command line style rules.
-     * <p>
-     * The effect is equivalent to resultant directory after changing
-     * directory to the first argument, followed by changing directory to
-     * the second argument.
-     * <p>
-     * The first argument is the base path, the second is the path to concatenate.
-     * The returned path is always normalized via {@link #normalize(String)},
-     * thus <code>..</code> is handled.
-     * <p>
-     * If <code>pathToAdd</code> is absolute (has an absolute prefix), then
-     * it will be normalized and returned.
-     * Otherwise, the paths will be joined, normalized and returned.
-     * <p>
-     * The output will be the same on both Unix and Windows except
-     * for the separator character.
-     * <pre>
-     * /foo/ + bar          -->   /foo/bar
-     * /foo + bar           -->   /foo/bar
-     * /foo + /bar          -->   /bar
-     * /foo + C:/bar        -->   C:/bar
-     * /foo + C:bar         -->   C:bar (*)
-     * /foo/a/ + ../bar     -->   foo/bar
-     * /foo/ + ../../bar    -->   null
-     * /foo/ + /bar         -->   /bar
-     * /foo/.. + /bar       -->   /bar
-     * /foo + bar/c.txt     -->   /foo/bar/c.txt
-     * /foo/c.txt + bar     -->   /foo/c.txt/bar (!)
-     * </pre>
-     * (*) Note that the Windows relative drive prefix is unreliable when
-     * used with this method.
-     * (!) Note that the first parameter must be a path. If it ends with a name, then
-     * the name will be built into the concatenated path. If this might be a problem,
-     * use {@link #getFullPath(String)} on the base path argument.
-     *
-     * @param basePath  the base path to attach to, always treated as a path
-     * @param fullFilenameToAdd  the filename (or path) to attach to the base
-     * @return the concatenated path, or null if invalid
-     */
-    public static String concat(String basePath, String fullFilenameToAdd) {
-        int prefix = getPrefixLength(fullFilenameToAdd);
-        if (prefix < 0) {
-            return null;
-        }
-        if (prefix > 0) {
-            return normalize(fullFilenameToAdd);
-        }
-        if (basePath == null) {
-            return null;
-        }
-        int len = basePath.length();
-        if (len == 0) {
-            return normalize(fullFilenameToAdd);
-        }
-        char ch = basePath.charAt(len - 1);
-        if (isSeparator(ch)) {
-            return normalize(basePath + fullFilenameToAdd);
-        } else {
-            return normalize(basePath + '/' + fullFilenameToAdd);
-        }
-    }
-
-    /**
-     * Determines whether the {@code parent} directory contains the {@code child} element (a file or directory).
-     * <p>
-     * The files names are expected to be normalized.
-     * </p>
-     * 
-     * Edge cases:
-     * <ul>
-     * <li>A {@code directory} must not be null: if null, throw IllegalArgumentException</li>
-     * <li>A directory does not contain itself: return false</li>
-     * <li>A null child file is not contained in any parent: return false</li>
-     * </ul>
-     * 
-     * @param canonicalParent
-     *            the file to consider as the parent.
-     * @param canonicalChild
-     *            the file to consider as the child.
-     * @return true is the candidate leaf is under by the specified composite. False otherwise.
-     * @throws IOException
-     *             if an IO error occurs while checking the files.
-     * @since 2.2
-     * @see FileUtils#directoryContains(File, File)
-     */
-    public static boolean directoryContains(final String canonicalParent, final String canonicalChild)
-            throws IOException {
-
-        // Fail fast against NullPointerException
-        if (canonicalParent == null) {
-            throw new IllegalArgumentException("Directory must not be null");
-        }
-
-        if (canonicalChild == null) {
-            return false;
-        }
-
-        if (IOCase.SYSTEM.checkEquals(canonicalParent, canonicalChild)) {
-            return false;
-        }
-
-        return IOCase.SYSTEM.checkStartsWith(canonicalChild, canonicalParent);
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Converts all separators to the Unix separator of forward slash.
-     * 
-     * @param path  the path to be changed, null ignored
-     * @return the updated path
-     */
-    public static String separatorsToUnix(String path) {
-        if (path == null || path.indexOf(WINDOWS_SEPARATOR) == -1) {
-            return path;
-        }
-        return path.replace(WINDOWS_SEPARATOR, UNIX_SEPARATOR);
-    }
-
-    /**
-     * Converts all separators to the Windows separator of backslash.
-     * 
-     * @param path  the path to be changed, null ignored
-     * @return the updated path
-     */
-    public static String separatorsToWindows(String path) {
-        if (path == null || path.indexOf(UNIX_SEPARATOR) == -1) {
-            return path;
-        }
-        return path.replace(UNIX_SEPARATOR, WINDOWS_SEPARATOR);
-    }
-
-    /**
-     * Converts all separators to the system separator.
-     * 
-     * @param path  the path to be changed, null ignored
-     * @return the updated path
-     */
-    public static String separatorsToSystem(String path) {
-        if (path == null) {
-            return null;
-        }
-        if (isSystemWindows()) {
-            return separatorsToWindows(path);
-        } else {
-            return separatorsToUnix(path);
-        }
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Returns the length of the filename prefix, such as <code>C:/</code> or <code>~/</code>.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * <p>
-     * The prefix length includes the first slash in the full filename
-     * if applicable. Thus, it is possible that the length returned is greater
-     * than the length of the input string.
-     * <pre>
-     * Windows:
-     * a\b\c.txt           --> ""          --> relative
-     * \a\b\c.txt          --> "\"         --> current drive absolute
-     * C:a\b\c.txt         --> "C:"        --> drive relative
-     * C:\a\b\c.txt        --> "C:\"       --> absolute
-     * \\server\a\b\c.txt  --> "\\server\" --> UNC
-     *
-     * Unix:
-     * a/b/c.txt           --> ""          --> relative
-     * /a/b/c.txt          --> "/"         --> absolute
-     * ~/a/b/c.txt         --> "~/"        --> current user
-     * ~                   --> "~/"        --> current user (slash added)
-     * ~user/a/b/c.txt     --> "~user/"    --> named user
-     * ~user               --> "~user/"    --> named user (slash added)
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     * ie. both Unix and Windows prefixes are matched regardless.
-     *
-     * @param filename  the filename to find the prefix in, null returns -1
-     * @return the length of the prefix, -1 if invalid or null
-     */
-    public static int getPrefixLength(String filename) {
-        if (filename == null) {
-            return -1;
-        }
-        int len = filename.length();
-        if (len == 0) {
-            return 0;
-        }
-        char ch0 = filename.charAt(0);
-        if (ch0 == ':') {
-            return -1;
-        }
-        if (len == 1) {
-            if (ch0 == '~') {
-                return 2;  // return a length greater than the input
-            }
-            return isSeparator(ch0) ? 1 : 0;
-        } else {
-            if (ch0 == '~') {
-                int posUnix = filename.indexOf(UNIX_SEPARATOR, 1);
-                int posWin = filename.indexOf(WINDOWS_SEPARATOR, 1);
-                if (posUnix == -1 && posWin == -1) {
-                    return len + 1;  // return a length greater than the input
-                }
-                posUnix = posUnix == -1 ? posWin : posUnix;
-                posWin = posWin == -1 ? posUnix : posWin;
-                return Math.min(posUnix, posWin) + 1;
-            }
-            char ch1 = filename.charAt(1);
-            if (ch1 == ':') {
-                ch0 = Character.toUpperCase(ch0);
-                if (ch0 >= 'A' && ch0 <= 'Z') {
-                    if (len == 2 || isSeparator(filename.charAt(2)) == false) {
-                        return 2;
-                    }
-                    return 3;
-                }
-                return -1;
-                
-            } else if (isSeparator(ch0) && isSeparator(ch1)) {
-                int posUnix = filename.indexOf(UNIX_SEPARATOR, 2);
-                int posWin = filename.indexOf(WINDOWS_SEPARATOR, 2);
-                if (posUnix == -1 && posWin == -1 || posUnix == 2 || posWin == 2) {
-                    return -1;
-                }
-                posUnix = posUnix == -1 ? posWin : posUnix;
-                posWin = posWin == -1 ? posUnix : posWin;
-                return Math.min(posUnix, posWin) + 1;
-            } else {
-                return isSeparator(ch0) ? 1 : 0;
-            }
-        }
-    }
-
-    /**
-     * Returns the index of the last directory separator character.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The position of the last forward or backslash is returned.
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     * 
-     * @param filename  the filename to find the last path separator in, null returns -1
-     * @return the index of the last separator character, or -1 if there
-     * is no such character
-     */
-    public static int indexOfLastSeparator(String filename) {
-        if (filename == null) {
-            return -1;
-        }
-        int lastUnixPos = filename.lastIndexOf(UNIX_SEPARATOR);
-        int lastWindowsPos = filename.lastIndexOf(WINDOWS_SEPARATOR);
-        return Math.max(lastUnixPos, lastWindowsPos);
-    }
-
-    /**
-     * Returns the index of the last extension separator character, which is a dot.
-     * <p>
-     * This method also checks that there is no directory separator after the last dot.
-     * To do this it uses {@link #indexOfLastSeparator(String)} which will
-     * handle a file in either Unix or Windows format.
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     * 
-     * @param filename  the filename to find the last path separator in, null returns -1
-     * @return the index of the last separator character, or -1 if there
-     * is no such character
-     */
-    public static int indexOfExtension(String filename) {
-        if (filename == null) {
-            return -1;
-        }
-        int extensionPos = filename.lastIndexOf(EXTENSION_SEPARATOR);
-        int lastSeparator = indexOfLastSeparator(filename);
-        return lastSeparator > extensionPos ? -1 : extensionPos;
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Gets the prefix from a full filename, such as <code>C:/</code>
-     * or <code>~/</code>.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The prefix includes the first slash in the full filename where applicable.
-     * <pre>
-     * Windows:
-     * a\b\c.txt           --> ""          --> relative
-     * \a\b\c.txt          --> "\"         --> current drive absolute
-     * C:a\b\c.txt         --> "C:"        --> drive relative
-     * C:\a\b\c.txt        --> "C:\"       --> absolute
-     * \\server\a\b\c.txt  --> "\\server\" --> UNC
-     *
-     * Unix:
-     * a/b/c.txt           --> ""          --> relative
-     * /a/b/c.txt          --> "/"         --> absolute
-     * ~/a/b/c.txt         --> "~/"        --> current user
-     * ~                   --> "~/"        --> current user (slash added)
-     * ~user/a/b/c.txt     --> "~user/"    --> named user
-     * ~user               --> "~user/"    --> named user (slash added)
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     * ie. both Unix and Windows prefixes are matched regardless.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the prefix of the file, null if invalid
-     */
-    public static String getPrefix(String filename) {
-        if (filename == null) {
-            return null;
-        }
-        int len = getPrefixLength(filename);
-        if (len < 0) {
-            return null;
-        }
-        if (len > filename.length()) {
-            return filename + UNIX_SEPARATOR;  // we know this only happens for unix
-        }
-        return filename.substring(0, len);
-    }
-
-    /**
-     * Gets the path from a full filename, which excludes the prefix.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The method is entirely text based, and returns the text before and
-     * including the last forward or backslash.
-     * <pre>
-     * C:\a\b\c.txt --> a\b\
-     * ~/a/b/c.txt  --> a/b/
-     * a.txt        --> ""
-     * a/b/c        --> a/b/
-     * a/b/c/       --> a/b/c/
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     * <p>
-     * This method drops the prefix from the result.
-     * See {@link #getFullPath(String)} for the method that retains the prefix.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the path of the file, an empty string if none exists, null if invalid
-     */
-    public static String getPath(String filename) {
-        return doGetPath(filename, 1);
-    }
-
-    /**
-     * Gets the path from a full filename, which excludes the prefix, and
-     * also excluding the final directory separator.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The method is entirely text based, and returns the text before the
-     * last forward or backslash.
-     * <pre>
-     * C:\a\b\c.txt --> a\b
-     * ~/a/b/c.txt  --> a/b
-     * a.txt        --> ""
-     * a/b/c        --> a/b
-     * a/b/c/       --> a/b/c
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     * <p>
-     * This method drops the prefix from the result.
-     * See {@link #getFullPathNoEndSeparator(String)} for the method that retains the prefix.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the path of the file, an empty string if none exists, null if invalid
-     */
-    public static String getPathNoEndSeparator(String filename) {
-        return doGetPath(filename, 0);
-    }
-
-    /**
-     * Does the work of getting the path.
-     * 
-     * @param filename  the filename
-     * @param separatorAdd  0 to omit the end separator, 1 to return it
-     * @return the path
-     */
-    private static String doGetPath(String filename, int separatorAdd) {
-        if (filename == null) {
-            return null;
-        }
-        int prefix = getPrefixLength(filename);
-        if (prefix < 0) {
-            return null;
-        }
-        int index = indexOfLastSeparator(filename);
-        int endIndex = index+separatorAdd;
-        if (prefix >= filename.length() || index < 0 || prefix >= endIndex) {
-            return "";
-        }
-        return filename.substring(prefix, endIndex);
-    }
-
-    /**
-     * Gets the full path from a full filename, which is the prefix + path.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The method is entirely text based, and returns the text before and
-     * including the last forward or backslash.
-     * <pre>
-     * C:\a\b\c.txt --> C:\a\b\
-     * ~/a/b/c.txt  --> ~/a/b/
-     * a.txt        --> ""
-     * a/b/c        --> a/b/
-     * a/b/c/       --> a/b/c/
-     * C:           --> C:
-     * C:\          --> C:\
-     * ~            --> ~/
-     * ~/           --> ~/
-     * ~user        --> ~user/
-     * ~user/       --> ~user/
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the path of the file, an empty string if none exists, null if invalid
-     */
-    public static String getFullPath(String filename) {
-        return doGetFullPath(filename, true);
-    }
-
-    /**
-     * Gets the full path from a full filename, which is the prefix + path,
-     * and also excluding the final directory separator.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The method is entirely text based, and returns the text before the
-     * last forward or backslash.
-     * <pre>
-     * C:\a\b\c.txt --> C:\a\b
-     * ~/a/b/c.txt  --> ~/a/b
-     * a.txt        --> ""
-     * a/b/c        --> a/b
-     * a/b/c/       --> a/b/c
-     * C:           --> C:
-     * C:\          --> C:\
-     * ~            --> ~
-     * ~/           --> ~
-     * ~user        --> ~user
-     * ~user/       --> ~user
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the path of the file, an empty string if none exists, null if invalid
-     */
-    public static String getFullPathNoEndSeparator(String filename) {
-        return doGetFullPath(filename, false);
-    }
-
-    /**
-     * Does the work of getting the path.
-     * 
-     * @param filename  the filename
-     * @param includeSeparator  true to include the end separator
-     * @return the path
-     */
-    private static String doGetFullPath(String filename, boolean includeSeparator) {
-        if (filename == null) {
-            return null;
-        }
-        int prefix = getPrefixLength(filename);
-        if (prefix < 0) {
-            return null;
-        }
-        if (prefix >= filename.length()) {
-            if (includeSeparator) {
-                return getPrefix(filename);  // add end slash if necessary
-            } else {
-                return filename;
-            }
-        }
-        int index = indexOfLastSeparator(filename);
-        if (index < 0) {
-            return filename.substring(0, prefix);
-        }
-        int end = index + (includeSeparator ?  1 : 0);
-        if (end == 0) {
-            end++;
-        }
-        return filename.substring(0, end);
-    }
-
-    /**
-     * Gets the name minus the path from a full filename.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The text after the last forward or backslash is returned.
-     * <pre>
-     * a/b/c.txt --> c.txt
-     * a.txt     --> a.txt
-     * a/b/c     --> c
-     * a/b/c/    --> ""
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the name of the file without the path, or an empty string if none exists
-     */
-    public static String getName(String filename) {
-        if (filename == null) {
-            return null;
-        }
-        int index = indexOfLastSeparator(filename);
-        return filename.substring(index + 1);
-    }
-
-    /**
-     * Gets the base name, minus the full path and extension, from a full filename.
-     * <p>
-     * This method will handle a file in either Unix or Windows format.
-     * The text after the last forward or backslash and before the last dot is returned.
-     * <pre>
-     * a/b/c.txt --> c
-     * a.txt     --> a
-     * a/b/c     --> c
-     * a/b/c/    --> ""
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the name of the file without the path, or an empty string if none exists
-     */
-    public static String getBaseName(String filename) {
-        return removeExtension(getName(filename));
-    }
-
-    /**
-     * Gets the extension of a filename.
-     * <p>
-     * This method returns the textual part of the filename after the last dot.
-     * There must be no directory separator after the dot.
-     * <pre>
-     * foo.txt      --> "txt"
-     * a/b/c.jpg    --> "jpg"
-     * a/b.txt/c    --> ""
-     * a/b/c        --> ""
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     *
-     * @param filename the filename to retrieve the extension of.
-     * @return the extension of the file or an empty string if none exists or {@code null}
-     * if the filename is {@code null}.
-     */
-    public static String getExtension(String filename) {
-        if (filename == null) {
-            return null;
-        }
-        int index = indexOfExtension(filename);
-        if (index == -1) {
-            return "";
-        } else {
-            return filename.substring(index + 1);
-        }
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Removes the extension from a filename.
-     * <p>
-     * This method returns the textual part of the filename before the last dot.
-     * There must be no directory separator after the dot.
-     * <pre>
-     * foo.txt    --> foo
-     * a\b\c.jpg  --> a\b\c
-     * a\b\c      --> a\b\c
-     * a.b\c      --> a.b\c
-     * </pre>
-     * <p>
-     * The output will be the same irrespective of the machine that the code is running on.
-     *
-     * @param filename  the filename to query, null returns null
-     * @return the filename minus the extension
-     */
-    public static String removeExtension(String filename) {
-        if (filename == null) {
-            return null;
-        }
-        int index = indexOfExtension(filename);
-        if (index == -1) {
-            return filename;
-        } else {
-            return filename.substring(0, index);
-        }
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Checks whether two filenames are equal exactly.
-     * <p>
-     * No processing is performed on the filenames other than comparison,
-     * thus this is merely a null-safe case-sensitive equals.
-     *
-     * @param filename1  the first filename to query, may be null
-     * @param filename2  the second filename to query, may be null
-     * @return true if the filenames are equal, null equals null
-     * @see IOCase#SENSITIVE
-     */
-    public static boolean equals(String filename1, String filename2) {
-        return equals(filename1, filename2, false, IOCase.SENSITIVE);
-    }
-
-    /**
-     * Checks whether two filenames are equal using the case rules of the system.
-     * <p>
-     * No processing is performed on the filenames other than comparison.
-     * The check is case-sensitive on Unix and case-insensitive on Windows.
-     *
-     * @param filename1  the first filename to query, may be null
-     * @param filename2  the second filename to query, may be null
-     * @return true if the filenames are equal, null equals null
-     * @see IOCase#SYSTEM
-     */
-    public static boolean equalsOnSystem(String filename1, String filename2) {
-        return equals(filename1, filename2, false, IOCase.SYSTEM);
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Checks whether two filenames are equal after both have been normalized.
-     * <p>
-     * Both filenames are first passed to {@link #normalize(String)}.
-     * The check is then performed in a case-sensitive manner.
-     *
-     * @param filename1  the first filename to query, may be null
-     * @param filename2  the second filename to query, may be null
-     * @return true if the filenames are equal, null equals null
-     * @see IOCase#SENSITIVE
-     */
-    public static boolean equalsNormalized(String filename1, String filename2) {
-        return equals(filename1, filename2, true, IOCase.SENSITIVE);
-    }
-
-    /**
-     * Checks whether two filenames are equal after both have been normalized
-     * and using the case rules of the system.
-     * <p>
-     * Both filenames are first passed to {@link #normalize(String)}.
-     * The check is then performed case-sensitive on Unix and
-     * case-insensitive on Windows.
-     *
-     * @param filename1  the first filename to query, may be null
-     * @param filename2  the second filename to query, may be null
-     * @return true if the filenames are equal, null equals null
-     * @see IOCase#SYSTEM
-     */
-    public static boolean equalsNormalizedOnSystem(String filename1, String filename2) {
-        return equals(filename1, filename2, true, IOCase.SYSTEM);
-    }
-
-    /**
-     * Checks whether two filenames are equal, optionally normalizing and providing
-     * control over the case-sensitivity.
-     *
-     * @param filename1  the first filename to query, may be null
-     * @param filename2  the second filename to query, may be null
-     * @param normalized  whether to normalize the filenames
-     * @param caseSensitivity  what case sensitivity rule to use, null means case-sensitive
-     * @return true if the filenames are equal, null equals null
-     * @since 1.3
-     */
-    public static boolean equals(
-            String filename1, String filename2,
-            boolean normalized, IOCase caseSensitivity) {
-        
-        if (filename1 == null || filename2 == null) {
-            return filename1 == null && filename2 == null;
-        }
-        if (normalized) {
-            filename1 = normalize(filename1);
-            filename2 = normalize(filename2);
-            if (filename1 == null || filename2 == null) {
-                throw new NullPointerException(
-                    "Error normalizing one or both of the file names");
-            }
-        }
-        if (caseSensitivity == null) {
-            caseSensitivity = IOCase.SENSITIVE;
-        }
-        return caseSensitivity.checkEquals(filename1, filename2);
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Checks whether the extension of the filename is that specified.
-     * <p>
-     * This method obtains the extension as the textual part of the filename
-     * after the last dot. There must be no directory separator after the dot.
-     * The extension check is case-sensitive on all platforms.
-     *
-     * @param filename  the filename to query, null returns false
-     * @param extension  the extension to check for, null or empty checks for no extension
-     * @return true if the filename has the specified extension
-     */
-    public static boolean isExtension(String filename, String extension) {
-        if (filename == null) {
-            return false;
-        }
-        if (extension == null || extension.length() == 0) {
-            return indexOfExtension(filename) == -1;
-        }
-        String fileExt = getExtension(filename);
-        return fileExt.equals(extension);
-    }
-
-    /**
-     * Checks whether the extension of the filename is one of those specified.
-     * <p>
-     * This method obtains the extension as the textual part of the filename
-     * after the last dot. There must be no directory separator after the dot.
-     * The extension check is case-sensitive on all platforms.
-     *
-     * @param filename  the filename to query, null returns false
-     * @param extensions  the extensions to check for, null checks for no extension
-     * @return true if the filename is one of the extensions
-     */
-    public static boolean isExtension(String filename, String[] extensions) {
-        if (filename == null) {
-            return false;
-        }
-        if (extensions == null || extensions.length == 0) {
-            return indexOfExtension(filename) == -1;
-        }
-        String fileExt = getExtension(filename);
-        for (String extension : extensions) {
-            if (fileExt.equals(extension)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    /**
-     * Checks whether the extension of the filename is one of those specified.
-     * <p>
-     * This method obtains the extension as the textual part of the filename
-     * after the last dot. There must be no directory separator after the dot.
-     * The extension check is case-sensitive on all platforms.
-     *
-     * @param filename  the filename to query, null returns false
-     * @param extensions  the extensions to check for, null checks for no extension
-     * @return true if the filename is one of the extensions
-     */
-    public static boolean isExtension(String filename, Collection<String> extensions) {
-        if (filename == null) {
-            return false;
-        }
-        if (extensions == null || extensions.isEmpty()) {
-            return indexOfExtension(filename) == -1;
-        }
-        String fileExt = getExtension(filename);
-        for (String extension : extensions) {
-            if (fileExt.equals(extension)) {
-                return true;
-            }
-        }
-        return false;
-    }
-
-    //-----------------------------------------------------------------------
-    /**
-     * Checks a filename to see if it matches the specified wildcard matcher,
-     * always testing case-sensitive.
-     * <p>
-     * The wildcard matcher uses the characters '?' and '*' to represent a
-     * single or multiple (zero or more) wildcard characters.
-     * This is the same as often found on Dos/Unix command lines.
-     * The check is case-sensitive always.
-     * <pre>
-     * wildcardMatch("c.txt", "*.txt")      --> true
-     * wildcardMatch("c.txt", "*.jpg")      --> false
-     * wildcardMatch("a/b/c.txt", "a/b/*")  --> true
-     * wildcardMatch("c.txt", "*.???")      --> true
-     * wildcardMatch("c.txt", "*.????")     --> false
-     * </pre>
-     * N.B. the sequence "*?" does not work properly at present in match strings.
-     * 
-     * @param filename  the filename to match on
-     * @param wildcardMatcher  the wildcard string to match against
-     * @return true if the filename matches the wilcard string
-     * @see IOCase#SENSITIVE
-     */
-    public static boolean wildcardMatch(String filename, String wildcardMatcher) {
-        return wildcardMatch(filename, wildcardMatcher, IOCase.SENSITIVE);
-    }
-
-    /**
-     * Checks a filename to see if it matches the specified wildcard matcher
-     * using the case rules of the system.
-     * <p>
-     * The wildcard matcher uses the characters '?' and '*' to represent a
-     * single or multiple (zero or more) wildcard characters.
-     * This is the same as often found on Dos/Unix command lines.
-     * The check is case-sensitive on Unix and case-insensitive on Windows.
-     * <pre>
-     * wildcardMatch("c.txt", "*.txt")      --> true
-     * wildcardMatch("c.txt", "*.jpg")      --> false
-     * wildcardMatch("a/b/c.txt", "a/b/*")  --> true
-     * wildcardMatch("c.txt", "*.???")      --> true
-     * wildcardMatch("c.txt", "*.????")     --> false
-     * </pre>
-     * N.B. the sequence "*?" does not work properly at present in match strings.
-     * 
-     * @param filename  the filename to match on
-     * @param wildcardMatcher  the wildcard string to match against
-     * @return true if the filename matches the wilcard string
-     * @see IOCase#SYSTEM
-     */
-    public static boolean wildcardMatchOnSystem(String filename, String wildcardMatcher) {
-        return wildcardMatch(filename, wildcardMatcher, IOCase.SYSTEM);
-    }
-
-    /**
-     * Checks a filename to see if it matches the specified wildcard matcher
-     * allowing control over case-sensitivity.
-     * <p>
-     * The wildcard matcher uses the characters '?' and '*' to represent a
-     * single or multiple (zero or more) wildcard characters.
-     * N.B. the sequence "*?" does not work properly at present in match strings.
-     * 
-     * @param filename  the filename to match on
-     * @param wildcardMatcher  the wildcard string to match against
-     * @param caseSensitivity  what case sensitivity rule to use, null means case-sensitive
-     * @return true if the filename matches the wilcard string
-     * @since 1.3
-     */
-    public static boolean wildcardMatch(String filename, String wildcardMatcher, IOCase caseSensitivity) {
-        if (filename == null && wildcardMatcher == null) {
-            return true;
-        }
-        if (filename == null || wildcardMatcher == null) {
-            return false;
-        }
-        if (caseSensitivity == null) {
-            caseSensitivity = IOCase.SENSITIVE;
-        }
-        String[] wcs = splitOnTokens(wildcardMatcher);
-        boolean anyChars = false;
-        int textIdx = 0;
-        int wcsIdx = 0;
-        Stack<int[]> backtrack = new Stack<int[]>();
-        
-        // loop around a backtrack stack, to handle complex * matching
-        do {
-            if (backtrack.size() > 0) {
-                int[] array = backtrack.pop();
-                wcsIdx = array[0];
-                textIdx = array[1];
-                anyChars = true;
-            }
-            
-            // loop whilst tokens and text left to process
-            while (wcsIdx < wcs.length) {
-      
-                if (wcs[wcsIdx].equals("?")) {
-                    // ? so move to next text char
-                    textIdx++;
-                    if (textIdx > filename.length()) {
-                        break;
-                    }
-                    anyChars = false;
-                    
-                } else if (wcs[wcsIdx].equals("*")) {
-                    // set any chars status
-                    anyChars = true;
-                    if (wcsIdx == wcs.length - 1) {
-                        textIdx = filename.length();
-                    }
-                    
-                } else {
-                    // matching text token
-                    if (anyChars) {
-                        // any chars then try to locate text token
-                        textIdx = caseSensitivity.checkIndexOf(filename, textIdx, wcs[wcsIdx]);
-                        if (textIdx == -1) {
-                            // token not found
-                            break;
-                        }
-                        int repeat = caseSensitivity.checkIndexOf(filename, textIdx + 1, wcs[wcsIdx]);
-                        if (repeat >= 0) {
-                            backtrack.push(new int[] {wcsIdx, repeat});
-                        }
-                    } else {
-                        // matching from current position
-                        if (!caseSensitivity.checkRegionMatches(filename, textIdx, wcs[wcsIdx])) {
-                            // couldnt match token
-                            break;
-                        }
-                    }
-      
-                    // matched text token, move text index to end of matched token
-                    textIdx += wcs[wcsIdx].length();
-                    anyChars = false;
-                }
-      
-                wcsIdx++;
-            }
-            
-            // full match
-            if (wcsIdx == wcs.length && textIdx == filename.length()) {
-                return true;
-            }
-            
-        } while (backtrack.size() > 0);
-  
-        return false;
-    }
-
-    /**
-     * Splits a string into a number of tokens.
-     * The text is split by '?' and '*'.
-     * Where multiple '*' occur consecutively they are collapsed into a single '*'.
-     * 
-     * @param text  the text to split
-     * @return the array of tokens, never null
-     */
-    static String[] splitOnTokens(String text) {
-        // used by wildcardMatch
-        // package level so a unit test may run on this
-        
-        if (text.indexOf('?') == -1 && text.indexOf('*') == -1) {
-            return new String[] { text };
-        }
-
-        char[] array = text.toCharArray();
-        ArrayList<String> list = new ArrayList<String>();
-        StringBuilder buffer = new StringBuilder();
-        for (int i = 0; i < array.length; i++) {
-            if (array[i] == '?' || array[i] == '*') {
-                if (buffer.length() != 0) {
-                    list.add(buffer.toString());
-                    buffer.setLength(0);
-                }
-                if (array[i] == '?') {
-                    list.add("?");
-                } else if (list.isEmpty() ||
-                        i > 0 && list.get(list.size() - 1).equals("*") == false) {
-                    list.add("*");
-                }
-            } else {
-                buffer.append(array[i]);
-            }
-        }
-        if (buffer.length() != 0) {
-            list.add(buffer.toString());
-        }
-
-        return list.toArray( new String[ list.size() ] );
-    }
-
-}