Java ByteSequence类代码示例

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
		throws IOException {
	super.initFromFile(bytes, wide);

	int low = bytes.readInt();
	int high = bytes.readInt();

	match_length = high - low + 1;
	fixed_length = (short) (13 + match_length * 4);
	length = (short) (fixed_length + padding);

	match = new int[match_length];
	indices = new int[match_length];
	targets = new InstructionHandle[match_length];

	for (int i = low; i <= high; i++)
		match[i - low] = i;

	for (int i = 0; i < match_length; i++) {
		indices[i] = bytes.readInt();
	}
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
		throws IOException {
	super.initFromFile(bytes, wide); // reads padding

	match_length = bytes.readInt();
	fixed_length = (short) (9 + match_length * 8);
	length = (short) (fixed_length + padding);

	match = new int[match_length];
	indices = new int[match_length];
	targets = new InstructionHandle[match_length];

	for (int i = 0; i < match_length; i++) {
		match[i] = bytes.readInt();
		indices[i] = bytes.readInt();
	}
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
  * Read needed data (e.g. index) from file.
  * PRE: (ILOAD <= tag <= ALOAD_3) || (ISTORE <= tag <= ASTORE_3)
  */
 protected void initFromFile(ByteSequence bytes, boolean wide)
   throws IOException
 {
   if(wide) {
     n         = bytes.readUnsignedShort();
     length    = 4;
   } else if(((opcode >= Constants.ILOAD) &&
       (opcode <= Constants.ALOAD)) ||
      ((opcode >= Constants.ISTORE) &&
       (opcode <= Constants.ASTORE))) {
     n      = bytes.readUnsignedByte();
     length = 2;
   } else if(opcode <= Constants.ALOAD_3) { // compact load instruction such as ILOAD_2
     n      = (opcode - Constants.ILOAD_0) % 4;
     length = 1;
   } else { // Assert ISTORE_0 <= tag <= ASTORE_3
     n      = (opcode - Constants.ISTORE_0) % 4;
     length = 1;
   }
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
  * 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.
  *
  * @param  code byte code array
  * @param  constant_pool Array of constants
  * @param  index offset in `code' array
  * <EM>(number of opcodes, not bytes!)</EM>
  * @param  length number of opcodes to decompile, -1 for all
  * @param  verbose be verbose, e.g. print constant pool index
  * @return String representation of byte codes
  */
 public static final String codeToString(byte[] code, 
				  ConstantPool constant_pool, 
				  int index, int length, boolean verbose)
 {
   StringBuffer buf    = new StringBuffer(code.length * 20); // Should be sufficient
   ByteSequence stream = new ByteSequence(code);

   try {
     for(int i=0; i < index; i++) // Skip `index' lines of code
codeToString(stream, constant_pool, verbose);

     for(int i=0; stream.available() > 0; i++) {
if((length < 0) || (i < length)) {
  String indices = fillup(stream.getIndex() + ":", 6, true, ' ');
  buf.append(indices + codeToString(stream, constant_pool, verbose) + '\n');
}
     }
   } catch(IOException e) {
     System.out.println(buf.toString());
     e.printStackTrace();
     throw new ClassFormatException("Byte code error: " + e);
   }

   return buf.toString();
 }
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException {
    super.initFromFile(bytes, wide);
    int low = bytes.readInt();
    int high = bytes.readInt();
    match_length = high - low + 1;
    fixed_length = (short) (13 + match_length * 4);
    length = (short) (fixed_length + padding);
    match = new int[match_length];
    indices = new int[match_length];
    targets = new InstructionHandle[match_length];
    for (int i = low; i <= high; i++) {
        match[i - low] = i;
    }
    for (int i = 0; i < match_length; i++) {
        indices[i] = bytes.readInt();
    }
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 * PRE: (ILOAD <= tag <= ALOAD_3) || (ISTORE <= tag <= ASTORE_3)
 */
protected void initFromFile( ByteSequence bytes, boolean wide ) throws IOException {
    if (wide) {
        n = bytes.readUnsignedShort();
        length = 4;
    } else if (((opcode >= Constants.ILOAD) && (opcode <= Constants.ALOAD))
            || ((opcode >= Constants.ISTORE) && (opcode <= Constants.ASTORE))) {
        n = bytes.readUnsignedByte();
        length = 2;
    } else if (opcode <= Constants.ALOAD_3) { // compact load instruction such as ILOAD_2
        n = (opcode - Constants.ILOAD_0) % 4;
        length = 1;
    } else { // Assert ISTORE_0 <= tag <= ASTORE_3
        n = (opcode - Constants.ISTORE_0) % 4;
        length = 1;
    }
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * 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.
 *
 * @param  code byte code array
 * @param  constant_pool Array of constants
 * @param  index offset in `code' array
 * <EM>(number of opcodes, not bytes!)</EM>
 * @param  length number of opcodes to decompile, -1 for all
 * @param  verbose be verbose, e.g. print constant pool index
 * @return String representation of byte codes
 */
public static final String codeToString( byte[] code, ConstantPool constant_pool, int index,
        int length, boolean verbose ) {
    StringBuffer buf = new StringBuffer(code.length * 20); // Should be sufficient
    ByteSequence stream = new ByteSequence(code);
    try {
        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)) {
                String indices = fillup(stream.getIndex() + ":", 6, true, ' ');
                buf.append(indices).append(codeToString(stream, constant_pool, verbose))
                        .append('\n');
            }
        }
    } catch (IOException e) {
        System.out.println(buf.toString());
        e.printStackTrace();
        throw new ClassFormatException("Byte code error: " + e);
    }
    return buf.toString();
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
        throws IOException {
    super.initFromFile(bytes, wide);

    int low = bytes.readInt();
    int high = bytes.readInt();

    match_length = high - low + 1;
    fixed_length = (short) (13 + match_length * 4);
    length = (short) (fixed_length + padding);

    match = new int[match_length];
    indices = new int[match_length];
    targets = new InstructionHandle[match_length];

    for (int i = low; i <= high; i++)
        match[i - low] = i;

    for (int i = 0; i < match_length; i++) {
        indices[i] = bytes.readInt();
    }
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * @return an array of instructions without target information for branch instructions.
 */
public Instruction[] getInstructions() {
    ByteSequence bytes = new ByteSequence(getByteCode());
    ArrayList<Instruction> instructions = new ArrayList<Instruction>();

    try {
        while (bytes.available() > 0) {
            instructions.add(Instruction.readInstruction(bytes));
        }
    } catch (IOException e) {
        throw new ClassGenException(e.toString());
    }

    Instruction[] result = new Instruction[instructions.size()];
    instructions.toArray(result);
    return result;
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
        throws IOException {
    super.initFromFile(bytes, wide); // reads padding

    match_length = bytes.readInt();
    fixed_length = (short) (9 + match_length * 8);
    length = (short) (fixed_length + padding);

    match = new int[match_length];
    indices = new int[match_length];
    targets = new InstructionHandle[match_length];

    for (int i = 0; i < match_length; i++) {
        match[i] = bytes.readInt();
        indices[i] = bytes.readInt();
    }
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 * PRE: (ILOAD <= tag <= ALOAD_3) || (ISTORE <= tag <= ASTORE_3)
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
        throws IOException {
    if (wide) {
        n = bytes.readUnsignedShort();
        length = 4;
    } else if (((opcode >= Constants.ILOAD) &&
            (opcode <= Constants.ALOAD)) ||
            ((opcode >= Constants.ISTORE) &&
                    (opcode <= Constants.ASTORE))) {
        n = bytes.readUnsignedByte();
        length = 2;
    } else if (opcode <= Constants.ALOAD_3) { // compact load instruction such as ILOAD_2
        n = (opcode - Constants.ILOAD_0) % 4;
        length = 1;
    } else { // Assert ISTORE_0 <= tag <= ASTORE_3
        n = (opcode - Constants.ISTORE_0) % 4;
        length = 1;
    }
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * 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.
 *
 * @param code          byte code array
 * @param constant_pool Array of constants
 * @param index         offset in `code' array
 *                      <EM>(number of opcodes, not bytes!)</EM>
 * @param length        number of opcodes to decompile, -1 for all
 * @param verbose       be verbose, e.g. print constant pool index
 * @return String representation of byte codes
 */
public static String codeToString(byte[] code,
                                        ConstantPool constant_pool,
                                        int index, int length, boolean verbose) {
    StringBuffer buf = new StringBuffer(code.length * 20); // Should be sufficient
    ByteSequence stream = new ByteSequence(code);

    try {
        for (int i = 0; i < index; i++) // Skip `index' lines of code
            codeToString(stream, constant_pool, verbose);

        for (int i = 0; stream.available() > 0; i++) {
            if ((length < 0) || (i < length)) {
                String indices = fillup(stream.getIndex() + ":", 6, true, ' ');
                buf.append(indices).append(codeToString(stream, constant_pool, verbose)).append('\n');
            }
        }
    } catch (IOException e) {
        System.out.println(buf.toString());
        e.printStackTrace();
        throw new ClassFormatException("Byte code error: " + e);
    }

    return buf.toString();
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (i.e., index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
     throws IOException
{
  setIndex(bytes.readUnsignedShort());
  // Override just in case it has been changed
  opcode = org.apache.bcel.Constants.LDC_W;
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
     throws IOException
{
  length = 2;
  index  = bytes.readUnsignedByte();
}
 

import org.apache.bcel.util.ByteSequence; //导入依赖的package包/类
/**
 * Read needed data (e.g. index) from file.
 */
protected void initFromFile(ByteSequence bytes, boolean wide)
		throws IOException {
	padding = (4 - (bytes.getIndex() % 4)) % 4; // Compute number of pad
												// bytes

	for (int i = 0; i < padding; i++) {
		bytes.readByte();
	}

	// Default branch target common for both cases (TABLESWITCH,
	// LOOKUPSWITCH)
	index = bytes.readInt();
}