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

Use printn rather than println. Add string methods for copying.

Browse Source
This commit is contained in:
Christoffer Lerno
2023-02-04 15:38:06 +01:00
committed by Christoffer Lerno
parent 6b928c7a3d
commit dce171670f
39 changed files with 1627 additions and 677 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@@ -228,7 +228,7 @@ import std::io;
fn void main()
{
io::println("Hello, world!");
io::printn("Hello, world!");
}
```

8
lib/std/core/runtime.c3
View File

@@ -50,7 +50,7 @@ import libc;
private TestRunner* current_runner;
fn void test_panic(String message, String file, String function, uint line)
{
io::println("[error]");
io::printn("[error]");
io::printfn("\n Error: %s", message);
io::printfn(" - in %s %s:%s.\n", function, file, line);
libc::longjmp(&current_runner.buf, 1);
@@ -64,7 +64,7 @@ fn bool TestRunner.run(TestRunner* runner)
builtin::panic = &test_panic;
int tests_passed = 0;
int tests = runner.test_names.len;
io::println("----- TESTS -----");
io::printn("----- TESTS -----");
foreach(i, String name : runner.test_names)
{
io::printf("Testing %s ... ", name);
@@ -72,10 +72,10 @@ fn bool TestRunner.run(TestRunner* runner)
{
if (catch err = runner.test_fns[i]())
{
io::println("[failed]");
io::printn("[failed]");
continue;
}
io::println("[ok]");
io::printn("[ok]");
tests_passed++;
}
}

6
lib/std/core/str.c3
View File

@@ -239,6 +239,11 @@ fn usz! index_of(String s, String needle)
return SearchResult.MISSING!;
}
fn ZString String.zstrcopy(String s, Allocator* allocator = mem::current_allocator()) => copy_zstring(s, allocator) @inline;
fn ZString String.zstrtcopy(String s) => copy_zstring(s, mem::temp_allocator()) @inline;
fn String String.copyz(String s, Allocator* allocator = mem::current_allocator()) => copyz(s, allocator) @inline;
fn String String.tcopyz(String s) => copyz(s, mem::temp_allocator()) @inline;
fn ZString copy_zstring(String s, Allocator* allocator = mem::current_allocator())
{
usz len = s.len;
@@ -248,6 +253,7 @@ fn ZString copy_zstring(String s, Allocator* allocator = mem::current_allocator(
return (ZString)str;
}
fn String copyz(String s, Allocator* allocator = mem::current_allocator())
{
usz len = s.len;

6
lib/std/core/string.c3
View File

@@ -271,12 +271,12 @@ macro void VarString.append(VarString* str, value)
$case Char32:
str.append_char32(value);
$default:
$if (@convertible($Type, Char32)):
$if (@convertible(value, Char32)):
str.append_char32(value);
$elif (@convertible($Type, String)):
$elif (@convertible(value, String)):
str.append_chars(value);
$else:
$assert("Unsupported type for appending");
$assert(false, "Unsupported type for append – use printf instead.");
$endif;
$endswitch;
}

57
lib/std/io/io.c3
View File

@@ -34,37 +34,50 @@ fault IoError
UNKNOWN_ERROR,
}
fn int putchar(char c) @inline
fn void putchar(char c) @inline
{
return libc::putchar(c);
libc::putchar(c);
}
/**
* @param [&in] message
* @return `number of bytes printed.`
*/
fn int print(char* message)
macro void print(x)
{
char* pointer = message;
while (*pointer != '\0')
{
if (!putchar(*pointer)) return 0;
pointer++;
}
return 1;
var $Type = $typeof(x);
$switch ($Type):
$case String:
catch(stdout().print(x));
$case ZString:
catch(stdout().print(x.as_str()));
$case VarString:
catch(stdout().print(x.str()));
$default:
$if (@convertible(x, String)):
catch(stdout().print((String)x));
$else:
catch(stdout().printf("%s", x));
$endif;
$endswitch;
}
/**
* @param [&in] message
* @return `number of bytes printed.`
*/
fn int println(char *message = "") @inline
macro void printn(x = "")
{
return libc::puts(message);
var $Type = $typeof(x);
$switch ($Type):
$case String:
catch(stdout().printn(x));
$case ZString:
catch(stdout().printn(x.as_str()));
$case VarString:
catch(stdout().printn(x.str()));
$default:
$if (@convertible(x, String)):
catch(stdout().printn((String)x));
$else:
catch(stdout().printfn("%s", x));
$endif;
$endswitch;
}
macro void println(x = "") => printn(x);
fn File stdout()
{

70
lib/std/io/io_file.c3
View File

@@ -5,18 +5,49 @@ fn void! File.open(File* file, String filename, String mode)
{
@pool()
{
char* filename_copy = tmalloc(filename.len + 1);
char* mode_copy = tmalloc(mode.len + 1);
mem::copy(filename_copy, (char*)(filename), filename.len);
mem::copy(mode_copy, (char*)(mode), mode.len);
filename_copy[filename.len] = 0;
mode_copy[filename.len] = 0;
file.file = libc::fopen(filename_copy, mode_copy);
file.file = libc::fopen(filename.zstrtcopy(), mode.zstrtcopy());
if (!file.file) return IoError.FILE_NOT_FOUND!;
};
}
/**
* @require file.file != null
**/
fn void! File.reopen(File* file, String filename, String mode)
{
@pool()
{
file.file = libc::freopen(filename.zstrtcopy(), mode.zstrtcopy(), file.file);
if (!file.file) return IoError.FILE_NOT_FOUND!;
};
}
/**
* @require file.file != null
**/
fn void! File.chmode(File* file, String filename, String mode)
{
@pool()
{
file.file = libc::freopen(null, mode.zstrtcopy(), file.file);
if (!file.file) return IoError.FILE_NOT_FOUND!;
};
}
/*
Implement later
/**
* @require file.file == null
**/
fn void! File.memopen(File* file, char[] data, String mode)
{
@pool()
{
file.file = libc::memopen(data.ptr, data.len, mode.zstrtcopy(), file.file);
// TODO errors
};
}
*/
/**
* @require file.file != null
**/
@@ -102,14 +133,26 @@ fn usz File.write(File* file, void* buffer, usz items, usz element_size = 1)
* @param [&in] file
* @require file.file `File must be initialized`
*/
fn usz! File.println(File* file, String string)
fn usz! File.printn(File* file, String string)
{
usz len = file.print(string)?;
if (!libc::putc('\n', file.file)) return IoError.UNKNOWN_ERROR!;
return len + 1;
}
/**
* @param [&in] file
* @require file.file `File must be initialized`
*/
fn usz! File.print(File* file, String string)
{
usz len = string.len;
if (len != libc::fwrite(string.ptr, 1, len, file.file)) return IoError.UNKNOWN_ERROR!;
if (!libc::putc('\n', file.file)) return IoError.UNKNOWN_ERROR!;
return len + 1;
return len;
}
fn usz! File.println(File* file, String string) => file.printn(string);
/**
* @param [&in] file
* @require file.file `File must be initialized`
@@ -134,10 +177,7 @@ fn VarString File.getline(File* file, Allocator* allocator = mem::current_alloca
*/
fn String File.tgetline(File* file)
{
VarString s = file.getline(mem::temp_allocator());
ZString z = s.zstr();
return z[:s.len()];
return file.getline(mem::temp_allocator()).zstr().as_str();
}
fn char! File.getc(File* file)

5
lib/std/libc/libc.c3
View File

@@ -211,9 +211,10 @@ extern fn int feof(CFile stream);
extern fn int ferror(CFile stream);
extern fn int fflush(CFile stream);
extern fn int fgetpos(CFile stream, Fpos* pos);
extern fn CFile fopen(char* filename, char* mode);
extern fn CFile fopen(ZString filename, ZString mode);
extern fn usz fread(void* ptr, usz size, usz nmemb, CFile stream);
extern fn CFile freopen(char* filename, char* mode, CFile stream);
extern fn CFile freopen(ZString filename, ZString mode, CFile stream);
extern fn CFile fmemopen(void* ptr, usz size, ZString mode);
extern fn int fseek(CFile stream, SeekIndex offset, int whence);
extern fn int fsetpos(CFile stream, Fpos* pos);
extern fn SeekIndex ftell(CFile stream);

2
resources/examples/contextfree/boolerr.c3
View File

@@ -127,7 +127,7 @@ fn void main()
Summary summary = readAndBuildSummary(url);
io::printf(" Summary: ");
summary.print(io::stdout());
io::println("");
io::printn("");
String title_sure = summary.title ? summary.title.str() : "";
io::printf(" Title: %s\n", title_sure);
bool! has_title = readWhetherTitleNonEmpty(url);

2
resources/examples/contextfree/multi.c3
View File

@@ -16,7 +16,7 @@ fn void main()
hello();
`;
io::println(text);
io::printn(text);
// Binary
const DATA = x"4749463839610100010080"

2
resources/examples/hello_world_many.c3
View File

@@ -14,6 +14,6 @@ fn void main()
};
foreach (greeting : greetings)
{
io::println(greeting);
io::printn(greeting);
}
}

4
resources/examples/notworking/madlibs.c3
View File

@@ -3,7 +3,7 @@ import regex, stdio;
fn void main()
{
println("Enter a story template, terminated by an empty line:");
printn("Enter a story template, terminated by an empty line:");
VarString story = "";
while (1)
{
@@ -25,5 +25,5 @@ fn void main()
story = story.replace(s, word);
}
println("\nThe story becomes:\n%s\n", story);
printn("\nThe story becomes:\n%s\n", story);
}

2
resources/examples/plus_minus.c3
View File

@@ -49,7 +49,7 @@ fn void main(String[] args)
case "-":
add = false;
default:
io::println("Failed to parse expression.");
io::printn("Failed to parse expression.");
return;
}
}

4
resources/rosettacode/antiprime.c3
View File

@@ -16,7 +16,7 @@ fn int main()
{
int maxDiv;
int count;
io::println("The first 20 anti-primes are:");
io::printn("The first 20 anti-primes are:");
int n = 1;
while (count < 20)
{
@@ -29,6 +29,6 @@ fn int main()
}
n++;
}
io::println("");
io::printn("");
return 0;
}

2
resources/rosettacode/helloworld.c3
View File

@@ -2,6 +2,6 @@ import std::io;
fn int main()
{
io::println("Hello world");
io::printn("Hello world");
return 0;
}

4
resources/testfragments/allocators_testing.c3
View File

@@ -23,7 +23,7 @@ fn void setstring(char* dst, String str)
fn void testAllocator(Allocator* a, int val)
{
io::println("Test");
io::printn("Test");
void* data = a.alloc_aligned(val, 128, 16)!!;
io::printf("Aligned with offset %p, align 16: %s offset align 128: %s\n", data, mem::ptr_is_aligned(data, 16), mem::ptr_is_aligned(data + 16, 128));
data = a.calloc_aligned(val, 128, 16)!!;
@@ -78,7 +78,7 @@ fn void main()
ArenaAllocator aa;
aa.init(&&char[1024] {});
testAllocator(&aa, 126);
io::println("Test dynamic arena");
io::printn("Test dynamic arena");
DynamicArenaAllocator dynamic_arena;
dynamic_arena.init(1024);
testAllocator(&dynamic_arena, 112);

2
src/build/project_creation.c
View File

@@ -191,7 +191,7 @@ const char* MAIN_TEMPLATE =
"\n"
"fn int main(char[][] args)\n"
"{\n"
"\tio::println(\"Hello, World!\");\n"
"\tio::printn(\"Hello, World!\");\n"
"\treturn 0;\n"
"}\n";

11
src/compiler/llvm_codegen.c
View File

@@ -1446,14 +1446,3 @@ TypeSize llvm_alloc_size(GenContext *c, LLVMTypeRef type)
return (TypeSize)aligned_offset((AlignSize)LLVMStoreSizeOfType(c->target_data, type), llvm_abi_alignment(c, type));
}
void llvm_set_catch_exit(GenContext *c, LLVMBasicBlockRef block)
{
c->catch_block = block;
c->opt_var = NULL;
}
void llvm_set_catch_exit_and_var(GenContext *c, LLVMBasicBlockRef block, LLVMValueRef catch_var)
{
c->catch_block = block;
c->opt_var = catch_var;
}

3
src/compiler/llvm_codegen_internal.h
View File

@@ -459,8 +459,7 @@ void llvm_emit_builtin_call(GenContext *c, BEValue *result_value, Expr *expr);
// -- Optional --
LLVMValueRef llvm_emit_is_no_opt(GenContext *c, LLVMValueRef error_value);
LLVMValueRef llvm_get_opt_ref(GenContext *c, Decl *decl);
void llvm_set_catch_exit(GenContext *c, LLVMBasicBlockRef block);
void llvm_set_catch_exit_and_var(GenContext *c, LLVMBasicBlockRef block, LLVMValueRef catch_var);
#define PUSH_OPT() LLVMBasicBlockRef _old_catch = c->catch_block; LLVMValueRef _old_opt_var = c->opt_var
#define POP_OPT() c->catch_block = _old_catch; c->opt_var = _old_opt_var

10
src/compiler/llvm_codegen_stmt.c
View File

@@ -1222,7 +1222,13 @@ static inline void llvm_emit_asm_block_stmt(GenContext *c, Ast *ast)
static void llvm_emit_expr_stmt(GenContext *c, Ast *ast)
{
BEValue value;
if (IS_OPTIONAL(ast->expr_stmt))
Expr *e = ast->expr_stmt;
// For a standalone catch, we can ignore storing the value.
if (e->expr_kind == EXPR_CATCH)
{
e = e->inner_expr;
}
if (IS_OPTIONAL(e))
{
PUSH_OPT();
LLVMBasicBlockRef discard_fail = llvm_basic_block_new(c, "voiderr");
@@ -1236,7 +1242,7 @@ static void llvm_emit_expr_stmt(GenContext *c, Ast *ast)
POP_OPT();
return;
}
llvm_emit_expr(c, &value, ast->expr_stmt);
llvm_emit_expr(c, &value, e);
}
LLVMValueRef llvm_emit_string_const(GenContext *c, const char *str, const char *extname)

7
src/compiler/sema_decls.c
View File

