Debian Codegraph @

.cargo/vendor/cbindgen/tests/expectations/asserted_cast.cpp

raw
1 #define MY_ASSERT(...) do { } while (0)
2 #define MY_ATTRS __attribute((noinline))
3
4
5 #include <cstdarg>
6 #include <cstdint>
7 #include <cstdlib>
8 #include <ostream>
9 #include <new>
10
11 struct I;
12
13 struct H {
14 enum class Tag : uint8_t {
15 H_Foo,
16 H_Bar,
17 H_Baz,
18 };
19
20 struct H_Foo_Body {
21 int16_t _0;
22 };
23
24 struct H_Bar_Body {
25 uint8_t x;
26 int16_t y;
27 };
28
29 Tag tag;
30 union {
31 H_Foo_Body foo;
32 H_Bar_Body bar;
33 };
34
35 static H H_Foo(const int16_t &_0) {
36 H result;
37 ::new (&result.foo._0) (int16_t)(_0);
38 result.tag = Tag::H_Foo;
39 return result;
40 }
41
42 bool IsH_Foo() const {
43 return tag == Tag::H_Foo;
44 }
45
46 const int16_t& AsH_Foo() const {
47 MY_ASSERT(IsH_Foo());
48 return foo._0;
49 }
50
51 MY_ATTRS int16_t& AsH_Foo() {
52 MY_ASSERT(IsH_Foo());
53 return foo._0;
54 }
55
56 static H H_Bar(const uint8_t &x,
57 const int16_t &y) {
58 H result;
59 ::new (&result.bar.x) (uint8_t)(x);
60 ::new (&result.bar.y) (int16_t)(y);
61 result.tag = Tag::H_Bar;
62 return result;
63 }
64
65 bool IsH_Bar() const {
66 return tag == Tag::H_Bar;
67 }
68
69 MY_ATTRS const H_Bar_Body& AsH_Bar() const {
70 MY_ASSERT(IsH_Bar());
71 return bar;
72 }
73
74 H_Bar_Body& AsH_Bar() {
75 MY_ASSERT(IsH_Bar());
76 return bar;
77 }
78
79 static H H_Baz() {
80 H result;
81 result.tag = Tag::H_Baz;
82 return result;
83 }
84
85 MY_ATTRS bool IsH_Baz() const {
86 return tag == Tag::H_Baz;
87 }
88 };
89
90 struct J {
91 enum class Tag : uint8_t {
92 J_Foo,
93 J_Bar,
94 J_Baz,
95 };
96
97 struct J_Foo_Body {
98 int16_t _0;
99 };
100
101 struct J_Bar_Body {
102 uint8_t x;
103 int16_t y;
104 };
105
106 Tag tag;
107 union {
108 J_Foo_Body foo;
109 J_Bar_Body bar;
110 };
111
112 static J J_Foo(const int16_t &_0) {
113 J result;
114 ::new (&result.foo._0) (int16_t)(_0);
115 result.tag = Tag::J_Foo;
116 return result;
117 }
118
119 bool IsJ_Foo() const {
120 return tag == Tag::J_Foo;
121 }
122
123 const int16_t& AsJ_Foo() const {
124 MY_ASSERT(IsJ_Foo());
125 return foo._0;
126 }
127
128 int16_t& AsJ_Foo() {
129 MY_ASSERT(IsJ_Foo());
130 return foo._0;
131 }
132
133 static J J_Bar(const uint8_t &x,
134 const int16_t &y) {
135 J result;
136 ::new (&result.bar.x) (uint8_t)(x);
137 ::new (&result.bar.y) (int16_t)(y);
138 result.tag = Tag::J_Bar;
139 return result;
140 }
141
142 bool IsJ_Bar() const {
143 return tag == Tag::J_Bar;
144 }
145
146 const J_Bar_Body& AsJ_Bar() const {
147 MY_ASSERT(IsJ_Bar());
148 return bar;
149 }
150
151 J_Bar_Body& AsJ_Bar() {
152 MY_ASSERT(IsJ_Bar());
153 return bar;
154 }
155
156 static J J_Baz() {
157 J result;
158 result.tag = Tag::J_Baz;
159 return result;
160 }
161
162 bool IsJ_Baz() const {
163 return tag == Tag::J_Baz;
164 }
165 };
166
167 union K {
168 enum class Tag : uint8_t {
169 K_Foo,
170 K_Bar,
171 K_Baz,
172 };
173
174 struct K_Foo_Body {
175 Tag tag;
176 int16_t _0;
177 };
178
179 struct K_Bar_Body {
180 Tag tag;
181 uint8_t x;
182 int16_t y;
183 };
184
185 struct {
186 Tag tag;
187 };
188 K_Foo_Body foo;
189 K_Bar_Body bar;
190
191 static K K_Foo(const int16_t &_0) {
192 K result;
193 ::new (&result.foo._0) (int16_t)(_0);
194 result.tag = Tag::K_Foo;
195 return result;
196 }
197
198 bool IsK_Foo() const {
199 return tag == Tag::K_Foo;
200 }
201
202 const int16_t& AsK_Foo() const {
203 MY_ASSERT(IsK_Foo());
204 return foo._0;
205 }
206
207 int16_t& AsK_Foo() {
208 MY_ASSERT(IsK_Foo());
209 return foo._0;
210 }
211
212 static K K_Bar(const uint8_t &x,
213 const int16_t &y) {
214 K result;
215 ::new (&result.bar.x) (uint8_t)(x);
216 ::new (&result.bar.y) (int16_t)(y);
217 result.tag = Tag::K_Bar;
218 return result;
219 }
220
221 bool IsK_Bar() const {
222 return tag == Tag::K_Bar;
223 }
224
225 const K_Bar_Body& AsK_Bar() const {
226 MY_ASSERT(IsK_Bar());
227 return bar;
228 }
229
230 K_Bar_Body& AsK_Bar() {
231 MY_ASSERT(IsK_Bar());
232 return bar;
233 }
234
235 static K K_Baz() {
236 K result;
237 result.tag = Tag::K_Baz;
238 return result;
239 }
240
241 bool IsK_Baz() const {
242 return tag == Tag::K_Baz;
243 }
244 };
245
246 extern "C" {
247
248 void foo(H h, I i, J j, K k);
249
250 } // extern "C"