Rename elna_generator to elna_tac

1 files changed, 491 insertions, 464 deletions

diff --git a/boot/stage15.elna b/boot/stage15.elna
index cf5c69b..c641a62 100644
--- a/boot/stage15.elna
+++ b/boot/stage15.elna
@@ -152,14 +152,14 @@ type
 	);
 	InfoKind = (type_info, parameter_info, temporary_info, procedure_info);
 	TypeKind = (primitive, enumeration);
-	ElnaGeneratorKind = (
+	ElnaTacOperator = (
 		load_immediate,
 		load_address,
 		add,
 		add_immediate,
 		load_word,
 		store_word,
-		call,
+		jal,
 		move,
 		sub,
 		div,
@@ -177,13 +177,10 @@ type
 		jump,
 		beqz,
 		ret,
-		label,
-		procedure,
-		variable,
-		_module
+		label
 	);
-	ElnaGeneratorOperand = (register, immediate, symbol, offset);
-	ElnaGeneratorRegister = (
+	ElnaTacOperand = (register, immediate, symbol, offset);
+	ElnaTacRegister = (
 		zero,
 		ra,
 		sp,
@@ -569,39 +566,39 @@ proc _node_get_kind(this: Word);
 	return this^
 end;
 
-proc _elna_generator_instruction_size();
+proc _elna_tac_instruction_size();
 	return 44
 end;
 
-proc _elna_generator_instruction_get_kind(this: Word);
+proc _elna_tac_instruction_get_kind(this: Word);
 	return this^
 end;
 
-proc _elna_generator_instruction_set_kind(this: Word, value: Word);
+proc _elna_tac_instruction_set_kind(this: Word, value: Word);
 begin
 	this^ := value
 end;
 
-proc _elna_generator_instruction_get_next(this: Word);
+proc _elna_tac_instruction_get_next(this: Word);
 begin
 	this := this + 4;
 	return this^
 end;
 
-proc _elna_generator_instruction_set_next(this: Word, value: Word);
+proc _elna_tac_instruction_set_next(this: Word, value: Word);
 begin
-	.elna_generator_instruction_set_next_loop;
+	.elna_tac_instruction_set_next_loop;
 	this := this + 4;
 	if value <> 0 then
 		if this^ <> 0 then
 			this := this^;
-			goto elna_generator_instruction_set_next_loop
+			goto elna_tac_instruction_set_next_loop
 		end
 	end;
 	this^ := value
 end;
 
-proc _elna_generator_instruction_get_operand_type(this: Word, n: Word);
+proc _elna_tac_instruction_get_operand_type(this: Word, n: Word);
 begin
 	n := n - 1;
 	n := n * 12;
@@ -611,7 +608,7 @@ begin
 	return this^
 end;
 
-proc _elna_generator_instruction_get_operand_value(this: Word, n: Word);
+proc _elna_tac_instruction_get_operand_value(this: Word, n: Word);
 begin
 	n := n - 1;
 	n := n * 12;
@@ -622,7 +619,7 @@ begin
 	return this^
 end;
 
-proc _elna_generator_instruction_get_operand_length(this: Word, n: Word);
+proc _elna_tac_instruction_get_operand_length(this: Word, n: Word);
 begin
 	n := n - 1;
 	n := n * 12;
@@ -633,7 +630,7 @@ begin
 	return this^
 end;
 
-proc _elna_generator_instruction_set_operand(this: Word, n: Word, operand_type: Word, operand_value: Word, operand_length: Word);
+proc _elna_tac_instruction_set_operand(this: Word, n: Word, operand_type: Word, operand_value: Word, operand_length: Word);
 begin
 	n := n - 1;
 	n := n * 12;
@@ -647,373 +644,386 @@ begin
 	this^ := operand_length
 end;
 
-proc _elna_generator_instruction_create(kind: Word);
+proc _elna_tac_instruction_create(kind: Word);
 var
 	result: Word;
 	instruction_size: Word;
 begin
-	instruction_size := _elna_generator_instruction_size();
+	instruction_size := _elna_tac_instruction_size();
 	result := _allocate(instruction_size);
 
-	_elna_generator_instruction_set_kind(result, kind);
-	_elna_generator_instruction_set_next(result, 0);
+	_elna_tac_instruction_set_kind(result, kind);
+	_elna_tac_instruction_set_next(result, 0);
 
 	return result
 end;
 
-proc _elna_generator_procedure_size();
-	return 20
+proc _elna_tac_module_create(data: Word, code: Word);
+var
+	result: Word;
+	current_word: Word;
+begin
+	result := _allocate(8);
+
+	current_word := result;
+	current_word^ := data;
+	current_word := current_word + 4;
+	current_word^ := code;
+
+	return result
 end;
 
-proc _elna_generator_procedure_get_kind(this: Word);
+proc _elna_tac_module_get_data(this: Word);
 	return this^
 end;
 
-proc _elna_generator_procedure_set_kind(this: Word, value: Word);
+proc _elna_tac_module_get_code(this: Word);
 begin
-	this^ := value
+	this := this + 4;
+	return this^
 end;
 
-proc _elna_generator_procedure_get_next(this: Word);
-begin
-	this := this + 4;
+proc _elna_tac_declaration_size();
+	return 16
+end;
+
+proc _elna_tac_declaration_get_next(this: Word);
 	return this^
 end;
 
-proc _elna_generator_procedure_set_next(this: Word, value: Word);
+proc _elna_tac_declaration_set_next(this: Word, value: Word);
 begin
-	this := this + 4;
 	this^ := value
 end;
 
-proc _elna_generator_procedure_get_name(this: Word);
+proc _elna_tac_declaration_get_name(this: Word);
 begin
-	this := this + 8;
+	this := this + 4;
 	return this^
 end;
 
-proc _elna_generator_procedure_set_name(this: Word, value: Word);
+proc _elna_tac_declaration_set_name(this: Word, value: Word);
 begin
-	this := this + 8;
+	this := this + 4;
 	this^ := value
 end;
 
-proc _elna_generator_procedure_get_length(this: Word);
+proc _elna_tac_declaration_get_length(this: Word);
 begin
-	this := this + 12;
+	this := this + 8;
 	return this^
 end;
 
-proc _elna_generator_procedure_set_length(this: Word, value: Word);
+proc _elna_tac_declaration_set_length(this: Word, value: Word);
 begin
-	this := this + 12;
+	this := this + 8;
 	this^ := value
 end;
 
-proc _elna_generator_procedure_get_body(this: Word);
+proc _elna_tac_declaration_get_body(this: Word);
 begin
-	this := this + 16;
+	this := this + 12;
 	return this^
 end;
 
-proc _elna_generator_procedure_set_body(this: Word, value: Word);
+proc _elna_tac_declaration_set_body(this: Word, value: Word);
 begin
-	this := this + 16;
+	this := this + 12;
 	this^ := value
 end;
 
-proc _elna_generator_load_immediate(target_register: Word, source_immediate: Word, immediate_length: Word);
+proc _elna_tac_load_immediate(target_register: Word, source_immediate: Word, immediate_length: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.load_immediate);
+	result := _elna_tac_instruction_create(ElnaTacOperator.load_immediate);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, target_register, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.immediate, source_immediate, immediate_length);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, target_register, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.immediate, source_immediate, immediate_length);
 
 	return result
 end;
 
-proc _elna_generator_load_address(target_register: Word, source_symbol: Word, symbol_length: Word);
+proc _elna_tac_load_address(target_register: Word, source_symbol: Word, symbol_length: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.load_address);
+	result := _elna_tac_instruction_create(ElnaTacOperator.load_address);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, target_register, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.symbol, source_symbol, symbol_length);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, target_register, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.symbol, source_symbol, symbol_length);
 
 	return result
 end;
 
-proc _elna_generator_beqz(target_register: Word, source_symbol: Word, symbol_length: Word);
+proc _elna_tac_beqz(target_register: Word, source_symbol: Word, symbol_length: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.beqz);
+	result := _elna_tac_instruction_create(ElnaTacOperator.beqz);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, target_register, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.symbol, source_symbol, symbol_length);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, target_register, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.symbol, source_symbol, symbol_length);
 
 	return result
 end;
 
-proc _elna_generator_jump(source_symbol: Word, symbol_length: Word);
+proc _elna_tac_jump(source_symbol: Word, symbol_length: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.jump);
+	result := _elna_tac_instruction_create(ElnaTacOperator.jump);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.symbol, source_symbol, symbol_length);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.symbol, source_symbol, symbol_length);
 
 	return result
 end;
 
