podman

1
// Copyright 2018 The Go Authors. All rights reserved.
2
// Use of this source code is governed by a BSD-style
3
// license that can be found in the LICENSE file.
4

5
//go:build purego || appengine
6
// +build purego appengine
7

8
package impl
9

10
import (
11
	"fmt"
12
	"reflect"
13
	"sync"
14
)
15

16
const UnsafeEnabled = false
17

18
// Pointer is an opaque pointer type.
19
type Pointer interface{}
20

21
// offset represents the offset to a struct field, accessible from a pointer.
22
// The offset is the field index into a struct.
23
type offset struct {
24
	index  int
25
	export exporter
26
}
27

28
// offsetOf returns a field offset for the struct field.
29
func offsetOf(f reflect.StructField, x exporter) offset {
30
	if len(f.Index) != 1 {
31
		panic("embedded structs are not supported")
32
	}
33
	if f.PkgPath == "" {
34
		return offset{index: f.Index[0]} // field is already exported
35
	}
36
	if x == nil {
37
		panic("exporter must be provided for unexported field")
38
	}
39
	return offset{index: f.Index[0], export: x}
40
}
41

42
// IsValid reports whether the offset is valid.
43
func (f offset) IsValid() bool { return f.index >= 0 }
44

45
// invalidOffset is an invalid field offset.
46
var invalidOffset = offset{index: -1}
47

48
// zeroOffset is a noop when calling pointer.Apply.
49
var zeroOffset = offset{index: 0}
50

51
// pointer is an abstract representation of a pointer to a struct or field.
52
type pointer struct{ v reflect.Value }
53

54
// pointerOf returns p as a pointer.
55
func pointerOf(p Pointer) pointer {
56
	return pointerOfIface(p)
57
}
58

59
// pointerOfValue returns v as a pointer.
60
func pointerOfValue(v reflect.Value) pointer {
61
	return pointer{v: v}
62
}
63

64
// pointerOfIface returns the pointer portion of an interface.
65
func pointerOfIface(v interface{}) pointer {
66
	return pointer{v: reflect.ValueOf(v)}
67
}
68

69
// IsNil reports whether the pointer is nil.
70
func (p pointer) IsNil() bool {
71
	return p.v.IsNil()
72
}
73

74
// Apply adds an offset to the pointer to derive a new pointer
75
// to a specified field. The current pointer must be pointing at a struct.
76
func (p pointer) Apply(f offset) pointer {
77
	if f.export != nil {
78
		if v := reflect.ValueOf(f.export(p.v.Interface(), f.index)); v.IsValid() {
79
			return pointer{v: v}
80
		}
81
	}
82
	return pointer{v: p.v.Elem().Field(f.index).Addr()}
83
}
84

85
// AsValueOf treats p as a pointer to an object of type t and returns the value.
86
// It is equivalent to reflect.ValueOf(p.AsIfaceOf(t))
87
func (p pointer) AsValueOf(t reflect.Type) reflect.Value {
88
	if got := p.v.Type().Elem(); got != t {
89
		panic(fmt.Sprintf("invalid type: got %v, want %v", got, t))
90
	}
91
	return p.v
92
}
93

94
// AsIfaceOf treats p as a pointer to an object of type t and returns the value.
95
// It is equivalent to p.AsValueOf(t).Interface()
96
func (p pointer) AsIfaceOf(t reflect.Type) interface{} {
97
	return p.AsValueOf(t).Interface()
98
}
99

