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  ;
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   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  [] getMethodParams(String   descriptor) {
79          int i = 0;
80          if (descriptor.charAt(i) != '(') {
81              throw new IllegalArgumentException  ("Method descriptor should start with a '('");
82          }
83          Vector   params = new Vector  ();
84          StringBuffer   param = new StringBuffer  ();
85          i++;
86          while ((i = descriptor2java(descriptor, i, param)) < descriptor.length()) {
87              params.add(param.substring(0));
88              param = new StringBuffer  ();
89              if (descriptor.charAt(i) == ')') {
90                  i++;
91                  break;
92              }
93          }
94          String  [] array = new String  [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   getMethodReturnType(String   descriptor) {
105         int pos = descriptor.indexOf(')');
106         StringBuffer   rettype = new StringBuffer  ();
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   descriptor, int i, StringBuffer   sb) {
119         // get the dimension
120         StringBuffer   dim = new StringBuffer  ();
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   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   getMethodAccess(int access_flags) {
291         StringBuffer   sb = new StringBuffer  ();
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   getFieldAccess(int access_flags) {
323         StringBuffer   sb = new StringBuffer  ();
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   getClassAccess(int access_flags) {
352         StringBuffer   sb = new StringBuffer  ();
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
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags