]> pd.if.org Git - lice/blob - tests/struct.c
autocommit for files dated 2014-11-17 20:15:14
[lice] / tests / struct.c
1 // structures
2
3 struct A {
4     int a;
5     struct {
6         char b;
7         int  c;
8     } y;
9 } A;
10
11 struct B {
12     int a;
13 } B;
14
15 struct C {
16     int a;
17     int b;
18 } C;
19
20 int main(void) {
21     struct {
22         int a;
23     } a;
24     a.a = 1024;
25     expecti(a.a, 1024);
26
27     struct {
28         int a;
29         int b;
30     } b;
31     b.a = 1024;
32     b.b = 2048;
33     expecti(b.a, 1024);
34     expecti(b.b, 2048);
35
36     struct {
37         int a;
38         struct {
39             char b;
40             int  c;
41         } b;
42     } c;
43     c.a   = 1024;
44     c.b.b = 32;
45     c.b.c = 2048;
46     expecti(c.a,   1024);
47     expecti(c.b.b, 32);
48     expecti(c.b.c, 2048);
49
50     struct name1 {
51         int a;
52         struct {
53             char b;
54             int  c;
55         } b;
56     };
57     struct name1 d;
58     d.a   = 16;
59     d.b.b = 32;
60     d.b.c = 64;
61     expecti(d.a,   16);
62     expecti(d.b.b, 32);
63     expecti(d.b.c, 64);
64
65     struct name2 {
66         int a;
67         int b;
68     } e;
69     struct name2 *f = &e;
70
71     // obj->ptr
72     e.a = 128;
73     expecti((*f).a, 128);
74
75     // ptr->obj
76     (*f).a = 256;
77     expecti(e.a, 256);
78
79     // again
80     e.b = 64;
81     expecti((*f).b, 64);
82
83     (*f).b = 128;
84     expecti(e.b, 128);
85
86     // over read?
87     struct {
88         int a[3];
89         int b[3];
90     } g;
91     g.a[0] = 1024;
92     g.b[1] = 2048;
93     expecti(g.a[0], 1024);
94     expecti(g.b[1], 2048);
95     expecti(g.a[4], 2048); // &g.a[4] == &g.b[0]
96
97     A.a   = 64;
98     A.y.b = 65;
99     A.y.c = 256;
100     expecti(A.a,   64);
101     expecti(A.y.b, 65);
102     expecti(A.y.c, 256);
103
104     struct B *h = &B;
105     B.a = 128;
106     expecti((*h).a, 128);
107     expecti(B.a,    128);
108     expecti(h->a,   128);
109
110     h->a = 256;
111     expecti((*h).a, 256);
112     expecti(B.a,    256);
113     expecti(h->a,   256);
114
115     struct C i[3];
116     i[0].a = 32;
117     expecti(i[0].a, 32);
118     i[0].b = 64;
119     expecti(i[0].b, 64);
120     i[1].b = 128;
121     expecti(i[1].b, 128);
122     int *j = i;
123     expecti(j[3], 128); // &j[3] == &i[1].b
124
125     struct { char c; } k = { 'a' };
126     expecti(k.c, 'a');
127
128     struct { int a[3]; } l = { { 1, 2, 3 } };
129     expecti(l.a[0], 1);
130     expecti(l.a[1], 2);
131     expecti(l.a[2], 3);
132
133     // unnamed shit
134     struct {
135         union {
136             struct {
137                 int x;
138                 int y;
139             };
140             struct {
141                 char c[8];
142             };
143         };
144     } m;
145     m.x = 10;
146     m.y = 20;
147     expecti(m.c[0], 10);
148     expecti(m.c[4], 20);
149
150     // structure copy via assignment
151     struct {
152         int a;
153         int b;
154         int c;
155     } X, Y, Z;
156     X.a = 8;
157     X.b = 16;
158     X.c = 32;
159     Y = X;
160     Z.a = 64;
161     Z.b = 128;
162     Z.c = 256;
163     expecti(Y.a, 8);
164     expecti(Y.b, 16);
165     expecti(Y.c, 32);
166     Y = Z;
167     expecti(Y.a, 64);
168     expecti(Y.b, 128);
169     expecti(Y.c, 256);
170
171     // arrows
172     struct cell {
173         int value;
174         struct cell *next;
175     };
176     struct cell aa = { 10, 0 };
177     struct cell bb = { 20, &aa };
178     struct cell cc = { 30, &bb };
179     struct cell *dd = &cc;
180
181     expecti(cc.value,              30);
182     expecti(dd->value,             30);
183     expecti(dd->next->value,       20);
184     expecti(dd->next->next->value, 10);
185
186     dd->value             = 16;
187     dd->next->value       = 32;
188     dd->next->next->value = 64;
189     expecti(dd->value,             16);
190     expecti(dd->next->value,       32);
191     expecti(dd->next->next->value, 64);
192
193     // addressing
194     struct super {
195         int a;
196         struct {
197             int b;
198         } y;
199     } poke = { 99, 100 };
200
201     int *poke1 = &poke.a;
202     int *poke2 = &poke.y.b;
203
204     expecti(*poke1,     99);
205     expecti(*poke2,     100);
206     expecti(*&poke.a,   99);
207     expecti(*&poke.y.b, 100);
208
209     struct super *inward = &poke;
210     int *poke3 = &inward->a;
211     int *poke4 = &inward->y.b;
212
213     expecti(*poke3,        99);
214     expecti(*poke4,        100);
215     expecti(*&inward->a,   99);
216     expecti(*&inward->y.b, 100);
217
218     // incomplete in the opposite direction
219     struct incomplete1;
220     struct incomplete2 {
221         struct incomplete1 *next;
222     };
223     struct incomplete1 {
224         int value;
225     };
226
227     struct incomplete1 in1 = { 3 };
228     struct incomplete2 in2 = { &in1 };
229
230     expecti(in2.next->value, 3);
231
232     struct {
233         int x;
234     } __a = {
235         1024
236     }, *__b = &__a;
237     int *__c = &__b->x;
238
239     expecti(*__c, 1024);
240
241
242     // bit fields
243     union {
244         int i;
245         struct {
246             int a: 5;
247             int b: 5;
248         };
249     } bitfield;
250     bitfield.i = 0;
251     bitfield.a = 20;
252     bitfield.b = 15;
253     expecti(bitfield.i, 500); // (15 << 5) + 20 == 500
254
255     struct {
256         char a:4;
257         char b:4;
258     } bitfield2 = { 5, 10 };
259
260     expecti(bitfield2.a, 5);
261     expecti(bitfield2.b, 10);
262
263     union {
264         int  a: 10;
265         char b: 5;
266         char c: 5;
267     } bitfield3;
268
269     bitfield3.a = 2;
270     expecti(bitfield3.a, 2);
271     expecti(bitfield3.b, 2);
272     expecti(bitfield3.c, 2);
273
274     struct __empty {};
275     expecti(sizeof(struct __empty), 0);
276
277     // FAMS
278     struct __fam0 { int a, b[]; };
279     struct __fam1 { int a, b[0]; };
280
281     expecti(sizeof(struct __fam0), 4);
282     expecti(sizeof(struct __fam1), 4);
283
284     struct __gccfam { int a[0]; };
285     expecti(sizeof(struct __gccfam), 0);
286
287     struct __famoverwrite { int a, b[]; };
288     struct __famoverwrite OV = { 1, 2, 3, 4, 5 };
289
290     expecti(OV.b[0], 2);
291     expecti(OV.b[1], 3);
292     expecti(OV.b[2], 4);
293     expecti(OV.b[3], 5);
294
295     return 0;
296 }