History

changed tcc tests name

bellard committed 24 years ago

Commit 04ae07f1 parent d85bf501 file · +1280 −0Browse files

Unified · Split

tcctest.c+1280−0
@@ -0,0 +1,1280 @@
1+/*
2+ * TCC auto test program
3+ */
4+#include <tcclib.h>
5+
6+/* Unfortunately, gcc version < 3 does not handle that! */
7+//#define ALL_ISOC99
8+
9+/* only gcc 3 handles _Bool correctly */
10+//#define BOOL_ISOC99
11+
12+//#define C99_MACROS
13+
14+void string_test();
15+void expr_test();
16+void macro_test();
17+void scope_test();
18+void forward_test();
19+void funcptr_test();
20+void loop_test();
21+void switch_test();
22+void goto_test();
23+void enum_test();
24+void typedef_test();
25+void struct_test();
26+void array_test();
27+void expr_ptr_test();
28+void bool_test();
29+void expr2_test();
30+void constant_expr_test();
31+void expr_cmp_test();
32+void char_short_test();
33+void init_test(void);
34+void compound_literal_test(void);
35+int kr_test();
36+void struct_assign_test();
37+void cast_test(void);
38+void bitfield_test(void);
39+void c99_bool_test(void);
40+void float_test(void);
41+void longlong_test(void);
42+
43+int fib(int n);
44+void num(int n);
45+void forward_ref(void);
46+int isid(int c);
47+
48+#define A 2
49+#define N 1234 + A
50+#define pf printf
51+#define M1(a, b) (a) + (b)
52+
53+#define str(s) # s
54+#define glue(a, b) a ## b
55+#define xglue(a, b) glue(a, b)
56+#define HIGHLOW "hello"
57+#define LOW LOW ", world"
58+
59+#define min(a, b) ((a) < (b) ? (a) : (b))
60+
61+#ifdef C99_MACROS
62+#define dprintf(level,...) printf(__VA_ARGS__)
63+#endif
64+
65+#define AAA 3
66+#undef AAA
67+#define AAA 4
68+
69+void macro_test()
70+{
71+ printf("macro:\n");
72+ pf("N=%d\n", N);
73+ printf("aaa=%d\n", AAA);
74+
75+ printf("min=%d\n", min(1, min(2, -1)));
76+
77+ printf("s1=%s\n", glue(HIGH, LOW));
78+ printf("s2=%s\n", xglue(HIGH, LOW));
79+ printf("s3=%s\n", str("c"));
80+ printf("s4=%s\n", str(a1));
81+
82+#ifdef A
83+ printf("A defined\n");
84+#endif
85+#ifdef B
86+ printf("B defined\n");
87+#endif
88+#ifdef A
89+ printf("A defined\n");
90+#else
91+ printf("A not defined\n");
92+#endif
93+#ifdef B
94+ printf("B defined\n");
95+#else
96+ printf("B not defined\n");
97+#endif
98+
99+#ifdef A
100+ printf("A defined\n");
101+#ifdef B
102+ printf("B1 defined\n");
103+#else
104+ printf("B1 not defined\n");
105+#endif
106+#else
107+ printf("A not defined\n");
108+#ifdef B
109+ printf("B2 defined\n");
110+#else
111+ printf("B2 not defined\n");
112+#endif
113+#endif
114+
115+#if 1+1
116+ printf("test true1\n");
117+#endif
118+#if 0
119+ printf("test true2\n");
120+#endif
121+#if 1-1
122+ printf("test true3\n");
123+#endif
124+#if defined(A)
125+ printf("test trueA\n");
126+#endif
127+#if defined(B)
128+ printf("test trueB\n");
129+#endif
130+
131+#if 0
132+ printf("test 0\n");
133+#elif 0
134+ printf("test 1\n");
135+#elif 2
136+ printf("test 2\n");
137+#else
138+ printf("test 3\n");
139+#endif
140+
141+ printf("__LINE__=%d __FILE__=%s\n",
142+ __LINE__, __FILE__);
143+ /* not strictly preprocessor, but we test it there */
144+#ifdef C99_MACROS
145+ printf("__func__ = %s\n", __func__);
146+ dprintf(1, "vaarg=%d\n", 1);
147+#endif
148+}
149+
150+int op(a,b)
151+{
152+ return a / b;
153+}
154+
155+int ret(a)
156+{
157+ if (a == 2)
158+ return 1;
159+ if (a == 3)
160+ return 2;
161+ return 0;
162+}
163+
164+void ps(char *s)
165+{
166+ int c;
167+ while (1) {
168+ c = *s;
169+ if (c == 0)
170+ break;
171+ printf("%c", c);
172+ s++;
173+ }
174+}
175+
176+void string_test()
177+{
178+ int b;
179+ printf("string:\n");
180+ printf("\141\1423\143\n");/* dezdez test */
181+ printf("\x41\x42\x43\x3a\n");
182+ printf("c=%c\n", 'r');
183+ printf("wc=%C 0x%lx %C\n", L'a', L'\x1234', L'c');
184+ printf("wstring=%S\n", L"abc");
185+ printf("wstring=%S\n", L"abc" L"def" "ghi");
186+ ps("test");
187+ b = 32;
188+ while ((b = b + 1) < 96) {
189+ printf("%c", b);
190+ }
191+ printf("\n");
192+ printf("fib=%d\n", fib(33));
193+ b = 262144;
194+ while (b != 0x80000000) {
195+ num(b);
196+ b = b * 2;
197+ }
198+}
199+
200+void loop_test()
201+{
202+ int i;
203+ i = 0;
204+ while (i < 10)
205+ printf("%d", i++);
206+ printf("\n");
207+ for(i = 0; i < 10;i++)
208+ printf("%d", i);
209+ printf("\n");
210+ i = 0;
211+ do {
212+ printf("%d", i++);
213+ } while (i < 10);
214+ printf("\n");
215+
216+ /* break/continue tests */
217+ i = 0;
218+ while (1) {
219+ if (i == 6)
220+ break;
221+ i++;
222+ if (i == 3)
223+ continue;
224+ printf("%d", i);
225+ }
226+ printf("\n");
227+
228+ /* break/continue tests */
229+ i = 0;
230+ do {
231+ if (i == 6)
232+ break;
233+ i++;
234+ if (i == 3)
235+ continue;
236+ printf("%d", i);
237+ } while(1);
238+ printf("\n");
239+
240+ for(i = 0;i < 10;i++) {
241+ if (i == 3)
242+ continue;
243+ printf("%d", i);
244+ }
245+ printf("\n");
246+}
247+
248+
249+void goto_test()
250+{
251+ int i;
252+
253+ printf("goto:\n");
254+ i = 0;
255+ s_loop:
256+ if (i >= 10)
257+ goto s_end;
258+ printf("%d", i);
259+ i++;
260+ goto s_loop;
261+ s_end:
262+ printf("\n");
263+}
264+
265+enum {
266+ E0,
267+ E1 = 2,
268+ E2 = 4,
269+ E3,
270+ E4,
271+};
272+
273+enum test {
274+ E5 = 1000,
275+};
276+
277+void enum_test()
278+{
279+ enum test b1;
280+ printf("enum:\n%d %d %d %d %d %d\n",
281+ E0, E1, E2, E3, E4, E5);
282+ b1 = 1;
283+ printf("b1=%d\n", b1);
284+}
285+
286+typedef int *my_ptr;
287+
288+void typedef_test()
289+{
290+ my_ptr a;
291+ int b;
292+ a = &b;
293+ *a = 1234;
294+ printf("typedef:\n");
295+ printf("a=%d\n", *a);
296+}
297+
298+void forward_test()
299+{
300+ printf("forward:\n");
301+ forward_ref();
302+ forward_ref();
303+}
304+
305+
306+void forward_ref(void)
307+{
308+ printf("forward ok\n");
309+}
310+
311+typedef struct struct1 {
312+ int f1;
313+ int f2, f3;
314+ union union1 {
315+ int v1;
316+ int v2;
317+ } u;
318+ char str[3];
319+} struct1;
320+
321+struct struct2 {
322+ int a;
323+ char b;
324+};
325+
326+union union2 {
327+ int w1;
328+ int w2;
329+};
330+
331+struct struct1 st1, st2;
332+
333+int main(int argc, char **argv)
334+{
335+ string_test();
336+ expr_test();
337+ macro_test();
338+ scope_test();
339+ forward_test();
340+ funcptr_test();
341+ loop_test();
342+ switch_test();
343+ goto_test();
344+ enum_test();
345+ typedef_test();
346+ struct_test();
347+ array_test();
348+ expr_ptr_test();
349+ bool_test();
350+ expr2_test();
351+ constant_expr_test();
352+ expr_cmp_test();
353+ char_short_test();
354+ init_test();
355+ compound_literal_test();
356+ kr_test();
357+ struct_assign_test();
358+ cast_test();
359+ bitfield_test();
360+ c99_bool_test();
361+ float_test();
362+ longlong_test();
363+ return 0;
364+}
365+
366+int tab[3];
367+int tab2[3][2];
368+
369+int g;
370+
371+void f1(g)
372+{
373+ printf("g1=%d\n", g);
374+}
375+
376+void scope_test()
377+{
378+ printf("scope:\n");
379+ g = 2;
380+ f1(1);
381+ printf("g2=%d\n", g);
382+ {
383+ int g;
384+ g = 3;
385+ printf("g3=%d\n", g);
386+ {
387+ int g;
388+ g = 4;
389+ printf("g4=%d\n", g);
390+ }
391+ }
392+ printf("g5=%d\n", g);
393+}
394+
395+void array_test(int a[4])
396+{
397+ int i, j;
398+
399+ printf("array:\n");
400+ printf("sizeof(a) = %d\n", sizeof(a));
401+ printf("sizeof(int) = %d\n", sizeof(int));
402+ printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
403+ printf("sizeof(short) = %d\n", sizeof(short));
404+ printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
405+ printf("sizeof(char) = %d\n", sizeof(char));
406+ printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
407+ printf("sizeof tab %d\n", sizeof(tab));
408+ printf("sizeof tab2 %d\n", sizeof tab2);
409+ tab[0] = 1;
410+ tab[1] = 2;
411+ tab[2] = 3;
412+ printf("%d %d %d\n", tab[0], tab[1], tab[2]);
413+ for(i=0;i<3;i++)
414+ for(j=0;j<2;j++)
415+ tab2[i][j] = 10 * i + j;
416+ for(i=0;i<3*2;i++) {
417+ printf(" %3d", ((int *)tab2)[i]);
418+ }
419+ printf("\n");
420+}
421+
422+void expr_test()
423+{
424+ int a, b;
425+ a = 0;
426+ printf("%d\n", a += 1);
427+ printf("%d\n", a -= 2);
428+ printf("%d\n", a *= 31232132);
429+ printf("%d\n", a /= 4);
430+ printf("%d\n", a %= 20);
431+ printf("%d\n", a &= 6);
432+ printf("%d\n", a ^= 7);
433+ printf("%d\n", a |= 8);
434+ printf("%d\n", a >>= 3);
435+ printf("%d\n", a <<= 4);
436+
437+ a = 22321;
438+ b = -22321;
439+ printf("%d\n", a + 1);
440+ printf("%d\n", a - 2);
441+ printf("%d\n", a * 312);
442+ printf("%d\n", a / 4);
443+ printf("%d\n", b / 4);
444+ printf("%d\n", (unsigned)b / 4);
445+ printf("%d\n", a % 20);
446+ printf("%d\n", b % 20);
447+ printf("%d\n", (unsigned)b % 20);
448+ printf("%d\n", a & 6);
449+ printf("%d\n", a ^ 7);
450+ printf("%d\n", a | 8);
451+ printf("%d\n", a >> 3);
452+ printf("%d\n", b >> 3);
453+ printf("%d\n", (unsigned)b >> 3);
454+ printf("%d\n", a << 4);
455+ printf("%d\n", ~a);
456+ printf("%d\n", -a);
457+ printf("%d\n", +a);
458+
459+ printf("%d\n", 12 + 1);
460+ printf("%d\n", 12 - 2);
461+ printf("%d\n", 12 * 312);
462+ printf("%d\n", 12 / 4);
463+ printf("%d\n", 12 % 20);
464+ printf("%d\n", 12 & 6);
465+ printf("%d\n", 12 ^ 7);
466+ printf("%d\n", 12 | 8);
467+ printf("%d\n", 12 >> 2);
468+ printf("%d\n", 12 << 4);
469+ printf("%d\n", ~12);
470+ printf("%d\n", -12);
471+ printf("%d\n", +12);
472+ printf("%d %d %d %d\n",
473+ isid('a'),
474+ isid('g'),
475+ isid('T'),
476+ isid('('));
477+}
478+
479+int isid(int c)
480+{
481+ return (c >= 'a' & c <= 'z') | (c >= 'A' & c <= 'Z') | c == '_';
482+}
483+
484+/**********************/
485+
486+int vstack[10], *vstack_ptr;
487+
488+void vpush(int vt, int vc)
489+{
490+ *vstack_ptr++ = vt;
491+ *vstack_ptr++ = vc;
492+}
493+
494+void vpop(int *ft, int *fc)
495+{
496+ *fc = *--vstack_ptr;
497+ *ft = *--vstack_ptr;
498+}
499+
500+void expr2_test()
501+{
502+ int a, b;
503+
504+ printf("expr2:\n");
505+ vstack_ptr = vstack;
506+ vpush(1432432, 2);
507+ vstack_ptr[-2] &= ~0xffffff80;
508+ vpop(&a, &b);
509+ printf("res= %d %d\n", a, b);
510+}
511+
512+void constant_expr_test()
513+{
514+ int a;
515+ printf("constant_expr:\n");
516+ a = 3;
517+ printf("%d\n", a * 16);
518+ printf("%d\n", a * 1);
519+ printf("%d\n", a + 0);
520+}
521+
522+int tab4[10];
523+
524+void expr_ptr_test()
525+{
526+ int *p, *q;
527+
528+ printf("expr_ptr:\n");
529+ p = tab4;
530+ q = tab4 + 10;
531+ printf("diff=%d\n", q - p);
532+ p++;
533+ printf("inc=%d\n", p - tab4);
534+ p--;
535+ printf("dec=%d\n", p - tab4);
536+ ++p;
537+ printf("inc=%d\n", p - tab4);
538+ --p;
539+ printf("dec=%d\n", p - tab4);
540+ printf("add=%d\n", p + 3 - tab4);
541+ printf("add=%d\n", 3 + p - tab4);
542+}
543+
544+void expr_cmp_test()
545+{
546+ int a, b;
547+ printf("constant_expr:\n");
548+ a = -1;
549+ b = 1;
550+ printf("%d\n", a == a);
551+ printf("%d\n", a != a);
552+
553+ printf("%d\n", a < b);
554+ printf("%d\n", a <= b);
555+ printf("%d\n", a <= a);
556+ printf("%d\n", b >= a);
557+ printf("%d\n", a >= a);
558+ printf("%d\n", b > a);
559+
560+ printf("%d\n", (unsigned)a < b);
561+ printf("%d\n", (unsigned)a <= b);
562+ printf("%d\n", (unsigned)a <= a);
563+ printf("%d\n", (unsigned)b >= a);
564+ printf("%d\n", (unsigned)a >= a);
565+ printf("%d\n", (unsigned)b > a);
566+}
567+
568+void struct_test()
569+{
570+ struct1 *s;
571+ union union2 u;
572+
573+ printf("struct:\n");
574+ printf("sizes: %d %d %d %d\n",
575+ sizeof(struct struct1),
576+ sizeof(struct struct2),
577+ sizeof(union union1),
578+ sizeof(union union2));
579+ st1.f1 = 1;
580+ st1.f2 = 2;
581+ st1.f3 = 3;
582+ printf("st1: %d %d %d\n",
583+ st1.f1, st1.f2, st1.f3);
584+ st1.u.v1 = 1;
585+ st1.u.v2 = 2;
586+ printf("union1: %d\n", st1.u.v1);
587+ u.w1 = 1;
588+ u.w2 = 2;
589+ printf("union2: %d\n", u.w1);
590+ s = &st2;
591+ s->f1 = 3;
592+ s->f2 = 2;
593+ s->f3 = 1;
594+ printf("st2: %d %d %d\n",
595+ s->f1, s->f2, s->f3);
596+ printf("str_addr=%x\n", (int)st1.str - (int)&st1.f1);
597+}
598+
599+/* XXX: depend on endianness */
600+void char_short_test()
601+{
602+ int var1, var2;
603+
604+ printf("char_short:\n");
605+
606+ var1 = 0x01020304;
607+ var2 = 0xfffefdfc;
608+ printf("s8=%d %d\n",
609+ *(char *)&var1, *(char *)&var2);
610+ printf("u8=%d %d\n",
611+ *(unsigned char *)&var1, *(unsigned char *)&var2);
612+ printf("s16=%d %d\n",
613+ *(short *)&var1, *(short *)&var2);
614+ printf("u16=%d %d\n",
615+ *(unsigned short *)&var1, *(unsigned short *)&var2);
616+ printf("s32=%d %d\n",
617+ *(int *)&var1, *(int *)&var2);
618+ printf("u32=%d %d\n",
619+ *(unsigned int *)&var1, *(unsigned int *)&var2);
620+ *(char *)&var1 = 0x08;
621+ printf("var1=%x\n", var1);
622+ *(short *)&var1 = 0x0809;
623+ printf("var1=%x\n", var1);
624+ *(int *)&var1 = 0x08090a0b;
625+ printf("var1=%x\n", var1);
626+}
627+
628+/******************/
629+
630+typedef struct Sym {
631+ int v;
632+ int t;
633+ int c;
634+ struct Sym *next;
635+ struct Sym *prev;
636+} Sym;
637+
638+void bool_test()
639+{
640+ int *s, a;
641+
642+ a = 0;
643+ s = (void*)0;
644+ printf("!s=%d\n", !s);
645+
646+ if (!s || !s[0])
647+ a = 1;
648+ printf("a=%d\n", a);
649+
650+ printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
651+ printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
652+ printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
653+#if 1 && 1
654+ printf("a1\n");
655+#endif
656+#if 1 || 0
657+ printf("a2\n");
658+#endif
659+#if 1 ? 0 : 1
660+ printf("a3\n");
661+#endif
662+#if 0 ? 0 : 1
663+ printf("a4\n");
664+#endif
665+
666+ a = 4;
667+ printf("b=%d\n", a + (0 ? 1 : a / 2));
668+}
669+
670+
671+int cinit1 = 0;
672+int *cinit2 = (int []){3, 2, 1};
673+
674+void compound_literal_test(void)
675+{
676+ int *p, i;
677+ char *q, *q3;
678+
679+ printf("compound_test:\n");
680+
681+ p = (int []){1, 2, 3};
682+ for(i=0;i<3;i++)
683+ printf(" %d", p[i]);
684+ printf("\n");
685+
686+ for(i=0;i<3;i++)
687+ printf("%d", cinit2[i]);
688+ printf("\n");
689+
690+ q = "tralala1";
691+ printf("q1=%s\n", q);
692+
693+ q = (char *){ "tralala2" };
694+ printf("q2=%s\n", q);
695+
696+ q3 = (char *){ q };
697+ printf("q3=%s\n", q3);
698+
699+ q = (char []){ "tralala3" };
700+ printf("q4=%s\n", q);
701+
702+#ifdef ALL_ISOC99
703+ p = (int []){1, 2, cinit1 + 3};
704+ for(i=0;i<3;i++)
705+ printf(" %d", p[i]);
706+ printf("\n");
707+
708+ for(i=0;i<3;i++) {
709+ p = (int []){1, 2, 4 + i};
710+ printf("%d %d %d\n",
711+ p[0],
712+ p[1],
713+ p[2]);
714+ }
715+#endif
716+}
717+
718+/* K & R protos */
719+
720+kr_func1(a, b)
721+{
722+ return a + b;
723+}
724+
725+int kr_func2(a, b)
726+{
727+ return a + b;
728+}
729+
730+kr_test()
731+{
732+ printf("kr_test:\n");
733+ printf("func1=%d\n", kr_func1(3, 4));
734+ printf("func2=%d\n", kr_func2(3, 4));
735+ return 0;
736+}
737+
738+void num(int n)
739+{
740+ char *tab, *p;
741+ tab = (char*)malloc(20);
742+ p = tab;
743+ while (1) {
744+ *p = 48 + (n % 10);
745+ p++;
746+ n = n / 10;
747+ if (n == 0)
748+ break;
749+ }
750+ while (p != tab) {
751+ p--;
752+ printf("%c", *p);
753+ }
754+ printf("\n");
755+}
756+
757+/* structure assignment tests */
758+struct structa1 {
759+ int f1;
760+ char f2;
761+};
762+
763+struct structa1 ssta1;
764+
765+void struct_assign_test1(struct structa1 s1, int t)
766+{
767+ printf("%d %d %d\n", s1.f1, s1.f2, t);
768+}
769+
770+struct structa1 struct_assign_test2(struct structa1 s1, int t)
771+{
772+ s1.f1 += t;
773+ s1.f2 -= t;
774+ return s1;
775+}
776+
777+void struct_assign_test()
778+{
779+ struct structa1 lsta1, lsta2;
780+
781+ printf("struct_assign_test:\n");
782+
783+ lsta1.f1 = 1;
784+ lsta1.f2 = 2;
785+ printf("%d %d\n", lsta1.f1, lsta1.f2);
786+ lsta2 = lsta1;
787+ printf("%d %d\n", lsta2.f1, lsta2.f2);
788+
789+ struct_assign_test1(lsta2, 3);
790+
791+ printf("before call: %d %d\n", lsta2.f1, lsta2.f2);
792+ lsta2 = struct_assign_test2(lsta2, 4);
793+ printf("after call: %d %d\n", lsta2.f1, lsta2.f2);
794+}
795+
796+/* casts to short/char */
797+
798+void cast1(char a, short b, unsigned char c, unsigned short d)
799+{
800+ printf("%d %d %d %d\n", a, b, c, d);
801+}
802+
803+char bcast;
804+short scast;
805+
806+void cast_test()
807+{
808+ int a;
809+
810+ printf("cast_test:\n");
811+ a = 0xfffff;
812+ cast1(a, a, a, a);
813+ a = 0xffffe;
814+ printf("%d %d %d %d\n",
815+ (char)(a + 1),
816+ (short)(a + 1),
817+ (unsigned char)(a + 1),
818+ (unsigned short)(a + 1));
819+ printf("%d %d %d %d\n",
820+ (char)0xfffff,
821+ (short)0xfffff,
822+ (unsigned char)0xfffff,
823+ (unsigned short)0xfffff);
824+
825+ a = (bcast = 128) + 1;
826+ printf("%d\n", a);
827+ a = (scast = 65536) + 1;
828+ printf("%d\n", a);
829+}
830+
831+/* initializers tests */
832+struct structinit1 {
833+ int f1;
834+ char f2;
835+ short f3;
836+ int farray[3];
837+};
838+
839+int sinit1 = 2;
840+int sinit2 = { 3 };
841+int sinit3[3] = { 1, 2, {{3}}, };
842+int sinit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
843+int sinit5[3][2] = { 1, 2, 3, 4, 5, 6 };
844+int sinit6[] = { 1, 2, 3 };
845+int sinit7[] = { [2] = 3, [0] = 1, 2 };
846+char sinit8[] = "hello" "trala";
847+
848+struct structinit1 sinit9 = { 1, 2, 3 };
849+struct structinit1 sinit10 = { .f2 = 2, 3, .f1 = 1 };
850+struct structinit1 sinit11 = { .f2 = 2, 3, .f1 = 1,
851+#ifdef ALL_ISOC99
852+ .farray[0] = 10,
853+ .farray[1] = 11,
854+ .farray[2] = 12,
855+#endif
856+};
857+
858+char *sinit12 = "hello world";
859+char *sinit13[] = {
860+ "test1",
861+ "test2",
862+ "test3",
863+};
864+char sinit14[10] = { "abc" };
865+
866+void init_test(void)
867+{
868+ int linit1 = 2;
869+ int linit2 = { 3 };
870+ int linit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
871+ int linit6[] = { 1, 2, 3 };
872+ int i, j;
873+ char linit8[] = "hello" "trala";
874+ int linit12[10] = { 1, 2 };
875+ int linit13[10] = { 1, 2, [7] = 3, [3] = 4, };
876+ char linit14[10] = "abc";
877+ int linit15[10] = { linit1, linit1 + 1, [6] = linit1 + 2, };
878+ struct linit16 { int a1, a2, a3, a4; } linit16 = { 1, .a3 = 2 };
879+
880+ printf("init_test:\n");
881+
882+ printf("sinit1=%d\n", sinit1);
883+ printf("sinit2=%d\n", sinit2);
884+ printf("sinit3=%d %d %d %d\n",
885+ sizeof(sinit3),
886+ sinit3[0],
887+ sinit3[1],
888+ sinit3[2]
889+ );
890+ printf("sinit6=%d\n", sizeof(sinit6));
891+ printf("sinit7=%d %d %d %d\n",
892+ sizeof(sinit7),
893+ sinit7[0],
894+ sinit7[1],
895+ sinit7[2]
896+ );
897+ printf("sinit8=%s\n", sinit8);
898+ printf("sinit9=%d %d %d\n",
899+ sinit9.f1,
900+ sinit9.f2,
901+ sinit9.f3
902+ );
903+ printf("sinit10=%d %d %d\n",
904+ sinit10.f1,
905+ sinit10.f2,
906+ sinit10.f3
907+ );
908+ printf("sinit11=%d %d %d %d %d %d\n",
909+ sinit11.f1,
910+ sinit11.f2,
911+ sinit11.f3,
912+ sinit11.farray[0],
913+ sinit11.farray[1],
914+ sinit11.farray[2]
915+ );
916+
917+ for(i=0;i<3;i++)
918+ for(j=0;j<2;j++)
919+ printf("[%d][%d] = %d %d %d\n",
920+ i, j, sinit4[i][j], sinit5[i][j], linit4[i][j]);
921+ printf("linit1=%d\n", linit1);
922+ printf("linit2=%d\n", linit2);
923+ printf("linit6=%d\n", sizeof(linit6));
924+ printf("linit8=%d %s\n", sizeof(linit8), linit8);
925+
926+ printf("sinit12=%s\n", sinit12);
927+ printf("sinit13=%d %s %s %s\n",
928+ sizeof(sinit13),
929+ sinit13[0],
930+ sinit13[1],
931+ sinit13[2]);
932+ printf("sinit14=%s\n", sinit14);
933+
934+ for(i=0;i<10;i++) printf(" %d", linit12[i]);
935+ printf("\n");
936+ for(i=0;i<10;i++) printf(" %d", linit13[i]);
937+ printf("\n");
938+ for(i=0;i<10;i++) printf(" %d", linit14[i]);
939+ printf("\n");
940+ for(i=0;i<10;i++) printf(" %d", linit15[i]);
941+ printf("\n");
942+ printf("%d %d %d %d\n",
943+ linit16.a1,
944+ linit16.a2,
945+ linit16.a3,
946+ linit16.a4);
947+}
948+
949+void switch_test()
950+{
951+ int i;
952+
953+ for(i=0;i<15;i++) {
954+ switch(i) {
955+ case 0:
956+ case 1:
957+ printf("a");
958+ break;
959+ default:
960+ printf("%d", i);
961+ break;
962+ case 8 ... 12:
963+ printf("c");
964+ break;
965+ case 3:
966+ printf("b");
967+ break;
968+ }
969+ }
970+ printf("\n");
971+}
972+
973+/* ISOC99 _Bool type */
974+void c99_bool_test(void)
975+{
976+#ifdef BOOL_ISOC99
977+ int a;
978+ _Bool b;
979+
980+ printf("bool_test:\n");
981+ printf("sizeof(_Bool) = %d\n", sizeof(_Bool));
982+ a = 3;
983+ printf("cast: %d %d %d\n", (_Bool)10, (_Bool)0, (_Bool)a);
984+ b = 3;
985+ printf("b = %d\n", b);
986+ b++;
987+ printf("b = %d\n", b);
988+#endif
989+}
990+
991+void bitfield_test(void)
992+{
993+ int a;
994+ struct sbf1 {
995+ int f1 : 3;
996+ int : 2;
997+ int f2 : 1;
998+ int : 0;
999+ int f3 : 5;
1000+ int f4 : 7;
1001+ unsigned int f5 : 7;
1002+ } st1;
1003+ printf("bitfield_test:");
1004+ printf("sizeof(st1) = %d\n", sizeof(st1));
1005+
1006+ st1.f1 = 3;
1007+ st1.f2 = 1;
1008+ st1.f3 = 15;
1009+ a = 120;
1010+ st1.f4 = a;
1011+ st1.f5 = a;
1012+ st1.f5++;
1013+ printf("%d %d %d %d %d\n",
1014+ st1.f1, st1.f2, st1.f3, st1.f4, st1.f5);
1015+}
1016+
1017+#define FTEST(prefix, type, fmt)\
1018+void prefix ## cmp(type a, type b)\
1019+{\
1020+ printf("%d %d %d %d %d %d\n",\
1021+ a == b,\
1022+ a != b,\
1023+ a < b,\
1024+ a > b,\
1025+ a >= b,\
1026+ a <= b);\
1027+ printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
1028+ a,\
1029+ b,\
1030+ a + b,\
1031+ a - b,\
1032+ a * b,\
1033+ a / b,\
1034+ -a);\
1035+ printf(fmt "\n", ++a);\
1036+ printf(fmt "\n", a++);\
1037+ printf(fmt "\n", a);\
1038+}\
1039+void prefix ## fcast(type a)\
1040+{\
1041+ float fa;\
1042+ double da;\
1043+ long double la;\
1044+ int ia;\
1045+ unsigned int ua;\
1046+ type b;\
1047+ fa = a;\
1048+ da = a;\
1049+ la = a;\
1050+ printf("ftof: %f %f %Lf\n", fa, da, la);\
1051+ ia = (int)a;\
1052+ ua = (unsigned int)a;\
1053+ printf("ftoi: %d %u\n", ia, ua);\
1054+ ia = -1234;\
1055+ ua = 0x81234500;\
1056+ b = ia;\
1057+ printf("itof: " fmt "\n", b);\
1058+ b = ua;\
1059+ printf("utof: " fmt "\n", b);\
1060+}\
1061+\
1062+void prefix ## test(void)\
1063+{\
1064+ printf("testing '%s'\n", #type);\
1065+ prefix ## cmp(1, 2.5);\
1066+ prefix ## cmp(2, 1.5);\
1067+ prefix ## cmp(1, 1);\
1068+ prefix ## fcast(234.6);\
1069+ prefix ## fcast(-2334.6);\
1070+}
1071+
1072+FTEST(f, float, "%f")
1073+FTEST(d, double, "%f")
1074+FTEST(ld, long double, "%Lf")
1075+
1076+double ftab1[3] = { 1.2, 3.4, 5.6 };
1077+
1078+
1079+void float_test(void)
1080+{
1081+ float fa, fb;
1082+ double da, db;
1083+ int a;
1084+ unsigned int b;
1085+
1086+ printf("float_test:\n");
1087+ printf("sizeof(float) = %d\n", sizeof(float));
1088+ printf("sizeof(double) = %d\n", sizeof(double));
1089+ printf("sizeof(long double) = %d\n", sizeof(long double));
1090+ ftest();
1091+ dtest();
1092+ ldtest();
1093+ printf("%f %f %f\n", ftab1[0], ftab1[1], ftab1[2]);
1094+ printf("%f %f %f\n", 2.12, .5, 2.3e10);
1095+ // printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
1096+ da = 123;
1097+ printf("da=%f\n", da);
1098+ fa = 123;
1099+ printf("fa=%f\n", fa);
1100+ a = 4000000000;
1101+ da = a;
1102+ printf("da = %f\n", da);
1103+ b = 4000000000;
1104+ db = b;
1105+ printf("db = %f\n", db);
1106+}
1107+
1108+int fib(int n)
1109+{
1110+ if (n <= 2)
1111+ return 1;
1112+ else
1113+ return fib(n-1) + fib(n-2);
1114+}
1115+
1116+void funcptr_test()
1117+{
1118+ void (*func)(int);
1119+ int a;
1120+ struct {
1121+ int dummy;
1122+ void (*func)(int);
1123+ } st1;
1124+
1125+ printf("funcptr:\n");
1126+ func = &num;
1127+ (*func)(12345);
1128+ func = num;
1129+ a = 1;
1130+ a = 1;
1131+ func(12345);
1132+ /* more complicated pointer computation */
1133+ st1.func = num;
1134+ st1.func(12346);
1135+ printf("sizeof1 = %d\n", sizeof(funcptr_test));
1136+ printf("sizeof2 = %d\n", sizeof funcptr_test);
1137+ printf("sizeof3 = %d\n", sizeof(&funcptr_test));
1138+ printf("sizeof4 = %d\n", sizeof &funcptr_test);
1139+}
1140+
1141+void lloptest(long long a, long long b)
1142+{
1143+ unsigned long long ua, ub;
1144+
1145+ ua = a;
1146+ ub = b;
1147+ /* arith */
1148+ printf("arith: %Ld %Ld %Ld %Ld %Ld\n",
1149+ a + b,
1150+ a - b,
1151+ a * b,
1152+ a / b,
1153+ a % b);
1154+
1155+ /* binary */
1156+ printf("bin: %Ld %Ld %Ld\n",
1157+ a & b,
1158+ a | b,
1159+ a ^ b);
1160+
1161+ /* tests */
1162+ printf("test: %d %d %d %d %d %d\n",
1163+ a == b,
1164+ a != b,
1165+ a < b,
1166+ a > b,
1167+ a >= b,
1168+ a <= b);
1169+
1170+ printf("utest: %d %d %d %d %d %d\n",
1171+ ua == ub,
1172+ ua != ub,
1173+ ua < ub,
1174+ ua > ub,
1175+ ua >= ub,
1176+ ua <= ub);
1177+
1178+ /* arith2 */
1179+ a++;
1180+ b++;
1181+ printf("arith2: %Ld %Ld\n", a, b);
1182+ printf("arith2: %Ld %Ld\n", a++, b++);
1183+ printf("arith2: %Ld %Ld\n", --a, --b);
1184+ printf("arith2: %Ld %Ld\n", a, b);
1185+}
1186+
1187+void llshift(long long a, int b)
1188+{
1189+ printf("shift: %Ld %Ld %Ld\n",
1190+ (unsigned long long)a >> b,
1191+ a >> b,
1192+ a << b);
1193+ printf("shiftc: %Ld %Ld %Ld\n",
1194+ (unsigned long long)a >> 3,
1195+ a >> 3,
1196+ a << 3);
1197+ printf("shiftc: %Ld %Ld %Ld\n",
1198+ (unsigned long long)a >> 35,
1199+ a >> 35,
1200+ a << 35);
1201+}
1202+
1203+void llfloat(void)
1204+{
1205+ float fa;
1206+ double da;
1207+ long double lda;
1208+ long long la, lb, lc;
1209+ unsigned long long ula, ulb, ulc;
1210+ la = 0x12345678;
1211+ ula = 0x72345678;
1212+ la = (la << 20) | 0x12345;
1213+ ula = ula << 33;
1214+ printf("la=%Ld ula=%Lu\n", la, ula);
1215+
1216+ fa = la;
1217+ da = la;
1218+ lda = la;
1219+ printf("lltof: %f %f %Lf\n", fa, da, lda);
1220+
1221+ la = fa;
1222+ lb = da;
1223+ lc = lda;
1224+ printf("ftoll: %Ld %Ld %Ld\n", la, lb, lc);
1225+
1226+ fa = ula;
1227+ da = ula;
1228+ lda = ula;
1229+ printf("ulltof: %f %f %Lf\n", fa, da, lda);
1230+
1231+ ula = fa;
1232+ ulb = da;
1233+ ulc = lda;
1234+ printf("ftoull: %Lu %Lu %Lu\n", ula, ulb, ulc);
1235+}
1236+
1237+long long llfunc1(int a)
1238+{
1239+ return a;
1240+}
1241+
1242+/* currently not supported, except for typing */
1243+void longlong_test(void)
1244+{
1245+ long long a, b, c;
1246+ int ia;
1247+ unsigned int ua;
1248+ printf("longlong_test:\n");
1249+ printf("sizeof(long long) = %d\n", sizeof(long long));
1250+ ia = -1;
1251+ ua = -2;
1252+ a = ia;
1253+ b = ua;
1254+ printf("%Ld %Ld\n", a, b);
1255+ printf("%Ld %Ld %Ld %Lx\n",
1256+ (long long)1,
1257+ (long long)-2,
1258+ 1LL,
1259+ 0x1234567812345679);
1260+ a = llfunc1(-3);
1261+ printf("%Ld\n", a);
1262+
1263+ lloptest(1000, 23);
1264+ lloptest(0xff, 0x1234);
1265+ b = 0x72345678 << 10;
1266+ lloptest(-3, b);
1267+ llshift(0x123, 5);
1268+ llshift(-23, 5);
1269+ b = 0x72345678 << 10;
1270+ llshift(b, 47);
1271+
1272+ llfloat();
1273+#if 1
1274+ b = 0x12345678;
1275+ a = -1;
1276+ c = a + b;
1277+ printf("%Lx\n", c);
1278+#endif
1279+}
1280+

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t