class

type Annotation struct {
	TypeIndex         uint16
	ElementValuePairs []*ElementValuePair
}

type AttrAccessFlag uint16

type AttrAnnotationDefault struct {
	*AttributeBase

	DefaultValue *ElementValue
}

type AttrBootstrapMethods struct {
	*AttributeBase

	BootstrapMethods []*BootstrapMethod
}

type AttrCode struct {
	*AttributeBase

	// Maximum depth of the operand stack of this method at any point during execution of the method.
	MaxStack uint16

	// The number of local variables in the local variable array allocated upon invocation of this method,
	//   including the local variables used to pass parameters to the method on its invocation.
	MaxLocals uint16

	// Actual bytes of Java Virtual Machine code that implement the method
	// If the method is either native or abstract, and is not a class or interface initialization method,
	//   then its Method structure must not have a Code attribute in its attributes table.
	//   Otherwise, its Method structure must have exactly one Code attribute in its attributes table.
	Code []byte

	// Each entry in the ExceptionTable array describes one exception handler in the code array.
	//   The order of the handlers in the ExceptionTable array is significant
	ExceptionTable []*Exception

	// Attributes related to AttrCode
	Attributes []Attribute
}

type AttrConstValue struct {
	*AttributeBase

	// indicate the index of the constant value
	// one of ConstantInteger, ConstantFloat, ConstantDouble, ConstantString, ConstantLong
	ConstantValueIndex uint16
}

type AttrDeprecated struct {
	*AttributeBase
}

type AttrEnclosingMethod struct {
	*AttributeBase

	// The value of the class_index item must be a valid index into the constant_pool table.
	ClassIndex uint16

	// The value of the method_index item must be a valid index into the constant_pool table
	MethodIndex uint16
}

type AttrExceptions struct {
	*AttributeBase

	// Each value in the exception_index_table array must be a valid index into the constant_pool table.
	// The constant_pool entry at that index must be a CONSTANT_Class_info structure (§4.4.1) representing
	//  a class type that this method is declared to throw.
	ExceptionIndexes []uint16
}

type AttrInnerClasses struct {
	*AttributeBase

	InnerClasses []*InnerClass
}

type AttrLineNumberTable struct {
	*AttributeBase

	Tables []*LineNumberTable
}

type AttrLocalVariableTable struct {
	*AttributeBase

	Tables []*LocalVariableTable
}

type AttrLocalVariableTypeTable struct {
	*AttributeBase

	Tables []*LocalVariableTypeTable
}

type AttrMethodParameters struct {
	*AttributeBase

	Parameters []*MethodParameter
}

type AttrModule struct {
	*AttributeBase

	ModuleName         uint16
	ModuleFlags        uint16
	ModuleVersionIndex uint16

	Requires  []*ModuleRequires
	Exports   []*ModuleExports
	Opens     []*ModuleOpens
	UsesIndex []uint16
	Provides  []*ModuleProvides
}

type AttrModuleMainClass struct {
	*AttributeBase

	MainClassIndex uint16
}

type AttrModulePackages struct {
	*AttributeBase

	PackageIndex []uint16
}

type AttrNestHost struct {
	*AttributeBase

	// The value of the host_class_index item must be a valid index into the constant_pool table.
	//  The constant_pool entry at that index must be a CONSTANT_Class_info structure (§4.4.1) representing a class or interface which is the nest host for the current class or interface.
	HostClassIndex uint16
}

type AttrNestMembers struct {
	*AttributeBase
	// contains filtered or unexported fields
}

type AttrPermittedSubclasses struct {
	*AttributeBase
	// contains filtered or unexported fields
}

type AttrRecord struct {
	*AttributeBase

	Components []*RecordComponentInfo
}

type AttrRuntimeInvisibleAnnotations struct {
	*AttributeBase

	Annotations []*Annotation
}

type AttrRuntimeInvisibleParameterAnnotations struct {
	*AttributeBase

	Parameters []*ParameterAnnotation
}

type AttrRuntimeInvisibleTypeAnnotations struct {
	*AttributeBase

	Annotations []*TypeAnnotation
}

type AttrRuntimeVisibleAnnotations struct {
	*AttributeBase

	Annotations []*Annotation
}

type AttrRuntimeVisibleParameterAnnotations struct {
	*AttributeBase

	Parameters []*ParameterAnnotation
}