-proc _elna_generator_add(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_add(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.add);
+	result := _elna_tac_instruction_create(ElnaTacOperator.add);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_mul(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_mul(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.mul);
+	result := _elna_tac_instruction_create(ElnaTacOperator.mul);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_sub(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_sub(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.sub);
+	result := _elna_tac_instruction_create(ElnaTacOperator.sub);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_div(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_div(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.div);
+	result := _elna_tac_instruction_create(ElnaTacOperator.div);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_rem(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_rem(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.rem);
+	result := _elna_tac_instruction_create(ElnaTacOperator.rem);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_xor(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_xor(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind._xor);
+	result := _elna_tac_instruction_create(ElnaTacOperator._xor);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_xor_immediate(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_xor_immediate(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind._xor);
+	result := _elna_tac_instruction_create(ElnaTacOperator._xor);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.immediate, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.immediate, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_or(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_or(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind._or);
+	result := _elna_tac_instruction_create(ElnaTacOperator._or);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_and(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_and(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.and);
+	result := _elna_tac_instruction_create(ElnaTacOperator.and);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_add_immediate(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_add_immediate(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.add_immediate);
+	result := _elna_tac_instruction_create(ElnaTacOperator.add_immediate);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.immediate, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.immediate, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_slt(destination: Word, lhs: Word, rhs: Word);
+proc _elna_tac_slt(destination: Word, lhs: Word, rhs: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.slt);
+	result := _elna_tac_instruction_create(ElnaTacOperator.slt);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, lhs, 0);
-	_elna_generator_instruction_set_operand(result, 3, ElnaGeneratorOperand.register, rhs, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, lhs, 0);
+	_elna_tac_instruction_set_operand(result, 3, ElnaTacOperand.register, rhs, 0);
 
 	return result
 end;
 
-proc _elna_generator_call(symbol: Word, length: Word);
+proc _elna_tac_jal(symbol: Word, length: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.call);
+	result := _elna_tac_instruction_create(ElnaTacOperator.jal);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.symbol, symbol, length);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.symbol, symbol, length);
 
 	return result
 end;
 
-proc _elna_generator_load_word(target: Word, register: Word, offset: Word);
+proc _elna_tac_load_word(target: Word, register: Word, offset: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.load_word);
+	result := _elna_tac_instruction_create(ElnaTacOperator.load_word);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, target, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.offset, register, offset);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, target, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.offset, register, offset);
 
 	return result
 end;
 
-proc _elna_generator_store_word(target: Word, register: Word, offset: Word);
+proc _elna_tac_store_word(target: Word, register: Word, offset: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.store_word);
+	result := _elna_tac_instruction_create(ElnaTacOperator.store_word);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, target, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.offset, register, offset);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, target, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.offset, register, offset);
 
 	return result
 end;
 
-proc _elna_generator_move(destination: Word, source: Word);
+proc _elna_tac_move(destination: Word, source: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.move);
+	result := _elna_tac_instruction_create(ElnaTacOperator.move);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, source, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, source, 0);
 
 	return result
 end;
 
-proc _elna_generator_seqz(destination: Word, source: Word);
+proc _elna_tac_seqz(destination: Word, source: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.seqz);
+	result := _elna_tac_instruction_create(ElnaTacOperator.seqz);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, source, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, source, 0);
 
 	return result
 end;
 
-proc _elna_generator_snez(destination: Word, source: Word);
+proc _elna_tac_snez(destination: Word, source: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.snez);
+	result := _elna_tac_instruction_create(ElnaTacOperator.snez);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, source, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, source, 0);
 
 	return result
 end;
 
-proc _elna_generator_neg(destination: Word, source: Word);
+proc _elna_tac_neg(destination: Word, source: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.neg);
+	result := _elna_tac_instruction_create(ElnaTacOperator.neg);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, source, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, source, 0);
 
 	return result
 end;
 
-proc _elna_generator_not(destination: Word, source: Word);
+proc _elna_tac_not(destination: Word, source: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.not);
+	result := _elna_tac_instruction_create(ElnaTacOperator.not);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.register, destination, 0);
-	_elna_generator_instruction_set_operand(result, 2, ElnaGeneratorOperand.register, source, 0);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.register, destination, 0);
+	_elna_tac_instruction_set_operand(result, 2, ElnaTacOperand.register, source, 0);
 
 	return result
 end;
 
-proc _elna_generator_label(counter: Word, length: Word);
+proc _elna_tac_label(counter: Word, length: Word);
 var
 	result: Word;
 begin
-	result := _elna_generator_instruction_create(ElnaGeneratorKind.label);
+	result := _elna_tac_instruction_create(ElnaTacOperator.label);
 
-	_elna_generator_instruction_set_operand(result, 1, ElnaGeneratorOperand.symbol, counter, length);
+	_elna_tac_instruction_set_operand(result, 1, ElnaTacOperand.symbol, counter, length);
 
 	return result
 end;
@@ -1022,76 +1032,76 @@ proc _elna_writer_instruction_name(instruction_kind: Word);
 var
 	argument_count: Word;
 begin
-	if instruction_kind = ElnaGeneratorKind.load_immediate then
+	if instruction_kind = ElnaTacOperator.load_immediate then
 		argument_count := 2;
 		_write_s("\tli", 3)
-	elsif instruction_kind = ElnaGeneratorKind.load_address then
+	elsif instruction_kind = ElnaTacOperator.load_address then
 		argument_count := 2;
 		_write_s("\tla", 3)
-	elsif instruction_kind = ElnaGeneratorKind.add then
+	elsif instruction_kind = ElnaTacOperator.add then
 		argument_count := 3;
 		_write_s("\tadd", 4)
-	elsif instruction_kind = ElnaGeneratorKind.add_immediate then
+	elsif instruction_kind = ElnaTacOperator.add_immediate then
 		argument_count := 3;
 		_write_s("\taddi", 5)
-	elsif instruction_kind = ElnaGeneratorKind.load_word then
+	elsif instruction_kind = ElnaTacOperator.load_word then
 		argument_count := 2;
 		_write_s("\tlw", 3)
-	elsif instruction_kind = ElnaGeneratorKind.store_word then
+	elsif instruction_kind = ElnaTacOperator.store_word then
 		argument_count := 2;
 		_write_s("\tsw", 3)
-	elsif instruction_kind = ElnaGeneratorKind.call then
+	elsif instruction_kind = ElnaTacOperator.jal then
 		argument_count := 1;
 		_write_s("\tcall", 5)
-	elsif instruction_kind = ElnaGeneratorKind.move then
+	elsif instruction_kind = ElnaTacOperator.move then
 		argument_count := 2;
 		_write_s("\tmv", 3)
-	elsif instruction_kind = ElnaGeneratorKind.sub then
+	elsif instruction_kind = ElnaTacOperator.sub then
 		argument_count := 3;
 		_write_s("\tsub", 4)
-	elsif instruction_kind = ElnaGeneratorKind.mul then
+	elsif instruction_kind = ElnaTacOperator.mul then
 		argument_count := 3;
 		_write_s("\tmul", 4)
-	elsif instruction_kind = ElnaGeneratorKind.div then
+	elsif instruction_kind = ElnaTacOperator.div then
 		argument_count := 3;
 		_write_s("\tdiv", 4)
-	elsif instruction_kind = ElnaGeneratorKind.rem then
+	elsif instruction_kind = ElnaTacOperator.rem then
 		argument_count := 3;
 		_write_s("\trem", 4)
-	elsif instruction_kind = ElnaGeneratorKind._xor then
+	elsif instruction_kind = ElnaTacOperator._xor then
 		argument_count := 3;
 		_write_s("\txor", 4)
-	elsif instruction_kind = ElnaGeneratorKind.xor_immediate then
+	elsif instruction_kind = ElnaTacOperator.xor_immediate then
 		argument_count := 3;
 		_write_s("\txori", 5)
-	elsif instruction_kind = ElnaGeneratorKind._or then
+	elsif instruction_kind = ElnaTacOperator._or then
 		argument_count := 3;
 		_write_s("\tor", 3)
-	elsif instruction_kind = ElnaGeneratorKind.and then
+	elsif instruction_kind = ElnaTacOperator.and then
 		argument_count := 3;
 		_write_s("\tand", 4)
-	elsif instruction_kind = ElnaGeneratorKind.seqz then
+	elsif instruction_kind = ElnaTacOperator.seqz then
 		argument_count := 2;
 		_write_s("\tseqz", 5)
-	elsif instruction_kind = ElnaGeneratorKind.snez then
+	elsif instruction_kind = ElnaTacOperator.snez then
 		argument_count := 2;
 		_write_s("\tsnez", 5)
-	elsif instruction_kind = ElnaGeneratorKind.slt then
+	elsif instruction_kind = ElnaTacOperator.slt then
 		argument_count := 3;
 		_write_s("\tslt", 4)
-	elsif instruction_kind = ElnaGeneratorKind.neg then
+	elsif instruction_kind = ElnaTacOperator.neg then
 		argument_count := 2;
 		_write_s("\tneg", 4)
-	elsif instruction_kind = ElnaGeneratorKind.not then
+	elsif instruction_kind = ElnaTacOperator.not then
 		argument_count := 2;
 		_write_s("\tnot", 4)