100
func (p pointer) Bool() *bool              { return p.v.Interface().(*bool) }
101
func (p pointer) BoolPtr() **bool          { return p.v.Interface().(**bool) }
102
func (p pointer) BoolSlice() *[]bool       { return p.v.Interface().(*[]bool) }
103
func (p pointer) Int32() *int32            { return p.v.Interface().(*int32) }
104
func (p pointer) Int32Ptr() **int32        { return p.v.Interface().(**int32) }
105
func (p pointer) Int32Slice() *[]int32     { return p.v.Interface().(*[]int32) }
106
func (p pointer) Int64() *int64            { return p.v.Interface().(*int64) }
107
func (p pointer) Int64Ptr() **int64        { return p.v.Interface().(**int64) }
108
func (p pointer) Int64Slice() *[]int64     { return p.v.Interface().(*[]int64) }
109
func (p pointer) Uint32() *uint32          { return p.v.Interface().(*uint32) }
110
func (p pointer) Uint32Ptr() **uint32      { return p.v.Interface().(**uint32) }
111
func (p pointer) Uint32Slice() *[]uint32   { return p.v.Interface().(*[]uint32) }
112
func (p pointer) Uint64() *uint64          { return p.v.Interface().(*uint64) }
113
func (p pointer) Uint64Ptr() **uint64      { return p.v.Interface().(**uint64) }
114
func (p pointer) Uint64Slice() *[]uint64   { return p.v.Interface().(*[]uint64) }
115
func (p pointer) Float32() *float32        { return p.v.Interface().(*float32) }
116
func (p pointer) Float32Ptr() **float32    { return p.v.Interface().(**float32) }
117
func (p pointer) Float32Slice() *[]float32 { return p.v.Interface().(*[]float32) }
118
func (p pointer) Float64() *float64        { return p.v.Interface().(*float64) }
119
func (p pointer) Float64Ptr() **float64    { return p.v.Interface().(**float64) }
120
func (p pointer) Float64Slice() *[]float64 { return p.v.Interface().(*[]float64) }
121
func (p pointer) String() *string          { return p.v.Interface().(*string) }
122
func (p pointer) StringPtr() **string      { return p.v.Interface().(**string) }
123
func (p pointer) StringSlice() *[]string   { return p.v.Interface().(*[]string) }
124
func (p pointer) Bytes() *[]byte           { return p.v.Interface().(*[]byte) }
125
func (p pointer) BytesPtr() **[]byte       { return p.v.Interface().(**[]byte) }
126
func (p pointer) BytesSlice() *[][]byte    { return p.v.Interface().(*[][]byte) }
127
func (p pointer) WeakFields() *weakFields  { return (*weakFields)(p.v.Interface().(*WeakFields)) }
128
func (p pointer) Extensions() *map[int32]ExtensionField {
129
	return p.v.Interface().(*map[int32]ExtensionField)
130
}
131

132
func (p pointer) Elem() pointer {
133
	return pointer{v: p.v.Elem()}
134
}
135

136
// PointerSlice copies []*T from p as a new []pointer.
137
// This behavior differs from the implementation in pointer_unsafe.go.
138
func (p pointer) PointerSlice() []pointer {
139
	// TODO: reconsider this
140
	if p.v.IsNil() {
141
		return nil
142
	}
143
	n := p.v.Elem().Len()
144
	s := make([]pointer, n)
145
	for i := 0; i < n; i++ {
146
		s[i] = pointer{v: p.v.Elem().Index(i)}
147
	}
148
	return s
149
}
150

151
// AppendPointerSlice appends v to p, which must be a []*T.
152
func (p pointer) AppendPointerSlice(v pointer) {
153
	sp := p.v.Elem()
154
	sp.Set(reflect.Append(sp, v.v))
155
}
156

157
// SetPointer sets *p to v.
158
func (p pointer) SetPointer(v pointer) {
159
	p.v.Elem().Set(v.v)
160
}
161

162
func growSlice(p pointer, addCap int) {
163
	// TODO: Once we only support Go 1.20 and newer, use reflect.Grow.
164
	in := p.v.Elem()
165
	out := reflect.MakeSlice(in.Type(), in.Len(), in.Len()+addCap)
166
	reflect.Copy(out, in)
167
	p.v.Elem().Set(out)
168
}
169

170
func (p pointer) growBoolSlice(addCap int) {
171
	growSlice(p, addCap)
172
}
173

174
func (p pointer) growInt32Slice(addCap int) {
175
	growSlice(p, addCap)
176
}
177

178
func (p pointer) growUint32Slice(addCap int) {
179
	growSlice(p, addCap)
180
}
181

182
func (p pointer) growInt64Slice(addCap int) {
183
	growSlice(p, addCap)
184
}
185

186
func (p pointer) growUint64Slice(addCap int) {
187
	growSlice(p, addCap)
188
}
189

190
func (p pointer) growFloat64Slice(addCap int) {
191
	growSlice(p, addCap)
192
}
193

194
func (p pointer) growFloat32Slice(addCap int) {
195
	growSlice(p, addCap)
196
}
197

198
func (Export) MessageStateOf(p Pointer) *messageState     { panic("not supported") }
199
func (ms *messageState) pointer() pointer                 { panic("not supported") }
200
func (ms *messageState) messageInfo() *MessageInfo        { panic("not supported") }
201
func (ms *messageState) LoadMessageInfo() *MessageInfo    { panic("not supported") }
202
func (ms *messageState) StoreMessageInfo(mi *MessageInfo) { panic("not supported") }
203

204
type atomicNilMessage struct {
205
	once sync.Once
206
	m    messageReflectWrapper
207
}
208

209
func (m *atomicNilMessage) Init(mi *MessageInfo) *messageReflectWrapper {
210
	m.once.Do(func() {
211
		m.m.p = pointerOfIface(reflect.Zero(mi.GoReflectType).Interface())
212
		m.m.mi = mi
213
	})
214
	return &m.m
215
}
216