shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 03:51:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fix error message on deprecated enum =

Browse Source
This commit is contained in:
Christoffer Lerno
2026-02-25 23:27:22 +01:00
parent 5974bf6cd0
commit 98e0985a10
12 changed files with 2727 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/compiler/parse_global.c
View File

@@ -2870,7 +2870,7 @@ static bool parse_enum_values(ParseContext *c, Decl*** values_ref, Visibility vi
if (!is_constdef && deprecate_warn)
{
deprecate_warn = false;
print_deprecation_at(c->prev_span, "Use () declaration of associated values instead.");
print_deprecation_at(c->prev_span, "Use {} declaration of associated values instead.");
}
if (is_single_value || !tok_is(c, TOKEN_LBRACE))
{

271
test/compiler_bench/file1.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module1;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file10.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module10;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file2.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module2;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file3.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module3;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file4.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module4;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file5.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module5;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file6.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module6;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file7.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module7;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file8.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module8;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

271
test/compiler_bench/file9.c3 Normal file
View File

@@ -0,0 +1,271 @@
module module9;
extern fn int rand();
extern fn void* malloc(usz);
extern fn void free(void*);
extern fn int printf(char*, ...);
macro @inc(#x)
{
#x = #x + 1;
}
macro mix(a, b)
{
return ((a * 31) ^ (b + 7));
}
macro clamp(v, lo, hi)
{
if (v < lo)
{
v = lo;
}
else if (v > hi)
{
v = hi;
}
return v;
}
macro uint hash_block(ptr, len, out)
{
int i = 0;
uint h = 2166136261u;
for (i = 0; i < len; i++)
{
h ^= ptr[i];
if ((i & 3) == 0)
{
h *= 16777619u;
}
else
{
h += i;
}
}
return (uint)h;
}
fn int t1(int a) { return a + 1; }
fn int t2(int a) { return a * 2; }
fn int t3(int a) { return mix(a, 3); }
fn int t4(int a) { @inc(a); return a; }
fn int t5(int a) { return a - 7; }
fn int t6(int a) { return a ^ 0x55; }
fn int t7(int a) { return a & 0xFF; }
fn int t8(int a) { return (a << 1) | 1; }
fn int s1(int x)
{
int i;
for (i = 0; i < 10; i++)
{
x += i;
}
return x;
}
fn int s2(int x)
{
if (x & 1)
{
x *= 3;
}
else
{
x /= 2;
}
return x;
}
fn int s3(int x)
{
switch (x % 4)
{
case 0: return x + 10;
case 1: return x + 20;
case 2: return x + 30;
default: return x + 40;
}
}
fn int s4(int x)
{
x = clamp(x, 0, 100);
return x;
}
fn int s5(int x)
{
int r = rand();
return mix(x, r);
}
fn int s6(int x)
{
int i;
for (i = 0; i < 5; i++)
{
@inc(x);
}
return x;
}
fn int m1(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
int v = rand();
if (v & 1)
{
total += t1(v);
}
else
{
total += s1(v);
}
total ^= s3(v);
}
return total;
}
fn int m2(int n)
{
int* mem = (int*)malloc(n * int.sizeof);
int i;
int total = 0;
for (i = 0; i < n; i++)
{
mem[i] = rand();
}
int hash = hash_block(mem, n, 0);
total += hash;
free(mem);
return total;
}
fn int m3(int n)
{
int i;
int acc = 0;
for (i = 0; i < n; i++)
{
acc += s2(i);
acc ^= s3(i);
acc += t5(i);
}
return acc;
}
fn int m4(int n)
{
int i = 0;
int total = 0;
while (i < n)
{
total += mix(i, total);
if (i % 3 == 0)
{
total += s6(i);
}
i++;
}
return total;
}
fn int large1(int n)
{
int i, j;
int total = 0;
for (i = 0; i < n; i++)
{
for (j = 0; j < 10; j++)
{
int v = rand();
switch ((v + j) % 5)
{
case 0:
total += m1(5);
break;
case 1:
total += m3(7);
break;
case 2:
total ^= s2(v);
break;
case 3:
total += t7(v);
break;
default:
total += v;
break;
}
if (total & 1)
{
total += mix(i, j);
}
else
{
total ^= mix(j, i);
}
}
}
return total;
}
fn int large2(int n)
{
int i;
int total = 0;
for (i = 0; i < n; i++)
{
total += large1(3);
if (i % 2)
{
total += m4(10);
}
else
{
total ^= m2(16);
}
total = clamp(total, -1000000, 1000000);
}
return total;
}
fn int start()
{
return large2(5);
}

16
test/compiler_bench/main.c3 Normal file
View File

@@ -0,0 +1,16 @@
import module1, module2, module3, module4, module5, module6, module7, module8, module9, module10;
fn int main()
{
module1::start();
module2::start();
module3::start();
module4::start();
module5::start();
module6::start();
module7::start();
module8::start();
module9::start();
module10::start();
return 0;
}