tcctest.c

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