patch reflect
This commit is contained in:
xushiwei
@@ -21,6 +21,7 @@
|
||||
package reflect
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"unsafe"
|
||||
|
||||
"github.com/goplus/llgo/internal/abi"
|
||||
@@ -357,6 +358,260 @@ func (v Value) bytesSlow() []byte {
|
||||
panic("todo")
|
||||
}
|
||||
|
||||
// runes returns v's underlying value.
|
||||
// It panics if v's underlying value is not a slice of runes (int32s).
|
||||
func (v Value) runes() []rune {
|
||||
v.mustBe(Slice)
|
||||
if v.typ().Elem().Kind() != abi.Int32 {
|
||||
panic("reflect.Value.Bytes of non-rune slice")
|
||||
}
|
||||
// Slice is always bigger than a word; assume flagIndir.
|
||||
return *(*[]rune)(v.ptr)
|
||||
}
|
||||
|
||||
// CanAddr reports whether the value's address can be obtained with Addr.
|
||||
// Such values are called addressable. A value is addressable if it is
|
||||
// an element of a slice, an element of an addressable array,
|
||||
// a field of an addressable struct, or the result of dereferencing a pointer.
|
||||
// If CanAddr returns false, calling Addr will panic.
|
||||
func (v Value) CanAddr() bool {
|
||||
return v.flag&flagAddr != 0
|
||||
}
|
||||
|
||||
// CanSet reports whether the value of v can be changed.
|
||||
// A Value can be changed only if it is addressable and was not
|
||||
// obtained by the use of unexported struct fields.
|
||||
// If CanSet returns false, calling Set or any type-specific
|
||||
// setter (e.g., SetBool, SetInt) will panic.
|
||||
func (v Value) CanSet() bool {
|
||||
return v.flag&(flagAddr|flagRO) == flagAddr
|
||||
}
|
||||
|
||||
// Cap returns v's capacity.
|
||||
// It panics if v's Kind is not Array, Chan, Slice or pointer to Array.
|
||||
func (v Value) Cap() int {
|
||||
/* TODO(xsw):
|
||||
// capNonSlice is split out to keep Cap inlineable for slice kinds.
|
||||
if v.kind() == Slice {
|
||||
return (*unsafeheader.Slice)(v.ptr).Cap
|
||||
}
|
||||
return v.capNonSlice()
|
||||
*/
|
||||
panic("todo: reflect.Value.Cap")
|
||||
}
|
||||
|
||||
func (v Value) capNonSlice() int {
|
||||
/* TODO(xsw):
|
||||
k := v.kind()
|
||||
switch k {
|
||||
case Array:
|
||||
return v.typ().Len()
|
||||
case Chan:
|
||||
return chancap(v.pointer())
|
||||
case Ptr:
|
||||
if v.typ().Elem().Kind() == abi.Array {
|
||||
return v.typ().Elem().Len()
|
||||
}
|
||||
panic("reflect: call of reflect.Value.Cap on ptr to non-array Value")
|
||||
}
|
||||
panic(&ValueError{"reflect.Value.Cap", v.kind()})
|
||||
*/
|
||||
panic("todo: reflect.Value.capNonSlice")
|
||||
}
|
||||
|
||||
// Close closes the channel v.
|
||||
// It panics if v's Kind is not Chan.
|
||||
func (v Value) Close() {
|
||||
/* TODO(xsw):
|
||||
v.mustBe(Chan)
|
||||
v.mustBeExported()
|
||||
chanclose(v.pointer())
|
||||
*/
|
||||
panic("todo: reflect.Value.Close")
|
||||
}
|
||||
|
||||
// CanComplex reports whether Complex can be used without panicking.
|
||||
func (v Value) CanComplex() bool {
|
||||
switch v.kind() {
|
||||
case Complex64, Complex128:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Complex returns v's underlying value, as a complex128.
|
||||
// It panics if v's Kind is not Complex64 or Complex128
|
||||
func (v Value) Complex() complex128 {
|
||||
k := v.kind()
|
||||
switch k {
|
||||
case Complex64:
|
||||
return complex128(*(*complex64)(v.ptr))
|
||||
case Complex128:
|
||||
return *(*complex128)(v.ptr)
|
||||
}
|
||||
panic(&ValueError{"reflect.Value.Complex", v.kind()})
|
||||
}
|
||||
|
||||
// Elem returns the value that the interface v contains
|
||||
// or that the pointer v points to.
|
||||
// It panics if v's Kind is not Interface or Pointer.
|
||||
// It returns the zero Value if v is nil.
|
||||
func (v Value) Elem() Value {
|
||||
/* TODO(xsw):
|
||||
k := v.kind()
|
||||
switch k {
|
||||
case Interface:
|
||||
var eface any
|
||||
if v.typ().NumMethod() == 0 {
|
||||
eface = *(*any)(v.ptr)
|
||||
} else {
|
||||
eface = (any)(*(*interface {
|
||||
M()
|
||||
})(v.ptr))
|
||||
}
|
||||
x := unpackEface(eface)
|
||||
if x.flag != 0 {
|
||||
x.flag |= v.flag.ro()
|
||||
}
|
||||
return x
|
||||
case Pointer:
|
||||
ptr := v.ptr
|
||||
if v.flag&flagIndir != 0 {
|
||||
if ifaceIndir(v.typ()) {
|
||||
// This is a pointer to a not-in-heap object. ptr points to a uintptr
|
||||
// in the heap. That uintptr is the address of a not-in-heap object.
|
||||
// In general, pointers to not-in-heap objects can be total junk.
|
||||
// But Elem() is asking to dereference it, so the user has asserted
|
||||
// that at least it is a valid pointer (not just an integer stored in
|
||||
// a pointer slot). So let's check, to make sure that it isn't a pointer
|
||||
// that the runtime will crash on if it sees it during GC or write barriers.
|
||||
// Since it is a not-in-heap pointer, all pointers to the heap are
|
||||
// forbidden! That makes the test pretty easy.
|
||||
// See issue 48399.
|
||||
if !verifyNotInHeapPtr(*(*uintptr)(ptr)) {
|
||||
panic("reflect: reflect.Value.Elem on an invalid notinheap pointer")
|
||||
}
|
||||
}
|
||||
ptr = *(*unsafe.Pointer)(ptr)
|
||||
}
|
||||
// The returned value's address is v's value.
|
||||
if ptr == nil {
|
||||
return Value{}
|
||||
}
|
||||
tt := (*ptrType)(unsafe.Pointer(v.typ()))
|
||||
typ := tt.Elem
|
||||
fl := v.flag&flagRO | flagIndir | flagAddr
|
||||
fl |= flag(typ.Kind())
|
||||
return Value{typ, ptr, fl}
|
||||
}
|
||||
panic(&ValueError{"reflect.Value.Elem", v.kind()})
|
||||
*/
|
||||
panic("todo: reflect.Value.Elem")
|
||||
}
|
||||
|
||||
// Field returns the i'th field of the struct v.
|
||||
// It panics if v's Kind is not Struct or i is out of range.
|
||||
func (v Value) Field(i int) Value {
|
||||
/* TODO(xsw):
|
||||
if v.kind() != Struct {
|
||||
panic(&ValueError{"reflect.Value.Field", v.kind()})
|
||||
}
|
||||
tt := (*structType)(unsafe.Pointer(v.typ()))
|
||||
if uint(i) >= uint(len(tt.Fields)) {
|
||||
panic("reflect: Field index out of range")
|
||||
}
|
||||
field := &tt.Fields[i]
|
||||
typ := field.Typ
|
||||
|
||||
// Inherit permission bits from v, but clear flagEmbedRO.
|
||||
fl := v.flag&(flagStickyRO|flagIndir|flagAddr) | flag(typ.Kind())
|
||||
// Using an unexported field forces flagRO.
|
||||
if !field.Name.IsExported() {
|
||||
if field.Embedded() {
|
||||
fl |= flagEmbedRO
|
||||
} else {
|
||||
fl |= flagStickyRO
|
||||
}
|
||||
}
|
||||
// Either flagIndir is set and v.ptr points at struct,
|
||||
// or flagIndir is not set and v.ptr is the actual struct data.
|
||||
// In the former case, we want v.ptr + offset.
|
||||
// In the latter case, we must have field.offset = 0,
|
||||
// so v.ptr + field.offset is still the correct address.
|
||||
ptr := add(v.ptr, field.Offset, "same as non-reflect &v.field")
|
||||
return Value{typ, ptr, fl}
|
||||
*/
|
||||
panic("todo: reflect.Value.Field")
|
||||
}
|
||||
|
||||
// FieldByIndex returns the nested field corresponding to index.
|
||||
// It panics if evaluation requires stepping through a nil
|
||||
// pointer or a field that is not a struct.
|
||||
func (v Value) FieldByIndex(index []int) Value {
|
||||
if len(index) == 1 {
|
||||
return v.Field(index[0])
|
||||
}
|
||||
v.mustBe(Struct)
|
||||
for i, x := range index {
|
||||
if i > 0 {
|
||||
if v.Kind() == Pointer && v.typ().Elem().Kind() == abi.Struct {
|
||||
if v.IsNil() {
|
||||
panic("reflect: indirection through nil pointer to embedded struct")
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
}
|
||||
v = v.Field(x)
|
||||
}
|
||||
return v
|
||||
}
|
||||
|
||||
// FieldByIndexErr returns the nested field corresponding to index.
|
||||
// It returns an error if evaluation requires stepping through a nil
|
||||
// pointer, but panics if it must step through a field that
|
||||
// is not a struct.
|
||||
func (v Value) FieldByIndexErr(index []int) (Value, error) {
|
||||
if len(index) == 1 {
|
||||
return v.Field(index[0]), nil
|
||||
}
|
||||
v.mustBe(Struct)
|
||||
for i, x := range index {
|
||||
if i > 0 {
|
||||
if v.Kind() == Ptr && v.typ().Elem().Kind() == abi.Struct {
|
||||
if v.IsNil() {
|
||||
return Value{}, errors.New("reflect: indirection through nil pointer to embedded struct field " + nameFor(v.typ().Elem()))
|
||||
}
|
||||
v = v.Elem()
|
||||
}
|
||||
}
|
||||
v = v.Field(x)
|
||||
}
|
||||
return v, nil
|
||||
}
|
||||
|
||||
// FieldByName returns the struct field with the given name.
|
||||
// It returns the zero Value if no field was found.
|
||||
// It panics if v's Kind is not struct.
|
||||
func (v Value) FieldByName(name string) Value {
|
||||
v.mustBe(Struct)
|
||||
if f, ok := toRType(v.typ()).FieldByName(name); ok {
|
||||
return v.FieldByIndex(f.Index)
|
||||
}
|
||||
return Value{}
|
||||
}
|
||||
|
||||
// FieldByNameFunc returns the struct field with a name
|
||||
// that satisfies the match function.
|
||||
// It panics if v's Kind is not struct.
|
||||
// It returns the zero Value if no field was found.
|
||||
func (v Value) FieldByNameFunc(match func(string) bool) Value {
|
||||
if f, ok := toRType(v.typ()).FieldByNameFunc(match); ok {
|
||||
return v.FieldByIndex(f.Index)
|
||||
}
|
||||
return Value{}
|
||||
}
|
||||
|
||||
// CanFloat reports whether Float can be used without panicking.
|
||||
func (v Value) CanFloat() bool {
|
||||
switch v.kind() {
|
||||
@@ -746,6 +1001,133 @@ func (v Value) lenNonSlice() int {
|
||||
panic("todo")
|
||||
}
|
||||
|
||||
// Pointer returns v's value as a uintptr.
|
||||
// It panics if v's Kind is not Chan, Func, Map, Pointer, Slice, or UnsafePointer.
|
||||
//
|
||||
// If v's Kind is Func, the returned pointer is an underlying
|
||||
// code pointer, but not necessarily enough to identify a
|
||||
// single function uniquely. The only guarantee is that the
|
||||
// result is zero if and only if v is a nil func Value.
|
||||
//
|
||||
// If v's Kind is Slice, the returned pointer is to the first
|
||||
// element of the slice. If the slice is nil the returned value
|
||||
// is 0. If the slice is empty but non-nil the return value is non-zero.
|
||||
//
|
||||
// It's preferred to use uintptr(Value.UnsafePointer()) to get the equivalent result.
|
||||
func (v Value) Pointer() uintptr {
|
||||
/* TODO(xsw):
|
||||
// The compiler loses track as it converts to uintptr. Force escape.
|
||||
escapes(v.ptr)
|
||||
|
||||
k := v.kind()
|
||||
switch k {
|
||||
case Pointer:
|
||||
if v.typ().PtrBytes == 0 {
|
||||
val := *(*uintptr)(v.ptr)
|
||||
// Since it is a not-in-heap pointer, all pointers to the heap are
|
||||
// forbidden! See comment in Value.Elem and issue #48399.
|
||||
if !verifyNotInHeapPtr(val) {
|
||||
panic("reflect: reflect.Value.Pointer on an invalid notinheap pointer")
|
||||
}
|
||||
return val
|
||||
}
|
||||
fallthrough
|
||||
case Chan, Map, UnsafePointer:
|
||||
return uintptr(v.pointer())
|
||||
case Func:
|
||||
if v.flag&flagMethod != 0 {
|
||||
// As the doc comment says, the returned pointer is an
|
||||
// underlying code pointer but not necessarily enough to
|
||||
// identify a single function uniquely. All method expressions
|
||||
// created via reflect have the same underlying code pointer,
|
||||
// so their Pointers are equal. The function used here must
|
||||
// match the one used in makeMethodValue.
|
||||
return methodValueCallCodePtr()
|
||||
}
|
||||
p := v.pointer()
|
||||
// Non-nil func value points at data block.
|
||||
// First word of data block is actual code.
|
||||
if p != nil {
|
||||
p = *(*unsafe.Pointer)(p)
|
||||
}
|
||||
return uintptr(p)
|
||||
|
||||
case Slice:
|
||||
return uintptr((*unsafeheader.Slice)(v.ptr).Data)
|
||||
}
|
||||
panic(&ValueError{"reflect.Value.Pointer", v.kind()})
|
||||
*/
|
||||
panic("todo: reflect.Value.Pointer")
|
||||
}
|
||||
|
||||
// Recv receives and returns a value from the channel v.
|
||||
// It panics if v's Kind is not Chan.
|
||||
// The receive blocks until a value is ready.
|
||||
// The boolean value ok is true if the value x corresponds to a send
|
||||
// on the channel, false if it is a zero value received because the channel is closed.
|
||||
func (v Value) Recv() (x Value, ok bool) {
|
||||
v.mustBe(Chan)
|
||||
v.mustBeExported()
|
||||
return v.recv(false)
|
||||
}
|
||||
|
||||
// internal recv, possibly non-blocking (nb).
|
||||
// v is known to be a channel.
|
||||
func (v Value) recv(nb bool) (val Value, ok bool) {
|
||||
/* TODO(xsw):
|
||||
tt := (*chanType)(unsafe.Pointer(v.typ()))
|
||||
if ChanDir(tt.Dir)&RecvDir == 0 {
|
||||
panic("reflect: recv on send-only channel")
|
||||
}
|
||||
t := tt.Elem
|
||||
val = Value{t, nil, flag(t.Kind())}
|
||||
var p unsafe.Pointer
|
||||
if ifaceIndir(t) {
|
||||
p = unsafe_New(t)
|
||||
val.ptr = p
|
||||
val.flag |= flagIndir
|
||||
} else {
|
||||
p = unsafe.Pointer(&val.ptr)
|
||||
}
|
||||
selected, ok := chanrecv(v.pointer(), nb, p)
|
||||
if !selected {
|
||||
val = Value{}
|
||||
}
|
||||
return
|
||||
*/
|
||||
panic("todo: reflect.Value.recv")
|
||||
}
|
||||
|
||||
// Send sends x on the channel v.
|
||||
// It panics if v's kind is not Chan or if x's type is not the same type as v's element type.
|
||||
// As in Go, x's value must be assignable to the channel's element type.
|
||||
func (v Value) Send(x Value) {
|
||||
v.mustBe(Chan)
|
||||
v.mustBeExported()
|
||||
v.send(x, false)
|
||||
}
|
||||
|
||||
// internal send, possibly non-blocking.
|
||||
// v is known to be a channel.
|
||||
func (v Value) send(x Value, nb bool) (selected bool) {
|
||||
/* TODO(xsw):
|
||||
tt := (*chanType)(unsafe.Pointer(v.typ()))
|
||||
if ChanDir(tt.Dir)&SendDir == 0 {
|
||||
panic("reflect: send on recv-only channel")
|
||||
}
|
||||
x.mustBeExported()
|
||||
x = x.assignTo("reflect.Value.Send", tt.Elem, nil)
|
||||
var p unsafe.Pointer
|
||||
if x.flag&flagIndir != 0 {
|
||||
p = x.ptr
|
||||
} else {
|
||||
p = unsafe.Pointer(&x.ptr)
|
||||
}
|
||||
return chansend(v.pointer(), p, nb)
|
||||
*/
|
||||
panic("todo: reflect.Value.send")
|
||||
}
|
||||
|
||||
// Set assigns x to the value v.
|
||||
// It panics if CanSet returns false.
|
||||
// As in Go, x's value must be assignable to v's type and
|
||||
@@ -847,6 +1229,448 @@ func (v Value) SetInt(x int64) {
|
||||
}
|
||||
}
|
||||
|
||||
// SetLen sets v's length to n.
|
||||
// It panics if v's Kind is not Slice or if n is negative or
|
||||
// greater than the capacity of the slice.
|
||||
func (v Value) SetLen(n int) {
|
||||
/* TODO(xsw):
|
||||
v.mustBeAssignable()
|
||||
v.mustBe(Slice)
|
||||
s := (*unsafeheader.Slice)(v.ptr)
|
||||
if uint(n) > uint(s.Cap) {
|
||||
panic("reflect: slice length out of range in SetLen")
|
||||
}
|
||||
s.Len = n
|
||||
*/
|
||||
panic("todo: reflect.Value.SetLen")
|
||||
}
|
||||
|
||||
// SetCap sets v's capacity to n.
|
||||
// It panics if v's Kind is not Slice or if n is smaller than the length or
|
||||
// greater than the capacity of the slice.
|
||||
func (v Value) SetCap(n int) {
|
||||
/* TODO(xsw):
|
||||
v.mustBeAssignable()
|
||||
v.mustBe(Slice)
|
||||
s := (*unsafeheader.Slice)(v.ptr)
|
||||
if n < s.Len || n > s.Cap {
|
||||
panic("reflect: slice capacity out of range in SetCap")
|
||||
}
|
||||
s.Cap = n
|
||||
*/
|
||||
panic("todo: reflect.Value.SetCap")
|
||||
}
|
||||
|
||||
// SetMapIndex sets the element associated with key in the map v to elem.
|
||||
// It panics if v's Kind is not Map.
|
||||
// If elem is the zero Value, SetMapIndex deletes the key from the map.
|
||||
// Otherwise if v holds a nil map, SetMapIndex will panic.
|
||||
// As in Go, key's elem must be assignable to the map's key type,
|
||||
// and elem's value must be assignable to the map's elem type.
|
||||
func (v Value) SetMapIndex(key, elem Value) {
|
||||
/* TODO(xsw):
|
||||
v.mustBe(Map)
|
||||
v.mustBeExported()
|
||||
key.mustBeExported()
|
||||
tt := (*mapType)(unsafe.Pointer(v.typ()))
|
||||
|
||||
if (tt.Key == stringType || key.kind() == String) && tt.Key == key.typ() && tt.Elem.Size() <= maxValSize {
|
||||
k := *(*string)(key.ptr)
|
||||
if elem.typ() == nil {
|
||||
mapdelete_faststr(v.typ(), v.pointer(), k)
|
||||
return
|
||||
}
|
||||
elem.mustBeExported()
|
||||
elem = elem.assignTo("reflect.Value.SetMapIndex", tt.Elem, nil)
|
||||
var e unsafe.Pointer
|
||||
if elem.flag&flagIndir != 0 {
|
||||
e = elem.ptr
|
||||
} else {
|
||||
e = unsafe.Pointer(&elem.ptr)
|
||||
}
|
||||
mapassign_faststr(v.typ(), v.pointer(), k, e)
|
||||
return
|
||||
}
|
||||
|
||||
key = key.assignTo("reflect.Value.SetMapIndex", tt.Key, nil)
|
||||
var k unsafe.Pointer
|
||||
if key.flag&flagIndir != 0 {
|
||||
k = key.ptr
|
||||
} else {
|
||||
k = unsafe.Pointer(&key.ptr)
|
||||
}
|
||||
if elem.typ() == nil {
|
||||
mapdelete(v.typ(), v.pointer(), k)
|
||||
return
|
||||
}
|
||||
elem.mustBeExported()
|
||||
elem = elem.assignTo("reflect.Value.SetMapIndex", tt.Elem, nil)
|
||||
var e unsafe.Pointer
|
||||
if elem.flag&flagIndir != 0 {
|
||||
e = elem.ptr
|
||||
} else {
|
||||
e = unsafe.Pointer(&elem.ptr)
|
||||
}
|
||||
mapassign(v.typ(), v.pointer(), k, e)
|
||||
*/
|
||||
panic("todo: reflect.Value.SetMapIndex")
|
||||
}
|
||||
|
||||
// SetUint sets v's underlying value to x.
|
||||
// It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64, or if CanSet() is false.
|
||||
func (v Value) SetUint(x uint64) {
|
||||
v.mustBeAssignable()
|
||||
switch k := v.kind(); k {
|
||||
default:
|
||||
panic(&ValueError{"reflect.Value.SetUint", v.kind()})
|
||||
case Uint:
|
||||
*(*uint)(v.ptr) = uint(x)
|
||||
case Uint8:
|
||||
*(*uint8)(v.ptr) = uint8(x)
|
||||
case Uint16:
|
||||
*(*uint16)(v.ptr) = uint16(x)
|
||||
case Uint32:
|
||||
*(*uint32)(v.ptr) = uint32(x)
|
||||
case Uint64:
|
||||
*(*uint64)(v.ptr) = x
|
||||
case Uintptr:
|
||||
*(*uintptr)(v.ptr) = uintptr(x)
|
||||
}
|
||||
}
|
||||
|
||||
// SetPointer sets the [unsafe.Pointer] value v to x.
|
||||
// It panics if v's Kind is not UnsafePointer.
|
||||
func (v Value) SetPointer(x unsafe.Pointer) {
|
||||
v.mustBeAssignable()
|
||||
v.mustBe(UnsafePointer)
|
||||
*(*unsafe.Pointer)(v.ptr) = x
|
||||
}
|
||||
|
||||
// SetString sets v's underlying value to x.
|
||||
// It panics if v's Kind is not String or if CanSet() is false.
|
||||
func (v Value) SetString(x string) {
|
||||
v.mustBeAssignable()
|
||||
v.mustBe(String)
|
||||
*(*string)(v.ptr) = x
|
||||
}
|
||||
|
||||
// Slice returns v[i:j].
|
||||
// It panics if v's Kind is not Array, Slice or String, or if v is an unaddressable array,
|
||||
// or if the indexes are out of bounds.
|
||||
func (v Value) Slice(i, j int) Value {
|
||||
/* TODO(xsw):
|
||||
var (
|
||||
cap int
|
||||
typ *sliceType
|
||||
base unsafe.Pointer
|
||||
)
|
||||
switch kind := v.kind(); kind {
|
||||
default:
|
||||
panic(&ValueError{"reflect.Value.Slice", v.kind()})
|
||||
|
||||
case Array:
|
||||
if v.flag&flagAddr == 0 {
|
||||
panic("reflect.Value.Slice: slice of unaddressable array")
|
||||
}
|
||||
tt := (*arrayType)(unsafe.Pointer(v.typ()))
|
||||
cap = int(tt.Len)
|
||||
typ = (*sliceType)(unsafe.Pointer(tt.Slice))
|
||||
base = v.ptr
|
||||
|
||||
case Slice:
|
||||
typ = (*sliceType)(unsafe.Pointer(v.typ()))
|
||||
s := (*unsafeheader.Slice)(v.ptr)
|
||||
base = s.Data
|
||||
cap = s.Cap
|
||||
|
||||
case String:
|
||||
s := (*unsafeheader.String)(v.ptr)
|
||||
if i < 0 || j < i || j > s.Len {
|
||||
panic("reflect.Value.Slice: string slice index out of bounds")
|
||||
}
|
||||
var t unsafeheader.String
|
||||
if i < s.Len {
|
||||
t = unsafeheader.String{Data: arrayAt(s.Data, i, 1, "i < s.Len"), Len: j - i}
|
||||
}
|
||||
return Value{v.typ(), unsafe.Pointer(&t), v.flag}
|
||||
}
|
||||
|
||||
if i < 0 || j < i || j > cap {
|
||||
panic("reflect.Value.Slice: slice index out of bounds")
|
||||
}
|
||||
|
||||
// Declare slice so that gc can see the base pointer in it.
|
||||
var x []unsafe.Pointer
|
||||
|
||||
// Reinterpret as *unsafeheader.Slice to edit.
|
||||
s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
|
||||
s.Len = j - i
|
||||
s.Cap = cap - i
|
||||
if cap-i > 0 {
|
||||
s.Data = arrayAt(base, i, typ.Elem.Size(), "i < cap")
|
||||
} else {
|
||||
// do not advance pointer, to avoid pointing beyond end of slice
|
||||
s.Data = base
|
||||
}
|
||||
|
||||
fl := v.flag.ro() | flagIndir | flag(Slice)
|
||||
return Value{typ.Common(), unsafe.Pointer(&x), fl}
|
||||
*/
|
||||
panic("todo: reflect.Value.Slice")
|
||||
}
|
||||
|
||||
// Slice3 is the 3-index form of the slice operation: it returns v[i:j:k].
|
||||
// It panics if v's Kind is not Array or Slice, or if v is an unaddressable array,
|
||||
// or if the indexes are out of bounds.
|
||||
func (v Value) Slice3(i, j, k int) Value {
|
||||
/* TODO(xsw):
|
||||
var (
|
||||
cap int
|
||||
typ *sliceType
|
||||
base unsafe.Pointer
|
||||
)
|
||||
switch kind := v.kind(); kind {
|
||||
default:
|
||||
panic(&ValueError{"reflect.Value.Slice3", v.kind()})
|
||||
|
||||
case Array:
|
||||
if v.flag&flagAddr == 0 {
|
||||
panic("reflect.Value.Slice3: slice of unaddressable array")
|
||||
}
|
||||
tt := (*arrayType)(unsafe.Pointer(v.typ()))
|
||||
cap = int(tt.Len)
|
||||
typ = (*sliceType)(unsafe.Pointer(tt.Slice))
|
||||
base = v.ptr
|
||||
|
||||
case Slice:
|
||||
typ = (*sliceType)(unsafe.Pointer(v.typ()))
|
||||
s := (*unsafeheader.Slice)(v.ptr)
|
||||
base = s.Data
|
||||
cap = s.Cap
|
||||
}
|
||||
|
||||
if i < 0 || j < i || k < j || k > cap {
|
||||
panic("reflect.Value.Slice3: slice index out of bounds")
|
||||
}
|
||||
|
||||
// Declare slice so that the garbage collector
|
||||
// can see the base pointer in it.
|
||||
var x []unsafe.Pointer
|
||||
|
||||
// Reinterpret as *unsafeheader.Slice to edit.
|
||||
s := (*unsafeheader.Slice)(unsafe.Pointer(&x))
|
||||
s.Len = j - i
|
||||
s.Cap = k - i
|
||||
if k-i > 0 {
|
||||
s.Data = arrayAt(base, i, typ.Elem.Size(), "i < k <= cap")
|
||||
} else {
|
||||
// do not advance pointer, to avoid pointing beyond end of slice
|
||||
s.Data = base
|
||||
}
|
||||
|
||||
fl := v.flag.ro() | flagIndir | flag(Slice)
|
||||
return Value{typ.Common(), unsafe.Pointer(&x), fl}
|
||||
*/
|
||||
panic("todo: reflect.Value.Slice3")
|
||||
}
|
||||
|
||||
// String returns the string v's underlying value, as a string.
|
||||
// String is a special case because of Go's String method convention.
|
||||
// Unlike the other getters, it does not panic if v's Kind is not String.
|
||||
// Instead, it returns a string of the form "<T value>" where T is v's type.
|
||||
// The fmt package treats Values specially. It does not call their String
|
||||
// method implicitly but instead prints the concrete values they hold.
|
||||
func (v Value) String() string {
|
||||
// stringNonString is split out to keep String inlineable for string kinds.
|
||||
if v.kind() == String {
|
||||
return *(*string)(v.ptr)
|
||||
}
|
||||
return v.stringNonString()
|
||||
}
|
||||
|
||||
func (v Value) stringNonString() string {
|
||||
if v.kind() == Invalid {
|
||||
return "<invalid Value>"
|
||||
}
|
||||
// If you call String on a reflect.Value of other type, it's better to
|
||||
// print something than to panic. Useful in debugging.
|
||||
return "<" + v.Type().String() + " Value>"
|
||||
}
|
||||
|
||||
// TryRecv attempts to receive a value from the channel v but will not block.
|
||||
// It panics if v's Kind is not Chan.
|
||||
// If the receive delivers a value, x is the transferred value and ok is true.
|
||||
// If the receive cannot finish without blocking, x is the zero Value and ok is false.
|
||||
// If the channel is closed, x is the zero value for the channel's element type and ok is false.
|
||||
func (v Value) TryRecv() (x Value, ok bool) {
|
||||
/* TODO(xsw):
|
||||
v.mustBe(Chan)
|
||||
v.mustBeExported()
|
||||
return v.recv(true)
|
||||
*/
|
||||
panic("todo: reflect.Value.TryRecv")
|
||||
}
|
||||
|
||||
// TrySend attempts to send x on the channel v but will not block.
|
||||
// It panics if v's Kind is not Chan.
|
||||
// It reports whether the value was sent.
|
||||
// As in Go, x's value must be assignable to the channel's element type.
|
||||
func (v Value) TrySend(x Value) bool {
|
||||
/* TODO(xsw):
|
||||
v.mustBe(Chan)
|
||||
v.mustBeExported()
|
||||
return v.send(x, true)
|
||||
*/
|
||||
panic("todo: reflect.Value.TrySend")
|
||||
}
|
||||
|
||||
// Type returns v's type.
|
||||
func (v Value) Type() Type {
|
||||
if v.flag != 0 && v.flag&flagMethod == 0 {
|
||||
return (*rtype)(unsafe.Pointer(v.typ_)) // inline of toRType(v.typ()), for own inlining in inline test
|
||||
}
|
||||
return v.typeSlow()
|
||||
}
|
||||
|
||||
func (v Value) typeSlow() Type {
|
||||
/* TODO(xsw):
|
||||
if v.flag == 0 {
|
||||
panic(&ValueError{"reflect.Value.Type", Invalid})
|
||||
}
|
||||
|
||||
typ := v.typ()
|
||||
if v.flag&flagMethod == 0 {
|
||||
return toRType(v.typ())
|
||||
}
|
||||
|
||||
// Method value.
|
||||
// v.typ describes the receiver, not the method type.
|
||||
i := int(v.flag) >> flagMethodShift
|
||||
if v.typ().Kind() == abi.Interface {
|
||||
// Method on interface.
|
||||
tt := (*interfaceType)(unsafe.Pointer(typ))
|
||||
if uint(i) >= uint(len(tt.Methods)) {
|
||||
panic("reflect: internal error: invalid method index")
|
||||
}
|
||||
m := &tt.Methods[i]
|
||||
return toRType(typeOffFor(typ, m.Typ))
|
||||
}
|
||||
// Method on concrete type.
|
||||
ms := typ.ExportedMethods()
|
||||
if uint(i) >= uint(len(ms)) {
|
||||
panic("reflect: internal error: invalid method index")
|
||||
}
|
||||
m := ms[i]
|
||||
return toRType(typeOffFor(typ, m.Mtyp))
|
||||
*/
|
||||
panic("todo: reflect.Value.Type")
|
||||
}
|
||||
|
||||
// CanUint reports whether Uint can be used without panicking.
|
||||
func (v Value) CanUint() bool {
|
||||
switch v.kind() {
|
||||
case Uint, Uint8, Uint16, Uint32, Uint64, Uintptr:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
// Uint returns v's underlying value, as a uint64.
|
||||
// It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
|
||||
func (v Value) Uint() uint64 {
|
||||
k := v.kind()
|
||||
p := v.ptr
|
||||
switch k {
|
||||
case Uint:
|
||||
return uint64(*(*uint)(p))
|
||||
case Uint8:
|
||||
return uint64(*(*uint8)(p))
|
||||
case Uint16:
|
||||
return uint64(*(*uint16)(p))
|
||||
case Uint32:
|
||||
return uint64(*(*uint32)(p))
|
||||
case Uint64:
|
||||
return *(*uint64)(p)
|
||||
case Uintptr:
|
||||
return uint64(*(*uintptr)(p))
|
||||
}
|
||||
panic(&ValueError{"reflect.Value.Uint", v.kind()})
|
||||
}
|
||||
|
||||
//go:nocheckptr
|
||||
// This prevents inlining Value.UnsafeAddr when -d=checkptr is enabled,
|
||||
// which ensures cmd/compile can recognize unsafe.Pointer(v.UnsafeAddr())
|
||||
// and make an exception.
|
||||
|
||||
// UnsafeAddr returns a pointer to v's data, as a uintptr.
|
||||
// It panics if v is not addressable.
|
||||
//
|
||||
// It's preferred to use uintptr(Value.Addr().UnsafePointer()) to get the equivalent result.
|
||||
func (v Value) UnsafeAddr() uintptr {
|
||||
if v.typ() == nil {
|
||||
panic(&ValueError{"reflect.Value.UnsafeAddr", Invalid})
|
||||
}
|
||||
if v.flag&flagAddr == 0 {
|
||||
panic("reflect.Value.UnsafeAddr of unaddressable value")
|
||||
}
|
||||
return uintptr(v.ptr)
|
||||
}
|
||||
|
||||
// UnsafePointer returns v's value as a [unsafe.Pointer].
|
||||
// It panics if v's Kind is not Chan, Func, Map, Pointer, Slice, or UnsafePointer.
|
||||
//
|
||||
// If v's Kind is Func, the returned pointer is an underlying
|
||||
// code pointer, but not necessarily enough to identify a
|
||||
// single function uniquely. The only guarantee is that the
|
||||
// result is zero if and only if v is a nil func Value.
|
||||
//
|
||||
// If v's Kind is Slice, the returned pointer is to the first
|
||||
// element of the slice. If the slice is nil the returned value
|
||||
// is nil. If the slice is empty but non-nil the return value is non-nil.
|
||||
func (v Value) UnsafePointer() unsafe.Pointer {
|
||||
/* TODO(xsw):
|
||||
k := v.kind()
|
||||
switch k {
|
||||
case Pointer:
|
||||
if v.typ().PtrBytes == 0 {
|
||||
// Since it is a not-in-heap pointer, all pointers to the heap are
|
||||
// forbidden! See comment in Value.Elem and issue #48399.
|
||||
if !verifyNotInHeapPtr(*(*uintptr)(v.ptr)) {
|
||||
panic("reflect: reflect.Value.UnsafePointer on an invalid notinheap pointer")
|
||||
}
|
||||
return *(*unsafe.Pointer)(v.ptr)
|
||||
}
|
||||
fallthrough
|
||||
case Chan, Map, UnsafePointer:
|
||||
return v.pointer()
|
||||
case Func:
|
||||
if v.flag&flagMethod != 0 {
|
||||
// As the doc comment says, the returned pointer is an
|
||||
// underlying code pointer but not necessarily enough to
|
||||
// identify a single function uniquely. All method expressions
|
||||
// created via reflect have the same underlying code pointer,
|
||||
// so their Pointers are equal. The function used here must
|
||||
// match the one used in makeMethodValue.
|
||||
code := methodValueCallCodePtr()
|
||||
return *(*unsafe.Pointer)(unsafe.Pointer(&code))
|
||||
}
|
||||
p := v.pointer()
|
||||
// Non-nil func value points at data block.
|
||||
// First word of data block is actual code.
|
||||
if p != nil {
|
||||
p = *(*unsafe.Pointer)(p)
|
||||
}
|
||||
return p
|
||||
|
||||
case Slice:
|
||||
return (*unsafeheader.Slice)(v.ptr).Data
|
||||
}
|
||||
panic(&ValueError{"reflect.Value.UnsafePointer", v.kind()})
|
||||
*/
|
||||
panic("todo: reflect.Value.UnsafePointer")
|
||||
}
|
||||
|
||||
//go:linkname unsafe_New github.com/goplus/llgo/internal/runtime.New
|
||||
func unsafe_New(*abi.Type) unsafe.Pointer
|
||||
|
||||
|
||||
Reference in New Issue
Block a user