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