type AttrRuntimeVisibleTypeAnnotations struct {
	*AttributeBase

	Annotations []*TypeAnnotation
}

type AttrSignature struct {
	*AttributeBase

	// The value of the SignatureIndex item must be a valid index into the constant_pool table.
	SignatureIndex uint16
}

type AttrSourceDebugExtension struct {
	*AttributeBase

	// The DebugExtension array holds extended debugging information which has no semantic effect on the Java Virtual Machine.
	DebugExtension []byte
}

type AttrSourceFile struct {
	*AttributeBase
	SourceFileIndex uint16 // indicate the name of the source file of the class
}

type AttrStackMapTable struct {
	*AttributeBase

	Data []byte
}

type AttrSynthetic struct {
	*AttributeBase
}

type Attribute interface {
	// contains filtered or unexported methods
}

type AttributeBase struct {
	AttributeNameIndex uint16
	AttributeLength    uint32
	// contains filtered or unexported fields
}

type BootstrapMethod struct {
	// The value of the bootstrap_method_ref item must be a valid index into the constant_pool table.
	//  The constant_pool entry at that index must be a CONSTANT_MethodHandle_info structure.
	BootstrapMethodRef uint16

	// Each entry in the bootstrap_arguments array must be a valid index into the constant_pool table.
	//  The constant_pool entry at that index must be loadable.
	BoostrapArguments []uint16
}

type CatchTarget struct {
	ExceptionTableIndex uint16
}

type ClassAccessFlag uint16

type ClassFile struct {
	MagicNumber         []byte
	MinorVersion        uint16
	MajorVersion        uint16
	ConstantPool        []Constant
	AccessFlag          ClassAccessFlag
	ThisClassIndex      uint16
	SuperClassIndex     uint16
	InterfaceIndexArray []uint16
	Fields              []*Field
	Methods             []*Method
	Attributes          []*Attribute
}

type Constant interface {
	ToBytes() []byte
}

type ConstantClass struct {
	NameIndex uint16
}

type ConstantDouble struct {
	Double float64
}

type ConstantDynamic struct {
	BootstrapMethodIndex uint16 // a reference to the BootstrapMethod in ClassFile.Attributes
	NameAndTypeIndex     uint16
}

type ConstantFieldRef struct {
	ClassIndex       uint16
	NameAndTypeIndex uint16
}

type ConstantFloat struct {
	Float float32
}

type ConstantInteger struct {
	Integer int32
}

type ConstantInterfaceMethodRef struct {
	ClassIndex       uint16
	NameAndTypeIndex uint16
}

type ConstantInvokeDynamic struct {
	BootstrapMethodIndex uint16 // a reference to the BootstrapMethod in ClassFile.Attributes
	NameAndTypeIndex     uint16
}

type ConstantLong struct {
	Long int64
}

type ConstantMethodHandle struct {
	ReferenceKind  byte
	ReferenceIndex uint16
}

type ConstantMethodRef struct {
	ClassIndex       uint16
	NameAndTypeIndex uint16
}

type ConstantMethodType struct {
	DescriptorIndex uint16
}

type ConstantModule struct {
	NameIndex uint16
}

type ConstantNameAndType struct {
	NameIndex       uint16
	DescriptorIndex uint16
}

type ConstantPackage struct {
	NameIndex uint16
}

type ConstantString struct {
	StringIndex uint16
}

type ConstantUTF8 struct {
	Data string
}

type ElementValue struct {
	Tag byte

	ConstValueIndex uint16
	EnumConstValue  *EnumConstValue
	ClassInfoIndex  uint16
	AnnotationValue *Annotation
	ArrayValue      []*ElementValue
}

type ElementValuePair struct {
	ElementNameIndex uint16
	Value            *ElementValue
}

type EmptyTarget struct {
}

type EnumConstValue struct {
	TypeNameIndex  uint16
	ConstNameIndex uint16
}

type Exception struct {
	// The values of the two items StartPC and EndPC indicate the ranges
	//    in the code array at which the exception handler is active.
	StartPC uint16
	EndPC   uint16

	// The value of the HandlerPC item indicates the start of the exception handler.
	HandlerPC uint16

	// If the value of the CatchType item is nonzero, it must be a valid index into the constant pool table.
	// If the value of the CatchType item is zero, this exception handler is called for all exceptions.
	CatchType uint16
}

