All Classes and Interfaces

Class	Description
AALOAD	AALOAD - Load reference from array
AASTORE	AASTORE - Store into reference array
AbstractClassPathRepository	This abstract class provides a logic of a loading JavaClass objects class names via ClassPath.
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.
AttributeHTML	Convert found attributes into HTML file.
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.
BCELFactory	Factory creates il.append() statements, and sets instruction targets.
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, etc..
BREAKPOINT	BREAKPOINT, JVM dependent, ignored by default
ByteSequence	Utility class that implements a sequence of bytes which can be read via the 'readByte()' method.
ByteSequence.ByteArrayStream
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.AbstractPathEntry
ClassPath.AbstractZip
ClassPath.ClassFile	Contains information about file/ZIP entry of the Java class.
ClassPath.Dir
ClassPath.Jar
ClassPath.JrtModule
ClassPath.JrtModules
ClassPath.Module
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.
CodeHTML	Convert code into HTML file.
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.
ConstantHTML	Convert constant pool into HTML file.
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, etc..
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.
ConstantUtf8.Cache
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, e.g.
EmptyVisitor	Supplies empty method bodies to be overridden by subclasses.
EnclosingMethod	This attribute exists for local or anonymous classes and ...
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, e.g.
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.
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, e.g., to generate typed versions of instructions.
InstructionFactory.MethodObject
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	Denote 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.
LoadInstruction	Denotes an unparameterized instruction to load a value from a local variable, e.g.
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.
MethodGen.BranchStack
MethodGen.BranchTarget
MethodHTML	Convert methods and fields into HTML file.
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.
Pass2Verifier.InnerClassDetector	This class serves for finding out if a given JavaClass' ConstantPool references an Inner Class.
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.
Pass3bVerifier.InstructionContextQueue	An InstructionContextQueue is a utility class that holds (InstructionContext, ArrayList) pairs in a Queue data structure.
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
ReferenceType	Super class for object and array types.
Repository	The repository maintains informations about class interdependencies, e.g., 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	represents 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	represents 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.
Signature.MyByteArrayInputStream	Extends ByteArrayInputStream to make 'unreading' chars possible.
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, e.g.)
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, e.g.
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.
Subroutines.ColourConstants
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.remove() 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, e.g.
TypedInstruction	Gets the type associated with an instruction, int for ILOAD, or the type of the field of a PUTFIELD instruction, e.g..
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.
Utility.JavaReader	Decode characters into bytes.
Utility.JavaWriter	Encode bytes into valid Java identifier characters.
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.