Source file src/pkg/reflect/value.go
1 // Copyright 2009 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 package reflect 6 7 import ( 8 "math" 9 "runtime" 10 "strconv" 11 "unsafe" 12 ) 13 14 const bigEndian = false // can be smarter if we find a big-endian machine 15 const ptrSize = unsafe.Sizeof((*byte)(nil)) 16 const cannotSet = "cannot set value obtained from unexported struct field" 17 18 // TODO: This will have to go away when 19 // the new gc goes in. 20 func memmove(adst, asrc unsafe.Pointer, n uintptr) { 21 dst := uintptr(adst) 22 src := uintptr(asrc) 23 switch { 24 case src < dst && src+n > dst: 25 // byte copy backward 26 // careful: i is unsigned 27 for i := n; i > 0; { 28 i-- 29 *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(src + i)) 30 } 31 case (n|src|dst)&(ptrSize-1) != 0: 32 // byte copy forward 33 for i := uintptr(0); i < n; i++ { 34 *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(src + i)) 35 } 36 default: 37 // word copy forward 38 for i := uintptr(0); i < n; i += ptrSize { 39 *(*uintptr)(unsafe.Pointer(dst + i)) = *(*uintptr)(unsafe.Pointer(src + i)) 40 } 41 } 42 } 43 44 // Value is the reflection interface to a Go value. 45 // 46 // Not all methods apply to all kinds of values. Restrictions, 47 // if any, are noted in the documentation for each method. 48 // Use the Kind method to find out the kind of value before 49 // calling kind-specific methods. Calling a method 50 // inappropriate to the kind of type causes a run time panic. 51 // 52 // The zero Value represents no value. 53 // Its IsValid method returns false, its Kind method returns Invalid, 54 // its String method returns "<invalid Value>", and all other methods panic. 55 // Most functions and methods never return an invalid value. 56 // If one does, its documentation states the conditions explicitly. 57 // 58 // A Value can be used concurrently by multiple goroutines provided that 59 // the underlying Go value can be used concurrently for the equivalent 60 // direct operations. 61 type Value struct { 62 // typ holds the type of the value represented by a Value. 63 typ *commonType 64 65 // val holds the 1-word representation of the value. 66 // If flag's flagIndir bit is set, then val is a pointer to the data. 67 // Otherwise val is a word holding the actual data. 68 // When the data is smaller than a word, it begins at 69 // the first byte (in the memory address sense) of val. 70 // We use unsafe.Pointer so that the garbage collector 71 // knows that val could be a pointer. 72 val unsafe.Pointer 73 74 // flag holds metadata about the value. 75 // The lowest bits are flag bits: 76 // - flagRO: obtained via unexported field, so read-only 77 // - flagIndir: val holds a pointer to the data 78 // - flagAddr: v.CanAddr is true (implies flagIndir) 79 // - flagMethod: v is a method value. 80 // The next five bits give the Kind of the value. 81 // This repeats typ.Kind() except for method values. 82 // The remaining 23+ bits give a method number for method values. 83 // If flag.kind() != Func, code can assume that flagMethod is unset. 84 // If typ.size > ptrSize, code can assume that flagIndir is set. 85 flag 86 87 // A method value represents a curried method invocation 88 // like r.Read for some receiver r. The typ+val+flag bits describe 89 // the receiver r, but the flag's Kind bits say Func (methods are 90 // functions), and the top bits of the flag give the method number 91 // in r's type's method table. 92 } 93 94 type flag uintptr 95 96 const ( 97 flagRO flag = 1 << iota 98 flagIndir 99 flagAddr 100 flagMethod 101 flagKindShift = iota 102 flagKindWidth = 5 // there are 27 kinds 103 flagKindMask flag = 1<<flagKindWidth - 1 104 flagMethodShift = flagKindShift + flagKindWidth 105 ) 106 107 func (f flag) kind() Kind { 108 return Kind((f >> flagKindShift) & flagKindMask) 109 } 110 111 // A ValueError occurs when a Value method is invoked on 112 // a Value that does not support it. Such cases are documented 113 // in the description of each method. 114 type ValueError struct { 115 Method string 116 Kind Kind 117 } 118 119 func (e *ValueError) Error() string { 120 if e.Kind == 0 { 121 return "reflect: call of " + e.Method + " on zero Value" 122 } 123 return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value" 124 } 125 126 // methodName returns the name of the calling method, 127 // assumed to be two stack frames above. 128 func methodName() string { 129 pc, _, _, _ := runtime.Caller(2) 130 f := runtime.FuncForPC(pc) 131 if f == nil { 132 return "unknown method" 133 } 134 return f.Name() 135 } 136 137 // An iword is the word that would be stored in an 138 // interface to represent a given value v. Specifically, if v is 139 // bigger than a pointer, its word is a pointer to v's data. 140 // Otherwise, its word holds the data stored 141 // in its leading bytes (so is not a pointer). 142 // Because the value sometimes holds a pointer, we use 143 // unsafe.Pointer to represent it, so that if iword appears 144 // in a struct, the garbage collector knows that might be 145 // a pointer. 146 type iword unsafe.Pointer 147 148 func (v Value) iword() iword { 149 if v.flag&flagIndir != 0 && v.typ.size <= ptrSize { 150 // Have indirect but want direct word. 151 return loadIword(v.val, v.typ.size) 152 } 153 return iword(v.val) 154 } 155 156 // loadIword loads n bytes at p from memory into an iword. 157 func loadIword(p unsafe.Pointer, n uintptr) iword { 158 // Run the copy ourselves instead of calling memmove 159 // to avoid moving w to the heap. 160 var w iword 161 switch n { 162 default: 163 panic("reflect: internal error: loadIword of " + strconv.Itoa(int(n)) + "-byte value") 164 case 0: 165 case 1: 166 *(*uint8)(unsafe.Pointer(&w)) = *(*uint8)(p) 167 case 2: 168 *(*uint16)(unsafe.Pointer(&w)) = *(*uint16)(p) 169 case 3: 170 *(*[3]byte)(unsafe.Pointer(&w)) = *(*[3]byte)(p) 171 case 4: 172 *(*uint32)(unsafe.Pointer(&w)) = *(*uint32)(p) 173 case 5: 174 *(*[5]byte)(unsafe.Pointer(&w)) = *(*[5]byte)(p) 175 case 6: 176 *(*[6]byte)(unsafe.Pointer(&w)) = *(*[6]byte)(p) 177 case 7: 178 *(*[7]byte)(unsafe.Pointer(&w)) = *(*[7]byte)(p) 179 case 8: 180 *(*uint64)(unsafe.Pointer(&w)) = *(*uint64)(p) 181 } 182 return w 183 } 184 185 // storeIword stores n bytes from w into p. 186 func storeIword(p unsafe.Pointer, w iword, n uintptr) { 187 // Run the copy ourselves instead of calling memmove 188 // to avoid moving w to the heap. 189 switch n { 190 default: 191 panic("reflect: internal error: storeIword of " + strconv.Itoa(int(n)) + "-byte value") 192 case 0: 193 case 1: 194 *(*uint8)(p) = *(*uint8)(unsafe.Pointer(&w)) 195 case 2: 196 *(*uint16)(p) = *(*uint16)(unsafe.Pointer(&w)) 197 case 3: 198 *(*[3]byte)(p) = *(*[3]byte)(unsafe.Pointer(&w)) 199 case 4: 200 *(*uint32)(p) = *(*uint32)(unsafe.Pointer(&w)) 201 case 5: 202 *(*[5]byte)(p) = *(*[5]byte)(unsafe.Pointer(&w)) 203 case 6: 204 *(*[6]byte)(p) = *(*[6]byte)(unsafe.Pointer(&w)) 205 case 7: 206 *(*[7]byte)(p) = *(*[7]byte)(unsafe.Pointer(&w)) 207 case 8: 208 *(*uint64)(p) = *(*uint64)(unsafe.Pointer(&w)) 209 } 210 } 211 212 // emptyInterface is the header for an interface{} value. 213 type emptyInterface struct { 214 typ *runtimeType 215 word iword 216 } 217 218 // nonEmptyInterface is the header for a interface value with methods. 219 type nonEmptyInterface struct { 220 // see ../runtime/iface.c:/Itab 221 itab *struct { 222 ityp *runtimeType // static interface type 223 typ *runtimeType // dynamic concrete type 224 link unsafe.Pointer 225 bad int32 226 unused int32 227 fun [100000]unsafe.Pointer // method table 228 } 229 word iword 230 } 231 232 // mustBe panics if f's kind is not expected. 233 // Making this a method on flag instead of on Value 234 // (and embedding flag in Value) means that we can write 235 // the very clear v.mustBe(Bool) and have it compile into 236 // v.flag.mustBe(Bool), which will only bother to copy the 237 // single important word for the receiver. 238 func (f flag) mustBe(expected Kind) { 239 k := f.kind() 240 if k != expected { 241 panic(&ValueError{methodName(), k}) 242 } 243 } 244 245 // mustBeExported panics if f records that the value was obtained using 246 // an unexported field. 247 func (f flag) mustBeExported() { 248 if f == 0 { 249 panic(&ValueError{methodName(), 0}) 250 } 251 if f&flagRO != 0 { 252 panic(methodName() + " using value obtained using unexported field") 253 } 254 } 255 256 // mustBeAssignable panics if f records that the value is not assignable, 257 // which is to say that either it was obtained using an unexported field 258 // or it is not addressable. 259 func (f flag) mustBeAssignable() { 260 if f == 0 { 261 panic(&ValueError{methodName(), Invalid}) 262 } 263 // Assignable if addressable and not read-only. 264 if f&flagRO != 0 { 265 panic(methodName() + " using value obtained using unexported field") 266 } 267 if f&flagAddr == 0 { 268 panic(methodName() + " using unaddressable value") 269 } 270 } 271 272 // Addr returns a pointer value representing the address of v. 273 // It panics if CanAddr() returns false. 274 // Addr is typically used to obtain a pointer to a struct field 275 // or slice element in order to call a method that requires a 276 // pointer receiver. 277 func (v Value) Addr() Value { 278 if v.flag&flagAddr == 0 { 279 panic("reflect.Value.Addr of unaddressable value") 280 } 281 return Value{v.typ.ptrTo(), v.val, (v.flag & flagRO) | flag(Ptr)<<flagKindShift} 282 } 283 284 // Bool returns v's underlying value. 285 // It panics if v's kind is not Bool. 286 func (v Value) Bool() bool { 287 v.mustBe(Bool) 288 if v.flag&flagIndir != 0 { 289 return *(*bool)(v.val) 290 } 291 return *(*bool)(unsafe.Pointer(&v.val)) 292 } 293 294 // Bytes returns v's underlying value. 295 // It panics if v's underlying value is not a slice of bytes. 296 func (v Value) Bytes() []byte { 297 v.mustBe(Slice) 298 if v.typ.Elem().Kind() != Uint8 { 299 panic("reflect.Value.Bytes of non-byte slice") 300 } 301 // Slice is always bigger than a word; assume flagIndir. 302 return *(*[]byte)(v.val) 303 } 304 305 // CanAddr returns true if the value's address can be obtained with Addr. 306 // Such values are called addressable. A value is addressable if it is 307 // an element of a slice, an element of an addressable array, 308 // a field of an addressable struct, or the result of dereferencing a pointer. 309 // If CanAddr returns false, calling Addr will panic. 310 func (v Value) CanAddr() bool { 311 return v.flag&flagAddr != 0 312 } 313 314 // CanSet returns true if the value of v can be changed. 315 // A Value can be changed only if it is addressable and was not 316 // obtained by the use of unexported struct fields. 317 // If CanSet returns false, calling Set or any type-specific 318 // setter (e.g., SetBool, SetInt64) will panic. 319 func (v Value) CanSet() bool { 320 return v.flag&(flagAddr|flagRO) == flagAddr 321 } 322 323 // Call calls the function v with the input arguments in. 324 // For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]). 325 // Call panics if v's Kind is not Func. 326 // It returns the output results as Values. 327 // As in Go, each input argument must be assignable to the 328 // type of the function's corresponding input parameter. 329 // If v is a variadic function, Call creates the variadic slice parameter 330 // itself, copying in the corresponding values. 331 func (v Value) Call(in []Value) []Value { 332 v.mustBe(Func) 333 v.mustBeExported() 334 return v.call("Call", in) 335 } 336 337 // CallSlice calls the variadic function v with the input arguments in, 338 // assigning the slice in[len(in)-1] to v's final variadic argument. 339 // For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]...). 340 // Call panics if v's Kind is not Func or if v is not variadic. 341 // It returns the output results as Values. 342 // As in Go, each input argument must be assignable to the 343 // type of the function's corresponding input parameter. 344 func (v Value) CallSlice(in []Value) []Value { 345 v.mustBe(Func) 346 v.mustBeExported() 347 return v.call("CallSlice", in) 348 } 349 350 func (v Value) call(method string, in []Value) []Value { 351 // Get function pointer, type. 352 t := v.typ 353 var ( 354 fn unsafe.Pointer 355 rcvr iword 356 ) 357 if v.flag&flagMethod != 0 { 358 i := int(v.flag) >> flagMethodShift 359 if v.typ.Kind() == Interface { 360 tt := (*interfaceType)(unsafe.Pointer(v.typ)) 361 if i < 0 || i >= len(tt.methods) { 362 panic("reflect: broken Value") 363 } 364 m := &tt.methods[i] 365 if m.pkgPath != nil { 366 panic(method + " of unexported method") 367 } 368 t = toCommonType(m.typ) 369 iface := (*nonEmptyInterface)(v.val) 370 if iface.itab == nil { 371 panic(method + " of method on nil interface value") 372 } 373 fn = iface.itab.fun[i] 374 rcvr = iface.word 375 } else { 376 ut := v.typ.uncommon() 377 if ut == nil || i < 0 || i >= len(ut.methods) { 378 panic("reflect: broken Value") 379 } 380 m := &ut.methods[i] 381 if m.pkgPath != nil { 382 panic(method + " of unexported method") 383 } 384 fn = m.ifn 385 t = toCommonType(m.mtyp) 386 rcvr = v.iword() 387 } 388 } else if v.flag&flagIndir != 0 { 389 fn = *(*unsafe.Pointer)(v.val) 390 } else { 391 fn = v.val 392 } 393 394 if fn == nil { 395 panic("reflect.Value.Call: call of nil function") 396 } 397 398 isSlice := method == "CallSlice" 399 n := t.NumIn() 400 if isSlice { 401 if !t.IsVariadic() { 402 panic("reflect: CallSlice of non-variadic function") 403 } 404 if len(in) < n { 405 panic("reflect: CallSlice with too few input arguments") 406 } 407 if len(in) > n { 408 panic("reflect: CallSlice with too many input arguments") 409 } 410 } else { 411 if t.IsVariadic() { 412 n-- 413 } 414 if len(in) < n { 415 panic("reflect: Call with too few input arguments") 416 } 417 if !t.IsVariadic() && len(in) > n { 418 panic("reflect: Call with too many input arguments") 419 } 420 } 421 for _, x := range in { 422 if x.Kind() == Invalid { 423 panic("reflect: " + method + " using zero Value argument") 424 } 425 } 426 for i := 0; i < n; i++ { 427 if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) { 428 panic("reflect: " + method + " using " + xt.String() + " as type " + targ.String()) 429 } 430 } 431 if !isSlice && t.IsVariadic() { 432 // prepare slice for remaining values 433 m := len(in) - n 434 slice := MakeSlice(t.In(n), m, m) 435 elem := t.In(n).Elem() 436 for i := 0; i < m; i++ { 437 x := in[n+i] 438 if xt := x.Type(); !xt.AssignableTo(elem) { 439 panic("reflect: cannot use " + xt.String() + " as type " + elem.String() + " in " + method) 440 } 441 slice.Index(i).Set(x) 442 } 443 origIn := in 444 in = make([]Value, n+1) 445 copy(in[:n], origIn) 446 in[n] = slice 447 } 448 449 nin := len(in) 450 if nin != t.NumIn() { 451 panic("reflect.Value.Call: wrong argument count") 452 } 453 nout := t.NumOut() 454 455 // Compute arg size & allocate. 456 // This computation is 5g/6g/8g-dependent 457 // and probably wrong for gccgo, but so 458 // is most of this function. 459 size := uintptr(0) 460 if v.flag&flagMethod != 0 { 461 // extra word for receiver interface word 462 size += ptrSize 463 } 464 for i := 0; i < nin; i++ { 465 tv := t.In(i) 466 a := uintptr(tv.Align()) 467 size = (size + a - 1) &^ (a - 1) 468 size += tv.Size() 469 } 470 size = (size + ptrSize - 1) &^ (ptrSize - 1) 471 for i := 0; i < nout; i++ { 472 tv := t.Out(i) 473 a := uintptr(tv.Align()) 474 size = (size + a - 1) &^ (a - 1) 475 size += tv.Size() 476 } 477 478 // size must be > 0 in order for &args[0] to be valid. 479 // the argument copying is going to round it up to 480 // a multiple of ptrSize anyway, so make it ptrSize to begin with. 481 if size < ptrSize { 482 size = ptrSize 483 } 484 485 // round to pointer size 486 size = (size + ptrSize - 1) &^ (ptrSize - 1) 487 488 // Copy into args. 489 // 490 // TODO(rsc): revisit when reference counting happens. 491 // The values are holding up the in references for us, 492 // but something must be done for the out references. 493 // For now make everything look like a pointer by pretending 494 // to allocate a []*int. 495 args := make([]*int, size/ptrSize) 496 ptr := uintptr(unsafe.Pointer(&args[0])) 497 off := uintptr(0) 498 if v.flag&flagMethod != 0 { 499 // Hard-wired first argument. 500 *(*iword)(unsafe.Pointer(ptr)) = rcvr 501 off = ptrSize 502 } 503 for i, v := range in { 504 v.mustBeExported() 505 targ := t.In(i).(*commonType) 506 a := uintptr(targ.align) 507 off = (off + a - 1) &^ (a - 1) 508 n := targ.size 509 addr := unsafe.Pointer(ptr + off) 510 v = v.assignTo("reflect.Value.Call", targ, (*interface{})(addr)) 511 if v.flag&flagIndir == 0 { 512 storeIword(addr, iword(v.val), n) 513 } else { 514 memmove(addr, v.val, n) 515 } 516 off += n 517 } 518 off = (off + ptrSize - 1) &^ (ptrSize - 1) 519 520 // Call. 521 call(fn, unsafe.Pointer(ptr), uint32(size)) 522 523 // Copy return values out of args. 524 // 525 // TODO(rsc): revisit like above. 526 ret := make([]Value, nout) 527 for i := 0; i < nout; i++ { 528 tv := t.Out(i) 529 a := uintptr(tv.Align()) 530 off = (off + a - 1) &^ (a - 1) 531 fl := flagIndir | flag(tv.Kind())<<flagKindShift 532 ret[i] = Value{tv.common(), unsafe.Pointer(ptr + off), fl} 533 off += tv.Size() 534 } 535 536 return ret 537 } 538 539 // Cap returns v's capacity. 540 // It panics if v's Kind is not Array, Chan, or Slice. 541 func (v Value) Cap() int { 542 k := v.kind() 543 switch k { 544 case Array: 545 return v.typ.Len() 546 case Chan: 547 return int(chancap(v.iword())) 548 case Slice: 549 // Slice is always bigger than a word; assume flagIndir. 550 return (*SliceHeader)(v.val).Cap 551 } 552 panic(&ValueError{"reflect.Value.Cap", k}) 553 } 554 555 // Close closes the channel v. 556 // It panics if v's Kind is not Chan. 557 func (v Value) Close() { 558 v.mustBe(Chan) 559 v.mustBeExported() 560 chanclose(v.iword()) 561 } 562 563 // Complex returns v's underlying value, as a complex128. 564 // It panics if v's Kind is not Complex64 or Complex128 565 func (v Value) Complex() complex128 { 566 k := v.kind() 567 switch k { 568 case Complex64: 569 if v.flag&flagIndir != 0 { 570 return complex128(*(*complex64)(v.val)) 571 } 572 return complex128(*(*complex64)(unsafe.Pointer(&v.val))) 573 case Complex128: 574 // complex128 is always bigger than a word; assume flagIndir. 575 return *(*complex128)(v.val) 576 } 577 panic(&ValueError{"reflect.Value.Complex", k}) 578 } 579 580 // Elem returns the value that the interface v contains 581 // or that the pointer v points to. 582 // It panics if v's Kind is not Interface or Ptr. 583 // It returns the zero Value if v is nil. 584 func (v Value) Elem() Value { 585 k := v.kind() 586 switch k { 587 case Interface: 588 var ( 589 typ *commonType 590 val unsafe.Pointer 591 ) 592 if v.typ.NumMethod() == 0 { 593 eface := (*emptyInterface)(v.val) 594 if eface.typ == nil { 595 // nil interface value 596 return Value{} 597 } 598 typ = toCommonType(eface.typ) 599 val = unsafe.Pointer(eface.word) 600 } else { 601 iface := (*nonEmptyInterface)(v.val) 602 if iface.itab == nil { 603 // nil interface value 604 return Value{} 605 } 606 typ = toCommonType(iface.itab.typ) 607 val = unsafe.Pointer(iface.word) 608 } 609 fl := v.flag & flagRO 610 fl |= flag(typ.Kind()) << flagKindShift 611 if typ.size > ptrSize { 612 fl |= flagIndir 613 } 614 return Value{typ, val, fl} 615 616 case Ptr: 617 val := v.val 618 if v.flag&flagIndir != 0 { 619 val = *(*unsafe.Pointer)(val) 620 } 621 // The returned value's address is v's value. 622 if val == nil { 623 return Value{} 624 } 625 tt := (*ptrType)(unsafe.Pointer(v.typ)) 626 typ := toCommonType(tt.elem) 627 fl := v.flag&flagRO | flagIndir | flagAddr 628 fl |= flag(typ.Kind() << flagKindShift) 629 return Value{typ, val, fl} 630 } 631 panic(&ValueError{"reflect.Value.Elem", k}) 632 } 633 634 // Field returns the i'th field of the struct v. 635 // It panics if v's Kind is not Struct or i is out of range. 636 func (v Value) Field(i int) Value { 637 v.mustBe(Struct) 638 tt := (*structType)(unsafe.Pointer(v.typ)) 639 if i < 0 || i >= len(tt.fields) { 640 panic("reflect: Field index out of range") 641 } 642 field := &tt.fields[i] 643 typ := toCommonType(field.typ) 644 645 // Inherit permission bits from v. 646 fl := v.flag & (flagRO | flagIndir | flagAddr) 647 // Using an unexported field forces flagRO. 648 if field.pkgPath != nil { 649 fl |= flagRO 650 } 651 fl |= flag(typ.Kind()) << flagKindShift 652 653 var val unsafe.Pointer 654 switch { 655 case fl&flagIndir != 0: 656 // Indirect. Just bump pointer. 657 val = unsafe.Pointer(uintptr(v.val) + field.offset) 658 case bigEndian: 659 // Direct. Discard leading bytes. 660 val = unsafe.Pointer(uintptr(v.val) << (field.offset * 8)) 661 default: 662 // Direct. Discard leading bytes. 663 val = unsafe.Pointer(uintptr(v.val) >> (field.offset * 8)) 664 } 665 666 return Value{typ, val, fl} 667 } 668 669 // FieldByIndex returns the nested field corresponding to index. 670 // It panics if v's Kind is not struct. 671 func (v Value) FieldByIndex(index []int) Value { 672 v.mustBe(Struct) 673 for i, x := range index { 674 if i > 0 { 675 if v.Kind() == Ptr && v.Elem().Kind() == Struct { 676 v = v.Elem() 677 } 678 } 679 v = v.Field(x) 680 } 681 return v 682 } 683 684 // FieldByName returns the struct field with the given name. 685 // It returns the zero Value if no field was found. 686 // It panics if v's Kind is not struct. 687 func (v Value) FieldByName(name string) Value { 688 v.mustBe(Struct) 689 if f, ok := v.typ.FieldByName(name); ok { 690 return v.FieldByIndex(f.Index) 691 } 692 return Value{} 693 } 694 695 // FieldByNameFunc returns the struct field with a name 696 // that satisfies the match function. 697 // It panics if v's Kind is not struct. 698 // It returns the zero Value if no field was found. 699 func (v Value) FieldByNameFunc(match func(string) bool) Value { 700 v.mustBe(Struct) 701 if f, ok := v.typ.FieldByNameFunc(match); ok { 702 return v.FieldByIndex(f.Index) 703 } 704 return Value{} 705 } 706 707 // Float returns v's underlying value, as a float64. 708 // It panics if v's Kind is not Float32 or Float64 709 func (v Value) Float() float64 { 710 k := v.kind() 711 switch k { 712 case Float32: 713 if v.flag&flagIndir != 0 { 714 return float64(*(*float32)(v.val)) 715 } 716 return float64(*(*float32)(unsafe.Pointer(&v.val))) 717 case Float64: 718 if v.flag&flagIndir != 0 { 719 return *(*float64)(v.val) 720 } 721 return *(*float64)(unsafe.Pointer(&v.val)) 722 } 723 panic(&ValueError{"reflect.Value.Float", k}) 724 } 725 726 // Index returns v's i'th element. 727 // It panics if v's Kind is not Array or Slice or i is out of range. 728 func (v Value) Index(i int) Value { 729 k := v.kind() 730 switch k { 731 case Array: 732 tt := (*arrayType)(unsafe.Pointer(v.typ)) 733 if i < 0 || i > int(tt.len) { 734 panic("reflect: array index out of range") 735 } 736 typ := toCommonType(tt.elem) 737 fl := v.flag & (flagRO | flagIndir | flagAddr) // bits same as overall array 738 fl |= flag(typ.Kind()) << flagKindShift 739 offset := uintptr(i) * typ.size 740 741 var val unsafe.Pointer 742 switch { 743 case fl&flagIndir != 0: 744 // Indirect. Just bump pointer. 745 val = unsafe.Pointer(uintptr(v.val) + offset) 746 case bigEndian: 747 // Direct. Discard leading bytes. 748 val = unsafe.Pointer(uintptr(v.val) << (offset * 8)) 749 default: 750 // Direct. Discard leading bytes. 751 val = unsafe.Pointer(uintptr(v.val) >> (offset * 8)) 752 } 753 return Value{typ, val, fl} 754 755 case Slice: 756 // Element flag same as Elem of Ptr. 757 // Addressable, indirect, possibly read-only. 758 fl := flagAddr | flagIndir | v.flag&flagRO 759 s := (*SliceHeader)(v.val) 760 if i < 0 || i >= s.Len { 761 panic("reflect: slice index out of range") 762 } 763 tt := (*sliceType)(unsafe.Pointer(v.typ)) 764 typ := toCommonType(tt.elem) 765 fl |= flag(typ.Kind()) << flagKindShift 766 val := unsafe.Pointer(s.Data + uintptr(i)*typ.size) 767 return Value{typ, val, fl} 768 } 769 panic(&ValueError{"reflect.Value.Index", k}) 770 } 771 772 // Int returns v's underlying value, as an int64. 773 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64. 774 func (v Value) Int() int64 { 775 k := v.kind() 776 var p unsafe.Pointer 777 if v.flag&flagIndir != 0 { 778 p = v.val 779 } else { 780 // The escape analysis is good enough that &v.val 781 // does not trigger a heap allocation. 782 p = unsafe.Pointer(&v.val) 783 } 784 switch k { 785 case Int: 786 return int64(*(*int)(p)) 787 case Int8: 788 return int64(*(*int8)(p)) 789 case Int16: 790 return int64(*(*int16)(p)) 791 case Int32: 792 return int64(*(*int32)(p)) 793 case Int64: 794 return int64(*(*int64)(p)) 795 } 796 panic(&ValueError{"reflect.Value.Int", k}) 797 } 798 799 // CanInterface returns true if Interface can be used without panicking. 800 func (v Value) CanInterface() bool { 801 if v.flag == 0 { 802 panic(&ValueError{"reflect.Value.CanInterface", Invalid}) 803 } 804 return v.flag&(flagMethod|flagRO) == 0 805 } 806 807 // Interface returns v's current value as an interface{}. 808 // It is equivalent to: 809 // var i interface{} = (v's underlying value) 810 // If v is a method obtained by invoking Value.Method 811 // (as opposed to Type.Method), Interface cannot return an 812 // interface value, so it panics. 813 // It also panics if the Value was obtained by accessing 814 // unexported struct fields. 815 func (v Value) Interface() (i interface{}) { 816 return valueInterface(v, true) 817 } 818 819 func valueInterface(v Value, safe bool) interface{} { 820 if v.flag == 0 { 821 panic(&ValueError{"reflect.Value.Interface", 0}) 822 } 823 if v.flag&flagMethod != 0 { 824 panic("reflect.Value.Interface: cannot create interface value for method with bound receiver") 825 } 826 827 if safe && v.flag&flagRO != 0 { 828 // Do not allow access to unexported values via Interface, 829 // because they might be pointers that should not be 830 // writable or methods or function that should not be callable. 831 panic("reflect.Value.Interface: cannot return value obtained from unexported field or method") 832 } 833 834 k := v.kind() 835 if k == Interface { 836 // Special case: return the element inside the interface. 837 // Empty interface has one layout, all interfaces with 838 // methods have a second layout. 839 if v.NumMethod() == 0 { 840 return *(*interface{})(v.val) 841 } 842 return *(*interface { 843 M() 844 })(v.val) 845 } 846 847 // Non-interface value. 848 var eface emptyInterface 849 eface.typ = v.typ.runtimeType() 850 eface.word = v.iword() 851 852 if v.flag&flagIndir != 0 && v.typ.size > ptrSize { 853 // eface.word is a pointer to the actual data, 854 // which might be changed. We need to return 855 // a pointer to unchanging data, so make a copy. 856 ptr := unsafe_New(v.typ) 857 memmove(ptr, unsafe.Pointer(eface.word), v.typ.size) 858 eface.word = iword(ptr) 859 } 860 861 return *(*interface{})(unsafe.Pointer(&eface)) 862 } 863 864 // InterfaceData returns the interface v's value as a uintptr pair. 865 // It panics if v's Kind is not Interface. 866 func (v Value) InterfaceData() [2]uintptr { 867 v.mustBe(Interface) 868 // We treat this as a read operation, so we allow 869 // it even for unexported data, because the caller 870 // has to import "unsafe" to turn it into something 871 // that can be abused. 872 // Interface value is always bigger than a word; assume flagIndir. 873 return *(*[2]uintptr)(v.val) 874 } 875 876 // IsNil returns true if v is a nil value. 877 // It panics if v's Kind is not Chan, Func, Interface, Map, Ptr, or Slice. 878 func (v Value) IsNil() bool { 879 k := v.kind() 880 switch k { 881 case Chan, Func, Map, Ptr: 882 if v.flag&flagMethod != 0 { 883 panic("reflect: IsNil of method Value") 884 } 885 ptr := v.val 886 if v.flag&flagIndir != 0 { 887 ptr = *(*unsafe.Pointer)(ptr) 888 } 889 return ptr == nil 890 case Interface, Slice: 891 // Both interface and slice are nil if first word is 0. 892 // Both are always bigger than a word; assume flagIndir. 893 return *(*unsafe.Pointer)(v.val) == nil 894 } 895 panic(&ValueError{"reflect.Value.IsNil", k}) 896 } 897 898 // IsValid returns true if v represents a value. 899 // It returns false if v is the zero Value. 900 // If IsValid returns false, all other methods except String panic. 901 // Most functions and methods never return an invalid value. 902 // If one does, its documentation states the conditions explicitly. 903 func (v Value) IsValid() bool { 904 return v.flag != 0 905 } 906 907 // Kind returns v's Kind. 908 // If v is the zero Value (IsValid returns false), Kind returns Invalid. 909 func (v Value) Kind() Kind { 910 return v.kind() 911 } 912 913 // Len returns v's length. 914 // It panics if v's Kind is not Array, Chan, Map, Slice, or String. 915 func (v Value) Len() int { 916 k := v.kind() 917 switch k { 918 case Array: 919 tt := (*arrayType)(unsafe.Pointer(v.typ)) 920 return int(tt.len) 921 case Chan: 922 return int(chanlen(v.iword())) 923 case Map: 924 return int(maplen(v.iword())) 925 case Slice: 926 // Slice is bigger than a word; assume flagIndir. 927 return (*SliceHeader)(v.val).Len 928 case String: 929 // String is bigger than a word; assume flagIndir. 930 return (*StringHeader)(v.val).Len 931 } 932 panic(&ValueError{"reflect.Value.Len", k}) 933 } 934 935 // MapIndex returns the value associated with key in the map v. 936 // It panics if v's Kind is not Map. 937 // It returns the zero Value if key is not found in the map or if v represents a nil map. 938 // As in Go, the key's value must be assignable to the map's key type. 939 func (v Value) MapIndex(key Value) Value { 940 v.mustBe(Map) 941 tt := (*mapType)(unsafe.Pointer(v.typ)) 942 943 // Do not require key to be exported, so that DeepEqual 944 // and other programs can use all the keys returned by 945 // MapKeys as arguments to MapIndex. If either the map 946 // or the key is unexported, though, the result will be 947 // considered unexported. This is consistent with the 948 // behavior for structs, which allow read but not write 949 // of unexported fields. 950 key = key.assignTo("reflect.Value.MapIndex", toCommonType(tt.key), nil) 951 952 word, ok := mapaccess(v.typ.runtimeType(), v.iword(), key.iword()) 953 if !ok { 954 return Value{} 955 } 956 typ := toCommonType(tt.elem) 957 fl := (v.flag | key.flag) & flagRO 958 if typ.size > ptrSize { 959 fl |= flagIndir 960 } 961 fl |= flag(typ.Kind()) << flagKindShift 962 return Value{typ, unsafe.Pointer(word), fl} 963 } 964 965 // MapKeys returns a slice containing all the keys present in the map, 966 // in unspecified order. 967 // It panics if v's Kind is not Map. 968 // It returns an empty slice if v represents a nil map. 969 func (v Value) MapKeys() []Value { 970 v.mustBe(Map) 971 tt := (*mapType)(unsafe.Pointer(v.typ)) 972 keyType := toCommonType(tt.key) 973 974 fl := v.flag & flagRO 975 fl |= flag(keyType.Kind()) << flagKindShift 976 if keyType.size > ptrSize { 977 fl |= flagIndir 978 } 979 980 m := v.iword() 981 mlen := int32(0) 982 if m != nil { 983 mlen = maplen(m) 984 } 985 it := mapiterinit(v.typ.runtimeType(), m) 986 a := make([]Value, mlen) 987 var i int 988 for i = 0; i < len(a); i++ { 989 keyWord, ok := mapiterkey(it) 990 if !ok { 991 break 992 } 993 a[i] = Value{keyType, unsafe.Pointer(keyWord), fl} 994 mapiternext(it) 995 } 996 return a[:i] 997 } 998 999 // Method returns a function value corresponding to v's i'th method. 1000 // The arguments to a Call on the returned function should not include 1001 // a receiver; the returned function will always use v as the receiver. 1002 // Method panics if i is out of range. 1003 func (v Value) Method(i int) Value { 1004 if v.typ == nil { 1005 panic(&ValueError{"reflect.Value.Method", Invalid}) 1006 } 1007 if v.flag&flagMethod != 0 || i < 0 || i >= v.typ.NumMethod() { 1008 panic("reflect: Method index out of range") 1009 } 1010 fl := v.flag & (flagRO | flagAddr | flagIndir) 1011 fl |= flag(Func) << flagKindShift 1012 fl |= flag(i)<<flagMethodShift | flagMethod 1013 return Value{v.typ, v.val, fl} 1014 } 1015 1016 // NumMethod returns the number of methods in the value's method set. 1017 func (v Value) NumMethod() int { 1018 if v.typ == nil { 1019 panic(&ValueError{"reflect.Value.NumMethod", Invalid}) 1020 } 1021 if v.flag&flagMethod != 0 { 1022 return 0 1023 } 1024 return v.typ.NumMethod() 1025 } 1026 1027 // MethodByName returns a function value corresponding to the method 1028 // of v with the given name. 1029 // The arguments to a Call on the returned function should not include 1030 // a receiver; the returned function will always use v as the receiver. 1031 // It returns the zero Value if no method was found. 1032 func (v Value) MethodByName(name string) Value { 1033 if v.typ == nil { 1034 panic(&ValueError{"reflect.Value.MethodByName", Invalid}) 1035 } 1036 if v.flag&flagMethod != 0 { 1037 return Value{} 1038 } 1039 m, ok := v.typ.MethodByName(name) 1040 if !ok { 1041 return Value{} 1042 } 1043 return v.Method(m.Index) 1044 } 1045 1046 // NumField returns the number of fields in the struct v. 1047 // It panics if v's Kind is not Struct. 1048 func (v Value) NumField() int { 1049 v.mustBe(Struct) 1050 tt := (*structType)(unsafe.Pointer(v.typ)) 1051 return len(tt.fields) 1052 } 1053 1054 // OverflowComplex returns true if the complex128 x cannot be represented by v's type. 1055 // It panics if v's Kind is not Complex64 or Complex128. 1056 func (v Value) OverflowComplex(x complex128) bool { 1057 k := v.kind() 1058 switch k { 1059 case Complex64: 1060 return overflowFloat32(real(x)) || overflowFloat32(imag(x)) 1061 case Complex128: 1062 return false 1063 } 1064 panic(&ValueError{"reflect.Value.OverflowComplex", k}) 1065 } 1066 1067 // OverflowFloat returns true if the float64 x cannot be represented by v's type. 1068 // It panics if v's Kind is not Float32 or Float64. 1069 func (v Value) OverflowFloat(x float64) bool { 1070 k := v.kind() 1071 switch k { 1072 case Float32: 1073 return overflowFloat32(x) 1074 case Float64: 1075 return false 1076 } 1077 panic(&ValueError{"reflect.Value.OverflowFloat", k}) 1078 } 1079 1080 func overflowFloat32(x float64) bool { 1081 if x < 0 { 1082 x = -x 1083 } 1084 return math.MaxFloat32 <= x && x <= math.MaxFloat64 1085 } 1086 1087 // OverflowInt returns true if the int64 x cannot be represented by v's type. 1088 // It panics if v's Kind is not Int, Int8, int16, Int32, or Int64. 1089 func (v Value) OverflowInt(x int64) bool { 1090 k := v.kind() 1091 switch k { 1092 case Int, Int8, Int16, Int32, Int64: 1093 bitSize := v.typ.size * 8 1094 trunc := (x << (64 - bitSize)) >> (64 - bitSize) 1095 return x != trunc 1096 } 1097 panic(&ValueError{"reflect.Value.OverflowInt", k}) 1098 } 1099 1100 // OverflowUint returns true if the uint64 x cannot be represented by v's type. 1101 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64. 1102 func (v Value) OverflowUint(x uint64) bool { 1103 k := v.kind() 1104 switch k { 1105 case Uint, Uintptr, Uint8, Uint16, Uint32, Uint64: 1106 bitSize := v.typ.size * 8 1107 trunc := (x << (64 - bitSize)) >> (64 - bitSize) 1108 return x != trunc 1109 } 1110 panic(&ValueError{"reflect.Value.OverflowUint", k}) 1111 } 1112 1113 // Pointer returns v's value as a uintptr. 1114 // It returns uintptr instead of unsafe.Pointer so that 1115 // code using reflect cannot obtain unsafe.Pointers 1116 // without importing the unsafe package explicitly. 1117 // It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer. 1118 func (v Value) Pointer() uintptr { 1119 k := v.kind() 1120 switch k { 1121 case Chan, Func, Map, Ptr, UnsafePointer: 1122 if k == Func && v.flag&flagMethod != 0 { 1123 panic("reflect.Value.Pointer of method Value") 1124 } 1125 p := v.val 1126 if v.flag&flagIndir != 0 { 1127 p = *(*unsafe.Pointer)(p) 1128 } 1129 return uintptr(p) 1130 case Slice: 1131 return (*SliceHeader)(v.val).Data 1132 } 1133 panic(&ValueError{"reflect.Value.Pointer", k}) 1134 } 1135 1136 // Recv receives and returns a value from the channel v. 1137 // It panics if v's Kind is not Chan. 1138 // The receive blocks until a value is ready. 1139 // The boolean value ok is true if the value x corresponds to a send 1140 // on the channel, false if it is a zero value received because the channel is closed. 1141 func (v Value) Recv() (x Value, ok bool) { 1142 v.mustBe(Chan) 1143 v.mustBeExported() 1144 return v.recv(false) 1145 } 1146 1147 // internal recv, possibly non-blocking (nb). 1148 // v is known to be a channel. 1149 func (v Value) recv(nb bool) (val Value, ok bool) { 1150 tt := (*chanType)(unsafe.Pointer(v.typ)) 1151 if ChanDir(tt.dir)&RecvDir == 0 { 1152 panic("recv on send-only channel") 1153 } 1154 word, selected, ok := chanrecv(v.typ.runtimeType(), v.iword(), nb) 1155 if selected { 1156 typ := toCommonType(tt.elem) 1157 fl := flag(typ.Kind()) << flagKindShift 1158 if typ.size > ptrSize { 1159 fl |= flagIndir 1160 } 1161 val = Value{typ, unsafe.Pointer(word), fl} 1162 } 1163 return 1164 } 1165 1166 // Send sends x on the channel v. 1167 // It panics if v's kind is not Chan or if x's type is not the same type as v's element type. 1168 // As in Go, x's value must be assignable to the channel's element type. 1169 func (v Value) Send(x Value) { 1170 v.mustBe(Chan) 1171 v.mustBeExported() 1172 v.send(x, false) 1173 } 1174 1175 // internal send, possibly non-blocking. 1176 // v is known to be a channel. 1177 func (v Value) send(x Value, nb bool) (selected bool) { 1178 tt := (*chanType)(unsafe.Pointer(v.typ)) 1179 if ChanDir(tt.dir)&SendDir == 0 { 1180 panic("send on recv-only channel") 1181 } 1182 x.mustBeExported() 1183 x = x.assignTo("reflect.Value.Send", toCommonType(tt.elem), nil) 1184 return chansend(v.typ.runtimeType(), v.iword(), x.iword(), nb) 1185 } 1186 1187 // Set assigns x to the value v. 1188 // It panics if CanSet returns false. 1189 // As in Go, x's value must be assignable to v's type. 1190 func (v Value) Set(x Value) { 1191 v.mustBeAssignable() 1192 x.mustBeExported() // do not let unexported x leak 1193 var target *interface{} 1194 if v.kind() == Interface { 1195 target = (*interface{})(v.val) 1196 } 1197 x = x.assignTo("reflect.Set", v.typ, target) 1198 if x.flag&flagIndir != 0 { 1199 memmove(v.val, x.val, v.typ.size) 1200 } else { 1201 storeIword(v.val, iword(x.val), v.typ.size) 1202 } 1203 } 1204 1205 // SetBool sets v's underlying value. 1206 // It panics if v's Kind is not Bool or if CanSet() is false. 1207 func (v Value) SetBool(x bool) { 1208 v.mustBeAssignable() 1209 v.mustBe(Bool) 1210 *(*bool)(v.val) = x 1211 } 1212 1213 // SetBytes sets v's underlying value. 1214 // It panics if v's underlying value is not a slice of bytes. 1215 func (v Value) SetBytes(x []byte) { 1216 v.mustBeAssignable() 1217 v.mustBe(Slice) 1218 if v.typ.Elem().Kind() != Uint8 { 1219 panic("reflect.Value.SetBytes of non-byte slice") 1220 } 1221 *(*[]byte)(v.val) = x 1222 } 1223 1224 // SetComplex sets v's underlying value to x. 1225 // It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false. 1226 func (v Value) SetComplex(x complex128) { 1227 v.mustBeAssignable() 1228 switch k := v.kind(); k { 1229 default: 1230 panic(&ValueError{"reflect.Value.SetComplex", k}) 1231 case Complex64: 1232 *(*complex64)(v.val) = complex64(x) 1233 case Complex128: 1234 *(*complex128)(v.val) = x 1235 } 1236 } 1237 1238 // SetFloat sets v's underlying value to x. 1239 // It panics if v's Kind is not Float32 or Float64, or if CanSet() is false. 1240 func (v Value) SetFloat(x float64) { 1241 v.mustBeAssignable() 1242 switch k := v.kind(); k { 1243 default: 1244 panic(&ValueError{"reflect.Value.SetFloat", k}) 1245 case Float32: 1246 *(*float32)(v.val) = float32(x) 1247 case Float64: 1248 *(*float64)(v.val) = x 1249 } 1250 } 1251 1252 // SetInt sets v's underlying value to x. 1253 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64, or if CanSet() is false. 1254 func (v Value) SetInt(x int64) { 1255 v.mustBeAssignable() 1256 switch k := v.kind(); k { 1257 default: 1258 panic(&ValueError{"reflect.Value.SetInt", k}) 1259 case Int: 1260 *(*int)(v.val) = int(x) 1261 case Int8: 1262 *(*int8)(v.val) = int8(x) 1263 case Int16: 1264 *(*int16)(v.val) = int16(x) 1265 case Int32: 1266 *(*int32)(v.val) = int32(x) 1267 case Int64: 1268 *(*int64)(v.val) = x 1269 } 1270 } 1271 1272 // SetLen sets v's length to n. 1273 // It panics if v's Kind is not Slice or if n is negative or 1274 // greater than the capacity of the slice. 1275 func (v Value) SetLen(n int) { 1276 v.mustBeAssignable() 1277 v.mustBe(Slice) 1278 s := (*SliceHeader)(v.val) 1279 if n < 0 || n > int(s.Cap) { 1280 panic("reflect: slice length out of range in SetLen") 1281 } 1282 s.Len = n 1283 } 1284 1285 // SetMapIndex sets the value associated with key in the map v to val. 1286 // It panics if v's Kind is not Map. 1287 // If val is the zero Value, SetMapIndex deletes the key from the map. 1288 // As in Go, key's value must be assignable to the map's key type, 1289 // and val's value must be assignable to the map's value type. 1290 func (v Value) SetMapIndex(key, val Value) { 1291 v.mustBe(Map) 1292 v.mustBeExported() 1293 key.mustBeExported() 1294 tt := (*mapType)(unsafe.Pointer(v.typ)) 1295 key = key.assignTo("reflect.Value.SetMapIndex", toCommonType(tt.key), nil) 1296 if val.typ != nil { 1297 val.mustBeExported() 1298 val = val.assignTo("reflect.Value.SetMapIndex", toCommonType(tt.elem), nil) 1299 } 1300 mapassign(v.typ.runtimeType(), v.iword(), key.iword(), val.iword(), val.typ != nil) 1301 } 1302 1303 // SetUint sets v's underlying value to x. 1304 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64, or if CanSet() is false. 1305 func (v Value) SetUint(x uint64) { 1306 v.mustBeAssignable() 1307 switch k := v.kind(); k { 1308 default: 1309 panic(&ValueError{"reflect.Value.SetUint", k}) 1310 case Uint: 1311 *(*uint)(v.val) = uint(x) 1312 case Uint8: 1313 *(*uint8)(v.val) = uint8(x) 1314 case Uint16: 1315 *(*uint16)(v.val) = uint16(x) 1316 case Uint32: 1317 *(*uint32)(v.val) = uint32(x) 1318 case Uint64: 1319 *(*uint64)(v.val) = x 1320 case Uintptr: 1321 *(*uintptr)(v.val) = uintptr(x) 1322 } 1323 } 1324 1325 // SetPointer sets the unsafe.Pointer value v to x. 1326 // It panics if v's Kind is not UnsafePointer. 1327 func (v Value) SetPointer(x unsafe.Pointer) { 1328 v.mustBeAssignable() 1329 v.mustBe(UnsafePointer) 1330 *(*unsafe.Pointer)(v.val) = x 1331 } 1332 1333 // SetString sets v's underlying value to x. 1334 // It panics if v's Kind is not String or if CanSet() is false. 1335 func (v Value) SetString(x string) { 1336 v.mustBeAssignable() 1337 v.mustBe(String) 1338 *(*string)(v.val) = x 1339 } 1340 1341 // Slice returns a slice of v. 1342 // It panics if v's Kind is not Array or Slice. 1343 func (v Value) Slice(beg, end int) Value { 1344 var ( 1345 cap int 1346 typ *sliceType 1347 base unsafe.Pointer 1348 ) 1349 switch k := v.kind(); k { 1350 default: 1351 panic(&ValueError{"reflect.Value.Slice", k}) 1352 case Array: 1353 if v.flag&flagAddr == 0 { 1354 panic("reflect.Value.Slice: slice of unaddressable array") 1355 } 1356 tt := (*arrayType)(unsafe.Pointer(v.typ)) 1357 cap = int(tt.len) 1358 typ = (*sliceType)(unsafe.Pointer(toCommonType(tt.slice))) 1359 base = v.val 1360 case Slice: 1361 typ = (*sliceType)(unsafe.Pointer(v.typ)) 1362 s := (*SliceHeader)(v.val) 1363 base = unsafe.Pointer(s.Data) 1364 cap = s.Cap 1365 1366 } 1367 if beg < 0 || end < beg || end > cap { 1368 panic("reflect.Value.Slice: slice index out of bounds") 1369 } 1370 1371 // Declare slice so that gc can see the base pointer in it. 1372 var x []byte 1373 1374 // Reinterpret as *SliceHeader to edit. 1375 s := (*SliceHeader)(unsafe.Pointer(&x)) 1376 s.Data = uintptr(base) + uintptr(beg)*toCommonType(typ.elem).Size() 1377 s.Len = end - beg 1378 s.Cap = cap - beg 1379 1380 fl := v.flag&flagRO | flagIndir | flag(Slice)<<flagKindShift 1381 return Value{typ.common(), unsafe.Pointer(&x), fl} 1382 } 1383 1384 // String returns the string v's underlying value, as a string. 1385 // String is a special case because of Go's String method convention. 1386 // Unlike the other getters, it does not panic if v's Kind is not String. 1387 // Instead, it returns a string of the form "<T value>" where T is v's type. 1388 func (v Value) String() string { 1389 switch k := v.kind(); k { 1390 case Invalid: 1391 return "<invalid Value>" 1392 case String: 1393 return *(*string)(v.val) 1394 } 1395 // If you call String on a reflect.Value of other type, it's better to 1396 // print something than to panic. Useful in debugging. 1397 return "<" + v.typ.String() + " Value>" 1398 } 1399 1400 // TryRecv attempts to receive a value from the channel v but will not block. 1401 // It panics if v's Kind is not Chan. 1402 // If the receive cannot finish without blocking, x is the zero Value. 1403 // The boolean ok is true if the value x corresponds to a send 1404 // on the channel, false if it is a zero value received because the channel is closed. 1405 func (v Value) TryRecv() (x Value, ok bool) { 1406 v.mustBe(Chan) 1407 v.mustBeExported() 1408 return v.recv(true) 1409 } 1410 1411 // TrySend attempts to send x on the channel v but will not block. 1412 // It panics if v's Kind is not Chan. 1413 // It returns true if the value was sent, false otherwise. 1414 // As in Go, x's value must be assignable to the channel's element type. 1415 func (v Value) TrySend(x Value) bool { 1416 v.mustBe(Chan) 1417 v.mustBeExported() 1418 return v.send(x, true) 1419 } 1420 1421 // Type returns v's type. 1422 func (v Value) Type() Type { 1423 f := v.flag 1424 if f == 0 { 1425 panic(&ValueError{"reflect.Value.Type", Invalid}) 1426 } 1427 if f&flagMethod == 0 { 1428 // Easy case 1429 return v.typ 1430 } 1431 1432 // Method value. 1433 // v.typ describes the receiver, not the method type. 1434 i := int(v.flag) >> flagMethodShift 1435 if v.typ.Kind() == Interface { 1436 // Method on interface. 1437 tt := (*interfaceType)(unsafe.Pointer(v.typ)) 1438 if i < 0 || i >= len(tt.methods) { 1439 panic("reflect: broken Value") 1440 } 1441 m := &tt.methods[i] 1442 return toCommonType(m.typ) 1443 } 1444 // Method on concrete type. 1445 ut := v.typ.uncommon() 1446 if ut == nil || i < 0 || i >= len(ut.methods) { 1447 panic("reflect: broken Value") 1448 } 1449 m := &ut.methods[i] 1450 return toCommonType(m.mtyp) 1451 } 1452 1453 // Uint returns v's underlying value, as a uint64. 1454 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64. 1455 func (v Value) Uint() uint64 { 1456 k := v.kind() 1457 var p unsafe.Pointer 1458 if v.flag&flagIndir != 0 { 1459 p = v.val 1460 } else { 1461 // The escape analysis is good enough that &v.val 1462 // does not trigger a heap allocation. 1463 p = unsafe.Pointer(&v.val) 1464 } 1465 switch k { 1466 case Uint: 1467 return uint64(*(*uint)(p)) 1468 case Uint8: 1469 return uint64(*(*uint8)(p)) 1470 case Uint16: 1471 return uint64(*(*uint16)(p)) 1472 case Uint32: 1473 return uint64(*(*uint32)(p)) 1474 case Uint64: 1475 return uint64(*(*uint64)(p)) 1476 case Uintptr: 1477 return uint64(*(*uintptr)(p)) 1478 } 1479 panic(&ValueError{"reflect.Value.Uint", k}) 1480 } 1481 1482 // UnsafeAddr returns a pointer to v's data. 1483 // It is for advanced clients that also import the "unsafe" package. 1484 // It panics if v is not addressable. 1485 func (v Value) UnsafeAddr() uintptr { 1486 if v.typ == nil { 1487 panic(&ValueError{"reflect.Value.UnsafeAddr", Invalid}) 1488 } 1489 if v.flag&flagAddr == 0 { 1490 panic("reflect.Value.UnsafeAddr of unaddressable value") 1491 } 1492 return uintptr(v.val) 1493 } 1494 1495 // StringHeader is the runtime representation of a string. 1496 // It cannot be used safely or portably. 1497 type StringHeader struct { 1498 Data uintptr 1499 Len int 1500 } 1501 1502 // SliceHeader is the runtime representation of a slice. 1503 // It cannot be used safely or portably. 1504 type SliceHeader struct { 1505 Data uintptr 1506 Len int 1507 Cap int 1508 } 1509 1510 func typesMustMatch(what string, t1, t2 Type) { 1511 if t1 != t2 { 1512 panic(what + ": " + t1.String() + " != " + t2.String()) 1513 } 1514 } 1515 1516 // grow grows the slice s so that it can hold extra more values, allocating 1517 // more capacity if needed. It also returns the old and new slice lengths. 1518 func grow(s Value, extra int) (Value, int, int) { 1519 i0 := s.Len() 1520 i1 := i0 + extra 1521 if i1 < i0 { 1522 panic("reflect.Append: slice overflow") 1523 } 1524 m := s.Cap() 1525 if i1 <= m { 1526 return s.Slice(0, i1), i0, i1 1527 } 1528 if m == 0 { 1529 m = extra 1530 } else { 1531 for m < i1 { 1532 if i0 < 1024 { 1533 m += m 1534 } else { 1535 m += m / 4 1536 } 1537 } 1538 } 1539 t := MakeSlice(s.Type(), i1, m) 1540 Copy(t, s) 1541 return t, i0, i1 1542 } 1543 1544 // Append appends the values x to a slice s and returns the resulting slice. 1545 // As in Go, each x's value must be assignable to the slice's element type. 1546 func Append(s Value, x ...Value) Value { 1547 s.mustBe(Slice) 1548 s, i0, i1 := grow(s, len(x)) 1549 for i, j := i0, 0; i < i1; i, j = i+1, j+1 { 1550 s.Index(i).Set(x[j]) 1551 } 1552 return s 1553 } 1554 1555 // AppendSlice appends a slice t to a slice s and returns the resulting slice. 1556 // The slices s and t must have the same element type. 1557 func AppendSlice(s, t Value) Value { 1558 s.mustBe(Slice) 1559 t.mustBe(Slice) 1560 typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem()) 1561 s, i0, i1 := grow(s, t.Len()) 1562 Copy(s.Slice(i0, i1), t) 1563 return s 1564 } 1565 1566 // Copy copies the contents of src into dst until either 1567 // dst has been filled or src has been exhausted. 1568 // It returns the number of elements copied. 1569 // Dst and src each must have kind Slice or Array, and 1570 // dst and src must have the same element type. 1571 func Copy(dst, src Value) int { 1572 dk := dst.kind() 1573 if dk != Array && dk != Slice { 1574 panic(&ValueError{"reflect.Copy", dk}) 1575 } 1576 if dk == Array { 1577 dst.mustBeAssignable() 1578 } 1579 dst.mustBeExported() 1580 1581 sk := src.kind() 1582 if sk != Array && sk != Slice { 1583 panic(&ValueError{"reflect.Copy", sk}) 1584 } 1585 src.mustBeExported() 1586 1587 de := dst.typ.Elem() 1588 se := src.typ.Elem() 1589 typesMustMatch("reflect.Copy", de, se) 1590 1591 n := dst.Len() 1592 if sn := src.Len(); n > sn { 1593 n = sn 1594 } 1595 1596 // If sk is an in-line array, cannot take its address. 1597 // Instead, copy element by element. 1598 if src.flag&flagIndir == 0 { 1599 for i := 0; i < n; i++ { 1600 dst.Index(i).Set(src.Index(i)) 1601 } 1602 return n 1603 } 1604 1605 // Copy via memmove. 1606 var da, sa unsafe.Pointer 1607 if dk == Array { 1608 da = dst.val 1609 } else { 1610 da = unsafe.Pointer((*SliceHeader)(dst.val).Data) 1611 } 1612 if sk == Array { 1613 sa = src.val 1614 } else { 1615 sa = unsafe.Pointer((*SliceHeader)(src.val).Data) 1616 } 1617 memmove(da, sa, uintptr(n)*de.Size()) 1618 return n 1619 } 1620 1621 /* 1622 * constructors 1623 */ 1624 1625 // implemented in package runtime 1626 func unsafe_New(Type) unsafe.Pointer 1627 func unsafe_NewArray(Type, int) unsafe.Pointer 1628 1629 // MakeSlice creates a new zero-initialized slice value 1630 // for the specified slice type, length, and capacity. 1631 func MakeSlice(typ Type, len, cap int) Value { 1632 if typ.Kind() != Slice { 1633 panic("reflect.MakeSlice of non-slice type") 1634 } 1635 if len < 0 { 1636 panic("reflect.MakeSlice: negative len") 1637 } 1638 if cap < 0 { 1639 panic("reflect.MakeSlice: negative cap") 1640 } 1641 if len > cap { 1642 panic("reflect.MakeSlice: len > cap") 1643 } 1644 1645 // Declare slice so that gc can see the base pointer in it. 1646 var x []byte 1647 1648 // Reinterpret as *SliceHeader to edit. 1649 s := (*SliceHeader)(unsafe.Pointer(&x)) 1650 s.Data = uintptr(unsafe_NewArray(typ.Elem(), cap)) 1651 s.Len = len 1652 s.Cap = cap 1653 1654 return Value{typ.common(), unsafe.Pointer(&x), flagIndir | flag(Slice)<<flagKindShift} 1655 } 1656 1657 // MakeChan creates a new channel with the specified type and buffer size. 1658 func MakeChan(typ Type, buffer int) Value { 1659 if typ.Kind() != Chan { 1660 panic("reflect.MakeChan of non-chan type") 1661 } 1662 if buffer < 0 { 1663 panic("reflect.MakeChan: negative buffer size") 1664 } 1665 if typ.ChanDir() != BothDir { 1666 panic("reflect.MakeChan: unidirectional channel type") 1667 } 1668 ch := makechan(typ.runtimeType(), uint32(buffer)) 1669 return Value{typ.common(), unsafe.Pointer(ch), flag(Chan) << flagKindShift} 1670 } 1671 1672 // MakeMap creates a new map of the specified type. 1673 func MakeMap(typ Type) Value { 1674 if typ.Kind() != Map { 1675 panic("reflect.MakeMap of non-map type") 1676 } 1677 m := makemap(typ.runtimeType()) 1678 return Value{typ.common(), unsafe.Pointer(m), flag(Map) << flagKindShift} 1679 } 1680 1681 // Indirect returns the value that v points to. 1682 // If v is a nil pointer, Indirect returns a zero Value. 1683 // If v is not a pointer, Indirect returns v. 1684 func Indirect(v Value) Value { 1685 if v.Kind() != Ptr { 1686 return v 1687 } 1688 return v.Elem() 1689 } 1690 1691 // ValueOf returns a new Value initialized to the concrete value 1692 // stored in the interface i. ValueOf(nil) returns the zero Value. 1693 func ValueOf(i interface{}) Value { 1694 if i == nil { 1695 return Value{} 1696 } 1697 1698 // TODO(rsc): Eliminate this terrible hack. 1699 // In the call to packValue, eface.typ doesn't escape, 1700 // and eface.word is an integer. So it looks like 1701 // i (= eface) doesn't escape. But really it does, 1702 // because eface.word is actually a pointer. 1703 escapes(i) 1704 1705 // For an interface value with the noAddr bit set, 1706 // the representation is identical to an empty interface. 1707 eface := *(*emptyInterface)(unsafe.Pointer(&i)) 1708 typ := toCommonType(eface.typ) 1709 fl := flag(typ.Kind()) << flagKindShift 1710 if typ.size > ptrSize { 1711 fl |= flagIndir 1712 } 1713 return Value{typ, unsafe.Pointer(eface.word), fl} 1714 } 1715 1716 // Zero returns a Value representing a zero value for the specified type. 1717 // The result is different from the zero value of the Value struct, 1718 // which represents no value at all. 1719 // For example, Zero(TypeOf(42)) returns a Value with Kind Int and value 0. 1720 func Zero(typ Type) Value { 1721 if typ == nil { 1722 panic("reflect: Zero(nil)") 1723 } 1724 t := typ.common() 1725 fl := flag(t.Kind()) << flagKindShift 1726 if t.size <= ptrSize { 1727 return Value{t, nil, fl} 1728 } 1729 return Value{t, unsafe_New(typ), fl | flagIndir} 1730 } 1731 1732 // New returns a Value representing a pointer to a new zero value 1733 // for the specified type. That is, the returned Value's Type is PtrTo(t). 1734 func New(typ Type) Value { 1735 if typ == nil { 1736 panic("reflect: New(nil)") 1737 } 1738 ptr := unsafe_New(typ) 1739 fl := flag(Ptr) << flagKindShift 1740 return Value{typ.common().ptrTo(), ptr, fl} 1741 } 1742 1743 // NewAt returns a Value representing a pointer to a value of the 1744 // specified type, using p as that pointer. 1745 func NewAt(typ Type, p unsafe.Pointer) Value { 1746 fl := flag(Ptr) << flagKindShift 1747 return Value{typ.common().ptrTo(), p, fl} 1748 } 1749 1750 // assignTo returns a value v that can be assigned directly to typ. 1751 // It panics if v is not assignable to typ. 1752 // For a conversion to an interface type, target is a suggested scratch space to use. 1753 func (v Value) assignTo(context string, dst *commonType, target *interface{}) Value { 1754 if v.flag&flagMethod != 0 { 1755 panic(context + ": cannot assign method value to type " + dst.String()) 1756 } 1757 1758 switch { 1759 case directlyAssignable(dst, v.typ): 1760 // Overwrite type so that they match. 1761 // Same memory layout, so no harm done. 1762 v.typ = dst 1763 fl := v.flag & (flagRO | flagAddr | flagIndir) 1764 fl |= flag(dst.Kind()) << flagKindShift 1765 return Value{dst, v.val, fl} 1766 1767 case implements(dst, v.typ): 1768 if target == nil { 1769 target = new(interface{}) 1770 } 1771 x := valueInterface(v, false) 1772 if dst.NumMethod() == 0 { 1773 *target = x 1774 } else { 1775 ifaceE2I(dst.runtimeType(), x, unsafe.Pointer(target)) 1776 } 1777 return Value{dst, unsafe.Pointer(target), flagIndir | flag(Interface)<<flagKindShift} 1778 } 1779 1780 // Failed. 1781 panic(context + ": value of type " + v.typ.String() + " is not assignable to type " + dst.String()) 1782 } 1783 1784 // implemented in ../pkg/runtime 1785 func chancap(ch iword) int32 1786 func chanclose(ch iword) 1787 func chanlen(ch iword) int32 1788 func chanrecv(t *runtimeType, ch iword, nb bool) (val iword, selected, received bool) 1789 func chansend(t *runtimeType, ch iword, val iword, nb bool) bool 1790 1791 func makechan(typ *runtimeType, size uint32) (ch iword) 1792 func makemap(t *runtimeType) (m iword) 1793 func mapaccess(t *runtimeType, m iword, key iword) (val iword, ok bool) 1794 func mapassign(t *runtimeType, m iword, key, val iword, ok bool) 1795 func mapiterinit(t *runtimeType, m iword) *byte 1796 func mapiterkey(it *byte) (key iword, ok bool) 1797 func mapiternext(it *byte) 1798 func maplen(m iword) int32 1799 1800 func call(fn, arg unsafe.Pointer, n uint32) 1801 func ifaceE2I(t *runtimeType, src interface{}, dst unsafe.Pointer) 1802 1803 // Dummy annotation marking that the value x escapes, 1804 // for use in cases where the reflect code is so clever that 1805 // the compiler cannot follow. 1806 func escapes(x interface{}) { 1807 if dummy.b { 1808 dummy.x = x 1809 } 1810 } 1811 1812 var dummy struct { 1813 b bool 1814 x interface{} 1815 }