OSDN Git Service

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