1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
package vm
import "reflect"
// Runtime type and value representations (based on reflect).
// Type is the representation of a runtime type.
type Type struct {
PkgPath string
Name string
Rtype reflect.Type
}
func (t *Type) String() string {
if t.Name != "" {
if t.PkgPath != "" {
return t.PkgPath + "." + t.Name
}
return t.Name
}
return t.Rtype.String()
}
// Elem returns a type's element type.
func (t *Type) Elem() *Type {
return &Type{Rtype: t.Rtype.Elem()}
}
// Out returns the type's i'th output parameter.
func (t *Type) Out(i int) *Type {
return &Type{Rtype: t.Rtype.Out(i)}
}
// Value is the representation of a runtime value.
type Value struct {
*Type
reflect.Value
}
// NewValue returns an addressable zero value for the specified type.
func NewValue(typ *Type) Value {
if typ.Rtype.Kind() == reflect.Func {
typ = TypeOf(0) // Function value is its index in the code segment.
}
return Value{Type: typ, Value: reflect.New(typ.Rtype).Elem()}
}
// TypeOf returns the runtime type of v.
func TypeOf(v any) *Type {
t := reflect.TypeOf(v)
return &Type{Name: t.Name(), Rtype: t}
}
// ValueOf returns the runtime value of v.
func ValueOf(v any) Value {
return Value{Value: reflect.ValueOf(v)}
}
// PointerTo returns the pointer type with element t.
func PointerTo(t *Type) *Type {
return &Type{Rtype: reflect.PointerTo(t.Rtype)}
}
// ArrayOf returns the array type with the given length and element type.
func ArrayOf(length int, t *Type) *Type {
return &Type{Rtype: reflect.ArrayOf(length, t.Rtype)}
}
// SliceOf returns the slice type with the given element type.
func SliceOf(t *Type) *Type {
return &Type{Rtype: reflect.SliceOf(t.Rtype)}
}
// FuncOf returns the function type with the given argument and result types.
func FuncOf(arg, ret []*Type, variadic bool) *Type {
a := make([]reflect.Type, len(arg))
for i, e := range arg {
a[i] = e.Rtype
}
r := make([]reflect.Type, len(ret))
for i, e := range ret {
r[i] = e.Rtype
}
return &Type{Rtype: reflect.FuncOf(a, r, variadic)}
}
// StructOf returns the struct type with the given field types.
func StructOf(fields []*Type) *Type {
rf := make([]reflect.StructField, len(fields))
for i, f := range fields {
rf[i].Name = f.Name
rf[i].PkgPath = f.PkgPath
rf[i].Type = f.Rtype
}
return &Type{Rtype: reflect.StructOf(rf)}
}
// FieldNameIndex returns the index of struct field name.
func (t *Type) FieldNameIndex(name string) []int {
for _, f := range reflect.VisibleFields(t.Rtype) {
if f.Name == name {
return f.Index
}
}
return nil
}
|
