/* File.java -- Class representing a file on disk   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006   Free Software Foundation, Inc.This file is part of GNU Classpath.GNU Classpath is free software; you can redistribute it and/or modifyit under the terms of the GNU General Public License as published bythe Free Software Foundation; either version 2, or (at your option)any later version. GNU Classpath is distributed in the hope that it will be useful, butWITHOUT ANY WARRANTY; without even the implied warranty ofMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNUGeneral Public License for more details.You should have received a copy of the GNU General Public Licensealong with GNU Classpath; see the file COPYING.  If not, write to theFree Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA02110-1301 USA.Linking this library statically or dynamically with other modules ismaking a combined work based on this library.  Thus, the terms andconditions of the GNU General Public License cover the wholecombination.As a special exception, the copyright holders of this library give youpermission to link this library with independent modules to produce anexecutable, regardless of the license terms of these independentmodules, and to copy and distribute the resulting executable underterms of your choice, provided that you also meet, for each linkedindependent module, the terms and conditions of the license of thatmodule.  An independent module is a module which is not derived fromor based on this library.  If you modify this library, you may extendthis exception to your version of the library, but you are notobligated to do so.  If you do not wish to do so, delete thisexception statement from your version. */package java.io;import java.net.MalformedURLException;import java.net.URI;import java.net.URISyntaxException;import java.net.URL;import gnu.classpath.Configuration;/* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3 * "The Java Language Specification", ISBN 0-201-63451-1 * Status:  Complete to version 1.3. *//** * This class represents a file or directory on a local disk.  It provides * facilities for dealing with a variety of systems that use various * types of path separators ("/" versus "\", for example).  It also * contains method useful for creating and deleting files and directories. * * @author Aaron M. Renn (arenn@urbanophile.com) * @author Tom Tromey (tromey@cygnus.com) */public class File implements Serializable, Comparable{  private static final long serialVersionUID = 301077366599181567L;	  // QUERY arguments to access function.  private final static int READ = 0;  private final static int WRITE = 1;  private final static int EXISTS = 2;  // QUERY arguments to stat function.  private final static int DIRECTORY = 0;  private final static int ISFILE = 1;  private final static int ISHIDDEN = 2;  // QUERY arguments to attr function.  private final static int MODIFIED = 0;  private final static int LENGTH = 1;    private final native long attr (int query);  // On OSF1 V5.0, `stat' is a macro.  It is easiest to use the name  // `_stat' instead.  We do the same thing for `_access' just in  // case.  private final native boolean _access (int query);  private final native boolean _stat (int query);  /**   * This is the path separator string for the current host. This field   * contains the value of the <code>file.separator</code> system property.   * An example separator string would be "/" on the GNU system.   */  public static final String separator = System.getProperty("file.separator");  private static final String dupSeparator = separator + separator;  /**   * This is the first character of the file separator string.  On many   * hosts (for example, on the GNU system), this represents the entire    * separator string.  The complete separator string is obtained from the   * <code>file.separator</code>system property.   */  public static final char separatorChar = separator.charAt(0);    /**   * This is the string that is used to separate the host name from the   * path name in paths than include the host name.  It is the value of   * the <code>path.separator</code> system property.   */  public static final String pathSeparator    = System.getProperty("path.separator");    /**   * This is the first character of the string used to separate the host name   * from the path name in paths that include a host.  The separator string   * is taken from the <code>path.separator</code> system property.   */  public static final char pathSeparatorChar = pathSeparator.charAt(0);  static final String tmpdir = System.getProperty("java.io.tmpdir");  static int maxPathLen;  static boolean caseSensitive;    static  {    if (Configuration.INIT_LOAD_LIBRARY)      {        System.loadLibrary("javaio");      }        init_native();  }    // Native function called at class initialization. This should should  // set the maxPathLen and caseSensitive variables.  private static native void init_native();  /**   * This is the path to the file set when the object is created.  It   * may be an absolute or relative path name.   */  private String path;  // We keep a counter for use by createTempFile.  We choose the first  // value randomly to try to avoid clashes with other VMs.  private static long counter = Double.doubleToLongBits (Math.random());  /**   * This method tests whether or not the current thread is allowed to   * to read the file pointed to by this object.  This will be true if and   * and only if 1) the file exists and 2) the <code>SecurityManager</code>   * (if any) allows access to the file via it's <code>checkRead</code>   * method 3) the file is readable.   *   * @return <code>true</code> if reading is allowed,    * <code>false</code> otherwise   *   * @exception SecurityException If the <code>SecurityManager</code>    * does not allow access to the file   */  public boolean canRead()  {    checkRead();    return _access (READ);  }  /**   * This method test whether or not the current thread is allowed to   * write to this object.  This will be true if and only if 1) The   * <code>SecurityManager</code> (if any) allows write access to the   * file and 2) The file exists and 3) The file is writable.  To determine   * whether or not a non-existent file can be created, check the parent   * directory for write access.   *   * @return <code>true</code> if writing is allowed, <code>false</code>    * otherwise   *   * @exception SecurityException If the <code>SecurityManager</code>    * does not allow access to the file   */  public boolean canWrite()  {    checkWrite();    return _access (WRITE);  }    private native boolean performCreate() throws IOException;  /**   * This method creates a new file of zero length with the same name as   * the path of this <code>File</code> object if an only if that file   * does not already exist.   * <p>   * A <code>SecurityManager.checkWrite</code> check is done prior   * to performing this action.   *   * @return <code>true</code> if the file was created, <code>false</code> if   * the file alread existed.   *   * @exception IOException If an I/O error occurs   * @exception SecurityException If the <code>SecurityManager</code> will   * not allow this operation to be performed.   *   * @since 1.2   */  public boolean createNewFile() throws IOException  {    checkWrite();    return performCreate();  }   /*   * This native method handles the actual deleting of the file   */  private native boolean performDelete();  /**   * This method deletes the file represented by this object.  If this file   * is a directory, it must be empty in order for the delete to succeed.   *   * @return <code>true</code> if the file was deleted, <code>false</code>    * otherwise   *   * @exception SecurityException If deleting of the file is not allowed   */  public synchronized boolean delete()  {    SecurityManager s = System.getSecurityManager();        if (s != null)      s.checkDelete(path);        return performDelete();  }  /**   * This method tests two <code>File</code> objects for equality by    * comparing the path of the specified <code>File</code> against the path   * of this object.  The two objects are equal if an only if 1) The   * argument is not null 2) The argument is a <code>File</code> object and   * 3) The path of the <code>File</code>argument is equal to the path   * of this object.   * <p>   * The paths of the files are determined by calling the    * <code>getPath()</code>   * method on each object.   *   * @return <code>true</code> if the two objects are equal,    * <code>false</code> otherwise.   */  public boolean equals(Object obj)  {    if (! (obj instanceof File))      return false;        File other = (File) obj;    if (caseSensitive)      return path.equals(other.path);    else      return path.equalsIgnoreCase(other.path);  }  /**   * This method tests whether or not the file represented by the object   * actually exists on the filesystem.   *   * @return <code>true</code> if the file exists, <code>false</code>otherwise.   *   * @exception SecurityException If reading of the file is not permitted   */  public boolean exists()  {    checkRead();    return _access (EXISTS);  }  /**   * This method initializes a new <code>File</code> object to represent   * a file with the specified path.   *   * @param name The path name of the file   */  public File(String name)  {    path = normalizePath (name);  }  // Remove duplicate and redundant separator characters.  private String normalizePath(String p)  {    // On Windows, convert any '/' to '\'.  This appears to be the same logic    // that Sun's Win32 Java performs.    if (separatorChar == '\\')      {        p = p.replace ('/', '\\');	// We have to special case the "\c:" prefix.	if (p.length() > 2 && p.charAt(0) == '\\' &&	    ((p.charAt(1) >= 'a' && p.charAt(1) <= 'z') ||	    (p.charAt(1) >= 'A' && p.charAt(1) <= 'Z')) &&	    p.charAt(2) == ':')	  p = p.substring(1);      }    int dupIndex = p.indexOf(dupSeparator);    int plen = p.length();    // Special case: permit Windows UNC path prefix.    if (dupSeparator.equals("\\\\") && dupIndex == 0)      dupIndex = p.indexOf(dupSeparator, 1);    if (dupIndex == -1)      {        // Ignore trailing separator (though on Windows "a:\", for        // example, is a valid and minimal path).        if (plen > 1 && p.charAt (plen - 1) == separatorChar)	  {	    if (! (separatorChar == '\\' && plen == 3 && p.charAt (1) == ':'))	      return p.substring (0, plen - 1);	  }	else	  return p;      }        StringBuffer newpath = new StringBuffer(plen);    int last = 0;    while (dupIndex != -1)      {        newpath.append(p.substring(last, dupIndex));	// Ignore the duplicate path characters.	while (p.charAt(dupIndex) == separatorChar)	  {	    dupIndex++;	    if (dupIndex == plen)	      return newpath.toString();	  }	newpath.append(separatorChar);	last = dupIndex;	dupIndex = p.indexOf(dupSeparator, last);      }        // Again, ignore possible trailing separator (except special cases    // like "a:\" on Windows).    int end;    if (plen > 1 && p.charAt (plen - 1) == separatorChar)    {      if (separatorChar == '\\' && plen == 3 && p.charAt (1) == ':')        end = plen;      else        end = plen - 1;    }    else      end = plen;    newpath.append(p.substring(last, end));        return newpath.toString();  }   /**   * This method initializes a new <code>File</code> object to represent   * a file in the specified named directory.  The path name to the file   * will be the directory name plus the separator string plus the file   * name.  If the directory path name ends in the separator string, another   * separator string will still be appended.   *   * @param dirPath The path to the directory the file resides in   * @param name The name of the file   */  public File(String dirPath, String name)  {    if (name == null)      throw new NullPointerException();    if (dirPath != null)      {	if (dirPath.length() > 0)	  {	    // Try to be smart about the number of separator characters.	    if (dirPath.charAt(dirPath.length() - 1) == separatorChar		|| name.length() == 0)	      path = normalizePath(dirPath + name);	    else	      path = normalizePath(dirPath + separatorChar + name);	  }	else	  {	    // If dirPath is empty, use a system dependant	    // default prefix.	    // Note that the leading separators in name have	    // to be chopped off, to prevent them forming	    // a UNC prefix on Windows.	    if (separatorChar == '\\' /* TODO use ON_WINDOWS */)	      {		int skip = 0;		while(name.length() > skip		    && (name.charAt(skip) == separatorChar		    || name.charAt(skip) == '/'))		  {		    skip++;		  }		name = name.substring(skip);	      }	    path = normalizePath(separatorChar + name);	  }      }    else      path = normalizePath(name);  }  /**   * This method initializes a new <code>File</code> object to represent   * a file in the specified directory.  If the <code>directory</code>   * argument is <code>null</code>, the file is assumed to be in the   * current directory as specified by the <code>user.dir</code> system   * property   *   * @param directory The directory this file resides in   * @param name The name of the file   */  public File(File directory, String name)  {    this (directory == null ? null : directory.path, name);  }  /**   * This method initializes a new <code>File</code> object to represent   * a file corresponding to the specified <code>file:</code> protocol URI.   *   * @param uri The uri.   */  public File(URI uri)  {    if (uri == null)	throw new NullPointerException("uri is null");    if (!uri.getScheme().equals("file"))	throw new IllegalArgumentException("invalid uri protocol");    String name = uri.getPath();    if (name == null)      throw new IllegalArgumentException("URI \"" + uri                     + "\" is not hierarchical");    path = normalizePath(name);  }  /**   * This method returns the path of this file as an absolute path name.   * If the path name is already absolute, then it is returned.  Otherwise   * the value returned is the current directory plus the separatory   * string plus the path of the file.  The current directory is determined   * from the <code>user.dir</code> system property.   *   * @return The absolute path of this file   */  public String getAbsolutePath()  {    if (isAbsolute())      return path;    else if (separatorChar == '\\'              && path.length() > 0 && path.charAt (0) == '\\')      {        // On Windows, even if the path starts with a '\\' it is not        // really absolute until we prefix the drive specifier from        // the current working directory to it.        return System.getProperty ("user.dir").substring (0, 2) + path;      }    else if (separatorChar == '\\'              && path.length() > 1 && path.charAt (1) == ':'             && ((path.charAt (0) >= 'a' && path.charAt (0) <= 'z')                 || (path.charAt (0) >= 'A' && path.charAt (0) <= 'Z')))