jdk-sandbox: comparison src/java.xml/share/classes/com/sun/org/apache/bcel/internal/classfile/Utility.java

equal deleted inserted replaced

-:badfa812b82a
+:8e0ae3830fca
 /*
-* Copyright (c) 2017, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2017, 2019, Oracle and/or its affiliates. All rights reserved.
 */
 /*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 import com.sun.org.apache.bcel.internal.util.ByteSequence;
 /**
 * Utility functions that do not really belong to any class in particular.
 *
-* @version $Id: Utility.java 1751107 2016-07-03 02:41:18Z dbrosius $
+* @version $Id$
-* @LastModified: Oct 2017
+* @LastModified: Jun 2019
 */
 // @since 6.0 methods are no longer final
 public abstract class Utility {
-private static int unwrap(final ThreadLocal<Integer> tl) {
+private static int unwrap( final ThreadLocal<Integer> tl ) {
-return tl.get().intValue();
+return tl.get();
 }
-private static void wrap(final ThreadLocal<Integer> tl, final int value) {
-tl.set(Integer.valueOf(value));
+private static void wrap( final ThreadLocal<Integer> tl, final int value ) {
+tl.set(value);
 }
 private static ThreadLocal<Integer> consumed_chars = new ThreadLocal<Integer>() {
 @Override
 protected Integer initialValue() {
-return Integer.valueOf(0);
+return 0;
 }
 };/* How many chars have been consumed
 * during parsing in signatureToString().
 * Read by methodSignatureToString().
 * Set by side effect,but only internally.
 */
 private static boolean wide = false; /* The `WIDE' instruction is used in the
 * byte code to allow 16-bit wide indices
 * for local variables. This opcode
 * precedes an `ILOAD', e.g.. The opcode
 * immediately following takes an extra
 /**
 * Convert bit field of flags into string such as `static final'.
 *
-* @param access_flags Access flags
+* @param  access_flags Access flags
 * @return String representation of flags
 */
-public static String accessToString(final int access_flags) {
+public static String accessToString( final int access_flags ) {
 return accessToString(access_flags, false);
 }
 /**
 * 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
+* `ACC_SUPER' flag would be said to be "synchronized". This is
-* used the same value for the flags `ACC_SUPER' and `ACC_SYNCHRONIZED'.
+* because SUN used the same value for the flags `ACC_SUPER' and
-*
+* `ACC_SYNCHRONIZED'.
-* @param access_flags Access flags
+*
-* @param for_class access flags are for class qualifiers ?
+* @param  access_flags Access flags
+* @param  for_class access flags are for class qualifiers ?
 * @return String representation of flags
 */
-public static String accessToString(final int access_flags, final boolean for_class) {
+public static String accessToString( final int access_flags, final boolean for_class ) {
 final StringBuilder buf = new StringBuilder();
 int p = 0;
 for (int i = 0; p < Const.MAX_ACC_FLAG; i++) { // Loop through known flags
 p = pow2(i);
 if ((access_flags & p) != 0) {
 }
 }
 return buf.toString().trim();
 }
 /**
 * @param access_flags the class flags
 *
 * @return "class" or "interface", depending on the ACC_INTERFACE flag
 */
-public static String classOrInterface(final int access_flags) {
+public static String classOrInterface( final int access_flags ) {
 return ((access_flags & Const.ACC_INTERFACE) != 0) ? "interface" : "class";
 }
 /**
 * 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
+* `num' opcodes (including their operands), use -1 if you want to
-* everything.
+* decompile everything.
 *
-* @param code byte code array
+* @param  code byte code array
-* @param constant_pool Array of constants
+* @param  constant_pool Array of constants
-* @param index offset in `code' array
+* @param  index offset in `code' array
 * <EM>(number of opcodes, not bytes!)</EM>
-* @param length number of opcodes to decompile, -1 for all
+* @param  length number of opcodes to decompile, -1 for all
-* @param verbose be verbose, e.g. print constant pool index
+* @param  verbose be verbose, e.g. print constant pool index
 * @return String representation of byte codes
 */
-public static String codeToString(final byte[] code, final ConstantPool constant_pool,
+public static String codeToString( final byte[] code, final ConstantPool constant_pool, final int index,
-final int index, final int length, final boolean verbose) {
+final int length, final boolean verbose ) {
-// Should be sufficient // CHECKSTYLE IGNORE MagicNumber
+final StringBuilder buf = new StringBuilder(code.length * 20); // Should be sufficient // CHECKSTYLE IGNORE MagicNumber
-final StringBuilder buf = new StringBuilder(code.length * 20);
 try (ByteSequence stream = new ByteSequence(code)) {
 for (int i = 0; i < index; i++) {
 codeToString(stream, constant_pool, verbose);
 }
 for (int i = 0; stream.available() > 0; i++) {
 if ((length < 0) || (i < length)) {
 final String indices = fillup(stream.getIndex() + ":", 6, true, ' ');
-buf.append(indices)
+buf.append(indices).append(codeToString(stream, constant_pool, verbose)).append('\n');
-.append(codeToString(stream, constant_pool, verbose))
-.append('\n');
 }
 }
 } catch (final IOException e) {
 throw new ClassFormatException("Byte code error: " + buf.toString(), e);
 }
 return buf.toString();
 }
-public static String codeToString(final byte[] code, final ConstantPool constant_pool,
-final int index, final int length) {
+public static String codeToString( final byte[] code, final ConstantPool constant_pool, final int index, final int length ) {
 return codeToString(code, constant_pool, index, length, true);
 }
-/**
-* Disassemble a stream of byte codes and return the string representation.
+/**
-*
+* Disassemble a stream of byte codes and return the
-* @param bytes stream of bytes
+* string representation.
-* @param constant_pool Array of constants
+*
-* @param verbose be verbose, e.g. print constant pool index
+* @param  bytes stream of bytes
+* @param  constant_pool Array of constants
+* @param  verbose be verbose, e.g. print constant pool index
 * @return String representation of byte code
 *
-* @throws IOException if a failure from reading from the bytes argument
+* @throws IOException if a failure from reading from the bytes argument occurs
-* occurs
 */
 @SuppressWarnings("fallthrough") // by design for case Const.INSTANCEOF
 public static String codeToString(final ByteSequence bytes, final ConstantPool constant_pool,
 final boolean verbose) throws IOException {
 final short opcode = (short) bytes.readUnsignedByte();
 buf.append(", ");
 }
 }
 buf.append(")");
 }
 break;
 /* Two address bytes + offset from start of byte stream form the
 * jump target
 */
 case Const.GOTO:
 case Const.IFEQ:
 case Const.PUTFIELD:
 case Const.PUTSTATIC:
 index = bytes.readUnsignedShort();
 buf.append("\t\t").append(
 constant_pool.constantToString(index, Const.CONSTANT_Fieldref)).append(
 verbose ? " (" + index + ")" : "");
 break;
 /* Operands are references to classes in constant pool
 */
 case Const.NEW:
 case Const.CHECKCAST:
 buf.append("\t");
 //$FALL-THROUGH$
 case Const.INSTANCEOF:
 index = bytes.readUnsignedShort();
 buf.append("\t<").append(
 constant_pool.constantToString(index, Const.CONSTANT_Class))
 .append(">").append(verbose ? " (" + index + ")" : "");
 case Const.INVOKEINTERFACE:
 index = bytes.readUnsignedShort();
 final int nargs = bytes.readUnsignedByte(); // historical, redundant
 buf.append("\t").append(
 constant_pool
 .constantToString(index, Const.CONSTANT_InterfaceMethodref))
 .append(verbose ? " (" + index + ")\t" : "").append(nargs).append("\t")
 .append(bytes.readUnsignedByte()); // Last byte is a reserved space
 break;
 case Const.INVOKEDYNAMIC:
 index = bytes.readUnsignedShort();
 buf.append("\t").append(
 constant_pool
 .constantToString(index, Const.CONSTANT_InvokeDynamic))
 .append(verbose ? " (" + index + ")\t" : "")
-.append(bytes.readUnsignedByte()) // Thrid byte is a reserved space
+.append(bytes.readUnsignedByte())  // Thrid byte is a reserved space
 .append(bytes.readUnsignedByte()); // Last byte is a reserved space
 break;
 /* Operands are references to items in constant pool
 */
 case Const.LDC_W:
 */
 case Const.ANEWARRAY:
 index = bytes.readUnsignedShort();
 buf.append("\t\t<").append(
 compactClassName(constant_pool.getConstantString(index,
 Const.CONSTANT_Class), false)).append(">").append(
 verbose ? " (" + index + ")" : "");
 break;
 /* Multidimensional array of references.
 */
 case Const.MULTIANEWARRAY: {
 index = bytes.readUnsignedShort();
 final int dimensions = bytes.readUnsignedByte();
 buf.append("\t<").append(
 compactClassName(constant_pool.getConstantString(index,
 Const.CONSTANT_Class), false)).append(">\t").append(dimensions)
 .append(verbose ? " (" + index + ")" : "");
 }
 break;
 /* Increment local variable.
 */
 case Const.IINC:
 if (wide) {
 vindex = bytes.readUnsignedShort();
 }
 }
 return buf.toString();
 }
-public static String codeToString(final ByteSequence bytes, final ConstantPool constant_pool)
+public static String codeToString( final ByteSequence bytes, final ConstantPool constant_pool )
 throws IOException {
 return codeToString(bytes, constant_pool, true);
 }
 /**
 * Shorten long class names, <em>java/lang/String</em> becomes
 * <em>String</em>.
 *
 * @param str The long class name
 * @return Compacted class name
 */
-public static String compactClassName(final String str) {
+public static String compactClassName( final String str ) {
 return compactClassName(str, true);
 }
 /**
 * Shorten long class name <em>str</em>, i.e., chop off the <em>prefix</em>,
-* if the class name starts with this string and the flag <em>chopit</em> is
+* if the
-* true. Slashes <em>/</em> are converted to dots <em>.</em>.
+* class name starts with this string and the flag <em>chopit</em> is true.
+* Slashes <em>/</em> are converted to dots <em>.</em>.
 *
 * @param str The long class name
 * @param prefix The prefix the get rid off
 * @param chopit Flag that determines whether chopping is executed or not
 * @return Compacted class name
 */
-public static String compactClassName(String str, final String prefix, final boolean chopit) {
+public static String compactClassName( String str, final String prefix, final boolean chopit ) {
 final int len = prefix.length();
 str = str.replace('/', '.'); // Is `/' on all systems, even DOS
 if (chopit) {
 // If string starts with `prefix' and contains no further dots
 if (str.startsWith(prefix) && (str.substring(len).indexOf('.') == -1)) {
 }
 }
 return str;
 }
 /**
 * Shorten long class names, <em>java/lang/String</em> becomes
-* <em>java.lang.String</em>, e.g.. If <em>chopit</em> is <em>true</em> the
+* <em>java.lang.String</em>,
-* prefix <em>java.lang</em>
+* e.g.. If <em>chopit</em> is <em>true</em> the prefix <em>java.lang</em>
 * is also removed.
 *
 * @param str The long class name
 * @param chopit Flag that determines whether chopping is executed or not
 * @return Compacted class name
 */
-public static String compactClassName(final String str, final boolean chopit) {
+public static String compactClassName( final String str, final boolean chopit ) {
 return compactClassName(str, "java.lang.", chopit);
 }
 /**
 * @return `flag' with bit `i' set to 1
 */
-public static int setBit(final int flag, final int i) {
+public static int setBit( final int flag, final int i ) {
 return flag | pow2(i);
 }
 /**
 * @return `flag' with bit `i' set to 0
 */
-public static int clearBit(final int flag, final int i) {
+public static int clearBit( final int flag, final int i ) {
 final int bit = pow2(i);
 return (flag & bit) == 0 ? flag : flag ^ bit;
 }
 /**
 * @return true, if bit `i' in `flag' is set
 */
-public static boolean isSet(final int flag, final int i) {
+public static boolean isSet( final int flag, final int i ) {
 return (flag & pow2(i)) != 0;
 }
-/**
-* Converts string containing the method return and argument types to a byte
+/**
-* code method signature.
+* Converts string containing the method return and argument types
-*
+* to a byte code method signature.
-* @param ret Return type of method
+*
-* @param argv Types of method arguments
+* @param  ret Return type of method
+* @param  argv Types of method arguments
 * @return Byte code representation of method signature
 *
 * @throws ClassFormatException if the signature is for Void
 */
-public static String methodTypeToSignature(final String ret, final String[] argv)
+public static String methodTypeToSignature( final String ret, final String[] argv )
 throws ClassFormatException {
 final StringBuilder buf = new StringBuilder("(");
 String str;
 if (argv != null) {
 for (final String element : argv) {
 str = getSignature(ret);
 buf.append(")").append(str);
 return buf.toString();
 }
-/**
-* @param signature Method signature
+/**
+* @param  signature    Method signature
 * @return Array of argument types
-* @throws ClassFormatException
+* @throws  ClassFormatException
 */
-public static String[] methodSignatureArgumentTypes(final String signature)
+public static String[] methodSignatureArgumentTypes( final String signature )
 throws ClassFormatException {
 return methodSignatureArgumentTypes(signature, true);
 }
-/**
-* @param signature Method signature
+/**
+* @param  signature    Method signature
 * @param chopit Shorten class names ?
 * @return Array of argument types
-* @throws ClassFormatException
+* @throws  ClassFormatException
 */
-public static String[] methodSignatureArgumentTypes(final String signature, final boolean chopit)
+public static String[] methodSignatureArgumentTypes( final String signature, final boolean chopit )
 throws ClassFormatException {
 final List<String> vec = new ArrayList<>();
 int index;
 try { // Read all declarations between for `(' and `)'
 if (signature.charAt(0) != '(') {
 throw new ClassFormatException("Invalid method signature: " + signature, e);
 }
 return vec.toArray(new String[vec.size()]);
 }
-/**
-* @param signature Method signature
+/**
+* @param  signature    Method signature
 * @return return type of method
-* @throws ClassFormatException
+* @throws  ClassFormatException
 */
-public static String methodSignatureReturnType(final String signature)
+public static String methodSignatureReturnType( final String signature ) throws ClassFormatException {
-throws ClassFormatException {
 return methodSignatureReturnType(signature, true);
 }
-/**
-* @param signature Method signature
+/**
+* @param  signature    Method signature
 * @param chopit Shorten class names ?
 * @return return type of method
-* @throws ClassFormatException
+* @throws  ClassFormatException
 */
-public static String methodSignatureReturnType(final String signature,
+public static String methodSignatureReturnType( final String signature, final boolean chopit ) throws ClassFormatException {
-final boolean chopit) throws ClassFormatException {
 int index;
 String type;
 try {
 // Read return type after `)'
 index = signature.lastIndexOf(')') + 1;
 throw new ClassFormatException("Invalid method signature: " + signature, e);
 }
 return type;
 }
 /**
 * Converts method signature to string with all class names compacted.
 *
 * @param signature to convert
 * @param name of method
 * @param access flags of method
 * @return Human readable signature
 */
-public static String methodSignatureToString(final String signature,
+public static String methodSignatureToString( final String signature, final String name, final String access ) {
-final String name, final String access) {
 return methodSignatureToString(signature, name, access, true);
 }
-public static String methodSignatureToString(final String signature,
-final String name, final String access, final boolean chopit) {
+public static String methodSignatureToString( final String signature, final String name, final String access, final boolean chopit ) {
 return methodSignatureToString(signature, name, access, chopit, null);
 }
-/**
-* A returntype signature represents the return value from a method. It is a
+/**
-* series of bytes in the following grammar:
+* A returntype signature represents the return value from a method.
+* It is a series of bytes in the following grammar:
 *
 * <pre>
 * &lt;return_signature&gt; ::= &lt;field_type&gt; | V
 * </pre>
 *
-* The character V indicates that the method returns no value. Otherwise,
+* The character V indicates that the method returns no value. Otherwise, the
-* the signature indicates the type of the return value. An argument
+* signature indicates the type of the return value.
-* signature represents an argument passed to a method:
+* An argument signature represents an argument passed to a method:
 *
 * <pre>
 * &lt;argument_signature&gt; ::= &lt;field_type&gt;
 * </pre>
 *
 *
 * 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  signature    Method signature
-* @param name Method name
+* @param  name         Method name
-* @param access Method access rights
+* @param  access       Method access rights
 * @param chopit
 * @param vars
 * @return Java type declaration
-* @throws ClassFormatException
+* @throws  ClassFormatException
 */
-public static String methodSignatureToString(final String signature, final String name,
+public static String methodSignatureToString( final String signature, final String name,
-final String access, final boolean chopit, final LocalVariableTable vars)
+final String access, final boolean chopit, final LocalVariableTable vars ) throws ClassFormatException {
-throws ClassFormatException {
 final StringBuilder buf = new StringBuilder("(");
 String type;
 int index;
 int var_index = access.contains("static") ? 0 : 1;
 try { // Read all declarations between for `(' and `)'
 buf.append(")");
 return access + ((access.length() > 0) ? " " : "") + // May be an empty string
 type + " " + name + buf.toString();
 }
 // Guess what this does
-private static int pow2(final int n) {
+private static int pow2( final int n ) {
 return 1 << n;
 }
-/**
-* Replace all occurrences of <em>old</em> in <em>str</em> with
+/**
-* <em>new</em>.
+* Replace all occurrences of <em>old</em> in <em>str</em> with <em>new</em>.
 *
 * @param str String to permute
 * @param old String to be replaced
 * @param new_ Replacement string
 * @return new String object
 */
-public static String replace(String str, final String old, final String new_) {
+public static String replace( String str, final String old, final String new_ ) {
 int index;
 int old_index;
 try {
 if (str.contains(old)) { // `old' found in str
 final StringBuilder buf = new StringBuilder();
 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 String signatureToString(final String signature) {
+public static String signatureToString( final 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:
 *
 * 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  signature  Class signature
 * @param chopit Flag that determines whether chopping is executed or not
 * @return Java type declaration
 * @throws ClassFormatException
 */
-public static String signatureToString(final String signature, final boolean chopit) {
+public static String signatureToString( final String signature, final 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':
 }
 final int index = signature.indexOf(';', fromIndex); // Look for closing `;'
 if (index < 0) {
 throw new ClassFormatException("Invalid signature: " + signature);
 }
 // check to see if there are any TypeArguments
 final int bracketIndex = signature.substring(0, index).indexOf('<');
 if (bracketIndex < 0) {
 // just a class identifier
 wrap(consumed_chars, index + 1); // "Lblabla;" `L' and `;' are removed
 return compactClassName(signature.substring(1, index), chopit);
 }
+// but make sure we are not looking past the end of the current item
+fromIndex = signature.indexOf(';');
+if (fromIndex < 0) {
+throw new ClassFormatException("Invalid signature: " + signature);
+}
+if (fromIndex < bracketIndex) {
+// just a class identifier
+wrap(consumed_chars, fromIndex + 1); // "Lblabla;" `L' and `;' are removed
+return compactClassName(signature.substring(1, fromIndex), chopit);
+}
 // we have TypeArguments; build up partial result
 // as we recurse for each TypeArgument
-final StringBuilder type = new StringBuilder(
+final StringBuilder type = new StringBuilder(compactClassName(signature.substring(1, bracketIndex), chopit)).append("<");
-compactClassName(signature.substring(1, bracketIndex), chopit))
-.append("<");
 int consumed_chars = bracketIndex + 1; // Shadows global var
 // check for wildcards
 if (signature.charAt(consumed_chars) == '+') {
 type.append("? extends ");
 consumed_chars++;
 } else if (signature.charAt(consumed_chars) == '-') {
 type.append("? super ");
 consumed_chars++;
-} else if (signature.charAt(consumed_chars) == '*') {
-// must be at end of signature
-if (signature.charAt(consumed_chars + 1) != '>') {
-throw new ClassFormatException("Invalid signature: " + signature);
-}
-if (signature.charAt(consumed_chars + 2) != ';') {
-throw new ClassFormatException("Invalid signature: " + signature);
-}
-wrap(Utility.consumed_chars, consumed_chars + 3); // remove final "*>;"
-return type + "?>...";
 }
 // get the first TypeArgument
-type.append(signatureToString(signature.substring(consumed_chars), chopit));
+if (signature.charAt(consumed_chars) == '*') {
-// update our consumed count by the number of characters the for type argument
+type.append("?");
-consumed_chars = unwrap(Utility.consumed_chars) + consumed_chars;
+consumed_chars++;
-wrap(Utility.consumed_chars, consumed_chars);
+} else {
+type.append(signatureToString(signature.substring(consumed_chars), chopit));
-// are there more TypeArguments?
-while (signature.charAt(consumed_chars) != '>') {
-type.append(", ").append(signatureToString(signature.substring(consumed_chars), chopit));
 // update our consumed count by the number of characters the for type argument
 consumed_chars = unwrap(Utility.consumed_chars) + consumed_chars;
 wrap(Utility.consumed_chars, consumed_chars);
 }
-if (signature.charAt(consumed_chars + 1) != ';') {
+// are there more TypeArguments?
+while (signature.charAt(consumed_chars) != '>') {
+type.append(", ");
+// check for wildcards
+if (signature.charAt(consumed_chars) == '+') {
+type.append("? extends ");
+consumed_chars++;
+} else if (signature.charAt(consumed_chars) == '-') {
+type.append("? super ");
+consumed_chars++;
+}
+if (signature.charAt(consumed_chars) == '*') {
+type.append("?");
+consumed_chars++;
+} else {
+type.append(signatureToString(signature.substring(consumed_chars), chopit));
+// update our consumed count by the number of characters the for type argument
+consumed_chars = unwrap(Utility.consumed_chars) + consumed_chars;
+wrap(Utility.consumed_chars, consumed_chars);
+}
+}
+// process the closing ">"
+consumed_chars++;
+type.append(">");
+if (signature.charAt(consumed_chars) == '.') {
+// we have a ClassTypeSignatureSuffix
+type.append(".");
+// convert SimpleClassTypeSignature to fake ClassTypeSignature
+// and then recurse to parse it
+type.append(signatureToString("L" + signature.substring(consumed_chars+1), chopit));
+// update our consumed count by the number of characters the for type argument
+// note that this count includes the "L" we added, but that is ok
+// as it accounts for the "." we didn't consume
+consumed_chars = unwrap(Utility.consumed_chars) + consumed_chars;
+wrap(Utility.consumed_chars, consumed_chars);
+return type.toString();
+}
+if (signature.charAt(consumed_chars) != ';') {
 throw new ClassFormatException("Invalid signature: " + signature);
 }
-wrap(Utility.consumed_chars, consumed_chars + 2); // remove final ">;"
+wrap(Utility.consumed_chars, consumed_chars + 1); // remove final ";"
-return type.append(">").toString();
+return type.toString();
 }
 case 'S':
 return "short";
 case 'Z':
 return "boolean";
 } catch (final StringIndexOutOfBoundsException e) { // Should never occur
 throw new ClassFormatException("Invalid signature: " + signature, e);
 }
 }
-/**
-* Parse Java type such as "char", or "java.lang.String[]" and return the
+/** 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;"
+* signature in byte code format, e.g. "C" or "[Ljava/lang/String;" respectively.
-* respectively.
+*
-*
+* @param  type Java type
-* @param type Java type
 * @return byte code signature
 */
-public static String getSignature(String type) {
+public static String getSignature( String type ) {
 final StringBuilder buf = new StringBuilder();
 final char[] chars = type.toCharArray();
 boolean char_found = false;
 boolean delim = false;
 int index = -1;
-loop:
+loop: for (int i = 0; i < chars.length; i++) {
-for (int i = 0; i < chars.length; i++) {
 switch (chars[i]) {
 case ' ':
 case '\t':
 case '\n':
 case '\r':
 buf.append('L').append(type.replace('.', '/')).append(';');
 }
 return buf.toString();
 }
-private static int countBrackets(final String brackets) {
+private static int countBrackets( final String brackets ) {
 final char[] chars = brackets.toCharArray();
 int count = 0;
 boolean open = false;
 for (final char c : chars) {
 switch (c) {
 throw new RuntimeException("Illegally nested brackets:" + brackets);
 }
 return count;
 }
-/**
-* Return type of method signature as a byte value as defined in
+/**
-* <em>Constants</em>
+* Return type of method signature as a byte value as defined in <em>Constants</em>
 *
-* @param signature in format described above
+* @param  signature in format described above
 * @return type of method signature
-* @see Const
+* @see    Const
 *
 * @throws ClassFormatException if signature is not a method signature
 */
-public static byte typeOfMethodSignature(final String signature) throws ClassFormatException {
+public static byte typeOfMethodSignature( final String signature ) throws ClassFormatException {
 int index;
 try {
 if (signature.charAt(0) != '(') {
 throw new ClassFormatException("Invalid method signature: " + signature);
 }
 } catch (final StringIndexOutOfBoundsException e) {
 throw new ClassFormatException("Invalid method signature: " + signature, e);
 }
 }
 /**
 * Return type of signature as a byte value as defined in <em>Constants</em>
 *
-* @param signature in format described above
+* @param  signature in format described above
 * @return type of signature
-* @see Const
+* @see    Const
 *
 * @throws ClassFormatException if signature isn't a known type
 */
-public static byte typeOfSignature(final String signature) throws ClassFormatException {
+public static byte typeOfSignature( final String signature ) throws ClassFormatException {
 try {
 switch (signature.charAt(0)) {
 case 'B':
 return Const.T_BYTE;
 case 'C':
 } catch (final StringIndexOutOfBoundsException e) {
 throw new ClassFormatException("Invalid method signature: " + signature, e);
 }
 }
-/**
-* Map opcode names to opcode numbers. E.g., return Constants.ALOAD for
+/** Map opcode names to opcode numbers. E.g., return Constants.ALOAD for "aload"
-* "aload"
+*/
-*/
+public static short searchOpcode( String name ) {
-public static short searchOpcode(String name) {
 name = name.toLowerCase(Locale.ENGLISH);
 for (short i = 0; i < Const.OPCODE_NAMES_LENGTH; i++) {
 if (Const.getOpcodeName(i).equals(name)) {
 return i;
 }
 }
 return -1;
 }
 /**
 * Convert (signed) byte to (unsigned) short value, i.e., all negative
 * values become positive.
 */
-private static short byteToShort(final byte b) {
+private static short byteToShort( final byte b ) {
 return (b < 0) ? (short) (256 + b) : (short) b;
 }
-/**
-* Convert bytes into hexadecimal string
+/** Convert bytes into hexadecimal string
 *
 * @param bytes an array of bytes to convert to hexadecimal
 *
 * @return bytes as hexadecimal string, e.g. 00 fa 12 ...
 */
-public static String toHexString(final byte[] bytes) {
+public static String toHexString( final byte[] bytes ) {
 final StringBuilder buf = new StringBuilder();
 for (int i = 0; i < bytes.length; i++) {
 final short b = byteToShort(bytes[i]);
 final String hex = Integer.toHexString(b);
 if (b < 0x10) {
 }
 }
 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 String format(final int i, final int length,
+public static String format( final int i, final int length, final boolean left_justify, final char fill ) {
-final boolean left_justify, final 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.
+* 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 String fillup(final String str, final int length,
+public static String fillup( final String str, final int length, final boolean left_justify, final char fill ) {
-final boolean left_justify, final char fill) {
 final int len = length - str.length();
 final char[] buf = new char[(len < 0) ? 0 : len];
 for (int j = 0; j < buf.length; j++) {
 buf[j] = fill;
 }
 return str + new String(buf);
 }
 return new String(buf) + str;
 }
-static boolean equals(final byte[] a, final byte[] b) {
+static boolean equals( final byte[] a, final byte[] b ) {
 int size;
 if ((size = a.length) != b.length) {
 return false;
 }
 for (int i = 0; i < size; i++) {
 }
 }
 return true;
 }
-public static void printArray(final PrintStream out, final Object[] obj) {
+public static void printArray( final PrintStream out, final Object[] obj ) {
 out.println(printArray(obj, true));
 }
-public static void printArray(final PrintWriter out, final Object[] obj) {
+public static void printArray( final PrintWriter out, final Object[] obj ) {
 out.println(printArray(obj, true));
 }
-public static String printArray(final Object[] obj) {
+public static String printArray( final Object[] obj ) {
 return printArray(obj, true);
 }
-public static String printArray(final Object[] obj, final boolean braces) {
+public static String printArray( final Object[] obj, final boolean braces ) {
 return printArray(obj, braces, false);
 }
-public static String printArray(final Object[] obj, final boolean braces, final boolean quote) {
+public static String printArray( final Object[] obj, final boolean braces, final boolean quote ) {
 if (obj == null) {
 return null;
 }
 final StringBuilder buf = new StringBuilder();
 if (braces) {
 buf.append('}');
 }
 return buf.toString();
 }
 /**
 * @param ch the character to test if it's part of an identifier
 *
 * @return true, if character is one of (a, ... z, A, ... Z, 0, ... 9, _)
 */
-public static boolean isJavaIdentifierPart(final char ch) {
+public static boolean isJavaIdentifierPart( final 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, _,
+* Encode byte array it into Java identifier string, i.e., a string
-* $). The encoding algorithm itself is not too clever: if the current
+* that only contains the following characters: (a, ... z, A, ... Z,
-* byte's ASCII value already is a valid Java identifier part, leave it as
+* 0, ... 9, _, $).  The encoding algorithm itself is not too
-* it is. Otherwise it writes the escape character($) followed by:
+* 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:
 *
 * <ul>
-* <li> the ASCII value as a hexadecimal string, if the value is not in the
+*   <li> the ASCII value as a hexadecimal string, if the value is not in the range 200..247</li>
-* range 200..247</li>
+*   <li>a Java identifier char not used in a lowercase hexadecimal string, if the value is in the range 200..247</li>
-* <li>a Java identifier char not used in a lowercase hexadecimal string, if
-* the value is in the range 200..247</li>
 * </ul>
 *
-* <p>
+* <p>This operation inflates the original byte array by roughly 40-50%</p>
-* This operation inflates the original byte array by roughly 40-50%</p>
 *
 * @param bytes the byte array to convert
 * @param compress use gzip to minimize string
 *
 * @throws IOException if there's a gzip exception
 jw.write(in);
 }
 }
 return caw.toString();
 }
 /**
 * Decode a string back to a byte array.
 *
 * @param s the string to convert
 // 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;
 for (int i = 'A'; i <= 'Z'; i++) {
 CHAR_MAP[j] = i;
 MAP_CHAR[i] = j;
 CHAR_MAP[j] = '_';
 MAP_CHAR['_'] = j;
 }
 /**
-* Decode characters into bytes. Used by <a
+* Decode characters into bytes.
-* href="Utility.html#decode(java.lang.String, boolean)">decode()</a>
+* Used by <a href="Utility.html#decode(java.lang.String, boolean)">decode()</a>
 */
 private static class JavaReader extends FilterReader {
 public JavaReader(final Reader in) {
 super(in);
 }
 @Override
 public int read() throws IOException {
 final int b = in.read();
 if (b != ESCAPE_CHAR) {
 final int j = in.read();
 if (j < 0) {
 return -1;
 }
 final char[] tmp = {
 (char) i, (char) j
 };
 final int s = Integer.parseInt(new String(tmp), 16);
 return s;
 }
 return MAP_CHAR[i];
 }
 @Override
-public int read(final char[] cbuf, final int off, final int len) throws IOException {
+public int read( final char[] cbuf, final int off, final 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 <a
+* Encode bytes into valid java identifier characters.
-* href="Utility.html#encode(byte[], boolean)">encode()</a>
+* Used by <a href="Utility.html#encode(byte[], boolean)">encode()</a>
 */
 private static class JavaWriter extends FilterWriter {
 public JavaWriter(final Writer out) {
 super(out);
 }
 @Override
-public void write(final int b) throws IOException {
+public void write( final int b ) throws IOException {
 if (isJavaIdentifierPart((char) b) && (b != ESCAPE_CHAR)) {
 out.write(b);
 } else {
 out.write(ESCAPE_CHAR); // Escape character
 // Special escape
 }
 }
 }
 }
 @Override
-public void write(final char[] cbuf, final int off, final int len) throws IOException {
+public void write( final char[] cbuf, final int off, final int len ) throws IOException {
 for (int i = 0; i < len; i++) {
 write(cbuf[off + i]);
 }
 }
 @Override
-public void write(final String str, final int off, final int len) throws IOException {
+public void write( final String str, final int off, final int len ) throws IOException {
 write(str.toCharArray(), off, len);
 }
 }
 /**
 * Escape all occurences of newline chars '\n', quotes \", etc.
 */
-public static String convertString(final String label) {
+public static String convertString( final String label ) {
 final char[] ch = label.toCharArray();
 final StringBuilder buf = new StringBuilder();
 for (final char element : ch) {
 switch (element) {
 case '\n':
 break;
 }
 }
 return buf.toString();
 }
 }

changeset 55496	8e0ae3830fca
parent 48409	5ab69533994b