/[classpath]/classpath/native/jni/java-nio/gnu_java_nio_channels_FileChannelImpl.c
ViewVC logotype

Diff of /classpath/native/jni/java-nio/gnu_java_nio_channels_FileChannelImpl.c

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

revision 1.12.2.2 by gnu_andrew, Sun Jan 16 15:15:14 2005 UTC revision 1.12.2.3 by gnu_andrew, Mon Apr 18 01:37:43 2005 UTC
# Line 46  exception statement from your version. * Line 46  exception statement from your version. *
46    
47  #include "target_native.h"  #include "target_native.h"
48  #ifndef WITHOUT_FILESYSTEM  #ifndef WITHOUT_FILESYSTEM
49    #include "target_native_file.h"  #include "target_native_file.h"
50  #endif  #endif
51  #include "target_native_math_int.h"  #include "target_native_math_int.h"
52    
# Line 91  exception statement from your version. * Line 91  exception statement from your version. *
91  static jfieldID native_fd_fieldID;  static jfieldID native_fd_fieldID;
92    
93  static jint  static jint
94  get_native_fd (JNIEnv *env, jobject obj)  get_native_fd (JNIEnv * env, jobject obj)
95  {  {
96    return (*env)->GetIntField (env, obj, native_fd_fieldID);    return (*env)->GetIntField (env, obj, native_fd_fieldID);
97  }  }
# Line 101  get_native_fd (JNIEnv *env, jobject obj) Line 101  get_native_fd (JNIEnv *env, jobject obj)
101   * static initialization.   * static initialization.
102   */   */
103  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
104  Java_gnu_java_nio_channels_FileChannelImpl_init (JNIEnv *env, jclass clazz)  Java_gnu_java_nio_channels_FileChannelImpl_init (JNIEnv * env, jclass clazz)
105  {  {
106    jclass clazz_fc;    jclass clazz_fc;
107    jfieldID field;    jfieldID field;
# Line 112  Java_gnu_java_nio_channels_FileChannelIm Line 112  Java_gnu_java_nio_channels_FileChannelIm
112    clazz_fc = (*env)->FindClass (env, "gnu/java/nio/channels/FileChannelImpl");    clazz_fc = (*env)->FindClass (env, "gnu/java/nio/channels/FileChannelImpl");
113    if (!clazz_fc)    if (!clazz_fc)
114      {      {
115        JCL_ThrowException(env, IO_EXCEPTION, "Internal error");        JCL_ThrowException (env, IO_EXCEPTION, "Internal error");
116        return;        return;
117      }      }
118    
119    field = (*env)->GetFieldID (env, clazz_fc, "fd", "I");    field = (*env)->GetFieldID (env, clazz_fc, "fd", "I");
120    if (!field)    if (!field)
121      {      {
122        JCL_ThrowException(env, IO_EXCEPTION, "Internal error");                  JCL_ThrowException (env, IO_EXCEPTION, "Internal error");
123        return;        return;
124      }      }
125    
126    native_fd_fieldID = field;    native_fd_fieldID = field;
127    
128    constructor = (*env)->GetMethodID (env, clazz, "<init>", "(II)V");    constructor = (*env)->GetMethodID (env, clazz, "<init>", "(II)V");
129    if (! constructor)    if (!constructor)
130      return;      return;
131    
132  #define INIT_FIELD(FIELDNAME, FDVALUE, MODE)                            \  #define INIT_FIELD(FIELDNAME, FDVALUE, MODE)                            \
# Line 152  Java_gnu_java_nio_channels_FileChannelIm Line 152  Java_gnu_java_nio_channels_FileChannelIm
152   * Open the specified file and return a native file descriptor   * Open the specified file and return a native file descriptor
153   */   */
154  JNIEXPORT jint JNICALL  JNIEXPORT jint JNICALL
155  Java_gnu_java_nio_channels_FileChannelImpl_open (JNIEnv *env,  Java_gnu_java_nio_channels_FileChannelImpl_open (JNIEnv * env,
156                                                   jobject obj                                                   jobject obj
157                                                   __attribute__ ((__unused__)),                                                   __attribute__ ((__unused__)),
158                                                   jstring name, jint mode)                                                   jstring name, jint mode)
159  {  {
160    const char *filename;    const char *filename;
161    int        flags;    int flags;
162    int        permissions;    int permissions;
163    int        native_fd;    int native_fd;
164    int        result;    int result;
165    
166    filename = JCL_jstring_to_cstring(env, name);    filename = JCL_jstring_to_cstring (env, name);
167    if (filename == NULL)    if (filename == NULL)
168      return(-1); /* Exception will already have been thrown */      return (-1);                /* Exception will already have been thrown */
169    
170    /* get file/permission flags for open() */    /* get file/permission flags for open() */
171    if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_READ) && (mode & FILECHANNELIMPL_FILEOPEN_FLAG_WRITE))    if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_READ)
172          && (mode & FILECHANNELIMPL_FILEOPEN_FLAG_WRITE))
173      {      {
174        /* read/write */        /* read/write */
175        flags       = TARGET_NATIVE_FILE_FILEFLAG_CREATE | TARGET_NATIVE_FILE_FILEFLAG_READWRITE;        flags =
176            TARGET_NATIVE_FILE_FILEFLAG_CREATE |
177            TARGET_NATIVE_FILE_FILEFLAG_READWRITE;
178        permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL;        permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL;
179      }      }
180    else if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_READ))    else if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_READ))
181      {      {
182        /* read */        /* read */
183        flags       = TARGET_NATIVE_FILE_FILEFLAG_READ;        flags = TARGET_NATIVE_FILE_FILEFLAG_READ;
184        permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL;        permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL;
185      }      }
186    else    else
187      {      {
188        /* write */        /* write */
189        flags       = TARGET_NATIVE_FILE_FILEFLAG_CREATE | TARGET_NATIVE_FILE_FILEFLAG_WRITE;        flags =
190            TARGET_NATIVE_FILE_FILEFLAG_CREATE |
191            TARGET_NATIVE_FILE_FILEFLAG_WRITE;
192        if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_APPEND))        if ((mode & FILECHANNELIMPL_FILEOPEN_FLAG_APPEND))
193          {          {
194             flags |= TARGET_NATIVE_FILE_FILEFLAG_APPEND;            flags |= TARGET_NATIVE_FILE_FILEFLAG_APPEND;
195          }          }
196        else        else
197          {          {
198             flags |= TARGET_NATIVE_FILE_FILEFLAG_TRUNCATE;            flags |= TARGET_NATIVE_FILE_FILEFLAG_TRUNCATE;
199          }          }
200        permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL;        permissions = TARGET_NATIVE_FILE_FILEPERMISSION_NORMAL;
201      }      }
202    
# Line 208  Java_gnu_java_nio_channels_FileChannelIm Line 213  Java_gnu_java_nio_channels_FileChannelIm
213    flags |= TARGET_NATIVE_FILE_FILEFLAG_BINARY;    flags |= TARGET_NATIVE_FILE_FILEFLAG_BINARY;
214  #endif  #endif
215    
216    TARGET_NATIVE_FILE_OPEN(filename,native_fd,flags,permissions,result);    TARGET_NATIVE_FILE_OPEN (filename, native_fd, flags, permissions, result);
217    JCL_free_cstring(env, name, filename);    JCL_free_cstring (env, name, filename);
218    
219    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
220      {      {
221        /* We can only throw FileNotFoundException.  */        /* We can only throw FileNotFoundException.  */
222        JCL_ThrowException(env,        JCL_ThrowException (env,
223                           "java/io/FileNotFoundException",                            "java/io/FileNotFoundException",
224                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
225        return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;        return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;
226      }      }
227    
# Line 228  Java_gnu_java_nio_channels_FileChannelIm Line 233  Java_gnu_java_nio_channels_FileChannelIm
233   * Exception on error   * Exception on error
234   */   */
235  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
236  Java_gnu_java_nio_channels_FileChannelImpl_implCloseChannel (JNIEnv *env, jobject obj)  Java_gnu_java_nio_channels_FileChannelImpl_implCloseChannel (JNIEnv * env,
237                                                                 jobject obj)
238  {  {
239    int native_fd;    int native_fd;
240    int result;    int result;
241    
242    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
243    
244    TARGET_NATIVE_FILE_CLOSE(native_fd,result);    TARGET_NATIVE_FILE_CLOSE (native_fd, result);
245    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
246      {      {
247        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
248                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
249      }      }
250  }  }
251    
# Line 248  Java_gnu_java_nio_channels_FileChannelIm Line 254  Java_gnu_java_nio_channels_FileChannelIm
254   * Exception on error   * Exception on error
255   */   */
256  JNIEXPORT jint JNICALL  JNIEXPORT jint JNICALL
257  Java_gnu_java_nio_channels_FileChannelImpl_available (JNIEnv *env, jobject obj)  Java_gnu_java_nio_channels_FileChannelImpl_available (JNIEnv * env,
258                                                          jobject obj)
259  {  {
260    int   native_fd;    int native_fd;
261    jlong bytes_available;    jlong bytes_available;
262    int   result;    int result;
263    
264    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
265    
266    TARGET_NATIVE_FILE_AVAILABLE(native_fd,bytes_available,result);    TARGET_NATIVE_FILE_AVAILABLE (native_fd, bytes_available, result);
267    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
268      {      {
269        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
270                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
271        return 0;        return 0;
272      }      }
273    
274    /* FIXME NYI ??? why only jint and not jlong? */    /* FIXME NYI ??? why only jint and not jlong? */
275    return TARGET_NATIVE_MATH_INT_INT64_TO_INT32(bytes_available);    return TARGET_NATIVE_MATH_INT_INT64_TO_INT32 (bytes_available);
276  }  }
277    
278  JNIEXPORT jlong JNICALL  JNIEXPORT jlong JNICALL
279  Java_gnu_java_nio_channels_FileChannelImpl_size (JNIEnv *env, jobject obj)  Java_gnu_java_nio_channels_FileChannelImpl_size (JNIEnv * env, jobject obj)
280  {  {
281    int   native_fd;    int native_fd;
282    jlong file_size;    jlong file_size;
283    int   result;    int result;
284    
285    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
286    
287    TARGET_NATIVE_FILE_SIZE(native_fd, file_size, result);    TARGET_NATIVE_FILE_SIZE (native_fd, file_size, result);
288    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
289      {      {
290        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
291                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
292        return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;        return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;
293      }      }
294    
# Line 293  Java_gnu_java_nio_channels_FileChannelIm Line 300  Java_gnu_java_nio_channels_FileChannelIm
300   * Exception on error   * Exception on error
301   */   */
302  JNIEXPORT jlong JNICALL  JNIEXPORT jlong JNICALL
303  Java_gnu_java_nio_channels_FileChannelImpl_implPosition (JNIEnv *env, jobject obj)  Java_gnu_java_nio_channels_FileChannelImpl_implPosition (JNIEnv * env,
304                                                             jobject obj)
305  {  {
306    int   native_fd;    int native_fd;
307    jlong current_offset;    jlong current_offset;
308    int   result;    int result;
309    
310    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
311    
312    TARGET_NATIVE_FILE_TELL(native_fd, current_offset, result);    TARGET_NATIVE_FILE_TELL (native_fd, current_offset, result);
313    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
314      {      {
315        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
316                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
317        return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;        return TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;
318      }      }
319    
# Line 317  Java_gnu_java_nio_channels_FileChannelIm Line 325  Java_gnu_java_nio_channels_FileChannelIm
325   * Exception on error   * Exception on error
326   */   */
327  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
328  Java_gnu_java_nio_channels_FileChannelImpl_seek (JNIEnv *env, jobject obj, jlong offset)  Java_gnu_java_nio_channels_FileChannelImpl_seek (JNIEnv * env, jobject obj,
329                                                     jlong offset)
330  {  {
331    int   native_fd;    int native_fd;
332    jlong new_offset;    jlong new_offset;
333    int   result;    int result;
334    
335    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
336    
337  #if 0  #if 0
338    /* Should there be such an exception? All native layer macros should    /* Should there be such an exception? All native layer macros should
# Line 334  Java_gnu_java_nio_channels_FileChannelIm Line 343  Java_gnu_java_nio_channels_FileChannelIm
343       to handle 64bit-values the system is limited to 32bit at all, thus       to handle 64bit-values the system is limited to 32bit at all, thus
344       the application can not do a seek() or something else beyond the       the application can not do a seek() or something else beyond the
345       32bit limit. It this true?       32bit limit. It this true?
346    */     */
347    
348    /* FIXME: What do we do if offset > the max value of off_t on this 32bit    /* FIXME: What do we do if offset > the max value of off_t on this 32bit
349     * system?  How do we detect that and what do we do? */     * system?  How do we detect that and what do we do? */
350    if (CONVERT_OFF_T_TO_JLONG(native_offset) != offset)    if (CONVERT_OFF_T_TO_JLONG (native_offset) != offset)
351      {      {
352        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
353                           "Cannot represent position correctly on this system");                            "Cannot represent position correctly on this system");
354      }      }
355  #endif /* 0 */  #endif /* 0 */
356    
357    result = TARGET_NATIVE_ERROR;    result = TARGET_NATIVE_ERROR;
358    new_offset = TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;    new_offset = TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1;
359    TARGET_NATIVE_FILE_SEEK_BEGIN(native_fd, offset, new_offset, result);    TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, offset, new_offset, result);
360    
361    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
362      {      {
363        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
364                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
365      }      }
366  }  }
367    
# Line 361  Java_gnu_java_nio_channels_FileChannelIm Line 370  Java_gnu_java_nio_channels_FileChannelIm
370   * Exception on error   * Exception on error
371   */   */
372  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
373  Java_gnu_java_nio_channels_FileChannelImpl_implTruncate (JNIEnv *env, jobject obj, jlong len)  Java_gnu_java_nio_channels_FileChannelImpl_implTruncate (JNIEnv * env,
374                                                             jobject obj,
375                                                             jlong len)
376  {  {
377    int   native_fd;    int native_fd;
378    jlong file_size;    jlong file_size;
379    int   bytes_written;    int bytes_written;
380    jlong save_offset,new_offset;    jlong save_offset, new_offset;
381    char  data;    char data;
382    int   result;    int result;
383    
384    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
385    
386  #if 0  #if 0
387    /* Should there be such an exception? All native layer macros should    /* Should there be such an exception? All native layer macros should
# Line 381  Java_gnu_java_nio_channels_FileChannelIm Line 392  Java_gnu_java_nio_channels_FileChannelIm
392       to handle 64bit-values the system is limited to 32bit at all, thus       to handle 64bit-values the system is limited to 32bit at all, thus
393       the application can not do a seek() or something else beyond the       the application can not do a seek() or something else beyond the
394       32bit limit. It this true?       32bit limit. It this true?
395    */     */
396    
397    /* FIXME: What do we do if len > the max value of off_t on this 32bit    /* FIXME: What do we do if len > the max value of off_t on this 32bit
398     * system?  How do we detect that and what do we do? */     * system?  How do we detect that and what do we do? */
399    if (CONVERT_OFF_T_TO_JLONG(native_len) != len)    if (CONVERT_OFF_T_TO_JLONG (native_len) != len)
400      {      {
401        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
402                           "Cannot represent position correctly on this system");                            "Cannot represent position correctly on this system");
403        return;        return;
404      }      }
405  #endif /* 0 */  #endif /* 0 */
406    
407    /* get file size */    /* get file size */
408    TARGET_NATIVE_FILE_SIZE(native_fd, file_size, result);    TARGET_NATIVE_FILE_SIZE (native_fd, file_size, result);
409    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
410      {      {
411        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
412                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
413        return;        return;
414      }      }
415    
416    /* Save off current position */    /* Save off current position */
417    TARGET_NATIVE_FILE_TELL(native_fd, save_offset, result);    TARGET_NATIVE_FILE_TELL (native_fd, save_offset, result);
418    if (result != TARGET_NATIVE_OK)    if (result != TARGET_NATIVE_OK)
419      {      {
420        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION,
421                           TARGET_NATIVE_LAST_ERROR_STRING());                            TARGET_NATIVE_LAST_ERROR_STRING ());
422        return;        return;
423      }      }
424    
425    if (TARGET_NATIVE_MATH_INT_INT64_LT(file_size,len))    if (TARGET_NATIVE_MATH_INT_INT64_LT (file_size, len))
426      {      {
427        /* File is too short -- seek to one byte short of where we want,        /* File is too short -- seek to one byte short of where we want,
428         * then write a byte */         * then write a byte */
429    
430        /* move to position n-1 */        /* move to position n-1 */
431        TARGET_NATIVE_FILE_SEEK_BEGIN(native_fd, TARGET_NATIVE_MATH_INT_INT64_SUB(len,1), new_offset, result);        TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd,
432                                         TARGET_NATIVE_MATH_INT_INT64_SUB (len,
433                                                                           1),
434                                         new_offset, result);
435        if (result != TARGET_NATIVE_OK)        if (result != TARGET_NATIVE_OK)
436          {          {
437            JCL_ThrowException(env, IO_EXCEPTION,            JCL_ThrowException (env, IO_EXCEPTION,
438                               TARGET_NATIVE_LAST_ERROR_STRING());                                TARGET_NATIVE_LAST_ERROR_STRING ());
439            return;            return;
440          }          }
441    
442        /* write a byte        /* write a byte
443           Note: This will fail if we somehow get here in read only mode           Note: This will fail if we somehow get here in read only mode
444         * That shouldn't happen */           * That shouldn't happen */
445        data='\0';        data = '\0';
446        TARGET_NATIVE_FILE_WRITE(native_fd, &data, 1, bytes_written, result);        TARGET_NATIVE_FILE_WRITE (native_fd, &data, 1, bytes_written, result);
447        if (result != TARGET_NATIVE_OK)        if (result != TARGET_NATIVE_OK)
448          {          {
449            JCL_ThrowException(env, IO_EXCEPTION,            JCL_ThrowException (env, IO_EXCEPTION,
450                               TARGET_NATIVE_LAST_ERROR_STRING());                                TARGET_NATIVE_LAST_ERROR_STRING ());
451            return;            return;
452          }          }
453    
454        /* Reposition file pointer to where we started if not beyond new len. */        /* Reposition file pointer to where we started if not beyond new len. */
455        if (TARGET_NATIVE_MATH_INT_INT64_LT(save_offset, len))        if (TARGET_NATIVE_MATH_INT_INT64_LT (save_offset, len))
456          {          {
457            TARGET_NATIVE_FILE_SEEK_BEGIN(native_fd, save_offset,            TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, save_offset,
458                                          new_offset, result);                                           new_offset, result);
459            if (result != TARGET_NATIVE_OK)            if (result != TARGET_NATIVE_OK)
460              {              {
461                JCL_ThrowException(env, IO_EXCEPTION,                JCL_ThrowException (env, IO_EXCEPTION,
462                                   TARGET_NATIVE_LAST_ERROR_STRING());                                    TARGET_NATIVE_LAST_ERROR_STRING ());
463                return;                return;
464              }              }
465          }          }
466      }      }
467      else if (TARGET_NATIVE_MATH_INT_INT64_GT(file_size,len))    else if (TARGET_NATIVE_MATH_INT_INT64_GT (file_size, len))
468      {      {
469        /* File is too long - use ftruncate if available */        /* File is too long - use ftruncate if available */
470  #ifdef HAVE_FTRUNCATE  #ifdef HAVE_FTRUNCATE
471        TARGET_NATIVE_FILE_TRUNCATE(native_fd, len, result);        TARGET_NATIVE_FILE_TRUNCATE (native_fd, len, result);
472        if (result != TARGET_NATIVE_OK)        if (result != TARGET_NATIVE_OK)
473        {          {
474          JCL_ThrowException(env, IO_EXCEPTION,            JCL_ThrowException (env, IO_EXCEPTION,
475                             TARGET_NATIVE_LAST_ERROR_STRING());                                TARGET_NATIVE_LAST_ERROR_STRING ());
476          return;            return;
477        }          }
478  #else /* HAVE_FTRUNCATE */  #else /* HAVE_FTRUNCATE */
479        /* FIXME: Probably operation isn't supported, but this exception        /* FIXME: Probably operation isn't supported, but this exception
480         * is too harsh as it will probably crash the program without need         * is too harsh as it will probably crash the program without need
481        JCL_ThrowException(env, "java/lang/UnsupportedOperationException",         JCL_ThrowException(env, "java/lang/UnsupportedOperationException",
482          "not implemented - can't shorten files on this platform");         "not implemented - can't shorten files on this platform");
483        */         */
484        JCL_ThrowException(env, IO_EXCEPTION,        JCL_ThrowException (env, IO_EXCEPTION, "Unable to shorten file length");
                          "Unable to shorten file length");  
485  #endif /* HAVE_FTRUNCATE */  #endif /* HAVE_FTRUNCATE */
486    
487        /* Reposition file pointer when it now is beyond the end of file. */        /* Reposition file pointer when it now is beyond the end of file. */
488        if (TARGET_NATIVE_MATH_INT_INT64_GT(save_offset, len))        if (TARGET_NATIVE_MATH_INT_INT64_GT (save_offset, len))
489          {          {
490            TARGET_NATIVE_FILE_SEEK_BEGIN(native_fd, len, new_offset, result);            TARGET_NATIVE_FILE_SEEK_BEGIN (native_fd, len, new_offset, result);
491            if (result != TARGET_NATIVE_OK)            if (result != TARGET_NATIVE_OK)
492              {              {
493                JCL_ThrowException(env, IO_EXCEPTION,                JCL_ThrowException (env, IO_EXCEPTION,
494                                   TARGET_NATIVE_LAST_ERROR_STRING());                                    TARGET_NATIVE_LAST_ERROR_STRING ());
495                return;                return;
496              }              }
497          }          }
# Line 486  Java_gnu_java_nio_channels_FileChannelIm Line 499  Java_gnu_java_nio_channels_FileChannelIm
499  }  }
500    
501  JNIEXPORT jobject JNICALL  JNIEXPORT jobject JNICALL
502  Java_gnu_java_nio_channels_FileChannelImpl_mapImpl(JNIEnv *env,  Java_gnu_java_nio_channels_FileChannelImpl_mapImpl (JNIEnv * env,
503                                                   jobject obj                                                      jobject obj
504                                                   __attribute__ ((__unused__)),                                                      __attribute__ ((__unused__)), jchar mode __attribute__ ((__unused__)), jlong position __attribute__ ((__unused__)), jint size __attribute__ ((__unused__)))
                                                  jchar mode  
                                                  __attribute__ ((__unused__)),  
                                                  jlong position  
                                                  __attribute__ ((__unused__)),  
                                                  jint size  
                                                  __attribute__ ((__unused__)))  