@@ -1371,13 +1371,6 @@ static inline bool sema_analyse_method(SemaContext *context, Decl *decl)
TypeInfo *parent_type = type_infoptr(decl->func_decl.type_parent);
if (!sema_resolve_type_info(context, parent_type)) return false;
Type *type = parent_type->type->canonical;
if (!type_may_have_sub_elements(type) && !type_underlying_is_numeric(type) && !type_is_arraylike(type))
{
SEMA_ERROR(decl,
"Methods can not be associated with '%s'",
type_to_error_string(parent_type->type));
return false;
}
Decl **params = decl->func_decl.signature.params;
if (!vec_size(params))
{

2
src/version.h
View File

@@ -1 +1 @@
#define COMPILER_VERSION "0.4.41"
#define COMPILER_VERSION "0.4.43"

296
test/test_suite/bitstruct/bitstruct_be.c3t
View File

@@ -25,15 +25,15 @@ fn void main()
char[4]* z = (char[4]*)&abc;
char[4]* z2 = (char[4]*)&abc2;
foreach (d : z2) io::printf(" %x", d);
io::println("");
io::printn("");
foreach (d : z) io::printf(" %x", d);
io::println("");
io::printn("");
io::printfn("abc.a = %x", abc.a);
abc.a = 0x1234;
abc.b = 0x5678;
io::printfn("->abc.a = %x", abc.a);
foreach (d : z) io::printf(" %x", d);
io::println("");
io::printn("");
IntLE y;
y.val = 123;
@@ -103,143 +103,197 @@ voiderr6: ; preds = %after_check5, %loop
br label %loop.cond
loop.exit: ; preds = %loop.cond
%22 = call i32 @std_io_println(ptr @.str.2) #2
%23 = load ptr, ptr %z, align 8
store ptr %23, ptr %.anon7, align 8
store i64 0, ptr %.anon8, align 8
br label %loop.cond9
store ptr @.str.2, ptr %x7, align 8
store i64 0, ptr %error_var, align 8
%22 = call ptr @std_io_stdout()
store ptr %22, ptr %result, align 8
%23 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result, ptr null, i64 0)
%not_err9 = icmp eq i64 %23, 0
br i1 %not_err9, label %after_check10, label %assign_optional
loop.cond9: ; preds = %voiderr17, %loop.exit
%24 = load i64, ptr %.anon8, align 8
%gt10 = icmp ugt i64 4, %24
br i1 %gt10, label %loop.body11, label %loop.exit19
assign_optional: ; preds = %loop.exit
store i64 %23, ptr %error_var, align 8
br label %noerr_block
loop.body11: ; preds = %loop.cond9
%25 = load ptr, ptr %.anon7, align 8
%26 = load i64, ptr %.anon8, align 8
%27 = getelementptr inbounds [4 x i8], ptr %25, i64 0, i64 %26
%28 = load i8, ptr %27, align 1
store i8 %28, ptr %d12, align 1
%29 = insertvalue %variant undef, ptr %d12, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$char" to i64), 1
%31 = getelementptr inbounds [1 x %variant], ptr %varargslots14, i64 0, i64 0
store %variant %30, ptr %31, align 16
%32 = call i64 @std_io_printf(ptr %retparam13, ptr @.str.3, i64 3, ptr %varargslots14, i64 1)
%not_err15 = icmp eq i64 %32, 0
br i1 %not_err15, label %after_check16, label %voiderr17
after_check10: ; preds = %loop.exit
br label %noerr_block
after_check16: ; preds = %loop.body11
br label %voiderr17
noerr_block: ; preds = %after_check10, %assign_optional
br label %voiderr11
voiderr17: ; preds = %after_check16, %loop.body11
%33 = load i64, ptr %.anon8, align 8
%add18 = add i64 %33, 1
store i64 %add18, ptr %.anon8, align 8
br label %loop.cond9
voiderr11: ; preds = %noerr_block
%24 = load ptr, ptr %z, align 8
store ptr %24, ptr %.anon12, align 8
store i64 0, ptr %.anon13, align 8
br label %loop.cond14
loop.exit19: ; preds = %loop.cond9
%34 = call i32 @std_io_println(ptr @.str.4) #2
%35 = load i32, ptr %abc, align 4
%36 = call i32 @llvm.bswap.i32(i32 %35)
%37 = and i32 65535, %36
%ztrunc = trunc i32 %37 to i16
store i16 %ztrunc, ptr %taddr22, align 2
%38 = insertvalue %variant undef, ptr %taddr22, 0
%39 = insertvalue %variant %38, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
%40 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
store %variant %39, ptr %40, align 16
%41 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.5, i64 10, ptr %varargslots21, i64 1)
%not_err23 = icmp eq i64 %41, 0
br i1 %not_err23, label %after_check24, label %voiderr25
loop.cond14: ; preds = %voiderr22, %voiderr11
%25 = load i64, ptr %.anon13, align 8
%gt15 = icmp ugt i64 4, %25
br i1 %gt15, label %loop.body16, label %loop.exit24
after_check24: ; preds = %loop.exit19
br label %voiderr25
loop.body16: ; preds = %loop.cond14
%26 = load ptr, ptr %.anon12, align 8
%27 = load i64, ptr %.anon13, align 8
%28 = getelementptr inbounds [4 x i8], ptr %26, i64 0, i64 %27
%29 = load i8, ptr %28, align 1
store i8 %29, ptr %d17, align 1
%30 = insertvalue %variant undef, ptr %d17, 0
%31 = insertvalue %variant %30, i64 ptrtoint (ptr @"ct$char" to i64), 1
%32 = getelementptr inbounds [1 x %variant], ptr %varargslots19, i64 0, i64 0
store %variant %31, ptr %32, align 16
%33 = call i64 @std_io_printf(ptr %retparam18, ptr @.str.3, i64 3, ptr %varargslots19, i64 1)
%not_err20 = icmp eq i64 %33, 0
br i1 %not_err20, label %after_check21, label %voiderr22
voiderr25: ; preds = %after_check24, %loop.exit19
%42 = load i32, ptr %abc, align 4
%43 = call i32 @llvm.bswap.i32(i32 %42)
%44 = and i32 %43, -65536
%45 = or i32 %44, 4660
%46 = call i32 @llvm.bswap.i32(i32 %45)
store i32 %46, ptr %abc, align 4
%47 = load i32, ptr %abc, align 4
after_check21: ; preds = %loop.body16
br label %voiderr22
voiderr22: ; preds = %after_check21, %loop.body16
%34 = load i64, ptr %.anon13, align 8
%add23 = add i64 %34, 1
store i64 %add23, ptr %.anon13, align 8
br label %loop.cond14
loop.exit24: ; preds = %loop.cond14
store ptr @.str.4, ptr %x25, align 8
store i64 0, ptr %error_var26, align 8
%35 = call ptr @std_io_stdout()
store ptr %35, ptr %result28, align 8
%36 = call i64 @std_io_File_printn(ptr %retparam27, ptr %result28, ptr null, i64 0)
%not_err29 = icmp eq i64 %36, 0
br i1 %not_err29, label %after_check31, label %assign_optional30
assign_optional30: ; preds = %loop.exit24
store i64 %36, ptr %error_var26, align 8
br label %noerr_block32
after_check31: ; preds = %loop.exit24
br label %noerr_block32
noerr_block32: ; preds = %after_check31, %assign_optional30
br label %voiderr33
voiderr33: ; preds = %noerr_block32
%37 = load i32, ptr %abc, align 4
%38 = call i32 @llvm.bswap.i32(i32 %37)
%39 = and i32 65535, %38
%ztrunc = trunc i32 %39 to i16
store i16 %ztrunc, ptr %taddr36, align 2
%40 = insertvalue %variant undef, ptr %taddr36, 0
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
%42 = getelementptr inbounds [1 x %variant], ptr %varargslots35, i64 0, i64 0
store %variant %41, ptr %42, align 16
%43 = call i64 @std_io_printfn(ptr %retparam34, ptr @.str.5, i64 10, ptr %varargslots35, i64 1)
%not_err37 = icmp eq i64 %43, 0
br i1 %not_err37, label %after_check38, label %voiderr39
after_check38: ; preds = %voiderr33
br label %voiderr39
voiderr39: ; preds = %after_check38, %voiderr33
%44 = load i32, ptr %abc, align 4
%45 = call i32 @llvm.bswap.i32(i32 %44)
%46 = and i32 %45, -65536
%47 = or i32 %46, 4660
%48 = call i32 @llvm.bswap.i32(i32 %47)
%49 = and i32 %48, 65535
%50 = or i32 %49, 1450704896
%51 = call i32 @llvm.bswap.i32(i32 %50)
store i32 %51, ptr %abc, align 4
%52 = load i32, ptr %abc, align 4
store i32 %48, ptr %abc, align 4
%49 = load i32, ptr %abc, align 4
%50 = call i32 @llvm.bswap.i32(i32 %49)
%51 = and i32 %50, 65535
%52 = or i32 %51, 1450704896
%53 = call i32 @llvm.bswap.i32(i32 %52)
%54 = and i32 65535, %53
%ztrunc28 = trunc i32 %54 to i16
store i16 %ztrunc28, ptr %taddr29, align 2
%55 = insertvalue %variant undef, ptr %taddr29, 0
%56 = insertvalue %variant %55, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
%57 = getelementptr inbounds [1 x %variant], ptr %varargslots27, i64 0, i64 0
store %variant %56, ptr %57, align 16
%58 = call i64 @std_io_printfn(ptr %retparam26, ptr @.str.6, i64 12, ptr %varargslots27, i64 1)
%not_err30 = icmp eq i64 %58, 0
br i1 %not_err30, label %after_check31, label %voiderr32
store i32 %53, ptr %abc, align 4
%54 = load i32, ptr %abc, align 4
%55 = call i32 @llvm.bswap.i32(i32 %54)
%56 = and i32 65535, %55
%ztrunc42 = trunc i32 %56 to i16
store i16 %ztrunc42, ptr %taddr43, align 2
%57 = insertvalue %variant undef, ptr %taddr43, 0
%58 = insertvalue %variant %57, i64 ptrtoint (ptr @"ct$ushort" to i64), 1
%59 = getelementptr inbounds [1 x %variant], ptr %varargslots41, i64 0, i64 0
store %variant %58, ptr %59, align 16
%60 = call i64 @std_io_printfn(ptr %retparam40, ptr @.str.6, i64 12, ptr %varargslots41, i64 1)
%not_err44 = icmp eq i64 %60, 0
br i1 %not_err44, label %after_check45, label %voiderr46
after_check31: ; preds = %voiderr25
br label %voiderr32
after_check45: ; preds = %voiderr39
br label %voiderr46
voiderr32: ; preds = %after_check31, %voiderr25
%59 = load ptr, ptr %z, align 8
store ptr %59, ptr %.anon33, align 8
store i64 0, ptr %.anon34, align 8
br label %loop.cond35
voiderr46: ; preds = %after_check45, %voiderr39
%61 = load ptr, ptr %z, align 8
store ptr %61, ptr %.anon47, align 8
store i64 0, ptr %.anon48, align 8
br label %loop.cond49
loop.cond35: ; preds = %voiderr43, %voiderr32
%60 = load i64, ptr %.anon34, align 8
%gt36 = icmp ugt i64 4, %60
br i1 %gt36, label %loop.body37, label %loop.exit45
loop.cond49: ; preds = %voiderr57, %voiderr46
%62 = load i64, ptr %.anon48, align 8
%gt50 = icmp ugt i64 4, %62
br i1 %gt50, label %loop.body51, label %loop.exit59
loop.body37: ; preds = %loop.cond35
%61 = load ptr, ptr %.anon33, align 8
%62 = load i64, ptr %.anon34, align 8
%63 = getelementptr inbounds [4 x i8], ptr %61, i64 0, i64 %62
%64 = load i8, ptr %63, align 1
store i8 %64, ptr %d38, align 1
%65 = insertvalue %variant undef, ptr %d38, 0
%66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$char" to i64), 1
%67 = getelementptr inbounds [1 x %variant], ptr %varargslots40, i64 0, i64 0
store %variant %66, ptr %67, align 16
%68 = call i64 @std_io_printf(ptr %retparam39, ptr @.str.7, i64 3, ptr %varargslots40, i64 1)
%not_err41 = icmp eq i64 %68, 0
br i1 %not_err41, label %after_check42, label %voiderr43
loop.body51: ; preds = %loop.cond49
%63 = load ptr, ptr %.anon47, align 8
%64 = load i64, ptr %.anon48, align 8
%65 = getelementptr inbounds [4 x i8], ptr %63, i64 0, i64 %64
%66 = load i8, ptr %65, align 1
store i8 %66, ptr %d52, align 1
%67 = insertvalue %variant undef, ptr %d52, 0
%68 = insertvalue %variant %67, i64 ptrtoint (ptr @"ct$char" to i64), 1
%69 = getelementptr inbounds [1 x %variant], ptr %varargslots54, i64 0, i64 0
store %variant %68, ptr %69, align 16
%70 = call i64 @std_io_printf(ptr %retparam53, ptr @.str.7, i64 3, ptr %varargslots54, i64 1)
%not_err55 = icmp eq i64 %70, 0
br i1 %not_err55, label %after_check56, label %voiderr57
after_check42: ; preds = %loop.body37
br label %voiderr43
after_check56: ; preds = %loop.body51
br label %voiderr57
voiderr43: ; preds = %after_check42, %loop.body37
%69 = load i64, ptr %.anon34, align 8
%add44 = add i64 %69, 1
store i64 %add44, ptr %.anon34, align 8
br label %loop.cond35
voiderr57: ; preds = %after_check56, %loop.body51
%71 = load i64, ptr %.anon48, align 8
%add58 = add i64 %71, 1
store i64 %add58, ptr %.anon48, align 8
br label %loop.cond49
loop.exit45: ; preds = %loop.cond35
%70 = call i32 @std_io_println(ptr @.str.8) #2
loop.exit59: ; preds = %loop.cond49
store ptr @.str.8, ptr %x60, align 8
store i64 0, ptr %error_var61, align 8
%72 = call ptr @std_io_stdout()
store ptr %72, ptr %result63, align 8
%73 = call i64 @std_io_File_printn(ptr %retparam62, ptr %result63, ptr null, i64 0)
%not_err64 = icmp eq i64 %73, 0
br i1 %not_err64, label %after_check66, label %assign_optional65
assign_optional65: ; preds = %loop.exit59
store i64 %73, ptr %error_var61, align 8
br label %noerr_block67
after_check66: ; preds = %loop.exit59
br label %noerr_block67
noerr_block67: ; preds = %after_check66, %assign_optional65
br label %voiderr68
voiderr68: ; preds = %noerr_block67
store i32 0, ptr %y, align 4
%71 = load i32, ptr %y, align 4
%74 = load i32, ptr %y, align 4
store i32 123, ptr %y, align 4
%72 = insertvalue %variant undef, ptr %y, 0
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$int" to i64), 1
%74 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 0
store %variant %73, ptr %74, align 16
%75 = load i32, ptr %y, align 4
store i32 %75, ptr %taddr48, align 4
%76 = insertvalue %variant undef, ptr %taddr48, 0
%77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$int" to i64), 1
%78 = getelementptr inbounds [2 x %variant], ptr %varargslots47, i64 0, i64 1
store %variant %77, ptr %78, align 16
%79 = call i64 @std_io_printf(ptr %retparam46, ptr @.str.9, i64 18, ptr %varargslots47, i64 2)
%not_err49 = icmp eq i64 %79, 0
br i1 %not_err49, label %after_check50, label %voiderr51
%75 = insertvalue %variant undef, ptr %y, 0
%76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$int" to i64), 1
%77 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0
store %variant %76, ptr %77, align 16
%78 = load i32, ptr %y, align 4
store i32 %78, ptr %taddr71, align 4
%79 = insertvalue %variant undef, ptr %taddr71, 0
%80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$int" to i64), 1
%81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1
store %variant %80, ptr %81, align 16
%82 = call i64 @std_io_printf(ptr %retparam69, ptr @.str.9, i64 18, ptr %varargslots70, i64 2)
%not_err72 = icmp eq i64 %82, 0
br i1 %not_err72, label %after_check73, label %voiderr74
after_check50: ; preds = %loop.exit45
br label %voiderr51
after_check73: ; preds = %voiderr68
br label %voiderr74
voiderr51: ; preds = %after_check50, %loop.exit45
voiderr74: ; preds = %after_check73, %voiderr68
ret void
}

