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 / RandomAccessFile.c < prev   
C/C++ Source or Header  |  1996-09-28  |  4KB  |  167 lines
  1. /*
  2.  * java.io.RandomAccessFile.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 <stdio.h>
  15. #include <assert.h>
  16. #if defined(HAVE_UNISTD_H)
  17. #include <unistd.h>
  18. #endif
  19. #include "defs.h"
  20. #include "files.h"
  21. #include "java.io.stubs/RandomAccessFile.h"
  22. #include "java.io.stubs/FileDescriptor.h"
  23. #include "kthread.h"
  24.  
  25. /*
  26.  * Open a file for random access.
  27.  */
  28. void
  29. java_io_RandomAccessFile_open(struct Hjava_io_RandomAccessFile* this, struct Hjava_lang_String* name, jint /* bool */ rw)
  30. {
  31.     int fd;
  32.     char str[MAXPATHLEN];
  33.  
  34.     javaString2CString(name, str, sizeof(str));
  35.  
  36.     fd = threadedOpen(str, (rw == 0 ? O_RDONLY : O_RDWR|O_CREAT)|O_BINARY, 0666);
  37.     unhand(unhand(this)->fd)->fd = fd;
  38.     if (fd < 0) {
  39.         SignalError(0, "java.io.IOException", SYS_ERROR);
  40.     }
  41. }
  42.  
  43. /*
  44.  * Return length of file.
  45.  */
  46. jlong
  47. java_io_RandomAccessFile_length(struct Hjava_io_RandomAccessFile* this)
  48. {
  49.     struct stat buf;
  50.     int r;
  51.  
  52.     r = fstat(unhand(unhand(this)->fd)->fd, &buf);
  53.     if (r < 0) {
  54.         SignalError(0, "java.io.IOException", SYS_ERROR);
  55.     }
  56.     return (off_t2jlong(buf.st_size));
  57. }
  58.  
  59. /*
  60.  * Seek into file.
  61.  */
  62. void
  63. java_io_RandomAccessFile_seek(struct Hjava_io_RandomAccessFile* this, jlong pos)
  64. {
  65.     int r;
  66.  
  67.     r = lseek(unhand(unhand(this)->fd)->fd, jlong2off_t(pos), SEEK_SET);
  68.     if (r < 0) {
  69.         SignalError(0, "java.io.IOException", SYS_ERROR);
  70.     }
  71. }
  72.  
  73. /*
  74.  * Read in bytes from file.
  75.  */
  76. jint
  77. java_io_RandomAccessFile_readBytes(struct Hjava_io_RandomAccessFile* this, HArrayOfByte* bytes, jint off, jint len)
  78. {
  79.     jint ret;
  80.  
  81.     ret = threadedRead(unhand(unhand(this)->fd)->fd, &unhand(bytes)->body[off], len);
  82.     if (ret < 0) {
  83.         SignalError(0, "java.io.IOException", SYS_ERROR);
  84.     }
  85.     return (ret > 0 ? ret : -1);
  86. }
  87.  
  88. /*
  89.  * Read a byte from file.
  90.  */
  91. jint
  92. java_io_RandomAccessFile_read(struct Hjava_io_RandomAccessFile* this)
  93. {
  94.     jint ret;
  95.     unsigned char byte;
  96.  
  97.     ret = threadedRead(unhand(unhand(this)->fd)->fd, &byte, 1);
  98.     if (ret < 0) {
  99.         SignalError(0, "java.io.IOException", SYS_ERROR);
  100.     }
  101.  
  102.     return (ret > 0 ? byte : -1);
  103. }
  104.  
  105. /*
  106.  * Write a byte to file.
  107.  */
  108. void
  109. java_io_RandomAccessFile_write(struct Hjava_io_RandomAccessFile* this, jint data)
  110. {
  111.     jint ret;
  112.     unsigned char byte;
  113.  
  114.     byte = data;
  115.  
  116.     ret = threadedWrite(unhand(unhand(this)->fd)->fd, &byte, 1);
  117.     if (ret < 0) {
  118.         SignalError(0, "java.io.IOException", SYS_ERROR);
  119.     }
  120. }
  121.  
  122. /*
  123.  * Write a number of bytes to file.
  124.  */
  125. void
  126. java_io_RandomAccessFile_writeBytes(struct Hjava_io_RandomAccessFile* this, HArrayOfByte* bytes, jint off, jint len)
  127. {
  128.     jint ret;
  129.  
  130.     ret = threadedWrite(unhand(unhand(this)->fd)->fd, &unhand(bytes)->body[off], len);
  131.     if (ret < 0) {
  132.         SignalError(0, "java.io.IOException", SYS_ERROR);
  133.     }
  134. }
  135.  
  136. /*
  137.  * Get current file position.
  138.  */
  139. jlong
  140. java_io_RandomAccessFile_getFilePointer(struct Hjava_io_RandomAccessFile* this)
  141. {
  142.     off_t r;
  143.  
  144.     r = lseek(unhand(unhand(this)->fd)->fd, 0, SEEK_CUR);
  145.     if (r < 0) {
  146.         SignalError(0, "java.io.IOException", SYS_ERROR);
  147.     }
  148.     return (off_t2jlong(r));
  149. }
  150.  
  151. /*
  152.  * Close file.
  153.  */
  154. void
  155. java_io_RandomAccessFile_close(struct Hjava_io_RandomAccessFile* this)
  156. {
  157.     int r;
  158.  
  159.     if (unhand(unhand(this)->fd)->fd >= 0) {
  160.         r = close(unhand(unhand(this)->fd)->fd);
  161.         unhand(unhand(this)->fd)->fd = -1;
  162.         if (r < 0) {
  163.             SignalError(0, "java.io.IOException", SYS_ERROR);
  164.         }
  165.     }
  166. }
  167.