libjava/java/lang/reflect/natField.cc

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