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