KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > eclipse > jdi > internal > TypeImpl


1 /*******************************************************************************
2  * Copyright (c) 2000, 2005 IBM Corporation and others.
3  * All rights reserved. This program and the accompanying materials
4  * are made available under the terms of the Eclipse Public License v1.0
5  * which accompanies this distribution, and is available at
6  * http://www.eclipse.org/legal/epl-v10.html
7  *
8  * Contributors:
9  * IBM Corporation - initial API and implementation
10  *******************************************************************************/

11 package org.eclipse.jdi.internal;
12
13
14 import com.sun.jdi.ClassLoaderReference;
15 import com.sun.jdi.ClassNotLoadedException;
16 import com.sun.jdi.ClassNotPreparedException;
17 import com.sun.jdi.Type;
18 import com.sun.jdi.Value;
19
20 /**
21  * this class implements the corresponding interfaces
22  * declared by the JDI specification. See the com.sun.jdi package
23  * for more information.
24  *
25  */

26 public abstract class TypeImpl extends AccessibleImpl implements Type {
27     /** Text representation of this type. */
28     protected String JavaDoc fName = null;
29     /** JNI-style signature for this type. */
30     protected String JavaDoc fSignature = null;
31
32     /**
33      * Creates new instance, used for REFERENCE types.
34      */

35     protected TypeImpl(String JavaDoc description, VirtualMachineImpl vmImpl) {
36         super(description, vmImpl);
37     }
38     
39     /**
40      * Creates new instance, used for PRIMITIVE types or VOID.
41      */

42     protected TypeImpl(String JavaDoc description, VirtualMachineImpl vmImpl, String JavaDoc name, String JavaDoc signature) {
43         super(description, vmImpl);
44         setName(name);
45         setSignature(signature);
46     }
47
48     /**
49      * @return Returns new instance based on signature and (if it is a ReferenceType) classLoader.
50      * @throws ClassNotLoadedException when type is a ReferenceType and it has not been loaded
51      * by the specified class loader.
52      */

53     public static TypeImpl create(VirtualMachineImpl vmImpl, String JavaDoc signature, ClassLoaderReference classLoader) throws ClassNotLoadedException {
54         // For void values, a VoidType is always returned.
55
if (isVoidSignature(signature))
56             return new VoidTypeImpl(vmImpl);
57         
58         // For primitive variables, an appropriate PrimitiveType is always returned.
59
if (isPrimitiveSignature(signature))
60             return PrimitiveTypeImpl.create(vmImpl, signature);
61         
62         // For object variables, the appropriate ReferenceType is returned if it has
63
// been loaded through the enclosing type's class loader.
64
return ReferenceTypeImpl.create(vmImpl, signature, classLoader);
65     }
66
67     /**
68      * Assigns name.
69      */

70     public void setName(String JavaDoc name) {
71         fName = name;
72     }
73     
74     /**
75      * Assigns signature.
76      */

77     public void setSignature(String JavaDoc signature) {
78         fSignature = signature;
79     }
80     
81     /**
82      * @return Returns description of Mirror object.
83      */

84     public String JavaDoc toString() {
85         try {
86             return name();
87         } catch (ClassNotPreparedException e) {
88             return JDIMessages.TypeImpl__Unloaded_Type__1;
89         } catch (Exception JavaDoc e) {
90             return fDescription;
91         }
92     }
93     
94     /**
95      * @return Create a null value instance of the type.
96      */

97     public abstract Value createNullValue();
98
99     /**
100      * @return Returns text representation of this type.
101      */

102     public String JavaDoc name() {
103         return fName;
104     }
105     
106     /**
107      * @return JNI-style signature for this type.
108      */

109     public String JavaDoc signature() {
110         return fSignature;
111     }
112     
113     /**
114      * @return Returns modifier bits.
115      */

116     public abstract int modifiers();
117     
118     /**
119      * Converts a class name to a JNI signature.
120      */

121     public static String JavaDoc classNameToSignature(String JavaDoc qualifiedName) {
122         // L<classname>; : fully-qualified-class
123
/* JNI signature examples:
124          * int[][] -> [[I
125          * long[] -> [J
126          * java.lang.String -> Ljava/lang/String;
127          * java.lang.String[] -> [Ljava/lang/String;
128          */

129         StringBuffer JavaDoc signature= new StringBuffer JavaDoc();
130
131         int firstBrace= qualifiedName.indexOf('[');
132         if (firstBrace < 0) {
133             // Not an array type. Must be class type.
134
signature.append('L');
135             signature.append(qualifiedName.replace('.','/'));
136             signature.append(';');
137             return signature.toString();
138         }
139         
140         int index= 0;
141         while ((index= (qualifiedName.indexOf('[', index) + 1)) > 0) {
142             signature.append('[');
143         }
144
145         String JavaDoc name= qualifiedName.substring(0, firstBrace);
146         switch (name.charAt(0)) {
147             // Check for primitive array type
148
case 'b':
149                 if (name.equals("byte")) { //$NON-NLS-1$
150
signature.append('B');
151                     return signature.toString();
152                 } else if (name.equals("boolean")) { //$NON-NLS-1$
153
signature.append('Z');
154                     return signature.toString();
155                 }
156                 break;
157             case 'i':
158                 if (name.equals("int")) { //$NON-NLS-1$
159
signature.append('I');
160                     return signature.toString();
161                 }
162                 break;
163             case 'd':
164                 if (name.equals("double")) { //$NON-NLS-1$
165
signature.append('D');
166                     return signature.toString();
167                 }
168                 break;
169             case 's':
170                 if (name.equals("short")) { //$NON-NLS-1$
171
signature.append('S');
172                     return signature.toString();
173                 }
174                 break;
175             case 'c':
176                 if (name.equals("char")) { //$NON-NLS-1$
177
signature.append('C');
178                     return signature.toString();
179                 }
180                 break;
181             case 'l':
182                 if (name.equals("long")) { //$NON-NLS-1$
183
signature.append('J');
184                     return signature.toString();
185                 }
186                 break;
187             case 'f':
188                 if (name.equals("float")) { //$NON-NLS-1$
189
signature.append('F');
190                     return signature.toString();
191                 }
192                 break;
193         }
194         // Class type array
195
signature.append('L');
196         signature.append(name.replace('.','/'));
197         signature.append(';');
198         return signature.toString();
199     }
200     
201
202     /**
203      * Converts a JNI class signature to a name.
204      */

205     public static String JavaDoc classSignatureToName(String JavaDoc signature) {
206         // L<classname>; : fully-qualified-class
207
return signature.substring(1, signature.length() - 1).replace('/','.');
208     }
209
210     /**
211      * Converts a JNI array signature to a name.
212      */

213     public static String JavaDoc arraySignatureToName(String JavaDoc signature) {
214         // [<type> : array of type <type>
215
if (signature.indexOf('[') < 0) {
216             return signature;
217         }
218         StringBuffer JavaDoc name= new StringBuffer JavaDoc();
219         String JavaDoc type= signature.substring(signature.lastIndexOf('[') + 1);
220         if (type.length() == 1 && isPrimitiveSignature(type)) {
221             name.append(getPrimitiveSignatureToName(type.charAt(0)));
222         } else {
223             name.append(classSignatureToName(type));
224         }
225         int index= 0;
226         while ((index= (signature.indexOf('[', index) + 1)) > 0) {
227             name.append('[').append(']');
228         }
229         return signatureToName(signature.substring(1)) + "[]"; //$NON-NLS-1$
230
}
231
232     /**
233      * @returns Returns Type Name, converted from a JNI signature.
234      */

235     public static String JavaDoc signatureToName(String JavaDoc signature) {
236         // See JNI 1.1 Specification, Table 3-2 Java VM Type Signatures.
237
String JavaDoc primitive= getPrimitiveSignatureToName(signature.charAt(0));
238         if (primitive != null) {
239             return primitive;
240         }
241         switch (signature.charAt(0)) {
242             case 'V':
243                 return "void"; //$NON-NLS-1$
244
case 'L':
245                 return classSignatureToName(signature);
246             case '[':
247                 return arraySignatureToName(signature);
248             case '(':
249                 throw new InternalError JavaDoc(JDIMessages.TypeImpl_Can__t_convert_method_signature_to_name_2);
250         }
251         throw new InternalError JavaDoc(JDIMessages.TypeImpl_Invalid_signature____10 + signature + JDIMessages.TypeImpl___11); //
252
}
253
254     private static String JavaDoc getPrimitiveSignatureToName(char signature) {
255         switch (signature) {
256             case 'Z':
257                 return "boolean"; //$NON-NLS-1$
258
case 'B':
259                 return "byte"; //$NON-NLS-1$
260
case 'C':
261                 return "char"; //$NON-NLS-1$
262
case 'S':
263                 return "short"; //$NON-NLS-1$
264
case 'I':
265                 return "int"; //$NON-NLS-1$
266
case 'J':
267                 return "long"; //$NON-NLS-1$
268
case 'F':
269                 return "float"; //$NON-NLS-1$
270
case 'D':
271                 return "double"; //$NON-NLS-1$
272
default:
273                 return null;
274         }
275     }
276     
277     /**
278      * @returns Returns Jdwp Tag, converted from a JNI signature.
279      */

280     public static byte signatureToTag(String JavaDoc signature) {
281         switch (signature.charAt(0)) {
282             case 'Z':
283                 return BooleanValueImpl.tag;
284             case 'B':
285                 return ByteValueImpl.tag;
286             case 'C':
287                 return CharValueImpl.tag;
288             case 'S':
289                 return ShortValueImpl.tag;
290             case 'I':
291                 return IntegerValueImpl.tag;
292             case 'J':
293                 return LongValueImpl.tag;
294             case 'F':
295                 return FloatValueImpl.tag;
296             case 'D':
297                 return DoubleValueImpl.tag;
298             case 'V':
299                 return VoidValueImpl.tag;
300             case 'L':
301                 return ObjectReferenceImpl.tag;
302             case '[':
303                 return ArrayReferenceImpl.tag;
304             case '(':
305                 throw new InternalError JavaDoc(JDIMessages.TypeImpl_Can__t_covert_method_signature_to_tag___9 + signature);
306         }
307         throw new InternalError JavaDoc(JDIMessages.TypeImpl_Invalid_signature____10 + signature + JDIMessages.TypeImpl___11); //
308
}
309     
310     /**
311      * @returns Returns true if signature is an primitive signature.
312      */

313     public static boolean isPrimitiveSignature(String JavaDoc signature) {
314         switch (signature.charAt(0)) {
315             case 'Z':
316             case 'B':
317             case 'C':
318             case 'S':
319             case 'I':
320             case 'J':
321             case 'F':
322             case 'D':
323                 return true;
324         }
325         return false;
326     }
327
328     /**
329      * @returns Returns true if signature is void signature.
330      */

331     public static boolean isVoidSignature(String JavaDoc signature) {
332         return (signature.charAt(0) == 'V');
333     }
334     
335
336 }
337
Popular Tags