-	elsif instruction_kind = ElnaGeneratorKind.jump then
+	elsif instruction_kind = ElnaTacOperator.jump then
 		argument_count := 1;
 		_write_s("\tj", 2)
-	elsif instruction_kind = ElnaGeneratorKind.beqz then
+	elsif instruction_kind = ElnaTacOperator.beqz then
 		argument_count := 2;
 		_write_s("\tbeqz", 5)
-	elsif instruction_kind = ElnaGeneratorKind.ret then
+	elsif instruction_kind = ElnaTacOperator.ret then
 		argument_count := 0;
 		_write_s("\tret", 4)
 	end;
@@ -1113,25 +1123,25 @@ var
 	operand_length: Word;
 	operand_type: Word;
 begin
-	operand_type := _elna_generator_instruction_get_operand_type(instruction, n);
-	operand_value := _elna_generator_instruction_get_operand_value(instruction, n);
-	operand_length := _elna_generator_instruction_get_operand_length(instruction, n);
+	operand_type := _elna_tac_instruction_get_operand_type(instruction, n);
+	operand_value := _elna_tac_instruction_get_operand_value(instruction, n);
+	operand_length := _elna_tac_instruction_get_operand_length(instruction, n);
 
 	_write_c(' ');
-	if operand_type = ElnaGeneratorOperand.register then
+	if operand_type = ElnaTacOperand.register then
 		_elna_writer_register(operand_value)
-	elsif operand_type = ElnaGeneratorOperand.offset then
+	elsif operand_type = ElnaTacOperand.offset then
 		_write_i(operand_length);
 		_write_c('(');
 		_elna_writer_register(operand_value);
 		_write_c(')')
-	elsif operand_type = ElnaGeneratorOperand.symbol then
+	elsif operand_type = ElnaTacOperand.symbol then
 		if operand_length = 0 then
 			_write_label(operand_value, 0)
 		else
 			_write_s(operand_value, operand_length)
 		end
-	elsif operand_length = 0 then (* ElnaGeneratorOperand.immediate *)
+	elsif operand_length = 0 then (* ElnaTacOperand.immediate *)
 		_write_i(operand_value)
 	else
 		_write_s(operand_value, operand_length)
@@ -1146,12 +1156,12 @@ var
 	operand_value: Word;
 	operand_length: Word;
 begin
-	instruction_kind := _elna_generator_instruction_get_kind(instruction);
+	instruction_kind := _elna_tac_instruction_get_kind(instruction);
 
-	if instruction_kind = ElnaGeneratorKind.label then
+	if instruction_kind = ElnaTacOperator.label then
 		argument_count := 0;
-		operand_value := _elna_generator_instruction_get_operand_value(instruction, 1);
-		operand_length := _elna_generator_instruction_get_operand_length(instruction, 1);
+		operand_value := _elna_tac_instruction_get_operand_value(instruction, 1);
+		operand_length := _elna_tac_instruction_get_operand_length(instruction, 1);
 		_write_label(operand_value, operand_length);
 		_write_c(':')
 	else
@@ -1176,11 +1186,23 @@ proc _elna_writer_instructions(instruction: Word);
 begin
 	if instruction <> 0 then
 		_elna_writer_instruction(instruction);
-		instruction := _elna_generator_instruction_get_next(instruction);
+		instruction := _elna_tac_instruction_get_next(instruction);
 		_elna_writer_instructions(instruction)
 	end
 end;
 
+(* Write the prologue. *)
+proc _elna_writer_prologue();
+begin
+	_write_z("\taddi sp, sp, -128\n\tsw ra, 124(sp)\n\tsw s0, 120(sp)\n\taddi s0, sp, 128\n\0")
+end;
+
+(* Write the epilogue. *)
+proc _elna_writer_epilogue();
+begin
+	_write_z("\tlw ra, 124(sp)\n\tlw s0, 120(sp)\n\taddi sp, sp, 128\n\tret\n\0")
+end;
+
 proc _elna_writer_procedure(procedure: Word);
 var
 	name_pointer: Word;
@@ -1188,9 +1210,9 @@ var
 	body_statements: Word;
 begin
 	.elna_writer_procedure_loop;
-	name_pointer := _elna_generator_procedure_get_name(procedure);
-	name_length := _elna_generator_procedure_get_length(procedure);
-	body_statements := _elna_generator_procedure_get_body(procedure);
+	name_pointer := _elna_tac_declaration_get_name(procedure);
+	name_length := _elna_tac_declaration_get_length(procedure);
+	body_statements := _elna_tac_declaration_get_body(procedure);
 
 	(* Write .type _procedure_name, @function. *)
 	_write_z(".type \0");
@@ -1202,8 +1224,11 @@ begin
 	_write_s(name_pointer, name_length);
 	_write_z(":\n\0");
 
+	_elna_writer_prologue();
 	_elna_writer_instructions(body_statements);
-	procedure := _elna_generator_procedure_get_next(procedure);
+	_elna_writer_epilogue();
+
+	procedure := _elna_tac_declaration_get_next(procedure);
 	if procedure <> 0 then
 		goto elna_writer_procedure_loop
 	end
@@ -1217,9 +1242,9 @@ var
 begin
 	.elna_writer_variable_loop;
 	if variable <> 0 then
-		name := _elna_generator_procedure_get_name(variable);
-		name_length := _elna_generator_procedure_get_length(variable);
-		size := _elna_generator_procedure_get_body(variable);
+		name := _elna_tac_declaration_get_name(variable);
+		name_length := _elna_tac_declaration_get_length(variable);
+		size := _elna_tac_declaration_get_body(variable);
 
 		_write_z(".type \0");
 		_write_s(name, name_length);
@@ -1232,7 +1257,7 @@ begin
 		_write_i(size);
 
 		_write_c('\n');
-		variable := _elna_generator_procedure_get_next(variable);
+		variable := _elna_tac_declaration_get_next(variable);
 
 		goto elna_writer_variable_loop
 	end
@@ -1248,7 +1273,7 @@ begin
 	_write_z(".globl _start\n\n\0");
 	_write_z(".section .data\n\0");
 
-	current_part := _elna_generator_procedure_get_name(pair);
+	current_part := _elna_tac_module_get_data(pair);
 	_elna_writer_variable(current_part);
 
 	_write_z(".section .text\n\n\0");
@@ -1256,7 +1281,7 @@ begin
 	_write_z(".type _load_byte, @function\n_load_byte:\n\tlb a0, (a0)\nret\n\n\0");
 	_write_z(".type _store_byte, @function\n_store_byte:\n\tsb a0, (a1)\nret\n\n\0");
 
-	current_part := _elna_generator_procedure_get_body(pair);
+	current_part := _elna_tac_module_get_code(pair);
 	_elna_writer_procedure(current_part);
 
 	_write_z(".section .rodata\n.type strings, @object\nstrings: .ascii \0");
@@ -1265,13 +1290,13 @@ begin
 	compiler_strings_copy := @compiler_strings;
 	compiler_strings_end := compiler_strings_position;
 
-	.compile_module_declaration_loop;
+	.elna_writer_module_loop;
 	if compiler_strings_copy < compiler_strings_end then
 		current_byte := _load_byte(compiler_strings_copy);
 		compiler_strings_copy := compiler_strings_copy + 1;
 		_write_c(current_byte);
 
-		goto compile_module_declaration_loop
+		goto elna_writer_module_loop
 	end;
 	_write_c('"');
 	_write_c('\n');
@@ -1332,7 +1357,7 @@ begin
 	return result
 end;
 
-proc _compile_integer_literal(integer_literal_node: Word);
+proc _elna_tac_integer_literal(integer_literal_node: Word);
 var
 	integer_token: Word;
 	integer_length: Word;
@@ -1341,7 +1366,7 @@ begin
 	integer_token := _integer_literal_node_get_value(integer_literal_node);
 	integer_length := _integer_literal_node_get_length(integer_literal_node);
 
-	return _elna_generator_load_immediate(ElnaGeneratorRegister.t0, integer_token, integer_length)
+	return _elna_tac_load_immediate(ElnaTacRegister.t0, integer_token, integer_length)
 end;
 
 proc _character_literal_node_size();
@@ -1394,7 +1419,7 @@ begin
 	return result
 end;
 
-proc _compile_character_literal(character_literal_node: Word);
+proc _elna_tac_character_literal(character_literal_node: Word);
 var
 	character: Word;
 	character_length: Word;
@@ -1402,7 +1427,7 @@ begin
 	character := _character_literal_node_get_value(character_literal_node);
 	character_length := _character_literal_node_get_length(character_literal_node);
 
-	return _elna_generator_load_immediate(ElnaGeneratorRegister.t0, character, character_length)
+	return _elna_tac_load_immediate(ElnaTacRegister.t0, character, character_length)
 end;
 
 proc _variable_expression_size();
@@ -1464,7 +1489,7 @@ begin
 	return result
 end;
 
