Package org.apache.bcel.classfile

Class Utility

  • public abstract class Utility
extends Object
    Utility functions that do not really belong to any class in particular.

    • Constructor Detail

      • Utility

        public Utility()

    • Method Detail

      • accessToString

        public static String accessToString​(int access_flags)
        Convert bit field of flags into string such as `static final'.
        Parameters:
        access_flags - Access flags
        Returns:
        String representation of flags

      • accessToString

        public static String accessToString​(int access_flags,
                                    boolean for_class)
        Convert bit field of flags into string such as `static final'. Special case: Classes compiled with new compilers and with the `ACC_SUPER' flag would be said to be "synchronized". This is because SUN used the same value for the flags `ACC_SUPER' and `ACC_SYNCHRONIZED'.
        Parameters:
        access_flags - Access flags
        for_class - access flags are for class qualifiers ?
        Returns:
        String representation of flags

      • classOrInterface

        public static String classOrInterface​(int access_flags)
        Parameters:
        access_flags - the class flags
        Returns:
        "class" or "interface", depending on the ACC_INTERFACE flag

      • codeToString

        public static String codeToString​(byte[] code,
                                  ConstantPool constant_pool,
                                  int index,
                                  int length,
                                  boolean verbose)
        Disassemble a byte array of JVM byte codes starting from code line `index' and return the disassembled string representation. Decode only `num' opcodes (including their operands), use -1 if you want to decompile everything.
        Parameters:
        code - byte code array
        constant_pool - Array of constants
        index - offset in `code' array (number of opcodes, not bytes!)
        length - number of opcodes to decompile, -1 for all
        verbose - be verbose, e.g. print constant pool index
        Returns:
        String representation of byte codes

      • codeToString

        public static String codeToString​(byte[] code,
                                  ConstantPool constant_pool,
                                  int index,
                                  int length)

      • codeToString

        public static String codeToString​(ByteSequence bytes,
                                  ConstantPool constant_pool,
                                  boolean verbose)
                           throws IOException
        Disassemble a stream of byte codes and return the string representation.
        Parameters:
        bytes - stream of bytes
        constant_pool - Array of constants
        verbose - be verbose, e.g. print constant pool index
        Returns:
        String representation of byte code
        Throws:
        IOException - if a failure from reading from the bytes argument occurs

      • compactClassName

        public static String compactClassName​(String str)
        Shorten long class names, java/lang/String becomes String.
        Parameters:
        str - The long class name
        Returns:
        Compacted class name

      • compactClassName

        public static String compactClassName​(String str,
                                      boolean chopit)
        Shorten long class names, java/lang/String becomes java.lang.String, e.g.. If chopit is true the prefix java.lang is also removed.
        Parameters:
        str - The long class name
        chopit - flag that determines whether chopping is executed or not
        Returns:
        Compacted class name

      • compactClassName

        public static String compactClassName​(String str,
                                      String prefix,
                                      boolean chopit)
        Shorten long class name str, i.e., chop off the prefix, if the class name starts with this string and the flag chopit is true. Slashes / are converted to dots ..
        Parameters:
        str - The long class name
        prefix - The prefix the get rid off
        chopit - flag that determines whether chopping is executed or not
        Returns:
        Compacted class name

      • setBit

        public static int setBit​(int flag,
                         int i)
        Returns:
        `flag' with bit `i' set to 1

      • clearBit

        public static int clearBit​(int flag,
                           int i)
        Returns:
        `flag' with bit `i' set to 0

      • isSet

        public static boolean isSet​(int flag,
                            int i)
        Returns:
        true, if bit `i' in `flag' is set

      • methodTypeToSignature

        public static String methodTypeToSignature​(String ret,
                                           String[] argv)
                                    throws ClassFormatException
        Converts string containing the method return and argument types to a byte code method signature.
        Parameters:
        ret - Return type of method
        argv - Types of method arguments
        Returns:
        Byte code representation of method signature
        Throws:
        ClassFormatException - if the signature is for Void

      • methodSignatureArgumentTypes

        public static String[] methodSignatureArgumentTypes​(String signature)
                                             throws ClassFormatException
        Converts argument list portion of method signature to string with all class names compacted.
        Parameters:
        signature - Method signature
        Returns:
        String Array of argument types
        Throws:
        ClassFormatException

      • methodSignatureArgumentTypes

        public static String[] methodSignatureArgumentTypes​(String signature,
                                                    boolean chopit)
                                             throws ClassFormatException
        Converts argument list portion of method signature to string.
        Parameters:
        signature - Method signature
        chopit - flag that determines whether chopping is executed or not
        Returns:
        String Array of argument types
        Throws:
        ClassFormatException

      • methodSignatureReturnType

        public static String methodSignatureReturnType​(String signature)
                                        throws ClassFormatException
        Converts return type portion of method signature to string with all class names compacted.
        Parameters:
        signature - Method signature
        Returns:
        String representation of method return type
        Throws:
        ClassFormatException

      • methodSignatureReturnType

        public static String methodSignatureReturnType​(String signature,
                                               boolean chopit)
                                        throws ClassFormatException
        Converts return type portion of method signature to string.
        Parameters:
        signature - Method signature
        chopit - flag that determines whether chopping is executed or not
        Returns:
        String representation of method return type
        Throws:
        ClassFormatException

      • methodSignatureToString

        public static String methodSignatureToString​(String signature,
                                             String name,
                                             String access)
        Converts method signature to string with all class names compacted.
        Parameters:
        signature - to convert
        name - of method
        access - flags of method
        Returns:
        Human readable signature

      • methodSignatureToString

        public static String methodSignatureToString​(String signature,
                                             String name,
                                             String access,
                                             boolean chopit)
        Converts method signature to string.
        Parameters:
        signature - to convert
        name - of method
        access - flags of method
        chopit - flag that determines whether chopping is executed or not
        Returns:
        Human readable signature

      • methodSignatureToString

        public static String methodSignatureToString​(String signature,
                                             String name,
                                             String access,
                                             boolean chopit,
                                             LocalVariableTable vars)
                                      throws ClassFormatException
        This method converts a method signature string into a Java type declaration like `void main(String[])' and throws a `ClassFormatException' when the parsed type is invalid.
        Parameters:
        signature - Method signature
        name - Method name
        access - Method access rights
        chopit - flag that determines whether chopping is executed or not
        vars - the LocalVariableTable for the method
        Returns:
        Java type declaration
        Throws:
        ClassFormatException

      • replace

        public static String replace​(String str,
                             String old,
                             String new_)
        Replace all occurrences of old in str with new.
        Parameters:
        str - String to permute
        old - String to be replaced
        new_ - Replacement string
        Returns:
        new String object

      • signatureToString

        public static String signatureToString​(String signature)
        Converts a signature to a string with all class names compacted. Class, Method and Type signatures are supported. Enum and Interface signatures are not supported.
        Parameters:
        signature - signature to convert
        Returns:
        String containg human readable signature

      • signatureToString

        public static String signatureToString​(String signature,
                                       boolean chopit)
        Converts a signature to a string. Class, Method and Type signatures are supported. Enum and Interface signatures are not supported.
        Parameters:
        signature - signature to convert
        chopit - flag that determines whether chopping is executed or not
        Returns:
        String containg human readable signature

      • typeSignatureToString

        public static String typeSignatureToString​(String signature,
                                           boolean chopit)
                                    throws ClassFormatException
        This method converts a type signature string into a Java type declaration such as `String[]' and throws a `ClassFormatException' when the parsed type is invalid.
        Parameters:
        signature - type signature
        chopit - flag that determines whether chopping is executed or not
        Returns:
        string containing human readable type signature
        Throws:
        ClassFormatException
        Since:
        6.4.0

      • getSignature

        public static String getSignature​(String type)
        Parse Java type such as "char", or "java.lang.String[]" and return the signature in byte code format, e.g. "C" or "[Ljava/lang/String;" respectively.
        Parameters:
        type - Java type
        Returns:
        byte code signature

      • typeOfMethodSignature

        public static byte typeOfMethodSignature​(String signature)
                                  throws ClassFormatException
        Return type of method signature as a byte value as defined in Constants
        Parameters:
        signature - in format described above
        Returns:
        type of method signature
        Throws:
        ClassFormatException - if signature is not a method signature
        See Also:
        Const

      • typeOfSignature

        public static byte typeOfSignature​(String signature)
                            throws ClassFormatException
        Return type of signature as a byte value as defined in Constants
        Parameters:
        signature - in format described above
        Returns:
        type of signature
        Throws:
        ClassFormatException - if signature isn't a known type
        See Also:
        Const

      • searchOpcode

        public static short searchOpcode​(String name)
        Map opcode names to opcode numbers. E.g., return Constants.ALOAD for "aload"

      • toHexString

        public static String toHexString​(byte[] bytes)
        Convert bytes into hexadecimal string
        Parameters:
        bytes - an array of bytes to convert to hexadecimal
        Returns:
        bytes as hexadecimal string, e.g. 00 fa 12 ...

      • format

        public static String format​(int i,
                            int length,
                            boolean left_justify,
                            char fill)
        Return a string for an integer justified left or right and filled up with `fill' characters if necessary.
        Parameters:
        i - integer to format
        length - length of desired string
        left_justify - format left or right
        fill - fill character
        Returns:
        formatted int

      • fillup

        public static String fillup​(String str,
                            int length,
                            boolean left_justify,
                            char fill)
        Fillup char with up to length characters with char `fill' and justify it left or right.
        Parameters:
        str - string to format
        length - length of desired string
        left_justify - format left or right
        fill - fill character
        Returns:
        formatted string

      • printArray

        public static String printArray​(Object[] obj)

      • printArray

        public static String printArray​(Object[] obj,
                                boolean braces)

      • printArray

        public static String printArray​(Object[] obj,
                                boolean braces,
                                boolean quote)

      • isJavaIdentifierPart

        public static boolean isJavaIdentifierPart​(char ch)
        Parameters:
        ch - the character to test if it's part of an identifier
        Returns:
        true, if character is one of (a, ... z, A, ... Z, 0, ... 9, _)

      • encode

        public static String encode​(byte[] bytes,
                            boolean compress)
                     throws IOException
        Encode byte array it into Java identifier string, i.e., a string that only contains the following characters: (a, ... z, A, ... Z, 0, ... 9, _, $). The encoding algorithm itself is not too clever: if the current byte's ASCII value already is a valid Java identifier part, leave it as it is. Otherwise it writes the escape character($) followed by:
        • the ASCII value as a hexadecimal string, if the value is not in the range 200..247
        • a Java identifier char not used in a lowercase hexadecimal string, if the value is in the range 200..247

        This operation inflates the original byte array by roughly 40-50%

        Parameters:
        bytes - the byte array to convert
        compress - use gzip to minimize string
        Throws:
        IOException - if there's a gzip exception

      • decode

        public static byte[] decode​(String s,
                            boolean uncompress)
                     throws IOException
        Decode a string back to a byte array.
        Parameters:
        s - the string to convert
        uncompress - use gzip to uncompress the stream of bytes
        Throws:
        IOException - if there's a gzip exception

      • convertString

        public static String convertString​(String label)
        Escape all occurences of newline chars '\n', quotes \", etc.