gcc/libjava/java/lang/reflect/natField.cc

// natField.cc - Implementation of java.lang.reflect.Field native methods.

/* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation

   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 <jvm.h>
#include <java/lang/reflect/Field.h>
#include <java/lang/reflect/Modifier.h>
#include <java/lang/IllegalArgumentException.h>
#include <java/lang/IllegalAccessException.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>

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);
  JvSynchronize sync (declaringClass);
  _Jv_ResolveField (fld, declaringClass->getClassLoader ());
  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)
	throw new java::lang::NullPointerException;
      if (! _Jv_IsInstanceOf (obj, field->getDeclaringClass()))
	throw new java::lang::IllegalArgumentException;
      return (void*) ((char*) obj + fld->getOffset ());
    }
}

static jboolean
getBoolean (jclass cls, void* addr)
{
  if (cls == JvPrimClass (boolean))
    return * (jboolean *) addr;
  throw new java::lang::IllegalArgumentException;
}

static jchar
getChar (jclass cls, void* addr)
{
  if (cls == JvPrimClass (char))
    return * (jchar *) addr;
  throw new java::lang::IllegalArgumentException;
}

static jbyte
getByte (jclass cls, void* addr)
{
  if (cls == JvPrimClass (byte))
    return * (jbyte *) addr;
  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;
  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;
  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))
    {
      _Jv_InitClass (&java::lang::Boolean::class$);
      if (* (jboolean*) addr)
	return java::lang::Boolean::TRUE;
      else
	return java::lang::Boolean::FALSE;
    }
  throw new java::lang::IllegalArgumentException;
}

static void*
setAddr (java::lang::reflect::Field* field, jclass caller, jobject obj)
{
  void *addr = getAddr(field, caller, obj);
  if  (!field->isAccessible()
	&& field->getModifiers() & java::lang::reflect::Modifier::FINAL)
    throw new java::lang::IllegalAccessException();
  return addr;
}

static void
setBoolean (jclass type, void *addr, jboolean value)
{
  if (type == JvPrimClass (boolean))
    * (jboolean *) addr = value;
  else
    throw 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
    throw 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
    throw 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
    throw 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
    throw 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
    throw 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
    throw new java::lang::IllegalArgumentException;
}

static void
setDouble (jclass type, void *addr, jdouble value)
{
  if (type == JvPrimClass (double))
    * (jdouble *) addr = value;
  else
    throw new java::lang::IllegalArgumentException;
}

void
java::lang::reflect::Field::setBoolean (jclass caller, jobject obj, jboolean b)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setBoolean (fld->type, setAddr (this, caller, obj), b);
}

void
java::lang::reflect::Field::setChar (jclass caller, jobject obj, jchar c)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setChar (fld->type, setAddr (this, caller, obj), c);
}

void
java::lang::reflect::Field::setByte (jclass caller, jobject obj, jbyte b)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setByte (fld->type, setAddr (this, caller, obj), b);
}

void
java::lang::reflect::Field::setShort (jclass caller, jobject obj, jshort s)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setShort (fld->type, setAddr (this, caller, obj), s);
}

void
java::lang::reflect::Field::setInt (jclass caller, jobject obj, jint i)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setInt (fld->type, setAddr (this, caller, obj), i);
}

void
java::lang::reflect::Field::setLong (jclass caller, jobject obj, jlong l)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setLong (fld->type, setAddr (this, caller, obj), l);
}
void
java::lang::reflect::Field::setFloat (jclass caller, jobject obj, jfloat f)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setFloat (fld->type, setAddr (this, caller, obj), f);
}

void
java::lang::reflect::Field::setDouble (jclass caller, jobject obj, jdouble d)
{
  jfieldID fld = _Jv_FromReflectedField (this);
  ::setDouble (fld->type, setAddr (this, caller, obj), d);
}

void
java::lang::reflect::Field::set (jclass caller, jobject object, jobject value,
				 jclass type)
{
  void* addr = setAddr (this, caller, object);
  if (value != NULL && ! _Jv_IsInstanceOf (value, type))
    throw new java::lang::IllegalArgumentException;
  * (jobject*) addr = value;
}