158
test/test_suite/compile_time/ct_builtin_time_date.c3t
View File

@@ -10,11 +10,11 @@ fn void test(int x)
{
io::printfn("%d", x);
if (x > 0) $$FUNCTION(x - 1);
io::println($$TIME);
io::println($$DATE);
io::printn($$TIME);
io::printn($$DATE);
printline();
io::println($$FILE);
io::println($$MODULE);
io::printn($$FILE);
io::printn($$MODULE);
}
bool is_def = $defined($$FUNCTION);
@@ -32,12 +32,28 @@ entry:
%retparam = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%taddr = alloca i32, align 4
%x = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam1 = alloca i64, align 8
%varargslots2 = alloca [1 x %variant], align 16
%taddr3 = alloca i64, align 8
%result = alloca %File, align 8
%x5 = alloca ptr, align 8
%error_var6 = alloca i64, align 8
%retparam7 = alloca i64, align 8
%varargslots8 = alloca [1 x %variant], align 16
%taddr9 = alloca i64, align 8
%result8 = alloca %File, align 8
%retparam14 = alloca i64, align 8
%varargslots15 = alloca [1 x %variant], align 16
%taddr16 = alloca i64, align 8
%retparam20 = alloca i64, align 8
%varargslots21 = alloca [1 x %variant], align 16
%taddr22 = alloca i64, align 8
%x26 = alloca ptr, align 8
%error_var27 = alloca i64, align 8
%retparam28 = alloca i64, align 8
%result29 = alloca %File, align 8
%x35 = alloca ptr, align 8
%error_var36 = alloca i64, align 8
%retparam37 = alloca i64, align 8
%result38 = alloca %File, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
%2 = insertvalue %variant %1, i64 ptrtoint (ptr @"ct$int" to i64), 1
@@ -60,35 +76,111 @@ if.then: ; preds = %voiderr
br label %if.exit
if.exit: ; preds = %if.then, %voiderr
%5 = call i32 @std_io_println(ptr @.str.1) #1
%6 = call i32 @std_io_println(ptr @.str.2) #1
store i64 14, ptr %taddr3, align 8
%7 = insertvalue %variant undef, ptr %taddr3, 0
%8 = insertvalue %variant %7, i64 ptrtoint (ptr @"ct$long" to i64), 1
%9 = getelementptr inbounds [1 x %variant], ptr %varargslots2, i64 0, i64 0
store %variant %8, ptr %9, align 16
%10 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.3, i64 2, ptr %varargslots2, i64 1)
%not_err4 = icmp eq i64 %10, 0
br i1 %not_err4, label %after_check5, label %voiderr6
store ptr @.str.1, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%5 = call ptr @std_io_stdout()
store ptr %5, ptr %result, align 8
%6 = load ptr, ptr %x, align 8
%7 = call i64 @std_io_File_printn(ptr %retparam1, ptr %result, ptr %6, i64 8)
%not_err2 = icmp eq i64 %7, 0
br i1 %not_err2, label %after_check3, label %assign_optional
after_check5: ; preds = %if.exit
br label %voiderr6
assign_optional: ; preds = %if.exit
store i64 %7, ptr %error_var, align 8
br label %noerr_block
voiderr6: ; preds = %after_check5, %if.exit
store i64 6, ptr %taddr9, align 8
%11 = insertvalue %variant undef, ptr %taddr9, 0
after_check3: ; preds = %if.exit
br label %noerr_block
noerr_block: ; preds = %after_check3, %assign_optional
br label %voiderr4
voiderr4: ; preds = %noerr_block
store ptr @.str.2, ptr %x5, align 8
store i64 0, ptr %error_var6, align 8
%8 = call ptr @std_io_stdout()
store ptr %8, ptr %result8, align 8
%9 = load ptr, ptr %x5, align 8
%10 = call i64 @std_io_File_printn(ptr %retparam7, ptr %result8, ptr %9, i64 10)
%not_err9 = icmp eq i64 %10, 0
br i1 %not_err9, label %after_check11, label %assign_optional10
assign_optional10: ; preds = %voiderr4
store i64 %10, ptr %error_var6, align 8
br label %noerr_block12
after_check11: ; preds = %voiderr4
br label %noerr_block12
noerr_block12: ; preds = %after_check11, %assign_optional10
br label %voiderr13
voiderr13: ; preds = %noerr_block12
store i64 14, ptr %taddr16, align 8
%11 = insertvalue %variant undef, ptr %taddr16, 0
%12 = insertvalue %variant %11, i64 ptrtoint (ptr @"ct$long" to i64), 1
%13 = getelementptr inbounds [1 x %variant], ptr %varargslots8, i64 0, i64 0
%13 = getelementptr inbounds [1 x %variant], ptr %varargslots15, i64 0, i64 0
store %variant %12, ptr %13, align 16
%14 = call i64 @std_io_printfn(ptr %retparam7, ptr @.str.4, i64 2, ptr %varargslots8, i64 1)
%not_err10 = icmp eq i64 %14, 0
br i1 %not_err10, label %after_check11, label %voiderr12
%14 = call i64 @std_io_printfn(ptr %retparam14, ptr @.str.3, i64 2, ptr %varargslots15, i64 1)
%not_err17 = icmp eq i64 %14, 0
br i1 %not_err17, label %after_check18, label %voiderr19
after_check11: ; preds = %voiderr6
br label %voiderr12
after_check18: ; preds = %voiderr13
br label %voiderr19
voiderr12: ; preds = %after_check11, %voiderr6
%15 = call i32 @std_io_println(ptr @.str.5) #1
%16 = call i32 @std_io_println(ptr @.str.6) #1
voiderr19: ; preds = %after_check18, %voiderr13
store i64 6, ptr %taddr22, align 8
%15 = insertvalue %variant undef, ptr %taddr22, 0
%16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$long" to i64), 1
%17 = getelementptr inbounds [1 x %variant], ptr %varargslots21, i64 0, i64 0
store %variant %16, ptr %17, align 16
%18 = call i64 @std_io_printfn(ptr %retparam20, ptr @.str.4, i64 2, ptr %varargslots21, i64 1)
%not_err23 = icmp eq i64 %18, 0
br i1 %not_err23, label %after_check24, label %voiderr25
after_check24: ; preds = %voiderr19
br label %voiderr25
voiderr25: ; preds = %after_check24, %voiderr19
store ptr @.str.5, ptr %x26, align 8
store i64 0, ptr %error_var27, align 8
%19 = call ptr @std_io_stdout()
store ptr %19, ptr %result29, align 8
%20 = load ptr, ptr %x26, align 8
%21 = call i64 @std_io_File_printn(ptr %retparam28, ptr %result29, ptr %20, i64 23)
%not_err30 = icmp eq i64 %21, 0
br i1 %not_err30, label %after_check32, label %assign_optional31
assign_optional31: ; preds = %voiderr25
store i64 %21, ptr %error_var27, align 8
br label %noerr_block33
after_check32: ; preds = %voiderr25
br label %noerr_block33
noerr_block33: ; preds = %after_check32, %assign_optional31
br label %voiderr34
voiderr34: ; preds = %noerr_block33
store ptr @.str.6, ptr %x35, align 8
store i64 0, ptr %error_var36, align 8
%22 = call ptr @std_io_stdout()
store ptr %22, ptr %result38, align 8
%23 = load ptr, ptr %x35, align 8
%24 = call i64 @std_io_File_printn(ptr %retparam37, ptr %result38, ptr %23, i64 4)
%not_err39 = icmp eq i64 %24, 0
br i1 %not_err39, label %after_check41, label %assign_optional40
assign_optional40: ; preds = %voiderr34
store i64 %24, ptr %error_var36, align 8
br label %noerr_block42
after_check41: ; preds = %voiderr34
br label %noerr_block42
noerr_block42: ; preds = %after_check41, %assign_optional40
br label %voiderr43
voiderr43: ; preds = %noerr_block42
ret void
}
}

4
test/test_suite/compile_time/ct_func.c3t
View File

@@ -4,7 +4,7 @@ import std::io;
fn int test()
{
io::println($$FUNC);
io::printn($$FUNC);
return 1;
}
@@ -13,7 +13,7 @@ struct Foo
fn void Foo.tester(Foo* f)
{
io::println($$FUNC);
io::printn($$FUNC);
}
fn void main()

623
test/test_suite/compile_time/ct_memberof.c3t
View File

