OSDN Git Service

Remove the types float and complex.
[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 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 }