libgo/go/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         "unsafe"
  11 )
  12
  13 const ptrSize = uintptr(unsafe.Sizeof((*byte)(nil)))
  14 const cannotSet = "cannot set value obtained via unexported struct field"
  15
  16 type addr unsafe.Pointer
  17
  18 // TODO: This will have to go away when
  19 // the new gc goes in.
  20 func memmove(adst, asrc addr, 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)(addr(dst + i)) = *(*byte)(addr(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)(addr(dst + i)) = *(*byte)(addr(src + i))
  35                 }
  36         default:
  37                 // word copy forward
  38                 for i := uintptr(0); i < n; i += ptrSize {
  39                         *(*uintptr)(addr(dst + i)) = *(*uintptr)(addr(src + i))
  40                 }
  41         }
  42 }
  43
  44 // Value is the common interface to reflection values.
  45 // The implementations of Value (e.g., ArrayValue, StructValue)
  46 // have additional type-specific methods.
  47 type Value interface {
  48         // Type returns the value's type.
  49         Type() Type
  50
  51         // Interface returns the value as an interface{}.
  52         Interface() interface{}
  53
  54         // CanSet returns whether the value can be changed.
  55         // Values obtained by the use of non-exported struct fields
  56         // can be used in Get but not Set.
  57         // If CanSet() returns false, calling the type-specific Set
  58         // will cause a crash.
  59         CanSet() bool
  60
  61         // SetValue assigns v to the value; v must have the same type as the value.
  62         SetValue(v Value)
  63
  64         // Addr returns a pointer to the underlying data.
  65         // It is for advanced clients that also
  66         // import the "unsafe" package.
  67         Addr() uintptr
  68
  69         // Method returns a FuncValue corresponding to the value's i'th method.
  70         // The arguments to a Call on the returned FuncValue
  71         // should not include a receiver; the FuncValue will use
  72         // the value as the receiver.
  73         Method(i int) *FuncValue
  74
  75         getAddr() addr
  76 }
  77
  78 // value is the common implementation of most values.
  79 // It is embedded in other, public struct types, but always
  80 // with a unique tag like "uint" or "float" so that the client cannot
  81 // convert from, say, *UintValue to *FloatValue.
  82 type value struct {
  83         typ    Type
  84         addr   addr
  85         canSet bool
  86 }
  87
  88 func (v *value) Type() Type { return v.typ }
  89
  90 func (v *value) Addr() uintptr { return uintptr(v.addr) }
  91
  92 func (v *value) getAddr() addr { return v.addr }
  93
  94 func (v *value) Interface() interface{} {
  95         if typ, ok := v.typ.(*InterfaceType); ok {
  96                 // There are two different representations of interface values,
  97                 // one if the interface type has methods and one if it doesn't.
  98                 // These two representations require different expressions
  99                 // to extract correctly.
 100                 if typ.NumMethod() == 0 {
 101                         // Extract as interface value without methods.
 102                         return *(*interface{})(v.addr)
 103                 }
 104                 // Extract from v.addr as interface value with methods.
 105                 return *(*interface {
 106                         m()
 107                 })(v.addr)
 108         }
 109         return unsafe.Unreflect(v.typ, unsafe.Pointer(v.addr))
 110 }
 111
 112 func (v *value) CanSet() bool { return v.canSet }
 113
 114 /*
 115  * basic types
 116  */
 117
 118 // BoolValue represents a bool value.
 119 type BoolValue struct {
 120         value "bool"
 121 }
 122
 123 // Get returns the underlying bool value.
 124 func (v *BoolValue) Get() bool { return *(*bool)(v.addr) }
 125
 126 // Set sets v to the value x.
 127 func (v *BoolValue) Set(x bool) {
 128         if !v.canSet {
 129                 panic(cannotSet)
 130         }
 131         *(*bool)(v.addr) = x
 132 }
 133
 134 // Set sets v to the value x.
 135 func (v *BoolValue) SetValue(x Value) { v.Set(x.(*BoolValue).Get()) }
 136
 137 // FloatValue represents a float value.
 138 type FloatValue struct {
 139         value "float"
 140 }
 141
 142 // Get returns the underlying int value.
 143 func (v *FloatValue) Get() float64 {
 144         switch v.typ.(*FloatType).Kind() {
 145         case Float:
 146                 return float64(*(*float)(v.addr))
 147         case Float32:
 148                 return float64(*(*float32)(v.addr))
 149         case Float64:
 150                 return *(*float64)(v.addr)
 151         }
 152         panic("reflect: invalid float kind")
 153 }
 154
 155 // Set sets v to the value x.
 156 func (v *FloatValue) Set(x float64) {
 157         if !v.canSet {
 158                 panic(cannotSet)
 159         }
 160         switch v.typ.(*FloatType).Kind() {
 161         default:
 162                 panic("reflect: invalid float kind")
 163         case Float:
 164                 *(*float)(v.addr) = float(x)
 165         case Float32:
 166                 *(*float32)(v.addr) = float32(x)
 167         case Float64:
 168                 *(*float64)(v.addr) = x
 169         }
 170 }
 171
 172 // Overflow returns true if x cannot be represented by the type of v.
 173 func (v *FloatValue) Overflow(x float64) bool {
 174         if v.typ.Size() == 8 {
 175                 return false
 176         }
 177         if x < 0 {
 178                 x = -x
 179         }
 180         return math.MaxFloat32 < x && x <= math.MaxFloat64
 181 }
 182
 183 // Set sets v to the value x.
 184 func (v *FloatValue) SetValue(x Value) { v.Set(x.(*FloatValue).Get()) }
 185
 186 // ComplexValue represents a complex value.
 187 type ComplexValue struct {
 188         value "complex"
 189 }
 190
 191 // Get returns the underlying complex value.
 192 func (v *ComplexValue) Get() complex128 {
 193         switch v.typ.(*ComplexType).Kind() {
 194         case Complex:
 195                 return complex128(*(*complex)(v.addr))
 196         case Complex64:
 197                 return complex128(*(*complex64)(v.addr))
 198         case Complex128:
 199                 return *(*complex128)(v.addr)
 200         }
 201         panic("reflect: invalid complex kind")
 202 }
 203
 204 // Set sets v to the value x.
 205 func (v *ComplexValue) Set(x complex128) {
 206         if !v.canSet {
 207                 panic(cannotSet)
 208         }
 209         switch v.typ.(*ComplexType).Kind() {
 210         default:
 211                 panic("reflect: invalid complex kind")
 212         case Complex:
 213                 *(*complex)(v.addr) = complex(x)
 214         case Complex64:
 215                 *(*complex64)(v.addr) = complex64(x)
 216         case Complex128:
 217                 *(*complex128)(v.addr) = x
 218         }
 219 }
 220
 221 // Set sets v to the value x.
 222 func (v *ComplexValue) SetValue(x Value) { v.Set(x.(*ComplexValue).Get()) }
 223
 224 // IntValue represents an int value.
 225 type IntValue struct {
 226         value "int"
 227 }
 228
 229 // Get returns the underlying int value.
 230 func (v *IntValue) Get() int64 {
 231         switch v.typ.(*IntType).Kind() {
 232         case Int:
 233                 return int64(*(*int)(v.addr))
 234         case Int8:
 235                 return int64(*(*int8)(v.addr))
 236         case Int16:
 237                 return int64(*(*int16)(v.addr))
 238         case Int32:
 239                 return int64(*(*int32)(v.addr))
 240         case Int64:
 241                 return *(*int64)(v.addr)
 242         }
 243         panic("reflect: invalid int kind")
 244 }
 245
 246 // Set sets v to the value x.
 247 func (v *IntValue) Set(x int64) {
 248         if !v.canSet {
 249                 panic(cannotSet)
 250         }
 251         switch v.typ.(*IntType).Kind() {
 252         default:
 253                 panic("reflect: invalid int kind")
 254         case Int:
 255                 *(*int)(v.addr) = int(x)
 256         case Int8:
 257                 *(*int8)(v.addr) = int8(x)
 258         case Int16:
 259                 *(*int16)(v.addr) = int16(x)
 260         case Int32:
 261                 *(*int32)(v.addr) = int32(x)
 262         case Int64:
 263                 *(*int64)(v.addr) = x
 264         }
 265 }
 266
 267 // Set sets v to the value x.
 268 func (v *IntValue) SetValue(x Value) { v.Set(x.(*IntValue).Get()) }
 269
 270 // Overflow returns true if x cannot be represented by the type of v.
 271 func (v *IntValue) Overflow(x int64) bool {
 272         bitSize := uint(v.typ.Bits())
 273         trunc := (x << (64 - bitSize)) >> (64 - bitSize)
 274         return x != trunc
 275 }
 276
 277 // StringHeader is the runtime representation of a string.
 278 type StringHeader struct {
 279         Data uintptr
 280         Len  int
 281 }
 282
 283 // StringValue represents a string value.
 284 type StringValue struct {
 285         value "string"
 286 }
 287
 288 // Get returns the underlying string value.
 289 func (v *StringValue) Get() string { return *(*string)(v.addr) }
 290
 291 // Set sets v to the value x.
 292 func (v *StringValue) Set(x string) {
 293         if !v.canSet {
 294                 panic(cannotSet)
 295         }
 296         *(*string)(v.addr) = x
 297 }
 298
 299 // Set sets v to the value x.
 300 func (v *StringValue) SetValue(x Value) { v.Set(x.(*StringValue).Get()) }
 301
 302 // UintValue represents a uint value.
 303 type UintValue struct {
 304         value "uint"
 305 }
 306
 307 // Get returns the underlying uuint value.
 308 func (v *UintValue) Get() uint64 {
 309         switch v.typ.(*UintType).Kind() {
 310         case Uint:
 311                 return uint64(*(*uint)(v.addr))
 312         case Uint8:
 313                 return uint64(*(*uint8)(v.addr))
 314         case Uint16:
 315                 return uint64(*(*uint16)(v.addr))
 316         case Uint32:
 317                 return uint64(*(*uint32)(v.addr))
 318         case Uint64:
 319                 return *(*uint64)(v.addr)
 320         case Uintptr:
 321                 return uint64(*(*uintptr)(v.addr))
 322         }
 323         panic("reflect: invalid uint kind")
 324 }
 325
 326 // Set sets v to the value x.
 327 func (v *UintValue) Set(x uint64) {
 328         if !v.canSet {
 329                 panic(cannotSet)
 330         }
 331         switch v.typ.(*UintType).Kind() {
 332         default:
 333                 panic("reflect: invalid uint kind")
 334         case Uint:
 335                 *(*uint)(v.addr) = uint(x)
 336         case Uint8:
 337                 *(*uint8)(v.addr) = uint8(x)
 338         case Uint16:
 339                 *(*uint16)(v.addr) = uint16(x)
 340         case Uint32:
 341                 *(*uint32)(v.addr) = uint32(x)
 342         case Uint64:
 343                 *(*uint64)(v.addr) = x
 344         case Uintptr:
 345                 *(*uintptr)(v.addr) = uintptr(x)
 346         }
 347 }
 348
 349 // Overflow returns true if x cannot be represented by the type of v.
 350 func (v *UintValue) Overflow(x uint64) bool {
 351         bitSize := uint(v.typ.Bits())
 352         trunc := (x << (64 - bitSize)) >> (64 - bitSize)
 353         return x != trunc
 354 }
 355
 356 // Set sets v to the value x.
 357 func (v *UintValue) SetValue(x Value) { v.Set(x.(*UintValue).Get()) }
 358
 359 // UnsafePointerValue represents an unsafe.Pointer value.
 360 type UnsafePointerValue struct {
 361         value "unsafe.Pointer"
 362 }
 363
 364 // Get returns the underlying uintptr value.
 365 // Get returns uintptr, not unsafe.Pointer, so that
 366 // programs that do not import "unsafe" cannot
 367 // obtain a value of unsafe.Pointer type from "reflect".
 368 func (v *UnsafePointerValue) Get() uintptr { return uintptr(*(*unsafe.Pointer)(v.addr)) }
 369
 370 // Set sets v to the value x.
 371 func (v *UnsafePointerValue) Set(x unsafe.Pointer) {
 372         if !v.canSet {
 373                 panic(cannotSet)
 374         }
 375         *(*unsafe.Pointer)(v.addr) = x
 376 }
 377
 378 // Set sets v to the value x.
 379 func (v *UnsafePointerValue) SetValue(x Value) {
 380         v.Set(unsafe.Pointer(x.(*UnsafePointerValue).Get()))
 381 }
 382
 383 func typesMustMatch(t1, t2 Type) {
 384         if t1 != t2 {
 385                 panic("type mismatch: " + t1.String() + " != " + t2.String())
 386         }
 387 }
 388
 389 /*
 390  * array
 391  */
 392
 393 // ArrayOrSliceValue is the common interface
 394 // implemented by both ArrayValue and SliceValue.
 395 type ArrayOrSliceValue interface {
 396         Value
 397         Len() int
 398         Cap() int
 399         Elem(i int) Value
 400         addr() addr
 401 }
 402
 403 // ArrayCopy copies the contents of src into dst until either
 404 // dst has been filled or src has been exhausted.
 405 // It returns the number of elements copied.
 406 // The arrays dst and src must have the same element type.
 407 func ArrayCopy(dst, src ArrayOrSliceValue) int {
 408         // TODO: This will have to move into the runtime
 409         // once the real gc goes in.
 410         de := dst.Type().(ArrayOrSliceType).Elem()
 411         se := src.Type().(ArrayOrSliceType).Elem()
 412         typesMustMatch(de, se)
 413         n := dst.Len()
 414         if xn := src.Len(); n > xn {
 415                 n = xn
 416         }
 417         memmove(dst.addr(), src.addr(), uintptr(n)*de.Size())
 418         return n
 419 }
 420
 421 // An ArrayValue represents an array.
 422 type ArrayValue struct {
 423         value "array"
 424 }
 425
 426 // Len returns the length of the array.
 427 func (v *ArrayValue) Len() int { return v.typ.(*ArrayType).Len() }
 428
 429 // Cap returns the capacity of the array (equal to Len()).
 430 func (v *ArrayValue) Cap() int { return v.typ.(*ArrayType).Len() }
 431
 432 // addr returns the base address of the data in the array.
 433 func (v *ArrayValue) addr() addr { return v.value.addr }
 434
 435 // Set assigns x to v.
 436 // The new value x must have the same type as v.
 437 func (v *ArrayValue) Set(x *ArrayValue) {
 438         if !v.canSet {
 439                 panic(cannotSet)
 440         }
 441         typesMustMatch(v.typ, x.typ)
 442         ArrayCopy(v, x)
 443 }
 444
 445 // Set sets v to the value x.
 446 func (v *ArrayValue) SetValue(x Value) { v.Set(x.(*ArrayValue)) }
 447
 448 // Elem returns the i'th element of v.
 449 func (v *ArrayValue) Elem(i int) Value {
 450         typ := v.typ.(*ArrayType).Elem()
 451         n := v.Len()
 452         if i < 0 || i >= n {
 453                 panic("array index out of bounds")
 454         }
 455         p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size())
 456         return newValue(typ, p, v.canSet)
 457 }
 458
 459 /*
 460  * slice
 461  */
 462
 463 // runtime representation of slice
 464 type SliceHeader struct {
 465         Data uintptr
 466         Len  int
 467         Cap  int
 468 }
 469
 470 // A SliceValue represents a slice.
 471 type SliceValue struct {
 472         value "slice"
 473 }
 474
 475 func (v *SliceValue) slice() *SliceHeader { return (*SliceHeader)(v.value.addr) }
 476
 477 // IsNil returns whether v is a nil slice.
 478 func (v *SliceValue) IsNil() bool { return v.slice().Data == 0 }
 479
 480 // Len returns the length of the slice.
 481 func (v *SliceValue) Len() int { return int(v.slice().Len) }
 482
 483 // Cap returns the capacity of the slice.
 484 func (v *SliceValue) Cap() int { return int(v.slice().Cap) }
 485
 486 // addr returns the base address of the data in the slice.
 487 func (v *SliceValue) addr() addr { return addr(v.slice().Data) }
 488
 489 // SetLen changes the length of v.
 490 // The new length n must be between 0 and the capacity, inclusive.
 491 func (v *SliceValue) SetLen(n int) {
 492         s := v.slice()
 493         if n < 0 || n > int(s.Cap) {
 494                 panic("reflect: slice length out of range in SetLen")
 495         }
 496         s.Len = n
 497 }
 498
 499 // Set assigns x to v.
 500 // The new value x must have the same type as v.
 501 func (v *SliceValue) Set(x *SliceValue) {
 502         if !v.canSet {
 503                 panic(cannotSet)
 504         }
 505         typesMustMatch(v.typ, x.typ)
 506         *v.slice() = *x.slice()
 507 }
 508
 509 // Set sets v to the value x.
 510 func (v *SliceValue) SetValue(x Value) { v.Set(x.(*SliceValue)) }
 511
 512 // Get returns the uintptr address of the v.Cap()'th element.  This gives
 513 // the same result for all slices of the same array.
 514 // It is mainly useful for printing.
 515 func (v *SliceValue) Get() uintptr {
 516         typ := v.typ.(*SliceType)
 517         return uintptr(v.addr()) + uintptr(v.Cap())*typ.Elem().Size()
 518 }
 519
 520 // Slice returns a sub-slice of the slice v.
 521 func (v *SliceValue) Slice(beg, end int) *SliceValue {
 522         cap := v.Cap()
 523         if beg < 0 || end < beg || end > cap {
 524                 panic("slice index out of bounds")
 525         }
 526         typ := v.typ.(*SliceType)
 527         s := new(SliceHeader)
 528         s.Data = uintptr(v.addr()) + uintptr(beg)*typ.Elem().Size()
 529         s.Len = end - beg
 530         s.Cap = cap - beg
 531         return newValue(typ, addr(s), v.canSet).(*SliceValue)
 532 }
 533
 534 // Elem returns the i'th element of v.
 535 func (v *SliceValue) Elem(i int) Value {
 536         typ := v.typ.(*SliceType).Elem()
 537         n := v.Len()
 538         if i < 0 || i >= n {
 539                 panic("reflect: slice index out of range")
 540         }
 541         p := addr(uintptr(v.addr()) + uintptr(i)*typ.Size())
 542         return newValue(typ, p, v.canSet)
 543 }
 544
 545 // MakeSlice creates a new zero-initialized slice value
 546 // for the specified slice type, length, and capacity.
 547 func MakeSlice(typ *SliceType, len, cap int) *SliceValue {
 548         s := &SliceHeader{
 549                 Data: uintptr(unsafe.NewArray(typ.Elem(), cap)),
 550                 Len:  len,
 551                 Cap:  cap,
 552         }
 553         return newValue(typ, addr(s), true).(*SliceValue)
 554 }
 555
 556 /*
 557  * chan
 558  */
 559
 560 // A ChanValue represents a chan.
 561 type ChanValue struct {
 562         value "chan"
 563 }
 564
 565 // IsNil returns whether v is a nil channel.
 566 func (v *ChanValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
 567
 568 // Set assigns x to v.
 569 // The new value x must have the same type as v.
 570 func (v *ChanValue) Set(x *ChanValue) {
 571         if !v.canSet {
 572                 panic(cannotSet)
 573         }
 574         typesMustMatch(v.typ, x.typ)
 575         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
 576 }
 577
 578 // Set sets v to the value x.
 579 func (v *ChanValue) SetValue(x Value) { v.Set(x.(*ChanValue)) }
 580
 581 // Get returns the uintptr value of v.
 582 // It is mainly useful for printing.
 583 func (v *ChanValue) Get() uintptr { return *(*uintptr)(v.addr) }
 584
 585 // implemented in ../pkg/runtime/reflect.cgo
 586 func makechan(typ *runtime.ChanType, size uint32) (ch *byte)
 587 func chansend(ch, val *byte, pres *bool)
 588 func chanrecv(ch, val *byte, pres *bool)
 589 func chanclosed(ch *byte) bool
 590 func chanclose(ch *byte)
 591 func chanlen(ch *byte) int32
 592 func chancap(ch *byte) int32
 593
 594 // Closed returns the result of closed(c) on the underlying channel.
 595 func (v *ChanValue) Closed() bool {
 596         ch := *(**byte)(v.addr)
 597         return chanclosed(ch)
 598 }
 599
 600 // Close closes the channel.
 601 func (v *ChanValue) Close() {
 602         ch := *(**byte)(v.addr)
 603         chanclose(ch)
 604 }
 605
 606 func (v *ChanValue) Len() int {
 607         ch := *(**byte)(v.addr)
 608         return int(chanlen(ch))
 609 }
 610
 611 func (v *ChanValue) Cap() int {
 612         ch := *(**byte)(v.addr)
 613         return int(chancap(ch))
 614 }
 615
 616 // internal send; non-blocking if b != nil
 617 func (v *ChanValue) send(x Value, b *bool) {
 618         t := v.Type().(*ChanType)
 619         if t.Dir()&SendDir == 0 {
 620                 panic("send on recv-only channel")
 621         }
 622         typesMustMatch(t.Elem(), x.Type())
 623         ch := *(**byte)(v.addr)
 624         chansend(ch, (*byte)(x.getAddr()), b)
 625 }
 626
 627 // internal recv; non-blocking if b != nil
 628 func (v *ChanValue) recv(b *bool) Value {
 629         t := v.Type().(*ChanType)
 630         if t.Dir()&RecvDir == 0 {
 631                 panic("recv on send-only channel")
 632         }
 633         ch := *(**byte)(v.addr)
 634         x := MakeZero(t.Elem())
 635         chanrecv(ch, (*byte)(x.getAddr()), b)
 636         return x
 637 }
 638
 639 // Send sends x on the channel v.
 640 func (v *ChanValue) Send(x Value) { v.send(x, nil) }
 641
 642 // Recv receives and returns a value from the channel v.
 643 func (v *ChanValue) Recv() Value { return v.recv(nil) }
 644
 645 // TrySend attempts to sends x on the channel v but will not block.
 646 // It returns true if the value was sent, false otherwise.
 647 func (v *ChanValue) TrySend(x Value) bool {
 648         var ok bool
 649         v.send(x, &ok)
 650         return ok
 651 }
 652
 653 // TryRecv attempts to receive a value from the channel v but will not block.
 654 // It returns the value if one is received, nil otherwise.
 655 func (v *ChanValue) TryRecv() Value {
 656         var ok bool
 657         x := v.recv(&ok)
 658         if !ok {
 659                 return nil
 660         }
 661         return x
 662 }
 663
 664 // MakeChan creates a new channel with the specified type and buffer size.
 665 func MakeChan(typ *ChanType, buffer int) *ChanValue {
 666         if buffer < 0 {
 667                 panic("MakeChan: negative buffer size")
 668         }
 669         if typ.Dir() != BothDir {
 670                 panic("MakeChan: unidirectional channel type")
 671         }
 672         v := MakeZero(typ).(*ChanValue)
 673         *(**byte)(v.addr) = makechan((*runtime.ChanType)(unsafe.Pointer(typ)), uint32(buffer))
 674         return v
 675 }
 676
 677 /*
 678  * func
 679  */
 680
 681 // A FuncValue represents a function value.
 682 type FuncValue struct {
 683         value       "func"
 684         first       *value
 685         isInterface bool
 686 }
 687
 688 // IsNil returns whether v is a nil function.
 689 func (v *FuncValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
 690
 691 // Get returns the uintptr value of v.
 692 // It is mainly useful for printing.
 693 func (v *FuncValue) Get() uintptr { return *(*uintptr)(v.addr) }
 694
 695 // Set assigns x to v.
 696 // The new value x must have the same type as v.
 697 func (v *FuncValue) Set(x *FuncValue) {
 698         if !v.canSet {
 699                 panic(cannotSet)
 700         }
 701         typesMustMatch(v.typ, x.typ)
 702         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
 703 }
 704
 705 // Set sets v to the value x.
 706 func (v *FuncValue) SetValue(x Value) { v.Set(x.(*FuncValue)) }
 707
 708 // Method returns a FuncValue corresponding to v's i'th method.
 709 // The arguments to a Call on the returned FuncValue
 710 // should not include a receiver; the FuncValue will use v
 711 // as the receiver.
 712 func (v *value) Method(i int) *FuncValue {
 713         t := v.Type().uncommon()
 714         if t == nil || i < 0 || i >= len(t.methods) {
 715                 return nil
 716         }
 717         p := &t.methods[i]
 718         fn := p.tfn
 719         fv := &FuncValue{value: value{runtimeToType(p.typ), addr(&fn), true}, first: v, isInterface: false}
 720         return fv
 721 }
 722
 723 // implemented in ../pkg/runtime/*/asm.s
 724 func call(typ *FuncType, fnaddr *byte, isInterface bool, params *addr, results *addr)
 725
 726 // Call calls the function fv with input parameters in.
 727 // It returns the function's output parameters as Values.
 728 func (fv *FuncValue) Call(in []Value) []Value {
 729         t := fv.Type().(*FuncType)
 730         nin := len(in)
 731         if fv.first != nil && !fv.isInterface {
 732                 nin++
 733         }
 734         if nin != t.NumIn() {
 735                 panic("FuncValue: wrong argument count")
 736         }
 737         if fv.first != nil && fv.isInterface {
 738                 nin++
 739         }
 740         nout := t.NumOut()
 741
 742         params := make([]addr, nin)
 743         delta := 0
 744         off := 0
 745         if v := fv.first; v != nil {
 746                 // Hard-wired first argument.
 747                 if fv.isInterface {
 748                         // v is a single uninterpreted word
 749                         params[0] = v.getAddr()
 750                 } else {
 751                         // v is a real value
 752                         tv := v.Type()
 753
 754                         // This is a method, so we need to always pass
 755                         // a pointer.
 756                         vAddr := v.getAddr()
 757                         if ptv, ok := tv.(*PtrType); ok {
 758                                 typesMustMatch(t.In(0), tv)
 759                         } else {
 760                                 p := addr(new(addr))
 761                                 *(*addr)(p) = vAddr
 762                                 vAddr = p
 763                                 typesMustMatch(t.In(0).(*PtrType).Elem(), tv)
 764                         }
 765
 766                         params[0] = vAddr
 767                         delta = 1
 768                 }
 769                 off = 1
 770         }
 771         for i, v := range in {
 772                 tv := v.Type()
 773                 tf := t.In(i + delta)
 774
 775                 // If this is really a method, and we are explicitly
 776                 // passing the object, then we need to pass the address
 777                 // of the object instead.  Unfortunately, we don't
 778                 // have any way to know that this is a method, so we just
 779                 // check the type.  FIXME: This is ugly.
 780                 vAddr := v.getAddr()
 781                 if i == 0 && tf != tv {
 782                         if ptf, ok := tf.(*PtrType); ok {
 783                                 p := addr(new(addr))
 784                                 *(*addr)(p) = vAddr
 785                                 vAddr = p
 786                                 tf = ptf.Elem()
 787                         }
 788                 }
 789
 790                 typesMustMatch(tf, tv)
 791                 params[i+off] = vAddr
 792         }
 793
 794         ret := make([]Value, nout)
 795         results := make([]addr, nout)
 796         for i := 0; i < nout; i++ {
 797                 tv := t.Out(i)
 798                 v := MakeZero(tv)
 799                 results[i] = v.getAddr()
 800                 ret[i] = v
 801         }
 802
 803         call(t, *(**byte)(fv.addr), fv.isInterface, &params[0], &results[0])
 804
 805         return ret
 806 }
 807
 808 /*
 809  * interface
 810  */
 811
 812 // An InterfaceValue represents an interface value.
 813 type InterfaceValue struct {
 814         value "interface"
 815 }
 816
 817 // IsNil returns whether v is a nil interface value.
 818 func (v *InterfaceValue) IsNil() bool { return v.Interface() == nil }
 819
 820 // No single uinptr Get because v.Interface() is available.
 821
 822 // Get returns the two words that represent an interface in the runtime.
 823 // Those words are useful only when playing unsafe games.
 824 func (v *InterfaceValue) Get() [2]uintptr {
 825         return *(*[2]uintptr)(v.addr)
 826 }
 827
 828 // Elem returns the concrete value stored in the interface value v.
 829 func (v *InterfaceValue) Elem() Value { return NewValue(v.Interface()) }
 830
 831 // ../runtime/reflect.cgo
 832 func setiface(typ *InterfaceType, x *interface{}, addr addr)
 833
 834 // Set assigns x to v.
 835 func (v *InterfaceValue) Set(x Value) {
 836         var i interface{}
 837         if x != nil {
 838                 i = x.Interface()
 839         }
 840         if !v.canSet {
 841                 panic(cannotSet)
 842         }
 843         // Two different representations; see comment in Get.
 844         // Empty interface is easy.
 845         t := v.typ.(*InterfaceType)
 846         if t.NumMethod() == 0 {
 847                 *(*interface{})(v.addr) = i
 848                 return
 849         }
 850
 851         // Non-empty interface requires a runtime check.
 852         setiface(t, &i, v.addr)
 853 }
 854
 855 // Set sets v to the value x.
 856 func (v *InterfaceValue) SetValue(x Value) { v.Set(x) }
 857
 858 // Method returns a FuncValue corresponding to v's i'th method.
 859 // The arguments to a Call on the returned FuncValue
 860 // should not include a receiver; the FuncValue will use v
 861 // as the receiver.
 862 func (v *InterfaceValue) Method(i int) *FuncValue {
 863         t := v.Type().(*InterfaceType)
 864         if t == nil || i < 0 || i >= len(t.methods) {
 865                 return nil
 866         }
 867         p := &t.methods[i]
 868
 869         // Interface is two words: itable, data.
 870         tab := *(**[10000]addr)(v.addr)
 871         data := &value{Typeof((*byte)(nil)), addr(uintptr(v.addr) + ptrSize), true}
 872
 873         fn := tab[i+1]
 874         fv := &FuncValue{value: value{runtimeToType(p.typ), addr(&fn), true}, first: data, isInterface: true}
 875         return fv
 876 }
 877
 878 /*
 879  * map
 880  */
 881
 882 // A MapValue represents a map value.
 883 type MapValue struct {
 884         value "map"
 885 }
 886
 887 // IsNil returns whether v is a nil map value.
 888 func (v *MapValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
 889
 890 // Set assigns x to v.
 891 // The new value x must have the same type as v.
 892 func (v *MapValue) Set(x *MapValue) {
 893         if !v.canSet {
 894                 panic(cannotSet)
 895         }
 896         if x == nil {
 897                 *(**uintptr)(v.addr) = nil
 898                 return
 899         }
 900         typesMustMatch(v.typ, x.typ)
 901         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
 902 }
 903
 904 // Set sets v to the value x.
 905 func (v *MapValue) SetValue(x Value) {
 906         if x == nil {
 907                 v.Set(nil)
 908                 return
 909         }
 910         v.Set(x.(*MapValue))
 911 }
 912
 913 // Get returns the uintptr value of v.
 914 // It is mainly useful for printing.
 915 func (v *MapValue) Get() uintptr { return *(*uintptr)(v.addr) }
 916
 917 // implemented in ../pkg/runtime/reflect.cgo
 918 func mapaccess(m, key, val *byte) bool
 919 func mapassign(m, key, val *byte)
 920 func maplen(m *byte) int32
 921 func mapiterinit(m *byte) *byte
 922 func mapiternext(it *byte)
 923 func mapiterkey(it *byte, key *byte) bool
 924 func makemap(t *runtime.MapType) *byte
 925
 926 // Elem returns the value associated with key in the map v.
 927 // It returns nil if key is not found in the map.
 928 func (v *MapValue) Elem(key Value) Value {
 929         t := v.Type().(*MapType)
 930         typesMustMatch(t.Key(), key.Type())
 931         m := *(**byte)(v.addr)
 932         if m == nil {
 933                 return nil
 934         }
 935         newval := MakeZero(t.Elem())
 936         if !mapaccess(m, (*byte)(key.getAddr()), (*byte)(newval.getAddr())) {
 937                 return nil
 938         }
 939         return newval
 940 }
 941
 942 // SetElem sets the value associated with key in the map v to val.
 943 // If val is nil, Put deletes the key from map.
 944 func (v *MapValue) SetElem(key, val Value) {
 945         t := v.Type().(*MapType)
 946         typesMustMatch(t.Key(), key.Type())
 947         var vaddr *byte
 948         if val != nil {
 949                 typesMustMatch(t.Elem(), val.Type())
 950                 vaddr = (*byte)(val.getAddr())
 951         }
 952         m := *(**byte)(v.addr)
 953         mapassign(m, (*byte)(key.getAddr()), vaddr)
 954 }
 955
 956 // Len returns the number of keys in the map v.
 957 func (v *MapValue) Len() int {
 958         m := *(**byte)(v.addr)
 959         if m == nil {
 960                 return 0
 961         }
 962         return int(maplen(m))
 963 }
 964
 965 // Keys returns a slice containing all the keys present in the map,
 966 // in unspecified order.
 967 func (v *MapValue) Keys() []Value {
 968         tk := v.Type().(*MapType).Key()
 969         m := *(**byte)(v.addr)
 970         mlen := int32(0)
 971         if m != nil {
 972                 mlen = maplen(m)
 973         }
 974         it := mapiterinit(m)
 975         a := make([]Value, mlen)
 976         var i int
 977         for i = 0; i < len(a); i++ {
 978                 k := MakeZero(tk)
 979                 if !mapiterkey(it, (*byte)(k.getAddr())) {
 980                         break
 981                 }
 982                 a[i] = k
 983                 mapiternext(it)
 984         }
 985         return a[0:i]
 986 }
 987
 988 // MakeMap creates a new map of the specified type.
 989 func MakeMap(typ *MapType) *MapValue {
 990         v := MakeZero(typ).(*MapValue)
 991         *(**byte)(v.addr) = makemap((*runtime.MapType)(unsafe.Pointer(typ)))
 992         return v
 993 }
 994
 995 /*
 996  * ptr
 997  */
 998
 999 // A PtrValue represents a pointer.
1000 type PtrValue struct {
1001         value "ptr"
1002 }
1003
1004 // IsNil returns whether v is a nil pointer.
1005 func (v *PtrValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
1006
1007 // Get returns the uintptr value of v.
1008 // It is mainly useful for printing.
1009 func (v *PtrValue) Get() uintptr { return *(*uintptr)(v.addr) }
1010
1011 // Set assigns x to v.
1012 // The new value x must have the same type as v.
1013 func (v *PtrValue) Set(x *PtrValue) {
1014         if x == nil {
1015                 *(**uintptr)(v.addr) = nil
1016                 return
1017         }
1018         if !v.canSet {
1019                 panic(cannotSet)
1020         }
1021         typesMustMatch(v.typ, x.typ)
1022         // TODO: This will have to move into the runtime
1023         // once the new gc goes in
1024         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
1025 }
1026
1027 // Set sets v to the value x.
1028 func (v *PtrValue) SetValue(x Value) {
1029         if x == nil {
1030                 v.Set(nil)
1031                 return
1032         }
1033         v.Set(x.(*PtrValue))
1034 }
1035
1036 // PointTo changes v to point to x.
1037 // If x is a nil Value, PointTo sets v to nil.
1038 func (v *PtrValue) PointTo(x Value) {
1039         if x == nil {
1040                 *(**uintptr)(v.addr) = nil
1041                 return
1042         }
1043         if !x.CanSet() {
1044                 panic("cannot set x; cannot point to x")
1045         }
1046         typesMustMatch(v.typ.(*PtrType).Elem(), x.Type())
1047         // TODO: This will have to move into the runtime
1048         // once the new gc goes in.
1049         *(*uintptr)(v.addr) = x.Addr()
1050 }
1051
1052 // Elem returns the value that v points to.
1053 // If v is a nil pointer, Elem returns a nil Value.
1054 func (v *PtrValue) Elem() Value {
1055         if v.IsNil() {
1056                 return nil
1057         }
1058         return newValue(v.typ.(*PtrType).Elem(), *(*addr)(v.addr), v.canSet)
1059 }
1060
1061 // Indirect returns the value that v points to.
1062 // If v is a nil pointer, Indirect returns a nil Value.
1063 // If v is not a pointer, Indirect returns v.
1064 func Indirect(v Value) Value {
1065         if pv, ok := v.(*PtrValue); ok {
1066                 return pv.Elem()
1067         }
1068         return v
1069 }
1070
1071 /*
1072  * struct
1073  */
1074
1075 // A StructValue represents a struct value.
1076 type StructValue struct {
1077         value "struct"
1078 }
1079
1080 // Set assigns x to v.
1081 // The new value x must have the same type as v.
1082 func (v *StructValue) Set(x *StructValue) {
1083         // TODO: This will have to move into the runtime
1084         // once the gc goes in.
1085         if !v.canSet {
1086                 panic(cannotSet)
1087         }
1088         typesMustMatch(v.typ, x.typ)
1089         memmove(v.addr, x.addr, v.typ.Size())
1090 }
1091
1092 // Set sets v to the value x.
1093 func (v *StructValue) SetValue(x Value) { v.Set(x.(*StructValue)) }
1094
1095 // Field returns the i'th field of the struct.
1096 func (v *StructValue) Field(i int) Value {
1097         t := v.typ.(*StructType)
1098         if i < 0 || i >= t.NumField() {
1099                 return nil
1100         }
1101         f := t.Field(i)
1102         return newValue(f.Type, addr(uintptr(v.addr)+f.Offset), v.canSet && f.PkgPath == "")
1103 }
1104
1105 // FieldByIndex returns the nested field corresponding to index.
1106 func (t *StructValue) FieldByIndex(index []int) (v Value) {
1107         v = t
1108         for i, x := range index {
1109                 if i > 0 {
1110                         if p, ok := v.(*PtrValue); ok {
1111                                 v = p.Elem()
1112                         }
1113                         if s, ok := v.(*StructValue); ok {
1114                                 t = s
1115                         } else {
1116                                 v = nil
1117                                 return
1118                         }
1119                 }
1120                 v = t.Field(x)
1121         }
1122         return
1123 }
1124
1125 // FieldByName returns the struct field with the given name.
1126 // The result is nil if no field was found.
1127 func (t *StructValue) FieldByName(name string) Value {
1128         if f, ok := t.Type().(*StructType).FieldByName(name); ok {
1129                 return t.FieldByIndex(f.Index)
1130         }
1131         return nil
1132 }
1133
1134 // FieldByNameFunc returns the struct field with a name that satisfies the
1135 // match function.
1136 // The result is nil if no field was found.
1137 func (t *StructValue) FieldByNameFunc(match func(string) bool) Value {
1138         if f, ok := t.Type().(*StructType).FieldByNameFunc(match); ok {
1139                 return t.FieldByIndex(f.Index)
1140         }
1141         return nil
1142 }
1143
1144 // NumField returns the number of fields in the struct.
1145 func (v *StructValue) NumField() int { return v.typ.(*StructType).NumField() }
1146
1147 /*
1148  * constructors
1149  */
1150
1151 // NewValue returns a new Value initialized to the concrete value
1152 // stored in the interface i.  NewValue(nil) returns nil.
1153 func NewValue(i interface{}) Value {
1154         if i == nil {
1155                 return nil
1156         }
1157         t, a := unsafe.Reflect(i)
1158         return newValue(canonicalize(toType(t)), addr(a), true)
1159 }
1160
1161 func newValue(typ Type, addr addr, canSet bool) Value {
1162         v := value{typ, addr, canSet}
1163         switch typ.(type) {
1164         case *ArrayType:
1165                 return &ArrayValue{v}
1166         case *BoolType:
1167                 return &BoolValue{v}
1168         case *ChanType:
1169                 return &ChanValue{v}
1170         case *FloatType:
1171                 return &FloatValue{v}
1172         case *FuncType:
1173                 return &FuncValue{value: v}
1174         case *ComplexType:
1175                 return &ComplexValue{v}
1176         case *IntType:
1177                 return &IntValue{v}
1178         case *InterfaceType:
1179                 return &InterfaceValue{v}
1180         case *MapType:
1181                 return &MapValue{v}
1182         case *PtrType:
1183                 return &PtrValue{v}
1184         case *SliceType:
1185                 return &SliceValue{v}
1186         case *StringType:
1187                 return &StringValue{v}
1188         case *StructType:
1189                 return &StructValue{v}
1190         case *UintType:
1191                 return &UintValue{v}
1192         case *UnsafePointerType:
1193                 return &UnsafePointerValue{v}
1194         }
1195         panic("newValue" + typ.String())
1196 }
1197
1198 // MakeZero returns a zero Value for the specified Type.
1199 func MakeZero(typ Type) Value {
1200         if typ == nil {
1201                 return nil
1202         }
1203         return newValue(typ, addr(unsafe.New(typ)), true)
1204 }