tcctest.c

   1 /*
   2  * TCC auto test program
   3  */
   4 #include "config.h"
   5
   6 #if GCC_MAJOR >= 3
   7
   8 /* Unfortunately, gcc version < 3 does not handle that! */
   9 #define ALL_ISOC99
  10
  11 /* only gcc 3 handles _Bool correctly */
  12 #define BOOL_ISOC99
  13
  14 /* gcc 2.95.3 does not handle correctly CR in strings or after strays */
  15 #define CORRECT_CR_HANDLING
  16
  17 #endif
  18
  19 /* deprecated and no longer supported in gcc 3.3 */
  20 //#define ACCEPT_CR_IN_STRINGS
  21
  22 /* __VA_ARGS__ and __func__ support */
  23 #define C99_MACROS
  24
  25 /* test various include syntaxes */
  26
  27 #define TCCLIB_INC <tcclib.h>
  28 #define TCCLIB_INC1 <tcclib
  29 #define TCCLIB_INC2 h>
  30 #define TCCLIB_INC3 "tcclib"
  31
  32 #include TCCLIB_INC
  33
  34 #include TCCLIB_INC1.TCCLIB_INC2
  35
  36 #include TCCLIB_INC1.h>
  37
  38 /* gcc 3.2 does not accept that (bug ?) */
  39 //#include TCCLIB_INC3 ".h"
  40
  41 #include <tcclib.h>
  42
  43 #include "tcclib.h"
  44
  45 void string_test();
  46 void expr_test();
  47 void macro_test();
  48 void scope_test();
  49 void forward_test();
  50 void funcptr_test();
  51 void loop_test();
  52 void switch_test();
  53 void goto_test();
  54 void enum_test();
  55 void typedef_test();
  56 void struct_test();
  57 void array_test();
  58 void expr_ptr_test();
  59 void bool_test();
  60 void expr2_test();
  61 void constant_expr_test();
  62 void expr_cmp_test();
  63 void char_short_test();
  64 void init_test(void);
  65 void compound_literal_test(void);
  66 int kr_test();
  67 void struct_assign_test(void);
  68 void cast_test(void);
  69 void bitfield_test(void);
  70 void c99_bool_test(void);
  71 void float_test(void);
  72 void longlong_test(void);
  73 void stdarg_test(void);
  74 void whitespace_test(void);
  75 void relocation_test(void);
  76 void old_style_function(void);
  77 void sizeof_test(void);
  78 void typeof_test(void);
  79 void local_label_test(void);
  80 void statement_expr_test(void);
  81 void asm_test(void);
  82 void builtin_test(void);
  83
  84 int fib(int n);
  85 void num(int n);
  86 void forward_ref(void);
  87 int isid(int c);
  88
  89 #define A 2
  90 #define N 1234 + A
  91 #define pf printf
  92 #define M1(a, b)  (a) + (b)
  93
  94 #define str\
  95 (s) # s
  96 #define glue(a, b) a ## b
  97 #define xglue(a, b) glue(a, b)
  98 #define HIGHLOW "hello"
  99 #define LOW LOW ", world"
 100
 101 #define min(a, b) ((a) < (b) ? (a) : (b))
 102
 103 #ifdef C99_MACROS
 104 #define dprintf(level,...) printf(__VA_ARGS__)
 105 #endif
 106
 107 /* gcc vararg macros */
 108 #define dprintf1(level, fmt, args...) printf(fmt, ## args)
 109
 110 #define MACRO_NOARGS()
 111
 112 #define AAA 3
 113 #undef AAA
 114 #define AAA 4
 115
 116 #if 1
 117 #define B3 1
 118 #elif 1
 119 #define B3 2
 120 #elif 0
 121 #define B3 3
 122 #else
 123 #define B3 4
 124 #endif
 125
 126 #define __INT64_C(c)    c ## LL
 127 #define INT64_MIN       (-__INT64_C(9223372036854775807)-1)
 128
 129 int qq(int x)
 130 {
 131     return x + 40;
 132 }
 133 #define qq(x) x
 134
 135 #define spin_lock(lock) do { } while (0)
 136 #define wq_spin_lock spin_lock
 137 #define TEST2() wq_spin_lock(a)
 138
 139 void macro_test(void)
 140 {
 141     printf("macro:\n");\f\v
 142     pf("N=%d\n", N);
 143     printf("aaa=%d\n", AAA);
 144
 145     printf("min=%d\n", min(1, min(2, -1)));
 146
 147     printf("s1=%s\n", glue(HIGH, LOW));
 148     printf("s2=%s\n", xglue(HIGH, LOW));
 149     printf("s3=%s\n", str("c"));
 150     printf("s4=%s\n", str(a1));
 151     printf("B3=%d\n", B3);
 152
 153 #ifdef A
 154     printf("A defined\n");
 155 #endif
 156 #ifdef B
 157     printf("B defined\n");
 158 #endif
 159 #ifdef A
 160     printf("A defined\n");
 161 #else
 162     printf("A not defined\n");
 163 #endif
 164 #ifdef B
 165     printf("B defined\n");
 166 #else
 167     printf("B not defined\n");
 168 #endif
 169
 170 #ifdef A
 171     printf("A defined\n");
 172 #ifdef B
 173     printf("B1 defined\n");
 174 #else
 175     printf("B1 not defined\n");
 176 #endif
 177 #else
 178     printf("A not defined\n");
 179 #ifdef B
 180     printf("B2 defined\n");
 181 #else
 182     printf("B2 not defined\n");
 183 #endif
 184 #endif
 185
 186 #if 1+1
 187     printf("test true1\n");
 188 #endif
 189 #if 0
 190     printf("test true2\n");
 191 #endif
 192 #if 1-1
 193     printf("test true3\n");
 194 #endif
 195 #if defined(A)
 196     printf("test trueA\n");
 197 #endif
 198 #if defined(B)
 199     printf("test trueB\n");
 200 #endif
 201
 202 #if 0
 203     printf("test 0\n");
 204 #elif 0
 205     printf("test 1\n");
 206 #elif 2
 207     printf("test 2\n");
 208 #else
 209     printf("test 3\n");
 210 #endif
 211
 212     MACRO_NOARGS();
 213
 214 #ifdef __LINE__
 215     printf("__LINE__ defined\n");
 216 #endif
 217
 218     printf("__LINE__=%d __FILE__=%s\n",
 219            __LINE__, __FILE__);
 220 #line 200
 221     printf("__LINE__=%d __FILE__=%s\n",
 222            __LINE__, __FILE__);
 223 #line 203 "test"
 224     printf("__LINE__=%d __FILE__=%s\n",
 225            __LINE__, __FILE__);
 226 #line 227 "tcctest.c"
 227
 228     /* not strictly preprocessor, but we test it there */
 229 #ifdef C99_MACROS
 230     printf("__func__ = %s\n", __func__);
 231     dprintf(1, "vaarg=%d\n", 1);
 232 #endif
 233     dprintf1(1, "vaarg1\n");
 234     dprintf1(1, "vaarg1=%d\n", 2);
 235     dprintf1(1, "vaarg1=%d %d\n", 1, 2);
 236
 237     /* gcc extension */
 238     printf("func='%s'\n", __FUNCTION__);
 239
 240     /* complicated macros in glibc */
 241     printf("INT64_MIN=%Ld\n", INT64_MIN);
 242     {
 243         int a;
 244         a = 1;
 245         glue(a+, +);
 246         printf("a=%d\n", a);
 247         glue(a <, <= 2);
 248         printf("a=%d\n", a);
 249     }
 250
 251     /* macro function with argument outside the macro string */
 252 #define MF_s MF_hello
 253 #define MF_hello(msg) printf("%s\n",msg)
 254
 255 #define MF_t printf("tralala\n"); MF_hello
 256
 257     MF_s("hi");
 258     MF_t("hi");
 259
 260     /* test macro substituion inside args (should not eat stream) */
 261     printf("qq=%d\n", qq(qq)(2));
 262
 263     /* test zero argument case. NOTE: gcc 2.95.x does not accept a
 264        null argument without a space. gcc 3.2 fixes that. */
 265
 266 #define qq1(x) 1
 267     printf("qq1=%d\n", qq1( ));
 268
 269     /* comment with stray handling *\
 270 /
 271        /* this is a valid *\/ comment */
 272        /* this is a valid comment *\*/
 273     //  this is a valid\
 274 comment
 275
 276     /* test function macro substitution when the function name is
 277        substituted */
 278     TEST2();
 279 }
 280
 281 int op(a,b)
 282 {
 283     return a / b;
 284 }
 285
 286 int ret(a)
 287 {
 288     if (a == 2)
 289         return 1;
 290     if (a == 3)
 291         return 2;
 292     return 0;
 293 }
 294
 295 void ps(const char *s)
 296 {
 297     int c;
 298     while (1) {
 299         c = *s;
 300         if (c == 0)
 301             break;
 302         printf("%c", c);
 303         s++;
 304     }
 305 }
 306
 307 const char foo1_string[] = "\
 308 bar\n\
 309 test\14\
 310 1";
 311
 312 void string_test()
 313 {
 314 #if defined(__x86_64__) && defined(__GNUC__)
 315     unsigned int b;
 316 #else
 317     int b;
 318 #endif
 319     printf("string:\n");
 320     printf("\141\1423\143\n");/* dezdez test */
 321     printf("\x41\x42\x43\x3a\n");
 322     printf("c=%c\n", 'r');
 323     printf("wc=%C 0x%lx %C\n", L'a', L'\x1234', L'c');
 324     printf("foo1_string='%s'\n", foo1_string);
 325 #if 0
 326     printf("wstring=%S\n", L"abc");
 327     printf("wstring=%S\n", L"abc" L"def" "ghi");
 328     printf("'\\377'=%d '\\xff'=%d\n", '\377', '\xff');
 329     printf("L'\\377'=%d L'\\xff'=%d\n", L'\377', L'\xff');
 330 #endif
 331     ps("test\n");
 332     b = 32;
 333     while ((b = b + 1) < 96) {
 334         printf("%c", b);
 335     }
 336     printf("\n");
 337     printf("fib=%d\n", fib(33));
 338     b = 262144;
 339     while (b != 0x80000000) {
 340         num(b);
 341         b = b * 2;
 342     }
 343 }
 344
 345 void loop_test()
 346 {
 347     int i;
 348     i = 0;
 349     while (i < 10)
 350         printf("%d", i++);
 351     printf("\n");
 352     for(i = 0; i < 10;i++)
 353         printf("%d", i);
 354     printf("\n");
 355     i = 0;
 356     do {
 357         printf("%d", i++);
 358     } while (i < 10);
 359     printf("\n");
 360
 361     /* break/continue tests */
 362     i = 0;
 363     while (1) {
 364         if (i == 6)
 365             break;
 366         i++;
 367         if (i == 3)
 368             continue;
 369         printf("%d", i);
 370     }
 371     printf("\n");
 372
 373     /* break/continue tests */
 374     i = 0;
 375     do {
 376         if (i == 6)
 377             break;
 378         i++;
 379         if (i == 3)
 380             continue;
 381         printf("%d", i);
 382     } while(1);
 383     printf("\n");
 384
 385     for(i = 0;i < 10;i++) {
 386         if (i == 3)
 387             continue;
 388         printf("%d", i);
 389     }
 390     printf("\n");
 391 }
 392
 393
 394 void goto_test()
 395 {
 396     int i;
 397     static void *label_table[3] = { &&label1, &&label2, &&label3 };
 398
 399     printf("goto:\n");
 400     i = 0;
 401  s_loop:
 402     if (i >= 10)
 403         goto s_end;
 404     printf("%d", i);
 405     i++;
 406     goto s_loop;
 407  s_end:
 408     printf("\n");
 409
 410     /* we also test computed gotos (GCC extension) */
 411     for(i=0;i<3;i++) {
 412         goto *label_table[i];
 413     label1:
 414         printf("label1\n");
 415         goto next;
 416     label2:
 417         printf("label2\n");
 418         goto next;
 419     label3:
 420         printf("label3\n");
 421     next: ;
 422     }
 423 }
 424
 425 enum {
 426     E0,
 427     E1 = 2,
 428     E2 = 4,
 429     E3,
 430     E4,
 431 };
 432
 433 enum test {
 434     E5 = 1000,
 435 };
 436
 437 void enum_test()
 438 {
 439     enum test b1;
 440     printf("enum:\n%d %d %d %d %d %d\n",
 441            E0, E1, E2, E3, E4, E5);
 442     b1 = 1;
 443     printf("b1=%d\n", b1);
 444 }
 445
 446 typedef int *my_ptr;
 447
 448 typedef int mytype1;
 449 typedef int mytype2;
 450
 451 void typedef_test()
 452 {
 453     my_ptr a;
 454     mytype1 mytype2;
 455     int b;
 456
 457     a = &b;
 458     *a = 1234;
 459     printf("typedef:\n");
 460     printf("a=%d\n", *a);
 461     mytype2 = 2;
 462     printf("mytype2=%d\n", mytype2);
 463 }
 464
 465 void forward_test()
 466 {
 467     printf("forward:\n");
 468     forward_ref();
 469     forward_ref();
 470 }
 471
 472
 473 void forward_ref(void)
 474 {
 475     printf("forward ok\n");
 476 }
 477
 478 typedef struct struct1 {
 479     int f1;
 480     int f2, f3;
 481     union union1 {
 482         int v1;
 483         int v2;
 484     } u;
 485     char str[3];
 486 } struct1;
 487
 488 struct struct2 {
 489     int a;
 490     char b;
 491 };
 492
 493 union union2 {
 494     int w1;
 495     int w2;
 496 };
 497
 498 struct struct1 st1, st2;
 499
 500 int main(int argc, char **argv)
 501 {
 502     string_test();
 503     expr_test();
 504     macro_test();
 505     scope_test();
 506     forward_test();
 507     funcptr_test();
 508     loop_test();
 509     switch_test();
 510     goto_test();
 511     enum_test();
 512     typedef_test();
 513     struct_test();
 514     array_test();
 515     expr_ptr_test();
 516     bool_test();
 517     expr2_test();
 518     constant_expr_test();
 519     expr_cmp_test();
 520     char_short_test();
 521     init_test();
 522     compound_literal_test();
 523     kr_test();
 524     struct_assign_test();
 525     cast_test();
 526     bitfield_test();
 527     c99_bool_test();
 528     float_test();
 529     longlong_test();
 530     stdarg_test();
 531     whitespace_test();
 532     relocation_test();
 533     old_style_function();
 534     sizeof_test();
 535     typeof_test();
 536     statement_expr_test();
 537     local_label_test();
 538     asm_test();
 539     builtin_test();
 540     return 0;
 541 }
 542
 543 int tab[3];
 544 int tab2[3][2];
 545
 546 int g;
 547
 548 void f1(g)
 549 {
 550     printf("g1=%d\n", g);
 551 }
 552
 553 void scope_test()
 554 {
 555     printf("scope:\n");
 556     g = 2;
 557     f1(1);
 558     printf("g2=%d\n", g);
 559     {
 560         int g;
 561         g = 3;
 562         printf("g3=%d\n", g);
 563         {
 564             int g;
 565             g = 4;
 566             printf("g4=%d\n", g);
 567         }
 568     }
 569     printf("g5=%d\n", g);
 570 }
 571
 572 void array_test(int a[4])
 573 {
 574     int i, j;
 575
 576     printf("array:\n");
 577     printf("sizeof(a) = %d\n", sizeof(a));
 578     printf("sizeof(\"a\") = %d\n", sizeof("a"));
 579 #ifdef C99_MACROS
 580     printf("sizeof(__func__) = %d\n", sizeof(__func__));
 581 #endif
 582     printf("sizeof tab %d\n", sizeof(tab));
 583     printf("sizeof tab2 %d\n", sizeof tab2);
 584     tab[0] = 1;
 585     tab[1] = 2;
 586     tab[2] = 3;
 587     printf("%d %d %d\n", tab[0], tab[1], tab[2]);
 588     for(i=0;i<3;i++)
 589         for(j=0;j<2;j++)
 590             tab2[i][j] = 10 * i + j;
 591     for(i=0;i<3*2;i++) {
 592         printf(" %3d", ((int *)tab2)[i]);
 593     }
 594     printf("\n");
 595 }
 596
 597 void expr_test()
 598 {
 599     int a, b;
 600     a = 0;
 601     printf("%d\n", a += 1);
 602     printf("%d\n", a -= 2);
 603     printf("%d\n", a *= 31232132);
 604     printf("%d\n", a /= 4);
 605     printf("%d\n", a %= 20);
 606     printf("%d\n", a &= 6);
 607     printf("%d\n", a ^= 7);
 608     printf("%d\n", a |= 8);
 609     printf("%d\n", a >>= 3);
 610     printf("%d\n", a <<= 4);
 611
 612     a = 22321;
 613     b = -22321;
 614     printf("%d\n", a + 1);
 615     printf("%d\n", a - 2);
 616     printf("%d\n", a * 312);
 617     printf("%d\n", a / 4);
 618     printf("%d\n", b / 4);
 619     printf("%d\n", (unsigned)b / 4);
 620     printf("%d\n", a % 20);
 621     printf("%d\n", b % 20);
 622     printf("%d\n", (unsigned)b % 20);
 623     printf("%d\n", a & 6);
 624     printf("%d\n", a ^ 7);
 625     printf("%d\n", a | 8);
 626     printf("%d\n", a >> 3);
 627     printf("%d\n", b >> 3);
 628     printf("%d\n", (unsigned)b >> 3);
 629     printf("%d\n", a << 4);
 630     printf("%d\n", ~a);
 631     printf("%d\n", -a);
 632     printf("%d\n", +a);
 633
 634     printf("%d\n", 12 + 1);
 635     printf("%d\n", 12 - 2);
 636     printf("%d\n", 12 * 312);
 637     printf("%d\n", 12 / 4);
 638     printf("%d\n", 12 % 20);
 639     printf("%d\n", 12 & 6);
 640     printf("%d\n", 12 ^ 7);
 641     printf("%d\n", 12 | 8);
 642     printf("%d\n", 12 >> 2);
 643     printf("%d\n", 12 << 4);
 644     printf("%d\n", ~12);
 645     printf("%d\n", -12);
 646     printf("%d\n", +12);
 647     printf("%d %d %d %d\n",
 648            isid('a'),
 649            isid('g'),
 650            isid('T'),
 651            isid('('));
 652 }
 653
 654 int isid(int c)
 655 {
 656     return (c >= 'a' & c <= 'z') | (c >= 'A' & c <= 'Z') | c == '_';
 657 }
 658
 659 /**********************/
 660
 661 int vstack[10], *vstack_ptr;
 662
 663 void vpush(int vt, int vc)
 664 {
 665     *vstack_ptr++ = vt;
 666     *vstack_ptr++ = vc;
 667 }
 668
 669 void vpop(int *ft, int *fc)
 670 {
 671     *fc = *--vstack_ptr;
 672     *ft = *--vstack_ptr;
 673 }
 674
 675 void expr2_test()
 676 {
 677     int a, b;
 678
 679     printf("expr2:\n");
 680     vstack_ptr = vstack;
 681     vpush(1432432, 2);
 682     vstack_ptr[-2] &= ~0xffffff80;
 683     vpop(&a, &b);
 684     printf("res= %d %d\n", a, b);
 685 }
 686
 687 void constant_expr_test()
 688 {
 689     int a;
 690     printf("constant_expr:\n");
 691     a = 3;
 692     printf("%d\n", a * 16);
 693     printf("%d\n", a * 1);
 694     printf("%d\n", a + 0);
 695 }
 696
 697 int tab4[10];
 698
 699 void expr_ptr_test()
 700 {
 701     int *p, *q;
 702
 703     printf("expr_ptr:\n");
 704     p = tab4;
 705     q = tab4 + 10;
 706     printf("diff=%d\n", q - p);
 707     p++;
 708     printf("inc=%d\n", p - tab4);
 709     p--;
 710     printf("dec=%d\n", p - tab4);
 711     ++p;
 712     printf("inc=%d\n", p - tab4);
 713     --p;
 714     printf("dec=%d\n", p - tab4);
 715     printf("add=%d\n", p + 3 - tab4);
 716     printf("add=%d\n", 3 + p - tab4);
 717 }
 718
 719 void expr_cmp_test()
 720 {
 721     int a, b;
 722     printf("constant_expr:\n");
 723     a = -1;
 724     b = 1;
 725     printf("%d\n", a == a);
 726     printf("%d\n", a != a);
 727
 728     printf("%d\n", a < b);
 729     printf("%d\n", a <= b);
 730     printf("%d\n", a <= a);
 731     printf("%d\n", b >= a);
 732     printf("%d\n", a >= a);
 733     printf("%d\n", b > a);
 734
 735     printf("%d\n", (unsigned)a < b);
 736     printf("%d\n", (unsigned)a <= b);
 737     printf("%d\n", (unsigned)a <= a);
 738     printf("%d\n", (unsigned)b >= a);
 739     printf("%d\n", (unsigned)a >= a);
 740     printf("%d\n", (unsigned)b > a);
 741 }
 742
 743 struct empty {
 744 };
 745
 746 struct aligntest1 {
 747     char a[10];
 748 };
 749
 750 struct aligntest2 {
 751     int a;
 752     char b[10];
 753 };
 754
 755 struct aligntest3 {
 756     double a, b;
 757 };
 758
 759 struct aligntest4 {
 760     double a[0];
 761 };
 762
 763 void struct_test()
 764 {
 765     struct1 *s;
 766     union union2 u;
 767
 768     printf("struct:\n");
 769     printf("sizes: %d %d %d %d\n",
 770            sizeof(struct struct1),
 771            sizeof(struct struct2),
 772            sizeof(union union1),
 773            sizeof(union union2));
 774     st1.f1 = 1;
 775     st1.f2 = 2;
 776     st1.f3 = 3;
 777     printf("st1: %d %d %d\n",
 778            st1.f1, st1.f2, st1.f3);
 779     st1.u.v1 = 1;
 780     st1.u.v2 = 2;
 781     printf("union1: %d\n", st1.u.v1);
 782     u.w1 = 1;
 783     u.w2 = 2;
 784     printf("union2: %d\n", u.w1);
 785     s = &st2;
 786     s->f1 = 3;
 787     s->f2 = 2;
 788     s->f3 = 1;
 789     printf("st2: %d %d %d\n",
 790            s->f1, s->f2, s->f3);
 791     printf("str_addr=%x\n", (int)st1.str - (int)&st1.f1);
 792
 793     /* align / size tests */
 794     printf("aligntest1 sizeof=%d alignof=%d\n",
 795            sizeof(struct aligntest1), __alignof__(struct aligntest1));
 796     printf("aligntest2 sizeof=%d alignof=%d\n",
 797            sizeof(struct aligntest2), __alignof__(struct aligntest2));
 798     printf("aligntest3 sizeof=%d alignof=%d\n",
 799            sizeof(struct aligntest3), __alignof__(struct aligntest3));
 800     printf("aligntest4 sizeof=%d alignof=%d\n",
 801            sizeof(struct aligntest4), __alignof__(struct aligntest4));
 802
 803     /* empty structures (GCC extension) */
 804     printf("sizeof(struct empty) = %d\n", sizeof(struct empty));
 805     printf("alignof(struct empty) = %d\n", __alignof__(struct empty));
 806 }
 807
 808 /* XXX: depend on endianness */
 809 void char_short_test()
 810 {
 811     int var1, var2;
 812
 813     printf("char_short:\n");
 814
 815     var1 = 0x01020304;
 816     var2 = 0xfffefdfc;
 817     printf("s8=%d %d\n",
 818            *(char *)&var1, *(char *)&var2);
 819     printf("u8=%d %d\n",
 820            *(unsigned char *)&var1, *(unsigned char *)&var2);
 821     printf("s16=%d %d\n",
 822            *(short *)&var1, *(short *)&var2);
 823     printf("u16=%d %d\n",
 824            *(unsigned short *)&var1, *(unsigned short *)&var2);
 825     printf("s32=%d %d\n",
 826            *(int *)&var1, *(int *)&var2);
 827     printf("u32=%d %d\n",
 828            *(unsigned int *)&var1, *(unsigned int *)&var2);
 829     *(char *)&var1 = 0x08;
 830     printf("var1=%x\n", var1);
 831     *(short *)&var1 = 0x0809;
 832     printf("var1=%x\n", var1);
 833     *(int *)&var1 = 0x08090a0b;
 834     printf("var1=%x\n", var1);
 835 }
 836
 837 /******************/
 838
 839 typedef struct Sym {
 840     int v;
 841     int t;
 842     int c;
 843     struct Sym *next;
 844     struct Sym *prev;
 845 } Sym;
 846
 847 #define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
 848 #define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
 849
 850 static int toupper1(int a)
 851 {
 852     return TOUPPER(a);
 853 }
 854
 855 void bool_test()
 856 {
 857     int *s, a, b, t, f, i;
 858
 859     a = 0;
 860     s = (void*)0;
 861     printf("!s=%d\n", !s);
 862
 863     if (!s || !s[0])
 864         a = 1;
 865     printf("a=%d\n", a);
 866
 867     printf("a=%d %d %d\n", 0 || 0, 0 || 1, 1 || 1);
 868     printf("a=%d %d %d\n", 0 && 0, 0 && 1, 1 && 1);
 869     printf("a=%d %d\n", 1 ? 1 : 0, 0 ? 1 : 0);
 870 #if 1 && 1
 871     printf("a1\n");
 872 #endif
 873 #if 1 || 0
 874     printf("a2\n");
 875 #endif
 876 #if 1 ? 0 : 1
 877     printf("a3\n");
 878 #endif
 879 #if 0 ? 0 : 1
 880     printf("a4\n");
 881 #endif
 882
 883     a = 4;
 884     printf("b=%d\n", a + (0 ? 1 : a / 2));
 885
 886     /* test register spilling */
 887     a = 10;
 888     b = 10;
 889     a = (a + b) * ((a < b) ?
 890                    ((b - a) * (a - b)): a + b);
 891     printf("a=%d\n", a);
 892
 893     /* test complex || or && expressions */
 894     t = 1;
 895     f = 0;
 896     a = 32;
 897     printf("exp=%d\n", f == (32 <= a && a <= 3));
 898     printf("r=%d\n", (t || f) + (t && f));
 899
 900     /* test ? : cast */
 901     {
 902         int aspect_on;
 903         int aspect_native = 65536;
 904         double bfu_aspect = 1.0;
 905         int aspect;
 906         for(aspect_on = 0; aspect_on < 2; aspect_on++) {
 907             aspect=aspect_on?(aspect_native*bfu_aspect+0.5):65535UL;
 908             printf("aspect=%d\n", aspect);
 909         }
 910     }
 911
 912     /* test ? : GCC extension */
 913     {
 914         static int v1 = 34 ? : -1; /* constant case */
 915         static int v2 = 0 ? : -1; /* constant case */
 916         int a = 30;
 917
 918         printf("%d %d\n", v1, v2);
 919         printf("%d %d\n", a - 30 ? : a * 2, a + 1 ? : a * 2);
 920     }
 921
 922     /* again complex expression */
 923     for(i=0;i<256;i++) {
 924         if (toupper1 (i) != TOUPPER (i))
 925             printf("error %d\n", i);
 926     }
 927 }
 928
 929 /* GCC accepts that */
 930 static int tab_reinit[];
 931 static int tab_reinit[10];
 932
 933 //int cinit1; /* a global variable can be defined several times without error ! */
 934 int cinit1;
 935 int cinit1;
 936 int cinit1 = 0;
 937 int *cinit2 = (int []){3, 2, 1};
 938
 939 void compound_literal_test(void)
 940 {
 941     int *p, i;
 942     char *q, *q3;
 943
 944     printf("compound_test:\n");
 945
 946     p = (int []){1, 2, 3};
 947     for(i=0;i<3;i++)
 948         printf(" %d", p[i]);
 949     printf("\n");
 950
 951     for(i=0;i<3;i++)
 952         printf("%d", cinit2[i]);
 953     printf("\n");
 954
 955     q = "tralala1";
 956     printf("q1=%s\n", q);
 957
 958     q = (char *){ "tralala2" };
 959     printf("q2=%s\n", q);
 960
 961     q3 = (char *){ q };
 962     printf("q3=%s\n", q3);
 963
 964     q = (char []){ "tralala3" };
 965     printf("q4=%s\n", q);
 966
 967 #ifdef ALL_ISOC99
 968     p = (int []){1, 2, cinit1 + 3};
 969     for(i=0;i<3;i++)
 970         printf(" %d", p[i]);
 971     printf("\n");
 972
 973     for(i=0;i<3;i++) {
 974         p = (int []){1, 2, 4 + i};
 975         printf("%d %d %d\n",
 976                p[0],
 977                p[1],
 978                p[2]);
 979     }
 980 #endif
 981 }
 982
 983 /* K & R protos */
 984
 985 kr_func1(a, b)
 986 {
 987     return a + b;
 988 }
 989
 990 int kr_func2(a, b)
 991 {
 992     return a + b;
 993 }
 994
 995 kr_test()
 996 {
 997     printf("kr_test:\n");
 998     printf("func1=%d\n", kr_func1(3, 4));
 999     printf("func2=%d\n", kr_func2(3, 4));
1000     return 0;
1001 }
1002
1003 void num(int n)
1004 {
1005     char *tab, *p;
1006     tab = (char*)malloc(20);
1007     p = tab;
1008     while (1) {
1009         *p = 48 + (n % 10);
1010         p++;
1011         n = n / 10;
1012         if (n == 0)
1013             break;
1014     }
1015     while (p != tab) {
1016         p--;
1017         printf("%c", *p);
1018     }
1019     printf("\n");
1020 }
1021
1022 /* structure assignment tests */
1023 struct structa1 {
1024     int f1;
1025     char f2;
1026 };
1027
1028 struct structa1 ssta1;
1029
1030 void struct_assign_test1(struct structa1 s1, int t)
1031 {
1032     printf("%d %d %d\n", s1.f1, s1.f2, t);
1033 }
1034
1035 struct structa1 struct_assign_test2(struct structa1 s1, int t)
1036 {
1037     s1.f1 += t;
1038     s1.f2 -= t;
1039     return s1;
1040 }
1041
1042 void struct_assign_test(void)
1043 {
1044     struct structa1 lsta1, lsta2;
1045
1046 #if 0
1047     printf("struct_assign_test:\n");
1048
1049     lsta1.f1 = 1;
1050     lsta1.f2 = 2;
1051     printf("%d %d\n", lsta1.f1, lsta1.f2);
1052     lsta2 = lsta1;
1053     printf("%d %d\n", lsta2.f1, lsta2.f2);
1054 #else
1055     lsta2.f1 = 1;
1056     lsta2.f2 = 2;
1057 #endif
1058     struct_assign_test1(lsta2, 3);
1059
1060     printf("before call: %d %d\n", lsta2.f1, lsta2.f2);
1061     lsta2 = struct_assign_test2(lsta2, 4);
1062     printf("after call: %d %d\n", lsta2.f1, lsta2.f2);
1063 }
1064
1065 /* casts to short/char */
1066
1067 void cast1(char a, short b, unsigned char c, unsigned short d)
1068 {
1069     printf("%d %d %d %d\n", a, b, c, d);
1070 }
1071
1072 char bcast;
1073 short scast;
1074
1075 void cast_test()
1076 {
1077     int a;
1078     char c;
1079     char tab[10];
1080     unsigned b,d;
1081     short s;
1082
1083     printf("cast_test:\n");
1084     a = 0xfffff;
1085     cast1(a, a, a, a);
1086     a = 0xffffe;
1087     printf("%d %d %d %d\n",
1088            (char)(a + 1),
1089            (short)(a + 1),
1090            (unsigned char)(a + 1),
1091            (unsigned short)(a + 1));
1092     printf("%d %d %d %d\n",
1093            (char)0xfffff,
1094            (short)0xfffff,
1095            (unsigned char)0xfffff,
1096            (unsigned short)0xfffff);
1097
1098     a = (bcast = 128) + 1;
1099     printf("%d\n", a);
1100     a = (scast = 65536) + 1;
1101     printf("%d\n", a);
1102
1103     printf("sizeof(c) = %d, sizeof((int)c) = %d\n", sizeof(c), sizeof((int)c));
1104
1105     /* test cast from unsigned to signed short to int */
1106     b = 0xf000;
1107     d = (short)b;
1108     printf("((unsigned)(short)0x%08x) = 0x%08x\n", b, d);
1109     b = 0xf0f0;
1110     d = (char)b;
1111     printf("((unsigned)(char)0x%08x) = 0x%08x\n", b, d);
1112
1113     /* test implicit int casting for array accesses */
1114     c = 0;
1115     tab[1] = 2;
1116     tab[c] = 1;
1117     printf("%d %d\n", tab[0], tab[1]);
1118
1119     /* test implicit casting on some operators */
1120     printf("sizeof(+(char)'a') = %d\n", sizeof(+(char)'a'));
1121     printf("sizeof(-(char)'a') = %d\n", sizeof(-(char)'a'));
1122     printf("sizeof(~(char)'a') = %d\n", sizeof(-(char)'a'));
1123 }
1124
1125 /* initializers tests */
1126 struct structinit1 {
1127     int f1;
1128     char f2;
1129     short f3;
1130     int farray[3];
1131 };
1132
1133 int sinit1 = 2;
1134 int sinit2 = { 3 };
1135 int sinit3[3] = { 1, 2, {{3}}, };
1136 int sinit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1137 int sinit5[3][2] = { 1, 2, 3, 4, 5, 6 };
1138 int sinit6[] = { 1, 2, 3 };
1139 int sinit7[] = { [2] = 3, [0] = 1, 2 };
1140 char sinit8[] = "hello" "trala";
1141
1142 struct structinit1 sinit9 = { 1, 2, 3 };
1143 struct structinit1 sinit10 = { .f2 = 2, 3, .f1 = 1 };
1144 struct structinit1 sinit11 = { .f2 = 2, 3, .f1 = 1,
1145 #ifdef ALL_ISOC99
1146                                .farray[0] = 10,
1147                                .farray[1] = 11,
1148                                .farray[2] = 12,
1149 #endif
1150 };
1151
1152 char *sinit12 = "hello world";
1153 char *sinit13[] = {
1154     "test1",
1155     "test2",
1156     "test3",
1157 };
1158 char sinit14[10] = { "abc" };
1159 int sinit15[3] = { sizeof(sinit15), 1, 2 };
1160
1161 struct { int a[3], b; } sinit16[] = { { 1 }, 2 };
1162
1163 struct bar {
1164         char *s;
1165         int len;
1166 } sinit17[] = {
1167         "a1", 4,
1168         "a2", 1
1169 };
1170
1171 int sinit18[10] = {
1172     [2 ... 5] = 20,
1173     2,
1174     [8] = 10,
1175 };
1176
1177 void init_test(void)
1178 {
1179     int linit1 = 2;
1180     int linit2 = { 3 };
1181     int linit4[3][2] = { {1, 2}, {3, 4}, {5, 6} };
1182     int linit6[] = { 1, 2, 3 };
1183     int i, j;
1184     char linit8[] = "hello" "trala";
1185     int linit12[10] = { 1, 2 };
1186     int linit13[10] = { 1, 2, [7] = 3, [3] = 4, };
1187     char linit14[10] = "abc";
1188     int linit15[10] = { linit1, linit1 + 1, [6] = linit1 + 2, };
1189     struct linit16 { int a1, a2, a3, a4; } linit16 = { 1, .a3 = 2 };
1190     int linit17 = sizeof(linit17);
1191
1192     printf("init_test:\n");
1193
1194     printf("sinit1=%d\n", sinit1);
1195     printf("sinit2=%d\n", sinit2);
1196     printf("sinit3=%d %d %d %d\n",
1197            sizeof(sinit3),
1198            sinit3[0],
1199            sinit3[1],
1200            sinit3[2]
1201            );
1202     printf("sinit6=%d\n", sizeof(sinit6));
1203     printf("sinit7=%d %d %d %d\n",
1204            sizeof(sinit7),
1205            sinit7[0],
1206            sinit7[1],
1207            sinit7[2]
1208            );
1209     printf("sinit8=%s\n", sinit8);
1210     printf("sinit9=%d %d %d\n",
1211            sinit9.f1,
1212            sinit9.f2,
1213            sinit9.f3
1214            );
1215     printf("sinit10=%d %d %d\n",
1216            sinit10.f1,
1217            sinit10.f2,
1218            sinit10.f3
1219            );
1220     printf("sinit11=%d %d %d %d %d %d\n",
1221            sinit11.f1,
1222            sinit11.f2,
1223            sinit11.f3,
1224            sinit11.farray[0],
1225            sinit11.farray[1],
1226            sinit11.farray[2]
1227            );
1228
1229     for(i=0;i<3;i++)
1230         for(j=0;j<2;j++)
1231             printf("[%d][%d] = %d %d %d\n",
1232                    i, j, sinit4[i][j], sinit5[i][j], linit4[i][j]);
1233     printf("linit1=%d\n", linit1);
1234     printf("linit2=%d\n", linit2);
1235     printf("linit6=%d\n", sizeof(linit6));
1236     printf("linit8=%d %s\n", sizeof(linit8), linit8);
1237
1238     printf("sinit12=%s\n", sinit12);
1239     printf("sinit13=%d %s %s %s\n",
1240            sizeof(sinit13),
1241            sinit13[0],
1242            sinit13[1],
1243            sinit13[2]);
1244     printf("sinit14=%s\n", sinit14);
1245
1246     for(i=0;i<10;i++) printf(" %d", linit12[i]);
1247     printf("\n");
1248     for(i=0;i<10;i++) printf(" %d", linit13[i]);
1249     printf("\n");
1250     for(i=0;i<10;i++) printf(" %d", linit14[i]);
1251     printf("\n");
1252     for(i=0;i<10;i++) printf(" %d", linit15[i]);
1253     printf("\n");
1254     printf("%d %d %d %d\n",
1255            linit16.a1,
1256            linit16.a2,
1257            linit16.a3,
1258            linit16.a4);
1259     /* test that initialisation is done after variable declare */
1260     printf("linit17=%d\n", linit17);
1261     printf("sinit15=%d\n", sinit15[0]);
1262     printf("sinit16=%d %d\n", sinit16[0].a[0], sinit16[1].a[0]);
1263     printf("sinit17=%s %d %s %d\n",
1264            sinit17[0].s, sinit17[0].len,
1265            sinit17[1].s, sinit17[1].len);
1266     for(i=0;i<10;i++)
1267         printf("%x ", sinit18[i]);
1268     printf("\n");
1269 }
1270
1271
1272 void switch_test()
1273 {
1274     int i;
1275
1276     for(i=0;i<15;i++) {
1277         switch(i) {
1278         case 0:
1279         case 1:
1280             printf("a");
1281             break;
1282         default:
1283             printf("%d", i);
1284             break;
1285         case 8 ... 12:
1286             printf("c");
1287             break;
1288         case 3:
1289             printf("b");
1290             break;
1291         }
1292     }
1293     printf("\n");
1294 }
1295
1296 /* ISOC99 _Bool type */
1297 void c99_bool_test(void)
1298 {
1299 #ifdef BOOL_ISOC99
1300     int a;
1301     _Bool b;
1302
1303     printf("bool_test:\n");
1304     printf("sizeof(_Bool) = %d\n", sizeof(_Bool));
1305     a = 3;
1306     printf("cast: %d %d %d\n", (_Bool)10, (_Bool)0, (_Bool)a);
1307     b = 3;
1308     printf("b = %d\n", b);
1309     b++;
1310     printf("b = %d\n", b);
1311 #endif
1312 }
1313
1314 void bitfield_test(void)
1315 {
1316     int a;
1317     struct sbf1 {
1318         int f1 : 3;
1319         int : 2;
1320         int f2 : 1;
1321         int : 0;
1322         int f3 : 5;
1323         int f4 : 7;
1324         unsigned int f5 : 7;
1325     } st1;
1326     printf("bitfield_test:");
1327     printf("sizeof(st1) = %d\n", sizeof(st1));
1328
1329     st1.f1 = 3;
1330     st1.f2 = 1;
1331     st1.f3 = 15;
1332     a = 120;
1333     st1.f4 = a;
1334     st1.f5 = a;
1335     st1.f5++;
1336     printf("%d %d %d %d %d\n",
1337            st1.f1, st1.f2, st1.f3, st1.f4, st1.f5);
1338
1339     st1.f1 = 7;
1340     if (st1.f1 == -1)
1341         printf("st1.f1 == -1\n");
1342     else
1343         printf("st1.f1 != -1\n");
1344     if (st1.f2 == -1)
1345         printf("st1.f2 == -1\n");
1346     else
1347         printf("st1.f2 != -1\n");
1348 }
1349
1350 #define FTEST(prefix, type, fmt)\
1351 void prefix ## cmp(type a, type b)\
1352 {\
1353     printf("%d %d %d %d %d %d\n",\
1354            a == b,\
1355            a != b,\
1356            a < b,\
1357            a > b,\
1358            a >= b,\
1359            a <= b);\
1360     printf(fmt " " fmt " " fmt " " fmt " " fmt " " fmt " " fmt "\n",\
1361            a,\
1362            b,\
1363            a + b,\
1364            a - b,\
1365            a * b,\
1366            a / b,\
1367            -a);\
1368     printf(fmt "\n", ++a);\
1369     printf(fmt "\n", a++);\
1370     printf(fmt "\n", a);\
1371 }\
1372 void prefix ## fcast(type a)\
1373 {\
1374     float fa;\
1375     double da;\
1376     long double la;\
1377     int ia;\
1378     unsigned int ua;\
1379     type b;\
1380     fa = a;\
1381     da = a;\
1382     la = a;\
1383     printf("ftof: %f %f %Lf\n", fa, da, la);\
1384     ia = (int)a;\
1385     ua = (unsigned int)a;\
1386     printf("ftoi: %d %u\n", ia, ua);\
1387     ia = -1234;\
1388     ua = 0x81234500;\
1389     b = ia;\
1390     printf("itof: " fmt "\n", b);\
1391     b = ua;\
1392     printf("utof: " fmt "\n", b);\
1393 }\
1394 \
1395 void prefix ## test(void)\
1396 {\
1397     printf("testing '%s'\n", #type);\
1398     prefix ## cmp(1, 2.5);\
1399     prefix ## cmp(2, 1.5);\
1400     prefix ## cmp(1, 1);\
1401     prefix ## fcast(234.6);\
1402     prefix ## fcast(-2334.6);\
1403 }
1404
1405 FTEST(f, float, "%f")
1406 FTEST(d, double, "%f")
1407 FTEST(ld, long double, "%Lf")
1408
1409 double ftab1[3] = { 1.2, 3.4, -5.6 };
1410
1411
1412 void float_test(void)
1413 {
1414     float fa, fb;
1415     double da, db;
1416     int a;
1417     unsigned int b;
1418
1419     printf("float_test:\n");
1420     printf("sizeof(float) = %d\n", sizeof(float));
1421     printf("sizeof(double) = %d\n", sizeof(double));
1422     printf("sizeof(long double) = %d\n", sizeof(long double));
1423     ftest();
1424     dtest();
1425     ldtest();
1426     printf("%f %f %f\n", ftab1[0], ftab1[1], ftab1[2]);
1427     printf("%f %f %f\n", 2.12, .5, 2.3e10);
1428     //    printf("%f %f %f\n", 0x1234p12, 0x1e23.23p10, 0x12dp-10);
1429     da = 123;
1430     printf("da=%f\n", da);
1431     fa = 123;
1432     printf("fa=%f\n", fa);
1433     a = 4000000000;
1434     da = a;
1435     printf("da = %f\n", da);
1436     b = 4000000000;
1437     db = b;
1438     printf("db = %f\n", db);
1439 }
1440
1441 int fib(int n)
1442 {
1443     if (n <= 2)
1444         return 1;
1445     else
1446         return fib(n-1) + fib(n-2);
1447 }
1448
1449 void funcptr_test()
1450 {
1451     void (*func)(int);
1452     int a;
1453     struct {
1454         int dummy;
1455         void (*func)(int);
1456     } st1;
1457
1458     printf("funcptr:\n");
1459     func = &num;
1460     (*func)(12345);
1461     func = num;
1462     a = 1;
1463     a = 1;
1464     func(12345);
1465     /* more complicated pointer computation */
1466     st1.func = num;
1467     st1.func(12346);
1468     printf("sizeof1 = %d\n", sizeof(funcptr_test));
1469     printf("sizeof2 = %d\n", sizeof funcptr_test);
1470     printf("sizeof3 = %d\n", sizeof(&funcptr_test));
1471     printf("sizeof4 = %d\n", sizeof &funcptr_test);
1472 }
1473
1474 void lloptest(long long a, long long b)
1475 {
1476     unsigned long long ua, ub;
1477
1478     ua = a;
1479     ub = b;
1480     /* arith */
1481     printf("arith: %Ld %Ld %Ld\n",
1482            a + b,
1483            a - b,
1484            a * b);
1485
1486     if (b != 0) {
1487         printf("arith1: %Ld %Ld\n",
1488            a / b,
1489            a % b);
1490     }
1491
1492     /* binary */
1493     printf("bin: %Ld %Ld %Ld\n",
1494            a & b,
1495            a | b,
1496            a ^ b);
1497
1498     /* tests */
1499     printf("test: %d %d %d %d %d %d\n",
1500            a == b,
1501            a != b,
1502            a < b,
1503            a > b,
1504            a >= b,
1505            a <= b);
1506
1507     printf("utest: %d %d %d %d %d %d\n",
1508            ua == ub,
1509            ua != ub,
1510            ua < ub,
1511            ua > ub,
1512            ua >= ub,
1513            ua <= ub);
1514
1515     /* arith2 */
1516     a++;
1517     b++;
1518     printf("arith2: %Ld %Ld\n", a, b);
1519     printf("arith2: %Ld %Ld\n", a++, b++);
1520     printf("arith2: %Ld %Ld\n", --a, --b);
1521     printf("arith2: %Ld %Ld\n", a, b);
1522 }
1523
1524 void llshift(long long a, int b)
1525 {
1526     printf("shift: %Ld %Ld %Ld\n",
1527            (unsigned long long)a >> b,
1528            a >> b,
1529            a << b);
1530     printf("shiftc: %Ld %Ld %Ld\n",
1531            (unsigned long long)a >> 3,
1532            a >> 3,
1533            a << 3);
1534     printf("shiftc: %Ld %Ld %Ld\n",
1535            (unsigned long long)a >> 35,
1536            a >> 35,
1537            a << 35);
1538 }
1539
1540 void llfloat(void)
1541 {
1542     float fa;
1543     double da;
1544     long double lda;
1545     long long la, lb, lc;
1546     unsigned long long ula, ulb, ulc;
1547     la = 0x12345678;
1548     ula = 0x72345678;
1549     la = (la << 20) | 0x12345;
1550     ula = ula << 33;
1551     printf("la=%Ld ula=%Lu\n", la, ula);
1552
1553     fa = la;
1554     da = la;
1555     lda = la;
1556     printf("lltof: %f %f %Lf\n", fa, da, lda);
1557
1558     la = fa;
1559     lb = da;
1560     lc = lda;
1561     printf("ftoll: %Ld %Ld %Ld\n", la, lb, lc);
1562
1563     fa = ula;
1564     da = ula;
1565     lda = ula;
1566     printf("ulltof: %f %f %Lf\n", fa, da, lda);
1567
1568     ula = fa;
1569     ulb = da;
1570     ulc = lda;
1571     printf("ftoull: %Lu %Lu %Lu\n", ula, ulb, ulc);
1572 }
1573
1574 long long llfunc1(int a)
1575 {
1576     return a * 2;
1577 }
1578
1579 struct S {
1580     int id;
1581     char item;
1582 };
1583
1584 long long int value(struct S *v)
1585 {
1586     return ((long long int)v->item);
1587 }
1588
1589 void longlong_test(void)
1590 {
1591     long long a, b, c;
1592     int ia;
1593     unsigned int ua;
1594     printf("longlong_test:\n");
1595     printf("sizeof(long long) = %d\n", sizeof(long long));
1596     ia = -1;
1597     ua = -2;
1598     a = ia;
1599     b = ua;
1600     printf("%Ld %Ld\n", a, b);
1601     printf("%Ld %Ld %Ld %Lx\n",
1602            (long long)1,
1603            (long long)-2,
1604            1LL,
1605            0x1234567812345679);
1606     a = llfunc1(-3);
1607     printf("%Ld\n", a);
1608
1609     lloptest(1000, 23);
1610     lloptest(0xff, 0x1234);
1611     b = 0x72345678 << 10;
1612     lloptest(-3, b);
1613     llshift(0x123, 5);
1614     llshift(-23, 5);
1615     b = 0x72345678LL << 10;
1616     llshift(b, 47);
1617
1618     llfloat();
1619 #if 1
1620     b = 0x12345678;
1621     a = -1;
1622     c = a + b;
1623     printf("%Lx\n", c);
1624 #endif
1625
1626     /* long long reg spill test */
1627     {
1628           struct S a;
1629
1630           a.item = 3;
1631           printf("%lld\n", value(&a));
1632     }
1633     lloptest(0x80000000, 0);
1634
1635     /* another long long spill test */
1636     {
1637         long long *p, v;
1638         v = 1;
1639         p = &v;
1640         p[0]++;
1641         printf("%lld\n", *p);
1642     }
1643 }
1644
1645 void vprintf1(const char *fmt, ...)
1646 {
1647     va_list ap;
1648     const char *p;
1649     int c, i;
1650     double d;
1651     long long ll;
1652
1653     va_start(ap, fmt);
1654
1655     p = fmt;
1656     for(;;) {
1657         c = *p;
1658         if (c == '\0')
1659             break;
1660         p++;
1661         if (c == '%') {
1662             c = *p;
1663             switch(c) {
1664             case '\0':
1665                 goto the_end;
1666             case 'd':
1667                 i = va_arg(ap, int);
1668                 printf("%d", i);
1669                 break;
1670             case 'f':
1671                 d = va_arg(ap, double);
1672                 printf("%f", d);
1673                 break;
1674             case 'l':
1675                 ll = va_arg(ap, long long);
1676                 printf("%Ld", ll);
1677                 break;
1678             }
1679             p++;
1680         } else {
1681             putchar(c);
1682         }
1683     }
1684  the_end:
1685     va_end(ap);
1686 }
1687
1688
1689 void stdarg_test(void)
1690 {
1691     vprintf1("%d %d %d\n", 1, 2, 3);
1692     vprintf1("%f %d %f\n", 1.0, 2, 3.0);
1693     vprintf1("%l %l %d %f\n", 1234567891234LL, 987654321986LL, 3, 1234.0);
1694 }
1695
1696 void whitespace_test(void)
1697 {
1698     char *str;
1699
1700 \f\v
#if 1
1701     pri\
1702 ntf("whitspace:\n");\f\v
1703 #endif
1704     pf("N=%d\n", 2);
1705
1706 #ifdef CORRECT_CR_HANDLING
1707     pri\
1708 ntf("aaa=%d\n", 3);
1709 #endif
1710
1711     pri\
1712 \
1713 ntf("min=%d\n", 4);
1714
1715 #ifdef ACCEPT_CR_IN_STRINGS
1716     printf("len1=%d\n", strlen("
1717 "));
1718 #ifdef CORRECT_CR_HANDLING
1719     str = "
1720 ";
1721     printf("len1=%d str[0]=%d\n", strlen(str), str[0]);
1722 #endif
1723     printf("len1=%d\n", strlen("
a
1724 "));
1725 #endif /* ACCEPT_CR_IN_STRINGS */
1726 }
1727
1728 int reltab[3] = { 1, 2, 3 };
1729
1730 int *rel1 = &reltab[1];
1731 int *rel2 = &reltab[2];
1732
1733 void relocation_test(void)
1734 {
1735     printf("*rel1=%d\n", *rel1);
1736     printf("*rel2=%d\n", *rel2);
1737 }
1738
1739 void old_style_f(a,b,c)
1740      int a, b;
1741      double c;
1742 {
1743     printf("a=%d b=%d b=%f\n", a, b, c);
1744 }
1745
1746 void decl_func1(int cmpfn())
1747 {
1748     printf("cmpfn=%lx\n", (long)cmpfn);
1749 }
1750
1751 void decl_func2(cmpfn)
1752 int cmpfn();
1753 {
1754     printf("cmpfn=%lx\n", (long)cmpfn);
1755 }
1756
1757 void old_style_function(void)
1758 {
1759     old_style_f((void *)1, 2, 3.0);
1760     decl_func1(NULL);
1761     decl_func2(NULL);
1762 }
1763
1764 void sizeof_test(void)
1765 {
1766     int a;
1767     int **ptr;
1768
1769     printf("sizeof(int) = %d\n", sizeof(int));
1770     printf("sizeof(unsigned int) = %d\n", sizeof(unsigned int));
1771     printf("sizeof(short) = %d\n", sizeof(short));
1772     printf("sizeof(unsigned short) = %d\n", sizeof(unsigned short));
1773     printf("sizeof(char) = %d\n", sizeof(char));
1774     printf("sizeof(unsigned char) = %d\n", sizeof(unsigned char));
1775     printf("sizeof(func) = %d\n", sizeof sizeof_test());
1776     a = 1;
1777     printf("sizeof(a++) = %d\n", sizeof a++);
1778     printf("a=%d\n", a);
1779     ptr = NULL;
1780     printf("sizeof(**ptr) = %d\n", sizeof (**ptr));
1781
1782     /* some alignof tests */
1783     printf("__alignof__(int) = %d\n", __alignof__(int));
1784     printf("__alignof__(unsigned int) = %d\n", __alignof__(unsigned int));
1785     printf("__alignof__(short) = %d\n", __alignof__(short));
1786     printf("__alignof__(unsigned short) = %d\n", __alignof__(unsigned short));
1787     printf("__alignof__(char) = %d\n", __alignof__(char));
1788     printf("__alignof__(unsigned char) = %d\n", __alignof__(unsigned char));
1789     printf("__alignof__(func) = %d\n", __alignof__ sizeof_test());
1790 }
1791
1792 void typeof_test(void)
1793 {
1794     double a;
1795     typeof(a) b;
1796     typeof(float) c;
1797
1798     a = 1.5;
1799     b = 2.5;
1800     c = 3.5;
1801     printf("a=%f b=%f c=%f\n", a, b, c);
1802 }
1803
1804 void statement_expr_test(void)
1805 {
1806     int a, i;
1807
1808     a = 0;
1809     for(i=0;i<10;i++) {
1810         a += 1 +
1811             ( { int b, j;
1812                 b = 0;
1813                 for(j=0;j<5;j++)
1814                     b += j; b;
1815             } );
1816     }
1817     printf("a=%d\n", a);
1818
1819 }
1820
1821 void local_label_test(void)
1822 {
1823     int a;
1824     goto l1;
1825  l2:
1826     a = 1 + ({
1827         __label__ l1, l2, l3, l4;
1828         goto l1;
1829     l4:
1830         printf("aa1\n");
1831         goto l3;
1832     l2:
1833         printf("aa3\n");
1834         goto l4;
1835     l1:
1836         printf("aa2\n");
1837         goto l2;
1838     l3:;
1839         1;
1840     });
1841     printf("a=%d\n", a);
1842     return;
1843  l4:
1844     printf("bb1\n");
1845     goto l2;
1846  l1:
1847     printf("bb2\n");
1848     goto l4;
1849 }
1850
1851 /* inline assembler test */
1852 #ifdef __i386__
1853
1854 /* from linux kernel */
1855 static char * strncat1(char * dest,const char * src,size_t count)
1856 {
1857 int d0, d1, d2, d3;
1858 __asm__ __volatile__(
1859         "repne\n\t"
1860         "scasb\n\t"
1861         "decl %1\n\t"
1862         "movl %8,%3\n"
1863         "1:\tdecl %3\n\t"
1864         "js 2f\n\t"
1865         "lodsb\n\t"
1866         "stosb\n\t"
1867         "testb %%al,%%al\n\t"
1868         "jne 1b\n"
1869         "2:\txorl %2,%2\n\t"
1870         "stosb"
1871         : "=&S" (d0), "=&D" (d1), "=&a" (d2), "=&c" (d3)
1872         : "0" (src),"1" (dest),"2" (0),"3" (0xffffffff), "g" (count)
1873         : "memory");
1874 return dest;
1875 }
1876
1877 static inline void * memcpy1(void * to, const void * from, size_t n)
1878 {
1879 int d0, d1, d2;
1880 __asm__ __volatile__(
1881         "rep ; movsl\n\t"
1882         "testb $2,%b4\n\t"
1883         "je 1f\n\t"
1884         "movsw\n"
1885         "1:\ttestb $1,%b4\n\t"
1886         "je 2f\n\t"
1887         "movsb\n"
1888         "2:"
1889         : "=&c" (d0), "=&D" (d1), "=&S" (d2)
1890         :"0" (n/4), "q" (n),"1" ((long) to),"2" ((long) from)
1891         : "memory");
1892 return (to);
1893 }
1894
1895 static __inline__ void sigaddset1(unsigned int *set, int _sig)
1896 {
1897         __asm__("btsl %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
1898 }
1899
1900 static __inline__ void sigdelset1(unsigned int *set, int _sig)
1901 {
1902         asm("btrl %1,%0" : "=m"(*set) : "Ir"(_sig - 1) : "cc");
1903 }
1904
1905 static __inline__ __const__ unsigned int swab32(unsigned int x)
1906 {
1907         __asm__("xchgb %b0,%h0\n\t"     /* swap lower bytes     */
1908                 "rorl $16,%0\n\t"       /* swap words           */
1909                 "xchgb %b0,%h0"         /* swap higher bytes    */
1910                 :"=q" (x)
1911                 : "0" (x));
1912         return x;
1913 }
1914
1915 static __inline__ unsigned long long mul64(unsigned int a, unsigned int b)
1916 {
1917     unsigned long long res;
1918     __asm__("mull %2" : "=A" (res) : "a" (a), "r" (b));
1919     return res;
1920 }
1921
1922 static __inline__ unsigned long long inc64(unsigned long long a)
1923 {
1924     unsigned long long res;
1925     __asm__("addl $1, %%eax ; adcl $0, %%edx" : "=A" (res) : "A" (a));
1926     return res;
1927 }
1928
1929 unsigned int set;
1930
1931 void asm_test(void)
1932 {
1933     char buf[128];
1934     unsigned int val;
1935
1936     printf("inline asm:\n");
1937     /* test the no operand case */
1938     asm volatile ("xorl %eax, %eax");
1939
1940     memcpy1(buf, "hello", 6);
1941     strncat1(buf, " worldXXXXX", 3);
1942     printf("%s\n", buf);
1943
1944     /* 'A' constraint test */
1945     printf("mul64=0x%Lx\n", mul64(0x12345678, 0xabcd1234));
1946     printf("inc64=0x%Lx\n", inc64(0x12345678ffffffff));
1947
1948     set = 0xff;
1949     sigdelset1(&set, 2);
1950     sigaddset1(&set, 16);
1951     /* NOTE: we test here if C labels are correctly restored after the
1952        asm statement */
1953     goto label1;
1954  label2:
1955     __asm__("btsl %1,%0" : "=m"(set) : "Ir"(20) : "cc");
1956     printf("set=0x%x\n", set);
1957     val = 0x01020304;
1958     printf("swab32(0x%08x) = 0x%0x\n", val, swab32(val));
1959     return;
1960  label1:
1961     goto label2;
1962 }
1963
1964 #else
1965
1966 void asm_test(void)
1967 {
1968 }
1969
1970 #endif
1971
1972 #define COMPAT_TYPE(type1, type2) \
1973 {\
1974     printf("__builtin_types_compatible_p(%s, %s) = %d\n", #type1, #type2, \
1975            __builtin_types_compatible_p (type1, type2));\
1976 }
1977
1978 int constant_p_var;
1979
1980 void builtin_test(void)
1981 {
1982 #if GCC_MAJOR >= 3
1983     COMPAT_TYPE(int, int);
1984     COMPAT_TYPE(int, unsigned int);
1985     COMPAT_TYPE(int, char);
1986     COMPAT_TYPE(int, const int);
1987     COMPAT_TYPE(int, volatile int);
1988     COMPAT_TYPE(int *, int *);
1989     COMPAT_TYPE(int *, void *);
1990     COMPAT_TYPE(int *, const int *);
1991     COMPAT_TYPE(char *, unsigned char *);
1992 /* space is needed because tcc preprocessor introduces a space between each token */
1993     COMPAT_TYPE(char * *, void *);
1994 #endif
1995     printf("res = %d\n", __builtin_constant_p(1));
1996     printf("res = %d\n", __builtin_constant_p(1 + 2));
1997     printf("res = %d\n", __builtin_constant_p(&constant_p_var));
1998     printf("res = %d\n", __builtin_constant_p(constant_p_var));
1999 }
2000
2001
2002 void const_func(const int a)
2003 {
2004 }
2005
2006 void const_warn_test(void)
2007 {
2008     const_func(1);
2009 }