| /* VMFile.java -- Class for methods natively accessing files | |
| Copyright (C) 2004, 2006 Free Software Foundation, Inc. | |
| This file is part of GNU Classpath. | |
| GNU Classpath is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published by | |
| the 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, but | |
| WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
| General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with GNU Classpath; see the file COPYING. If not, write to the | |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
| 02110-1301 USA. | |
| Linking this library statically or dynamically with other modules is | |
| making a combined work based on this library. Thus, the terms and | |
| conditions of the GNU General Public License cover the whole | |
| combination. | |
| As a special exception, the copyright holders of this library give you | |
| permission to link this library with independent modules to produce an | |
| executable, regardless of the license terms of these independent | |
| modules, and to copy and distribute the resulting executable under | |
| terms of your choice, provided that you also meet, for each linked | |
| independent module, the terms and conditions of the license of that | |
| module. An independent module is a module which is not derived from | |
| or based on this library. If you modify this library, you may extend | |
| this exception to your version of the library, but you are not | |
| obligated to do so. If you do not wish to do so, delete this | |
| exception statement from your version. */ | |
| package java.io; | |
| import java.net.MalformedURLException; | |
| import java.net.URL; | |
| import gnu.classpath.Configuration; | |
| import gnu.java.io.PlatformHelper; | |
| /** | |
| * @author Michael Koch (konqueror@gmx.de) | |
| */ | |
| final class VMFile | |
| { | |
| // FIXME: We support only case sensitive filesystems currently. | |
| static final boolean IS_CASE_SENSITIVE = true; | |
| static final boolean IS_DOS_8_3 = false; | |
| static | |
| { | |
| if (Configuration.INIT_LOAD_LIBRARY) | |
| { | |
| System.loadLibrary("javaio"); | |
| } | |
| } | |
| /* | |
| * This native method does the actual work of getting the last file | |
| * modification time. It also does the existence check to avoid the | |
| * overhead of a call to exists() | |
| */ | |
| static native long lastModified(String path); | |
| /* | |
| * This native method sets the permissions to make the file read only. | |
| */ | |
| static native boolean setReadOnly(String path); | |
| /** | |
| * This method is used to create a temporary file | |
| */ | |
| static native boolean create(String path) throws IOException; | |
| /* | |
| * This native function actually produces the list of files in this | |
| * directory | |
| */ | |
| static native synchronized String[] list(String dirpath); | |
| /* | |
| * This native method actually performs the rename. | |
| */ | |
| static native boolean renameTo(String targetpath, String destpath); | |
| /* | |
| * This native method actually determines the length of the file and | |
| * handles the existence check | |
| */ | |
| static native long length(String path); | |
| /* | |
| * This native method does the actual checking of file existence. | |
| */ | |
| static native boolean exists(String path); | |
| /* | |
| * This native method handles the actual deleting of the file | |
| */ | |
| static native boolean delete(String path); | |
| /* | |
| * This method does the actual setting of the modification time. | |
| */ | |
| static native boolean setLastModified(String path, long time); | |
| /* | |
| * This native method actually creates the directory | |
| */ | |
| static native boolean mkdir(String dirpath); | |
| /** | |
| * Gets the total bytes of the filesystem named by path. | |
| */ | |
| public static native long getTotalSpace(String path); | |
| /** | |
| * Gets the total free bytes of the filesystem named by path. | |
| */ | |
| public static native long getFreeSpace(String path); | |
| /** | |
| * Gets the available bytes of the filesystem named by path. | |
| */ | |
| public static native long getUsableSpace(String path); | |
| /** | |
| * Set the read permission of the file. | |
| */ | |
| public static synchronized native boolean setReadable(String path, | |
| boolean readable, | |
| boolean ownerOnly); | |
| /** | |
| * Set the write permission of the file. | |
| */ | |
| public static synchronized native boolean setWritable(String path, | |
| boolean writable, | |
| boolean ownerOnly); | |
| /** | |
| * Set the execute permission of the file. | |
| */ | |
| public static synchronized native boolean setExecutable(String path, | |
| boolean executable, | |
| boolean ownerOnly); | |
| /* | |
| * 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() | |
| */ | |
| static native boolean isFile(String path); | |
| /** | |
| * This native method checks file permissions for writing | |
| */ | |
| static synchronized native boolean canWrite(String path); | |
| /** | |
| * This methods checks if a directory can be written to. | |
| */ | |
| static native boolean canWriteDirectory(String path); | |
| /** | |
| * This native method checks file permissions for reading | |
| */ | |
| static synchronized native boolean canRead(String path); | |
| /** | |
| * This native method checks file permissions for execution | |
| */ | |
| static synchronized native boolean canExecute(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() | |
| */ | |
| static native boolean isDirectory(String dirpath); | |
| /** | |
| * This methods checks if a directory can be written to. | |
| */ | |
| static boolean canWriteDirectory(File path) | |
| { | |
| return canWriteDirectory(path.getAbsolutePath()); | |
| } | |
| /** | |
| * This method returns an array of filesystem roots. Some operating systems | |
| * have volume oriented filesystem. This method provides a mechanism for | |
| * determining which volumes exist. GNU systems use a single hierarchical | |
| * filesystem, so will have only one "/" filesystem root. | |
| * | |
| * @return An array of <code>File</code> objects for each filesystem root | |
| * available. | |
| * | |
| * @since 1.2 | |
| */ | |
| static File[] listRoots() | |
| { | |
| File[] roots = new File[1]; | |
| roots[0] = new File("/"); | |
| return roots; | |
| } | |
| /** | |
| * This method tests whether or not this file represents a "hidden" file. | |
| * On GNU systems, a file is hidden if its name begins with a "." | |
| * character. Files with these names are traditionally not shown with | |
| * directory listing tools. | |
| * | |
| * @return <code>true</code> if the file is hidden, <code>false</code> | |
| * otherwise. | |
| * | |
| * @since 1.2 | |
| */ | |
| static boolean isHidden(String path) | |
| { | |
| // FIXME: this only works on UNIX | |
| return getName(path).startsWith("."); | |
| } | |
| /** | |
| * This method returns the name of the file. This is everything in the | |
| * complete path of the file after the last instance of the separator | |
| * string. | |
| * | |
| * @return The file name | |
| */ | |
| static String getName(String path) | |
| { | |
| int pos = PlatformHelper.lastIndexOfSeparator(path); | |
| if (pos == -1) | |
| return path; | |
| if (PlatformHelper.endWithSeparator(path)) | |
| return ""; | |
| return path.substring(pos + File.separator.length()); | |
| } | |
| /** | |
| * Returns the path as an absolute path name. 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. | |
| * | |
| * @param path the path to convert to absolute path | |
| * | |
| * @return the absolute path that corresponds to <code>path</code> | |
| */ | |
| static String getAbsolutePath(String path) | |
| { | |
| if (File.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 (File.separatorChar == '\\' | |
| && path.length() > 1 && path.charAt (1) == ':' | |
| && ((path.charAt (0) >= 'a' && path.charAt (0) <= 'z') | |
| || (path.charAt (0) >= 'A' && path.charAt (0) <= 'Z'))) | |
| { | |
| // On Windows, a process has a current working directory for | |
| // each drive and a path like "G:foo\bar" would mean the | |
| // absolute path "G:\wombat\foo\bar" if "\wombat" is the | |
| // working directory on the G drive. | |
| String drvDir = null; | |
| try | |
| { | |
| drvDir = new File (path.substring (0, 2)).getCanonicalPath(); | |
| } | |
| catch (IOException e) | |
| { | |
| drvDir = path.substring (0, 2) + "\\"; | |
| } | |
| // Note: this would return "C:\\." for the path "C:.", if "\" | |
| // is the working folder on the C drive, but this is | |
| // consistent with what Sun's JRE 1.4.1.01 actually returns! | |
| if (path.length() > 2) | |
| return drvDir + '\\' + path.substring (2, path.length()); | |
| else | |
| return drvDir; | |
| } | |
| else if (path.equals("")) | |
| return System.getProperty ("user.dir"); | |
| else | |
| return System.getProperty ("user.dir") + File.separatorChar + path; | |
| } | |
| /** | |
| * This method returns true if the path represents an absolute file | |
| * path and false if it does not. The definition of an absolute path varies | |
| * by system. As an example, on GNU systems, a path is absolute if it starts | |
| * with a "/". | |
| * | |
| * @param path the path to check | |
| * | |
| * @return <code>true</code> if path represents an absolute file name, | |
| * <code>false</code> otherwise. | |
| */ | |
| static boolean isAbsolute(String path) | |
| { | |
| if (File.separatorChar == '\\') | |
| return path.startsWith(File.separator + File.separator) | |
| || (path.length() > 2 | |
| && ((path.charAt(0) >= 'a' && path.charAt(0) <= 'z') | |
| || (path.charAt(0) >= 'A' && path.charAt(0) <= 'Z')) | |
| && path.charAt(1) == ':' | |
| && path.charAt(2) == '\\'); | |
| else | |
| return path.startsWith(File.separator); | |
| } | |
| /** | |
| * Returns a <code>URL</code> with the <code>file:</code> | |
| * protocol that represents this file. The exact form of this URL is | |
| * system dependent. | |
| * | |
| * @param file the file to convert to URL | |
| * | |
| * @return a <code>URL</code> for this object. | |
| * | |
| * @throws MalformedURLException if the URL cannot be created | |
| * successfully. | |
| */ | |
| static URL toURL(File file) | |
| throws MalformedURLException | |
| { | |
| // On Win32, Sun's JDK returns URLs of the form "file:/c:/foo/bar.txt", | |
| // while on UNIX, it returns URLs of the form "file:/foo/bar.txt". | |
| if (File.separatorChar == '\\') | |
| return new URL ("file:/" + file.getAbsolutePath().replace ('\\', '/') | |
| + (file.isDirectory() ? "/" : "")); | |
| else | |
| return new URL ("file:" + file.getAbsolutePath() | |
| + (file.isDirectory() ? "/" : "")); | |
| } | |
| /** | |
| * This method returns a canonical representation of the pathname of | |
| * this file. The actual form of the canonical representation is | |
| * system-dependent. On the GNU system, conversion to canonical | |
| * form involves the removal of redundant separators, references to | |
| * "." and "..", and symbolic links. | |
| * <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 static native String toCanonicalForm(String path) throws IOException; | |
| } |