libjava/java/lang/reflect/natArray.cc

   1 // natField.cc - Implementation of java.lang.reflect.Field native methods.
   2
   3 /* Copyright (C) 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 <gcj/cni.h>
  17 #include <java/lang/reflect/Array.h>
  18 #include <java/lang/ArrayIndexOutOfBoundsException.h>
  19 #include <java/lang/IllegalArgumentException.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 jobject
  30 java::lang::reflect::Array::newInstance (jclass componentType, jint length)
  31 {
  32   if (componentType->isPrimitive())
  33     {
  34       // We could check for this in _Jv_NewPrimArray, but that seems
  35       // like needless overhead when the only real route to this
  36       // problem is here.
  37       if (componentType == JvPrimClass (void))
  38         throw new java::lang::IllegalArgumentException ();
  39       return _Jv_NewPrimArray (componentType, length);
  40     }
  41   else
  42     // FIXME: class loader?
  43     return JvNewObjectArray (length, componentType, NULL);
  44 }
  45
  46 jobject
  47 java::lang::reflect::Array::newInstance (jclass componentType,
  48                                          jintArray dimensions)
  49 {
  50   jint ndims = dimensions->length;
  51   if (ndims == 0)
  52     throw new java::lang::IllegalArgumentException ();
  53   jint* dims = elements (dimensions);
  54   if (ndims == 1)
  55     return newInstance (componentType, dims[0]);
  56
  57   gnu::gcj::runtime::StackTrace *t
  58     = new gnu::gcj::runtime::StackTrace(4);
  59   Class *caller = NULL;
  60   ClassLoader *caller_loader = NULL;
  61   try
  62     {
  63       for (int i = 1; !caller; i++)
  64         {
  65           caller = t->classAt (i);
  66         }
  67       caller_loader = caller->getClassLoaderInternal();
  68     }
  69   catch (::java::lang::ArrayIndexOutOfBoundsException *e)
  70     {
  71     }
  72
  73   jclass arrayType = componentType;
  74   for (int i = 0;  i < ndims;  i++)
  75     arrayType = _Jv_GetArrayClass (arrayType, caller_loader);
  76
  77   return _Jv_NewMultiArray (arrayType, ndims, dims);
  78 }
  79
  80 jint
  81 java::lang::reflect::Array::getLength (jobject array)
  82 {
  83   jclass arrayType = array->getClass();
  84   if (! arrayType->isArray ())
  85     throw new java::lang::IllegalArgumentException;
  86   return ((__JArray*) array)->length;
  87 }
  88
  89 jclass
  90 java::lang::reflect::Array::getElementType (jobject array, jint index)
  91 {
  92   jclass arrayType = array->getClass();
  93   if (! arrayType->isArray ())
  94     throw new java::lang::IllegalArgumentException;
  95   jint length = ((__JArray*) array)->length;
  96   if ((_Jv_uint) index >= (_Jv_uint) length)
  97     _Jv_ThrowBadArrayIndex(index);
  98   return arrayType->getComponentType ();
  99 }
 100
 101 jboolean
 102 java::lang::reflect::Array::getBoolean (jobject array, jint index)
 103 {
 104   jclass elementType = getElementType (array, index);
 105   if (elementType == JvPrimClass (boolean))
 106     return elements ((jbooleanArray) array) [index];
 107   throw new java::lang::IllegalArgumentException;
 108 }
 109
 110 jchar
 111 java::lang::reflect::Array::getChar (jobject array, jint index)
 112 {
 113   jclass elementType = getElementType (array, index);
 114   if (elementType == JvPrimClass (char))
 115     return elements ((jcharArray) array) [index];
 116   throw new java::lang::IllegalArgumentException;
 117 }
 118
 119 jbyte
 120 java::lang::reflect::Array::getByte (jobject array, jint index)
 121 {
 122   jclass elementType = getElementType (array, index);
 123   if (elementType == JvPrimClass (byte))
 124     return elements ((jbyteArray) array) [index];
 125   throw new java::lang::IllegalArgumentException;
 126 }
 127
 128 jshort
 129 java::lang::reflect::Array::getShort (jobject array, jint index)
 130 {
 131   jclass elementType = getElementType (array, index);
 132   if (elementType == JvPrimClass (short))
 133     return elements ((jshortArray) array) [index];
 134   if (elementType == JvPrimClass (byte))
 135     return elements ((jbyteArray) array) [index];
 136   throw new java::lang::IllegalArgumentException;
 137 }
 138
 139 jint
 140 java::lang::reflect::Array::getInt (jobject array, jint index)
 141 {
 142   jclass elementType = getElementType (array, index);
 143   if (elementType == JvPrimClass (int))
 144     return elements ((jintArray) array) [index];
 145   if (elementType == JvPrimClass (short))
 146     return elements ((jshortArray) array) [index];
 147   if (elementType == JvPrimClass (byte))
 148     return elements ((jbyteArray) array) [index];
 149   if (elementType == JvPrimClass (char))
 150     return elements ((jcharArray) array) [index];
 151   throw new java::lang::IllegalArgumentException;
 152 }
 153
 154 jlong
 155 java::lang::reflect::Array::getLong (jobject array, jint index)
 156 {
 157   jclass elementType = getElementType (array, index);
 158   if (elementType == JvPrimClass (long))
 159     return elements ((jlongArray) array) [index];
 160   if (elementType == JvPrimClass (int))
 161     return elements ((jintArray) array) [index];
 162   if (elementType == JvPrimClass (short))
 163     return elements ((jshortArray) array) [index];
 164   if (elementType == JvPrimClass (byte))
 165     return elements ((jbyteArray) array) [index];
 166   if (elementType == JvPrimClass (char))
 167     return elements ((jcharArray) array) [index];
 168   throw new java::lang::IllegalArgumentException;
 169 }
 170
 171 jfloat
 172 java::lang::reflect::Array::getFloat (jobject array, jint index)
 173 {
 174   jclass elementType = getElementType (array, index);
 175   if (elementType == JvPrimClass (float))
 176     return elements ((jfloatArray) array) [index];
 177   if (elementType == JvPrimClass (long))
 178     return elements ((jlongArray) array) [index];
 179   if (elementType == JvPrimClass (int))
 180     return elements ((jintArray) array) [index];
 181   if (elementType == JvPrimClass (short))
 182     return elements ((jshortArray) array) [index];
 183   if (elementType == JvPrimClass (byte))
 184     return elements ((jbyteArray) array) [index];
 185   if (elementType == JvPrimClass (char))
 186     return elements ((jcharArray) array) [index];
 187   throw new java::lang::IllegalArgumentException;
 188 }
 189
 190 jdouble
 191 java::lang::reflect::Array::getDouble (jobject array, jint index)
 192 {
 193   jclass elementType = getElementType (array, index);
 194   if (elementType == JvPrimClass (double))
 195     return elements ((jdoubleArray) array) [index];
 196   if (elementType == JvPrimClass (float))
 197     return elements ((jfloatArray) array) [index];
 198   if (elementType == JvPrimClass (long))
 199     return elements ((jlongArray) array) [index];
 200   if (elementType == JvPrimClass (int))
 201     return elements ((jintArray) array) [index];
 202   if (elementType == JvPrimClass (short))
 203     return elements ((jshortArray) array) [index];
 204   if (elementType == JvPrimClass (byte))
 205     return elements ((jbyteArray) array) [index];
 206   if (elementType == JvPrimClass (char))
 207     return elements ((jcharArray) array) [index];
 208   throw new java::lang::IllegalArgumentException;
 209 }
 210
 211 jobject
 212 java::lang::reflect::Array::get (jobject array, jint index)
 213 {
 214   jclass elementType = getElementType (array, index);
 215   if (! elementType->isPrimitive ())
 216     return elements ((jobjectArray) array) [index];
 217   if (elementType == JvPrimClass (double))
 218     return new java::lang::Double (elements ((jdoubleArray) array) [index]);
 219   if (elementType == JvPrimClass (float))
 220     return new java::lang::Float (elements ((jfloatArray) array) [index]);
 221   if (elementType == JvPrimClass (long))
 222     return new java::lang::Long (elements ((jlongArray) array) [index]);
 223   if (elementType == JvPrimClass (int))
 224     return new java::lang::Integer (elements ((jintArray) array) [index]);
 225   if (elementType == JvPrimClass (short))
 226     return new java::lang::Short (elements ((jshortArray) array) [index]);
 227   if (elementType == JvPrimClass (byte))
 228     return new java::lang::Byte (elements ((jbyteArray) array) [index]);
 229   if (elementType == JvPrimClass (char))
 230     return new java::lang::Character (elements ((jcharArray) array) [index]);
 231   if (elementType == JvPrimClass (boolean))
 232     {
 233       _Jv_InitClass (&java::lang::Boolean::class$);
 234       if (elements ((jbooleanArray) array) [index])
 235         return java::lang::Boolean::TRUE;
 236       else
 237         return java::lang::Boolean::FALSE;
 238     }
 239   throw new java::lang::IllegalArgumentException;
 240 }
 241
 242 void
 243 java::lang::reflect::Array::setChar (jobject array, jint index, jchar value)
 244 {
 245   jclass elementType = getElementType (array, index);
 246   if (elementType == JvPrimClass (char))
 247     elements ((jcharArray) array) [index] = value;
 248   else if (elementType == JvPrimClass (int))
 249     elements ((jintArray) array) [index] = value;
 250   else if (elementType == JvPrimClass (long))
 251     elements ((jlongArray) array) [index] = value;
 252   else if (elementType == JvPrimClass (float))
 253     elements ((jfloatArray) array) [index] = value;
 254   else if (elementType == JvPrimClass (double))
 255     elements ((jdoubleArray) array) [index] = value;
 256   else
 257     throw new java::lang::IllegalArgumentException;
 258 }
 259
 260 void
 261 java::lang::reflect::Array::setByte (jobject array, jint index, jbyte value)
 262 {
 263   jclass elementType = getElementType (array, index);
 264   if (elementType == JvPrimClass (byte))
 265     elements ((jbyteArray) array) [index] = value;
 266   else if (elementType == JvPrimClass (short))
 267     elements ((jshortArray) array) [index] = value;
 268   else if (elementType == JvPrimClass (int))
 269     elements ((jintArray) array) [index] = value;
 270   else if (elementType == JvPrimClass (long))
 271     elements ((jlongArray) array) [index] = value;
 272   else if (elementType == JvPrimClass (float))
 273     elements ((jfloatArray) array) [index] = value;
 274   else if (elementType == JvPrimClass (double))
 275     elements ((jdoubleArray) array) [index] = value;
 276   else
 277     throw new java::lang::IllegalArgumentException;
 278 }
 279
 280 void
 281 java::lang::reflect::Array::setShort (jobject array, jint index, jshort value)
 282 {
 283   jclass elementType = getElementType (array, index);
 284   if (elementType == JvPrimClass (short))
 285     elements ((jshortArray) array) [index] = value;
 286   else if (elementType == JvPrimClass (int))
 287     elements ((jintArray) array) [index] = value;
 288   else if (elementType == JvPrimClass (long))
 289     elements ((jlongArray) array) [index] = value;
 290   else if (elementType == JvPrimClass (float))
 291     elements ((jfloatArray) array) [index] = value;
 292   else if (elementType == JvPrimClass (double))
 293     elements ((jdoubleArray) array) [index] = value;
 294   else
 295     throw new java::lang::IllegalArgumentException;
 296 }
 297
 298 void
 299 java::lang::reflect::Array::setInt (jobject array, jint index, jint value)
 300 {
 301   jclass elementType = getElementType (array, index);
 302   if (elementType == JvPrimClass (int))
 303     elements ((jintArray) array) [index] = value;
 304   else if (elementType == JvPrimClass (long))
 305     elements ((jlongArray) array) [index] = value;
 306   else if (elementType == JvPrimClass (float))
 307     elements ((jfloatArray) array) [index] = value;
 308   else if (elementType == JvPrimClass (double))
 309     elements ((jdoubleArray) array) [index] = value;
 310   else
 311     throw new java::lang::IllegalArgumentException;
 312 }
 313
 314 void
 315 java::lang::reflect::Array::setLong (jobject array, jint index, jlong value)
 316 {
 317   jclass elementType = getElementType (array, index);
 318   if (elementType == JvPrimClass (long))
 319     elements ((jlongArray) array) [index] = value;
 320   else if (elementType == JvPrimClass (float))
 321     elements ((jfloatArray) array) [index] = value;
 322   else if (elementType == JvPrimClass (double))
 323     elements ((jdoubleArray) array) [index] = value;
 324   else
 325     throw new java::lang::IllegalArgumentException;
 326 }
 327
 328 void
 329 java::lang::reflect::Array::setFloat (jobject array, jint index, jfloat value)
 330 {
 331   jclass elementType = getElementType (array, index);
 332   if (elementType == JvPrimClass (float))
 333     elements ((jfloatArray) array) [index] = value;
 334   else if (elementType == JvPrimClass (double))
 335     elements ((jdoubleArray) array) [index] = value;
 336   else
 337     throw new java::lang::IllegalArgumentException;
 338 }
 339
 340 void
 341 java::lang::reflect::Array::setDouble (jobject array, jint index, jdouble value)
 342 {
 343   jclass elementType = getElementType (array, index);
 344   if (elementType == JvPrimClass (double))
 345     elements ((jdoubleArray) array) [index] = value;
 346   else
 347     throw new java::lang::IllegalArgumentException;
 348 }
 349
 350 void
 351 java::lang::reflect::Array::setBoolean (jobject array,
 352                                         jint index, jboolean value)
 353 {
 354   jclass elementType = getElementType (array, index);
 355   if (elementType == JvPrimClass (boolean))
 356     elements ((jbooleanArray) array) [index] = value;
 357   else
 358     throw new java::lang::IllegalArgumentException;
 359 }
 360
 361 void
 362 java::lang::reflect::Array::set (jobject array, jint index,
 363                                  jobject value, jclass elType)
 364 {
 365   // We don't have to call getElementType here, or check INDEX,
 366   // because it was already done in the Java wrapper.
 367   if (value != NULL && ! _Jv_IsInstanceOf (value, elType))
 368     throw new java::lang::IllegalArgumentException;
 369   elements ((jobjectArray) array) [index] = value;
 370 }