| ... | @@ -426,6 +426,180 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -426,6 +426,180 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 426 | }, | 426 | }, |
| 427 | ); | 427 | ); |
| 428 | | 428 | |
| | 429 | cases.addC_both("null statements", |
| | 430 | \\void foo(void) { |
| | 431 | \\ ;;;;; |
| | 432 | \\} |
| | 433 | , &[_][]const u8{ |
| | 434 | \\pub export fn foo() void { |
| | 435 | \\ {} |
| | 436 | \\ {} |
| | 437 | \\ {} |
| | 438 | \\ {} |
| | 439 | \\ {} |
| | 440 | \\} |
| | 441 | }); |
| | 442 | |
| | 443 | if (builtin.os != builtin.Os.windows) { |
| | 444 | // Windows treats this as an enum with type c_int |
| | 445 | cases.add_both("big negative enum init values when C ABI supports long long enums", |
| | 446 | \\enum EnumWithInits { |
| | 447 | \\ VAL01 = 0, |
| | 448 | \\ VAL02 = 1, |
| | 449 | \\ VAL03 = 2, |
| | 450 | \\ VAL04 = 3, |
| | 451 | \\ VAL05 = -1, |
| | 452 | \\ VAL06 = -2, |
| | 453 | \\ VAL07 = -3, |
| | 454 | \\ VAL08 = -4, |
| | 455 | \\ VAL09 = VAL02 + VAL08, |
| | 456 | \\ VAL10 = -1000012000, |
| | 457 | \\ VAL11 = -1000161000, |
| | 458 | \\ VAL12 = -1000174001, |
| | 459 | \\ VAL13 = VAL09, |
| | 460 | \\ VAL14 = VAL10, |
| | 461 | \\ VAL15 = VAL11, |
| | 462 | \\ VAL16 = VAL13, |
| | 463 | \\ VAL17 = (VAL16 - VAL10 + 1), |
| | 464 | \\ VAL18 = 0x1000000000000000L, |
| | 465 | \\ VAL19 = VAL18 + VAL18 + VAL18 - 1, |
| | 466 | \\ VAL20 = VAL19 + VAL19, |
| | 467 | \\ VAL21 = VAL20 + 0xFFFFFFFFFFFFFFFF, |
| | 468 | \\ VAL22 = 0xFFFFFFFFFFFFFFFF + 1, |
| | 469 | \\ VAL23 = 0xFFFFFFFFFFFFFFFF, |
| | 470 | \\}; |
| | 471 | , &[_][]const u8{ |
| | 472 | \\pub const enum_EnumWithInits = extern enum(c_longlong) { |
| | 473 | \\ VAL01 = 0, |
| | 474 | \\ VAL02 = 1, |
| | 475 | \\ VAL03 = 2, |
| | 476 | \\ VAL04 = 3, |
| | 477 | \\ VAL05 = -1, |
| | 478 | \\ VAL06 = -2, |
| | 479 | \\ VAL07 = -3, |
| | 480 | \\ VAL08 = -4, |
| | 481 | \\ VAL09 = -3, |
| | 482 | \\ VAL10 = -1000012000, |
| | 483 | \\ VAL11 = -1000161000, |
| | 484 | \\ VAL12 = -1000174001, |
| | 485 | \\ VAL13 = -3, |
| | 486 | \\ VAL14 = -1000012000, |
| | 487 | \\ VAL15 = -1000161000, |
| | 488 | \\ VAL16 = -3, |
| | 489 | \\ VAL17 = 1000011998, |
| | 490 | \\ VAL18 = 1152921504606846976, |
| | 491 | \\ VAL19 = 3458764513820540927, |
| | 492 | \\ VAL20 = 6917529027641081854, |
| | 493 | \\ VAL21 = 6917529027641081853, |
| | 494 | \\ VAL22 = 0, |
| | 495 | \\ VAL23 = -1, |
| | 496 | \\}; |
| | 497 | }); |
| | 498 | } |
| | 499 | |
| | 500 | cases.addC_both("predefined expressions", |
| | 501 | \\void foo(void) { |
| | 502 | \\ __func__; |
| | 503 | \\ __FUNCTION__; |
| | 504 | \\ __PRETTY_FUNCTION__; |
| | 505 | \\} |
| | 506 | , &[_][]const u8{ |
| | 507 | \\pub export fn foo() void { |
| | 508 | \\ _ = "foo"; |
| | 509 | \\ _ = "foo"; |
| | 510 | \\ _ = "void foo(void)"; |
| | 511 | \\} |
| | 512 | }); |
| | 513 | |
| | 514 | cases.addC_both("ignore result, no function arguments", |
| | 515 | \\void foo() { |
| | 516 | \\ int a; |
| | 517 | \\ 1; |
| | 518 | \\ "hey"; |
| | 519 | \\ 1 + 1; |
| | 520 | \\ 1 - 1; |
| | 521 | \\ a = 1; |
| | 522 | \\} |
| | 523 | , &[_][]const u8{ |
| | 524 | \\pub export fn foo() void { |
| | 525 | \\ var a: c_int = undefined; |
| | 526 | \\ _ = 1; |
| | 527 | \\ _ = "hey"; |
| | 528 | \\ _ = (1 + 1); |
| | 529 | \\ _ = (1 - 1); |
| | 530 | \\ a = 1; |
| | 531 | \\} |
| | 532 | }); |
| | 533 | |
| | 534 | cases.add_2("qualified struct and enum", |
| | 535 | \\struct Foo { |
| | 536 | \\ int x; |
| | 537 | \\ int y; |
| | 538 | \\}; |
| | 539 | \\enum Bar { |
| | 540 | \\ BarA, |
| | 541 | \\ BarB, |
| | 542 | \\}; |
| | 543 | \\void func(struct Foo *a, enum Bar **b); |
| | 544 | , &[_][]const u8{ |
| | 545 | \\pub const struct_Foo = extern struct { |
| | 546 | \\ x: c_int, |
| | 547 | \\ y: c_int, |
| | 548 | \\}; |
| | 549 | \\pub const BarA = enum_Bar.A; |
| | 550 | \\pub const BarB = enum_Bar.B; |
| | 551 | \\pub const enum_Bar = extern enum { |
| | 552 | \\ A, |
| | 553 | \\ B, |
| | 554 | \\}; |
| | 555 | \\pub extern fn func(a: [*c]struct_Foo, b: [*c][*c]enum_Bar) void; |
| | 556 | , |
| | 557 | \\pub const Foo = struct_Foo; |
| | 558 | \\pub const Bar = enum_Bar; |
| | 559 | }); |
| | 560 | |
| | 561 | cases.add_both("constant size array", |
| | 562 | \\void func(int array[20]); |
| | 563 | , &[_][]const u8{ |
| | 564 | \\pub extern fn func(array: [*c]c_int) void; |
| | 565 | }); |
| | 566 | |
| | 567 | cases.add_both("__cdecl doesn't mess up function pointers", |
| | 568 | \\void foo(void (__cdecl *fn_ptr)(void)); |
| | 569 | , &[_][]const u8{ |
| | 570 | \\pub extern fn foo(fn_ptr: ?extern fn () void) void; |
| | 571 | }); |
| | 572 | |
| | 573 | cases.addC_both("void cast", |
| | 574 | \\void foo(int a) { |
| | 575 | \\ (void) a; |
| | 576 | \\} |
| | 577 | , &[_][]const u8{ |
| | 578 | \\pub export fn foo(a: c_int) void { |
| | 579 | \\ _ = a; |
| | 580 | \\} |
| | 581 | }); |
| | 582 | |
| | 583 | cases.addC_both("implicit cast to void *", |
| | 584 | \\void *foo(unsigned short *x) { |
| | 585 | \\ return x; |
| | 586 | \\} |
| | 587 | , &[_][]const u8{ |
| | 588 | \\pub export fn foo(x: [*c]c_ushort) ?*c_void { |
| | 589 | \\ return @ptrCast(?*c_void, x); |
| | 590 | \\} |
| | 591 | }); |
| | 592 | |
| | 593 | cases.addC_both("null pointer implicit cast", |
| | 594 | \\int* foo(void) { |
| | 595 | \\ return 0; |
| | 596 | \\} |
| | 597 | , &[_][]const u8{ |
| | 598 | \\pub export fn foo() [*c]c_int { |
| | 599 | \\ return null; |
| | 600 | \\} |
| | 601 | }); |
| | 602 | |
| 429 | /////////////// Cases that pass for only stage2 //////////////// | 603 | /////////////// Cases that pass for only stage2 //////////////// |
| 430 | | 604 | |
| 431 | cases.add_2("Parameterless function prototypes", | 605 | cases.add_2("Parameterless function prototypes", |
| ... | @@ -904,145 +1078,75 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -904,145 +1078,75 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 904 | \\}; | 1078 | \\}; |
| 905 | }); | 1079 | }); |
| 906 | | 1080 | |
| 907 | /////////////// Cases for only stage1 which are TODO items for stage2 //////////////// | 1081 | cases.add_2("undefined array global", |
| 908 | | 1082 | \\int array[100] = {}; |
| 909 | if (builtin.os != builtin.Os.windows) { | | |
| 910 | // Windows treats this as an enum with type c_int | | |
| 911 | cases.add("big negative enum init values when C ABI supports long long enums", | | |
| 912 | \\enum EnumWithInits { | | |
| 913 | \\ VAL01 = 0, | | |
| 914 | \\ VAL02 = 1, | | |
| 915 | \\ VAL03 = 2, | | |
| 916 | \\ VAL04 = 3, | | |
| 917 | \\ VAL05 = -1, | | |
| 918 | \\ VAL06 = -2, | | |
| 919 | \\ VAL07 = -3, | | |
| 920 | \\ VAL08 = -4, | | |
| 921 | \\ VAL09 = VAL02 + VAL08, | | |
| 922 | \\ VAL10 = -1000012000, | | |
| 923 | \\ VAL11 = -1000161000, | | |
| 924 | \\ VAL12 = -1000174001, | | |
| 925 | \\ VAL13 = VAL09, | | |
| 926 | \\ VAL14 = VAL10, | | |
| 927 | \\ VAL15 = VAL11, | | |
| 928 | \\ VAL16 = VAL13, | | |
| 929 | \\ VAL17 = (VAL16 - VAL10 + 1), | | |
| 930 | \\ VAL18 = 0x1000000000000000L, | | |
| 931 | \\ VAL19 = VAL18 + VAL18 + VAL18 - 1, | | |
| 932 | \\ VAL20 = VAL19 + VAL19, | | |
| 933 | \\ VAL21 = VAL20 + 0xFFFFFFFFFFFFFFFF, | | |
| 934 | \\ VAL22 = 0xFFFFFFFFFFFFFFFF + 1, | | |
| 935 | \\ VAL23 = 0xFFFFFFFFFFFFFFFF, | | |
| 936 | \\}; | | |
| 937 | , &[_][]const u8{ | | |
| 938 | \\pub const enum_EnumWithInits = extern enum(c_longlong) { | | |
| 939 | \\ VAL01 = 0, | | |
| 940 | \\ VAL02 = 1, | | |
| 941 | \\ VAL03 = 2, | | |
| 942 | \\ VAL04 = 3, | | |
| 943 | \\ VAL05 = -1, | | |
| 944 | \\ VAL06 = -2, | | |
| 945 | \\ VAL07 = -3, | | |
| 946 | \\ VAL08 = -4, | | |
| 947 | \\ VAL09 = -3, | | |
| 948 | \\ VAL10 = -1000012000, | | |
| 949 | \\ VAL11 = -1000161000, | | |
| 950 | \\ VAL12 = -1000174001, | | |
| 951 | \\ VAL13 = -3, | | |
| 952 | \\ VAL14 = -1000012000, | | |
| 953 | \\ VAL15 = -1000161000, | | |
| 954 | \\ VAL16 = -3, | | |
| 955 | \\ VAL17 = 1000011998, | | |
| 956 | \\ VAL18 = 1152921504606846976, | | |
| 957 | \\ VAL19 = 3458764513820540927, | | |
| 958 | \\ VAL20 = 6917529027641081854, | | |
| 959 | \\ VAL21 = 6917529027641081853, | | |
| 960 | \\ VAL22 = 0, | | |
| 961 | \\ VAL23 = -1, | | |
| 962 | \\}; | | |
| 963 | }); | | |
| 964 | } | | |
| 965 | | | |
| 966 | cases.add("predefined expressions", | | |
| 967 | \\void foo(void) { | | |
| 968 | \\ __func__; | | |
| 969 | \\ __FUNCTION__; | | |
| 970 | \\ __PRETTY_FUNCTION__; | | |
| 971 | \\} | | |
| 972 | , &[_][]const u8{ | 1083 | , &[_][]const u8{ |
| 973 | \\pub fn foo() void { | 1084 | \\pub export var array: [100]c_int = .{0} ** 100; |
| 974 | \\ _ = "foo"; | | |
| 975 | \\ _ = "foo"; | | |
| 976 | \\ _ = "void foo(void)"; | | |
| 977 | \\} | | |
| 978 | }); | 1085 | }); |
| 979 | | 1086 | |
| 980 | cases.add("ignore result, no function arguments", | 1087 | cases.add_2("restrict -> noalias", |
| 981 | \\void foo() { | 1088 | \\void foo(void *restrict bar, void *restrict); |
| 982 | \\ int a; | | |
| 983 | \\ 1; | | |
| 984 | \\ "hey"; | | |
| 985 | \\ 1 + 1; | | |
| 986 | \\ 1 - 1; | | |
| 987 | \\ a = 1; | | |
| 988 | \\} | | |
| 989 | , &[_][]const u8{ | 1089 | , &[_][]const u8{ |
| 990 | \\pub fn foo() void { | 1090 | \\pub extern fn foo(noalias bar: ?*c_void, noalias arg_1: ?*c_void) void; |
| 991 | \\ var a: c_int = undefined; | | |
| 992 | \\ _ = 1; | | |
| 993 | \\ _ = "hey"; | | |
| 994 | \\ _ = (1 + 1); | | |
| 995 | \\ _ = (1 - 1); | | |
| 996 | \\ a = 1; | | |
| 997 | \\} | | |
| 998 | }); | 1091 | }); |
| 999 | | 1092 | |
| 1000 | cases.add("for loop with var init but empty body", | 1093 | cases.add_2("assign", |
| 1001 | \\void foo(void) { | 1094 | \\int max(int a) { |
| 1002 | \\ for (int x = 0; x < 10; x++); | 1095 | \\ int tmp; |
| | 1096 | \\ tmp = a; |
| | 1097 | \\ a = tmp; |
| 1003 | \\} | 1098 | \\} |
| 1004 | , &[_][]const u8{ | 1099 | , &[_][]const u8{ |
| 1005 | \\pub fn foo() void { | 1100 | \\pub export fn max(a: c_int) c_int { |
| 1006 | \\ { | 1101 | \\ var tmp: c_int = undefined; |
| 1007 | \\ var x: c_int = 0; | 1102 | \\ tmp = a; |
| 1008 | \\ while (x < 10) : (x += 1) {} | 1103 | \\ a = tmp; |
| 1009 | \\ } | | |
| 1010 | \\} | 1104 | \\} |
| 1011 | }); | 1105 | }); |
| 1012 | | 1106 | |
| 1013 | cases.add("do while with empty body", | 1107 | cases.add_2("chaining assign", |
| 1014 | \\void foo(void) { | 1108 | \\void max(int a) { |
| 1015 | \\ do ; while (1); | 1109 | \\ int b, c; |
| | 1110 | \\ c = b = a; |
| 1016 | \\} | 1111 | \\} |
| 1017 | , &[_][]const u8{ // TODO this should be if (1 != 0) break | 1112 | , &[_][]const u8{ |
| 1018 | \\pub fn foo() void { | 1113 | \\pub export fn max(a: c_int) void { |
| 1019 | \\ while (true) { | 1114 | \\ var b: c_int = undefined; |
| 1020 | \\ {} | 1115 | \\ var c: c_int = undefined; |
| 1021 | \\ if (!1) break; | 1116 | \\ c = blk: { |
| 1022 | \\ } | 1117 | \\ const _tmp_1 = a; |
| | 1118 | \\ b = _tmp_1; |
| | 1119 | \\ break :blk _tmp_1; |
| | 1120 | \\ }; |
| 1023 | \\} | 1121 | \\} |
| 1024 | }); | 1122 | }); |
| 1025 | | 1123 | |
| 1026 | cases.add("for with empty body", | 1124 | cases.add_2("anonymous enum", |
| 1027 | \\void foo(void) { | 1125 | \\enum { |
| 1028 | \\ for (;;); | 1126 | \\ One, |
| 1029 | \\} | 1127 | \\ Two, |
| | 1128 | \\}; |
| 1030 | , &[_][]const u8{ | 1129 | , &[_][]const u8{ |
| 1031 | \\pub fn foo() void { | 1130 | \\pub const One = enum_unnamed_1.One; |
| 1032 | \\ while (true) {} | 1131 | \\pub const Two = enum_unnamed_1.Two; |
| 1033 | \\} | 1132 | \\pub const enum_unnamed_1 = extern enum { |
| | 1133 | \\ One, |
| | 1134 | \\ Two, |
| | 1135 | \\}; |
| 1034 | }); | 1136 | }); |
| 1035 | | 1137 | |
| 1036 | cases.add("while with empty body", | 1138 | cases.add_2("c style cast", |
| 1037 | \\void foo(void) { | 1139 | \\int float_to_int(float a) { |
| 1038 | \\ while (1); | 1140 | \\ return (int)a; |
| 1039 | \\} | 1141 | \\} |
| 1040 | , &[_][]const u8{ | 1142 | , &[_][]const u8{ |
| 1041 | \\pub fn foo() void { | 1143 | \\pub export fn float_to_int(a: f32) c_int { |
| 1042 | \\ while (1 != 0) {} | 1144 | \\ return @floatToInt(c_int, a); |
| 1043 | \\} | 1145 | \\} |
| 1044 | }); | 1146 | }); |
| 1045 | | 1147 | |
| | 1148 | /////////////// Cases for only stage1 which are TODO items for stage2 //////////////// |
| | 1149 | |
| 1046 | cases.addAllowWarnings("simple data types", | 1150 | cases.addAllowWarnings("simple data types", |
| 1047 | \\#include <stdint.h> | 1151 | \\#include <stdint.h> |
| 1048 | \\int foo(char a, unsigned char b, signed char c); | 1152 | \\int foo(char a, unsigned char b, signed char c); |
| ... | @@ -1067,56 +1171,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -1067,56 +1171,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 1067 | \\} | 1171 | \\} |
| 1068 | }); | 1172 | }); |
| 1069 | | 1173 | |
| 1070 | cases.add("restrict -> noalias", | | |
| 1071 | \\void foo(void *restrict bar, void *restrict); | | |
| 1072 | , &[_][]const u8{ | | |
| 1073 | \\pub extern fn foo(noalias bar: ?*c_void, noalias arg1: ?*c_void) void; | | |
| 1074 | }); | | |
| 1075 | | | |
| 1076 | cases.add("qualified struct and enum", | | |
| 1077 | \\struct Foo { | | |
| 1078 | \\ int x; | | |
| 1079 | \\ int y; | | |
| 1080 | \\}; | | |
| 1081 | \\enum Bar { | | |
| 1082 | \\ BarA, | | |
| 1083 | \\ BarB, | | |
| 1084 | \\}; | | |
| 1085 | \\void func(struct Foo *a, enum Bar **b); | | |
| 1086 | , &[_][]const u8{ | | |
| 1087 | \\pub const struct_Foo = extern struct { | | |
| 1088 | \\ x: c_int, | | |
| 1089 | \\ y: c_int, | | |
| 1090 | \\}; | | |
| 1091 | , | | |
| 1092 | \\pub const enum_Bar = extern enum { | | |
| 1093 | \\ A, | | |
| 1094 | \\ B, | | |
| 1095 | \\}; | | |
| 1096 | , | | |
| 1097 | \\pub const BarA = enum_Bar.A; | | |
| 1098 | , | | |
| 1099 | \\pub const BarB = enum_Bar.B; | | |
| 1100 | , | | |
| 1101 | \\pub extern fn func(a: [*c]struct_Foo, b: [*c]([*c]enum_Bar)) void; | | |
| 1102 | , | | |
| 1103 | \\pub const Foo = struct_Foo; | | |
| 1104 | , | | |
| 1105 | \\pub const Bar = enum_Bar; | | |
| 1106 | }); | | |
| 1107 | | | |
| 1108 | cases.add("constant size array", | | |
| 1109 | \\void func(int array[20]); | | |
| 1110 | , &[_][]const u8{ | | |
| 1111 | \\pub extern fn func(array: [*c]c_int) void; | | |
| 1112 | }); | | |
| 1113 | | | |
| 1114 | cases.add("__cdecl doesn't mess up function pointers", | | |
| 1115 | \\void foo(void (__cdecl *fn_ptr)(void)); | | |
| 1116 | , &[_][]const u8{ | | |
| 1117 | \\pub extern fn foo(fn_ptr: ?extern fn () void) void; | | |
| 1118 | }); | | |
| 1119 | | | |
| 1120 | cases.add("macro defines string literal with hex", | 1174 | cases.add("macro defines string literal with hex", |
| 1121 | \\#define FOO "aoeu\xab derp" | 1175 | \\#define FOO "aoeu\xab derp" |
| 1122 | \\#define FOO2 "aoeu\x0007a derp" | 1176 | \\#define FOO2 "aoeu\x0007a derp" |
| ... | @@ -1247,54 +1301,22 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -1247,54 +1301,22 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 1247 | cases.addC("logical and, logical or on none bool values", | 1301 | cases.addC("logical and, logical or on none bool values", |
| 1248 | \\int and_or_none_bool(int a, float b, void *c) { | 1302 | \\int and_or_none_bool(int a, float b, void *c) { |
| 1249 | \\ if (a && b) return 0; | 1303 | \\ if (a && b) return 0; |
| 1250 | \\ if (b && c) return 1; | 1304 | \\ if (b && c) return 1; |
| 1251 | \\ if (a && c) return 2; | 1305 | \\ if (a && c) return 2; |
| 1252 | \\ if (a || b) return 3; | 1306 | \\ if (a || b) return 3; |
| 1253 | \\ if (b || c) return 4; | 1307 | \\ if (b || c) return 4; |
| 1254 | \\ if (a || c) return 5; | 1308 | \\ if (a || c) return 5; |
| 1255 | \\ return 6; | 1309 | \\ return 6; |
| 1256 | \\} | | |
| 1257 | , &[_][]const u8{ | | |
| 1258 | \\pub export fn and_or_none_bool(a: c_int, b: f32, c: ?*c_void) c_int { | | |
| 1259 | \\ if ((a != 0) and (b != 0)) return 0; | | |
| 1260 | \\ if ((b != 0) and (c != null)) return 1; | | |
| 1261 | \\ if ((a != 0) and (c != null)) return 2; | | |
| 1262 | \\ if ((a != 0) or (b != 0)) return 3; | | |
| 1263 | \\ if ((b != 0) or (c != null)) return 4; | | |
| 1264 | \\ if ((a != 0) or (c != null)) return 5; | | |
| 1265 | \\ return 6; | | |
| 1266 | \\} | | |
| 1267 | }); | | |
| 1268 | | | |
| 1269 | cases.addC("assign", | | |
| 1270 | \\int max(int a) { | | |
| 1271 | \\ int tmp; | | |
| 1272 | \\ tmp = a; | | |
| 1273 | \\ a = tmp; | | |
| 1274 | \\} | | |
| 1275 | , &[_][]const u8{ | | |
| 1276 | \\pub export fn max(_arg_a: c_int) c_int { | | |
| 1277 | \\ var a = _arg_a; | | |
| 1278 | \\ var tmp: c_int = undefined; | | |
| 1279 | \\ tmp = a; | | |
| 1280 | \\ a = tmp; | | |
| 1281 | \\} | | |
| 1282 | }); | | |
| 1283 | | | |
| 1284 | cases.addC("chaining assign", | | |
| 1285 | \\void max(int a) { | | |
| 1286 | \\ int b, c; | | |
| 1287 | \\ c = b = a; | | |
| 1288 | \\} | 1310 | \\} |
| 1289 | , &[_][]const u8{ | 1311 | , &[_][]const u8{ |
| 1290 | \\pub export fn max(a: c_int) void { | 1312 | \\pub export fn and_or_none_bool(a: c_int, b: f32, c: ?*c_void) c_int { |
| 1291 | \\ var b: c_int = undefined; | 1313 | \\ if ((a != 0) and (b != 0)) return 0; |
| 1292 | \\ var c: c_int = undefined; | 1314 | \\ if ((b != 0) and (c != null)) return 1; |
| 1293 | \\ c = (x: { | 1315 | \\ if ((a != 0) and (c != null)) return 2; |
| 1294 | \\ const _tmp = a; | 1316 | \\ if ((a != 0) or (b != 0)) return 3; |
| 1295 | \\ b = _tmp; | 1317 | \\ if ((b != 0) or (c != null)) return 4; |
| 1296 | \\ break :x _tmp; | 1318 | \\ if ((a != 0) or (c != null)) return 5; |
| 1297 | \\ }); | 1319 | \\ return 6; |
| 1298 | \\} | 1320 | \\} |
| 1299 | }); | 1321 | }); |
| 1300 | | 1322 | |
| ... | @@ -1318,16 +1340,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -1318,16 +1340,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 1318 | \\} | 1340 | \\} |
| 1319 | }); | 1341 | }); |
| 1320 | | 1342 | |
| 1321 | cases.add("anonymous enum", | | |
| 1322 | \\enum { | | |
| 1323 | \\ One, | | |
| 1324 | \\ Two, | | |
| 1325 | \\}; | | |
| 1326 | , &[_][]const u8{ | | |
| 1327 | \\pub const One = 0; | | |
| 1328 | \\pub const Two = 1; | | |
| 1329 | }); | | |
| 1330 | | | |
| 1331 | cases.addC("function call", | 1343 | cases.addC("function call", |
| 1332 | \\static void bar(void) { } | 1344 | \\static void bar(void) { } |
| 1333 | \\static int baz(void) { return 0; } | 1345 | \\static int baz(void) { return 0; } |
| ... | @@ -1362,26 +1374,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -1362,26 +1374,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 1362 | \\} | 1374 | \\} |
| 1363 | }); | 1375 | }); |
| 1364 | | 1376 | |
| 1365 | cases.addC("null statements", | | |
| 1366 | \\void foo(void) { | | |
| 1367 | \\ ;;;;; | | |
| 1368 | \\} | | |
| 1369 | , &[_][]const u8{ | | |
| 1370 | \\pub export fn foo() void { | | |
| 1371 | \\ {} | | |
| 1372 | \\ {} | | |
| 1373 | \\ {} | | |
| 1374 | \\ {} | | |
| 1375 | \\ {} | | |
| 1376 | \\} | | |
| 1377 | }); | | |
| 1378 | | | |
| 1379 | cases.add("undefined array global", | | |
| 1380 | \\int array[100]; | | |
| 1381 | , &[_][]const u8{ | | |
| 1382 | \\pub var array: [100]c_int = undefined; | | |
| 1383 | }); | | |
| 1384 | | | |
| 1385 | cases.addC("array access", | 1377 | cases.addC("array access", |
| 1386 | \\int array[100]; | 1378 | \\int array[100]; |
| 1387 | \\int foo(int index) { | 1379 | \\int foo(int index) { |
| ... | @@ -1394,36 +1386,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -1394,36 +1386,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 1394 | \\} | 1386 | \\} |
| 1395 | }); | 1387 | }); |
| 1396 | | 1388 | |
| 1397 | cases.addC("c style cast", | | |
| 1398 | \\int float_to_int(float a) { | | |
| 1399 | \\ return (int)a; | | |
| 1400 | \\} | | |
| 1401 | , &[_][]const u8{ | | |
| 1402 | \\pub export fn float_to_int(a: f32) c_int { | | |
| 1403 | \\ return @as(c_int, a); | | |
| 1404 | \\} | | |
| 1405 | }); | | |
| 1406 | | | |
| 1407 | cases.addC("void cast", | | |
| 1408 | \\void foo(int a) { | | |
| 1409 | \\ (void) a; | | |
| 1410 | \\} | | |
| 1411 | , &[_][]const u8{ | | |
| 1412 | \\pub export fn foo(a: c_int) void { | | |
| 1413 | \\ _ = a; | | |
| 1414 | \\} | | |
| 1415 | }); | | |
| 1416 | | | |
| 1417 | cases.addC("implicit cast to void *", | | |
| 1418 | \\void *foo(unsigned short *x) { | | |
| 1419 | \\ return x; | | |
| 1420 | \\} | | |
| 1421 | , &[_][]const u8{ | | |
| 1422 | \\pub export fn foo(x: [*c]c_ushort) ?*c_void { | | |
| 1423 | \\ return @ptrCast(?*c_void, x); | | |
| 1424 | \\} | | |
| 1425 | }); | | |
| 1426 | | | |
| 1427 | cases.addC("sizeof", | 1389 | cases.addC("sizeof", |
| 1428 | \\#include <stddef.h> | 1390 | \\#include <stddef.h> |
| 1429 | \\size_t size_of(void) { | 1391 | \\size_t size_of(void) { |
| ... | @@ -1435,29 +1397,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -1435,29 +1397,6 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 1435 | \\} | 1397 | \\} |
| 1436 | }); | 1398 | }); |
| 1437 | | 1399 | |
| 1438 | cases.addC("null pointer implicit cast", | | |
| 1439 | \\int* foo(void) { | | |
| 1440 | \\ return 0; | | |
| 1441 | \\} | | |
| 1442 | , &[_][]const u8{ | | |
| 1443 | \\pub export fn foo() [*c]c_int { | | |
| 1444 | \\ return null; | | |
| 1445 | \\} | | |
| 1446 | }); | | |
| 1447 | | | |
| 1448 | cases.addC("comma operator", | | |
| 1449 | \\int foo(void) { | | |
| 1450 | \\ return 1, 2; | | |
| 1451 | \\} | | |
| 1452 | , &[_][]const u8{ | | |
| 1453 | \\pub export fn foo() c_int { | | |
| 1454 | \\ return x: { | | |
| 1455 | \\ _ = 1; | | |
| 1456 | \\ break :x 2; | | |
| 1457 | \\ }; | | |
| 1458 | \\} | | |
| 1459 | }); | | |
| 1460 | | | |
| 1461 | cases.addC("statement expression", | 1400 | cases.addC("statement expression", |
| 1462 | \\int foo(void) { | 1401 | \\int foo(void) { |
| 1463 | \\ return ({ | 1402 | \\ return ({ |
| ... | @@ -2292,4 +2231,159 @@ pub fn addCases(cases: *tests.TranslateCContext) void { | ... | @@ -2292,4 +2231,159 @@ pub fn addCases(cases: *tests.TranslateCContext) void { |
| 2292 | \\ } | 2231 | \\ } |
| 2293 | \\} | 2232 | \\} |
| 2294 | }); | 2233 | }); |
| | 2234 | |
| | 2235 | cases.add("for loop with var init but empty body", |
| | 2236 | \\void foo(void) { |
| | 2237 | \\ for (int x = 0; x < 10; x++); |
| | 2238 | \\} |
| | 2239 | , &[_][]const u8{ |
| | 2240 | \\pub fn foo() void { |
| | 2241 | \\ { |
| | 2242 | \\ var x: c_int = 0; |
| | 2243 | \\ while (x < 10) : (x += 1) {} |
| | 2244 | \\ } |
| | 2245 | \\} |
| | 2246 | }); |
| | 2247 | |
| | 2248 | cases.add("do while with empty body", |
| | 2249 | \\void foo(void) { |
| | 2250 | \\ do ; while (1); |
| | 2251 | \\} |
| | 2252 | , &[_][]const u8{ // TODO this should be if (1 != 0) break |
| | 2253 | \\pub fn foo() void { |
| | 2254 | \\ while (true) { |
| | 2255 | \\ {} |
| | 2256 | \\ if (!1) break; |
| | 2257 | \\ } |
| | 2258 | \\} |
| | 2259 | }); |
| | 2260 | |
| | 2261 | cases.add("for with empty body", |
| | 2262 | \\void foo(void) { |
| | 2263 | \\ for (;;); |
| | 2264 | \\} |
| | 2265 | , &[_][]const u8{ |
| | 2266 | \\pub fn foo() void { |
| | 2267 | \\ while (true) {} |
| | 2268 | \\} |
| | 2269 | }); |
| | 2270 | |
| | 2271 | cases.add("while with empty body", |
| | 2272 | \\void foo(void) { |
| | 2273 | \\ while (1); |
| | 2274 | \\} |
| | 2275 | , &[_][]const u8{ |
| | 2276 | \\pub fn foo() void { |
| | 2277 | \\ while (1 != 0) {} |
| | 2278 | \\} |
| | 2279 | }); |
| | 2280 | |
| | 2281 | cases.add("undefined array global", |
| | 2282 | \\int array[100]; |
| | 2283 | , &[_][]const u8{ |
| | 2284 | \\pub var array: [100]c_int = undefined; |
| | 2285 | }); |
| | 2286 | |
| | 2287 | cases.add("qualified struct and enum", |
| | 2288 | \\struct Foo { |
| | 2289 | \\ int x; |
| | 2290 | \\ int y; |
| | 2291 | \\}; |
| | 2292 | \\enum Bar { |
| | 2293 | \\ BarA, |
| | 2294 | \\ BarB, |
| | 2295 | \\}; |
| | 2296 | \\void func(struct Foo *a, enum Bar **b); |
| | 2297 | , &[_][]const u8{ |
| | 2298 | \\pub const struct_Foo = extern struct { |
| | 2299 | \\ x: c_int, |
| | 2300 | \\ y: c_int, |
| | 2301 | \\}; |
| | 2302 | , |
| | 2303 | \\pub const enum_Bar = extern enum { |
| | 2304 | \\ A, |
| | 2305 | \\ B, |
| | 2306 | \\}; |
| | 2307 | , |
| | 2308 | \\pub const BarA = enum_Bar.A; |
| | 2309 | , |
| | 2310 | \\pub const BarB = enum_Bar.B; |
| | 2311 | , |
| | 2312 | \\pub extern fn func(a: [*c]struct_Foo, b: [*c]([*c]enum_Bar)) void; |
| | 2313 | , |
| | 2314 | \\pub const Foo = struct_Foo; |
| | 2315 | , |
| | 2316 | \\pub const Bar = enum_Bar; |
| | 2317 | }); |
| | 2318 | |
| | 2319 | cases.add("restrict -> noalias", |
| | 2320 | \\void foo(void *restrict bar, void *restrict); |
| | 2321 | , &[_][]const u8{ |
| | 2322 | \\pub extern fn foo(noalias bar: ?*c_void, noalias arg1: ?*c_void) void; |
| | 2323 | }); |
| | 2324 | |
| | 2325 | cases.addC("assign", |
| | 2326 | \\int max(int a) { |
| | 2327 | \\ int tmp; |
| | 2328 | \\ tmp = a; |
| | 2329 | \\ a = tmp; |
| | 2330 | \\} |
| | 2331 | , &[_][]const u8{ |
| | 2332 | \\pub export fn max(_arg_a: c_int) c_int { |
| | 2333 | \\ var a = _arg_a; |
| | 2334 | \\ var tmp: c_int = undefined; |
| | 2335 | \\ tmp = a; |
| | 2336 | \\ a = tmp; |
| | 2337 | \\} |
| | 2338 | }); |
| | 2339 | |
| | 2340 | cases.addC("chaining assign", |
| | 2341 | \\void max(int a) { |
| | 2342 | \\ int b, c; |
| | 2343 | \\ c = b = a; |
| | 2344 | \\} |
| | 2345 | , &[_][]const u8{ |
| | 2346 | \\pub export fn max(a: c_int) void { |
| | 2347 | \\ var b: c_int = undefined; |
| | 2348 | \\ var c: c_int = undefined; |
| | 2349 | \\ c = (x: { |
| | 2350 | \\ const _tmp = a; |
| | 2351 | \\ b = _tmp; |
| | 2352 | \\ break :x _tmp; |
| | 2353 | \\ }); |
| | 2354 | \\} |
| | 2355 | }); |
| | 2356 | |
| | 2357 | cases.add("anonymous enum", |
| | 2358 | \\enum { |
| | 2359 | \\ One, |
| | 2360 | \\ Two, |
| | 2361 | \\}; |
| | 2362 | , &[_][]const u8{ |
| | 2363 | \\pub const One = 0; |
| | 2364 | \\pub const Two = 1; |
| | 2365 | }); |
| | 2366 | |
| | 2367 | cases.addC("c style cast", |
| | 2368 | \\int float_to_int(float a) { |
| | 2369 | \\ return (int)a; |
| | 2370 | \\} |
| | 2371 | , &[_][]const u8{ |
| | 2372 | \\pub export fn float_to_int(a: f32) c_int { |
| | 2373 | \\ return @as(c_int, a); |
| | 2374 | \\} |
| | 2375 | }); |
| | 2376 | |
| | 2377 | cases.addC("comma operator", |
| | 2378 | \\int foo(void) { |
| | 2379 | \\ return 1, 2; |
| | 2380 | \\} |
| | 2381 | , &[_][]const u8{ |
| | 2382 | \\pub export fn foo() c_int { |
| | 2383 | \\ return x: { |
| | 2384 | \\ _ = 1; |
| | 2385 | \\ break :x 2; |
| | 2386 | \\ }; |
| | 2387 | \\} |
| | 2388 | }); |
| 2295 | } | 2389 | } |
Veikka Tuominen <git@vexu.eu> 2019-12-17 23:28:13+02:00