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