-proc _compile_variable_expression(variable_expression: Word, symbol_table: Word);
+proc _elna_tac_variable_expression(variable_expression: Word, symbol_table: Word);
 var
 	name: Word;
 	name_token: Word;
@@ -1476,9 +1501,9 @@ begin
 
 	lookup_result := _symbol_table_lookup(symbol_table, name, name_token);
 	if lookup_result <> 0 then
-		instruction := _compile_local_designator(lookup_result)
+		instruction := _elna_tac_local_designator(lookup_result)
 	else
-		instruction := _compile_global_designator(variable_expression)
+		instruction := _elna_tac_global_designator(variable_expression)
 	end;
 	return instruction
 end;
@@ -1532,7 +1557,7 @@ begin
 	return result
 end;
 
-proc _compile_string_literal(string_literal_node: Word);
+proc _elna_tac_string_literal(string_literal_node: Word);
 var
 	token_start: Word;
 	length: Word;
@@ -1545,11 +1570,11 @@ begin
 	length := _string_literal_node_get_length(string_literal_node);
 	offset := _add_string(token_start);
 
-	first_instruction := _elna_generator_load_address(ElnaGeneratorRegister.t0, "strings", 7);
-	instruction := _elna_generator_load_immediate(ElnaGeneratorRegister.t1, offset, 0);
-	_elna_generator_instruction_set_next(first_instruction, instruction);
-	next_instruction := _elna_generator_add(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-	_elna_generator_instruction_set_next(instruction, next_instruction);
+	first_instruction := _elna_tac_load_address(ElnaTacRegister.t0, "strings", 7);
+	instruction := _elna_tac_load_immediate(ElnaTacRegister.t1, offset, 0);
+	_elna_tac_instruction_set_next(first_instruction, instruction);
+	next_instruction := _elna_tac_add(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+	_elna_tac_instruction_set_next(instruction, next_instruction);
 
 	return first_instruction
 end;
@@ -1625,7 +1650,7 @@ begin
 	return simple_expression
 end;
 
-proc _compile_simple_expression(parser_node: Word, symbol_table: Word, is_address: Word);
+proc _elna_tac_simple_expression(parser_node: Word, symbol_table: Word, is_address: Word);
 var
 	is_address: Word;
 	node_kind: Word;
@@ -1635,13 +1660,13 @@ begin
 	node_kind := _node_get_kind(parser_node);
 
 	if node_kind = NodeKind.character_literal then
-		instruction := _compile_character_literal(parser_node)
+		instruction := _elna_tac_character_literal(parser_node)
 	elsif node_kind = NodeKind.string_literal then
-		instruction := _compile_string_literal(parser_node)
+		instruction := _elna_tac_string_literal(parser_node)
 	elsif node_kind = NodeKind.integer_literal then
-		instruction := _compile_integer_literal(parser_node)
+		instruction := _elna_tac_integer_literal(parser_node)
 	else
-		instruction := _compile_variable_expression(parser_node, symbol_table);
+		instruction := _elna_tac_variable_expression(parser_node, symbol_table);
 		is_address^ := 1
 	end;
 	return instruction
@@ -1711,7 +1736,7 @@ begin
 	return result
 end;
 
-proc _compile_unary_expression(parser_node: Word, symbol_table: Word);
+proc _elna_tac_unary_expression(parser_node: Word, symbol_table: Word);
 var
 	current_character: Word;
 	token_kind: Word;
@@ -1735,20 +1760,20 @@ begin
 	end;
 
 	if operator = '@' then
-		first_instruction := _compile_designator(operand, symbol_table, @is_address)
+		first_instruction := _elna_tac_designator(operand, symbol_table, @is_address)
 	else
-		first_instruction := _compile_designator(operand, symbol_table, @is_address);
+		first_instruction := _elna_tac_designator(operand, symbol_table, @is_address);
 		if is_address then
-			instruction := _elna_generator_load_word(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, 0);
-			_elna_generator_instruction_set_next(first_instruction, instruction)
+			instruction := _elna_tac_load_word(ElnaTacRegister.t0, ElnaTacRegister.t0, 0);
+			_elna_tac_instruction_set_next(first_instruction, instruction)
 		end
 	end;
 	if operator = '-' then
-		instruction := _elna_generator_neg(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0);
-		_elna_generator_instruction_set_next(first_instruction, instruction)
+		instruction := _elna_tac_neg(ElnaTacRegister.t0, ElnaTacRegister.t0);
+		_elna_tac_instruction_set_next(first_instruction, instruction)
 	elsif operator = '~' then
-		instruction := _elna_generator_not(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0);
-		_elna_generator_instruction_set_next(first_instruction, instruction)
+		instruction := _elna_tac_not(ElnaTacRegister.t0, ElnaTacRegister.t0);
+		_elna_tac_instruction_set_next(first_instruction, instruction)
 	end;
 	return first_instruction
 end;
@@ -1862,7 +1887,7 @@ begin
 	return result
 end;
 
-proc _compile_binary_expression(parser_node: Word, symbol_table: Word);
+proc _elna_tac_binary_expression(parser_node: Word, symbol_table: Word);
 var
 	token_kind: Word;
 	expression_kind: Word;
@@ -1874,87 +1899,87 @@ begin
 	expression_kind := _node_get_kind(parser_node);
 
 	if expression_kind <> NodeKind.binary_expression then
-		first_instruction := _compile_unary_expression(parser_node, symbol_table)
+		first_instruction := _elna_tac_unary_expression(parser_node, symbol_table)
 	else
 		token_kind := _binary_expression_get_operator(parser_node);
 
 		operand_node := _binary_expression_get_lhs(parser_node);
-		first_instruction := _compile_unary_expression(operand_node, symbol_table);
+		first_instruction := _elna_tac_unary_expression(operand_node, symbol_table);
 
 		(* Save the value of the left expression on the stack. *)
-		instruction := _elna_generator_store_word(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.sp, 64);
-		_elna_generator_instruction_set_next(first_instruction, instruction);
+		instruction := _elna_tac_store_word(ElnaTacRegister.t0, ElnaTacRegister.sp, 64);
+		_elna_tac_instruction_set_next(first_instruction, instruction);
 		current_instruction := instruction;
 
 		operand_node := _binary_expression_get_rhs(parser_node);
-		instruction := _compile_unary_expression(operand_node, symbol_table);
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		instruction := _elna_tac_unary_expression(operand_node, symbol_table);
+		_elna_tac_instruction_set_next(current_instruction, instruction);
 		current_instruction := instruction;
 
 		(* Load the left expression from the stack; *)
-		instruction := _elna_generator_load_word(ElnaGeneratorRegister.t1, ElnaGeneratorRegister.sp, 64);
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		instruction := _elna_tac_load_word(ElnaTacRegister.t1, ElnaTacRegister.sp, 64);
+		_elna_tac_instruction_set_next(current_instruction, instruction);
 		current_instruction := instruction;
 
 		if token_kind = LexerTokenKind.plus then
-			instruction := _elna_generator_add(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_add(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.minus then
-			instruction := _elna_generator_sub(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_sub(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.multiplication then
-			instruction := _elna_generator_mul(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_mul(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.and then
-			instruction := _elna_generator_and(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_and(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind._or then
-			instruction := _elna_generator_or(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_or(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind._xor then
-			instruction := _elna_generator_xor(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.equals then
-			instruction := _elna_generator_xor(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction);
+			instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction);
 			current_instruction := instruction;
 
-			instruction := _elna_generator_seqz(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_seqz(ElnaTacRegister.t0, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.remainder then
-			instruction := _elna_generator_rem(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_rem(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.division then
-			instruction := _elna_generator_div(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_div(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.less_than then
-			instruction := _elna_generator_slt(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.greater_than then
-			instruction := _elna_generator_slt(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.less_equal then
-			instruction := _elna_generator_slt(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction);
+			instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction);
 			current_instruction := instruction;
 
-			instruction := _elna_generator_xor_immediate(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, 1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_xor_immediate(ElnaTacRegister.t0, ElnaTacRegister.t0, 1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.not_equal then
-			instruction := _elna_generator_xor(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1);
-			_elna_generator_instruction_set_next(current_instruction, instruction);
+			instruction := _elna_tac_xor(ElnaTacRegister.t0, ElnaTacRegister.t0, ElnaTacRegister.t1);
+			_elna_tac_instruction_set_next(current_instruction, instruction);
 			current_instruction := instruction;
 
-			instruction := _elna_generator_snez(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			instruction := _elna_tac_snez(ElnaTacRegister.t0, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		elsif token_kind = LexerTokenKind.greater_equal then
-			instruction := _elna_generator_slt(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1, ElnaGeneratorRegister.t0);
-			_elna_generator_instruction_set_next(current_instruction, instruction);
+			instruction := _elna_tac_slt(ElnaTacRegister.t0, ElnaTacRegister.t1, ElnaTacRegister.t0);
+			_elna_tac_instruction_set_next(current_instruction, instruction);
 			current_instruction := instruction;
 
-			instruction := _elna_generator_xor_immediate(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, 1);
-			_elna_generator_instruction_set_next(current_instruction, instruction)
-		end;
+			instruction := _elna_tac_xor_immediate(ElnaTacRegister.t0, ElnaTacRegister.t0, 1);
+			_elna_tac_instruction_set_next(current_instruction, instruction)
+		end
 	end;
 	return first_instruction
 end;
@@ -2035,7 +2060,7 @@ begin
 	return result
 end;
 
-proc _compile_call(parsed_call: Word, symbol_table: Word);
+proc _elna_tac_call(parsed_call: Word, symbol_table: Word);
 var
 	name_length: Word;
 	name: Word;
@@ -2052,32 +2077,32 @@ begin
 	argument_count := 0;
 	first_instruction := 0;
 
-	.compile_call_loop;
+	.elna_tac_call_loop;
 
 	parsed_expression := _call_get_argument(parsed_call, argument_count + 1);
 	if parsed_expression = 0 then
-		goto compile_call_finalize
+		goto elna_tac_call_finalize
 	else
-		instruction := _compile_binary_expression(parsed_expression, symbol_table);
+		instruction := _elna_tac_binary_expression(parsed_expression, symbol_table);
 		if first_instruction = 0 then
 			first_instruction := instruction
 		else
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		end;
 		current_instruction := instruction;
 
 		(* Save the argument on the stack. *)
 		stack_offset := argument_count * 4;
 
-		instruction := _elna_generator_store_word(ElnaGeneratorRegister.t0,
-			ElnaGeneratorRegister.sp, 116 - stack_offset);
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		instruction := _elna_tac_store_word(ElnaTacRegister.t0,
+			ElnaTacRegister.sp, 116 - stack_offset);
+		_elna_tac_instruction_set_next(current_instruction, instruction);
 		current_instruction := instruction;
 
 		argument_count := argument_count + 1;
-		goto compile_call_loop
+		goto elna_tac_call_loop
 	end;
-	.compile_call_finalize;
+	.elna_tac_call_finalize;
 
 	(* Load the argument from the stack. *)
 	if argument_count <> 0 then
@@ -2086,18 +2111,18 @@ begin
 		stack_offset := argument_count * 4;
 
 		(* Calculate the stack offset: 116 - (4 * argument_counter) *)
-		instruction := _elna_generator_load_word(ElnaGeneratorRegister.a0 + argument_count,
-			ElnaGeneratorRegister.sp, 116 - stack_offset);
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		instruction := _elna_tac_load_word(ElnaTacRegister.a0 + argument_count,
+			ElnaTacRegister.sp, 116 - stack_offset);
+		_elna_tac_instruction_set_next(current_instruction, instruction);
 		current_instruction := instruction;
 
-		goto compile_call_finalize
+		goto elna_tac_call_finalize
 	end;
-	instruction := _elna_generator_call(name, name_length);
+	instruction := _elna_tac_jal(name, name_length);
 	if first_instruction = 0 then
 		first_instruction := instruction
 	else
-		_elna_generator_instruction_set_next(current_instruction, instruction)
+		_elna_tac_instruction_set_next(current_instruction, instruction)
 	end;
 	return first_instruction
 end;
@@ -2172,7 +2197,7 @@ begin
 	return result
 end;
 
-proc _compile_goto_statement(parser_node: Word);
+proc _elna_tac_goto_statement(parser_node: Word);
 var
 	label_name: Word;
 	label_length: Word;
@@ -2186,7 +2211,7 @@ begin
 	_store_byte('.', label_with_dot);
 	_memcpy(label_with_dot + 1, label_name, label_length);
 
-	return _elna_generator_jump(label_with_dot, label_length + 1)
+	return _elna_tac_jump(label_with_dot, label_length + 1)
 end;
 
 proc _label_declaration_size();
@@ -2243,7 +2268,7 @@ begin
 	return result
 end;
 
-proc _compile_label_declaration(parser_node: Word);
+proc _elna_tac_label_declaration(parser_node: Word);
 var
 	label_name: Word;
 	label_length: Word;
@@ -2251,30 +2276,27 @@ begin
 	label_name := _label_declaration_get_label(parser_node);
 	label_length := _label_declaration_get_length(parser_node);
 
-	return _elna_generator_label(label_name, label_length)
+	return _elna_tac_label(label_name, label_length)
 end;
 
-proc _compile_local_designator(symbol: Word);
+proc _elna_tac_local_designator(symbol: Word);
 var
 	variable_offset: Word;
-	instruction: Word;
 begin
 	variable_offset := _parameter_info_get_offset(symbol);
-	instruction := _elna_generator_add_immediate(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.sp, variable_offset);
-	return instruction
+
+	return _elna_tac_add_immediate(ElnaTacRegister.t0, ElnaTacRegister.sp, variable_offset)
 end;
 
-proc _compile_global_designator(variable_expression: Word);
+proc _elna_tac_global_designator(variable_expression: Word);
 var
 	name: Word;
 	token_length: Word;
-	instruction: Word;
 begin
 	name := _variable_expression_get_name(variable_expression);
 	token_length := _variable_expression_get_length(variable_expression);
-	instruction := _elna_generator_load_address(ElnaGeneratorRegister.t0, name, token_length);
 
-	return instruction
+	return _elna_tac_load_address(ElnaTacRegister.t0, name, token_length)
 end;
 
 proc _field_access_expression_size();
@@ -2317,7 +2339,7 @@ begin
 	this^ := value
 end;
 
-proc _compile_enumeration_value(field_access_expression: Word);
+proc _elna_tac_enumeration_value(field_access_expression: Word);
 var
 	enumeration_type: Word;
 	members: Word;
@@ -2348,7 +2370,7 @@ begin
 	counter := 1;
 
 	instruction := 0;
-	.compile_enumeration_value_members;
+	.elna_tac_enumeration_value_members;
 	if members_length > 0 then
 		member_name := members^;
 		member_length := members + 4;
@@ -2358,9 +2380,9 @@ begin
 			members_length := members_length - 1;
 			members := members + 8;
 			counter := counter + 1;
-			goto compile_enumeration_value_members
+			goto elna_tac_enumeration_value_members
 		end;
-		instruction := _elna_generator_load_immediate(ElnaGeneratorRegister.t0, counter, 0)
+		instruction := _elna_tac_load_immediate(ElnaTacRegister.t0, counter, 0)
 	end;
 	return instruction
 end;
@@ -2392,7 +2414,7 @@ begin
 	return result
 end;
 
-proc _compile_designator(parser_node: Word, symbol_table: Word, is_address: Word);
+proc _elna_tac_designator(parser_node: Word, symbol_table: Word, is_address: Word);
 var
 	name_token: Word;
 	lookup_result: Word;
@@ -2406,19 +2428,19 @@ begin
 
 	if node_kind = NodeKind.dereference_expression then
 		parser_node := _dereference_expression_get_pointer(parser_node);
-		first_instruction := _compile_simple_expression(parser_node, symbol_table, is_address);
-		instruction := _elna_generator_load_word(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t0, 0);
-		_elna_generator_instruction_set_next(first_instruction, instruction);
+		first_instruction := _elna_tac_simple_expression(parser_node, symbol_table, is_address);
+		instruction := _elna_tac_load_word(ElnaTacRegister.t0, ElnaTacRegister.t0, 0);
+		_elna_tac_instruction_set_next(first_instruction, instruction)
 	elsif node_kind = NodeKind.field_access_expression then
-		first_instruction := _compile_enumeration_value(parser_node);
+		first_instruction := _elna_tac_enumeration_value(parser_node);
 		is_address^ := 0
 	elsif node_kind = NodeKind.call then
-		first_instruction := _compile_call(parser_node, symbol_table);
-		instruction := _elna_generator_move(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.a0);
-		_elna_generator_instruction_set_next(first_instruction, instruction);
+		first_instruction := _elna_tac_call(parser_node, symbol_table);
+		instruction := _elna_tac_move(ElnaTacRegister.t0, ElnaTacRegister.a0);
+		_elna_tac_instruction_set_next(first_instruction, instruction);
 		is_address^ := 0
 	else
-		first_instruction := _compile_simple_expression(parser_node, symbol_table, is_address)
+		first_instruction := _elna_tac_simple_expression(parser_node, symbol_table, is_address)
 	end;
 	return first_instruction
 end;
@@ -2475,7 +2497,7 @@ begin
 	return result
 end;
 
-proc _compile_assign_statement(parser_tree: Word, symbol_table: Word);
+proc _elna_tac_assign_statement(parser_tree: Word, symbol_table: Word);
 var
 	current_expression: Word;
 	is_address: Word;
@@ -2484,22 +2506,22 @@ var
 	current_instruction: Word;
 begin
 	current_expression := _assign_statement_get_assignee(parser_tree);
-	first_instruction := _compile_designator(current_expression, symbol_table, @is_address);
+	first_instruction := _elna_tac_designator(current_expression, symbol_table, @is_address);
 
 	(* Save the assignee address on the stack. *)
-	current_instruction := _elna_generator_store_word(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.sp, 60);
-	_elna_generator_instruction_set_next(first_instruction, current_instruction);
+	current_instruction := _elna_tac_store_word(ElnaTacRegister.t0, ElnaTacRegister.sp, 60);
+	_elna_tac_instruction_set_next(first_instruction, current_instruction);
 
 	(* Compile the assignment. *)
 	current_expression := _assign_statement_get_assignment(parser_tree);
-	instruction := _compile_binary_expression(current_expression, symbol_table);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
+	instruction := _elna_tac_binary_expression(current_expression, symbol_table);
+	_elna_tac_instruction_set_next(current_instruction, instruction);
 
-	current_instruction := _elna_generator_load_word(ElnaGeneratorRegister.t1, ElnaGeneratorRegister.sp, 60);
-	_elna_generator_instruction_set_next(instruction, current_instruction);
+	current_instruction := _elna_tac_load_word(ElnaTacRegister.t1, ElnaTacRegister.sp, 60);
+	_elna_tac_instruction_set_next(instruction, current_instruction);
 
-	instruction := _elna_generator_store_word(ElnaGeneratorRegister.t0, ElnaGeneratorRegister.t1, 0);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
+	instruction := _elna_tac_store_word(ElnaTacRegister.t0, ElnaTacRegister.t1, 0);
+	_elna_tac_instruction_set_next(current_instruction, instruction);
 
 	return first_instruction
 end;
@@ -2544,16 +2566,16 @@ begin
 	return result
 end;
 
-proc _compile_return_statement(parser_node: Word, symbol_table: Word);
+proc _elna_tac_return_statement(parser_node: Word, symbol_table: Word);
 var
 	return_expression: Word;
 	first_instruction: Word;
 	instruction: Word;
 begin
 	return_expression := _return_statement_get_returned(parser_node);
-	first_instruction := _compile_binary_expression(return_expression, symbol_table);
-	instruction := _elna_generator_move(ElnaGeneratorRegister.a0, ElnaGeneratorRegister.t0);
-	_elna_generator_instruction_set_next(first_instruction, instruction);
+	first_instruction := _elna_tac_binary_expression(return_expression, symbol_table);
+	instruction := _elna_tac_move(ElnaTacRegister.a0, ElnaTacRegister.t0);
+	_elna_tac_instruction_set_next(first_instruction, instruction);
 	return first_instruction
 end;
 
@@ -2606,7 +2628,7 @@ begin
 	return result
 end;
 
-proc _compile_conditional_statements(parser_node: Word, after_end_label: Word, symbol_table: Word);
+proc _elna_tac_conditional_statements(parser_node: Word, after_end_label: Word, symbol_table: Word);
 var
 	condition_label: Word;
 	current_node: Word;
@@ -2616,27 +2638,27 @@ var
 begin
 	(* Compile condition. *)
 	current_node := _conditional_statements_get_condition(parser_node);
-	first_instruction := _compile_binary_expression(current_node, symbol_table);
+	first_instruction := _elna_tac_binary_expression(current_node, symbol_table);
 
 	(* condition_label is the label in front of the next elsif condition or end. *)
 	condition_label := label_counter;
 	label_counter := label_counter + 1;
 
-	current_instruction := _elna_generator_beqz(ElnaGeneratorRegister.t0, condition_label, 0);
-	_elna_generator_instruction_set_next(first_instruction, current_instruction);
+	current_instruction := _elna_tac_beqz(ElnaTacRegister.t0, condition_label, 0);
+	_elna_tac_instruction_set_next(first_instruction, current_instruction);
 
 	current_node := _conditional_statements_get_statements(parser_node);
-	instruction := _compile_statements(current_node, symbol_table);
+	instruction := _elna_tac_statements(current_node, symbol_table);
 	if instruction <> 0 then
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		_elna_tac_instruction_set_next(current_instruction, instruction);
 		current_instruction := instruction
 	end;
 
-	instruction := _elna_generator_jump(after_end_label, 0);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
+	instruction := _elna_tac_jump(after_end_label, 0);
+	_elna_tac_instruction_set_next(current_instruction, instruction);
 
-	current_instruction := _elna_generator_label(condition_label, 0);
-	_elna_generator_instruction_set_next(instruction, current_instruction);
+	current_instruction := _elna_tac_label(condition_label, 0);
+	_elna_tac_instruction_set_next(instruction, current_instruction);
 
 	return first_instruction
 end;
@@ -2811,7 +2833,7 @@ begin
 	return first_statement
 end;
 
-proc _compile_statements(parser_node: Word, symbol_table: Word);
+proc _elna_tac_statements(parser_node: Word, symbol_table: Word);
 var
 	current_statement: Word;
 	instruction: Word;
@@ -2821,25 +2843,25 @@ begin
 	current_statement := parser_node;
 	first_instruction := 0;
 
-	.compile_statements_loop;
+	.elna_tac_statements_loop;
 	if current_statement <> 0 then
-		instruction := _compile_statement(current_statement, symbol_table);
+		instruction := _elna_tac_statement(current_statement, symbol_table);
 		current_statement := _statement_get_next(current_statement);
 		if instruction = 0 then
-			goto compile_statements_loop
+			goto elna_tac_statements_loop
 		end;
 		if first_instruction = 0 then
 			first_instruction := instruction
 		else
-			_elna_generator_instruction_set_next(current_instruction, instruction)
+			_elna_tac_instruction_set_next(current_instruction, instruction)
 		end;
 		current_instruction := instruction;
-		goto compile_statements_loop
+		goto elna_tac_statements_loop
 	end;
 	return first_instruction
 end;
 
-proc _compile_if_statement(parser_node: Word, symbol_table: Word);
+proc _elna_tac_if_statement(parser_node: Word, symbol_table: Word);
 var
 	current_node: Word;
 	after_end_label: Word;
@@ -2852,33 +2874,33 @@ begin
 	label_counter := label_counter + 1;
 
 	current_node := _if_statement_get_conditionals(parser_node);
-	first_instruction := _compile_conditional_statements(current_node, after_end_label, symbol_table);
+	first_instruction := _elna_tac_conditional_statements(current_node, after_end_label, symbol_table);
 	current_instruction := first_instruction;
 
-	.compile_if_statement_loop;
+	.elna_tac_if_statement_loop;
 	current_node := _conditional_statements_get_next(current_node);
 	if current_node <> 0 then
-		instruction := _compile_conditional_statements(current_node, after_end_label, symbol_table);
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		instruction := _elna_tac_conditional_statements(current_node, after_end_label, symbol_table);
+		_elna_tac_instruction_set_next(current_instruction, instruction);
 		current_instruction := instruction;
-		goto compile_if_statement_loop
+		goto elna_tac_if_statement_loop
 	end;
 	current_node := _if_statement_get_else(parser_node);
 
 	if current_node <> 0 then
-		instruction := _compile_statements(current_node, symbol_table);
+		instruction := _elna_tac_statements(current_node, symbol_table);
 		if instruction <> 0 then
-			_elna_generator_instruction_set_next(current_instruction, instruction);
+			_elna_tac_instruction_set_next(current_instruction, instruction);
 			current_instruction := instruction
 		end
 	end;
-	instruction := _elna_generator_label(after_end_label, 0);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
+	instruction := _elna_tac_label(after_end_label, 0);
+	_elna_tac_instruction_set_next(current_instruction, instruction);
 
 	return first_instruction
 end;
 
-proc _compile_statement(parser_node: Word, symbol_table: Word);
+proc _elna_tac_statement(parser_node: Word, symbol_table: Word);
 var
 	statement_kind: Word;
 	instruction: Word;
@@ -2886,17 +2908,17 @@ begin
 	statement_kind := _node_get_kind(parser_node);
 
 	if statement_kind = NodeKind.goto_statement then
-		instruction := _compile_goto_statement(parser_node)
+		instruction := _elna_tac_goto_statement(parser_node)
 	elsif statement_kind = NodeKind.if_statement then
-		instruction := _compile_if_statement(parser_node, symbol_table)
+		instruction := _elna_tac_if_statement(parser_node, symbol_table)
 	elsif statement_kind = NodeKind.return_statement then
-		instruction := _compile_return_statement(parser_node, symbol_table)
+		instruction := _elna_tac_return_statement(parser_node, symbol_table)
 	elsif statement_kind = NodeKind.label_declaration then
-		instruction := _compile_label_declaration(parser_node)
+		instruction := _elna_tac_label_declaration(parser_node)
 	elsif statement_kind = NodeKind.call then
-		instruction := _compile_call(parser_node, symbol_table)
+		instruction := _elna_tac_call(parser_node, symbol_table)
 	elsif statement_kind = NodeKind.assign_statement then
-		instruction := _compile_assign_statement(parser_node, symbol_table)
+		instruction := _elna_tac_assign_statement(parser_node, symbol_table)
 	else
 		instruction := 0
 	end;
@@ -3093,7 +3115,7 @@ end;
  *
  * Returns enumeration type description.
  *)
-proc _read_type_enumeration(parser_node: Word);
+proc _elna_name_type_enumeration(parser_node: Word);
 var
 	result: Word;
 	memory_start: Word;
@@ -3113,7 +3135,7 @@ begin
 	member_array_start := _allocate(member_array_size);
 	member_array_current := member_array_start;
 
-	.read_type_enumeration_loop;
+	.elna_name_type_enumeration_loop;
 	if member_count > 0 then
 		member_array_current^ := memory_start^;
 		member_array_current := member_array_current + 4;
@@ -3125,7 +3147,7 @@ begin
 
 		memory_start := memory_start^;
 		member_count := member_count - 1;
-		goto read_type_enumeration_loop
+		goto elna_name_type_enumeration_loop
 	end;
 	member_count := _enumeration_type_expression_get_length(parser_node);
 
@@ -3173,7 +3195,7 @@ begin
 	return result
 end;
 
-proc _read_type_expression(parser_node: Word);
+proc _elna_name_type_expression(parser_node: Word);
 var
 	token_kind: Word;
 	type_name: Word;
@@ -3189,7 +3211,7 @@ begin
 		result := _symbol_table_lookup(@symbol_table_global, type_name, name_length);
 		result := _type_info_get_type(result)
 	elsif token_kind = NodeKind.enumeration_type_expression then
-		result := _read_type_enumeration(parser_node)
+		result := _elna_name_type_enumeration(parser_node)
 	end;
 
 	return result
@@ -3295,7 +3317,7 @@ end;
  * Parameters:
  * parameter_index - Parameter index.
  *)
-proc _read_procedure_parameter(parser_node: Word, parameter_index: Word, symbol_table: Word);
+proc _elna_name_procedure_parameter(parser_node: Word, parameter_index: Word, symbol_table: Word);
 var
 	name_length: Word;
 	info: Word;
@@ -3312,7 +3334,7 @@ end;
  * Parameters:
  * variable_index - Variable index.
  *)
-proc _read_procedure_temporary(parser_node: Word, variable_index: Word, symbol_table: Word);
+proc _elna_name_procedure_temporary(parser_node: Word, variable_index: Word, symbol_table: Word);
 var
 	name_length: Word;
 	info: Word;
@@ -3325,23 +3347,23 @@ begin
 	_symbol_table_enter(symbol_table, name_position, name_length, info)
 end;
 
-proc _read_procedure_temporaries(parser_node: Word, symbol_table: Word);
+proc _elna_name_procedure_temporaries(parser_node: Word, symbol_table: Word);
 var
 	temporary_counter: Word;
 begin
 	temporary_counter := 0;
 
-	.read_procedure_temporaries_loop;
+	.elna_name_procedure_temporaries_loop;
 	if parser_node = 0 then
-		goto read_procedure_temporaries_end
+		goto elna_name_procedure_temporaries_end
 	end;
-	_read_procedure_temporary(parser_node, temporary_counter, symbol_table);
+	_elna_name_procedure_temporary(parser_node, temporary_counter, symbol_table);
 
 	temporary_counter := temporary_counter + 1;
 	parser_node := _declaration_get_next(parser_node);
-	goto read_procedure_temporaries_loop;
+	goto elna_name_procedure_temporaries_loop;
 
-	.read_procedure_temporaries_end
+	.elna_name_procedure_temporaries_end
 end;
 
 proc _declaration_get_next(this: Word);
@@ -3500,7 +3522,7 @@ begin
 	return result
 end;
 
-proc _compile_procedure_declaration(parser_node: Word);
+proc _elna_tac_procedure_declaration(parser_node: Word);
 var
 	name_pointer: Word;
 	name_length: Word;
@@ -3514,33 +3536,24 @@ var
 	result: Word;
 	result_size: Word;
 begin
-	result_size := _elna_generator_procedure_size();
+	result_size := _elna_tac_declaration_size();
 	result := _allocate(result_size);
 
-	_elna_generator_procedure_set_kind(result, ElnaGeneratorKind.procedure);
-	_elna_generator_procedure_set_next(result, 0);
+	_elna_tac_declaration_set_next(result, 0);
 
 	name_pointer := _declaration_get_name(parser_node);
 	name_length := _declaration_get_length(parser_node);
 
-	_elna_generator_procedure_set_name(result, name_pointer);
-	_elna_generator_procedure_set_length(result, name_length);
+	_elna_tac_declaration_set_name(result, name_pointer);
+	_elna_tac_declaration_set_length(result, name_length);
 
 	symbol_info := _symbol_table_lookup(@symbol_table_global, name_pointer, name_length);
 	new_symbol_table := _procedure_info_get_symbol_table(symbol_info);
 
-	(* Write the prologue. *)
-	first_instruction := _elna_generator_add_immediate(ElnaGeneratorRegister.sp, ElnaGeneratorRegister.sp, -128);
-	current_instruction := _elna_generator_store_word(ElnaGeneratorRegister.ra, ElnaGeneratorRegister.sp, 124);
-	_elna_generator_instruction_set_next(first_instruction, current_instruction);
-	instruction := _elna_generator_store_word(ElnaGeneratorRegister.s0, ElnaGeneratorRegister.sp, 120);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
-	current_instruction := _elna_generator_add_immediate(ElnaGeneratorRegister.s0, ElnaGeneratorRegister.sp, 128);
-	_elna_generator_instruction_set_next(instruction, current_instruction);
-
 	current_parameter := _procedure_declaration_get_parameters(parser_node);
+	first_instruction := 0;
 	parameter_counter := 0;
-	.compile_procedure_declaration_parameters;
+	.elna_tac_procedure_declaration_parameters;
 	if current_parameter <> 0 then
 		name_pointer := _declaration_get_name(current_parameter);
 		name_length := _declaration_get_length(current_parameter);
@@ -3548,37 +3561,29 @@ begin
 
 		symbol_info := _parameter_info_get_offset(symbol_info);
 
-		instruction := _elna_generator_store_word(ElnaGeneratorRegister.a0 + parameter_counter,
-			ElnaGeneratorRegister.sp, symbol_info);
-		_elna_generator_instruction_set_next(current_instruction, instruction);
+		instruction := _elna_tac_store_word(ElnaTacRegister.a0 + parameter_counter,
+			ElnaTacRegister.sp, symbol_info);
+		if first_instruction = 0 then
+			first_instruction := instruction
+		else
+			_elna_tac_instruction_set_next(current_instruction, instruction)
+		end;
 		current_instruction := instruction;
 
-		(* _read_procedure_parameter(current_parameter, parameter_counter, new_symbol_table); *)
 		parameter_counter := parameter_counter + 1;
 
 		current_parameter := _declaration_get_next(current_parameter);
-		goto compile_procedure_declaration_parameters
+		goto elna_tac_procedure_declaration_parameters
 	end;
 	current_parameter := _procedure_declaration_get_body(parser_node);
 
-	instruction := _compile_statements(current_parameter, new_symbol_table);
-	if instruction <> 0 then
-		_elna_generator_instruction_set_next(current_instruction, instruction);
-		current_instruction := instruction
+	instruction := _elna_tac_statements(current_parameter, new_symbol_table);
+	if first_instruction <> 0 then
+		_elna_tac_instruction_set_next(first_instruction, instruction)
+	else
+		first_instruction := instruction
 	end;
-
-	(* Write the epilogue. *)
-	instruction := _elna_generator_load_word(ElnaGeneratorRegister.ra, ElnaGeneratorRegister.sp, 124);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
-
-	current_instruction := _elna_generator_load_word(ElnaGeneratorRegister.s0, ElnaGeneratorRegister.sp, 120);
-	_elna_generator_instruction_set_next(instruction, current_instruction);
-	instruction := _elna_generator_add_immediate(ElnaGeneratorRegister.sp, ElnaGeneratorRegister.sp, 128);
-	_elna_generator_instruction_set_next(current_instruction, instruction);
-	current_instruction := _elna_generator_instruction_create(ElnaGeneratorKind.ret);
-	_elna_generator_instruction_set_next(instruction, current_instruction);
-
-	_elna_generator_procedure_set_body(result, first_instruction);
+	_elna_tac_declaration_set_body(result, first_instruction);
 
 	return result
 end;
@@ -3614,7 +3619,7 @@ begin
 	return result
 end;
 
-proc _compile_procedures(parser_node: Word);
+proc _elna_tac_procedures(parser_node: Word);
 var
 	result: Word;
 	current_procedure: Word;
@@ -3622,22 +3627,22 @@ var
 begin
 	first_procedure := 0;
 
-	.compile_procedures_loop;
+	.elna_tac_procedures_loop;
 	if parser_node = 0 then
-		goto compile_procedures_end
+		goto elna_tac_procedures_end
 	end;
-	result := _compile_procedure_declaration(parser_node);
+	result := _elna_tac_procedure_declaration(parser_node);
 	if first_procedure = 0 then
 		first_procedure := result
 	else
-		_elna_generator_procedure_set_next(current_procedure, result)
+		_elna_tac_declaration_set_next(current_procedure, result)
 	end;
 	current_procedure := result;
 
 	parser_node := _declaration_get_next(parser_node);
-	goto compile_procedures_loop;
+	goto elna_tac_procedures_loop;
 
-	.compile_procedures_end;
+	.elna_tac_procedures_end;
 	return first_procedure
 end;
 
@@ -3708,7 +3713,7 @@ begin
 	return result
 end;
 
-proc _read_type_declaration(parser_node: Word);
+proc _elna_name_type_declaration(parser_node: Word);
 var
 	type_name: Word;
 	name_length: Word;
@@ -3718,11 +3723,15 @@ begin
 	name_length := _declaration_get_length(parser_node);
 
 	parser_node := _type_declaration_get_type(parser_node);
-	type_info := _read_type_expression(parser_node);
+	type_info := _elna_name_type_expression(parser_node);
 
 	_symbol_table_enter(@symbol_table_global, type_name, name_length, type_info)
 end;
 
+proc _elna_type_type_declaration(parser_node: Word);
+begin
+end;
+
 proc _parse_type_part();
 var
 	token_kind: Word;
@@ -3807,7 +3816,7 @@ begin
 	return result
 end;
 
-proc _compile_variable_declaration(parser_tree: Word);
+proc _elna_tac_variable_declaration(parser_tree: Word);
 var
 	name: Word;
 	name_length: Word;
@@ -3815,27 +3824,26 @@ var
 	result: Word;
 	result_size: Word;
 begin
-	result_size := _elna_generator_procedure_size();
+	result_size := _elna_tac_declaration_size();
 	result := _allocate(result_size);
 
-	_elna_generator_procedure_set_kind(result, ElnaGeneratorKind.variable);
-	_elna_generator_procedure_set_next(result, 0);
+	_elna_tac_declaration_set_next(result, 0);
 
 	name := _declaration_get_name(parser_tree);
 	name_length := _declaration_get_length(parser_tree);
 	variable_type := _variable_declaration_get_type(parser_tree);
 
-	_elna_generator_procedure_set_name(result, name);
-	_elna_generator_procedure_set_length(result, name_length);
+	_elna_tac_declaration_set_name(result, name);
+	_elna_tac_declaration_set_length(result, name_length);
 
 	name := _named_type_expression_get_name(variable_type);
 	name_length := _named_type_expression_get_length(variable_type);
 
 	if _lexer_compare_keyword("Array", 5, name, name_length) then
 		(* Else we assume this is a zeroed 4096 bytes big array. *)
-		_elna_generator_procedure_set_body(result, 4096)
+		_elna_tac_declaration_set_body(result, 4096)
 	else
-		_elna_generator_procedure_set_body(result, 4)
+		_elna_tac_declaration_set_body(result, 4)
 	end;
 	return result
 end;
@@ -3880,7 +3888,7 @@ begin
 	return result
 end;
 
-proc _compile_var_part(parser_node: Word);
+proc _elna_tac_var_part(parser_node: Word);
 var
 	node: Word;
 	current_variable: Word;
@@ -3888,24 +3896,24 @@ var
 begin
 	first_variable := 0;
 	if parser_node = 0 then
-		goto compile_var_part_end
+		goto elna_tac_var_part_end
 	end;
 
-	.compile_var_part_loop;
-	node := _compile_variable_declaration(parser_node);
+	.elna_tac_var_part_loop;
+	node := _elna_tac_variable_declaration(parser_node);
 	if first_variable = 0 then
 		first_variable := node
 	else
-		_elna_generator_procedure_set_next(current_variable, node)
+		_elna_tac_declaration_set_next(current_variable, node)
 	end;
 	current_variable := node;
 
 	parser_node := _declaration_get_next(parser_node);
 	if parser_node <> 0 then
-		goto compile_var_part_loop
+		goto elna_tac_var_part_loop
 	end;
 
-	.compile_var_part_end;
+	.elna_tac_var_part_end;
 	return first_variable
 end;
 
@@ -3975,30 +3983,21 @@ end;
 (**
  * Process the source code and print the generated code.
  *)
-proc _compile_module_declaration(parser_node: Word);
+proc _elna_tac_module_declaration(parser_node: Word);
 var
-	current_part: Word;
-	result: Word;
-	result_size: Word;
+	data_part: Word;
+	code_part: Word;
 begin
-	result_size := _elna_generator_procedure_size();
-	result := _allocate(result_size);
-
-	_elna_generator_procedure_set_kind(result, ElnaGeneratorKind._module);
-	_elna_generator_procedure_set_next(result, 0);
+	data_part := _module_declaration_get_globals(parser_node);
+	data_part := _elna_tac_var_part(data_part);
 
-	current_part := _module_declaration_get_globals(parser_node);
-	current_part := _compile_var_part(current_part);
-	_elna_generator_procedure_set_name(result, current_part);
+	code_part := _module_declaration_get_procedures(parser_node);
+	code_part := _elna_tac_procedures(code_part);
 
-	current_part := _module_declaration_get_procedures(parser_node);
-	current_part := _compile_procedures(current_part);
-	_elna_generator_procedure_set_body(result, current_part);
-
-	return result
+	return _elna_tac_module_create(data_part, code_part)
 end;
 
-proc _read_procedure_declaration(parser_node: Word);
+proc _elna_name_procedure_declaration(parser_node: Word);
 var
 	name_pointer: Word;
 	name_length: Word;
@@ -4015,41 +4014,68 @@ begin
 
 	current_parameter := _procedure_declaration_get_parameters(parser_node);
 	parameter_counter := 0;
-	.compile_procedure_declaration_parameter;
+	.elna_name_procedure_declaration_parameter;
 	if current_parameter <> 0 then
-		_read_procedure_parameter(current_parameter, parameter_counter, new_symbol_table);
+		_elna_name_procedure_parameter(current_parameter, parameter_counter, new_symbol_table);
 		parameter_counter := parameter_counter + 1;
 
 		current_parameter := _declaration_get_next(current_parameter);
-		goto compile_procedure_declaration_parameter
+		goto elna_name_procedure_declaration_parameter
 	end;
 	current_parameter := _procedure_declaration_get_temporaries(parser_node);
-	_read_procedure_temporaries(current_parameter, new_symbol_table);
+	_elna_name_procedure_temporaries(current_parameter, new_symbol_table);
 
 	_symbol_table_enter(@symbol_table_global, name_pointer, name_length, symbol_info)
 end;
 
-proc _read_module_declaration(parser_node: Word);
+proc _elna_type_procedure_declaration(parser_node: Word);
+begin
+end;
+
+proc _elna_name_module_declaration(parser_node: Word);
 var
 	current_part: Word;
 	result: Word;
 begin
 	current_part := _module_declaration_get_types(parser_node);
-	.read_module_declaration_type;
+	.elna_name_module_declaration_type;
+	if current_part <> 0 then
+		_elna_name_type_declaration(current_part);
+		current_part := _declaration_get_next(current_part);
+
+		goto elna_name_module_declaration_type
+	end;
+
+	current_part := _module_declaration_get_procedures(parser_node);
+	.elna_name_module_declaration_procedure;
+	if current_part <> 0 then
+		_elna_name_procedure_declaration(current_part);
+		current_part := _declaration_get_next(current_part);
+
+		goto elna_name_module_declaration_procedure
+	end
+end;
+
+proc _elna_type_module_declaration(parser_node: Word);
+var
+	current_part: Word;
+begin
+	current_part := _module_declaration_get_types(parser_node);
+	.elna_type_module_declaration_type;
 	if current_part <> 0 then
-		_read_type_declaration(current_part);
+		_elna_type_type_declaration(current_part);
 		current_part := _declaration_get_next(current_part);
 
-		goto read_module_declaration_type
+		goto elna_type_module_declaration_type
 	end;
 
 	current_part := _module_declaration_get_procedures(parser_node);
-	.read_module_declaration_procedure;
+	.elna_type_module_declaration_procedure;
 	if current_part <> 0 then
-		_read_procedure_declaration(current_part);
+		_elna_type_procedure_declaration(current_part);
 		current_part := _declaration_get_next(current_part);
 
-		goto read_module_declaration_procedure
+		goto elna_type_module_declaration_procedure
 	end
 end;
 
@@ -4059,8 +4085,9 @@ var
 	tac: Word;
 begin
 	parser_node := _parse_module_declaration();
-	_read_module_declaration(parser_node);
-	tac := _compile_module_declaration(parser_node);
+	_elna_name_module_declaration(parser_node);
+	_elna_type_module_declaration(parser_node);
+	tac := _elna_tac_module_declaration(parser_node);
 	_elna_writer_module(tac)
 end;