jdk8u.jaxp.org.apache.bcel.external.classfile.Utility Maven / Gradle / Ivy
The newest version!
/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
package jdk8u.jaxp.org.apache.bcel.external.classfile;
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2001 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Apache" and "Apache Software Foundation" and
* "Apache BCEL" must not be used to endorse or promote products
* derived from this software without prior written permission. For
* written permission, please contact [email protected].
*
* 5. Products derived from this software may not be called "Apache",
* "Apache BCEL", nor may "Apache" appear in their name, without
* prior written permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* ::= | V
*
* The character V indicates that the method returns no value. Otherwise, the
* signature indicates the type of the return value.
* An argument signature represents an argument passed to a method:
*
* ::=
*
* A method signature represents the arguments that the method expects, and
* the value that it returns.
* ::= ()
* ::= *
*
* This method converts such a string into a Java type declaration like
* `void _main(String[])' and throws a `ClassFormatException' when the parsed
* type is invalid.
*
* @param signature Method signature
* @param name Method name
* @param access Method access rights
* @return Java type declaration
* @throws ClassFormatException
*/
public static final String methodSignatureToString(String signature,
String name,
String access,
boolean chopit,
LocalVariableTable vars)
throws ClassFormatException
{
StringBuffer buf = new StringBuffer("(");
String type;
int index;
int var_index = (access.indexOf("static") >= 0)? 0 : 1;
try { // Read all declarations between for `(' and `)'
if(signature.charAt(0) != '(')
throw new ClassFormatException("Invalid method signature: " + signature);
index = 1; // current string position
while(signature.charAt(index) != ')') {
String param_type = signatureToString(signature.substring(index), chopit);
buf.append(param_type);
if(vars != null) {
LocalVariable l = vars.getLocalVariable(var_index);
if(l != null)
buf.append(" " + l.getName());
} else
buf.append(" arg" + var_index);
if("double".equals(param_type) || "long".equals(param_type))
var_index += 2;
else
var_index++;
buf.append(", ");
index += consumed_chars; // update position
}
index++; // update position
// Read return type after `)'
type = signatureToString(signature.substring(index), chopit);
} catch(StringIndexOutOfBoundsException e) { // Should never occur
throw new ClassFormatException("Invalid method signature: " + signature);
}
if(buf.length() > 1) // Tack off the extra ", "
buf.setLength(buf.length() - 2);
buf.append(")");
return access + ((access.length() > 0)? " " : "") + // May be an empty string
type + " " + name + buf.toString();
}
// Guess what this does
private static final int pow2(int n) {
return 1 << n;
}
/**
* Replace all occurences of old in str with new.
*
* @param str String to permute
* @param old String to be replaced
* @param new Replacement string
* @return new String object
*/
public static final String replace(String str, String old, String new_) {
int index, old_index;
StringBuffer buf = new StringBuffer();
try {
if((index = str.indexOf(old)) != -1) { // `old' found in str
old_index = 0; // String start offset
// While we have something to replace
while((index = str.indexOf(old, old_index)) != -1) {
buf.append(str.substring(old_index, index)); // append prefix
buf.append(new_); // append replacement
old_index = index + old.length(); // Skip `old'.length chars
}
buf.append(str.substring(old_index)); // append rest of string
str = buf.toString();
}
} catch(StringIndexOutOfBoundsException e) { // Should not occur
System.err.println(e);
}
return str;
}
/**
* Converts signature to string with all class names compacted.
*
* @param signature to convert
* @return Human readable signature
*/
public static final String signatureToString(String signature) {
return signatureToString(signature, true);
}
/**
* The field signature represents the value of an argument to a function or
* the value of a variable. It is a series of bytes generated by the
* following grammar:
*
*
* ::=
* ::= ||
* ::= B|C|D|F|I|J|S|Z
* ::= L;
* ::= [
*
* The meaning of the base types is as follows:
* B byte signed byte
* C char character
* D double double precision IEEE float
* F float single precision IEEE float
* I int integer
* J long long integer
* L; ... an object of the given class
* S short signed short
* Z boolean true or false
* [ ... array
*
*
* This method converts this string into a Java type declaration such as
* `String[]' and throws a `ClassFormatException' when the parsed type is
* invalid.
*
* @param signature Class signature
* @param chopit Flag that determines whether chopping is executed or not
* @return Java type declaration
* @throws ClassFormatException
*/
public static final String signatureToString(String signature,
boolean chopit)
{
consumed_chars = 1; // This is the default, read just one char like `B'
try {
switch(signature.charAt(0)) {
case 'B' : return "byte";
case 'C' : return "char";
case 'D' : return "double";
case 'F' : return "float";
case 'I' : return "int";
case 'J' : return "long";
case 'L' : { // Full class name
int index = signature.indexOf(';'); // Look for closing `;'
if(index < 0)
throw new ClassFormatException("Invalid signature: " + signature);
consumed_chars = index + 1; // "Lblabla;" `L' and `;' are removed
return compactClassName(signature.substring(1, index), chopit);
}
case 'S' : return "short";
case 'Z' : return "boolean";
case '[' : { // Array declaration
int n;
StringBuffer buf, brackets;
String type;
char ch;
int consumed_chars; // Shadows global var
brackets = new StringBuffer(); // Accumulate []'s
// Count opening brackets and look for optional size argument
for(n=0; signature.charAt(n) == '['; n++)
brackets.append("[]");
consumed_chars = n; // Remember value
// The rest of the string denotes a `'
type = signatureToString(signature.substring(n), chopit);
Utility.consumed_chars += consumed_chars;
return type + brackets.toString();
}
case 'V' : return "void";
default : throw new ClassFormatException("Invalid signature: `" +
signature + "'");
}
} catch(StringIndexOutOfBoundsException e) { // Should never occur
throw new ClassFormatException("Invalid signature: " + e + ":" + signature);
}
}
/** 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.
*
* @param type Java type
* @return byte code signature
*/
public static String getSignature(String type) {
StringBuffer buf = new StringBuffer();
char[] chars = type.toCharArray();
boolean char_found = false, delim = false;
int index = -1;
loop:
for(int i=0; i < chars.length; i++) {
switch(chars[i]) {
case ' ': case '\t': case '\n': case '\r': case '\f':
if(char_found)
delim = true;
break;
case '[':
if(!char_found)
throw new RuntimeException("Illegal type: " + type);
index = i;
break loop;
default:
char_found = true;
if(!delim)
buf.append(chars[i]);
}
}
int brackets = 0;
if(index > 0)
brackets = countBrackets(type.substring(index));
type = buf.toString();
buf.setLength(0);
for(int i=0; i < brackets; i++)
buf.append('[');
boolean found = false;
for(int i=Constants.T_BOOLEAN; (i <= Constants.T_VOID) && !found; i++) {
if(Constants.TYPE_NAMES[i].equals(type)) {
found = true;
buf.append(Constants.SHORT_TYPE_NAMES[i]);
}
}
if(!found) // Class name
buf.append('L' + type.replace('.', '/') + ';');
return buf.toString();
}
private static int countBrackets(String brackets) {
char[] chars = brackets.toCharArray();
int count = 0;
boolean open = false;
for(int i=0; iConstants
*
* @param signature in format described above
* @return type of method signature
* @see Constants
*/
public static final byte typeOfMethodSignature(String signature)
throws ClassFormatException
{
int index;
try {
if(signature.charAt(0) != '(')
throw new ClassFormatException("Invalid method signature: " + signature);
index = signature.lastIndexOf(')') + 1;
return typeOfSignature(signature.substring(index));
} catch(StringIndexOutOfBoundsException e) {
throw new ClassFormatException("Invalid method signature: " + signature);
}
}
/**
* Return type of signature as a byte value as defined in Constants
*
* @param signature in format described above
* @return type of signature
* @see Constants
*/
public static final byte typeOfSignature(String signature)
throws ClassFormatException
{
try {
switch(signature.charAt(0)) {
case 'B' : return Constants.T_BYTE;
case 'C' : return Constants.T_CHAR;
case 'D' : return Constants.T_DOUBLE;
case 'F' : return Constants.T_FLOAT;
case 'I' : return Constants.T_INT;
case 'J' : return Constants.T_LONG;
case 'L' : return Constants.T_REFERENCE;
case '[' : return Constants.T_ARRAY;
case 'V' : return Constants.T_VOID;
case 'Z' : return Constants.T_BOOLEAN;
case 'S' : return Constants.T_SHORT;
default:
throw new ClassFormatException("Invalid method signature: " + signature);
}
} catch(StringIndexOutOfBoundsException e) {
throw new ClassFormatException("Invalid method signature: " + signature);
}
}
/** Map opcode names to opcode numbers. E.g., return Constants.ALOAD for "aload"
*/
public static short searchOpcode(String name) {
name = name.toLowerCase();
for(short i=0; i < Constants.OPCODE_NAMES.length; i++)
if(Constants.OPCODE_NAMES[i].equals(name))
return i;
return -1;
}
/**
* Convert (signed) byte to (unsigned) short value, i.e., all negative
* values become positive.
*/
private static final short byteToShort(byte b) {
return (b < 0)? (short)(256 + b) : (short)b;
}
/** Convert bytes into hexidecimal string
*
* @return bytes as hexidecimal string, e.g. 00 FA 12 ...
*/
public static final String toHexString(byte[] bytes) {
StringBuffer buf = new StringBuffer();
for(int i=0; i < bytes.length; i++) {
short b = byteToShort(bytes[i]);
String hex = Integer.toString(b, 0x10);
if(b < 0x10) // just one digit, prepend '0'
buf.append('0');
buf.append(hex);
if(i < bytes.length - 1)
buf.append(' ');
}
return buf.toString();
}
/**
* Return a string for an integer justified left or right and filled up with
* `fill' characters if necessary.
*
* @param i integer to format
* @param length length of desired string
* @param left_justify format left or right
* @param fill fill character
* @return formatted int
*/
public static final String format(int i, int length, boolean left_justify, char fill) {
return fillup(Integer.toString(i), length, left_justify, fill);
}
/**
* Fillup char with up to length characters with char `fill' and justify it left or right.
*
* @param str string to format
* @param length length of desired string
* @param left_justify format left or right
* @param fill fill character
* @return formatted string
*/
public static final String fillup(String str, int length, boolean left_justify, char fill) {
int len = length - str.length();
char[] buf = new char[(len < 0)? 0 : len];
for(int j=0; j < buf.length; j++)
buf[j] = fill;
if(left_justify)
return str + new String(buf);
else
return new String(buf) + str;
}
static final boolean equals(byte[] a, byte[] b) {
int size;
if((size=a.length) != b.length)
return false;
for(int i=0; i < size; i++)
if(a[i] != b[i])
return false;
return true;
}
public static final void printArray(PrintStream out, Object[] obj) {
out.println(printArray(obj, true));
}
public static final void printArray(PrintWriter out, Object[] obj) {
out.println(printArray(obj, true));
}
public static final String printArray(Object[] obj) {
return printArray(obj, true);
}
public static final String printArray(Object[] obj, boolean braces) {
return printArray(obj, braces, false);
}
public static final String printArray(Object[] obj, boolean braces,
boolean quote) {
if(obj == null)
return null;
StringBuffer buf = new StringBuffer();
if(braces)
buf.append('{');
for(int i=0; i < obj.length; i++) {
if(obj[i] != null) {
buf.append((quote? "\"" : "") + obj[i].toString() + (quote? "\"" : ""));
} else {
buf.append("null");
}
if(i < obj.length - 1) {
buf.append(", ");
}
}
if(braces)
buf.append('}');
return buf.toString();
}
/** @return true, if character is one of (a, ... z, A, ... Z, 0, ... 9, _)
*/
public static boolean isJavaIdentifierPart(char ch) {
return ((ch >= 'a') && (ch <= 'z')) ||
((ch >= 'A') && (ch <= 'Z')) ||
((ch >= '0') && (ch <= '9')) ||
(ch == '_');
}
/** 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%
*
* @param bytes the byte array to convert
* @param compress use gzip to minimize string
*/
public static String encode(byte[] bytes, boolean compress) throws IOException {
if(compress) {
ByteArrayOutputStream baos = new ByteArrayOutputStream();
GZIPOutputStream gos = new GZIPOutputStream(baos);
gos.write(bytes, 0, bytes.length);
gos.close();
baos.close();
bytes = baos.toByteArray();
}
CharArrayWriter caw = new CharArrayWriter();
JavaWriter jw = new JavaWriter(caw);
for(int i=0; i < bytes.length; i++) {
int in = bytes[i] & 0x000000ff; // Normalize to unsigned
jw.write(in);
}
return caw.toString();
}
/** Decode a string back to a byte array.
*
* @param bytes the byte array to convert
* @param uncompress use gzip to uncompress the stream of bytes
*/
public static byte[] decode(String s, boolean uncompress) throws IOException {
char[] chars = s.toCharArray();
CharArrayReader car = new CharArrayReader(chars);
JavaReader jr = new JavaReader(car);
ByteArrayOutputStream bos = new ByteArrayOutputStream();
int ch;
while((ch = jr.read()) >= 0) {
bos.write(ch);
}
bos.close();
car.close();
jr.close();
byte[] bytes = bos.toByteArray();
if(uncompress) {
GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(bytes));
byte[] tmp = new byte[bytes.length * 3]; // Rough estimate
int count = 0;
int b;
while((b = gis.read()) >= 0)
tmp[count++] = (byte)b;
bytes = new byte[count];
System.arraycopy(tmp, 0, bytes, 0, count);
}
return bytes;
}
// A-Z, g-z, _, $
private static final int FREE_CHARS = 48;
private static int[] CHAR_MAP = new int[FREE_CHARS];
private static int[] MAP_CHAR = new int[256]; // Reverse map
private static final char ESCAPE_CHAR = '$';
static {
int j = 0, k = 0;
for(int i='A'; i <= 'Z'; i++) {
CHAR_MAP[j] = i;
MAP_CHAR[i] = j;
j++;
}
for(int i='g'; i <= 'z'; i++) {
CHAR_MAP[j] = i;
MAP_CHAR[i] = j;
j++;
}
CHAR_MAP[j] = '$';
MAP_CHAR['$'] = j;
j++;
CHAR_MAP[j] = '_';
MAP_CHAR['_'] = j;
}
/** Decode characters into bytes.
* Used by decode()
*/
private static class JavaReader extends FilterReader {
public JavaReader(Reader in) {
super(in);
}
public int read() throws IOException {
int b = in.read();
if(b != ESCAPE_CHAR) {
return b;
} else {
int i = in.read();
if(i < 0)
return -1;
if(((i >= '0') && (i <= '9')) || ((i >= 'a') && (i <= 'f'))) { // Normal escape
int j = in.read();
if(j < 0)
return -1;
char[] tmp = { (char)i, (char)j };
int s = Integer.parseInt(new String(tmp), 16);
return s;
} else { // Special escape
return MAP_CHAR[i];
}
}
}
public int read(char[] cbuf, int off, int len) throws IOException {
for(int i=0; i < len; i++)
cbuf[off + i] = (char)read();
return len;
}
}
/** Encode bytes into valid java identifier characters.
* Used by encode()
*/
private static class JavaWriter extends FilterWriter {
public JavaWriter(Writer out) {
super(out);
}
public void write(int b) throws IOException {
if(isJavaIdentifierPart((char)b) && (b != ESCAPE_CHAR)) {
out.write(b);
} else {
out.write(ESCAPE_CHAR); // Escape character
// Special escape
if(b >= 0 && b < FREE_CHARS) {
out.write(CHAR_MAP[b]);
} else { // Normal escape
char[] tmp = Integer.toHexString(b).toCharArray();
if(tmp.length == 1) {
out.write('0');
out.write(tmp[0]);
} else {
out.write(tmp[0]);
out.write(tmp[1]);
}
}
}
}
public void write(char[] cbuf, int off, int len) throws IOException {
for(int i=0; i < len; i++)
write(cbuf[off + i]);
}
public void write(String str, int off, int len) throws IOException {
write(str.toCharArray(), off, len);
}
}
/**
* Escape all occurences of newline chars '\n', quotes \", etc.
*/
public static final String convertString(String label) {
char[] ch = label.toCharArray();
StringBuffer buf = new StringBuffer();
for(int i=0; i < ch.length; i++) {
switch(ch[i]) {
case '\n':
buf.append("\\n"); break;
case '\r':
buf.append("\\r"); break;
case '\"':
buf.append("\\\""); break;
case '\'':
buf.append("\\'"); break;
case '\\':
buf.append("\\\\"); break;
default:
buf.append(ch[i]); break;
}
}
return buf.toString();
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy