540 lines
12 KiB
Plaintext
540 lines
12 KiB
Plaintext
Struct_u64_u64 = struct
|
|
{
|
|
a: u64,
|
|
b: u64,
|
|
}
|
|
|
|
BigStruct = struct
|
|
{
|
|
a: u64,
|
|
b: u64,
|
|
c: u64,
|
|
d: u64,
|
|
e: u8,
|
|
}
|
|
|
|
SmallPackedStruct = bits u8
|
|
{
|
|
a: u2,
|
|
b: u2,
|
|
c: u2,
|
|
d: u2,
|
|
}
|
|
|
|
SmallStructInts = struct
|
|
{
|
|
a: u8,
|
|
b: u8,
|
|
c: u8,
|
|
d: u8,
|
|
}
|
|
|
|
SplitStructInt = struct
|
|
{
|
|
a: u64,
|
|
b: u8,
|
|
c: u32,
|
|
}
|
|
|
|
MedStructInts = struct
|
|
{
|
|
x: s32,
|
|
y: s32,
|
|
z: s32,
|
|
}
|
|
|
|
Rect = struct
|
|
{
|
|
left: u32,
|
|
right: u32,
|
|
top: u32,
|
|
bottom: u32,
|
|
}
|
|
|
|
StructWithArray = struct
|
|
{
|
|
a: s32,
|
|
padding: [4]u8,
|
|
b: s64,
|
|
}
|
|
|
|
ByRef = struct
|
|
{
|
|
val: s32,
|
|
arr: [15]s32,
|
|
}
|
|
|
|
ByValOrigin = struct
|
|
{
|
|
x: u64,
|
|
y: u64,
|
|
z: u64,
|
|
}
|
|
|
|
ByValSize = struct
|
|
{
|
|
width: u64,
|
|
height: u64,
|
|
depth: u64,
|
|
}
|
|
|
|
ByVal = struct
|
|
{
|
|
origin: ByValOrigin,
|
|
size: ByValSize,
|
|
}
|
|
|
|
[extern] run_c_tests = fn [cc(c)] () void;
|
|
|
|
[extern] c_u8 = fn [cc(c)] (x: u8) void;
|
|
[extern] c_u16 = fn [cc(c)] (x: u16) void;
|
|
[extern] c_u32 = fn [cc(c)] (x: u32) void;
|
|
[extern] c_u64 = fn [cc(c)] (x: u64) void;
|
|
|
|
[extern] c_s8 = fn [cc(c)] (x: s8) void;
|
|
[extern] c_s16 = fn [cc(c)] (x: s16) void;
|
|
[extern] c_s32 = fn [cc(c)] (x: s32) void;
|
|
[extern] c_s64 = fn [cc(c)] (x: s64) void;
|
|
|
|
[extern] c_bool = fn [cc(c)] (x: u8) void;
|
|
|
|
[extern] c_five_integers = fn [cc(c)] (a: s32, b: s32, c: s32, d: s32, e: s32) void;
|
|
[extern] c_ret_struct_u64_u64 = fn [cc(c)] () Struct_u64_u64;
|
|
|
|
[extern] c_struct_u64_u64_0 = fn [cc(c)] (a: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_1 = fn [cc(c)] (a: u64, b: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_2 = fn [cc(c)] (a: u64, b: u64, c: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_3 = fn [cc(c)] (a: u64, b: u64, c: u64, d: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_4 = fn [cc(c)] (a: u64, b: u64, c: u64, d: u64, e: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_5 = fn [cc(c)] (a: u64, b: u64, c: u64, d: u64, e: u64, f: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_6 = fn [cc(c)] (a: u64, b: u64, c: u64, d: u64, e: u64, f: u64, g: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_7 = fn [cc(c)] (a: u64, b: u64, c: u64, d: u64, e: u64, f: u64, g: u64, h: Struct_u64_u64) void;
|
|
[extern] c_struct_u64_u64_8 = fn [cc(c)] (a: u64, b: u64, c: u64, d: u64, e: u64, f: u64, g: u64, h: u64, i: Struct_u64_u64) void;
|
|
|
|
[extern] c_big_struct = fn [cc(c)] (x: BigStruct) void;
|
|
[extern] c_small_struct_ints = fn [cc(c)] (x: SmallStructInts) void;
|
|
[extern] c_ret_small_struct_ints = fn [cc(c)] () SmallStructInts;
|
|
[extern] c_med_struct_ints = fn [cc(c)] (x: MedStructInts) void;
|
|
[extern] c_ret_med_struct_ints = fn [cc(c)] () MedStructInts;
|
|
[extern] c_small_packed_struct = fn [cc(c)] (x: SmallPackedStruct) void;
|
|
[extern] c_ret_small_packed_struct = fn [cc(c)] () SmallPackedStruct;
|
|
[extern] c_split_struct_ints = fn [cc(c)] (x: SplitStructInt) void;
|
|
[extern] c_big_struct_both = fn [cc(c)] (x: BigStruct) BigStruct;
|
|
[extern] c_multiple_struct_ints = fn [cc(c)] (a: Rect, b: Rect) void;
|
|
|
|
[extern] c_ret_bool = fn [cc(c)] () u8;
|
|
|
|
[extern] c_ret_u8 = fn [cc(c)] () u8;
|
|
[extern] c_ret_u16 = fn [cc(c)] () u16;
|
|
[extern] c_ret_u32 = fn [cc(c)] () u32;
|
|
[extern] c_ret_u64 = fn [cc(c)] () u64;
|
|
|
|
[extern] c_ret_s8 = fn [cc(c)] () s8;
|
|
[extern] c_ret_s16 = fn [cc(c)] () s16;
|
|
[extern] c_ret_s32 = fn [cc(c)] () s32;
|
|
[extern] c_ret_s64 = fn [cc(c)] () s64;
|
|
|
|
[extern] c_struct_with_array = fn [cc(c)] (x: StructWithArray) void;
|
|
[extern] c_ret_struct_with_array = fn [cc(c)] () StructWithArray;
|
|
|
|
[extern] c_modify_by_ref_param = fn [cc(c)] (x: ByRef) ByRef;
|
|
[extern] c_func_ptr_byval fn [cc(c)] (a: u64, b: u64, c: ByVal, d: u64, e: u64, f: u64) void;
|
|
|
|
[export] require = fn [cc(c)] (ok: u8)
|
|
{
|
|
if (!ok)
|
|
{
|
|
#trap();
|
|
}
|
|
}
|
|
|
|
[export] main = fn [cc(c)] () s32
|
|
{
|
|
run_c_tests();
|
|
c_u8(0xff);
|
|
c_u16(0xfffe);
|
|
c_u32(0xfffffffd);
|
|
c_u64(0xfffffffffffffffc);
|
|
|
|
//if (has_i128) {
|
|
// c_struct_u128({ .value = 0xfffffffffffffffc, });
|
|
//}
|
|
|
|
c_s8(-1);
|
|
c_s16(-2);
|
|
c_s32(-3);
|
|
c_s64(-4);
|
|
|
|
//if (has_i128) {
|
|
// c_struct_i128({ .value = -6, });
|
|
//}
|
|
|
|
c_bool(1);
|
|
|
|
c_five_integers(12, 34, 56, 78, 90);
|
|
|
|
>s = c_ret_struct_u64_u64();
|
|
require(s.a == 21);
|
|
require(s.b == 22);
|
|
c_struct_u64_u64_0({ .a = 23, .b = 24, });
|
|
c_struct_u64_u64_1(0, { .a = 25, .b = 26, });
|
|
c_struct_u64_u64_2(0, 1, { .a = 27, .b = 28, });
|
|
c_struct_u64_u64_3(0, 1, 2, { .a = 29, .b = 30, });
|
|
c_struct_u64_u64_4(0, 1, 2, 3, { .a = 31, .b = 32, });
|
|
c_struct_u64_u64_5(0, 1, 2, 3, 4, { .a = 33, .b = 34, });
|
|
c_struct_u64_u64_6(0, 1, 2, 3, 4, 5, { .a = 35, .b = 36, });
|
|
c_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, { .a = 37, .b = 38, });
|
|
c_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, { .a = 39, .b = 40, });
|
|
|
|
>big_struct: BigStruct = {
|
|
.a = 1,
|
|
.b = 2,
|
|
.c = 3,
|
|
.d = 4,
|
|
.e = 5,
|
|
};
|
|
c_big_struct(big_struct);
|
|
|
|
>small: SmallStructInts = {
|
|
.a = 1,
|
|
.b = 2,
|
|
.c = 3,
|
|
.d = 4,
|
|
};
|
|
c_small_struct_ints(small);
|
|
>small2 = c_ret_small_struct_ints();
|
|
require(small2.a == 1);
|
|
require(small2.b == 2);
|
|
require(small2.c == 3);
|
|
require(small2.d == 4);
|
|
|
|
>med: MedStructInts = {
|
|
.x = 1,
|
|
.y = 2,
|
|
.z = 3,
|
|
};
|
|
c_med_struct_ints(med);
|
|
>med2 = c_ret_med_struct_ints();
|
|
require(med2.x == 1);
|
|
require(med2.y == 2);
|
|
require(med2.z == 3);
|
|
|
|
>p: SmallPackedStruct = { .a = 0, .b = 1, .c = 2, .d = 3, };
|
|
c_small_packed_struct(p);
|
|
>p2 = c_ret_small_packed_struct();
|
|
require(p2.a == 0);
|
|
require(p2.b == 1);
|
|
require(p2.c == 2);
|
|
require(p2.d == 3);
|
|
|
|
>split: SplitStructInt = {
|
|
.a = 1234,
|
|
.b = 100,
|
|
.c = 1337,
|
|
};
|
|
c_split_struct_ints(split);
|
|
|
|
> big: BigStruct = {
|
|
.a = 1,
|
|
.b = 2,
|
|
.c = 3,
|
|
.d = 4,
|
|
.e = 5,
|
|
};
|
|
>big2 = c_big_struct_both(big);
|
|
require(big2.a == 10);
|
|
require(big2.b == 11);
|
|
require(big2.c == 12);
|
|
require(big2.d == 13);
|
|
require(big2.e == 14);
|
|
|
|
>r1: Rect = {
|
|
.left = 1,
|
|
.right = 21,
|
|
.top = 16,
|
|
.bottom = 4,
|
|
};
|
|
>r2: Rect = {
|
|
.left = 178,
|
|
.right = 189,
|
|
.top = 21,
|
|
.bottom = 15,
|
|
};
|
|
c_multiple_struct_ints(r1, r2);
|
|
|
|
require(c_ret_bool() == 1);
|
|
|
|
require(c_ret_u8() == 0xff);
|
|
require(c_ret_u16() == 0xffff);
|
|
require(c_ret_u32() == 0xffffffff);
|
|
require(c_ret_u64() == 0xffffffffffffffff);
|
|
|
|
require(c_ret_s8() == -1);
|
|
require(c_ret_s16() == -1);
|
|
require(c_ret_s32() == -1);
|
|
require(c_ret_s64() == -1);
|
|
|
|
c_struct_with_array({ .a = 1, .padding = undefined, .b = 2, });
|
|
|
|
>x = c_ret_struct_with_array();
|
|
require(x.a == 4);
|
|
require(x.b == 155);
|
|
|
|
>res = c_modify_by_ref_param({ .val = 1, .arr = undefined, });
|
|
require(res.val == 42);
|
|
|
|
>function_pointer = c_func_ptr_byval&;
|
|
function_pointer(1, 2, { .origin = { .x = 9, .y = 10, .z = 11, }, .size = { .width = 12, .height = 13, .depth = 14, }, }, 3, 4, 5);
|
|
return 0;
|
|
}
|
|
|
|
[export] bb_u8 = fn [cc(c)] (x: u8) void
|
|
{
|
|
require(x == 0xff);
|
|
}
|
|
|
|
[export] bb_u16 = fn [cc(c)] (x: u16) void
|
|
{
|
|
require(x == 0xfffe);
|
|
}
|
|
|
|
[export] bb_u32 = fn [cc(c)] (x: u32) void
|
|
{
|
|
require(x == 0xfffffffd);
|
|
}
|
|
|
|
[export] bb_u64 = fn [cc(c)] (x: u64) void
|
|
{
|
|
require(x == 0xfffffffffffffffc);
|
|
}
|
|
|
|
[export] bb_s8 = fn [cc(c)] (x: s8) void
|
|
{
|
|
require(x == -1);
|
|
}
|
|
|
|
[export] bb_s16 = fn [cc(c)] (x: s16) void
|
|
{
|
|
require(x == -2);
|
|
}
|
|
|
|
[export] bb_s32 = fn [cc(c)] (x: s32) void
|
|
{
|
|
require(x == -3);
|
|
}
|
|
|
|
[export] bb_s64 = fn [cc(c)] (x: s64) void
|
|
{
|
|
require(x == -4);
|
|
}
|
|
|
|
[export] bb_ptr = fn [cc(c)] (x: *u8) void
|
|
{
|
|
require(#int_from_pointer(x) == 0xdeadbeef);
|
|
}
|
|
|
|
[export] bb_five_integers = fn [cc(c)] (a: s32, b: s32, c: s32, d: s32, e: s32) void
|
|
{
|
|
require(a == 12);
|
|
require(b == 34);
|
|
require(c == 56);
|
|
require(d == 78);
|
|
require(e == 90);
|
|
}
|
|
|
|
[export] bb_bool = fn [cc(c)] (x: u8) void
|
|
{
|
|
require(x);
|
|
}
|
|
|
|
[export] bb_ret_struct_u64_u64 = fn [cc(c)] () Struct_u64_u64
|
|
{
|
|
return { .a = 1, .b = 2, };
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_0 = fn [cc(c)] (s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 3);
|
|
require(s.b == 4);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_1 = fn [cc(c)] (_: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 5);
|
|
require(s.b == 6);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_2 = fn [cc(c)] (_: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 7);
|
|
require(s.b == 8);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_3 = fn [cc(c)] (_: u64, _: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 9);
|
|
require(s.b == 10);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_4 = fn [cc(c)] (_: u64, _: u64, _: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 11);
|
|
require(s.b == 12);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_5 = fn [cc(c)] (_: u64, _: u64, _: u64, _: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 13);
|
|
require(s.b == 14);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_6 = fn [cc(c)] (_: u64, _: u64, _: u64, _: u64, _: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 15);
|
|
require(s.b == 16);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_7 = fn [cc(c)] (_: u64, _: u64, _: u64, _: u64, _: u64, _: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 17);
|
|
require(s.b == 18);
|
|
}
|
|
|
|
[export] bb_struct_u64_u64_8 = fn [cc(c)] (_: u64, _: u64, _: u64, _: u64, _: u64, _: u64, _: u64, _: u64, s: Struct_u64_u64) void
|
|
{
|
|
require(s.a == 19);
|
|
require(s.b == 20);
|
|
}
|
|
|
|
[export] bb_big_struct = fn [cc(c)] (x: BigStruct) void
|
|
{
|
|
require(x.a == 1);
|
|
require(x.b == 2);
|
|
require(x.c == 3);
|
|
require(x.d == 4);
|
|
require(x.e == 5);
|
|
}
|
|
|
|
[export] bb_small_packed_struct = fn [cc(c)] (x: SmallPackedStruct) void
|
|
{
|
|
require(x.a == 0);
|
|
require(x.b == 1);
|
|
require(x.c == 2);
|
|
require(x.d == 3);
|
|
}
|
|
|
|
[export] bb_split_struct_ints = fn [cc(c)] (x: SplitStructInt) void
|
|
{
|
|
require(x.a == 1234);
|
|
require(x.b == 100);
|
|
require(x.c == 1337);
|
|
}
|
|
|
|
[export] bb_big_struct_both = fn [cc(c)] (x: BigStruct) BigStruct
|
|
{
|
|
require(x.a == 30);
|
|
require(x.b == 31);
|
|
require(x.c == 32);
|
|
require(x.d == 33);
|
|
require(x.e == 34);
|
|
>s: BigStruct = {
|
|
.a = 20,
|
|
.b = 21,
|
|
.c = 22,
|
|
.d = 23,
|
|
.e = 24,
|
|
};
|
|
return s;
|
|
}
|
|
|
|
[export] bb_ret_bool = fn [cc(c)] () u8
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
[export] bb_ret_u8 = fn [cc(c)] () u8
|
|
{
|
|
return 0xff;
|
|
}
|
|
|
|
[export] bb_ret_u16 = fn [cc(c)] () u16
|
|
{
|
|
return 0xffff;
|
|
}
|
|
|
|
[export] bb_ret_u32 = fn [cc(c)] () u32
|
|
{
|
|
return 0xffffffff;
|
|
}
|
|
|
|
[export] bb_ret_u64 = fn [cc(c)] () u64
|
|
{
|
|
return 0xffffffffffffffff;
|
|
}
|
|
|
|
[export] bb_ret_s8 = fn [cc(c)] () s8
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
[export] bb_ret_s16 = fn [cc(c)] () s16
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
[export] bb_ret_s32 = fn [cc(c)] () s32
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
[export] bb_ret_s64 = fn [cc(c)] () s64
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
[export] bb_ret_small_struct_ints = fn [cc(c)] () SmallStructInts
|
|
{
|
|
return {
|
|
.a = 1,
|
|
.b = 2,
|
|
.c = 3,
|
|
.d = 4,
|
|
};
|
|
}
|
|
|
|
[export] bb_ret_med_struct_ints = fn [cc(c)] () MedStructInts
|
|
{
|
|
return {
|
|
.x = 1,
|
|
.y = 2,
|
|
.z = 3,
|
|
};
|
|
}
|
|
|
|
[export] bb_multiple_struct_ints = fn [cc(c)] (x: Rect, y: Rect) void
|
|
{
|
|
require(x.left == 1);
|
|
require(x.right == 21);
|
|
require(x.top == 16);
|
|
require(x.bottom == 4);
|
|
require(y.left == 178);
|
|
require(y.right == 189);
|
|
require(y.top == 21);
|
|
require(y.bottom == 15);
|
|
}
|
|
|
|
[export] bb_small_struct_ints = fn [cc(c)] (x: SmallStructInts) void
|
|
{
|
|
require(x.a == 1);
|
|
require(x.b == 2);
|
|
require(x.c == 3);
|
|
require(x.d == 4);
|
|
}
|
|
|
|
[export] bb_med_struct_ints = fn [cc(c)] (s: MedStructInts) void
|
|
{
|
|
require(s.x == 1);
|
|
require(s.y == 2);
|
|
require(s.z == 3);
|
|
}
|