reflect

type ArrayType struct {
	Type
	Elem  *Type // array element type
	Slice *Type // Slice type
	Len   uintptr
}

type ChanType struct {
	Type
	Elem *Type   // channel element type
	Dir  uintptr // channel direction (ChanDir)
}

type Eface struct {
	Type  *Type
	Value unsafe.Pointer
}

type Flag uintptr

type Func struct {
	Entry   uintptr // start pc
	Nameoff int32   // function name

	Args        int32  // in/out args size
	Deferreturn uint32 // offset of start of a deferreturn call instruction from entry, if any.

	Pcsp     uint32
	Pcfile   uint32
	Pcln     uint32
	Npcdata  uint32
	CuOffset uint32 // runtime.cutab offset of this function's CU
	FuncID   FuncID // set for certain special runtime functions

	Nfuncdata uint8 // must be last
	// contains filtered or unexported fields
}

type FuncID uint8

type FuncType struct {
	Type
	InCount  uint16
	OutCount uint16 // top bit is set if last input parameter is ...
}

type IMethod struct {
	Name NameOff // name of method
	Typ  TypeOff // .(*FuncType) underneath
}

type Iface struct {
	Itab  *Itab
	Value unsafe.Pointer
}

type InterfaceType struct {
	Type
	PkgPath *byte     // import path
	Methods []IMethod // sorted by hash
}

type Itab struct {
	Inter  *InterfaceType
	Type   *Type
	Hash   uint32 // copy of _type.hash. Used for type switches.
	Unused [4]byte
	Fun    [1]uintptr // variable sized
}

type KindHandler [reflect.UnsafePointer + 1][]ValueRecursionHandler

type Map struct {
	Count      int
	Flags      uint8
	B          uint8
	Overflow   uint16
	Hash0      uint32
	Buckets    unsafe.Pointer
	OldBuckets unsafe.Pointer
	Evacuate   uintptr
	Extra      unsafe.Pointer
}

type MapIterator struct {
	K           unsafe.Pointer
	V           unsafe.Pointer
	T           *MapType
	H           *Map
	Buckets     unsafe.Pointer
	Bptr        *unsafe.Pointer
	Overflow    *[]unsafe.Pointer
	OldOverflow *[]unsafe.Pointer
	StartBucket uintptr
	Offset      uint8
	Wrapped     bool
	B           uint8
	I           uint8
	Bucket      uintptr
	CheckBucket uintptr
}

type MapType struct {
	Type
	Key    *Type // map key type
	Elem   *Type // map element (value) type
	Bucket *Type // internal bucket structure
	// function for hashing keys (ptr to key, seed) -> hash
	Hasher     func(unsafe.Pointer, uintptr) uintptr
	KeySize    uint8  // size of key slot
	ValueSize  uint8  // size of value slot
	BucketSize uint16 // size of bucket
	Flags      uint32
}

type NameOff int32 // offset to a name

type PtrType struct {
	Type
	Elem *Type // pointer element (pointed at) type
}

type Slice struct {
	Ptr unsafe.Pointer
	Len int
	Cap int
}

type SliceType struct {
	Type
	Elem *Type // Slice element type
}

type String struct {
	Ptr unsafe.Pointer
	Len int
}

type StructField struct {
	Name        *byte   // name is always non-empty
	Typ         *Type   // type of field
	OffsetEmbed uintptr // byte offset of field<<1 | isEmbedded
}

type StructType struct {
	Type
	PkgPath *byte
	Fields  []StructField // sorted by offset
}

type TextOff int32 // offset from top of text section

type Type struct {
	Size       uintptr
	Ptrdata    uintptr // number of bytes in the type that can contain pointers
	Hash       uint32  // hash of type; avoids computation in hash tables
	Flags      uint8   // extra type information flags
	Align      uint8   // alignment of variable with this type
	FieldAlign uint8   // alignment of struct field with this type
	KindFlags  uint8   // enumeration for C
	// function for comparing objects of this type
	// (ptr to object A, ptr to object B) -> ==?
	Equal func(unsafe.Pointer, unsafe.Pointer) bool
	// gcdata stores the GC type data for the garbage collector.
	// If the KindGCProg bit is set in kind, gcdata is a GC program.
	// Otherwise it is a ptrmask bitmap. See mbitmap.go for details.
	Gcdata    *byte   // garbage collection data
	Str       NameOff // string form
	PtrToThis TypeOff // type for pointer to this type, may be zero
}

type TypeOff int32 // offset to an *Rtype

type Value struct {
	Typ *Type
	Ptr unsafe.Pointer
	Flag
}

type ValueHandler func(reflect.Value)

type ValueRecursionHandler func(reflect.Value, ValueHandler)