KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > apache > tools > ant > taskdefs > optional > sitraka > bytecode > Utils


1 /*
2  * Copyright 2001-2004 The Apache Software Foundation
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 package org.apache.tools.ant.taskdefs.optional.sitraka.bytecode;
19
20 import java.util.Vector JavaDoc;
21 import org.apache.tools.ant.taskdefs.optional.depend.constantpool.ConstantPool;
22 import org.apache.tools.ant.taskdefs.optional.depend.constantpool.Utf8CPInfo;
23
24 /**
25  * Utilities mostly to manipulate methods and access flags.
26  *
27  */

28 public class Utils {
29     /** public access flag */
30     public static final short ACC_PUBLIC = 1;
31     /** private access flag */
32     public static final short ACC_PRIVATE = 2;
33     /** protected access flag */
34     public static final short ACC_PROTECTED = 4;
35     /** static access flag */
36     public static final short ACC_STATIC = 8;
37     /** final access flag */
38     public static final short ACC_FINAL = 16;
39     /** super access flag */
40     public static final short ACC_SUPER = 32;
41     /** synchronized access flag */
42     public static final short ACC_SYNCHRONIZED = 32;
43     /** volatile access flag */
44     public static final short ACC_VOLATILE = 64;
45     /** transient access flag */
46     public static final short ACC_TRANSIENT = 128;
47     /** native access flag */
48     public static final short ACC_NATIVE = 256;
49     /** interface access flag */
50     public static final short ACC_INTERFACE = 512;
51     /** abstract access flag */
52     public static final short ACC_ABSTRACT = 1024;
53     /** strict access flag */
54     public static final short ACC_STRICT = 2048;
55
56     /** private constructor */
57     private Utils() {
58     }
59
60     /**
61      * return an UTF8 value from the pool located a a specific index.
62      * @param pool the constant pool to look at
63      * @param index index of the UTF8 value in the constant pool
64      * @return the value of the string if it exists
65      * @throws ClassCastException if the index is not an UTF8 constant.
66      */

67     public static String JavaDoc getUTF8Value(ConstantPool pool, int index) {
68         return ((Utf8CPInfo) pool.getEntry(index)).getValue();
69     }
70
71     /**
72      * parse all parameters from a descritor into fields of java name.
73      * @param descriptor of a method.
74      * @return the parameter list of a given method descriptor. Each string
75      * represent a java object with its fully qualified classname or the
76      * primitive name such as int, long, ...
77      */

78     public static String JavaDoc[] getMethodParams(String JavaDoc descriptor) {
79         int i = 0;
80         if (descriptor.charAt(i) != '(') {
81             throw new IllegalArgumentException JavaDoc("Method descriptor should start with a '('");
82         }
83         Vector JavaDoc params = new Vector JavaDoc();
84         StringBuffer JavaDoc param = new StringBuffer JavaDoc();
85         i++;
86         while ((i = descriptor2java(descriptor, i, param)) < descriptor.length()) {
87             params.add(param.substring(0));
88             param = new StringBuffer JavaDoc();
89             if (descriptor.charAt(i) == ')') {
90                 i++;
91                 break;
92             }
93         }
94         String JavaDoc[] array = new String JavaDoc[params.size()];
95         params.copyInto(array);
96         return array;
97     }
98
99     /**
100      * return the object type of a return type.
101      * @param descriptor
102      * @return get the return type objet of a given descriptor
103      */

104     public static String JavaDoc getMethodReturnType(String JavaDoc descriptor) {
105         int pos = descriptor.indexOf(')');
106         StringBuffer JavaDoc rettype = new StringBuffer JavaDoc();
107         descriptor2java(descriptor, pos + 1, rettype);
108         return rettype.toString();
109     }
110
111     /**
112      * Parse a single descriptor symbol and returns it java equivalent.
113      * @param descriptor the descriptor symbol.
114      * @param i the index to look at the symbol in the descriptor string
115      * @param sb the stringbuffer to return the java equivalent of the symbol
116      * @return the index after the descriptor symbol
117      */

118     public static int descriptor2java(String JavaDoc descriptor, int i, StringBuffer JavaDoc sb) {
119         // get the dimension
120
StringBuffer JavaDoc dim = new StringBuffer JavaDoc();
121         for (; descriptor.charAt(i) == '['; i++) {
122             dim.append("[]");
123         }
124         // now get the type
125
switch (descriptor.charAt(i)) {
126             case 'B':
127                 sb.append("byte");
128                 break;
129             case 'C':
130                 sb.append("char");
131                 break;
132             case 'D':
133                 sb.append("double");
134                 break;
135             case 'F':
136                 sb.append("float");
137                 break;
138             case 'I':
139                 sb.append("int");
140                 break;
141             case 'J':
142                 sb.append("long");
143                 break;
144             case 'S':
145                 sb.append("short");
146                 break;
147             case 'Z':
148                 sb.append("boolean");
149                 break;
150             case 'V':
151                 sb.append("void");
152                 break;
153             case 'L':
154                 // it is a class
155
int pos = descriptor.indexOf(';', i + 1);
156                 String JavaDoc classname = descriptor.substring(i + 1, pos).replace('/', '.');
157                 sb.append(classname);
158                 i = pos;
159                 break;
160             default:
161                 //@todo, yeah this happens because I got things like:
162
// ()Ljava/lang/Object; and it will return and ) will be here
163
// think about it.
164

165                 //ooooops should never happen
166
//throw new IllegalArgumentException("Invalid descriptor
167
// symbol: '" + i + "' in '" + descriptor + "'");
168
}
169         sb.append(dim.toString());
170         return ++i;
171     }
172
173     /**
174      * check for abstract access
175      * @param access_flags access flags
176      */

177     public static boolean isAbstract(int access_flags) {
178         return (access_flags & ACC_ABSTRACT) != 0;
179     }
180
181     /**
182      * check for public access
183      * @param access_flags access flags
184      */

185     public static boolean isPublic(int access_flags) {
186         return (access_flags & ACC_PUBLIC) != 0;
187     }
188
189     /**
190      * check for a static access
191      * @param access_flags access flags
192      */

193     public static boolean isStatic(int access_flags) {
194         return (access_flags & ACC_STATIC) != 0;
195     }
196
197     /**
198      * check for native access
199      * @param access_flags access flags
200      */

201     public static boolean isNative(int access_flags) {
202         return (access_flags & ACC_NATIVE) != 0;
203     }
204
205     /**
206      * check for class access
207      * @param access_flags access flags
208      */

209     public static boolean isClass(int access_flags) {
210         return !isInterface(access_flags);
211     }
212
213     /**
214      * check for strict access
215      * @param access_flags access flags
216      */

217     public static boolean isStrict(int access_flags) {
218         return (access_flags & ACC_STRICT) != 0;
219     }
220
221     /**
222      * check for interface access
223      * @param access_flags access flags
224      */

225     public static boolean isInterface(int access_flags) {
226         return (access_flags & ACC_INTERFACE) != 0;
227     }
228
229     /**
230      * check for private access
231      * @param access_flags access flags
232      */

233     public static boolean isPrivate(int access_flags) {
234         return (access_flags & ACC_PRIVATE) != 0;
235     }
236
237     /**
238      * check for transient flag
239      * @param access_flags access flags
240      */

241     public static boolean isTransient(int access_flags) {
242         return (access_flags & ACC_TRANSIENT) != 0;
243     }
244
245     /**
246      * check for volatile flag
247      * @param access_flags access flags
248      */

249     public static boolean isVolatile(int access_flags) {
250         return (access_flags & ACC_VOLATILE) != 0;
251     }
252
253     /**
254      * check for super flag
255      * @param access_flags access flag
256      */

257     public static boolean isSuper(int access_flags) {
258         return (access_flags & ACC_SUPER) != 0;
259     }
260
261     /**
262      * check for protected flag
263      * @param access_flags access flags
264      */

265     public static boolean isProtected(int access_flags) {
266         return (access_flags & ACC_PROTECTED) != 0;
267     }
268
269     /**
270      * chck for final flag
271      * @param access_flags access flags
272      */

273     public static boolean isFinal(int access_flags) {
274         return (access_flags & ACC_FINAL) != 0;
275     }
276
277     /**
278      * check for synchronized flag
279      * @param access_flags access flags
280      */

281     public static boolean isSynchronized(int access_flags) {
282         return (access_flags & ACC_SYNCHRONIZED) != 0;
283     }
284
285     /**
286      * return the method access flag as java modifiers
287      * @param access_flags access flags
288      * @return the access flags as modifier strings
289      */

290     public static String JavaDoc getMethodAccess(int access_flags) {
291         StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
292         if (isPublic(access_flags)) {
293             sb.append("public ");
294         } else if (isPrivate(access_flags)) {
295             sb.append("private ");
296         } else if (isProtected(access_flags)) {
297             sb.append("protected ");
298         }
299         if (isFinal(access_flags)) {
300             sb.append("final ");
301         }
302         if (isStatic(access_flags)) {
303             sb.append("static ");
304         }
305         if (isSynchronized(access_flags)) {
306             sb.append("synchronized ");
307         }
308         if (isNative(access_flags)) {
309             sb.append("native ");
310         }
311         if (isAbstract(access_flags)) {
312             sb.append("abstract ");
313         }
314         return sb.toString().trim();
315     }
316
317     /**
318      * return the field access flag as java modifiers
319      * @param access_flags access flags
320      * @return the access flags as modifier strings
321      */

322     public static String JavaDoc getFieldAccess(int access_flags) {
323         StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
324         if (isPublic(access_flags)) {
325             sb.append("public ");
326         } else if (isPrivate(access_flags)) {
327             sb.append("private ");
328         } else if (isProtected(access_flags)) {
329             sb.append("protected ");
330         }
331         if (isFinal(access_flags)) {
332             sb.append("final ");
333         }
334         if (isStatic(access_flags)) {
335             sb.append("static ");
336         }
337         if (isVolatile(access_flags)) {
338             sb.append("volatile ");
339         }
340         if (isTransient(access_flags)) {
341             sb.append("transient ");
342         }
343         return sb.toString().trim();
344     }
345
346     /**
347      * return the class access flag as java modifiers
348      * @param access_flags access flags
349      * @return the access flags as modifier strings
350      */

351     public static String JavaDoc getClassAccess(int access_flags) {
352         StringBuffer JavaDoc sb = new StringBuffer JavaDoc();
353         if (isPublic(access_flags)) {
354             sb.append("public ");
355         } else if (isProtected(access_flags)) {
356             sb.append("protected ");
357         } else if (isPrivate(access_flags)) {
358             sb.append("private ");
359         }
360         if (isFinal(access_flags)) {
361             sb.append("final ");
362         }
363         if (isSuper(access_flags)) {
364             sb.append("/*super*/ ");
365         }
366         if (isInterface(access_flags)) {
367             sb.append("interface ");
368         }
369         if (isAbstract(access_flags)) {
370             sb.append("abstract ");
371         }
372         if (isClass(access_flags)) {
373             sb.append("class ");
374         }
375         return sb.toString().trim();
376     }
377 }
378
379
380
381
Popular Tags