* ::=
* ::= ||
* ::= 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 ) {
//corrected concurrent private static field acess
wrap(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);
}
//corrected concurrent private static field acess
wrap(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 brackets;
String type;
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 `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 s the string 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; static int[] CHAR_MAP = new int[FREE_CHARS]; static int[] MAP_CHAR = new int[256]; // Reverse map private static final char ESCAPE_CHAR = '$'; static { int j = 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; } 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; } 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(); } }