505  {  {
506    JCL_ThrowException (env, IO_EXCEPTION, "java.nio.FileChannelImpl.nio_mmap_file(): not implemented");    JCL_ThrowException (env, IO_EXCEPTION,
507                          "java.nio.FileChannelImpl.nio_mmap_file(): not implemented");
508    return 0;    return 0;
509  }  }
510    
# Line 505  Java_gnu_java_nio_channels_FileChannelIm Line 513  Java_gnu_java_nio_channels_FileChannelIm
513   * Return byte read or -1 on eof, exception on error   * Return byte read or -1 on eof, exception on error
514   */   */
515  JNIEXPORT jint JNICALL  JNIEXPORT jint JNICALL
516  Java_gnu_java_nio_channels_FileChannelImpl_read__ (JNIEnv *env, jobject obj)  Java_gnu_java_nio_channels_FileChannelImpl_read__ (JNIEnv * env, jobject obj)
517  {  {
518    int     native_fd;    int native_fd;
519    char    data;    char data;
520    ssize_t bytes_read;    ssize_t bytes_read;
521    int     result;    int result;
522    
523    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
524    
525    bytes_read = 0;    bytes_read = 0;
526    do    do
527      {      {
528        TARGET_NATIVE_FILE_READ(native_fd, &data, 1, bytes_read, result);        TARGET_NATIVE_FILE_READ (native_fd, &data, 1, bytes_read, result);
529        if ((result == TARGET_NATIVE_OK) && (bytes_read == 0))        if ((result == TARGET_NATIVE_OK) && (bytes_read == 0))
530          {          {
531            return(-1);            return (-1);
532          }          }
533        if ((result != TARGET_NATIVE_OK)        if ((result != TARGET_NATIVE_OK)
534            && (TARGET_NATIVE_LAST_ERROR() != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))            && (TARGET_NATIVE_LAST_ERROR () !=
535          {                TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
536            JCL_ThrowException(env,IO_EXCEPTION,          {
537                               TARGET_NATIVE_LAST_ERROR_STRING());            JCL_ThrowException (env, IO_EXCEPTION,
538            return(-1);                                TARGET_NATIVE_LAST_ERROR_STRING ());
539              return (-1);
540          }          }
541      }      }
542    while (bytes_read != 1);    while (bytes_read != 1);
543    
544    return((jint)(data & 0xFF));    return ((jint) (data & 0xFF));
545  }  }
546    
547  /*  /*
# Line 540  Java_gnu_java_nio_channels_FileChannelIm Line 549  Java_gnu_java_nio_channels_FileChannelIm
549   * Return number of bytes read or -1 on eof, exception on error   * Return number of bytes read or -1 on eof, exception on error
550   */   */
551  JNIEXPORT jint JNICALL  JNIEXPORT jint JNICALL
552  Java_gnu_java_nio_channels_FileChannelImpl_read___3BII (JNIEnv *env, jobject obj, jbyteArray buffer, jint offset, jint length)  Java_gnu_java_nio_channels_FileChannelImpl_read___3BII (JNIEnv * env,
553                                                            jobject obj,
554                                                            jbyteArray buffer,
555                                                            jint offset,
556                                                            jint length)
557  {  {
558    int     native_fd;    int native_fd;
559    jbyte   *bufptr;    jbyte *bufptr;
560    ssize_t bytes_read;    ssize_t bytes_read;
561    ssize_t n;    ssize_t n;
562    int     result;    int result;
563    
564    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
565    
566    /* Must return 0 if an attempt is made to read 0 bytes. */    /* Must return 0 if an attempt is made to read 0 bytes. */
567    if (length == 0)    if (length == 0)
568      return 0;      return 0;
569    
570    bufptr = (*env)->GetByteArrayElements(env, buffer, 0);    bufptr = (*env)->GetByteArrayElements (env, buffer, 0);
571    if (!bufptr)    if (!bufptr)
572      {      {
573        JCL_ThrowException(env, IO_EXCEPTION, "Unexpected JNI error");        JCL_ThrowException (env, IO_EXCEPTION, "Unexpected JNI error");
574        return(-1);        return (-1);
575      }      }
576    
577    bytes_read = 0;    bytes_read = 0;
578    do    do
579      {      {
580        TARGET_NATIVE_FILE_READ(native_fd, (bufptr + offset + bytes_read), (length - bytes_read), n, result);        TARGET_NATIVE_FILE_READ (native_fd, (bufptr + offset + bytes_read),
581                                   (length - bytes_read), n, result);
582        if ((result == TARGET_NATIVE_OK) && (n == 0))        if ((result == TARGET_NATIVE_OK) && (n == 0))
583          {          {
584            (*env)->ReleaseByteArrayElements(env, buffer, bufptr, 0);            (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0);
585            if (bytes_read == 0)            if (bytes_read == 0)
586              return -1; /* Signal end of file to Java */              return -1;          /* Signal end of file to Java */
587            else            else
588              return CONVERT_SSIZE_T_TO_JINT(bytes_read);              return CONVERT_SSIZE_T_TO_JINT (bytes_read);
589          }          }
590        if ((result != TARGET_NATIVE_OK)        if ((result != TARGET_NATIVE_OK)
591            && (TARGET_NATIVE_LAST_ERROR() != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))            && (TARGET_NATIVE_LAST_ERROR () !=
592          {                TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
593            JCL_ThrowException(env, IO_EXCEPTION,          {
594                               TARGET_NATIVE_LAST_ERROR_STRING());            JCL_ThrowException (env, IO_EXCEPTION,
595            (*env)->ReleaseByteArrayElements(env, buffer, bufptr, 0);                                TARGET_NATIVE_LAST_ERROR_STRING ());
596            return -1;            (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0);
597          }            return -1;
598            }
599        bytes_read += n;        bytes_read += n;
600      }      }
601    while (bytes_read < 1);    while (bytes_read < 1);
602    
603    (*env)->ReleaseByteArrayElements(env, buffer, bufptr, 0);    (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0);
604    return CONVERT_SSIZE_T_TO_JINT(bytes_read);    return CONVERT_SSIZE_T_TO_JINT (bytes_read);
605  }  }
606    
607  /*  /*
# Line 594  Java_gnu_java_nio_channels_FileChannelIm Line 609  Java_gnu_java_nio_channels_FileChannelIm
609   * Return status code, exception on error   * Return status code, exception on error
610   */   */
611  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
612  Java_gnu_java_nio_channels_FileChannelImpl_write__I (JNIEnv *env, jobject obj, jint b)  Java_gnu_java_nio_channels_FileChannelImpl_write__I (JNIEnv * env,
613                                                         jobject obj, jint b)
614  {  {
615    int     native_fd;    int native_fd;
616    char    native_data;    char native_data;
617    ssize_t bytes_written;    ssize_t bytes_written;
618    int     result;    int result;
619    
620    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
621    native_data = (char)(CONVERT_JINT_TO_INT(b) & 0xFF);    native_data = (char) (CONVERT_JINT_TO_INT (b) & 0xFF);
622    
623    do    do
624      {      {
625        TARGET_NATIVE_FILE_WRITE(native_fd, &native_data, 1, bytes_written, result);        TARGET_NATIVE_FILE_WRITE (native_fd, &native_data, 1, bytes_written,
626                                    result);
627        if ((result != TARGET_NATIVE_OK)        if ((result != TARGET_NATIVE_OK)
628            && (TARGET_NATIVE_LAST_ERROR() != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))            && (TARGET_NATIVE_LAST_ERROR () !=
629          {                TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
630            JCL_ThrowException(env, IO_EXCEPTION,          {
631                               TARGET_NATIVE_LAST_ERROR_STRING());            JCL_ThrowException (env, IO_EXCEPTION,
632                                  TARGET_NATIVE_LAST_ERROR_STRING ());
633          }          }
634      }      }
635    while (result != TARGET_NATIVE_OK);    while (result != TARGET_NATIVE_OK);
# Line 622  Java_gnu_java_nio_channels_FileChannelIm Line 640  Java_gnu_java_nio_channels_FileChannelIm
640   * Return status code, exception on error   * Return status code, exception on error
641   */   */
642  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
643  Java_gnu_java_nio_channels_FileChannelImpl_write___3BII (JNIEnv *env, jobject obj, jbyteArray buffer, jint offset, jint length)  Java_gnu_java_nio_channels_FileChannelImpl_write___3BII (JNIEnv * env,
644                                                             jobject obj,
645                                                             jbyteArray buffer,
646                                                             jint offset,
647                                                             jint length)
648  {  {
649    int     native_fd;    int native_fd;
650    jbyte   *bufptr;    jbyte *bufptr;
651    ssize_t bytes_written;    ssize_t bytes_written;
652    ssize_t n;    ssize_t n;
653    int     result;    int result;
654    
655    native_fd = get_native_fd(env, obj);    native_fd = get_native_fd (env, obj);
656    
657    /* Just return if an attempt is made to write 0 bytes. */    /* Just return if an attempt is made to write 0 bytes. */
658    if (length == 0)    if (length == 0)
659      return;      return;
660    
661    bufptr = (*env)->GetByteArrayElements(env, buffer, 0);    bufptr = (*env)->GetByteArrayElements (env, buffer, 0);
662    if (!bufptr)    if (!bufptr)
663      {      {
664        JCL_ThrowException(env, IO_EXCEPTION, "Unexpected JNI error");        JCL_ThrowException (env, IO_EXCEPTION, "Unexpected JNI error");
665        return;        return;
666      }      }
667    
668    bytes_written = 0;    bytes_written = 0;
669    while (bytes_written < CONVERT_JINT_TO_SSIZE_T(length))    while (bytes_written < CONVERT_JINT_TO_SSIZE_T (length))
670      {      {
671        TARGET_NATIVE_FILE_WRITE(native_fd, (bufptr + offset + bytes_written), (length - bytes_written), n, result);        TARGET_NATIVE_FILE_WRITE (native_fd, (bufptr + offset + bytes_written),
672                                    (length - bytes_written), n, result);
673        if ((result != TARGET_NATIVE_OK)        if ((result != TARGET_NATIVE_OK)
674            && (TARGET_NATIVE_LAST_ERROR() != TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))            && (TARGET_NATIVE_LAST_ERROR () !=
675          {                TARGET_NATIVE_ERROR_INTERRUPT_FUNCTION_CALL))
676            JCL_ThrowException(env, IO_EXCEPTION,          {
677                               TARGET_NATIVE_LAST_ERROR_STRING());            JCL_ThrowException (env, IO_EXCEPTION,
678            (*env)->ReleaseByteArrayElements(env, buffer, bufptr, 0);                                TARGET_NATIVE_LAST_ERROR_STRING ());
679            return;            (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0);
680              return;
681          }          }
682        bytes_written += n;        bytes_written += n;
683      }      }
684    
685    (*env)->ReleaseByteArrayElements(env, buffer, bufptr, 0);    (*env)->ReleaseByteArrayElements (env, buffer, bufptr, 0);
686  }  }
687    
688  JNIEXPORT jboolean JNICALL  JNIEXPORT jboolean JNICALL
689  Java_gnu_java_nio_channels_FileChannelImpl_lock(JNIEnv *env,  Java_gnu_java_nio_channels_FileChannelImpl_lock (JNIEnv * env,
690                                                  jobject obj                                                   jobject obj
691                                                  __attribute__ ((__unused__)),                                                   __attribute__ ((__unused__)),
692                                                  jlong position                                                   jlong position
693                                                  __attribute__ ((__unused__)),                                                   __attribute__ ((__unused__)),
694                                                  jlong size                                                   jlong size
695                                                  __attribute__ ((__unused__)),                                                   __attribute__ ((__unused__)),
696                                                  jboolean shared                                                   jboolean shared
697                                                  __attribute__ ((__unused__)),                                                   __attribute__ ((__unused__)),
698                                                  jboolean wait                                                   jboolean wait
699                                                  __attribute__ ((__unused__)))                                                   __attribute__ ((__unused__)))
700  {  {
701    JCL_ThrowException (env, IO_EXCEPTION, "java.nio.FileChannelImpl.lock(): not implemented");    JCL_ThrowException (env, IO_EXCEPTION,
702                          "java.nio.FileChannelImpl.lock(): not implemented");
703    return 0;    return 0;
704  }  }
705    
706  JNIEXPORT void JNICALL  JNIEXPORT void JNICALL
707  Java_gnu_java_nio_channels_FileChannelImpl_unlock(JNIEnv *env,  Java_gnu_java_nio_channels_FileChannelImpl_unlock (JNIEnv * env,
708                                                    jobject obj                                                     jobject obj
709                                                    __attribute__ ((__unused__)),                                                     __attribute__ ((__unused__)), jlong position __attribute__ ((__unused__)), jlong length __attribute__ ((__unused__)))
                                                   jlong position  
                                                   __attribute__ ((__unused__)),  
                                                   jlong length  
                                                   __attribute__ ((__unused__)))  
710  {  {
711    JCL_ThrowException (env, IO_EXCEPTION, "java.nio.FileChannelImpl.unlock(): not implemented");    JCL_ThrowException (env, IO_EXCEPTION,
712                          "java.nio.FileChannelImpl.unlock(): not implemented");
713  }  }

Legend:
Removed from v.1.12.2.2  
changed lines
  Added in v.1.12.2.3

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