## Uses of Class
org.apache.bcel.generic.Type

Packages that use Type
org.apache.bcel.classfile: This package contains the classes that describe the structure of a Java class file and a class file parser.
org.apache.bcel.generic: This package contains the "generic" part of the Byte Code Engineering Library, i.e., classes to dynamically modify class objects and byte code instructions.
org.apache.bcel.verifier.statics: Provides PassVerifier classes used internally by JustIce.
org.apache.bcel.verifier.structurals: Provides a PassVerifier class mostly used internally by JustIce, yielding a control flow graph for public use as a nice side effect.

Uses of Type in org.apache.bcel.classfile

Methods in org.apache.bcel.classfile that return Type
`Type[]` `Method.getArgumentTypes()`
`Type` `Method.getReturnType()`
`Type` `Field.getType()`

Uses of Type in org.apache.bcel.generic

Subclasses of Type in org.apache.bcel.generic
`class` `ArrayType` Denotes array type, such as int[][]
`class` `BasicType` Denotes basic type such as int.
`class` `ObjectType` Denotes reference such as java.lang.String.
`class` `ReferenceType` Super class for object and array types.
`class` `ReturnaddressType` Returnaddress, the type JSR or JSR_W instructions push upon the stack.

Fields in org.apache.bcel.generic declared as Type
`static Type[]` `Type.NO_ARGS`
`protected Type` `FieldGenOrMethodGen.type`
`static Type` `Type.UNKNOWN`

Methods in org.apache.bcel.generic that return Type
`Type` `MethodGen.getArgumentType(int i)`
`Type[]` `MethodGen.getArgumentTypes()`
`Type[]` `InvokeInstruction.getArgumentTypes(ConstantPoolGen cpg)`
`static Type[]` `Type.getArgumentTypes(String signature)` Convert arguments of a method (signature) to an array of Type objects.
`Type` `ArrayType.getBasicType()`
`Type` `ArrayType.getElementType()`
`Type` `FieldInstruction.getFieldType(ConstantPoolGen cpg)`
`Type` `MethodGen.getReturnType()`
`Type` `InvokeInstruction.getReturnType(ConstantPoolGen cpg)`
`static Type` `Type.getReturnType(String signature)` Convert return value of a method (signature) to a Type object.
`Type` `ReturnInstruction.getType()`
`Type` `NEWARRAY.getType()`
`Type` `NamedAndTyped.getType()`
`Type` `LocalVariableGen.getType()`
`Type` `FieldGenOrMethodGen.getType()`
`static Type` `Type.getType(Class cl)` Convert runtime java.lang.Class to BCEL Type object.
`Type` `TypedInstruction.getType(ConstantPoolGen cpg)`
`Type` `StackInstruction.getType(ConstantPoolGen cp)`
`Type` `SIPUSH.getType(ConstantPoolGen cp)`
`Type` `ReturnInstruction.getType(ConstantPoolGen cp)`
`Type` `RET.getType(ConstantPoolGen cp)`
`Type` `LocalVariableInstruction.getType(ConstantPoolGen cp)` Returns the type associated with the instruction - in case of ALOAD or ASTORE Type.OBJECT is returned.
`Type` `LoadClass.getType(ConstantPoolGen cpg)` Returns the type associated with this instruction.
`Type` `LDC2_W.getType(ConstantPoolGen cpg)`
`Type` `LDC.getType(ConstantPoolGen cpg)`
`Type` `LCONST.getType(ConstantPoolGen cp)`
`Type` `LCMP.getType(ConstantPoolGen cp)`
`Type` `JsrInstruction.getType(ConstantPoolGen cp)`
`Type` `InvokeInstruction.getType(ConstantPoolGen cpg)`
`Type` `IINC.getType(ConstantPoolGen cp)`
`Type` `ICONST.getType(ConstantPoolGen cp)`
`Type` `FieldInstruction.getType(ConstantPoolGen cpg)`
`Type` `FCONST.getType(ConstantPoolGen cp)`
`Type` `FCMPL.getType(ConstantPoolGen cp)`
`Type` `FCMPG.getType(ConstantPoolGen cp)`
`Type` `DCONST.getType(ConstantPoolGen cp)`
`Type` `DCMPL.getType(ConstantPoolGen cp)`
`Type` `DCMPG.getType(ConstantPoolGen cp)`
`Type` `CPInstruction.getType(ConstantPoolGen cpg)`
`Type` `ConversionInstruction.getType(ConstantPoolGen cp)`
`Type` `BIPUSH.getType(ConstantPoolGen cp)`
`Type` `ArrayInstruction.getType(ConstantPoolGen cp)`
`Type` `ArithmeticInstruction.getType(ConstantPoolGen cp)`
`Type` `ACONST_NULL.getType(ConstantPoolGen cp)`
`static Type` `Type.getType(String signature)` Convert signature to a Type object.
`static Type[]` `Type.getTypes(Class[] classes)` Convert runtime java.lang.Class[] to BCEL Type objects.

