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.