/*
* @(#) $(JCGO)/goclsp/vm/java/io/VMFile.java --
* VM specific native file access API implementation.
**
* Project: JCGO (http://www.ivmaisoft.com/jcgo/)
* Copyright (C) 2001-2009 Ivan Maidanski <ivmai@ivmaisoft.com>
* All rights reserved.
**
* Class specification origin: GNU Classpath v0.93 vm/reference
*/
/*
* This 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.
**
* This software 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 (GPL) for more details.
**
* 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 gnu.java.nio.VMAccessorGnuJavaNio;
import gnu.java.nio.VMChannel;
import java.net.MalformedURLException;
import java.net.URL;
final class VMFile /* hard-coded class name */
{
static final boolean IS_CASE_SENSITIVE = isCaseSensitive0() != 0;
static final boolean IS_DOS_8_3 = isLongNameSupported0() == 0;
private static final boolean IS_UNIX_FS = isUniRootFileSys0() != 0;
private static final boolean IS_DOTFILE_HIDDEN = isDotFileHidden0() != 0;
private static final char FILE_SEP = (char) getFilePathSepChar0(0);
private static final char PATH_SEP = (char) getFilePathSepChar0(1);
private static final int DIR_DATASIZE_ISFIND = dirDataSizeAndIsFind0();
private static final Object DIR_OP_LOCK =
dirOpNeedsSync0() != 0 ? new Object() : null;
private static final String[] driveDirCache =
new String[IS_UNIX_FS ? 1 : 'Z' - 'A' + 2];
private static final String DOS_UNIX_DRIVE_PREFIX =
getDosUnixDrivePrefix0().replace('/', FILE_SEP);
private static final String LIBNAME_PREFIX = getLibNamePrefixSuffix0(0);
private static final String LIBNAME_SUFFIX = getLibNamePrefixSuffix0(1);
private static int defaultDrive;
private VMFile() {}
static long lastModified(String path)
{
return getLastModified0(normVolumeColon(path));
}
static boolean setReadOnly(String path)
{
return setReadOnly0(normVolumeColon(path)) >= 0;
}
static boolean create(String path)
throws IOException
{
VMChannel ch =
VMAccessorGnuJavaNio.createUnlessExistsVMChannel(new File(path));
if (ch == null)
return false;
try
{
ch.close();
}
catch (IOException e) {}
return true;
}
static String[] list(String path)
{
int dirDSize = DIR_DATASIZE_ISFIND;
if (dirDSize < 0)
dirDSize = -dirDSize;
byte[] dirdata = new byte[dirDSize];
path = normVolumeColon(path);
String[] names;
if (DIR_OP_LOCK != null)
{
synchronized (DIR_OP_LOCK)
{
names = listInner(path, dirdata);
}
}
else names = listInner(path, dirdata);
return names;
}
static boolean renameTo(String srcpath, String destpath)
{
return rename0(srcpath, destpath) >= 0;
}
static native long length(String path);
static boolean exists(String path)
{
return path.equals(".") || isRegFileOrDir0(normVolumeColon(path)) >= 0;
}
static boolean delete(String path)
{
return delete0(path) >= 0;
}
static boolean setLastModified(String path, long time)
{
return setLastModified0(time, normVolumeColon(path)) >= 0;
}
static boolean mkdir(String path)
{
return mkdir0(path) >= 0;
}
static long getTotalSpace(String path)
{
/* not implemented */
return 0L;
}
static long getFreeSpace(String path)
{
/* not implemented */
return 0L;
}
static long getUsableSpace(String path)
{
/* not implemented */
return 0L;
}
static boolean setReadable(String path, boolean readable,
boolean ownerOnly)
{
/* not implemented */
return false;
}
static boolean setWritable(String path, boolean writable,
boolean ownerOnly)
{
/* not implemented */
return false;
}
static boolean setExecutable(String path, boolean executable,
boolean ownerOnly)
{
/* not implemented */
return false;
}
static boolean isFile(String path)
{
return isRegFileOrDir0(path) == 1;
}
static boolean canWrite(String path)
{
return access0(path, 0, 1, 0) >= 0;
}
static boolean canWriteDirectory(String path)
{
return canWrite(normVolumeColon(path));
}
static boolean canWriteDirectory(File dir)
{
return canWriteDirectory(dir.getPath());
/* File testFile = null;
try
{
testFile = File.createTempFile(IS_DOS_8_3 ? "tst" : "test-dir-write",
null, dir);
}
catch (IOException e) {}
if (testFile != null)
{
String path = testFile.getPath();
if (delete(path))
return true;
System.err.println("Cannot remove temporary file: " + path);
}
return false; */
}
static boolean canRead(String path)
{
return access0(normVolumeColon(path), 1, 0, 0) >= 0;
}
static boolean canExecute(String path)
{
return access0(normVolumeColon(path), 0, 0, 1) >= 0;
}
static boolean isDirectory(String path)
{
return path.equals(".") || isRegFileOrDir0(normVolumeColon(path)) == 2;
}
static File[] listRoots()
{
File[] roots;
if (IS_UNIX_FS)
roots = new File[] { new File(String.valueOf(FILE_SEP)) };
else
{
int mask = getDrivesMask0();
roots = new File['Z' - 'A' + 1];
int count = 0;
if (mask != -1)
{
int drive = 0;
while (mask != 0)
{
drive++;
if ((mask & 1) != 0)
roots[count++] = new File(drivePathPrefix(drive) +
String.valueOf(FILE_SEP));
mask >>>= 1;
}
}
else
{
String path = getVolumeRoot0(0);
if (path != null && path.length() > 0)
{
int index = 0;
do
{
if (!path.equals("."))
{
if (roots.length <= count)
{
File[] newRoots = new File[(count >> 1) + count + 1];
System.arraycopy(roots, 0, newRoots, 0, count);
roots = newRoots;
}
roots[count++] = new File(path.charAt(path.length() - 1) == ':' ?
path + String.valueOf(FILE_SEP) : path);
}
path = getVolumeRoot0(++index);
} while (path != null && path.length() > 0);
}
else
{
int drive = 0;
do
{
String driveColon = drivePathPrefix(++drive);
int res = checkVolumeRoot0(driveColon + ".");
if (res > 0 || (res != 0 && getDriveCurDir(drive, false) != null))
roots[count++] = new File(driveColon + String.valueOf(FILE_SEP));
} while (drive <= 'Z' - 'A');
}
}
if (roots.length > count)
{
File[] newRoots = new File[count];
System.arraycopy(roots, 0, newRoots, 0, count);
roots = newRoots;
}
}
return roots;
}
static boolean isHidden(String path)
{
if (IS_DOTFILE_HIDDEN)
{
String name = getName(path);
int len = name.length();
if (len > 0)
{
if (name.charAt(0) != '.')
return false;
if (len > 2 || (len == 2 && name.charAt(1) != '.'))
return true;
}
if ((path = makeAbsPath(path)) == null)
return false;
name = getName(collapsePathDots(path));
return (len = name.length()) > 1 && name.charAt(0) == '.' &&
(len > 2 || name.charAt(1) != '.');
}
path = normVolumeColon(path);
int res = isHidden0(path);
int dirDSize;
if (res < 0 && (dirDSize = DIR_DATASIZE_ISFIND) > 0)
{
byte[] dirdata = new byte[dirDSize];
String filename = realPath0(path, new int[1]);
if (filename != path && filename != null)
path = normPlatformPath(filename);
if (DIR_OP_LOCK != null)
{
synchronized (DIR_OP_LOCK)
{
res = isHiddenInner(path, dirdata);
}
}
else res = isHiddenInner(path, dirdata);
}
return res > 0;
}
static String getName(String path)
{
int prefixLen = pathPrefixLength(path);
int pos = path.lastIndexOf(FILE_SEP);
return path.substring(pos >= prefixLen ? pos + 1 : prefixLen);
}
static String getAbsolutePath(String path)
{
String absPath = makeAbsPath(path);
return absPath != null ? absPath : path;
}
static boolean isAbsolute(String path)
{
int prefixLen = pathPrefixLength(path);
return prefixLen > 0 && (IS_UNIX_FS ||
(prefixLen > 2 && path.charAt(prefixLen - 1) != ':'));
}
static URL toURL(File file)
throws MalformedURLException
{
String path = file.getPath();
String normPath = makeAbsPath(path);
normPath = (normPath != null ? normPath : path).replace(FILE_SEP, '/');
int len = normPath.length();
if (len > 0)
{
if (normPath.charAt(len - 1) != '/' && isDirectory(path))
normPath = normPath + "/";
if (normPath.charAt(0) == '/')
{
if (len > 1 && normPath.charAt(1) == '/')
normPath = ("/" + "/") + normPath;
}
else normPath = "/" + normPath;
}
return new URL("file:" + normPath);
}
static String toCanonicalForm(String path)
throws IOException
{
int drive;
if (!IS_UNIX_FS && path.length() == 2 && path.charAt(1) == ':' &&
(drive = driveIndexOf(path.charAt(0))) > 0)
return getDriveCurDir(drive, true);
path = makeAbsPath(realPath((new File(path)).getPath()));
if (path == null)
throw new IOException();
return canonPathCase(collapsePathDots(path));
}
static final long currentTime(boolean isNano)
{ /* used by VM classes only */
return currentTime0(isNano ? 1 : 0);
}
static final String getFileSeparator()
{ /* used by VM classes only */
return String.valueOf(FILE_SEP);
}
static final String getPathSeparator()
{ /* used by VM classes only */
return String.valueOf(PATH_SEP);
}
static final String pathParentOf(String path)
{ /* used by VM classes only */
int prefixLen = pathPrefixLength(path);
if (path.length() == prefixLen)
return null;
int pos = path.lastIndexOf(FILE_SEP);
if (pos <= prefixLen)
pos = prefixLen;
return pos > 0 ? path.substring(0, pos) : null;
}
static final String makeAbsPath(String path)
{ /* used by VM classes only */
int prefixLen = pathPrefixLength(path);
String curDir;
if (prefixLen > 0)
{
if (IS_UNIX_FS)
return path;
if (prefixLen > 2)
return path.charAt(prefixLen - 1) == ':' ? path.substring(0, prefixLen) +
String.valueOf(FILE_SEP) + path.substring(prefixLen) : path;
if (prefixLen == 1)
return (curDir = getCurDir()) != null &&
(prefixLen = pathPrefixLength(curDir)) > 0 ?
pathAppendName(curDir.substring(0, prefixLen > 3 ?
prefixLen - 1 : prefixLen), path.substring(1)) : null;
curDir = getDriveCurDir(driveIndexOf(path.charAt(0)), true);
path = path.substring(2);
}
else
{
curDir = getCurDir();
if (path.equals("."))
return curDir;
}
return curDir != null ? pathAppendName(curDir, path.length() > 1 &&
path.charAt(0) == '.' && path.charAt(1) == FILE_SEP ?
path.substring(2) : path) : null;
}
static final String collapsePathDots(String path)
{ /* used by VM classes only */
int ofs = pathPrefixLength(path);
int skip = 0;
for (int pos = path.length(); pos > ofs; pos--)
{
int next = pos;
pos = path.lastIndexOf(FILE_SEP, next - 1) + 1;
if (pos <= ofs)
pos = ofs;
if (next - 1 == pos && path.charAt(pos) == '.')
{
if (path.length() == next)
{
if (pos <= ofs)
{
if (pos > 0)
path = path.substring(0, pos);
break;
}
next--;
}
path = path.substring(0, next - 1) + path.substring(next + 1);
}
else
{
if (next - 1 > pos && path.charAt(pos) == '.' &&
path.charAt(pos + 1) == '.')
{
int i = pos + 2;
if (!IS_UNIX_FS)
while (i < next && path.charAt(i) == '.')
i++;
if (i == next)
skip += next - pos;
}
if (skip > 0)
{
int i = pos;
skip--;
if (path.length() == next)
{
next--;
if (pos <= ofs)
{
if (pos <= 0)
{
path = ".";
i = 1;
}
}
else i--;
}
path = path.substring(0, i) + path.substring(next + 1);
}
}
}
return path;
}
static final String canonPathCase(String path)
throws IOException
{ /* used by VM classes only */
if (!IS_CASE_SENSITIVE)
{
int prefixLen = pathPrefixLength(path);
String name = path.substring(0, prefixLen);
String canonName = VMAccessorJavaLang.toUpperCaseLatinVMSystem(name);
if (canonName != name)
path = canonName + path.substring(prefixLen);
int pos = prefixLen;
char sep = FILE_SEP;
int dirDSize = DIR_DATASIZE_ISFIND;
byte[] dirdata = new byte[dirDSize >= 0 ? dirDSize : -dirDSize];
Object lockObj = DIR_OP_LOCK;
while (path.length() > pos)
{
int next = path.indexOf(sep, pos);
if (next < 0)
next = path.length();
int i = pos;
while (i < next && path.charAt(i) == '.')
i++;
if (i < next)
{
String curPath = path.substring(0, next);
name = path.substring(pos, next);
if (dirDSize > 0)
{
if (pos > prefixLen)
{
canonName = path.substring(0, pos - 1);
int[] resArr = new int[1];
String filename = realPath0(canonName, resArr);
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(resArr[0]);
if (filename != canonName && filename != null)
curPath = pathAppendName(normPlatformPath(filename), name);
}
if (lockObj != null)
{
synchronized (lockObj)
{
canonName = canonPathCaseMatch(curPath, dirdata);
}
}
else canonName = canonPathCaseMatch(curPath, dirdata);
if (canonName == null || name.indexOf('*', 0) >= 0 ||
name.indexOf('?', 0) >= 0)
break;
}
else
{
long[] devInodeArr = new long[2];
devInodeArr[0] = -1L;
int res = getLnkDevInode0(curPath, devInodeArr);
if (res < 0 && isIOErrorNoEntity0(res) != 0)
break;
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(res);
if (devInodeArr[0] == -1L || devInodeArr[1] == 0L)
break;
curPath = path.substring(0, pos > prefixLen ? pos - 1 : pos);
if (lockObj != null)
{
synchronized (lockObj)
{
canonName = canonPathCaseFind(curPath, dirdata, name);
}
}
else canonName = canonPathCaseFind(curPath, dirdata, name);
if (canonName == null)
break;
if (canonName.length() == 0)
{
if (lockObj != null)
{
synchronized (lockObj)
{
canonName = canonPathCaseScan(curPath, dirdata, devInodeArr);
}
}
else canonName = canonPathCaseScan(curPath, dirdata, devInodeArr);
if (canonName == null || canonName.length() == 0)
break;
}
}
if (!canonName.equals(name))
{
path = path.substring(0, pos) + canonName + path.substring(next);
next = canonName.length() + pos;
}
}
pos = next + 1;
}
}
return path;
}
static final String normPlatformPath(String path)
{ /* used by VM classes only */
int len = path.length();
if (len == 0)
return ".";
String normPath = normPlatformPath0(path);
if (normPath != null && normPath.length() > 0)
{
char ch;
if (!IS_UNIX_FS && (ch = normPath.charAt(0)) >= 'a' && ch <= 'z' &&
normPath.length() > 1 && normPath.charAt(1) == ':')
normPath = String.valueOf((char) (ch - ('a' - 'A'))) +
normPath.substring(1);
return normPath;
}
char sep = FILE_SEP;
if (IS_UNIX_FS)
{
path = path.replace('\\', sep);
if (len > 1)
{
int drive;
if (path.charAt(1) == ':' && (drive = driveIndexOf(path.charAt(0))) > 0)
{
path = drive == defaultDrive ? (len > 2 ? path.substring(2) : ".") :
DOS_UNIX_DRIVE_PREFIX + String.valueOf((char) (drive +
('a' - 1))) + (len != 2 && path.charAt(2) != sep ?
String.valueOf(sep) : "") + path.substring(2);
len = path.length();
}
if (path.charAt(len - 1) == sep && len > 1)
path = path.substring(0, len - 1);
}
}
else
{
if (len > 2 && path.charAt(0) == '/')
{
if (path.charAt(2) == ':' && driveIndexOf(path.charAt(1)) > 0)
{
path = path.substring(1);
if (len == 3)
path += String.valueOf(sep);
len = path.length();
}
else
{
String prefix = DOS_UNIX_DRIVE_PREFIX;
int pos = prefix.length() + 1;
char ch;
if (pos <= len && path.startsWith(prefix) &&
(ch = path.charAt(pos - 1)) >= 'a' && ch <= 'z' &&
(len == pos || path.charAt(pos) == '/'))
{
path = path.substring(pos - 1, pos) + ":" +
(len != pos ? path.substring(pos) : String.valueOf(sep));
len = path.length();
}
}
}
path = path.replace('/', sep);
if (len > 1)
{
char ch;
if (path.charAt(1) == ':' && (ch = path.charAt(0)) >= 'a' && ch <= 'z')
path = String.valueOf((char) (ch - ('a' - 'A'))) + path.substring(1);
if (path.charAt(len - 1) == sep && (len > 3 ||
(path.charAt(1) != ':' && path.charAt(len - 2) != sep)))
path = path.substring(0, len - 1);
}
}
return path;
}
static final String normPlatformListOfPaths(String pathlist)
{ /* used by VM classes only */
char sep = pathListPlatformSep(pathlist);
int pos = 0;
String properPathSep = sep != PATH_SEP ? String.valueOf(PATH_SEP) : null;
do
{
int next = pathlist.indexOf(sep, pos);
if (next < 0)
next = pathlist.length();
else if (properPathSep != null)
pathlist = pathlist.substring(0, next) + properPathSep +
pathlist.substring(next + 1);
String path = pathlist.substring(pos, next);
String normPath = normPlatformPath(path);
if (path != normPath)
{
pathlist = pathlist.substring(0, pos) + normPath +
pathlist.substring(next);
next = normPath.length() + pos;
}
pos = next + 1;
} while (pathlist.length() >= pos);
return pathlist;
}
static final String normVolumeColon(String path)
{ /* used by VM classes only */
int len = path.length();
return len > 1 ? (path.charAt(len - 1) == ':' &&
pathPrefixLength(path) == len ? path + "." : path) :
len > 0 ? path : ".";
}
static final String mapLibraryName(String libname)
{ /* used by VM classes only */
if (libname == null)
throw new NullPointerException();
String prefix = LIBNAME_PREFIX;
String suffix = LIBNAME_SUFFIX;
String mappedName = mapLibraryName0((prefix != null ? prefix : "") +
libname + (suffix != null ? suffix : ""));
return mappedName != null ? mappedName : "";
}
static final String getenvPlatform(String name)
{ /* used by VM classes only */
String value = getenv0(name);
if (value != null && value.length() == 0)
value = null;
return value;
}
static final String getLineSeparator()
{ /* used by VM classes only */
String newline = getLineSeparator0();
return newline != null && newline.length() > 0 ? newline : "\n";
}
private static char pathListPlatformSep(String pathlist)
{
char ch;
int val = pathListPlatformSep0(pathlist);
return val > 0 ? (char) val : (pathlist.length() > 2 &&
pathlist.charAt(1) == ':' && driveIndexOf(pathlist.charAt(0)) > 0 &&
((ch = pathlist.charAt(2)) == '/' || ch == '\\')) ||
pathlist.indexOf(';', 0) >= 0 || (pathlist.indexOf('\\', 0) > 0 &&
(val = pathlist.indexOf(':', 0)) > 1 &&
pathlist.indexOf(':', val + 1) < 0) ? ';' :
(ch = PATH_SEP) == ';' || (ch != ':' &&
pathlist.indexOf(':', 0) >= 0) ? ':' : ch;
}
private static String pathAppendName(String path, String name)
{
int len = path.length();
return len > 0 ? (name.length() > 0 ? (path.charAt(len - 1) != FILE_SEP ?
path + String.valueOf(FILE_SEP) + name : path + name) : path) : name;
}
private static String[] listInner(String path, byte[] dirdata)
{
String filename = path;
if (DIR_DATASIZE_ISFIND > 0)
{
filename = realPath0(path, new int[1]);
filename = pathAppendName(filename != path && filename != null ?
normPlatformPath(filename) : path, "*.*");
}
filename = dirOpenReadFirst0(dirdata, filename);
if (filename == null || filename.length() == 0)
{
/* if (DIR_DATASIZE_ISFIND > 0 && isRegFileOrDir0(path) == 2)
return new String[0]; */
return null;
}
String[] names;
int count;
try
{
names = new String[1];
count = 0;
do
{
if (!filename.equals(".") && !filename.equals(".."))
{
if (names.length <= count)
{
String[] newNames = new String[(count >> 1) + count + 32];
System.arraycopy(names, 0, newNames, 0, count);
names = newNames;
}
names[count++] = filename;
}
filename = dirReadNext0(dirdata);
} while (filename != null && filename.length() > 0);
}
finally
{
dirClose0(dirdata);
}
if (names.length > count)
{
String[] newNames = new String[count];
System.arraycopy(names, 0, newNames, 0, count);
names = newNames;
}
return names;
}
private static int isHiddenInner(String path, byte[] dirdata)
{
int res = -1;
String filename = dirOpenReadFirst0(dirdata, path);
if (filename != null && filename.length() > 0)
{
try
{
res = dirIsHiddenFound0(dirdata);
filename = dirReadNext0(dirdata);
if (filename != null && filename.length() > 0)
{
res = 0;
do
{
filename = dirReadNext0(dirdata);
} while (filename != null && filename.length() > 0);
}
}
finally
{
dirClose0(dirdata);
}
if (res > 0)
{
filename = getName(path);
if (filename.indexOf('*', 0) >= 0 || filename.indexOf('?', 0) >= 0)
res = 0;
}
}
return res;
}
private static String canonPathCaseMatch(String curPath, byte[] dirdata)
throws IOException
{
String canonName = dirOpenReadFirst0(dirdata, curPath);
if (canonName != null && canonName.length() > 0)
{
try
{
String filename = dirReadNext0(dirdata);
if (filename != null && filename.length() > 0)
{
canonName = null;
do
{
filename = dirReadNext0(dirdata);
} while (filename != null && filename.length() > 0);
}
}
finally
{
dirClose0(dirdata);
}
}
else
{
int res = access0(curPath, 0, 0, 0);
if (res < 0 && isIOErrorNoEntity0(res) == 0)
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(res);
canonName = null;
}
return canonName;
}
private static String canonPathCaseFind(String curPath, byte[] dirdata,
String name)
{
String canonName = dirOpenReadFirst0(dirdata, curPath);
if (canonName != null)
{
if (canonName.length() > 0)
{
try
{
do
{
if (canonName.equals(name))
break;
canonName = dirReadNext0(dirdata);
} while (canonName != null && canonName.length() > 0);
}
finally
{
dirClose0(dirdata);
}
if (canonName == null)
canonName = "";
}
else canonName = null;
}
return canonName;
}
private static String canonPathCaseScan(String curPath, byte[] dirdata,
long[] devInodeArr)
throws IOException
{
String canonName = dirOpenReadFirst0(dirdata, curPath);
if (canonName != null && canonName.length() > 0)
{
try
{
long stDev = devInodeArr[0];
long stIno = devInodeArr[1];
int compared = 0;
do
{
if (!canonName.equals(".") && !canonName.equals(".."))
{
devInodeArr[0] = -1L;
int res = getLnkDevInode0(pathAppendName(curPath, canonName),
devInodeArr);
if (res >= 0)
{
if (devInodeArr[0] == stDev && devInodeArr[1] == stIno)
{
if (compared > 0)
break;
String filename = dirReadNext0(dirdata);
if (filename == null || filename.length() == 0)
break;
devInodeArr[0] = -1L;
if (getLnkDevInode0(pathAppendName(curPath, filename),
devInodeArr) >= 0 && devInodeArr[0] == stDev &&
devInodeArr[1] == stIno)
canonName = null;
break;
}
compared++;
}
else if (isIOErrorNoEntity0(res) == 0)
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(res);
}
canonName = dirReadNext0(dirdata);
} while (canonName != null && canonName.length() > 0);
}
finally
{
dirClose0(dirdata);
}
}
return canonName;
}
static final String realPath(String path)
throws IOException
{ /* used by VM classes only */
path = normVolumeColon(path);
int[] resArr = new int[1];
String filename = realPath0(path, resArr);
int res = resArr[0];
if (res >= 0)
return filename != path && filename != null ?
normPlatformPath(filename) : path;
if (isIOErrorNoEntity0(res) == 0)
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(res);
int prefixLen = pathPrefixLength(path);
int pos = path.length();
do
{
if (pos == prefixLen)
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(res);
pos = path.lastIndexOf(FILE_SEP, pos - 1);
if (pos <= prefixLen)
pos = prefixLen;
filename = realPath0(path.substring(0, pos), resArr);
res = resArr[0];
} while (res < 0 && isIOErrorNoEntity0(res) != 0);
VMAccessorGnuJavaNio.checkIOResCodeVMChannel(res);
return filename != null ? pathAppendName(normPlatformPath(filename),
path.substring(pos + 1)) : path;
}
private static int pathPrefixLength(String path)
{
int pos = 0;
int len = path.length();
if (len > 0)
{
char sep = FILE_SEP;
if (IS_UNIX_FS)
{
if (path.charAt(0) == sep)
pos = 1;
}
else
{
if (path.charAt(0) == sep)
{
pos = 1;
if (len != 1 && path.charAt(1) == sep)
{
while (++pos < len)
if (path.charAt(pos) == sep)
break;
if (pos < len)
{
while (++pos < len)
if (path.charAt(pos) == sep)
break;
if (pos < len)
pos++;
}
}
}
else
{
pos = path.indexOf(':', 0) + 1;
if (pos > 1)
{
int i;
if (path.lastIndexOf('.', pos - 2) >= 0 ||
((i = path.lastIndexOf(sep, pos - 2)) > 0 &&
path.lastIndexOf(sep, i - 1) >= 0))
pos = 0;
else
{
if (pos < len)
{
if (path.charAt(pos) == sep)
pos++;
else if (pos > 2 && path.indexOf(':', pos) < 0 &&
path.indexOf(sep, pos + 1) < 0)
pos = 0;
}
}
}
}
}
}
return pos;
}
private static int driveIndexOf(char ch)
{
if (ch >= 'A' && ch <= 'Z')
return ch - ('A' - 1);
if (ch >= 'a' && ch <= 'z')
return ch - ('a' - 1);
return -1;
}
private static String drivePathPrefix(int drive)
{
return drive > 0 && drive <= 'Z' - 'A' + 1 ?
String.valueOf((char) (drive + ('A' - 1))) + ":" : null;
}
private static String getCurDir()
{
String path = driveDirCache[0];
if (path == null)
{
path = getDriveCurDir0(0);
if (path == null || path.length() == 0)
return null;
if (IS_UNIX_FS && path.length() > 2 && path.charAt(1) == ':' &&
path.charAt(2) == FILE_SEP)
defaultDrive = driveIndexOf(path.charAt(0));
path = normPlatformPath(path);
driveDirCache[0] = path;
int drive;
if (driveDirCache.length > 1 && path.length() > 2 &&
path.charAt(1) == ':' && (drive = driveIndexOf(path.charAt(0))) > 0 &&
path.charAt(2) == FILE_SEP)
driveDirCache[drive] = path;
}
return path;
}
private static String getDriveCurDir(int drive, boolean useCache)
{
String path = null;
if (drive > 0 && driveDirCache.length > drive &&
(!useCache || (path = driveDirCache[drive]) == null))
{
path = getDriveCurDir0(drive);
if (path != null && path.length() > 0)
{
path = normPlatformPath(path);
if (path.charAt(0) == FILE_SEP)
path = drivePathPrefix(drive) + path;
}
else
{
String drivePrefix = drivePathPrefix(drive) + ".";
String filename = realPath0(drivePrefix, new int[1]);
if ((filename == drivePrefix || filename == null ||
(path = normPlatformPath(filename)).length() <= 2 ||
driveIndexOf(path.charAt(0)) != drive || path.charAt(1) != ':' ||
path.charAt(2) != FILE_SEP) &&
((path = getVolumeCurDir0(drivePrefix)) == null ||
(path = normPlatformPath(path)).length() <= 2 ||
driveIndexOf(path.charAt(0)) != drive || path.charAt(1) != ':' ||
path.charAt(2) != FILE_SEP))
return null;
}
if (driveDirCache[drive] == null)
driveDirCache[drive] = path;
}
return path;
}
private static native long currentTime0(int isNano);
private static native int isCaseSensitive0();
private static native int isLongNameSupported0();
private static native int isUniRootFileSys0();
private static native int isDotFileHidden0();
private static native int getFilePathSepChar0(int isPath);
private static native String getLineSeparator0();
private static native String getDosUnixDrivePrefix0();
private static native String getLibNamePrefixSuffix0(int isSuffix);
private static native String mapLibraryName0(String libname);
private static native String getenv0(String name);
private static native int rename0(String path, String destpath);
private static native int delete0(String path);
private static native int mkdir0(String path);
private static native int access0(String path, int chkRead, int chkWrite,
int chkExec);
private static native int isRegFileOrDir0(String path);
private static native long getLastModified0(String path);
private static native int setLastModified0(long mtime, String path);
private static native int setReadOnly0(String path);
private static native int isIOErrorNoEntity0(int res);
private static native String realPath0(String path, int[] resArr);
private static native int getDrivesMask0();
private static native String getVolumeRoot0(int index);
private static native int checkVolumeRoot0(String path);
private static native String getDriveCurDir0(int drive);
private static native String getVolumeCurDir0(String path);
private static native String normPlatformPath0(String path);
private static native int pathListPlatformSep0(String pathlist);
private static native int isHidden0(String path);
private static native int getLnkDevInode0(String path, long[] devInodeArr);
private static native int dirOpNeedsSync0();
private static native int dirDataSizeAndIsFind0();
private static native String dirOpenReadFirst0(byte[] dirdata, String path);
private static native String dirReadNext0(byte[] dirdata);
private static native int dirIsHiddenFound0(byte[] dirdata);
private static native int dirClose0(byte[] dirdata);
}