OSDN Git Service

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