OSDN Git Service

Update to current version of Go library.
[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         "strconv"
11         "unsafe"
12 )
13
14 const ptrSize = uintptr(unsafe.Sizeof((*byte)(nil)))
15 const cannotSet = "cannot set value obtained from unexported struct field"
16
17 // TODO: This will have to go away when
18 // the new gc goes in.
19 func memmove(adst, asrc unsafe.Pointer, n uintptr) {
20         dst := uintptr(adst)
21         src := uintptr(asrc)
22         switch {
23         case src < dst && src+n > dst:
24                 // byte copy backward
25                 // careful: i is unsigned
26                 for i := n; i > 0; {
27                         i--
28                         *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(src + i))
29                 }
30         case (n|src|dst)&(ptrSize-1) != 0:
31                 // byte copy forward
32                 for i := uintptr(0); i < n; i++ {
33                         *(*byte)(unsafe.Pointer(dst + i)) = *(*byte)(unsafe.Pointer(src + i))
34                 }
35         default:
36                 // word copy forward
37                 for i := uintptr(0); i < n; i += ptrSize {
38                         *(*uintptr)(unsafe.Pointer(dst + i)) = *(*uintptr)(unsafe.Pointer(src + i))
39                 }
40         }
41 }
42
43 // Value is the reflection interface to a Go value.
44 //
45 // Not all methods apply to all kinds of values.  Restrictions,
46 // if any, are noted in the documentation for each method.
47 // Use the Kind method to find out the kind of value before
48 // calling kind-specific methods.  Calling a method
49 // inappropriate to the kind of type causes a run time panic.
50 //
51 // The zero Value represents no value.
52 // Its IsValid method returns false, its Kind method returns Invalid,
53 // its String method returns "<invalid Value>", and all other methods panic.
54 // Most functions and methods never return an invalid value.
55 // If one does, its documentation states the conditions explicitly.
56 //
57 // The fields of Value are exported so that clients can copy and
58 // pass Values around, but they should not be edited or inspected
59 // directly.  A future language change may make it possible not to
60 // export these fields while still keeping Values usable as values.
61 type Value struct {
62         Internal       interface{}
63         InternalMethod int
64 }
65
66 // A ValueError occurs when a Value method is invoked on
67 // a Value that does not support it.  Such cases are documented
68 // in the description of each method.
69 type ValueError struct {
70         Method string
71         Kind   Kind
72 }
73
74 func (e *ValueError) String() string {
75         if e.Kind == 0 {
76                 return "reflect: call of " + e.Method + " on zero Value"
77         }
78         return "reflect: call of " + e.Method + " on " + e.Kind.String() + " Value"
79 }
80
81 // methodName returns the name of the calling method,
82 // assumed to be two stack frames above.
83 func methodName() string {
84         pc, _, _, _ := runtime.Caller(2)
85         f := runtime.FuncForPC(pc)
86         if f == nil {
87                 return "unknown method"
88         }
89         return f.Name()
90 }
91
92 // An iword is the word that would be stored in an
93 // interface to represent a given value v.  Specifically, if v is
94 // bigger than a pointer, its word is a pointer to v's data.
95 // Otherwise, its word is a zero uintptr with the data stored
96 // in the leading bytes.
97 type iword uintptr
98
99 func loadIword(p unsafe.Pointer, size uintptr) iword {
100         // Run the copy ourselves instead of calling memmove
101         // to avoid moving v to the heap.
102         w := iword(0)
103         switch size {
104         default:
105                 panic("reflect: internal error: loadIword of " + strconv.Itoa(int(size)) + "-byte value")
106         case 0:
107         case 1:
108                 *(*uint8)(unsafe.Pointer(&w)) = *(*uint8)(p)
109         case 2:
110                 *(*uint16)(unsafe.Pointer(&w)) = *(*uint16)(p)
111         case 3:
112                 *(*[3]byte)(unsafe.Pointer(&w)) = *(*[3]byte)(p)
113         case 4:
114                 *(*uint32)(unsafe.Pointer(&w)) = *(*uint32)(p)
115         case 5:
116                 *(*[5]byte)(unsafe.Pointer(&w)) = *(*[5]byte)(p)
117         case 6:
118                 *(*[6]byte)(unsafe.Pointer(&w)) = *(*[6]byte)(p)
119         case 7:
120                 *(*[7]byte)(unsafe.Pointer(&w)) = *(*[7]byte)(p)
121         case 8:
122                 *(*uint64)(unsafe.Pointer(&w)) = *(*uint64)(p)
123         }
124         return w
125 }
126
127 func storeIword(p unsafe.Pointer, w iword, size uintptr) {
128         // Run the copy ourselves instead of calling memmove
129         // to avoid moving v to the heap.
130         switch size {
131         default:
132                 panic("reflect: internal error: storeIword of " + strconv.Itoa(int(size)) + "-byte value")
133         case 0:
134         case 1:
135                 *(*uint8)(p) = *(*uint8)(unsafe.Pointer(&w))
136         case 2:
137                 *(*uint16)(p) = *(*uint16)(unsafe.Pointer(&w))
138         case 3:
139                 *(*[3]byte)(p) = *(*[3]byte)(unsafe.Pointer(&w))
140         case 4:
141                 *(*uint32)(p) = *(*uint32)(unsafe.Pointer(&w))
142         case 5:
143                 *(*[5]byte)(p) = *(*[5]byte)(unsafe.Pointer(&w))
144         case 6:
145                 *(*[6]byte)(p) = *(*[6]byte)(unsafe.Pointer(&w))
146         case 7:
147                 *(*[7]byte)(p) = *(*[7]byte)(unsafe.Pointer(&w))
148         case 8:
149                 *(*uint64)(p) = *(*uint64)(unsafe.Pointer(&w))
150         }
151 }
152
153 // emptyInterface is the header for an interface{} value.
154 type emptyInterface struct {
155         typ  *runtime.Type
156         word iword
157 }
158
159 // nonEmptyInterface is the header for a interface value with methods.
160 type nonEmptyInterface struct {
161         // see ../runtime/iface.c:/Itab
162         itab *struct {
163                 typ    *runtime.Type // dynamic concrete type
164                 fun    [100000]unsafe.Pointer // method table
165         }
166         word iword
167 }
168
169 // Regarding the implementation of Value:
170 //
171 // The Internal interface is a true interface value in the Go sense,
172 // but it also serves as a (type, address) pair in whcih one cannot
173 // be changed separately from the other.  That is, it serves as a way
174 // to prevent unsafe mutations of the Internal state even though
175 // we cannot (yet?) hide the field while preserving the ability for
176 // clients to make copies of Values.
177 //
178 // The internal method converts a Value into the expanded internalValue struct.
179 // If we could avoid exporting fields we'd probably make internalValue the
180 // definition of Value.
181 //
182 // If a Value is addressable (CanAddr returns true), then the Internal
183 // interface value holds a pointer to the actual field data, and Set stores
184 // through that pointer.  If a Value is not addressable (CanAddr returns false),
185 // then the Internal interface value holds the actual value.
186 //
187 // In addition to whether a value is addressable, we track whether it was
188 // obtained by using an unexported struct field.  Such values are allowed
189 // to be read, mainly to make fmt.Print more useful, but they are not
190 // allowed to be written.  We call such values read-only.
191 //
192 // A Value can be set (via the Set, SetUint, etc. methods) only if it is both
193 // addressable and not read-only.
194 //
195 // The two permission bits - addressable and read-only - are stored in
196 // the bottom two bits of the type pointer in the interface value.
197 //
198 //      ordinary value: Internal = value
199 //      addressable value: Internal = value, Internal.typ |= flagAddr
200 //      read-only value: Internal = value, Internal.typ |= flagRO
201 //      addressable, read-only value: Internal = value, Internal.typ |= flagAddr | flagRO
202 //
203 // It is important that the read-only values have the extra bit set
204 // (as opposed to using the bit to mean writable), because client code
205 // can grab the interface field and try to use it.  Having the extra bit
206 // set makes the type pointer compare not equal to any real type,
207 // so that a client cannot, say, write through v.Internal.(*int).
208 // The runtime routines that access interface types reject types with
209 // low bits set.
210 //
211 // If a Value fv = v.Method(i), then fv = v with the InternalMethod
212 // field set to i+1.  Methods are never addressable.
213 //
214 // All in all, this is a lot of effort just to avoid making this new API
215 // depend on a language change we'll probably do anyway, but
216 // it's helpful to keep the two separate, and much of the logic is
217 // necessary to implement the Interface method anyway.
218
219 const (
220         flagAddr uint32 = 1 << iota // holds address of value
221         flagRO                      // read-only
222
223         reflectFlags = 3
224 )
225
226 // An internalValue is the unpacked form of a Value.
227 // The zero Value unpacks to a zero internalValue
228 type internalValue struct {
229         typ       *commonType // type of value
230         kind      Kind        // kind of value
231         flag      uint32
232         word      iword
233         addr      unsafe.Pointer
234         rcvr      iword
235         method    bool
236         nilmethod bool
237 }
238
239 func (v Value) internal() internalValue {
240         var iv internalValue
241         eface := *(*emptyInterface)(unsafe.Pointer(&v.Internal))
242         p := uintptr(unsafe.Pointer(eface.typ))
243         iv.typ = toCommonType((*runtime.Type)(unsafe.Pointer(p &^ reflectFlags)))
244         if iv.typ == nil {
245                 return iv
246         }
247         iv.flag = uint32(p & reflectFlags)
248         iv.word = eface.word
249         if iv.flag&flagAddr != 0 {
250                 iv.addr = unsafe.Pointer(uintptr(iv.word))
251                 iv.typ = iv.typ.Elem().common()
252                 if Kind(iv.typ.kind) == Ptr || Kind(iv.typ.kind) == UnsafePointer {
253                         iv.word = loadIword(iv.addr, iv.typ.size)
254                 }
255         } else {
256                 if Kind(iv.typ.kind) != Ptr && Kind(iv.typ.kind) != UnsafePointer {
257                         iv.addr = unsafe.Pointer(uintptr(iv.word))
258                 }
259         }
260         iv.kind = iv.typ.Kind()
261
262         // Is this a method?  If so, iv describes the receiver.
263         // Rewrite to describe the method function.
264         if v.InternalMethod != 0 {
265                 // If this Value is a method value (x.Method(i) for some Value x)
266                 // then we will invoke it using the interface form of the method,
267                 // which always passes the receiver as a single word.
268                 // Record that information.
269                 i := v.InternalMethod - 1
270                 if iv.kind == Interface {
271                         it := (*interfaceType)(unsafe.Pointer(iv.typ))
272                         if i < 0 || i >= len(it.methods) {
273                                 panic("reflect: broken Value")
274                         }
275                         m := &it.methods[i]
276                         if m.pkgPath != nil {
277                                 iv.flag |= flagRO
278                         }
279                         iv.typ = toCommonType(m.typ)
280                         iface := (*nonEmptyInterface)(iv.addr)
281                         if iface.itab == nil {
282                                 iv.word = 0
283                                 iv.nilmethod = true
284                         } else {
285                                 iv.word = iword(uintptr(iface.itab.fun[i]))
286                         }
287                         iv.rcvr = iface.word
288                 } else {
289                         ut := iv.typ.uncommon()
290                         if ut == nil || i < 0 || i >= len(ut.methods) {
291                                 panic("reflect: broken Value")
292                         }
293                         m := &ut.methods[i]
294                         if m.pkgPath != nil {
295                                 iv.flag |= flagRO
296                         }
297                         iv.typ = toCommonType(m.mtyp)
298                         iv.rcvr = iv.word
299                         iv.word = iword(uintptr(m.tfn))
300                 }
301                 if iv.word != 0 {
302                         p := new(iword)
303                         *p = iv.word
304                         iv.word = iword(uintptr(unsafe.Pointer(p)))
305                 }
306                 iv.kind = Func
307                 iv.method = true
308                 iv.flag &^= flagAddr
309                 iv.addr = unsafe.Pointer(uintptr(iv.word))
310         }
311
312         return iv
313 }
314
315 // packValue returns a Value with the given flag bits, type, and interface word.
316 func packValue(flag uint32, typ *runtime.Type, word iword) Value {
317         if typ == nil {
318                 panic("packValue")
319         }
320         t := uintptr(unsafe.Pointer(typ))
321         t |= uintptr(flag)
322         eface := emptyInterface{(*runtime.Type)(unsafe.Pointer(t)), word}
323         return Value{Internal: *(*interface{})(unsafe.Pointer(&eface))}
324 }
325
326 // valueFromAddr returns a Value using the given type and address.
327 func valueFromAddr(flag uint32, typ Type, addr unsafe.Pointer) Value {
328         if flag&flagAddr != 0 {
329                 // Addressable, so the internal value is
330                 // an interface containing a pointer to the real value.
331                 return packValue(flag, PtrTo(typ).runtimeType(), iword(uintptr(addr)))
332         }
333
334         var w iword
335         if k := typ.Kind(); k == Ptr || k == UnsafePointer {
336                 // In line, so the interface word is the actual value.
337                 w = loadIword(addr, typ.Size())
338         } else {
339                 // Not in line: the interface word is the address.
340                 w = iword(uintptr(addr))
341         }
342         return packValue(flag, typ.runtimeType(), w)
343 }
344
345 // valueFromIword returns a Value using the given type and interface word.
346 func valueFromIword(flag uint32, typ Type, w iword) Value {
347         if flag&flagAddr != 0 {
348                 panic("reflect: internal error: valueFromIword addressable")
349         }
350         return packValue(flag, typ.runtimeType(), w)
351 }
352
353 func (iv internalValue) mustBe(want Kind) {
354         if iv.kind != want {
355                 panic(&ValueError{methodName(), iv.kind})
356         }
357 }
358
359 func (iv internalValue) mustBeExported() {
360         if iv.kind == 0 {
361                 panic(&ValueError{methodName(), iv.kind})
362         }
363         if iv.flag&flagRO != 0 {
364                 panic(methodName() + " using value obtained using unexported field")
365         }
366 }
367
368 func (iv internalValue) mustBeAssignable() {
369         if iv.kind == 0 {
370                 panic(&ValueError{methodName(), iv.kind})
371         }
372         // Assignable if addressable and not read-only.
373         if iv.flag&flagRO != 0 {
374                 panic(methodName() + " using value obtained using unexported field")
375         }
376         if iv.flag&flagAddr == 0 {
377                 panic(methodName() + " using unaddressable value")
378         }
379 }
380
381 // Addr returns a pointer value representing the address of v.
382 // It panics if CanAddr() returns false.
383 // Addr is typically used to obtain a pointer to a struct field
384 // or slice element in order to call a method that requires a
385 // pointer receiver.
386 func (v Value) Addr() Value {
387         iv := v.internal()
388         if iv.flag&flagAddr == 0 {
389                 panic("reflect.Value.Addr of unaddressable value")
390         }
391         return valueFromIword(iv.flag&flagRO, PtrTo(iv.typ.toType()), iword(uintptr(iv.addr)))
392 }
393
394 // Bool returns v's underlying value.
395 // It panics if v's kind is not Bool.
396 func (v Value) Bool() bool {
397         iv := v.internal()
398         iv.mustBe(Bool)
399         return *(*bool)(unsafe.Pointer(iv.addr))
400 }
401
402 // CanAddr returns true if the value's address can be obtained with Addr.
403 // Such values are called addressable.  A value is addressable if it is
404 // an element of a slice, an element of an addressable array,
405 // a field of an addressable struct, or the result of dereferencing a pointer.
406 // If CanAddr returns false, calling Addr will panic.
407 func (v Value) CanAddr() bool {
408         iv := v.internal()
409         return iv.flag&flagAddr != 0
410 }
411
412 // CanSet returns true if the value of v can be changed.
413 // A Value can be changed only if it is addressable and was not
414 // obtained by the use of unexported struct fields.
415 // If CanSet returns false, calling Set or any type-specific
416 // setter (e.g., SetBool, SetInt64) will panic.
417 func (v Value) CanSet() bool {
418         iv := v.internal()
419         return iv.flag&(flagAddr|flagRO) == flagAddr
420 }
421
422 // Call calls the function v with the input arguments in.
423 // For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]).
424 // Call panics if v's Kind is not Func.
425 // It returns the output results as Values.
426 // As in Go, each input argument must be assignable to the
427 // type of the function's corresponding input parameter.
428 // If v is a variadic function, Call creates the variadic slice parameter
429 // itself, copying in the corresponding values.
430 func (v Value) Call(in []Value) []Value {
431         iv := v.internal()
432         iv.mustBe(Func)
433         iv.mustBeExported()
434         return iv.call("Call", in)
435 }
436
437 // CallSlice calls the variadic function v with the input arguments in,
438 // assigning the slice in[len(in)-1] to v's final variadic argument.  
439 // For example, if len(in) == 3, v.Call(in) represents the Go call v(in[0], in[1], in[2]...).
440 // Call panics if v's Kind is not Func or if v is not variadic.
441 // It returns the output results as Values.
442 // As in Go, each input argument must be assignable to the
443 // type of the function's corresponding input parameter.
444 func (v Value) CallSlice(in []Value) []Value {
445         iv := v.internal()
446         iv.mustBe(Func)
447         iv.mustBeExported()
448         return iv.call("CallSlice", in)
449 }
450
451 func (iv internalValue) call(method string, in []Value) []Value {
452         if iv.word == 0 {
453                 if iv.nilmethod {
454                         panic("reflect.Value.Call: call of method on nil interface value")
455                 }
456                 panic("reflect.Value.Call: call of nil function")
457         }
458
459         isSlice := method == "CallSlice"
460         t := iv.typ
461         n := t.NumIn()
462         if isSlice {
463                 if !t.IsVariadic() {
464                         panic("reflect: CallSlice of non-variadic function")
465                 }
466                 if len(in) < n {
467                         panic("reflect: CallSlice with too few input arguments")
468                 }
469                 if len(in) > n {
470                         panic("reflect: CallSlice with too many input arguments")
471                 }
472         } else {
473                 if t.IsVariadic() {
474                         n--
475                 }
476                 if len(in) < n {
477                         panic("reflect: Call with too few input arguments")
478                 }
479                 if !t.IsVariadic() && len(in) > n {
480                         panic("reflect: Call with too many input arguments")
481                 }
482         }
483         for _, x := range in {
484                 if x.Kind() == Invalid {
485                         panic("reflect: " + method + " using zero Value argument")
486                 }
487         }
488         for i := 0; i < n; i++ {
489                 if xt, targ := in[i].Type(), t.In(i); !xt.AssignableTo(targ) {
490                         panic("reflect: " + method + " using " + xt.String() + " as type " + targ.String())
491                 }
492         }
493         if !isSlice && t.IsVariadic() {
494                 // prepare slice for remaining values
495                 m := len(in) - n
496                 slice := MakeSlice(t.In(n), m, m)
497                 elem := t.In(n).Elem()
498                 for i := 0; i < m; i++ {
499                         x := in[n+i]
500                         if xt := x.Type(); !xt.AssignableTo(elem) {
501                                 panic("reflect: cannot use " + xt.String() + " as type " + elem.String() + " in " + method)
502                         }
503                         slice.Index(i).Set(x)
504                 }
505                 origIn := in
506                 in = make([]Value, n+1)
507                 copy(in[:n], origIn)
508                 in[n] = slice
509         }
510
511         nin := len(in)
512         if nin != t.NumIn() {
513                 panic("reflect.Value.Call: wrong argument count")
514         }
515         nout := t.NumOut()
516
517         if iv.method {
518                 nin++
519         }
520         params := make([]unsafe.Pointer, nin)
521         delta := 0
522         off := 0
523         if iv.method {
524                 // Hard-wired first argument.
525                 p := new(iword)
526                 *p = iv.rcvr
527                 params[0] = unsafe.Pointer(p)
528                 off = 1
529         }
530
531         first_pointer := false
532         for i, v := range in {
533                 siv := v.internal()
534                 siv.mustBeExported()
535                 targ := t.In(i).(*commonType)
536                 siv = convertForAssignment("reflect.Value.Call", nil, targ, siv)
537                 if siv.addr == nil {
538                         p := new(unsafe.Pointer)
539                         *p = unsafe.Pointer(uintptr(siv.word))
540                         params[off] = unsafe.Pointer(p)
541                 } else {
542                         params[off] = siv.addr
543                 }
544                 if i == 0 && Kind(targ.kind) != Ptr && !iv.method && isMethod(iv.typ) {
545                         p := new(unsafe.Pointer)
546                         *p = params[off]
547                         params[off] = unsafe.Pointer(p)
548                         first_pointer = true
549                 }
550                 off++
551         }
552
553         ret := make([]Value, nout)
554         results := make([]unsafe.Pointer, nout)
555         for i := 0; i < nout; i++ {
556                 v := New(t.Out(i))
557                 results[i] = unsafe.Pointer(v.Pointer())
558                 ret[i] = Indirect(v)
559         }
560
561         call(t, *(*unsafe.Pointer)(iv.addr), iv.method, first_pointer, &params[0], &results[0])
562
563         return ret
564 }
565
566 // gccgo specific test to see if typ is a method.  We can tell by
567 // looking at the string to see if there is a receiver.  We need this
568 // because for gccgo all methods take pointer receivers.
569 func isMethod(t *commonType) bool {
570         if Kind(t.kind) != Func {
571                 return false
572         }
573         s := *t.string
574         parens := 0
575         params := 0
576         sawRet := false
577         for i, c := range s {
578                 if c == '(' {
579                         parens++
580                         params++
581                 } else if c == ')' {
582                         parens--
583                 } else if parens == 0 && c == ' ' && s[i + 1] != '(' && !sawRet {
584                         params++
585                         sawRet = true
586                 }
587         }
588         return params > 2
589 }
590
591 // Cap returns v's capacity.
592 // It panics if v's Kind is not Array, Chan, or Slice.
593 func (v Value) Cap() int {
594         iv := v.internal()
595         switch iv.kind {
596         case Array:
597                 return iv.typ.Len()
598         case Chan:
599                 return int(chancap(*(*iword)(iv.addr)))
600         case Slice:
601                 return (*SliceHeader)(iv.addr).Cap
602         }
603         panic(&ValueError{"reflect.Value.Cap", iv.kind})
604 }
605
606 // Close closes the channel v.
607 // It panics if v's Kind is not Chan.
608 func (v Value) Close() {
609         iv := v.internal()
610         iv.mustBe(Chan)
611         iv.mustBeExported()
612         ch := *(*iword)(iv.addr)
613         chanclose(ch)
614 }
615
616 // Complex returns v's underlying value, as a complex128.
617 // It panics if v's Kind is not Complex64 or Complex128
618 func (v Value) Complex() complex128 {
619         iv := v.internal()
620         switch iv.kind {
621         case Complex64:
622                 return complex128(*(*complex64)(iv.addr))
623         case Complex128:
624                 return *(*complex128)(iv.addr)
625         }
626         panic(&ValueError{"reflect.Value.Complex", iv.kind})
627 }
628
629 // Elem returns the value that the interface v contains
630 // or that the pointer v points to.
631 // It panics if v's Kind is not Interface or Ptr.
632 // It returns the zero Value if v is nil.
633 func (v Value) Elem() Value {
634         iv := v.internal()
635         return iv.Elem()
636 }
637
638 func (iv internalValue) Elem() Value {
639         switch iv.kind {
640         case Interface:
641                 // Empty interface and non-empty interface have different layouts.
642                 // Convert to empty interface.
643                 var eface emptyInterface
644                 if iv.typ.NumMethod() == 0 {
645                         eface = *(*emptyInterface)(iv.addr)
646                 } else {
647                         iface := (*nonEmptyInterface)(iv.addr)
648                         if iface.itab != nil {
649                                 eface.typ = iface.itab.typ
650                         }
651                         eface.word = iface.word
652                 }
653                 if eface.typ == nil {
654                         return Value{}
655                 }
656                 return valueFromIword(iv.flag&flagRO, toType(eface.typ), eface.word)
657
658         case Ptr:
659                 // The returned value's address is v's value.
660                 if iv.word == 0 {
661                         return Value{}
662                 }
663                 return valueFromAddr(iv.flag&flagRO|flagAddr, iv.typ.Elem(), unsafe.Pointer(uintptr(iv.word)))
664         }
665         panic(&ValueError{"reflect.Value.Elem", iv.kind})
666 }
667
668 // Field returns the i'th field of the struct v.
669 // It panics if v's Kind is not Struct or i is out of range.
670 func (v Value) Field(i int) Value {
671         iv := v.internal()
672         iv.mustBe(Struct)
673         t := iv.typ.toType()
674         if i < 0 || i >= t.NumField() {
675                 panic("reflect: Field index out of range")
676         }
677         f := t.Field(i)
678
679         // Inherit permission bits from v.
680         flag := iv.flag
681         // Using an unexported field forces flagRO.
682         if f.PkgPath != "" {
683                 flag |= flagRO
684         }
685         return valueFromValueOffset(flag, f.Type, iv, f.Offset)
686 }
687
688 // valueFromValueOffset returns a sub-value of outer
689 // (outer is an array or a struct) with the given flag and type
690 // starting at the given byte offset into outer.
691 func valueFromValueOffset(flag uint32, typ Type, outer internalValue, offset uintptr) Value {
692         if outer.addr != nil {
693                 return valueFromAddr(flag, typ, unsafe.Pointer(uintptr(outer.addr)+offset))
694         }
695
696         // outer is so tiny it is in line.
697         // We have to use outer.word and derive
698         // the new word (it cannot possibly be bigger).
699         // In line, so not addressable.
700         if flag&flagAddr != 0 {
701                 panic("reflect: internal error: misuse of valueFromValueOffset")
702         }
703         b := *(*[ptrSize]byte)(unsafe.Pointer(&outer.word))
704         for i := uintptr(0); i < typ.Size(); i++ {
705                 b[i] = b[offset+i]
706         }
707         for i := typ.Size(); i < ptrSize; i++ {
708                 b[i] = 0
709         }
710         w := *(*iword)(unsafe.Pointer(&b))
711         return valueFromIword(flag, typ, w)
712 }
713
714 // FieldByIndex returns the nested field corresponding to index.
715 // It panics if v's Kind is not struct.
716 func (v Value) FieldByIndex(index []int) Value {
717         v.internal().mustBe(Struct)
718         for i, x := range index {
719                 if i > 0 {
720                         if v.Kind() == Ptr && v.Elem().Kind() == Struct {
721                                 v = v.Elem()
722                         }
723                 }
724                 v = v.Field(x)
725         }
726         return v
727 }
728
729 // FieldByName returns the struct field with the given name.
730 // It returns the zero Value if no field was found.
731 // It panics if v's Kind is not struct.
732 func (v Value) FieldByName(name string) Value {
733         iv := v.internal()
734         iv.mustBe(Struct)
735         if f, ok := iv.typ.FieldByName(name); ok {
736                 return v.FieldByIndex(f.Index)
737         }
738         return Value{}
739 }
740
741 // FieldByNameFunc returns the struct field with a name
742 // that satisfies the match function.
743 // It panics if v's Kind is not struct.
744 // It returns the zero Value if no field was found.
745 func (v Value) FieldByNameFunc(match func(string) bool) Value {
746         v.internal().mustBe(Struct)
747         if f, ok := v.Type().FieldByNameFunc(match); ok {
748                 return v.FieldByIndex(f.Index)
749         }
750         return Value{}
751 }
752
753 // Float returns v's underlying value, as an float64.
754 // It panics if v's Kind is not Float32 or Float64
755 func (v Value) Float() float64 {
756         iv := v.internal()
757         switch iv.kind {
758         case Float32:
759                 return float64(*(*float32)(iv.addr))
760         case Float64:
761                 return *(*float64)(iv.addr)
762         }
763         panic(&ValueError{"reflect.Value.Float", iv.kind})
764 }
765
766 // Index returns v's i'th element.
767 // It panics if v's Kind is not Array or Slice or i is out of range.
768 func (v Value) Index(i int) Value {
769         iv := v.internal()
770         switch iv.kind {
771         default:
772                 panic(&ValueError{"reflect.Value.Index", iv.kind})
773         case Array:
774                 flag := iv.flag // element flag same as overall array
775                 t := iv.typ.toType()
776                 if i < 0 || i > t.Len() {
777                         panic("reflect: array index out of range")
778                 }
779                 typ := t.Elem()
780                 return valueFromValueOffset(flag, typ, iv, uintptr(i)*typ.Size())
781
782         case Slice:
783                 // Element flag same as Elem of Ptr.
784                 // Addressable, possibly read-only.
785                 flag := iv.flag&flagRO | flagAddr
786                 s := (*SliceHeader)(iv.addr)
787                 if i < 0 || i >= s.Len {
788                         panic("reflect: slice index out of range")
789                 }
790                 typ := iv.typ.Elem()
791                 addr := unsafe.Pointer(s.Data + uintptr(i)*typ.Size())
792                 return valueFromAddr(flag, typ, addr)
793         }
794
795         panic("not reached")
796 }
797
798 // Int returns v's underlying value, as an int64.
799 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64.
800 func (v Value) Int() int64 {
801         iv := v.internal()
802         switch iv.kind {
803         case Int:
804                 return int64(*(*int)(iv.addr))
805         case Int8:
806                 return int64(*(*int8)(iv.addr))
807         case Int16:
808                 return int64(*(*int16)(iv.addr))
809         case Int32:
810                 return int64(*(*int32)(iv.addr))
811         case Int64:
812                 return *(*int64)(iv.addr)
813         }
814         panic(&ValueError{"reflect.Value.Int", iv.kind})
815 }
816
817 // CanInterface returns true if Interface can be used without panicking.
818 func (v Value) CanInterface() bool {
819         iv := v.internal()
820         if iv.kind == Invalid {
821                 panic(&ValueError{"reflect.Value.CanInterface", iv.kind})
822         }
823         // TODO(rsc): Check flagRO too.  Decide what to do about asking for
824         // interface for a value obtained via an unexported field.
825         // If the field were of a known type, say chan int or *sync.Mutex,
826         // the caller could interfere with the data after getting the
827         // interface.  But fmt.Print depends on being able to look.
828         // Now that reflect is more efficient the special cases in fmt
829         // might be less important.
830         return v.InternalMethod == 0
831 }
832
833 // Interface returns v's value as an interface{}.
834 // If v is a method obtained by invoking Value.Method
835 // (as opposed to Type.Method), Interface cannot return an
836 // interface value, so it panics.
837 func (v Value) Interface() interface{} {
838         return v.internal().Interface()
839 }
840
841 func (iv internalValue) Interface() interface{} {
842         if iv.method {
843                 panic("reflect.Value.Interface: cannot create interface value for method with bound receiver")
844         }
845         /*
846                 if v.flag()&noExport != 0 {
847                         panic("reflect.Value.Interface: cannot return value obtained from unexported struct field")
848                 }
849         */
850
851         if iv.kind == Interface {
852                 // Special case: return the element inside the interface.
853                 // Won't recurse further because an interface cannot contain an interface.
854                 if iv.IsNil() {
855                         return nil
856                 }
857                 return iv.Elem().Interface()
858         }
859
860         // Non-interface value.
861         var eface emptyInterface
862         eface.typ = iv.typ.runtimeType()
863         eface.word = iv.word
864         return *(*interface{})(unsafe.Pointer(&eface))
865 }
866
867 // InterfaceData returns the interface v's value as a uintptr pair.
868 // It panics if v's Kind is not Interface.
869 func (v Value) InterfaceData() [2]uintptr {
870         iv := v.internal()
871         iv.mustBe(Interface)
872         // We treat this as a read operation, so we allow
873         // it even for unexported data, because the caller
874         // has to import "unsafe" to turn it into something
875         // that can be abused.
876         return *(*[2]uintptr)(iv.addr)
877 }
878
879 // IsNil returns true if v is a nil value.
880 // It panics if v's Kind is not Chan, Func, Interface, Map, Ptr, or Slice.
881 func (v Value) IsNil() bool {
882         return v.internal().IsNil()
883 }
884
885 func (iv internalValue) IsNil() bool {
886         switch iv.kind {
887         case Ptr:
888                 if iv.method {
889                         panic("reflect: IsNil of method Value")
890                 }
891                 return iv.word == 0
892         case Chan, Func, Map:
893                 if iv.method {
894                         panic("reflect: IsNil of method Value")
895                 }
896                 return *(*uintptr)(iv.addr) == 0
897         case Interface, Slice:
898                 // Both interface and slice are nil if first word is 0.
899                 return *(*uintptr)(iv.addr) == 0
900         }
901         panic(&ValueError{"reflect.Value.IsNil", iv.kind})
902 }
903
904 // IsValid returns true if v represents a value.
905 // It returns false if v is the zero Value.
906 // If IsValid returns false, all other methods except String panic.
907 // Most functions and methods never return an invalid value.
908 // If one does, its documentation states the conditions explicitly.
909 func (v Value) IsValid() bool {
910         return v.Internal != nil
911 }
912
913 // Kind returns v's Kind.
914 // If v is the zero Value (IsValid returns false), Kind returns Invalid.
915 func (v Value) Kind() Kind {
916         return v.internal().kind
917 }
918
919 // Len returns v's length.
920 // It panics if v's Kind is not Array, Chan, Map, or Slice.
921 func (v Value) Len() int {
922         iv := v.internal()
923         switch iv.kind {
924         case Array:
925                 return iv.typ.Len()
926         case Chan:
927                 return int(chanlen(*(*iword)(iv.addr)))
928         case Map:
929                 return int(maplen(*(*iword)(iv.addr)))
930         case Slice:
931                 return (*SliceHeader)(iv.addr).Len
932         }
933         panic(&ValueError{"reflect.Value.Len", iv.kind})
934 }
935
936 // MapIndex returns the value associated with key in the map v.
937 // It panics if v's Kind is not Map.
938 // It returns the zero Value if key is not found in the map or if v represents a nil map.
939 // As in Go, the key's value must be assignable to the map's key type.
940 func (v Value) MapIndex(key Value) Value {
941         iv := v.internal()
942         iv.mustBe(Map)
943         typ := iv.typ.toType()
944
945         // Do not require ikey to be exported, so that DeepEqual
946         // and other programs can use all the keys returned by
947         // MapKeys as arguments to MapIndex.  If either the map
948         // or the key is unexported, though, the result will be
949         // considered unexported.
950
951         ikey := key.internal()
952         ikey = convertForAssignment("reflect.Value.MapIndex", nil, typ.Key(), ikey)
953         if iv.word == 0 {
954                 return Value{}
955         }
956
957         flag := (iv.flag | ikey.flag) & flagRO
958         elemType := typ.Elem()
959         elemWord, ok := mapaccess(*(*iword)(iv.addr), ikey.word)
960         if !ok {
961                 return Value{}
962         }
963         return valueFromIword(flag, elemType, elemWord)
964 }
965
966 // MapKeys returns a slice containing all the keys present in the map,
967 // in unspecified order.
968 // It panics if v's Kind is not Map.
969 // It returns an empty slice if v represents a nil map.
970 func (v Value) MapKeys() []Value {
971         iv := v.internal()
972         iv.mustBe(Map)
973         keyType := iv.typ.Key()
974
975         flag := iv.flag & flagRO
976         m := *(*iword)(iv.addr)
977         mlen := int32(0)
978         if m != 0 {
979                 mlen = maplen(m)
980         }
981         it := mapiterinit(m)
982         a := make([]Value, mlen)
983         var i int
984         for i = 0; i < len(a); i++ {
985                 keyWord, ok := mapiterkey(it)
986                 if !ok {
987                         break
988                 }
989                 a[i] = valueFromIword(flag, keyType, keyWord)
990                 mapiternext(it)
991         }
992         return a[:i]
993 }
994
995 // Method returns a function value corresponding to v's i'th method.
996 // The arguments to a Call on the returned function should not include
997 // a receiver; the returned function will always use v as the receiver.
998 // Method panics if i is out of range.
999 func (v Value) Method(i int) Value {
1000         iv := v.internal()
1001         if iv.kind == Invalid {
1002                 panic(&ValueError{"reflect.Value.Method", Invalid})
1003         }
1004         if i < 0 || i >= iv.typ.NumMethod() {
1005                 panic("reflect: Method index out of range")
1006         }
1007         return Value{v.Internal, i + 1}
1008 }
1009
1010 // NumField returns the number of fields in the struct v.
1011 // It panics if v's Kind is not Struct.
1012 func (v Value) NumField() int {
1013         iv := v.internal()
1014         iv.mustBe(Struct)
1015         return iv.typ.NumField()
1016 }
1017
1018 // OverflowComplex returns true if the complex128 x cannot be represented by v's type.
1019 // It panics if v's Kind is not Complex64 or Complex128.
1020 func (v Value) OverflowComplex(x complex128) bool {
1021         iv := v.internal()
1022         switch iv.kind {
1023         case Complex64:
1024                 return overflowFloat32(real(x)) || overflowFloat32(imag(x))
1025         case Complex128:
1026                 return false
1027         }
1028         panic(&ValueError{"reflect.Value.OverflowComplex", iv.kind})
1029 }
1030
1031 // OverflowFloat returns true if the float64 x cannot be represented by v's type.
1032 // It panics if v's Kind is not Float32 or Float64.
1033 func (v Value) OverflowFloat(x float64) bool {
1034         iv := v.internal()
1035         switch iv.kind {
1036         case Float32:
1037                 return overflowFloat32(x)
1038         case Float64:
1039                 return false
1040         }
1041         panic(&ValueError{"reflect.Value.OverflowFloat", iv.kind})
1042 }
1043
1044 func overflowFloat32(x float64) bool {
1045         if x < 0 {
1046                 x = -x
1047         }
1048         return math.MaxFloat32 <= x && x <= math.MaxFloat64
1049 }
1050
1051 // OverflowInt returns true if the int64 x cannot be represented by v's type.
1052 // It panics if v's Kind is not Int, Int8, int16, Int32, or Int64.
1053 func (v Value) OverflowInt(x int64) bool {
1054         iv := v.internal()
1055         switch iv.kind {
1056         case Int, Int8, Int16, Int32, Int64:
1057                 bitSize := iv.typ.size * 8
1058                 trunc := (x << (64 - bitSize)) >> (64 - bitSize)
1059                 return x != trunc
1060         }
1061         panic(&ValueError{"reflect.Value.OverflowInt", iv.kind})
1062 }
1063
1064 // OverflowUint returns true if the uint64 x cannot be represented by v's type.
1065 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
1066 func (v Value) OverflowUint(x uint64) bool {
1067         iv := v.internal()
1068         switch iv.kind {
1069         case Uint, Uintptr, Uint8, Uint16, Uint32, Uint64:
1070                 bitSize := iv.typ.size * 8
1071                 trunc := (x << (64 - bitSize)) >> (64 - bitSize)
1072                 return x != trunc
1073         }
1074         panic(&ValueError{"reflect.Value.OverflowUint", iv.kind})
1075 }
1076
1077 // Pointer returns v's value as a uintptr.
1078 // It returns uintptr instead of unsafe.Pointer so that
1079 // code using reflect cannot obtain unsafe.Pointers
1080 // without importing the unsafe package explicitly.
1081 // It panics if v's Kind is not Chan, Func, Map, Ptr, Slice, or UnsafePointer.
1082 func (v Value) Pointer() uintptr {
1083         iv := v.internal()
1084         switch iv.kind {
1085         case Ptr, UnsafePointer:
1086                 if iv.kind == Func && v.InternalMethod != 0 {
1087                         panic("reflect.Value.Pointer of method Value")
1088                 }
1089                 return uintptr(iv.word)
1090         case Chan, Func, Map:
1091                 if iv.kind == Func && v.InternalMethod != 0 {
1092                         panic("reflect.Value.Pointer of method Value")
1093                 }
1094                 return *(*uintptr)(iv.addr)
1095         case Slice:
1096                 return (*SliceHeader)(iv.addr).Data
1097         }
1098         panic(&ValueError{"reflect.Value.Pointer", iv.kind})
1099 }
1100
1101 // Recv receives and returns a value from the channel v.
1102 // It panics if v's Kind is not Chan.
1103 // The receive blocks until a value is ready.
1104 // The boolean value ok is true if the value x corresponds to a send
1105 // on the channel, false if it is a zero value received because the channel is closed.
1106 func (v Value) Recv() (x Value, ok bool) {
1107         iv := v.internal()
1108         iv.mustBe(Chan)
1109         iv.mustBeExported()
1110         return iv.recv(false)
1111 }
1112
1113 // internal recv, possibly non-blocking (nb)
1114 func (iv internalValue) recv(nb bool) (val Value, ok bool) {
1115         t := iv.typ.toType()
1116         if t.ChanDir()&RecvDir == 0 {
1117                 panic("recv on send-only channel")
1118         }
1119         ch := *(*iword)(iv.addr)
1120         if ch == 0 {
1121                 panic("recv on nil channel")
1122         }
1123         valWord, selected, ok := chanrecv(ch, nb)
1124         if selected {
1125                 val = valueFromIword(0, t.Elem(), valWord)
1126         }
1127         return
1128 }
1129
1130 // Send sends x on the channel v.
1131 // It panics if v's kind is not Chan or if x's type is not the same type as v's element type.
1132 // As in Go, x's value must be assignable to the channel's element type.
1133 func (v Value) Send(x Value) {
1134         iv := v.internal()
1135         iv.mustBe(Chan)
1136         iv.mustBeExported()
1137         iv.send(x, false)
1138 }
1139
1140 // internal send, possibly non-blocking
1141 func (iv internalValue) send(x Value, nb bool) (selected bool) {
1142         t := iv.typ.toType()
1143         if t.ChanDir()&SendDir == 0 {
1144                 panic("send on recv-only channel")
1145         }
1146         ix := x.internal()
1147         ix.mustBeExported() // do not let unexported x leak
1148         ix = convertForAssignment("reflect.Value.Send", nil, t.Elem(), ix)
1149         ch := *(*iword)(iv.addr)
1150         if ch == 0 {
1151                 panic("send on nil channel")
1152         }
1153         return chansend(ch, ix.word, nb)
1154 }
1155
1156 // Set assigns x to the value v.
1157 // It panics if CanSet returns false.
1158 // As in Go, x's value must be assignable to v's type.
1159 func (v Value) Set(x Value) {
1160         iv := v.internal()
1161         ix := x.internal()
1162
1163         iv.mustBeAssignable()
1164         ix.mustBeExported() // do not let unexported x leak
1165
1166         ix = convertForAssignment("reflect.Set", iv.addr, iv.typ, ix)
1167
1168         n := ix.typ.size
1169         if Kind(ix.typ.kind) == Ptr || Kind(ix.typ.kind) == UnsafePointer {
1170                 storeIword(iv.addr, ix.word, n)
1171         } else {
1172                 memmove(iv.addr, ix.addr, n)
1173         }
1174 }
1175
1176 // SetBool sets v's underlying value.
1177 // It panics if v's Kind is not Bool or if CanSet() is false.
1178 func (v Value) SetBool(x bool) {
1179         iv := v.internal()
1180         iv.mustBeAssignable()
1181         iv.mustBe(Bool)
1182         *(*bool)(iv.addr) = x
1183 }
1184
1185 // SetComplex sets v's underlying value to x.
1186 // It panics if v's Kind is not Complex64 or Complex128, or if CanSet() is false.
1187 func (v Value) SetComplex(x complex128) {
1188         iv := v.internal()
1189         iv.mustBeAssignable()
1190         switch iv.kind {
1191         default:
1192                 panic(&ValueError{"reflect.Value.SetComplex", iv.kind})
1193         case Complex64:
1194                 *(*complex64)(iv.addr) = complex64(x)
1195         case Complex128:
1196                 *(*complex128)(iv.addr) = x
1197         }
1198 }
1199
1200 // SetFloat sets v's underlying value to x.
1201 // It panics if v's Kind is not Float32 or Float64, or if CanSet() is false.
1202 func (v Value) SetFloat(x float64) {
1203         iv := v.internal()
1204         iv.mustBeAssignable()
1205         switch iv.kind {
1206         default:
1207                 panic(&ValueError{"reflect.Value.SetFloat", iv.kind})
1208         case Float32:
1209                 *(*float32)(iv.addr) = float32(x)
1210         case Float64:
1211                 *(*float64)(iv.addr) = x
1212         }
1213 }
1214
1215 // SetInt sets v's underlying value to x.
1216 // It panics if v's Kind is not Int, Int8, Int16, Int32, or Int64, or if CanSet() is false.
1217 func (v Value) SetInt(x int64) {
1218         iv := v.internal()
1219         iv.mustBeAssignable()
1220         switch iv.kind {
1221         default:
1222                 panic(&ValueError{"reflect.Value.SetInt", iv.kind})
1223         case Int:
1224                 *(*int)(iv.addr) = int(x)
1225         case Int8:
1226                 *(*int8)(iv.addr) = int8(x)
1227         case Int16:
1228                 *(*int16)(iv.addr) = int16(x)
1229         case Int32:
1230                 *(*int32)(iv.addr) = int32(x)
1231         case Int64:
1232                 *(*int64)(iv.addr) = x
1233         }
1234 }
1235
1236 // SetLen sets v's length to n.
1237 // It panics if v's Kind is not Slice.
1238 func (v Value) SetLen(n int) {
1239         iv := v.internal()
1240         iv.mustBeAssignable()
1241         iv.mustBe(Slice)
1242         s := (*SliceHeader)(iv.addr)
1243         if n < 0 || n > int(s.Cap) {
1244                 panic("reflect: slice length out of range in SetLen")
1245         }
1246         s.Len = n
1247 }
1248
1249 // SetMapIndex sets the value associated with key in the map v to val.
1250 // It panics if v's Kind is not Map.
1251 // If val is the zero Value, SetMapIndex deletes the key from the map.
1252 // As in Go, key's value must be assignable to the map's key type,
1253 // and val's value must be assignable to the map's value type.
1254 func (v Value) SetMapIndex(key, val Value) {
1255         iv := v.internal()
1256         ikey := key.internal()
1257         ival := val.internal()
1258
1259         iv.mustBe(Map)
1260         iv.mustBeExported()
1261
1262         ikey.mustBeExported()
1263         ikey = convertForAssignment("reflect.Value.SetMapIndex", nil, iv.typ.Key(), ikey)
1264
1265         if ival.kind != Invalid {
1266                 ival.mustBeExported()
1267                 ival = convertForAssignment("reflect.Value.SetMapIndex", nil, iv.typ.Elem(), ival)
1268         }
1269
1270         mapassign(*(*iword)(iv.addr), ikey.word, ival.word, ival.kind != Invalid)
1271 }
1272
1273 // SetUint sets v's underlying value to x.
1274 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64, or if CanSet() is false.
1275 func (v Value) SetUint(x uint64) {
1276         iv := v.internal()
1277         iv.mustBeAssignable()
1278         switch iv.kind {
1279         default:
1280                 panic(&ValueError{"reflect.Value.SetUint", iv.kind})
1281         case Uint:
1282                 *(*uint)(iv.addr) = uint(x)
1283         case Uint8:
1284                 *(*uint8)(iv.addr) = uint8(x)
1285         case Uint16:
1286                 *(*uint16)(iv.addr) = uint16(x)
1287         case Uint32:
1288                 *(*uint32)(iv.addr) = uint32(x)
1289         case Uint64:
1290                 *(*uint64)(iv.addr) = x
1291         case Uintptr:
1292                 *(*uintptr)(iv.addr) = uintptr(x)
1293         }
1294 }
1295
1296 // SetPointer sets the unsafe.Pointer value v to x.
1297 // It panics if v's Kind is not UnsafePointer.
1298 func (v Value) SetPointer(x unsafe.Pointer) {
1299         iv := v.internal()
1300         iv.mustBeAssignable()
1301         iv.mustBe(UnsafePointer)
1302         *(*unsafe.Pointer)(iv.addr) = x
1303 }
1304
1305 // SetString sets v's underlying value to x.
1306 // It panics if v's Kind is not String or if CanSet() is false.
1307 func (v Value) SetString(x string) {
1308         iv := v.internal()
1309         iv.mustBeAssignable()
1310         iv.mustBe(String)
1311         *(*string)(iv.addr) = x
1312 }
1313
1314 // Slice returns a slice of v.
1315 // It panics if v's Kind is not Array or Slice.
1316 func (v Value) Slice(beg, end int) Value {
1317         iv := v.internal()
1318         if iv.kind != Array && iv.kind != Slice {
1319                 panic(&ValueError{"reflect.Value.Slice", iv.kind})
1320         }
1321         cap := v.Cap()
1322         if beg < 0 || end < beg || end > cap {
1323                 panic("reflect.Value.Slice: slice index out of bounds")
1324         }
1325         var typ Type
1326         var base uintptr
1327         switch iv.kind {
1328         case Array:
1329                 if iv.flag&flagAddr == 0 {
1330                         panic("reflect.Value.Slice: slice of unaddressable array")
1331                 }
1332                 typ = toType((*arrayType)(unsafe.Pointer(iv.typ)).slice)
1333                 base = uintptr(iv.addr)
1334         case Slice:
1335                 typ = iv.typ.toType()
1336                 base = (*SliceHeader)(iv.addr).Data
1337         }
1338         s := new(SliceHeader)
1339         s.Data = base + uintptr(beg)*typ.Elem().Size()
1340         s.Len = end - beg
1341         s.Cap = cap - beg
1342         return valueFromAddr(iv.flag&flagRO, typ, unsafe.Pointer(s))
1343 }
1344
1345 // String returns the string v's underlying value, as a string.
1346 // String is a special case because of Go's String method convention.
1347 // Unlike the other getters, it does not panic if v's Kind is not String.
1348 // Instead, it returns a string of the form "<T value>" where T is v's type.
1349 func (v Value) String() string {
1350         iv := v.internal()
1351         switch iv.kind {
1352         case Invalid:
1353                 return "<invalid Value>"
1354         case String:
1355                 return *(*string)(iv.addr)
1356         }
1357         return "<" + iv.typ.String() + " Value>"
1358 }
1359
1360 // TryRecv attempts to receive a value from the channel v but will not block.
1361 // It panics if v's Kind is not Chan.
1362 // If the receive cannot finish without blocking, x is the zero Value.
1363 // The boolean ok is true if the value x corresponds to a send
1364 // on the channel, false if it is a zero value received because the channel is closed.
1365 func (v Value) TryRecv() (x Value, ok bool) {
1366         iv := v.internal()
1367         iv.mustBe(Chan)
1368         iv.mustBeExported()
1369         return iv.recv(true)
1370 }
1371
1372 // TrySend attempts to send x on the channel v but will not block.
1373 // It panics if v's Kind is not Chan.
1374 // It returns true if the value was sent, false otherwise.
1375 // As in Go, x's value must be assignable to the channel's element type.
1376 func (v Value) TrySend(x Value) bool {
1377         iv := v.internal()
1378         iv.mustBe(Chan)
1379         iv.mustBeExported()
1380         return iv.send(x, true)
1381 }
1382
1383 // Type returns v's type.
1384 func (v Value) Type() Type {
1385         t := v.internal().typ
1386         if t == nil {
1387                 panic(&ValueError{"reflect.Value.Type", Invalid})
1388         }
1389         return t.toType()
1390 }
1391
1392 // Uint returns v's underlying value, as a uint64.
1393 // It panics if v's Kind is not Uint, Uintptr, Uint8, Uint16, Uint32, or Uint64.
1394 func (v Value) Uint() uint64 {
1395         iv := v.internal()
1396         switch iv.kind {
1397         case Uint:
1398                 return uint64(*(*uint)(iv.addr))
1399         case Uint8:
1400                 return uint64(*(*uint8)(iv.addr))
1401         case Uint16:
1402                 return uint64(*(*uint16)(iv.addr))
1403         case Uint32:
1404                 return uint64(*(*uint32)(iv.addr))
1405         case Uintptr:
1406                 return uint64(*(*uintptr)(iv.addr))
1407         case Uint64:
1408                 return *(*uint64)(iv.addr)
1409         }
1410         panic(&ValueError{"reflect.Value.Uint", iv.kind})
1411 }
1412
1413 // UnsafeAddr returns a pointer to v's data.
1414 // It is for advanced clients that also import the "unsafe" package.
1415 // It panics if v is not addressable.
1416 func (v Value) UnsafeAddr() uintptr {
1417         iv := v.internal()
1418         if iv.kind == Invalid {
1419                 panic(&ValueError{"reflect.Value.UnsafeAddr", iv.kind})
1420         }
1421         if iv.flag&flagAddr == 0 {
1422                 panic("reflect.Value.UnsafeAddr of unaddressable value")
1423         }
1424         return uintptr(iv.addr)
1425 }
1426
1427 // StringHeader is the runtime representation of a string.
1428 // It cannot be used safely or portably.
1429 type StringHeader struct {
1430         Data uintptr
1431         Len  int
1432 }
1433
1434 // SliceHeader is the runtime representation of a slice.
1435 // It cannot be used safely or portably.
1436 type SliceHeader struct {
1437         Data uintptr
1438         Len  int
1439         Cap  int
1440 }
1441
1442 func typesMustMatch(what string, t1, t2 Type) {
1443         if t1 != t2 {
1444                 panic("reflect: " + what + ": " + t1.String() + " != " + t2.String())
1445         }
1446 }
1447
1448 // grow grows the slice s so that it can hold extra more values, allocating
1449 // more capacity if needed. It also returns the old and new slice lengths.
1450 func grow(s Value, extra int) (Value, int, int) {
1451         i0 := s.Len()
1452         i1 := i0 + extra
1453         if i1 < i0 {
1454                 panic("reflect.Append: slice overflow")
1455         }
1456         m := s.Cap()
1457         if i1 <= m {
1458                 return s.Slice(0, i1), i0, i1
1459         }
1460         if m == 0 {
1461                 m = extra
1462         } else {
1463                 for m < i1 {
1464                         if i0 < 1024 {
1465                                 m += m
1466                         } else {
1467                                 m += m / 4
1468                         }
1469                 }
1470         }
1471         t := MakeSlice(s.Type(), i1, m)
1472         Copy(t, s)
1473         return t, i0, i1
1474 }
1475
1476 // Append appends the values x to a slice s and returns the resulting slice.
1477 // As in Go, each x's value must be assignable to the slice's element type.
1478 func Append(s Value, x ...Value) Value {
1479         s.internal().mustBe(Slice)
1480         s, i0, i1 := grow(s, len(x))
1481         for i, j := i0, 0; i < i1; i, j = i+1, j+1 {
1482                 s.Index(i).Set(x[j])
1483         }
1484         return s
1485 }
1486
1487 // AppendSlice appends a slice t to a slice s and returns the resulting slice.
1488 // The slices s and t must have the same element type.
1489 func AppendSlice(s, t Value) Value {
1490         s.internal().mustBe(Slice)
1491         t.internal().mustBe(Slice)
1492         typesMustMatch("reflect.AppendSlice", s.Type().Elem(), t.Type().Elem())
1493         s, i0, i1 := grow(s, t.Len())
1494         Copy(s.Slice(i0, i1), t)
1495         return s
1496 }
1497
1498 // Copy copies the contents of src into dst until either
1499 // dst has been filled or src has been exhausted.
1500 // It returns the number of elements copied.
1501 // Dst and src each must have kind Slice or Array, and
1502 // dst and src must have the same element type.
1503 func Copy(dst, src Value) int {
1504         idst := dst.internal()
1505         isrc := src.internal()
1506
1507         if idst.kind != Array && idst.kind != Slice {
1508                 panic(&ValueError{"reflect.Copy", idst.kind})
1509         }
1510         if idst.kind == Array {
1511                 idst.mustBeAssignable()
1512         }
1513         idst.mustBeExported()
1514         if isrc.kind != Array && isrc.kind != Slice {
1515                 panic(&ValueError{"reflect.Copy", isrc.kind})
1516         }
1517         isrc.mustBeExported()
1518
1519         de := idst.typ.Elem()
1520         se := isrc.typ.Elem()
1521         typesMustMatch("reflect.Copy", de, se)
1522
1523         n := dst.Len()
1524         if sn := src.Len(); n > sn {
1525                 n = sn
1526         }
1527
1528         // If sk is an in-line array, cannot take its address.
1529         // Instead, copy element by element.
1530         if isrc.addr == nil {
1531                 for i := 0; i < n; i++ {
1532                         dst.Index(i).Set(src.Index(i))
1533                 }
1534                 return n
1535         }
1536
1537         // Copy via memmove.
1538         var da, sa unsafe.Pointer
1539         if idst.kind == Array {
1540                 da = idst.addr
1541         } else {
1542                 da = unsafe.Pointer((*SliceHeader)(idst.addr).Data)
1543         }
1544         if isrc.kind == Array {
1545                 sa = isrc.addr
1546         } else {
1547                 sa = unsafe.Pointer((*SliceHeader)(isrc.addr).Data)
1548         }
1549         memmove(da, sa, uintptr(n)*de.Size())
1550         return n
1551 }
1552
1553 /*
1554  * constructors
1555  */
1556
1557 // MakeSlice creates a new zero-initialized slice value
1558 // for the specified slice type, length, and capacity.
1559 func MakeSlice(typ Type, len, cap int) Value {
1560         if typ.Kind() != Slice {
1561                 panic("reflect: MakeSlice of non-slice type")
1562         }
1563         s := &SliceHeader{
1564                 Data: uintptr(unsafe.NewArray(typ.Elem(), cap)),
1565                 Len:  len,
1566                 Cap:  cap,
1567         }
1568         return valueFromAddr(0, typ, unsafe.Pointer(s))
1569 }
1570
1571 // MakeChan creates a new channel with the specified type and buffer size.
1572 func MakeChan(typ Type, buffer int) Value {
1573         if typ.Kind() != Chan {
1574                 panic("reflect: MakeChan of non-chan type")
1575         }
1576         if buffer < 0 {
1577                 panic("MakeChan: negative buffer size")
1578         }
1579         if typ.ChanDir() != BothDir {
1580                 panic("MakeChan: unidirectional channel type")
1581         }
1582         ch := makechan(typ.runtimeType(), uint32(buffer))
1583         return valueFromIword(0, typ, ch)
1584 }
1585
1586 // MakeMap creates a new map of the specified type.
1587 func MakeMap(typ Type) Value {
1588         if typ.Kind() != Map {
1589                 panic("reflect: MakeMap of non-map type")
1590         }
1591         m := makemap(typ.runtimeType())
1592         return valueFromIword(0, typ, m)
1593 }
1594
1595 // Indirect returns the value that v points to.
1596 // If v is a nil pointer, Indirect returns a nil Value.
1597 // If v is not a pointer, Indirect returns v.
1598 func Indirect(v Value) Value {
1599         if v.Kind() != Ptr {
1600                 return v
1601         }
1602         return v.Elem()
1603 }
1604
1605 // ValueOf returns a new Value initialized to the concrete value
1606 // stored in the interface i.  ValueOf(nil) returns the zero Value.
1607 func ValueOf(i interface{}) Value {
1608         if i == nil {
1609                 return Value{}
1610         }
1611         // For an interface value with the noAddr bit set,
1612         // the representation is identical to an empty interface.
1613         eface := *(*emptyInterface)(unsafe.Pointer(&i))
1614         return packValue(0, eface.typ, eface.word)
1615 }
1616
1617 // Zero returns a Value representing a zero value for the specified type.
1618 // The result is different from the zero value of the Value struct,
1619 // which represents no value at all.
1620 // For example, Zero(TypeOf(42)) returns a Value with Kind Int and value 0.
1621 func Zero(typ Type) Value {
1622         if typ == nil {
1623                 panic("reflect: Zero(nil)")
1624         }
1625         if typ.Kind() == Ptr || typ.Kind() == UnsafePointer {
1626                 return valueFromIword(0, typ, 0)
1627         }
1628         return valueFromAddr(0, typ, unsafe.New(typ))
1629 }
1630
1631 // New returns a Value representing a pointer to a new zero value
1632 // for the specified type.  That is, the returned Value's Type is PtrTo(t).
1633 func New(typ Type) Value {
1634         if typ == nil {
1635                 panic("reflect: New(nil)")
1636         }
1637         ptr := unsafe.New(typ)
1638         return valueFromIword(0, PtrTo(typ), iword(uintptr(ptr)))
1639 }
1640
1641 // convertForAssignment 
1642 func convertForAssignment(what string, addr unsafe.Pointer, dst Type, iv internalValue) internalValue {
1643         if iv.method {
1644                 panic(what + ": cannot assign method value to type " + dst.String())
1645         }
1646
1647         dst1 := dst.(*commonType)
1648         if directlyAssignable(dst1, iv.typ) {
1649                 // Overwrite type so that they match.
1650                 // Same memory layout, so no harm done.
1651                 iv.typ = dst1
1652                 return iv
1653         }
1654         if implements(dst1, iv.typ) {
1655                 if addr == nil {
1656                         addr = unsafe.Pointer(new(interface{}))
1657                 }
1658                 x := iv.Interface()
1659                 if dst.NumMethod() == 0 {
1660                         *(*interface{})(addr) = x
1661                 } else {
1662                         ifaceE2I(dst1.runtimeType(), x, addr)
1663                 }
1664                 iv.addr = addr
1665                 iv.word = iword(uintptr(addr))
1666                 iv.typ = dst1
1667                 return iv
1668         }
1669
1670         // Failed.
1671         panic(what + ": value of type " + iv.typ.String() + " is not assignable to type " + dst.String())
1672 }
1673
1674 // implemented in ../pkg/runtime
1675 func chancap(ch iword) int32
1676 func chanclose(ch iword)
1677 func chanlen(ch iword) int32
1678 func chanrecv(ch iword, nb bool) (val iword, selected, received bool)
1679 func chansend(ch iword, val iword, nb bool) bool
1680
1681 func makechan(typ *runtime.Type, size uint32) (ch iword)
1682 func makemap(t *runtime.Type) iword
1683 func mapaccess(m iword, key iword) (val iword, ok bool)
1684 func mapassign(m iword, key, val iword, ok bool)
1685 func mapiterinit(m iword) *byte
1686 func mapiterkey(it *byte) (key iword, ok bool)
1687 func mapiternext(it *byte)
1688 func maplen(m iword) int32
1689
1690 func call(typ *commonType, fnaddr unsafe.Pointer, isInterface bool, isMethod bool, params *unsafe.Pointer, results *unsafe.Pointer)
1691 func ifaceE2I(t *runtime.Type, src interface{}, dst unsafe.Pointer)