210 if (a->is_objArray()) { |
210 if (a->is_objArray()) { |
211 value->l = (jobject) objArrayOop(a)->obj_at(index); |
211 value->l = (jobject) objArrayOop(a)->obj_at(index); |
212 return T_OBJECT; |
212 return T_OBJECT; |
213 } else { |
213 } else { |
214 assert(a->is_typeArray(), "just checking"); |
214 assert(a->is_typeArray(), "just checking"); |
215 BasicType type = typeArrayKlass::cast(a->klass())->element_type(); |
215 BasicType type = TypeArrayKlass::cast(a->klass())->element_type(); |
216 switch (type) { |
216 switch (type) { |
217 case T_BOOLEAN: |
217 case T_BOOLEAN: |
218 value->z = typeArrayOop(a)->bool_at(index); |
218 value->z = typeArrayOop(a)->bool_at(index); |
219 break; |
219 break; |
220 case T_CHAR: |
220 case T_CHAR: |
252 } |
252 } |
253 if (a->is_objArray()) { |
253 if (a->is_objArray()) { |
254 if (value_type == T_OBJECT) { |
254 if (value_type == T_OBJECT) { |
255 oop obj = (oop) value->l; |
255 oop obj = (oop) value->l; |
256 if (obj != NULL) { |
256 if (obj != NULL) { |
257 Klass* element_klass = objArrayKlass::cast(a->klass())->element_klass(); |
257 Klass* element_klass = ObjArrayKlass::cast(a->klass())->element_klass(); |
258 if (!obj->is_a(element_klass)) { |
258 if (!obj->is_a(element_klass)) { |
259 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch"); |
259 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), "array element type mismatch"); |
260 } |
260 } |
261 } |
261 } |
262 objArrayOop(a)->obj_at_put(index, obj); |
262 objArrayOop(a)->obj_at_put(index, obj); |
263 } |
263 } |
264 } else { |
264 } else { |
265 assert(a->is_typeArray(), "just checking"); |
265 assert(a->is_typeArray(), "just checking"); |
266 BasicType array_type = typeArrayKlass::cast(a->klass())->element_type(); |
266 BasicType array_type = TypeArrayKlass::cast(a->klass())->element_type(); |
267 if (array_type != value_type) { |
267 if (array_type != value_type) { |
268 // The widen operation can potentially throw an exception, but cannot block, |
268 // The widen operation can potentially throw an exception, but cannot block, |
269 // so typeArrayOop a is safe if the call succeeds. |
269 // so typeArrayOop a is safe if the call succeeds. |
270 widen(value, value_type, array_type, CHECK); |
270 widen(value, value_type, array_type, CHECK); |
271 } |
271 } |
311 } |
311 } |
312 } |
312 } |
313 |
313 |
314 |
314 |
315 oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) { |
315 oop Reflection:: basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) { |
316 BasicType type = typeArrayKlass::cast(basic_type_arrayklass)->element_type(); |
316 BasicType type = TypeArrayKlass::cast(basic_type_arrayklass)->element_type(); |
317 return Universe::java_mirror(type); |
317 return Universe::java_mirror(type); |
318 } |
318 } |
319 |
319 |
320 |
320 |
321 arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) { |
321 arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) { |
325 if (length < 0) { |
325 if (length < 0) { |
326 THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); |
326 THROW_0(vmSymbols::java_lang_NegativeArraySizeException()); |
327 } |
327 } |
328 if (java_lang_Class::is_primitive(element_mirror)) { |
328 if (java_lang_Class::is_primitive(element_mirror)) { |
329 Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); |
329 Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); |
330 return typeArrayKlass::cast(tak)->allocate(length, THREAD); |
330 return TypeArrayKlass::cast(tak)->allocate(length, THREAD); |
331 } else { |
331 } else { |
332 Klass* k = java_lang_Class::as_Klass(element_mirror); |
332 Klass* k = java_lang_Class::as_Klass(element_mirror); |
333 if (Klass::cast(k)->oop_is_array() && arrayKlass::cast(k)->dimension() >= MAX_DIM) { |
333 if (Klass::cast(k)->oop_is_array() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) { |
334 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); |
334 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); |
335 } |
335 } |
336 return oopFactory::new_objArray(k, length, THREAD); |
336 return oopFactory::new_objArray(k, length, THREAD); |
337 } |
337 } |
338 } |
338 } |
339 |
339 |
340 |
340 |
341 arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) { |
341 arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) { |
342 assert(dim_array->is_typeArray(), "just checking"); |
342 assert(dim_array->is_typeArray(), "just checking"); |
343 assert(typeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking"); |
343 assert(TypeArrayKlass::cast(dim_array->klass())->element_type() == T_INT, "just checking"); |
344 |
344 |
345 if (element_mirror == NULL) { |
345 if (element_mirror == NULL) { |
346 THROW_0(vmSymbols::java_lang_NullPointerException()); |
346 THROW_0(vmSymbols::java_lang_NullPointerException()); |
347 } |
347 } |
348 |
348 |
365 if (java_lang_Class::is_primitive(element_mirror)) { |
365 if (java_lang_Class::is_primitive(element_mirror)) { |
366 klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); |
366 klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL); |
367 } else { |
367 } else { |
368 klass = java_lang_Class::as_Klass(element_mirror); |
368 klass = java_lang_Class::as_Klass(element_mirror); |
369 if (Klass::cast(klass)->oop_is_array()) { |
369 if (Klass::cast(klass)->oop_is_array()) { |
370 int k_dim = arrayKlass::cast(klass)->dimension(); |
370 int k_dim = ArrayKlass::cast(klass)->dimension(); |
371 if (k_dim + len > MAX_DIM) { |
371 if (k_dim + len > MAX_DIM) { |
372 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); |
372 THROW_0(vmSymbols::java_lang_IllegalArgumentException()); |
373 } |
373 } |
374 dim += k_dim; |
374 dim += k_dim; |
375 } |
375 } |
376 } |
376 } |
377 klass = Klass::cast(klass)->array_klass(dim, CHECK_NULL); |
377 klass = Klass::cast(klass)->array_klass(dim, CHECK_NULL); |
378 oop obj = arrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD); |
378 oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, THREAD); |
379 assert(obj->is_array(), "just checking"); |
379 assert(obj->is_array(), "just checking"); |
380 return arrayOop(obj); |
380 return arrayOop(obj); |
381 } |
381 } |
382 |
382 |
383 |
383 |
389 Klass* klass = java_lang_Class::as_Klass(mirror); |
389 Klass* klass = java_lang_Class::as_Klass(mirror); |
390 if (!Klass::cast(klass)->oop_is_array()) { |
390 if (!Klass::cast(klass)->oop_is_array()) { |
391 return NULL; |
391 return NULL; |
392 } |
392 } |
393 |
393 |
394 oop result = arrayKlass::cast(klass)->component_mirror(); |
394 oop result = ArrayKlass::cast(klass)->component_mirror(); |
395 #ifdef ASSERT |
395 #ifdef ASSERT |
396 oop result2 = NULL; |
396 oop result2 = NULL; |
397 if (arrayKlass::cast(klass)->dimension() == 1) { |
397 if (ArrayKlass::cast(klass)->dimension() == 1) { |
398 if (Klass::cast(klass)->oop_is_typeArray()) { |
398 if (Klass::cast(klass)->oop_is_typeArray()) { |
399 result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL); |
399 result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL); |
400 } else { |
400 } else { |
401 result2 = Klass::cast(objArrayKlass::cast(klass)->element_klass())->java_mirror(); |
401 result2 = Klass::cast(ObjArrayKlass::cast(klass)->element_klass())->java_mirror(); |
402 } |
402 } |
403 } else { |
403 } else { |
404 Klass* lower_dim = arrayKlass::cast(klass)->lower_dimension(); |
404 Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension(); |
405 assert(Klass::cast(lower_dim)->oop_is_array(), "just checking"); |
405 assert(Klass::cast(lower_dim)->oop_is_array(), "just checking"); |
406 result2 = Klass::cast(lower_dim)->java_mirror(); |
406 result2 = Klass::cast(lower_dim)->java_mirror(); |
407 } |
407 } |
408 assert(result == result2, "results must be consistent"); |
408 assert(result == result2, "results must be consistent"); |
409 #endif //ASSERT |
409 #endif //ASSERT |