rewrite code generation

[lucalewin]

Reason

The previous method of code generation was messy. It was pretty hard to implement new features like #11 or #12.
Therefore I decided to rewrite the code generation for x86-64 machines completely.

Difference between the old and new generation

The old method was based on functions returning the code they generated which would then be concatenated with the code in the current function. This and using some badly written utility functions resulted in a lot of memory leaks.

The new method uses an additional data structure to store the generated instructions during the generation. After the generation finishes, the data structure will be stringified, which requires a lot less string concatenation.

String Literals

The main reason to work on this was to resolve #11. As previously stated it was nearly impossible to implement it in the old code generation system. Therefore the new system was designed to be able to support local string literals.

This old example

import sys.io::print;

const str: string = "Hello, World!";

function main(): i32 {
    print(str);
    return 0;
}

can now be rewritten in a much simpler form

import sys.io::print;

function main(): i32 {
    print("Hello, World!");
    return 0;
}

which previously was impossible.

String Table

This is now possible because of the implementation of a String Table which stores all string literals that are defined.
The String Table also holds an array of labels to allow multiple variables to reference the same string literal. It also makes sure that if a string literal is defined multiple times, it will only be generated once.

Example:

const str0: string = "Test";
const str1: string = "Different String Literal";
const str2: string = "Test";

function main(): char {
    return str0[2];
}

The string literal "Test" is defined twice, but in the generated assembly code:

global _var_str0__char@1
global _var_str1__char@1
global _var_str2__char@1
global _func_main_
global _start
_var_str0__char@1:
_var_str2__char@1:
_string_0: db `Test`,0
_var_str1__char@1:
_string_1: db `Different String Literal`,0
section .data
section .bss
section .text
_func_main_:
	mov rax, 2
	movsx rax, byte[_var_str0__char@1+1*rax]
	ret
_start:
	call _func_main_
	mov rdi, rax
	mov rax, 60
	syscall

it is only generated once.

Tests

This pull request also contains new tests for conditional expressions and string literals.
But there are also two tests (one new, one old) that currently fail. I'm going to fix them with another pull request.

Tags

#11 #12