98 lines
2.7 KiB
Go
Vendored
98 lines
2.7 KiB
Go
Vendored
// Copyright 2018 The Go Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSE file.
|
|
|
|
// +build !purego,!appengine
|
|
|
|
package protoreflect
|
|
|
|
import (
|
|
"unsafe"
|
|
|
|
"google.golang.org/protobuf/internal/pragma"
|
|
)
|
|
|
|
type (
|
|
stringHeader struct {
|
|
Data unsafe.Pointer
|
|
Len int
|
|
}
|
|
sliceHeader struct {
|
|
Data unsafe.Pointer
|
|
Len int
|
|
Cap int
|
|
}
|
|
ifaceHeader struct {
|
|
Type unsafe.Pointer
|
|
Data unsafe.Pointer
|
|
}
|
|
)
|
|
|
|
var (
|
|
nilType = typeOf(nil)
|
|
boolType = typeOf(*new(bool))
|
|
int32Type = typeOf(*new(int32))
|
|
int64Type = typeOf(*new(int64))
|
|
uint32Type = typeOf(*new(uint32))
|
|
uint64Type = typeOf(*new(uint64))
|
|
float32Type = typeOf(*new(float32))
|
|
float64Type = typeOf(*new(float64))
|
|
stringType = typeOf(*new(string))
|
|
bytesType = typeOf(*new([]byte))
|
|
enumType = typeOf(*new(EnumNumber))
|
|
)
|
|
|
|
// typeOf returns a pointer to the Go type information.
|
|
// The pointer is comparable and equal if and only if the types are identical.
|
|
func typeOf(t interface{}) unsafe.Pointer {
|
|
return (*ifaceHeader)(unsafe.Pointer(&t)).Type
|
|
}
|
|
|
|
// value is a union where only one type can be represented at a time.
|
|
// The struct is 24B large on 64-bit systems and requires the minimum storage
|
|
// necessary to represent each possible type.
|
|
//
|
|
// The Go GC needs to be able to scan variables containing pointers.
|
|
// As such, pointers and non-pointers cannot be intermixed.
|
|
type value struct {
|
|
pragma.DoNotCompare // 0B
|
|
|
|
// typ stores the type of the value as a pointer to the Go type.
|
|
typ unsafe.Pointer // 8B
|
|
|
|
// ptr stores the data pointer for a String, Bytes, or interface value.
|
|
ptr unsafe.Pointer // 8B
|
|
|
|
// num stores a Bool, Int32, Int64, Uint32, Uint64, Float32, Float64, or
|
|
// Enum value as a raw uint64.
|
|
//
|
|
// It is also used to store the length of a String or Bytes value;
|
|
// the capacity is ignored.
|
|
num uint64 // 8B
|
|
}
|
|
|
|
func valueOfString(v string) Value {
|
|
p := (*stringHeader)(unsafe.Pointer(&v))
|
|
return Value{typ: stringType, ptr: p.Data, num: uint64(len(v))}
|
|
}
|
|
func valueOfBytes(v []byte) Value {
|
|
p := (*sliceHeader)(unsafe.Pointer(&v))
|
|
return Value{typ: bytesType, ptr: p.Data, num: uint64(len(v))}
|
|
}
|
|
func valueOfIface(v interface{}) Value {
|
|
p := (*ifaceHeader)(unsafe.Pointer(&v))
|
|
return Value{typ: p.Type, ptr: p.Data}
|
|
}
|
|
|
|
func (v Value) getString() (x string) {
|
|
*(*stringHeader)(unsafe.Pointer(&x)) = stringHeader{Data: v.ptr, Len: int(v.num)}
|
|
return x
|
|
}
|
|
func (v Value) getBytes() (x []byte) {
|
|
*(*sliceHeader)(unsafe.Pointer(&x)) = sliceHeader{Data: v.ptr, Len: int(v.num), Cap: int(v.num)}
|
|
return x
|
|
}
|
|
func (v Value) getIface() (x interface{}) {
|
|
*(*ifaceHeader)(unsafe.Pointer(&x)) = ifaceHeader{Type: v.typ, Data: v.ptr}
|
|
return x
|
|
}
|