diff options
Diffstat (limited to 'libjava/classpath/native/jni/java-io')
7 files changed, 1626 insertions, 0 deletions
diff --git a/libjava/classpath/native/jni/java-io/.cvsignore b/libjava/classpath/native/jni/java-io/.cvsignore new file mode 100644 index 00000000000..e9f2658a694 --- /dev/null +++ b/libjava/classpath/native/jni/java-io/.cvsignore @@ -0,0 +1,8 @@ +*.o +*.a +*.lo +*.la +.libs +.deps +Makefile +Makefile.in diff --git a/libjava/classpath/native/jni/java-io/Makefile.am b/libjava/classpath/native/jni/java-io/Makefile.am new file mode 100644 index 00000000000..5ed8a1baf4c --- /dev/null +++ b/libjava/classpath/native/jni/java-io/Makefile.am @@ -0,0 +1,13 @@ +pkglib_LTLIBRARIES = libjavaio.la + +libjavaio_la_SOURCES = javaio.h \ + javaio.c \ + java_io_VMFile.c \ + java_io_VMObjectInputStream.c \ + java_io_VMObjectStreamClass.c + +libjavaio_la_LIBADD = $(top_builddir)/native/jni/classpath/jcl.lo + +AM_LDFLAGS = @CLASSPATH_MODULE@ +AM_CPPFLAGS = @CLASSPATH_INCLUDES@ +AM_CFLAGS = @WARNING_CFLAGS@ @STRICT_WARNING_CFLAGS@ @ERROR_CFLAGS@ diff --git a/libjava/classpath/native/jni/java-io/java_io_VMFile.c b/libjava/classpath/native/jni/java-io/java_io_VMFile.c new file mode 100644 index 00000000000..b32c29477e0 --- /dev/null +++ b/libjava/classpath/native/jni/java-io/java_io_VMFile.c @@ -0,0 +1,734 @@ +/* java_io_VMFile.c - Native methods for java.io.File class + Copyright (C) 1998, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +/* do not move; needed here because of some macro definitions */ +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> + +#include <jni.h> +#include <jcl.h> + +#include "target_native.h" +#ifndef WITHOUT_FILESYSTEM +#include "target_native_file.h" +#endif +#include "target_native_math_int.h" + +#include "javaio.h" + +#include "java_io_VMFile.h" + +/*************************************************************************/ + +/* + * Method to create an empty file. + * + * Class: java_io_VMFile + * Method: create + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_create (JNIEnv * env, + jclass clazz __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int fd; + int result; + + filename = JCL_jstring_to_cstring (env, name); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_OPEN_CREATE (filename, fd, result); + if (result != TARGET_NATIVE_OK) + { + /* XXX ??? NYI */ + if (errno != EEXIST) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + JCL_free_cstring (env, name, filename); + return (0); + } + TARGET_NATIVE_FILE_CLOSE (fd, result); + + JCL_free_cstring (env, name, filename); + return (1); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method checks to see if we have read permission on a file. + * + * Class: java_io_VMFile + * Method: canRead + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_canRead (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int fd; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + /* The lazy man's way out. We actually do open the file for reading + briefly to verify it can be done */ + TARGET_NATIVE_FILE_OPEN_READ (filename, fd, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + if (result != TARGET_NATIVE_OK) + { + return (0); + } + TARGET_NATIVE_FILE_CLOSE (fd, result); + + return (1); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method checks to see if we have write permission on a file. + * + * Class: java_io_VMFile + * Method: canWrite + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_canWrite (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int fd; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + /* The lazy man's way out. We actually do open the file for writing + briefly to verify it can be done */ + TARGET_NATIVE_FILE_OPEN_READWRITE (filename, fd, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + if (result != TARGET_NATIVE_OK) + { + return (0); + } + TARGET_NATIVE_FILE_CLOSE (fd, result); + + return (1); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method makes a file read only. + * + * Class: java_io_VMFile + * Method: setReadOnly + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_setReadOnly (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_SET_MODE_READONLY (filename, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method checks to see if a file exists. + * + * Class: java_io_VMFile + * Method: exists + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_exists (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_EXISTS (filename, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method checks to see if a file is a "plain" file; that is, not + * a directory, pipe, etc. + * + * Class: java_io_VMFile + * Method: isFile + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_isFile (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_IS_FILE (filename, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method checks to see if a file is a directory or not. + * + * Class: java_io_VMFile + * Method: isDirectory + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_isDirectory (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_IS_DIRECTORY (filename, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method returns the length of the file. + * + * Class: java_io_VMFile + * Method: length + * Signature: (Ljava/lang/String;)J + */ + +JNIEXPORT jlong JNICALL +Java_java_io_VMFile_length (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int tmpfd; + jlong length; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); + } + + /* open file for reading, get size and close file */ + TARGET_NATIVE_FILE_OPEN_READ (filename, tmpfd, result); + if (result != TARGET_NATIVE_OK) + { + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); + } + TARGET_NATIVE_FILE_SIZE (tmpfd, length, result); + if (result != TARGET_NATIVE_OK) + { + TARGET_NATIVE_FILE_CLOSE (tmpfd, result); + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); + } + TARGET_NATIVE_FILE_CLOSE (tmpfd, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == + TARGET_NATIVE_OK) ? length : TARGET_NATIVE_MATH_INT_INT64_CONST_0); +#else /* not WITHOUT_FILESYSTEM */ + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method returns the modification date of the file. + * + * Class: java_io_VMFile + * Method: lastModified + * Signature: (Ljava/lang/String;)J + */ + +JNIEXPORT jlong JNICALL +Java_java_io_VMFile_lastModified (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + jlong mtime; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); + } + + TARGET_NATIVE_FILE_GET_LAST_MODIFIED (filename, mtime, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == + TARGET_NATIVE_OK) ? mtime : TARGET_NATIVE_MATH_INT_INT64_CONST_0); +#else /* not WITHOUT_FILESYSTEM */ + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method sets the modification date of the file. + * + * Class: java_io_VMFile + * Method: setLastModified + * Signature: (Ljava/lang/String;J)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_setLastModified (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name, jlong newtime) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_SET_LAST_MODIFIED (filename, newtime, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method deletes a file (actually a name for a file - additional + * links could exist). + * + * Class: java_io_VMFile + * Method: delete + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_delete (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + filename = (*env)->GetStringUTFChars (env, name, 0); + if (filename == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_DELETE (filename, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method creates a directory. + * + * Class: java_io_VMFile + * Method: mkdir + * Signature: (Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_mkdir (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *pathname; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + pathname = (*env)->GetStringUTFChars (env, name, 0); + if (pathname == NULL) + { + return (0); + } + + TARGET_NATIVE_FILE_MAKE_DIR (pathname, result); + (*env)->ReleaseStringUTFChars (env, name, pathname); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method renames a (link to a) file. + * + * Class: java_io_VMFile + * Method: renameTo + * Signature: (Ljava/lang/String;Ljava/lang/String;)Z + */ + +JNIEXPORT jboolean JNICALL +Java_java_io_VMFile_renameTo (JNIEnv * env, + jobject obj __attribute__ ((__unused__)), + jstring t, jstring d) +{ +#ifndef WITHOUT_FILESYSTEM + const char *old_filename, *new_filename; + int result; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + old_filename = (*env)->GetStringUTFChars (env, t, 0); + if (old_filename == NULL) + { + return (0); + } + + new_filename = (*env)->GetStringUTFChars (env, d, 0); + if (new_filename == NULL) + { + (*env)->ReleaseStringUTFChars (env, t, old_filename); + return (0); + } + + TARGET_NATIVE_FILE_RENAME (old_filename, new_filename, result); + (*env)->ReleaseStringUTFChars (env, d, new_filename); + (*env)->ReleaseStringUTFChars (env, t, old_filename); + + return ((result == TARGET_NATIVE_OK) ? 1 : 0); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * This method returns an array of String representing all the files + * in a directory except "." and "..". + * + * Class: java_io_VMFile + * Method: list + * Signature: (Ljava/lang/String;)[Ljava/lang/String; + */ + +JNIEXPORT jobjectArray JNICALL +Java_java_io_VMFile_list (JNIEnv * env, jobject obj + __attribute__ ((__unused__)), jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const int REALLOC_SIZE = 10; + + const char *dirname; + int result; + char **filelist; + void *handle; + const char *filename; + unsigned long int filelist_count, max_filelist_count; + char **tmp_filelist; + jclass str_clazz; + jobjectArray filearray; + unsigned long int i; + jstring str; + + /* Don't use the JCL convert function because it throws an exception + on failure */ + dirname = (*env)->GetStringUTFChars (env, name, 0); + if (dirname == NULL) + { + return (0); + } + + /* open directory for reading */ + TARGET_NATIVE_FILE_OPEN_DIR (dirname, handle, result); + + (*env)->ReleaseStringUTFChars (env, name, dirname); + + if (result != TARGET_NATIVE_OK) + { + return (0); + } + + /* allocate filelist */ + filelist = (char **) JCL_malloc (env, sizeof (char *) * REALLOC_SIZE); + if (filelist == NULL) + { + TARGET_NATIVE_FILE_CLOSE_DIR (handle, result); + return (0); + } + filelist_count = 0; + max_filelist_count = REALLOC_SIZE; + + /* read the files from the directory */ + TARGET_NATIVE_FILE_READ_DIR (handle, filename, result); + while (result == TARGET_NATIVE_OK) + { + if ((strcmp (filename, ".") != 0) && (strcmp (filename, "..") != 0)) + { + /* allocate more memory if necessary */ + if (filelist_count >= max_filelist_count) + { + tmp_filelist = (char **) JCL_realloc (env, + filelist, + (max_filelist_count + + REALLOC_SIZE) * + sizeof (char *)); + if (tmp_filelist == NULL) + { + for (i = 0; i < filelist_count; i++) + { + JCL_free (env, filelist[i]); + } + JCL_free (env, filelist); + TARGET_NATIVE_FILE_CLOSE_DIR (handle, result); + return (0); + } + filelist = tmp_filelist; + max_filelist_count += REALLOC_SIZE; + } + + /* save entry in list (avoid strdup, because it is not ANSI C, thus difficult to port) */ + filelist[filelist_count] = + (char *) JCL_malloc (env, strlen (filename) + 1); + assert (filelist[filelist_count] != NULL); + strcpy (filelist[filelist_count], filename); + filelist_count++; + } + + /* read next directory entry */ + TARGET_NATIVE_FILE_READ_DIR (handle, filename, result); + } + + /* close directory */ + TARGET_NATIVE_FILE_CLOSE_DIR (handle, result); + + /* put the list of files into a Java String array and return it */ + str_clazz = (*env)->FindClass (env, "java/lang/String"); + if (str_clazz == NULL) + { + for (i = 0; i < filelist_count; i++) + { + JCL_free (env, filelist[i]); + } + JCL_free (env, filelist); + return (0); + } + filearray = (*env)->NewObjectArray (env, filelist_count, str_clazz, 0); + if (filearray == NULL) + { + for (i = 0; i < filelist_count; i++) + { + JCL_free (env, filelist[i]); + } + JCL_free (env, filelist); + return (0); + } + for (i = 0; i < filelist_count; i++) + { + /* create new string */ + str = (*env)->NewStringUTF (env, filelist[i]); + if (str == NULL) + { + /* We don't clean up everything here, but if this failed, + something serious happened anyway */ + for (i = 0; i < filelist_count; i++) + { + JCL_free (env, filelist[i]); + } + JCL_free (env, filelist); + return (0); + } + + /* save into array */ + (*env)->SetObjectArrayElement (env, filearray, i, str); + + /* delete local reference */ + (*env)->DeleteLocalRef (env, str); + } + + /* free resources */ + for (i = 0; i < filelist_count; i++) + { + JCL_free (env, filelist[i]); + } + JCL_free (env, filelist); + + return (filearray); +#else /* not WITHOUT_FILESYSTEM */ + return (0); +#endif /* not WITHOUT_FILESYSTEM */ +} diff --git a/libjava/classpath/native/jni/java-io/java_io_VMObjectInputStream.c b/libjava/classpath/native/jni/java-io/java_io_VMObjectInputStream.c new file mode 100644 index 00000000000..d8d80714989 --- /dev/null +++ b/libjava/classpath/native/jni/java-io/java_io_VMObjectInputStream.c @@ -0,0 +1,69 @@ +/* java_io_VMObjectInputStream.c -- Native methods for ObjectInputStream class + Copyright (C) 1998, 2004, 2005 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +/* TODO: check exceptions */ +/* comments */ + +/* do not move; needed here because of some macro definitions */ +#include <config.h> + +#include <jni.h> +#include <jcl.h> + +#include "java_io_VMObjectInputStream.h" + +/* + * Class: java_io_VMObjectInputStream + * Method: allocateObject + * Signature: (Ljava/lang/Class;)Ljava/lang/Object; + */ +JNIEXPORT jobject JNICALL +Java_java_io_VMObjectInputStream_allocateObject (JNIEnv * env, + jclass clazz + __attribute__((__unused__)), + jclass target_clazz, + jclass constr_clazz, + jobject constructor) +{ + jobject obj = (*env)->AllocObject (env, target_clazz); + jmethodID id = (*env)->FromReflectedMethod (env, constructor); + + (*env)->CallNonvirtualVoidMethod (env, obj, constr_clazz, id); + + return obj; +} diff --git a/libjava/classpath/native/jni/java-io/java_io_VMObjectStreamClass.c b/libjava/classpath/native/jni/java-io/java_io_VMObjectStreamClass.c new file mode 100644 index 00000000000..8c2556bcf30 --- /dev/null +++ b/libjava/classpath/native/jni/java-io/java_io_VMObjectStreamClass.c @@ -0,0 +1,381 @@ +/* java_io_VMObjectStreamClass.c -- Native methods for VMObjectStreamClass.java + Copyright (C) 2003, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +#include <jni.h> +#include <jcl.h> + +#include <stdlib.h> +#include <string.h> + +#include "java_io_VMObjectStreamClass.h" + +/* + * Class: java_io_VMObjectOutputStream + * Method: hasClassInitializer + * Signature: (Ljava/lang/Class;)Z + */ +JNIEXPORT jboolean JNICALL +Java_java_io_VMObjectStreamClass_hasClassInitializer (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), jclass klass) +{ + jmethodID mid = (*env)->GetStaticMethodID (env, klass, "<clinit>", "()V"); + if (mid == NULL) + { + (*env)->ExceptionClear (env); + return JNI_FALSE; + } + return JNI_TRUE; +} + +static void +throwInternalError (JNIEnv * env) +{ + jclass internalErrorClass; + jthrowable previousException, newException; + jmethodID initException, getMessageID, initCauseID; + jstring message; + + internalErrorClass = (*env)->FindClass (env, "java/lang/InternalError"); + /** Just give up if this also fails. */ + if (internalErrorClass == NULL) + return; + + previousException = (*env)->ExceptionOccurred (env); + + if (previousException == NULL) + { + (*env)->ThrowNew (env, internalErrorClass, + "Unknown error raised by the VM"); + return; + } + + initException = (*env)->GetMethodID + (env, internalErrorClass, "<init>", "(Ljava/lang/String;)V"); + getMessageID = (*env)->GetMethodID + (env, (*env)->GetObjectClass (env, previousException), + "getMessage", "()Ljava/lang/String;"); + initCauseID = (*env)->GetMethodID + (env, internalErrorClass, "initCause", "(Ljava/lang/Throwable;)V"); + + message = (*env)->CallObjectMethod (env, previousException, getMessageID); + + newException = (*env)->NewObject (env, internalErrorClass, initException, + message); + (*env)->CallVoidMethod (env, newException, initCauseID, previousException); + + (*env)->ExceptionClear (env); + (*env)->Throw (env, newException); +} + +static jfieldID +getFieldReference (JNIEnv * env, jobject field, const char *type) +{ + jclass classClass; + jclass fieldClass; + jclass declaringClass; + jclass typeClass; + jfieldID fid; + const char *field_name; + const char *type_name; + int type_len; + jmethodID mid; + jstring name; + jstring tname; + int i; + + fieldClass = (*env)->GetObjectClass (env, field); + + mid = + (*env)->GetMethodID (env, fieldClass, "getName", "()Ljava/lang/String;"); + if (mid == NULL || (*env)->ExceptionOccurred (env) != NULL) + { + throwInternalError (env); + return NULL; + } + + name = (*env)->CallObjectMethod (env, field, mid); + field_name = (*env)->GetStringUTFChars (env, name, NULL); + + mid = (*env)->GetMethodID (env, fieldClass, + "getDeclaringClass", "()Ljava/lang/Class;"); + if (mid == NULL || (*env)->ExceptionOccurred (env) != NULL) + { + throwInternalError (env); + return NULL; + } + + declaringClass = (*env)->CallObjectMethod (env, field, mid); + + /* Do we need to find out the exact type descriptor of the field? */ + if (type == NULL) + { + char *the_type; + + mid = (*env)->GetMethodID (env, fieldClass, + "getType", "()Ljava/lang/Class;"); + + if (mid == NULL || (*env)->ExceptionOccurred (env) != NULL) + { + throwInternalError (env); + return NULL; + } + + typeClass = (*env)->CallObjectMethod (env, field, mid); + classClass = (*env)->FindClass (env, "java/lang/Class"); + + mid = (*env)->GetMethodID (env, classClass, + "getName", "()Ljava/lang/String;"); + + if (mid == NULL || (*env)->ExceptionOccurred (env) != NULL) + { + throwInternalError (env); + return NULL; + } + + tname = (*env)->CallObjectMethod (env, typeClass, mid); + type_name = (*env)->GetStringUTFChars (env, tname, NULL); + + /* + * If it isn't an array class then the actual field type descriptor + * starts with 'L', ends with ';' and has '/' instead of '.'. + */ + type_len = strlen ((char *) type_name); + if (type_name[0] != '[') + { + /* XXX - FIXME - should not use dynamic allocation in core lib. */ + the_type = (char *) malloc (type_len + 3); + the_type[0] = 'L'; + the_type[type_len + 1] = ';'; + the_type[type_len + 2] = '\0'; + the_type++; + } + else + { + /* XXX - FIXME - should not use dynamic allocation in core lib. */ + the_type = (char *) malloc (type_len + 1); + the_type[type_len] = '\0'; + } + + for (i = 0; i < type_len; i++) + if (type_name[i] == '.') + the_type[i] = '/'; + else + the_type[i] = type_name[i]; + + if (type_name[0] != '[') + the_type--; + + (*env)->ReleaseStringUTFChars (env, tname, type_name); + fid = (*env)->GetFieldID (env, declaringClass, field_name, the_type); + free (the_type); + } + else + { + type_len = -1; + fid = (*env)->GetFieldID (env, declaringClass, field_name, type); + } + + if (fid == NULL) + { + throwInternalError (env); + return NULL; + } + (*env)->ReleaseStringUTFChars (env, name, field_name); + + return fid; +} + +/* + * Class: java_io_VMObjectOutputStream + * Method: setBooleanNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;Z)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setBooleanNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), jobject field, jobject object, jboolean value) +{ + jfieldID fid = getFieldReference (env, field, "Z"); + + if (fid != NULL) + (*env)->SetBooleanField (env, object, fid, value); +} + +/* + * Class: java_io_VMObjectOutputStream + * Method: setCharNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;C)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setCharNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), + jobject field, + jobject object, jchar value) +{ + jfieldID fid = getFieldReference (env, field, "C"); + + if (fid != NULL) + (*env)->SetCharField (env, object, fid, value); +} + +/* + * Class: java_io_VMObjectOutputStream + * Method: setByteNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;B)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setByteNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), + jobject field, + jobject object, jbyte value) +{ + jfieldID fid = getFieldReference (env, field, "B"); + + if (fid != NULL) + (*env)->SetByteField (env, object, fid, value); +} + + +/* + * Class: java_io_VMObjectOutputStream + * Method: setShortNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;S)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setShortNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), + jobject field, + jobject object, jshort value) +{ + jfieldID fid = getFieldReference (env, field, "S"); + + if (fid != NULL) + (*env)->SetShortField (env, object, fid, value); +} + +/* + * Class: java_io_VMObjectOutputStream + * Method: setIntNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;I)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setIntNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), + jobject field, + jobject object, jint value) +{ + jfieldID fid = getFieldReference (env, field, "I"); + + if (fid != NULL) + (*env)->SetIntField (env, object, fid, value); +} + + +/* + * Class: java_io_VMObjectOutputStream + * Method: setLongNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;J)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setLongNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), + jobject field, + jobject object, jlong value) +{ + jfieldID fid = getFieldReference (env, field, "J"); + + if (fid != NULL) + (*env)->SetLongField (env, object, fid, value); +} + + +/* + * Class: java_io_VMObjectOutputStream + * Method: setFloatNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;F)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setFloatNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), + jobject field, + jobject object, jfloat value) +{ + jfieldID fid = getFieldReference (env, field, "F"); + + if (fid != NULL) + (*env)->SetFloatField (env, object, fid, value); +} + +/* + * Class: java_io_VMObjectOutputStream + * Method: setDoubleNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;D)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setDoubleNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), jobject field, jobject object, jdouble value) +{ + jfieldID fid = getFieldReference (env, field, "D"); + + if (fid != NULL) + (*env)->SetDoubleField (env, object, fid, value); +} + +/* + * Class: java_io_VMObjectOutputStream + * Method: setObjectNative + * Signature: (Ljava/lang/reflect/Field;Ljava/lang/Object;Ljava/lang/Object;)V + */ +JNIEXPORT void JNICALL +Java_java_io_VMObjectStreamClass_setObjectNative (JNIEnv * env, + jclass vmosklass + __attribute__ ((__unused__)), jobject field, jobject object, jobject value) +{ + jfieldID fid = getFieldReference (env, field, NULL); + + if (fid != NULL) + (*env)->SetObjectField (env, object, fid, value); +} diff --git a/libjava/classpath/native/jni/java-io/javaio.c b/libjava/classpath/native/jni/java-io/javaio.c new file mode 100644 index 00000000000..6dc3de8f041 --- /dev/null +++ b/libjava/classpath/native/jni/java-io/javaio.c @@ -0,0 +1,363 @@ +/* javaio.c - Common java.io native functions + Copyright (C) 1998, 2002, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + +/* do not move; needed here because of some macro definitions */ +#include <config.h> + +#include <stdio.h> +#include <stdlib.h> + +#include <jni.h> +#include <jcl.h> + +#include "target_native.h" +#ifndef WITHOUT_FILESYSTEM +#include "target_native_file.h" +#endif +#include "target_native_math_int.h" + +#include "javaio.h" + +/* + * Function to open a file + */ + +jint +_javaio_open_read (JNIEnv * env, jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int fd; + int result; + + filename = JCL_jstring_to_cstring (env, name); + if (filename == NULL) + return (-1); + + TARGET_NATIVE_FILE_OPEN_READ (filename, fd, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + if (result != TARGET_NATIVE_OK) + { + if (TARGET_NATIVE_LAST_ERROR () == TARGET_NATIVE_ERROR_NO_SUCH_FILE) + JCL_ThrowException (env, + "java/io/FileNotFoundException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + else + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + } + + JCL_free_cstring (env, name, filename); + return (fd); +#else /* not WITHOUT_FILESYSTEM */ + return (-1); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/* + * Function to open a file for reading/writing + */ + +jint +_javaio_open_readwrite (JNIEnv * env, jstring name) +{ +#ifndef WITHOUT_FILESYSTEM + const char *filename; + int fd; + int result; + + filename = JCL_jstring_to_cstring (env, name); + if (filename == NULL) + return (-1); + + TARGET_NATIVE_FILE_OPEN_READWRITE (filename, fd, result); + (*env)->ReleaseStringUTFChars (env, name, filename); + if (result != TARGET_NATIVE_OK) + { + if (TARGET_NATIVE_LAST_ERROR () == TARGET_NATIVE_ERROR_NO_SUCH_FILE) + JCL_ThrowException (env, + "java/io/FileNotFoundException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + else + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + } + + JCL_free_cstring (env, name, filename); + return (fd); +#else /* not WITHOUT_FILESYSTEM */ + return (-1); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * Function to close a file + */ + +void +_javaio_close (JNIEnv * env, jint fd) +{ +#ifndef WITHOUT_FILESYSTEM + int result; + + if (fd != -1) + { + TARGET_NATIVE_FILE_CLOSE (fd, result); + if (result != TARGET_NATIVE_OK) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + } +#else /* not WITHOUT_FILESYSTEM */ +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * Skips bytes in a file + */ + +jlong +_javaio_skip_bytes (JNIEnv * env, jint fd, jlong num_bytes) +{ +#ifndef WITHOUT_FILESYSTEM + jlong current_offset, new_offset; + int result; + + TARGET_NATIVE_FILE_SEEK_CURRENT (fd, TARGET_NATIVE_MATH_INT_INT64_CONST_0, + current_offset, result); + if (result != TARGET_NATIVE_OK) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + + TARGET_NATIVE_FILE_SEEK_CURRENT (fd, num_bytes, new_offset, result); + if (result != TARGET_NATIVE_OK) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + + return (TARGET_NATIVE_MATH_INT_INT64_SUB (new_offset, current_offset)); +#else /* not WITHOUT_FILESYSTEM */ + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * Gets the size of the file + */ + +jlong +_javaio_get_file_length (JNIEnv * env, jint fd) +{ +#ifndef WITHOUT_FILESYSTEM + jlong length; + int result; + + TARGET_NATIVE_FILE_SIZE (fd, length, result); + if (result != TARGET_NATIVE_OK) + { + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + return (TARGET_NATIVE_MATH_INT_INT64_CONST_MINUS_1); + } + + return (length); +#else /* not WITHOUT_FILESYSTEM */ + return (TARGET_NATIVE_MATH_INT_INT64_CONST_0); +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * Reads data from a file + */ + +jint +_javaio_read (JNIEnv * env, jint fd, jarray buf, jint offset, jint len) +{ +#ifndef WITHOUT_FILESYSTEM + jbyte *bufptr; + int bytesRead; + int result; + + assert (offset >= 0); + assert (len >= 0); + + if (len == 0) + return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */ + + bufptr = (*env)->GetByteArrayElements (env, buf, JNI_FALSE); + if (bufptr == NULL) + { + JCL_ThrowException (env, "java/io/IOException", + "Internal Error: get byte array fail"); + return (-1); + } + + TARGET_NATIVE_FILE_READ (fd, (bufptr + offset), len, bytesRead, result); + (*env)->ReleaseByteArrayElements (env, buf, bufptr, 0); + if (result != TARGET_NATIVE_OK) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + + if (bytesRead == 0) + return (-1); + + return (bytesRead); +#else /* not WITHOUT_FILESYSTEM */ + jbyte *bufptr; + int bytesRead; + + assert (offset >= 0); + assert (len >= 0); + + if ((fd == 0) || (fd == 1) || (fd == 2)) + { + if (len == 0) + return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */ + + bufptr = (*env)->GetByteArrayElements (env, buf, JNI_FALSE); + if (bufptr == NULL) + { + JCL_ThrowException (env, "java/io/IOException", + "Internal Error: get byte array"); + return (-1); + } + + TARGET_NATIVE_FILE_READ (fd, (bufptr + offset), len, bytesRead, result); + (*env)->ReleaseByteArrayElements (env, buf, bufptr, 0); + if (result != TARGET_NATIVE_OK) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + + if (bytesRead == 0) + return (-1); + + return (bytesRead); + } + else + { + return (-1); + } +#endif /* not WITHOUT_FILESYSTEM */ +} + +/*************************************************************************/ + +/* + * Writes data to a file + */ + +jint +_javaio_write (JNIEnv * env, jint fd, jarray buf, jint offset, jint len) +{ +#ifndef WITHOUT_FILESYSTEM + jbyte *bufptr; + int bytes_written; + int result; + + if (len == 0) + return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */ + + bufptr = (*env)->GetByteArrayElements (env, buf, 0); + if (bufptr == NULL) + { + JCL_ThrowException (env, "java/io/IOException", + "Internal Error: get byte array"); + return (-1); + } + + TARGET_NATIVE_FILE_WRITE (fd, (bufptr + offset), len, bytes_written, + result); + (*env)->ReleaseByteArrayElements (env, buf, bufptr, 0); + if (result != TARGET_NATIVE_OK) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + + if (bytes_written == 0) + return (-1); + + return (bytes_written); +#else /* not WITHOUT_FILESYSTEM */ + jbyte *bufptr; + int bytesWritten; + + if ((fd == 0) || (fd == 1) || (fd == 2)) + { + if (len == 0) + return 0; /* Nothing todo, and GetByteArrayElements() seems undefined. */ + + bufptr = (*env)->GetByteArrayElements (env, buf, 0); + if (bufptr == NULL) + { + JCL_ThrowException (env, "java/io/IOException", "Internal Error"); + return (-1); + } + + TARGET_NATIVE_FILE_WRITE (fd, (bufptr + offset), len, bytes_written, + result); + (*env)->ReleaseByteArrayElements (env, buf, bufptr, 0); + + if (bytes_written == -1) + JCL_ThrowException (env, + "java/io/IOException", + TARGET_NATIVE_LAST_ERROR_STRING ()); + + if (bytes_written == 0) + return (-1); + + return (bytes_written); + } + else + { + return (-1); + } +#endif /* not WITHOUT_FILESYSTEM */ +} diff --git a/libjava/classpath/native/jni/java-io/javaio.h b/libjava/classpath/native/jni/java-io/javaio.h new file mode 100644 index 00000000000..2e4a8d1037f --- /dev/null +++ b/libjava/classpath/native/jni/java-io/javaio.h @@ -0,0 +1,58 @@ +/* javaio.h - Declaration for common java.io native functions + Copyright (C) 1998, 2004 Free Software Foundation, Inc. + +This file is part of GNU Classpath. + +GNU Classpath is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2, or (at your option) +any later version. + +GNU Classpath is distributed in the hope that it will be useful, but +WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Classpath; see the file COPYING. If not, write to the +Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA +02110-1301 USA. + +Linking this library statically or dynamically with other modules is +making a combined work based on this library. Thus, the terms and +conditions of the GNU General Public License cover the whole +combination. + +As a special exception, the copyright holders of this library give you +permission to link this library with independent modules to produce an +executable, regardless of the license terms of these independent +modules, and to copy and distribute the resulting executable under +terms of your choice, provided that you also meet, for each linked +independent module, the terms and conditions of the license of that +module. An independent module is a module which is not derived from +or based on this library. If you modify this library, you may extend +this exception to your version of the library, but you are not +obligated to do so. If you do not wish to do so, delete this +exception statement from your version. */ + + +#ifndef JAVAIO_H_INCLUDED +#define JAVAIO_H_INCLUDED + +#include <stddef.h> + +/* + * Function Prototypes + */ + +extern jlong _javaio_get_file_length(JNIEnv *, jint); +extern jlong _javaio_skip_bytes(JNIEnv *, jint, jlong); +extern jint _javaio_open(JNIEnv *, jstring, int); +extern jint _javaio_open_read(JNIEnv *, jstring); +extern jint _javaio_open_readwrite(JNIEnv *, jstring); +extern void _javaio_close(JNIEnv *, jint fd); +extern jint _javaio_read(JNIEnv *, jint, jarray, jint, jint); +extern jint _javaio_write(JNIEnv *, jint, jarray, jint, jint); + +#endif /* JAVAIO_H_INCLUDED */ + |