From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- .../jni/java-io/java_io_VMObjectStreamClass.c | 381 +++++++++++++++++++++ 1 file changed, 381 insertions(+) create mode 100644 libjava/classpath/native/jni/java-io/java_io_VMObjectStreamClass.c (limited to 'libjava/classpath/native/jni/java-io/java_io_VMObjectStreamClass.c') 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 000000000..f5d785ecd --- /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 +#include + +#include +#include + +#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, "", "()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, "", "(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 (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); +} -- cgit v1.2.3