File.java 51.6 KB
Newer Older
Tom Tromey committed
1
/* File.java -- Class representing a file on disk
2
   Copyright (C) 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006
Tom Tromey committed
3 4 5 6 7 8 9 10
   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.
11

Tom Tromey committed
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
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 gnu.classpath.SystemProperties;

44 45
import gnu.java.lang.CPStringBuilder;

Tom Tromey committed
46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;

/* 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)
 */
65
public class File implements Serializable, Comparable<File>
Tom Tromey committed
66 67 68 69 70 71 72 73 74 75 76 77 78
{
  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 = SystemProperties.getProperty("file.separator");
  private static final String dupSeparator = separator + separator;

  /**
   * This is the first character of the file separator string.  On many
79
   * hosts (for example, on the GNU system), this represents the entire
Tom Tromey committed
80 81 82 83
   * separator string.  The complete separator string is obtained from the
   * <code>file.separator</code>system property.
   */
  public static final char separatorChar = separator.charAt(0);
84

Tom Tromey committed
85 86
  /**
   * This is the string that is used to separate the host name from the
87
   * path name in paths that include the host name.  It is the value of
Tom Tromey committed
88 89 90 91
   * the <code>path.separator</code> system property.
   */
  public static final String pathSeparator
    = SystemProperties.getProperty("path.separator");
92

Tom Tromey committed
93 94 95 96 97 98 99 100 101 102 103 104
  /**
   * 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);

  /**
   * 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;
105 106


107 108 109 110
  /**
   * The time (millisecond), when the last temporary file was created.
   */
  private static long last_tmp;
111

112 113 114
  /**
   * The number of files, created during the current millisecond.
   */
115
  private static int n_created;
Tom Tromey committed
116 117 118 119 120 121 122 123

  /**
   * 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.
   *
124
   * @return <code>true</code> if reading is allowed,
Tom Tromey committed
125 126
   * <code>false</code> otherwise
   *
127
   * @exception SecurityException If the <code>SecurityManager</code>
Tom Tromey committed
128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146
   * does not allow access to the file
   */
  public boolean canRead()
  {
    // Test for existence. This also does the SecurityManager check
    if (!exists())
      return false;

    return VMFile.canRead(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.
   *
147
   * @return <code>true</code> if writing is allowed, <code>false</code>
Tom Tromey committed
148 149
   * otherwise
   *
150
   * @exception SecurityException If the <code>SecurityManager</code>
Tom Tromey committed
151 152 153 154 155 156
   * does not allow access to the file
   */
  public boolean canWrite()
  {
    // First do a SecurityCheck before doing anything else.
    checkWrite();
157

Tom Tromey committed
158 159 160 161 162
    // Test for existence.  This is required by the spec
    if (! VMFile.exists(path))
      return false;

    if (VMFile.isDirectory(path))
163
      return VMFile.canWriteDirectory(path);
Tom Tromey committed
164 165 166 167 168
    else
      return VMFile.canWrite(path);
  }

  /**
169 170 171 172 173 174
   * This method tests whether or not the current thread is allowed to
   * to execute 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>checkExec</code>
   * method 3) the file is executable.
   *
175
   * @return <code>true</code> if execution is allowed,
176 177
   * <code>false</code> otherwise
   *
178
   * @exception SecurityException If the <code>SecurityManager</code>
179 180 181 182 183 184 185 186
   * does not allow access to the file
   */
  public boolean canExecute()
  {
    if (!VMFile.exists(path))
      return false;

    checkExec();
187

188 189 190 191
    return VMFile.canExecute(path);
  }

  /**
Tom Tromey committed
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
   * 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 VMFile.create(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.
   *
217
   * @return <code>true</code> if the file was deleted, <code>false</code>
Tom Tromey committed
218 219 220 221 222 223 224
   * otherwise
   *
   * @exception SecurityException If deleting of the file is not allowed
   */
  public synchronized boolean delete()
  {
    SecurityManager s = System.getSecurityManager();
225

Tom Tromey committed
226 227
    if (s != null)
      s.checkDelete(path);
228

Tom Tromey committed
229 230 231 232
    return VMFile.delete(path);
  }

  /**
233
   * This method tests two <code>File</code> objects for equality by
Tom Tromey committed
234 235 236 237 238 239
   * 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>
240
   * The paths of the files are determined by calling the
Tom Tromey committed
241 242 243
   * <code>getPath()</code>
   * method on each object.
   *
244
   * @return <code>true</code> if the two objects are equal,
Tom Tromey committed
245 246 247 248 249 250
   * <code>false</code> otherwise.
   */
  public boolean equals(Object obj)
  {
    if (! (obj instanceof File))
      return false;
251

Tom Tromey committed
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
    File other = (File) obj;

    if (VMFile.IS_CASE_SENSITIVE)
      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 VMFile.exists(path);
  }

  /**
   * 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);
  }
284

Tom Tromey committed
285 286 287 288 289 290 291 292
  // 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 ('/', '\\');
293 294 295 296 297 298
        // 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);
Tom Tromey committed
299 300 301 302 303 304 305 306 307 308 309 310 311 312
      }

    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)
313 314
          {
            if (! (separatorChar == '\\' && ((plen == 3 && p.charAt(1) == ':')
315
                || (plen == 2 && p.charAt(0) == separatorChar))))
316 317 318 319
              return p.substring (0, plen - 1);
          }
        else
          return p;
Tom Tromey committed
320
      }
321

322
    CPStringBuilder newpath = new CPStringBuilder(plen);
Tom Tromey committed
323 324 325 326
    int last = 0;
    while (dupIndex != -1)
      {
        newpath.append(p.substring(last, dupIndex));
327 328 329 330 331
        // Ignore the duplicate path characters.
        while (p.charAt(dupIndex) == separatorChar)
          {
            dupIndex++;
            if (dupIndex == plen)
332 333 334 335 336 337 338 339
              {
                if ((separatorChar == '\\'
                    && newpath.length() == 2
                    && newpath.charAt(1) == ':')
                    || (separatorChar != '\\' && newpath.length() == 0))
                  {
                    newpath.append(separatorChar);
                  }
340
                return newpath.toString();
341
              }
342 343 344 345
          }
        newpath.append(separatorChar);
        last = dupIndex;
        dupIndex = p.indexOf(dupSeparator, last);
Tom Tromey committed
346
      }
347

Tom Tromey committed
348 349 350 351 352
    // Again, ignore possible trailing separator (except special cases
    // like "a:\" on Windows).
    int end;
    if (plen > 1 && p.charAt (plen - 1) == separatorChar)
    {
353 354 355
      if (separatorChar == '\\'
        && ((plen == 3 && p.charAt(1) == ':')
            || (plen == 2 && p.charAt(0) == separatorChar)))
Tom Tromey committed
356 357 358 359 360 361 362
        end = plen;
      else
        end = plen - 1;
    }
    else
      end = plen;
    newpath.append(p.substring(last, end));
363

Tom Tromey committed
364 365
    return newpath.toString();
  }
366

Tom Tromey committed
367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382
  /**
   * 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)
      {
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
        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);
          }
Tom Tromey committed
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
      }
    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.
   *
436 437
   * @param uri The URI
   * @throws IllegalArgumentException if the URI is not hierarchical
Tom Tromey committed
438 439 440 441
   */
  public File(URI uri)
  {
    if (uri == null)
442
        throw new NullPointerException("uri is null");
Tom Tromey committed
443 444

    if (!uri.getScheme().equals("file"))
445
        throw new IllegalArgumentException("invalid uri protocol");
Tom Tromey committed
446

447 448 449 450 451
    String name = uri.getPath();
    if (name == null)
      throw new IllegalArgumentException("URI \"" + uri
                     + "\" is not hierarchical");
    path = normalizePath(name);
Tom Tromey committed
452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
  }

  /**
   * 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
468
      return VMFile.getAbsolutePath(path);
Tom Tromey committed
469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486
  }

  /**
   * 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
487 488 489
   * system-dependent.  On the GNU system, conversion to canonical
   * form involves the removal of redundant separators, references to
   * "." and "..", and symbolic links.
Tom Tromey committed
490 491
   * <p>
   * Note that this method, unlike the other methods which return path
492
   * names, can throw an IOException.  This is because native method
Tom Tromey committed
493 494 495 496 497 498 499 500 501
   * might be required in order to resolve the canonical path
   *
   * @exception IOException If an error occurs
   */
  public String getCanonicalPath() throws IOException
  {
    // On Windows, getAbsolutePath might end up calling us, so we
    // have to special case that call to avoid infinite recursion.
    if (separatorChar == '\\' && path.length() == 2 &&
502 503 504
        ((path.charAt(0) >= 'a' && path.charAt(0) <= 'z') ||
         (path.charAt(0) >= 'A' && path.charAt(0) <= 'Z')) &&
        path.charAt(1) == ':')
Tom Tromey committed
505
    {
506
        return VMFile.toCanonicalForm(path);
Tom Tromey committed
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538
    }
    // Call getAbsolutePath first to make sure that we do the
    // current directory handling, because the native code
    // may have a different idea of the current directory.
    return VMFile.toCanonicalForm(getAbsolutePath());
  }

  /**
   * 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
   * complete path of the file after the last instance of the separator
   * string.
   *
   * @return The file name
   */
  public String getName()
  {
539
        return VMFile.getName(path);
Tom Tromey committed
540 541 542 543 544
  }

  /**
   * This method returns a <code>String</code> the represents this file's
   * parent.  <code>null</code> is returned if the file has no parent.  The
545 546
   * parent is determined via a simple operation which removes the name
   * after the last file separator character, as determined by the platform.
Tom Tromey committed
547 548 549 550 551 552 553
   *
   * @return The parent directory of this file
   */
  public String getParent()
  {
    String prefix = null;
    int nameSeqIndex = 0;
554

555 556
    if (path.equals(""))
      return null;
Tom Tromey committed
557

558
    // The "prefix", if present, is the leading "/" on UNIX and
Tom Tromey committed
559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577
    // either the drive specifier (e.g. "C:") or the leading "\\"
    // of a UNC network path on Windows.
    if (separatorChar == '/' && path.charAt (0) == '/')
      {
        prefix = "/";
        nameSeqIndex = 1;
      }
    else if (separatorChar == '\\' && path.length() > 1)
      {
        if ((path.charAt (0) == '\\' && path.charAt (1) == '\\')
            || (((path.charAt (0) >= 'a' && path.charAt (0) <= 'z')
                 || (path.charAt (0) >= 'A' && path.charAt (0) <= 'Z'))
                && path.charAt (1) == ':'))
          {
            prefix = path.substring (0, 2);
            nameSeqIndex = 2;
          }
      }

578
    // According to the JDK docs, the returned parent path is the
Tom Tromey committed
579 580 581 582 583 584 585 586 587 588
    // portion of the name sequence before the last separator
    // character, if found, prefixed by the prefix, otherwise null.
    if (nameSeqIndex < path.length())
      {
        String nameSeq = path.substring (nameSeqIndex, path.length());
        int last = nameSeq.lastIndexOf (separatorChar);
        if (last == -1)
          return prefix;
        else if (last == (nameSeq.length() - 1))
          // Note: The path would not have a trailing separator
589
          // except for cases like "C:\" on Windows (see
Tom Tromey committed
590 591 592 593 594 595 596 597 598 599 600
          // normalizePath( )), where Sun's JRE 1.4 returns null.
          return null;
        else if (last == 0)
          last++;

        if (prefix != null)
          return prefix + nameSeq.substring (0, last);
        else
          return nameSeq.substring (0, last);
      }
    else
601 602
      // Sun's JRE 1.4 returns null if the prefix is the only
      // component of the path - so "/" gives null on UNIX and
Tom Tromey committed
603 604 605 606 607 608 609 610
      // "C:", "\\", etc. return null on Windows.
      return null;
  }

  /**
   * This method returns a <code>File</code> object representing the parent
   * file of this one.
   *
611
   * @return a <code>File</code> for the parent of this object.
Tom Tromey committed
612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
   * <code>null</code>
   * will be returned if this object does not have a parent.
   *
   * @since 1.2
   */
  public File getParentFile()
  {
    String parent = getParent();
    return parent != null ? new File(parent) : null;
  }

  /**
   * Returns the path name that represents this file.  May be a relative
   * or an absolute path name
   *
   * @return The pathname of this file
   */
  public String getPath()
  {
    return path;
  }

  /**
   * This method returns a hash code representing this file.  It is the
   * hash code of the path of this file (as returned by <code>getPath()</code>)
   * exclusived or-ed with the value 1234321.
   *
   * @return The hash code for this object
   */
  public int hashCode()
  {
    if (VMFile.IS_CASE_SENSITIVE)
      return path.hashCode() ^ 1234321;
    else
      return path.toLowerCase().hashCode() ^ 1234321;
  }

  /**
   * This method returns true if this object 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 "/".
   *
655
   * @return <code>true</code> if this object represents an absolute
Tom Tromey committed
656 657 658 659
   * file name, <code>false</code> otherwise.
   */
  public boolean isAbsolute()
  {
660
    return VMFile.isAbsolute(path);
Tom Tromey committed
661 662 663 664 665 666
  }

  /**
   * This method tests whether or not the file represented by this object
   * is a directory.  In order for this method to return <code>true</code>,
   * the file represented by this object must exist and be a directory.
667
   *
Tom Tromey committed
668 669 670 671 672 673 674 675
   * @return <code>true</code> if this file is a directory, <code>false</code>
   * otherwise
   *
   * @exception SecurityException If reading of the file is not permitted
   */
  public boolean isDirectory()
  {
    checkRead();
676
    return VMFile.isDirectory(path);
Tom Tromey committed
677 678 679 680 681 682 683
  }

  /**
   * This method tests whether or not the file represented by this object
   * is a "plain" file.  A file is a plain file if and only if it 1) Exists,
   * 2) Is not a directory or other type of special file.
   *
684
   * @return <code>true</code> if this is a plain file, <code>false</code>
Tom Tromey committed
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702
   * otherwise
   *
   * @exception SecurityException If reading of the file is not permitted
   */
  public boolean isFile()
  {
    checkRead();
    return VMFile.isFile(path);
  }

  /**
   * 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.
703 704
   * @throws SecurityException if a security manager exists and denies
   *                           read access to this file.
Tom Tromey committed
705 706 707 708
   * @since 1.2
   */
  public boolean isHidden()
  {
709
    checkRead();
Tom Tromey committed
710 711 712 713 714 715 716 717
    return VMFile.isHidden(path);
  }

  /**
   * This method returns the last modification time of this file.  The
   * time value returned is an abstract value that should not be interpreted
   * as a specified time value.  It is only useful for comparing to other
   * such time values returned on the same system.  In that case, the larger
718
   * value indicates a more recent modification time.
Tom Tromey committed
719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763
   * <p>
   * If the file does not exist, then a value of 0 is returned.
   *
   * @return The last modification time of the file
   *
   * @exception SecurityException If reading of the file is not permitted
   */
  public long lastModified()
  {
    checkRead();
    return VMFile.lastModified(path);
  }

  /**
   * This method returns the length of the file represented by this object,
   * or 0 if the specified file does not exist.
   *
   * @return The length of the file
   *
   * @exception SecurityException If reading of the file is not permitted
   */
  public long length()
  {
    checkRead();
    return VMFile.length(path);
  }

  /**
   * This method returns a array of <code>String</code>'s representing the
   * list of files is then directory represented by this object.  If this
   * object represents a non-directory file or a non-existent file, then
   * <code>null</code> is returned.  The list of files will not contain
   * any names such as "." or ".." which indicate the current or parent
   * directory.  Also, the names are not guaranteed to be sorted.
   * <p>
   * In this form of the <code>list()</code> method, a filter is specified
   * that allows the caller to control which files are returned in the
   * list.  The <code>FilenameFilter</code> specified is called for each
   * file returned to determine whether or not that file should be included
   * in the list.
   * <p>
   * A <code>SecurityManager</code> check is made prior to reading the
   * directory.  If read access to the directory is denied, an exception
   * will be thrown.
   *
764
   * @param filter An object which will identify files to exclude from
Tom Tromey committed
765 766
   * the directory listing.
   *
767
   * @return An array of files in the directory, or <code>null</code>
Tom Tromey committed
768
   * if this object does not represent a valid directory.
769 770
   *
   * @exception SecurityException If read access is not allowed to the
Tom Tromey committed
771 772 773 774 775 776 777 778
   * directory by the <code>SecurityManager</code>
   */
  public String[] list(FilenameFilter filter)
  {
    checkRead();

    if (!exists() || !isDirectory())
      return null;
779

Tom Tromey committed
780 781
    // Get the list of files
    String files[] = VMFile.list(path);
782

Tom Tromey committed
783
    // Check if an error occured in listInternal().
784
    // This is an unreadable directory, pretend there is nothing inside.
Tom Tromey committed
785
    if (files == null)
786
      return new String[0];
Tom Tromey committed
787 788 789

    if (filter == null)
      return files;
790

Tom Tromey committed
791 792 793 794 795
    // Apply the filter
    int count = 0;
    for (int i = 0; i < files.length; i++)
      {
        if (filter.accept(this, files[i]))
796
          ++count;
Tom Tromey committed
797
        else
798
          files[i] = null;
Tom Tromey committed
799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821
      }

    String[] retfiles = new String[count];
    count = 0;
    for (int i = 0; i < files.length; i++)
      if (files[i] != null)
        retfiles[count++] = files[i];

    return retfiles;
  }

  /**
   * This method returns a array of <code>String</code>'s representing the
   * list of files is then directory represented by this object.  If this
   * object represents a non-directory file or a non-existent file, then
   * <code>null</code> is returned.  The list of files will not contain
   * any names such as "." or ".." which indicate the current or parent
   * directory.  Also, the names are not guaranteed to be sorted.
   * <p>
   * A <code>SecurityManager</code> check is made prior to reading the
   * directory.  If read access to the directory is denied, an exception
   * will be thrown.
   *
822
   * @return An array of files in the directory, or <code>null</code> if
Tom Tromey committed
823
   * this object does not represent a valid directory.
824 825
   *
   * @exception SecurityException If read access is not allowed to the
Tom Tromey committed
826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854
   * directory by the <code>SecurityManager</code>
   */
  public String[] list()
  {
    return list(null);
  }

  /**
   * This method returns an array of <code>File</code> objects representing
   * all the files in the directory represented by this object. If this
   * object does not represent a directory, <code>null</code> is returned.
   * Each of the returned <code>File</code> object is constructed with this
   * object as its parent.
   * <p>
   * A <code>SecurityManager</code> check is made prior to reading the
   * directory.  If read access to the directory is denied, an exception
   * will be thrown.
   *
   * @return An array of <code>File</code> objects for this directory.
   *
   * @exception SecurityException If the <code>SecurityManager</code> denies
   * access to this directory.
   *
   * @since 1.2
   */
  public File[] listFiles()
  {
    return listFiles((FilenameFilter) null);
  }
855

Tom Tromey committed
856 857 858 859 860 861
  /**
   * This method returns an array of <code>File</code> objects representing
   * all the files in the directory represented by this object. If this
   * object does not represent a directory, <code>null</code> is returned.
   * Each of the returned <code>File</code> object is constructed with this
   * object as its parent.
862
   * <p>
Tom Tromey committed
863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
   * In this form of the <code>listFiles()</code> method, a filter is specified
   * that allows the caller to control which files are returned in the
   * list.  The <code>FilenameFilter</code> specified is called for each
   * file returned to determine whether or not that file should be included
   * in the list.
   * <p>
   * A <code>SecurityManager</code> check is made prior to reading the
   * directory.  If read access to the directory is denied, an exception
   * will be thrown.
   *
   * @return An array of <code>File</code> objects for this directory.
   *
   * @exception SecurityException If the <code>SecurityManager</code> denies
   * access to this directory.
   *
   * @since 1.2
   */
  public File[] listFiles(FilenameFilter filter)
  {
    String[] filelist = list(filter);
883

Tom Tromey committed
884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
    if (filelist == null)
      return null;

    File[] fobjlist = new File [filelist.length];

    for (int i = 0; i < filelist.length; i++)
      fobjlist [i] = new File(this, filelist [i]);

    return fobjlist;
  }

  /**
   * This method returns an array of <code>File</code> objects representing
   * all the files in the directory represented by this object. If this
   * object does not represent a directory, <code>null</code> is returned.
   * Each of the returned <code>File</code> object is constructed with this
   * object as its parent.
901
   * <p>
Tom Tromey committed
902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
   * In this form of the <code>listFiles()</code> method, a filter is specified
   * that allows the caller to control which files are returned in the
   * list.  The <code>FileFilter</code> specified is called for each
   * file returned to determine whether or not that file should be included
   * in the list.
   * <p>
   * A <code>SecurityManager</code> check is made prior to reading the
   * directory.  If read access to the directory is denied, an exception
   * will be thrown.
   *
   * @return An array of <code>File</code> objects for this directory.
   *
   * @exception SecurityException If the <code>SecurityManager</code> denies
   * access to this directory.
   *
   * @since 1.2
   */
  public File[] listFiles(FileFilter filter)
  {
    File[] fobjlist = listFiles((FilenameFilter) null);

    if (fobjlist == null)
      return null;

    if (filter == null)
      return fobjlist;

    int count = 0;
    for (int i = 0; i < fobjlist.length; i++)
      if (filter.accept(fobjlist[i]) == true)
        ++count;

    File[] final_list = new File[count];
    count = 0;
    for (int i = 0; i < fobjlist.length; i++)
      if (filter.accept(fobjlist[i]) == true)
        {
          final_list[count] = fobjlist[i];
          ++count;
        }

    return final_list;
  }

  /**
   * This method returns a <code>String</code> that is the path name of the
   * file as returned by <code>getPath</code>.
   *
   * @return A <code>String</code> representation of this file
   */
  public String toString()
  {
    return path;
  }

  /**
   * @return A <code>URI</code> for this object.
   */
  public URI toURI()
  {
    String abspath = getAbsolutePath();
963

964
    if (isDirectory() || path.equals(""))
Tom Tromey committed
965 966 967 968
      abspath = abspath + separatorChar;

    if (separatorChar == '\\')
      abspath = separatorChar + abspath;
969

Tom Tromey committed
970 971 972 973 974 975 976 977 978 979
    try
      {
        return new URI("file", null, null, -1,
                       abspath.replace(separatorChar, '/'),
                       null, null);
      }
    catch (URISyntaxException use)
      {
        // Can't happen.
        throw (InternalError) new InternalError("Unconvertible file: "
980
                                                + this).initCause(use);
Tom Tromey committed
981 982 983 984 985 986 987 988 989 990
      }
  }

  /**
   * This method returns a <code>URL</code> with the <code>file:</code>
   * protocol that represents this file.  The exact form of this URL is
   * system dependent.
   *
   * @return A <code>URL</code> for this object.
   *
991
   * @exception MalformedURLException If the URL cannot be created
Tom Tromey committed
992 993 994 995
   * successfully.
   */
  public URL toURL() throws MalformedURLException
  {
996
    return VMFile.toURL(this);
Tom Tromey committed
997 998 999 1000 1001 1002
  }


  /**
   * This method creates a directory for the path represented by this object.
   *
1003
   * @return <code>true</code> if the directory was created,
Tom Tromey committed
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
   * <code>false</code> otherwise
   *
   * @exception SecurityException If write access is not allowed to this file
   */
  public boolean mkdir()
  {
    checkWrite();
    return VMFile.mkdir(path);
  }

  /**
   * This method creates a directory for the path represented by this file.
   * It will also create any intervening parent directories if necessary.
   *
1018
   * @return <code>true</code> if the directory was created,
Tom Tromey committed
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
   * <code>false</code> otherwise
   *
   * @exception SecurityException If write access is not allowed to this file
   */
  public boolean mkdirs()
  {
    String parent = getParent();
    if (parent == null)
      {
        return mkdir();
      }
1030

Tom Tromey committed
1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042
    File f = new File(parent);
    if (!f.exists())
      {
        boolean rc = f.mkdirs();
        if (rc == false)
          return false;
      }

    return mkdir();
  }

  /**
1043 1044 1045 1046 1047 1048
   * This method creates a temporary file in the specified directory.  If
   * the directory name is null, then this method uses the system temporary
   * directory. The files created are guaranteed not to currently exist and
   * the same file name will never be used twice in the same virtual
   * machine instance.
   * The system temporary directory is determined by examinging the
Tom Tromey committed
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061
   * <code>java.io.tmpdir</code> system property.
   * <p>
   * The <code>prefix</code> parameter is a sequence of at least three
   * characters that are used as the start of the generated filename.  The
   * <code>suffix</code> parameter is a sequence of characters that is used
   * to terminate the file name.  This parameter may be <code>null</code>
   * and if it is, the suffix defaults to ".tmp".
   * <p>
   * If a <code>SecurityManager</code> exists, then its <code>checkWrite</code>
   * method is used to verify that this operation is permitted.
   *
   * @param prefix The character prefix to use in generating the path name.
   * @param suffix The character suffix to use in generating the path name.
1062
   * @param directory The directory to create the file in, or
Tom Tromey committed
1063 1064 1065
   * <code>null</code> for the default temporary directory
   *
   * @exception IllegalArgumentException If the patterns is not valid
1066
   * @exception SecurityException If there is no permission to perform
Tom Tromey committed
1067 1068 1069 1070 1071
   * this operation
   * @exception IOException If an error occurs
   *
   * @since 1.2
   */
1072
  public static synchronized File createTempFile(String prefix, String suffix,
1073
                                    File directory)
Tom Tromey committed
1074 1075 1076 1077 1078 1079 1080
    throws IOException
  {
    // Grab the system temp directory if necessary
    if (directory == null)
      {
        String dirname = System.getProperty("java.io.tmpdir");
        if (dirname == null)
1081 1082
          throw new IOException("Cannot determine system temporary directory");

Tom Tromey committed
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
        directory = new File(dirname);
        if (! VMFile.exists(directory.path))
          throw new IOException("System temporary directory "
                                + directory.getName() + " does not exist.");
        if (! VMFile.isDirectory(directory.path))
          throw new IOException("System temporary directory "
                                + directory.getName()
                                + " is not really a directory.");
      }

    // Check if prefix is at least 3 characters long
    if (prefix.length() < 3)
      throw new IllegalArgumentException("Prefix too short: " + prefix);

    // Set default value of suffix
    if (suffix == null)
      suffix = ".tmp";

    // Now identify a file name and make sure it doesn't exist.
    File file;
    if (!VMFile.IS_DOS_8_3)
1104
      {
Tom Tromey committed
1105 1106
        do
          {
1107 1108 1109 1110 1111 1112 1113 1114 1115
            long now = System.currentTimeMillis();
            if (now > last_tmp)
              {
                // The last temporary file was created more than 1 ms ago.
                last_tmp = now;
                n_created = 0;
              }
            else
              n_created++;
1116

1117 1118 1119 1120
            String name = Long.toHexString(now);
            if (n_created > 0)
              name += '_'+Integer.toHexString(n_created);
            String filename = prefix + name + suffix;
Tom Tromey committed
1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147
            file = new File(directory, filename);
          }
        while (VMFile.exists(file.path));
      }
    else
      {
        // make sure prefix is not longer than 7 characters
        if (prefix.length() >= 8)
          throw new IllegalArgumentException("Prefix too long: " + prefix + "(valid length 3..7)");

        long mask = 0x000000ffffFFFFL >> (prefix.length() * 4);
        do
          {
            int n = (int) (System.currentTimeMillis() & mask);
            String filename = prefix + java.lang.Integer.toHexString(n) + suffix;
            file = new File(directory, filename);
          }
        while (VMFile.exists(file.path));
      }

    // Verify that we are allowed to create this file
    SecurityManager sm = System.getSecurityManager();
    if (sm != null)
      sm.checkWrite(file.getAbsolutePath());

    // Now create the file and return our file object
    // XXX - FIXME race condition.
1148
    VMFile.create(file.getAbsolutePath());
Tom Tromey committed
1149 1150 1151 1152
    return file;
  }

  /**
1153 1154
   * This method sets the owner's read permission for the File represented by
   * this object.
1155
   *
1156
   * It is the same as calling <code>setReadable(readable, true)</code>.
1157
   *
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
   * @param <code>readable</code> <code>true</code> to set read permission,
   * <code>false</code> to unset the read permission.
   * @return <code>true</code> if the file permissions are changed,
   * <code>false</code> otherwise.
   * @exception SecurityException If write access of the file is not permitted.
   * @see #setReadable(boolean, boolean)
   * @since 1.6
   */
  public boolean setReadable(boolean readable)
  {
    return setReadable(readable, true);
  }
1170

1171 1172 1173
  /**
   * This method sets the read permissions for the File represented by
   * this object.
1174
   *
1175 1176
   * If <code>ownerOnly</code> is set to <code>true</code> then only the
   * read permission bit for the owner of the file is changed.
1177
   *
1178 1179
   * If <code>ownerOnly</code> is set to <code>false</code>, the file
   * permissions are changed so that the file can be read by everyone.
1180
   *
1181 1182 1183
   * On unix like systems this sets the <code>user</code>, <code>group</code>
   * and <code>other</code> read bits and is equal to call
   * <code>chmod a+r</code> on the file.
1184
   *
1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
   * @param <code>readable</code> <code>true</code> to set read permission,
   * <code>false</code> to unset the read permission.
   * @param <code>ownerOnly</code> <code>true</code> to set read permission
   * for owner only, <code>false</code> for all.
   * @return <code>true</code> if the file permissions are changed,
   * <code>false</code> otherwise.
   * @exception SecurityException If write access of the file is not permitted.
   * @see #setReadable(boolean)
   * @since 1.6
   */
  public boolean setReadable(boolean readable, boolean ownerOnly)
  {
    checkWrite();
    return VMFile.setReadable(path, readable, ownerOnly);
  }
1200

1201 1202 1203
  /**
   * This method sets the owner's write permission for the File represented by
   * this object.
1204 1205 1206
   *
   * It is the same as calling <code>setWritable(readable, true)</code>.
   *
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
   * @param <code>writable</code> <code>true</code> to set write permission,
   * <code>false</code> to unset write permission.
   * @return <code>true</code> if the file permissions are changed,
   * <code>false</code> otherwise.
   * @exception SecurityException If write access of the file is not permitted.
   * @see #setWritable(boolean, boolean)
   * @since 1.6
   */
  public boolean setWritable(boolean writable)
  {
    return setWritable(writable, true);
  }
1219

1220 1221 1222
  /**
   * This method sets the write permissions for the File represented by
   * this object.
1223
   *
1224 1225
   * If <code>ownerOnly</code> is set to <code>true</code> then only the
   * write permission bit for the owner of the file is changed.
1226
   *
1227 1228
   * If <code>ownerOnly</code> is set to <code>false</code>, the file
   * permissions are changed so that the file can be written by everyone.
1229
   *
1230 1231 1232
   * On unix like systems this set the <code>user</code>, <code>group</code>
   * and <code>other</code> write bits and is equal to call
   * <code>chmod a+w</code> on the file.
1233
   *
1234 1235 1236
   * @param <code>writable</code> <code>true</code> to set write permission,
   * <code>false</code> to unset write permission.
   * @param <code>ownerOnly</code> <code>true</code> to set write permission
1237
   * for owner only, <code>false</code> for all.
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248
   * @return <code>true</code> if the file permissions are changed,
   * <code>false</code> otherwise.
   * @exception SecurityException If write access of the file is not permitted.
   * @see #setWritable(boolean)
   * @since 1.6
   */
  public boolean setWritable(boolean writable, boolean ownerOnly)
  {
    checkWrite();
    return VMFile.setWritable(path, writable, ownerOnly);
  }
1249

1250 1251 1252
  /**
   * This method sets the owner's execute permission for the File represented
   * by this object.
1253 1254 1255
   *
   * It is the same as calling <code>setExecutable(readable, true)</code>.
   *
1256 1257 1258 1259 1260 1261 1262 1263
   * @param <code>executable</code> <code>true</code> to set execute permission,
   * <code>false</code> to unset execute permission.
   * @return <code>true</code> if the file permissions are changed,
   * <code>false</code> otherwise.
   * @exception SecurityException If write access of the file is not permitted.
   * @see #setExecutable(boolean, boolean)
   * @since 1.6
   */
1264
  public boolean setExecutable(boolean executable)
1265 1266 1267
  {
    return setExecutable(executable, true);
  }
1268

1269 1270 1271
  /**
   * This method sets the execute permissions for the File represented by
   * this object.
1272
   *
1273 1274
   * If <code>ownerOnly</code> is set to <code>true</code> then only the
   * execute permission bit for the owner of the file is changed.
1275
   *
1276 1277
   * If <code>ownerOnly</code> is set to <code>false</code>, the file
   * permissions are changed so that the file can be executed by everyone.
1278
   *
1279 1280 1281
   * On unix like systems this set the <code>user</code>, <code>group</code>
   * and <code>other</code> write bits and is equal to call
   * <code>chmod a+x</code> on the file.
1282
   *
1283 1284 1285
   * @param <code>executable</code> <code>true</code> to set write permission,
   * <code>false</code> to unset write permission.
   * @param <code>ownerOnly</code> <code>true</code> to set write permission
1286
   * for owner only, <code>false</code> for all.
1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299
   * @return <code>true</code> if the file permissions are changed,
   * <code>false</code> otherwise.
   * @exception SecurityException If write access of the file is not permitted.
   * @see #setExecutable(boolean)
   * @since 1.6
   */
  public boolean setExecutable(boolean executable, boolean ownerOnly)
  {
    checkWrite();
    return VMFile.setExecutable(path, executable, ownerOnly);
  }

  /**
1300
   * Get the total space for the partition pointed by this file path, in bytes.
1301 1302
   *
   * @return the total number of bytes in this partition.
1303 1304 1305 1306 1307 1308 1309 1310 1311
   * @since 1.6
   */
  public long getTotalSpace()
  {
    // check security manager.
    SecurityManager s = System.getSecurityManager();
    if (s != null)
      s.checkPermission(new RuntimePermission("getFileSystemAttributes"));
    checkRead();
1312

1313 1314
    return VMFile.getTotalSpace(path);
  }
1315

1316 1317
  /**
   * Get the free space in the partition pointed by this file path, in bytes.
1318 1319
   *
   * @return the number of free bytes in this partition.
1320 1321 1322 1323 1324 1325 1326 1327 1328
   * @since 1.6
   */
  public long getFreeSpace()
  {
    // check security manager.
    SecurityManager s = System.getSecurityManager();
    if (s != null)
      s.checkPermission(new RuntimePermission("getFileSystemAttributes"));
    checkRead();
1329

1330 1331
    return VMFile.getFreeSpace(path);
  }
1332

1333 1334 1335 1336
  /**
   * Get the usable space in the partition pointed by this file path, in bytes.
   * This is not necessarily the same as the number returned by
   * {@link #getFreeSpace()}.
1337
   *
1338 1339 1340 1341
   * <strong>Implementation note</strong>: Unlike the RI, on Linux and UNIX
   * like systems this methods take into account the reserved space for the
   * "root" user. This means that the returned results will be a little
   * different if a normal user or root perform the query.
1342
   *
1343 1344 1345
   * Also, the bytes returned should be interpreted as an hint, and may be
   * different at each call of this method or even right after the method
   * returns.
1346 1347
   *
   * @return the number of usable bytes in this partition.
1348 1349 1350 1351 1352 1353 1354 1355 1356
   * @since 1.6
   */
  public long getUsableSpace()
  {
    // check security manager.
    SecurityManager s = System.getSecurityManager();
    if (s != null)
      s.checkPermission(new RuntimePermission("getFileSystemAttributes"));
    checkRead();
1357

1358 1359 1360 1361
    // root users can use the reserved extra space
    String user = System.getProperty("user.name");
    if (user != null && user.equals("root"))
      return VMFile.getFreeSpace(path);
1362

1363 1364
    return VMFile.getUsableSpace(path);
  }
1365

1366
  /**
Tom Tromey committed
1367
   * This method sets the file represented by this object to be read only.
1368
   * A read only file or directory cannot be modified.  Please note that
Tom Tromey committed
1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
   * GNU systems allow read only files to be deleted if the directory it
   * is contained in is writable.
   *
   * @return <code>true</code> if the operation succeeded, <code>false</code>
   * otherwise.
   *
   * @exception SecurityException If the <code>SecurityManager</code> does
   * not allow this operation.
   *
   * @since 1.2
   */
  public boolean setReadOnly()
  {
    // Do a security check before trying to do anything else.
    checkWrite();

    // Test for existence.
    if (! VMFile.exists(path))
      return false;

    return VMFile.setReadOnly(path);
  }

  /**
   * 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
   */
  public static File[] listRoots()
  {
1405
    File[] roots = VMFile.listRoots();
1406

1407 1408 1409
    SecurityManager s = System.getSecurityManager();
    if (s != null)
      {
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434
        // Only return roots to which the security manager permits read access.
        int count = roots.length;
        for (int i = 0; i < roots.length; i++)
          {
            try
              {
                s.checkRead (roots[i].path);
              }
            catch (SecurityException sx)
              {
                roots[i] = null;
                count--;
              }
          }
        if (count != roots.length)
          {
            File[] newRoots = new File[count];
            int k = 0;
            for (int i = 0; i < roots.length; i++)
              {
                if (roots[i] != null)
                  newRoots[k++] = roots[i];
              }
            roots = newRoots;
          }
1435 1436
      }
    return roots;
Tom Tromey committed
1437 1438 1439
  }

  /**
1440
   * This method creates a temporary file in the system temporary directory.
Tom Tromey committed
1441 1442
   * The files created are guaranteed not to currently exist and the same file
   * name will never be used twice in the same virtual machine instance.  The
1443
   * system temporary directory is determined by examinging the
Tom Tromey committed
1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
   * <code>java.io.tmpdir</code> system property.
   * <p>
   * The <code>prefix</code> parameter is a sequence of at least three
   * characters that are used as the start of the generated filename.  The
   * <code>suffix</code> parameter is a sequence of characters that is used
   * to terminate the file name.  This parameter may be <code>null</code>
   * and if it is, the suffix defaults to ".tmp".
   * <p>
   * If a <code>SecurityManager</code> exists, then its <code>checkWrite</code>
   * method is used to verify that this operation is permitted.
   * <p>
1455
   * This method is identical to calling
Tom Tromey committed
1456 1457 1458 1459 1460 1461
   * <code>createTempFile(prefix, suffix, null)</code>.
   *
   * @param prefix The character prefix to use in generating the path name.
   * @param suffix The character suffix to use in generating the path name.
   *
   * @exception IllegalArgumentException If the prefix or suffix are not valid.
1462
   * @exception SecurityException If there is no permission to perform
Tom Tromey committed
1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
   * this operation
   * @exception IOException If an error occurs
   */
  public static File createTempFile(String prefix, String suffix)
    throws IOException
  {
    return createTempFile(prefix, suffix, null);
  }

  /**
   * This method compares the specified <code>File</code> to this one
   * to test for equality.  It does this by comparing the canonical path names
1475
   * of the files.
Tom Tromey committed
1476 1477 1478 1479 1480
   * <p>
   * The canonical paths of the files are determined by calling the
   * <code>getCanonicalPath</code> method on each object.
   * <p>
   * This method returns a 0 if the specified <code>Object</code> is equal
1481
   * to this one, a negative value if it is less than this one
Tom Tromey committed
1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501
   * a positive value if it is greater than this one.
   *
   * @return An integer as described above
   *
   * @since 1.2
   */
  public int compareTo(File other)
  {
    if (VMFile.IS_CASE_SENSITIVE)
      return path.compareTo (other.path);
    else
      return path.compareToIgnoreCase (other.path);
  }

  /**
   * This method renames the file represented by this object to the path
   * of the file represented by the argument <code>File</code>.
   *
   * @param dest The <code>File</code> object representing the target name
   *
1502
   * @return <code>true</code> if the rename succeeds, <code>false</code>
Tom Tromey committed
1503 1504
   * otherwise.
   *
1505
   * @exception SecurityException If write access is not allowed to the
Tom Tromey committed
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531
   * file by the <code>SecurityMananger</code>.
   */
  public synchronized boolean renameTo(File dest)
  {
    checkWrite();
    dest.checkWrite();
    // Call our native rename method
    return VMFile.renameTo(path, dest.path);
  }

  /**
   * This method sets the modification time on the file to the specified
   * value.  This is specified as the number of seconds since midnight
   * on January 1, 1970 GMT.
   *
   * @param time The desired modification time.
   *
   * @return <code>true</code> if the operation succeeded, <code>false</code>
   * otherwise.
   *
   * @exception IllegalArgumentException If the specified time is negative.
   * @exception SecurityException If the <code>SecurityManager</code> will
   * not allow this operation.
   *
   * @since 1.2
   */
1532
  public boolean setLastModified(long time)
Tom Tromey committed
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544
  {
    if (time < 0)
      throw new IllegalArgumentException("Negative modification time: " + time);

    checkWrite();
    return VMFile.setLastModified(path, time);
  }

  private void checkWrite()
  {
    // Check the SecurityManager
    SecurityManager s = System.getSecurityManager();
1545

Tom Tromey committed
1546 1547 1548 1549 1550 1551 1552 1553
    if (s != null)
      s.checkWrite(path);
  }

  private void checkRead()
  {
    // Check the SecurityManager
    SecurityManager s = System.getSecurityManager();
1554

Tom Tromey committed
1555 1556 1557 1558
    if (s != null)
      s.checkRead(path);
  }

1559 1560 1561 1562
  private void checkExec()
  {
    // Check the SecurityManager
    SecurityManager s = System.getSecurityManager();
1563

1564 1565 1566
    if (s != null)
      s.checkExec(path);
  }
1567 1568

  /**
Tom Tromey committed
1569 1570 1571 1572 1573 1574 1575
   * Calling this method requests that the file represented by this object
   * be deleted when the virtual machine exits.  Note that this request cannot
   * be cancelled.  Also, it will only be carried out if the virtual machine
   * exits normally.
   *
   * @exception SecurityException If deleting of the file is not allowed
   *
1576
   * @since 1.2
Tom Tromey committed
1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
   */
  public void deleteOnExit()
  {
    // Check the SecurityManager
    SecurityManager sm = System.getSecurityManager();
    if (sm != null)
      sm.checkDelete(path);

    DeleteFileHelper.add(this);
  }

  private void writeObject(ObjectOutputStream oos) throws IOException
  {
    oos.defaultWriteObject();
    oos.writeChar(separatorChar);
  }

  private void readObject(ObjectInputStream ois)
    throws ClassNotFoundException, IOException
  {
    ois.defaultReadObject();

    // If the file was from an OS with a different dir separator,
    // fixup the path to use the separator on this OS.
    char oldSeparatorChar = ois.readChar();
1602

Tom Tromey committed
1603 1604 1605 1606
    if (oldSeparatorChar != separatorChar)
      path = path.replace(oldSeparatorChar, separatorChar);
  }

1607
} // class File