From 63c211a8e97c7af69d6faf4fe3d2c1caecc35f25 Mon Sep 17 00:00:00 2001 From: Eugen Wissner Date: Mon, 3 Nov 2025 16:16:48 +0100 Subject: [PATCH] Rename elna_generator to elna_tac --- boot/stage15.elna | 963 ++++++++++++++++++++++++---------------------- 1 file changed, 495 insertions(+), 468 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); -begin - this^ := value -end; - -proc _elna_generator_procedure_get_next(this: Word); +proc _elna_tac_module_get_code(this: Word); begin this := this + 4; return this^ end; -proc _elna_generator_procedure_set_next(this: Word, value: Word); +proc _elna_tac_declaration_size(); + return 16 +end; + +proc _elna_tac_declaration_get_next(this: Word); + return this^ +end; + +proc _elna_tac_declaration_set_next(this: Word, value: Word); +begin + this^ := value +end; + +proc _elna_tac_declaration_get_name(this: Word); +begin + this := this + 4; + return this^ +end; + +proc _elna_tac_declaration_set_name(this: Word, value: Word); begin this := this + 4; this^ := value end; -proc _elna_generator_procedure_get_name(this: Word); +proc _elna_tac_declaration_get_length(this: Word); begin this := this + 8; return this^ end; -proc _elna_generator_procedure_set_name(this: Word, value: Word); +proc _elna_tac_declaration_set_length(this: Word, value: Word); begin this := this + 8; this^ := value end; -proc _elna_generator_procedure_get_length(this: Word); +proc _elna_tac_declaration_get_body(this: Word); begin this := this + 12; return this^ end; -proc _elna_generator_procedure_set_length(this: Word, value: Word); +proc _elna_tac_declaration_set_body(this: Word, value: Word); begin this := this + 12; this^ := value end; -proc _elna_generator_procedure_get_body(this: Word); -begin - this := this + 16; - return this^ -end; - -proc _elna_generator_procedure_set_body(this: Word, value: Word); -begin - this := this + 16; - 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); + data_part := _module_declaration_get_globals(parser_node); + data_part := _elna_tac_var_part(data_part); - _elna_generator_procedure_set_kind(result, ElnaGeneratorKind._module); - _elna_generator_procedure_set_next(result, 0); + code_part := _module_declaration_get_procedures(parser_node); + code_part := _elna_tac_procedures(code_part); - current_part := _module_declaration_get_globals(parser_node); - current_part := _compile_var_part(current_part); - _elna_generator_procedure_set_name(result, current_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 - _read_type_declaration(current_part); + _elna_name_type_declaration(current_part); current_part := _declaration_get_next(current_part); - goto read_module_declaration_type + goto elna_name_module_declaration_type end; current_part := _module_declaration_get_procedures(parser_node); - .read_module_declaration_procedure; + .elna_name_module_declaration_procedure; if current_part <> 0 then - _read_procedure_declaration(current_part); + _elna_name_procedure_declaration(current_part); current_part := _declaration_get_next(current_part); - goto read_module_declaration_procedure + 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 + _elna_type_type_declaration(current_part); + current_part := _declaration_get_next(current_part); + + goto elna_type_module_declaration_type + end; + + current_part := _module_declaration_get_procedures(parser_node); + .elna_type_module_declaration_procedure; + if current_part <> 0 then + _elna_type_procedure_declaration(current_part); + current_part := _declaration_get_next(current_part); + + 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;