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