OSDN Git Service

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