/[classpath]/classpath/native/jni/java-io/java_io_File.c
ViewVC logotype

Diff of /classpath/native/jni/java-io/java_io_File.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.6 by rupp, Wed Jun 11 10:55:48 2003 UTC revision 1.7 by rupp, Wed Jul 9 08:14:18 2003 UTC
# Line 35  this exception to your version of the li Line 35  this exception to your version of the li
35  obligated to do so.  If you do not wish to do so, delete this  obligated to do so.  If you do not wish to do so, delete this
36  exception statement from your version. */  exception statement from your version. */
37    
38    /* do not move; needed here because of some macro definitions */
39    #include <config.h>
40    
41  #include <stdio.h>  #include <stdio.h>
42  #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  
 #include <errno.h>  
 #include <sys/types.h>  
 #include <fcntl.h>  
 #include <utime.h>  
 #include <unistd.h>  
 #include <sys/stat.h>  
 #include <dirent.h>  
43    
44  #include <jni.h>  #include <jni.h>
45  #include <jcl.h>  #include <jcl.h>
46    
47    #include "target_native.h"
48    #ifndef WITHOUT_FILESYSTEM
49      #include "target_native_file.h"
50    #endif
51    #include "target_native_math_int.h"
52    
53  #include "javaio.h"  #include "javaio.h"
54    
55  #include "java_io_File.h"  #include "java_io_File.h"
# Line 66  exception statement from your version. * Line 67  exception statement from your version. *
67  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
68  Java_java_io_File_createInternal(JNIEnv *env, jclass clazz, jstring name)  Java_java_io_File_createInternal(JNIEnv *env, jclass clazz, jstring name)
69  {  {
70    const char *fname;  #ifndef WITHOUT_FILESYSTEM
71    int fd;    const char *filename;
72      int        fd;
73      int        result;
74    
75    fname = JCL_jstring_to_cstring(env, name);    filename = JCL_jstring_to_cstring(env, name);
76    if (!fname)    if (filename == NULL)
77      return(0);      {
78          return(0);
79        }
80    
81    fd = open(fname, O_CREAT|O_EXCL|O_RDWR, 0777);    TARGET_NATIVE_FILE_OPEN_CREATE(filename,fd,result);
82    if (fd == -1)    if (result != TARGET_NATIVE_OK)
83      {      {
84    //??? NYI
85        if (errno != EEXIST)        if (errno != EEXIST)
86          JCL_ThrowException(env, "java/io/IOException", strerror(errno));          JCL_ThrowException(env,
87                               "java/io/IOException",
88                               TARGET_NATIVE_LAST_ERROR_STRING());
89        return(0);        return(0);
90      }      }
91      TARGET_NATIVE_FILE_CLOSE(fd,result);
92    
   close(fd);  
93    return(1);    return(1);
94    #else /* not WITHOUT_FILESYSTEM */
95      return(0);
96    #endif /* not WITHOUT_FILESYSTEM */
97  }  }
98    
99  /*************************************************************************/  /*************************************************************************/
# Line 98  Java_java_io_File_createInternal(JNIEnv Line 109  Java_java_io_File_createInternal(JNIEnv
109  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
110  Java_java_io_File_canReadInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_canReadInternal(JNIEnv *env, jobject obj, jstring name)
111  {  {
112    const char *fname;  #ifndef WITHOUT_FILESYSTEM
113    int fd;    const char *filename;
114      int        fd;
115      int        result;
116    
117    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
118       on failure */       on failure */
119    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
120    if (!fname)    if (filename == NULL)
121      return(0);      {
122          return(0);
123        }
124    
125    /* The lazy man's way out.  We actually do open the file for reading    /* The lazy man's way out.  We actually do open the file for reading
126       briefly to verify it can be done */         briefly to verify it can be done */  
127    fd = open(fname, O_RDONLY);    TARGET_NATIVE_FILE_OPEN_READ(filename,fd,result);
128    (*env)->ReleaseStringUTFChars(env, name, fname);    (*env)->ReleaseStringUTFChars(env, name, filename);
129      if (result != TARGET_NATIVE_OK)
130    if (fd == -1)      {
131      return(0);        return(0);
132        }
133      TARGET_NATIVE_FILE_CLOSE(fd,result);
134    
   close(fd);  
135    return(1);    return(1);
136    #else /* not WITHOUT_FILESYSTEM */
137      return(0);
138    #endif /* not WITHOUT_FILESYSTEM */
139  }    }  
140    
141  /*************************************************************************/  /*************************************************************************/
# Line 132  Java_java_io_File_canReadInternal(JNIEnv Line 151  Java_java_io_File_canReadInternal(JNIEnv
151  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
152  Java_java_io_File_canWriteInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_canWriteInternal(JNIEnv *env, jobject obj, jstring name)
153  {  {
154    const char *fname;  #ifndef WITHOUT_FILESYSTEM
155    int fd;    const char *filename;
156      int        fd;
157      int        result;
158    
159    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
160       on failure */       on failure */
161    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
162    if (!fname)    if (filename == NULL)
163      return(0);      {
164          return(0);
165        }
166    
167    /* The lazy man's way out.  We actually do open the file for writing    /* The lazy man's way out.  We actually do open the file for writing
168       briefly to verify it can be done */         briefly to verify it can be done */  
169    fd = open(fname, O_RDWR);    TARGET_NATIVE_FILE_OPEN_READWRITE(filename,fd,result);
170    (*env)->ReleaseStringUTFChars(env, name, fname);    (*env)->ReleaseStringUTFChars(env, name, filename);
171      if (result != TARGET_NATIVE_OK)
172    if (fd == -1)      {
173      return(0);        return(0);
174        }
175      TARGET_NATIVE_FILE_CLOSE(fd,result);
176    
   close(fd);  
177    return(1);    return(1);
178    #else /* not WITHOUT_FILESYSTEM */
179      return(0);
180    #endif /* not WITHOUT_FILESYSTEM */
181  }    }  
182    
183  /*************************************************************************/  /*************************************************************************/
# Line 166  Java_java_io_File_canWriteInternal(JNIEn Line 193  Java_java_io_File_canWriteInternal(JNIEn
193  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
194  Java_java_io_File_setReadOnlyInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_setReadOnlyInternal(JNIEnv *env, jobject obj, jstring name)
195  {  {
196    const char *fname;  #ifndef WITHOUT_FILESYSTEM
197    struct stat buf;    const char *filename;
198    mode_t newmode;    int        result;
   int rc;  
199    
200    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
201       on failure */       on failure */
202    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
203    if (!fname)    if (filename == NULL)
     return(0);  
   
   rc = stat(fname, &buf);  
   
   if (rc == -1)  
204      {      {
       (*env)->ReleaseStringUTFChars(env, name, fname);  
205        return(0);        return(0);
206      }      }
207    
208    newmode = buf.st_mode;    TARGET_NATIVE_FILE_SET_MODE_READONLY(filename,result);
209    newmode = newmode & (~(S_IWRITE|S_IWGRP|S_IWOTH));    (*env)->ReleaseStringUTFChars(env, name, filename);
210    
211    rc = chmod(fname, newmode);    return ((result == TARGET_NATIVE_OK)?1:0);
212    (*env)->ReleaseStringUTFChars(env, name, fname);  #else /* not WITHOUT_FILESYSTEM */
213      return(0);
214    if (rc == -1)  #endif /* not WITHOUT_FILESYSTEM */
     return(0);  
   else  
     return(1);  
215  }    }  
216    
217  /*************************************************************************/  /*************************************************************************/
# Line 210  Java_java_io_File_setReadOnlyInternal(JN Line 227  Java_java_io_File_setReadOnlyInternal(JN
227  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
228  Java_java_io_File_existsInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_existsInternal(JNIEnv *env, jobject obj, jstring name)
229  {  {
230    const char *fname;  #ifndef WITHOUT_FILESYSTEM
231    struct stat buf;    const char *filename;
232    int rc;    int        result;
233        
234    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
235       on failure */       on failure */
236    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
237    if (!fname)    if (filename == NULL)
238      return(0);      {
239          return(0);
240        }
241    
242    rc = stat(fname, &buf);    TARGET_NATIVE_FILE_EXISTS(filename,result);
243    (*env)->ReleaseStringUTFChars(env, name, fname);    (*env)->ReleaseStringUTFChars(env, name, filename);
244    
245    if (rc == -1)    return ((result == TARGET_NATIVE_OK)?1:0);
246      return(0);  #else /* not WITHOUT_FILESYSTEM */
247    else    return(0);
248      return(1);  #endif /* not WITHOUT_FILESYSTEM */
249  }  }
250    
251  /*************************************************************************/  /*************************************************************************/
# Line 243  Java_java_io_File_existsInternal(JNIEnv Line 262  Java_java_io_File_existsInternal(JNIEnv
262  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
263  Java_java_io_File_isFileInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_isFileInternal(JNIEnv *env, jobject obj, jstring name)
264  {  {
265    const char *fname;  #ifndef WITHOUT_FILESYSTEM
266    struct stat buf;    const char *filename;
267    int rc;    int        result;
268        
269    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
270       on failure */       on failure */
271    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
272    if (!fname)    if (filename == NULL)
273      return(0);      {
274          return(0);
275    rc = stat(fname, &buf);      }
276    (*env)->ReleaseStringUTFChars(env, name, fname);  
277      TARGET_NATIVE_FILE_IS_FILE(filename,result);
278      (*env)->ReleaseStringUTFChars(env, name, filename);
279    
280    if (rc == -1)    return ((result == TARGET_NATIVE_OK)?1:0);
281      return(0);  #else /* not WITHOUT_FILESYSTEM */
282    if (S_ISREG(buf.st_mode))    return(0);
283      return(1);  #endif /* not WITHOUT_FILESYSTEM */
   else  
     return(0);  
284  }  }
285    
286  /*************************************************************************/  /*************************************************************************/
# Line 277  Java_java_io_File_isFileInternal(JNIEnv Line 296  Java_java_io_File_isFileInternal(JNIEnv
296  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
297  Java_java_io_File_isDirectoryInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_isDirectoryInternal(JNIEnv *env, jobject obj, jstring name)
298  {  {
299    const char *fname;  #ifndef WITHOUT_FILESYSTEM
300    struct stat buf;    const char *filename;
301    int rc;    int        result;
302        
303    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
304       on failure */       on failure */
305    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
306    if (!fname)    if (filename == NULL)
307      return(0);      {
308          return(0);
309    rc = stat(fname, &buf);      }
310    (*env)->ReleaseStringUTFChars(env, name, fname);  
311      TARGET_NATIVE_FILE_IS_DIRECTORY(filename,result);
312      (*env)->ReleaseStringUTFChars(env, name, filename);
313    
314    if (rc == -1)    return ((result == TARGET_NATIVE_OK)?1:0);
315      return(0);  #else /* not WITHOUT_FILESYSTEM */
316    if (S_ISDIR(buf.st_mode))    return(0);
317      return(1);  #endif /* not WITHOUT_FILESYSTEM */
   else  
     return(0);  
318  }  }
319    
320  /*************************************************************************/  /*************************************************************************/
# Line 311  Java_java_io_File_isDirectoryInternal(JN Line 330  Java_java_io_File_isDirectoryInternal(JN
330  JNIEXPORT jlong JNICALL  JNIEXPORT jlong JNICALL
331  Java_java_io_File_lengthInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_lengthInternal(JNIEnv *env, jobject obj, jstring name)
332  {  {
333    const char *fname;  #ifndef WITHOUT_FILESYSTEM
334    struct stat buf;    const char *filename;
335    int rc;    int        tmpfd;
336      jlong      length;
337      int        result;
338        
339    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
340       on failure */       on failure */
341    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
342    if (!fname)    if (filename == NULL)
343      return(0);      {
344          return(JNI_JLONG_CONST_0);
345        }
346    
347    rc = stat(fname, &buf);    /* open file for reading, get size and close file */
348    (*env)->ReleaseStringUTFChars(env, name, fname);    TARGET_NATIVE_FILE_OPEN_READ(filename,tmpfd,result);
349      if (result != TARGET_NATIVE_OK)
350    if (rc == -1)      {
351      return(0);        return(JNI_JLONG_CONST_0);
352        }
353      TARGET_NATIVE_FILE_SIZE(tmpfd,length,result);  
354      if (result != TARGET_NATIVE_OK)
355        {
356          TARGET_NATIVE_FILE_CLOSE(tmpfd,result);
357          return(JNI_JLONG_CONST_0);
358        }
359      TARGET_NATIVE_FILE_CLOSE(tmpfd,result);
360      (*env)->ReleaseStringUTFChars(env, name, filename);
361    
362    return(buf.st_size);    return ((result == TARGET_NATIVE_OK)?length:JNI_JLONG_CONST_0);
363    #else /* not WITHOUT_FILESYSTEM */
364      return(JNI_JLONG_CONST_0);
365    #endif /* not WITHOUT_FILESYSTEM */
366  }  }
367    
368  /*************************************************************************/  /*************************************************************************/
# Line 343  Java_java_io_File_lengthInternal(JNIEnv Line 378  Java_java_io_File_lengthInternal(JNIEnv
378  JNIEXPORT jlong JNICALL  JNIEXPORT jlong JNICALL
379  Java_java_io_File_lastModifiedInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_lastModifiedInternal(JNIEnv *env, jobject obj, jstring name)
380  {  {
381    const char *fname;  #ifndef WITHOUT_FILESYSTEM
382    struct stat buf;    const char *filename;
383    int rc;    jlong      mtime;
384    jlong mtime;    int        result;
385    
386    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
387       on failure */       on failure */
388    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
389    if (!fname)    if (filename == NULL)
390      return(0);      {
391          return(0);
392        }
393    
394    rc = stat(fname, &buf);    TARGET_NATIVE_FILE_GET_LAST_MODIFIED(filename,mtime,result);
395    (*env)->ReleaseStringUTFChars(env, name, fname);    (*env)->ReleaseStringUTFChars(env, name, filename);
396    
397    if (rc == -1)    return ((result == TARGET_NATIVE_OK)?mtime:JNI_JLONG_CONST_0);
398      return(0);  #else /* not WITHOUT_FILESYSTEM */
399      return(JNI_JLONG_CONST_0);
400    // milliseconds required  #endif /* not WITHOUT_FILESYSTEM */
   mtime = buf.st_mtime;  
   mtime = mtime * 1000;  
   return(mtime);  
401  }  }
402    
403  /*************************************************************************/  /*************************************************************************/
# Line 380  JNIEXPORT jboolean JNICALL Line 414  JNIEXPORT jboolean JNICALL
414  Java_java_io_File_setLastModifiedInternal(JNIEnv *env, jobject obj,  Java_java_io_File_setLastModifiedInternal(JNIEnv *env, jobject obj,
415                                            jstring name, jlong newtime)                                            jstring name, jlong newtime)
416  {  {
417    const char *fname;  #ifndef WITHOUT_FILESYSTEM
418    struct stat buf;    const char *filename;
419    struct utimbuf ut;    int        result;
   int rc;  
420        
421    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
422       on failure */       on failure */
423    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
424    if (!fname)    if (filename == NULL)
     return(0);  
   
   rc = stat(fname, &buf);  
   
   if (rc == -1)  
425      {      {
       (*env)->ReleaseStringUTFChars(env, name, fname);  
426        return(0);        return(0);
427      }      }
428    
429      TARGET_NATIVE_FILE_SET_LAST_MODIFIED(filename,newtime,result);
430      (*env)->ReleaseStringUTFChars(env, name, filename);
431    
432    ut.actime = buf.st_atime;    return ((result == TARGET_NATIVE_OK)?1:0);
433    ut.modtime = buf.st_mtime;  #else /* not WITHOUT_FILESYSTEM */
434      return(0);
435    rc = utime(fname, &ut);  #endif /* not WITHOUT_FILESYSTEM */
   (*env)->ReleaseStringUTFChars(env, name, fname);  
   
   if (rc == -1)  
     return(0);  
   else  
     return(1);  
436  }  }
437    
438  /*************************************************************************/  /*************************************************************************/
# Line 425  Java_java_io_File_setLastModifiedInterna Line 449  Java_java_io_File_setLastModifiedInterna
449  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
450  Java_java_io_File_deleteInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_deleteInternal(JNIEnv *env, jobject obj, jstring name)
451  {  {
452    const char *fname;  #ifndef WITHOUT_FILESYSTEM
453    int rc;    const char *filename;
454      int        result;
455        
456    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
457       on failure */       on failure */
458    fname = (*env)->GetStringUTFChars(env, name, 0);    filename = (*env)->GetStringUTFChars(env, name, 0);
459    if (!fname)    if (filename == NULL)
460      return(0);      {
461          return(0);
462        }
463    
464    rc = unlink(fname);    TARGET_NATIVE_FILE_DELETE(filename,result);
465    if (rc == -1)    (*env)->ReleaseStringUTFChars(env, name, filename);
466       rc = rmdir(fname);  
467    (*env)->ReleaseStringUTFChars(env, name, fname);    return ((result == TARGET_NATIVE_OK)?1:0);
468    #else /* not WITHOUT_FILESYSTEM */
469    if (rc == -1)    return(0);
470      return(0);  #endif /* not WITHOUT_FILESYSTEM */
   else  
     return(1);  
471  }  }
472    
473  /*************************************************************************/  /*************************************************************************/
# Line 458  Java_java_io_File_deleteInternal(JNIEnv Line 483  Java_java_io_File_deleteInternal(JNIEnv
483  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
484  Java_java_io_File_mkdirInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_mkdirInternal(JNIEnv *env, jobject obj, jstring name)
485  {  {
486    const char *fname;  #ifndef WITHOUT_FILESYSTEM
487    int rc;    const char *pathname;
488      int        result;
489        
490    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
491       on failure */       on failure */
492    fname = (*env)->GetStringUTFChars(env, name, 0);    pathname = (*env)->GetStringUTFChars(env, name, 0);
493    if (!fname)    if (pathname == NULL)
494      return(0);      {
495          return(0);
496        }
497    
498    rc = mkdir(fname, 0777);    TARGET_NATIVE_FILE_MAKE_DIR(pathname,result);
499    (*env)->ReleaseStringUTFChars(env, name, fname);    (*env)->ReleaseStringUTFChars(env, name, pathname);
500    
501    if (rc == -1)    return ((result == TARGET_NATIVE_OK)?1:0);
502      return(0);  #else /* not WITHOUT_FILESYSTEM */
503    else    return(0);
504      return(1);  #endif /* not WITHOUT_FILESYSTEM */
505  }  }
506    
507  /*************************************************************************/  /*************************************************************************/
# Line 489  Java_java_io_File_mkdirInternal(JNIEnv * Line 517  Java_java_io_File_mkdirInternal(JNIEnv *
517  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
518  Java_java_io_File_renameToInternal(JNIEnv *env, jobject obj, jstring t, jstring d)  Java_java_io_File_renameToInternal(JNIEnv *env, jobject obj, jstring t, jstring d)
519  {  {
520    const char *target, *destination;  #ifndef WITHOUT_FILESYSTEM
521    int rc;    const char *old_filename, *new_filename;
522      int        result;
523        
524    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
525       on failure */       on failure */
526    target = (*env)->GetStringUTFChars(env, t, 0);    old_filename = (*env)->GetStringUTFChars(env, t, 0);
527    if (!target)    if (old_filename == NULL)
528      return(0);      {
529          return(0);
530        }
531    
532    destination = (*env)->GetStringUTFChars(env, d, 0);    new_filename = (*env)->GetStringUTFChars(env, d, 0);
533    if (!destination)    if (new_filename == NULL)
534      {      {
535        (*env)->ReleaseStringUTFChars(env, t, target);        (*env)->ReleaseStringUTFChars(env, t, old_filename);
536        return(0);        return(0);
537      }      }
538    
539    rc = rename(target, destination);    TARGET_NATIVE_FILE_RENAME(old_filename,new_filename,result);
540    (*env)->ReleaseStringUTFChars(env, t, target);    (*env)->ReleaseStringUTFChars(env, d, new_filename);
541    (*env)->ReleaseStringUTFChars(env, d, destination);    (*env)->ReleaseStringUTFChars(env, t, old_filename);
542    
543    if (rc == -1)    return ((result == TARGET_NATIVE_OK)?1:0);
544      return(0);  #else /* not WITHOUT_FILESYSTEM */
545    else    return(0);
546      return(1);  #endif /* not WITHOUT_FILESYSTEM */
547  }  }
548    
549  /*************************************************************************/  /*************************************************************************/
# Line 529  Java_java_io_File_renameToInternal(JNIEn Line 560  Java_java_io_File_renameToInternal(JNIEn
560  JNIEXPORT jobjectArray JNICALL  JNIEXPORT jobjectArray JNICALL
561  Java_java_io_File_listInternal(JNIEnv *env, jobject obj, jstring name)  Java_java_io_File_listInternal(JNIEnv *env, jobject obj, jstring name)
562  {  {
563    static jclass str_clazz = 0;  #ifndef WITHOUT_FILESYSTEM
564    int  realloc_size = 10;    const int REALLOC_SIZE = 10;
565    const char *dirname;  
566    char **filelist;    const char        *dirname;
567    jobjectArray retarray;    int               result;
568    DIR *dir;    char              **filelist;
569    struct dirent *dirent;    void              *handle;
570    int i, j;    const char        *filename;
571        unsigned long int filelist_count,max_filelist_count;
572      char              **tmp_filelist;
573      jclass            str_clazz;
574      jobjectArray      filearray;
575      unsigned long int i;
576      jstring           str;
577    
578    /* Don't use the JCL convert function because it throws an exception    /* Don't use the JCL convert function because it throws an exception
579       on failure */       on failure */
580    dirname = (*env)->GetStringUTFChars(env, name, 0);    dirname = (*env)->GetStringUTFChars(env, name, 0);
581    if (!dirname)    if (dirname == NULL)
582      return(0);      {
583          return(0);
584        }
585    
586      /* open directory for reading */
587      TARGET_NATIVE_FILE_OPEN_DIR(dirname,handle,result);
588    
   /* Read the files from the directory */  
   filelist = (char **)JCL_malloc(env, sizeof(char *) * realloc_size);  
   //filelist = (char **)malloc(sizeof(char *) * realloc_size);  
   dir = opendir(dirname);  
589    (*env)->ReleaseStringUTFChars(env, name, dirname);    (*env)->ReleaseStringUTFChars(env, name, dirname);
   if (!filelist || !dir)  
     return(0);  
590    
591    for (i = 0;;)    if (result != TARGET_NATIVE_OK)
592      {      {
593        dirent = readdir(dir);        return(0);
594        if (!dirent)      }
595          break;  
596      /* allocate filelist */
597        if (!strcmp(dirent->d_name, ".") || !strcmp(dirent->d_name, ".."))    filelist = (char **)JCL_malloc(env, sizeof(char *) * REALLOC_SIZE);
598          continue;    if (filelist==NULL)
599        {
600        /* Allocate more memory if necessary */        TARGET_NATIVE_FILE_CLOSE_DIR(handle,result);
601        if ((((i + 1) % realloc_size) == 0) && (i != 0))        return(0);
602        }
603      filelist_count=0;
604      max_filelist_count=REALLOC_SIZE;
605    
606      /* read the files from the directory */
607      TARGET_NATIVE_FILE_READ_DIR(handle,filename,result);
608      while (result == TARGET_NATIVE_OK)
609        {
610          if ((strcmp(filename, ".")!=0) && (strcmp(filename, "..")!=0))
611          {          {
612            char **newlist;            /* allocate more memory if necessary */
613              if (filelist_count >= max_filelist_count)
           newlist = JCL_realloc(env, filelist, ((i + 1) + realloc_size) *  
                                 sizeof(char *));  
           //newlist = realloc(filelist, (i + 1) + realloc_size);  
           if (!filelist)  
614              {              {
615                free(filelist);                tmp_filelist = (char**)JCL_realloc(env,
616                return(0);                                                   filelist,
617                                                     (max_filelist_count + REALLOC_SIZE) * sizeof(char*));
618                  if (tmp_filelist==NULL)
619                    {
620                      for (i = 0; i < filelist_count; i++)
621                        {
622                          JCL_free(env,filelist[i]);
623                        }
624                      JCL_free(env,filelist);
625                      TARGET_NATIVE_FILE_CLOSE_DIR(handle,result);
626                      return(0);
627                    }
628                  filelist           = tmp_filelist;
629                  max_filelist_count += REALLOC_SIZE;
630              }              }
631            filelist = newlist;  
632          }              /* save entry in list (avoid strdup, because it is not ANSI C, thus difficult to port) */
633                filelist[filelist_count]=(char*)JCL_malloc(env,strlen(filename)+1);
634        filelist[i] = strdup(dirent->d_name);              assert(filelist[filelist_count]!=NULL);
635        ++i;              strcpy(filelist[filelist_count],filename);
636                filelist_count++;
637              }
638    
639          /* read next directory entry */
640          TARGET_NATIVE_FILE_READ_DIR(handle,filename,result);
641      }      }
   closedir(dir);  
642    
643    /* Now put the list of files into a Java String array and return it */    /* close directory */
644      TARGET_NATIVE_FILE_CLOSE_DIR(handle,result);
645    
646      /* put the list of files into a Java String array and return it */
647    str_clazz = (*env)->FindClass(env, "java/lang/String");    str_clazz = (*env)->FindClass(env, "java/lang/String");
648    if (!str_clazz)    if (str_clazz==NULL)
649      {      {
650        free(filelist);        for (i = 0; i < filelist_count; i++)
651            {
652              JCL_free(env,filelist[i]);
653            }
654          JCL_free(env,filelist);
655        return(0);        return(0);
656      }      }
657      filearray = (*env)->NewObjectArray(env, filelist_count, str_clazz, 0);
658    retarray = (*env)->NewObjectArray(env, i, str_clazz, 0);    if (filearray==NULL)
   if (!retarray)  
659      {      {
660        free(filelist);        for (i = 0; i < filelist_count; i++)
661            {
662              JCL_free(env,filelist[i]);
663            }
664          JCL_free(env,filelist);
665        return(0);        return(0);
666      }      }
667      for (i = 0; i < filelist_count; i++)
   for (j = 0; j < i; j++)  
668      {      {
669        jstring str;        /* create new string */
670          str = (*env)->NewStringUTF(env, filelist[i]);
671        str = (*env)->NewStringUTF(env, filelist[j]);        if (str==NULL)
       if (!str)        
672          {          {
673             /* We don't clean up everything here, but if this failed,            /* We don't clean up everything here, but if this failed,
674                something serious happened anyway */                something serious happened anyway */
675            free(filelist);            for (i = 0; i < filelist_count; i++)
676                {
677                  JCL_free(env,filelist[i]);
678                }
679              JCL_free(env,filelist);
680            return(0);            return(0);
681          }          }
682    
683        (*env)->SetObjectArrayElement(env, retarray, j, str);        /* save into array */
684          (*env)->SetObjectArrayElement(env, filearray, i, str);
685        }
686    
687      /* free resources */
688      for (i = 0; i < filelist_count; i++)
689        {
690          JCL_free(env,filelist[i]);
691      }      }
692      JCL_free(env,filelist);
693    
694    return(retarray);    return(filearray);
695    #else /* not WITHOUT_FILESYSTEM */
696      return(0);
697    #endif /* not WITHOUT_FILESYSTEM */
698  }  }
699    

Legend:
Removed from v.1.6  
changed lines
  Added in v.1.7

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26