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