@@ -8,7 +8,7 @@ macro print_args($Type)
{
var $params = $Type.params;
$foreach ($param : $params):
io::println($param.nameof);
io::printn($param.nameof);
$endforeach;
}
@@ -46,8 +46,8 @@ fn void test(int x)
print_args($typeof(&test));
print_args($typeof(&hell));
print_args($typeof(&hello));
io::println($typeof(&test).returns.nameof);
io::println($typeof(&hell).returns.nameof);
io::printn($typeof(&test).returns.nameof);
io::printn($typeof(&hell).returns.nameof);
print_fields(Foo);
print_fields(Bar);
print_fields(Bark);
@@ -117,281 +117,442 @@ entry:
; Function Attrs: nounwind
define void @test_test(i32 %0) #0 {
entry:
%x = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
%x1 = alloca ptr, align 8
%error_var2 = alloca i64, align 8
%retparam3 = alloca i64, align 8
%result4 = alloca %File, align 8
%x10 = alloca ptr, align 8
%error_var11 = alloca i64, align 8
%retparam12 = alloca i64, align 8
%result13 = alloca %File, align 8
%x19 = alloca ptr, align 8
%error_var20 = alloca i64, align 8
%retparam21 = alloca i64, align 8
%result22 = alloca %File, align 8
%x28 = alloca ptr, align 8
%error_var29 = alloca i64, align 8
%retparam30 = alloca i64, align 8
%result31 = alloca %File, align 8
%x37 = alloca ptr, align 8
%error_var38 = alloca i64, align 8
%retparam39 = alloca i64, align 8
%result40 = alloca %File, align 8
%x46 = alloca ptr, align 8
%error_var47 = alloca i64, align 8
%retparam48 = alloca i64, align 8
%result49 = alloca %File, align 8
%retparam55 = alloca i64, align 8
%varargslots = alloca [1 x %variant], align 16
%taddr = alloca ptr, align 8
%retparam1 = alloca i64, align 8
%varargslots2 = alloca [2 x %variant], align 16
%taddr3 = alloca ptr, align 8
%taddr4 = alloca ptr, align 8
%retparam8 = alloca i64, align 8
%varargslots9 = alloca [2 x %variant], align 16
%taddr10 = alloca ptr, align 8
%taddr11 = alloca ptr, align 8
%retparam15 = alloca i64, align 8
%varargslots16 = alloca [2 x %variant], align 16
%taddr17 = alloca ptr, align 8
%taddr18 = alloca ptr, align 8
%retparam22 = alloca i64, align 8
%varargslots23 = alloca [2 x %variant], align 16
%taddr24 = alloca ptr, align 8
%taddr25 = alloca ptr, align 8
%retparam29 = alloca i64, align 8
%varargslots30 = alloca [1 x %variant], align 16
%taddr31 = alloca ptr, align 8
%retparam35 = alloca i64, align 8
%varargslots36 = alloca [2 x %variant], align 16
%taddr37 = alloca ptr, align 8
%taddr38 = alloca ptr, align 8
%retparam42 = alloca i64, align 8
%varargslots43 = alloca [2 x %variant], align 16
%taddr44 = alloca ptr, align 8
%taddr45 = alloca ptr, align 8
%retparam49 = alloca i64, align 8
%varargslots50 = alloca [2 x %variant], align 16
%taddr51 = alloca ptr, align 8
%taddr52 = alloca ptr, align 8
%retparam56 = alloca i64, align 8
%varargslots57 = alloca [2 x %variant], align 16
%taddr58 = alloca ptr, align 8
%taddr59 = alloca ptr, align 8
%retparam63 = alloca i64, align 8
%varargslots64 = alloca [1 x %variant], align 16
%taddr65 = alloca ptr, align 8
%retparam69 = alloca i64, align 8
%varargslots70 = alloca [2 x %variant], align 16
%taddr71 = alloca ptr, align 8
%taddr72 = alloca ptr, align 8
%retparam76 = alloca i64, align 8
%varargslots77 = alloca [2 x %variant], align 16
%taddr78 = alloca ptr, align 8
%taddr79 = alloca ptr, align 8
%1 = call i32 @std_io_println(ptr @.str) #1
%2 = call i32 @std_io_println(ptr @.str.10) #1
%3 = call i32 @std_io_println(ptr @.str.11) #1
%4 = call i32 @std_io_println(ptr @.str.12) #1
%5 = call i32 @std_io_println(ptr @.str.13) #1
%6 = call i32 @std_io_println(ptr @.str.14) #1
%7 = call i32 @std_io_println(ptr @.str.15) #1
store ptr @.str.17, ptr %taddr, align 8
%8 = insertvalue %variant undef, ptr %taddr, 0
%9 = insertvalue %variant %8, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%10 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %9, ptr %10, align 16
%11 = call i64 @std_io_printfn(ptr %retparam, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
%not_err = icmp eq i64 %11, 0
br i1 %not_err, label %after_check, label %voiderr
%retparam59 = alloca i64, align 8
%varargslots60 = alloca [2 x %variant], align 16
%taddr61 = alloca ptr, align 8
%taddr62 = alloca ptr, align 8
%retparam66 = alloca i64, align 8
%varargslots67 = alloca [2 x %variant], align 16
%taddr68 = alloca ptr, align 8
%taddr69 = alloca ptr, align 8
%retparam73 = alloca i64, align 8
%varargslots74 = alloca [2 x %variant], align 16
%taddr75 = alloca ptr, align 8
%taddr76 = alloca ptr, align 8
%retparam80 = alloca i64, align 8
%varargslots81 = alloca [2 x %variant], align 16
%taddr82 = alloca ptr, align 8
%taddr83 = alloca ptr, align 8
%retparam87 = alloca i64, align 8
%varargslots88 = alloca [1 x %variant], align 16
%taddr89 = alloca ptr, align 8
%retparam93 = alloca i64, align 8
%varargslots94 = alloca [2 x %variant], align 16
%taddr95 = alloca ptr, align 8
%taddr96 = alloca ptr, align 8
%retparam100 = alloca i64, align 8
%varargslots101 = alloca [2 x %variant], align 16
%taddr102 = alloca ptr, align 8
%taddr103 = alloca ptr, align 8
%retparam107 = alloca i64, align 8
%varargslots108 = alloca [2 x %variant], align 16
%taddr109 = alloca ptr, align 8
%taddr110 = alloca ptr, align 8
%retparam114 = alloca i64, align 8
%varargslots115 = alloca [2 x %variant], align 16
%taddr116 = alloca ptr, align 8
%taddr117 = alloca ptr, align 8
%retparam121 = alloca i64, align 8
%varargslots122 = alloca [1 x %variant], align 16
%taddr123 = alloca ptr, align 8
%retparam127 = alloca i64, align 8
%varargslots128 = alloca [2 x %variant], align 16
%taddr129 = alloca ptr, align 8
%taddr130 = alloca ptr, align 8
%retparam134 = alloca i64, align 8
%varargslots135 = alloca [2 x %variant], align 16
%taddr136 = alloca ptr, align 8
%taddr137 = alloca ptr, align 8
store ptr @.str, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%1 = call ptr @std_io_stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %x, align 8
%3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 3)
%not_err = icmp eq i64 %3, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %entry
store i64 %3, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %entry
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %after_check, %entry
store ptr @.str.19, ptr %taddr3, align 8
%12 = insertvalue %variant undef, ptr %taddr3, 0
%13 = insertvalue %variant %12, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%14 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 0
store %variant %13, ptr %14, align 16
store ptr @.str.20, ptr %taddr4, align 8
%15 = insertvalue %variant undef, ptr %taddr4, 0
%16 = insertvalue %variant %15, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%17 = getelementptr inbounds [2 x %variant], ptr %varargslots2, i64 0, i64 1
store %variant %16, ptr %17, align 16
%18 = call i64 @std_io_printfn(ptr %retparam1, ptr @.str.18, i64 6, ptr %varargslots2, i64 2)
%not_err5 = icmp eq i64 %18, 0
br i1 %not_err5, label %after_check6, label %voiderr7
voiderr: ; preds = %noerr_block
store ptr @.str.10, ptr %x1, align 8
store i64 0, ptr %error_var2, align 8
%4 = call ptr @std_io_stdout()
store ptr %4, ptr %result4, align 8
%5 = load ptr, ptr %x1, align 8
%6 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr %5, i64 3)
%not_err5 = icmp eq i64 %6, 0
br i1 %not_err5, label %after_check7, label %assign_optional6
after_check6: ; preds = %voiderr
br label %voiderr7
assign_optional6: ; preds = %voiderr
store i64 %6, ptr %error_var2, align 8
br label %noerr_block8
voiderr7: ; preds = %after_check6, %voiderr
store ptr @.str.22, ptr %taddr10, align 8
%19 = insertvalue %variant undef, ptr %taddr10, 0
%20 = insertvalue %variant %19, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%21 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 0
store %variant %20, ptr %21, align 16
store ptr @.str.23, ptr %taddr11, align 8
%22 = insertvalue %variant undef, ptr %taddr11, 0
%23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%24 = getelementptr inbounds [2 x %variant], ptr %varargslots9, i64 0, i64 1
after_check7: ; preds = %voiderr
br label %noerr_block8
noerr_block8: ; preds = %after_check7, %assign_optional6
br label %voiderr9
voiderr9: ; preds = %noerr_block8
store ptr @.str.11, ptr %x10, align 8
store i64 0, ptr %error_var11, align 8
%7 = call ptr @std_io_stdout()
store ptr %7, ptr %result13, align 8
%8 = load ptr, ptr %x10, align 8
%9 = call i64 @std_io_File_printn(ptr %retparam12, ptr %result13, ptr %8, i64 6)
%not_err14 = icmp eq i64 %9, 0
br i1 %not_err14, label %after_check16, label %assign_optional15
assign_optional15: ; preds = %voiderr9
store i64 %9, ptr %error_var11, align 8
br label %noerr_block17
after_check16: ; preds = %voiderr9
br label %noerr_block17
noerr_block17: ; preds = %after_check16, %assign_optional15
br label %voiderr18
voiderr18: ; preds = %noerr_block17
store ptr @.str.12, ptr %x19, align 8
store i64 0, ptr %error_var20, align 8
%10 = call ptr @std_io_stdout()
store ptr %10, ptr %result22, align 8
%11 = load ptr, ptr %x19, align 8
%12 = call i64 @std_io_File_printn(ptr %retparam21, ptr %result22, ptr %11, i64 6)
%not_err23 = icmp eq i64 %12, 0
br i1 %not_err23, label %after_check25, label %assign_optional24
assign_optional24: ; preds = %voiderr18
store i64 %12, ptr %error_var20, align 8
br label %noerr_block26
after_check25: ; preds = %voiderr18
br label %noerr_block26
noerr_block26: ; preds = %after_check25, %assign_optional24
br label %voiderr27
voiderr27: ; preds = %noerr_block26
store ptr @.str.13, ptr %x28, align 8
store i64 0, ptr %error_var29, align 8
%13 = call ptr @std_io_stdout()
store ptr %13, ptr %result31, align 8
%14 = load ptr, ptr %x28, align 8
%15 = call i64 @std_io_File_printn(ptr %retparam30, ptr %result31, ptr %14, i64 9)
%not_err32 = icmp eq i64 %15, 0
br i1 %not_err32, label %after_check34, label %assign_optional33
assign_optional33: ; preds = %voiderr27
store i64 %15, ptr %error_var29, align 8
br label %noerr_block35
after_check34: ; preds = %voiderr27
br label %noerr_block35
noerr_block35: ; preds = %after_check34, %assign_optional33
br label %voiderr36
voiderr36: ; preds = %noerr_block35
store ptr @.str.14, ptr %x37, align 8
store i64 0, ptr %error_var38, align 8
%16 = call ptr @std_io_stdout()
store ptr %16, ptr %result40, align 8
%17 = load ptr, ptr %x37, align 8
%18 = call i64 @std_io_File_printn(ptr %retparam39, ptr %result40, ptr %17, i64 4)
%not_err41 = icmp eq i64 %18, 0
br i1 %not_err41, label %after_check43, label %assign_optional42
assign_optional42: ; preds = %voiderr36
store i64 %18, ptr %error_var38, align 8
br label %noerr_block44
after_check43: ; preds = %voiderr36
br label %noerr_block44
noerr_block44: ; preds = %after_check43, %assign_optional42
br label %voiderr45
voiderr45: ; preds = %noerr_block44
store ptr @.str.15, ptr %x46, align 8
store i64 0, ptr %error_var47, align 8
%19 = call ptr @std_io_stdout()
store ptr %19, ptr %result49, align 8
%20 = load ptr, ptr %x46, align 8
%21 = call i64 @std_io_File_printn(ptr %retparam48, ptr %result49, ptr %20, i64 3)
%not_err50 = icmp eq i64 %21, 0
br i1 %not_err50, label %after_check52, label %assign_optional51
assign_optional51: ; preds = %voiderr45
store i64 %21, ptr %error_var47, align 8
br label %noerr_block53
after_check52: ; preds = %voiderr45
br label %noerr_block53
noerr_block53: ; preds = %after_check52, %assign_optional51
br label %voiderr54
voiderr54: ; preds = %noerr_block53
store ptr @.str.17, ptr %taddr, align 8
%22 = insertvalue %variant undef, ptr %taddr, 0
%23 = insertvalue %variant %22, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%24 = getelementptr inbounds [1 x %variant], ptr %varargslots, i64 0, i64 0
store %variant %23, ptr %24, align 16
%25 = call i64 @std_io_printfn(ptr %retparam8, ptr @.str.21, i64 6, ptr %varargslots9, i64 2)
%not_err12 = icmp eq i64 %25, 0
br i1 %not_err12, label %after_check13, label %voiderr14
%25 = call i64 @std_io_printfn(ptr %retparam55, ptr @.str.16, i64 8, ptr %varargslots, i64 1)
%not_err56 = icmp eq i64 %25, 0
br i1 %not_err56, label %after_check57, label %voiderr58
after_check13: ; preds = %voiderr7
br label %voiderr14
after_check57: ; preds = %voiderr54
br label %voiderr58
voiderr14: ; preds = %after_check13, %voiderr7
store ptr @.str.25, ptr %taddr17, align 8
%26 = insertvalue %variant undef, ptr %taddr17, 0
%27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
%28 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 0
voiderr58: ; preds = %after_check57, %voiderr54
store ptr @.str.19, ptr %taddr61, align 8
%26 = insertvalue %variant undef, ptr %taddr61, 0
%27 = insertvalue %variant %26, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%28 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 0
store %variant %27, ptr %28, align 16
store ptr @.str.26, ptr %taddr18, align 8
%29 = insertvalue %variant undef, ptr %taddr18, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%31 = getelementptr inbounds [2 x %variant], ptr %varargslots16, i64 0, i64 1
store ptr @.str.20, ptr %taddr62, align 8
%29 = insertvalue %variant undef, ptr %taddr62, 0
%30 = insertvalue %variant %29, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%31 = getelementptr inbounds [2 x %variant], ptr %varargslots60, i64 0, i64 1
store %variant %30, ptr %31, align 16
%32 = call i64 @std_io_printfn(ptr %retparam15, ptr @.str.24, i64 6, ptr %varargslots16, i64 2)
%not_err19 = icmp eq i64 %32, 0
br i1 %not_err19, label %after_check20, label %voiderr21
%32 = call i64 @std_io_printfn(ptr %retparam59, ptr @.str.18, i64 6, ptr %varargslots60, i64 2)
%not_err63 = icmp eq i64 %32, 0
br i1 %not_err63, label %after_check64, label %voiderr65
after_check20: ; preds = %voiderr14
br label %voiderr21
after_check64: ; preds = %voiderr58
br label %voiderr65
voiderr21: ; preds = %after_check20, %voiderr14
store ptr @.str.28, ptr %taddr24, align 8
%33 = insertvalue %variant undef, ptr %taddr24, 0
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%35 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 0
voiderr65: ; preds = %after_check64, %voiderr58
store ptr @.str.22, ptr %taddr68, align 8
%33 = insertvalue %variant undef, ptr %taddr68, 0
%34 = insertvalue %variant %33, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%35 = getelementptr inbounds [2 x %variant], ptr %varargslots67, i64 0, i64 0
store %variant %34, ptr %35, align 16
store ptr @.str.29, ptr %taddr25, align 8
%36 = insertvalue %variant undef, ptr %taddr25, 0
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
%38 = getelementptr inbounds [2 x %variant], ptr %varargslots23, i64 0, i64 1
store ptr @.str.23, ptr %taddr69, align 8
%36 = insertvalue %variant undef, ptr %taddr69, 0
%37 = insertvalue %variant %36, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%38 = getelementptr inbounds [2 x %variant], ptr %varargslots67, i64 0, i64 1
store %variant %37, ptr %38, align 16
%39 = call i64 @std_io_printfn(ptr %retparam22, ptr @.str.27, i64 6, ptr %varargslots23, i64 2)
%not_err26 = icmp eq i64 %39, 0
br i1 %not_err26, label %after_check27, label %voiderr28
%39 = call i64 @std_io_printfn(ptr %retparam66, ptr @.str.21, i64 6, ptr %varargslots67, i64 2)
%not_err70 = icmp eq i64 %39, 0
br i1 %not_err70, label %after_check71, label %voiderr72
after_check27: ; preds = %voiderr21
br label %voiderr28
after_check71: ; preds = %voiderr65
br label %voiderr72
voiderr28: ; preds = %after_check27, %voiderr21
store ptr @.str.31, ptr %taddr31, align 8
%40 = insertvalue %variant undef, ptr %taddr31, 0
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%42 = getelementptr inbounds [1 x %variant], ptr %varargslots30, i64 0, i64 0
voiderr72: ; preds = %after_check71, %voiderr65
store ptr @.str.25, ptr %taddr75, align 8
%40 = insertvalue %variant undef, ptr %taddr75, 0
%41 = insertvalue %variant %40, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
%42 = getelementptr inbounds [2 x %variant], ptr %varargslots74, i64 0, i64 0
store %variant %41, ptr %42, align 16
%43 = call i64 @std_io_printfn(ptr %retparam29, ptr @.str.30, i64 8, ptr %varargslots30, i64 1)
%not_err32 = icmp eq i64 %43, 0
br i1 %not_err32, label %after_check33, label %voiderr34
store ptr @.str.26, ptr %taddr76, align 8
%43 = insertvalue %variant undef, ptr %taddr76, 0
%44 = insertvalue %variant %43, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%45 = getelementptr inbounds [2 x %variant], ptr %varargslots74, i64 0, i64 1
store %variant %44, ptr %45, align 16
%46 = call i64 @std_io_printfn(ptr %retparam73, ptr @.str.24, i64 6, ptr %varargslots74, i64 2)
%not_err77 = icmp eq i64 %46, 0
br i1 %not_err77, label %after_check78, label %voiderr79
after_check33: ; preds = %voiderr28
br label %voiderr34
after_check78: ; preds = %voiderr72
br label %voiderr79
voiderr34: ; preds = %after_check33, %voiderr28
store ptr @.str.33, ptr %taddr37, align 8
%44 = insertvalue %variant undef, ptr %taddr37, 0
%45 = insertvalue %variant %44, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%46 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 0
store %variant %45, ptr %46, align 16
store ptr @.str.34, ptr %taddr38, align 8
%47 = insertvalue %variant undef, ptr %taddr38, 0
%48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%49 = getelementptr inbounds [2 x %variant], ptr %varargslots36, i64 0, i64 1
voiderr79: ; preds = %after_check78, %voiderr72
store ptr @.str.28, ptr %taddr82, align 8
%47 = insertvalue %variant undef, ptr %taddr82, 0
%48 = insertvalue %variant %47, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%49 = getelementptr inbounds [2 x %variant], ptr %varargslots81, i64 0, i64 0
store %variant %48, ptr %49, align 16
%50 = call i64 @std_io_printfn(ptr %retparam35, ptr @.str.32, i64 6, ptr %varargslots36, i64 2)
%not_err39 = icmp eq i64 %50, 0
br i1 %not_err39, label %after_check40, label %voiderr41
store ptr @.str.29, ptr %taddr83, align 8
%50 = insertvalue %variant undef, ptr %taddr83, 0
%51 = insertvalue %variant %50, i64 ptrtoint (ptr @"ct$p$a6$char" to i64), 1
%52 = getelementptr inbounds [2 x %variant], ptr %varargslots81, i64 0, i64 1
store %variant %51, ptr %52, align 16
%53 = call i64 @std_io_printfn(ptr %retparam80, ptr @.str.27, i64 6, ptr %varargslots81, i64 2)
%not_err84 = icmp eq i64 %53, 0
br i1 %not_err84, label %after_check85, label %voiderr86
after_check40: ; preds = %voiderr34
br label %voiderr41
after_check85: ; preds = %voiderr79
br label %voiderr86
voiderr41: ; preds = %after_check40, %voiderr34
store ptr @.str.36, ptr %taddr44, align 8
%51 = insertvalue %variant undef, ptr %taddr44, 0
%52 = insertvalue %variant %51, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%53 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 0
store %variant %52, ptr %53, align 16
store ptr @.str.37, ptr %taddr45, align 8
%54 = insertvalue %variant undef, ptr %taddr45, 0
%55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%56 = getelementptr inbounds [2 x %variant], ptr %varargslots43, i64 0, i64 1
voiderr86: ; preds = %after_check85, %voiderr79
store ptr @.str.31, ptr %taddr89, align 8
%54 = insertvalue %variant undef, ptr %taddr89, 0
%55 = insertvalue %variant %54, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%56 = getelementptr inbounds [1 x %variant], ptr %varargslots88, i64 0, i64 0
store %variant %55, ptr %56, align 16
%57 = call i64 @std_io_printfn(ptr %retparam42, ptr @.str.35, i64 6, ptr %varargslots43, i64 2)
%not_err46 = icmp eq i64 %57, 0
br i1 %not_err46, label %after_check47, label %voiderr48
%57 = call i64 @std_io_printfn(ptr %retparam87, ptr @.str.30, i64 8, ptr %varargslots88, i64 1)
%not_err90 = icmp eq i64 %57, 0
br i1 %not_err90, label %after_check91, label %voiderr92
after_check47: ; preds = %voiderr41
br label %voiderr48
after_check91: ; preds = %voiderr86
br label %voiderr92
voiderr48: ; preds = %after_check47, %voiderr41
store ptr @.str.39, ptr %taddr51, align 8
%58 = insertvalue %variant undef, ptr %taddr51, 0
%59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
%60 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 0
voiderr92: ; preds = %after_check91, %voiderr86
store ptr @.str.33, ptr %taddr95, align 8
%58 = insertvalue %variant undef, ptr %taddr95, 0
%59 = insertvalue %variant %58, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%60 = getelementptr inbounds [2 x %variant], ptr %varargslots94, i64 0, i64 0
store %variant %59, ptr %60, align 16
store ptr @.str.40, ptr %taddr52, align 8
%61 = insertvalue %variant undef, ptr %taddr52, 0
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%63 = getelementptr inbounds [2 x %variant], ptr %varargslots50, i64 0, i64 1
store ptr @.str.34, ptr %taddr96, align 8
%61 = insertvalue %variant undef, ptr %taddr96, 0
%62 = insertvalue %variant %61, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%63 = getelementptr inbounds [2 x %variant], ptr %varargslots94, i64 0, i64 1
store %variant %62, ptr %63, align 16
%64 = call i64 @std_io_printfn(ptr %retparam49, ptr @.str.38, i64 6, ptr %varargslots50, i64 2)
%not_err53 = icmp eq i64 %64, 0
br i1 %not_err53, label %after_check54, label %voiderr55
%64 = call i64 @std_io_printfn(ptr %retparam93, ptr @.str.32, i64 6, ptr %varargslots94, i64 2)
%not_err97 = icmp eq i64 %64, 0
br i1 %not_err97, label %after_check98, label %voiderr99
after_check54: ; preds = %voiderr48
br label %voiderr55
after_check98: ; preds = %voiderr92
br label %voiderr99
voiderr55: ; preds = %after_check54, %voiderr48
store ptr @.str.42, ptr %taddr58, align 8
%65 = insertvalue %variant undef, ptr %taddr58, 0
%66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%67 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 0
voiderr99: ; preds = %after_check98, %voiderr92
store ptr @.str.36, ptr %taddr102, align 8
%65 = insertvalue %variant undef, ptr %taddr102, 0
%66 = insertvalue %variant %65, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%67 = getelementptr inbounds [2 x %variant], ptr %varargslots101, i64 0, i64 0
store %variant %66, ptr %67, align 16
store ptr @.str.43, ptr %taddr59, align 8
%68 = insertvalue %variant undef, ptr %taddr59, 0
%69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%70 = getelementptr inbounds [2 x %variant], ptr %varargslots57, i64 0, i64 1
store ptr @.str.37, ptr %taddr103, align 8
%68 = insertvalue %variant undef, ptr %taddr103, 0
%69 = insertvalue %variant %68, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%70 = getelementptr inbounds [2 x %variant], ptr %varargslots101, i64 0, i64 1
store %variant %69, ptr %70, align 16
%71 = call i64 @std_io_printfn(ptr %retparam56, ptr @.str.41, i64 6, ptr %varargslots57, i64 2)
%not_err60 = icmp eq i64 %71, 0
br i1 %not_err60, label %after_check61, label %voiderr62
%71 = call i64 @std_io_printfn(ptr %retparam100, ptr @.str.35, i64 6, ptr %varargslots101, i64 2)
%not_err104 = icmp eq i64 %71, 0
br i1 %not_err104, label %after_check105, label %voiderr106
after_check61: ; preds = %voiderr55
br label %voiderr62
after_check105: ; preds = %voiderr99
br label %voiderr106
voiderr62: ; preds = %after_check61, %voiderr55
store ptr @.str.45, ptr %taddr65, align 8
%72 = insertvalue %variant undef, ptr %taddr65, 0
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%74 = getelementptr inbounds [1 x %variant], ptr %varargslots64, i64 0, i64 0
voiderr106: ; preds = %after_check105, %voiderr99
store ptr @.str.39, ptr %taddr109, align 8
%72 = insertvalue %variant undef, ptr %taddr109, 0
%73 = insertvalue %variant %72, i64 ptrtoint (ptr @"ct$p$a0$char" to i64), 1
%74 = getelementptr inbounds [2 x %variant], ptr %varargslots108, i64 0, i64 0
store %variant %73, ptr %74, align 16
%75 = call i64 @std_io_printfn(ptr %retparam63, ptr @.str.44, i64 8, ptr %varargslots64, i64 1)
%not_err66 = icmp eq i64 %75, 0
br i1 %not_err66, label %after_check67, label %voiderr68
store ptr @.str.40, ptr %taddr110, align 8
%75 = insertvalue %variant undef, ptr %taddr110, 0
%76 = insertvalue %variant %75, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%77 = getelementptr inbounds [2 x %variant], ptr %varargslots108, i64 0, i64 1
store %variant %76, ptr %77, align 16
%78 = call i64 @std_io_printfn(ptr %retparam107, ptr @.str.38, i64 6, ptr %varargslots108, i64 2)
%not_err111 = icmp eq i64 %78, 0
br i1 %not_err111, label %after_check112, label %voiderr113
after_check67: ; preds = %voiderr62
br label %voiderr68
after_check112: ; preds = %voiderr106
br label %voiderr113
voiderr68: ; preds = %after_check67, %voiderr62
store ptr @.str.47, ptr %taddr71, align 8
%76 = insertvalue %variant undef, ptr %taddr71, 0
%77 = insertvalue %variant %76, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%78 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 0
store %variant %77, ptr %78, align 16
store ptr @.str.48, ptr %taddr72, align 8
%79 = insertvalue %variant undef, ptr %taddr72, 0
voiderr113: ; preds = %after_check112, %voiderr106
store ptr @.str.42, ptr %taddr116, align 8
%79 = insertvalue %variant undef, ptr %taddr116, 0
%80 = insertvalue %variant %79, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%81 = getelementptr inbounds [2 x %variant], ptr %varargslots70, i64 0, i64 1
%81 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 0
store %variant %80, ptr %81, align 16
%82 = call i64 @std_io_printfn(ptr %retparam69, ptr @.str.46, i64 6, ptr %varargslots70, i64 2)
%not_err73 = icmp eq i64 %82, 0
br i1 %not_err73, label %after_check74, label %voiderr75
store ptr @.str.43, ptr %taddr117, align 8
%82 = insertvalue %variant undef, ptr %taddr117, 0
%83 = insertvalue %variant %82, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%84 = getelementptr inbounds [2 x %variant], ptr %varargslots115, i64 0, i64 1
store %variant %83, ptr %84, align 16
%85 = call i64 @std_io_printfn(ptr %retparam114, ptr @.str.41, i64 6, ptr %varargslots115, i64 2)
%not_err118 = icmp eq i64 %85, 0
br i1 %not_err118, label %after_check119, label %voiderr120
after_check74: ; preds = %voiderr68
br label %voiderr75
after_check119: ; preds = %voiderr113
br label %voiderr120
voiderr75: ; preds = %after_check74, %voiderr68
store ptr @.str.50, ptr %taddr78, align 8
%83 = insertvalue %variant undef, ptr %taddr78, 0
%84 = insertvalue %variant %83, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%85 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 0
store %variant %84, ptr %85, align 16
store ptr @.str.51, ptr %taddr79, align 8
%86 = insertvalue %variant undef, ptr %taddr79, 0
%87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%88 = getelementptr inbounds [2 x %variant], ptr %varargslots77, i64 0, i64 1
voiderr120: ; preds = %after_check119, %voiderr113
store ptr @.str.45, ptr %taddr123, align 8
%86 = insertvalue %variant undef, ptr %taddr123, 0
%87 = insertvalue %variant %86, i64 ptrtoint (ptr @"ct$p$a4$char" to i64), 1
%88 = getelementptr inbounds [1 x %variant], ptr %varargslots122, i64 0, i64 0
store %variant %87, ptr %88, align 16
%89 = call i64 @std_io_printfn(ptr %retparam76, ptr @.str.49, i64 6, ptr %varargslots77, i64 2)
%not_err80 = icmp eq i64 %89, 0
br i1 %not_err80, label %after_check81, label %voiderr82
%89 = call i64 @std_io_printfn(ptr %retparam121, ptr @.str.44, i64 8, ptr %varargslots122, i64 1)
%not_err124 = icmp eq i64 %89, 0
br i1 %not_err124, label %after_check125, label %voiderr126
after_check81: ; preds = %voiderr75
br label %voiderr82
after_check125: ; preds = %voiderr120
br label %voiderr126
voiderr82: ; preds = %after_check81, %voiderr75
voiderr126: ; preds = %after_check125, %voiderr120
store ptr @.str.47, ptr %taddr129, align 8
%90 = insertvalue %variant undef, ptr %taddr129, 0
%91 = insertvalue %variant %90, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%92 = getelementptr inbounds [2 x %variant], ptr %varargslots128, i64 0, i64 0
store %variant %91, ptr %92, align 16
store ptr @.str.48, ptr %taddr130, align 8
%93 = insertvalue %variant undef, ptr %taddr130, 0
%94 = insertvalue %variant %93, i64 ptrtoint (ptr @"ct$p$a3$char" to i64), 1
%95 = getelementptr inbounds [2 x %variant], ptr %varargslots128, i64 0, i64 1
store %variant %94, ptr %95, align 16
%96 = call i64 @std_io_printfn(ptr %retparam127, ptr @.str.46, i64 6, ptr %varargslots128, i64 2)
%not_err131 = icmp eq i64 %96, 0
br i1 %not_err131, label %after_check132, label %voiderr133
after_check132: ; preds = %voiderr126
br label %voiderr133
voiderr133: ; preds = %after_check132, %voiderr126
store ptr @.str.50, ptr %taddr136, align 8
%97 = insertvalue %variant undef, ptr %taddr136, 0
%98 = insertvalue %variant %97, i64 ptrtoint (ptr @"ct$p$a1$char" to i64), 1
%99 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 0
store %variant %98, ptr %99, align 16
store ptr @.str.51, ptr %taddr137, align 8
%100 = insertvalue %variant undef, ptr %taddr137, 0
%101 = insertvalue %variant %100, i64 ptrtoint (ptr @"ct$p$a5$char" to i64), 1
%102 = getelementptr inbounds [2 x %variant], ptr %varargslots135, i64 0, i64 1
store %variant %101, ptr %102, align 16
%103 = call i64 @std_io_printfn(ptr %retparam134, ptr @.str.49, i64 6, ptr %varargslots135, i64 2)
%not_err138 = icmp eq i64 %103, 0
br i1 %not_err138, label %after_check139, label %voiderr140
after_check139: ; preds = %voiderr133
br label %voiderr140
voiderr140: ; preds = %after_check139, %voiderr133
ret void
}

