/* File.java -- Class representing a file on disk   Copyright (C) 1998, 1999, 2000, 2001, 2003 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., 59 Temple Place, Suite 330, Boston, MA02111-1307 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.URISyntaxException;import java.net.URL;import java.net.URI;import gnu.classpath.Configuration;import gnu.java.io.PlatformHelper;import java.util.LinkedList;import java.util.Iterator;/* 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;  /**   * 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");  /**   * 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);  // FIXME: We support only caseSensitive filesystems currently.  static boolean caseSensitive = true;    static  {    if (Configuration.INIT_LOAD_LIBRARY)      {        System.loadLibrary ("io");      }  }    /**   * 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;  /*   * This native method does the actual check of whether or not a file   * is a plain file or not.  It also handles the existence check to   * eliminate the overhead of a call to exists()   */  private native boolean isFileInternal(String path);  /*   * This method does the actual check of whether or not a file is a   * directory or not.  It also handle the existence check to eliminate   * the overhead of a call to exists()   */  private native boolean isDirectoryInternal(String path);  /**   * This native method checks file permissions for reading   */  private synchronized native boolean canReadInternal(String path);  /**   * This native method checks file permissions for writing   */  private synchronized native boolean canWriteInternal(String path);  /**   * 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()  {    // Test for existence. This also does the SecurityManager check    if (!exists())      return false;    return canReadInternal (path);  }  /**   * 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()  {    // We still need to do a SecurityCheck since exists() only checks    // for read access    checkWrite();         // Test for existence.  This is required by the spec    if (!exists())      return false;    if (!isDirectory())      return canWriteInternal (path);    else      try        {          /* If the separator is '\' a DOS-style-filesystem is assumed             and a short name is used, otherwise use a long name.             WARNGIN: some implementation of DOS-style-filesystems also             accept '/' as separator. In that case the following code             will fail.          */          String filename = (separatorChar!='\\')?"test-dir-write":"tst";  	  File test = createTempFile (filename, null, this);  	  return (test != null && test.delete());        }      catch (IOException ioe)        {  	  return false;        }  }  /**   * 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</code>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 createInternal (path);  }   /*   * This native method handles the actual deleting of the file   */  private native boolean deleteInternal(String path);  /**   * 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 deleteInternal(path);  }  /**   * 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 native method does the actual checking of file existence.   */  private native boolean existsInternal(String 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 existsInternal (path);  }  /**   * This method initializes a new <code>File</code> object to represent   * a file with the specified URI.   *   * @param uri The URI of the file   * @author Ito Kazumitsu   */  public File(URI uri)  {    this.path = uri.getPath();    if (this.path == null)      {	throw new IllegalArgumentException();      }  }  /**   * 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 = name;    // Per the spec    if (path == null)      throw new NullPointerException("File name is null");    while (!PlatformHelper.isRootDirectory(path)  	 && PlatformHelper.endWithSeparator(path))        path = PlatformHelper.removeTailSeparator(path);  }   /**   * 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)  {    this (dirPath == null ? (File) null : new File (dirPath), 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)  {    if (name == null)      throw new NullPointerException("filename is null");    String dirPath;        if (directory == null)      dirPath = "";    else if (directory.getPath() == "")      dirPath = PlatformHelper.isWindows ? "\\" : "/";    else      dirPath = directory.getPath();    if (name == null)      throw new NullPointerException("filename is null");    if (PlatformHelper.isRootDirectory(dirPath) || dirPath == "")      path = dirPath + name;    else      path = dirPath + separator + 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;        String dir = System.getProperty ("user.dir");    if (dir == null)      return path;    if (PlatformHelper.endWithSeparator (dir))      return dir + path;    return dir + separator + path;  }  /**   * This method returns a <code>File</code> object representing the   * absolute path of this object.   *   * @return A <code>File</code> with the absolute path of the object.   *   * @since 1.2   */  public File getAbsoluteFile()  {    return new File (getAbsolutePath());  }  /**   * This method returns a canonical representation of the pathname of   * this file.  The actual form of the canonical representation is   * different.  On the GNU system, the canonical form differs from the   * absolute form in that all relative file references to "." and ".."   * are resolved and removed.   * <p>   * Note that this method, unlike the other methods which return path   * names, can throw an IOException.  This is because native method    * might be required in order to resolve the canonical path   *   * @exception IOException If an error occurs   */  public String getCanonicalPath() throws IOException  {    String abspath = getAbsolutePath();    return PlatformHelper.toCanonicalForm(abspath);  }  /**   * This method returns a <code>File</code> object representing the   * canonical path of this object.   *   * @return A <code>File</code> instance representing the canonical path of   * this object.   *   * @exception IOException If an error occurs.   *   * @since 1.2   */  public File getCanonicalFile() throws IOException  {    return new File (getCanonicalPath());  }  /**   * This method returns the name of the file.  This is everything in the