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.Constructor
19 */
20 #include "Dalvik.h"
21 #include "native/InternalNativePriv.h"
22
23
24 /*
25 * public int getConstructorModifiers(Class declaringClass, int slot)
26 */
Dalvik_java_lang_reflect_Constructor_getConstructorModifiers(const u4 * args,JValue * pResult)27 static void Dalvik_java_lang_reflect_Constructor_getConstructorModifiers(
28 const u4* args, JValue* pResult)
29 {
30 // ignore thisPtr in args[0]
31 ClassObject* declaringClass = (ClassObject*) args[1];
32 int slot = args[2];
33 Method* meth;
34
35 meth = dvmSlotToMethod(declaringClass, slot);
36 RETURN_INT(dvmFixMethodFlags(meth->accessFlags));
37 }
38
39 /*
40 * public int constructNative(Object[] args, Class declaringClass,
41 * Class[] parameterTypes, int slot, boolean noAccessCheck)
42 *
43 * We get here through Constructor.newInstance(). The Constructor object
44 * would not be available if the constructor weren't public (per the
45 * definition of Class.getConstructor), so we can skip the method access
46 * check. We can also safely assume the constructor isn't associated
47 * with an interface, array, or primitive class.
48 */
Dalvik_java_lang_reflect_Constructor_constructNative(const u4 * args,JValue * pResult)49 static void Dalvik_java_lang_reflect_Constructor_constructNative(
50 const u4* args, JValue* pResult)
51 {
52 // ignore thisPtr in args[0]
53 ArrayObject* argList = (ArrayObject*) args[1];
54 ClassObject* declaringClass = (ClassObject*) args[2];
55 ArrayObject* params = (ArrayObject*) args[3];
56 int slot = args[4];
57 bool noAccessCheck = (args[5] != 0);
58 Object* newObj;
59 Method* meth;
60
61 if (dvmIsAbstractClass(declaringClass)) {
62 dvmThrowExceptionWithClassMessage("Ljava/lang/InstantiationException;",
63 declaringClass->descriptor);
64 RETURN_VOID();
65 }
66
67 /* initialize the class if it hasn't been already */
68 if (!dvmIsClassInitialized(declaringClass)) {
69 if (!dvmInitClass(declaringClass)) {
70 LOGW("Class init failed in Constructor.constructNative (%s)\n",
71 declaringClass->descriptor);
72 assert(dvmCheckException(dvmThreadSelf()));
73 RETURN_VOID();
74 }
75 }
76
77 newObj = dvmAllocObject(declaringClass, ALLOC_DEFAULT);
78 if (newObj == NULL)
79 RETURN_PTR(NULL);
80
81 meth = dvmSlotToMethod(declaringClass, slot);
82 assert(meth != NULL);
83
84 (void) dvmInvokeMethod(newObj, meth, argList, params, NULL, noAccessCheck);
85 dvmReleaseTrackedAlloc(newObj, NULL);
86 RETURN_PTR(newObj);
87 }
88
89 /*
90 * public Annotation[] getDeclaredAnnotations(Class declaringClass, int slot)
91 *
92 * Return the annotations declared for this constructor.
93 */
Dalvik_java_lang_reflect_Constructor_getDeclaredAnnotations(const u4 * args,JValue * pResult)94 static void Dalvik_java_lang_reflect_Constructor_getDeclaredAnnotations(
95 const u4* args, JValue* pResult)
96 {
97 // ignore thisPtr in args[0]
98 ClassObject* declaringClass = (ClassObject*) args[1];
99 int slot = args[2];
100 Method* meth;
101
102 meth = dvmSlotToMethod(declaringClass, slot);
103 assert(meth != NULL);
104
105 ArrayObject* annos = dvmGetMethodAnnotations(meth);
106 dvmReleaseTrackedAlloc((Object*)annos, NULL);
107 RETURN_PTR(annos);
108 }
109
110 /*
111 * public Annotation[][] getParameterAnnotations(Class declaringClass, int slot)
112 *
113 * Return the annotations declared for this constructor's parameters.
114 */
Dalvik_java_lang_reflect_Constructor_getParameterAnnotations(const u4 * args,JValue * pResult)115 static void Dalvik_java_lang_reflect_Constructor_getParameterAnnotations(
116 const u4* args, JValue* pResult)
117 {
118 // ignore thisPtr in args[0]
119 ClassObject* declaringClass = (ClassObject*) args[1];
120 int slot = args[2];
121 Method* meth;
122
123 meth = dvmSlotToMethod(declaringClass, slot);
124 assert(meth != NULL);
125
126 ArrayObject* annos = dvmGetParameterAnnotations(meth);
127 dvmReleaseTrackedAlloc((Object*)annos, NULL);
128 RETURN_PTR(annos);
129 }
130
131 /*
132 * private Object[] getSignatureAnnotation()
133 *
134 * Returns the signature annotation.
135 */
Dalvik_java_lang_reflect_Constructor_getSignatureAnnotation(const u4 * args,JValue * pResult)136 static void Dalvik_java_lang_reflect_Constructor_getSignatureAnnotation(
137 const u4* args, JValue* pResult)
138 {
139 // ignore thisPtr in args[0]
140 ClassObject* declaringClass = (ClassObject*) args[1];
141 int slot = args[2];
142 Method* meth;
143
144 meth = dvmSlotToMethod(declaringClass, slot);
145 assert(meth != NULL);
146
147 ArrayObject* arr = dvmGetMethodSignatureAnnotation(meth);
148 dvmReleaseTrackedAlloc((Object*) arr, NULL);
149 RETURN_PTR(arr);
150 }
151
152 const DalvikNativeMethod dvm_java_lang_reflect_Constructor[] = {
153 { "constructNative", "([Ljava/lang/Object;Ljava/lang/Class;[Ljava/lang/Class;IZ)Ljava/lang/Object;",
154 Dalvik_java_lang_reflect_Constructor_constructNative },
155 { "getConstructorModifiers", "(Ljava/lang/Class;I)I",
156 Dalvik_java_lang_reflect_Constructor_getConstructorModifiers },
157 { "getDeclaredAnnotations", "(Ljava/lang/Class;I)[Ljava/lang/annotation/Annotation;",
158 Dalvik_java_lang_reflect_Constructor_getDeclaredAnnotations },
159 { "getParameterAnnotations", "(Ljava/lang/Class;I)[[Ljava/lang/annotation/Annotation;",
160 Dalvik_java_lang_reflect_Constructor_getParameterAnnotations },
161 { "getSignatureAnnotation", "(Ljava/lang/Class;I)[Ljava/lang/Object;",
162 Dalvik_java_lang_reflect_Constructor_getSignatureAnnotation },
163 { NULL, NULL, NULL },
164 };
165
166