All Classes and Interfaces
Class
Description
AALOAD - Load reference from array
AASTORE - Store into reference array
Super class for all objects that have modifiers like private, final, ...
ACONST_NULL - Push null reference
Denote family of instructions that allocates space in the heap.
ALOAD - Load reference from local variable
ANEWARRAY - Create new array of references
represents the default value of a annotation for a method info
represents one annotation in the annotation table
base class for annotations
ARETURN - Return reference from method
Super class for the family of arithmetic instructions.
Super class for instructions dealing with array access such as IALOAD.
ARRAYLENGTH - Get length of array
Denotes array type, such as int[][]
Instances of this class should never be thrown.
ASTORE - Store reference into local variable
ATHROW - Throw exception
Abstract super class for Attribute objects.
Unknown (non-standard) attributes may be read via user-defined factory
objects that can be registered with the Attribute.addAttributeReader
method.
BALOAD - Load byte or boolean from array
Denotes basic type such as int.
BASTORE - Store into byte or boolean array
Used for BCEL comparison strategy
This class takes a given JavaClass object and converts it to a
Java program that creates that very class using BCEL.
BIPUSH - Push byte on stack
BranchHandle is returned by specialized InstructionList.append() whenever a
BranchInstruction is appended.
Abstract super class for branching instructions like GOTO, IFEQ, etc..
BREAKPOINT, JVM dependent, ignored by default
Utility class that implements a sequence of bytes which can be read
via the `readByte()' method.
CALOAD - Load char from array
CASTORE - Store into char array
CHECKCAST - Check whether object is of given type
Read class file(s) and convert them into HTML files.
Instances of this class are thrown by BCEL's class file verifier "JustIce"
when a class file to verify does not pass the verification pass 2 as described
in the Java Virtual Machine specification, 2nd edition.
Thrown when the BCEL attempts to read a class file and determines
that the file is malformed or otherwise cannot be interpreted as a
class file.
Template class for building up a java class.
Thrown on internal errors.
Drop in replacement for the standard class loader of the JVM.
The repository maintains information about which classes have
been loaded.
Implement this interface if you're interested in changes to a ClassGen object
and register yourself with addObserver().
Wrapper class that parses a given Java .class file.
Responsible for loading (class) files from the CLASSPATH.
Contains information about file/ZIP entry of the Java class.
Utility class implementing a (typesafe) queue of JavaClass
objects.
Utility class implementing a (typesafe) set of JavaClass objects.
Utility class implementing a (typesafe) stack of JavaClass objects.
Deprecated.
as of 5.1.1 - 7/17/2005
This class represents a chunk of Java byte code contained in a
method.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when
a class file does not pass the verification pass 3.
This class represents an entry in the exception table of the Code
attribute and is used only there.
This class represents an exception handler, i.e., specifies the region where
a handler is active and an instruction where the actual handling is done.
Wrapper class for `compound' operations, virtual instructions that
don't exist as byte code, but give a useful meaning.
Abstract superclass for classes to represent the different constant types
in the constant pool of a class file.
This class is derived from the abstract
Constant class
and represents a reference to a (external) class.
Abstract super class for Fieldref and Methodref constants.
This class is derived from the abstract
Constant class
and represents a reference to a Double object.
This class represents a constant pool reference to a field.
This class is derived from the abstract
Constant class
and represents a reference to a float object.
This class is derived from the abstract
Constant class
and represents a reference to an int object.
This class represents a constant pool reference to an interface method.
This class is derived from the abstract
Constant class
and represents a reference to a long object.
This class represents a constant pool reference to a method.
This class is derived from the abstract
Constant class
and represents a reference to the name and signature
of a field or method.
This interface denotes those constants that have a "natural" value,
such as ConstantLong, ConstantString, etc..
This class represents the constant pool, i.e., a table of constants, of
a parsed classfile.
This class is used to build up a constant pool.
Denotes a push instruction that produces a literal on the stack
such as SIPUSH, BIPUSH, ICONST, etc.
Constants for the project, mostly defined in the JVM specification.
This class is derived from the abstract
Constant class
and represents a reference to a String object.
This class is derived from the abstract
Constant class
and represents a reference to a Utf8 encoded string.
This class is derived from Attribute and represents a constant
value, i.e., a default value for initializing a class field.
This class represents a control flow graph of a method.
Super class for the x2y family of instructions.
Abstract super class for instructions that use an index into the
constant pool such as LDC, INVOKEVIRTUAL, etc.
D2F - Convert double to float
D2I - Convert double to int
D2L - Convert double to long
DADD - Add doubles
DALOAD - Load double from array
DASTORE - Store into double array
DCMPG - Compare doubles: value1 > value2
DCMPL - Compare doubles: value1 invalid input: '<' value2
DCONST - Push 0.0 or 1.0, other values cause an exception
DDIV - Divide doubles
This class is derived from Attribute and denotes that this is a
deprecated method.
Traverses a JavaClass with another Visitor object 'piggy-backed' that is
applied to all components of a JavaClass object.
DLOAD - Load double from local variable
DMUL - Multiply doubles
DNEG - Negate double
This class represents the upper half of a DOUBLE variable.
DREM - Remainder of doubles
DRETURN - Return double from method
DSTORE - Store double into local variable
DSUB - Substract doubles
DUP - Duplicate top operand stack word
DUP_X1 - Duplicate top operand stack word and put two down
DUP_X2 - Duplicate top operand stack word and put three down
DUP2 - Duplicate two top operand stack words
DUP2_X1 - Duplicate two top operand stack words and put three down
DUP2_X2 - Duplicate two top operand stack words and put four down
an annotation's element value pair
Visitor with empty method bodies, can be extended and used in conjunction
with the DescendingVisitor class, e.g.
Supplies empty method bodies to be overridden by subclasses.
This attribute exists for local or
anonymous classes and ...
Exception constants.
This class represents an exception handler; that is, an ObjectType
representing a subclass of java.lang.Throwable and the instruction
the handler starts off (represented by an InstructionContext).
This class allows easy access to ExceptionHandler objects.
This class represents the table of exceptions that are thrown by a
method.
Denote an instruction that may throw a run-time or a linking
exception (or both) during execution.
This Visitor class may be used for a type-based Java Virtual Machine
simulation.
F2D - Convert float to double
F2I - Convert float to int
F2L - Convert float to long
FADD - Add floats
FALOAD - Load float from array
FASTORE - Store into float array
FCMPG - Compare floats: value1 > value2
FCMPL - Compare floats: value1 invalid input: '<' value2
FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
FDIV - Divide floats
This class represents the field info structure, i.e., the representation
for a variable in the class.
Template class for building up a field.
Super class for FieldGen and MethodGen objects, since they have
some methods in common!
Super class for the GET/PUTxxx family of instructions.
Imnplement this interface if you're interested in changes to a FieldGen object
and register yourself with addObserver().
Abstract super class for fields and methods.
Super class for InvokeInstruction and FieldInstruction, since they have
some methods in common!
FLOAD - Load float from local variable
FMUL - Multiply floats
FNEG - Negate float
This class represents a JVM execution frame; that means,
a local variable array and an operand stack.
FREM - Remainder of floats
FRETURN - Return float from method
FSTORE - Store float into local variable
FSUB - Substract floats
A placeholder class that can be used to create an ObjectType of which
has some of the properties arrays have.
GETFIELD - Fetch field from object
GETSTATIC - Fetch static field from class
GOTO - Branch always (to relative offset, not absolute address)
GOTO_W - Branch always (to relative offset, not absolute address)
Super class for GOTO
A graphical user interface application demonstrating JustIce.
I2B - Convert int to byte
I2C - Convert int to char
I2D - Convert int to double
I2F - Convert int to float
I2L - Convert int to long
I2S - Convert int to short
IADD - Add ints
IALOAD - Load int from array
IAND - Bitwise AND int
IASTORE - Store into int array
ICONST - Push value between -1, ..., 5, other values cause an exception
IDIV - Divide ints
IF_ACMPEQ - Branch if reference comparison succeeds
IF_ACMPNE - Branch if reference comparison doesn't succeed
IF_ICMPEQ - Branch if int comparison succeeds
IF_ICMPGE - Branch if int comparison succeeds
IF_ICMPGT - Branch if int comparison succeeds
IF_ICMPLE - Branch if int comparison succeeds
IF_ICMPLT - Branch if int comparison succeeds
IF_ICMPNE - Branch if int comparison doesn't succeed
IFEQ - Branch if int comparison with zero succeeds
IFGE - Branch if int comparison with zero succeeds
IFGT - Branch if int comparison with zero succeeds
Super class for the IFxxx family of instructions.
IFLE - Branch if int comparison with zero succeeds
IFLT - Branch if int comparison with zero succeeds
IFNE - Branch if int comparison with zero succeeds
IFNONNULL - Branch if reference is not null
IFNULL - Branch if reference is not null
IINC - Increment local variable by constant
ILOAD - Load int from local variable onto stack
IMPDEP1 - Implementation dependent
IMPDEP2 - Implementation dependent
IMUL - Multiply ints
Denote entity that refers to an index, e.g.
INEG - Negate int
This class represents a inner class attribute, i.e., the class
indices of the inner and outer classes, the name and the attributes
of the inner class.
This class is derived from Attribute and denotes that this class
is an Inner class of another.
INSTANCEOF - Determine if object is of given type
A Visitor class testing for valid preconditions of JVM instructions.
Abstract super class for all Java byte codes.
Equality of instructions isn't clearly to be defined.
This interface contains shareable instruction objects.
An InstructionContext offers convenient access
to information like control flow successors and
such.
Instances of this class may be used, e.g., to generate typed
versions of instructions.
InstructionFinder is a tool to search for given instructions patterns, i.e.,
match sequences of instructions in an instruction list via regular
expressions.
Code patterns found may be checked using an additional user-defined
constraint object whether they really match the needed criterion.
Instances of this class give users a handle to the instructions contained in
an InstructionList.
This class is a container for a list of Instruction objects.
Implement this interface if you're interested in changes to an InstructionList object
and register yourself with addObserver().
Denote that a class targets InstructionHandles within an InstructionList.
A small utility class representing a set of basic int values.
Instances of this class are thrown by BCEL's class file verifier "JustIce"
when the verification of a method is requested that does not exist.
Super class for the INVOKExxx family of instructions.
INVOKEINTERFACE - Invoke interface method
INVOKESPECIAL - Invoke instance method; special handling for superclass, private
and instance initialization method invocations
INVOKESTATIC - Invoke a class (static) method
INVOKEVIRTUAL - Invoke instance method; dispatch based on class
IOR - Bitwise OR int
IREM - Remainder of int
IRETURN - Return int from method
ISHL - Arithmetic shift left int
ISHR - Arithmetic shift right int
ISTORE - Store int from stack into local variable
ISUB - Substract ints
IUSHR - Logical shift right int
IXOR - Bitwise XOR int
Represents a Java class, i.e., the data structures, constant pool,
fields, methods and commands contained in a Java .class file.
Java interpreter replacement, i.e., wrapper that uses its own ClassLoader
to modify/generate classes as they're requested.
JSR - Jump to subroutine
JSR_W - Jump to subroutine
Super class for JSR - Jump to subroutine
L2D - Convert long to double
L2F - Convert long to float
L2I - Convert long to int
LADD - Add longs
LALOAD - Load long from array
LAND - Bitwise AND longs
LASTORE - Store into long array
LCMP - Compare longs:
LCONST - Push 0 or 1, other values cause an exception
LDC - Push item from constant pool.
LDC_W - Push item from constant pool (wide index)
LDC2_W - Push long or double from constant pool
LDIV - Divide longs
This class represents a (PC offset, line number) pair, i.e., a line number in
the source that corresponds to a relative address in the byte code.
This class represents a line number within a method, i.e., give an instruction
a line number corresponding to the source code line.
This class represents a table of line numbers for debugging
purposes.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when
a class file to verify does not pass the verification pass 3 because of a violation
of a constraint that is usually only verified at run-time (pass 4).
LLOAD - Load long from local variable
LMUL - Multiply longs
LNEG - Negate long
Denotes that an instruction may start the process of loading and resolving
the referenced class in the Virtual Machine.
When loading a class file, BCEL will throw an instance of LoadingException if
the class file is malformed; so it is not conforming to the "Pass 1" verification
process as described in the Java Virtual Machine specification, 2nd.
Denotes an unparameterized instruction to load a value from a local
variable, e.g.
This class represents a local variable within a method.
This class represents a local variable within a method.
A utility class holding the information about
the name and the type of a local variable in
a given slot (== index).
A LocalVariableInfoInconsistentException instance is thrown by
the LocalVariableInfo class when it detects that the information
it holds is inconsistent; this is normally due to inconsistent
LocalVariableTable entries in the Code attribute of a certain
Method object.
Abstract super class for instructions dealing with local variables.
This class implements an array of local variables used for symbolic JVM
simulation.
A utility class holding the information about
the names and the types of the local variables in
a given method.
This class represents colection of local variables in a
method.
This class represents the upper half of a LONG variable.
LOOKUPSWITCH - Switch with unordered set of values
LOR - Bitwise OR long
LREM - Remainder of long
LRETURN - Return long from method
LSHL - Arithmetic shift left long
LSHR - Arithmetic shift right long
LSTORE - Store long into local variable
LSUB - Substract longs
LUSHR - Logical shift right long
LXOR - Bitwise XOR long
This class represents the method info structure, i.e., the representation
for a method in the class.
Template class for building up a method.
Implement this interface if you're interested in changes to a MethodGen object
and register yourself with addObserver().
MONITORENTER - Enter monitor for object
MONITOREXIT - Exit monitor for object
MULTIANEWARRAY - Create new mutidimensional array of references
Denote entity that has both name and type.
The NativeVerifier class implements a main(String[] args) method that's
roughly compatible to the one in the Verifier class, but that uses the
JVM's internal verifier for its class file verification.
NEW - Create new object
NEWARRAY - Create new array of basic type (int, short, ...)
Denote class to have an accept method();
NOP - Do nothing
Denotes reference such as java.lang.String.
This class implements a stack used for symbolic JVM stack simulation.
represents one parameter annotation in the parameter annotation table
base class for parameter annotations
This PassVerifier verifies a class file according to pass 1 as
described in The Java Virtual Machine Specification, 2nd edition.
This PassVerifier verifies a class file according to
pass 2 as described in The Java Virtual Machine
Specification, 2nd edition.
This PassVerifier verifies a class file according to
pass 3, static part as described in The Java Virtual
Machine Specification, 2nd edition.
This PassVerifier verifies a method of class file according to pass 3,
so-called structural verification as described in The Java Virtual Machine
Specification, 2nd edition.
A PassVerifier actually verifies a class file; it is instantiated
by a Verifier.
This class is derived from Attribute and represents a reference
to a PMG attribute.
POP - Pop top operand stack word
POP2 - Pop two top operand stack words
Denotes an unparameterized instruction to pop a value on top from the stack,
such as ISTORE, POP, PUTSTATIC.
Wrapper class for push operations, which are implemented either as BIPUSH,
LDC or xCONST_n instructions.
Denotes an unparameterized instruction to produce a value on top of the stack,
such as ILOAD, LDC, SIPUSH, DUP, ICONST, etc.
PUTFIELD - Put field in object
PUTSTATIC - Put static field in class
Super class for object and array types.
The repository maintains informations about class interdependencies, e.g.,
whether a class is a sub-class of another.
Abstract definition of a class repository.
RET - Return from subroutine
RETURN - Return from void method
Returnaddress, the type JSR or JSR_W instructions push upon the stack.
Super class for the xRETURN family of instructions.
represents an annotation that is represented in the class file but is not
provided to the JVM.
represents a parameter annotation that is represented in the class file
but is not provided to the JVM.
represents an annotation that is represented in the class file and is
provided to the JVM.
represents a parameter annotation that is represented in the class file
and is provided to the JVM.
SALOAD - Load short from array
SASTORE - Store into short array
Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
This class is derived from Attribute and represents a reference
to a GJ attribute.
SIPUSH - Push short
This class is derived from Attribute and represents a reference
to the source file of this class.
Denote an instruction that may consume a value from the stack.
Super class for stack operations like DUP and POP.
This class represents a stack map attribute used for
preverification of Java classes for the Java 2 Micro Edition
(J2ME).
This class represents a stack map entry recording the types of
local variables and the the of stack items at a given byte code offset.
This class represents the type of a local variable or item on stack
used in the StackMap entries.
Denote an instruction that may produce a value on top of the stack
(this excludes DUP_X1, e.g.)
Instances of this class are thrown by BCEL's class file verifier "JustIce" when
a class file to verify does not pass the verification pass 3 because of a violation
of a static constraint as described in the Java Virtual Machine Specification,
2nd edition, 4.8.1, pages 133-137.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when
a class file to verify does not pass the verification pass 3 because of a violation
of a static constraint as described in the Java Virtual Machine Specification,
Second edition, 4.8.1, pages 133-137.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when
a class file to verify does not pass the verification pass 3 because of a violation
of a static constraint as described in the Java Virtual Machine Specification,
Second edition, 4.8.1, pages 133-137.
Denotes an unparameterized instruction to store a value into a local variable,
e.g.
BCEL's Node classes (those from the classfile API that accept() Visitor
instances) have toString() methods that were not designed to be robust,
this gap is closed by this class.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when
a class file to verify does not pass the verification pass 3 because of a violation
of a structural constraint as described in the Java Virtual Machine Specification,
2nd edition, 4.8.2, pages 137-139.
This interface defines properties of JVM bytecode subroutines.
Instances of this class contain information about the subroutines
found in a code array of a method.
SWAP - Swa top operand stack word
SWITCH - Branch depending on int value, generates either LOOKUPSWITCH or
TABLESWITCH instruction, depending on whether the match values (int[]) can be
sorted with no gaps between the numbers.
This class is derived from Attribute and declares this class as
`synthetic', i.e., it needs special handling.
This repository is used in situations where a Class is created
outside the realm of a ClassLoader.
TABLESWITCH - Switch within given range of values, i.e., low..high
Thrown by InstructionList.remove() when one or multiple disposed instruction
are still being referenced by a InstructionTargeter object.
This class has a main method implementing a demonstration program
of how to use the VerifierFactoryObserver.
Abstract super class for all possible java types, namely basic types
such as int, object types like String and array types, e.g.
Get the type associated with an instruction, int for ILOAD, or the type
of the field of a PUTFIELD instruction, e.g..
Denotes an instruction to perform an unconditional branch, i.e., GOTO, JSR.
This class represents an uninitialized object type; see The Java
Virtual Machine Specification, Second Edition, page 147: 4.9.4 for
more details.
This class represents a reference to an unknown (i.e.,
application-specific) attribute of a class.
Utility functions that do not really belong to any class in particular.
A utility class providing convenience methods concerning Throwable instances.
Denotes an instruction to be a variable length instruction, such as
GOTO, JSR, LOOKUPSWITCH and TABLESWITCH.
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a
class file to verify does not pass one of the verification passes 2 or 3.
A VerificationResult is what a PassVerifier returns
after verifying.
A Verifier instance is there to verify a class file according to The Java Virtual
Machine Specification, 2nd Edition.
This class implements a machine-generated frame for use with
the GraphicalVerfifier.
Instances of this class are thrown by BCEL's class file verifier "JustIce"
whenever
verification proves that some constraint of a class file (as stated in the
Java Virtual Machine Specification, Edition 2) is violated.
This class produces instances of the Verifier class.
This class implements an adapter; it implements both a Swing ListModel and
a VerifierFactoryObserver.
VerifierFactoryObserver instances are notified when new Verifier
instances are created.
A class for simple graphical class file verification.
Interface to make use of the Visitor pattern programming style.
Interface implementing the Visitor pattern programming style.