OSDN Git Service

05e37736b8879c2e6627f2001e72d7ef1c076a9f
[pf3gnuchains/gcc-fork.git] / libgo / runtime / iface.goc
1 // Copyright 2010 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 runtime
6 #include "go-panic.h"
7 #include "go-type.h"
8 #include "interface.h"
9 #define nil NULL
10
11 typedef _Bool bool;
12 typedef struct __go_type_descriptor descriptor;
13 typedef const struct __go_type_descriptor const_descriptor;
14 typedef struct __go_interface interface;
15 typedef struct __go_empty_interface empty_interface;
16
17 // Compare two type descriptors.
18 func ifacetypeeq(a *descriptor, b *descriptor) (eq bool) {
19         eq = __go_type_descriptors_equal(a, b);
20 }
21
22 // Return the descriptor for an empty interface type.n
23 func efacetype(e empty_interface) (d *const_descriptor) {
24         return e.__type_descriptor;
25 }
26
27 // Return the descriptor for a non-empty interface type.
28 func ifacetype(i interface) (d *const_descriptor) {
29         if (i.__methods == nil) {
30                 return nil;
31         }
32         d = i.__methods[0];
33 }
34
35 // Convert an empty interface to an empty interface.
36 func ifaceE2E2(e empty_interface) (ret empty_interface, ok bool) {
37         if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
38                 __go_panic_msg("invalid interface value");
39         ret = e;
40         ok = ret.__type_descriptor != nil;
41 }
42
43 // Convert a non-empty interface to an empty interface.
44 func ifaceI2E2(i interface) (ret empty_interface, ok bool) {
45         if (i.__methods == nil) {
46                 ret.__type_descriptor = nil;
47                 ret.__object = nil;
48                 ok = 0;
49         } else {
50                 ret.__type_descriptor = i.__methods[0];
51                 ret.__object = i.__object;
52                 ok = 1;
53         }
54 }
55
56 // Convert an empty interface to a non-empty interface.
57 func ifaceE2I2(inter *descriptor, e empty_interface) (ret interface, ok bool) {
58         if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
59                 __go_panic_msg("invalid interface value");
60         if (e.__type_descriptor == nil) {
61                 ret.__methods = nil;
62                 ret.__object = nil;
63                 ok = 0;
64         } else {
65                 ret.__methods = __go_convert_interface_2(inter,
66                                                          e.__type_descriptor,
67                                                          1);
68                 ret.__object = e.__object;
69                 ok = ret.__methods != nil;
70         }
71 }
72
73 // Convert a non-empty interface to a non-empty interface.
74 func ifaceI2I2(inter *descriptor, i interface) (ret interface, ok bool) {
75         if (i.__methods == nil) {
76                 ret.__methods = nil;
77                 ret.__object = nil;
78                 ok = 0;
79         } else {
80                 ret.__methods = __go_convert_interface_2(inter,
81                                                          i.__methods[0], 1);
82                 ret.__object = i.__object;
83                 ok = ret.__methods != nil;
84         }
85 }
86
87 // Convert an empty interface to a pointer type.
88 func ifaceE2T2P(inter *descriptor, e empty_interface) (ret *void, ok bool) {
89         if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
90                 __go_panic_msg("invalid interface value");
91         if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
92                 ret = nil;
93                 ok = 0;
94         } else {
95                 ret = e.__object;
96                 ok = 1;
97         }
98 }
99
100 // Convert a non-empty interface to a pointer type.
101 func ifaceI2T2P(inter *descriptor, i interface) (ret *void, ok bool) {
102         if (i.__methods == nil
103             || !__go_type_descriptors_equal(inter, i.__methods[0])) {
104                 ret = nil;
105                 ok = 0;
106         } else {
107                 ret = i.__object;
108                 ok = 1;
109         }
110 }
111
112 // Convert an empty interface to a non-pointer type.
113 func ifaceE2T2(inter *descriptor, e empty_interface, ret *void) (ok bool) {
114         if(((uintptr_t)e.__type_descriptor&reflectFlags) != 0)
115                 __go_panic_msg("invalid interface value");
116         if (!__go_type_descriptors_equal(inter, e.__type_descriptor)) {
117                 __builtin_memset(ret, 0, inter->__size);
118                 ok = 0;
119         } else {
120                 __builtin_memcpy(ret, e.__object, inter->__size);
121                 ok = 1;
122         }
123 }
124
125 // Convert a non-empty interface to a non-pointer type.
126 func ifaceI2T2(inter *descriptor, i interface, ret *void) (ok bool) {
127         if (i.__methods == nil
128             || !__go_type_descriptors_equal(inter, i.__methods[0])) {
129                 __builtin_memset(ret, 0, inter->__size);
130                 ok = 0;
131         } else {
132                 __builtin_memcpy(ret, i.__object, inter->__size);
133                 ok = 1;
134         }
135 }
136
137 // Return whether we can convert an interface to a type.
138 func ifaceI2Tp(to *descriptor, from *descriptor) (ok bool) {
139         ok = __go_can_convert_to_interface(to, from);
140 }