# All Classes and Interfaces

Class
Description
AALOAD
AALOAD - Load reference from array
AASTORE
AASTORE - Store into reference array
AccessFlags
Super class for all objects that have modifiers like private, final, ...
ACONST_NULL
ACONST_NULL - Push null reference
AllocationInstruction
Denote family of instructions that allocates space in the heap.
ALOAD
ALOAD - Load reference from local variable
ANEWARRAY
ANEWARRAY - Create new array of references
AnnotationDefault
Represents the default value of a annotation for a method info.
AnnotationElementValue
AnnotationElementValueGen
AnnotationEntry
Represents one annotation in the annotation table
AnnotationEntryGen
Annotations
base class for annotations
ARETURN
ARETURN - Return reference from method
Args
Argument validation.
ArithmeticInstruction
Super class for the family of arithmetic instructions.
ArrayElementValue
ArrayElementValueGen
ArrayInstruction
Super class for instructions dealing with array access such as IALOAD.
ARRAYLENGTH
ARRAYLENGTH - Get length of array
ArrayType
Denotes array type, such as int[][]
AssertionViolatedException
Instances of this class should never be thrown.
ASTORE
ASTORE - Store reference into local variable
ATHROW
ATHROW - Throw exception
Attribute
Abstract super class for Attribute objects.
AttributeReader
Deprecated.
Use UnknownAttributeReader instead
BALOAD
BALOAD - Load byte or boolean from array
BasicType
Denotes basic type such as int.
BASTORE
BASTORE - Store into byte or boolean array
BCELComparator<T>
Used for BCEL comparison strategy.
BCELifier
This class takes a given JavaClass object and converts it to a Java program that creates that very class using BCEL.
BCELifier.FLAGS
Enum corresponding to flag source.
BIPUSH
BIPUSH - Push byte on stack
BootstrapMethod
This class represents a bootstrap method attribute, i.e., the bootstrap method ref, the number of bootstrap arguments and an array of the bootstrap arguments.
BootstrapMethods
This class represents a BootstrapMethods attribute.
BranchHandle
BranchHandle is returned by specialized InstructionList.append() whenever a BranchInstruction is appended.
BranchInstruction
Abstract super class for branching instructions like GOTO, IFEQ, and so on.
BREAKPOINT
BREAKPOINT, JVM dependent, ignored by default
ByteSequence
Utility class that implements a sequence of bytes which can be read via the 'readByte()' method.
CALOAD
CALOAD - Load char from array
CASTORE
CASTORE - Store into char array
CHECKCAST
CHECKCAST - Check whether object is of given type
Class2HTML
Read class file(s) and convert them into HTML files.
ClassConstraintException
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.
ClassElementValue
ClassElementValueGen
ClassFormatException
Thrown when the BCEL attempts to read a class file and determines that a class is malformed or otherwise cannot be interpreted as a class file.
ClassGen
Template class for building up a java class.
ClassGenException
Thrown on internal exceptions.
ClassLoader
Deprecated.
6.0 Do not use - does not work
ClassLoaderRepository
The repository maintains information about which classes have been loaded.
ClassObserver
Implement this interface if you're interested in changes to a ClassGen object and register yourself with addObserver().
ClassParser
Wrapper class that parses a given Java .class file.
ClassPath
Loads class files from the CLASSPATH.
ClassPath.ClassFile
Contains information about file/ZIP entry of the Java class.
ClassPathRepository
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
ClassQueue
Utility class implementing a (typesafe) queue of JavaClass objects.
ClassSet
Utility class implementing a (type-safe) set of JavaClass objects.
ClassStack
Utility class implementing a (typesafe) stack of JavaClass objects.
ClassVector
Deprecated.
as of 5.1.1 - 7/17/2005
Code
This class represents a chunk of Java byte code contained in a method.
CodeConstraintException
Instances of this class are thrown by BCEL's class file verifier "JustIce" when a class file does not pass the verification pass 3.
CodeException
This class represents an entry in the exception table of the Code attribute and is used only there.
CodeExceptionGen
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. pool as parameters.
CompoundInstruction
Wrapper class for 'compound' operations, virtual instructions that don't exist as byte code, but give a useful meaning.
Const
Constants for the project, mostly defined in the JVM specification.
Constant
Abstract superclass for classes to represent the different constant types in the constant pool of a class file.
ConstantClass
This class is derived from the abstract `Constant` and represents a reference to a (external) class.
ConstantCP
Abstract super class for Fieldref, Methodref, InterfaceMethodref and InvokeDynamic constants.
ConstantDouble
This class is derived from the abstract `Constant` and represents a reference to a Double object.
ConstantDynamic
This class is derived from the abstract `Constant` and represents a reference to a dynamically computed constant.
ConstantFieldref
This class represents a constant pool reference to a field.
ConstantFloat
This class is derived from the abstract `Constant` and represents a reference to a float object.
ConstantInteger
This class is derived from the abstract `Constant` and represents a reference to an int object.
ConstantInterfaceMethodref
This class represents a constant pool reference to an interface method.
ConstantInvokeDynamic
This class is derived from the abstract `Constant` and represents a reference to a invoke dynamic.
ConstantLong
This class is derived from the abstract `Constant` and represents a reference to a long object.
ConstantMethodHandle
This class is derived from the abstract `Constant` and represents a reference to a method handle.
ConstantMethodref
This class represents a constant pool reference to a method.
ConstantMethodType
This class is derived from the abstract `Constant` and represents a reference to a method type.
ConstantModule
This class is derived from the abstract `Constant` and represents a reference to a module.
ConstantNameAndType
This class is derived from the abstract `Constant` and represents a reference to the name and signature of a field or method.
ConstantObject
This interface denotes those constants that have a "natural" value, such as ConstantLong, ConstantString, and so on.
ConstantPackage
This class is derived from the abstract `Constant` and represents a reference to a package.
ConstantPool
This class represents the constant pool, i.e., a table of constants, of a parsed classfile.
ConstantPoolGen
This class is used to build up a constant pool.
ConstantPushInstruction
Denotes a push instruction that produces a literal on the stack such as SIPUSH, BIPUSH, ICONST, etc.
Constants
Deprecated.
(since 6.0) DO NOT USE - use `Const` instead.
ConstantString
This class is derived from the abstract `Constant` and represents a reference to a String object.
ConstantUtf8
Extends the abstract `Constant` to represent a reference to a UTF-8 encoded string.
ConstantValue
This class is derived from Attribute and represents a constant value, i.e., a default value for initializing a class field.
ControlFlowGraph
This class represents a control flow graph of a method.
ConversionInstruction
Super class for the x2y family of instructions.
CPInstruction
Abstract super class for instructions that use an index into the constant pool such as LDC, INVOKEVIRTUAL, etc.
D2F
D2F - Convert double to float
D2I
D2I - Convert double to int
D2L
D2L - Convert double to long
DADD
DADD - Add doubles
DALOAD
DALOAD - Load double from array
DASTORE
DASTORE - Store into double array
DCMPG
DCMPG - Compare doubles: value1 > value2
DCMPL
DCMPL - Compare doubles: value1 < value2
DCONST
DCONST - Push 0.0 or 1.0, other values cause an exception
DDIV
DDIV - Divide doubles
Deprecated
This class is derived from Attribute and denotes that this is a deprecated method.
DescendingVisitor
Traverses a JavaClass with another Visitor object 'piggy-backed' that is applied to all components of a JavaClass object.
DLOAD
DLOAD - Load double from local variable
DMUL
DMUL - Multiply doubles
DNEG
DNEG - Negate double
DOUBLE_Upper
This class represents the upper half of a DOUBLE variable.
DREM
DREM - Remainder of doubles
DRETURN
DRETURN - Return double from method
DSTORE
DSTORE - Store double into local variable
DSUB
DSUB - Substract doubles
DUP
DUP - Duplicate top operand stack word
DUP_X1
DUP_X1 - Duplicate top operand stack word and put two down
DUP_X2
DUP_X2 - Duplicate top operand stack word and put three down
DUP2
DUP2 - Duplicate two top operand stack words
DUP2_X1
DUP2_X1 - Duplicate two top operand stack words and put three down
DUP2_X2
DUP2_X2 - Duplicate two top operand stack words and put four down
ElementValue
The element_value structure is documented at https://docs.oracle.com/javase/specs/jvms/se11/html/jvms-4.html#jvms-4.7.16.1
ElementValueGen
ElementValuePair
An annotation's element value pair.
ElementValuePairGen
EmptyVisitor
Visitor with empty method bodies, can be extended and used in conjunction with the DescendingVisitor class, for example.
EmptyVisitor
Supplies empty method bodies to be overridden by subclasses.
EnclosingMethod
This attribute exists for local or anonymous classes and ... there can be only one.
EnumElementValue
EnumElementValueGen
ExceptionConst
Exception constants.
ExceptionConst.EXCS
Enum corresponding to the various Exception Class arrays, used by `ExceptionConst.createExceptions(EXCS, Class...)`
ExceptionConstants
Deprecated.
(since 6.0) DO NOT USE - use ExceptionConst instead
ExceptionHandler
This class represents an exception handler; that is, an ObjectType representing a subclass of `Throwable` and the instruction the handler starts off (represented by an InstructionContext).
ExceptionHandlers
This class allows easy access to ExceptionHandler objects.
ExceptionTable
This class represents the table of exceptions that are thrown by a method.
ExceptionThrower
Denote an instruction that may throw a run-time or a linking exception (or both) during execution.
ExecutionVisitor
This Visitor class may be used for a type-based Java Virtual Machine simulation.
F2D
F2D - Convert float to double
F2I
F2I - Convert float to int
F2L
F2L - Convert float to long
FADD
FADD - Add floats
FALOAD
FALOAD - Load float from array
FASTORE
FASTORE - Store into float array
FCMPG
FCMPG - Compare floats: value1 > value2
FCMPL
FCMPL - Compare floats: value1 < value2
FCONST
FCONST - Push 0.0, 1.0 or 2.0, other values cause an exception
FDIV
FDIV - Divide floats
Field
This class represents the field info structure, i.e., the representation for a variable in the class.
FieldGen
Template class for building up a field.
FieldGenOrMethodGen
Super class for FieldGen and MethodGen objects, since they have some methods in common!
FieldInstruction
Super class for the GET/PUTxxx family of instructions.
FieldObserver
Imnplement this interface if you're interested in changes to a FieldGen object and register yourself with addObserver().
FieldOrMethod
Abstract super class for fields and methods.
FieldOrMethod
Super class for InvokeInstruction and FieldInstruction, since they have some methods in common!
FLOAD
FLOAD - Load float from local variable
FMUL
FMUL - Multiply floats
FNEG
FNEG - Negate float
Frame
This class represents a JVM execution frame; that means, a local variable array and an operand stack.
FREM
FREM - Remainder of floats
FRETURN
FRETURN - Return float from method
FSTORE
FSTORE - Store float into local variable
FSUB
FSUB - Substract floats
GenericArray
A placeholder class that can be used to create an ObjectType of which has some of the properties arrays have.
GETFIELD
GETFIELD - Fetch field from object
GETSTATIC
GETSTATIC - Fetch static field from class
GOTO
GOTO - Branch always (to relative offset, not absolute address)
GOTO_W
GOTO_W - Branch always (to relative offset, not absolute address)
GotoInstruction
Super class for GOTO
GraphicalVerifier
A graphical user interface application demonstrating JustIce.
I2B
I2B - Convert int to byte
I2C
I2C - Convert int to char
I2D
I2D - Convert int to double
I2F
I2F - Convert int to float
I2L
I2L - Convert int to long
I2S
I2S - Convert int to short
IADD
IADD - Add ints
IALOAD
IALOAD - Load int from array
IAND
IAND - Bitwise AND int
IASTORE
IASTORE - Store into int array
ICONST
ICONST - Push value between -1, ..., 5, other values cause an exception
IDIV
IDIV - Divide ints
IF_ACMPEQ
IF_ACMPEQ - Branch if reference comparison succeeds
IF_ACMPNE
IF_ACMPNE - Branch if reference comparison doesn't succeed
IF_ICMPEQ
IF_ICMPEQ - Branch if int comparison succeeds
IF_ICMPGE
IF_ICMPGE - Branch if int comparison succeeds
IF_ICMPGT
IF_ICMPGT - Branch if int comparison succeeds
IF_ICMPLE
IF_ICMPLE - Branch if int comparison succeeds
IF_ICMPLT
IF_ICMPLT - Branch if int comparison succeeds
IF_ICMPNE
IF_ICMPNE - Branch if int comparison doesn't succeed
IFEQ
IFEQ - Branch if int comparison with zero succeeds
IFGE
IFGE - Branch if int comparison with zero succeeds
IFGT
IFGT - Branch if int comparison with zero succeeds
IfInstruction
Super class for the IFxxx family of instructions.
IFLE
IFLE - Branch if int comparison with zero succeeds
IFLT
IFLT - Branch if int comparison with zero succeeds
IFNE
IFNE - Branch if int comparison with zero succeeds
IFNONNULL
IFNONNULL - Branch if reference is not null
IFNULL
IFNULL - Branch if reference is not null
IINC
IINC - Increment local variable by constant
ILOAD
ILOAD - Load int from local variable onto stack
IMPDEP1
IMPDEP1 - Implementation dependent
IMPDEP2
IMPDEP2 - Implementation dependent
IMUL
IMUL - Multiply ints
IndexedInstruction
Denote entity that refers to an index, for example local variable instructions, RET, CPInstruction, etc.
INEG
INEG - Negate int
InnerClass
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.
InnerClasses
This class is derived from Attribute and denotes that this class is an Inner class of another. to the source file of this class.
INSTANCEOF
INSTANCEOF - Determine if object is of given type
InstConstraintVisitor
A Visitor class testing for valid preconditions of JVM instructions.
Instruction
Abstract super class for all Java byte codes.
InstructionComparator
Equality of instructions isn't clearly to be defined.
InstructionConst
Contains shareable instruction objects.
InstructionConstants
Deprecated.
(since 6.0) Do not use.
InstructionConstants.Clinit
Deprecated, consider private and ignore.
InstructionContext
An InstructionContext offers convenient access to information like control flow successors and such.
InstructionFactory
Instances of this class may be used, for example, to generate typed versions of instructions.
InstructionFinder
InstructionFinder is a tool to search for given instructions patterns, i.e., match sequences of instructions in an instruction list via regular expressions.
InstructionFinder.CodeConstraint
Code patterns found may be checked using an additional user-defined constraint object whether they really match the needed criterion.
InstructionHandle
Instances of this class give users a handle to the instructions contained in an InstructionList.
InstructionList
This class is a container for a list of Instruction objects.
InstructionListObserver
Implement this interface if you're interested in changes to an InstructionList object and register yourself with addObserver().
InstructionTargeter
Denotes that a class targets InstructionHandles within an InstructionList.
IntList
A small utility class representing a set of basic int values.
InvalidMethodException
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.
InvalidMethodSignatureException
Thrown when the BCEL attempts to read a class file and determines that a class is malformed or otherwise cannot be interpreted as a class file.
INVOKEDYNAMIC
Class for INVOKEDYNAMIC.
InvokeInstruction
Super class for the INVOKExxx family of instructions.
INVOKEINTERFACE
INVOKEINTERFACE - Invoke interface method
INVOKESPECIAL
INVOKESPECIAL - Invoke instance method; special handling for superclass, private and instance initialization method invocations
INVOKESTATIC
INVOKESTATIC - Invoke a class (static) method
INVOKEVIRTUAL
INVOKEVIRTUAL - Invoke instance method; dispatch based on class
IOR
IOR - Bitwise OR int
IREM
IREM - Remainder of int
IRETURN
IRETURN - Return int from method
ISHL
ISHL - Arithmetic shift left int
ISHR
ISHR - Arithmetic shift right int
ISTORE
ISTORE - Store int from stack into local variable
ISUB
ISUB - Substract ints
IUSHR
IUSHR - Logical shift right int
IXOR
IXOR - Bitwise XOR int
JavaClass
Represents a Java class, i.e., the data structures, constant pool, fields, methods and commands contained in a Java .class file.
JavaWrapper
Java interpreter replacement, i.e., wrapper that uses its own ClassLoader to modify/generate classes as they're requested.
JSR
JSR - Jump to subroutine
JSR_W
JSR_W - Jump to subroutine
JsrInstruction
Super class for JSR - Jump to subroutine
L2D
L2D - Convert long to double
L2F
L2F - Convert long to float
L2I
L2I - Convert long to int
LADD
LADD - Add longs
LALOAD
LALOAD - Load long from array
LAND
LAND - Bitwise AND longs
LASTORE
LASTORE - Store into long array
LCMP
LCMP - Compare longs:
LCONST
LCONST - Push 0 or 1, other values cause an exception
LDC
LDC - Push item from constant pool.
LDC_W
LDC_W - Push item from constant pool (wide index)
LDC2_W
LDC2_W - Push long or double from constant pool
LDIV
LDIV - Divide longs
LineNumber
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.
LineNumberGen
This class represents a line number within a method, i.e., give an instruction a line number corresponding to the source code line.
LineNumberTable
This class represents a table of line numbers for debugging purposes.
LinkingConstraintException
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
LLOAD - Load long from local variable
LMUL
LMUL - Multiply longs
LNEG
LNEG - Negate long
LoadClass
Denotes that an instruction may start the process of loading and resolving the referenced class in the Virtual Machine.
LoadingException
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. edition.
LoadInstruction
Denotes an unparameterized instruction to load a value from a local variable, for example ILOAD.
LocalVariable
This class represents a local variable within a method.
LocalVariableGen
Represents a local variable within a method.
LocalVariableInfo
A utility class holding the information about the name and the type of a local variable in a given slot (== index).
LocalVariableInfoInconsistentException
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.
LocalVariableInstruction
Abstract super class for instructions dealing with local variables.
LocalVariables
This class implements an array of local variables used for symbolic JVM simulation.
LocalVariablesInfo
A utility class holding the information about the names and the types of the local variables in a given method.
LocalVariableTable
This class represents colection of local variables in a method.
LocalVariableTypeTable
LONG_Upper
This class represents the upper half of a LONG variable.
LOOKUPSWITCH
LOOKUPSWITCH - Switch with unordered set of values
LOR
LOR - Bitwise OR long
LREM
LREM - Remainder of long
LRETURN
LRETURN - Return long from method
LruCacheClassPathRepository
Maintains a least-recently-used (LRU) cache of `JavaClass` with maximum size `cacheSize`.
LSHL
LSHL - Arithmetic shift left long
LSHR
LSHR - Arithmetic shift right long
LSTORE
LSTORE - Store long into local variable
LSUB
LSUB - Substract longs
LUSHR
LUSHR - Logical shift right long
LXOR
LXOR - Bitwise XOR long
MemorySensitiveClassPathRepository
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
Method
This class represents the method info structure, i.e., the representation for a method in the class.
MethodGen
Template class for building up a method.
MethodObserver
Implement this interface if you're interested in changes to a MethodGen object and register yourself with addObserver().
MethodParameter
Entry of the parameters table.
MethodParameters
This class represents a MethodParameters attribute.
ModularRuntimeImage
Wraps a Java 9 JEP 220 modular runtime image.
Module
This class is derived from Attribute and represents the list of modules required, exported, opened or provided by a module.
ModuleExports
This class represents an entry in the exports table of the Module attribute.
ModuleMainClass
This class is derived from Attribute and indicates the main class of a module.
ModuleOpens
This class represents an entry in the opens table of the Module attribute.
ModulePackages
This class is derived from Attribute and represents the list of packages that are exported or opened by the Module attribute.
ModuleProvides
This class represents an entry in the provides table of the Module attribute.
ModuleRequires
This class represents an entry in the requires table of the Module attribute.
MONITORENTER
MONITORENTER - Enter monitor for object
MONITOREXIT
MONITOREXIT - Exit monitor for object
MULTIANEWARRAY
MULTIANEWARRAY - Create new mutidimensional array of references
NamedAndTyped
Denote entity that has both name and type.
NameSignatureInstruction
Super class for FieldOrMethod and INVOKEDYNAMIC, since they both have names and signatures
NativeVerifier
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.
NestHost
This class is derived from Attribute and records the nest host of the nest to which the current class or interface claims to belong.
NestMembers
This class is derived from Attribute and records the classes and interfaces that are authorized to claim membership in the nest hosted by the current class or interface.
NEW
NEW - Create new object
NEWARRAY
NEWARRAY - Create new array of basic type (int, short, ...)
Node
Denote class to have an accept method();
NOP
NOP - Do nothing
ObjectType
Denotes reference such as `String`.
OperandStack
This class implements a stack used for symbolic JVM stack simulation.
ParameterAnnotationEntry
represents one parameter annotation in the parameter annotation table
ParameterAnnotations
base class for parameter annotations
Pass1Verifier
This PassVerifier verifies a class file according to pass 1 as described in The Java Virtual Machine Specification, 2nd edition.
Pass2Verifier
This PassVerifier verifies a class file according to pass 2 as described in The Java Virtual Machine Specification, 2nd edition.
Pass3aVerifier
This PassVerifier verifies a class file according to pass 3, static part as described in The Java Virtual Machine Specification, 2nd edition.
Pass3bVerifier
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.
PassVerifier
A PassVerifier actually verifies a class file; it is instantiated by a Verifier.
PMGClass
This class is derived from Attribute and represents a reference to a PMG attribute.
POP
POP - Pop top operand stack word
POP2
POP2 - Pop two top operand stack words
PopInstruction
Denotes an unparameterized instruction to pop a value on top from the stack, such as ISTORE, POP, PUTSTATIC.
PUSH
Wrapper class for push operations, which are implemented either as BIPUSH, LDC or xCONST_n instructions.
PushInstruction
Denotes an unparameterized instruction to produce a value on top of the stack, such as ILOAD, LDC, SIPUSH, DUP, ICONST, etc.
PUTFIELD
PUTFIELD - Put field in object
PUTSTATIC
PUTSTATIC - Put static field in class
Record
Extends `Attribute` and records the classes and interfaces that are authorized to claim membership in the nest hosted by the current class or interface.
RecordComponentInfo
Record component info from a record.
ReferenceType
Super class for object and array types.
Repository
The repository maintains informations about class interdependencies, for example, whether a class is a sub-class of another.
Repository
Abstract definition of a class repository.
RET
RET - Return from subroutine
RETURN
RETURN - Return from void method
ReturnaddressType
Returnaddress, the type JSR or JSR_W instructions push upon the stack.
ReturnInstruction
Super class for the xRETURN family of instructions.
RuntimeInvisibleAnnotations
An annotation that is represented in the class file but is not provided to the JVM.
RuntimeInvisibleParameterAnnotations
Represents a parameter annotation that is represented in the class file but is not provided to the JVM.
RuntimeVisibleAnnotations
An annotation that is represented in the class file and is provided to the JVM.
RuntimeVisibleParameterAnnotations
Represents a parameter annotation that is represented in the class file and is provided to the JVM.
SALOAD
SALOAD - Load short from array
SASTORE
SASTORE - Store into short array
Select
Select - Abstract super class for LOOKUPSWITCH and TABLESWITCH instructions.
Signature
This class is derived from Attribute and represents a reference to a GJ attribute.
SimpleElementValue
SimpleElementValueGen
SIPUSH
SIPUSH - Push short
SourceFile
This class is derived from Attribute and represents a reference to the source file of this class.
StackConsumer
Denote an instruction that may consume a value from the stack.
StackInstruction
Super class for stack operations like DUP and POP.
StackMap
This class represents a stack map attribute used for preverification of Java classes for the Java 2 Micro Edition (J2ME).
StackMapEntry
This class represents a stack map entry recording the types of local variables and the of stack items at a given byte code offset.
StackMapType
This class represents the type of a local variable or item on stack used in the StackMap entries.
StackProducer
Denotes an instruction that may produce a value on top of the stack (this excludes DUP_X1, for example)
StaticCodeConstraintException
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.
StaticCodeInstructionConstraintException
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.
StaticCodeInstructionOperandConstraintException
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.
StoreInstruction
Denotes an unparameterized instruction to store a value into a local variable, for example ISTORE.
StringRepresentation
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.
StructuralCodeConstraintException
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.
Subroutine
This interface defines properties of JVM bytecode subroutines.
Subroutines
Instances of this class contain information about the subroutines found in a code array of a method.
SWAP
SWAP - Swa top operand stack word
SWITCH
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.
Synthetic
This class is derived from Attribute and declares this class as 'synthetic', i.e., it needs special handling.
SyntheticRepository
This repository is used in situations where a Class is created outside the realm of a ClassLoader.
TABLESWITCH
TABLESWITCH - Switch within given range of values, i.e., low..high
TargetLostException
Thrown by `InstructionList` when one or multiple disposed instructions are still being referenced by an `InstructionTargeter` object.
TransitiveHull
This class has a main method implementing a demonstration program of how to use the VerifierFactoryObserver.
Type
Abstract super class for all possible Java types, namely basic types such as int, object types like String and array types, for example int[]
TypedInstruction
Gets the type associated with an instruction, int for ILOAD, or the type of the field of a PUTFIELD instruction.
UnconditionalBranch
Denotes an instruction to perform an unconditional branch, i.e., GOTO, JSR.
UninitializedObjectType
This class represents an uninitialized object type; see The Java Virtual Machine Specification, Second Edition, page 147: 4.9.4 for more details.
Unknown
This class represents a reference to an unknown (i.e., application-specific) attribute of a class.
UnknownAttributeReader
Unknown (non-standard) attributes may be read via user-defined factory objects that can be registered with the Attribute.addAttributeReader method.
Utility
Utility functions that do not really belong to any class in particular.
Utility
A utility class providing convenience methods concerning Throwable instances.
VariableLengthInstruction
Denotes an instruction to be a variable length instruction, such as GOTO, JSR, LOOKUPSWITCH and TABLESWITCH.
VerificationException
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.
VerificationResult
A VerificationResult is what a PassVerifier returns after verifying.
Verifier
A Verifier instance is there to verify a class file according to The Java Virtual Machine Specification, 2nd Edition.
VerifierAppFrame
This class implements a machine-generated frame for use with the GraphicalVerfifier.
VerifierConstraintViolatedException
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.
VerifierFactory
This class produces instances of the Verifier class.
VerifierFactoryListModel
This class implements an adapter; it implements both a Swing ListModel and a VerifierFactoryObserver.
VerifierFactoryObserver
VerifierFactoryObserver instances are notified when new Verifier instances are created.
VerifyDialog
A class for simple graphical class file verification.
Visitor
Interface to make use of the Visitor pattern programming style.
Visitor
Interface implementing the Visitor pattern programming style.