18
test/test_suite/compile_time/ct_switch_more_checks.c3
View File

@@ -6,9 +6,9 @@ fn void foo()
int a;
$switch ($typeof(a)):
$case int..float: // #error: $case ranges are only allowed for floats
io::println("Hello");
io::printn("Hello");
$default:
io::println("World");
io::printn("World");
$endswitch;
}
@@ -17,9 +17,9 @@ fn void foo2()
int a;
$switch ($typeof(a)):
$case true..false: // #error: $case ranges are only allowed
io::println("Hello");
io::printn("Hello");
$default:
io::println("World");
io::printn("World");
$endswitch;
}
@@ -28,9 +28,9 @@ fn void foo3()
int a;
$switch ({ 1, 3 }): // #error: Only types, strings, integers, floats and booleans
$case 1:
io::println("Hello");
io::printn("Hello");
$default:
io::println("World");
io::printn("World");
$endswitch;
}
@@ -39,10 +39,10 @@ fn void main()
int a;
$switch ("abc"):
$case "cde":
io::println("!!!");
io::printn("!!!");
$case "abc":
io::println("Hello");
io::printn("Hello");
$default:
io::println("World");
io::printn("World");
$endswitch;
}

81
test/test_suite/errors/general_error_regression.c3t
View File

@@ -29,17 +29,17 @@ enum MyEnum
fn void Foo.hello(Foo *f)
{
io::println("Hello from Foo");
io::printn("Hello from Foo");
}
fn void Bar.hello(Bar *b)
{
io::println("Hello from Bar");
io::printn("Hello from Bar");
}
fn void MyEnum.hello(MyEnum *myenum)
{
io::println("Hello from MyEnum");
io::printn("Hello from MyEnum");
}
fn void main()
{
@@ -74,19 +74,88 @@ fn void main()
define void @foo_Foo_hello(ptr %0) #0 {
entry:
%1 = call i32 @std_io_println(ptr @.str.12) #1
%x = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store ptr @.str.12, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%1 = call ptr @std_io_stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %x, align 8
%3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
%not_err = icmp eq i64 %3, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %entry
store i64 %3, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %entry
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %noerr_block
ret void
}
define void @foo_Bar_hello(ptr %0) #0 {
entry:
%1 = call i32 @std_io_println(ptr @.str.13) #1
%x = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store ptr @.str.13, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%1 = call ptr @std_io_stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %x, align 8
%3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 14)
%not_err = icmp eq i64 %3, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %entry
store i64 %3, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %entry
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %noerr_block
ret void
}
define void @foo_MyEnum_hello(ptr %0) #0 {
entry:
%1 = call i32 @std_io_println(ptr @.str.14) #1
%x = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
store ptr @.str.14, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%1 = call ptr @std_io_stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %x, align 8
%3 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %2, i64 17)
%not_err = icmp eq i64 %3, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %entry
store i64 %3, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %entry
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %noerr_block
ret void
}

