OSDN Git Service

Update to current version of Go library (revision 94d654be2064).
[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, pres *bool)
675 func chanrecv(ch, val *byte, pres *bool)
676 func chanclosed(ch *byte) bool
677 func chanclose(ch *byte)
678 func chanlen(ch *byte) int32
679 func chancap(ch *byte) int32
680
681 // Closed returns the result of closed(c) on the underlying channel.
682 func (v *ChanValue) Closed() bool {
683         ch := *(**byte)(v.addr)
684         return chanclosed(ch)
685 }
686
687 // Close closes the channel.
688 func (v *ChanValue) Close() {
689         ch := *(**byte)(v.addr)
690         chanclose(ch)
691 }
692
693 func (v *ChanValue) Len() int {
694         ch := *(**byte)(v.addr)
695         return int(chanlen(ch))
696 }
697
698 func (v *ChanValue) Cap() int {
699         ch := *(**byte)(v.addr)
700         return int(chancap(ch))
701 }
702
703 // internal send; non-blocking if b != nil
704 func (v *ChanValue) send(x Value, b *bool) {
705         t := v.Type().(*ChanType)
706         if t.Dir()&SendDir == 0 {
707                 panic("send on recv-only channel")
708         }
709         typesMustMatch(t.Elem(), x.Type())
710         ch := *(**byte)(v.addr)
711         chansend(ch, (*byte)(x.getAddr()), b)
712 }
713
714 // internal recv; non-blocking if b != nil
715 func (v *ChanValue) recv(b *bool) Value {
716         t := v.Type().(*ChanType)
717         if t.Dir()&RecvDir == 0 {
718                 panic("recv on send-only channel")
719         }
720         ch := *(**byte)(v.addr)
721         x := MakeZero(t.Elem())
722         chanrecv(ch, (*byte)(x.getAddr()), b)
723         return x
724 }
725
726 // Send sends x on the channel v.
727 func (v *ChanValue) Send(x Value) { v.send(x, nil) }
728
729 // Recv receives and returns a value from the channel v.
730 func (v *ChanValue) Recv() Value { return v.recv(nil) }
731
732 // TrySend attempts to sends x on the channel v but will not block.
733 // It returns true if the value was sent, false otherwise.
734 func (v *ChanValue) TrySend(x Value) bool {
735         var ok bool
736         v.send(x, &ok)
737         return ok
738 }
739
740 // TryRecv attempts to receive a value from the channel v but will not block.
741 // It returns the value if one is received, nil otherwise.
742 func (v *ChanValue) TryRecv() Value {
743         var ok bool
744         x := v.recv(&ok)
745         if !ok {
746                 return nil
747         }
748         return x
749 }
750
751 // MakeChan creates a new channel with the specified type and buffer size.
752 func MakeChan(typ *ChanType, buffer int) *ChanValue {
753         if buffer < 0 {
754                 panic("MakeChan: negative buffer size")
755         }
756         if typ.Dir() != BothDir {
757                 panic("MakeChan: unidirectional channel type")
758         }
759         v := MakeZero(typ).(*ChanValue)
760         *(**byte)(v.addr) = makechan((*runtime.ChanType)(unsafe.Pointer(typ)), uint32(buffer))
761         return v
762 }
763
764 /*
765  * func
766  */
767
768 // A FuncValue represents a function value.
769 type FuncValue struct {
770         value       "func"
771         first       *value
772         isInterface bool
773 }
774
775 // IsNil returns whether v is a nil function.
776 func (v *FuncValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
777
778 // Get returns the uintptr value of v.
779 // It is mainly useful for printing.
780 func (v *FuncValue) Get() uintptr { return *(*uintptr)(v.addr) }
781
782 // Set assigns x to v.
783 // The new value x must have the same type as v.
784 func (v *FuncValue) Set(x *FuncValue) {
785         if !v.CanSet() {
786                 panic(cannotSet)
787         }
788         typesMustMatch(v.typ, x.typ)
789         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
790 }
791
792 // Set sets v to the value x.
793 func (v *FuncValue) SetValue(x Value) { v.Set(x.(*FuncValue)) }
794
795 // Method returns a FuncValue corresponding to v's i'th method.
796 // The arguments to a Call on the returned FuncValue
797 // should not include a receiver; the FuncValue will use v
798 // as the receiver.
799 func (v *value) Method(i int) *FuncValue {
800         t := v.Type().uncommon()
801         if t == nil || i < 0 || i >= len(t.methods) {
802                 return nil
803         }
804         p := &t.methods[i]
805         fn := p.tfn
806         fv := &FuncValue{value: value{runtimeToType(p.typ), addr(&fn), 0}, first: v, isInterface: false}
807         return fv
808 }
809
810 // implemented in ../pkg/runtime/*/asm.s
811 func call(typ *FuncType, fnaddr *byte, isInterface bool, params *addr, results *addr)
812
813 // Interface returns the fv as an interface value.
814 // If fv is a method obtained by invoking Value.Method
815 // (as opposed to Type.Method), Interface cannot return an
816 // interface value, so it panics.
817 func (fv *FuncValue) Interface() interface{} {
818         if fv.first != nil {
819                 panic("FuncValue: cannot create interface value for method with bound receiver")
820         }
821         return fv.value.Interface()
822 }
823
824 // Call calls the function fv with input parameters in.
825 // It returns the function's output parameters as Values.
826 func (fv *FuncValue) Call(in []Value) []Value {
827         t := fv.Type().(*FuncType)
828         nin := len(in)
829         if fv.first != nil && !fv.isInterface {
830                 nin++
831         }
832         if nin != t.NumIn() {
833                 panic("FuncValue: wrong argument count")
834         }
835         if fv.first != nil && fv.isInterface {
836                 nin++
837         }
838         nout := t.NumOut()
839
840         params := make([]addr, nin)
841         delta := 0
842         off := 0
843         if v := fv.first; v != nil {
844                 // Hard-wired first argument.
845                 if fv.isInterface {
846                         // v is a single uninterpreted word
847                         params[0] = v.getAddr()
848                 } else {
849                         // v is a real value
850                         tv := v.Type()
851
852                         // This is a method, so we need to always pass
853                         // a pointer.
854                         vAddr := v.getAddr()
855                         if ptv, ok := tv.(*PtrType); ok {
856                                 typesMustMatch(t.In(0), tv)
857                         } else {
858                                 p := addr(new(addr))
859                                 *(*addr)(p) = vAddr
860                                 vAddr = p
861                                 typesMustMatch(t.In(0).(*PtrType).Elem(), tv)
862                         }
863
864                         params[0] = vAddr
865                         delta = 1
866                 }
867                 off = 1
868         }
869         for i, v := range in {
870                 tv := v.Type()
871                 tf := t.In(i + delta)
872
873                 // If this is really a method, and we are explicitly
874                 // passing the object, then we need to pass the address
875                 // of the object instead.  Unfortunately, we don't
876                 // have any way to know that this is a method, so we just
877                 // check the type.  FIXME: This is ugly.
878                 vAddr := v.getAddr()
879                 if i == 0 && tf != tv {
880                         if ptf, ok := tf.(*PtrType); ok {
881                                 p := addr(new(addr))
882                                 *(*addr)(p) = vAddr
883                                 vAddr = p
884                                 tf = ptf.Elem()
885                         }
886                 }
887
888                 typesMustMatch(tf, tv)
889                 params[i+off] = vAddr
890         }
891
892         ret := make([]Value, nout)
893         results := make([]addr, nout)
894         for i := 0; i < nout; i++ {
895                 tv := t.Out(i)
896                 v := MakeZero(tv)
897                 results[i] = v.getAddr()
898                 ret[i] = v
899         }
900
901         call(t, *(**byte)(fv.addr), fv.isInterface, &params[0], &results[0])
902
903         return ret
904 }
905
906 /*
907  * interface
908  */
909
910 // An InterfaceValue represents an interface value.
911 type InterfaceValue struct {
912         value "interface"
913 }
914
915 // IsNil returns whether v is a nil interface value.
916 func (v *InterfaceValue) IsNil() bool { return v.Interface() == nil }
917
918 // No single uinptr Get because v.Interface() is available.
919
920 // Get returns the two words that represent an interface in the runtime.
921 // Those words are useful only when playing unsafe games.
922 func (v *InterfaceValue) Get() [2]uintptr {
923         return *(*[2]uintptr)(v.addr)
924 }
925
926 // Elem returns the concrete value stored in the interface value v.
927 func (v *InterfaceValue) Elem() Value { return NewValue(v.Interface()) }
928
929 // ../runtime/reflect.cgo
930 func setiface(typ *InterfaceType, x *interface{}, addr addr)
931
932 // Set assigns x to v.
933 func (v *InterfaceValue) Set(x Value) {
934         var i interface{}
935         if x != nil {
936                 i = x.Interface()
937         }
938         if !v.CanSet() {
939                 panic(cannotSet)
940         }
941         // Two different representations; see comment in Get.
942         // Empty interface is easy.
943         t := v.typ.(*InterfaceType)
944         if t.NumMethod() == 0 {
945                 *(*interface{})(v.addr) = i
946                 return
947         }
948
949         // Non-empty interface requires a runtime check.
950         setiface(t, &i, v.addr)
951 }
952
953 // Set sets v to the value x.
954 func (v *InterfaceValue) SetValue(x Value) { v.Set(x) }
955
956 // Method returns a FuncValue corresponding to v's i'th method.
957 // The arguments to a Call on the returned FuncValue
958 // should not include a receiver; the FuncValue will use v
959 // as the receiver.
960 func (v *InterfaceValue) Method(i int) *FuncValue {
961         t := v.Type().(*InterfaceType)
962         if t == nil || i < 0 || i >= len(t.methods) {
963                 return nil
964         }
965         p := &t.methods[i]
966
967         // Interface is two words: itable, data.
968         tab := *(**[10000]addr)(v.addr)
969         data := &value{Typeof((*byte)(nil)), addr(uintptr(v.addr) + ptrSize), 0}
970
971         fn := tab[i+1]
972         fv := &FuncValue{value: value{runtimeToType(p.typ), addr(&fn), 0}, first: data, isInterface: true}
973         return fv
974 }
975
976 /*
977  * map
978  */
979
980 // A MapValue represents a map value.
981 type MapValue struct {
982         value "map"
983 }
984
985 // IsNil returns whether v is a nil map value.
986 func (v *MapValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
987
988 // Set assigns x to v.
989 // The new value x must have the same type as v.
990 func (v *MapValue) Set(x *MapValue) {
991         if !v.CanSet() {
992                 panic(cannotSet)
993         }
994         if x == nil {
995                 *(**uintptr)(v.addr) = nil
996                 return
997         }
998         typesMustMatch(v.typ, x.typ)
999         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
1000 }
1001
1002 // Set sets v to the value x.
1003 func (v *MapValue) SetValue(x Value) {
1004         if x == nil {
1005                 v.Set(nil)
1006                 return
1007         }
1008         v.Set(x.(*MapValue))
1009 }
1010
1011 // Get returns the uintptr value of v.
1012 // It is mainly useful for printing.
1013 func (v *MapValue) Get() uintptr { return *(*uintptr)(v.addr) }
1014
1015 // implemented in ../pkg/runtime/reflect.cgo
1016 func mapaccess(m, key, val *byte) bool
1017 func mapassign(m, key, val *byte)
1018 func maplen(m *byte) int32
1019 func mapiterinit(m *byte) *byte
1020 func mapiternext(it *byte)
1021 func mapiterkey(it *byte, key *byte) bool
1022 func makemap(t *runtime.MapType) *byte
1023
1024 // Elem returns the value associated with key in the map v.
1025 // It returns nil if key is not found in the map.
1026 func (v *MapValue) Elem(key Value) Value {
1027         t := v.Type().(*MapType)
1028         typesMustMatch(t.Key(), key.Type())
1029         m := *(**byte)(v.addr)
1030         if m == nil {
1031                 return nil
1032         }
1033         newval := MakeZero(t.Elem())
1034         if !mapaccess(m, (*byte)(key.getAddr()), (*byte)(newval.getAddr())) {
1035                 return nil
1036         }
1037         return newval
1038 }
1039
1040 // SetElem sets the value associated with key in the map v to val.
1041 // If val is nil, Put deletes the key from map.
1042 func (v *MapValue) SetElem(key, val Value) {
1043         t := v.Type().(*MapType)
1044         typesMustMatch(t.Key(), key.Type())
1045         var vaddr *byte
1046         if val != nil {
1047                 typesMustMatch(t.Elem(), val.Type())
1048                 vaddr = (*byte)(val.getAddr())
1049         }
1050         m := *(**byte)(v.addr)
1051         mapassign(m, (*byte)(key.getAddr()), vaddr)
1052 }
1053
1054 // Len returns the number of keys in the map v.
1055 func (v *MapValue) Len() int {
1056         m := *(**byte)(v.addr)
1057         if m == nil {
1058                 return 0
1059         }
1060         return int(maplen(m))
1061 }
1062
1063 // Keys returns a slice containing all the keys present in the map,
1064 // in unspecified order.
1065 func (v *MapValue) Keys() []Value {
1066         tk := v.Type().(*MapType).Key()
1067         m := *(**byte)(v.addr)
1068         mlen := int32(0)
1069         if m != nil {
1070                 mlen = maplen(m)
1071         }
1072         it := mapiterinit(m)
1073         a := make([]Value, mlen)
1074         var i int
1075         for i = 0; i < len(a); i++ {
1076                 k := MakeZero(tk)
1077                 if !mapiterkey(it, (*byte)(k.getAddr())) {
1078                         break
1079                 }
1080                 a[i] = k
1081                 mapiternext(it)
1082         }
1083         return a[0:i]
1084 }
1085
1086 // MakeMap creates a new map of the specified type.
1087 func MakeMap(typ *MapType) *MapValue {
1088         v := MakeZero(typ).(*MapValue)
1089         *(**byte)(v.addr) = makemap((*runtime.MapType)(unsafe.Pointer(typ)))
1090         return v
1091 }
1092
1093 /*
1094  * ptr
1095  */
1096
1097 // A PtrValue represents a pointer.
1098 type PtrValue struct {
1099         value "ptr"
1100 }
1101
1102 // IsNil returns whether v is a nil pointer.
1103 func (v *PtrValue) IsNil() bool { return *(*uintptr)(v.addr) == 0 }
1104
1105 // Get returns the uintptr value of v.
1106 // It is mainly useful for printing.
1107 func (v *PtrValue) Get() uintptr { return *(*uintptr)(v.addr) }
1108
1109 // Set assigns x to v.
1110 // The new value x must have the same type as v, and x.Elem().CanSet() must be true.
1111 func (v *PtrValue) Set(x *PtrValue) {
1112         if x == nil {
1113                 *(**uintptr)(v.addr) = nil
1114                 return
1115         }
1116         if !v.CanSet() {
1117                 panic(cannotSet)
1118         }
1119         if x.flag&canStore == 0 {
1120                 panic("cannot copy pointer obtained from unexported struct field")
1121         }
1122         typesMustMatch(v.typ, x.typ)
1123         // TODO: This will have to move into the runtime
1124         // once the new gc goes in
1125         *(*uintptr)(v.addr) = *(*uintptr)(x.addr)
1126 }
1127
1128 // Set sets v to the value x.
1129 func (v *PtrValue) SetValue(x Value) {
1130         if x == nil {
1131                 v.Set(nil)
1132                 return
1133         }
1134         v.Set(x.(*PtrValue))
1135 }
1136
1137 // PointTo changes v to point to x.
1138 // If x is a nil Value, PointTo sets v to nil.
1139 func (v *PtrValue) PointTo(x Value) {
1140         if x == nil {
1141                 *(**uintptr)(v.addr) = nil
1142                 return
1143         }
1144         if !x.CanSet() {
1145                 panic("cannot set x; cannot point to x")
1146         }
1147         typesMustMatch(v.typ.(*PtrType).Elem(), x.Type())
1148         // TODO: This will have to move into the runtime
1149         // once the new gc goes in.
1150         *(*uintptr)(v.addr) = x.UnsafeAddr()
1151 }
1152
1153 // Elem returns the value that v points to.
1154 // If v is a nil pointer, Elem returns a nil Value.
1155 func (v *PtrValue) Elem() Value {
1156         if v.IsNil() {
1157                 return nil
1158         }
1159         flag := canAddr
1160         if v.flag&canStore != 0 {
1161                 flag |= canSet | canStore
1162         }
1163         return newValue(v.typ.(*PtrType).Elem(), *(*addr)(v.addr), flag)
1164 }
1165
1166 // Indirect returns the value that v points to.
1167 // If v is a nil pointer, Indirect returns a nil Value.
1168 // If v is not a pointer, Indirect returns v.
1169 func Indirect(v Value) Value {
1170         if pv, ok := v.(*PtrValue); ok {
1171                 return pv.Elem()
1172         }
1173         return v
1174 }
1175
1176 /*
1177  * struct
1178  */
1179
1180 // A StructValue represents a struct value.
1181 type StructValue struct {
1182         value "struct"
1183 }
1184
1185 // Set assigns x to v.
1186 // The new value x must have the same type as v.
1187 func (v *StructValue) Set(x *StructValue) {
1188         // TODO: This will have to move into the runtime
1189         // once the gc goes in.
1190         if !v.CanSet() {
1191                 panic(cannotSet)
1192         }
1193         typesMustMatch(v.typ, x.typ)
1194         memmove(v.addr, x.addr, v.typ.Size())
1195 }
1196
1197 // Set sets v to the value x.
1198 func (v *StructValue) SetValue(x Value) { v.Set(x.(*StructValue)) }
1199
1200 // Field returns the i'th field of the struct.
1201 func (v *StructValue) Field(i int) Value {
1202         t := v.typ.(*StructType)
1203         if i < 0 || i >= t.NumField() {
1204                 return nil
1205         }
1206         f := t.Field(i)
1207         flag := v.flag
1208         if f.PkgPath != "" {
1209                 // unexported field
1210                 flag &^= canSet | canStore
1211         }
1212         return newValue(f.Type, addr(uintptr(v.addr)+f.Offset), flag)
1213 }
1214
1215 // FieldByIndex returns the nested field corresponding to index.
1216 func (t *StructValue) FieldByIndex(index []int) (v Value) {
1217         v = t
1218         for i, x := range index {
1219                 if i > 0 {
1220                         if p, ok := v.(*PtrValue); ok {
1221                                 v = p.Elem()
1222                         }
1223                         if s, ok := v.(*StructValue); ok {
1224                                 t = s
1225                         } else {
1226                                 v = nil
1227                                 return
1228                         }
1229                 }
1230                 v = t.Field(x)
1231         }
1232         return
1233 }
1234
1235 // FieldByName returns the struct field with the given name.
1236 // The result is nil if no field was found.
1237 func (t *StructValue) FieldByName(name string) Value {
1238         if f, ok := t.Type().(*StructType).FieldByName(name); ok {
1239                 return t.FieldByIndex(f.Index)
1240         }
1241         return nil
1242 }
1243
1244 // FieldByNameFunc returns the struct field with a name that satisfies the
1245 // match function.
1246 // The result is nil if no field was found.
1247 func (t *StructValue) FieldByNameFunc(match func(string) bool) Value {
1248         if f, ok := t.Type().(*StructType).FieldByNameFunc(match); ok {
1249                 return t.FieldByIndex(f.Index)
1250         }
1251         return nil
1252 }
1253
1254 // NumField returns the number of fields in the struct.
1255 func (v *StructValue) NumField() int { return v.typ.(*StructType).NumField() }
1256
1257 /*
1258  * constructors
1259  */
1260
1261 // NewValue returns a new Value initialized to the concrete value
1262 // stored in the interface i.  NewValue(nil) returns nil.
1263 func NewValue(i interface{}) Value {
1264         if i == nil {
1265                 return nil
1266         }
1267         t, a := unsafe.Reflect(i)
1268         return newValue(canonicalize(toType(t)), addr(a), canSet|canAddr|canStore)
1269 }
1270
1271 func newValue(typ Type, addr addr, flag uint32) Value {
1272         v := value{typ, addr, flag}
1273         switch typ.(type) {
1274         case *ArrayType:
1275                 return &ArrayValue{v}
1276         case *BoolType:
1277                 return &BoolValue{v}
1278         case *ChanType:
1279                 return &ChanValue{v}
1280         case *FloatType:
1281                 return &FloatValue{v}
1282         case *FuncType:
1283                 return &FuncValue{value: v}
1284         case *ComplexType:
1285                 return &ComplexValue{v}
1286         case *IntType:
1287                 return &IntValue{v}
1288         case *InterfaceType:
1289                 return &InterfaceValue{v}
1290         case *MapType:
1291                 return &MapValue{v}
1292         case *PtrType:
1293                 return &PtrValue{v}
1294         case *SliceType:
1295                 return &SliceValue{v}
1296         case *StringType:
1297                 return &StringValue{v}
1298         case *StructType:
1299                 return &StructValue{v}
1300         case *UintType:
1301                 return &UintValue{v}
1302         case *UnsafePointerType:
1303                 return &UnsafePointerValue{v}
1304         }
1305         panic("newValue" + typ.String())
1306 }
1307
1308 // MakeZero returns a zero Value for the specified Type.
1309 func MakeZero(typ Type) Value {
1310         if typ == nil {
1311                 return nil
1312         }
1313         return newValue(typ, addr(unsafe.New(typ)), canSet|canAddr|canStore)
1314 }