OSDN Git Service

* java/io/File.java (toURL): Use getAbsolutePath and `file://'.
[pf3gnuchains/gcc-fork.git] / libjava / java / io / File.java
1 // File.java - File name
2
3 /* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
4
5    This file is part of libgcj.
6
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9 details.  */
10
11 package java.io;
12
13 import java.util.*;
14 import java.net.*;
15 import gnu.gcj.runtime.FileDeleter;
16
17 /**
18  * @author Tom Tromey <tromey@cygnus.com>
19  * @date September 24, 1998 
20  */
21
22 /* Written using "Java Class Libraries", 2nd edition, ISBN 0-201-31002-3
23  * "The Java Language Specification", ISBN 0-201-63451-1
24  * Status:  Complete to version 1.3.
25  */
26
27 public class File implements Serializable, Comparable
28 {
29   public boolean canRead ()
30   {
31     checkRead();
32     return _access (READ);
33   }
34
35   public boolean canWrite ()
36   {
37     checkWrite();
38     return _access (WRITE);
39   }
40   
41   private native boolean performCreate() throws IOException;
42
43   /** @since 1.2 */
44   public boolean createNewFile() throws IOException
45   {
46     checkWrite();
47     return performCreate();
48   }
49   
50   private native boolean performDelete ();
51   public boolean delete ()
52   {
53     SecurityManager s = System.getSecurityManager();
54     String name = path;
55     if (s != null)
56       s.checkDelete(path);
57     return performDelete ();
58   }
59
60   public boolean equals (Object obj)
61   {
62     if (! (obj instanceof File))
63       return false;
64     File other = (File) obj;
65     if (caseSensitive)
66       return (path.equals(other.path));
67     else
68       return (path.equalsIgnoreCase(other.path));      
69   }
70
71   public boolean exists ()
72   {
73     checkRead();
74     return _access (EXISTS);
75   }
76
77   public File (String p)
78   {
79     path = normalizePath(p);
80   }
81
82   // Remove duplicate and redundant separator characters.
83   private String normalizePath(String p)
84   {
85     int dupIndex = p.indexOf(dupSeparator);
86     int plen = p.length();
87     
88     // Special case: permit Windows UNC path prefix.
89     if (dupSeparator == "\\" && dupIndex == 0)
90       dupIndex = p.indexOf(dupSeparator, 1);
91
92     if (dupIndex == -1)
93       {
94         // Ignore trailing separator.
95         if (plen > 1 && p.charAt(plen - 1) == separatorChar)
96           return p.substring(0, plen - 1);
97         else
98           return p;
99       }
100     
101     StringBuffer newpath = new StringBuffer(plen);
102     int last = 0;
103     while (dupIndex != -1)
104       {
105         newpath.append(p.substring(last, dupIndex));
106         // Ignore the duplicate path characters.
107         while (p.charAt(dupIndex) == separatorChar)
108           {
109             dupIndex++;
110             if (dupIndex == plen)
111               return newpath.toString();
112           }
113         newpath.append(separatorChar);
114         last = dupIndex;
115         dupIndex = p.indexOf(dupSeparator, last);
116       }
117     
118     // Again, ignore possible trailing separator.
119     int end;
120     if (plen > 1 && p.charAt(plen - 1) == separatorChar)
121       end = plen - 1;
122     else
123       end = plen;
124     newpath.append(p.substring(last, end));
125     
126     return newpath.toString();
127   }
128   
129   public File (String dirPath, String name)
130   {
131     if (name == null)
132       throw new NullPointerException ();
133     if (dirPath != null && dirPath.length() > 0)
134       {
135         // Try to be smart about the number of separator characters.
136         if (dirPath.charAt(dirPath.length() - 1) == separatorChar
137             || name.length() == 0)
138           path = normalizePath(dirPath + name);
139         else
140           path = normalizePath(dirPath + separatorChar + name);
141       }
142     else
143       path = normalizePath(name);
144   }
145
146   public File (File dir, String name)
147   {
148     this (dir == null ? null : dir.path, name);
149   }
150
151   // FIXME  ???
152   public String getAbsolutePath ()
153   {
154     if (isAbsolute ())
155       return path;
156     return System.getProperty("user.dir") + separatorChar + path;
157   }
158
159   /** @since 1.2 */
160   public File getAbsoluteFile ()
161   {
162     return new File (getAbsolutePath());
163   }
164
165   public native String getCanonicalPath () throws IOException;
166
167   /** @since 1.2 */
168   public File getCanonicalFile () throws IOException
169   {
170     return new File (getCanonicalPath());
171   }
172
173   public String getName ()
174   {
175     int last = path.lastIndexOf(separatorChar);
176     return path.substring(last + 1);
177   }
178
179   public String getParent ()
180   {
181     int last = path.lastIndexOf(separatorChar);
182     if (last == -1)
183       return null;
184     return path.substring(0, last);
185   }
186
187   /** @since 1.2 */
188   public File getParentFile ()
189   {
190     String parent = getParent ();
191     return (parent == null ? null : new File (parent));
192   }
193
194   public String getPath ()
195   {
196     return path;
197   }
198
199   public int hashCode ()
200   {
201     if (caseSensitive)
202       return (path.hashCode() ^ 1234321);
203     else
204       return (path.toLowerCase().hashCode() ^ 1234321);
205   }
206
207   public native boolean isAbsolute ();
208
209   public boolean isDirectory ()
210   {
211     checkRead();
212     return _stat (DIRECTORY);
213   }
214
215   public boolean isFile ()
216   {
217     checkRead();
218     return _stat (ISFILE);
219   }
220
221   /** @since 1.2 */
222   public boolean isHidden()
223   {
224     checkRead();
225     return _stat (ISHIDDEN);
226   }
227
228   public long lastModified ()
229   {
230     checkRead();
231     return attr (MODIFIED);
232   }
233
234   public long length ()
235   {
236     checkRead();
237     return attr (LENGTH);
238   }
239     
240   private final native Object[] performList (FilenameFilter filter,
241                                              FileFilter fileFilter,
242                                              Class result_type);
243
244   public String[] list (FilenameFilter filter)
245   {
246     checkRead();
247     return (String[]) performList (filter, null, String.class);
248   }
249
250   public String[] list ()
251   {
252     checkRead();
253     return (String[]) performList (null, null, String.class);
254   }
255
256   /** @since 1.2 */
257   public File[] listFiles()
258   {
259     checkRead();
260     return (File[]) performList (null, null, File.class);
261   }
262   
263   /** @since 1.2 */
264   public File[] listFiles(FilenameFilter filter)
265   {
266     checkRead();
267     return (File[]) performList (filter, null, File.class);
268   }
269   
270   /** @since 1.2 */
271   public File[] listFiles(FileFilter filter)
272   {
273     checkRead();
274     return (File[]) performList (null, filter, File.class);
275   }
276
277   public String toString ()
278   {
279     return path;
280   }
281
282   public URL toURL () throws MalformedURLException
283   {
284     return new URL ("file://" + getAbsolutePath ()
285                     + (isDirectory() ? "/" : ""));
286   }
287
288   private final native boolean performMkdir ();
289
290   public boolean mkdir ()
291   {
292     checkWrite();
293     return performMkdir ();
294   }
295
296   private static boolean mkdirs (File x)
297   {
298     if (x.isDirectory())
299       return true;
300     String p = x.getPath();
301     String parent = x.getParent();
302     if (parent != null)
303       {
304         x.path = parent;
305         if (! mkdirs (x))
306           return false;
307         x.path = p;
308       }
309     return x.mkdir();
310   }
311
312   public boolean mkdirs ()
313   {
314     checkWrite();
315     if (isDirectory ())
316       return false;
317     return mkdirs (new File (path));
318   }
319
320   private static synchronized String nextValue ()
321   {
322     return Long.toString(counter++, Character.MAX_RADIX);
323   }
324
325   /** @since 1.2 */
326   public static File createTempFile (String prefix, String suffix,
327                                      File directory)
328     throws IOException
329   {
330     // Grab the system temp directory if necessary
331     if (directory == null)
332       {
333         String dirname = tmpdir;
334         if (dirname == null)
335           throw 
336             new IOException("Cannot determine system temporary directory"); 
337         
338         directory = new File(dirname);
339         if (!directory.exists())
340           throw new IOException("System temporary directory " 
341                                 + directory.getName() + " does not exist.");
342         if (!directory.isDirectory())
343           throw new IOException("System temporary directory " 
344                                 + directory.getName() 
345                                 + " is not really a directory.");
346       }
347
348     if (prefix.length () < 3)
349       throw new IllegalArgumentException ("Prefix too short: " + prefix);
350     if (suffix == null)
351       suffix = ".tmp";
352
353     // Truncation rules.
354     // `6' is the number of characters we generate.
355     if (prefix.length () + 6 + suffix.length () > maxPathLen)
356       {
357         int suf_len = 0;
358         if (suffix.charAt(0) == '.')
359           suf_len = 4;
360         suffix = suffix.substring(0, suf_len);
361         if (prefix.length () + 6 + suf_len > maxPathLen)
362           prefix = prefix.substring(0, maxPathLen - 6 - suf_len);
363       }
364
365     File f;
366
367     // How many times should we try?  We choose 100.
368     for (int i = 0; i < 100; ++i)
369       {
370         // This is ugly.
371         String t = "ZZZZZZ" + nextValue ();
372         String l = prefix + t.substring(t.length() - 6) + suffix;
373         try
374           {
375             f = new File(directory, l);
376             if (f.createNewFile())
377               return f;
378           }
379         catch (IOException ignored)
380           {
381           }
382       }
383
384     throw new IOException ("cannot create temporary file");
385   }
386
387   private native boolean performSetReadOnly();
388
389   /** @since 1.2 */
390   public boolean setReadOnly()
391   {
392     checkWrite();
393     return performSetReadOnly();
394   }
395
396   private static native File[] performListRoots();
397
398   /** @since 1.2 */
399   public static File[] listRoots()
400   {
401     File[] roots = performListRoots();
402     
403     SecurityManager s = System.getSecurityManager();
404     if (s != null)
405       {
406         // Only return roots to which the security manager permits read access.
407         int count = roots.length;
408         for (int i = 0; i < roots.length; i++)
409           {
410             try
411               {
412                 s.checkRead(roots[i].path);             
413               }
414             catch (SecurityException sx)
415               {
416                 roots[i] = null;
417                 count--;
418               }
419           }
420         if (count != roots.length)
421           {
422             File[] newRoots = new File[count];
423             int k = 0;
424             for (int i=0; i < roots.length; i++)
425               {
426                 if (roots[i] != null)
427                   newRoots[k++] = roots[i];
428               }
429             roots = newRoots;
430           }
431       }
432     return roots;
433   }
434
435   public static File createTempFile (String prefix, String suffix)
436     throws IOException
437   {
438     return createTempFile (prefix, suffix, null);
439   }
440
441   /** @since 1.2 */
442   public int compareTo(File other)
443   {
444     if (caseSensitive)
445       return path.compareTo (other.path);
446     else
447       return path.compareToIgnoreCase (other.path);
448   }
449
450   /** @since 1.2 */
451   public int compareTo(Object o)
452   {
453     File other = (File) o;
454     return compareTo (other);
455   }
456
457   private native boolean performRenameTo (File dest);
458   public boolean renameTo (File dest)
459   {
460     SecurityManager s = System.getSecurityManager();
461     String sname = getName();
462     String dname = dest.getName();
463     if (s != null)
464       {
465         s.checkWrite(sname);
466         s.checkWrite(dname);
467       }
468     return performRenameTo (dest);
469   }
470
471   private native boolean performSetLastModified(long time);
472   
473   /** @since 1.2 */
474   public boolean setLastModified(long time)
475   {
476     checkWrite();
477     return performSetLastModified(time);
478   }
479
480   public static final String pathSeparator
481     = System.getProperty("path.separator");
482   public static final char pathSeparatorChar = pathSeparator.charAt(0);
483   public static final String separator = System.getProperty("file.separator");
484   public static final char separatorChar = separator.charAt(0);
485
486   static final String tmpdir = System.getProperty("java.io.tmpdir");
487   static int maxPathLen;
488   static boolean caseSensitive;
489   static String dupSeparator = separator + separator;
490   
491   static
492   {
493     init_native();
494   }
495   
496   // Native function called at class initialization. This should should
497   // set the maxPathLen and caseSensitive variables.
498   private static native void init_native();
499
500   // The path.
501   private String path;
502
503   // We keep a counter for use by createTempFile.  We choose the first
504   // value randomly to try to avoid clashes with other VMs.
505   private static long counter = Double.doubleToLongBits (Math.random ());
506
507   private void checkWrite ()
508   {
509     SecurityManager s = System.getSecurityManager();
510     if (s != null)
511       s.checkWrite(path);
512   }
513
514   private void checkRead ()
515   {
516     SecurityManager s = System.getSecurityManager();
517     if (s != null)
518       s.checkRead(path);
519   }
520
521   /** 
522     * Add this File to the set of files to be deleted upon normal
523     * termination.
524     *
525     * @since 1.2 
526     */
527   // FIXME: This should use the ShutdownHook API once we implement that.
528   public void deleteOnExit ()
529   {
530     SecurityManager sm = System.getSecurityManager ();
531     if (sm != null)
532       sm.checkDelete (getName ());
533
534     FileDeleter.add (this);
535   }
536
537   private void writeObject (ObjectOutputStream oos) throws IOException
538   {
539     oos.defaultWriteObject ();
540     oos.writeChar (separatorChar);
541   }
542
543   private void readObject (ObjectInputStream ois)
544     throws ClassNotFoundException, IOException
545   {
546     ois.defaultReadObject ();
547
548     // If the file was from an OS with a different dir separator,
549     // fixup the path to use the separator on this OS.
550     char oldSeparatorChar = ois.readChar ();
551     if (oldSeparatorChar != separatorChar)
552       path = path.replace (oldSeparatorChar, separatorChar);
553   }
554
555   // QUERY arguments to access function.
556   private final static int READ = 0;
557   private final static int WRITE = 1;
558   private final static int EXISTS = 2;
559
560   // QUERY arguments to stat function.
561   private final static int DIRECTORY = 0;
562   private final static int ISFILE = 1;
563   private final static int ISHIDDEN = 2;
564
565   // QUERY arguments to attr function.
566   private final static int MODIFIED = 0;
567   private final static int LENGTH = 1;
568   
569   private final native long attr (int query);
570   // On OSF1 V5.0, `stat' is a macro.  It is easiest to use the name
571   // `_stat' instead.  We do the same thing for `_access' just in
572   // case.
573   private final native boolean _access (int query);
574   private final native boolean _stat (int query);
575
576   private static final long serialVersionUID = 301077366599181567L;
577 }