208
test/test_suite/errors/or_and_rethrow.c3t
View File

@@ -4,7 +4,7 @@ import std::io;
fault Foo { ABC }
fn void blurb() { io::println("Blurb");}
fn void blurb() { io::printn("Blurb");}
macro int! tester()
{
@@ -14,19 +14,19 @@ macro int! tester()
fn void! test(int x)
{
io::printfn("test(%d)", x);
if (x || (tester()?)) io::println("Ok1");
io::println("Test next");
if (tester()? || x) io::println("Ok?");
io::println("Test ok");
if (x || (tester()?)) io::printn("Ok1");
io::printn("Test next");
if (tester()? || x) io::printn("Ok?");
io::printn("Test ok");
}
fn void! test2(int x)
{
io::printfn("test2(%d)", x);
if (x && (tester()?)) io::println("Ok1");
io::println("Test next");
if ((tester()?) && x) io::println("Ok?");
io::println("Test ok");
if (x && (tester()?)) io::printn("Ok1");
io::printn("Test next");
if ((tester()?) && x) io::printn("Ok?");
io::printn("Test ok");
}
fn void main()
@@ -46,8 +46,24 @@ entry:
%taddr = alloca i32, align 4
%error_var = alloca i64, align 8
%blockret = alloca i32, align 4
%x = alloca ptr, align 8
%error_var1 = alloca i64, align 8
%blockret2 = alloca i32, align 4
%retparam2 = alloca i64, align 8
%result = alloca %File, align 8
%x6 = alloca ptr, align 8
%error_var7 = alloca i64, align 8
%retparam8 = alloca i64, align 8
%result9 = alloca %File, align 8
%error_var15 = alloca i64, align 8
%blockret16 = alloca i32, align 4
%x21 = alloca ptr, align 8
%error_var22 = alloca i64, align 8
%retparam23 = alloca i64, align 8
%result24 = alloca %File, align 8
%x31 = alloca ptr, align 8
%error_var32 = alloca i64, align 8
%retparam33 = alloca i64, align 8
%result34 = alloca %File, align 8
%reterr = alloca i64, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
@@ -81,24 +97,104 @@ or.phi: ; preds = %voiderr
br label %if.then
if.then: ; preds = %or.phi
%6 = call i32 @std_io_println(ptr @.str.2) #1
store ptr @.str.2, ptr %x, align 8
store i64 0, ptr %error_var1, align 8
%6 = call ptr @std_io_stdout()
store ptr %6, ptr %result, align 8
%7 = load ptr, ptr %x, align 8
%8 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result, ptr %7, i64 3)
%not_err3 = icmp eq i64 %8, 0
br i1 %not_err3, label %after_check4, label %assign_optional
assign_optional: ; preds = %if.then
store i64 %8, ptr %error_var1, align 8
br label %noerr_block
after_check4: ; preds = %if.then
br label %noerr_block
noerr_block: ; preds = %after_check4, %assign_optional
br label %voiderr5
voiderr5: ; preds = %noerr_block
br label %if.exit
if.exit: ; preds = %if.then
%7 = call i32 @std_io_println(ptr @.str.3) #1
store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var1, align 8
br label %opt_block_cleanup3
if.exit: ; preds = %voiderr5
store ptr @.str.3, ptr %x6, align 8
store i64 0, ptr %error_var7, align 8
%9 = call ptr @std_io_stdout()
store ptr %9, ptr %result9, align 8
%10 = load ptr, ptr %x6, align 8
%11 = call i64 @std_io_File_printn(ptr %retparam8, ptr %result9, ptr %10, i64 9)
%not_err10 = icmp eq i64 %11, 0
br i1 %not_err10, label %after_check12, label %assign_optional11
opt_block_cleanup3: ; preds = %if.exit
assign_optional11: ; preds = %if.exit
store i64 %11, ptr %error_var7, align 8
br label %noerr_block13
after_check12: ; preds = %if.exit
br label %noerr_block13
noerr_block13: ; preds = %after_check12, %assign_optional11
br label %voiderr14
voiderr14: ; preds = %noerr_block13
store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var15, align 8
br label %opt_block_cleanup17
opt_block_cleanup17: ; preds = %voiderr14
call void @foo_blurb()
br label %guard_block4
br label %guard_block18
guard_block4: ; preds = %opt_block_cleanup3
%8 = load i64, ptr %error_var1, align 8
ret i64 %8
guard_block18: ; preds = %opt_block_cleanup17
%12 = load i64, ptr %error_var15, align 8
ret i64 %12
if.exit6: ; No predecessors!
%9 = call i32 @std_io_println(ptr @.str.5) #1
if.then20: ; No predecessors!
store ptr @.str.4, ptr %x21, align 8
store i64 0, ptr %error_var22, align 8
%13 = call ptr @std_io_stdout()
store ptr %13, ptr %result24, align 8
%14 = load ptr, ptr %x21, align 8
%15 = call i64 @std_io_File_printn(ptr %retparam23, ptr %result24, ptr %14, i64 3)
%not_err25 = icmp eq i64 %15, 0
br i1 %not_err25, label %after_check27, label %assign_optional26
assign_optional26: ; preds = %if.then20
store i64 %15, ptr %error_var22, align 8
br label %noerr_block28
after_check27: ; preds = %if.then20
br label %noerr_block28
noerr_block28: ; preds = %after_check27, %assign_optional26
br label %voiderr29
voiderr29: ; preds = %noerr_block28
br label %if.exit30
if.exit30: ; preds = %voiderr29
store ptr @.str.5, ptr %x31, align 8
store i64 0, ptr %error_var32, align 8
%16 = call ptr @std_io_stdout()
store ptr %16, ptr %result34, align 8
%17 = load ptr, ptr %x31, align 8
%18 = call i64 @std_io_File_printn(ptr %retparam33, ptr %result34, ptr %17, i64 7)
%not_err35 = icmp eq i64 %18, 0
br i1 %not_err35, label %after_check37, label %assign_optional36
assign_optional36: ; preds = %if.exit30
store i64 %18, ptr %error_var32, align 8
br label %noerr_block38
after_check37: ; preds = %if.exit30
br label %noerr_block38
noerr_block38: ; preds = %after_check37, %assign_optional36
br label %voiderr39
voiderr39: ; preds = %noerr_block38
ret i64 0
}
@@ -110,8 +206,16 @@ entry:
%taddr = alloca i32, align 4
%error_var = alloca i64, align 8
%blockret = alloca i32, align 4
%x = alloca ptr, align 8
%error_var1 = alloca i64, align 8
%blockret2 = alloca i32, align 4
%retparam2 = alloca i64, align 8
%result = alloca %File, align 8
%error_var6 = alloca i64, align 8
%blockret7 = alloca i32, align 4
%x12 = alloca ptr, align 8
%error_var13 = alloca i64, align 8
%retparam14 = alloca i64, align 8
%result15 = alloca %File, align 8
%reterr = alloca i64, align 8
store i32 %0, ptr %taddr, align 4
%1 = insertvalue %variant undef, ptr %taddr, 0
@@ -145,19 +249,57 @@ and.phi: ; preds = %voiderr
br label %if.exit
if.exit: ; preds = %and.phi
%6 = call i32 @std_io_println(ptr @.str.7) #1
store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var1, align 8
br label %opt_block_cleanup3
store ptr @.str.7, ptr %x, align 8
store i64 0, ptr %error_var1, align 8
%6 = call ptr @std_io_stdout()
store ptr %6, ptr %result, align 8
%7 = load ptr, ptr %x, align 8
%8 = call i64 @std_io_File_printn(ptr %retparam2, ptr %result, ptr %7, i64 9)
%not_err3 = icmp eq i64 %8, 0
br i1 %not_err3, label %after_check4, label %assign_optional
opt_block_cleanup3: ; preds = %if.exit
assign_optional: ; preds = %if.exit
store i64 %8, ptr %error_var1, align 8
br label %noerr_block
after_check4: ; preds = %if.exit
br label %noerr_block
noerr_block: ; preds = %after_check4, %assign_optional
br label %voiderr5
voiderr5: ; preds = %noerr_block
store i64 ptrtoint (ptr @"foo_Foo$ABC" to i64), ptr %error_var6, align 8
br label %opt_block_cleanup8
opt_block_cleanup8: ; preds = %voiderr5
call void @foo_blurb()
br label %guard_block4
br label %guard_block9
guard_block4: ; preds = %opt_block_cleanup3
%7 = load i64, ptr %error_var1, align 8
ret i64 %7
guard_block9: ; preds = %opt_block_cleanup8
%9 = load i64, ptr %error_var6, align 8
ret i64 %9
if.exit5: ; No predecessors!
%8 = call i32 @std_io_println(ptr @.str.8) #1
if.exit11: ; No predecessors!
store ptr @.str.8, ptr %x12, align 8
store i64 0, ptr %error_var13, align 8
%10 = call ptr @std_io_stdout()
store ptr %10, ptr %result15, align 8
%11 = load ptr, ptr %x12, align 8
%12 = call i64 @std_io_File_printn(ptr %retparam14, ptr %result15, ptr %11, i64 7)
%not_err16 = icmp eq i64 %12, 0
br i1 %not_err16, label %after_check18, label %assign_optional17
assign_optional17: ; preds = %if.exit11
store i64 %12, ptr %error_var13, align 8
br label %noerr_block19
after_check18: ; preds = %if.exit11
br label %noerr_block19
noerr_block19: ; preds = %after_check18, %assign_optional17
br label %voiderr20
voiderr20: ; preds = %noerr_block19
ret i64 0
}

2
test/test_suite/expression_block/expression_block_break.c3
View File

@@ -8,6 +8,6 @@ fn int main()
{
return {| break; return 0; |}; // #error: There is no valid target for 'break', did you make a mistake
}
io::println("I didn't return.");
io::printn("I didn't return.");
return 0;
}

6
test/test_suite/expressions/call_inline.c3t
View File

@@ -4,17 +4,17 @@ import std::io;
fn void test1() @inline
{
io::println("Inline!");
io::printn("Inline!");
}
fn void test2() @noinline
{
io::println("No inline!");
io::printn("No inline!");
}
fn void test3()
{
io::println("Plain");
io::printn("Plain");
}
fn void main()

198
test/test_suite/from_docs/examples_defer.c3t
View File

