1 /*
2 * Copyright (c) 2002, 2012, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 package sun.jvm.hotspot.utilities;
26
27 import java.lang.reflect.Modifier;
28 import java.util.*;
29 import sun.jvm.hotspot.debugger.*;
30 import sun.jvm.hotspot.oops.*;
31 import sun.jvm.hotspot.runtime.*;
32 import sun.jvm.hotspot.utilities.*;
33
34 /**
35 * ObjectReader can "deserialize" objects from debuggee.
36 *
37 * Class Loading:
38 *
39 * ObjectReader loads classes using the given class loader. If no
40 * class loader is supplied, it uses a ProcImageClassLoader, which
41 * loads classes from debuggee core or process.
42
43 * Object creation:
44 *
45 * This class uses no-arg constructor to construct objects. But if
46 * there is no no-arg constructor in a given class, then it tries to
47 * use other constructors with 'default' values - null for object
48 * types, 0, 0.0, false etc. for primitives. If this process fails to
49 * construct an instance (because of null checking by constructor or 0
50 * being invalid for an int arg etc.), then null is returned. While
51 * constructing complete object graph 'null' is inserted silently on
52 * failure and the deserialization continues to construct best-effort
53 * object graph.
54 *
55 * Debug messages:
56 *
57 * The flag sun.jvm.hotspot.utilities.ObjectReader.DEBUG may be set to
58 * non-null to get debug error messages and stack traces.
59 *
60 * JDK version:
61 *
62 * JDK classes are loaded by bootstrap class loader and not by the
63 * supplied class loader or ProcImageClassLoader. This may create
64 * problems if a JDK class evolves. i.e., if SA runs a JDK version
65 * different from that of the debuggee, there is a possibility of
66 * schema change. It is recommended that the matching JDK version be
67 * used to run SA for proper object deserialization.
68 *
69 */
70
71 public class ObjectReader {
72
73 private static final boolean DEBUG;
74 static {
75 DEBUG = System.getProperty("sun.jvm.hotspot.utilities.ObjectReader.DEBUG") != null;
76 }
77
78 public ObjectReader(ClassLoader cl) {
79 this.cl = cl;
80 this.oopToObjMap = new HashMap();
81 this.fieldMap = new HashMap();
82 }
83
84 public ObjectReader() {
85 this(new ProcImageClassLoader());
86 }
87
88 static void debugPrintln(String msg) {
89 if (DEBUG) {
90 System.err.println("DEBUG>" + msg);
91 }
92 }
93
94 static void debugPrintStackTrace(Exception exp) {
95 if (DEBUG) {
96 StackTraceElement[] els = exp.getStackTrace();
97 for (int i = 0; i < els.length; i++) {
98 System.err.println("DEBUG>" + els[i].toString());
99 }
100 }
101 }
102
103 public Object readObject(Oop oop) throws ClassNotFoundException {
104 if (oop instanceof Instance) {
105 return readInstance((Instance) oop);
106 } else if (oop instanceof TypeArray){
107 return readPrimitiveArray((TypeArray)oop);
108 } else if (oop instanceof ObjArray){
109 return readObjectArray((ObjArray)oop);
110 } else {
111 return null;
112 }
113 }
114
115 protected final Object getDefaultPrimitiveValue(Class clz) {
116 if (clz == Boolean.TYPE) {
117 return Boolean.FALSE;
118 } else if (clz == Character.TYPE) {
119 return new Character(' ');
120 } else if (clz == Byte.TYPE) {
121 return new Byte((byte) 0);
122 } else if (clz == Short.TYPE) {
123 return new Short((short) 0);
124 } else if (clz == Integer.TYPE) {
125 return new Integer(0);
126 } else if (clz == Long.TYPE) {
127 return new Long(0L);
128 } else if (clz == Float.TYPE) {
129 return new Float(0.0f);
130 } else if (clz == Double.TYPE) {
131 return new Double(0.0);
132 } else {
133 throw new RuntimeException("should not reach here!");
134 }
135 }
136
137 protected Symbol javaLangString;
138 protected Symbol javaUtilHashtableEntry;
139 protected Symbol javaUtilHashtable;
140 protected Symbol javaUtilProperties;
141
142 protected Symbol getVMSymbol(String name) {
143 return VM.getVM().getSymbolTable().probe(name);
144 }
145
146 protected Symbol javaLangString() {
147 if (javaLangString == null) {
148 javaLangString = getVMSymbol("java/lang/String");
149 }
150 return javaLangString;
151 }
152
153 protected Symbol javaUtilHashtableEntry() {
154 if (javaUtilHashtableEntry == null) {
155 javaUtilHashtableEntry = getVMSymbol("java/util/Hashtable$Entry");
156 }
157 return javaUtilHashtableEntry;
158 }
159
160 protected Symbol javaUtilHashtable() {
161 if (javaUtilHashtable == null) {
162 javaUtilHashtable = getVMSymbol("java/util/Hashtable");
163 }
164 return javaUtilHashtable;
165 }
166
167 protected Symbol javaUtilProperties() {
168 if (javaUtilProperties == null) {
169 javaUtilProperties = getVMSymbol("java/util/Properties");
170 }
171 return javaUtilProperties;
172 }
173
174 private void setHashtableEntry(java.util.Hashtable p, Oop oop) {
175 InstanceKlass ik = (InstanceKlass)oop.getKlass();
176 OopField keyField = (OopField)ik.findField("key", "Ljava/lang/Object;");
177 OopField valueField = (OopField)ik.findField("value", "Ljava/lang/Object;");
178 OopField nextField = (OopField)ik.findField("next", "Ljava/util/Hashtable$Entry;");
179 if (DEBUG) {
180 if (Assert.ASSERTS_ENABLED) {
181 Assert.that(ik.getName().equals(javaUtilHashtableEntry()), "Not a Hashtable$Entry?");
182 Assert.that(keyField != null && valueField != null && nextField != null, "Invalid fields!");
183 }
184 }
185
186 Object key = null;
187 Object value = null;
188 Oop next = null;
189 try {
190 key = readObject(keyField.getValue(oop));
191 value = readObject(valueField.getValue(oop));
192 next = (Oop)nextField.getValue(oop);
193 // For Properties, should use setProperty(k, v). Since it only runs in SA
194 // using put(k, v) should be OK.
195 p.put(key, value);
196 if (next != null) {
197 setHashtableEntry(p, next);
198 }
199 } catch (ClassNotFoundException ce) {
200 if( DEBUG) {
201 debugPrintln("Class not found " + ce);
202 debugPrintStackTrace(ce);
203 }
204 }
205 }
206
207 protected Object getHashtable(Instance oop, boolean isProperties) {
208 InstanceKlass k = (InstanceKlass)oop.getKlass();
209 OopField tableField = (OopField)k.findField("table", "[Ljava/util/Hashtable$Entry;");
210 if (tableField == null) {
211 debugPrintln("Could not find field of [Ljava/util/Hashtable$Entry;");
212 return null;
213 }
214 java.util.Hashtable table = (isProperties) ? new java.util.Properties()
215 : new java.util.Hashtable();
216 ObjArray kvs = (ObjArray)tableField.getValue(oop);
217 long size = kvs.getLength();
218 debugPrintln("Hashtable$Entry Size = " + size);
219 for (long i=0; i<size; i++) {
220 Oop entry = kvs.getObjAt(i);
221 if (entry != null && entry.isInstance()) {
222 setHashtableEntry(table, entry);
223 }
224 }
225 return table;
226 }
227
228 public Object readInstance(Instance oop) throws ClassNotFoundException {
229 Object result = getFromObjTable(oop);
230 if (result == null) {
231 InstanceKlass kls = (InstanceKlass) oop.getKlass();
232 // Handle java.lang.String instances differently. As part of JSR-133, fields of immutable
233 // classes have been made final. The algorithm below will not be able to read Strings from
234 // debuggee (can't use reflection to set final fields). But, need to read Strings is very
235 // important.
236 // Same for Hashtable, key and hash are final, could not be set in the algorithm too.
237 // FIXME: need a framework to handle many other special cases.
238 if (kls.getName().equals(javaLangString())) {
239 return OopUtilities.stringOopToString(oop);
240 }
241
242 if (kls.getName().equals(javaUtilHashtable())) {
243 return getHashtable(oop, false);
244 }
245
246 if (kls.getName().equals(javaUtilProperties())) {
247 return getHashtable(oop, true);
248 }
249
250 Class clz = readClass(kls);
251 try {
252 result = clz.newInstance();
253 } catch (Exception ex) {
254 // no-arg constructor failed to create object. Let us try
255 // to call constructors one-by-one with default arguments
256 // (null for objects, 0/0.0 etc. for primitives) till we
257 // succeed or fail on all constructors.
258
259 java.lang.reflect.Constructor[] ctrs = clz.getDeclaredConstructors();
260 for (int n = 0; n < ctrs.length; n++) {
261 java.lang.reflect.Constructor c = ctrs[n];
262 Class[] paramTypes = c.getParameterTypes();
263 Object[] params = new Object[paramTypes.length];
264 for (int i = 0; i < params.length; i++) {
265 if (paramTypes[i].isPrimitive()) {
266 params[i] = getDefaultPrimitiveValue(paramTypes[i]);
267 }
268 }
269 try {
270 c.setAccessible(true);
271 result = c.newInstance(params);
272 break;
273 } catch (Exception exp) {
274 if (DEBUG) {
275 debugPrintln("Can't create object using " + c);
276 debugPrintStackTrace(exp);
277 }
278 }
279 }
280 }
281
282 if (result != null) {
283 putIntoObjTable(oop, result);
284 oop.iterate(new FieldSetter(result), false);
285 }
286 }
287 return result;
288 }
289
290 public Object readPrimitiveArray(final TypeArray array) {
291
292 Object result = getFromObjTable(array);
293 if (result == null) {
294 int length = (int) array.getLength();
295 TypeArrayKlass klass = (TypeArrayKlass) array.getKlass();
296 int type = (int) klass.getElementType();
297 switch (type) {
298 case TypeArrayKlass.T_BOOLEAN: {
299 final boolean[] arrayObj = new boolean[length];
300 array.iterate(new DefaultOopVisitor() {
301 public void doBoolean(BooleanField field, boolean isVMField) {
302 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
303 arrayObj[ifd.getIndex()] = field.getValue(array);
304 }
305 }, false);
306 result = arrayObj;
307 }
308 break;
309
310 case TypeArrayKlass.T_CHAR: {
311 final char[] arrayObj = new char[length];
312 array.iterate(new DefaultOopVisitor() {
313 public void doChar(CharField field, boolean isVMField) {
314 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
315 arrayObj[ifd.getIndex()] = field.getValue(array);
316 }
317 }, false);
318 result = arrayObj;
319 }
320 break;
321
322 case TypeArrayKlass.T_FLOAT: {
323 final float[] arrayObj = new float[length];
324 array.iterate(new DefaultOopVisitor() {
325 public void doFloat(FloatField field, boolean isVMField) {
326 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
327 arrayObj[ifd.getIndex()] = field.getValue(array);
328 }
329 }, false);
330 result = arrayObj;
331 }
332 break;
333
334 case TypeArrayKlass.T_DOUBLE: {
335 final double[] arrayObj = new double[length];
336 array.iterate(new DefaultOopVisitor() {
337 public void doDouble(DoubleField field, boolean isVMField) {
338 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
339 arrayObj[ifd.getIndex()] = field.getValue(array);
340 }
341 }, false);
342 result = arrayObj;
343 }
344 break;
345
346 case TypeArrayKlass.T_BYTE: {
347 final byte[] arrayObj = new byte[length];
348 array.iterate(new DefaultOopVisitor() {
349 public void doByte(ByteField field, boolean isVMField) {
350 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
351 arrayObj[ifd.getIndex()] = field.getValue(array);
352 }
353 }, false);
354 result = arrayObj;
355 }
356 break;
357
358 case TypeArrayKlass.T_SHORT: {
359 final short[] arrayObj = new short[length];
360 array.iterate(new DefaultOopVisitor() {
361 public void doShort(ShortField field, boolean isVMField) {
362 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
363 arrayObj[ifd.getIndex()] = field.getValue(array);
364 }
365 }, false);
366 result = arrayObj;
367 }
368 break;
369
370 case TypeArrayKlass.T_INT: {
371 final int[] arrayObj = new int[length];
372 array.iterate(new DefaultOopVisitor() {
373 public void doInt(IntField field, boolean isVMField) {
374 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
375 arrayObj[ifd.getIndex()] = field.getValue(array);
376 }
377 }, false);
378 result = arrayObj;
379 }
380 break;
381
382 case TypeArrayKlass.T_LONG: {
383 final long[] arrayObj = new long[length];
384 array.iterate(new DefaultOopVisitor() {
385 public void doLong(LongField field, boolean isVMField) {
386 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
387 arrayObj[ifd.getIndex()] = field.getValue(array);
388 }
389 }, false);
390 result = arrayObj;
391 }
392 break;
393
394 default:
395 throw new RuntimeException("should not reach here!");
396 }
397
398 putIntoObjTable(array, result);
399 }
400 return result;
401 }
402
403 protected final boolean isRobust(OopHandle handle) {
404 return RobustOopDeterminator.oopLooksValid(handle);
405 }
406
407 public Object readObjectArray(final ObjArray array) throws ClassNotFoundException {
408 Object result = getFromObjTable(array);
409 if (result == null) {
410 int length = (int) array.getLength();
411 ObjArrayKlass klass = (ObjArrayKlass) array.getKlass();
412 Klass bottomKls = klass.getBottomKlass();
413 Class bottomCls = null;
414 final int dimension = (int) klass.getDimension();
415 int[] dimArray = null;
416 if (bottomKls instanceof InstanceKlass) {
417 bottomCls = readClass((InstanceKlass) bottomKls);
418 dimArray = new int[dimension];
419 } else { // instanceof TypeArrayKlass
420 TypeArrayKlass botKls = (TypeArrayKlass) bottomKls;
421 dimArray = new int[dimension -1];
422 }
423 // initialize the length
424 dimArray[0] = length;
425 final Object[] arrayObj = (Object[]) java.lang.reflect.Array.newInstance(bottomCls, dimArray);
426 putIntoObjTable(array, arrayObj);
427 result = arrayObj;
428 array.iterate(new DefaultOopVisitor() {
429 public void doOop(OopField field, boolean isVMField) {
430 OopHandle handle = field.getValueAsOopHandle(getObj());
431 if (! isRobust(handle)) {
432 return;
433 }
434
435 IndexableFieldIdentifier ifd = (IndexableFieldIdentifier) field.getID();
436 try {
437 arrayObj[ifd.getIndex()] = readObject(field.getValue(getObj()));
438 } catch (Exception e) {
439 if (DEBUG) {
440 debugPrintln("Array element set failed for " + ifd);
441 debugPrintStackTrace(e);
442 }
443 }
444 }
445 }, false);
446 }
447 return result;
448 }
449
450 protected class FieldSetter extends DefaultOopVisitor {
451 protected Object obj;
452
453 public FieldSetter(Object obj) {
454 this.obj = obj;
455 }
456
457 private void printFieldSetError(java.lang.reflect.Field f, Exception ex) {
458 if (DEBUG) {
459 if (f != null) debugPrintln("Field set failed for " + f);
460 debugPrintStackTrace(ex);
461 }
462 }
463
464 // Callback methods for each field type in an object
465 public void doOop(OopField field, boolean isVMField) {
466 OopHandle handle = field.getValueAsOopHandle(getObj());
467 if (! isRobust(handle) ) {
468 return;
469 }
470
471 java.lang.reflect.Field f = null;
472 try {
473 f = readField(field);
474 if (Modifier.isFinal(f.getModifiers())) return;
475 f.setAccessible(true);
476 f.set(obj, readObject(field.getValue(getObj())));
477 } catch (Exception ex) {
478 printFieldSetError(f, ex);
479 }
480 }
481
482 public void doByte(ByteField field, boolean isVMField) {
483 java.lang.reflect.Field f = null;
484 try {
485 f = readField(field);
486 if (Modifier.isFinal(f.getModifiers())) return;
487 f.setAccessible(true);
488 f.setByte(obj, field.getValue(getObj()));
489 } catch (Exception ex) {
490 printFieldSetError(f, ex);
491 }
492 }
493
494 public void doChar(CharField field, boolean isVMField) {
495 java.lang.reflect.Field f = null;
496 try {
497 f = readField(field);
498 if (Modifier.isFinal(f.getModifiers())) return;
499 f.setAccessible(true);
500 f.setChar(obj, field.getValue(getObj()));
501 } catch (Exception ex) {
502 printFieldSetError(f, ex);
503 }
504 }
505
506 public void doBoolean(BooleanField field, boolean isVMField) {
507 java.lang.reflect.Field f = null;
508 try {
509 f = readField(field);
510 if (Modifier.isFinal(f.getModifiers())) return;
511 f.setAccessible(true);
512 f.setBoolean(obj, field.getValue(getObj()));
513 } catch (Exception ex) {
514 printFieldSetError(f, ex);
515 }
516 }
517
518 public void doShort(ShortField field, boolean isVMField) {
519 java.lang.reflect.Field f = null;
520 try {
521 f = readField(field);
522 if (Modifier.isFinal(f.getModifiers())) return;
523 f.setAccessible(true);
524 f.setShort(obj, field.getValue(getObj()));
525 } catch (Exception ex) {
526 printFieldSetError(f, ex);
527 }
528 }
529
530 public void doInt(IntField field, boolean isVMField) {
531 java.lang.reflect.Field f = null;
532 try {
533 f = readField(field);
534 if (Modifier.isFinal(f.getModifiers())) return;
535 f.setAccessible(true);
536 f.setInt(obj, field.getValue(getObj()));
537 } catch (Exception ex) {
538 printFieldSetError(f, ex);
539 }
540 }
541
542 public void doLong(LongField field, boolean isVMField) {
543 java.lang.reflect.Field f = null;
544 try {
545 f = readField(field);
546 if (Modifier.isFinal(f.getModifiers())) return;
547 f.setAccessible(true);
548 f.setLong(obj, field.getValue(getObj()));
549 } catch (Exception ex) {
550 printFieldSetError(f, ex);
551 }
552 }
553
554 public void doFloat(FloatField field, boolean isVMField) {
555 java.lang.reflect.Field f = null;
556 try {
557 f = readField(field);
558 if (Modifier.isFinal(f.getModifiers())) return;
559 f.setAccessible(true);
560 f.setFloat(obj, field.getValue(getObj()));
561 } catch (Exception ex) {
562 printFieldSetError(f, ex);
563 }
564 }
565
566 public void doDouble(DoubleField field, boolean isVMField) {
567 java.lang.reflect.Field f = null;
568 try {
569 f = readField(field);
570 if (Modifier.isFinal(f.getModifiers())) return;
571 f.setAccessible(true);
572 f.setDouble(obj, field.getValue(getObj()));
573 } catch (Exception ex) {
574 printFieldSetError(f, ex);
575 }
576 }
577
578 public void doCInt(CIntField field, boolean isVMField) {
579 throw new RuntimeException("should not reach here!");
580 }
581 }
582
583 public Class readClass(InstanceKlass kls) throws ClassNotFoundException {
584 Class cls = (Class) getFromObjTable(kls);
585 if (cls == null) {
586 cls = Class.forName(kls.getName().asString().replace('/', '.'), true, cl);
587 putIntoObjTable(kls, cls);
588 }
589 return cls;
590 }
591
592 public Object readMethodOrConstructor(sun.jvm.hotspot.oops.Method m)
593 throws NoSuchMethodException, ClassNotFoundException {
594 String name = m.getName().asString();
595 if (name.equals("<init>")) {
596 return readConstructor(m);
597 } else {
598 return readMethod(m);
599 }
600 }
601
602 public java.lang.reflect.Method readMethod(sun.jvm.hotspot.oops.Method m)
603 throws NoSuchMethodException, ClassNotFoundException {
604 java.lang.reflect.Method result = (java.lang.reflect.Method) getFromObjTable(m);
605 if (result == null) {
606 Class clz = readClass((InstanceKlass)m.getMethodHolder());
607 String name = m.getName().asString();
608 Class[] paramTypes = getParamTypes(m.getSignature());
609 result = clz.getMethod(name, paramTypes);
610 putIntoObjTable(m, result);
611 }
612 return result;
613 }
614
615 public java.lang.reflect.Constructor readConstructor(sun.jvm.hotspot.oops.Method m)
616 throws NoSuchMethodException, ClassNotFoundException {
617 java.lang.reflect.Constructor result = (java.lang.reflect.Constructor) getFromObjTable(m);
618 if (result == null) {
619 Class clz = readClass((InstanceKlass)m.getMethodHolder());
620 String name = m.getName().asString();
621 Class[] paramTypes = getParamTypes(m.getSignature());
622 result = clz.getDeclaredConstructor(paramTypes);
623 putIntoObjTable(m, result);
624 }
625 return result;
626 }
627
628 public java.lang.reflect.Field readField(sun.jvm.hotspot.oops.Field f)
629 throws NoSuchFieldException, ClassNotFoundException {
630 java.lang.reflect.Field result = (java.lang.reflect.Field) fieldMap.get(f);
631 if (result == null) {
632 FieldIdentifier fieldId = f.getID();
633 Class clz = readClass((InstanceKlass) f.getFieldHolder());
634 String name = fieldId.getName();
635 try {
636 result = clz.getField(name);
637 } catch (NoSuchFieldException nsfe) {
638 result = clz.getDeclaredField(name);
639 }
640 fieldMap.put(f, result);
641 }
642 return result;
643 }
644
645 protected final ClassLoader cl;
646 protected Map oopToObjMap; // Map<Oop, Object>
647 protected Map fieldMap; // Map<sun.jvm.hotspot.oops.Field, java.lang.reflect.Field>
648
649 protected void putIntoObjTable(Oop oop, Object obj) {
650 oopToObjMap.put(oop, obj);
651 }
652
653 protected Object getFromObjTable(Oop oop) {
654 return oopToObjMap.get(oop);
655 }
656
657 protected void putIntoObjTable(Metadata oop, Object obj) {
658 oopToObjMap.put(oop, obj);
659 }
660
661 protected Object getFromObjTable(Metadata oop) {
662 return oopToObjMap.get(oop);
663 }
664
665 protected class SignatureParser extends SignatureIterator {
666 protected Vector tmp = new Vector(); // Vector<Class>
667
668 public SignatureParser(Symbol s) {
669 super(s);
670 }
671
672 public void doBool () { tmp.add(Boolean.TYPE); }
673 public void doChar () { tmp.add(Character.TYPE); }
674 public void doFloat () { tmp.add(Float.TYPE); }
675 public void doDouble() { tmp.add(Double.TYPE); }
676 public void doByte () { tmp.add(Byte.TYPE); }
677 public void doShort () { tmp.add(Short.TYPE); }
678 public void doInt () { tmp.add(Integer.TYPE); }
679 public void doLong () { tmp.add(Long.TYPE); }
680 public void doVoid () {
681 if(isReturnType()) {
682 tmp.add(Void.TYPE);
683 } else {
684 throw new RuntimeException("should not reach here");
685 }
686 }
687
688 public void doObject(int begin, int end) {
689 tmp.add(getClass(begin, end));
690 }
691
692 public void doArray (int begin, int end) {
693 int inner = arrayInnerBegin(begin);
694 Class elemCls = null;
695 switch (_signature.getByteAt(inner)) {
696 case 'B': elemCls = Boolean.TYPE; break;
697 case 'C': elemCls = Character.TYPE; break;
698 case 'D': elemCls = Double.TYPE; break;
699 case 'F': elemCls = Float.TYPE; break;
700 case 'I': elemCls = Integer.TYPE; break;
701 case 'J': elemCls = Long.TYPE; break;
702 case 'S': elemCls = Short.TYPE; break;
703 case 'Z': elemCls = Boolean.TYPE; break;
704 case 'L': elemCls = getClass(inner + 1, end); break;
705 default: break;
706 }
707
708 int dimension = inner - begin;
709 // create 0 x 0 ... array and get class from that
710 int[] dimArray = new int[dimension];
711 tmp.add(java.lang.reflect.Array.newInstance(elemCls, dimArray).getClass());
712 }
713
714 protected Class getClass(int begin, int end) {
715 String className = getClassName(begin, end);
716 try {
717 return Class.forName(className, true, cl);
718 } catch (Exception e) {
719 if (DEBUG) {
720 debugPrintln("Can't load class " + className);
721 }
722 throw new RuntimeException(e);
723 }
724 }
725
726 protected String getClassName(int begin, int end) {
727 StringBuffer buf = new StringBuffer();
728 for (int i = begin; i < end; i++) {
729 char c = (char) (_signature.getByteAt(i) & 0xFF);
730 if (c == '/') {
731 buf.append('.');
732 } else {
733 buf.append(c);
734 }
735 }
736 return buf.toString();
737 }
738
739 protected int arrayInnerBegin(int begin) {
740 while (_signature.getByteAt(begin) == '[') {
741 ++begin;
742 }
743 return begin;
744 }
745
746 public int getNumParams() {
747 return tmp.size();
748 }
749
750 public Enumeration getParamTypes() {
751 return tmp.elements();
752 }
753 }
754
755 protected Class[] getParamTypes(Symbol signature) {
756 SignatureParser sp = new SignatureParser(signature);
757 sp.iterateParameters();
758 Class result[] = new Class[sp.getNumParams()];
759 Enumeration e = sp.getParamTypes();
760 int i = 0;
761 while (e.hasMoreElements()) {
762 result[i] = (Class) e.nextElement();
763 i++;
764 }
765 return result;
766 }
767 }