1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 /*
18 * java.lang.reflect.Array
19 */
20 #include "Dalvik.h"
21 #include "native/InternalNativePriv.h"
22
23
24 /*
25 * private static Object createObjectArray(Class<?> componentType,
26 * int length) throws NegativeArraySizeException;
27 *
28 * Create a one-dimensional array of Objects.
29 */
Dalvik_java_lang_reflect_Array_createObjectArray(const u4 * args,JValue * pResult)30 static void Dalvik_java_lang_reflect_Array_createObjectArray(const u4* args,
31 JValue* pResult)
32 {
33 ClassObject* elementClass = (ClassObject*) args[0];
34 int length = args[1];
35 ArrayObject* newArray;
36
37 assert(elementClass != NULL); // tested by caller
38 if (length < 0) {
39 dvmThrowException("Ljava/lang/NegativeArraySizeException;", NULL);
40 RETURN_VOID();
41 }
42
43 newArray = dvmAllocObjectArray(elementClass, length, ALLOC_DEFAULT);
44 if (newArray == NULL) {
45 assert(dvmCheckException(dvmThreadSelf()));
46 RETURN_VOID();
47 }
48 dvmReleaseTrackedAlloc((Object*) newArray, NULL);
49
50 RETURN_PTR(newArray);
51 }
52
53 /*
54 * private static Object createMultiArray(Class<?> componentType,
55 * int[] dimensions) throws NegativeArraySizeException;
56 *
57 * Create a multi-dimensional array of Objects or primitive types.
58 *
59 * We have to generate the names for X[], X[][], X[][][], and so on. The
60 * easiest way to deal with that is to create the full name once and then
61 * subtract pieces off. Besides, we want to start with the outermost
62 * piece and work our way in.
63 */
Dalvik_java_lang_reflect_Array_createMultiArray(const u4 * args,JValue * pResult)64 static void Dalvik_java_lang_reflect_Array_createMultiArray(const u4* args,
65 JValue* pResult)
66 {
67 static const char kPrimLetter[] = PRIM_TYPE_TO_LETTER;
68 ClassObject* elementClass = (ClassObject*) args[0];
69 ArrayObject* dimArray = (ArrayObject*) args[1];
70 ClassObject* arrayClass;
71 ArrayObject* newArray;
72 char* acDescriptor;
73 int numDim, i;
74 int* dimensions;
75
76 LOGV("createMultiArray: '%s' [%d]\n",
77 elementClass->descriptor, dimArray->length);
78
79 assert(elementClass != NULL); // verified by caller
80
81 /*
82 * Verify dimensions.
83 *
84 * The caller is responsible for verifying that "dimArray" is non-null
85 * and has a length > 0 and <= 255.
86 */
87 assert(dimArray != NULL); // verified by caller
88 numDim = dimArray->length;
89 assert(numDim > 0 && numDim <= 255);
90
91 dimensions = (int*) dimArray->contents;
92 for (i = 0; i < numDim; i++) {
93 if (dimensions[i] < 0) {
94 dvmThrowException("Ljava/lang/NegativeArraySizeException;", NULL);
95 RETURN_VOID();
96 }
97 LOGVV("DIM %d: %d\n", i, dimensions[i]);
98 }
99
100 /*
101 * Generate the full name of the array class.
102 */
103 acDescriptor =
104 (char*) malloc(strlen(elementClass->descriptor) + numDim + 1);
105 memset(acDescriptor, '[', numDim);
106
107 LOGVV("#### element name = '%s'\n", elementClass->descriptor);
108 if (dvmIsPrimitiveClass(elementClass)) {
109 assert(elementClass->primitiveType >= 0);
110 acDescriptor[numDim] = kPrimLetter[elementClass->primitiveType];
111 acDescriptor[numDim+1] = '\0';
112 } else {
113 strcpy(acDescriptor+numDim, elementClass->descriptor);
114 }
115 LOGVV("#### array name = '%s'\n", acDescriptor);
116
117 /*
118 * Find/generate the array class.
119 */
120 arrayClass = dvmFindArrayClass(acDescriptor, elementClass->classLoader);
121 if (arrayClass == NULL) {
122 LOGW("Unable to find or generate array class '%s'\n", acDescriptor);
123 assert(dvmCheckException(dvmThreadSelf()));
124 free(acDescriptor);
125 RETURN_VOID();
126 }
127 free(acDescriptor);
128
129 /* create the array */
130 newArray = dvmAllocMultiArray(arrayClass, numDim-1, dimensions);
131 if (newArray == NULL) {
132 assert(dvmCheckException(dvmThreadSelf()));
133 RETURN_VOID();
134 }
135
136 dvmReleaseTrackedAlloc((Object*) newArray, NULL);
137 RETURN_PTR(newArray);
138 }
139
140 const DalvikNativeMethod dvm_java_lang_reflect_Array[] = {
141 { "createObjectArray", "(Ljava/lang/Class;I)Ljava/lang/Object;",
142 Dalvik_java_lang_reflect_Array_createObjectArray },
143 { "createMultiArray", "(Ljava/lang/Class;[I)Ljava/lang/Object;",
144 Dalvik_java_lang_reflect_Array_createMultiArray },
145 { NULL, NULL, NULL },
146 };
147