Methods in org.apache.bcel.generic with parameters of type Type
`LocalVariableGen` `MethodGen.addLocalVariable(String name, Type type, InstructionHandle start, InstructionHandle end)` Adds a local variable to this method and assigns an index automatically.
`LocalVariableGen` `MethodGen.addLocalVariable(String name, Type type, int slot, InstructionHandle start, InstructionHandle end)` Adds a local variable to this method.
`Instruction` `InstructionFactory.createAppend(Type type)`
`static ArrayInstruction` `InstructionFactory.createArrayLoad(Type type)`
`static ArrayInstruction` `InstructionFactory.createArrayStore(Type type)`
`static ArithmeticInstruction` `InstructionFactory.createBinaryOperation(String op, Type type)` Create binary operation for simple basic types, such as int and float.
`Instruction` `InstructionFactory.createCast(Type src_type, Type dest_type)` Create conversion operation for two stack operands, this may be an I2C, instruction, e.g., if the operands are basic types and CHECKCAST if they are reference types.
`FieldInstruction` `InstructionFactory.createFieldAccess(String class_name, String name, Type type, short kind)` Create a field instruction.
`GETFIELD` `InstructionFactory.createGetField(String class_name, String name, Type t)`
`GETSTATIC` `InstructionFactory.createGetStatic(String class_name, String name, Type t)`
`InvokeInstruction` `InstructionFactory.createInvoke(String class_name, String name, Type ret_type, Type[] arg_types, short kind)` Create an invoke instruction.
`InvokeInstruction` `InstructionFactory.createInvoke(String class_name, String name, Type ret_type, Type[] arg_types, short kind)` Create an invoke instruction.
`static LocalVariableInstruction` `InstructionFactory.createLoad(Type type, int index)`
`Instruction` `InstructionFactory.createNewArray(Type t, short dim)` Create new array of given size and type.
`static Instruction` `InstructionFactory.createNull(Type type)` Create "null" value for reference types, 0 for basic types like int
`PUTFIELD` `InstructionFactory.createPutField(String class_name, String name, Type t)`
`PUTSTATIC` `InstructionFactory.createPutStatic(String class_name, String name, Type t)`
`static ReturnInstruction` `InstructionFactory.createReturn(Type type)` Create typed return
`static LocalVariableInstruction` `InstructionFactory.createStore(Type type, int index)`
`static String` `Type.getMethodSignature(Type return_type, Type[] arg_types)` Convert type to Java method signature, e.g.
`static String` `Type.getMethodSignature(Type return_type, Type[] arg_types)` Convert type to Java method signature, e.g.
`boolean` `ReferenceType.isAssignmentCompatibleWith(Type t)` Return true iff this is assignment compatible with another type t as defined in the JVM specification; see the AASTORE definition there.
`boolean` `ReferenceType.isCastableTo(Type t)` Return true iff this type is castable to another type t as defined in the JVM specification.
`void` `MethodGen.setArgumentType(int i, Type type)`
`void` `MethodGen.setArgumentTypes(Type[] arg_types)`
`void` `MethodGen.setReturnType(Type return_type)`
`void` `NamedAndTyped.setType(Type type)`
`void` `LocalVariableGen.setType(Type type)`
`void` `FieldGenOrMethodGen.setType(Type type)`

Constructors in org.apache.bcel.generic with parameters of type Type
`ArrayType(Type type, int dimensions)` Constructor for array of given type
`FieldGen(int access_flags, Type type, String name, ConstantPoolGen cp)` Declare a field.
`LocalVariableGen(int index, String name, Type type, InstructionHandle start, InstructionHandle end)` Generate a local variable that with index `index'.
`MethodGen(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name, String class_name, InstructionList il, ConstantPoolGen cp)` Declare method.
`MethodGen(int access_flags, Type return_type, Type[] arg_types, String[] arg_names, String method_name, String class_name, InstructionList il, ConstantPoolGen cp)` Declare method.

Uses of Type in org.apache.bcel.verifier.statics

Subclasses of Type in org.apache.bcel.verifier.statics
`class` `DOUBLE_Upper` This class represents the upper half of a DOUBLE variable.
`class` `LONG_Upper` This class represents the upper half of a LONG variable.

Methods in org.apache.bcel.verifier.statics that return Type
`Type` `LocalVariableInfo.getType(int offset)` Returns the type of the local variable that uses this local variable slot at the given bytecode offset.

Methods in org.apache.bcel.verifier.statics with parameters of type Type
`void` `LocalVariablesInfo.add(int slot, String name, int startpc, int length, Type t)` Adds information about the local variable in slot 'slot'.
`void` `LocalVariableInfo.add(String name, int startpc, int length, Type t)` Adds some information about this local variable (slot).

Uses of Type in org.apache.bcel.verifier.structurals

Subclasses of Type in org.apache.bcel.verifier.structurals
`class` `UninitializedObjectType` This class represents an uninitialized object type; see The Java Virtual Machine Specification, Second Edition, page 147: 4.9.4 for more details.

Methods in org.apache.bcel.verifier.structurals that return Type
`Type` `LocalVariables.get(int i)` Returns the type of the local variable slot i.
`Type` `OperandStack.peek()` Returns the element on top of the stack.
`Type` `OperandStack.peek(int i)` Returns the element that's i elements below the top element; that means, iff i==0 the top element is returned.
`Type` `OperandStack.pop()` Returns the element on top of the stack.
`Type` `OperandStack.pop(int i)` Pops i elements off the stack.

Methods in org.apache.bcel.verifier.structurals with parameters of type Type
`void` `OperandStack.push(Type type)` Pushes a Type object onto the stack.
`void` `LocalVariables.set(int i, Type type)` Sets a new Type for the given local variable slot.

Copyright © 2002-2006 Apache Software Foundation. All Rights Reserved.