diff options
Diffstat (limited to 'libjava/java/lang/reflect/natField.cc')
| -rw-r--r-- | libjava/java/lang/reflect/natField.cc | 435 |
1 files changed, 435 insertions, 0 deletions
diff --git a/libjava/java/lang/reflect/natField.cc b/libjava/java/lang/reflect/natField.cc new file mode 100644 index 00000000000..2449b42545c --- /dev/null +++ b/libjava/java/lang/reflect/natField.cc @@ -0,0 +1,435 @@ +// natField.cc - Implementation of java.lang.reflect.Field native methods. + +/* Copyright (C) 1998, 1999 Cygnus Solutions + + This file is part of libgcj. + +This software is copyrighted work licensed under the terms of the +Libgcj License. Please consult the file "LIBGCJ_LICENSE" for +details. */ + +#include <config.h> + +#include <stdlib.h> + +#include <cni.h> +#include <jvm.h> +#include <java/lang/reflect/Field.h> +#include <java/lang/reflect/Modifier.h> +#include <java/lang/IllegalArgumentException.h> +#include <java/lang/NullPointerException.h> +#include <java/lang/Byte.h> +#include <java/lang/Short.h> +#include <java/lang/Integer.h> +#include <java/lang/Long.h> +#include <java/lang/Float.h> +#include <java/lang/Double.h> +#include <java/lang/Boolean.h> +#include <java/lang/Character.h> +#include <java-field.h> + +jint +java::lang::reflect::Field::getModifiers () +{ + return _Jv_FromReflectedField (this)->getModifiers (); +} + +jstring +java::lang::reflect::Field::getName () +{ + if (name == NULL) + name = _Jv_NewStringUtf8Const (_Jv_FromReflectedField (this)->name); + return name; +} + +jclass +java::lang::reflect::Field::getType () +{ + jfieldID fld = _Jv_FromReflectedField (this); + if (! fld->isResolved()) + { + JvSynchronize sync (declaringClass); + if (! fld->isResolved()) + { + fld->type + = _Jv_FindClassFromSignature(((Utf8Const*) (fld->type))->data, + declaringClass->getClassLoader()); + fld->flags &= ~_Jv_FIELD_UNRESOLVED_FLAG; + } + } + return fld->type; +} + +static void +_Jv_CheckFieldAccessibility (jfieldID /*fld*/, jclass /*caller*/) +{ +#if 0 + if (caller == NULL) + caller = getCaller(); +#endif +#if 0 + _Jv_ushort flags = fld->getModifiers(); + check accesss; +#endif +} + +static void* +getAddr (java::lang::reflect::Field* field, jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (field); + _Jv_ushort flags = fld->getModifiers(); + if (! (flags & java::lang::reflect::Modifier::PUBLIC) + && ! field->isAccessible ()) + _Jv_CheckFieldAccessibility (fld, caller); + if (flags & java::lang::reflect::Modifier::STATIC) + { + jclass fldClass = field->getDeclaringClass (); + JvInitClass(fldClass); + return fld->u.addr; + } + else + { + if (obj == NULL) + _Jv_Throw (new java::lang::NullPointerException ()); + if (! _Jv_IsInstanceOf (obj, field->getDeclaringClass())) + JvThrow (new java::lang::IllegalArgumentException ()); + return (void*) ((char*) obj + fld->getOffset ()); + } +} + +static jboolean +getBoolean (jclass cls, void* addr) +{ + if (cls == JvPrimClass (boolean)) + return * (jboolean *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jchar +getChar (jclass cls, void* addr) +{ + if (cls == JvPrimClass (char)) + return * (jchar *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jbyte +getByte (jclass cls, void* addr) +{ + if (cls == JvPrimClass (byte)) + return * (jbyte *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jshort +getShort (jclass cls, void* addr) +{ + if (cls == JvPrimClass (short)) + return * (jshort *) addr; + if (cls == JvPrimClass (byte)) + return * (jbyte *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jint +getInt (jclass cls, void* addr) +{ + if (cls == JvPrimClass (int)) + return * (jint *) addr; + if (cls == JvPrimClass (short)) + return * (jshort *) addr; + if (cls == JvPrimClass (char)) + return * (jchar *) addr; + if (cls == JvPrimClass (byte)) + return * (jbyte *) addr; + _Jv_Throw (new java::lang::IllegalArgumentException()); +} + +static jlong +getLong (jclass cls, void* addr) +{ + if (cls == JvPrimClass (long)) + return * (jlong *) addr; + return ::getInt(cls, addr); +} + +static jfloat +getFloat (jclass cls, void* addr) +{ + if (cls == JvPrimClass (float)) + return * (jfloat *) addr; + if (cls == JvPrimClass (long)) + return * (jlong *) addr; + return ::getInt(cls, addr); +} + +static jdouble +getDouble (jclass cls, void* addr) +{ + if (cls == JvPrimClass (double)) + return * (jdouble *) addr; + if (cls == JvPrimClass (float)) + return * (jfloat *) addr; + if (cls == JvPrimClass (long)) + return * (jlong *) addr; + return ::getInt(cls, addr); +} + +jboolean +java::lang::reflect::Field::getBoolean (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getBoolean (fld->type, getAddr (this, caller, obj)); +} + +jchar +java::lang::reflect::Field::getChar (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getChar (fld->type, getAddr (this, caller, obj)); +} + +jbyte +java::lang::reflect::Field::getByte (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getByte (fld->type, getAddr (this, caller, obj)); +} + +jshort +java::lang::reflect::Field::getShort (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getShort (fld->type, getAddr (this, caller, obj)); +} + +jint +java::lang::reflect::Field::getInt (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getInt (fld->type, getAddr (this, caller, obj)); +} + +jlong +java::lang::reflect::Field::getLong (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getLong (fld->type, getAddr (this, caller, obj)); +} + +jfloat +java::lang::reflect::Field::getFloat (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getFloat (fld->type, getAddr (this, caller, obj)); +} + +jdouble +java::lang::reflect::Field::getDouble (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + return ::getDouble (fld->type, getAddr (this, caller, obj)); +} + +jobject +java::lang::reflect::Field::get (jclass caller, jobject obj) +{ + jfieldID fld = _Jv_FromReflectedField (this); + void* addr = getAddr (this, caller, obj); + if (! fld->type->isPrimitive ()) + return * (jobject*) addr; + if (fld->type == JvPrimClass (double)) + return new java::lang::Double (* (jdouble*) addr); + if (fld->type == JvPrimClass (float)) + return new java::lang::Float (* (jfloat*) addr); + if (fld->type == JvPrimClass (long)) + return new java::lang::Long (* (jlong*) addr); + if (fld->type == JvPrimClass (int)) + return new java::lang::Integer (* (jint*) addr); + if (fld->type == JvPrimClass (short)) + return new java::lang::Short (* (jshort*) addr); + if (fld->type == JvPrimClass (byte)) + return new java::lang::Byte (* (jbyte*) addr); + if (fld->type == JvPrimClass (char)) + return new java::lang::Character (* (jchar*) addr); + if (fld->type == JvPrimClass (boolean)) + if (* (jboolean*) addr) + return java::lang::Boolean::TRUE; + else + return java::lang::Boolean::FALSE; + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setBoolean (jclass type, void *addr, jboolean value) +{ + if (type == JvPrimClass (boolean)) + * (jboolean *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setChar (jclass type, void *addr, jchar value) +{ + if (type == JvPrimClass (char)) + * (jchar *) addr = value; + else if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setByte (jclass type, void *addr, jbyte value) +{ + if (type == JvPrimClass (byte)) + * (jbyte *) addr = value; + else if (type == JvPrimClass (short)) + * (jshort *) addr = value; + else if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setShort (jclass type, void *addr, jshort value) +{ + if (type == JvPrimClass (short)) + * (jshort *) addr = value; + else if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setInt (jclass type, void *addr, jint value) +{ + if (type == JvPrimClass (int)) + * (jint *) addr = value; + else if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setLong (jclass type, void *addr, jlong value) +{ + if (type == JvPrimClass (long)) + * (jlong *) addr = value; + else if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setFloat (jclass type, void *addr, jfloat value) +{ + if (type == JvPrimClass (float)) + * (jfloat *) addr = value; + else if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +static void +setDouble (jclass type, void *addr, jdouble value) +{ + if (type == JvPrimClass (double)) + * (jdouble *) addr = value; + else + JvThrow (new java::lang::IllegalArgumentException()); +} + +void +java::lang::reflect::Field::setBoolean (jclass caller, jobject obj, jboolean b) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setBoolean (fld->type, getAddr (this, caller, obj), b); +} + +void +java::lang::reflect::Field::setChar (jclass caller, jobject obj, jchar c) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setChar (fld->type, getAddr (this, caller, obj), c); +} + +void +java::lang::reflect::Field::setByte (jclass caller, jobject obj, jbyte b) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setByte (fld->type, getAddr (this, caller, obj), b); +} + +void +java::lang::reflect::Field::setShort (jclass caller, jobject obj, jshort s) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setShort (fld->type, getAddr (this, caller, obj), s); +} + +void +java::lang::reflect::Field::setInt (jclass caller, jobject obj, jint i) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setInt (fld->type, getAddr (this, caller, obj), i); +} + +void +java::lang::reflect::Field::setLong (jclass caller, jobject obj, jlong l) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setLong (fld->type, getAddr (this, caller, obj), l); +} +void +java::lang::reflect::Field::setFloat (jclass caller, jobject obj, jfloat f) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setFloat (fld->type, getAddr (this, caller, obj), f); +} + +void +java::lang::reflect::Field::setDouble (jclass caller, jobject obj, jdouble d) +{ + jfieldID fld = _Jv_FromReflectedField (this); + ::setDouble (fld->type, getAddr (this, caller, obj), d); +} + +void +java::lang::reflect::Field::set (jclass caller, jobject object, jobject value, jclass type) +{ + if (! _Jv_IsInstanceOf (value, type)) + JvThrow (new java::lang::IllegalArgumentException ()); + void* addr = getAddr (this, caller, object); + * (jobject*) addr = value; +} |
