tcctest.c

   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