libjava/java/lang/reflect/natField.cc

   1 // natField.cc - Implementation of java.lang.reflect.Field native methods.
   2
   3 /* Copyright (C) 1998, 1999, 2000, 2001  Free Software Foundation
   4
   5    This file is part of libgcj.
   6
   7 This software is copyrighted work licensed under the terms of the
   8 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
   9 details.  */
  10
  11 #include <config.h>
  12
  13 #include <stdlib.h>
  14
  15 #include <jvm.h>
  16 #include <java/lang/reflect/Field.h>
  17 #include <java/lang/reflect/Modifier.h>
  18 #include <java/lang/IllegalArgumentException.h>
  19 #include <java/lang/IllegalAccessException.h>
  20 #include <java/lang/NullPointerException.h>
  21 #include <java/lang/Byte.h>
  22 #include <java/lang/Short.h>
  23 #include <java/lang/Integer.h>
  24 #include <java/lang/Long.h>
  25 #include <java/lang/Float.h>
  26 #include <java/lang/Double.h>
  27 #include <java/lang/Boolean.h>
  28 #include <java/lang/Character.h>
  29
  30 jint
  31 java::lang::reflect::Field::getModifiers ()
  32 {
  33   return _Jv_FromReflectedField (this)->getModifiers ();
  34 }
  35
  36 jstring
  37 java::lang::reflect::Field::getName ()
  38 {
  39   if (name == NULL)
  40     name = _Jv_NewStringUtf8Const (_Jv_FromReflectedField (this)->name);
  41   return name;
  42 }
  43
  44 jclass
  45 java::lang::reflect::Field::getType ()
  46 {
  47   jfieldID fld = _Jv_FromReflectedField (this);
  48   JvSynchronize sync (declaringClass);
  49   _Jv_ResolveField (fld, declaringClass->getClassLoader ());
  50   return fld->type;
  51 }
  52
  53 static void
  54 _Jv_CheckFieldAccessibility (jfieldID /*fld*/, jclass /*caller*/)
  55 {
  56 #if 0
  57   if (caller == NULL)
  58     caller = getCaller();
  59 #endif
  60 #if 0
  61   _Jv_ushort flags = fld->getModifiers();
  62   check accesss;
  63 #endif
  64 }
  65
  66 static void*
  67 getAddr (java::lang::reflect::Field* field, jclass caller, jobject obj)
  68 {
  69   jfieldID fld = _Jv_FromReflectedField (field);
  70   _Jv_ushort flags = fld->getModifiers();
  71   if (! (flags & java::lang::reflect::Modifier::PUBLIC)
  72       && ! field->isAccessible ())
  73     _Jv_CheckFieldAccessibility (fld, caller);
  74   if (flags & java::lang::reflect::Modifier::STATIC)
  75     {
  76       jclass fldClass = field->getDeclaringClass ();
  77       JvInitClass(fldClass);
  78       return fld->u.addr;
  79     }
  80   else
  81     {
  82       if (obj == NULL)
  83         throw new java::lang::NullPointerException;
  84       if (! _Jv_IsInstanceOf (obj, field->getDeclaringClass()))
  85         throw new java::lang::IllegalArgumentException;
  86       return (void*) ((char*) obj + fld->getOffset ());
  87     }
  88 }
  89
  90 static jboolean
  91 getBoolean (jclass cls, void* addr)
  92 {
  93   if (cls == JvPrimClass (boolean))
  94     return * (jboolean *) addr;
  95   throw new java::lang::IllegalArgumentException;
  96 }
  97
  98 static jchar
  99 getChar (jclass cls, void* addr)
 100 {
 101   if (cls == JvPrimClass (char))
 102     return * (jchar *) addr;
 103   throw new java::lang::IllegalArgumentException;
 104 }
 105
 106 static jbyte
 107 getByte (jclass cls, void* addr)
 108 {
 109   if (cls == JvPrimClass (byte))
 110     return * (jbyte *) addr;
 111   throw new java::lang::IllegalArgumentException;
 112 }
 113
 114 static jshort
 115 getShort (jclass cls, void* addr)
 116 {
 117   if (cls == JvPrimClass (short))
 118     return * (jshort *) addr;
 119   if (cls == JvPrimClass (byte))
 120     return * (jbyte *) addr;
 121   throw new java::lang::IllegalArgumentException;
 122 }
 123
 124 static jint
 125 getInt (jclass cls, void* addr)
 126 {
 127   if (cls == JvPrimClass (int))
 128     return * (jint *) addr;
 129   if (cls == JvPrimClass (short))
 130     return * (jshort *) addr;
 131   if (cls == JvPrimClass (char))
 132     return * (jchar *) addr;
 133   if (cls == JvPrimClass (byte))
 134     return * (jbyte *) addr;
 135   throw new java::lang::IllegalArgumentException;
 136 }
 137
 138 static jlong
 139 getLong (jclass cls, void* addr)
 140 {
 141   if (cls == JvPrimClass (long))
 142     return * (jlong *) addr;
 143   return ::getInt(cls, addr);
 144 }
 145
 146 static jfloat
 147 getFloat (jclass cls, void* addr)
 148 {
 149   if (cls == JvPrimClass (float))
 150     return * (jfloat *) addr;
 151   if (cls == JvPrimClass (long))
 152     return * (jlong *) addr;
 153   return ::getInt(cls, addr);
 154 }
 155
 156 static jdouble
 157 getDouble (jclass cls, void* addr)
 158 {
 159   if (cls == JvPrimClass (double))
 160     return * (jdouble *) addr;
 161   if (cls == JvPrimClass (float))
 162     return * (jfloat *) addr;
 163   if (cls == JvPrimClass (long))
 164     return * (jlong *) addr;
 165   return ::getInt(cls, addr);
 166 }
 167
 168 jboolean
 169 java::lang::reflect::Field::getBoolean (jclass caller, jobject obj)
 170 {
 171   return ::getBoolean (this->getType(), getAddr (this, caller, obj));
 172 }
 173
 174 jchar
 175 java::lang::reflect::Field::getChar (jclass caller, jobject obj)
 176 {
 177   return ::getChar (this->getType(), getAddr (this, caller, obj));
 178 }
 179
 180 jbyte
 181 java::lang::reflect::Field::getByte (jclass caller, jobject obj)
 182 {
 183   return ::getByte (this->getType(), getAddr (this, caller, obj));
 184 }
 185
 186 jshort
 187 java::lang::reflect::Field::getShort (jclass caller, jobject obj)
 188 {
 189   return ::getShort (this->getType(), getAddr (this, caller, obj));
 190 }
 191
 192 jint
 193 java::lang::reflect::Field::getInt (jclass caller, jobject obj)
 194 {
 195   return ::getInt (this->getType(), getAddr (this, caller, obj));
 196 }
 197
 198 jlong
 199 java::lang::reflect::Field::getLong (jclass caller, jobject obj)
 200 {
 201   return ::getLong (this->getType(), getAddr (this, caller, obj));
 202 }
 203
 204 jfloat
 205 java::lang::reflect::Field::getFloat (jclass caller, jobject obj)
 206 {
 207   return ::getFloat (this->getType(), getAddr (this, caller, obj));
 208 }
 209
 210 jdouble
 211 java::lang::reflect::Field::getDouble (jclass caller, jobject obj)
 212 {
 213   return ::getDouble (this->getType(), getAddr (this, caller, obj));
 214 }
 215
 216 jobject
 217 java::lang::reflect::Field::get (jclass caller, jobject obj)
 218 {
 219   jclass type = this->getType();
 220   void* addr = getAddr (this, caller, obj);
 221   if (! type->isPrimitive ())
 222     return * (jobject*) addr;
 223   if (type == JvPrimClass (double))
 224     return new java::lang::Double (* (jdouble*) addr);
 225   if (type == JvPrimClass (float))
 226     return new java::lang::Float (* (jfloat*) addr);
 227   if (type == JvPrimClass (long))
 228     return new java::lang::Long (* (jlong*) addr);
 229   if (type == JvPrimClass (int))
 230     return new java::lang::Integer (* (jint*) addr);
 231   if (type == JvPrimClass (short))
 232     return new java::lang::Short (* (jshort*) addr);
 233   if (type == JvPrimClass (byte))
 234     return new java::lang::Byte (* (jbyte*) addr);
 235   if (type == JvPrimClass (char))
 236     return new java::lang::Character (* (jchar*) addr);
 237   if (type == JvPrimClass (boolean))
 238     {
 239       _Jv_InitClass (&java::lang::Boolean::class$);
 240       if (* (jboolean*) addr)
 241         return java::lang::Boolean::TRUE;
 242       else
 243         return java::lang::Boolean::FALSE;
 244     }
 245   throw new java::lang::IllegalArgumentException;
 246 }
 247
 248 static void*
 249 setAddr (java::lang::reflect::Field* field, jclass caller, jobject obj)
 250 {
 251   void *addr = getAddr(field, caller, obj);
 252   if  (!field->isAccessible()
 253         && field->getModifiers() & java::lang::reflect::Modifier::FINAL)
 254     throw new java::lang::IllegalAccessException();
 255   return addr;
 256 }
 257
 258 static void
 259 setBoolean (jclass type, void *addr, jboolean value)
 260 {
 261   if (type == JvPrimClass (boolean))
 262     * (jboolean *) addr = value;
 263   else
 264     throw new java::lang::IllegalArgumentException;
 265 }
 266
 267 static void
 268 setChar (jclass type, void *addr, jchar value)
 269 {
 270   if (type == JvPrimClass (char))
 271     * (jchar *) addr = value;
 272   else if (type == JvPrimClass (int))
 273     * (jint *) addr = value;
 274   else if (type == JvPrimClass (long))
 275     * (jlong *) addr = value;
 276   else if (type == JvPrimClass (float))
 277     * (jfloat *) addr = value;
 278   else if (type == JvPrimClass (double))
 279     * (jdouble *) addr = value;
 280   else
 281     throw new java::lang::IllegalArgumentException;
 282 }
 283
 284 static void
 285 setByte (jclass type, void *addr, jbyte value)
 286 {
 287   if (type == JvPrimClass (byte))
 288     * (jbyte *) addr = value;
 289   else if (type == JvPrimClass (short))
 290     * (jshort *) addr = value;
 291   else if (type == JvPrimClass (int))
 292     * (jint *) addr = value;
 293   else if (type == JvPrimClass (long))
 294     * (jlong *) addr = value;
 295   else if (type == JvPrimClass (float))
 296     * (jfloat *) addr = value;
 297   else if (type == JvPrimClass (double))
 298     * (jdouble *) addr = value;
 299   else
 300     throw new java::lang::IllegalArgumentException;
 301 }
 302
 303 static void
 304 setShort (jclass type, void *addr, jshort value)
 305 {
 306   if (type == JvPrimClass (short))
 307     * (jshort *) addr = value;
 308   else if (type == JvPrimClass (int))
 309     * (jint *) addr = value;
 310   else if (type == JvPrimClass (long))
 311     * (jlong *) addr = value;
 312   else if (type == JvPrimClass (float))
 313     * (jfloat *) addr = value;
 314   else if (type == JvPrimClass (double))
 315     * (jdouble *) addr = value;
 316   else
 317     throw new java::lang::IllegalArgumentException;
 318 }
 319
 320 static void
 321 setInt (jclass type, void *addr, jint value)
 322 {
 323   if (type == JvPrimClass (int))
 324     * (jint *) addr = value;
 325   else if (type == JvPrimClass (long))
 326     * (jlong *) addr = value;
 327   else if (type == JvPrimClass (float))
 328     * (jfloat *) addr = value;
 329   else if (type == JvPrimClass (double))
 330     * (jdouble *) addr = value;
 331   else
 332     throw new java::lang::IllegalArgumentException;
 333 }
 334
 335 static void
 336 setLong (jclass type, void *addr, jlong value)
 337 {
 338   if (type == JvPrimClass (long))
 339     * (jlong *) addr = value;
 340   else if (type == JvPrimClass (float))
 341     * (jfloat *) addr = value;
 342   else if (type == JvPrimClass (double))
 343     * (jdouble *) addr = value;
 344   else
 345     throw new java::lang::IllegalArgumentException;
 346 }
 347
 348 static void
 349 setFloat (jclass type, void *addr, jfloat value)
 350 {
 351   if (type == JvPrimClass (float))
 352     * (jfloat *) addr = value;
 353   else if (type == JvPrimClass (double))
 354     * (jdouble *) addr = value;
 355   else
 356     throw new java::lang::IllegalArgumentException;
 357 }
 358
 359 static void
 360 setDouble (jclass type, void *addr, jdouble value)
 361 {
 362   if (type == JvPrimClass (double))
 363     * (jdouble *) addr = value;
 364   else
 365     throw new java::lang::IllegalArgumentException;
 366 }
 367
 368 void
 369 java::lang::reflect::Field::setBoolean (jclass caller, jobject obj, jboolean b)
 370 {
 371   ::setBoolean (this->getType(), setAddr (this, caller, obj), b);
 372 }
 373
 374 void
 375 java::lang::reflect::Field::setChar (jclass caller, jobject obj, jchar c)
 376 {
 377   ::setChar (this->getType(), setAddr (this, caller, obj), c);
 378 }
 379
 380 void
 381 java::lang::reflect::Field::setByte (jclass caller, jobject obj, jbyte b)
 382 {
 383   ::setByte (this->getType(), setAddr (this, caller, obj), b);
 384 }
 385
 386 void
 387 java::lang::reflect::Field::setShort (jclass caller, jobject obj, jshort s)
 388 {
 389   ::setShort (this->getType(), setAddr (this, caller, obj), s);
 390 }
 391
 392 void
 393 java::lang::reflect::Field::setInt (jclass caller, jobject obj, jint i)
 394 {
 395   ::setInt (this->getType(), setAddr (this, caller, obj), i);
 396 }
 397
 398 void
 399 java::lang::reflect::Field::setLong (jclass caller, jobject obj, jlong l)
 400 {
 401   ::setLong (this->getType(), setAddr (this, caller, obj), l);
 402 }
 403 void
 404 java::lang::reflect::Field::setFloat (jclass caller, jobject obj, jfloat f)
 405 {
 406   ::setFloat (this->getType(), setAddr (this, caller, obj), f);
 407 }
 408
 409 void
 410 java::lang::reflect::Field::setDouble (jclass caller, jobject obj, jdouble d)
 411 {
 412   ::setDouble (this->getType(), setAddr (this, caller, obj), d);
 413 }
 414
 415 void
 416 java::lang::reflect::Field::set (jclass caller, jobject object, jobject value,
 417                                  jclass type)
 418 {
 419   void* addr = setAddr (this, caller, object);
 420   if (value != NULL && ! _Jv_IsInstanceOf (value, type))
 421     throw new java::lang::IllegalArgumentException;
 422   * (jobject*) addr = value;
 423 }