home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / kaffe-0.5p4-src.tgz / tar.out / contrib / kaffe / lib / native / java.io / File.c next >
Encoding:
C/C++ Source or Header  |  1996-09-28  |  5.3 KB  |  300 lines
  1. /*
  2.  * java.io.File.c
  3.  *
  4.  * Copyright (c) 1996 Systems Architecture Research Centre,
  5.  *           City University, London, UK.
  6.  *
  7.  * See the file "license.terms" for information on usage and redistribution
  8.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  9.  *
  10.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, February 1996.
  11.  */
  12.  
  13. #include "config.h"
  14. #include <sys/types.h>
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <assert.h>
  18. #include <native.h>
  19. #include "defs.h"
  20. #include "files.h"
  21. #include "system.h"
  22. #include "java.io.stubs/File.h"
  23.  
  24. #if defined(HAVE_DIRENT_H)
  25. # include <dirent.h>
  26. # define NAMLEN(dirent) (strlen((dirent)->d_name))
  27. #else
  28. # define dirent direct
  29. # define NAMLEN(dirent) ((dirent)->d_namlen)
  30. # if defined(HAVE_SYS_NDIR_H)
  31. #  include <sys/ndir.h>
  32. # endif
  33. # if defined(HAVE_NDIR_H)
  34. #  include <ndir.h>
  35. # endif
  36. #endif
  37. /* This may nolonger be necessary */
  38. #if defined(HAVE_DIR_H)
  39. #include <dir.h>
  40. #endif
  41.  
  42. #if !defined(S_ISDIR)
  43. #define    S_ISDIR(m)    ((m) & S_IFDIR)
  44. #endif
  45. #if !defined(S_ISREG)
  46. #define    S_ISREG(m)    ((m) & S_IFREG)
  47. #endif
  48.  
  49. /*
  50.  * Is named item a file?
  51.  */
  52. jint /* bool */
  53. java_io_File_isFile0(struct Hjava_io_File* this)
  54. {
  55.     struct stat buf;
  56.     char str[MAXPATHLEN];
  57.     int r;
  58.  
  59.     javaString2CString(unhand(this)->path, str, sizeof(str));
  60.  
  61.     r = stat(str, &buf);
  62.     if (r == 0 && S_ISREG(buf.st_mode)) {
  63.         return (1);
  64.     }
  65.     else {
  66.         return (0);
  67.     }
  68. }
  69.  
  70. /*
  71.  * Is named item a directory?
  72.  */
  73. jint /* bool */
  74. java_io_File_isDirectory0(struct Hjava_io_File* this)
  75. {
  76.     struct stat buf;
  77.     char str[MAXPATHLEN];
  78.     int r;
  79.  
  80.     javaString2CString(unhand(this)->path, str, sizeof(str));
  81.  
  82.     r = stat(str, &buf);
  83.     if (r == 0 & S_ISDIR(buf.st_mode)) {
  84.         return (1);
  85.     }
  86.     else {
  87.         return (0);
  88.     }
  89. }
  90.  
  91. /*
  92.  * Does named file exist?
  93.  */
  94. jint /* bool */
  95. java_io_File_exists0(struct Hjava_io_File* this)
  96. {
  97.     struct stat buf;
  98.     char str[MAXPATHLEN];
  99.     int r;
  100.  
  101.     javaString2CString(unhand(this)->path, str, sizeof(str));
  102.  
  103.     r = stat(str, &buf);
  104.     if (r < 0) {
  105.         return (0);
  106.     }
  107.     else {
  108.         return (1);
  109.     }
  110. }
  111.  
  112. /*
  113.  * Last modified time on file.
  114.  */
  115. jlong
  116. java_io_File_lastModified0(struct Hjava_io_File* this)
  117. {
  118.     struct stat buf;
  119.     char str[MAXPATHLEN];
  120.     int r;
  121.  
  122.     javaString2CString(unhand(this)->path, str, sizeof(str));
  123.  
  124.     r = stat(str, &buf);
  125.     if (r != 0) {
  126.         return (off_t2jlong(0));
  127.     }
  128. #if defined(HAVE_NATIVE_INT64)
  129.     return (buf.st_mtime * (jlong)1000);
  130. #else
  131.     return (off_t2jlong(buf.st_mtime * 1000));    /* HACK */
  132. #endif
  133. }
  134.  
  135. /*
  136.  * Can I write to this file?
  137.  */
  138. jint /* bool */
  139. java_io_File_canWrite0(struct Hjava_io_File* this)
  140. {
  141.     char str[MAXPATHLEN];
  142.     int r;
  143.  
  144.     javaString2CString(unhand(this)->path, str, sizeof(str));
  145.     r = access(str, W_OK);
  146.     return (r == 0 ? 1 : 0);
  147. }
  148.  
  149. /*
  150.  * Can I read from this file.
  151.  */
  152. jint /* bool */
  153. java_io_File_canRead0(struct Hjava_io_File* this)
  154. {
  155.     char str[MAXPATHLEN];
  156.     int r;
  157.  
  158.     javaString2CString(unhand(this)->path, str, sizeof(str));
  159.     r = access(str, R_OK);
  160.     return (r == 0 ? 1 : 0);
  161. }
  162.  
  163. /*
  164.  * Return length of file.
  165.  */
  166. jlong
  167. java_io_File_length0(struct Hjava_io_File* this)
  168. {
  169.     struct stat buf;
  170.     char str[MAXPATHLEN];
  171.     int r;
  172.  
  173.     javaString2CString(unhand(this)->path, str, sizeof(str));
  174.  
  175.     r = stat(str, &buf);
  176.     return (off_t2jlong(r == 0 ? buf.st_size : 0));
  177. }
  178.  
  179. /*
  180.  * Create a directory.
  181.  */
  182. jint /* bool */
  183. java_io_File_mkdir0(struct Hjava_io_File* this)
  184. {
  185.     char str[MAXPATHLEN];
  186.     int r;
  187.  
  188.     javaString2CString(unhand(this)->path, str, sizeof(str));
  189. #if defined(__WIN32__)
  190.     r = mkdir(str);
  191. #else
  192.     r = mkdir(str, 0777);
  193. #endif
  194.     return (r);
  195. }
  196.  
  197. /*
  198.  * Rename a file.
  199.  */
  200. jint /* bool */
  201. java_io_File_renameTo0(struct Hjava_io_File* this, struct Hjava_io_File* that)
  202. {
  203.     char str[MAXPATHLEN];
  204.     char str2[MAXPATHLEN];
  205.     int r;
  206.  
  207.     javaString2CString(unhand(this)->path, str, sizeof(str));
  208.     javaString2CString(unhand(that)->path, str2, sizeof(str2));
  209.  
  210.     r = rename(str, str2);
  211.     return (r);
  212. }
  213.  
  214. /*
  215.  * Delete a file.
  216.  */
  217. jint /* bool */
  218. java_io_File_delete0(struct Hjava_io_File* this)
  219. {
  220.     char str[MAXPATHLEN];
  221.     int r;
  222.  
  223.     javaString2CString(unhand(this)->path, str, sizeof(str));
  224.     r = remove(str);
  225.     return(r);
  226. }
  227.  
  228. /*
  229.  * Get a directory listing.
  230.  */
  231. HArrayOfObject* /* [Ljava.lang.String; */
  232. java_io_File_list0(struct Hjava_io_File* this)
  233. {
  234.     char path[MAXPATHLEN];
  235.     DIR* dir;
  236.     struct dirent* entry;
  237.     struct dentry {
  238.         struct dentry* next;
  239.         struct Hjava_lang_String* name;
  240.     };
  241.     struct dentry* dirlist;
  242.     struct dentry* mentry;
  243.     HArrayOfObject* array;
  244.     int count;
  245.     int i;
  246.  
  247.     javaString2CString(unhand(this)->path, path, sizeof(path));
  248.  
  249.     dir = opendir(path);
  250.     if (dir == 0) {
  251.         return (0);
  252.     }
  253.  
  254.     dirlist = 0;
  255.     count = 0;
  256.     while ((entry = readdir(dir)) != 0) {
  257.         /* We skip '.' and '..' */
  258.         if (strcmp(".", entry->d_name) == 0 ||
  259.             strcmp("..", entry->d_name) == 0) {
  260.             continue;
  261.         }
  262.         mentry = malloc(sizeof(struct dentry));
  263.         assert(mentry != 0);
  264.         mentry->name = makeJavaString(entry->d_name, NAMLEN(entry));
  265.         mentry->next = dirlist;
  266.         dirlist = mentry;
  267.         count++;
  268.     }
  269.     closedir(dir);
  270.  
  271.     array = (HArrayOfObject*)AllocObjectArray(count, "java/lang/String");
  272.     assert(array != 0);
  273.     for (i = 0; i < count; i++) {
  274.         mentry = dirlist;
  275.         dirlist = mentry->next;
  276.         unhand(array)->body[i] = (object*)mentry->name;
  277.         free(mentry);
  278.     }
  279.  
  280.     return (array);
  281. }
  282.  
  283. /*
  284.  * Is this filename absolute?
  285.  */
  286. jint /* bool */
  287. java_io_File_isAbsolute(struct Hjava_io_File* this)
  288. {
  289.     char str[2];
  290.  
  291.     javaString2CString(unhand(this)->path, str, sizeof(str));
  292.  
  293.     if (str[0] == file_seperator[0]) {
  294.         return (1);
  295.     }
  296.     else {
  297.         return (0);
  298.     }
  299. }
  300.