type Field struct {
	AccessFlag      AttrAccessFlag
	NameIndex       uint16
	DescriptorIndex uint16
	Attributes      []Attribute
}

type FormalParameterTarget struct {
	FormalParameterIndex uint8
}

type InnerClass struct {
	// The value of the InnerClassInfo item must be a valid index into the constant_pool table.
	InnerClassInfo uint16

	// The value of the InnerClassIndex item must be a valid index into the constant_pool table
	OuterClassInfo uint16

	// The value of the InnerClassIndex item must be a valid index into the constant_pool table
	InnerClassIndex uint16

	// The value of the InnerClassAccessFlags item is a mask of flags used to denote access permissions to
	//  and properties of class or interface C as declared in the source code from which this class file was compiled.
	InnerClassAccessFlags ClassAccessFlag
}

type LineNumberTable struct {
	// The value of the StartPC item must be a valid index into the code array of this AttrCode attribute.
	StartPC uint16

	// The value of the LineNumber item gives the corresponding line number in the original source file.
	LineNumber uint16
}

type LocalVarTarget struct {
	Table []*LocalVarTargetTable
}

type LocalVarTargetTable struct {
	StartPC uint16
	Length  uint16
	Index   uint16
}

type LocalVariableTable struct {
	StartPC         uint16
	Length          uint16
	NameIndex       uint16
	DescriptorIndex uint16
	Index           uint16
}

type LocalVariableTypeTable struct {
	StartPC        uint16
	Length         uint16
	NameIndex      uint16
	SignatureIndex uint16
	Index          uint16
}

type Method struct {
}

type MethodParameter struct {
	NameIndex   uint16
	AccessFlags ParameterAccessFlag
}

type ModuleExports struct {
	ExportsIndex   uint16
	ExportsFlags   uint16
	ExportsToIndex []uint16
}

type ModuleOpens struct {
	OpensIndex   uint16
	OpensFlags   uint16
	OpensToIndex []uint16
}

type ModuleProvides struct {
	ProvidesIndex     uint16
	ProvidesWithIndex []uint16
}

type ModuleRequires struct {
	RequiresIndex        uint16
	RequiresFlags        uint16
	RequiresVersionIndex uint16
}

type OffsetTarget struct {
	Offset uint16
}

type ParameterAccessFlag uint16

type ParameterAnnotation struct {
	Annotations []*Annotation
}

type RecordComponentInfo struct {
	// The value of the name_index item must be a valid index into the constant_pool table.
	//  The constant_pool entry at that index must be a CONSTANT_Utf8_info structure (§4.4.7) representing a valid unqualified name denoting the record component (§4.2.2).
	NameIndex uint16

	// The value of the descriptor_index item must be a valid index into the constant_pool table.
	//  The constant_pool entry at that index must be a CONSTANT_Utf8_info structure (§4.4.7) representing a field descriptor which encodes the type of the record component (§4.3.2).
	DescriptorIndex uint16

	// Each value of the attributes table must be an attribute_info structure (§4.7).
	Attributes []Attribute
}

type SuperTypeTarget struct {
	SuperTypeIndex uint16
}

type ThrowsTarget struct {
	ThrowsTypeIndex uint16
}

type TypeAnnotation struct {
	TargetType               uint8
	TypeParameterTarget      *TypeParameterTarget
	SuperTypeTarget          *SuperTypeTarget
	TypeParameterBoundTarget *TypeParameterBoundTarget
	EmptyTarget              *EmptyTarget
	FormalParameterTarget    *FormalParameterTarget
	ThrowsTarget             *ThrowsTarget
	LocalVarTarget           *LocalVarTarget
	CatchTarget              *CatchTarget
	OffsetTarget             *OffsetTarget
	TypeArgumentTarget       *TypeArgumentTarget

	TargetPath *TypePath

	// same as Annotation
	TypeIndex         uint16
	ElementValuePairs []*ElementValuePair
}

type TypeArgumentTarget struct {
	Offset            uint16
	TypeArgumentIndex uint8
}

type TypeParameterBoundTarget struct {
	TypeParameterIndex uint8
	BoundIndex         uint8
}

type TypeParameterTarget struct {
	TypeParameterIndex uint8
}

type TypePath struct {
	Path []*TypePathNode
}

type TypePathNode struct {
	TypePathKind      uint8
	TypeArgumentIndex uint8
}