|Home >> All >> com >> chaoswg|
|||com.chaoswg.util.* (1)||||com.chaoswg.xtc4y.* (92)|
LookupSwitchInstruction: A Lookup switch instruction is used to represent switch statements. It consists of the command, an int giving the number of entries, an int defining the default jump address and a set of entries where each entry consists of two ints, the case number and the jump address. The end of a LookupSwitch Instruction is aligned to 4 byte and therefore gaps are filled up with nop's. !The empty instructions are filled up before the default jump adress and the numberOfEntries That means: (1byte+4bytes+4bytes+(4bytes+4bytes)*+((index+length)%4))
TableSwitchInstruction: A Lookup switch instruction is used to represent switch statements. It consists of the command, an int giving the start number, an int defining the last number of table entires, an int defining the default jump address and a set of entries where each entry consists of one int, a jump address. The end of a TableSwitch Instruction is aligned to 4 byte and therefore gaps are filled up with nop's. That means: (1byte+4bytes+4bytes+4bytes+(4bytes)*+((index+length)%4)) TBD: add methods to instanciate a tableswitch without a stream
ClassDescriptor: This container class represents the content of a class file in a readable and reditable way. For further informations about the java class fiel format, see the Java Virtual Machine Specification §4. All mentioned references refere to the chapters and subchapters in this book.
InvokeInterface: A invoke interface instruction is used by calling a interface method. It consists of the command, the number of arguments passed, a index to a MethodsInterfacerefCPEntry and the byte value 0. The number of used bytes is therefore 5 (4 byte operands and the command) TBD: add constructor for an instruction creation withou stream
ConstantPool: This class describes the constant pool in a class file. It is mainly used internally The constant pool begins at index 1, therefore tries for storing data at this position wan't succeed, a ArrayIndexOutofBoundException will be thrown. It begins at index 1 so a reference to a cp entry at position 0 means no reference.
LogClassLoader: This is a classloader appending to every implemented method a begin and end log message of the level DEBUG using log4j. The log4j framework may be configured using the following the system property 'log4j.configuration', i.e. starting the application with java -Dlog4j.configuration=foobar.properties com.athome.myclass
ValueCPEntry: This abstract class is just used to identify a value constant pool entry. a value cp entry max be a float, int, long, double, short, byte, char, boolean or a String. More informations about the mappping of these types to the cp entry is shown in Table 4.6 in §4.7.2
ShortValueCPEntry: This abstract class is just used to identify a short value constant pool entry. a short value cp entry max be a float, int, short, byte, char, boolean or a String. More informations about the mappping of these types to the cp entry is shown in Table 4.6 in §4.7.2
CodeAttribute: This class describes the information for a code attribute ($4.7.3) TBD: replace the byte array representing the code by a code class thorugh which easily the code may be changed an extended and all the indices may be checked (as with the constant pool)
WideValueCPEntry: This abstract class is just used to identify a wide value constant pool entry. a wide value cp entry max be a long or double. More informations about the mappping of these types to the cp entry is shown in Table 4.6 in §4.7.2
Instruction: An instruction is a operation executed in java and consists either of no operand or one operand. The size of the operand my vary between a byte and a short. These specific instructions are implemented in the subclasses
RefCPEntry: this class represent a Ref constant pool entry and is an abstraction from all the reference CP Entried. No setter methods are implemented because the values may be changed in the returned constant pool entries.
CodeCompatible: This interface marks a attribute to be code compatible. Code compatible it may occur in the attributes section of a codeattribute and must therefore resolve it indices into the code array
FieldrefCPEntry: this class represent a Fieldref constant pool entry. No setter methods are implemented because the values may be changed in the returned constant pool entries.
ConstantPoolEntry: A Constant pool consists of a set of Constant pool entries. There are types of a constantpool entry defined, which wil be implemented in subclasses
AbstractClassImplementor: This class is used to implement an abstract class for testing purposes. It creates a subclass of it which implements all abstract methods
LocalVariableTableEntry: this class represents an antry in the localvariabletable attribute, described in §4.7.9 TBD: make an entry editable through methods
ByteContainer: this class is used to store several different data types into a byte container a retrieve at last a byte array or a DataInputStream
TestClassDescriptor: This is a non JUnit testclass for proving loading a class into a ClassDescriptor and writing bytes to a classloader works :-)
CPRefInstruction: a constant pool refernece instruction is an instruction composite of the command and a short refering into the cp table.
UnaryInstruction: An unaryinstruction consists only of a command with no operands. the size of such an instruction is 1 byte
MethodrefInstruction: Just a constructor for the creation of a methodreference instructions. Mainly used for invoke instructions
ShortCPRefInstruction: This cpreference instruction has as an operand just a byte representing a valid index into the cp table
LocalVariableTableAttribute: This class describes the information for a localVariableTable attribute ($4.7.9) TBD: make editable
WideBinaryInstruction: A binary instruction consists of a command and one two bytes operand, therefore its size is 3 bytes