@@ -4,7 +4,7 @@ import std::io;
fn void test(int x)
{
defer io::println();
defer io::printn();
defer io::print("A");
if (x == 1) return;
{
@@ -29,29 +29,197 @@ entry:
br i1 %eq, label %if.then, label %if.exit
if.then: ; preds = %entry
%1 = call i32 @std_io_print(ptr @.str)
%2 = call i32 @std_io_println(ptr @.str.1) #1
store ptr @.str, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%1 = call ptr @std_io_stdout()
store ptr %1, ptr %result, align 8
%2 = load ptr, ptr %x, align 8
%3 = call i64 @std_io_File_print(ptr %retparam, ptr %result, ptr %2, i64 1)
%not_err = icmp eq i64 %3, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %if.then
store i64 %3, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %if.then
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %noerr_block
store ptr @.str.1, ptr %x1, align 8
store i64 0, ptr %error_var2, align 8
%4 = call ptr @std_io_stdout()
store ptr %4, ptr %result4, align 8
%5 = call i64 @std_io_File_printn(ptr %retparam3, ptr %result4, ptr null, i64 0)
%not_err5 = icmp eq i64 %5, 0
br i1 %not_err5, label %after_check7, label %assign_optional6
assign_optional6: ; preds = %voiderr
store i64 %5, ptr %error_var2, align 8
br label %noerr_block8
after_check7: ; preds = %voiderr
br label %noerr_block8
noerr_block8: ; preds = %after_check7, %assign_optional6
br label %voiderr9
voiderr9: ; preds = %noerr_block8
ret void
if.exit: ; preds = %entry
%eq1 = icmp eq i32 %0, 0
br i1 %eq1, label %if.then2, label %if.exit3
%eq10 = icmp eq i32 %0, 0
br i1 %eq10, label %if.then11, label %if.exit39
if.then2: ; preds = %if.exit
%3 = call i32 @std_io_print(ptr @.str.2)
%4 = call i32 @std_io_print(ptr @.str.3)
%5 = call i32 @std_io_println(ptr @.str.4) #1
if.then11: ; preds = %if.exit
store ptr @.str.2, ptr %x12, align 8
store i64 0, ptr %error_var13, align 8
%6 = call ptr @std_io_stdout()
store ptr %6, ptr %result15, align 8
%7 = load ptr, ptr %x12, align 8
%8 = call i64 @std_io_File_print(ptr %retparam14, ptr %result15, ptr %7, i64 1)
%not_err16 = icmp eq i64 %8, 0
br i1 %not_err16, label %after_check18, label %assign_optional17
assign_optional17: ; preds = %if.then11
store i64 %8, ptr %error_var13, align 8
br label %noerr_block19
after_check18: ; preds = %if.then11
br label %noerr_block19
noerr_block19: ; preds = %after_check18, %assign_optional17
br label %voiderr20
voiderr20: ; preds = %noerr_block19
store ptr @.str.3, ptr %x21, align 8
store i64 0, ptr %error_var22, align 8
%9 = call ptr @std_io_stdout()
store ptr %9, ptr %result24, align 8
%10 = load ptr, ptr %x21, align 8
%11 = call i64 @std_io_File_print(ptr %retparam23, ptr %result24, ptr %10, i64 1)
%not_err25 = icmp eq i64 %11, 0
br i1 %not_err25, label %after_check27, label %assign_optional26
assign_optional26: ; preds = %voiderr20
store i64 %11, ptr %error_var22, align 8
br label %noerr_block28
after_check27: ; preds = %voiderr20
br label %noerr_block28
noerr_block28: ; preds = %after_check27, %assign_optional26
br label %voiderr29
voiderr29: ; preds = %noerr_block28
store ptr @.str.4, ptr %x30, align 8
store i64 0, ptr %error_var31, align 8
%12 = call ptr @std_io_stdout()
store ptr %12, ptr %result33, align 8
%13 = call i64 @std_io_File_printn(ptr %retparam32, ptr %result33, ptr null, i64 0)
%not_err34 = icmp eq i64 %13, 0
br i1 %not_err34, label %after_check36, label %assign_optional35
assign_optional35: ; preds = %voiderr29
store i64 %13, ptr %error_var31, align 8
br label %noerr_block37
after_check36: ; preds = %voiderr29
br label %noerr_block37
noerr_block37: ; preds = %after_check36, %assign_optional35
br label %voiderr38
voiderr38: ; preds = %noerr_block37
ret void
if.exit3: ; preds = %if.exit
%6 = call i32 @std_io_print(ptr @.str.5)
%7 = call i32 @std_io_print(ptr @.str.6)
%8 = call i32 @std_io_print(ptr @.str.7)
%9 = call i32 @std_io_println(ptr @.str.8) #1
if.exit39: ; preds = %if.exit
store ptr @.str.5, ptr %x40, align 8
store i64 0, ptr %error_var41, align 8
%14 = call ptr @std_io_stdout()
store ptr %14, ptr %result43, align 8
%15 = load ptr, ptr %x40, align 8
%16 = call i64 @std_io_File_print(ptr %retparam42, ptr %result43, ptr %15, i64 1)
%not_err44 = icmp eq i64 %16, 0
br i1 %not_err44, label %after_check46, label %assign_optional45
assign_optional45: ; preds = %if.exit39
store i64 %16, ptr %error_var41, align 8
br label %noerr_block47
after_check46: ; preds = %if.exit39
br label %noerr_block47
noerr_block47: ; preds = %after_check46, %assign_optional45
br label %voiderr48
voiderr48: ; preds = %noerr_block47
store ptr @.str.6, ptr %x49, align 8
store i64 0, ptr %error_var50, align 8
%17 = call ptr @std_io_stdout()
store ptr %17, ptr %result52, align 8
%18 = load ptr, ptr %x49, align 8
%19 = call i64 @std_io_File_print(ptr %retparam51, ptr %result52, ptr %18, i64 1)
%not_err53 = icmp eq i64 %19, 0
br i1 %not_err53, label %after_check55, label %assign_optional54
assign_optional54: ; preds = %voiderr48
store i64 %19, ptr %error_var50, align 8
br label %noerr_block56
after_check55: ; preds = %voiderr48
br label %noerr_block56
noerr_block56: ; preds = %after_check55, %assign_optional54
br label %voiderr57
voiderr57: ; preds = %noerr_block56
store ptr @.str.7, ptr %x58, align 8
store i64 0, ptr %error_var59, align 8
%20 = call ptr @std_io_stdout()
store ptr %20, ptr %result61, align 8
%21 = load ptr, ptr %x58, align 8
%22 = call i64 @std_io_File_print(ptr %retparam60, ptr %result61, ptr %21, i64 1)
%not_err62 = icmp eq i64 %22, 0
br i1 %not_err62, label %after_check64, label %assign_optional63
assign_optional63: ; preds = %voiderr57
store i64 %22, ptr %error_var59, align 8
br label %noerr_block65
after_check64: ; preds = %voiderr57
br label %noerr_block65
noerr_block65: ; preds = %after_check64, %assign_optional63
br label %voiderr66
voiderr66: ; preds = %noerr_block65
store ptr @.str.8, ptr %x67, align 8
store i64 0, ptr %error_var68, align 8
%23 = call ptr @std_io_stdout()
store ptr %23, ptr %result70, align 8
%24 = call i64 @std_io_File_printn(ptr %retparam69, ptr %result70, ptr null, i64 0)
%not_err71 = icmp eq i64 %24, 0
br i1 %not_err71, label %after_check73, label %assign_optional72
assign_optional72: ; preds = %voiderr66
store i64 %24, ptr %error_var68, align 8
br label %noerr_block74
after_check73: ; preds = %voiderr66
br label %noerr_block74
noerr_block74: ; preds = %after_check73, %assign_optional72
br label %voiderr75
voiderr75: ; preds = %noerr_block74
ret void
}
; Function Attrs: nounwind
define void @defer1_main() #0 {
entry:
call void @defer1_test(i32 1)

342
test/test_suite/from_docs/examples_forswitch.c3t
View File

@@ -31,10 +31,10 @@ fn void demo_enum(Height h)
{
case LOW:
case MEDIUM:
io::println("Not high");
io::printn("Not high");
// Implicit break.
case HIGH:
io::println("High");
io::printn("High");
}
// This also works
@@ -42,10 +42,10 @@ fn void demo_enum(Height h)
{
case LOW:
case MEDIUM:
io::println("Not high");
io::printn("Not high");
// Implicit break.
case Height.HIGH:
io::println("High");
io::printn("High");
}
// Completely empty cases are not allowed.
@@ -54,7 +54,7 @@ fn void demo_enum(Height h)
case LOW:
break; // Explicit break required, since switches can't be empty.
case MEDIUM:
io::println("Medium");
io::printn("Medium");
case HIGH:
break;
}
@@ -76,15 +76,15 @@ fn void demo_enum(Height h)
{
case LOW:
int a = 1;
io::println("A");
io::printn("A");
nextcase;
case MEDIUM:
int a = 2;
io::println("B");
io::printn("B");
nextcase;
case HIGH:
// a is not defined here
io::println("C");
io::printn("C");
}
}
/* #expect: examples.ll
@@ -121,12 +121,44 @@ unreachable_block: ; No predecessors!
define void @examples_demo_enum(i32 %0) #0 {
entry:
%switch = alloca i32, align 4
%switch2 = alloca i32, align 4
%switch7 = alloca i32, align 4
%switch13 = alloca i32, align 4
%switch17 = alloca i32, align 4
%x = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
%x2 = alloca ptr, align 8
%error_var3 = alloca i64, align 8
%retparam4 = alloca i64, align 8
%result5 = alloca %File, align 8
%switch11 = alloca i32, align 4
%x14 = alloca ptr, align 8
%error_var15 = alloca i64, align 8
%retparam16 = alloca i64, align 8
%result17 = alloca %File, align 8
%x24 = alloca ptr, align 8
%error_var25 = alloca i64, align 8
%retparam26 = alloca i64, align 8
%result27 = alloca %File, align 8
%switch34 = alloca i32, align 4
%x38 = alloca ptr, align 8
%error_var39 = alloca i64, align 8
%retparam40 = alloca i64, align 8
%result41 = alloca %File, align 8
%switch49 = alloca i32, align 4
%switch53 = alloca i32, align 4
%a = alloca i32, align 4
%a21 = alloca i32, align 4
%x56 = alloca ptr, align 8
%error_var57 = alloca i64, align 8
%retparam58 = alloca i64, align 8
%result59 = alloca %File, align 8
%a66 = alloca i32, align 4
%x67 = alloca ptr, align 8
%error_var68 = alloca i64, align 8
%retparam69 = alloca i64, align 8
%result70 = alloca %File, align 8
%x77 = alloca ptr, align 8
%error_var78 = alloca i64, align 8
%retparam79 = alloca i64, align 8
%result80 = alloca %File, align 8
store i32 %0, ptr %switch, align 4
br label %switch.entry
@@ -139,99 +171,251 @@ switch.entry: ; preds = %entry
]
switch.case: ; preds = %switch.entry, %switch.entry
%2 = call i32 @std_io_println(ptr @.str.1) #1
store ptr @.str.1, ptr %x, align 8
store i64 0, ptr %error_var, align 8
%2 = call ptr @std_io_stdout()
store ptr %2, ptr %result, align 8
%3 = load ptr, ptr %x, align 8
%4 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %3, i64 8)
%not_err = icmp eq i64 %4, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %switch.case
store i64 %4, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %switch.case
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %noerr_block
br label %switch.exit
switch.case1: ; preds = %switch.entry
%3 = call i32 @std_io_println(ptr @.str.2) #1
store ptr @.str.2, ptr %x2, align 8
store i64 0, ptr %error_var3, align 8
%5 = call ptr @std_io_stdout()
store ptr %5, ptr %result5, align 8
%6 = load ptr, ptr %x2, align 8
%7 = call i64 @std_io_File_printn(ptr %retparam4, ptr %result5, ptr %6, i64 4)
%not_err6 = icmp eq i64 %7, 0
br i1 %not_err6, label %after_check8, label %assign_optional7
assign_optional7: ; preds = %switch.case1
store i64 %7, ptr %error_var3, align 8
br label %noerr_block9
after_check8: ; preds = %switch.case1
br label %noerr_block9
noerr_block9: ; preds = %after_check8, %assign_optional7
br label %voiderr10
voiderr10: ; preds = %noerr_block9
br label %switch.exit
switch.exit: ; preds = %switch.case1, %switch.case, %switch.entry
store i32 %0, ptr %switch2, align 4
br label %switch.entry3
switch.exit: ; preds = %voiderr10, %voiderr, %switch.entry
store i32 %0, ptr %switch11, align 4
br label %switch.entry12
switch.entry3: ; preds = %switch.exit
%4 = load i32, ptr %switch2, align 4
switch i32 %4, label %switch.exit6 [
i32 0, label %switch.case4
i32 1, label %switch.case4
i32 2, label %switch.case5
switch.entry12: ; preds = %switch.exit
%8 = load i32, ptr %switch11, align 4
switch i32 %8, label %switch.exit33 [
i32 0, label %switch.case13
i32 1, label %switch.case13
i32 2, label %switch.case23
]
switch.case4: ; preds = %switch.entry3, %switch.entry3
%5 = call i32 @std_io_println(ptr @.str.3) #1
br label %switch.exit6
switch.case13: ; preds = %switch.entry12, %switch.entry12
store ptr @.str.3, ptr %x14, align 8
store i64 0, ptr %error_var15, align 8
%9 = call ptr @std_io_stdout()
store ptr %9, ptr %result17, align 8
%10 = load ptr, ptr %x14, align 8
%11 = call i64 @std_io_File_printn(ptr %retparam16, ptr %result17, ptr %10, i64 8)
%not_err18 = icmp eq i64 %11, 0
br i1 %not_err18, label %after_check20, label %assign_optional19
switch.case5: ; preds = %switch.entry3
%6 = call i32 @std_io_println(ptr @.str.4) #1
br label %switch.exit6
assign_optional19: ; preds = %switch.case13
store i64 %11, ptr %error_var15, align 8
br label %noerr_block21
switch.exit6: ; preds = %switch.case5, %switch.case4, %switch.entry3
store i32 %0, ptr %switch7, align 4
br label %switch.entry8
after_check20: ; preds = %switch.case13
br label %noerr_block21
switch.entry8: ; preds = %switch.exit6
%7 = load i32, ptr %switch7, align 4
switch i32 %7, label %switch.exit12 [
i32 0, label %switch.case9
i32 1, label %switch.case10
i32 2, label %switch.case11
noerr_block21: ; preds = %after_check20, %assign_optional19
br label %voiderr22
voiderr22: ; preds = %noerr_block21
br label %switch.exit33
switch.case23: ; preds = %switch.entry12
store ptr @.str.4, ptr %x24, align 8
store i64 0, ptr %error_var25, align 8
%12 = call ptr @std_io_stdout()
store ptr %12, ptr %result27, align 8
%13 = load ptr, ptr %x24, align 8
%14 = call i64 @std_io_File_printn(ptr %retparam26, ptr %result27, ptr %13, i64 4)
%not_err28 = icmp eq i64 %14, 0
br i1 %not_err28, label %after_check30, label %assign_optional29
assign_optional29: ; preds = %switch.case23
store i64 %14, ptr %error_var25, align 8
br label %noerr_block31
after_check30: ; preds = %switch.case23
br label %noerr_block31
noerr_block31: ; preds = %after_check30, %assign_optional29
br label %voiderr32
voiderr32: ; preds = %noerr_block31
br label %switch.exit33
switch.exit33: ; preds = %voiderr32, %voiderr22, %switch.entry12
store i32 %0, ptr %switch34, align 4
br label %switch.entry35
switch.entry35: ; preds = %switch.exit33
%15 = load i32, ptr %switch34, align 4
switch i32 %15, label %switch.exit48 [
i32 0, label %switch.case36
i32 1, label %switch.case37
i32 2, label %switch.case47
]
switch.case9: ; preds = %switch.entry8
br label %switch.exit12
switch.case36: ; preds = %switch.entry35
br label %switch.exit48
switch.case10: ; preds = %switch.entry8
%8 = call i32 @std_io_println(ptr @.str.5) #1
br label %switch.exit12
switch.case37: ; preds = %switch.entry35
store ptr @.str.5, ptr %x38, align 8
store i64 0, ptr %error_var39, align 8
%16 = call ptr @std_io_stdout()
store ptr %16, ptr %result41, align 8
%17 = load ptr, ptr %x38, align 8
%18 = call i64 @std_io_File_printn(ptr %retparam40, ptr %result41, ptr %17, i64 6)
%not_err42 = icmp eq i64 %18, 0
br i1 %not_err42, label %after_check44, label %assign_optional43
switch.case11: ; preds = %switch.entry8
br label %switch.exit12
assign_optional43: ; preds = %switch.case37
store i64 %18, ptr %error_var39, align 8
br label %noerr_block45
switch.exit12: ; preds = %switch.case11, %switch.case10, %switch.case9, %switch.entry8
store i32 %0, ptr %switch13, align 4
br label %switch.entry14
after_check44: ; preds = %switch.case37
br label %noerr_block45
switch.entry14: ; preds = %switch.exit12
%9 = load i32, ptr %switch13, align 4
switch i32 %9, label %switch.default [
i32 0, label %switch.case15
i32 1, label %switch.case15
i32 2, label %switch.case15
noerr_block45: ; preds = %after_check44, %assign_optional43
br label %voiderr46
voiderr46: ; preds = %noerr_block45
br label %switch.exit48
switch.case47: ; preds = %switch.entry35
br label %switch.exit48
switch.exit48: ; preds = %switch.case47, %voiderr46, %switch.case36, %switch.entry35
store i32 %0, ptr %switch49, align 4
br label %switch.entry50
switch.entry50: ; preds = %switch.exit48
%19 = load i32, ptr %switch49, align 4
switch i32 %19, label %switch.default [
i32 0, label %switch.case51
i32 1, label %switch.case51
i32 2, label %switch.case51
]
switch.case15: ; preds = %switch.entry14, %switch.entry14, %switch.entry14
br label %switch.exit16
switch.case51: ; preds = %switch.entry50, %switch.entry50, %switch.entry50
br label %switch.exit52
switch.default: ; preds = %switch.entry14
br label %switch.exit16
switch.default: ; preds = %switch.entry50
br label %switch.exit52
switch.exit16: ; preds = %switch.default, %switch.case15
store i32 %0, ptr %switch17, align 4
br label %switch.entry18
switch.exit52: ; preds = %switch.default, %switch.case51
store i32 %0, ptr %switch53, align 4
br label %switch.entry54
switch.entry18: ; preds = %switch.exit16
%10 = load i32, ptr %switch17, align 4
switch i32 %10, label %switch.exit23 [
i32 0, label %switch.case19
i32 1, label %switch.case20
i32 2, label %switch.case22
switch.entry54: ; preds = %switch.exit52
%20 = load i32, ptr %switch53, align 4
switch i32 %20, label %switch.exit86 [
i32 0, label %switch.case55
i32 1, label %switch.case65
i32 2, label %switch.case76
]
switch.case19: ; preds = %switch.entry18
switch.case55: ; preds = %switch.entry54
store i32 1, ptr %a, align 4
%11 = call i32 @std_io_println(ptr @.str.6) #1
br label %switch.case20
store ptr @.str.6, ptr %x56, align 8
store i64 0, ptr %error_var57, align 8
%21 = call ptr @std_io_stdout()
store ptr %21, ptr %result59, align 8
%22 = load ptr, ptr %x56, align 8
%23 = call i64 @std_io_File_printn(ptr %retparam58, ptr %result59, ptr %22, i64 1)
%not_err60 = icmp eq i64 %23, 0
br i1 %not_err60, label %after_check62, label %assign_optional61
switch.case20: ; preds = %switch.entry18, %switch.case19
store i32 2, ptr %a21, align 4
%12 = call i32 @std_io_println(ptr @.str.7) #1
br label %switch.case22
assign_optional61: ; preds = %switch.case55
store i64 %23, ptr %error_var57, align 8
br label %noerr_block63
switch.case22: ; preds = %switch.entry18, %switch.case20
%13 = call i32 @std_io_println(ptr @.str.8) #1
br label %switch.exit23
after_check62: ; preds = %switch.case55
br label %noerr_block63
switch.exit23: ; preds = %switch.case22, %switch.entry18
noerr_block63: ; preds = %after_check62, %assign_optional61
br label %voiderr64
voiderr64: ; preds = %noerr_block63
br label %switch.case65
switch.case65: ; preds = %switch.entry54, %voiderr64
store i32 2, ptr %a66, align 4
store ptr @.str.7, ptr %x67, align 8
store i64 0, ptr %error_var68, align 8
%24 = call ptr @std_io_stdout()
store ptr %24, ptr %result70, align 8
%25 = load ptr, ptr %x67, align 8
%26 = call i64 @std_io_File_printn(ptr %retparam69, ptr %result70, ptr %25, i64 1)
%not_err71 = icmp eq i64 %26, 0
br i1 %not_err71, label %after_check73, label %assign_optional72
assign_optional72: ; preds = %switch.case65
store i64 %26, ptr %error_var68, align 8
br label %noerr_block74
after_check73: ; preds = %switch.case65
br label %noerr_block74
noerr_block74: ; preds = %after_check73, %assign_optional72
br label %voiderr75
voiderr75: ; preds = %noerr_block74
br label %switch.case76
switch.case76: ; preds = %switch.entry54, %voiderr75
store ptr @.str.8, ptr %x77, align 8
store i64 0, ptr %error_var78, align 8
%27 = call ptr @std_io_stdout()
store ptr %27, ptr %result80, align 8
%28 = load ptr, ptr %x77, align 8
%29 = call i64 @std_io_File_printn(ptr %retparam79, ptr %result80, ptr %28, i64 1)
%not_err81 = icmp eq i64 %29, 0
br i1 %not_err81, label %after_check83, label %assign_optional82
assign_optional82: ; preds = %switch.case76
store i64 %29, ptr %error_var78, align 8
br label %noerr_block84
after_check83: ; preds = %switch.case76
br label %noerr_block84
noerr_block84: ; preds = %after_check83, %assign_optional82
br label %voiderr85
voiderr85: ; preds = %noerr_block84
br label %switch.exit86
switch.exit86: ; preds = %voiderr85, %switch.entry54
ret void
}

2
test/test_suite/initialize/initialize_finalize.c3t
View File

@@ -4,7 +4,7 @@ import std::io;
fn void main()
{
io::println("Hello, world!");
io::printn("Hello, world!");
}
extern fn void puts(char*);

131
test/test_suite/initializer_lists/subarrays.c3t
View File

@@ -25,7 +25,7 @@ fn int main()
libc::printf("%d\n", arrbar[1].x);
int[] x = { 1, 2, 3 };
int* y = &&(int[3]{ 123, 234, 567 });
io::println("Start:");
io::printn("Start:");
libc::printf("X len: %d mid element %d\n", (int)(x.len), x[1]);
libc::printf("Y mid element %d\n", y[1]);
libc::printf("Fofeo second element %d\n", fofeo[1]);
@@ -34,7 +34,7 @@ fn int main()
//var $foo = { 1, 2, 3 };
bool xy = ! int[] { 1, 2, 3 };
if (!xy) io::println("Ok");
if (!xy) io::printn("Ok");
Bar b = {};
Baz z = {};
int[] sub = {};
@@ -49,7 +49,6 @@ fn int main()
%"Bar[]" = type { ptr, i64 }
%"int[]" = type { ptr, i64 }
%Baz = type { double }
@"ct$subarrays_Baz" = linkonce constant %.introspect { i8 11, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@"ct$subarrays_Bar" = linkonce constant %.introspect { i8 10, i64 8, i64 0, i64 2, [0 x i64] zeroinitializer }, align 8
@.taddr = private global [2 x %Bar] [%Bar { i32 3, i32 4 }, %Bar { i32 8, i32 9 }], align 8
@@ -73,10 +72,18 @@ entry:
%literal = alloca [3 x i32], align 4
%y = alloca ptr, align 8
%literal2 = alloca [3 x i32], align 4
%x3 = alloca ptr, align 8
%error_var = alloca i64, align 8
%retparam = alloca i64, align 8
%result = alloca %File, align 8
%ffe = alloca %Baz, align 8
%azz = alloca [1 x i32], align 4
%xy = alloca i8, align 1
%literal6 = alloca [3 x i32], align 4
%literal7 = alloca [3 x i32], align 4
%x9 = alloca ptr, align 8
%error_var10 = alloca i64, align 8
%retparam11 = alloca i64, align 8
%result12 = alloca %File, align 8
%b = alloca %Bar, align 4
%z = alloca %Baz, align 8
%sub = alloca %"int[]", align 8
@@ -106,52 +113,80 @@ entry:
%12 = getelementptr inbounds [3 x i32], ptr %literal2, i64 0, i64 2
store i32 567, ptr %12, align 4
store ptr %literal2, ptr %y, align 8
%13 = call i32 @std_io_println(ptr @.str.5) #3
%14 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
%15 = load i64, ptr %14, align 8
%uisitrunc = trunc i64 %15 to i32
%16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
%17 = load ptr, ptr %16, align 8
%ptroffset3 = getelementptr inbounds i32, ptr %17, i64 1
%18 = load i32, ptr %ptroffset3, align 4
%19 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %18)
%20 = load ptr, ptr %y, align 8
%ptroffset4 = getelementptr inbounds i32, ptr %20, i64 1
%21 = load i32, ptr %ptroffset4, align 4
%22 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %21)
%23 = load ptr, ptr @subarrays_fofeo, align 8
%ptroffset5 = getelementptr inbounds i32, ptr %23, i64 1
%24 = load i32, ptr %ptroffset5, align 4
%25 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %24)
store ptr @.str.5, ptr %x3, align 8
store i64 0, ptr %error_var, align 8
%13 = call ptr @std_io_stdout()
store ptr %13, ptr %result, align 8
%14 = load ptr, ptr %x3, align 8
%15 = call i64 @std_io_File_printn(ptr %retparam, ptr %result, ptr %14, i64 6)
%not_err = icmp eq i64 %15, 0
br i1 %not_err, label %after_check, label %assign_optional
assign_optional: ; preds = %entry
store i64 %15, ptr %error_var, align 8
br label %noerr_block
after_check: ; preds = %entry
br label %noerr_block
noerr_block: ; preds = %after_check, %assign_optional
br label %voiderr
voiderr: ; preds = %noerr_block
%16 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 1
%17 = load i64, ptr %16, align 8
%uisitrunc = trunc i64 %17 to i32
%18 = getelementptr inbounds %"int[]", ptr %x, i32 0, i32 0
%19 = load ptr, ptr %18, align 8
%ptroffset4 = getelementptr inbounds i32, ptr %19, i64 1
%20 = load i32, ptr %ptroffset4, align 4
%21 = call i32 (ptr, ...) @printf(ptr @.str.6, i32 %uisitrunc, i32 %20)
%22 = load ptr, ptr %y, align 8
%ptroffset5 = getelementptr inbounds i32, ptr %22, i64 1
%23 = load i32, ptr %ptroffset5, align 4
%24 = call i32 (ptr, ...) @printf(ptr @.str.7, i32 %23)
%25 = load ptr, ptr @subarrays_fofeo, align 8
%ptroffset6 = getelementptr inbounds i32, ptr %25, i64 1
%26 = load i32, ptr %ptroffset6, align 4
%27 = call i32 (ptr, ...) @printf(ptr @.str.8, i32 %26)
call void @llvm.memcpy.p0.p0.i32(ptr align 8 %ffe, ptr align 8 @.__const, i32 8, i1 false)
%26 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
store i32 0, ptr %26, align 4
%27 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 0
store i32 1, ptr %27, align 4
%28 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 1
store i32 2, ptr %28, align 4
%29 = getelementptr inbounds [3 x i32], ptr %literal6, i64 0, i64 2
store i32 3, ptr %29, align 4
%30 = insertvalue %"int[]" undef, ptr %literal6, 0
%31 = insertvalue %"int[]" %30, i64 3, 1
%32 = extractvalue %"int[]" %31, 1
%not = icmp eq i64 %32, 0
%33 = zext i1 %not to i8
store i8 %33, ptr %xy, align 1
%34 = load i8, ptr %xy, align 1
%35 = trunc i8 %34 to i1
%not7 = xor i1 %35, true
br i1 %not7, label %if.then, label %if.exit
if.then: ; preds = %entry
%36 = call i32 @std_io_println(ptr @.str.9) #3
%28 = getelementptr inbounds [1 x i32], ptr %azz, i64 0, i64 0
store i32 0, ptr %28, align 4
%29 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 0
store i32 1, ptr %29, align 4
%30 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 1
store i32 2, ptr %30, align 4
%31 = getelementptr inbounds [3 x i32], ptr %literal7, i64 0, i64 2
store i32 3, ptr %31, align 4
%32 = insertvalue %"int[]" undef, ptr %literal7, 0
%33 = insertvalue %"int[]" %32, i64 3, 1
%34 = extractvalue %"int[]" %33, 1
%not = icmp eq i64 %34, 0
%35 = zext i1 %not to i8
store i8 %35, ptr %xy, align 1
%36 = load i8, ptr %xy, align 1
%37 = trunc i8 %36 to i1
%not8 = xor i1 %37, true
br i1 %not8, label %if.then, label %if.exit
if.then: ; preds = %voiderr
store ptr @.str.9, ptr %x9, align 8
store i64 0, ptr %error_var10, align 8
%38 = call ptr @std_io_stdout()
store ptr %38, ptr %result12, align 8
%39 = load ptr, ptr %x9, align 8
%40 = call i64 @std_io_File_printn(ptr %retparam11, ptr %result12, ptr %39, i64 2)
%not_err13 = icmp eq i64 %40, 0
br i1 %not_err13, label %after_check15, label %assign_optional14
assign_optional14: ; preds = %if.then
store i64 %40, ptr %error_var10, align 8
br label %noerr_block16
after_check15: ; preds = %if.then
br label %noerr_block16
noerr_block16: ; preds = %after_check15, %assign_optional14
br label %voiderr17
voiderr17: ; preds = %noerr_block16
br label %if.exit
if.exit: ; preds = %if.then, %entry
%37 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
store i32 0, ptr %37, align 4
%38 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
store i32 0, ptr %38, align 4
if.exit: ; preds = %voiderr17, %voiderr
%41 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 0
store i32 0, ptr %41, align 4
%42 = getelementptr inbounds %Bar, ptr %b, i32 0, i32 1
store i32 0, ptr %42, align 4
call void @llvm.memset.p0.i64(ptr align 8 %z, i8 0, i64 8, i1 false)
store %"int[]" zeroinitializer, ptr %sub, align 8
store %"Bar[]" zeroinitializer, ptr %foo, align 8

4
test/test_suite/macro_methods/macro_methods_defined_twice.c3
View File

@@ -11,14 +11,14 @@ import std::io;
macro void foo::Bar.@test(Bar &bar)
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
module bad;
import foo;
macro void Bar.@test(Bar &bar) // #error: This macro method is already defined for 'Bar'.
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
module abc;

10
test/test_suite/methods/enum_distinct_err_methods.c3t
View File

@@ -45,20 +45,18 @@ fn int main()
define void @foo_Foo_hello(ptr %0) #0 {
entry:
%1 = call i32 @std_io_println(ptr @.str) #1
store ptr @.str, ptr %x, align 8
ret void
}
define void @foo_Bar_hello(ptr %0) #0 {
entry:
%1 = call i32 @std_io_println(ptr @.str.1) #1
ret void
store ptr @.str.1, ptr %x, align 8
}
define void @foo_MyEnum_hello(ptr %0) #0 {
entry:
%1 = call i32 @std_io_println(ptr @.str.2) #1
ret void
store ptr @.str.2, ptr %x, align 8
}
define i32 @main() #0 {
@@ -73,4 +71,4 @@ entry:
call void @foo_Bar_hello(ptr %b)
call void @foo_MyEnum_hello(ptr %a)
ret i32 0
}
}

2
test/test_suite/methods/extension_method.c3t
View File

@@ -11,7 +11,7 @@ import std::io;
fn void foo::Bar.test(Bar *bar)
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
module abc;

4
test/test_suite/methods/extension_method_already_exist.c3
View File

@@ -2,7 +2,7 @@ module foo;
fn void Bar.test(Bar *bar)
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
struct Bar
@@ -16,7 +16,7 @@ import std::io;
fn void foo::Bar.test(Bar *bar) // #error: This method is already defined for 'Bar'
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
module abc;

4
test/test_suite/methods/methods_defined_twice.c3
View File

@@ -11,12 +11,12 @@ import std::io;
fn void foo::Bar.test(Bar *bar)
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
fn void Bar.test(Bar *bar) // #error: This method is already defined for
{
io::println("Inside of baz::Bar.test");
io::printn("Inside of baz::Bar.test");
}
module abc;